SG9lIHdlcmt0IE1hcmtldCBNYWtpbmc/

2023-01-25, 06:31

PHA+PGltZyBzcmM9Imh0dHBzOi8vZ2ltZzIuZ2F0ZWltZy5jb20vaW1hZ2UvYXJ0aWNsZS8xNjc0NjI4MjM4MTEucG5nIiBhbHQ9IiI+PGJyPkVlcmRlciBoZWJiZW4gd2UgZWVuIG92ZXJ6aWNodCBnZWdldmVuIHZhbiBlZW4gaW50cm9kdWN0aWUgdG90IG1hcmtldCBtYWtlcnMgZW4gd2Fhcm9tIHplIGJlbGFuZ3Jpamsgemlqbi4gPGEgaHJlZj0iaHR0cHM6Ly93d3cuZ2F0ZS5pby9ibG9nX2RldGFpbC8yMDYyL3doYXQtaXMtbWFya2V0LW1ha2luZz9jYXRlX2lkPTEwIiB0YXJnZXQ9Il9ibGFuayI+aGllcjwvYT4uIEluIGRpdCBhcnRpa2VsIHp1bGxlbiB3ZSBkaWVwZXIgaW5nYWFuIG9wIGhldCBtZWNoYW5pc21lIHZhbiBtYXJrZXQgbWFraW5nIGVuIGRlIGNydWNpYWxlIHJvbCBlcnZhbiBiaWogaGV0IHdhYXJib3JnZW4gdmFuIG1hcmt0c3RhYmlsaXRlaXQuPC9wPgo8cD5NYXJrZXQgbWFrZXJzIHNwZWxlbiBlZW4gY3J1Y2lhbGUgcm9sIGluIGZpbmFuY2nDq2xlIG1hcmt0ZW4gZG9vciBoZXQgZmFjaWxpdGVyZW4gdmFuIGRlIGtvb3AgZW4gdmVya29vcCB2YW4gZWZmZWN0ZW4gZW4gaGV0IGJldm9yZGVyZW4gdmFuIGxpcXVpZGl0ZWl0LjwvcD4KPHA+SmUga3VudCB6ZSB6aWVuIGFscyBlZW4gdHVzc2VucGVyc29vbiAtIHplIHpldHRlbiBodW4gZWlnZW4gZ2VsZCBpbiBvbSBhY3RpdmEgdGUga29wZW4gZW4gdmVya29wZW4sIGVuIGhvdWRlbiB6ZSBpbiBodW4gZWlnZW4gdm9vcnJhYWQuIEJlbGVnZ2VycyBrdW5uZW4gYWx0aWpkIGJpaiBoZW4gdGVyZWNodCBhbHMgemUgd2lsbGVuIGtvcGVuIGVuIHZlcmtvcGVuLjwvcD4KPHA+RG9vciB0ZSBhbGxlbiB0aWpkZSBrbGFhciB0ZSBzdGFhbiBvbSB0cmFuc2FjdGllcyB1aXQgdGUgdm9lcmVuLCB6b3JnZW4gbWFya2V0IG1ha2VycyBlcnZvb3IgZGF0IGVyIGNvbnRpbnUgbGlxdWlkaXRlaXQgaW4gZGUgbWFya3QgaXMuPC9wPgo8cD5NZXQgYmV0cmVra2luZyB0b3QgVG9rZW4gWCwgb20gaGV0IHNpbXBlbCB0ZSB6ZWdnZW46PC9wPgo8cD7il48gQWxzIGVlbiBpbnN0ZWxsaW5nIGVlbiBncm90ZSBob2V2ZWVsaGVpZCBUb2tlbiBYIGtvb3B0LCBuZWVtdCBkZSB2cmFhZyBuYWFyIGRlIGJlcGVya3RlIHZvb3JyYWFkIHRva2VucyBkaWUgbm9nIG9wIGRlIG1hcmt0IG92ZXIgemlqbiBzdGVyayB0b2UuPC9wPgo8cD5JbiBkaXQgZyBrYW4gZWVuIG1hcmtldCBtYWtlciBudSBlZW4gZ3JvdGUgaG9ldmVlbGhlaWQgVG9rZW4gWCB2YW51aXQgaHVuIGVpZ2VuIHBvcnRlbW9ubmVlIHZlcmtvcGVuLCB3YWFyZG9vciBoZXQgYWFuYm9kIHRvZW5lZW10IG9tIGRlIHZyYWFnIG9wIHRlIHZhbmdlbiBlbiB0ZSBoZWxwZW4gdm9vcmtvbWVuIGRhdCBkZSBwcmlqcyBvbm5vZGlnIHN0aWpndC48L3A+CjxwPldhbm5lZXIgZGUgaW5zdGVsbGluZyBUb2tlbiBYIHZlcmtvb3B0IGVuIGRlIG1hcmt0IG92ZXJzcG9lbHQsIGt1bm5lbiBtYXJrZXQgbWFrZXJzIHplbGYgZWVuIGdyb3RlIGhvZXZlZWxoZWlkIHZhbiBkZSB0b2tlbiBrb3Blbiwgd2F0IGhlbHB0IG9tIGRlIHRvZWdlbm9tZW4gdnJhYWcgdGUgdmVybWluZGVyZW4gZW4gdGUgdm9vcmtvbWVuIGRhdCBkZSBwcmlqemVuIG9ubm9kaWcgY3Jhc2hlbi48L3A+CjxoMiBpZD0iaDItSG9lMjBibGlqdmVuMjBtYXJrZXQyMG1ha2VyczIwd2luc3RnZXZlbmQ2NDg1MDUiPjxhIG5hbWU9IkhvZSBibGlqdmVuIG1hcmtldCBtYWtlcnMgd2luc3RnZXZlbmQ/IiBjbGFzcz0icmVmZXJlbmNlLWxpbmsiPjwvYT48c3BhbiBjbGFzcz0iaGVhZGVyLWxpbmsgb2N0aWNvbiBvY3RpY29uLWxpbmsiPjwvc3Bhbj5Ib2UgYmxpanZlbiBtYXJrZXQgbWFrZXJzIHdpbnN0Z2V2ZW5kPzwvaDI+PHA+QmV1cnplbiBvZiBERVhlcyBkaWUgbWFya3RtYWtlcnMgaW4gZGllbnN0IG5lbWVuIG9tIGFsZ2VtZW5lIGxpcXVpZGl0ZWl0IHRlIGJpZWRlbiB2b29yIGdlbm90ZWVyZGUgZWZmZWN0ZW4sIGt1bm5lbiBlZW4gdmFzdCBiZWRyYWcgYmV0YWFsZCBrcmlqZ2VuIG9mIHZlcmRpZW5lbiBhYW4gZGUgc3ByZWFkcyBkaWUgd29yZGVuIGdlbWFha3QgdmlhIHRyYW5zYWN0aWVzLjwvcD4KPHA+UHJvamVjdGVuIGRpZSBtYXJrZXQgbWFrZXJzIGluIGRpZW5zdCBuZW1lbiBvbSBsaXF1aWRpdGVpdCB0ZSBiaWVkZW4gdm9vciBodW4gc3BlY2lmaWVrZSB0b2tlbiBiZXRhbGVuIGRvb3JnYWFucyBlZW4gdmFzdCB0YXJpZWYsIHNvbXMgbWV0IHByZXN0YXRpZWNvbW1pc3NpZSBlcmJvdmVub3AuIEVlbiBhbmRlciBtb2RlbCBkYXQgbWFya2V0IG1ha2VycyBpbiBjcnlwdG9jdXJyZW5jeSBhYW5iaWVkZW4gaXMgZWVuIG11bnRsZWVubW9kZWwgd2Fhcm1lZSB6ZSBpbiBkZSB0b2Vrb21zdCBkZSBvcHRpZSBoZWJiZW4gb20gZGUgdG9rZW4gdGUga29wZW4uPC9wPgo8cD5OYXR1dXJsaWprIGlzIGhldCBuaWV0IG9ucmVnZWxtYXRpZyB2b29yIG1hcmtldCBtYWtlcnMgb20gYWN0aXZhIG1ldCB2ZXJsaWVzIHRlIHZlcmtvcGVuIC0gdWl0ZWluZGVsaWprIHppam4gemUgdmVycGxpY2h0IG9tIGJlcGFhbGRlIGhvZXZlZWxoZWRlbiB2YW4gZWVuIGFjdGl2dW0gYWFuIHRlIGhvdWRlbiBvbSBsaXF1aWRpdGVpdCB0ZSBiaWVkZW4gdm9vciBkZSBhZmdlc3Byb2tlbiB1cHRpbWUsIGVuIGFsbGUgZ2VwbGFhdHN0ZSBvcmRlcnMgb25taWRkZWxsaWprIHRlIHZlcnZ1bGxlbi48L3A+CjxwPk1hcmtldCBtYWtlcnMgbW9nZW4gb29rIGVlbiBkZWVsIG5lbWVuLCBiZWtlbmQgYWxzIGRlIGJpZWQtbGFhdHNwcmVhZC4gRGl0IGlzIGhldCB2ZXJzY2hpbCB0dXNzZW4gZGUgYmllZHByaWpzLCBkZSBob29nc3RlIHByaWpzIGRpZSB6ZSB3aWxsZW4gYmllZGVuIHZvb3IgZWVuIGFjdGl2dW0sIGVuIGRlIHZyYWFncHJpanMsIGRpZSBkZSBsYWFnc3RlIHByaWpzIGlzIGRpZSB6ZSB3aWxsZW4gYWNjZXB0ZXJlbi48L3A+CjxwPk1hcmtldCBtYWtlcnMgdmVyZGllbmVuIG9vayBkb29yIGhldCBhcmJpdHJhZ2UgdmFuIHByaWp6ZW4gdHVzc2VuIHZlcnNjaGlsbGVuZGUgYmV1cnplbi4gSGV0IHByb2NlcyBpcyBoZXQga29wZW4gdmFuIGNyeXB0b2N1cnJlbmN5IG9wIMOpw6luIG1hcmt0IGVuIGhldCB2ZXJrb3BlbiBlcnZhbiBvcCBlZW4gYW5kZXJlIG1hcmt0IHRlZ2VuIGVlbiBob2dlcmUgcHJpanMsIHdhYXJkb29yIGhldCBwcmlqc3ZlcnNjaGlsIGluIHdpbnN0IHdvcmR0IG9tZ2V6ZXQuPC9wPgo8aDIgaWQ9ImgyLVdlbGtlMjBhbmRlcmUyMHZvb3JkZWxlbjIwYmllZGVuMjBtYXJrZXQyMG1ha2VyczY5MDI4MCI+PGEgbmFtZT0iV2Vsa2UgYW5kZXJlIHZvb3JkZWxlbiBiaWVkZW4gbWFya2V0IG1ha2Vycz8iIGNsYXNzPSJyZWZlcmVuY2UtbGluayI+PC9hPjxzcGFuIGNsYXNzPSJoZWFkZXItbGluayBvY3RpY29uIG9jdGljb24tbGluayI+PC9zcGFuPldlbGtlIGFuZGVyZSB2b29yZGVsZW4gYmllZGVuIG1hcmtldCBtYWtlcnM/PC9oMj48cD5Eb29yIHZvb3J0ZHVyZW5kIGFjdGl2YSB0ZSBrb3BlbiBlbiB2ZXJrb3BlbiwgdmVya2xlaW5lbiBtYXJrZXQgbWFrZXJzIGRlIGJpZWQtbGFhdC1zcHJlYWQuIEVlbiBzbWFsbGUgYmllZC1sYWF0LXNwcmVhZCB3b3JkdCBvdmVyIGhldCBhbGdlbWVlbiBndW5zdGlnIGdlYWNodCB2b29yIGludmVzdGVlcmRlcnMsIG9tZGF0IGRlIGFhbmdlYm9kZW4gcHJpanMgbWluZGVyIHZlciBhZiBsaWd0IHZhbiBkZSBnZWFjY2VwdGVlcmRlIHByaWpzLiBNZXQgZWVuIHJlZGVsaWprIHByaWpzdmVyc2NoaWwgdHVzc2VuIGRlIGFhbmdlYm9kZW4gZW4gZ2VhY2NlcHRlZXJkZSBwcmlqcyBrdW5uZW4gbWVuc2VuIHdvcmRlbiBhYW5nZW1vZWRpZ2Qgb20gZGVlbCB0ZSBuZW1lbiBhYW4gZGUgaGFuZGVsIGluIGRlemUgYWN0aXZhLjwvcD4KPHA+TWFya2V0IG1ha2VycyBoZWxwZW4gb29rIG9tIGRlIGRpZXB0ZSB2YW4gb3JkZXJib2VrZW4gdGUgdmVyZ3JvdGVuLCB3YXQgZWVuIGRpZ2l0YWxlIHJlZ2lzdHJhdGllIGlzIHZhbiBkZSBnZXNjaGllZGVuaXMgdmFuIGtvb3AtIGVuIHZlcmtvb3BvcmRlcnMgdmFuIGVlbiBiZXBhYWxkIGFjdGllZi4gVm9vciBnZcOvbmZvcm1lZXJkZSBpbnZlc3RlZXJkZXJzIGlzIGhldCBvcmRlcmJvZWsgZWVuIGhhbmRpZyBodWxwbWlkZGVsIG9tIGRlIGdlem9uZGhlaWQgdmFuIGhldCBhY3RpZWYgdGUgYmVwYWxlbiAtIGhldCBvbnRodWx0IGhldCBhYW50YWwgb3JkZXJzIGRhdCBvcGVuc3RhYXQgdGVnZW4gdmVyc2NoaWxsZW5kZSBwcmlqemVuLCBldmVuYWxzIGV2ZW50dWVsZSBvbmV2ZW53aWNodGlnaGVkZW4gb2Ygd2VlcnN0YW5kc25pdmVhdXMuIERpZXBlIG9yZGVyYm9la2VuIGt1bm5lbiBpbnZlc3RlZXJkZXJzIGFhbnRyZWtrZW4sIG9tZGF0IGRpdCB3aWpzdCBvcCBlZW4gbGlxdWlkZSBtYXJrdCwgd2F0IGhldCByaXNpY28gdm9vciBpbnZlc3RlZXJkZXJzIHZlcm1pbmRlcnQuPC9wPgo8aDIgaWQ9ImgyLVNhbWVudmF0dGluZzUwMTE0OSI+PGEgbmFtZT0iU2FtZW52YXR0aW5nIiBjbGFzcz0icmVmZXJlbmNlLWxpbmsiPjwvYT48c3BhbiBjbGFzcz0iaGVhZGVyLWxpbmsgb2N0aWNvbiBvY3RpY29uLWxpbmsiPjwvc3Bhbj5TYW1lbnZhdHRpbmc8L2gyPjxwPuKXjyBNYXJrZXQgbWFraW5nIGlzIGhldCBmYWNpbGl0ZXJlbiB2YW4gZGUga29vcCBlbiB2ZXJrb29wIHZhbiBlZmZlY3RlbiBlbiBoZXQgYmV2b3JkZXJlbiB2YW4gbGlxdWlkaXRlaXQgb3AgZGUgbWFya3QuPC9wPgo8cD7il48gWmUgaGVscGVuIGJpaiBoZXQgb250ZGVra2VuIHZhbiBkZSBwcmlqemVuIGRvb3IgZGUgdnJhYWcgZW4gaGV0IGFhbmJvZCB0ZSBkZW1wZW4gZW4gZGUgcHJpanplbiBvcCBtYXJrdG5pdmVhdSB0ZSBzdGFiaWxpc2VyZW4uIFplIG1ha2VuIHdpbnN0IGRvb3IgZWVuIHBlcmNlbnRhZ2UgdGUgbmVtZW4sIGJla2VuZCBhbHMgaGV0IGJpZWQtbGFhdC12ZXJzY2hpbCwgZW4gYXJiaXRyYWdlIG9wIHZlcnNjaGlsbGVuZGUgYmV1cnplbi48L3A+CjxwPk1hcmt0bWFrZXJzIHNwZWxlbiBlZW4gY3J1Y2lhbGUgcm9sIGluIGZpbmFuY2nDq2xlIG1hcmt0ZW4gZG9vciBsaXF1aWRpdGVpdCBlbiBtYXJrdHN0YWJpbGl0ZWl0IHRlIGJldm9yZGVyZW4sIGVuIGh1biBhYW53ZXppZ2hlaWQgaXMgZXNzZW50aWVlbCB2b29yIGhldCBhYW50cmVra2VuIGVuIGJlaG91ZGVuIHZhbiBpbnZlc3RlZXJkZXJzLjwvcD4KPHA+PHN0cm9uZz48ZW0+T3BlbmJhYXJtYWtpbmc6IERpdCBhcnRpa2VsIGlzIGdlc2NocmV2ZW4gaW4gc2FtZW53ZXJraW5nIG1ldCBEV0YgTGFicywgZWVuIG1hcmtldCBtYWtlciBlbiBpbnN0aXR1dGlvbmVsZSBrbGFudCB2YW4gR2F0ZS5pby4gVm9vciBtZWVyIGluZm9ybWF0aWUgb3ZlciBEV0YgTGFicywgYmV6b2VrIDxhIGhyZWY9Imh0dHA6Ly93d3cuZHdmLWxhYnMuY29tLyIgcmVsPSJub2ZvbGxvdyBub29wZW5lciBub3JlZmVycmVyIiB0YXJnZXQ9Il9ibGFuayI+d3d3LmR3Zi1sYWJzLmNvbTwvYT48L2VtPjwvc3Ryb25nPjwvcD4KPGRpdiBjbGFzcz0iYmxvZy1kZXRhaWxzLWluZm8iPjxicj48ZGl2PkF1dGV1cjo8c3Ryb25nPiBEV0YgTGFiczwvc3Ryb25nPjxicj48ZGl2IGNsYXNzPSJpbmZvLXRpcHMiPjxlbT5EaXQgYXJ0aWtlbCB2ZXJ0ZWdlbndvb3JkaWd0IGFsbGVlbiBkZSBzdGFuZHB1bnRlbiB2YW4gZGUgb25kZXJ6b2VrZXIgZW4gdm9ybXQgZ2VlbiBlbmtlbGUgYmVsZWdnaW5nc3N1Z2dlc3RpZS48YnI+PC9lbT48ZGl2PjxlbT48L2VtPkdhdGUuaW8gYmVob3VkdCBhbGxlIHJlY2h0ZW4gb3AgZGl0IGFydGlrZWwuIEhldCBvcG5pZXV3IHBsYWF0c2VuIHZhbiBoZXQgYXJ0aWtlbCB6YWwgd29yZGVuIHRvZWdlc3RhYW4gbWl0cyBHYXRlLmlvIHdvcmR0IHZlcm1lbGQuIEluIGFsbGUgZ2xlbiB6YWwganVyaWRpc2NoZSBhY3RpZSB3b3JkZW4gb25kZXJub21lbiB2YW53ZWdlIHNjaGVuZGluZyB2YW4gaGV0IGF1dGV1cnNyZWNodC48YnI+PC9kaXY+PHA+PC9wPjxicj48L2Rpdj48L2Rpdj48L2Rpdj4=