R2F0ZS5pby1vbmRlcndpanMgfCBXYXQgemlqbiBVLWdlYmFzZWVyZGUgZWV1d2lnZHVyZW5kZSBjb250cmFjdGVuPw==

2024-12-24, 08:53

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