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