QmFzZWQgRndvZyAoRldPRyk6IGJsYXV3ZSBraWtrZXIgbWVtZSB0b2tlbiBvcCBCYXNlIG9wZW5iYXJlIGtldGVu

2025-01-12, 03:33

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