SGV0IG9udGh1bGxlbiB2YW4gYXJ0aXN0aWVrIHBvdGVudGllZWwgaW4gQsOpbmluIGRvb3IgbWlkZGVsIHZhbiBnYXRlIENoYXJpdHkncyBvcG1lcmtlbGlqa2UgcmVjeWNsaW5nIGV2ZW5lbWVudA==

2023-06-21, 17:37

PHA+QWZnZWxvcGVuIGRvbmRlcmRhZyAxNiBqdW5pIHpldHRlIEdhdGUuaW8gZWVuIGJlbGFuZ3JpamtlIHZvZXRhZmRydWsgaW4gaGV0IHphbmQgdmFuIGRlIHByYWNodGlnZSBrdXN0bGlqbiB2YW4gQsOpbmluLiBaZSB3ZXJrdGVuIHNhbWVuIG1ldCBtZWVyIGRhbiAzMCBrdW5zdHN0dWRlbnRlbiB2YW4gZGUgVW5pdmVyc2l0ZWl0IHZhbiBBYm9tZXktQ2FsYXZpIHZvb3IgZWVuIGlubm92YXRpZWYgZW4gbWlsaWV1YmV3dXN0IGV2ZW5lbWVudC4gRGV6ZSBzcGVjaWFsZSBnZWxlZ2VuaGVpZCBjb21iaW5lZXJkZSBjcmVhdGl2aXRlaXQsIGt1bnN0LCB0ZWNobm9sb2dpZSBlbiBsaWVmZGFkaWdoZWlkLCB3YWFybWVlIGhldCBiZWxhbmcgdmFuIGR1dXJ6YWFtaGVpZCBlbiB2ZXJhbnR3b29yZGVsaWpraGVpZCB3ZXJkIGJlbmFkcnVrdC4gPGEgaHJlZj0iaHR0cHM6Ly93d3cuZ2F0ZS5pby9jaGFyaXR5Lz9jaD1HTV9ibG9nX2JlbmluXzIwMjMwNjIyJmFtcDt1dG1fY2FtcGFpZ249VFJfbEY4UXlJQWsmYW1wO3V0bV9jb250ZW50PSZhbXA7dXRtX21lZGl1bT1wdHImYW1wO3V0bV9zb3VyY2U9Q0hfc0FwcXk4M0YmYW1wO3V0bV90ZXJtPSIgdGFyZ2V0PSJfYmxhbmsiPkdhdGUgQ2hhcml0eeKAmXM8L2E+IHRvZXdpamRpbmcgb20gaWV0cyB0ZXJ1ZyB0ZSBnZXZlbiBhYW4gZGUgZ2VtZWVuc2NoYXAgZW4gaGV0IGJlbmFkcnVra2VuIHZhbiBkZSBkcmluZ2VuZGUgYmVob2VmdGUgYWFuIG1pbGlldWJlaG91ZC48L3A+CjxwPjxpbWcgc3JjPSJodHRwczovL2dpbWcyLmdhdGVpbWcuY29tL2ltYWdlL2FydGljbGUvMTY4NzM2ODY5MTIwMjMwNjIxLTEzMTAxMi5qcGVnIiBhbHQ9IiI+PC9wPgo8aDIgaWQ9ImgyLURlYnJpc3ZlcnphbWVsaW5nMjBEZTIwZ2Vib29ydGUyMHZhbjIwY3JlYXRpZWYyMG1hdGVyaWFhbDI3NzY4NCI+PGEgbmFtZT0iRGVicmlzdmVyemFtZWxpbmc6IERlIGdlYm9vcnRlIHZhbiBjcmVhdGllZiBtYXRlcmlhYWwiIGNsYXNzPSJyZWZlcmVuY2UtbGluayI+PC9hPjxzcGFuIGNsYXNzPSJoZWFkZXItbGluayBvY3RpY29uIG9jdGljb24tbGluayI+PC9zcGFuPkRlYnJpc3ZlcnphbWVsaW5nOiBEZSBnZWJvb3J0ZSB2YW4gY3JlYXRpZWYgbWF0ZXJpYWFsPC9oMj48cD5EZSBkYWcgYmVnb24gbWV0IGVlbiBlbmVyZ2lla2UgYmlqZWVua29tc3QgdmFuIGt1bnN0c3R1ZGVudGVuLCBrbGFhciBvbSBwdWluIHRlIHZlcnphbWVsZW4gZGF0IHZlcnNwcmVpZCBsYWcgbGFuZ3MgaGV0IHNjaGlsZGVyYWNodGlnZSBzdHJhbmQuIFZlcnNpZXJkIG1ldCA8YSBocmVmPSJodHRwczovL3d3dy5nYXRlLmlvL2NoYXJpdHkvP2NoPUdNX2Jsb2dfYmVuaW5fMjAyMzA2MjImYW1wO3V0bV9jYW1wYWlnbj1UUl9sRjhReUlBayZhbXA7dXRtX2NvbnRlbnQ9JmFtcDt1dG1fbWVkaXVtPXB0ciZhbXA7dXRtX3NvdXJjZT1DSF9zQXBxeTgzRiZhbXA7dXRtX3Rlcm09IiB0YXJnZXQ9Il9ibGFuayI+R2F0ZSBDaGFyaXR5PC9hPiBNZXQgVC1zaGlydHMgYWFuIGhlYmJlbiBkZXplIG1pbGlldWFjdGl2aXN0ZW4gaWp2ZXJpZyBkb29yIGhldCB6YW5kIGdlc3BldXJkIG9tIGhldCBtaWxpZXUgdGUgcmVkZGVuIHZhbiBzY2hhZGVsaWprIGFmdmFsLiBEaXQgd2FzIG5pZXQgYWxsZWVuIGVlbiBkYWFkIHZhbiBtaWxpZXViZXNjaGVybWluZywgbWFhciBvb2sgZGUgZWVyc3RlIHN0YXAgaW4gaHVuIGNyZWF0aWV2ZSBwcm9jZXMuPC9wPgo8cD5UZXJ3aWpsIGRlIHpvbiBiZWdvbiB0ZSB6YWtrZW4sIHdlcmRlbiBkZSBoYXJkd2Vya2VuZGUgc3R1ZGVudGVuIGJlbG9vbmQgbWV0IGVlbiBvbnRzcGFubmVuZGUgc25hY2t0aWpkLiBaZSB3ZXJkZW4gZ2V0cmFrdGVlcmQgb3Agc2FuZHdpY2hlcyBlbiBzYXBwZW4sIGRpZSBicm9vZG5vZGlnZSB2b2VkaW5nIGJvZGVuIG5hIGVlbiBkYWcgaGFyZCB3ZXJrZW4uIERlIHBhdXplIHdhcyBvb2sgZWVuIGdlbGVnZW5oZWlkIG9tIGRlIHN0dWRlbnRlbiB0ZSBpbmZvcm1lcmVuIG92ZXIgZGUgbGllZmRhZGlnaGVpZHNpbnNwYW5uaW5nZW4gdmFuIEdhdGUgQ2hhcml0eSwgd2F0IGluc3BpcmF0aWUgb3B3ZWt0ZSB2b29yIGh1biBrb21lbmRlIGNyZWF0aWVzLjwvcD4KPHA+PGltZyBzcmM9Imh0dHBzOi8vZ2ltZzIuZ2F0ZWltZy5jb20vaW1hZ2UvYXJ0aWNsZS8xNjg3MzY4NzMwMjAyMzA2MjEtMTMxMDE4LmpwZWciIGFsdD0iIj48L3A+CjxoMiBpZD0iaDItQ3JlYXRpZTIwQWZ2YWwyMG9temV0dGVuMjBpbjIwc2NoYXR0ZW4zNDQzNjkiPjxhIG5hbWU9IkNyZWF0aWU6IEFmdmFsIG9temV0dGVuIGluIHNjaGF0dGVuIiBjbGFzcz0icmVmZXJlbmNlLWxpbmsiPjwvYT48c3BhbiBjbGFzcz0iaGVhZGVyLWxpbmsgb2N0aWNvbiBvY3RpY29uLWxpbmsiPjwvc3Bhbj5DcmVhdGllOiBBZnZhbCBvbXpldHRlbiBpbiBzY2hhdHRlbjwvaDI+PHA+SGV0IHZlcnphbWVsZGUgcHVpbiBkaWVuZGUgYWxzIGdyb25kc3RvZiB2b29yIGRlIGNyZWF0aWV2ZSBpbnNwYW5uaW5nZW4gdmFuIGRlIHN0dWRlbnRlbi4gR2V3YXBlbmQgbWV0IGVlbiBuaWV1dyBnZXZvZWwgdmFuIG1pbGlldWJld3VzdHppam4gZW4gYXJ0aXN0aWVrZSBpbnNwaXJhdGllLCB0cmFuc2Zvcm1lZXJkZW4gemUgd2VnZ2Vnb29pZGUgb2JqZWN0ZW4gdG90IHByYWNodGlnZSBrdW5zdHdlcmtlbiwgdmFyacOrcmVuZCB2YW4gZXhwcmVzc2lldmUgc2NoaWxkZXJpamVuIHRvdCBpbmdld2lra2VsZGUgc2N1bHB0dXJlbiBlbiB0aWpkZWxpamtlIHZsdWNodGlnZSBpbnN0YWxsYXRpZXMuIEVlbiBwcm9mZXNzaW9uZWxlIGZvdG9ncmFhZiB3YXMgYWFud2V6aWcgb20gZWxrIHVuaWVrIGt1bnN0d2VyayB2YXN0IHRlIGxlZ2dlbiBlbiBkZSBvcG1lcmtlbGlqa2UgdHJhbnNmb3JtYXRpZSB2YW4gYWZ2YWwgbmFhciB2ZXJ3b25kZXJpbmcgdmFzdCB0ZSBsZWdnZW4uPC9wPgo8aDIgaWQ9ImgyLU5GVDIwTWludGluZzIwS3Vuc3QyMGJlaG91ZGVuMjBpbjIwaGV0MjBkaWdpdGFsZTIwZG9tZWluMjI3Nzk0Ij48YSBuYW1lPSJORlQgTWludGluZzogS3Vuc3QgYmVob3VkZW4gaW4gaGV0IGRpZ2l0YWxlIGRvbWVpbiIgY2xhc3M9InJlZmVyZW5jZS1saW5rIj48L2E+PHNwYW4gY2xhc3M9ImhlYWRlci1saW5rIG9jdGljb24gb2N0aWNvbi1saW5rIj48L3NwYW4+TkZUIE1pbnRpbmc6IEt1bnN0IGJlaG91ZGVuIGluIGhldCBkaWdpdGFsZSBkb21laW48L2gyPjxwPkRlIHJlaXMgdmFuIGRlemUga3Vuc3R3ZXJrZW4gZWluZGlnZGUgbmlldCBpbiBkZSBmeXNpZWtlIHdlcmVsZC4gRWxrZSB2YXN0Z2VsZWdkZSBhZmJlZWxkaW5nIHphbCB3b3JkZW4gZ2VtdW50IHRvdCBlZW4gTkZULCBrbGFhciB2b29yIGRlIGxpZWZkYWRpZ2hlaWRzdmVya29vcCBvcCBHYXRlIE5GVC4gRGUgb3BicmVuZ3N0IHZhbiBkZSBORlQtdmVya29vcCB6YWwgd29yZGVuIGdlZG9uZWVyZCBhYW4gZGUgVW5pdmVyc2l0ZWl0IHZhbiBBYm9tZXktQ2FsYXZpLjwvcD4KPHA+TmV0IHpvYWxzIGt1bnN0ZW5hYXJzIG92ZXIgZGUgaGVsZSB3ZXJlbGQgc3RyYW5kYWZ2YWwgaGViYmVuIG9tZ2V0b3ZlcmQgdG90IGt1bnN0d2Vya2VuLCBoZWJiZW4gZGUgc3R1ZGVudGVuIGluIELDqW5pbiBlZW4gYmVsYW5ncmlqa2Ugc3RhcCBnZXpldCBuYWFyIGhldCBjb21iaW5lcmVuIHZhbiBjcmVhdGl2aXRlaXQgbWV0IG1pbGlldWJld3VzdHppam4uIERlemUgaW5pdGlhdGllZiBvdmVyYnJ1Z3QgZGUga2xvb2YgdHVzc2VuIHRyYWRpdGlvbmVsZSBrdW5zdCBlbiBkZSBvcGtvbWVuZGUgd2VyZWxkIHZhbiBjcnlwdG8sIHdhYXJkb29yIGRpZ2l0YWxlIGVudGhvdXNpYXN0ZWxpbmdlbiB3ZXJlbGR3aWpkIGRlIGNyZWF0aWV2ZSB0YWxlbnRlbiB2YW4gZGUgc3R1ZGVudGVuIHVpdCBCw6luaW4ga3VubmVuIHdhYXJkZXJlbiBlbiBpbnZlc3RlcmVuLiA8YSBocmVmPSJodHRwczovL3d3dy5nYXRlLmlvL2NoYXJpdHkvP2NoPUdNX2Jsb2dfYmVuaW5fMjAyMzA2MjImYW1wO3V0bV9jYW1wYWlnbj1UUl9sRjhReUlBayZhbXA7dXRtX2NvbnRlbnQ9JmFtcDt1dG1fbWVkaXVtPXB0ciZhbXA7dXRtX3NvdXJjZT1DSF9zQXBxeTgzRiZhbXA7dXRtX3Rlcm09IiB0YXJnZXQ9Il9ibGFuayI+R2F0ZSBMaWVmZGFkaWdoZWlkPC9hPiB3YXMgdHJvdHMgb20gZGl0IGluaXRpYXRpZWYgdGUgaGViYmVuIGdlbGVpZC48L3A+CjxwPkRpdCBzdWNjZXN2b2xsZSBldmVuZW1lbnQgaGVlZnQgYWFuZ2V0b29uZCBkYXQgdmVyYW5kZXJpbmcgdmFhayBiZWdpbnQgb3AgaGV0IHNuaWp2bGFrIHZhbiBjcmVhdGl2aXRlaXQsIHRlY2hub2xvZ2llIGVuIGJldHJva2tlbmhlaWQgdmFuIGRlIGdlbWVlbnNjaGFwLiA8YSBocmVmPSJodHRwczovL3d3dy5nYXRlLmlvL2NoYXJpdHkvP2NoPUdNX2Jsb2dfYmVuaW5fMjAyMzA2MjImYW1wO3V0bV9jYW1wYWlnbj1UUl9sRjhReUlBayZhbXA7dXRtX2NvbnRlbnQ9JmFtcDt1dG1fbWVkaXVtPXB0ciZhbXA7dXRtX3NvdXJjZT1DSF9zQXBxeTgzRiZhbXA7dXRtX3Rlcm09IiB0YXJnZXQ9Il9ibGFuayI+R2F0ZSBMaWVmZGFkaWdoZWlkPC9hPiB6YWwgcHJpb3JpdGVpdCBibGlqdmVuIGdldmVuIGFhbiBkZSBtaXNzaWUgdmFuIGhldCBiZXNjaGVybWVuIHZhbiBoZXQgbWlsaWV1IGVuIGhldCBvbmRlcnN0ZXVuZW4gdmFuIGRlIGt1bnN0ZW4sIGVuIHphbCB6aWpuIGJlc3QgZG9lbiBvbSBCw6luaW4gZW4gYW5kZXJlIHJlZ2lv4oCZcyBvdmVyIGRlIGhlbGUgd2VyZWxkIHRlIGhlbHBlbiBiaWogaGV0IHByb21vdGVuIHZhbiBpbm5vdmF0aWV2ZSBpbml0aWF0aWV2ZW4gb3AgaGV0IGdlYmllZCB2YW4gbWlsaWV1YmVzY2hlcm1pbmcuPC9wPgo8cD5BdXRldXI6IEdsb2JhbCBNYXJrZXRpbmcgTWFzb248YnI+RGl0IGFydGlrZWwgdmVydGVnZW53b29yZGlndCBhbGxlZW4gZGUgbWVuaW5nIHZhbiBkZSBvbmRlcnpvZWtlciBlbiB2b3JtdCBnZWVuIGVua2VsZSBiZWxlZ2dpbmdzYWFuYmV2ZWxpbmcuPGJyPkdhdGUuaW8gYmVob3VkdCBhbGxlIHJlY2h0ZW4gb3AgZGl0IGFydGlrZWwuIEhldCBpcyB0b2VnZXN0YWFuIG9tIGhldCBhcnRpa2VsIG9wbmlldXcgdGUgcGxhYXRzZW4sIG1pdHMgR2F0ZS5pbyB3b3JkdCB2ZXJtZWxkLiBJbiBhbGxlIGdsZW4gemFsIGp1cmlkaXNjaGUgYWN0aWUgd29yZGVuIG9uZGVybm9tZW4gdmFud2VnZSBhdXRldXJzcmVjaHRpbmJyZXVrLjwvcD4=