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