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