RGVMb3JlYW4gRE1DIFRva2VuIFByaWpzdm9vcnNwZWxsaW5nOiBLYW4gaGV0IGJvdmVuICQwLDAxIHVpdGtvbWVuIGluIDIwMjU/

2025-06-30, 08:18

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