V2F0IGlzIGRlIEVMREUgQ29pbj8gSG9lIHRlIGtvcGVuIGVuIGRlZWxuZW1lbiBhYW4gaGV0IEVsZGVyZ2xhZGUgR2FtaW5nLWVjb3N5c3RlZW0=

2025-05-28, 10:30

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