UXVhbCDDqCBpbCBwcmV6em8gZGVsbGEgbW9uZXRhIEtla2l1cyBNYXhpbXVzPyBFbG9uIE11c2sgbG8gbWVuemlvbmVyw6AgaW4gZnV0dXJvPw==

2025-02-13, 08:08

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