T0xBRjogU25vd21hbiBtZW1lIGNvaW4gb3AgU29sYW5hLWtldGVu

2024-12-16, 07:32

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