VW5pc2NpdGkgYWwgcHJvZ3JhbW1hIGRpIHN1cHBvcnRvIGFsIGNhbGNpbyBwZXIgYmFtYmluaSBpbiBCcmFzaWxlIHBlciBwcm9tdW92ZXJlIGxvIHNwaXJpdG8gc3BvcnRpdm8gZSBzb3N0ZW5lcmUgbGUgY29tdW5pdMOgIHN2YW50YWdnaWF0ZQ==

2023-07-26, 02:11

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