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