V2F0IGlzIGRlIHByaWpzIHZhbiBLZWtpdXMgTWF4aW11cyBDb2luPyBaYWwgRWxvbiBNdXNrIGhldCBpbiBkZSB0b2Vrb21zdCB2ZXJtZWxkZW4/

2025-02-13, 08:08

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