R2F0ZSBFVEggU3Rha2luZyBzaSBpbnRlbnNpZmljYTogMiw3OCUgQVBZIGNvbiBvbHRyZSAxNTAuMDAwIEVUSCBpbiBzdGFraW5n

2025-07-02, 02:11

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