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