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