UGVyY2jDqSBpIHRva2VuIGNvbiBsZXZhIGRldm9ubyBlc3NlcmUgZGl2aXNpIGludmVyc2FtZW50ZT8gKDIwMjUp

2022-03-30, 03:33

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