R2F0ZSBXYWxsZXQgQm91bnR5RHJvcDogRG9lIG1lZSBhYW4gZGUgSHlwZXJpb24gQWlyZHJvcCBlbiBkZWVsICQ3LjAwMCBhYW4gSHlwZXJpb24tdG9rZW5z

2025-06-23, 09:18

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