Tm90aXppZSBkaSBtZXJjYXRvIHwgUGFub3JhbWljYSBnaW9ybmFsaWVyYSBkZWxsZSB0ZW5kZW56ZSBwcmluY2lwYWxpIGRlaSB0b2tlbg==

2023-08-02, 02:57

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