Z2F0ZUxpdmUgQU1BIFJlY2FwLURlYm94

2024-09-14, 06:05

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