R2F0ZS5pbyBrb25kaWd0IG9mZmljacOrbGUgbW91d3BhcnRuZXJzY2hhcCBhYW4gbWV0IEludGVy

2024-08-23, 18:23

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