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