R2F0ZSBBbHBoYSBMYWF0c3RlIE5pZXV3czogR2VlbiBLb3N0ZW4gR2Vjb21iaW5lZXJkIG1ldCAkMzAwSyBCZWxvbmluZ2Vu

2025-05-29, 04:39

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