UXVhbCDDqCBpbCBtaWdsaW9yIGV4Y2hhbmdlIGRpIGNyaXB0b3ZhbHV0ZT8gR2F0ZSBzY2VsdG8gZGEgMzAgbWlsaW9uaSBkaSB1dGVudGkgaW4gdHV0dG8gaWwgbW9uZG8=

2025-07-03, 07:34

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