R2F0ZSBDaGFyaXR5IHdvcmR0IG9mZmljaWVlbCBnZWxhbmNlZXJkIGVuIHZlcnN0ZXJrdCBkZSBtaXNzaWUgdmFuICdIZXQgYmV2b3JkZXJlbiB2YW4gZWVuIGV2ZW53aWNodGlnZSB3ZXJlbGQn

2023-01-06, 01:39

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