V2F0IGlzIGRlIE1PUkUgQ29pbj8gSG9lIGhhbmRlbCBqZSBpbiBNT1JFIFBlcnBldHVhbCBGdXR1cmVzIG9wIEdhdGU/

2025-07-04, 11:12

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