Q29tZSBtaW5hcmUgRG9nZWNvaW4gY29uIGlsIGNsb3VkIG1pbmluZz8=

2025-06-09, 10:23

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