V2F0IGlzIEJBTkFOQVMzMT8gUHJpanN2b29yc3BlbGxpbmcgdmFuIEJBTkFOQVMzMS10b2tlbiBlbiB0b2Vrb21zdHBlcnNwZWN0aWVm

2025-07-03, 07:14

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