Q2hlIGNvc1wnw6ggbFwnQWxsZWFuemEgcGVyIGxcJ0ludGVsbGlnZW56YSBTdXBlcmlvcmUgQXJ0aWZpY2lhbGU/IFByZXZpc2lvbmUgZGVsIHByZXp6byBkZWwgdG9rZW4gRkVUIHBlciBpbCAyMDI1

2025-07-04, 12:42

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