SGVsaWNoYWluIFRva2Vub21pY3M6IEhvZSAkSEVMSSBpcyBHZXN0cnVjdHVyZWVyZCB2b29yIEdyb2Vp

2025-07-02, 07:06

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