V2FhciBCaXRjb2luIHRlIHZlcmhhbmRlbGVuPyBLaWVzIGVlbiB2ZXJ0cm91d2RlIEJpdGNvaW4tYmV1cnM=

2025-07-03, 07:49

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