R2F0ZSBXYWxsZXQ6IElsIGxlYWRlciBkZWxsXCdhZ2dyZWdhemlvbmUgbXVsdGktY2hhaW4gbmVsIHNldHRvcmUgZGVpIHdhbGxldCBvbi1jaGFpbg==

2025-07-03, 01:21

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