QVdFIFRva2VuOiBFZW4gYmxvY2tjaGFpbnByb3RvY29sIGdlcmljaHQgb3Agc2FtZW53ZXJraW5nIHR1c3NlbiBBSS1hZ2VudGVu

2025-05-27, 07:33

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