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