TktOOiBCbG9ja2NoYWluLUdlc3R1dXJkIEdlZGVjZW50cmFsaXNlZXJkIE5ldHdlcmsgdmFuIGRlIFRvZWtvbXN0

2025-05-09, 09:32

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