Q29zJ8OoIEdyb2tjb2luPyBDb21lIMOoIGNvbGxlZ2F0byBhbCBHcm9rIEFJIGRpIEVsb24gTXVzaz8=

2025-03-07, 10:10

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