Teknologio Estas Senkulpa

2022-09-08 2023-03-10 约 3000 字预计阅读 6 分钟

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