V2F0IGlzIGRlIENyeXB0byBGZWFyIGFuZCBHcmVlZCBJbmRleD8=

2025-06-30, 10:32

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