SG9lIEJPTksgQ29pbiB0ZSBrb3BlbjogRWVuIGFsbGVzLWluLcOpw6luIGdpZHMgZW4gbWFya3RvdmVyemljaHQgdm9vciAyMDI1

2025-07-07, 07:45

PHA+PGltZyBzcmM9Imh0dHBzOi8vZ2ltZzIuZ2F0ZWltZy5jb20vaW1hZ2UvYm9uazIwMjUwNzA3MTU0MTEzMDQ3MzY5NDA2OS5qcGciIGFsdD0iIj4KPC9wPjxwPkJPTksgaXMgZGUgZWVyc3RlIGRvb3IgZGUgZ2VtZWVuc2NoYXAgYWFuZ2VkcmV2ZW4gTWVtZSBUb2tlbiBvcCBkZSA8YSBocmVmPSIvcHJpY2Uvc29sYW5hLXNvbCIgcmVsPSJub2ZvbGxvdyBub29wZW5lciBub3JlZmVycmVyIiB0YXJnZXQ9Il9ibGFuayI+U29sYW5hPC9hPiBibG9ja2NoYWluLCBnZWJvcmVuIHRpamRlbnMgZGUgbGFnZSBwZXJpb2RlIHZhbiBkZSA8YSBocmVmPSIvcHJpY2Uvc29sYW5hLXNvbCIgcmVsPSJub2ZvbGxvdyBub29wZW5lciBub3JlZmVycmVyIiB0YXJnZXQ9Il9ibGFuayI+U29sYW5hPC9hPiBlY29zeXN0ZWVtIGluIGRlY2VtYmVyIDIwMjIuIERlIGtlcm5taXNzaWUgaXMgb20gZ2VicnVpa2Vyc3BhcnRpY2lwYXRpZSB0ZSBhY3RpdmVyZW4gZG9vciBtaWRkZWwgdmFuIGVlbiBnZWRlY2VudHJhbGlzZWVyZGUgY3VsdHV1ci4gSGV0IHByb2plY3QgYWlyZHJvcCBpbm5vdmF0aWVmIDUwJSB2YW4gZGUgdG90YWxlIHRva2Vudm9vcnJhYWQgbmFhciBvbnR3aWtrZWxhYXJzLCBhcnRpZXN0ZW4gZW4gZ2V3b25lIGdlYnJ1aWtlcnMsIGVuIHZlcnphbWVsdCBzbmVsIG1lZXIgZGFuIDQwMC4wMDAgaG91ZGFkcmVzc2VuLCB3YXQgZWVuIHN0ZXJrZSBnZW1lZW5zY2hhcHNiYXNpcyB2b3JtdC4gSW4gdGVnZW5zdGVsbGluZyB0b3QgTWVtZS1tdW50ZW4gZGllIHVpdHNsdWl0ZW5kIG9wIGh5cGUgdmVydHJvdXdlbiwgaXMgQk9OSyBkaWVwIGdlw69udGVncmVlcmQgaW4gaGV0IFNvbGFuYS1lY29zeXN0ZWVtOiBtZWVyIGRhbiAyMDAgcHJvamVjdGVuIGFjY2VwdGVyZW4gaGV0IGFscyBlZW4gYmV0YWxpbmdzbWlkZGVsLCBpbmNsdXNpZWYgTkZULWhhbmRlbCwgRGVGaS1wcm90b2NvbGxlbiBlbiB6ZWxmcyBpbi1hcHAgYWFua29wZW4gb3AgZGUgU29sYW5hLXRlbGVmb29uIFNhZ2EuIERlIGVjb2xvZ2lzY2hlIHRvb2xzLCB6b2FscyBkZSBCb25rQm90IGhhbmRlbHNyb2JvdCAoZGllIGdlbWlkZGVsZCAyMDAuMDAwIHRyYW5zYWN0aWVzIHBlciBkYWcgdmVyd2Vya3QpIGVuIGhldCBCb25rU3dhcC1wbGF0Zm9ybSwgYmllZGVuIGZ1bmN0aW9uZWxlIHdhYXJkZSBkaWUgdmVyZGVyIGdhYXQgZGFuIHR5cGlzY2hlIE1lbWUtbXVudGVuLjwvcD4KPGgyIGlkPSJoMi1CT05LMjBMYWF0c3RlMjBVcGRhdGVzNTI4MjgiPjxhIG5hbWU9IkJPTksgTGFhdHN0ZSBVcGRhdGVzIiBjbGFzcz0icmVmZXJlbmNlLWxpbmsiPjwvYT48c3BhbiBjbGFzcz0iaGVhZGVyLWxpbmsgb2N0aWNvbiBvY3RpY29uLWxpbmsiPjwvc3Bhbj5CT05LIExhYXRzdGUgVXBkYXRlczwvaDI+PHA+T3AgNyBqdWxpIDIwMjUgaXMgZGUgcHJpanMgdmFuIEJPTksgJDAuMDAwMDIxODQsIG1ldCBlZW4gZGFsaW5nIHZhbiAxLDEzJSBpbiAyNCB1dXIgZW4gZWVuIG1hcmt0a2FwaXRhbGlzYXRpZSB2YW4gb25nZXZlZXIgJDEsNzUgbWlsamFyZCwgd2F0IGRlIGRlcmRlIHBsYWF0cyBpbiBkZSBNZW1lLW11bnRzZWN0b3IgYmV0ZWtlbnQuIERlIGh1aWRpZ2UgY2lyY3VsYXRpZSB2YW4gQk9OSyBpcyA4MCw1MyBiaWxqb2VuIG11bnRlbiwgZ29lZCB2b29yIDkwLDYxJSB2YW4gZGUgdG90YWxlIHZvb3JyYWFkIHZhbiA4OCw4OCBiaWxqb2VuLiBEZSByZXN0ZXJlbmRlIHRva2VucyB6dWxsZW4gZ2VsZWlkZWxpamsgd29yZGVuIHZyaWpnZWdldmVuIHRvdCAyMDI1LiBVaXQgb24tY2hhaW4gZ2VnZXZlbnMgYmxpamt0IGRhdCBCT05LIHR3ZWUgZ3JvdGUgdWl0ZGFnaW5nZW4gb25kZXJ2aW5kdDo8L3A+CjxvbD4KPGxpPkdlY2VudHJhbGlzZWVyZCBob3VkaW5nc3Jpc2ljbzogRGUgdG9wIDEwIGFkcmVzc2VuIGJlaGVlcnNlbiAyOCUgdmFuIGRlIGNpcmN1bGVyZW5kZSB0b2tlbnMsIHdhdCBlZW4gcmlzaWNvIG9wIG1hbmlwdWxhdGllIG1ldCB6aWNoIG1lZWJyZW5ndDs8L2xpPjxsaT5JbmZsYXRpZWRydWs6IERlIHZyaWpnYXZlIHZhbiByZXN0ZXJlbmRlIHRva2VucyBrYW4gZGUgcG90ZW50aWVlbCB2b29yIHByaWpzc3RpamdpbmdlbiBvbmRlcmRydWtrZW4uPC9saT48L29sPgo8cD5PcCBoZXQgaGFuZGVsc3BsYXRmb3JtIGlzIEdhdGUgZWVuIGdhbmcga2FuYWFsIHZvb3IgYWFua29wZW4sIGRhdCBmaWF0dmFsdXRhLWRlcG9zaXRzIG9uZGVyc3RldW50IGVuIHRyYW5zYWN0aWVrb3N0ZW4gem8gbGFhZyBhbHMgMCwxJSBoZWVmdC48L3A+CjxoMiBpZD0iaDItUHJpanN2b29yc3BlbGxpbmcyMERyaWUyMFNjZW5hcmlvczIwZW4yMExhbmdlMjBUZXJtaWpuMjBQb3RlbnRpZWVsOTgzODI1Ij48YSBuYW1lPSJQcmlqc3Zvb3JzcGVsbGluZzogRHJpZSBTY2VuYXJpb+KAmXMgZW4gTGFuZ2UgVGVybWlqbiBQb3RlbnRpZWVsIiBjbGFzcz0icmVmZXJlbmNlLWxpbmsiPjwvYT48c3BhbiBjbGFzcz0iaGVhZGVyLWxpbmsgb2N0aWNvbiBvY3RpY29uLWxpbmsiPjwvc3Bhbj5Qcmlqc3Zvb3JzcGVsbGluZzogRHJpZSBTY2VuYXJpb+KAmXMgZW4gTGFuZ2UgVGVybWlqbiBQb3RlbnRpZWVsPC9oMj48cD5HZWJhc2VlcmQgb3AgbWFya3RjeWNsaSBlbiBkZSBvbnR3aWtrZWxpbmcgdmFuIGhldCBTb2xhbmEtZWNvc3lzdGVlbSBoZWJiZW4gYW5hbGlzdGVuIGRyaWUgc2NlbmFyaW/igJlzIHZvb3JnZXN0ZWxkIHZvb3IgZGUgcHJlc3RhdGllcyB2YW4gQk9OSyBpbiAyMDI1OjwvcD4KPG9sPgo8bGk+Vm9vcnR6ZXR0aW5nIHZhbiBkZSBiZXJlbm1hcmt0IChLYW5zIDIwJSk6IEFscyA8YSBocmVmPSIvcHJpY2UvYml0Y29pbi1idGMiIHJlbD0ibm9mb2xsb3cgbm9vcGVuZXIgbm9yZWZlcnJlciIgdGFyZ2V0PSJfYmxhbmsiPkJpdGNvaW48L2E+IGFscyBoZXQgb25kZXIgZGUgJDUwLjAwMCBkYWFsdCwga2FuIEJPTksgdmFsbGVuIHRvdCAkMC4wMDAwMDPigJMkMC4wMDAwMDU7PC9saT48bGk+R2VtYXRpZ2QgSGVyc3RlbCAoS2FucyA1MCUpOiBXYW5uZWVyIGRlIHRvdGFsZSB3YWFyZGUgZGllIGlzIHZlcmdyZW5kZWxkIChUVkwpIHZhbiBoZXQgU29sYW5hLWVjb3N5c3RlZW0gZ3JvZWl0IHRvdCAkMTAgbWlsamFyZCwga2FuIGRlIG1hcmt0a2FwaXRhbGlzYXRpZSB2YW4gQk9OSyAkMyBtaWxqYXJkIGJlcmVpa2VuLCBtZXQgZWVuIHByaWpzcmFuZ2UgdmFuICQwLjAwMDAz4oCTJDAuMDAwMDQ7PC9saT48bGk+RnJlbmV0aXNjaGUgU3RpZXJlbm1hcmt0IChLYW5zIDMwJSk6IEFscyA8YSBocmVmPSIvcHJpY2UvYml0Y29pbi1idGMiIHRhcmdldD0iX2JsYW5rIiBjbGFzcz0iYmxvZ19pbm5lcl9saW5rIj5CaXRjb2luPC9hPiBkb29yICQxNTAuMDAwIGJyZWVrdCBlbiA8YSBocmVmPSIvcHJpY2Uvc29sYW5hLXNvbCIgdGFyZ2V0PSJfYmxhbmsiIGNsYXNzPSJibG9nX2lubmVyX2xpbmsiPlNvbGFuYTwvYT4gaGV0IOKAnFdlYjMgQW5kcm9pZCBTeXN0ZWVt4oCdIHdvcmR0LCBrYW4gQk9OSyBkZSB0cmVuZCB2YW4gU0hJQiByZXBsaWNlcmVuLCBtZXQgZWVuIGJlcmVpayB2YW4gJDAuMDAwMeKAkyQwLjAwMDIuPC9saT48L29sPgo8cD5MYW5nZXRlcm1pam52b29yc3BlbGxpbmdlbiBnZXZlbiBhYW4gZGF0IEJPTksgdGVnZW4gMjAzMSAkMCwwMDA1IGthbiBiZXJlaWtlbiwgZWVuIHN0aWpnaW5nIHZhbiAyLjUwMCUgdGVuIG9wemljaHRlIHZhbiBkZSBodWlkaWdlIHByaWpzLjwvcD4KPGgyIGlkPSJoMi1Ub2Vrb21zdGlnZTIwVm9vcnVpdHppY2h0ZW4yMEludGVncmF0aWUyMHZhbjIwRWNvbG9naWUyMGVuMjBTYW1lbmxldmVuZGUyMFVpdGRhZ2luZ2VuOTMzNDIiPjxhIG5hbWU9IlRvZWtvbXN0aWdlIFZvb3J1aXR6aWNodGVuOiBJbnRlZ3JhdGllIHZhbiBFY29sb2dpZSBlbiBTYW1lbmxldmVuZGUgVWl0ZGFnaW5nZW4iIGNsYXNzPSJyZWZlcmVuY2UtbGluayI+PC9hPjxzcGFuIGNsYXNzPSJoZWFkZXItbGluayBvY3RpY29uIG9jdGljb24tbGluayI+PC9zcGFuPlRvZWtvbXN0aWdlIFZvb3J1aXR6aWNodGVuOiBJbnRlZ3JhdGllIHZhbiBFY29sb2dpZSBlbiBTYW1lbmxldmVuZGUgVWl0ZGFnaW5nZW48L2gyPjxwPkRlIG9udHdpa2tlbGluZyB2YW4gQk9OSyBpcyBzdGVyayBhZmhhbmtlbGlqayB2YW4gdHdlZSBiZWxhbmdyaWprZSBmYWN0b3Jlbjo8L3A+CjxvbD4KPGxpPkRvb3JicmFhayBpbiBkZSBlY29sb2dpc2NoZSB0b2VwYXNzaW5nc3NjZW5hcmlv4oCZcyB2YW4gU29sYW5hOiBBbHMgU29sYW5hIGFwcGxpY2F0aWVzIG1ldCBtaWxqb2VuZW4gZ2VicnVpa2VycyBpbiBkZSBiZXRhbGluZ3MtIGVuIGdhbWluZ3NlY3RvciBpbmN1YmVlcnQsIGthbiBCT05LLCBhbHMgZWVuIOKAnGN1bHR1cmVlbCBzeW1ib29s4oCdLCBlZW4gbWVkaXVtIHdvcmRlbiB2b29yIHdhYXJkZSBjaXJjdWxhdGllIGJpbm5lbiBoZXQgZWNvc3lzdGVlbTs8L2xpPjxsaT5PcHRpbWFsaXNhdGllIHZhbiBoZXQgVG9rZW4tZWNvbm9taXNjaGUgbW9kZWw6IERlIGdlbWVlbnNjaGFwIGhlZWZ0IGVlbiBwbGFuIHZvb3IgaGV0IHZlcmJyYW5kZW4gdmFuIHRva2VucyB2b29yZ2VzdGVsZCwgbWV0IGFscyBkb2VsIGVlbiBkZWVsIHZhbiBkZSB0cmFuc2FjdGllIGtvc3RlbiB0ZSBnZWJydWlrZW4gdm9vciB2ZXJicmFuZGluZy4gQWxzIGRlIGphYXJsaWprc2UgdmVyYnJhbmRpbmdzZ3JhYWQgMyUtNSUgYmVyZWlrdCwga2FuIGRpdCBkZSBpbmZsYXRvaXJlIGRydWsgdmVybGljaHRlbi48L2xpPjwvb2w+CjxwPldhdCBiZXRyZWZ0IGNvbXBldGl0aWUgbW9ldCBCT05LIGNvbmN1cnJlcmVuIG1ldCBkZSB2ZXJrZWVyc2NvbmN1cnJlbnRpZSB2YW4gbmlldXdlIE1lbWUtbXVudGVuIGJpbm5lbiBTb2xhbmEgKHpvYWxzIFdJRiwgUE9QQ0FUKSBlbiBleHRlcm5lIHB1YmxpZWtlIGtldGVuIE1lbWUtbXVudGVuICh6b2FscyBCUkVUVCBvcCBkZSBCYXNlLWtldGVuKS4gRWNodGVyLCBoZXQgdm9vcmRlZWwgdmFuIGRlIGVlcnN0ZSBtb3ZlciBlbiBkZSBkaWVwIGdlw69udGVncmVlcmRlIGVjb2xvZ2lzY2hlIHRvb2xzIGJsaWp2ZW4ga2VybmJhcnJpw6hyZXMuPC9wPgo8cD5Wb29yIGludmVzdGVlcmRlcnMgaXMgQk9OSyBnZXNjaGlrdGVyIGFscyBlZW4g4oCcU29sYW5hIGVjb3N5c3RlZW0gQmV0YeKAnSBhbGxvY2F0aWUsIHdhdCB2ZXJlaXN0IGRhdCBlciBhYW5kYWNodCBpcyB2b29yIG9uLWNoYWluIGJ1cm4tZ2VnZXZlbnMsIENFWC1saWpzdCBkeW5hbWllayBlbiBtYXJrdGdldm9lbCBjeWNsaSwgd2FhcmJpaiBob2dlIHZvbGF0aWxpdGVpdCB3b3JkdCBiZW51dCB2b29yIHN3aW5nIHRyYWRpbmcuPC9wPgo8ZGl2IGNsYXNzPSJibG9nLWRldGFpbHMtaW5mbyI+PGJyPjxkaXY+QXV0ZXVyOiA8c3Ryb25nPkJsb2d0ZWFtPC9zdHJvbmc+PGJyPjxkaXYgY2xhc3M9ImluZm8tdGlwcyI+PGVtPkRlIGluaG91ZCBoaWVydmFuIHZvcm10IGdlZW4gYWFuYm9kLCBzb2xsaWNpdGF0aWUgb2YgYWFuYmV2ZWxpbmcuIFUgZGllbnQgYWx0aWpkIG9uYWZoYW5rZWxpamsgcHJvZmVzc2lvbmVlbCBhZHZpZXMgaW4gdGUgd2lubmVuIHZvb3JkYXQgdSBpbnZlc3RlcmluZ3NiZXNsaXNzaW5nZW4gbmVlbXQuPGJyPjxkaXY+PC9kaXY+SG91ZCBlciByZWtlbmluZyBtZWUgZGF0IEdhdGUgaGV0IGdlYnJ1aWsgdmFuIGFsbGUgb2YgZWVuIGRlZWwgdmFuIGRlIERpZW5zdGVuIHZhbnVpdCBCZXBlcmt0ZSBMb2NhdGllcyBrYW4gYmVwZXJrZW4gb2YgdmVyYmllZGVuLiBWb29yIG1lZXIgaW5mb3JtYXRpZSBrdW50IHUgZGUgR2VicnVpa2Vyc292ZXJlZW5rb21zdCBsZXplbiB2aWEgPGEgaHJlZj0iaHR0cHM6Ly93d3cuZ2F0ZS5jb20vbGVnYWwvdXNlci1hZ3JlZW1lbnQiIGRhdGEtaW5kZXg9IjQiPmh0dHBzOi8vd3d3LmdhdGUuY29tL2xlZ2FsL3VzZXItYWdyZWVtZW50PC9hPi48YnI+PHA+PC9wPjxicj48L2VtPjwvZGl2PjwvZGl2PjwvZGl2Pg==