R2VlbiBhY2NvdW50LCBnZWVuIGxpbWlldGVuOiBHYXRlIHhTdG9ja3Mgb3BlbnQgZGUgZGV1ciBuYWFyIHdlcmVsZHdpamRlIGFhbmRlbGVuaGFuZGVs

2025-07-08, 04:13

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