UGVwZSBlbiBBaURvZ2UgR2FhbiBQYXJhYm9saXNjaCBvcCBHYXRlLmlv

2023-05-08, 08:07

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