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