Q2FyZGFubyAoQURBKSBOaWV1d3MgVmFuZGFhZyBlbiBQcmlqc2FuYWx5c2U=

2025-07-02, 07:24

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