V2F0IGlzIFhFTT8gRWNvc3lzdGVlbW92ZXJ6aWNodCBlbiBwcmlqc3Zvb3JzcGVsbGluZyB2b29yIDIwMjU=

2025-07-03, 10:37

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