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