TVRPUyBUb2tlbjogaGV0IHRvb25hYW5nZXZlbmRlIEFJLXNwZWwgb3AgU29sYW5h

2025-01-10, 06:23

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