U3RvY2tGaSB2cy4gVHJhZGl0aW9uZWxlIEJldXJ6ZW46IFdhYXJvbSBHZXRva2VuaXNlZXJkZSBBYW5kZWxlbiBkZSBUb2Vrb21zdCBaaWpu

2025-07-03, 09:09

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