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