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