Z2F0ZUxpdmUgQU1BIFJlY2FwLUFwdSBBcHVzdGFqYQ==

2024-05-30, 11:14

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