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