VG9rZW4gSzogTGEgcG90ZW56YSBkZWdsaSBpbnZlc3RpbWVudGkgRGVGaSBkaSBLaW50byBNb2R1bGFyIEV4Y2hhbmdl

2025-03-26, 02:53

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