V2F0IGlzIENhdGNvaW4/IExlZXIgb3ZlciBkZSBNZW1lIENvaW4gZGllIGluIMOpw6luIG1hYW5kIG1ldCA0LjAwMCUgc3RlZWc=

2025-03-05, 07:52

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