Q29zXCfDqCBpbCBTYWhhcmEgQUkgVG9rZW4/

2025-06-30, 10:43

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