Z2F0ZUxpdmUgQU1BIFJlY2FwLVByb3BiYXNl

2024-04-30, 07:03

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