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