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