V2F0IGlzIGRlIGR1dXJzdGUgTkZUPyBQYWtcJ3MgXCJUaGUgTWVyZ2VcIiB2ZXJrb2NodCB2b29yICQ5MSw4IG1pbGpvZW4=

2025-07-01, 08:31

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