R3VpZGEgYWdsaSBpbnZlc3RpbWVudGkgQlVCQiBUb2tlbiAyMDI1OiBQcmV6em8gZGVsbGEgRnJvZyBNZW1lIENvaW4gZSBDb21lIEFjcXVpc3RhcmU=

2025-04-13, 07:31

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