VFJVTVAtbXVudCBzY2hpZXQgZG9vciBkZSBtYXJrdGthcGl0YWxpc2F0aWUgdmFuICQyMCBtaWxqYXJkIGluIMOpw6luIGRhZywgd2F0IGlzIGhldCBnZXZvbGc/

2025-01-18, 09:43

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