Z2F0ZUxpdmUgQU1BIFJlY2FwLVNVTkRPRw==

2024-08-30, 08:07

PHA+PGltZyBzcmM9Imh0dHBzOi8vZ2ltZzIuZ2F0ZWltZy5jb20vaW1hZ2UvYXJ0aWNsZS8xNzI1MDA1MTQyZGNjNDNlYzAtMGI4MC00OGViLWEwOWItZWE1NDdlNDZhYjM5LnBuZyIgYWx0PSIiPjwvcD4KPGgyIGlkPSJoMi1RMTIwQ29zYTIwcGVuc2kyMHNpYW5vMjBpMjBmYXR0b3JpMjBjaGlhdmUyMGNoZTIwZ3VpZGFubzIwbGEyMHBvcG9sYXJpdDIwZGVsbGUyMFRST04yME1lbWVjb2luczYwOTA5MSI+PGEgbmFtZT0iUTEuIENvc2EgcGVuc2kgc2lhbm8gaSBmYXR0b3JpIGNoaWF2ZSBjaGUgZ3VpZGFubyBsYSBwb3BvbGFyaXTDoCBkZWxsZSBUUk9OIE1lbWVjb2lucz8iIGNsYXNzPSJyZWZlcmVuY2UtbGluayI+PC9hPjxzcGFuIGNsYXNzPSJoZWFkZXItbGluayBvY3RpY29uIG9jdGljb24tbGluayI+PC9zcGFuPlExLiBDb3NhIHBlbnNpIHNpYW5vIGkgZmF0dG9yaSBjaGlhdmUgY2hlIGd1aWRhbm8gbGEgcG9wb2xhcml0w6AgZGVsbGUgPGEgaHJlZj0iL3ByaWNlL3Ryb24tdHJ4IiB0YXJnZXQ9Il9ibGFuayIgY2xhc3M9ImJsb2dfaW5uZXJfbGluayI+VFJPTjwvYT4gTWVtZWNvaW5zPzwvaDI+PHA+TGEgcG9wb2xhcml0w6AgZGkgPGEgaHJlZj0iL3ByaWNlL3Ryb24tdHJ4IiByZWw9Im5vZm9sbG93IG5vb3BlbmVyIG5vcmVmZXJyZXIiIHRhcmdldD0iX2JsYW5rIj5UUk9OPC9hPiBJIG1lbWVjb2luIHBvc3Nvbm8gZXNzZXJlIGF0dHJpYnVpdGkgYSBkaXZlcnNpIGZhdHRvcmkgY2hpYXZlLiBM4oCZZWNvc2lzdGVtYSBTdW5wdW1wLCBhZCBlc2VtcGlvLCBzdGEgc3VwZXJhbmRvIFNPTCwgYXR0aXJhbmRvIGzigJlhdHRlbnppb25lIGNvbiBsYSBzdWEgbnVvdmEgY2F0ZW5hLCB1bmEgY29tdW5pdMOgIGRpbmFtaWNhIGUgdW4gdGVhbSBhZ2lsZSBlIHJlYXR0aXZvLiBMZSBzdGF0aXN0aWNoZSBpbXByZXNzaW9uYW50aSBpbmNsdWRvbm8gMTIuNzY1IG1lbWUgY3JlYXRpIHN1IFN1bnB1bXAgZSBxdWFzaSA1IG1pbGlvbmkgZGkgVFJYIGRpIGNvbW1pc3Npb25pLiBJbm9sdHJlLCBs4oCZZWNvc2lzdGVtYSBoYSBzdXBlcmF0byBTT0wgaW4gdGVybWluaSBkaSByaWNhdmkgZSB2b2x1bWUgbmVsbOKAmXVsdGltYSBzZXR0aW1hbmEuIEFuY2hlIGxhIGZvcnRlIHBvc2l6aW9uZSBkaSBUUk9OIG5lbCBtZXJjYXRvIGRlbGxlIHN0YWJsZWNvaW4gY29udHJpYnVpc2NlLCBjb24gdHJhbnNhemlvbmkgVVNEVCBzdWxsYSByZXRlIEVWTSBjaGUgc3VwZXJhbm8gaSAxOCBtaWxpb25pIHNldHRpbWFuYWxpIGUgVFJPTiBEQU8gY2hlIGdlc3Rpc2NlIGlsIDc4JSBkaSBxdWVzdG8gdm9sdW1lLiBDacOyIGluZGljYSB1buKAmW9wcG9ydHVuaXTDoCBzb3N0YW56aWFsZSBwZXIgY29udmVydGlyZSBpIGRldGVudG9yaSBkaSBUUlggaW4gZGV0ZW50b3JpIGRpICRTVU5ET0cuIENvbiBvbHRyZSAkNjAgbWlsaWFyZGkgZGkgc3RhYmxlY29pbiBlbWVzc2kgZSBwacO5IGRpIDIgbWlsaW9uaSBkaSB1dGVudGkgYXR0aXZpIGFsIGdpb3JubywgaWwgdm9sdW1lIGVsZXZhdG8gZGVsbGUgdHJhbnNhemlvbmkgZGkgVVNEVCBlIGxhIGJhc2UgZGkgdXRlbnRpIGZvcm5pc2Nvbm8gdW7igJlhbXBpYSBsaXF1aWRpdMOgIHBlciBpbCBtZXJjYXRvIGRlaSBtZW1lLjwvcD4KPGgyIGlkPSJoMi1RMjIwUHVvaTIwY29uZGl2aWRlcmUyMGRlbGxlMjBzdG9yaWUyMHN1MjBTVU5ET0c4OTA0OTkiPjxhIG5hbWU9IlEyLiBQdW9pIGNvbmRpdmlkZXJlIGRlbGxlIHN0b3JpZSBzdSBTVU5ET0c/IiBjbGFzcz0icmVmZXJlbmNlLWxpbmsiPjwvYT48c3BhbiBjbGFzcz0iaGVhZGVyLWxpbmsgb2N0aWNvbiBvY3RpY29uLWxpbmsiPjwvc3Bhbj5RMi4gUHVvaSBjb25kaXZpZGVyZSBkZWxsZSBzdG9yaWUgc3UgU1VORE9HPzwvaDI+PHA+U1VORE9HIGhhIHJhZ2dpdW50byBpbXBvcnRhbnRpIHRyYWd1YXJkaSwgdHJhIGN1aSBpbCByYWdnaXVuZ2ltZW50byBkaSB1biBtYXNzaW1vIHN0b3JpY28gZGkgY2FwaXRhbGl6emF6aW9uZSBkaSBtZXJjYXRvIGRpICQzMDAgbWlsaW9uaSBpbiBzb2xpIDEwIGdpb3JuaS4gSnVzdGluIFN1biBoYSBpbm9sdHJlIHN1cHBvcnRhdG8gbnVtZXJvc2Ugdm9sdGUgbOKAmXVmZmljaWFsZSAkU1VORE9HIFR3aXR0ZXIsIGF1bWVudGFuZG9uZSB1bHRlcmlvcm1lbnRlIHZpc2liaWxpdMOgIGUgY3JlZGliaWxpdMOgLjwvcD4KPGgyIGlkPSJoMi1RMzIwQ29tZTIwdmVkaTIwbGV2b2x1emlvbmUyMGZ1dHVyYTIwZGVsbGUyMFRST04yME1lbWVjb2luczQ0ODkyNyI+PGEgbmFtZT0iUTMuIENvbWUgdmVkaSBs4oCZZXZvbHV6aW9uZSBmdXR1cmEgZGVsbGUgVFJPTiBNZW1lY29pbnM/IiBjbGFzcz0icmVmZXJlbmNlLWxpbmsiPjwvYT48c3BhbiBjbGFzcz0iaGVhZGVyLWxpbmsgb2N0aWNvbiBvY3RpY29uLWxpbmsiPjwvc3Bhbj5RMy4gQ29tZSB2ZWRpIGzigJlldm9sdXppb25lIGZ1dHVyYSBkZWxsZSBUUk9OIE1lbWVjb2lucz88L2gyPjxwPklsIGZ1dHVybyBkZWxsZSBUUk9OIE1lbWVjb2lucyDDqCBwcm9tZXR0ZW50ZSBwb2ljaMOpIHNvbm8gZGVzdGluYXRlIGEgc3ZvbGdlcmUgdW4gcnVvbG8gZm9uZGFtZW50YWxlIG5lbCBwbGFzbWFyZSBsbyBzcGF6aW8gY3JpcHRvLiBUUk9OIHN0YSBkaXZlbnRhbmRvIHJhcGlkYW1lbnRlIHVuYSBwaWF0dGFmb3JtYSBsZWFkZXIgcGVyIHByb2dldHRpIGlubm92YXRpdmkgZ3VpZGF0aSBkYWxsYSBjb211bml0w6AuIE1hbiBtYW5vIGNoZSBsZSBtZW1lY29pbnMgZGkgVFJPTiBndWFkYWduYW5vIHBvcG9sYXJpdMOgLCBhdHRpcmVyYW5ubyBkZWNpbmUgZGkgbWlnbGlhaWEgZGkgbnVvdmkgdHJhZGVyLCBjcmVhbmRvIHVuIGVjb3Npc3RlbWEgdmlicmFudGUgZSBhdXRvLXNvc3RlbmliaWxlLiBOZWwgcHJvc3NpbW8gZnV0dXJvLCBzaSBwcmV2ZWRlIGNoZSBsZSBtZW1lY29pbnMgZGkgVFJPTiBub24gc29sbyBjb21wZXRhbm8gbWEgc3VwZXJpbm8gaSBsb3JvIG9tb2xvZ2hpIHN1IGFsdHJlIGNhdGVuZSwgc3RhYmlsZW5kbyBudW92aSBzdGFuZGFyZCBlIGd1aWRhbmRvIGxhIHByb3NzaW1hIG9uZGF0YSBkaSBpbm5vdmF6aW9uZSBjcmlwdG8uIExhIG5hcnJhemlvbmUgc3RhIGNhbWJpYW5kbyBlIFRST04gw6ggaW4gcHJpbWEgbGluZWEsIHByb250byBhIHRyYXNmb3JtYXJlIGxvIHNwYXppbyBkZWxsZSBtZW1lY29pbnMgaW4gcXVhbGNvc2EgZGkgaW1wYXR0YW50ZSBlIGR1cmF0dXJvLjwvcD4KPGgyIGlkPSJoMi1RNDIwUXVhbGkyMHNvbm8yMGxlMjBzZmlkZTIwY29tdW5pMjBhZmZyb250YXRlMjBkYWkyMFRST04yME1lbWVjb2luczcwMzQ5OSI+PGEgbmFtZT0iUTQuIFF1YWxpIHNvbm8gbGUgc2ZpZGUgY29tdW5pIGFmZnJvbnRhdGUgZGFpIFRST04gTWVtZWNvaW5zPyIgY2xhc3M9InJlZmVyZW5jZS1saW5rIj48L2E+PHNwYW4gY2xhc3M9ImhlYWRlci1saW5rIG9jdGljb24gb2N0aWNvbi1saW5rIj48L3NwYW4+UTQuIFF1YWxpIHNvbm8gbGUgc2ZpZGUgY29tdW5pIGFmZnJvbnRhdGUgZGFpIFRST04gTWVtZWNvaW5zPzwvaDI+PHA+TGUgc2ZpZGUgZXNpc3Rvbm8sIG1hIHByZXNlbnRhbm8gc2lnbmlmaWNhdGl2ZSBvcHBvcnR1bml0w6AgZGkgY3Jlc2NpdGEuIEzigJlpbmZyYXN0cnV0dHVyYSBhdHRvcm5vIGFsbGEgY2F0ZW5hIFRST04gw6ggYW5jb3JhIGluIGZhc2UgZGkgc3ZpbHVwcG8gZSBtb2x0ZSBwZXJzb25lIHNvbm8gbnVvdmUgaW4gcXVlc3RvIHNldHRvcmUuIFR1dHRhdmlhLCBxdWkgcmlzaWVkZSBpbCBwb3RlbnppYWxlLiBMYSBjcmVzY2l0YSBkZWxs4oCZaW5mcmFzdHJ1dHR1cmEgaW5kaWNhIGNoZSBzaWFtbyBhbmNvcmEgYWxs4oCZaW5pemlvIGRpIHF1YWxjb3NhIGRpIGdyYW5kZSwgY29uIHVuIGVub3JtZSBwb3RlbnppYWxlIGluIHF1YW50byB2ZW5nb25vIHN2aWx1cHBhdGkgbnVvdmkgc3RydW1lbnRpLCBwaWF0dGFmb3JtZSBlIHNlcnZpemkgaW50b3JubyBhIFRST04uIEdsaSBlYXJseSBhZG9wdGVyIHNvbm8gaW4gdW5hIHBvc2l6aW9uZSBmYXZvcmV2b2xlIHBlciBiZW5lZmljaWFyZSBtYW4gbWFubyBjaGUgcXVlc3RvIGVjb3Npc3RlbWEgbWF0dXJhIGUgZGl2ZW50YSBwacO5IHJvYnVzdG8uIExhIG5vdml0w6AgZGVsbGEgY29tdW5pdMOgIG9mZnJlIGFuY2hlIGxhIHBvc3NpYmlsaXTDoCBkaSBwbGFzbWFyZSBpbCBmdXR1cm8gY29uIGlkZWUgZnJlc2NoZSBlIGlubm92YXppb25lLCBzcGluZ2VuZG8gaSBtZW1lY29pbiBkaSBUUk9OIGFsIGNlbnRybyBkZWwgbW9uZG8gZGVsbGUgY3JpcHRvdmFsdXRlLjwvcD4KPGgyIGlkPSJoMi1RNTIwQ29zMjBTVU5CT1QyMFBlcmNoMjBoYWkyMGRlY2lzbzIwZGkyMGxhbmNpYXJsbzE0MzQwIj48YSBuYW1lPSJRNS4gQ29z4oCZw6ggU1VOQk9UPyBQZXJjaMOpIGhhaSBkZWNpc28gZGkgbGFuY2lhcmxvPyIgY2xhc3M9InJlZmVyZW5jZS1saW5rIj48L2E+PHNwYW4gY2xhc3M9ImhlYWRlci1saW5rIG9jdGljb24gb2N0aWNvbi1saW5rIj48L3NwYW4+UTUuIENvc+KAmcOoIFNVTkJPVD8gUGVyY2jDqSBoYWkgZGVjaXNvIGRpIGxhbmNpYXJsbz88L2gyPjxwPlNVTkJPVCDDqCBsbyBzdHJ1bWVudG8gZGVmaW5pdGl2byBwZXIgaWwgdHJhZGluZyBkaSBtZW1lIGNvaW4gc3UgVFJPTiwgbGEgY2F0ZW5hIHBpw7kgY2FsZGEgZGVsIGdpb2NvISBTdHJlYW1saW5lZCwgcG90ZW50ZSBlIHZlbG9jaXNzaW1vLCBTVU5CT1QgdGkgY29uc2VudGUgZGkgZmFyZSB0cmFkaW5nIGluIG1vZG8gcGnDuSBlZmZpY2llbnRlIHNpYSBzdSBzdW5wdW1wLm1lbWUgY2hlIHN1IHN1bi5pby4gQnJ1Y2lhbW8gZSByaWFjcXVpc3RpYW1vIHR1dHRlIGxlIGNvbW1pc3Npb25pIGRhbCBib3QgcGVyIGkgcHJvc3NpbWkgMzAgZ2lvcm5pLjwvcD4KPGRpdiBjbGFzcz0iYmxvZy1kZXRhaWxzLWluZm8iPjxicj48ZGl2PkF1dG9yZTo8c3Ryb25nPiBHYXRlTGl2ZTwvc3Ryb25nPiwgVGVhbSBkaSBHYXRlLmlvPGJyPjxkaXYgY2xhc3M9ImluZm8tdGlwcyI+PGVtPlF1ZXN0byBhcnRpY29sbyByYXBwcmVzZW50YSBzb2xvIGxlIG9waW5pb25pIGRlbCByaWNlcmNhdG9yZSBlIG5vbiBjb3N0aXR1aXNjZSBhbGN1biBzdWdnZXJpbWVudG8gZGkgaW52ZXN0aW1lbnRvLjxicj48L2VtPjxkaXY+PGVtPjwvZW0+R2F0ZS5pbyBzaSByaXNlcnZhIHR1dHRpIGkgZGlyaXR0aSBzdSBxdWVzdG8gYXJ0aWNvbG8uIFNhcsOgIGNvbnNlbnRpdG8gcmlwb3N0YXJlIGwnYXJ0aWNvbG8gYSBjb25kaXppb25lIGNoZSBzaSBmYWNjaWEgcmlmZXJpbWVudG8gYSBHYXRlLmlvLiBJbiB0dXR0aSBpIGNhc2ksIHZlcnJhbm5vIGludHJhcHJlc2UgYXppb25pIGxlZ2FsaSBwZXIgdmlvbGF6aW9uZSBkZWwgY29weXJpZ2h0Ljxicj48L2Rpdj48cD48L3A+PGJyPjwvZGl2PjwvZGl2PjwvZGl2Pg==