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