QlRDLWRvbWluYW50aWUgc3Rpamd0IHRvdCBib3ZlbiBkZSA2MyU6IE1hcmt0bGFuZHNjaGFwIGVuIHRvZWtvbXN0dHJlbmRhbmFseXNl

2025-06-04, 07:08

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