V2F0IGlzIFNFSSBUb2tlbj8=

2025-03-25, 07:14

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