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