存档导出后，怎么导入到新手机？

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