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