Z2F0ZUxpdmUgQU1BIFJlY2FwLUxFR0lPTg==

2024-06-21, 05:55

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