{"id":1061,"date":"2026-10-10T21:53:34","date_gmt":"2026-10-10T19:53:34","guid":{"rendered":"http:\/\/www.donttellus.com\/en_us\/?post_type=dtu_image_series&#038;p=1061"},"modified":"2026-10-10T22:39:32","modified_gmt":"2026-10-10T20:39:32","slug":"aus-dem-auto-verhaftet-bei-verkehrskontrolle","status":"publish","type":"dtu_image_series","link":"https:\/\/www.donttellus.com\/en_us\/bildserien\/aus-dem-auto-verhaftet-bei-verkehrskontrolle\/","title":{"rendered":"Aus dem Auto verhaftet bei Verkehrskontrolle"},"content":{"rendered":"<p><!--dtu-story-languages-v1:eyJzY2hlbWEiOjIsInBhbmVsX2NvdW50IjoxNywidmVyc2lvbnMiOnsiZGUiOnsidGl0bGUiOiJBdXMgZGVtIEF1dG8gdmVyaGFmdGV0IGJlaSBWZXJrZWhyc2tvbnRyb2xsZSIsImNvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZHR1LXJldmlldy1zdG9yeSBkdHUtYXBwcm92ZWQxNng5XCI+PG5hdiBhcmlhLWxhYmVsPVwiTGFuZ3VhZ2VzXCI+PGEgaHJlZj1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL2RlL2JpbGRzZXJpZW4vYXVzLWRlbS1hdXRvLXZlcmhhZnRldC1iZWktdmVya2VocnNrb250cm9sbGUvXCIgYXJpYS1jdXJyZW50PVwicGFnZVwiPkRldXRzY2g8L2E+PGEgaHJlZj1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL2VuX3VzL2JpbGRzZXJpZW4vYXVzLWRlbS1hdXRvLXZlcmhhZnRldC1iZWktdmVya2VocnNrb250cm9sbGUvXCI+RW5nbGlzaDwvYT48YSBocmVmPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vZXMvYmlsZHNlcmllbi9hdXMtZGVtLWF1dG8tdmVyaGFmdGV0LWJlaS12ZXJrZWhyc2tvbnRyb2xsZS9cIj5Fc3Bhw7FvbDwvYT48YSBocmVmPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vZnIvYmlsZHNlcmllbi9hdXMtZGVtLWF1dG8tdmVyaGFmdGV0LWJlaS12ZXJrZWhyc2tvbnRyb2xsZS9cIj5GcmFuw6dhaXM8L2E+PC9uYXY+PGgxPkF1cyBkZW0gQXV0byB2ZXJoYWZ0ZXQgYmVpIFZlcmtlaHJza29udHJvbGxlPC9oMT48YXNpZGUgY2xhc3M9XCJub3RpY2VcIj5GaWt0aW9uYWxlLCBpbnN6ZW5pZXJ0ZSBCaWxkZ2VzY2hpY2h0ZS4gS2VpbmUgcmVhbGUgRmVzdG5haG1lIG9kZXIgYmVow7ZyZGxpY2hlIERva3VtZW50YXRpb24uPC9hc2lkZT48c2VjdGlvbiBpZD1cIm5hcnJhdGl2ZVwiPjxoMj5EaWUgR2VzY2hpY2h0ZTwvaDI+PHA+IyBBdXMgZGVtIEF1dG8gdmVyaGFmdGV0IGJlaSBWZXJrZWhyc2tvbnRyb2xsZTwvcD48cD5GaWt0aW9uYWxlLCBpbnN6ZW5pZXJ0ZSBCaWxkZ2VzY2hpY2h0ZS4gS2VpbmUgcmVhbGUgRmVzdG5haG1lIG9kZXIgYmVow7ZyZGxpY2hlIERva3VtZW50YXRpb24uPC9wPjxwPkFscyBkaWUgZXJzdGVuIGJsYXVlbiBMaWNodHJlZmxleGUgw7xiZXIgZGllIE1vdG9yaGF1YmUgd2FuZGVybiwgaXN0IGRlciBBYmVuZCBub2NoIG5pY2h0IGdhbnogZHVua2VsLiBEaWUgTGFuZHN0cmHDn2UgbGllZ3Qgendpc2NoZW4gRmVsZGVybiB1bmQgZWluZXIgTGVpdHBsYW5rZTsgZGVyIFZlcmtlaHIgcmF1c2NodCB3ZWl0ZXIsIG9id29obCBmw7xyIGRlbiBGYWhyZXIgaW0gc2lsYmVybmVuIFdhZ2VuIGdlcmFkZSBhbGxlcyBsYW5nc2FtZXIgenUgd2VyZGVuIHNjaGVpbnQuIEVpbiB1bmlmb3JtaWVydGVyIEJlYW10ZXIgdHJpdHQgYW4gZGllIGdlw7ZmZm5ldGUgRmFocmVyc2VpdGUuIEVyIHNwcmljaHQgcnVoaWcgdW5kIHdhcnRldCwgd8OkaHJlbmQgZGVyIE1hbm4gYW0gU3RldWVyIHZlcnN1Y2h0LCBkaWUgU2l0dWF0aW9uIGVpbnp1b3JkbmVuLiBWb24gYXXDn2VuIHNpZWh0IGVzIHp1bsOkY2hzdCBuYWNoIGVpbmVyIGdld8O2aG5saWNoZW4gS29udHJvbGxlIGF1cy4gRsO8ciBpaG4gaXN0IGVzIGRlciBNb21lbnQsIGluIGRlbSBlaW5lIGFsbHTDpGdsaWNoZSBGYWhydCBwbMO2dHpsaWNoIGVpbmUgYW5kZXJlIFJpY2h0dW5nIG5pbW10LjwvcD48cD5JbSBTdHJlaWZlbndhZ2VuIGxldWNodGV0IGRhcyBtb2JpbGUgVGVybWluYWwuIEVpbiBCZWFtdGVyIGdsZWljaHQgZGllIEFuZ2FiZW4gYWIsIHfDpGhyZW5kIGRyYXXDn2VuIGRpZSBTaWduYWxlIGRlciBFaW5zYXR6ZmFocnpldWdlIGF1ZiBkZW0gTGFjayBkZXMgc2lsYmVybmVuIEF1dG9zIGZsYWNrZXJuLiBEaWUgWmFobGVuIHVuZCBaZWlsZW4gYXVmIGRlbSBCaWxkc2NoaXJtIHNpbmQgZsO8ciBkZW4gRmFocmVyIG5pY2h0IGxlc2JhcjsgZsO8ciBkaWUgR2VzY2hpY2h0ZSBpc3QgZW50c2NoZWlkZW5kLCBkYXNzIGVpbmUgQWJmcmFnZSBzdGF0dGZpbmRldCB1bmQgZGFzcyBkaWUgQmVhbXRlbiBkYW5hY2ggYW5kZXJzIGF1ZiBpaG4genVnZWhlbi4gRGllIFN6ZW5lIGJsZWlidCBiZXd1c3N0IGJlaSBkZW0sIHdhcyBzaWNodGJhciBpc3Q6IGVpbiBrb256ZW50cmllcnRlciBCbGljaywgZWluIEdlcsOkdCBpbSBFaW5zYXR6IHVuZCBlaW5lIGt1cnplIFBhdXNlLCBpbiBkZXIgbmllbWFuZCB3ZWnDnywgd2FzIGFscyBOw6RjaHN0ZXMgZ2VzYWd0IHdlcmRlbiB3aXJkLjwvcD48cD5EZXIgQmVhbXRlIGtlaHJ0IHp1bSBXYWdlbiB6dXLDvGNrLiBOdW4gaXN0IGRpZSBLb250cm9sbGUga2VpbmUgYmxvw59lIFByw7xmdW5nIHZvbiBGYWhyemV1Z3BhcGllcmVuIG1laHIuIEVyIHRlaWx0IGRlbSBGYWhyZXIgbWl0LCBkYXNzIGJlaSBkZXIgQWJmcmFnZSBlaW4gb2ZmZW5lciBIYWZ0YmVmZWhsIGFuZ2V6ZWlndCB3aXJkLiBEZXIgTWFubiBow7ZydCB6dSB1bmQgc2NoYXV0IHp3aXNjaGVuIGRlbSBCZWFtdGVuIHVuZCBkZW0gU3RyZWlmZW53YWdlbiBoaW4gdW5kIGhlci4gRGllIEJpbGRlciBsZWdlbiBrZWluZSB6dXPDpHR6bGljaGVuIEdyw7xuZGUsIFZvcnfDvHJmZSBvZGVyIEVpbnplbGhlaXRlbiBmZXN0OyBzaWUgemVpZ2VuIG51ciBkaWUgTmFjaHJpY2h0IHVuZCBkaWUgdW5taXR0ZWxiYXJlIFJlYWt0aW9uIGRhcmF1Zi4gSW4gZGllc2VtIEF1Z2VuYmxpY2sgdmVyc3RlaHQgZXIsIGRhc3MgZXIgbmljaHQgZWluZmFjaCB3ZWl0ZXJmYWhyZW4gd2lyZC4gRGVyIGJpc2hlcmlnZSBQbGFuIGbDvHIgZGVuIEFiZW5kIHZlcmxpZXJ0IHNlaW5lIEJlZGV1dHVuZywgYmV2b3IgZXIgw7xiZXJoYXVwdCBHZWxlZ2VuaGVpdCBoYXQsIGlobiB6dSBlcmtsw6RyZW4uPC9wPjxwPkRlciBGYWhyZXIgc3RlaWd0IGF1cyBkZW0gc2lsYmVybmVuIFdhZ2VuLiBEaWUgVMO8cmVuIGJsZWliZW4gb2ZmZW4sIGRpZSBMaWNodGJhbGtlbiBzcGllZ2VsbiBzaWNoIGluIGRlbiBGZW5zdGVybiwgdW5kIGRpZSBMYW5kc3RyYcOfZSBiaWxkZXQgZWluZSB1bmJldGVpbGlndGUgS3VsaXNzZS4gRWluIEJlYW10ZXIgc3ByaWNodCBtaXQgaWhtLCBlaW4gd2VpdGVyZXIgaMOkbHQgQWJzdGFuZCB1bmQgYmVvYmFjaHRldCBkaWUgVW1nZWJ1bmcuIERlciBNYW5uIHRyw6RndCBlaW5lbiBkdW5rbGVuIFRyYWluaW5nc2FuenVnIG1pdCBoZWxsZW4gU3RyZWlmZW4gdW5kIHdlacOfLWJsYXVlIFNwb3J0c2NodWhlLiBEaWVzZSBLbGVpZHVuZyBiZWdsZWl0ZXQgZGVuIHNww6R0ZXJlbiBUZWlsIGRlciBHZXNjaGljaHRlIHVuZCB3aXJkIHp1IGVpbmVtIHZpc3VlbGxlbiBBbmtlcjogV8OkaHJlbmQgT3J0IHVuZCBTaXR1YXRpb24gd2VjaHNlbG4sIGJsZWlidCBzaWUgaW4gZGVuIGZvbGdlbmRlbiBCaWxkZXJuIHdpZWRlcmVya2VubmJhci4gTm9jaCBzdGVodCBlciBuZWJlbiBzZWluZW0gQXV0bzsgZG9jaCBzZWluZSBBdWZtZXJrc2Fta2VpdCBnaWx0IGzDpG5nc3QgbmljaHQgbWVociBkZW0gVmVya2Voci48L3A+PHA+QWxzIGRpZSBGZXN0bmFobWUgZXLDtmZmbmV0IHdpcmQsIGhlYnQgZGVyIE1hbm4gZGllIEjDpG5kZSB1bmQgZm9sZ3QgZGVuIGtuYXBwZW4gQW53ZWlzdW5nZW4uIERpZSBCZWFtdGVuIHNpY2hlcm4gaWhuIGFtIFN0cmHDn2VucmFuZCB1bmQgaGFsdGVuIGRpZSBTaXR1YXRpb24gw7xiZXJzaWNodGxpY2guIERpZSBTemVuZSBpc3QgYW5nZXNwYW5udCwgYWJlciBuaWNodCBhbHMgS2FtcGYgZXJ6w6RobHQuIE5pZW1hbmQgcmVubnQsIG5pZW1hbmQgc2NobMOkZ3QgenU7IGltIFplbnRydW0gc3RlaHQgZGVyIMOcYmVyZ2FuZyB2b24gZWluZXIgS29udHJvbGxlIHp1IGVpbmVyIEZlc3RuYWhtZS4gRGVyIEZhaHJlciBzaWVodCBhdWYgZGVuIEJvZGVuLCBkYW5uIHp1IGRlbiBQb2xpemlzdGVuLiBIaW50ZXIgaWhtIHdhcnRlbiBkYXMgQXV0byB1bmQgZGllIHZvcmJlaWZhaHJlbmRlbiBGYWhyemV1Z2UuIFZvciBpaG0gbGllZ2VuIGRpZSBuw6RjaHN0ZW4gU2Nocml0dGUsIMO8YmVyIGRpZSBlciBuaWNodCBtZWhyIHNlbGJzdCBlbnRzY2hlaWRldC4gRGllIEJpbGRlciBoYWx0ZW4gZGllc2VuIFdlY2hzZWwgZmVzdCwgb2huZSBpaG4genUgZWluZW0gVXJ0ZWlsIMO8YmVyIGRlbiBNYW5uIHp1IG1hY2hlbi48L3A+PHA+RGllIFNpY2hlcnVuZyB3aXJkIG5lYmVuIGRlbSBGYWhyemV1ZyBmb3J0Z2VzZXR6dC4gRWluIEJlYW10ZXIgYmxlaWJ0IG5haGUgYmVpIGlobSwgd8OkaHJlbmQgZWluIGFuZGVyZXIgZGVuIEFibGF1ZiBiZW9iYWNodGV0LiBEaWUgSMOkbmRlIGRlcyBGZXN0Z2Vub21tZW5lbiB3ZXJkZW4ga29udHJvbGxpZXJ0IGdlaGFsdGVuOyBzZWluZSBLw7ZycGVyaGFsdHVuZyBpc3QgYW5nZXNwYW5udC4gRXIgdmVyc3VjaHQsIGRlbiBCbGljayBydWhpZyB6dSBoYWx0ZW4sIGRvY2ggZGllIHVuZ2V3b2hudGUgTsOkaGUgZGVyIEVpbnNhdHprcsOkZnRlIG1hY2h0IGRpZSBTaXR1YXRpb24gdW5taXR0ZWxiYXIuIEVzIGdpYnQga2VpbmUgZHJhbWF0aXNjaGUgR2VzdGUsIGRpZSBlcmtsw6RyZW4ga8O2bm50ZSwgd2FzIGVyIGRlbmt0LiBHZXJhZGUgZGllIGtsZWluZW4gRGV0YWlscyB0cmFnZW4gZGllIFN6ZW5lOiBkYXMgb2ZmZW5lIEF1dG90w7xyLCBkaWUgbmFzc2UgU3RyYcOfZSwgZGFzIHJlZmxla3RpZXJlbmRlIEJsYXVsaWNodCB1bmQgZGllIFNjaHVoZSwgZGllIGF1ZiBkZW0gQXNwaGFsdCBzdGVoZW4uIERlciBXZWcgenVyw7xjayBpbnMgQXV0byBpc3Qga2VpbmUgT3B0aW9uIG1laHIuPC9wPjxwPkVpbiBEZXRhaWxiaWxkIGxlbmt0IGRlbiBCbGljayBhdWYgZGVuIHNpbGJlcm5lbiBXYWdlbi4gRGFzIFZvcmRlcnJhZCwgZGllIG5hc3NlIEZhaHJiYWhuIHVuZCBkaWUgTGljaHRlciBkZXIgUG9saXplaSBlcnrDpGhsZW4gdm9uIGRlbSBPcnQsIGFuIGRlbSBkaWUgRmFocnQgdW50ZXJicm9jaGVuIHd1cmRlLiBEZXIgV2FnZW4gaXN0IG1laHIgYWxzIGVpbiBSZXF1aXNpdDogRXIgc3RlaHQgZsO8ciBkZW4gQWxsdGFnLCBkZXIgYmlzIGViZW4gbm9jaCBzZWxic3R2ZXJzdMOkbmRsaWNoIHdhci4gTnVuIHdpcmQgZXIgenVtIHp1csO8Y2tnZWxhc3NlbmVuIEdlZ2Vuc3RhbmQgYW0gU3RyYcOfZW5yYW5kLiBJbiBkZXIgRmVybmUgYmxlaWJlbiBkaWUgQmVhbXRlbiB1bmQgZGVyIEZlc3RnZW5vbW1lbmUgc2ljaHRiYXIuIERpZSBBdWZuYWhtZSB2ZXJ3ZWlsdCBrdXJ6IGJlaSBkZXIgVW1nZWJ1bmcsIGJldm9yIGRpZSBHZXNjaGljaHRlIHdlaXRlcmdlaHQuIFNvIGJla29tbXQgZGVyIEJldHJhY2h0ZXIgZWluZW4gTW9tZW50IHp1bSBEdXJjaGF0bWVuIHVuZCBrYW5uIGRlbiBXZWNoc2VsIHZvbSBwcml2YXRlbiBSYXVtIGRlcyBBdXRvcyBpbiBlaW5lIG9mZml6aWVsbGUgU2l0dWF0aW9uIG5hY2h2b2xsemllaGVuLjwvcD48cD5Gw7xyIGRlbiBUcmFuc3BvcnQgd2lyZCBkZXIgTWFubiB6dW0gRWluc2F0emZhaHJ6ZXVnIGJlZ2xlaXRldC4gRGllIEJlYW10ZW4gYmV3ZWdlbiBzaWNoIGtvbnRyb2xsaWVydCB1bmQgYmxlaWJlbiBkaWNodCBnZW51ZywgdW0gaWhuIHp1IGbDvGhyZW4uIFNlaW5lIEFybWUgc2luZCBnZXNpY2hlcnQ7IGRpZSBEYXJzdGVsbHVuZyBtYWNodCBkZXV0bGljaCwgZGFzcyBlciBuaWNodCBzZWxic3QgZGVuIG7DpGNoc3RlbiBXZWcgYXVzd8OkaGx0LiBHbGVpY2h6ZWl0aWcgYmxlaWJ0IHNlaW4gR2VzaWNodCBzaWNodGJhciB1bmQgZGllIFN6ZW5lIGtvbnplbnRyaWVydCBzaWNoIGF1ZiBkaWUgQmVnbGVpdHVuZywgbmljaHQgYXVmIGVpbmUgVmVybGV0enVuZy4gRGllIHdlacOfZW4gdW5kIGJsYXVlbiBTY2h1aGUgc2V0emVuIHNpY2ggZGV1dGxpY2ggdm9tIGR1bmtsZW4gVHJhaW5pbmdzYW56dWcgdW5kIHZvbSBncmF1ZW4gQXNwaGFsdCBhYi4gRGFzIHdpZWRlcmtlaHJlbmRlIERldGFpbCBoaWxmdCwgZGllIEZvbGdlIHp1IGxlc2VuOiBFcyBpc3QgZGVyc2VsYmUgRmVzdGdlbm9tbWVuZSwgZGVyIG51biB2b20gT3J0IGRlciBLb250cm9sbGUgd2VnZ2Vmw7xocnQgd2lyZC48L3A+PHA+RGllIG9mZmVuZSBUw7xyIGRlcyBUcmFuc3BvcnRlcnMgbWFya2llcnQgZWluZSBTY2h3ZWxsZS4gRHJhdcOfZW4gbGllZ2VuIGRpZSBTdHJhw59lIHVuZCBkYXMgc2lsYmVybmUgQXV0bzsgZGFoaW50ZXIgYmVnaW5udCBkZXIgSW5uZW5yYXVtIGRlcyBkZXV0c2NoZW4gR2VmYW5nZW5lbnRyYW5zcG9ydGVycyBtaXQgc2VpbmVyIFRyZW5ud2FuZC4gRWluIEJlYW10ZXIgYmVyZWl0ZXQgZGllIMOcYmVyZ2FiZSB2b3IsIHfDpGhyZW5kIGRlciBGZXN0Z2Vub21tZW5lIG5haGUgYW0gRWluc3RpZWcgd2FydGV0LiBEYXMgQmlsZCB6ZWlndCBuaWNodCwgd2FzIGltIEZhaHJ6ZXVnIGdlc3Byb2NoZW4gd2lyZCBvZGVyIHdlbGNoZSBhZG1pbmlzdHJhdGl2ZW4gU2Nocml0dGUgc3RhdHRmaW5kZW4uIEVzIHplaWd0IGRlbiByw6R1bWxpY2hlbiBXZWNoc2VsOiB2b20gw7ZmZmVudGxpY2hlbiBTdHJhw59lbnJhbmQgaW4gZWluZW4gYmVncmVuenRlbiwgZ2VzaWNoZXJ0ZW4gSW5uZW5yYXVtLiBEZXIgQWJzdGFuZCB6d2lzY2hlbiBkZW4gT3J0ZW4gaXN0IGtsZWluLCBkb2NoIGbDvHIgZGllIEZpZ3VyIGbDvGhsdCBlciBzaWNoIGdyb8OfIGFuLiBEZXIgV2FnZW4sIG1pdCBkZW0gZXIgZ2Vrb21tZW4gaXN0LCBibGVpYnQgaGludGVyIGlobSB6dXLDvGNrLjwvcD48cD5BbSBUcmFuc3BvcnRlciB0cmVmZmVuIGRpZSBCZXRlaWxpZ3RlbiBlcm5ldXQgenVzYW1tZW4uIEVpbiBCZWFtdGVyIHN0ZWh0IGFuIGRlciBvZmZlbmVuIEhlY2trbGFwcGUsIGVpbiBhbmRlcmVyIGjDpGx0IGRlbiBNYW5uIGluIHNlaW5lciBOw6RoZS4gRGllIEJlbGV1Y2h0dW5nIGltIElubmVucmF1bSB3aXJrdCB3w6RybWVyIGFscyBkYXMgYmxhdWUgQWJlbmRsaWNodCBkcmF1w59lbi4gRGVyIEZlc3RnZW5vbW1lbmUgc2NoYXV0IGt1cnogenVyIFNlaXRlLCBhbHMgd29sbGUgZXIgc2ljaCBub2NoIGVpbm1hbCBvcmllbnRpZXJlbi4gRGVyIEFibGF1ZiB3aXJkIGluIG1laHJlcmVuIEJpbGRlcm4gYXVzIGxlaWNodCB2ZXLDpG5kZXJ0ZW4gQmxpY2t3aW5rZWxuIGdlemVpZ3QsIG5pY2h0IGFscyBtZWhyZXJlIHZlcnNjaGllZGVuZSBGZXN0bmFobWVuLiBEaWVzZSBXaWVkZXJob2x1bmcgbWFjaHQgZGVuIMOcYmVyZ2FuZyBuYWNodm9sbHppZWhiYXJlcjogZXJzdCBkaWUgVm9yYmVyZWl0dW5nLCBkYW5uIGRpZSBCZWdsZWl0dW5nLCBzY2hsaWXDn2xpY2ggZGFzIEFua29tbWVuIGFtIEZhaHJ6ZXVnLiBEaWUgS2xlaWR1bmcgdW5kIGRpZSB3ZWnDny1ibGF1ZW4gU2NodWhlIGhlbGZlbiwgZGVuIFp1c2FtbWVuaGFuZyB6dSBoYWx0ZW4uPC9wPjxwPkRlciBNYW5uIHdpcmQgenVtIEVpbnN0aWVnIGdlZsO8aHJ0LiBTZWluZSBCZXdlZ3VuZ2VuIHNpbmQgdm9yc2ljaHRpZywgd2VpbCBkaWUgU2l0dWF0aW9uIHVuZ2V3b2hudCBpc3QgdW5kIGRpZSBCZWFtdGVuIGlobiBrb250cm9sbGllcnQgYmVnbGVpdGVuLiBFciB0csOkZ3Qgd2VpdGVyaGluIGRlbnNlbGJlbiBkdW5rbGVuIFRyYWluaW5nc2FuenVnLiBEaWUgb2ZmZW5lIEZhaHJ6ZXVndMO8ciBnaWJ0IGRlbiBCbGljayBhdWYgZGVuIGdlc2ljaGVydGVuIElubmVucmF1bSBmcmVpLCB3w6RocmVuZCBkcmF1w59lbiBkZXIgU3RyZWlmZW53YWdlbiB1bmQgZGllIExhbmRzdHJhw59lIHp1csO8Y2t0cmV0ZW4uIEluIGRpZXNlbSBNb21lbnQgd2lyZCBhdXMgZGVyIFZlcmtlaHJza29udHJvbGxlIGVpbmUgw5xiZXJzdGVsbHVuZy4gRGllIEJpbGRlciBiZWhhdXB0ZW4gbmljaHQsIGRhc3MgZWluIGJlc3RpbW10ZXMgU3RhbmRhcmR2ZXJmYWhyZW4gYWJnZWJpbGRldCB3aXJkOyBzaWUgZXJ6w6RobGVuIGRpZSBrb25rcmV0ZSBmaWt0aXZlIFN6ZW5lLCBkaWUgZsO8ciBkaWVzZSBCaWxkZ2VzY2hpY2h0ZSBnZXN0YWx0ZXQgd3VyZGUuIERlciBGb2t1cyBsaWVndCBhdWYgZGVtIFdlY2hzZWwgdm9uIGVpbmVtIE9ydCB6dW0gbsOkY2hzdGVuIHVuZCBhdWYgZGVyIFVuc2ljaGVyaGVpdCBkZXMgRmVzdGdlbm9tbWVuZW4uPC9wPjxwPk5vY2ggZWlubWFsIHdpcmQgZGVyIFRyYW5zcG9ydGVyIHZvbiBhdcOfZW4gZ2V6ZWlndC4gRGllIEVpbnNhdHpmYWhyemV1Z2Ugc3RlaGVuIGFtIFN0cmHDn2VucmFuZCwgZGllIFTDvHJlbiBzaW5kIGdlw7ZmZm5ldCwgdW5kIGRpZSBCZWFtdGVuIG9yZG5lbiBzaWNoIGbDvHIgZGllIEFiZmFocnQuIERlciBGZXN0Z2Vub21tZW5lIGJsZWlidCB6d2lzY2hlbiBpaG5lbiB1bmQgZGVtIEZhaHJ6ZXVnLiBEaWUgU3plbmUgaXN0IHdlbmlnZXIgZWluZSBuZXVlIEhhbmRsdW5nIGFscyBlaW4gcnVoaWdlciBBYnNjaGx1c3MgZGVzIFN0cmHDn2VuYWJzY2huaXR0cy4gU2llIGzDpHNzdCBkZW4gQmV0cmFjaHRlciBlcmtlbm5lbiwgZGFzcyBkaWUgS29udHJvbGxlIHZvcmJlaSBpc3QgdW5kIGRlciBuw6RjaHN0ZSBUZWlsIGFuIGVpbmVtIGFuZGVyZW4gT3J0IHNwaWVsZW4gd2lyZC4gRGVyIEhpbW1lbCBpc3QgaW56d2lzY2hlbiBkdW5rbGVyIGdld29yZGVuOyBkYXMgUmVzdGxpY2h0IGFtIEhvcml6b250IGtvbnRyYXN0aWVydCBtaXQgZGVuIGJsYXVlbiBTaWduYWxlbi4gRGllIFN0cmHDn2UgbMOkdWZ0IHdlaXRlciwgYWJlciBmw7xyIGRlbiBNYW5uIGlzdCBkaWUgRmFocnQgbmljaHQgbWVociBzZWluZSBlaWdlbmUuPC9wPjxwPkRpZSBBYmZhaHJ0IGJlZW5kZXQgZGllIEJpbGRlcmZvbGdlIGFtIFN0cmHDn2VucmFuZC4gRGVyIFRyYW5zcG9ydGVyIHNldHp0IGRpZSBHZXNjaGljaHRlIGZvcnQsIG9obmUgZGFzcyBkaWUgRmFocnQgc2VsYnN0IGF1c2dlc2NobcO8Y2t0IHdlcmRlbiBtdXNzLiBFcyBnaWJ0IGtlaW5lIGVyZnVuZGVuZW4gRGlhbG9nZSBhdXMgZGVtIEZhaHJ6ZXVnIHVuZCBrZWluZSB6dXPDpHR6bGljaGVuIEJlaGF1cHR1bmdlbiDDvGJlciBlaW5lIHJlYWxlIERpZW5zdHN0ZWxsZS4gRGVyIEJpbGR3ZWNoc2VsIGVyZsO8bGx0IGVpbmUgZWluZmFjaGUgZXJ6w6RobGVyaXNjaGUgQXVmZ2FiZTogRXIgdmVyYmluZGV0IGRlbiBPcnQgZGVyIEZlc3RuYWhtZSBtaXQgZGVtIHNww6R0ZXJlbiBBdWZuYWhtZWJlcmVpY2guIFdlciBkaWUgdm9yaGVyaWdlbiBTemVuZW4gdmVyZm9sZ3QgaGF0LCBrYW5uIGRpZSBLbGVpZHVuZyB1bmQgZGllIFNjaHVoZSBhbHMgS29udGludWl0w6R0c21lcmttYWxlIHdpZWRlcmVya2VubmVuLiBEZXIgRmVzdGdlbm9tbWVuZSBpc3QgbmljaHQgbWVociBhbSBlaWdlbmVuIFdhZ2VuOyBlciB3aXJkIG51biB2b24gZGVuIEJlYW10ZW4gYW4gZGVuIG7DpGNoc3RlbiBBYnNjaG5pdHQgw7xiZXJnZWJlbi48L3A+PHA+RGllIEJlZ2xlaXR1bmcgenVtIFRyYW5zcG9ydGVyIGJpbGRldCBkZW4gbGV0enRlbiBkZXV0bGljaGVuIE1vbWVudCBkcmF1w59lbi4gWndlaSBCZWFtdGUgZmxhbmtpZXJlbiBkZW4gTWFubiwgZWluIHdlaXRlcmVyIGJsZWlidCBiZWltIHNpbGJlcm5lbiBBdXRvLiBEaWUgU3plbmUgdmVyYmluZGV0IGRpZSBWZXJrZWhyc2tvbnRyb2xsZSBtaXQgZGVtIEFidHJhbnNwb3J0IHVuZCBzY2hhZmZ0IGVpbmVuIEFic2NobHVzcywgYmV2b3Igc2ljaCBkaWUgVW1nZWJ1bmcgw6RuZGVydC4gRGVyIEZlc3RnZW5vbW1lbmUgc2NoYXV0IG5hY2ggdm9ybi4gRGllIEJpbGRlciB6ZWlnZW4ga2VpbmUgdHJpdW1waGllcmVuZGUgSGFsdHVuZyB1bmQga2VpbmUgbW9yYWxpc2NoZSBCZXdlcnR1bmcsIHNvbmRlcm4gZWluZSBuw7xjaHRlcm5lLCBpbnN6ZW5pZXJ0ZSBTaXR1YXRpb24uIERpZSBibGF1ZSBTdHVuZGUsIGRpZSByZWZsZWt0aWVyZW5kZW4gU3RyZWlmZW4gdW5kIGRpZSBvZmZlbmVuIFTDvHJlbiBoYWx0ZW4gZGllIEF0bW9zcGjDpHJlIHp1c2FtbWVuLiBNaXQgZGVtIFNjaHJpdHQgaW4gZGVuIFRyYW5zcG9ydGVyIGVuZGV0IGRlciBTdHJhw59lbmFic2Nobml0dDsgZGllIG7DpGNoc3RlbiBCaWxkZXIgc3ByaW5nZW4gaW4gZGVuIEF1Zm5haG1lYmVyZWljaC48L3A+PHA+QmlsZCAxNSBmw7xocnQgaW4gZWluZW4gaGVsbGVuIElubmVucmF1bSB1bmQga2VubnplaWNobmV0IGRhbWl0IGVpbmVuIHplaXRsaWNoZW4gdW5kIHLDpHVtbGljaGVuIFNwcnVuZy4gRWluIG1lZGl6aW5pc2NoZXIgTWl0YXJiZWl0ZXIgdW50ZXJzdWNodCBkZW4gU2NodWggZGVzIE1hbm5lcywgZWluIEJlYW10ZXIgZG9rdW1lbnRpZXJ0IGRlbiBWb3JnYW5nLCB1bmQgZGVyIEZlc3RnZW5vbW1lbmUgc3RlaHQgaW4gc2VpbmVtIGR1bmtsZW4gVHJhaW5pbmdzYW56dWcgZGFuZWJlbi4gRGllc2VzIEJpbGQgaXN0IGFscyDDnGJlcmdhbmcgaW4gZGllIG1lZGl6aW5pc2NoZSBBdWZuYWhtZSBnZWRhY2h0LCBuaWNodCBhbHMgU3plbmUgYW0gU3RyYcOfZW5yYW5kLiBad2lzY2hlbiBkZXIgS29udHJvbGxlIHVuZCBkaWVzZXIgVW50ZXJzdWNodW5nIGxpZWd0IFplaXQsIGRpZSBpbiBkZXIgQmlsZHNlcmllIG5pY2h0IGVpbnplbG4gZXJ6w6RobHQgd2lyZC4gRGllIGhlbGxlLCBzYWNobGljaGUgVW1nZWJ1bmcgdW50ZXJzY2hlaWRldCBzaWNoIGRldXRsaWNoIHZvbSBBYmVuZCBkcmF1w59lbi4gU2llIG1hY2h0IHNpY2h0YmFyLCBkYXNzIG51biBlaW4gYW5kZXJlciBBYnNjaG5pdHQgYmVnaW5udCwgb2huZSBlaW5lIGtvbmtyZXRlIG1lZGl6aW5pc2NoZSBEaWFnbm9zZSBvZGVyIGVpbmVuIHJlYWxlbiBCZWZ1bmQgenUgYmVoYXVwdGVuLjwvcD48cD5JbiBkZXIgR0VTQSB3aXJkIGRpZSBtZWRpemluaXNjaGUgVW50ZXJzdWNodW5nIGRva3VtZW50aWVydC4gRGVyIE1hbm4gc2l0enQgYmVrbGVpZGV0IGF1ZiBlaW5lciBCYW5rOyBlaW4gQXJ6dCBpc3QgYW53ZXNlbmQsIGVpbiBCZWFtdGVyIGjDpGx0IGRpZSBTaXR1YXRpb24gZmVzdC4gRGllIERhcnN0ZWxsdW5nIGJsZWlidCBzYWNobGljaCB1bmQgbmljaHQgaW50aW0uIERpZSBzaWNodGJhciB2ZXJidW5kZW5lIFNpY2hlcnVuZyBhbiBIw6RuZGVuIHVuZCBGdcOfZ2VsZW5rZW4gZ2Vow7ZydCB6dXIgaW5zemVuaWVydGVuIEJpbGRrb21wb3NpdGlvbiBkaWVzZXIgR2VzY2hpY2h0ZS4gVHJhaW5pbmdzYW56dWcgdW5kIFNjaHVoZSBibGVpYmVuIGdsZWljaCwgZGFtaXQgZGFzIEJpbGQgYW4gZGVuIHZvcmhlcmlnZW4gQWJzY2huaXR0IGFuc2NobGllw590LiBEaWUgR0VTQS1CZXNjaGlsZGVydW5nIG9yZG5ldCBkZW4gT3J0IGVpbiwgb2huZSBlaW5lIGJlc3RpbW10ZSBFaW5yaWNodHVuZyBvZGVyIGVpbmVuIGVjaHRlbiBWb3JnYW5nIGFienViaWxkZW4uIEbDvHIgZGVuIEZlc3RnZW5vbW1lbmVuIGJlZGV1dGV0IGRlciBSYXVtIGVpbmVuIHdlaXRlcmVuIFdlY2hzZWw6IE5hY2ggZGVyIFN0cmHDn2UgdW5kIGRlbSBUcmFuc3BvcnRlciBiZWZpbmRldCBlciBzaWNoIG51biBpbiBlaW5lbSBoZWxsZW4gQXVmbmFobWViZXJlaWNoLCBpbiBkZW0gYW5kZXJlIFBlcnNvbmVuIGRlbiBBYmxhdWYgYmVzdGltbWVuLjwvcD48cD5BbSBFbmRlIGbDvGhydCBkZXIgV2VnIGluIGRpZSBFaW5nYW5nc3NjaGxldXNlIGRlciBKdXN0aXp2b2xsenVnc2Fuc3RhbHQuIERhcyBTY2hpbGQgbWFjaHQgZGVuIG5ldWVuIE9ydCBlcmtlbm5iYXI7IGhpbnRlciBkZW4gR2xhc3TDvHJlbiBzZXR6dCBzaWNoIGRlciBnZXNpY2hlcnRlIElubmVuYmVyZWljaCBmb3J0LiBad2VpIEJlYW10ZSBiZWdsZWl0ZW4gZGVuIE1hbm4gaGluZWluLiBTZWluZSBIw6RuZGUgc2luZCBoaW50ZXIgZGVtIEvDtnJwZXIgZ2VzaWNoZXJ0LCB1bmQgZGllIFLDvGNrZW5rZXR0ZSB6dW0gSMO8ZnRndXJ0IHNvd2llIGRpZSBWZXJiaW5kdW5nIGFuIGRlbiBGdcOfc2NoZWxsZW4gc2luZCBpbiBkZXIgU3plbmUgc2ljaHRiYXIuIERpZSBLbGVpZHVuZyB1bmQgZGllIFNjaHVoZSBlbnRzcHJlY2hlbiBkZW0gdm9yYW5nZWdhbmdlbmVuIEF1Zm5haG1lYWJzY2huaXR0LiBEYXMgQmlsZCBzY2hsaWXDn3QgZGllIEdlc2NoaWNodGUgbmljaHQgbWl0IGVpbmVtIFVydGVpbCBvZGVyIGVpbmVyIEVya2zDpHJ1bmcgYWIsIHNvbmRlcm4gbWl0IGVpbmVyIFNjaHdlbGxlOiBEcmF1w59lbiBsaWVnZW4gZGllIFN0cmHDn2UgdW5kIGRhcyBBdXRvLCBkcmlubmVuIGJlZ2lubnQgZGllIEpWQS1BdWZuYWhtZS4gV2FzIGRhbmFjaCBnZXNjaGllaHQsIGJsZWlidCBiZXd1c3N0IGF1w59lcmhhbGIgZGllc2VyIEJpbGRmb2xnZS48L3A+PHA+U28gZW5kZXQgZGllIGZpa3RpdmUgR2VzY2hpY2h0ZSBkb3J0LCB3byBkaWUgS29udHJvbGxlIGVuZGfDvGx0aWcgaW4gZWluZSBBdWZuYWhtZSDDvGJlcmdlaHQuIERpZSBBYmZvbGdlIGbDvGhydCB2b20gZXJzdGVuIEdlc3Byw6RjaCBhbSBXYWdlbiDDvGJlciBkaWUgTWl0dGVpbHVuZyBkZXMgSGFmdGJlZmVobHMgdW5kIGRpZSBGZXN0bmFobWUgYmlzIHp1bSBUcmFuc3BvcnQsIHp1ciBHRVNBIHVuZCBzY2hsaWXDn2xpY2ggenVyIEpWQS1FaW5nYW5nc3NjaGxldXNlLiBEaWUgd2llZGVya2VocmVuZGVuIEtsZWlkdW5nc3N0w7xja2UsIGRpZSBTY2h1aGUgdW5kIGRpZSB2ZXJzY2hpZWRlbmVuIEJlc2NoaWxkZXJ1bmdlbiBnZWJlbiBPcmllbnRpZXJ1bmcuIEVpbnplbG5lIGFkbWluaXN0cmF0aXZlIG9kZXIgbWVkaXppbmlzY2hlIERldGFpbHMgYmxlaWJlbiBvZmZlbiwgd2VpbCBkaWUgQmlsZGVyIHNpZSBuaWNodCB6dXZlcmzDpHNzaWcgYmVsZWdlbi4gRGllIFNlcmllIGlzdCBlaW5lIGluc3plbmllcnRlIEVyesOkaGx1bmcgdW5kIGtlaW5lIERva3VtZW50YXRpb24gZWluZXMgdGF0c8OkY2hsaWNoZW4gRWluc2F0emVzLiBJaHIgU2NobHVzcyBpc3QgZGVzaGFsYiBrZWluIEtvbW1lbnRhciDDvGJlciBTY2h1bGQgb2RlciBVbnNjaHVsZCwgc29uZGVybiBkZXIgc2ljaHRiYXJlIMOcYmVyZ2FuZyBlaW5lciBGaWd1ciBhdXMgZGVtIEFsbHRhZyBpbiBlaW5lbiB2b2xsc3TDpG5kaWcgZnJlbWRiZXN0aW1tdGVuIGluc3RpdHV0aW9uZWxsZW4gQWJsYXVmLjwvcD48L3NlY3Rpb24+PHNlY3Rpb24gaWQ9XCJzdG9yeVwiPjxoMj5BbGxlIFN6ZW5lbjwvaDI+PGRpdiBjbGFzcz1cImdhbGxlcnlcIj48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjFcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0wMS1hZTQzMjU5NGMzZDEud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTAxLTczZDcyMmRlMDc0Yy53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0wMS00MTlhNDM5YmM3ODIud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJFcnN0ZSBLb250cm9sbGUuIERlciBCZWFtdGUgbmltbXQgZGllIGVyc3RlIEtvbnRyb2xsZSBhdWYuXCIgbG9hZGluZz1cImVhZ2VyXCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wMSDCtyBFcnN0ZSBLb250cm9sbGU8L2gzPjxwPkRlciBCZWFtdGUgbmltbXQgZGllIGVyc3RlIEtvbnRyb2xsZSBhdWYuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjJcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0wMi0zYWI5NDY3NjZjOGQud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTAyLWU5NDZjYzQwODY3Ni53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0wMi0zYWM4NDZiNWUyZjAud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJBYmZyYWdlIGltIFN0cmVpZmVud2FnZW4uIERpZSBQZXJzb25hbGllbiB3ZXJkZW4gw7xiZXIgZGFzIG1vYmlsZSBUZXJtaW5hbCBnZXByw7xmdC5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MDIgwrcgQWJmcmFnZSBpbSBTdHJlaWZlbndhZ2VuPC9oMz48cD5EaWUgUGVyc29uYWxpZW4gd2VyZGVuIMO8YmVyIGRhcyBtb2JpbGUgVGVybWluYWwgZ2VwcsO8ZnQuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjNcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0wMy1mZWY5MTk5M2ViYjEud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTAzLWU5MjlhYzgxNDA0ZS53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0wMy0wMTEzYTM4YmVjNDYud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJEZXIgb2ZmZW5lIEhhZnRiZWZlaGwuIERlciBCZWFtdGUgdGVpbHQgZGFzIEVyZ2VibmlzIGRlciBBYmZyYWdlIG1pdC5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MDMgwrcgRGVyIG9mZmVuZSBIYWZ0YmVmZWhsPC9oMz48cD5EZXIgQmVhbXRlIHRlaWx0IGRhcyBFcmdlYm5pcyBkZXIgQWJmcmFnZSBtaXQuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjRcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0wNC02OTU4YmZjZTQ5NGMud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTA0LWY3MTA2MGRlMzliYi53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0wNC01MmU3MzdjZTJmNzQud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJBbmhhbHRlbiBhbSBGYWhyemV1Zy4gRGVyIEZhaHJlciB3aXJkIGFtIHNpbGJlcm5lbiBXYWdlbiBhbmdlc3Byb2NoZW4uXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjA0IMK3IEFuaGFsdGVuIGFtIEZhaHJ6ZXVnPC9oMz48cD5EZXIgRmFocmVyIHdpcmQgYW0gc2lsYmVybmVuIFdhZ2VuIGFuZ2VzcHJvY2hlbi48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiNVwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTA1LWEyOTQ2MjU2NmFkNC53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDUtYzQ0YTZhZWMyNWZmLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTA1LTMwYjVhOTg2NzBjNy53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkZlc3RuYWhtZSBhbSBTdHJhw59lbnJhbmQuIERlciBNYW5uIHdpcmQgbmViZW4gZGVtIFdhZ2VuIGZlc3RnZW5vbW1lbi5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MDUgwrcgRmVzdG5haG1lIGFtIFN0cmHDn2VucmFuZDwvaDM+PHA+RGVyIE1hbm4gd2lyZCBuZWJlbiBkZW0gV2FnZW4gZmVzdGdlbm9tbWVuLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCI2XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDYtYjM5YmVlMDE5NzExLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wNi04N2U4OGEyM2UwMDEud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDYtM2MwODdmYTUxNWMxLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiS29udHJvbGxpZXJ0ZSBTaWNoZXJ1bmcuIERpZSBGZXN0bmFobWUgd2lyZCBhbSBGYWhyemV1ZyBmb3J0Z2VzZXR6dC5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MDYgwrcgS29udHJvbGxpZXJ0ZSBTaWNoZXJ1bmc8L2gzPjxwPkRpZSBGZXN0bmFobWUgd2lyZCBhbSBGYWhyemV1ZyBmb3J0Z2VzZXR6dC48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiN1wiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTA3LWJhZGYxNGEzMjAyMy53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDctYzZmMGVmNWQwYWQ0LndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTA3LWRmZjRhNmI1Nzc4Zi53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkRldGFpbCBhbSBGYWhyemV1Zy4gRGV0YWlsYW5zaWNodCBkZXMgRmFocnpldWdzIHVuZCBkZXIgS29udHJvbGxlLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wNyDCtyBEZXRhaWwgYW0gRmFocnpldWc8L2gzPjxwPkRldGFpbGFuc2ljaHQgZGVzIEZhaHJ6ZXVncyB1bmQgZGVyIEtvbnRyb2xsZS48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiOFwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTA4LWNjMzQxNTBjYTBlNi53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDgtOGMxYjk1YTQ3NzE2LndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTA4LWQ3OWY3MTJhMGIyZS53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkFidHJhbnNwb3J0IHdpcmQgdm9yYmVyZWl0ZXQuIERlciBGZXN0Z2Vub21tZW5lIHdpcmQgZsO8ciBkZW4gVHJhbnNwb3J0IGdlc2ljaGVydC5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MDggwrcgQWJ0cmFuc3BvcnQgd2lyZCB2b3JiZXJlaXRldDwvaDM+PHA+RGVyIEZlc3RnZW5vbW1lbmUgd2lyZCBmw7xyIGRlbiBUcmFuc3BvcnQgZ2VzaWNoZXJ0LjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCI5XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDktNjNiMWIzZjJlNWIwLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wOS1mMThmZGI4ZGU0YzEud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDktZWM5MTQ3ZTMyMmZlLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiRmFocnpldWd6dWdhbmcuIERlciBadWdhbmcgenVtIEZhaHJ6ZXVnIHdpcmQgZG9rdW1lbnRpZXJ0LlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wOSDCtyBGYWhyemV1Z3p1Z2FuZzwvaDM+PHA+RGVyIFp1Z2FuZyB6dW0gRmFocnpldWcgd2lyZCBkb2t1bWVudGllcnQuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjEwXCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMTAtNDliYzA5MzAzNjM0LndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0xMC1hNzYxODczMjViMTEud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMTAtYzNiMTRlYTQ5ZTFkLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiVHJhbnNwb3J0IHp1bSBHZXdhaHJzYW0uIERlciBGZXN0Z2Vub21tZW5lIHdpcmQgenVtIGRldXRzY2hlbiBHZWZhbmdlbmVudHJhbnNwb3J0ZXIgYmVnbGVpdGV0LlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4xMCDCtyBUcmFuc3BvcnQgenVtIEdld2FocnNhbTwvaDM+PHA+RGVyIEZlc3RnZW5vbW1lbmUgd2lyZCB6dW0gZGV1dHNjaGVuIEdlZmFuZ2VuZW50cmFuc3BvcnRlciBiZWdsZWl0ZXQuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjExXCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMTEtYjY3ZmM2YTNmNWNlLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0xMS1lZjcxMDYyNGEwMmYud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMTEtMjBhOTA3NmJlYmYwLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiw5xiZXJnYWJlIGFtIFRyYW5zcG9ydGVyLiBEaWUgw5xiZXJnYWJlIGFtIFRyYW5zcG9ydGZhaHJ6ZXVnIHdpcmQgZ2V6ZWlndC5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MTEgwrcgw5xiZXJnYWJlIGFtIFRyYW5zcG9ydGVyPC9oMz48cD5EaWUgw5xiZXJnYWJlIGFtIFRyYW5zcG9ydGZhaHJ6ZXVnIHdpcmQgZ2V6ZWlndC48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMTJcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0xMi03OGUwZTUwZmQ2NmEud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTEyLTM0MjAwODBjMzk5OS53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0xMi1jOGQ0YWEzMjFkNzMud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJTaWNoZXJ1bmcgYW0gVHJhbnNwb3J0ZXIuIERlciBUcmFuc3BvcnRlciBpc3QgYmVyZWl0LlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4xMiDCtyBTaWNoZXJ1bmcgYW0gVHJhbnNwb3J0ZXI8L2gzPjxwPkRlciBUcmFuc3BvcnRlciBpc3QgYmVyZWl0LjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIxM1wiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTEzLTgwZTY0NjM0YWE5OS53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMTMtZmE1MzY2MzNlMzhjLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTEzLTg5NDgzNDM1Nzg5Yi53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkZhaHJ0IHp1ciBEaWVuc3RzdGVsbGUuIERlciBBYnRyYW5zcG9ydCB3aXJkIGFiZ2VzY2hsb3NzZW4uXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjEzIMK3IEZhaHJ0IHp1ciBEaWVuc3RzdGVsbGU8L2gzPjxwPkRlciBBYnRyYW5zcG9ydCB3aXJkIGFiZ2VzY2hsb3NzZW4uPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjE0XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMTQtMDE5NDFhZDgzZTg2LndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0xNC02ODhhYjIwOTVkZmUud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMTQtNmUwY2IyZmJlNGNmLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiQmVnbGVpdHVuZyB6dW0gVHJhbnNwb3J0ZXIuIERlciBGZXN0Z2Vub21tZW5lIHdpcmQgdm9uIHp3ZWkgQmVhbXRlbiB6dW0gZGV1dHNjaGVuIEdlZmFuZ2VuZW50cmFuc3BvcnRlciBiZWdsZWl0ZXQuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjE0IMK3IEJlZ2xlaXR1bmcgenVtIFRyYW5zcG9ydGVyPC9oMz48cD5EZXIgRmVzdGdlbm9tbWVuZSB3aXJkIHZvbiB6d2VpIEJlYW10ZW4genVtIGRldXRzY2hlbiBHZWZhbmdlbmVudHJhbnNwb3J0ZXIgYmVnbGVpdGV0LjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIxNVwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTE1LWNmMjFlZTM4NTIyZS53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMTUtZGE5NjNlNzAwNGJjLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTE1LTc4ZjVjMDg4ZTcwOC53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkFid2VpY2hlbmRlIFVudGVyc3VjaHVuZ3MtU3plbmUuIFNlcGFyYXRlcywgZmlrdGlvbmFsZXMgVW50ZXJzdWNodW5ncy0gdW5kIERva3VtZW50YXRpb25zbW90aXYgYWxzIG5hY2hnZWxhZ2VydGVyIFN6ZW5lbndlY2hzZWwuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjE1IMK3IEFid2VpY2hlbmRlIFVudGVyc3VjaHVuZ3MtU3plbmU8L2gzPjxwPlNlcGFyYXRlcywgZmlrdGlvbmFsZXMgVW50ZXJzdWNodW5ncy0gdW5kIERva3VtZW50YXRpb25zbW90aXYgYWxzIG5hY2hnZWxhZ2VydGVyIFN6ZW5lbndlY2hzZWwuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjE2XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMTYtMTI5MGU1YmFiNTJjLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0xNi00NmMxNGIwMzdiYWMud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMTYtMGFjMjc0M2EwYTkyLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiR0VTQSDigJMgTWVkaXppbmlzY2hlIFVudGVyc3VjaHVuZy4gSW4gZGVyIEdFU0EgZG9rdW1lbnRpZXJ0IGVpbmUgw4RyenRpbiBkaWUgbWVkaXppbmlzY2hlIFVudGVyc3VjaHVuZy4gRWluZSBkZXV0bGljaCBzaWNodGJhcmUgS2V0dGUgdmVyYmluZGV0IGRpZSB2b3JuZSBhbmdlbGVndGVuIEhhbmRmZXNzZWxuIG1pdCBkZW4gRnXDn3NjaGVsbGVuOyBUcmFpbmluZ3Nhbnp1ZyB1bmQgU2NodWhlIGJsZWliZW4gdW52ZXLDpG5kZXJ0LlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4xNiDCtyBHRVNBIOKAkyBNZWRpemluaXNjaGUgVW50ZXJzdWNodW5nPC9oMz48cD5JbiBkZXIgR0VTQSBkb2t1bWVudGllcnQgZWluZSDDhHJ6dGluIGRpZSBtZWRpemluaXNjaGUgVW50ZXJzdWNodW5nLiBFaW5lIGRldXRsaWNoIHNpY2h0YmFyZSBLZXR0ZSB2ZXJiaW5kZXQgZGllIHZvcm5lIGFuZ2VsZWd0ZW4gSGFuZGZlc3NlbG4gbWl0IGRlbiBGdcOfc2NoZWxsZW47IFRyYWluaW5nc2FuenVnIHVuZCBTY2h1aGUgYmxlaWJlbiB1bnZlcsOkbmRlcnQuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjE3XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMTctMjkyMTVlZmQ1YmQ3LndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0xNy05MDU1NTkyYTg4MDMud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMTctNzRjYjFjY2RmMGYwLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiQXVmbmFobWUgaW4gZGVyIEpWQS1FaW5nYW5nc3NjaGxldXNlLiBEaWUgQmVhbXRlbiBmw7xocmVuIGlobiB6dXIgSlZBLUF1Zm5haG1lIGR1cmNoIGRpZSBFaW5nYW5nc3NjaGxldXNlLiBEaWUgUsO8Y2tlbmtldHRlIHZvbiBkZW4gaGludGVyIGRlbSBLw7ZycGVyIGFuZ2VsZWd0ZW4gSGFuZGZlc3NlbG4genVtIEjDvGZ0Z3VydCBzb3dpZSBkaWUgVmVyYmluZHVuZyB6d2lzY2hlbiBkZW4gRnXDn3NjaGVsbGVuIHNpbmQgZGV1dGxpY2ggc2ljaHRiYXIuIFRyYW5zcG9ydGVyLCBUcmFpbmluZ3Nhbnp1ZyB1bmQgd2Vpw58tYmxhdWUgU2NodWhlIGJsZWliZW4ga29uc2lzdGVudC5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MTcgwrcgQXVmbmFobWUgaW4gZGVyIEpWQS1FaW5nYW5nc3NjaGxldXNlPC9oMz48cD5EaWUgQmVhbXRlbiBmw7xocmVuIGlobiB6dXIgSlZBLUF1Zm5haG1lIGR1cmNoIGRpZSBFaW5nYW5nc3NjaGxldXNlLiBEaWUgUsO8Y2tlbmtldHRlIHZvbiBkZW4gaGludGVyIGRlbSBLw7ZycGVyIGFuZ2VsZWd0ZW4gSGFuZGZlc3NlbG4genVtIEjDvGZ0Z3VydCBzb3dpZSBkaWUgVmVyYmluZHVuZyB6d2lzY2hlbiBkZW4gRnXDn3NjaGVsbGVuIHNpbmQgZGV1dGxpY2ggc2ljaHRiYXIuIFRyYW5zcG9ydGVyLCBUcmFpbmluZ3Nhbnp1ZyB1bmQgd2Vpw58tYmxhdWUgU2NodWhlIGJsZWliZW4ga29uc2lzdGVudC48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjwvZGl2PjxkaXYgY2xhc3M9XCJjb250cm9sc1wiPjxidXR0b24gaWQ9XCJwcmV2aW91c1wiIHR5cGU9XCJidXR0b25cIj5Wb3JoZXJpZ2VzIEJpbGQ8L2J1dHRvbj48c3BhbiBpZD1cImNhcm91c2VsQ291bnRlclwiPjEgLyAxNzwvc3Bhbj48YnV0dG9uIGlkPVwibmV4dFwiIHR5cGU9XCJidXR0b25cIj5Ow6RjaHN0ZXMgQmlsZDwvYnV0dG9uPjwvZGl2PjxkaXYgY2xhc3M9XCJjYXJvdXNlbFwiIHRhYmluZGV4PVwiMFwiIGFyaWEtbGFiZWw9XCJBdXMgZGVtIEF1dG8gdmVyaGFmdGV0IGJlaSBWZXJrZWhyc2tvbnRyb2xsZVwiPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMVwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTAxLWFlNDMyNTk0YzNkMS53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDEtNzNkNzIyZGUwNzRjLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTAxLTQxOWE0MzliYzc4Mi53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkVyc3RlIEtvbnRyb2xsZS4gRGVyIEJlYW10ZSBuaW1tdCBkaWUgZXJzdGUgS29udHJvbGxlIGF1Zi5cIiBsb2FkaW5nPVwiZWFnZXJcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjAxIMK3IEVyc3RlIEtvbnRyb2xsZTwvaDM+PHA+RGVyIEJlYW10ZSBuaW1tdCBkaWUgZXJzdGUgS29udHJvbGxlIGF1Zi48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMlwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTAyLTNhYjk0Njc2NmM4ZC53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDItZTk0NmNjNDA4Njc2LndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTAyLTNhYzg0NmI1ZTJmMC53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkFiZnJhZ2UgaW0gU3RyZWlmZW53YWdlbi4gRGllIFBlcnNvbmFsaWVuIHdlcmRlbiDDvGJlciBkYXMgbW9iaWxlIFRlcm1pbmFsIGdlcHLDvGZ0LlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wMiDCtyBBYmZyYWdlIGltIFN0cmVpZmVud2FnZW48L2gzPjxwPkRpZSBQZXJzb25hbGllbiB3ZXJkZW4gw7xiZXIgZGFzIG1vYmlsZSBUZXJtaW5hbCBnZXByw7xmdC48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiM1wiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTAzLWZlZjkxOTkzZWJiMS53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDMtZTkyOWFjODE0MDRlLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTAzLTAxMTNhMzhiZWM0Ni53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkRlciBvZmZlbmUgSGFmdGJlZmVobC4gRGVyIEJlYW10ZSB0ZWlsdCBkYXMgRXJnZWJuaXMgZGVyIEFiZnJhZ2UgbWl0LlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wMyDCtyBEZXIgb2ZmZW5lIEhhZnRiZWZlaGw8L2gzPjxwPkRlciBCZWFtdGUgdGVpbHQgZGFzIEVyZ2VibmlzIGRlciBBYmZyYWdlIG1pdC48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiNFwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTA0LTY5NThiZmNlNDk0Yy53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDQtZjcxMDYwZGUzOWJiLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTA0LTUyZTczN2NlMmY3NC53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkFuaGFsdGVuIGFtIEZhaHJ6ZXVnLiBEZXIgRmFocmVyIHdpcmQgYW0gc2lsYmVybmVuIFdhZ2VuIGFuZ2VzcHJvY2hlbi5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MDQgwrcgQW5oYWx0ZW4gYW0gRmFocnpldWc8L2gzPjxwPkRlciBGYWhyZXIgd2lyZCBhbSBzaWxiZXJuZW4gV2FnZW4gYW5nZXNwcm9jaGVuLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCI1XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDUtYTI5NDYyNTY2YWQ0LndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wNS1jNDRhNmFlYzI1ZmYud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDUtMzBiNWE5ODY3MGM3LndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiRmVzdG5haG1lIGFtIFN0cmHDn2VucmFuZC4gRGVyIE1hbm4gd2lyZCBuZWJlbiBkZW0gV2FnZW4gZmVzdGdlbm9tbWVuLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wNSDCtyBGZXN0bmFobWUgYW0gU3RyYcOfZW5yYW5kPC9oMz48cD5EZXIgTWFubiB3aXJkIG5lYmVuIGRlbSBXYWdlbiBmZXN0Z2Vub21tZW4uPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjZcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0wNi1iMzliZWUwMTk3MTEud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTA2LTg3ZTg4YTIzZTAwMS53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0wNi0zYzA4N2ZhNTE1YzEud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJLb250cm9sbGllcnRlIFNpY2hlcnVuZy4gRGllIEZlc3RuYWhtZSB3aXJkIGFtIEZhaHJ6ZXVnIGZvcnRnZXNldHp0LlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wNiDCtyBLb250cm9sbGllcnRlIFNpY2hlcnVuZzwvaDM+PHA+RGllIEZlc3RuYWhtZSB3aXJkIGFtIEZhaHJ6ZXVnIGZvcnRnZXNldHp0LjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCI3XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDctYmFkZjE0YTMyMDIzLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wNy1jNmYwZWY1ZDBhZDQud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDctZGZmNGE2YjU3NzhmLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiRGV0YWlsIGFtIEZhaHJ6ZXVnLiBEZXRhaWxhbnNpY2h0IGRlcyBGYWhyemV1Z3MgdW5kIGRlciBLb250cm9sbGUuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjA3IMK3IERldGFpbCBhbSBGYWhyemV1ZzwvaDM+PHA+RGV0YWlsYW5zaWNodCBkZXMgRmFocnpldWdzIHVuZCBkZXIgS29udHJvbGxlLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCI4XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDgtY2MzNDE1MGNhMGU2LndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wOC04YzFiOTVhNDc3MTYud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDgtZDc5ZjcxMmEwYjJlLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiQWJ0cmFuc3BvcnQgd2lyZCB2b3JiZXJlaXRldC4gRGVyIEZlc3RnZW5vbW1lbmUgd2lyZCBmw7xyIGRlbiBUcmFuc3BvcnQgZ2VzaWNoZXJ0LlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wOCDCtyBBYnRyYW5zcG9ydCB3aXJkIHZvcmJlcmVpdGV0PC9oMz48cD5EZXIgRmVzdGdlbm9tbWVuZSB3aXJkIGbDvHIgZGVuIFRyYW5zcG9ydCBnZXNpY2hlcnQuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjlcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0wOS02M2IxYjNmMmU1YjAud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTA5LWYxOGZkYjhkZTRjMS53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0wOS1lYzkxNDdlMzIyZmUud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJGYWhyemV1Z3p1Z2FuZy4gRGVyIFp1Z2FuZyB6dW0gRmFocnpldWcgd2lyZCBkb2t1bWVudGllcnQuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjA5IMK3IEZhaHJ6ZXVnenVnYW5nPC9oMz48cD5EZXIgWnVnYW5nIHp1bSBGYWhyemV1ZyB3aXJkIGRva3VtZW50aWVydC48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMTBcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0xMC00OWJjMDkzMDM2MzQud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTEwLWE3NjE4NzMyNWIxMS53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0xMC1jM2IxNGVhNDllMWQud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJUcmFuc3BvcnQgenVtIEdld2FocnNhbS4gRGVyIEZlc3RnZW5vbW1lbmUgd2lyZCB6dW0gZGV1dHNjaGVuIEdlZmFuZ2VuZW50cmFuc3BvcnRlciBiZWdsZWl0ZXQuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjEwIMK3IFRyYW5zcG9ydCB6dW0gR2V3YWhyc2FtPC9oMz48cD5EZXIgRmVzdGdlbm9tbWVuZSB3aXJkIHp1bSBkZXV0c2NoZW4gR2VmYW5nZW5lbnRyYW5zcG9ydGVyIGJlZ2xlaXRldC48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMTFcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0xMS1iNjdmYzZhM2Y1Y2Uud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTExLWVmNzEwNjI0YTAyZi53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0xMS0yMGE5MDc2YmViZjAud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCLDnGJlcmdhYmUgYW0gVHJhbnNwb3J0ZXIuIERpZSDDnGJlcmdhYmUgYW0gVHJhbnNwb3J0ZmFocnpldWcgd2lyZCBnZXplaWd0LlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4xMSDCtyDDnGJlcmdhYmUgYW0gVHJhbnNwb3J0ZXI8L2gzPjxwPkRpZSDDnGJlcmdhYmUgYW0gVHJhbnNwb3J0ZmFocnpldWcgd2lyZCBnZXplaWd0LjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIxMlwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTEyLTc4ZTBlNTBmZDY2YS53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMTItMzQyMDA4MGMzOTk5LndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTEyLWM4ZDRhYTMyMWQ3My53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIlNpY2hlcnVuZyBhbSBUcmFuc3BvcnRlci4gRGVyIFRyYW5zcG9ydGVyIGlzdCBiZXJlaXQuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjEyIMK3IFNpY2hlcnVuZyBhbSBUcmFuc3BvcnRlcjwvaDM+PHA+RGVyIFRyYW5zcG9ydGVyIGlzdCBiZXJlaXQuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjEzXCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMTMtODBlNjQ2MzRhYTk5LndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0xMy1mYTUzNjYzM2UzOGMud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMTMtODk0ODM0MzU3ODliLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiRmFocnQgenVyIERpZW5zdHN0ZWxsZS4gRGVyIEFidHJhbnNwb3J0IHdpcmQgYWJnZXNjaGxvc3Nlbi5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MTMgwrcgRmFocnQgenVyIERpZW5zdHN0ZWxsZTwvaDM+PHA+RGVyIEFidHJhbnNwb3J0IHdpcmQgYWJnZXNjaGxvc3Nlbi48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMTRcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0xNC0wMTk0MWFkODNlODYud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTE0LTY4OGFiMjA5NWRmZS53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0xNC02ZTBjYjJmYmU0Y2Yud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJCZWdsZWl0dW5nIHp1bSBUcmFuc3BvcnRlci4gRGVyIEZlc3RnZW5vbW1lbmUgd2lyZCB2b24gendlaSBCZWFtdGVuIHp1bSBkZXV0c2NoZW4gR2VmYW5nZW5lbnRyYW5zcG9ydGVyIGJlZ2xlaXRldC5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MTQgwrcgQmVnbGVpdHVuZyB6dW0gVHJhbnNwb3J0ZXI8L2gzPjxwPkRlciBGZXN0Z2Vub21tZW5lIHdpcmQgdm9uIHp3ZWkgQmVhbXRlbiB6dW0gZGV1dHNjaGVuIEdlZmFuZ2VuZW50cmFuc3BvcnRlciBiZWdsZWl0ZXQuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjE1XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMTUtY2YyMWVlMzg1MjJlLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0xNS1kYTk2M2U3MDA0YmMud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMTUtNzhmNWMwODhlNzA4LndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiQWJ3ZWljaGVuZGUgVW50ZXJzdWNodW5ncy1TemVuZS4gU2VwYXJhdGVzLCBmaWt0aW9uYWxlcyBVbnRlcnN1Y2h1bmdzLSB1bmQgRG9rdW1lbnRhdGlvbnNtb3RpdiBhbHMgbmFjaGdlbGFnZXJ0ZXIgU3plbmVud2VjaHNlbC5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MTUgwrcgQWJ3ZWljaGVuZGUgVW50ZXJzdWNodW5ncy1TemVuZTwvaDM+PHA+U2VwYXJhdGVzLCBmaWt0aW9uYWxlcyBVbnRlcnN1Y2h1bmdzLSB1bmQgRG9rdW1lbnRhdGlvbnNtb3RpdiBhbHMgbmFjaGdlbGFnZXJ0ZXIgU3plbmVud2VjaHNlbC48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMTZcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0xNi0xMjkwZTViYWI1MmMud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTE2LTQ2YzE0YjAzN2JhYy53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0xNi0wYWMyNzQzYTBhOTIud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJHRVNBIOKAkyBNZWRpemluaXNjaGUgVW50ZXJzdWNodW5nLiBJbiBkZXIgR0VTQSBkb2t1bWVudGllcnQgZWluZSDDhHJ6dGluIGRpZSBtZWRpemluaXNjaGUgVW50ZXJzdWNodW5nLiBFaW5lIGRldXRsaWNoIHNpY2h0YmFyZSBLZXR0ZSB2ZXJiaW5kZXQgZGllIHZvcm5lIGFuZ2VsZWd0ZW4gSGFuZGZlc3NlbG4gbWl0IGRlbiBGdcOfc2NoZWxsZW47IFRyYWluaW5nc2FuenVnIHVuZCBTY2h1aGUgYmxlaWJlbiB1bnZlcsOkbmRlcnQuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjE2IMK3IEdFU0Eg4oCTIE1lZGl6aW5pc2NoZSBVbnRlcnN1Y2h1bmc8L2gzPjxwPkluIGRlciBHRVNBIGRva3VtZW50aWVydCBlaW5lIMOEcnp0aW4gZGllIG1lZGl6aW5pc2NoZSBVbnRlcnN1Y2h1bmcuIEVpbmUgZGV1dGxpY2ggc2ljaHRiYXJlIEtldHRlIHZlcmJpbmRldCBkaWUgdm9ybmUgYW5nZWxlZ3RlbiBIYW5kZmVzc2VsbiBtaXQgZGVuIEZ1w59zY2hlbGxlbjsgVHJhaW5pbmdzYW56dWcgdW5kIFNjaHVoZSBibGVpYmVuIHVudmVyw6RuZGVydC48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMTdcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0xNy0yOTIxNWVmZDViZDcud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTE3LTkwNTU1OTJhODgwMy53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0xNy03NGNiMWNjZGYwZjAud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJBdWZuYWhtZSBpbiBkZXIgSlZBLUVpbmdhbmdzc2NobGV1c2UuIERpZSBCZWFtdGVuIGbDvGhyZW4gaWhuIHp1ciBKVkEtQXVmbmFobWUgZHVyY2ggZGllIEVpbmdhbmdzc2NobGV1c2UuIERpZSBSw7xja2Vua2V0dGUgdm9uIGRlbiBoaW50ZXIgZGVtIEvDtnJwZXIgYW5nZWxlZ3RlbiBIYW5kZmVzc2VsbiB6dW0gSMO8ZnRndXJ0IHNvd2llIGRpZSBWZXJiaW5kdW5nIHp3aXNjaGVuIGRlbiBGdcOfc2NoZWxsZW4gc2luZCBkZXV0bGljaCBzaWNodGJhci4gVHJhbnNwb3J0ZXIsIFRyYWluaW5nc2FuenVnIHVuZCB3ZWnDny1ibGF1ZSBTY2h1aGUgYmxlaWJlbiBrb25zaXN0ZW50LlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4xNyDCtyBBdWZuYWhtZSBpbiBkZXIgSlZBLUVpbmdhbmdzc2NobGV1c2U8L2gzPjxwPkRpZSBCZWFtdGVuIGbDvGhyZW4gaWhuIHp1ciBKVkEtQXVmbmFobWUgZHVyY2ggZGllIEVpbmdhbmdzc2NobGV1c2UuIERpZSBSw7xja2Vua2V0dGUgdm9uIGRlbiBoaW50ZXIgZGVtIEvDtnJwZXIgYW5nZWxlZ3RlbiBIYW5kZmVzc2VsbiB6dW0gSMO8ZnRndXJ0IHNvd2llIGRpZSBWZXJiaW5kdW5nIHp3aXNjaGVuIGRlbiBGdcOfc2NoZWxsZW4gc2luZCBkZXV0bGljaCBzaWNodGJhci4gVHJhbnNwb3J0ZXIsIFRyYWluaW5nc2FuenVnIHVuZCB3ZWnDny1ibGF1ZSBTY2h1aGUgYmxlaWJlbiBrb25zaXN0ZW50LjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PC9kaXY+PC9zZWN0aW9uPjxzZWN0aW9uIGNsYXNzPVwic2xpZGVzaG93XCI+PGgyPlNsaWRlc2hvdzwvaDI+PGRpdiBjbGFzcz1cImNvbnRyb2xzXCI+PGJ1dHRvbiBpZD1cInNsaWRlUHJldmlvdXNcIiB0eXBlPVwiYnV0dG9uXCI+Vm9yaGVyaWdlcyBCaWxkPC9idXR0b24+PHNwYW4gaWQ9XCJjb3VudGVyXCI+MSAvIDE3PC9zcGFuPjxidXR0b24gaWQ9XCJzbGlkZU5leHRcIiB0eXBlPVwiYnV0dG9uXCI+TsOkY2hzdGVzIEJpbGQ8L2J1dHRvbj48YnV0dG9uIGlkPVwidG9nZ2xlXCIgZGF0YS1wbGF5PVwi4pa2XCIgZGF0YS1wYXVzZT1cIuKFoVwiIGFyaWEtcHJlc3NlZD1cImZhbHNlXCIgdHlwZT1cImJ1dHRvblwiPuKWtjwvYnV0dG9uPjwvZGl2PjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMVwiIGRhdGEtc2Vjb25kcz1cIjZcIiBjbGFzcz1cImFjdGl2ZVwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDEtYWU0MzI1OTRjM2QxLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wMS03M2Q3MjJkZTA3NGMud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDEtNDE5YTQzOWJjNzgyLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiRXJzdGUgS29udHJvbGxlLiBEZXIgQmVhbXRlIG5pbW10IGRpZSBlcnN0ZSBLb250cm9sbGUgYXVmLlwiIGxvYWRpbmc9XCJlYWdlclwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MDEgwrcgRXJzdGUgS29udHJvbGxlPC9oMz48cD5EZXIgQmVhbXRlIG5pbW10IGRpZSBlcnN0ZSBLb250cm9sbGUgYXVmLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIyXCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDItM2FiOTQ2NzY2YzhkLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wMi1lOTQ2Y2M0MDg2NzYud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDItM2FjODQ2YjVlMmYwLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiQWJmcmFnZSBpbSBTdHJlaWZlbndhZ2VuLiBEaWUgUGVyc29uYWxpZW4gd2VyZGVuIMO8YmVyIGRhcyBtb2JpbGUgVGVybWluYWwgZ2VwcsO8ZnQuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjAyIMK3IEFiZnJhZ2UgaW0gU3RyZWlmZW53YWdlbjwvaDM+PHA+RGllIFBlcnNvbmFsaWVuIHdlcmRlbiDDvGJlciBkYXMgbW9iaWxlIFRlcm1pbmFsIGdlcHLDvGZ0LjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIzXCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDMtZmVmOTE5OTNlYmIxLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wMy1lOTI5YWM4MTQwNGUud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDMtMDExM2EzOGJlYzQ2LndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiRGVyIG9mZmVuZSBIYWZ0YmVmZWhsLiBEZXIgQmVhbXRlIHRlaWx0IGRhcyBFcmdlYm5pcyBkZXIgQWJmcmFnZSBtaXQuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjAzIMK3IERlciBvZmZlbmUgSGFmdGJlZmVobDwvaDM+PHA+RGVyIEJlYW10ZSB0ZWlsdCBkYXMgRXJnZWJuaXMgZGVyIEFiZnJhZ2UgbWl0LjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCI0XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDQtNjk1OGJmY2U0OTRjLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wNC1mNzEwNjBkZTM5YmIud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDQtNTJlNzM3Y2UyZjc0LndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiQW5oYWx0ZW4gYW0gRmFocnpldWcuIERlciBGYWhyZXIgd2lyZCBhbSBzaWxiZXJuZW4gV2FnZW4gYW5nZXNwcm9jaGVuLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wNCDCtyBBbmhhbHRlbiBhbSBGYWhyemV1ZzwvaDM+PHA+RGVyIEZhaHJlciB3aXJkIGFtIHNpbGJlcm5lbiBXYWdlbiBhbmdlc3Byb2NoZW4uPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjVcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0wNS1hMjk0NjI1NjZhZDQud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTA1LWM0NGE2YWVjMjVmZi53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0wNS0zMGI1YTk4NjcwYzcud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJGZXN0bmFobWUgYW0gU3RyYcOfZW5yYW5kLiBEZXIgTWFubiB3aXJkIG5lYmVuIGRlbSBXYWdlbiBmZXN0Z2Vub21tZW4uXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjA1IMK3IEZlc3RuYWhtZSBhbSBTdHJhw59lbnJhbmQ8L2gzPjxwPkRlciBNYW5uIHdpcmQgbmViZW4gZGVtIFdhZ2VuIGZlc3RnZW5vbW1lbi48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiNlwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTA2LWIzOWJlZTAxOTcxMS53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDYtODdlODhhMjNlMDAxLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTA2LTNjMDg3ZmE1MTVjMS53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIktvbnRyb2xsaWVydGUgU2ljaGVydW5nLiBEaWUgRmVzdG5haG1lIHdpcmQgYW0gRmFocnpldWcgZm9ydGdlc2V0enQuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjA2IMK3IEtvbnRyb2xsaWVydGUgU2ljaGVydW5nPC9oMz48cD5EaWUgRmVzdG5haG1lIHdpcmQgYW0gRmFocnpldWcgZm9ydGdlc2V0enQuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjdcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0wNy1iYWRmMTRhMzIwMjMud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTA3LWM2ZjBlZjVkMGFkNC53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0wNy1kZmY0YTZiNTc3OGYud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJEZXRhaWwgYW0gRmFocnpldWcuIERldGFpbGFuc2ljaHQgZGVzIEZhaHJ6ZXVncyB1bmQgZGVyIEtvbnRyb2xsZS5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MDcgwrcgRGV0YWlsIGFtIEZhaHJ6ZXVnPC9oMz48cD5EZXRhaWxhbnNpY2h0IGRlcyBGYWhyemV1Z3MgdW5kIGRlciBLb250cm9sbGUuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjhcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0wOC1jYzM0MTUwY2EwZTYud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTA4LThjMWI5NWE0NzcxNi53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0wOC1kNzlmNzEyYTBiMmUud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJBYnRyYW5zcG9ydCB3aXJkIHZvcmJlcmVpdGV0LiBEZXIgRmVzdGdlbm9tbWVuZSB3aXJkIGbDvHIgZGVuIFRyYW5zcG9ydCBnZXNpY2hlcnQuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjA4IMK3IEFidHJhbnNwb3J0IHdpcmQgdm9yYmVyZWl0ZXQ8L2gzPjxwPkRlciBGZXN0Z2Vub21tZW5lIHdpcmQgZsO8ciBkZW4gVHJhbnNwb3J0IGdlc2ljaGVydC48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiOVwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTA5LTYzYjFiM2YyZTViMC53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDktZjE4ZmRiOGRlNGMxLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTA5LWVjOTE0N2UzMjJmZS53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkZhaHJ6ZXVnenVnYW5nLiBEZXIgWnVnYW5nIHp1bSBGYWhyemV1ZyB3aXJkIGRva3VtZW50aWVydC5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MDkgwrcgRmFocnpldWd6dWdhbmc8L2gzPjxwPkRlciBadWdhbmcgenVtIEZhaHJ6ZXVnIHdpcmQgZG9rdW1lbnRpZXJ0LjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIxMFwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTEwLTQ5YmMwOTMwMzYzNC53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMTAtYTc2MTg3MzI1YjExLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTEwLWMzYjE0ZWE0OWUxZC53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIlRyYW5zcG9ydCB6dW0gR2V3YWhyc2FtLiBEZXIgRmVzdGdlbm9tbWVuZSB3aXJkIHp1bSBkZXV0c2NoZW4gR2VmYW5nZW5lbnRyYW5zcG9ydGVyIGJlZ2xlaXRldC5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MTAgwrcgVHJhbnNwb3J0IHp1bSBHZXdhaHJzYW08L2gzPjxwPkRlciBGZXN0Z2Vub21tZW5lIHdpcmQgenVtIGRldXRzY2hlbiBHZWZhbmdlbmVudHJhbnNwb3J0ZXIgYmVnbGVpdGV0LjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIxMVwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTExLWI2N2ZjNmEzZjVjZS53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMTEtZWY3MTA2MjRhMDJmLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTExLTIwYTkwNzZiZWJmMC53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIsOcYmVyZ2FiZSBhbSBUcmFuc3BvcnRlci4gRGllIMOcYmVyZ2FiZSBhbSBUcmFuc3BvcnRmYWhyemV1ZyB3aXJkIGdlemVpZ3QuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjExIMK3IMOcYmVyZ2FiZSBhbSBUcmFuc3BvcnRlcjwvaDM+PHA+RGllIMOcYmVyZ2FiZSBhbSBUcmFuc3BvcnRmYWhyemV1ZyB3aXJkIGdlemVpZ3QuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjEyXCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMTItNzhlMGU1MGZkNjZhLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0xMi0zNDIwMDgwYzM5OTkud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMTItYzhkNGFhMzIxZDczLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiU2ljaGVydW5nIGFtIFRyYW5zcG9ydGVyLiBEZXIgVHJhbnNwb3J0ZXIgaXN0IGJlcmVpdC5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MTIgwrcgU2ljaGVydW5nIGFtIFRyYW5zcG9ydGVyPC9oMz48cD5EZXIgVHJhbnNwb3J0ZXIgaXN0IGJlcmVpdC48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMTNcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0xMy04MGU2NDYzNGFhOTkud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTEzLWZhNTM2NjMzZTM4Yy53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0xMy04OTQ4MzQzNTc4OWIud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJGYWhydCB6dXIgRGllbnN0c3RlbGxlLiBEZXIgQWJ0cmFuc3BvcnQgd2lyZCBhYmdlc2NobG9zc2VuLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4xMyDCtyBGYWhydCB6dXIgRGllbnN0c3RlbGxlPC9oMz48cD5EZXIgQWJ0cmFuc3BvcnQgd2lyZCBhYmdlc2NobG9zc2VuLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIxNFwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTE0LTAxOTQxYWQ4M2U4Ni53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMTQtNjg4YWIyMDk1ZGZlLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTE0LTZlMGNiMmZiZTRjZi53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkJlZ2xlaXR1bmcgenVtIFRyYW5zcG9ydGVyLiBEZXIgRmVzdGdlbm9tbWVuZSB3aXJkIHZvbiB6d2VpIEJlYW10ZW4genVtIGRldXRzY2hlbiBHZWZhbmdlbmVudHJhbnNwb3J0ZXIgYmVnbGVpdGV0LlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4xNCDCtyBCZWdsZWl0dW5nIHp1bSBUcmFuc3BvcnRlcjwvaDM+PHA+RGVyIEZlc3RnZW5vbW1lbmUgd2lyZCB2b24gendlaSBCZWFtdGVuIHp1bSBkZXV0c2NoZW4gR2VmYW5nZW5lbnRyYW5zcG9ydGVyIGJlZ2xlaXRldC48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMTVcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0xNS1jZjIxZWUzODUyMmUud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTE1LWRhOTYzZTcwMDRiYy53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0xNS03OGY1YzA4OGU3MDgud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJBYndlaWNoZW5kZSBVbnRlcnN1Y2h1bmdzLVN6ZW5lLiBTZXBhcmF0ZXMsIGZpa3Rpb25hbGVzIFVudGVyc3VjaHVuZ3MtIHVuZCBEb2t1bWVudGF0aW9uc21vdGl2IGFscyBuYWNoZ2VsYWdlcnRlciBTemVuZW53ZWNoc2VsLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4xNSDCtyBBYndlaWNoZW5kZSBVbnRlcnN1Y2h1bmdzLVN6ZW5lPC9oMz48cD5TZXBhcmF0ZXMsIGZpa3Rpb25hbGVzIFVudGVyc3VjaHVuZ3MtIHVuZCBEb2t1bWVudGF0aW9uc21vdGl2IGFscyBuYWNoZ2VsYWdlcnRlciBTemVuZW53ZWNoc2VsLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIxNlwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTE2LTEyOTBlNWJhYjUyYy53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMTYtNDZjMTRiMDM3YmFjLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTE2LTBhYzI3NDNhMGE5Mi53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkdFU0Eg4oCTIE1lZGl6aW5pc2NoZSBVbnRlcnN1Y2h1bmcuIEluIGRlciBHRVNBIGRva3VtZW50aWVydCBlaW5lIMOEcnp0aW4gZGllIG1lZGl6aW5pc2NoZSBVbnRlcnN1Y2h1bmcuIEVpbmUgZGV1dGxpY2ggc2ljaHRiYXJlIEtldHRlIHZlcmJpbmRldCBkaWUgdm9ybmUgYW5nZWxlZ3RlbiBIYW5kZmVzc2VsbiBtaXQgZGVuIEZ1w59zY2hlbGxlbjsgVHJhaW5pbmdzYW56dWcgdW5kIFNjaHVoZSBibGVpYmVuIHVudmVyw6RuZGVydC5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MTYgwrcgR0VTQSDigJMgTWVkaXppbmlzY2hlIFVudGVyc3VjaHVuZzwvaDM+PHA+SW4gZGVyIEdFU0EgZG9rdW1lbnRpZXJ0IGVpbmUgw4RyenRpbiBkaWUgbWVkaXppbmlzY2hlIFVudGVyc3VjaHVuZy4gRWluZSBkZXV0bGljaCBzaWNodGJhcmUgS2V0dGUgdmVyYmluZGV0IGRpZSB2b3JuZSBhbmdlbGVndGVuIEhhbmRmZXNzZWxuIG1pdCBkZW4gRnXDn3NjaGVsbGVuOyBUcmFpbmluZ3Nhbnp1ZyB1bmQgU2NodWhlIGJsZWliZW4gdW52ZXLDpG5kZXJ0LjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIxN1wiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTE3LTI5MjE1ZWZkNWJkNy53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMTctOTA1NTU5MmE4ODAzLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTE3LTc0Y2IxY2NkZjBmMC53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkF1Zm5haG1lIGluIGRlciBKVkEtRWluZ2FuZ3NzY2hsZXVzZS4gRGllIEJlYW10ZW4gZsO8aHJlbiBpaG4genVyIEpWQS1BdWZuYWhtZSBkdXJjaCBkaWUgRWluZ2FuZ3NzY2hsZXVzZS4gRGllIFLDvGNrZW5rZXR0ZSB2b24gZGVuIGhpbnRlciBkZW0gS8O2cnBlciBhbmdlbGVndGVuIEhhbmRmZXNzZWxuIHp1bSBIw7xmdGd1cnQgc293aWUgZGllIFZlcmJpbmR1bmcgendpc2NoZW4gZGVuIEZ1w59zY2hlbGxlbiBzaW5kIGRldXRsaWNoIHNpY2h0YmFyLiBUcmFuc3BvcnRlciwgVHJhaW5pbmdzYW56dWcgdW5kIHdlacOfLWJsYXVlIFNjaHVoZSBibGVpYmVuIGtvbnNpc3RlbnQuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjE3IMK3IEF1Zm5haG1lIGluIGRlciBKVkEtRWluZ2FuZ3NzY2hsZXVzZTwvaDM+PHA+RGllIEJlYW10ZW4gZsO8aHJlbiBpaG4genVyIEpWQS1BdWZuYWhtZSBkdXJjaCBkaWUgRWluZ2FuZ3NzY2hsZXVzZS4gRGllIFLDvGNrZW5rZXR0ZSB2b24gZGVuIGhpbnRlciBkZW0gS8O2cnBlciBhbmdlbGVndGVuIEhhbmRmZXNzZWxuIHp1bSBIw7xmdGd1cnQgc293aWUgZGllIFZlcmJpbmR1bmcgendpc2NoZW4gZGVuIEZ1w59zY2hlbGxlbiBzaW5kIGRldXRsaWNoIHNpY2h0YmFyLiBUcmFuc3BvcnRlciwgVHJhaW5pbmdzYW56dWcgdW5kIHdlacOfLWJsYXVlIFNjaHVoZSBibGVpYmVuIGtvbnNpc3RlbnQuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48L3NlY3Rpb24+PHNlY3Rpb24gaWQ9XCJ2aWRlb1wiPjxoMj5TdHVtbWUgQmlsZC1TbGlkZXNob3c8L2gyPjx2aWRlbyBjb250cm9scyBwbGF5c2lubGluZSBwcmVsb2FkPVwibWV0YWRhdGFcIj48c291cmNlIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90cmFmZmljLXN0b3Atc2lsZW50LTE2eDktMjc3YTI4MjNhODE2Lm1wNFwiIHR5cGU9XCJ2aWRlby9tcDRcIj48dHJhY2sga2luZD1cInN1YnRpdGxlc1wiIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9jYXB0aW9ucy1kZS05YjE2YTMyM2FiOWMudnR0XCIgc3JjbGFuZz1cImRlXCIgbGFiZWw9XCJEZXV0c2NoXCIgZGVmYXVsdD48dHJhY2sga2luZD1cInN1YnRpdGxlc1wiIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9jYXB0aW9ucy1lbi05MmZlOTI1YjM1ZWIudnR0XCIgc3JjbGFuZz1cImVuXCIgbGFiZWw9XCJFbmdsaXNoXCI+PHRyYWNrIGtpbmQ9XCJzdWJ0aXRsZXNcIiBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvY2FwdGlvbnMtZXMtZWVhNGNiMjBkYTBmLnZ0dFwiIHNyY2xhbmc9XCJlc1wiIGxhYmVsPVwiRXNwYcOxb2xcIj48dHJhY2sga2luZD1cInN1YnRpdGxlc1wiIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9jYXB0aW9ucy1mci1mMzIwMDhhY2FjZTUudnR0XCIgc3JjbGFuZz1cImZyXCIgbGFiZWw9XCJGcmFuw6dhaXNcIj48L3ZpZGVvPjxwPkRpZSBkZXV0c2NoZSBFcnrDpGhsZmFzc3VuZyBzdGVodCBpbSBBdWRpb3BsYXllciBiZXJlaXQuPC9wPjwvc2VjdGlvbj48c2VjdGlvbiBpZD1cImF1ZGlvLW5hcnJhdGlvblwiPjxoMj5EZXV0c2NoZSBWZXJ0b251bmc8L2gyPjxhdWRpbyBjb250cm9scyBwcmVsb2FkPVwibWV0YWRhdGFcIj48c291cmNlIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9uYXJyYXRpb24tZGUtY2ExMDFkYzhiMGE4Lm1wM1wiIHR5cGU9XCJhdWRpby9tcGVnXCI+RGVpbiBCcm93c2VyIHVudGVyc3TDvHR6dCBkaWUgQXVkaW93aWVkZXJnYWJlIG5pY2h0LjwvYXVkaW8+PHA+R2VzcHJvY2hlbmUgRmFzc3VuZyBkZXIgdm9sbHN0w6RuZGlnZW4gQmlsZGdlc2NoaWNodGUuIFNwcmFjaGU6IERldXRzY2guPC9wPjwvc2VjdGlvbj48c2VjdGlvbiBpZD1cInN0b3J5LXRyaWdnZXJzXCI+PGgyPlRyaWdnZXI8L2gyPjxwPlZlcmtlaHJza29udHJvbGxlIMK3IEhhZnRiZWZlaGwgwrcgRmVzdG5haG1lIMK3IFBvbGl6ZWkgwrcgQWRpZGFzIMK3IEFkaWRhcyBIaWdoLVRvcHMgwrcgSm9nZ2VyIMK3IEhhbmRzY2hlbGxlbiDCtyBGdcOfc2NoZWxsZW4gwrcgUsO8Y2tlbmtldHRlIMK3IEdlZmFuZ2VuZW50cmFuc3BvcnRlciDCtyBtZWRpemluaXNjaGUgVW50ZXJzdWNodW5nIMK3IEdFU0EgwrcgSlZBPC9wPjwvc2VjdGlvbj48L2Rpdj4iLCJjb250ZW50X3NoYTI1NiI6IjAzODhlMzBkMzFlYWI1MjliNmY0M2UyMDRkMDQ0NmUxYzNlMTU5ZjdhZTA2MTA4NTA1ZTg2ZTBlNmZmN2QyMDkiLCJwYW5lbF9jb3VudCI6MTcsImNoYXB0ZXJfY291bnQiOjE3LCJzdG9yeV93b3JkcyI6MTcxMCwiYXVkaW9fbW9kZSI6Im5hcnJhdGlvbiIsIm5hcnJhdGlvbl9sYW5ndWFnZSI6ImRlIiwidmlkZW9fc2hhMjU2IjoiMjc3YTI4MjNhODE2NDYwNGZkMjRiMGRiMTc0NTFhNWNlNzAwMTE1MGEzYjdmNDBlNWVjMDY3MDk5MTg2MjQyMCIsIm5hcnJhdGlvbl9zaGEyNTYiOiJjYTEwMWRjOGIwYTgxYTkzYjVlZGNhZjFiYTg0OTYzNmExN2I0OTMzYzQzYmY2MTEwMzI1N2JhMWQ0OGQyNzUwIiwiYXVkaW9fdXJsIjoiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L25hcnJhdGlvbi1kZS1jYTEwMWRjOGIwYTgubXAzIn0sImVuIjp7InRpdGxlIjoiQXJyZXN0ZWQgRHVyaW5nIGEgVHJhZmZpYyBTdG9wIiwiY29udGVudCI6IjxkaXYgY2xhc3M9XCJkdHUtcmV2aWV3LXN0b3J5IGR0dS1hcHByb3ZlZDE2eDlcIj48bmF2IGFyaWEtbGFiZWw9XCJMYW5ndWFnZXNcIj48YSBocmVmPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vZGUvYmlsZHNlcmllbi9hdXMtZGVtLWF1dG8tdmVyaGFmdGV0LWJlaS12ZXJrZWhyc2tvbnRyb2xsZS9cIj5EZXV0c2NoPC9hPjxhIGhyZWY9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS9lbl91cy9iaWxkc2VyaWVuL2F1cy1kZW0tYXV0by12ZXJoYWZ0ZXQtYmVpLXZlcmtlaHJza29udHJvbGxlL1wiIGFyaWEtY3VycmVudD1cInBhZ2VcIj5FbmdsaXNoPC9hPjxhIGhyZWY9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS9lcy9iaWxkc2VyaWVuL2F1cy1kZW0tYXV0by12ZXJoYWZ0ZXQtYmVpLXZlcmtlaHJza29udHJvbGxlL1wiPkVzcGHDsW9sPC9hPjxhIGhyZWY9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS9mci9iaWxkc2VyaWVuL2F1cy1kZW0tYXV0by12ZXJoYWZ0ZXQtYmVpLXZlcmtlaHJza29udHJvbGxlL1wiPkZyYW7Dp2FpczwvYT48L25hdj48aDE+QXJyZXN0ZWQgRHVyaW5nIGEgVHJhZmZpYyBTdG9wPC9oMT48YXNpZGUgY2xhc3M9XCJub3RpY2VcIj5GaWN0aW9uYWwsIHN0YWdlZCBwaWN0dXJlIHN0b3J5LiBObyByZWFsIGFycmVzdCBvciBvZmZpY2lhbCBkb2N1bWVudGF0aW9uLjwvYXNpZGU+PHNlY3Rpb24gaWQ9XCJuYXJyYXRpdmVcIj48aDI+VGhlIHN0b3J5PC9oMj48cD5FYXJseSBvbmUgZXZlbmluZywgcG9saWNlIHN0b3AgYSB5b3VuZyBkcml2ZXIgb24gYSBjb3VudHJ5IHJvYWQuIFRoZSBvZmZpY2VycyBjaGVjayBoaXMgaWRlbnRpdHkgYW5kIHZlaGljbGUgZGV0YWlscyBvbiBhIG1vYmlsZSB0ZXJtaW5hbC4gVGhlIHF1ZXJ5IHJldHVybnMgYW4gb3V0c3RhbmRpbmcgYXJyZXN0IHdhcnJhbnQuIEFuIG9mZmljZXIgZXhwbGFpbnMgdGhlIHJlYXNvbiBmb3IgdGhlIGFjdGlvbiwgYW5kIHRoZSBhcnJlc3QgdGFrZXMgcGxhY2UgYmVzaWRlIHRoZSBjYXIuPC9wPjxwPkFmdGVyIHRoZSBhcnJlc3QsIHRoZSBtYW4gaXMgZXNjb3J0ZWQgdG8gYSB0cmFuc3BvcnQgdmFuIGFuZCB0YWtlbiB0byB0aGUgc3RhdGlvbi4gQXQgdGhlIEdFU0EsIGEgZG9jdG9yIGRvY3VtZW50cyB0aGUgbWVkaWNhbCBleGFtaW5hdGlvbi4gVGhlIGNsb3RoZWQgbWFuIHdlYXJzIGhhbmRjdWZmcyBpbiBmcm9udCBhbmQgYW5rbGUgY3VmZnMgam9pbmVkIGJ5IGEgY2hhaW4uIEhlIGlzIHRoZW4gdHJhbnNmZXJyZWQgdG8gdGhlIGNvcnJlY3Rpb25hbCBmYWNpbGl0eS4gVGhlIHN0b3J5IGVuZHMgYXQgdGhlIHNpZ25wb3N0ZWQgcHJpc29uIGVudHJhbmNlIGFpcmxvY2ssIHdoZXJlIG9mZmljZXJzIGVzY29ydCBoaW0gaW5zaWRlIGZvciBpbnRha2Ugd2VhcmluZyBoYW5kY3VmZnMsIGFua2xlIGN1ZmZzIGFuZCBhIGJhY2stY2hhaW4gcmVzdHJhaW50LjwvcD48L3NlY3Rpb24+PHNlY3Rpb24gaWQ9XCJzdG9yeVwiPjxoMj5BbGwgc2NlbmVzPC9oMj48ZGl2IGNsYXNzPVwiZ2FsbGVyeVwiPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMVwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTAxLWFlNDMyNTk0YzNkMS53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDEtNzNkNzIyZGUwNzRjLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTAxLTQxOWE0MzliYzc4Mi53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkluaXRpYWwgdHJhZmZpYyBzdG9wLiBBbiBvZmZpY2VyIGJlZ2lucyB0aGUgaW5pdGlhbCB0cmFmZmljIGNoZWNrLlwiIGxvYWRpbmc9XCJlYWdlclwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MDEgwrcgSW5pdGlhbCB0cmFmZmljIHN0b3A8L2gzPjxwPkFuIG9mZmljZXIgYmVnaW5zIHRoZSBpbml0aWFsIHRyYWZmaWMgY2hlY2suPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjJcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0wMi0zYWI5NDY3NjZjOGQud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTAyLWU5NDZjYzQwODY3Ni53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0wMi0zYWM4NDZiNWUyZjAud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJEYXRhYmFzZSBjaGVjay4gVGhlIGRyaXZlcuKAmXMgZGV0YWlscyBhcmUgY2hlY2tlZCBvbiB0aGUgbW9iaWxlIHRlcm1pbmFsLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wMiDCtyBEYXRhYmFzZSBjaGVjazwvaDM+PHA+VGhlIGRyaXZlcuKAmXMgZGV0YWlscyBhcmUgY2hlY2tlZCBvbiB0aGUgbW9iaWxlIHRlcm1pbmFsLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIzXCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDMtZmVmOTE5OTNlYmIxLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wMy1lOTI5YWM4MTQwNGUud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDMtMDExM2EzOGJlYzQ2LndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiT3V0c3RhbmRpbmcgd2FycmFudC4gVGhlIG9mZmljZXIgaW5mb3JtcyBoaW0gb2YgdGhlIHJlc3VsdCBvZiB0aGUgY2hlY2suXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjAzIMK3IE91dHN0YW5kaW5nIHdhcnJhbnQ8L2gzPjxwPlRoZSBvZmZpY2VyIGluZm9ybXMgaGltIG9mIHRoZSByZXN1bHQgb2YgdGhlIGNoZWNrLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCI0XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDQtNjk1OGJmY2U0OTRjLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wNC1mNzEwNjBkZTM5YmIud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDQtNTJlNzM3Y2UyZjc0LndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiU3RvcHBlZCBiZXNpZGUgdGhlIGNhci4gVGhlIGRyaXZlciBpcyBhcHByb2FjaGVkIGJlc2lkZSB0aGUgc2lsdmVyIGNhci5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MDQgwrcgU3RvcHBlZCBiZXNpZGUgdGhlIGNhcjwvaDM+PHA+VGhlIGRyaXZlciBpcyBhcHByb2FjaGVkIGJlc2lkZSB0aGUgc2lsdmVyIGNhci48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiNVwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTA1LWEyOTQ2MjU2NmFkNC53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDUtYzQ0YTZhZWMyNWZmLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTA1LTMwYjVhOTg2NzBjNy53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkFycmVzdCBhdCB0aGUgcm9hZHNpZGUuIFRoZSBtYW4gaXMgYXJyZXN0ZWQgYmVzaWRlIHRoZSBjYXIuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjA1IMK3IEFycmVzdCBhdCB0aGUgcm9hZHNpZGU8L2gzPjxwPlRoZSBtYW4gaXMgYXJyZXN0ZWQgYmVzaWRlIHRoZSBjYXIuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjZcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0wNi1iMzliZWUwMTk3MTEud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTA2LTg3ZTg4YTIzZTAwMS53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0wNi0zYzA4N2ZhNTE1YzEud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJTZWN1cmluZyB0aGUgYXJyZXN0LiBUaGUgYXJyZXN0IGNvbnRpbnVlcyBiZXNpZGUgdGhlIHZlaGljbGUuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjA2IMK3IFNlY3VyaW5nIHRoZSBhcnJlc3Q8L2gzPjxwPlRoZSBhcnJlc3QgY29udGludWVzIGJlc2lkZSB0aGUgdmVoaWNsZS48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiN1wiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTA3LWJhZGYxNGEzMjAyMy53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDctYzZmMGVmNWQwYWQ0LndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTA3LWRmZjRhNmI1Nzc4Zi53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIlZlaGljbGUgZGV0YWlsLiBBIGRldGFpbCB2aWV3IG9mIHRoZSBjYXIgYW5kIHRyYWZmaWMgc3RvcC5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MDcgwrcgVmVoaWNsZSBkZXRhaWw8L2gzPjxwPkEgZGV0YWlsIHZpZXcgb2YgdGhlIGNhciBhbmQgdHJhZmZpYyBzdG9wLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCI4XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDgtY2MzNDE1MGNhMGU2LndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wOC04YzFiOTVhNDc3MTYud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDgtZDc5ZjcxMmEwYjJlLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiUHJlcGFyaW5nIHRyYW5zcG9ydC4gVGhlIGFycmVzdGVkIG1hbiBpcyBzZWN1cmVkIGZvciB0cmFuc3BvcnQuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjA4IMK3IFByZXBhcmluZyB0cmFuc3BvcnQ8L2gzPjxwPlRoZSBhcnJlc3RlZCBtYW4gaXMgc2VjdXJlZCBmb3IgdHJhbnNwb3J0LjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCI5XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDktNjNiMWIzZjJlNWIwLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wOS1mMThmZGI4ZGU0YzEud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDktZWM5MTQ3ZTMyMmZlLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiQWNjZXNzIHRvIHRoZSB2ZWhpY2xlLiBBY2Nlc3MgdG8gdGhlIHZlaGljbGUgaXMgZG9jdW1lbnRlZC5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MDkgwrcgQWNjZXNzIHRvIHRoZSB2ZWhpY2xlPC9oMz48cD5BY2Nlc3MgdG8gdGhlIHZlaGljbGUgaXMgZG9jdW1lbnRlZC48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMTBcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0xMC00OWJjMDkzMDM2MzQud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTEwLWE3NjE4NzMyNWIxMS53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0xMC1jM2IxNGVhNDllMWQud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJUcmFuc3BvcnQgY3VzdG9keS4gVGhlIG1hbiBpcyBlc2NvcnRlZCB0byBhIEdlcm1hbiBwb2xpY2UgdHJhbnNwb3J0IHZhbi5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MTAgwrcgVHJhbnNwb3J0IGN1c3RvZHk8L2gzPjxwPlRoZSBtYW4gaXMgZXNjb3J0ZWQgdG8gYSBHZXJtYW4gcG9saWNlIHRyYW5zcG9ydCB2YW4uPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjExXCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMTEtYjY3ZmM2YTNmNWNlLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0xMS1lZjcxMDYyNGEwMmYud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMTEtMjBhOTA3NmJlYmYwLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiVHJhbnNmZXIgYXQgdGhlIHZhbi4gVGhlIGhhbmRvdmVyIGF0IHRoZSB0cmFuc3BvcnQgdmVoaWNsZSBpcyBzaG93bi5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MTEgwrcgVHJhbnNmZXIgYXQgdGhlIHZhbjwvaDM+PHA+VGhlIGhhbmRvdmVyIGF0IHRoZSB0cmFuc3BvcnQgdmVoaWNsZSBpcyBzaG93bi48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMTJcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0xMi03OGUwZTUwZmQ2NmEud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTEyLTM0MjAwODBjMzk5OS53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0xMi1jOGQ0YWEzMjFkNzMud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJWYW4gc2VjdXJlZC4gVGhlIHRyYW5zcG9ydCB2YW4gaXMgcmVhZHkuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjEyIMK3IFZhbiBzZWN1cmVkPC9oMz48cD5UaGUgdHJhbnNwb3J0IHZhbiBpcyByZWFkeS48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMTNcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0xMy04MGU2NDYzNGFhOTkud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTEzLWZhNTM2NjMzZTM4Yy53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0xMy04OTQ4MzQzNTc4OWIud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJKb3VybmV5IHRvIHRoZSBzdGF0aW9uLiBUaGUgcm9hZHNpZGUgdHJhbnNwb3J0IHNlcXVlbmNlIGNvbmNsdWRlcy5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MTMgwrcgSm91cm5leSB0byB0aGUgc3RhdGlvbjwvaDM+PHA+VGhlIHJvYWRzaWRlIHRyYW5zcG9ydCBzZXF1ZW5jZSBjb25jbHVkZXMuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjE0XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMTQtMDE5NDFhZDgzZTg2LndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0xNC02ODhhYjIwOTVkZmUud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMTQtNmUwY2IyZmJlNGNmLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiRXNjb3J0IHRvIHRoZSB0cmFuc3BvcnQgdmFuLiBUd28gb2ZmaWNlcnMgZXNjb3J0IHRoZSBhcnJlc3RlZCBtYW4gdG8gdGhlIEdlcm1hbiBwb2xpY2UgdHJhbnNwb3J0IHZhbi5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MTQgwrcgRXNjb3J0IHRvIHRoZSB0cmFuc3BvcnQgdmFuPC9oMz48cD5Ud28gb2ZmaWNlcnMgZXNjb3J0IHRoZSBhcnJlc3RlZCBtYW4gdG8gdGhlIEdlcm1hbiBwb2xpY2UgdHJhbnNwb3J0IHZhbi48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMTVcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0xNS1jZjIxZWUzODUyMmUud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTE1LWRhOTYzZTcwMDRiYy53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0xNS03OGY1YzA4OGU3MDgud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJTZXBhcmF0ZSBleGFtaW5hdGlvbiBzY2VuZS4gQSBzZXBhcmF0ZSBmaWN0aW9uYWwgZXhhbWluYXRpb24gYW5kIGRvY3VtZW50YXRpb24gc2NlbmUsIHByZXNlbnRlZCBhcyBhIGxhdGVyIHNjZW5lIGNoYW5nZS5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MTUgwrcgU2VwYXJhdGUgZXhhbWluYXRpb24gc2NlbmU8L2gzPjxwPkEgc2VwYXJhdGUgZmljdGlvbmFsIGV4YW1pbmF0aW9uIGFuZCBkb2N1bWVudGF0aW9uIHNjZW5lLCBwcmVzZW50ZWQgYXMgYSBsYXRlciBzY2VuZSBjaGFuZ2UuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjE2XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMTYtMTI5MGU1YmFiNTJjLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0xNi00NmMxNGIwMzdiYWMud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMTYtMGFjMjc0M2EwYTkyLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiR0VTQSDigJMgTWVkaWNhbCBFeGFtaW5hdGlvbi4gQXQgdGhlIEdFU0EsIGEgZG9jdG9yIGRvY3VtZW50cyB0aGUgbWVkaWNhbCBleGFtaW5hdGlvbi4gQSBjbGVhcmx5IHZpc2libGUgY2hhaW4gY29ubmVjdHMgdGhlIGZyb250IGhhbmRjdWZmcyB0byB0aGUgYW5rbGUgY3VmZnM7IGhpcyB0cmFja3N1aXQgYW5kIHNob2VzIHJlbWFpbiB1bmNoYW5nZWQuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjE2IMK3IEdFU0Eg4oCTIE1lZGljYWwgRXhhbWluYXRpb248L2gzPjxwPkF0IHRoZSBHRVNBLCBhIGRvY3RvciBkb2N1bWVudHMgdGhlIG1lZGljYWwgZXhhbWluYXRpb24uIEEgY2xlYXJseSB2aXNpYmxlIGNoYWluIGNvbm5lY3RzIHRoZSBmcm9udCBoYW5kY3VmZnMgdG8gdGhlIGFua2xlIGN1ZmZzOyBoaXMgdHJhY2tzdWl0IGFuZCBzaG9lcyByZW1haW4gdW5jaGFuZ2VkLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIxN1wiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTE3LTI5MjE1ZWZkNWJkNy53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMTctOTA1NTU5MmE4ODAzLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTE3LTc0Y2IxY2NkZjBmMC53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkludGFrZSBhdCB0aGUgUHJpc29uIEVudHJhbmNlIEFpcmxvY2suIE9mZmljZXJzIGVzY29ydCBoaW0gdGhyb3VnaCB0aGUgZW50cmFuY2UgYWlybG9jayBmb3IgcHJpc29uIGludGFrZS4gVGhlIGJhY2sgY2hhaW4gZnJvbSB0aGUgaGFuZGN1ZmZzIGJlaGluZCBoaW0gdG8gdGhlIHdhaXN0IGJlbHQsIGFzIHdlbGwgYXMgdGhlIGFua2xlLWN1ZmYgbGluaywgYXJlIGNsZWFybHkgdmlzaWJsZS4gVGhlIHZhbiwgdHJhY2tzdWl0IGFuZCB3aGl0ZS1hbmQtYmx1ZSBzaG9lcyByZW1haW4gY29uc2lzdGVudC5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MTcgwrcgSW50YWtlIGF0IHRoZSBQcmlzb24gRW50cmFuY2UgQWlybG9jazwvaDM+PHA+T2ZmaWNlcnMgZXNjb3J0IGhpbSB0aHJvdWdoIHRoZSBlbnRyYW5jZSBhaXJsb2NrIGZvciBwcmlzb24gaW50YWtlLiBUaGUgYmFjayBjaGFpbiBmcm9tIHRoZSBoYW5kY3VmZnMgYmVoaW5kIGhpbSB0byB0aGUgd2Fpc3QgYmVsdCwgYXMgd2VsbCBhcyB0aGUgYW5rbGUtY3VmZiBsaW5rLCBhcmUgY2xlYXJseSB2aXNpYmxlLiBUaGUgdmFuLCB0cmFja3N1aXQgYW5kIHdoaXRlLWFuZC1ibHVlIHNob2VzIHJlbWFpbiBjb25zaXN0ZW50LjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PC9kaXY+PGRpdiBjbGFzcz1cImNvbnRyb2xzXCI+PGJ1dHRvbiBpZD1cInByZXZpb3VzXCIgdHlwZT1cImJ1dHRvblwiPlByZXZpb3VzIGltYWdlPC9idXR0b24+PHNwYW4gaWQ9XCJjYXJvdXNlbENvdW50ZXJcIj4xIC8gMTc8L3NwYW4+PGJ1dHRvbiBpZD1cIm5leHRcIiB0eXBlPVwiYnV0dG9uXCI+TmV4dCBpbWFnZTwvYnV0dG9uPjwvZGl2PjxkaXYgY2xhc3M9XCJjYXJvdXNlbFwiIHRhYmluZGV4PVwiMFwiIGFyaWEtbGFiZWw9XCJBcnJlc3RlZCBEdXJpbmcgYSBUcmFmZmljIFN0b3BcIj48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjFcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0wMS1hZTQzMjU5NGMzZDEud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTAxLTczZDcyMmRlMDc0Yy53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0wMS00MTlhNDM5YmM3ODIud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJJbml0aWFsIHRyYWZmaWMgc3RvcC4gQW4gb2ZmaWNlciBiZWdpbnMgdGhlIGluaXRpYWwgdHJhZmZpYyBjaGVjay5cIiBsb2FkaW5nPVwiZWFnZXJcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjAxIMK3IEluaXRpYWwgdHJhZmZpYyBzdG9wPC9oMz48cD5BbiBvZmZpY2VyIGJlZ2lucyB0aGUgaW5pdGlhbCB0cmFmZmljIGNoZWNrLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIyXCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDItM2FiOTQ2NzY2YzhkLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wMi1lOTQ2Y2M0MDg2NzYud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDItM2FjODQ2YjVlMmYwLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiRGF0YWJhc2UgY2hlY2suIFRoZSBkcml2ZXLigJlzIGRldGFpbHMgYXJlIGNoZWNrZWQgb24gdGhlIG1vYmlsZSB0ZXJtaW5hbC5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MDIgwrcgRGF0YWJhc2UgY2hlY2s8L2gzPjxwPlRoZSBkcml2ZXLigJlzIGRldGFpbHMgYXJlIGNoZWNrZWQgb24gdGhlIG1vYmlsZSB0ZXJtaW5hbC48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiM1wiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTAzLWZlZjkxOTkzZWJiMS53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDMtZTkyOWFjODE0MDRlLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTAzLTAxMTNhMzhiZWM0Ni53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIk91dHN0YW5kaW5nIHdhcnJhbnQuIFRoZSBvZmZpY2VyIGluZm9ybXMgaGltIG9mIHRoZSByZXN1bHQgb2YgdGhlIGNoZWNrLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wMyDCtyBPdXRzdGFuZGluZyB3YXJyYW50PC9oMz48cD5UaGUgb2ZmaWNlciBpbmZvcm1zIGhpbSBvZiB0aGUgcmVzdWx0IG9mIHRoZSBjaGVjay48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiNFwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTA0LTY5NThiZmNlNDk0Yy53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDQtZjcxMDYwZGUzOWJiLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTA0LTUyZTczN2NlMmY3NC53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIlN0b3BwZWQgYmVzaWRlIHRoZSBjYXIuIFRoZSBkcml2ZXIgaXMgYXBwcm9hY2hlZCBiZXNpZGUgdGhlIHNpbHZlciBjYXIuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjA0IMK3IFN0b3BwZWQgYmVzaWRlIHRoZSBjYXI8L2gzPjxwPlRoZSBkcml2ZXIgaXMgYXBwcm9hY2hlZCBiZXNpZGUgdGhlIHNpbHZlciBjYXIuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjVcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0wNS1hMjk0NjI1NjZhZDQud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTA1LWM0NGE2YWVjMjVmZi53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0wNS0zMGI1YTk4NjcwYzcud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJBcnJlc3QgYXQgdGhlIHJvYWRzaWRlLiBUaGUgbWFuIGlzIGFycmVzdGVkIGJlc2lkZSB0aGUgY2FyLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wNSDCtyBBcnJlc3QgYXQgdGhlIHJvYWRzaWRlPC9oMz48cD5UaGUgbWFuIGlzIGFycmVzdGVkIGJlc2lkZSB0aGUgY2FyLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCI2XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDYtYjM5YmVlMDE5NzExLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wNi04N2U4OGEyM2UwMDEud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDYtM2MwODdmYTUxNWMxLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiU2VjdXJpbmcgdGhlIGFycmVzdC4gVGhlIGFycmVzdCBjb250aW51ZXMgYmVzaWRlIHRoZSB2ZWhpY2xlLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wNiDCtyBTZWN1cmluZyB0aGUgYXJyZXN0PC9oMz48cD5UaGUgYXJyZXN0IGNvbnRpbnVlcyBiZXNpZGUgdGhlIHZlaGljbGUuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjdcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0wNy1iYWRmMTRhMzIwMjMud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTA3LWM2ZjBlZjVkMGFkNC53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0wNy1kZmY0YTZiNTc3OGYud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJWZWhpY2xlIGRldGFpbC4gQSBkZXRhaWwgdmlldyBvZiB0aGUgY2FyIGFuZCB0cmFmZmljIHN0b3AuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjA3IMK3IFZlaGljbGUgZGV0YWlsPC9oMz48cD5BIGRldGFpbCB2aWV3IG9mIHRoZSBjYXIgYW5kIHRyYWZmaWMgc3RvcC48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiOFwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTA4LWNjMzQxNTBjYTBlNi53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDgtOGMxYjk1YTQ3NzE2LndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTA4LWQ3OWY3MTJhMGIyZS53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIlByZXBhcmluZyB0cmFuc3BvcnQuIFRoZSBhcnJlc3RlZCBtYW4gaXMgc2VjdXJlZCBmb3IgdHJhbnNwb3J0LlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wOCDCtyBQcmVwYXJpbmcgdHJhbnNwb3J0PC9oMz48cD5UaGUgYXJyZXN0ZWQgbWFuIGlzIHNlY3VyZWQgZm9yIHRyYW5zcG9ydC48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiOVwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTA5LTYzYjFiM2YyZTViMC53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDktZjE4ZmRiOGRlNGMxLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTA5LWVjOTE0N2UzMjJmZS53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkFjY2VzcyB0byB0aGUgdmVoaWNsZS4gQWNjZXNzIHRvIHRoZSB2ZWhpY2xlIGlzIGRvY3VtZW50ZWQuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjA5IMK3IEFjY2VzcyB0byB0aGUgdmVoaWNsZTwvaDM+PHA+QWNjZXNzIHRvIHRoZSB2ZWhpY2xlIGlzIGRvY3VtZW50ZWQuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjEwXCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMTAtNDliYzA5MzAzNjM0LndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0xMC1hNzYxODczMjViMTEud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMTAtYzNiMTRlYTQ5ZTFkLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiVHJhbnNwb3J0IGN1c3RvZHkuIFRoZSBtYW4gaXMgZXNjb3J0ZWQgdG8gYSBHZXJtYW4gcG9saWNlIHRyYW5zcG9ydCB2YW4uXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjEwIMK3IFRyYW5zcG9ydCBjdXN0b2R5PC9oMz48cD5UaGUgbWFuIGlzIGVzY29ydGVkIHRvIGEgR2VybWFuIHBvbGljZSB0cmFuc3BvcnQgdmFuLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIxMVwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTExLWI2N2ZjNmEzZjVjZS53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMTEtZWY3MTA2MjRhMDJmLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTExLTIwYTkwNzZiZWJmMC53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIlRyYW5zZmVyIGF0IHRoZSB2YW4uIFRoZSBoYW5kb3ZlciBhdCB0aGUgdHJhbnNwb3J0IHZlaGljbGUgaXMgc2hvd24uXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjExIMK3IFRyYW5zZmVyIGF0IHRoZSB2YW48L2gzPjxwPlRoZSBoYW5kb3ZlciBhdCB0aGUgdHJhbnNwb3J0IHZlaGljbGUgaXMgc2hvd24uPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjEyXCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMTItNzhlMGU1MGZkNjZhLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0xMi0zNDIwMDgwYzM5OTkud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMTItYzhkNGFhMzIxZDczLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiVmFuIHNlY3VyZWQuIFRoZSB0cmFuc3BvcnQgdmFuIGlzIHJlYWR5LlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4xMiDCtyBWYW4gc2VjdXJlZDwvaDM+PHA+VGhlIHRyYW5zcG9ydCB2YW4gaXMgcmVhZHkuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjEzXCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMTMtODBlNjQ2MzRhYTk5LndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0xMy1mYTUzNjYzM2UzOGMud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMTMtODk0ODM0MzU3ODliLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiSm91cm5leSB0byB0aGUgc3RhdGlvbi4gVGhlIHJvYWRzaWRlIHRyYW5zcG9ydCBzZXF1ZW5jZSBjb25jbHVkZXMuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjEzIMK3IEpvdXJuZXkgdG8gdGhlIHN0YXRpb248L2gzPjxwPlRoZSByb2Fkc2lkZSB0cmFuc3BvcnQgc2VxdWVuY2UgY29uY2x1ZGVzLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIxNFwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTE0LTAxOTQxYWQ4M2U4Ni53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMTQtNjg4YWIyMDk1ZGZlLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTE0LTZlMGNiMmZiZTRjZi53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkVzY29ydCB0byB0aGUgdHJhbnNwb3J0IHZhbi4gVHdvIG9mZmljZXJzIGVzY29ydCB0aGUgYXJyZXN0ZWQgbWFuIHRvIHRoZSBHZXJtYW4gcG9saWNlIHRyYW5zcG9ydCB2YW4uXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjE0IMK3IEVzY29ydCB0byB0aGUgdHJhbnNwb3J0IHZhbjwvaDM+PHA+VHdvIG9mZmljZXJzIGVzY29ydCB0aGUgYXJyZXN0ZWQgbWFuIHRvIHRoZSBHZXJtYW4gcG9saWNlIHRyYW5zcG9ydCB2YW4uPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjE1XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMTUtY2YyMWVlMzg1MjJlLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0xNS1kYTk2M2U3MDA0YmMud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMTUtNzhmNWMwODhlNzA4LndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiU2VwYXJhdGUgZXhhbWluYXRpb24gc2NlbmUuIEEgc2VwYXJhdGUgZmljdGlvbmFsIGV4YW1pbmF0aW9uIGFuZCBkb2N1bWVudGF0aW9uIHNjZW5lLCBwcmVzZW50ZWQgYXMgYSBsYXRlciBzY2VuZSBjaGFuZ2UuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjE1IMK3IFNlcGFyYXRlIGV4YW1pbmF0aW9uIHNjZW5lPC9oMz48cD5BIHNlcGFyYXRlIGZpY3Rpb25hbCBleGFtaW5hdGlvbiBhbmQgZG9jdW1lbnRhdGlvbiBzY2VuZSwgcHJlc2VudGVkIGFzIGEgbGF0ZXIgc2NlbmUgY2hhbmdlLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIxNlwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTE2LTEyOTBlNWJhYjUyYy53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMTYtNDZjMTRiMDM3YmFjLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTE2LTBhYzI3NDNhMGE5Mi53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkdFU0Eg4oCTIE1lZGljYWwgRXhhbWluYXRpb24uIEF0IHRoZSBHRVNBLCBhIGRvY3RvciBkb2N1bWVudHMgdGhlIG1lZGljYWwgZXhhbWluYXRpb24uIEEgY2xlYXJseSB2aXNpYmxlIGNoYWluIGNvbm5lY3RzIHRoZSBmcm9udCBoYW5kY3VmZnMgdG8gdGhlIGFua2xlIGN1ZmZzOyBoaXMgdHJhY2tzdWl0IGFuZCBzaG9lcyByZW1haW4gdW5jaGFuZ2VkLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4xNiDCtyBHRVNBIOKAkyBNZWRpY2FsIEV4YW1pbmF0aW9uPC9oMz48cD5BdCB0aGUgR0VTQSwgYSBkb2N0b3IgZG9jdW1lbnRzIHRoZSBtZWRpY2FsIGV4YW1pbmF0aW9uLiBBIGNsZWFybHkgdmlzaWJsZSBjaGFpbiBjb25uZWN0cyB0aGUgZnJvbnQgaGFuZGN1ZmZzIHRvIHRoZSBhbmtsZSBjdWZmczsgaGlzIHRyYWNrc3VpdCBhbmQgc2hvZXMgcmVtYWluIHVuY2hhbmdlZC48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMTdcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0xNy0yOTIxNWVmZDViZDcud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTE3LTkwNTU1OTJhODgwMy53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0xNy03NGNiMWNjZGYwZjAud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJJbnRha2UgYXQgdGhlIFByaXNvbiBFbnRyYW5jZSBBaXJsb2NrLiBPZmZpY2VycyBlc2NvcnQgaGltIHRocm91Z2ggdGhlIGVudHJhbmNlIGFpcmxvY2sgZm9yIHByaXNvbiBpbnRha2UuIFRoZSBiYWNrIGNoYWluIGZyb20gdGhlIGhhbmRjdWZmcyBiZWhpbmQgaGltIHRvIHRoZSB3YWlzdCBiZWx0LCBhcyB3ZWxsIGFzIHRoZSBhbmtsZS1jdWZmIGxpbmssIGFyZSBjbGVhcmx5IHZpc2libGUuIFRoZSB2YW4sIHRyYWNrc3VpdCBhbmQgd2hpdGUtYW5kLWJsdWUgc2hvZXMgcmVtYWluIGNvbnNpc3RlbnQuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjE3IMK3IEludGFrZSBhdCB0aGUgUHJpc29uIEVudHJhbmNlIEFpcmxvY2s8L2gzPjxwPk9mZmljZXJzIGVzY29ydCBoaW0gdGhyb3VnaCB0aGUgZW50cmFuY2UgYWlybG9jayBmb3IgcHJpc29uIGludGFrZS4gVGhlIGJhY2sgY2hhaW4gZnJvbSB0aGUgaGFuZGN1ZmZzIGJlaGluZCBoaW0gdG8gdGhlIHdhaXN0IGJlbHQsIGFzIHdlbGwgYXMgdGhlIGFua2xlLWN1ZmYgbGluaywgYXJlIGNsZWFybHkgdmlzaWJsZS4gVGhlIHZhbiwgdHJhY2tzdWl0IGFuZCB3aGl0ZS1hbmQtYmx1ZSBzaG9lcyByZW1haW4gY29uc2lzdGVudC48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjwvZGl2Pjwvc2VjdGlvbj48c2VjdGlvbiBjbGFzcz1cInNsaWRlc2hvd1wiPjxoMj5TbGlkZXNob3c8L2gyPjxkaXYgY2xhc3M9XCJjb250cm9sc1wiPjxidXR0b24gaWQ9XCJzbGlkZVByZXZpb3VzXCIgdHlwZT1cImJ1dHRvblwiPlByZXZpb3VzIGltYWdlPC9idXR0b24+PHNwYW4gaWQ9XCJjb3VudGVyXCI+MSAvIDE3PC9zcGFuPjxidXR0b24gaWQ9XCJzbGlkZU5leHRcIiB0eXBlPVwiYnV0dG9uXCI+TmV4dCBpbWFnZTwvYnV0dG9uPjxidXR0b24gaWQ9XCJ0b2dnbGVcIiBkYXRhLXBsYXk9XCLilrZcIiBkYXRhLXBhdXNlPVwi4oWhXCIgYXJpYS1wcmVzc2VkPVwiZmFsc2VcIiB0eXBlPVwiYnV0dG9uXCI+4pa2PC9idXR0b24+PC9kaXY+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIxXCIgZGF0YS1zZWNvbmRzPVwiNlwiIGNsYXNzPVwiYWN0aXZlXCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0wMS1hZTQzMjU5NGMzZDEud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTAxLTczZDcyMmRlMDc0Yy53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0wMS00MTlhNDM5YmM3ODIud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJJbml0aWFsIHRyYWZmaWMgc3RvcC4gQW4gb2ZmaWNlciBiZWdpbnMgdGhlIGluaXRpYWwgdHJhZmZpYyBjaGVjay5cIiBsb2FkaW5nPVwiZWFnZXJcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjAxIMK3IEluaXRpYWwgdHJhZmZpYyBzdG9wPC9oMz48cD5BbiBvZmZpY2VyIGJlZ2lucyB0aGUgaW5pdGlhbCB0cmFmZmljIGNoZWNrLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIyXCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDItM2FiOTQ2NzY2YzhkLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wMi1lOTQ2Y2M0MDg2NzYud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDItM2FjODQ2YjVlMmYwLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiRGF0YWJhc2UgY2hlY2suIFRoZSBkcml2ZXLigJlzIGRldGFpbHMgYXJlIGNoZWNrZWQgb24gdGhlIG1vYmlsZSB0ZXJtaW5hbC5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MDIgwrcgRGF0YWJhc2UgY2hlY2s8L2gzPjxwPlRoZSBkcml2ZXLigJlzIGRldGFpbHMgYXJlIGNoZWNrZWQgb24gdGhlIG1vYmlsZSB0ZXJtaW5hbC48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiM1wiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTAzLWZlZjkxOTkzZWJiMS53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDMtZTkyOWFjODE0MDRlLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTAzLTAxMTNhMzhiZWM0Ni53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIk91dHN0YW5kaW5nIHdhcnJhbnQuIFRoZSBvZmZpY2VyIGluZm9ybXMgaGltIG9mIHRoZSByZXN1bHQgb2YgdGhlIGNoZWNrLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wMyDCtyBPdXRzdGFuZGluZyB3YXJyYW50PC9oMz48cD5UaGUgb2ZmaWNlciBpbmZvcm1zIGhpbSBvZiB0aGUgcmVzdWx0IG9mIHRoZSBjaGVjay48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiNFwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTA0LTY5NThiZmNlNDk0Yy53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDQtZjcxMDYwZGUzOWJiLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTA0LTUyZTczN2NlMmY3NC53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIlN0b3BwZWQgYmVzaWRlIHRoZSBjYXIuIFRoZSBkcml2ZXIgaXMgYXBwcm9hY2hlZCBiZXNpZGUgdGhlIHNpbHZlciBjYXIuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjA0IMK3IFN0b3BwZWQgYmVzaWRlIHRoZSBjYXI8L2gzPjxwPlRoZSBkcml2ZXIgaXMgYXBwcm9hY2hlZCBiZXNpZGUgdGhlIHNpbHZlciBjYXIuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjVcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0wNS1hMjk0NjI1NjZhZDQud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTA1LWM0NGE2YWVjMjVmZi53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0wNS0zMGI1YTk4NjcwYzcud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJBcnJlc3QgYXQgdGhlIHJvYWRzaWRlLiBUaGUgbWFuIGlzIGFycmVzdGVkIGJlc2lkZSB0aGUgY2FyLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wNSDCtyBBcnJlc3QgYXQgdGhlIHJvYWRzaWRlPC9oMz48cD5UaGUgbWFuIGlzIGFycmVzdGVkIGJlc2lkZSB0aGUgY2FyLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCI2XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDYtYjM5YmVlMDE5NzExLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wNi04N2U4OGEyM2UwMDEud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDYtM2MwODdmYTUxNWMxLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiU2VjdXJpbmcgdGhlIGFycmVzdC4gVGhlIGFycmVzdCBjb250aW51ZXMgYmVzaWRlIHRoZSB2ZWhpY2xlLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wNiDCtyBTZWN1cmluZyB0aGUgYXJyZXN0PC9oMz48cD5UaGUgYXJyZXN0IGNvbnRpbnVlcyBiZXNpZGUgdGhlIHZlaGljbGUuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjdcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0wNy1iYWRmMTRhMzIwMjMud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTA3LWM2ZjBlZjVkMGFkNC53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0wNy1kZmY0YTZiNTc3OGYud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJWZWhpY2xlIGRldGFpbC4gQSBkZXRhaWwgdmlldyBvZiB0aGUgY2FyIGFuZCB0cmFmZmljIHN0b3AuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjA3IMK3IFZlaGljbGUgZGV0YWlsPC9oMz48cD5BIGRldGFpbCB2aWV3IG9mIHRoZSBjYXIgYW5kIHRyYWZmaWMgc3RvcC48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiOFwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTA4LWNjMzQxNTBjYTBlNi53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDgtOGMxYjk1YTQ3NzE2LndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTA4LWQ3OWY3MTJhMGIyZS53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIlByZXBhcmluZyB0cmFuc3BvcnQuIFRoZSBhcnJlc3RlZCBtYW4gaXMgc2VjdXJlZCBmb3IgdHJhbnNwb3J0LlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wOCDCtyBQcmVwYXJpbmcgdHJhbnNwb3J0PC9oMz48cD5UaGUgYXJyZXN0ZWQgbWFuIGlzIHNlY3VyZWQgZm9yIHRyYW5zcG9ydC48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiOVwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTA5LTYzYjFiM2YyZTViMC53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDktZjE4ZmRiOGRlNGMxLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTA5LWVjOTE0N2UzMjJmZS53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkFjY2VzcyB0byB0aGUgdmVoaWNsZS4gQWNjZXNzIHRvIHRoZSB2ZWhpY2xlIGlzIGRvY3VtZW50ZWQuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjA5IMK3IEFjY2VzcyB0byB0aGUgdmVoaWNsZTwvaDM+PHA+QWNjZXNzIHRvIHRoZSB2ZWhpY2xlIGlzIGRvY3VtZW50ZWQuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjEwXCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMTAtNDliYzA5MzAzNjM0LndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0xMC1hNzYxODczMjViMTEud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMTAtYzNiMTRlYTQ5ZTFkLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiVHJhbnNwb3J0IGN1c3RvZHkuIFRoZSBtYW4gaXMgZXNjb3J0ZWQgdG8gYSBHZXJtYW4gcG9saWNlIHRyYW5zcG9ydCB2YW4uXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjEwIMK3IFRyYW5zcG9ydCBjdXN0b2R5PC9oMz48cD5UaGUgbWFuIGlzIGVzY29ydGVkIHRvIGEgR2VybWFuIHBvbGljZSB0cmFuc3BvcnQgdmFuLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIxMVwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTExLWI2N2ZjNmEzZjVjZS53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMTEtZWY3MTA2MjRhMDJmLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTExLTIwYTkwNzZiZWJmMC53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIlRyYW5zZmVyIGF0IHRoZSB2YW4uIFRoZSBoYW5kb3ZlciBhdCB0aGUgdHJhbnNwb3J0IHZlaGljbGUgaXMgc2hvd24uXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjExIMK3IFRyYW5zZmVyIGF0IHRoZSB2YW48L2gzPjxwPlRoZSBoYW5kb3ZlciBhdCB0aGUgdHJhbnNwb3J0IHZlaGljbGUgaXMgc2hvd24uPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjEyXCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMTItNzhlMGU1MGZkNjZhLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0xMi0zNDIwMDgwYzM5OTkud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMTItYzhkNGFhMzIxZDczLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiVmFuIHNlY3VyZWQuIFRoZSB0cmFuc3BvcnQgdmFuIGlzIHJlYWR5LlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4xMiDCtyBWYW4gc2VjdXJlZDwvaDM+PHA+VGhlIHRyYW5zcG9ydCB2YW4gaXMgcmVhZHkuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjEzXCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMTMtODBlNjQ2MzRhYTk5LndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0xMy1mYTUzNjYzM2UzOGMud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMTMtODk0ODM0MzU3ODliLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiSm91cm5leSB0byB0aGUgc3RhdGlvbi4gVGhlIHJvYWRzaWRlIHRyYW5zcG9ydCBzZXF1ZW5jZSBjb25jbHVkZXMuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjEzIMK3IEpvdXJuZXkgdG8gdGhlIHN0YXRpb248L2gzPjxwPlRoZSByb2Fkc2lkZSB0cmFuc3BvcnQgc2VxdWVuY2UgY29uY2x1ZGVzLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIxNFwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTE0LTAxOTQxYWQ4M2U4Ni53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMTQtNjg4YWIyMDk1ZGZlLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTE0LTZlMGNiMmZiZTRjZi53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkVzY29ydCB0byB0aGUgdHJhbnNwb3J0IHZhbi4gVHdvIG9mZmljZXJzIGVzY29ydCB0aGUgYXJyZXN0ZWQgbWFuIHRvIHRoZSBHZXJtYW4gcG9saWNlIHRyYW5zcG9ydCB2YW4uXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjE0IMK3IEVzY29ydCB0byB0aGUgdHJhbnNwb3J0IHZhbjwvaDM+PHA+VHdvIG9mZmljZXJzIGVzY29ydCB0aGUgYXJyZXN0ZWQgbWFuIHRvIHRoZSBHZXJtYW4gcG9saWNlIHRyYW5zcG9ydCB2YW4uPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjE1XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMTUtY2YyMWVlMzg1MjJlLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0xNS1kYTk2M2U3MDA0YmMud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMTUtNzhmNWMwODhlNzA4LndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiU2VwYXJhdGUgZXhhbWluYXRpb24gc2NlbmUuIEEgc2VwYXJhdGUgZmljdGlvbmFsIGV4YW1pbmF0aW9uIGFuZCBkb2N1bWVudGF0aW9uIHNjZW5lLCBwcmVzZW50ZWQgYXMgYSBsYXRlciBzY2VuZSBjaGFuZ2UuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjE1IMK3IFNlcGFyYXRlIGV4YW1pbmF0aW9uIHNjZW5lPC9oMz48cD5BIHNlcGFyYXRlIGZpY3Rpb25hbCBleGFtaW5hdGlvbiBhbmQgZG9jdW1lbnRhdGlvbiBzY2VuZSwgcHJlc2VudGVkIGFzIGEgbGF0ZXIgc2NlbmUgY2hhbmdlLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIxNlwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTE2LTEyOTBlNWJhYjUyYy53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMTYtNDZjMTRiMDM3YmFjLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTE2LTBhYzI3NDNhMGE5Mi53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkdFU0Eg4oCTIE1lZGljYWwgRXhhbWluYXRpb24uIEF0IHRoZSBHRVNBLCBhIGRvY3RvciBkb2N1bWVudHMgdGhlIG1lZGljYWwgZXhhbWluYXRpb24uIEEgY2xlYXJseSB2aXNpYmxlIGNoYWluIGNvbm5lY3RzIHRoZSBmcm9udCBoYW5kY3VmZnMgdG8gdGhlIGFua2xlIGN1ZmZzOyBoaXMgdHJhY2tzdWl0IGFuZCBzaG9lcyByZW1haW4gdW5jaGFuZ2VkLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4xNiDCtyBHRVNBIOKAkyBNZWRpY2FsIEV4YW1pbmF0aW9uPC9oMz48cD5BdCB0aGUgR0VTQSwgYSBkb2N0b3IgZG9jdW1lbnRzIHRoZSBtZWRpY2FsIGV4YW1pbmF0aW9uLiBBIGNsZWFybHkgdmlzaWJsZSBjaGFpbiBjb25uZWN0cyB0aGUgZnJvbnQgaGFuZGN1ZmZzIHRvIHRoZSBhbmtsZSBjdWZmczsgaGlzIHRyYWNrc3VpdCBhbmQgc2hvZXMgcmVtYWluIHVuY2hhbmdlZC48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMTdcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0xNy0yOTIxNWVmZDViZDcud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTE3LTkwNTU1OTJhODgwMy53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0xNy03NGNiMWNjZGYwZjAud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJJbnRha2UgYXQgdGhlIFByaXNvbiBFbnRyYW5jZSBBaXJsb2NrLiBPZmZpY2VycyBlc2NvcnQgaGltIHRocm91Z2ggdGhlIGVudHJhbmNlIGFpcmxvY2sgZm9yIHByaXNvbiBpbnRha2UuIFRoZSBiYWNrIGNoYWluIGZyb20gdGhlIGhhbmRjdWZmcyBiZWhpbmQgaGltIHRvIHRoZSB3YWlzdCBiZWx0LCBhcyB3ZWxsIGFzIHRoZSBhbmtsZS1jdWZmIGxpbmssIGFyZSBjbGVhcmx5IHZpc2libGUuIFRoZSB2YW4sIHRyYWNrc3VpdCBhbmQgd2hpdGUtYW5kLWJsdWUgc2hvZXMgcmVtYWluIGNvbnNpc3RlbnQuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjE3IMK3IEludGFrZSBhdCB0aGUgUHJpc29uIEVudHJhbmNlIEFpcmxvY2s8L2gzPjxwPk9mZmljZXJzIGVzY29ydCBoaW0gdGhyb3VnaCB0aGUgZW50cmFuY2UgYWlybG9jayBmb3IgcHJpc29uIGludGFrZS4gVGhlIGJhY2sgY2hhaW4gZnJvbSB0aGUgaGFuZGN1ZmZzIGJlaGluZCBoaW0gdG8gdGhlIHdhaXN0IGJlbHQsIGFzIHdlbGwgYXMgdGhlIGFua2xlLWN1ZmYgbGluaywgYXJlIGNsZWFybHkgdmlzaWJsZS4gVGhlIHZhbiwgdHJhY2tzdWl0IGFuZCB3aGl0ZS1hbmQtYmx1ZSBzaG9lcyByZW1haW4gY29uc2lzdGVudC48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjwvc2VjdGlvbj48c2VjdGlvbiBpZD1cInZpZGVvXCI+PGgyPlNpbGVudCBwaWN0dXJlIHNsaWRlc2hvdzwvaDI+PHZpZGVvIGNvbnRyb2xzIHBsYXlzaW5saW5lIHByZWxvYWQ9XCJtZXRhZGF0YVwiPjxzb3VyY2Ugc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RyYWZmaWMtc3RvcC1zaWxlbnQtMTZ4OS0yNzdhMjgyM2E4MTYubXA0XCIgdHlwZT1cInZpZGVvL21wNFwiPjx0cmFjayBraW5kPVwic3VidGl0bGVzXCIgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2NhcHRpb25zLWRlLTliMTZhMzIzYWI5Yy52dHRcIiBzcmNsYW5nPVwiZGVcIiBsYWJlbD1cIkRldXRzY2hcIj48dHJhY2sga2luZD1cInN1YnRpdGxlc1wiIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9jYXB0aW9ucy1lbi05MmZlOTI1YjM1ZWIudnR0XCIgc3JjbGFuZz1cImVuXCIgbGFiZWw9XCJFbmdsaXNoXCIgZGVmYXVsdD48dHJhY2sga2luZD1cInN1YnRpdGxlc1wiIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9jYXB0aW9ucy1lcy1lZWE0Y2IyMGRhMGYudnR0XCIgc3JjbGFuZz1cImVzXCIgbGFiZWw9XCJFc3Bhw7FvbFwiPjx0cmFjayBraW5kPVwic3VidGl0bGVzXCIgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2NhcHRpb25zLWZyLWYzMjAwOGFjYWNlNS52dHRcIiBzcmNsYW5nPVwiZnJcIiBsYWJlbD1cIkZyYW7Dp2Fpc1wiPjwvdmlkZW8+PHA+Tm8gbmFycmF0aW9uIGNyZWF0ZWQuPC9wPjwvc2VjdGlvbj48L2Rpdj4iLCJjb250ZW50X3NoYTI1NiI6ImJkYmJlYTk4YjYwM2EwMWYyNzE4NDM5MDlhMWU2ZjRhOTlhYWFhMTc4ZjMyMDMxMGY1OTZhYjM4MjU5MmExYTAiLCJwYW5lbF9jb3VudCI6MTcsImNoYXB0ZXJfY291bnQiOjE3LCJzdG9yeV93b3JkcyI6MTE5LCJhdWRpb19tb2RlIjoidGV4dF9vbmx5IiwibmFycmF0aW9uX2xhbmd1YWdlIjpudWxsLCJ2aWRlb19zaGEyNTYiOiIyNzdhMjgyM2E4MTY0NjA0ZmQyNGIwZGIxNzQ1MWE1Y2U3MDAxMTUwYTNiN2Y0MGU1ZWMwNjcwOTkxODYyNDIwIn0sImVzIjp7InRpdGxlIjoiRGV0ZW5pZG8gZHVyYW50ZSB1biBjb250cm9sIGRlIHRyw6FmaWNvIiwiY29udGVudCI6IjxkaXYgY2xhc3M9XCJkdHUtcmV2aWV3LXN0b3J5IGR0dS1hcHByb3ZlZDE2eDlcIj48bmF2IGFyaWEtbGFiZWw9XCJMYW5ndWFnZXNcIj48YSBocmVmPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vZGUvYmlsZHNlcmllbi9hdXMtZGVtLWF1dG8tdmVyaGFmdGV0LWJlaS12ZXJrZWhyc2tvbnRyb2xsZS9cIj5EZXV0c2NoPC9hPjxhIGhyZWY9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS9lbl91cy9iaWxkc2VyaWVuL2F1cy1kZW0tYXV0by12ZXJoYWZ0ZXQtYmVpLXZlcmtlaHJza29udHJvbGxlL1wiPkVuZ2xpc2g8L2E+PGEgaHJlZj1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL2VzL2JpbGRzZXJpZW4vYXVzLWRlbS1hdXRvLXZlcmhhZnRldC1iZWktdmVya2VocnNrb250cm9sbGUvXCIgYXJpYS1jdXJyZW50PVwicGFnZVwiPkVzcGHDsW9sPC9hPjxhIGhyZWY9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS9mci9iaWxkc2VyaWVuL2F1cy1kZW0tYXV0by12ZXJoYWZ0ZXQtYmVpLXZlcmtlaHJza29udHJvbGxlL1wiPkZyYW7Dp2FpczwvYT48L25hdj48aDE+RGV0ZW5pZG8gZHVyYW50ZSB1biBjb250cm9sIGRlIHRyw6FmaWNvPC9oMT48YXNpZGUgY2xhc3M9XCJub3RpY2VcIj5IaXN0b3JpYSB2aXN1YWwgZmljdGljaWEgeSBlc2NlbmlmaWNhZGEuIE5vIG11ZXN0cmEgdW5hIGRldGVuY2nDs24gcmVhbCBuaSBkb2N1bWVudGFjacOzbiBvZmljaWFsLjwvYXNpZGU+PHNlY3Rpb24gaWQ9XCJuYXJyYXRpdmVcIj48aDI+TGEgaGlzdG9yaWE8L2gyPjxwPkFsIGFub2NoZWNlciwgbGEgcG9saWPDrWEgZGV0aWVuZSBhIHVuIGpvdmVuIGNvbmR1Y3RvciBlbiB1bmEgY2FycmV0ZXJhIHJ1cmFsLiBMb3MgYWdlbnRlcyBjb21wcnVlYmFuIHN1IGlkZW50aWRhZCB5IGxvcyBkYXRvcyBkZWwgdmVow61jdWxvIGVuIHVuIHRlcm1pbmFsIG3Ds3ZpbC4gTGEgY29uc3VsdGEgbXVlc3RyYSB1bmEgb3JkZW4gZGUgZGV0ZW5jacOzbiBwZW5kaWVudGUuIFVuIGFnZW50ZSBsZSBleHBsaWNhIGVsIG1vdGl2byBkZSBsYSBpbnRlcnZlbmNpw7NuIHkgbG8gZGV0aWVuZSBqdW50byBhbCBjb2NoZS48L3A+PHA+RGVzcHXDqXMsIGxvIGFjb21wYcOxYW4gaGFzdGEgdW5hIGZ1cmdvbmV0YSB5IGxvIHRyYXNsYWRhbiBhIGRlcGVuZGVuY2lhcyBwb2xpY2lhbGVzLiBFbiBsYSBHRVNBLCB1bmEgbcOpZGljYSBkb2N1bWVudGEgZWwgZXhhbWVuIG3DqWRpY28uIEVsIGhvbWJyZSBwZXJtYW5lY2UgdmVzdGlkbyB5IGxsZXZhIGxhcyBtYW5vcyBlc3Bvc2FkYXMgZGVsYW50ZSB5IGdyaWxsZXRlcyB1bmlkb3MgcG9yIHVuYSBjYWRlbmEgZW4gbG9zIHRvYmlsbG9zLiBMdWVnbyBsbyB0cmFzbGFkYW4gYWwgY2VudHJvIHBlbml0ZW5jaWFyaW8uIExhIGhpc3RvcmlhIHRlcm1pbmEgZW4gbGEgZXNjbHVzYSBkZSBlbnRyYWRhIHNlw7FhbGl6YWRhLCBkb25kZSBsb3MgYWdlbnRlcyBsbyBhY29tcGHDsWFuIHBhcmEgc3UgaW5ncmVzbyBjb24gZXNwb3NhcywgZ3JpbGxldGVzIHkgdW5hIGNhZGVuYSBkZSBzdWplY2nDs24gcG9zdGVyaW9yLjwvcD48L3NlY3Rpb24+PHNlY3Rpb24gaWQ9XCJzdG9yeVwiPjxoMj5Ub2RhcyBsYXMgZXNjZW5hczwvaDI+PGRpdiBjbGFzcz1cImdhbGxlcnlcIj48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjFcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0wMS1hZTQzMjU5NGMzZDEud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTAxLTczZDcyMmRlMDc0Yy53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0wMS00MTlhNDM5YmM3ODIud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJDb250cm9sIGluaWNpYWwuIFVuIGFnZW50ZSBpbmljaWEgZWwgY29udHJvbCBkZSB0csOhZmljby5cIiBsb2FkaW5nPVwiZWFnZXJcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjAxIMK3IENvbnRyb2wgaW5pY2lhbDwvaDM+PHA+VW4gYWdlbnRlIGluaWNpYSBlbCBjb250cm9sIGRlIHRyw6FmaWNvLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIyXCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDItM2FiOTQ2NzY2YzhkLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wMi1lOTQ2Y2M0MDg2NzYud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDItM2FjODQ2YjVlMmYwLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiQ29uc3VsdGEgZGUgZGF0b3MuIExvcyBkYXRvcyBkZWwgY29uZHVjdG9yIHNlIGNvbXBydWViYW4gZW4gZWwgdGVybWluYWwgbcOzdmlsLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wMiDCtyBDb25zdWx0YSBkZSBkYXRvczwvaDM+PHA+TG9zIGRhdG9zIGRlbCBjb25kdWN0b3Igc2UgY29tcHJ1ZWJhbiBlbiBlbCB0ZXJtaW5hbCBtw7N2aWwuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjNcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0wMy1mZWY5MTk5M2ViYjEud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTAzLWU5MjlhYzgxNDA0ZS53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0wMy0wMTEzYTM4YmVjNDYud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJPcmRlbiBkZSBkZXRlbmNpw7NuIHBlbmRpZW50ZS4gRWwgYWdlbnRlIGxlIGNvbXVuaWNhIGVsIHJlc3VsdGFkbyBkZSBsYSBjb25zdWx0YS5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MDMgwrcgT3JkZW4gZGUgZGV0ZW5jacOzbiBwZW5kaWVudGU8L2gzPjxwPkVsIGFnZW50ZSBsZSBjb211bmljYSBlbCByZXN1bHRhZG8gZGUgbGEgY29uc3VsdGEuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjRcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0wNC02OTU4YmZjZTQ5NGMud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTA0LWY3MTA2MGRlMzliYi53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0wNC01MmU3MzdjZTJmNzQud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJKdW50byBhbCB2ZWjDrWN1bG8uIEVsIGNvbmR1Y3RvciBlcyBpbnRlcmNlcHRhZG8ganVudG8gYWwgY29jaGUgcGxhdGVhZG8uXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjA0IMK3IEp1bnRvIGFsIHZlaMOtY3VsbzwvaDM+PHA+RWwgY29uZHVjdG9yIGVzIGludGVyY2VwdGFkbyBqdW50byBhbCBjb2NoZSBwbGF0ZWFkby48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiNVwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTA1LWEyOTQ2MjU2NmFkNC53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDUtYzQ0YTZhZWMyNWZmLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTA1LTMwYjVhOTg2NzBjNy53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkRldGVuY2nDs24gZW4gbGEgY2FycmV0ZXJhLiBFbCBob21icmUgZXMgZGV0ZW5pZG8ganVudG8gYWwgdmVow61jdWxvLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wNSDCtyBEZXRlbmNpw7NuIGVuIGxhIGNhcnJldGVyYTwvaDM+PHA+RWwgaG9tYnJlIGVzIGRldGVuaWRvIGp1bnRvIGFsIHZlaMOtY3Vsby48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiNlwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTA2LWIzOWJlZTAxOTcxMS53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDYtODdlODhhMjNlMDAxLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTA2LTNjMDg3ZmE1MTVjMS53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkFzZWd1cmFtaWVudG8gZGUgbGEgZGV0ZW5jacOzbi4gTGEgZGV0ZW5jacOzbiBjb250aW7DumEganVudG8gYWwgY29jaGUuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjA2IMK3IEFzZWd1cmFtaWVudG8gZGUgbGEgZGV0ZW5jacOzbjwvaDM+PHA+TGEgZGV0ZW5jacOzbiBjb250aW7DumEganVudG8gYWwgY29jaGUuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjdcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0wNy1iYWRmMTRhMzIwMjMud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTA3LWM2ZjBlZjVkMGFkNC53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0wNy1kZmY0YTZiNTc3OGYud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJEZXRhbGxlIGRlbCB2ZWjDrWN1bG8uIERldGFsbGUgZGVsIHZlaMOtY3VsbyB5IGRlbCBjb250cm9sLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wNyDCtyBEZXRhbGxlIGRlbCB2ZWjDrWN1bG88L2gzPjxwPkRldGFsbGUgZGVsIHZlaMOtY3VsbyB5IGRlbCBjb250cm9sLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCI4XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDgtY2MzNDE1MGNhMGU2LndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wOC04YzFiOTVhNDc3MTYud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDgtZDc5ZjcxMmEwYjJlLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiUHJlcGFyYXRpdm9zIHBhcmEgZWwgdHJhc2xhZG8uIEVsIGRldGVuaWRvIHF1ZWRhIGFzZWd1cmFkbyBwYXJhIGVsIHRyYXNsYWRvLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wOCDCtyBQcmVwYXJhdGl2b3MgcGFyYSBlbCB0cmFzbGFkbzwvaDM+PHA+RWwgZGV0ZW5pZG8gcXVlZGEgYXNlZ3VyYWRvIHBhcmEgZWwgdHJhc2xhZG8uPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjlcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0wOS02M2IxYjNmMmU1YjAud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTA5LWYxOGZkYjhkZTRjMS53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0wOS1lYzkxNDdlMzIyZmUud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJBY2Nlc28gYWwgdmVow61jdWxvLiBTZSBkb2N1bWVudGEgZWwgYWNjZXNvIGFsIHZlaMOtY3Vsby5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MDkgwrcgQWNjZXNvIGFsIHZlaMOtY3VsbzwvaDM+PHA+U2UgZG9jdW1lbnRhIGVsIGFjY2VzbyBhbCB2ZWjDrWN1bG8uPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjEwXCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMTAtNDliYzA5MzAzNjM0LndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0xMC1hNzYxODczMjViMTEud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMTAtYzNiMTRlYTQ5ZTFkLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiVHJhc2xhZG8gYmFqbyBjdXN0b2RpYS4gRWwgaG9tYnJlIGVzIGFjb21wYcOxYWRvIGhhc3RhIHVuYSBmdXJnb25ldGEgcG9saWNpYWwgYWxlbWFuYS5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MTAgwrcgVHJhc2xhZG8gYmFqbyBjdXN0b2RpYTwvaDM+PHA+RWwgaG9tYnJlIGVzIGFjb21wYcOxYWRvIGhhc3RhIHVuYSBmdXJnb25ldGEgcG9saWNpYWwgYWxlbWFuYS48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMTFcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0xMS1iNjdmYzZhM2Y1Y2Uud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTExLWVmNzEwNjI0YTAyZi53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0xMS0yMGE5MDc2YmViZjAud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJFbnRyZWdhIGp1bnRvIGEgbGEgZnVyZ29uZXRhLiBTZSBtdWVzdHJhIGxhIGVudHJlZ2EgZW4gZWwgdmVow61jdWxvIGRlIHRyYW5zcG9ydGUuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjExIMK3IEVudHJlZ2EganVudG8gYSBsYSBmdXJnb25ldGE8L2gzPjxwPlNlIG11ZXN0cmEgbGEgZW50cmVnYSBlbiBlbCB2ZWjDrWN1bG8gZGUgdHJhbnNwb3J0ZS48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMTJcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0xMi03OGUwZTUwZmQ2NmEud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTEyLTM0MjAwODBjMzk5OS53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0xMi1jOGQ0YWEzMjFkNzMud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJGdXJnb25ldGEgcHJlcGFyYWRhLiBMYSBmdXJnb25ldGEgZGUgdHJhbnNwb3J0ZSBlc3TDoSBwcmVwYXJhZGEuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjEyIMK3IEZ1cmdvbmV0YSBwcmVwYXJhZGE8L2gzPjxwPkxhIGZ1cmdvbmV0YSBkZSB0cmFuc3BvcnRlIGVzdMOhIHByZXBhcmFkYS48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMTNcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0xMy04MGU2NDYzNGFhOTkud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTEzLWZhNTM2NjMzZTM4Yy53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0xMy04OTQ4MzQzNTc4OWIud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJUcmF5ZWN0byBhIGRlcGVuZGVuY2lhcyBwb2xpY2lhbGVzLiBDb25jbHV5ZSBsYSBzZWN1ZW5jaWEgZGVsIHRyYXNsYWRvIGRlc2RlIGxhIGNhcnJldGVyYS5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MTMgwrcgVHJheWVjdG8gYSBkZXBlbmRlbmNpYXMgcG9saWNpYWxlczwvaDM+PHA+Q29uY2x1eWUgbGEgc2VjdWVuY2lhIGRlbCB0cmFzbGFkbyBkZXNkZSBsYSBjYXJyZXRlcmEuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjE0XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMTQtMDE5NDFhZDgzZTg2LndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0xNC02ODhhYjIwOTVkZmUud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMTQtNmUwY2IyZmJlNGNmLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiQWNvbXBhw7FhbWllbnRvIGEgbGEgZnVyZ29uZXRhLiBEb3MgYWdlbnRlcyBhY29tcGHDsWFuIGFsIGRldGVuaWRvIGhhc3RhIGxhIGZ1cmdvbmV0YSBwb2xpY2lhbCBhbGVtYW5hLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4xNCDCtyBBY29tcGHDsWFtaWVudG8gYSBsYSBmdXJnb25ldGE8L2gzPjxwPkRvcyBhZ2VudGVzIGFjb21wYcOxYW4gYWwgZGV0ZW5pZG8gaGFzdGEgbGEgZnVyZ29uZXRhIHBvbGljaWFsIGFsZW1hbmEuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjE1XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMTUtY2YyMWVlMzg1MjJlLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0xNS1kYTk2M2U3MDA0YmMud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMTUtNzhmNWMwODhlNzA4LndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiRXNjZW5hIGRlIGV4YW1lbiBzZXBhcmFkYS4gRXNjZW5hIGZpY3RpY2lhIHkgc2VwYXJhZGEgZGUgZXhhbWVuIHkgZG9jdW1lbnRhY2nDs24sIHByZXNlbnRhZGEgY29tbyB1biBjYW1iaW8gZGUgZXNjZW5hIHBvc3Rlcmlvci5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MTUgwrcgRXNjZW5hIGRlIGV4YW1lbiBzZXBhcmFkYTwvaDM+PHA+RXNjZW5hIGZpY3RpY2lhIHkgc2VwYXJhZGEgZGUgZXhhbWVuIHkgZG9jdW1lbnRhY2nDs24sIHByZXNlbnRhZGEgY29tbyB1biBjYW1iaW8gZGUgZXNjZW5hIHBvc3Rlcmlvci48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMTZcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0xNi0xMjkwZTViYWI1MmMud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTE2LTQ2YzE0YjAzN2JhYy53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0xNi0wYWMyNzQzYTBhOTIud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJHRVNBIOKAkyBSZXZpc2nDs24gbcOpZGljYS4gRW4gbGEgR0VTQSwgdW5hIG3DqWRpY2EgZG9jdW1lbnRhIGVsIGV4YW1lbiBtw6lkaWNvLiBVbmEgY2FkZW5hIGNsYXJhbWVudGUgdmlzaWJsZSB1bmUgbGFzIGVzcG9zYXMgZGVsYW50ZXJhcyBjb24gbG9zIGdyaWxsZXRlcyBkZSBsb3MgdG9iaWxsb3M7IGVsIGNow6FuZGFsIHkgZWwgY2FsemFkbyBubyBjYW1iaWFuLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4xNiDCtyBHRVNBIOKAkyBSZXZpc2nDs24gbcOpZGljYTwvaDM+PHA+RW4gbGEgR0VTQSwgdW5hIG3DqWRpY2EgZG9jdW1lbnRhIGVsIGV4YW1lbiBtw6lkaWNvLiBVbmEgY2FkZW5hIGNsYXJhbWVudGUgdmlzaWJsZSB1bmUgbGFzIGVzcG9zYXMgZGVsYW50ZXJhcyBjb24gbG9zIGdyaWxsZXRlcyBkZSBsb3MgdG9iaWxsb3M7IGVsIGNow6FuZGFsIHkgZWwgY2FsemFkbyBubyBjYW1iaWFuLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIxN1wiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTE3LTI5MjE1ZWZkNWJkNy53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMTctOTA1NTU5MmE4ODAzLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTE3LTc0Y2IxY2NkZjBmMC53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkluZ3Jlc28gcG9yIGxhIGVzY2x1c2EgZGUgZW50cmFkYSBkZSBsYSBwcmlzacOzbi4gTG9zIGFnZW50ZXMgbG8gYWNvbXBhw7FhbiBwb3IgbGEgZXNjbHVzYSBkZSBlbnRyYWRhIHBhcmEgc3UgaW5ncmVzby4gU2UgdmVuIGNsYXJhbWVudGUgbGEgY2FkZW5hIHBvc3RlcmlvciBkZXNkZSBsYXMgZXNwb3NhcywgY29sb2NhZGFzIGRldHLDoXMgZGVsIGN1ZXJwbywgaGFzdGEgZWwgY2ludHVyw7NuLCB5IGxhIHVuacOzbiBlbnRyZSBsb3MgZ3JpbGxldGVzIGRlIGxvcyB0b2JpbGxvcy4gTGEgZnVyZ29uZXRhLCBlbCBjaMOhbmRhbCB5IGxhcyB6YXBhdGlsbGFzIGJsYW5jYXMgeSBhenVsZXMgbWFudGllbmVuIGxhIGNvbnRpbnVpZGFkLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4xNyDCtyBJbmdyZXNvIHBvciBsYSBlc2NsdXNhIGRlIGVudHJhZGEgZGUgbGEgcHJpc2nDs248L2gzPjxwPkxvcyBhZ2VudGVzIGxvIGFjb21wYcOxYW4gcG9yIGxhIGVzY2x1c2EgZGUgZW50cmFkYSBwYXJhIHN1IGluZ3Jlc28uIFNlIHZlbiBjbGFyYW1lbnRlIGxhIGNhZGVuYSBwb3N0ZXJpb3IgZGVzZGUgbGFzIGVzcG9zYXMsIGNvbG9jYWRhcyBkZXRyw6FzIGRlbCBjdWVycG8sIGhhc3RhIGVsIGNpbnR1csOzbiwgeSBsYSB1bmnDs24gZW50cmUgbG9zIGdyaWxsZXRlcyBkZSBsb3MgdG9iaWxsb3MuIExhIGZ1cmdvbmV0YSwgZWwgY2jDoW5kYWwgeSBsYXMgemFwYXRpbGxhcyBibGFuY2FzIHkgYXp1bGVzIG1hbnRpZW5lbiBsYSBjb250aW51aWRhZC48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjwvZGl2PjxkaXYgY2xhc3M9XCJjb250cm9sc1wiPjxidXR0b24gaWQ9XCJwcmV2aW91c1wiIHR5cGU9XCJidXR0b25cIj5JbWFnZW4gYW50ZXJpb3I8L2J1dHRvbj48c3BhbiBpZD1cImNhcm91c2VsQ291bnRlclwiPjEgLyAxNzwvc3Bhbj48YnV0dG9uIGlkPVwibmV4dFwiIHR5cGU9XCJidXR0b25cIj5JbWFnZW4gc2lndWllbnRlPC9idXR0b24+PC9kaXY+PGRpdiBjbGFzcz1cImNhcm91c2VsXCIgdGFiaW5kZXg9XCIwXCIgYXJpYS1sYWJlbD1cIkRldGVuaWRvIGR1cmFudGUgdW4gY29udHJvbCBkZSB0csOhZmljb1wiPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMVwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTAxLWFlNDMyNTk0YzNkMS53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDEtNzNkNzIyZGUwNzRjLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTAxLTQxOWE0MzliYzc4Mi53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkNvbnRyb2wgaW5pY2lhbC4gVW4gYWdlbnRlIGluaWNpYSBlbCBjb250cm9sIGRlIHRyw6FmaWNvLlwiIGxvYWRpbmc9XCJlYWdlclwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MDEgwrcgQ29udHJvbCBpbmljaWFsPC9oMz48cD5VbiBhZ2VudGUgaW5pY2lhIGVsIGNvbnRyb2wgZGUgdHLDoWZpY28uPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjJcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0wMi0zYWI5NDY3NjZjOGQud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTAyLWU5NDZjYzQwODY3Ni53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0wMi0zYWM4NDZiNWUyZjAud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJDb25zdWx0YSBkZSBkYXRvcy4gTG9zIGRhdG9zIGRlbCBjb25kdWN0b3Igc2UgY29tcHJ1ZWJhbiBlbiBlbCB0ZXJtaW5hbCBtw7N2aWwuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjAyIMK3IENvbnN1bHRhIGRlIGRhdG9zPC9oMz48cD5Mb3MgZGF0b3MgZGVsIGNvbmR1Y3RvciBzZSBjb21wcnVlYmFuIGVuIGVsIHRlcm1pbmFsIG3Ds3ZpbC48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiM1wiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTAzLWZlZjkxOTkzZWJiMS53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDMtZTkyOWFjODE0MDRlLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTAzLTAxMTNhMzhiZWM0Ni53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIk9yZGVuIGRlIGRldGVuY2nDs24gcGVuZGllbnRlLiBFbCBhZ2VudGUgbGUgY29tdW5pY2EgZWwgcmVzdWx0YWRvIGRlIGxhIGNvbnN1bHRhLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wMyDCtyBPcmRlbiBkZSBkZXRlbmNpw7NuIHBlbmRpZW50ZTwvaDM+PHA+RWwgYWdlbnRlIGxlIGNvbXVuaWNhIGVsIHJlc3VsdGFkbyBkZSBsYSBjb25zdWx0YS48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiNFwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTA0LTY5NThiZmNlNDk0Yy53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDQtZjcxMDYwZGUzOWJiLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTA0LTUyZTczN2NlMmY3NC53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkp1bnRvIGFsIHZlaMOtY3Vsby4gRWwgY29uZHVjdG9yIGVzIGludGVyY2VwdGFkbyBqdW50byBhbCBjb2NoZSBwbGF0ZWFkby5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MDQgwrcgSnVudG8gYWwgdmVow61jdWxvPC9oMz48cD5FbCBjb25kdWN0b3IgZXMgaW50ZXJjZXB0YWRvIGp1bnRvIGFsIGNvY2hlIHBsYXRlYWRvLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCI1XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDUtYTI5NDYyNTY2YWQ0LndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wNS1jNDRhNmFlYzI1ZmYud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDUtMzBiNWE5ODY3MGM3LndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiRGV0ZW5jacOzbiBlbiBsYSBjYXJyZXRlcmEuIEVsIGhvbWJyZSBlcyBkZXRlbmlkbyBqdW50byBhbCB2ZWjDrWN1bG8uXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjA1IMK3IERldGVuY2nDs24gZW4gbGEgY2FycmV0ZXJhPC9oMz48cD5FbCBob21icmUgZXMgZGV0ZW5pZG8ganVudG8gYWwgdmVow61jdWxvLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCI2XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDYtYjM5YmVlMDE5NzExLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wNi04N2U4OGEyM2UwMDEud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDYtM2MwODdmYTUxNWMxLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiQXNlZ3VyYW1pZW50byBkZSBsYSBkZXRlbmNpw7NuLiBMYSBkZXRlbmNpw7NuIGNvbnRpbsO6YSBqdW50byBhbCBjb2NoZS5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MDYgwrcgQXNlZ3VyYW1pZW50byBkZSBsYSBkZXRlbmNpw7NuPC9oMz48cD5MYSBkZXRlbmNpw7NuIGNvbnRpbsO6YSBqdW50byBhbCBjb2NoZS48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiN1wiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTA3LWJhZGYxNGEzMjAyMy53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDctYzZmMGVmNWQwYWQ0LndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTA3LWRmZjRhNmI1Nzc4Zi53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkRldGFsbGUgZGVsIHZlaMOtY3Vsby4gRGV0YWxsZSBkZWwgdmVow61jdWxvIHkgZGVsIGNvbnRyb2wuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjA3IMK3IERldGFsbGUgZGVsIHZlaMOtY3VsbzwvaDM+PHA+RGV0YWxsZSBkZWwgdmVow61jdWxvIHkgZGVsIGNvbnRyb2wuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjhcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0wOC1jYzM0MTUwY2EwZTYud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTA4LThjMWI5NWE0NzcxNi53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0wOC1kNzlmNzEyYTBiMmUud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJQcmVwYXJhdGl2b3MgcGFyYSBlbCB0cmFzbGFkby4gRWwgZGV0ZW5pZG8gcXVlZGEgYXNlZ3VyYWRvIHBhcmEgZWwgdHJhc2xhZG8uXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjA4IMK3IFByZXBhcmF0aXZvcyBwYXJhIGVsIHRyYXNsYWRvPC9oMz48cD5FbCBkZXRlbmlkbyBxdWVkYSBhc2VndXJhZG8gcGFyYSBlbCB0cmFzbGFkby48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiOVwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTA5LTYzYjFiM2YyZTViMC53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDktZjE4ZmRiOGRlNGMxLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTA5LWVjOTE0N2UzMjJmZS53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkFjY2VzbyBhbCB2ZWjDrWN1bG8uIFNlIGRvY3VtZW50YSBlbCBhY2Nlc28gYWwgdmVow61jdWxvLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wOSDCtyBBY2Nlc28gYWwgdmVow61jdWxvPC9oMz48cD5TZSBkb2N1bWVudGEgZWwgYWNjZXNvIGFsIHZlaMOtY3Vsby48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMTBcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0xMC00OWJjMDkzMDM2MzQud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTEwLWE3NjE4NzMyNWIxMS53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0xMC1jM2IxNGVhNDllMWQud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJUcmFzbGFkbyBiYWpvIGN1c3RvZGlhLiBFbCBob21icmUgZXMgYWNvbXBhw7FhZG8gaGFzdGEgdW5hIGZ1cmdvbmV0YSBwb2xpY2lhbCBhbGVtYW5hLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4xMCDCtyBUcmFzbGFkbyBiYWpvIGN1c3RvZGlhPC9oMz48cD5FbCBob21icmUgZXMgYWNvbXBhw7FhZG8gaGFzdGEgdW5hIGZ1cmdvbmV0YSBwb2xpY2lhbCBhbGVtYW5hLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIxMVwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTExLWI2N2ZjNmEzZjVjZS53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMTEtZWY3MTA2MjRhMDJmLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTExLTIwYTkwNzZiZWJmMC53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkVudHJlZ2EganVudG8gYSBsYSBmdXJnb25ldGEuIFNlIG11ZXN0cmEgbGEgZW50cmVnYSBlbiBlbCB2ZWjDrWN1bG8gZGUgdHJhbnNwb3J0ZS5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MTEgwrcgRW50cmVnYSBqdW50byBhIGxhIGZ1cmdvbmV0YTwvaDM+PHA+U2UgbXVlc3RyYSBsYSBlbnRyZWdhIGVuIGVsIHZlaMOtY3VsbyBkZSB0cmFuc3BvcnRlLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIxMlwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTEyLTc4ZTBlNTBmZDY2YS53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMTItMzQyMDA4MGMzOTk5LndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTEyLWM4ZDRhYTMyMWQ3My53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkZ1cmdvbmV0YSBwcmVwYXJhZGEuIExhIGZ1cmdvbmV0YSBkZSB0cmFuc3BvcnRlIGVzdMOhIHByZXBhcmFkYS5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MTIgwrcgRnVyZ29uZXRhIHByZXBhcmFkYTwvaDM+PHA+TGEgZnVyZ29uZXRhIGRlIHRyYW5zcG9ydGUgZXN0w6EgcHJlcGFyYWRhLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIxM1wiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTEzLTgwZTY0NjM0YWE5OS53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMTMtZmE1MzY2MzNlMzhjLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTEzLTg5NDgzNDM1Nzg5Yi53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIlRyYXllY3RvIGEgZGVwZW5kZW5jaWFzIHBvbGljaWFsZXMuIENvbmNsdXllIGxhIHNlY3VlbmNpYSBkZWwgdHJhc2xhZG8gZGVzZGUgbGEgY2FycmV0ZXJhLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4xMyDCtyBUcmF5ZWN0byBhIGRlcGVuZGVuY2lhcyBwb2xpY2lhbGVzPC9oMz48cD5Db25jbHV5ZSBsYSBzZWN1ZW5jaWEgZGVsIHRyYXNsYWRvIGRlc2RlIGxhIGNhcnJldGVyYS48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMTRcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0xNC0wMTk0MWFkODNlODYud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTE0LTY4OGFiMjA5NWRmZS53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0xNC02ZTBjYjJmYmU0Y2Yud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJBY29tcGHDsWFtaWVudG8gYSBsYSBmdXJnb25ldGEuIERvcyBhZ2VudGVzIGFjb21wYcOxYW4gYWwgZGV0ZW5pZG8gaGFzdGEgbGEgZnVyZ29uZXRhIHBvbGljaWFsIGFsZW1hbmEuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjE0IMK3IEFjb21wYcOxYW1pZW50byBhIGxhIGZ1cmdvbmV0YTwvaDM+PHA+RG9zIGFnZW50ZXMgYWNvbXBhw7FhbiBhbCBkZXRlbmlkbyBoYXN0YSBsYSBmdXJnb25ldGEgcG9saWNpYWwgYWxlbWFuYS48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMTVcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0xNS1jZjIxZWUzODUyMmUud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTE1LWRhOTYzZTcwMDRiYy53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0xNS03OGY1YzA4OGU3MDgud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJFc2NlbmEgZGUgZXhhbWVuIHNlcGFyYWRhLiBFc2NlbmEgZmljdGljaWEgeSBzZXBhcmFkYSBkZSBleGFtZW4geSBkb2N1bWVudGFjacOzbiwgcHJlc2VudGFkYSBjb21vIHVuIGNhbWJpbyBkZSBlc2NlbmEgcG9zdGVyaW9yLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4xNSDCtyBFc2NlbmEgZGUgZXhhbWVuIHNlcGFyYWRhPC9oMz48cD5Fc2NlbmEgZmljdGljaWEgeSBzZXBhcmFkYSBkZSBleGFtZW4geSBkb2N1bWVudGFjacOzbiwgcHJlc2VudGFkYSBjb21vIHVuIGNhbWJpbyBkZSBlc2NlbmEgcG9zdGVyaW9yLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIxNlwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTE2LTEyOTBlNWJhYjUyYy53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMTYtNDZjMTRiMDM3YmFjLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTE2LTBhYzI3NDNhMGE5Mi53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkdFU0Eg4oCTIFJldmlzacOzbiBtw6lkaWNhLiBFbiBsYSBHRVNBLCB1bmEgbcOpZGljYSBkb2N1bWVudGEgZWwgZXhhbWVuIG3DqWRpY28uIFVuYSBjYWRlbmEgY2xhcmFtZW50ZSB2aXNpYmxlIHVuZSBsYXMgZXNwb3NhcyBkZWxhbnRlcmFzIGNvbiBsb3MgZ3JpbGxldGVzIGRlIGxvcyB0b2JpbGxvczsgZWwgY2jDoW5kYWwgeSBlbCBjYWx6YWRvIG5vIGNhbWJpYW4uXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjE2IMK3IEdFU0Eg4oCTIFJldmlzacOzbiBtw6lkaWNhPC9oMz48cD5FbiBsYSBHRVNBLCB1bmEgbcOpZGljYSBkb2N1bWVudGEgZWwgZXhhbWVuIG3DqWRpY28uIFVuYSBjYWRlbmEgY2xhcmFtZW50ZSB2aXNpYmxlIHVuZSBsYXMgZXNwb3NhcyBkZWxhbnRlcmFzIGNvbiBsb3MgZ3JpbGxldGVzIGRlIGxvcyB0b2JpbGxvczsgZWwgY2jDoW5kYWwgeSBlbCBjYWx6YWRvIG5vIGNhbWJpYW4uPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjE3XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMTctMjkyMTVlZmQ1YmQ3LndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0xNy05MDU1NTkyYTg4MDMud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMTctNzRjYjFjY2RmMGYwLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiSW5ncmVzbyBwb3IgbGEgZXNjbHVzYSBkZSBlbnRyYWRhIGRlIGxhIHByaXNpw7NuLiBMb3MgYWdlbnRlcyBsbyBhY29tcGHDsWFuIHBvciBsYSBlc2NsdXNhIGRlIGVudHJhZGEgcGFyYSBzdSBpbmdyZXNvLiBTZSB2ZW4gY2xhcmFtZW50ZSBsYSBjYWRlbmEgcG9zdGVyaW9yIGRlc2RlIGxhcyBlc3Bvc2FzLCBjb2xvY2FkYXMgZGV0csOhcyBkZWwgY3VlcnBvLCBoYXN0YSBlbCBjaW50dXLDs24sIHkgbGEgdW5pw7NuIGVudHJlIGxvcyBncmlsbGV0ZXMgZGUgbG9zIHRvYmlsbG9zLiBMYSBmdXJnb25ldGEsIGVsIGNow6FuZGFsIHkgbGFzIHphcGF0aWxsYXMgYmxhbmNhcyB5IGF6dWxlcyBtYW50aWVuZW4gbGEgY29udGludWlkYWQuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjE3IMK3IEluZ3Jlc28gcG9yIGxhIGVzY2x1c2EgZGUgZW50cmFkYSBkZSBsYSBwcmlzacOzbjwvaDM+PHA+TG9zIGFnZW50ZXMgbG8gYWNvbXBhw7FhbiBwb3IgbGEgZXNjbHVzYSBkZSBlbnRyYWRhIHBhcmEgc3UgaW5ncmVzby4gU2UgdmVuIGNsYXJhbWVudGUgbGEgY2FkZW5hIHBvc3RlcmlvciBkZXNkZSBsYXMgZXNwb3NhcywgY29sb2NhZGFzIGRldHLDoXMgZGVsIGN1ZXJwbywgaGFzdGEgZWwgY2ludHVyw7NuLCB5IGxhIHVuacOzbiBlbnRyZSBsb3MgZ3JpbGxldGVzIGRlIGxvcyB0b2JpbGxvcy4gTGEgZnVyZ29uZXRhLCBlbCBjaMOhbmRhbCB5IGxhcyB6YXBhdGlsbGFzIGJsYW5jYXMgeSBhenVsZXMgbWFudGllbmVuIGxhIGNvbnRpbnVpZGFkLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PC9kaXY+PC9zZWN0aW9uPjxzZWN0aW9uIGNsYXNzPVwic2xpZGVzaG93XCI+PGgyPlByZXNlbnRhY2nDs248L2gyPjxkaXYgY2xhc3M9XCJjb250cm9sc1wiPjxidXR0b24gaWQ9XCJzbGlkZVByZXZpb3VzXCIgdHlwZT1cImJ1dHRvblwiPkltYWdlbiBhbnRlcmlvcjwvYnV0dG9uPjxzcGFuIGlkPVwiY291bnRlclwiPjEgLyAxNzwvc3Bhbj48YnV0dG9uIGlkPVwic2xpZGVOZXh0XCIgdHlwZT1cImJ1dHRvblwiPkltYWdlbiBzaWd1aWVudGU8L2J1dHRvbj48YnV0dG9uIGlkPVwidG9nZ2xlXCIgZGF0YS1wbGF5PVwi4pa2XCIgZGF0YS1wYXVzZT1cIuKFoVwiIGFyaWEtcHJlc3NlZD1cImZhbHNlXCIgdHlwZT1cImJ1dHRvblwiPuKWtjwvYnV0dG9uPjwvZGl2PjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMVwiIGRhdGEtc2Vjb25kcz1cIjZcIiBjbGFzcz1cImFjdGl2ZVwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDEtYWU0MzI1OTRjM2QxLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wMS03M2Q3MjJkZTA3NGMud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDEtNDE5YTQzOWJjNzgyLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiQ29udHJvbCBpbmljaWFsLiBVbiBhZ2VudGUgaW5pY2lhIGVsIGNvbnRyb2wgZGUgdHLDoWZpY28uXCIgbG9hZGluZz1cImVhZ2VyXCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wMSDCtyBDb250cm9sIGluaWNpYWw8L2gzPjxwPlVuIGFnZW50ZSBpbmljaWEgZWwgY29udHJvbCBkZSB0csOhZmljby48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMlwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTAyLTNhYjk0Njc2NmM4ZC53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDItZTk0NmNjNDA4Njc2LndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTAyLTNhYzg0NmI1ZTJmMC53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkNvbnN1bHRhIGRlIGRhdG9zLiBMb3MgZGF0b3MgZGVsIGNvbmR1Y3RvciBzZSBjb21wcnVlYmFuIGVuIGVsIHRlcm1pbmFsIG3Ds3ZpbC5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MDIgwrcgQ29uc3VsdGEgZGUgZGF0b3M8L2gzPjxwPkxvcyBkYXRvcyBkZWwgY29uZHVjdG9yIHNlIGNvbXBydWViYW4gZW4gZWwgdGVybWluYWwgbcOzdmlsLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIzXCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDMtZmVmOTE5OTNlYmIxLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wMy1lOTI5YWM4MTQwNGUud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDMtMDExM2EzOGJlYzQ2LndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiT3JkZW4gZGUgZGV0ZW5jacOzbiBwZW5kaWVudGUuIEVsIGFnZW50ZSBsZSBjb211bmljYSBlbCByZXN1bHRhZG8gZGUgbGEgY29uc3VsdGEuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjAzIMK3IE9yZGVuIGRlIGRldGVuY2nDs24gcGVuZGllbnRlPC9oMz48cD5FbCBhZ2VudGUgbGUgY29tdW5pY2EgZWwgcmVzdWx0YWRvIGRlIGxhIGNvbnN1bHRhLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCI0XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDQtNjk1OGJmY2U0OTRjLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wNC1mNzEwNjBkZTM5YmIud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDQtNTJlNzM3Y2UyZjc0LndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiSnVudG8gYWwgdmVow61jdWxvLiBFbCBjb25kdWN0b3IgZXMgaW50ZXJjZXB0YWRvIGp1bnRvIGFsIGNvY2hlIHBsYXRlYWRvLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wNCDCtyBKdW50byBhbCB2ZWjDrWN1bG88L2gzPjxwPkVsIGNvbmR1Y3RvciBlcyBpbnRlcmNlcHRhZG8ganVudG8gYWwgY29jaGUgcGxhdGVhZG8uPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjVcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0wNS1hMjk0NjI1NjZhZDQud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTA1LWM0NGE2YWVjMjVmZi53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0wNS0zMGI1YTk4NjcwYzcud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJEZXRlbmNpw7NuIGVuIGxhIGNhcnJldGVyYS4gRWwgaG9tYnJlIGVzIGRldGVuaWRvIGp1bnRvIGFsIHZlaMOtY3Vsby5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MDUgwrcgRGV0ZW5jacOzbiBlbiBsYSBjYXJyZXRlcmE8L2gzPjxwPkVsIGhvbWJyZSBlcyBkZXRlbmlkbyBqdW50byBhbCB2ZWjDrWN1bG8uPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjZcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0wNi1iMzliZWUwMTk3MTEud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTA2LTg3ZTg4YTIzZTAwMS53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0wNi0zYzA4N2ZhNTE1YzEud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJBc2VndXJhbWllbnRvIGRlIGxhIGRldGVuY2nDs24uIExhIGRldGVuY2nDs24gY29udGluw7phIGp1bnRvIGFsIGNvY2hlLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wNiDCtyBBc2VndXJhbWllbnRvIGRlIGxhIGRldGVuY2nDs248L2gzPjxwPkxhIGRldGVuY2nDs24gY29udGluw7phIGp1bnRvIGFsIGNvY2hlLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCI3XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDctYmFkZjE0YTMyMDIzLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wNy1jNmYwZWY1ZDBhZDQud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDctZGZmNGE2YjU3NzhmLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiRGV0YWxsZSBkZWwgdmVow61jdWxvLiBEZXRhbGxlIGRlbCB2ZWjDrWN1bG8geSBkZWwgY29udHJvbC5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MDcgwrcgRGV0YWxsZSBkZWwgdmVow61jdWxvPC9oMz48cD5EZXRhbGxlIGRlbCB2ZWjDrWN1bG8geSBkZWwgY29udHJvbC48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiOFwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTA4LWNjMzQxNTBjYTBlNi53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDgtOGMxYjk1YTQ3NzE2LndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTA4LWQ3OWY3MTJhMGIyZS53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIlByZXBhcmF0aXZvcyBwYXJhIGVsIHRyYXNsYWRvLiBFbCBkZXRlbmlkbyBxdWVkYSBhc2VndXJhZG8gcGFyYSBlbCB0cmFzbGFkby5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MDggwrcgUHJlcGFyYXRpdm9zIHBhcmEgZWwgdHJhc2xhZG88L2gzPjxwPkVsIGRldGVuaWRvIHF1ZWRhIGFzZWd1cmFkbyBwYXJhIGVsIHRyYXNsYWRvLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCI5XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDktNjNiMWIzZjJlNWIwLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wOS1mMThmZGI4ZGU0YzEud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDktZWM5MTQ3ZTMyMmZlLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiQWNjZXNvIGFsIHZlaMOtY3Vsby4gU2UgZG9jdW1lbnRhIGVsIGFjY2VzbyBhbCB2ZWjDrWN1bG8uXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjA5IMK3IEFjY2VzbyBhbCB2ZWjDrWN1bG88L2gzPjxwPlNlIGRvY3VtZW50YSBlbCBhY2Nlc28gYWwgdmVow61jdWxvLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIxMFwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTEwLTQ5YmMwOTMwMzYzNC53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMTAtYTc2MTg3MzI1YjExLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTEwLWMzYjE0ZWE0OWUxZC53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIlRyYXNsYWRvIGJham8gY3VzdG9kaWEuIEVsIGhvbWJyZSBlcyBhY29tcGHDsWFkbyBoYXN0YSB1bmEgZnVyZ29uZXRhIHBvbGljaWFsIGFsZW1hbmEuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjEwIMK3IFRyYXNsYWRvIGJham8gY3VzdG9kaWE8L2gzPjxwPkVsIGhvbWJyZSBlcyBhY29tcGHDsWFkbyBoYXN0YSB1bmEgZnVyZ29uZXRhIHBvbGljaWFsIGFsZW1hbmEuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjExXCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMTEtYjY3ZmM2YTNmNWNlLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0xMS1lZjcxMDYyNGEwMmYud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMTEtMjBhOTA3NmJlYmYwLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiRW50cmVnYSBqdW50byBhIGxhIGZ1cmdvbmV0YS4gU2UgbXVlc3RyYSBsYSBlbnRyZWdhIGVuIGVsIHZlaMOtY3VsbyBkZSB0cmFuc3BvcnRlLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4xMSDCtyBFbnRyZWdhIGp1bnRvIGEgbGEgZnVyZ29uZXRhPC9oMz48cD5TZSBtdWVzdHJhIGxhIGVudHJlZ2EgZW4gZWwgdmVow61jdWxvIGRlIHRyYW5zcG9ydGUuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjEyXCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMTItNzhlMGU1MGZkNjZhLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0xMi0zNDIwMDgwYzM5OTkud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMTItYzhkNGFhMzIxZDczLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiRnVyZ29uZXRhIHByZXBhcmFkYS4gTGEgZnVyZ29uZXRhIGRlIHRyYW5zcG9ydGUgZXN0w6EgcHJlcGFyYWRhLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4xMiDCtyBGdXJnb25ldGEgcHJlcGFyYWRhPC9oMz48cD5MYSBmdXJnb25ldGEgZGUgdHJhbnNwb3J0ZSBlc3TDoSBwcmVwYXJhZGEuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjEzXCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMTMtODBlNjQ2MzRhYTk5LndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0xMy1mYTUzNjYzM2UzOGMud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMTMtODk0ODM0MzU3ODliLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiVHJheWVjdG8gYSBkZXBlbmRlbmNpYXMgcG9saWNpYWxlcy4gQ29uY2x1eWUgbGEgc2VjdWVuY2lhIGRlbCB0cmFzbGFkbyBkZXNkZSBsYSBjYXJyZXRlcmEuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjEzIMK3IFRyYXllY3RvIGEgZGVwZW5kZW5jaWFzIHBvbGljaWFsZXM8L2gzPjxwPkNvbmNsdXllIGxhIHNlY3VlbmNpYSBkZWwgdHJhc2xhZG8gZGVzZGUgbGEgY2FycmV0ZXJhLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIxNFwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTE0LTAxOTQxYWQ4M2U4Ni53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMTQtNjg4YWIyMDk1ZGZlLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTE0LTZlMGNiMmZiZTRjZi53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkFjb21wYcOxYW1pZW50byBhIGxhIGZ1cmdvbmV0YS4gRG9zIGFnZW50ZXMgYWNvbXBhw7FhbiBhbCBkZXRlbmlkbyBoYXN0YSBsYSBmdXJnb25ldGEgcG9saWNpYWwgYWxlbWFuYS5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MTQgwrcgQWNvbXBhw7FhbWllbnRvIGEgbGEgZnVyZ29uZXRhPC9oMz48cD5Eb3MgYWdlbnRlcyBhY29tcGHDsWFuIGFsIGRldGVuaWRvIGhhc3RhIGxhIGZ1cmdvbmV0YSBwb2xpY2lhbCBhbGVtYW5hLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIxNVwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTE1LWNmMjFlZTM4NTIyZS53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMTUtZGE5NjNlNzAwNGJjLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTE1LTc4ZjVjMDg4ZTcwOC53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkVzY2VuYSBkZSBleGFtZW4gc2VwYXJhZGEuIEVzY2VuYSBmaWN0aWNpYSB5IHNlcGFyYWRhIGRlIGV4YW1lbiB5IGRvY3VtZW50YWNpw7NuLCBwcmVzZW50YWRhIGNvbW8gdW4gY2FtYmlvIGRlIGVzY2VuYSBwb3N0ZXJpb3IuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjE1IMK3IEVzY2VuYSBkZSBleGFtZW4gc2VwYXJhZGE8L2gzPjxwPkVzY2VuYSBmaWN0aWNpYSB5IHNlcGFyYWRhIGRlIGV4YW1lbiB5IGRvY3VtZW50YWNpw7NuLCBwcmVzZW50YWRhIGNvbW8gdW4gY2FtYmlvIGRlIGVzY2VuYSBwb3N0ZXJpb3IuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjE2XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMTYtMTI5MGU1YmFiNTJjLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0xNi00NmMxNGIwMzdiYWMud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMTYtMGFjMjc0M2EwYTkyLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiR0VTQSDigJMgUmV2aXNpw7NuIG3DqWRpY2EuIEVuIGxhIEdFU0EsIHVuYSBtw6lkaWNhIGRvY3VtZW50YSBlbCBleGFtZW4gbcOpZGljby4gVW5hIGNhZGVuYSBjbGFyYW1lbnRlIHZpc2libGUgdW5lIGxhcyBlc3Bvc2FzIGRlbGFudGVyYXMgY29uIGxvcyBncmlsbGV0ZXMgZGUgbG9zIHRvYmlsbG9zOyBlbCBjaMOhbmRhbCB5IGVsIGNhbHphZG8gbm8gY2FtYmlhbi5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MTYgwrcgR0VTQSDigJMgUmV2aXNpw7NuIG3DqWRpY2E8L2gzPjxwPkVuIGxhIEdFU0EsIHVuYSBtw6lkaWNhIGRvY3VtZW50YSBlbCBleGFtZW4gbcOpZGljby4gVW5hIGNhZGVuYSBjbGFyYW1lbnRlIHZpc2libGUgdW5lIGxhcyBlc3Bvc2FzIGRlbGFudGVyYXMgY29uIGxvcyBncmlsbGV0ZXMgZGUgbG9zIHRvYmlsbG9zOyBlbCBjaMOhbmRhbCB5IGVsIGNhbHphZG8gbm8gY2FtYmlhbi48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMTdcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0xNy0yOTIxNWVmZDViZDcud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTE3LTkwNTU1OTJhODgwMy53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0xNy03NGNiMWNjZGYwZjAud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJJbmdyZXNvIHBvciBsYSBlc2NsdXNhIGRlIGVudHJhZGEgZGUgbGEgcHJpc2nDs24uIExvcyBhZ2VudGVzIGxvIGFjb21wYcOxYW4gcG9yIGxhIGVzY2x1c2EgZGUgZW50cmFkYSBwYXJhIHN1IGluZ3Jlc28uIFNlIHZlbiBjbGFyYW1lbnRlIGxhIGNhZGVuYSBwb3N0ZXJpb3IgZGVzZGUgbGFzIGVzcG9zYXMsIGNvbG9jYWRhcyBkZXRyw6FzIGRlbCBjdWVycG8sIGhhc3RhIGVsIGNpbnR1csOzbiwgeSBsYSB1bmnDs24gZW50cmUgbG9zIGdyaWxsZXRlcyBkZSBsb3MgdG9iaWxsb3MuIExhIGZ1cmdvbmV0YSwgZWwgY2jDoW5kYWwgeSBsYXMgemFwYXRpbGxhcyBibGFuY2FzIHkgYXp1bGVzIG1hbnRpZW5lbiBsYSBjb250aW51aWRhZC5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MTcgwrcgSW5ncmVzbyBwb3IgbGEgZXNjbHVzYSBkZSBlbnRyYWRhIGRlIGxhIHByaXNpw7NuPC9oMz48cD5Mb3MgYWdlbnRlcyBsbyBhY29tcGHDsWFuIHBvciBsYSBlc2NsdXNhIGRlIGVudHJhZGEgcGFyYSBzdSBpbmdyZXNvLiBTZSB2ZW4gY2xhcmFtZW50ZSBsYSBjYWRlbmEgcG9zdGVyaW9yIGRlc2RlIGxhcyBlc3Bvc2FzLCBjb2xvY2FkYXMgZGV0csOhcyBkZWwgY3VlcnBvLCBoYXN0YSBlbCBjaW50dXLDs24sIHkgbGEgdW5pw7NuIGVudHJlIGxvcyBncmlsbGV0ZXMgZGUgbG9zIHRvYmlsbG9zLiBMYSBmdXJnb25ldGEsIGVsIGNow6FuZGFsIHkgbGFzIHphcGF0aWxsYXMgYmxhbmNhcyB5IGF6dWxlcyBtYW50aWVuZW4gbGEgY29udGludWlkYWQuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48L3NlY3Rpb24+PHNlY3Rpb24gaWQ9XCJ2aWRlb1wiPjxoMj5QcmVzZW50YWNpw7NuIGRlIGltw6FnZW5lcyBzaW4gc29uaWRvPC9oMj48dmlkZW8gY29udHJvbHMgcGxheXNpbmxpbmUgcHJlbG9hZD1cIm1ldGFkYXRhXCI+PHNvdXJjZSBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdHJhZmZpYy1zdG9wLXNpbGVudC0xNng5LTI3N2EyODIzYTgxNi5tcDRcIiB0eXBlPVwidmlkZW8vbXA0XCI+PHRyYWNrIGtpbmQ9XCJzdWJ0aXRsZXNcIiBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvY2FwdGlvbnMtZGUtOWIxNmEzMjNhYjljLnZ0dFwiIHNyY2xhbmc9XCJkZVwiIGxhYmVsPVwiRGV1dHNjaFwiPjx0cmFjayBraW5kPVwic3VidGl0bGVzXCIgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2NhcHRpb25zLWVuLTkyZmU5MjViMzVlYi52dHRcIiBzcmNsYW5nPVwiZW5cIiBsYWJlbD1cIkVuZ2xpc2hcIj48dHJhY2sga2luZD1cInN1YnRpdGxlc1wiIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9jYXB0aW9ucy1lcy1lZWE0Y2IyMGRhMGYudnR0XCIgc3JjbGFuZz1cImVzXCIgbGFiZWw9XCJFc3Bhw7FvbFwiIGRlZmF1bHQ+PHRyYWNrIGtpbmQ9XCJzdWJ0aXRsZXNcIiBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvY2FwdGlvbnMtZnItZjMyMDA4YWNhY2U1LnZ0dFwiIHNyY2xhbmc9XCJmclwiIGxhYmVsPVwiRnJhbsOnYWlzXCI+PC92aWRlbz48cD5ObyBzZSBoYSBjcmVhZG8gbmFycmFjacOzbi48L3A+PC9zZWN0aW9uPjwvZGl2PiIsImNvbnRlbnRfc2hhMjU2IjoiOGVhZDk1MTc2MTVhMWNjYTIxZWQ0YmIyMWMxZTRhNDc5MTBlYWNlZDE4MzJmNDliYTg5NzJlNDUwZWZlYjc4ZiIsInBhbmVsX2NvdW50IjoxNywiY2hhcHRlcl9jb3VudCI6MTcsInN0b3J5X3dvcmRzIjoxMjIsImF1ZGlvX21vZGUiOiJ0ZXh0X29ubHkiLCJuYXJyYXRpb25fbGFuZ3VhZ2UiOm51bGwsInZpZGVvX3NoYTI1NiI6IjI3N2EyODIzYTgxNjQ2MDRmZDI0YjBkYjE3NDUxYTVjZTcwMDExNTBhM2I3ZjQwZTVlYzA2NzA5OTE4NjI0MjAifSwiZnIiOnsidGl0bGUiOiJBcnLDqnTDqSBsb3JzIGTigJl1biBjb250csO0bGUgcm91dGllciIsImNvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZHR1LXJldmlldy1zdG9yeSBkdHUtYXBwcm92ZWQxNng5XCI+PG5hdiBhcmlhLWxhYmVsPVwiTGFuZ3VhZ2VzXCI+PGEgaHJlZj1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL2RlL2JpbGRzZXJpZW4vYXVzLWRlbS1hdXRvLXZlcmhhZnRldC1iZWktdmVya2VocnNrb250cm9sbGUvXCI+RGV1dHNjaDwvYT48YSBocmVmPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vZW5fdXMvYmlsZHNlcmllbi9hdXMtZGVtLWF1dG8tdmVyaGFmdGV0LWJlaS12ZXJrZWhyc2tvbnRyb2xsZS9cIj5FbmdsaXNoPC9hPjxhIGhyZWY9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS9lcy9iaWxkc2VyaWVuL2F1cy1kZW0tYXV0by12ZXJoYWZ0ZXQtYmVpLXZlcmtlaHJza29udHJvbGxlL1wiPkVzcGHDsW9sPC9hPjxhIGhyZWY9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS9mci9iaWxkc2VyaWVuL2F1cy1kZW0tYXV0by12ZXJoYWZ0ZXQtYmVpLXZlcmtlaHJza29udHJvbGxlL1wiIGFyaWEtY3VycmVudD1cInBhZ2VcIj5GcmFuw6dhaXM8L2E+PC9uYXY+PGgxPkFycsOqdMOpIGxvcnMgZOKAmXVuIGNvbnRyw7RsZSByb3V0aWVyPC9oMT48YXNpZGUgY2xhc3M9XCJub3RpY2VcIj5Sw6ljaXQgcGhvdG9ncmFwaGlxdWUgZmljdGlmIGV0IG1pcyBlbiBzY8OobmUuIElsIG5lIHPigJlhZ2l0IG5pIGTigJl1bmUgYXJyZXN0YXRpb24gcsOpZWxsZSBuaSBk4oCZdW4gZG9jdW1lbnQgb2ZmaWNpZWwuPC9hc2lkZT48c2VjdGlvbiBpZD1cIm5hcnJhdGl2ZVwiPjxoMj5MZSByw6ljaXQ8L2gyPjxwPkVuIGTDqWJ1dCBkZSBzb2lyw6llLCBsYSBwb2xpY2UgYXJyw6p0ZSB1biBqZXVuZSBjb25kdWN0ZXVyIHN1ciB1bmUgcm91dGUgZGUgY2FtcGFnbmUuIExlcyBhZ2VudHMgdsOpcmlmaWVudCBzb24gaWRlbnRpdMOpIGV0IGxlcyBpbmZvcm1hdGlvbnMgZHUgdsOpaGljdWxlIHN1ciB1biB0ZXJtaW5hbCBtb2JpbGUuIExhIGNvbnN1bHRhdGlvbiByw6l2w6hsZSB1biBtYW5kYXQgZOKAmWFycsOqdCBlbiBjb3Vycy4gVW4gcG9saWNpZXIgbHVpIGV4cGxpcXVlIGxlIG1vdGlmIGRlIGzigJlpbnRlcnZlbnRpb24gOyBs4oCZYXJyZXN0YXRpb24gYSBsaWV1IHByw6hzIGRlIGxhIHZvaXR1cmUuPC9wPjxwPkFwcsOocyBs4oCZYXJyZXN0YXRpb24sIGzigJlob21tZSBlc3QgZXNjb3J0w6kganVzcXXigJnDoCB1biBmb3VyZ29uIHB1aXMgY29uZHVpdCBhdSBwb3N0ZS4gw4AgbGEgR0VTQSwgdW5lIG3DqWRlY2luIGNvbnNpZ25lIGzigJlleGFtZW4gbcOpZGljYWwuIEzigJlob21tZSByZXN0ZSBoYWJpbGzDqSA7IGlsIHBvcnRlIGRlcyBtZW5vdHRlcyBkZXZhbnQgbHVpIGV0IGRlcyBlbnRyYXZlcyBhdXggY2hldmlsbGVzIHJlbGnDqWVzIHBhciB1bmUgY2hhw65uZS4gSWwgZXN0IGVuc3VpdGUgdHJhbnNmw6lyw6kgw6AgbOKAmcOpdGFibGlzc2VtZW50IHDDqW5pdGVudGlhaXJlLiBM4oCZaGlzdG9pcmUgc2UgdGVybWluZSBhdSBzYXMgZOKAmWVudHLDqWUgc2lnbmFsw6ksIG\/DuSBsZXMgYWdlbnRzIGzigJlhY2NvbXBhZ25lbnQgcG91ciBzb24gYWRtaXNzaW9uIGF2ZWMgbWVub3R0ZXMsIGVudHJhdmVzIGF1eCBjaGV2aWxsZXMgZXQgY2hhw65uZSBkb3JzYWxlLjwvcD48L3NlY3Rpb24+PHNlY3Rpb24gaWQ9XCJzdG9yeVwiPjxoMj5Ub3V0ZXMgbGVzIHNjw6huZXM8L2gyPjxkaXYgY2xhc3M9XCJnYWxsZXJ5XCI+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIxXCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDEtYWU0MzI1OTRjM2QxLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wMS03M2Q3MjJkZTA3NGMud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDEtNDE5YTQzOWJjNzgyLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiUHJlbWllciBjb250csO0bGUuIFVuIGFnZW50IGNvbW1lbmNlIGxlIGNvbnRyw7RsZSByb3V0aWVyLlwiIGxvYWRpbmc9XCJlYWdlclwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MDEgwrcgUHJlbWllciBjb250csO0bGU8L2gzPjxwPlVuIGFnZW50IGNvbW1lbmNlIGxlIGNvbnRyw7RsZSByb3V0aWVyLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIyXCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDItM2FiOTQ2NzY2YzhkLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wMi1lOTQ2Y2M0MDg2NzYud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDItM2FjODQ2YjVlMmYwLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiVsOpcmlmaWNhdGlvbiBkYW5zIGxlIHbDqWhpY3VsZSBkZSBwb2xpY2UuIEzigJlpZGVudGl0w6kgZHUgY29uZHVjdGV1ciBlc3QgdsOpcmlmacOpZSBzdXIgbGUgdGVybWluYWwgbW9iaWxlLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wMiDCtyBWw6lyaWZpY2F0aW9uIGRhbnMgbGUgdsOpaGljdWxlIGRlIHBvbGljZTwvaDM+PHA+TOKAmWlkZW50aXTDqSBkdSBjb25kdWN0ZXVyIGVzdCB2w6lyaWZpw6llIHN1ciBsZSB0ZXJtaW5hbCBtb2JpbGUuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjNcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0wMy1mZWY5MTk5M2ViYjEud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTAzLWU5MjlhYzgxNDA0ZS53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0wMy0wMTEzYTM4YmVjNDYud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJNYW5kYXQgZOKAmWFycsOqdCBlbiBjb3Vycy4gTOKAmWFnZW50IGx1aSBjb21tdW5pcXVlIGxlIHLDqXN1bHRhdCBkZSBsYSB2w6lyaWZpY2F0aW9uLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wMyDCtyBNYW5kYXQgZOKAmWFycsOqdCBlbiBjb3VyczwvaDM+PHA+TOKAmWFnZW50IGx1aSBjb21tdW5pcXVlIGxlIHLDqXN1bHRhdCBkZSBsYSB2w6lyaWZpY2F0aW9uLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCI0XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDQtNjk1OGJmY2U0OTRjLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wNC1mNzEwNjBkZTM5YmIud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDQtNTJlNzM3Y2UyZjc0LndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiQXJyw6p0IHByw6hzIGRlIGxhIHZvaXR1cmUuIExlIGNvbmR1Y3RldXIgZXN0IGFib3Jkw6kgcHLDqHMgZGUgbGEgdm9pdHVyZSBhcmdlbnTDqWUuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjA0IMK3IEFycsOqdCBwcsOocyBkZSBsYSB2b2l0dXJlPC9oMz48cD5MZSBjb25kdWN0ZXVyIGVzdCBhYm9yZMOpIHByw6hzIGRlIGxhIHZvaXR1cmUgYXJnZW50w6llLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCI1XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDUtYTI5NDYyNTY2YWQ0LndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wNS1jNDRhNmFlYzI1ZmYud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDUtMzBiNWE5ODY3MGM3LndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiQXJyZXN0YXRpb24gYXUgYm9yZCBkZSBsYSByb3V0ZS4gTOKAmWhvbW1lIGVzdCBhcnLDqnTDqSBwcsOocyBkdSB2w6loaWN1bGUuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjA1IMK3IEFycmVzdGF0aW9uIGF1IGJvcmQgZGUgbGEgcm91dGU8L2gzPjxwPkzigJlob21tZSBlc3QgYXJyw6p0w6kgcHLDqHMgZHUgdsOpaGljdWxlLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCI2XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDYtYjM5YmVlMDE5NzExLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wNi04N2U4OGEyM2UwMDEud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDYtM2MwODdmYTUxNWMxLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiU8OpY3VyaXNhdGlvbiBkZSBs4oCZYXJyZXN0YXRpb24uIEzigJlpbnRlcnZlbnRpb24gc2UgcG91cnN1aXQgcHLDqHMgZGUgbGEgdm9pdHVyZS5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MDYgwrcgU8OpY3VyaXNhdGlvbiBkZSBs4oCZYXJyZXN0YXRpb248L2gzPjxwPkzigJlpbnRlcnZlbnRpb24gc2UgcG91cnN1aXQgcHLDqHMgZGUgbGEgdm9pdHVyZS48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiN1wiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTA3LWJhZGYxNGEzMjAyMy53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDctYzZmMGVmNWQwYWQ0LndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTA3LWRmZjRhNmI1Nzc4Zi53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkTDqXRhaWwgZHUgdsOpaGljdWxlLiBEw6l0YWlsIGRlIGxhIHZvaXR1cmUgZXQgZHUgY29udHLDtGxlLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wNyDCtyBEw6l0YWlsIGR1IHbDqWhpY3VsZTwvaDM+PHA+RMOpdGFpbCBkZSBsYSB2b2l0dXJlIGV0IGR1IGNvbnRyw7RsZS48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiOFwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTA4LWNjMzQxNTBjYTBlNi53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDgtOGMxYjk1YTQ3NzE2LndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTA4LWQ3OWY3MTJhMGIyZS53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIlByw6lwYXJhdGlvbiBkdSB0cmFuc2ZlcnQuIEzigJlob21tZSBhcnLDqnTDqSBlc3Qgc8OpY3VyaXPDqSBwb3VyIGxlIHRyYW5zZmVydC5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MDggwrcgUHLDqXBhcmF0aW9uIGR1IHRyYW5zZmVydDwvaDM+PHA+TOKAmWhvbW1lIGFycsOqdMOpIGVzdCBzw6ljdXJpc8OpIHBvdXIgbGUgdHJhbnNmZXJ0LjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCI5XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDktNjNiMWIzZjJlNWIwLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wOS1mMThmZGI4ZGU0YzEud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDktZWM5MTQ3ZTMyMmZlLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiQWNjw6hzIGF1IHbDqWhpY3VsZS4gTOKAmWFjY8OocyBhdSB2w6loaWN1bGUgZXN0IGRvY3VtZW50w6kuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjA5IMK3IEFjY8OocyBhdSB2w6loaWN1bGU8L2gzPjxwPkzigJlhY2PDqHMgYXUgdsOpaGljdWxlIGVzdCBkb2N1bWVudMOpLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIxMFwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTEwLTQ5YmMwOTMwMzYzNC53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMTAtYTc2MTg3MzI1YjExLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTEwLWMzYjE0ZWE0OWUxZC53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIlRyYW5zZmVydCBlbiBnYXJkZSDDoCB2dWUuIEzigJlob21tZSBlc3QgYWNjb21wYWduw6kganVzcXXigJnDoCB1biBmb3VyZ29uIGRlIHBvbGljZSBhbGxlbWFuZC5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MTAgwrcgVHJhbnNmZXJ0IGVuIGdhcmRlIMOgIHZ1ZTwvaDM+PHA+TOKAmWhvbW1lIGVzdCBhY2NvbXBhZ27DqSBqdXNxdeKAmcOgIHVuIGZvdXJnb24gZGUgcG9saWNlIGFsbGVtYW5kLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIxMVwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTExLWI2N2ZjNmEzZjVjZS53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMTEtZWY3MTA2MjRhMDJmLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTExLTIwYTkwNzZiZWJmMC53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIlJlbGFpcyBwcsOocyBkdSBmb3VyZ29uLiBMZSB0cmFuc2ZlcnQgYXUgdsOpaGljdWxlIGVzdCBtb250csOpLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4xMSDCtyBSZWxhaXMgcHLDqHMgZHUgZm91cmdvbjwvaDM+PHA+TGUgdHJhbnNmZXJ0IGF1IHbDqWhpY3VsZSBlc3QgbW9udHLDqS48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMTJcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0xMi03OGUwZTUwZmQ2NmEud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTEyLTM0MjAwODBjMzk5OS53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0xMi1jOGQ0YWEzMjFkNzMud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJGb3VyZ29uIHByw6p0LiBMZSBmb3VyZ29uIGRlIHRyYW5zcG9ydCBlc3QgcHLDqnQuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjEyIMK3IEZvdXJnb24gcHLDqnQ8L2gzPjxwPkxlIGZvdXJnb24gZGUgdHJhbnNwb3J0IGVzdCBwcsOqdC48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMTNcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0xMy04MGU2NDYzNGFhOTkud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTEzLWZhNTM2NjMzZTM4Yy53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0xMy04OTQ4MzQzNTc4OWIud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJUcmFqZXQgdmVycyBsZSBjb21taXNzYXJpYXQuIExhIHPDqXF1ZW5jZSBkZSB0cmFuc2ZlcnQgZGVwdWlzIGxhIHJvdXRlIHNlIHRlcm1pbmUuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjEzIMK3IFRyYWpldCB2ZXJzIGxlIGNvbW1pc3NhcmlhdDwvaDM+PHA+TGEgc8OpcXVlbmNlIGRlIHRyYW5zZmVydCBkZXB1aXMgbGEgcm91dGUgc2UgdGVybWluZS48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMTRcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0xNC0wMTk0MWFkODNlODYud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTE0LTY4OGFiMjA5NWRmZS53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0xNC02ZTBjYjJmYmU0Y2Yud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJBY2NvbXBhZ25lbWVudCB2ZXJzIGxlIGZvdXJnb24uIERldXggYWdlbnRzIGFjY29tcGFnbmVudCBs4oCZaG9tbWUgYXJyw6p0w6kganVzcXXigJlhdSBmb3VyZ29uIGRlIHBvbGljZSBhbGxlbWFuZC5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MTQgwrcgQWNjb21wYWduZW1lbnQgdmVycyBsZSBmb3VyZ29uPC9oMz48cD5EZXV4IGFnZW50cyBhY2NvbXBhZ25lbnQgbOKAmWhvbW1lIGFycsOqdMOpIGp1c3F14oCZYXUgZm91cmdvbiBkZSBwb2xpY2UgYWxsZW1hbmQuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjE1XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMTUtY2YyMWVlMzg1MjJlLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0xNS1kYTk2M2U3MDA0YmMud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMTUtNzhmNWMwODhlNzA4LndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiU2PDqG5lIGTigJlleGFtZW4gZGlzdGluY3RlLiBTY8OobmUgZmljdGl2ZSBkaXN0aW5jdGUgZOKAmWV4YW1lbiBldCBkZSBkb2N1bWVudGF0aW9uLCBwcsOpc2VudMOpZSBjb21tZSB1biBjaGFuZ2VtZW50IGRlIHNjw6huZSB1bHTDqXJpZXVyLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4xNSDCtyBTY8OobmUgZOKAmWV4YW1lbiBkaXN0aW5jdGU8L2gzPjxwPlNjw6huZSBmaWN0aXZlIGRpc3RpbmN0ZSBk4oCZZXhhbWVuIGV0IGRlIGRvY3VtZW50YXRpb24sIHByw6lzZW50w6llIGNvbW1lIHVuIGNoYW5nZW1lbnQgZGUgc2PDqG5lIHVsdMOpcmlldXIuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjE2XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMTYtMTI5MGU1YmFiNTJjLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0xNi00NmMxNGIwMzdiYWMud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMTYtMGFjMjc0M2EwYTkyLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiR0VTQSDigJMgRXhhbWVuIG3DqWRpY2FsLiDDgCBsYSBHRVNBLCB1bmUgbcOpZGVjaW4gY29uc2lnbmUgbOKAmWV4YW1lbiBtw6lkaWNhbC4gVW5lIGNoYcOubmUgYmllbiB2aXNpYmxlIHJlbGllIGxlcyBtZW5vdHRlcyBwb3J0w6llcyBkZXZhbnQgYXV4IGVudHJhdmVzIGRlcyBjaGV2aWxsZXMgOyBzb24gc3VydsOqdGVtZW50IGV0IHNlcyBjaGF1c3N1cmVzIHJlc3RlbnQgaWRlbnRpcXVlcy5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MTYgwrcgR0VTQSDigJMgRXhhbWVuIG3DqWRpY2FsPC9oMz48cD7DgCBsYSBHRVNBLCB1bmUgbcOpZGVjaW4gY29uc2lnbmUgbOKAmWV4YW1lbiBtw6lkaWNhbC4gVW5lIGNoYcOubmUgYmllbiB2aXNpYmxlIHJlbGllIGxlcyBtZW5vdHRlcyBwb3J0w6llcyBkZXZhbnQgYXV4IGVudHJhdmVzIGRlcyBjaGV2aWxsZXMgOyBzb24gc3VydsOqdGVtZW50IGV0IHNlcyBjaGF1c3N1cmVzIHJlc3RlbnQgaWRlbnRpcXVlcy48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMTdcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0xNy0yOTIxNWVmZDViZDcud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTE3LTkwNTU1OTJhODgwMy53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0xNy03NGNiMWNjZGYwZjAud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJBZG1pc3Npb24gcGFyIGxlIHNhcyBk4oCZZW50csOpZSBkZSBsYSBwcmlzb24uIExlcyBhZ2VudHMgbOKAmWFjY29tcGFnbmVudCBwYXIgbGUgc2FzIGTigJllbnRyw6llIHBvdXIgc29uIGFkbWlzc2lvbi4gTGEgY2hhw65uZSBkb3JzYWxlIHJlbGlhbnQgbGVzIG1lbm90dGVzIHBsYWPDqWVzIGRlcnJpw6hyZSBsdWkgw6AgbGEgY2VpbnR1cmUsIGFpbnNpIHF1ZSBsZSBsaWVuIGVudHJlIGxlcyBlbnRyYXZlcyBhdXggY2hldmlsbGVzLCBzb250IGJpZW4gdmlzaWJsZXMuIExlIGZvdXJnb24sIGxlIHN1cnbDqnRlbWVudCBldCBsZXMgY2hhdXNzdXJlcyBibGFuY2hlcyBldCBibGV1ZXMgcmVzdGVudCBjb2jDqXJlbnRzLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4xNyDCtyBBZG1pc3Npb24gcGFyIGxlIHNhcyBk4oCZZW50csOpZSBkZSBsYSBwcmlzb248L2gzPjxwPkxlcyBhZ2VudHMgbOKAmWFjY29tcGFnbmVudCBwYXIgbGUgc2FzIGTigJllbnRyw6llIHBvdXIgc29uIGFkbWlzc2lvbi4gTGEgY2hhw65uZSBkb3JzYWxlIHJlbGlhbnQgbGVzIG1lbm90dGVzIHBsYWPDqWVzIGRlcnJpw6hyZSBsdWkgw6AgbGEgY2VpbnR1cmUsIGFpbnNpIHF1ZSBsZSBsaWVuIGVudHJlIGxlcyBlbnRyYXZlcyBhdXggY2hldmlsbGVzLCBzb250IGJpZW4gdmlzaWJsZXMuIExlIGZvdXJnb24sIGxlIHN1cnbDqnRlbWVudCBldCBsZXMgY2hhdXNzdXJlcyBibGFuY2hlcyBldCBibGV1ZXMgcmVzdGVudCBjb2jDqXJlbnRzLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PC9kaXY+PGRpdiBjbGFzcz1cImNvbnRyb2xzXCI+PGJ1dHRvbiBpZD1cInByZXZpb3VzXCIgdHlwZT1cImJ1dHRvblwiPkltYWdlIHByw6ljw6lkZW50ZTwvYnV0dG9uPjxzcGFuIGlkPVwiY2Fyb3VzZWxDb3VudGVyXCI+MSAvIDE3PC9zcGFuPjxidXR0b24gaWQ9XCJuZXh0XCIgdHlwZT1cImJ1dHRvblwiPkltYWdlIHN1aXZhbnRlPC9idXR0b24+PC9kaXY+PGRpdiBjbGFzcz1cImNhcm91c2VsXCIgdGFiaW5kZXg9XCIwXCIgYXJpYS1sYWJlbD1cIkFycsOqdMOpIGxvcnMgZOKAmXVuIGNvbnRyw7RsZSByb3V0aWVyXCI+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIxXCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDEtYWU0MzI1OTRjM2QxLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wMS03M2Q3MjJkZTA3NGMud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDEtNDE5YTQzOWJjNzgyLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiUHJlbWllciBjb250csO0bGUuIFVuIGFnZW50IGNvbW1lbmNlIGxlIGNvbnRyw7RsZSByb3V0aWVyLlwiIGxvYWRpbmc9XCJlYWdlclwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MDEgwrcgUHJlbWllciBjb250csO0bGU8L2gzPjxwPlVuIGFnZW50IGNvbW1lbmNlIGxlIGNvbnRyw7RsZSByb3V0aWVyLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIyXCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDItM2FiOTQ2NzY2YzhkLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wMi1lOTQ2Y2M0MDg2NzYud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDItM2FjODQ2YjVlMmYwLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiVsOpcmlmaWNhdGlvbiBkYW5zIGxlIHbDqWhpY3VsZSBkZSBwb2xpY2UuIEzigJlpZGVudGl0w6kgZHUgY29uZHVjdGV1ciBlc3QgdsOpcmlmacOpZSBzdXIgbGUgdGVybWluYWwgbW9iaWxlLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wMiDCtyBWw6lyaWZpY2F0aW9uIGRhbnMgbGUgdsOpaGljdWxlIGRlIHBvbGljZTwvaDM+PHA+TOKAmWlkZW50aXTDqSBkdSBjb25kdWN0ZXVyIGVzdCB2w6lyaWZpw6llIHN1ciBsZSB0ZXJtaW5hbCBtb2JpbGUuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjNcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0wMy1mZWY5MTk5M2ViYjEud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTAzLWU5MjlhYzgxNDA0ZS53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0wMy0wMTEzYTM4YmVjNDYud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJNYW5kYXQgZOKAmWFycsOqdCBlbiBjb3Vycy4gTOKAmWFnZW50IGx1aSBjb21tdW5pcXVlIGxlIHLDqXN1bHRhdCBkZSBsYSB2w6lyaWZpY2F0aW9uLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wMyDCtyBNYW5kYXQgZOKAmWFycsOqdCBlbiBjb3VyczwvaDM+PHA+TOKAmWFnZW50IGx1aSBjb21tdW5pcXVlIGxlIHLDqXN1bHRhdCBkZSBsYSB2w6lyaWZpY2F0aW9uLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCI0XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDQtNjk1OGJmY2U0OTRjLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wNC1mNzEwNjBkZTM5YmIud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDQtNTJlNzM3Y2UyZjc0LndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiQXJyw6p0IHByw6hzIGRlIGxhIHZvaXR1cmUuIExlIGNvbmR1Y3RldXIgZXN0IGFib3Jkw6kgcHLDqHMgZGUgbGEgdm9pdHVyZSBhcmdlbnTDqWUuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjA0IMK3IEFycsOqdCBwcsOocyBkZSBsYSB2b2l0dXJlPC9oMz48cD5MZSBjb25kdWN0ZXVyIGVzdCBhYm9yZMOpIHByw6hzIGRlIGxhIHZvaXR1cmUgYXJnZW50w6llLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCI1XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDUtYTI5NDYyNTY2YWQ0LndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wNS1jNDRhNmFlYzI1ZmYud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDUtMzBiNWE5ODY3MGM3LndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiQXJyZXN0YXRpb24gYXUgYm9yZCBkZSBsYSByb3V0ZS4gTOKAmWhvbW1lIGVzdCBhcnLDqnTDqSBwcsOocyBkdSB2w6loaWN1bGUuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjA1IMK3IEFycmVzdGF0aW9uIGF1IGJvcmQgZGUgbGEgcm91dGU8L2gzPjxwPkzigJlob21tZSBlc3QgYXJyw6p0w6kgcHLDqHMgZHUgdsOpaGljdWxlLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCI2XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDYtYjM5YmVlMDE5NzExLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wNi04N2U4OGEyM2UwMDEud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDYtM2MwODdmYTUxNWMxLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiU8OpY3VyaXNhdGlvbiBkZSBs4oCZYXJyZXN0YXRpb24uIEzigJlpbnRlcnZlbnRpb24gc2UgcG91cnN1aXQgcHLDqHMgZGUgbGEgdm9pdHVyZS5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MDYgwrcgU8OpY3VyaXNhdGlvbiBkZSBs4oCZYXJyZXN0YXRpb248L2gzPjxwPkzigJlpbnRlcnZlbnRpb24gc2UgcG91cnN1aXQgcHLDqHMgZGUgbGEgdm9pdHVyZS48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiN1wiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTA3LWJhZGYxNGEzMjAyMy53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDctYzZmMGVmNWQwYWQ0LndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTA3LWRmZjRhNmI1Nzc4Zi53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkTDqXRhaWwgZHUgdsOpaGljdWxlLiBEw6l0YWlsIGRlIGxhIHZvaXR1cmUgZXQgZHUgY29udHLDtGxlLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wNyDCtyBEw6l0YWlsIGR1IHbDqWhpY3VsZTwvaDM+PHA+RMOpdGFpbCBkZSBsYSB2b2l0dXJlIGV0IGR1IGNvbnRyw7RsZS48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiOFwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTA4LWNjMzQxNTBjYTBlNi53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDgtOGMxYjk1YTQ3NzE2LndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTA4LWQ3OWY3MTJhMGIyZS53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIlByw6lwYXJhdGlvbiBkdSB0cmFuc2ZlcnQuIEzigJlob21tZSBhcnLDqnTDqSBlc3Qgc8OpY3VyaXPDqSBwb3VyIGxlIHRyYW5zZmVydC5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MDggwrcgUHLDqXBhcmF0aW9uIGR1IHRyYW5zZmVydDwvaDM+PHA+TOKAmWhvbW1lIGFycsOqdMOpIGVzdCBzw6ljdXJpc8OpIHBvdXIgbGUgdHJhbnNmZXJ0LjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCI5XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDktNjNiMWIzZjJlNWIwLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wOS1mMThmZGI4ZGU0YzEud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDktZWM5MTQ3ZTMyMmZlLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiQWNjw6hzIGF1IHbDqWhpY3VsZS4gTOKAmWFjY8OocyBhdSB2w6loaWN1bGUgZXN0IGRvY3VtZW50w6kuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjA5IMK3IEFjY8OocyBhdSB2w6loaWN1bGU8L2gzPjxwPkzigJlhY2PDqHMgYXUgdsOpaGljdWxlIGVzdCBkb2N1bWVudMOpLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIxMFwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTEwLTQ5YmMwOTMwMzYzNC53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMTAtYTc2MTg3MzI1YjExLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTEwLWMzYjE0ZWE0OWUxZC53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIlRyYW5zZmVydCBlbiBnYXJkZSDDoCB2dWUuIEzigJlob21tZSBlc3QgYWNjb21wYWduw6kganVzcXXigJnDoCB1biBmb3VyZ29uIGRlIHBvbGljZSBhbGxlbWFuZC5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MTAgwrcgVHJhbnNmZXJ0IGVuIGdhcmRlIMOgIHZ1ZTwvaDM+PHA+TOKAmWhvbW1lIGVzdCBhY2NvbXBhZ27DqSBqdXNxdeKAmcOgIHVuIGZvdXJnb24gZGUgcG9saWNlIGFsbGVtYW5kLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIxMVwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTExLWI2N2ZjNmEzZjVjZS53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMTEtZWY3MTA2MjRhMDJmLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTExLTIwYTkwNzZiZWJmMC53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIlJlbGFpcyBwcsOocyBkdSBmb3VyZ29uLiBMZSB0cmFuc2ZlcnQgYXUgdsOpaGljdWxlIGVzdCBtb250csOpLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4xMSDCtyBSZWxhaXMgcHLDqHMgZHUgZm91cmdvbjwvaDM+PHA+TGUgdHJhbnNmZXJ0IGF1IHbDqWhpY3VsZSBlc3QgbW9udHLDqS48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMTJcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0xMi03OGUwZTUwZmQ2NmEud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTEyLTM0MjAwODBjMzk5OS53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0xMi1jOGQ0YWEzMjFkNzMud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJGb3VyZ29uIHByw6p0LiBMZSBmb3VyZ29uIGRlIHRyYW5zcG9ydCBlc3QgcHLDqnQuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjEyIMK3IEZvdXJnb24gcHLDqnQ8L2gzPjxwPkxlIGZvdXJnb24gZGUgdHJhbnNwb3J0IGVzdCBwcsOqdC48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMTNcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0xMy04MGU2NDYzNGFhOTkud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTEzLWZhNTM2NjMzZTM4Yy53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0xMy04OTQ4MzQzNTc4OWIud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJUcmFqZXQgdmVycyBsZSBjb21taXNzYXJpYXQuIExhIHPDqXF1ZW5jZSBkZSB0cmFuc2ZlcnQgZGVwdWlzIGxhIHJvdXRlIHNlIHRlcm1pbmUuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjEzIMK3IFRyYWpldCB2ZXJzIGxlIGNvbW1pc3NhcmlhdDwvaDM+PHA+TGEgc8OpcXVlbmNlIGRlIHRyYW5zZmVydCBkZXB1aXMgbGEgcm91dGUgc2UgdGVybWluZS48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMTRcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0xNC0wMTk0MWFkODNlODYud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTE0LTY4OGFiMjA5NWRmZS53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0xNC02ZTBjYjJmYmU0Y2Yud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJBY2NvbXBhZ25lbWVudCB2ZXJzIGxlIGZvdXJnb24uIERldXggYWdlbnRzIGFjY29tcGFnbmVudCBs4oCZaG9tbWUgYXJyw6p0w6kganVzcXXigJlhdSBmb3VyZ29uIGRlIHBvbGljZSBhbGxlbWFuZC5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MTQgwrcgQWNjb21wYWduZW1lbnQgdmVycyBsZSBmb3VyZ29uPC9oMz48cD5EZXV4IGFnZW50cyBhY2NvbXBhZ25lbnQgbOKAmWhvbW1lIGFycsOqdMOpIGp1c3F14oCZYXUgZm91cmdvbiBkZSBwb2xpY2UgYWxsZW1hbmQuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjE1XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMTUtY2YyMWVlMzg1MjJlLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0xNS1kYTk2M2U3MDA0YmMud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMTUtNzhmNWMwODhlNzA4LndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiU2PDqG5lIGTigJlleGFtZW4gZGlzdGluY3RlLiBTY8OobmUgZmljdGl2ZSBkaXN0aW5jdGUgZOKAmWV4YW1lbiBldCBkZSBkb2N1bWVudGF0aW9uLCBwcsOpc2VudMOpZSBjb21tZSB1biBjaGFuZ2VtZW50IGRlIHNjw6huZSB1bHTDqXJpZXVyLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4xNSDCtyBTY8OobmUgZOKAmWV4YW1lbiBkaXN0aW5jdGU8L2gzPjxwPlNjw6huZSBmaWN0aXZlIGRpc3RpbmN0ZSBk4oCZZXhhbWVuIGV0IGRlIGRvY3VtZW50YXRpb24sIHByw6lzZW50w6llIGNvbW1lIHVuIGNoYW5nZW1lbnQgZGUgc2PDqG5lIHVsdMOpcmlldXIuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjE2XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMTYtMTI5MGU1YmFiNTJjLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0xNi00NmMxNGIwMzdiYWMud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMTYtMGFjMjc0M2EwYTkyLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiR0VTQSDigJMgRXhhbWVuIG3DqWRpY2FsLiDDgCBsYSBHRVNBLCB1bmUgbcOpZGVjaW4gY29uc2lnbmUgbOKAmWV4YW1lbiBtw6lkaWNhbC4gVW5lIGNoYcOubmUgYmllbiB2aXNpYmxlIHJlbGllIGxlcyBtZW5vdHRlcyBwb3J0w6llcyBkZXZhbnQgYXV4IGVudHJhdmVzIGRlcyBjaGV2aWxsZXMgOyBzb24gc3VydsOqdGVtZW50IGV0IHNlcyBjaGF1c3N1cmVzIHJlc3RlbnQgaWRlbnRpcXVlcy5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MTYgwrcgR0VTQSDigJMgRXhhbWVuIG3DqWRpY2FsPC9oMz48cD7DgCBsYSBHRVNBLCB1bmUgbcOpZGVjaW4gY29uc2lnbmUgbOKAmWV4YW1lbiBtw6lkaWNhbC4gVW5lIGNoYcOubmUgYmllbiB2aXNpYmxlIHJlbGllIGxlcyBtZW5vdHRlcyBwb3J0w6llcyBkZXZhbnQgYXV4IGVudHJhdmVzIGRlcyBjaGV2aWxsZXMgOyBzb24gc3VydsOqdGVtZW50IGV0IHNlcyBjaGF1c3N1cmVzIHJlc3RlbnQgaWRlbnRpcXVlcy48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMTdcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0xNy0yOTIxNWVmZDViZDcud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTE3LTkwNTU1OTJhODgwMy53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0xNy03NGNiMWNjZGYwZjAud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJBZG1pc3Npb24gcGFyIGxlIHNhcyBk4oCZZW50csOpZSBkZSBsYSBwcmlzb24uIExlcyBhZ2VudHMgbOKAmWFjY29tcGFnbmVudCBwYXIgbGUgc2FzIGTigJllbnRyw6llIHBvdXIgc29uIGFkbWlzc2lvbi4gTGEgY2hhw65uZSBkb3JzYWxlIHJlbGlhbnQgbGVzIG1lbm90dGVzIHBsYWPDqWVzIGRlcnJpw6hyZSBsdWkgw6AgbGEgY2VpbnR1cmUsIGFpbnNpIHF1ZSBsZSBsaWVuIGVudHJlIGxlcyBlbnRyYXZlcyBhdXggY2hldmlsbGVzLCBzb250IGJpZW4gdmlzaWJsZXMuIExlIGZvdXJnb24sIGxlIHN1cnbDqnRlbWVudCBldCBsZXMgY2hhdXNzdXJlcyBibGFuY2hlcyBldCBibGV1ZXMgcmVzdGVudCBjb2jDqXJlbnRzLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4xNyDCtyBBZG1pc3Npb24gcGFyIGxlIHNhcyBk4oCZZW50csOpZSBkZSBsYSBwcmlzb248L2gzPjxwPkxlcyBhZ2VudHMgbOKAmWFjY29tcGFnbmVudCBwYXIgbGUgc2FzIGTigJllbnRyw6llIHBvdXIgc29uIGFkbWlzc2lvbi4gTGEgY2hhw65uZSBkb3JzYWxlIHJlbGlhbnQgbGVzIG1lbm90dGVzIHBsYWPDqWVzIGRlcnJpw6hyZSBsdWkgw6AgbGEgY2VpbnR1cmUsIGFpbnNpIHF1ZSBsZSBsaWVuIGVudHJlIGxlcyBlbnRyYXZlcyBhdXggY2hldmlsbGVzLCBzb250IGJpZW4gdmlzaWJsZXMuIExlIGZvdXJnb24sIGxlIHN1cnbDqnRlbWVudCBldCBsZXMgY2hhdXNzdXJlcyBibGFuY2hlcyBldCBibGV1ZXMgcmVzdGVudCBjb2jDqXJlbnRzLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PC9kaXY+PC9zZWN0aW9uPjxzZWN0aW9uIGNsYXNzPVwic2xpZGVzaG93XCI+PGgyPkRpYXBvcmFtYTwvaDI+PGRpdiBjbGFzcz1cImNvbnRyb2xzXCI+PGJ1dHRvbiBpZD1cInNsaWRlUHJldmlvdXNcIiB0eXBlPVwiYnV0dG9uXCI+SW1hZ2UgcHLDqWPDqWRlbnRlPC9idXR0b24+PHNwYW4gaWQ9XCJjb3VudGVyXCI+MSAvIDE3PC9zcGFuPjxidXR0b24gaWQ9XCJzbGlkZU5leHRcIiB0eXBlPVwiYnV0dG9uXCI+SW1hZ2Ugc3VpdmFudGU8L2J1dHRvbj48YnV0dG9uIGlkPVwidG9nZ2xlXCIgZGF0YS1wbGF5PVwi4pa2XCIgZGF0YS1wYXVzZT1cIuKFoVwiIGFyaWEtcHJlc3NlZD1cImZhbHNlXCIgdHlwZT1cImJ1dHRvblwiPuKWtjwvYnV0dG9uPjwvZGl2PjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMVwiIGRhdGEtc2Vjb25kcz1cIjZcIiBjbGFzcz1cImFjdGl2ZVwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDEtYWU0MzI1OTRjM2QxLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wMS03M2Q3MjJkZTA3NGMud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDEtNDE5YTQzOWJjNzgyLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiUHJlbWllciBjb250csO0bGUuIFVuIGFnZW50IGNvbW1lbmNlIGxlIGNvbnRyw7RsZSByb3V0aWVyLlwiIGxvYWRpbmc9XCJlYWdlclwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MDEgwrcgUHJlbWllciBjb250csO0bGU8L2gzPjxwPlVuIGFnZW50IGNvbW1lbmNlIGxlIGNvbnRyw7RsZSByb3V0aWVyLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIyXCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDItM2FiOTQ2NzY2YzhkLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wMi1lOTQ2Y2M0MDg2NzYud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDItM2FjODQ2YjVlMmYwLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiVsOpcmlmaWNhdGlvbiBkYW5zIGxlIHbDqWhpY3VsZSBkZSBwb2xpY2UuIEzigJlpZGVudGl0w6kgZHUgY29uZHVjdGV1ciBlc3QgdsOpcmlmacOpZSBzdXIgbGUgdGVybWluYWwgbW9iaWxlLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wMiDCtyBWw6lyaWZpY2F0aW9uIGRhbnMgbGUgdsOpaGljdWxlIGRlIHBvbGljZTwvaDM+PHA+TOKAmWlkZW50aXTDqSBkdSBjb25kdWN0ZXVyIGVzdCB2w6lyaWZpw6llIHN1ciBsZSB0ZXJtaW5hbCBtb2JpbGUuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjNcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0wMy1mZWY5MTk5M2ViYjEud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTAzLWU5MjlhYzgxNDA0ZS53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0wMy0wMTEzYTM4YmVjNDYud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJNYW5kYXQgZOKAmWFycsOqdCBlbiBjb3Vycy4gTOKAmWFnZW50IGx1aSBjb21tdW5pcXVlIGxlIHLDqXN1bHRhdCBkZSBsYSB2w6lyaWZpY2F0aW9uLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wMyDCtyBNYW5kYXQgZOKAmWFycsOqdCBlbiBjb3VyczwvaDM+PHA+TOKAmWFnZW50IGx1aSBjb21tdW5pcXVlIGxlIHLDqXN1bHRhdCBkZSBsYSB2w6lyaWZpY2F0aW9uLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCI0XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDQtNjk1OGJmY2U0OTRjLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wNC1mNzEwNjBkZTM5YmIud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDQtNTJlNzM3Y2UyZjc0LndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiQXJyw6p0IHByw6hzIGRlIGxhIHZvaXR1cmUuIExlIGNvbmR1Y3RldXIgZXN0IGFib3Jkw6kgcHLDqHMgZGUgbGEgdm9pdHVyZSBhcmdlbnTDqWUuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjA0IMK3IEFycsOqdCBwcsOocyBkZSBsYSB2b2l0dXJlPC9oMz48cD5MZSBjb25kdWN0ZXVyIGVzdCBhYm9yZMOpIHByw6hzIGRlIGxhIHZvaXR1cmUgYXJnZW50w6llLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCI1XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDUtYTI5NDYyNTY2YWQ0LndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wNS1jNDRhNmFlYzI1ZmYud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDUtMzBiNWE5ODY3MGM3LndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiQXJyZXN0YXRpb24gYXUgYm9yZCBkZSBsYSByb3V0ZS4gTOKAmWhvbW1lIGVzdCBhcnLDqnTDqSBwcsOocyBkdSB2w6loaWN1bGUuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjA1IMK3IEFycmVzdGF0aW9uIGF1IGJvcmQgZGUgbGEgcm91dGU8L2gzPjxwPkzigJlob21tZSBlc3QgYXJyw6p0w6kgcHLDqHMgZHUgdsOpaGljdWxlLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCI2XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDYtYjM5YmVlMDE5NzExLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wNi04N2U4OGEyM2UwMDEud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDYtM2MwODdmYTUxNWMxLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiU8OpY3VyaXNhdGlvbiBkZSBs4oCZYXJyZXN0YXRpb24uIEzigJlpbnRlcnZlbnRpb24gc2UgcG91cnN1aXQgcHLDqHMgZGUgbGEgdm9pdHVyZS5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MDYgwrcgU8OpY3VyaXNhdGlvbiBkZSBs4oCZYXJyZXN0YXRpb248L2gzPjxwPkzigJlpbnRlcnZlbnRpb24gc2UgcG91cnN1aXQgcHLDqHMgZGUgbGEgdm9pdHVyZS48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiN1wiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTA3LWJhZGYxNGEzMjAyMy53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDctYzZmMGVmNWQwYWQ0LndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTA3LWRmZjRhNmI1Nzc4Zi53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIkTDqXRhaWwgZHUgdsOpaGljdWxlLiBEw6l0YWlsIGRlIGxhIHZvaXR1cmUgZXQgZHUgY29udHLDtGxlLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4wNyDCtyBEw6l0YWlsIGR1IHbDqWhpY3VsZTwvaDM+PHA+RMOpdGFpbCBkZSBsYSB2b2l0dXJlIGV0IGR1IGNvbnRyw7RsZS48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiOFwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTA4LWNjMzQxNTBjYTBlNi53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMDgtOGMxYjk1YTQ3NzE2LndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTA4LWQ3OWY3MTJhMGIyZS53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIlByw6lwYXJhdGlvbiBkdSB0cmFuc2ZlcnQuIEzigJlob21tZSBhcnLDqnTDqSBlc3Qgc8OpY3VyaXPDqSBwb3VyIGxlIHRyYW5zZmVydC5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MDggwrcgUHLDqXBhcmF0aW9uIGR1IHRyYW5zZmVydDwvaDM+PHA+TOKAmWhvbW1lIGFycsOqdMOpIGVzdCBzw6ljdXJpc8OpIHBvdXIgbGUgdHJhbnNmZXJ0LjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCI5XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMDktNjNiMWIzZjJlNWIwLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0wOS1mMThmZGI4ZGU0YzEud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMDktZWM5MTQ3ZTMyMmZlLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiQWNjw6hzIGF1IHbDqWhpY3VsZS4gTOKAmWFjY8OocyBhdSB2w6loaWN1bGUgZXN0IGRvY3VtZW50w6kuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjA5IMK3IEFjY8OocyBhdSB2w6loaWN1bGU8L2gzPjxwPkzigJlhY2PDqHMgYXUgdsOpaGljdWxlIGVzdCBkb2N1bWVudMOpLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIxMFwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTEwLTQ5YmMwOTMwMzYzNC53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMTAtYTc2MTg3MzI1YjExLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTEwLWMzYjE0ZWE0OWUxZC53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIlRyYW5zZmVydCBlbiBnYXJkZSDDoCB2dWUuIEzigJlob21tZSBlc3QgYWNjb21wYWduw6kganVzcXXigJnDoCB1biBmb3VyZ29uIGRlIHBvbGljZSBhbGxlbWFuZC5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MTAgwrcgVHJhbnNmZXJ0IGVuIGdhcmRlIMOgIHZ1ZTwvaDM+PHA+TOKAmWhvbW1lIGVzdCBhY2NvbXBhZ27DqSBqdXNxdeKAmcOgIHVuIGZvdXJnb24gZGUgcG9saWNlIGFsbGVtYW5kLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PGZpZ3VyZSBkYXRhLXN0YXRpb249XCIxMVwiIGRhdGEtc2Vjb25kcz1cIjZcIj48ZGl2IGNsYXNzPVwic2NlbmVcIj48cGljdHVyZT48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDo2NDBweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbW9iaWxlLTExLWI2N2ZjNmEzZjVjZS53ZWJwXCI+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6MTAyNHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90YWJsZXQtMTEtZWY3MTA2MjRhMDJmLndlYnBcIj48aW1nIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9kZXNrdG9wLTExLTIwYTkwNzZiZWJmMC53ZWJwXCIgd2lkdGg9XCIxOTIwXCIgaGVpZ2h0PVwiMTA4MFwiIGFsdD1cIlJlbGFpcyBwcsOocyBkdSBmb3VyZ29uLiBMZSB0cmFuc2ZlcnQgYXUgdsOpaGljdWxlIGVzdCBtb250csOpLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4xMSDCtyBSZWxhaXMgcHLDqHMgZHUgZm91cmdvbjwvaDM+PHA+TGUgdHJhbnNmZXJ0IGF1IHbDqWhpY3VsZSBlc3QgbW9udHLDqS48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMTJcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0xMi03OGUwZTUwZmQ2NmEud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTEyLTM0MjAwODBjMzk5OS53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0xMi1jOGQ0YWEzMjFkNzMud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJGb3VyZ29uIHByw6p0LiBMZSBmb3VyZ29uIGRlIHRyYW5zcG9ydCBlc3QgcHLDqnQuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjEyIMK3IEZvdXJnb24gcHLDqnQ8L2gzPjxwPkxlIGZvdXJnb24gZGUgdHJhbnNwb3J0IGVzdCBwcsOqdC48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMTNcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0xMy04MGU2NDYzNGFhOTkud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTEzLWZhNTM2NjMzZTM4Yy53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0xMy04OTQ4MzQzNTc4OWIud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJUcmFqZXQgdmVycyBsZSBjb21taXNzYXJpYXQuIExhIHPDqXF1ZW5jZSBkZSB0cmFuc2ZlcnQgZGVwdWlzIGxhIHJvdXRlIHNlIHRlcm1pbmUuXCIgbG9hZGluZz1cImxhenlcIj48L3BpY3R1cmU+PC9kaXY+PGZpZ2NhcHRpb24+PGgzPjEzIMK3IFRyYWpldCB2ZXJzIGxlIGNvbW1pc3NhcmlhdDwvaDM+PHA+TGEgc8OpcXVlbmNlIGRlIHRyYW5zZmVydCBkZXB1aXMgbGEgcm91dGUgc2UgdGVybWluZS48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMTRcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0xNC0wMTk0MWFkODNlODYud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTE0LTY4OGFiMjA5NWRmZS53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0xNC02ZTBjYjJmYmU0Y2Yud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJBY2NvbXBhZ25lbWVudCB2ZXJzIGxlIGZvdXJnb24uIERldXggYWdlbnRzIGFjY29tcGFnbmVudCBs4oCZaG9tbWUgYXJyw6p0w6kganVzcXXigJlhdSBmb3VyZ29uIGRlIHBvbGljZSBhbGxlbWFuZC5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MTQgwrcgQWNjb21wYWduZW1lbnQgdmVycyBsZSBmb3VyZ29uPC9oMz48cD5EZXV4IGFnZW50cyBhY2NvbXBhZ25lbnQgbOKAmWhvbW1lIGFycsOqdMOpIGp1c3F14oCZYXUgZm91cmdvbiBkZSBwb2xpY2UgYWxsZW1hbmQuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjE1XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMTUtY2YyMWVlMzg1MjJlLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0xNS1kYTk2M2U3MDA0YmMud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMTUtNzhmNWMwODhlNzA4LndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiU2PDqG5lIGTigJlleGFtZW4gZGlzdGluY3RlLiBTY8OobmUgZmljdGl2ZSBkaXN0aW5jdGUgZOKAmWV4YW1lbiBldCBkZSBkb2N1bWVudGF0aW9uLCBwcsOpc2VudMOpZSBjb21tZSB1biBjaGFuZ2VtZW50IGRlIHNjw6huZSB1bHTDqXJpZXVyLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4xNSDCtyBTY8OobmUgZOKAmWV4YW1lbiBkaXN0aW5jdGU8L2gzPjxwPlNjw6huZSBmaWN0aXZlIGRpc3RpbmN0ZSBk4oCZZXhhbWVuIGV0IGRlIGRvY3VtZW50YXRpb24sIHByw6lzZW50w6llIGNvbW1lIHVuIGNoYW5nZW1lbnQgZGUgc2PDqG5lIHVsdMOpcmlldXIuPC9wPjwvZmlnY2FwdGlvbj48L2ZpZ3VyZT48ZmlndXJlIGRhdGEtc3RhdGlvbj1cIjE2XCIgZGF0YS1zZWNvbmRzPVwiNlwiPjxkaXYgY2xhc3M9XCJzY2VuZVwiPjxwaWN0dXJlPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjY0MHB4KVwiIHNyY3NldD1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9tb2JpbGUtMTYtMTI5MGU1YmFiNTJjLndlYnBcIj48c291cmNlIG1lZGlhPVwiKG1heC13aWR0aDoxMDI0cHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L3RhYmxldC0xNi00NmMxNGIwMzdiYWMud2VicFwiPjxpbWcgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2Rlc2t0b3AtMTYtMGFjMjc0M2EwYTkyLndlYnBcIiB3aWR0aD1cIjE5MjBcIiBoZWlnaHQ9XCIxMDgwXCIgYWx0PVwiR0VTQSDigJMgRXhhbWVuIG3DqWRpY2FsLiDDgCBsYSBHRVNBLCB1bmUgbcOpZGVjaW4gY29uc2lnbmUgbOKAmWV4YW1lbiBtw6lkaWNhbC4gVW5lIGNoYcOubmUgYmllbiB2aXNpYmxlIHJlbGllIGxlcyBtZW5vdHRlcyBwb3J0w6llcyBkZXZhbnQgYXV4IGVudHJhdmVzIGRlcyBjaGV2aWxsZXMgOyBzb24gc3VydsOqdGVtZW50IGV0IHNlcyBjaGF1c3N1cmVzIHJlc3RlbnQgaWRlbnRpcXVlcy5cIiBsb2FkaW5nPVwibGF6eVwiPjwvcGljdHVyZT48L2Rpdj48ZmlnY2FwdGlvbj48aDM+MTYgwrcgR0VTQSDigJMgRXhhbWVuIG3DqWRpY2FsPC9oMz48cD7DgCBsYSBHRVNBLCB1bmUgbcOpZGVjaW4gY29uc2lnbmUgbOKAmWV4YW1lbiBtw6lkaWNhbC4gVW5lIGNoYcOubmUgYmllbiB2aXNpYmxlIHJlbGllIGxlcyBtZW5vdHRlcyBwb3J0w6llcyBkZXZhbnQgYXV4IGVudHJhdmVzIGRlcyBjaGV2aWxsZXMgOyBzb24gc3VydsOqdGVtZW50IGV0IHNlcyBjaGF1c3N1cmVzIHJlc3RlbnQgaWRlbnRpcXVlcy48L3A+PC9maWdjYXB0aW9uPjwvZmlndXJlPjxmaWd1cmUgZGF0YS1zdGF0aW9uPVwiMTdcIiBkYXRhLXNlY29uZHM9XCI2XCI+PGRpdiBjbGFzcz1cInNjZW5lXCI+PHBpY3R1cmU+PHNvdXJjZSBtZWRpYT1cIihtYXgtd2lkdGg6NjQwcHgpXCIgc3Jjc2V0PVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L21vYmlsZS0xNy0yOTIxNWVmZDViZDcud2VicFwiPjxzb3VyY2UgbWVkaWE9XCIobWF4LXdpZHRoOjEwMjRweClcIiBzcmNzZXQ9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvdGFibGV0LTE3LTkwNTU1OTJhODgwMy53ZWJwXCI+PGltZyBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvZGVza3RvcC0xNy03NGNiMWNjZGYwZjAud2VicFwiIHdpZHRoPVwiMTkyMFwiIGhlaWdodD1cIjEwODBcIiBhbHQ9XCJBZG1pc3Npb24gcGFyIGxlIHNhcyBk4oCZZW50csOpZSBkZSBsYSBwcmlzb24uIExlcyBhZ2VudHMgbOKAmWFjY29tcGFnbmVudCBwYXIgbGUgc2FzIGTigJllbnRyw6llIHBvdXIgc29uIGFkbWlzc2lvbi4gTGEgY2hhw65uZSBkb3JzYWxlIHJlbGlhbnQgbGVzIG1lbm90dGVzIHBsYWPDqWVzIGRlcnJpw6hyZSBsdWkgw6AgbGEgY2VpbnR1cmUsIGFpbnNpIHF1ZSBsZSBsaWVuIGVudHJlIGxlcyBlbnRyYXZlcyBhdXggY2hldmlsbGVzLCBzb250IGJpZW4gdmlzaWJsZXMuIExlIGZvdXJnb24sIGxlIHN1cnbDqnRlbWVudCBldCBsZXMgY2hhdXNzdXJlcyBibGFuY2hlcyBldCBibGV1ZXMgcmVzdGVudCBjb2jDqXJlbnRzLlwiIGxvYWRpbmc9XCJsYXp5XCI+PC9waWN0dXJlPjwvZGl2PjxmaWdjYXB0aW9uPjxoMz4xNyDCtyBBZG1pc3Npb24gcGFyIGxlIHNhcyBk4oCZZW50csOpZSBkZSBsYSBwcmlzb248L2gzPjxwPkxlcyBhZ2VudHMgbOKAmWFjY29tcGFnbmVudCBwYXIgbGUgc2FzIGTigJllbnRyw6llIHBvdXIgc29uIGFkbWlzc2lvbi4gTGEgY2hhw65uZSBkb3JzYWxlIHJlbGlhbnQgbGVzIG1lbm90dGVzIHBsYWPDqWVzIGRlcnJpw6hyZSBsdWkgw6AgbGEgY2VpbnR1cmUsIGFpbnNpIHF1ZSBsZSBsaWVuIGVudHJlIGxlcyBlbnRyYXZlcyBhdXggY2hldmlsbGVzLCBzb250IGJpZW4gdmlzaWJsZXMuIExlIGZvdXJnb24sIGxlIHN1cnbDqnRlbWVudCBldCBsZXMgY2hhdXNzdXJlcyBibGFuY2hlcyBldCBibGV1ZXMgcmVzdGVudCBjb2jDqXJlbnRzLjwvcD48L2ZpZ2NhcHRpb24+PC9maWd1cmU+PC9zZWN0aW9uPjxzZWN0aW9uIGlkPVwidmlkZW9cIj48aDI+RGlhcG9yYW1hIG11ZXQ8L2gyPjx2aWRlbyBjb250cm9scyBwbGF5c2lubGluZSBwcmVsb2FkPVwibWV0YWRhdGFcIj48c291cmNlIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS90cmFmZmljLXN0b3Atc2lsZW50LTE2eDktMjc3YTI4MjNhODE2Lm1wNFwiIHR5cGU9XCJ2aWRlby9tcDRcIj48dHJhY2sga2luZD1cInN1YnRpdGxlc1wiIHNyYz1cImh0dHBzOi8vd3d3LmRvbnR0ZWxsdXMuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9kdHUtc2VyaWVzLXN0YWdpbmcvRFRULVBTLTIwMjYtMTAtMTAtVFJBRkZJQy1TVE9QLTAzL2FwcHJvdmVkMTZ4OS9jYXB0aW9ucy1kZS05YjE2YTMyM2FiOWMudnR0XCIgc3JjbGFuZz1cImRlXCIgbGFiZWw9XCJEZXV0c2NoXCI+PHRyYWNrIGtpbmQ9XCJzdWJ0aXRsZXNcIiBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvY2FwdGlvbnMtZW4tOTJmZTkyNWIzNWViLnZ0dFwiIHNyY2xhbmc9XCJlblwiIGxhYmVsPVwiRW5nbGlzaFwiPjx0cmFjayBraW5kPVwic3VidGl0bGVzXCIgc3JjPVwiaHR0cHM6Ly93d3cuZG9udHRlbGx1cy5jb20vd3AtY29udGVudC91cGxvYWRzL2R0dS1zZXJpZXMtc3RhZ2luZy9EVFQtUFMtMjAyNi0xMC0xMC1UUkFGRklDLVNUT1AtMDMvYXBwcm92ZWQxNng5L2NhcHRpb25zLWVzLWVlYTRjYjIwZGEwZi52dHRcIiBzcmNsYW5nPVwiZXNcIiBsYWJlbD1cIkVzcGHDsW9sXCI+PHRyYWNrIGtpbmQ9XCJzdWJ0aXRsZXNcIiBzcmM9XCJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvY2FwdGlvbnMtZnItZjMyMDA4YWNhY2U1LnZ0dFwiIHNyY2xhbmc9XCJmclwiIGxhYmVsPVwiRnJhbsOnYWlzXCIgZGVmYXVsdD48L3ZpZGVvPjxwPkF1Y3VuZSBuYXJyYXRpb24gYXVkaW8gY3LDqcOpZS48L3A+PC9zZWN0aW9uPjwvZGl2PiIsImNvbnRlbnRfc2hhMjU2IjoiYTM5MDNiOTE2ODUyY2YyN2IwNTVhZGY4YTNmZjE5ZGQxZGE1MmFhYmZjOWU5OWIyMzUyMDM1ZTkxNzY0YjczYiIsInBhbmVsX2NvdW50IjoxNywiY2hhcHRlcl9jb3VudCI6MTcsInN0b3J5X3dvcmRzIjoxMzEsImF1ZGlvX21vZGUiOiJ0ZXh0X29ubHkiLCJuYXJyYXRpb25fbGFuZ3VhZ2UiOm51bGwsInZpZGVvX3NoYTI1NiI6IjI3N2EyODIzYTgxNjQ2MDRmZDI0YjBkYjE3NDUxYTVjZTcwMDExNTBhM2I3ZjQwZTVlYzA2NzA5OTE4NjI0MjAifX0sImF1ZGlvIjp7Imxhbmd1YWdlIjoiZGUiLCJ1cmwiOiJodHRwczovL3d3dy5kb250dGVsbHVzLmNvbS93cC1jb250ZW50L3VwbG9hZHMvZHR1LXNlcmllcy1zdGFnaW5nL0RUVC1QUy0yMDI2LTEwLTEwLVRSQUZGSUMtU1RPUC0wMy9hcHByb3ZlZDE2eDkvbmFycmF0aW9uLWRlLWNhMTAxZGM4YjBhOC5tcDMiLCJzaGEyNTYiOiJjYTEwMWRjOGIwYTgxYTkzYjVlZGNhZjFiYTg0OTYzNmExN2I0OTMzYzQzYmY2MTEwMzI1N2JhMWQ0OGQyNzUwIiwiZm9ybWF0IjoibXAzIiwiZHVyYXRpb25fc2Vjb25kcyI6NjIyfX0=--><\/p>\n<div class=\"dtu-review-story dtu-approved16x9\">\n<nav aria-label=\"Languages\"><a href=\"https:\/\/www.donttellus.com\/de\/bildserien\/aus-dem-auto-verhaftet-bei-verkehrskontrolle\/\" aria-current=\"page\">Deutsch<\/a><a href=\"https:\/\/www.donttellus.com\/en_us\/bildserien\/aus-dem-auto-verhaftet-bei-verkehrskontrolle\/\">English<\/a><a href=\"https:\/\/www.donttellus.com\/es\/bildserien\/aus-dem-auto-verhaftet-bei-verkehrskontrolle\/\">Espa\u00f1ol<\/a><a href=\"https:\/\/www.donttellus.com\/fr\/bildserien\/aus-dem-auto-verhaftet-bei-verkehrskontrolle\/\">Fran\u00e7ais<\/a><\/nav>\n<h1>Aus dem Auto verhaftet bei Verkehrskontrolle<\/h1>\n<aside class=\"notice\">Fiktionale, inszenierte Bildgeschichte. Keine reale Festnahme oder beh\u00f6rdliche Dokumentation.<\/aside>\n<section id=\"narrative\">\n<h2>Die Geschichte<\/h2>\n<p># Aus dem Auto verhaftet bei Verkehrskontrolle<\/p>\n<p>Fiktionale, inszenierte Bildgeschichte. Keine reale Festnahme oder beh\u00f6rdliche Dokumentation.<\/p>\n<p>Als die ersten blauen Lichtreflexe \u00fcber die Motorhaube wandern, ist der Abend noch nicht ganz dunkel. Die Landstra\u00dfe liegt zwischen Feldern und einer Leitplanke; der Verkehr rauscht weiter, obwohl f\u00fcr den Fahrer im silbernen Wagen gerade alles langsamer zu werden scheint. Ein uniformierter Beamter tritt an die ge\u00f6ffnete Fahrerseite. Er spricht ruhig und wartet, w\u00e4hrend der Mann am Steuer versucht, die Situation einzuordnen. Von au\u00dfen sieht es zun\u00e4chst nach einer gew\u00f6hnlichen Kontrolle aus. F\u00fcr ihn ist es der Moment, in dem eine allt\u00e4gliche Fahrt pl\u00f6tzlich eine andere Richtung nimmt.<\/p>\n<p>Im Streifenwagen leuchtet das mobile Terminal. Ein Beamter gleicht die Angaben ab, w\u00e4hrend drau\u00dfen die Signale der Einsatzfahrzeuge auf dem Lack des silbernen Autos flackern. Die Zahlen und Zeilen auf dem Bildschirm sind f\u00fcr den Fahrer nicht lesbar; f\u00fcr die Geschichte ist entscheidend, dass eine Abfrage stattfindet und dass die Beamten danach anders auf ihn zugehen. Die Szene bleibt bewusst bei dem, was sichtbar ist: ein konzentrierter Blick, ein Ger\u00e4t im Einsatz und eine kurze Pause, in der niemand wei\u00df, was als N\u00e4chstes gesagt werden wird.<\/p>\n<p>Der Beamte kehrt zum Wagen zur\u00fcck. Nun ist die Kontrolle keine blo\u00dfe Pr\u00fcfung von Fahrzeugpapieren mehr. Er teilt dem Fahrer mit, dass bei der Abfrage ein offener Haftbefehl angezeigt wird. Der Mann h\u00f6rt zu und schaut zwischen dem Beamten und dem Streifenwagen hin und her. Die Bilder legen keine zus\u00e4tzlichen Gr\u00fcnde, Vorw\u00fcrfe oder Einzelheiten fest; sie zeigen nur die Nachricht und die unmittelbare Reaktion darauf. In diesem Augenblick versteht er, dass er nicht einfach weiterfahren wird. Der bisherige Plan f\u00fcr den Abend verliert seine Bedeutung, bevor er \u00fcberhaupt Gelegenheit hat, ihn zu erkl\u00e4ren.<\/p>\n<p>Der Fahrer steigt aus dem silbernen Wagen. Die T\u00fcren bleiben offen, die Lichtbalken spiegeln sich in den Fenstern, und die Landstra\u00dfe bildet eine unbeteiligte Kulisse. Ein Beamter spricht mit ihm, ein weiterer h\u00e4lt Abstand und beobachtet die Umgebung. Der Mann tr\u00e4gt einen dunklen Trainingsanzug mit hellen Streifen und wei\u00df-blaue Sportschuhe. Diese Kleidung begleitet den sp\u00e4teren Teil der Geschichte und wird zu einem visuellen Anker: W\u00e4hrend Ort und Situation wechseln, bleibt sie in den folgenden Bildern wiedererkennbar. Noch steht er neben seinem Auto; doch seine Aufmerksamkeit gilt l\u00e4ngst nicht mehr dem Verkehr.<\/p>\n<p>Als die Festnahme er\u00f6ffnet wird, hebt der Mann die H\u00e4nde und folgt den knappen Anweisungen. Die Beamten sichern ihn am Stra\u00dfenrand und halten die Situation \u00fcbersichtlich. Die Szene ist angespannt, aber nicht als Kampf erz\u00e4hlt. Niemand rennt, niemand schl\u00e4gt zu; im Zentrum steht der \u00dcbergang von einer Kontrolle zu einer Festnahme. Der Fahrer sieht auf den Boden, dann zu den Polizisten. Hinter ihm warten das Auto und die vorbeifahrenden Fahrzeuge. Vor ihm liegen die n\u00e4chsten Schritte, \u00fcber die er nicht mehr selbst entscheidet. Die Bilder halten diesen Wechsel fest, ohne ihn zu einem Urteil \u00fcber den Mann zu machen.<\/p>\n<p>Die Sicherung wird neben dem Fahrzeug fortgesetzt. Ein Beamter bleibt nahe bei ihm, w\u00e4hrend ein anderer den Ablauf beobachtet. Die H\u00e4nde des Festgenommenen werden kontrolliert gehalten; seine K\u00f6rperhaltung ist angespannt. Er versucht, den Blick ruhig zu halten, doch die ungewohnte N\u00e4he der Einsatzkr\u00e4fte macht die Situation unmittelbar. Es gibt keine dramatische Geste, die erkl\u00e4ren k\u00f6nnte, was er denkt. Gerade die kleinen Details tragen die Szene: das offene Autot\u00fcr, die nasse Stra\u00dfe, das reflektierende Blaulicht und die Schuhe, die auf dem Asphalt stehen. Der Weg zur\u00fcck ins Auto ist keine Option mehr.<\/p>\n<p>Ein Detailbild lenkt den Blick auf den silbernen Wagen. Das Vorderrad, die nasse Fahrbahn und die Lichter der Polizei erz\u00e4hlen von dem Ort, an dem die Fahrt unterbrochen wurde. Der Wagen ist mehr als ein Requisit: Er steht f\u00fcr den Alltag, der bis eben noch selbstverst\u00e4ndlich war. Nun wird er zum zur\u00fcckgelassenen Gegenstand am Stra\u00dfenrand. In der Ferne bleiben die Beamten und der Festgenommene sichtbar. Die Aufnahme verweilt kurz bei der Umgebung, bevor die Geschichte weitergeht. So bekommt der Betrachter einen Moment zum Durchatmen und kann den Wechsel vom privaten Raum des Autos in eine offizielle Situation nachvollziehen.<\/p>\n<p>F\u00fcr den Transport wird der Mann zum Einsatzfahrzeug begleitet. Die Beamten bewegen sich kontrolliert und bleiben dicht genug, um ihn zu f\u00fchren. Seine Arme sind gesichert; die Darstellung macht deutlich, dass er nicht selbst den n\u00e4chsten Weg ausw\u00e4hlt. Gleichzeitig bleibt sein Gesicht sichtbar und die Szene konzentriert sich auf die Begleitung, nicht auf eine Verletzung. Die wei\u00dfen und blauen Schuhe setzen sich deutlich vom dunklen Trainingsanzug und vom grauen Asphalt ab. Das wiederkehrende Detail hilft, die Folge zu lesen: Es ist derselbe Festgenommene, der nun vom Ort der Kontrolle weggef\u00fchrt wird.<\/p>\n<p>Die offene T\u00fcr des Transporters markiert eine Schwelle. Drau\u00dfen liegen die Stra\u00dfe und das silberne Auto; dahinter beginnt der Innenraum des deutschen Gefangenentransporters mit seiner Trennwand. Ein Beamter bereitet die \u00dcbergabe vor, w\u00e4hrend der Festgenommene nahe am Einstieg wartet. Das Bild zeigt nicht, was im Fahrzeug gesprochen wird oder welche administrativen Schritte stattfinden. Es zeigt den r\u00e4umlichen Wechsel: vom \u00f6ffentlichen Stra\u00dfenrand in einen begrenzten, gesicherten Innenraum. Der Abstand zwischen den Orten ist klein, doch f\u00fcr die Figur f\u00fchlt er sich gro\u00df an. Der Wagen, mit dem er gekommen ist, bleibt hinter ihm zur\u00fcck.<\/p>\n<p>Am Transporter treffen die Beteiligten erneut zusammen. Ein Beamter steht an der offenen Heckklappe, ein anderer h\u00e4lt den Mann in seiner N\u00e4he. Die Beleuchtung im Innenraum wirkt w\u00e4rmer als das blaue Abendlicht drau\u00dfen. Der Festgenommene schaut kurz zur Seite, als wolle er sich noch einmal orientieren. Der Ablauf wird in mehreren Bildern aus leicht ver\u00e4nderten Blickwinkeln gezeigt, nicht als mehrere verschiedene Festnahmen. Diese Wiederholung macht den \u00dcbergang nachvollziehbarer: erst die Vorbereitung, dann die Begleitung, schlie\u00dflich das Ankommen am Fahrzeug. Die Kleidung und die wei\u00df-blauen Schuhe helfen, den Zusammenhang zu halten.<\/p>\n<p>Der Mann wird zum Einstieg gef\u00fchrt. Seine Bewegungen sind vorsichtig, weil die Situation ungewohnt ist und die Beamten ihn kontrolliert begleiten. Er tr\u00e4gt weiterhin denselben dunklen Trainingsanzug. Die offene Fahrzeugt\u00fcr gibt den Blick auf den gesicherten Innenraum frei, w\u00e4hrend drau\u00dfen der Streifenwagen und die Landstra\u00dfe zur\u00fccktreten. In diesem Moment wird aus der Verkehrskontrolle eine \u00dcberstellung. Die Bilder behaupten nicht, dass ein bestimmtes Standardverfahren abgebildet wird; sie erz\u00e4hlen die konkrete fiktive Szene, die f\u00fcr diese Bildgeschichte gestaltet wurde. Der Fokus liegt auf dem Wechsel von einem Ort zum n\u00e4chsten und auf der Unsicherheit des Festgenommenen.<\/p>\n<p>Noch einmal wird der Transporter von au\u00dfen gezeigt. Die Einsatzfahrzeuge stehen am Stra\u00dfenrand, die T\u00fcren sind ge\u00f6ffnet, und die Beamten ordnen sich f\u00fcr die Abfahrt. Der Festgenommene bleibt zwischen ihnen und dem Fahrzeug. Die Szene ist weniger eine neue Handlung als ein ruhiger Abschluss des Stra\u00dfenabschnitts. Sie l\u00e4sst den Betrachter erkennen, dass die Kontrolle vorbei ist und der n\u00e4chste Teil an einem anderen Ort spielen wird. Der Himmel ist inzwischen dunkler geworden; das Restlicht am Horizont kontrastiert mit den blauen Signalen. Die Stra\u00dfe l\u00e4uft weiter, aber f\u00fcr den Mann ist die Fahrt nicht mehr seine eigene.<\/p>\n<p>Die Abfahrt beendet die Bilderfolge am Stra\u00dfenrand. Der Transporter setzt die Geschichte fort, ohne dass die Fahrt selbst ausgeschm\u00fcckt werden muss. Es gibt keine erfundenen Dialoge aus dem Fahrzeug und keine zus\u00e4tzlichen Behauptungen \u00fcber eine reale Dienststelle. Der Bildwechsel erf\u00fcllt eine einfache erz\u00e4hlerische Aufgabe: Er verbindet den Ort der Festnahme mit dem sp\u00e4teren Aufnahmebereich. Wer die vorherigen Szenen verfolgt hat, kann die Kleidung und die Schuhe als Kontinuit\u00e4tsmerkmale wiedererkennen. Der Festgenommene ist nicht mehr am eigenen Wagen; er wird nun von den Beamten an den n\u00e4chsten Abschnitt \u00fcbergeben.<\/p>\n<p>Die Begleitung zum Transporter bildet den letzten deutlichen Moment drau\u00dfen. Zwei Beamte flankieren den Mann, ein weiterer bleibt beim silbernen Auto. Die Szene verbindet die Verkehrskontrolle mit dem Abtransport und schafft einen Abschluss, bevor sich die Umgebung \u00e4ndert. Der Festgenommene schaut nach vorn. Die Bilder zeigen keine triumphierende Haltung und keine moralische Bewertung, sondern eine n\u00fcchterne, inszenierte Situation. Die blaue Stunde, die reflektierenden Streifen und die offenen T\u00fcren halten die Atmosph\u00e4re zusammen. Mit dem Schritt in den Transporter endet der Stra\u00dfenabschnitt; die n\u00e4chsten Bilder springen in den Aufnahmebereich.<\/p>\n<p>Bild 15 f\u00fchrt in einen hellen Innenraum und kennzeichnet damit einen zeitlichen und r\u00e4umlichen Sprung. Ein medizinischer Mitarbeiter untersucht den Schuh des Mannes, ein Beamter dokumentiert den Vorgang, und der Festgenommene steht in seinem dunklen Trainingsanzug daneben. Dieses Bild ist als \u00dcbergang in die medizinische Aufnahme gedacht, nicht als Szene am Stra\u00dfenrand. Zwischen der Kontrolle und dieser Untersuchung liegt Zeit, die in der Bildserie nicht einzeln erz\u00e4hlt wird. Die helle, sachliche Umgebung unterscheidet sich deutlich vom Abend drau\u00dfen. Sie macht sichtbar, dass nun ein anderer Abschnitt beginnt, ohne eine konkrete medizinische Diagnose oder einen realen Befund zu behaupten.<\/p>\n<p>In der GESA wird die medizinische Untersuchung dokumentiert. Der Mann sitzt bekleidet auf einer Bank; ein Arzt ist anwesend, ein Beamter h\u00e4lt die Situation fest. Die Darstellung bleibt sachlich und nicht intim. Die sichtbar verbundene Sicherung an H\u00e4nden und Fu\u00dfgelenken geh\u00f6rt zur inszenierten Bildkomposition dieser Geschichte. Trainingsanzug und Schuhe bleiben gleich, damit das Bild an den vorherigen Abschnitt anschlie\u00dft. Die GESA-Beschilderung ordnet den Ort ein, ohne eine bestimmte Einrichtung oder einen echten Vorgang abzubilden. F\u00fcr den Festgenommenen bedeutet der Raum einen weiteren Wechsel: Nach der Stra\u00dfe und dem Transporter befindet er sich nun in einem hellen Aufnahmebereich, in dem andere Personen den Ablauf bestimmen.<\/p>\n<p>Am Ende f\u00fchrt der Weg in die Eingangsschleuse der Justizvollzugsanstalt. Das Schild macht den neuen Ort erkennbar; hinter den Glast\u00fcren setzt sich der gesicherte Innenbereich fort. Zwei Beamte begleiten den Mann hinein. Seine H\u00e4nde sind hinter dem K\u00f6rper gesichert, und die R\u00fcckenkette zum H\u00fcftgurt sowie die Verbindung an den Fu\u00dfschellen sind in der Szene sichtbar. Die Kleidung und die Schuhe entsprechen dem vorangegangenen Aufnahmeabschnitt. Das Bild schlie\u00dft die Geschichte nicht mit einem Urteil oder einer Erkl\u00e4rung ab, sondern mit einer Schwelle: Drau\u00dfen liegen die Stra\u00dfe und das Auto, drinnen beginnt die JVA-Aufnahme. Was danach geschieht, bleibt bewusst au\u00dferhalb dieser Bildfolge.<\/p>\n<p>So endet die fiktive Geschichte dort, wo die Kontrolle endg\u00fcltig in eine Aufnahme \u00fcbergeht. Die Abfolge f\u00fchrt vom ersten Gespr\u00e4ch am Wagen \u00fcber die Mitteilung des Haftbefehls und die Festnahme bis zum Transport, zur GESA und schlie\u00dflich zur JVA-Eingangsschleuse. Die wiederkehrenden Kleidungsst\u00fccke, die Schuhe und die verschiedenen Beschilderungen geben Orientierung. Einzelne administrative oder medizinische Details bleiben offen, weil die Bilder sie nicht zuverl\u00e4ssig belegen. Die Serie ist eine inszenierte Erz\u00e4hlung und keine Dokumentation eines tats\u00e4chlichen Einsatzes. Ihr Schluss ist deshalb kein Kommentar \u00fcber Schuld oder Unschuld, sondern der sichtbare \u00dcbergang einer Figur aus dem Alltag in einen vollst\u00e4ndig fremdbestimmten institutionellen Ablauf.<\/p>\n<\/section>\n<section id=\"story\">\n<h2>Alle Szenen<\/h2>\n<div class=\"gallery\">\n<figure data-station=\"1\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-01-ae432594c3d1.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-01-73d722de074c.webp\"><img fetchpriority=\"high\" decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-01-419a439bc782.webp\" width=\"1920\" height=\"1080\" alt=\"Erste Kontrolle. Der Beamte nimmt die erste Kontrolle auf.\" loading=\"eager\"><\/picture><\/div><figcaption>\n<h3>01 \u00b7 Erste Kontrolle<\/h3>\n<p>Der Beamte nimmt die erste Kontrolle auf.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"2\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-02-3ab946766c8d.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-02-e946cc408676.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-02-3ac846b5e2f0.webp\" width=\"1920\" height=\"1080\" alt=\"Abfrage im Streifenwagen. Die Personalien werden \u00fcber das mobile Terminal gepr\u00fcft.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>02 \u00b7 Abfrage im Streifenwagen<\/h3>\n<p>Die Personalien werden \u00fcber das mobile Terminal gepr\u00fcft.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"3\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-03-fef91993ebb1.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-03-e929ac81404e.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-03-0113a38bec46.webp\" width=\"1920\" height=\"1080\" alt=\"Der offene Haftbefehl. Der Beamte teilt das Ergebnis der Abfrage mit.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>03 \u00b7 Der offene Haftbefehl<\/h3>\n<p>Der Beamte teilt das Ergebnis der Abfrage mit.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"4\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-04-6958bfce494c.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-04-f71060de39bb.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-04-52e737ce2f74.webp\" width=\"1920\" height=\"1080\" alt=\"Anhalten am Fahrzeug. Der Fahrer wird am silbernen Wagen angesprochen.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>04 \u00b7 Anhalten am Fahrzeug<\/h3>\n<p>Der Fahrer wird am silbernen Wagen angesprochen.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"5\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-05-a29462566ad4.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-05-c44a6aec25ff.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-05-30b5a98670c7.webp\" width=\"1920\" height=\"1080\" alt=\"Festnahme am Stra\u00dfenrand. Der Mann wird neben dem Wagen festgenommen.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>05 \u00b7 Festnahme am Stra\u00dfenrand<\/h3>\n<p>Der Mann wird neben dem Wagen festgenommen.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"6\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-06-b39bee019711.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-06-87e88a23e001.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-06-3c087fa515c1.webp\" width=\"1920\" height=\"1080\" alt=\"Kontrollierte Sicherung. Die Festnahme wird am Fahrzeug fortgesetzt.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>06 \u00b7 Kontrollierte Sicherung<\/h3>\n<p>Die Festnahme wird am Fahrzeug fortgesetzt.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"7\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-07-badf14a32023.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-07-c6f0ef5d0ad4.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-07-dff4a6b5778f.webp\" width=\"1920\" height=\"1080\" alt=\"Detail am Fahrzeug. Detailansicht des Fahrzeugs und der Kontrolle.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>07 \u00b7 Detail am Fahrzeug<\/h3>\n<p>Detailansicht des Fahrzeugs und der Kontrolle.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"8\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-08-cc34150ca0e6.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-08-8c1b95a47716.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-08-d79f712a0b2e.webp\" width=\"1920\" height=\"1080\" alt=\"Abtransport wird vorbereitet. Der Festgenommene wird f\u00fcr den Transport gesichert.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>08 \u00b7 Abtransport wird vorbereitet<\/h3>\n<p>Der Festgenommene wird f\u00fcr den Transport gesichert.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"9\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-09-63b1b3f2e5b0.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-09-f18fdb8de4c1.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-09-ec9147e322fe.webp\" width=\"1920\" height=\"1080\" alt=\"Fahrzeugzugang. Der Zugang zum Fahrzeug wird dokumentiert.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>09 \u00b7 Fahrzeugzugang<\/h3>\n<p>Der Zugang zum Fahrzeug wird dokumentiert.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"10\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-10-49bc09303634.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-10-a76187325b11.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-10-c3b14ea49e1d.webp\" width=\"1920\" height=\"1080\" alt=\"Transport zum Gewahrsam. Der Festgenommene wird zum deutschen Gefangenentransporter begleitet.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>10 \u00b7 Transport zum Gewahrsam<\/h3>\n<p>Der Festgenommene wird zum deutschen Gefangenentransporter begleitet.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"11\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-11-b67fc6a3f5ce.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-11-ef710624a02f.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-11-20a9076bebf0.webp\" width=\"1920\" height=\"1080\" alt=\"\u00dcbergabe am Transporter. Die \u00dcbergabe am Transportfahrzeug wird gezeigt.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>11 \u00b7 \u00dcbergabe am Transporter<\/h3>\n<p>Die \u00dcbergabe am Transportfahrzeug wird gezeigt.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"12\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-12-78e0e50fd66a.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-12-3420080c3999.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-12-c8d4aa321d73.webp\" width=\"1920\" height=\"1080\" alt=\"Sicherung am Transporter. Der Transporter ist bereit.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>12 \u00b7 Sicherung am Transporter<\/h3>\n<p>Der Transporter ist bereit.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"13\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-13-80e64634aa99.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-13-fa536633e38c.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-13-89483435789b.webp\" width=\"1920\" height=\"1080\" alt=\"Fahrt zur Dienststelle. Der Abtransport wird abgeschlossen.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>13 \u00b7 Fahrt zur Dienststelle<\/h3>\n<p>Der Abtransport wird abgeschlossen.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"14\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-14-01941ad83e86.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-14-688ab2095dfe.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-14-6e0cb2fbe4cf.webp\" width=\"1920\" height=\"1080\" alt=\"Begleitung zum Transporter. Der Festgenommene wird von zwei Beamten zum deutschen Gefangenentransporter begleitet.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>14 \u00b7 Begleitung zum Transporter<\/h3>\n<p>Der Festgenommene wird von zwei Beamten zum deutschen Gefangenentransporter begleitet.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"15\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-15-cf21ee38522e.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-15-da963e7004bc.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-15-78f5c088e708.webp\" width=\"1920\" height=\"1080\" alt=\"Abweichende Untersuchungs-Szene. Separates, fiktionales Untersuchungs- und Dokumentationsmotiv als nachgelagerter Szenenwechsel.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>15 \u00b7 Abweichende Untersuchungs-Szene<\/h3>\n<p>Separates, fiktionales Untersuchungs- und Dokumentationsmotiv als nachgelagerter Szenenwechsel.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"16\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-16-1290e5bab52c.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-16-46c14b037bac.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-16-0ac2743a0a92.webp\" width=\"1920\" height=\"1080\" alt=\"GESA \u2013 Medizinische Untersuchung. In der GESA dokumentiert eine \u00c4rztin die medizinische Untersuchung. Eine deutlich sichtbare Kette verbindet die vorne angelegten Handfesseln mit den Fu\u00dfschellen; Trainingsanzug und Schuhe bleiben unver\u00e4ndert.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>16 \u00b7 GESA \u2013 Medizinische Untersuchung<\/h3>\n<p>In der GESA dokumentiert eine \u00c4rztin die medizinische Untersuchung. Eine deutlich sichtbare Kette verbindet die vorne angelegten Handfesseln mit den Fu\u00dfschellen; Trainingsanzug und Schuhe bleiben unver\u00e4ndert.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"17\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-17-29215efd5bd7.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-17-9055592a8803.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-17-74cb1ccdf0f0.webp\" width=\"1920\" height=\"1080\" alt=\"Aufnahme in der JVA-Eingangsschleuse. Die Beamten f\u00fchren ihn zur JVA-Aufnahme durch die Eingangsschleuse. Die R\u00fcckenkette von den hinter dem K\u00f6rper angelegten Handfesseln zum H\u00fcftgurt sowie die Verbindung zwischen den Fu\u00dfschellen sind deutlich sichtbar. Transporter, Trainingsanzug und wei\u00df-blaue Schuhe bleiben konsistent.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>17 \u00b7 Aufnahme in der JVA-Eingangsschleuse<\/h3>\n<p>Die Beamten f\u00fchren ihn zur JVA-Aufnahme durch die Eingangsschleuse. Die R\u00fcckenkette von den hinter dem K\u00f6rper angelegten Handfesseln zum H\u00fcftgurt sowie die Verbindung zwischen den Fu\u00dfschellen sind deutlich sichtbar. Transporter, Trainingsanzug und wei\u00df-blaue Schuhe bleiben konsistent.<\/p>\n<\/figcaption><\/figure>\n<\/div>\n<div class=\"controls\"><button id=\"previous\" type=\"button\">Vorheriges Bild<\/button><span id=\"carouselCounter\">1 \/ 17<\/span><button id=\"next\" type=\"button\">N\u00e4chstes Bild<\/button><\/div>\n<div class=\"carousel\" tabindex=\"0\" aria-label=\"Aus dem Auto verhaftet bei Verkehrskontrolle\">\n<figure data-station=\"1\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-01-ae432594c3d1.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-01-73d722de074c.webp\"><img fetchpriority=\"high\" decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-01-419a439bc782.webp\" width=\"1920\" height=\"1080\" alt=\"Erste Kontrolle. Der Beamte nimmt die erste Kontrolle auf.\" loading=\"eager\"><\/picture><\/div><figcaption>\n<h3>01 \u00b7 Erste Kontrolle<\/h3>\n<p>Der Beamte nimmt die erste Kontrolle auf.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"2\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-02-3ab946766c8d.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-02-e946cc408676.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-02-3ac846b5e2f0.webp\" width=\"1920\" height=\"1080\" alt=\"Abfrage im Streifenwagen. Die Personalien werden \u00fcber das mobile Terminal gepr\u00fcft.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>02 \u00b7 Abfrage im Streifenwagen<\/h3>\n<p>Die Personalien werden \u00fcber das mobile Terminal gepr\u00fcft.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"3\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-03-fef91993ebb1.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-03-e929ac81404e.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-03-0113a38bec46.webp\" width=\"1920\" height=\"1080\" alt=\"Der offene Haftbefehl. Der Beamte teilt das Ergebnis der Abfrage mit.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>03 \u00b7 Der offene Haftbefehl<\/h3>\n<p>Der Beamte teilt das Ergebnis der Abfrage mit.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"4\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-04-6958bfce494c.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-04-f71060de39bb.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-04-52e737ce2f74.webp\" width=\"1920\" height=\"1080\" alt=\"Anhalten am Fahrzeug. Der Fahrer wird am silbernen Wagen angesprochen.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>04 \u00b7 Anhalten am Fahrzeug<\/h3>\n<p>Der Fahrer wird am silbernen Wagen angesprochen.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"5\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-05-a29462566ad4.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-05-c44a6aec25ff.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-05-30b5a98670c7.webp\" width=\"1920\" height=\"1080\" alt=\"Festnahme am Stra\u00dfenrand. Der Mann wird neben dem Wagen festgenommen.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>05 \u00b7 Festnahme am Stra\u00dfenrand<\/h3>\n<p>Der Mann wird neben dem Wagen festgenommen.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"6\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-06-b39bee019711.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-06-87e88a23e001.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-06-3c087fa515c1.webp\" width=\"1920\" height=\"1080\" alt=\"Kontrollierte Sicherung. Die Festnahme wird am Fahrzeug fortgesetzt.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>06 \u00b7 Kontrollierte Sicherung<\/h3>\n<p>Die Festnahme wird am Fahrzeug fortgesetzt.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"7\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-07-badf14a32023.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-07-c6f0ef5d0ad4.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-07-dff4a6b5778f.webp\" width=\"1920\" height=\"1080\" alt=\"Detail am Fahrzeug. Detailansicht des Fahrzeugs und der Kontrolle.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>07 \u00b7 Detail am Fahrzeug<\/h3>\n<p>Detailansicht des Fahrzeugs und der Kontrolle.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"8\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-08-cc34150ca0e6.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-08-8c1b95a47716.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-08-d79f712a0b2e.webp\" width=\"1920\" height=\"1080\" alt=\"Abtransport wird vorbereitet. Der Festgenommene wird f\u00fcr den Transport gesichert.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>08 \u00b7 Abtransport wird vorbereitet<\/h3>\n<p>Der Festgenommene wird f\u00fcr den Transport gesichert.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"9\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-09-63b1b3f2e5b0.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-09-f18fdb8de4c1.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-09-ec9147e322fe.webp\" width=\"1920\" height=\"1080\" alt=\"Fahrzeugzugang. Der Zugang zum Fahrzeug wird dokumentiert.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>09 \u00b7 Fahrzeugzugang<\/h3>\n<p>Der Zugang zum Fahrzeug wird dokumentiert.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"10\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-10-49bc09303634.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-10-a76187325b11.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-10-c3b14ea49e1d.webp\" width=\"1920\" height=\"1080\" alt=\"Transport zum Gewahrsam. Der Festgenommene wird zum deutschen Gefangenentransporter begleitet.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>10 \u00b7 Transport zum Gewahrsam<\/h3>\n<p>Der Festgenommene wird zum deutschen Gefangenentransporter begleitet.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"11\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-11-b67fc6a3f5ce.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-11-ef710624a02f.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-11-20a9076bebf0.webp\" width=\"1920\" height=\"1080\" alt=\"\u00dcbergabe am Transporter. Die \u00dcbergabe am Transportfahrzeug wird gezeigt.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>11 \u00b7 \u00dcbergabe am Transporter<\/h3>\n<p>Die \u00dcbergabe am Transportfahrzeug wird gezeigt.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"12\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-12-78e0e50fd66a.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-12-3420080c3999.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-12-c8d4aa321d73.webp\" width=\"1920\" height=\"1080\" alt=\"Sicherung am Transporter. Der Transporter ist bereit.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>12 \u00b7 Sicherung am Transporter<\/h3>\n<p>Der Transporter ist bereit.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"13\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-13-80e64634aa99.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-13-fa536633e38c.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-13-89483435789b.webp\" width=\"1920\" height=\"1080\" alt=\"Fahrt zur Dienststelle. Der Abtransport wird abgeschlossen.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>13 \u00b7 Fahrt zur Dienststelle<\/h3>\n<p>Der Abtransport wird abgeschlossen.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"14\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-14-01941ad83e86.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-14-688ab2095dfe.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-14-6e0cb2fbe4cf.webp\" width=\"1920\" height=\"1080\" alt=\"Begleitung zum Transporter. Der Festgenommene wird von zwei Beamten zum deutschen Gefangenentransporter begleitet.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>14 \u00b7 Begleitung zum Transporter<\/h3>\n<p>Der Festgenommene wird von zwei Beamten zum deutschen Gefangenentransporter begleitet.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"15\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-15-cf21ee38522e.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-15-da963e7004bc.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-15-78f5c088e708.webp\" width=\"1920\" height=\"1080\" alt=\"Abweichende Untersuchungs-Szene. Separates, fiktionales Untersuchungs- und Dokumentationsmotiv als nachgelagerter Szenenwechsel.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>15 \u00b7 Abweichende Untersuchungs-Szene<\/h3>\n<p>Separates, fiktionales Untersuchungs- und Dokumentationsmotiv als nachgelagerter Szenenwechsel.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"16\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-16-1290e5bab52c.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-16-46c14b037bac.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-16-0ac2743a0a92.webp\" width=\"1920\" height=\"1080\" alt=\"GESA \u2013 Medizinische Untersuchung. In der GESA dokumentiert eine \u00c4rztin die medizinische Untersuchung. Eine deutlich sichtbare Kette verbindet die vorne angelegten Handfesseln mit den Fu\u00dfschellen; Trainingsanzug und Schuhe bleiben unver\u00e4ndert.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>16 \u00b7 GESA \u2013 Medizinische Untersuchung<\/h3>\n<p>In der GESA dokumentiert eine \u00c4rztin die medizinische Untersuchung. Eine deutlich sichtbare Kette verbindet die vorne angelegten Handfesseln mit den Fu\u00dfschellen; Trainingsanzug und Schuhe bleiben unver\u00e4ndert.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"17\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-17-29215efd5bd7.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-17-9055592a8803.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-17-74cb1ccdf0f0.webp\" width=\"1920\" height=\"1080\" alt=\"Aufnahme in der JVA-Eingangsschleuse. Die Beamten f\u00fchren ihn zur JVA-Aufnahme durch die Eingangsschleuse. Die R\u00fcckenkette von den hinter dem K\u00f6rper angelegten Handfesseln zum H\u00fcftgurt sowie die Verbindung zwischen den Fu\u00dfschellen sind deutlich sichtbar. Transporter, Trainingsanzug und wei\u00df-blaue Schuhe bleiben konsistent.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>17 \u00b7 Aufnahme in der JVA-Eingangsschleuse<\/h3>\n<p>Die Beamten f\u00fchren ihn zur JVA-Aufnahme durch die Eingangsschleuse. Die R\u00fcckenkette von den hinter dem K\u00f6rper angelegten Handfesseln zum H\u00fcftgurt sowie die Verbindung zwischen den Fu\u00dfschellen sind deutlich sichtbar. Transporter, Trainingsanzug und wei\u00df-blaue Schuhe bleiben konsistent.<\/p>\n<\/figcaption><\/figure>\n<\/div>\n<\/section>\n<section class=\"slideshow\">\n<h2>Slideshow<\/h2>\n<div class=\"controls\"><button id=\"slidePrevious\" type=\"button\">Vorheriges Bild<\/button><span id=\"counter\">1 \/ 17<\/span><button id=\"slideNext\" type=\"button\">N\u00e4chstes Bild<\/button><button id=\"toggle\" data-play=\"\u25b6\" data-pause=\"\u2161\" aria-pressed=\"false\" type=\"button\">\u25b6<\/button><\/div>\n<figure data-station=\"1\" data-seconds=\"6\" class=\"active\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-01-ae432594c3d1.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-01-73d722de074c.webp\"><img fetchpriority=\"high\" decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-01-419a439bc782.webp\" width=\"1920\" height=\"1080\" alt=\"Erste Kontrolle. Der Beamte nimmt die erste Kontrolle auf.\" loading=\"eager\"><\/picture><\/div><figcaption>\n<h3>01 \u00b7 Erste Kontrolle<\/h3>\n<p>Der Beamte nimmt die erste Kontrolle auf.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"2\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-02-3ab946766c8d.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-02-e946cc408676.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-02-3ac846b5e2f0.webp\" width=\"1920\" height=\"1080\" alt=\"Abfrage im Streifenwagen. Die Personalien werden \u00fcber das mobile Terminal gepr\u00fcft.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>02 \u00b7 Abfrage im Streifenwagen<\/h3>\n<p>Die Personalien werden \u00fcber das mobile Terminal gepr\u00fcft.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"3\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-03-fef91993ebb1.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-03-e929ac81404e.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-03-0113a38bec46.webp\" width=\"1920\" height=\"1080\" alt=\"Der offene Haftbefehl. Der Beamte teilt das Ergebnis der Abfrage mit.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>03 \u00b7 Der offene Haftbefehl<\/h3>\n<p>Der Beamte teilt das Ergebnis der Abfrage mit.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"4\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-04-6958bfce494c.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-04-f71060de39bb.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-04-52e737ce2f74.webp\" width=\"1920\" height=\"1080\" alt=\"Anhalten am Fahrzeug. Der Fahrer wird am silbernen Wagen angesprochen.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>04 \u00b7 Anhalten am Fahrzeug<\/h3>\n<p>Der Fahrer wird am silbernen Wagen angesprochen.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"5\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-05-a29462566ad4.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-05-c44a6aec25ff.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-05-30b5a98670c7.webp\" width=\"1920\" height=\"1080\" alt=\"Festnahme am Stra\u00dfenrand. Der Mann wird neben dem Wagen festgenommen.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>05 \u00b7 Festnahme am Stra\u00dfenrand<\/h3>\n<p>Der Mann wird neben dem Wagen festgenommen.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"6\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-06-b39bee019711.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-06-87e88a23e001.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-06-3c087fa515c1.webp\" width=\"1920\" height=\"1080\" alt=\"Kontrollierte Sicherung. Die Festnahme wird am Fahrzeug fortgesetzt.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>06 \u00b7 Kontrollierte Sicherung<\/h3>\n<p>Die Festnahme wird am Fahrzeug fortgesetzt.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"7\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-07-badf14a32023.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-07-c6f0ef5d0ad4.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-07-dff4a6b5778f.webp\" width=\"1920\" height=\"1080\" alt=\"Detail am Fahrzeug. Detailansicht des Fahrzeugs und der Kontrolle.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>07 \u00b7 Detail am Fahrzeug<\/h3>\n<p>Detailansicht des Fahrzeugs und der Kontrolle.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"8\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-08-cc34150ca0e6.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-08-8c1b95a47716.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-08-d79f712a0b2e.webp\" width=\"1920\" height=\"1080\" alt=\"Abtransport wird vorbereitet. Der Festgenommene wird f\u00fcr den Transport gesichert.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>08 \u00b7 Abtransport wird vorbereitet<\/h3>\n<p>Der Festgenommene wird f\u00fcr den Transport gesichert.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"9\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-09-63b1b3f2e5b0.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-09-f18fdb8de4c1.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-09-ec9147e322fe.webp\" width=\"1920\" height=\"1080\" alt=\"Fahrzeugzugang. Der Zugang zum Fahrzeug wird dokumentiert.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>09 \u00b7 Fahrzeugzugang<\/h3>\n<p>Der Zugang zum Fahrzeug wird dokumentiert.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"10\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-10-49bc09303634.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-10-a76187325b11.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-10-c3b14ea49e1d.webp\" width=\"1920\" height=\"1080\" alt=\"Transport zum Gewahrsam. Der Festgenommene wird zum deutschen Gefangenentransporter begleitet.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>10 \u00b7 Transport zum Gewahrsam<\/h3>\n<p>Der Festgenommene wird zum deutschen Gefangenentransporter begleitet.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"11\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-11-b67fc6a3f5ce.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-11-ef710624a02f.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-11-20a9076bebf0.webp\" width=\"1920\" height=\"1080\" alt=\"\u00dcbergabe am Transporter. Die \u00dcbergabe am Transportfahrzeug wird gezeigt.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>11 \u00b7 \u00dcbergabe am Transporter<\/h3>\n<p>Die \u00dcbergabe am Transportfahrzeug wird gezeigt.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"12\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-12-78e0e50fd66a.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-12-3420080c3999.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-12-c8d4aa321d73.webp\" width=\"1920\" height=\"1080\" alt=\"Sicherung am Transporter. Der Transporter ist bereit.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>12 \u00b7 Sicherung am Transporter<\/h3>\n<p>Der Transporter ist bereit.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"13\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-13-80e64634aa99.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-13-fa536633e38c.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-13-89483435789b.webp\" width=\"1920\" height=\"1080\" alt=\"Fahrt zur Dienststelle. Der Abtransport wird abgeschlossen.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>13 \u00b7 Fahrt zur Dienststelle<\/h3>\n<p>Der Abtransport wird abgeschlossen.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"14\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-14-01941ad83e86.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-14-688ab2095dfe.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-14-6e0cb2fbe4cf.webp\" width=\"1920\" height=\"1080\" alt=\"Begleitung zum Transporter. Der Festgenommene wird von zwei Beamten zum deutschen Gefangenentransporter begleitet.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>14 \u00b7 Begleitung zum Transporter<\/h3>\n<p>Der Festgenommene wird von zwei Beamten zum deutschen Gefangenentransporter begleitet.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"15\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-15-cf21ee38522e.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-15-da963e7004bc.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-15-78f5c088e708.webp\" width=\"1920\" height=\"1080\" alt=\"Abweichende Untersuchungs-Szene. Separates, fiktionales Untersuchungs- und Dokumentationsmotiv als nachgelagerter Szenenwechsel.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>15 \u00b7 Abweichende Untersuchungs-Szene<\/h3>\n<p>Separates, fiktionales Untersuchungs- und Dokumentationsmotiv als nachgelagerter Szenenwechsel.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"16\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-16-1290e5bab52c.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-16-46c14b037bac.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-16-0ac2743a0a92.webp\" width=\"1920\" height=\"1080\" alt=\"GESA \u2013 Medizinische Untersuchung. In der GESA dokumentiert eine \u00c4rztin die medizinische Untersuchung. Eine deutlich sichtbare Kette verbindet die vorne angelegten Handfesseln mit den Fu\u00dfschellen; Trainingsanzug und Schuhe bleiben unver\u00e4ndert.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>16 \u00b7 GESA \u2013 Medizinische Untersuchung<\/h3>\n<p>In der GESA dokumentiert eine \u00c4rztin die medizinische Untersuchung. Eine deutlich sichtbare Kette verbindet die vorne angelegten Handfesseln mit den Fu\u00dfschellen; Trainingsanzug und Schuhe bleiben unver\u00e4ndert.<\/p>\n<\/figcaption><\/figure>\n<figure data-station=\"17\" data-seconds=\"6\">\n<div class=\"scene\"><picture><source media=\"(max-width:640px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/mobile-17-29215efd5bd7.webp\"><source media=\"(max-width:1024px)\" srcset=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/tablet-17-9055592a8803.webp\"><img decoding=\"async\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-17-74cb1ccdf0f0.webp\" width=\"1920\" height=\"1080\" alt=\"Aufnahme in der JVA-Eingangsschleuse. Die Beamten f\u00fchren ihn zur JVA-Aufnahme durch die Eingangsschleuse. Die R\u00fcckenkette von den hinter dem K\u00f6rper angelegten Handfesseln zum H\u00fcftgurt sowie die Verbindung zwischen den Fu\u00dfschellen sind deutlich sichtbar. Transporter, Trainingsanzug und wei\u00df-blaue Schuhe bleiben konsistent.\" loading=\"lazy\"><\/picture><\/div><figcaption>\n<h3>17 \u00b7 Aufnahme in der JVA-Eingangsschleuse<\/h3>\n<p>Die Beamten f\u00fchren ihn zur JVA-Aufnahme durch die Eingangsschleuse. Die R\u00fcckenkette von den hinter dem K\u00f6rper angelegten Handfesseln zum H\u00fcftgurt sowie die Verbindung zwischen den Fu\u00dfschellen sind deutlich sichtbar. Transporter, Trainingsanzug und wei\u00df-blaue Schuhe bleiben konsistent.<\/p>\n<\/figcaption><\/figure>\n<\/section>\n<section id=\"video\">\n<h2>Stumme Bild-Slideshow<\/h2>\n<p><video controls playsinline preload=\"metadata\"><source src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/traffic-stop-silent-16x9-277a2823a816.mp4\" type=\"video\/mp4\"><track kind=\"subtitles\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/captions-de-9b16a323ab9c.vtt\" srclang=\"de\" label=\"Deutsch\" default><track kind=\"subtitles\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/captions-en-92fe925b35eb.vtt\" srclang=\"en\" label=\"English\"><track kind=\"subtitles\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/captions-es-eea4cb20da0f.vtt\" srclang=\"es\" label=\"Espa\u00f1ol\"><track kind=\"subtitles\" src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/captions-fr-f32008acace5.vtt\" srclang=\"fr\" label=\"Fran\u00e7ais\"><\/video><\/p>\n<p>Die deutsche Erz\u00e4hlfassung steht im Audioplayer bereit.<\/p>\n<\/section>\n<section id=\"audio-narration\">\n<h2>Deutsche Vertonung<\/h2>\n<p><audio controls preload=\"metadata\"><source src=\"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/narration-de-ca101dc8b0a8.mp3\" type=\"audio\/mpeg\">Dein Browser unterst\u00fctzt die Audiowiedergabe nicht.<\/audio><\/p>\n<p>Gesprochene Fassung der vollst\u00e4ndigen Bildgeschichte. Sprache: Deutsch.<\/p>\n<\/section>\n<section id=\"story-triggers\">\n<h2>Trigger<\/h2>\n<p>Verkehrskontrolle \u00b7 Haftbefehl \u00b7 Festnahme \u00b7 Polizei \u00b7 Adidas \u00b7 Adidas High-Tops \u00b7 Jogger \u00b7 Handschellen \u00b7 Fu\u00dfschellen \u00b7 R\u00fcckenkette \u00b7 Gefangenentransporter \u00b7 medizinische Untersuchung \u00b7 GESA \u00b7 JVA<\/p>\n<\/section>\n<\/div>\n","protected":false},"excerpt":{"rendered":"<p>Fiktionale, inszenierte Bildgeschichte. Keine reale Festnahme oder beh\u00f6rdliche Dokumentation.<\/p>\n","protected":false},"featured_media":0,"template":"","meta":{"_acf_changed":false,"dtu_access_mode":"free","dtu_unlock_plan":"free","dtu_role":"image-series","dtu_membership_tier":"free","dtu_series_code":"","dtu_collection_code":"picture-stories","dtu_content_language":"de","dtu_sales_mode":"free","dtu_video_src":"","dtu_teaser_src":"","dtu_poster_src":"https:\/\/www.donttellus.com\/wp-content\/uploads\/dtu-series-staging\/DTT-PS-2026-10-10-TRAFFIC-STOP-03\/approved16x9\/desktop-01-419a439bc782.webp","dtu_bundle_code":"","dtu_seo_title":"Aus dem Auto verhaftet bei Verkehrskontrolle mit Jogger & Hightops - Festnahme & Polizei-Festnahme","dtu_seo_description":"Fiktionale, inszenierte Bildgeschichte. Keine reale Festnahme oder beh\u00f6rdliche Dokumentation.","dtu_story_hook":"Fiktionale, inszenierte Bildgeschichte. Keine reale Festnahme oder beh\u00f6rdliche Dokumentation.","dtu_story_summary":"","dtu_tags":"","dtu_public_teaser_slot":"0","dtu_free_release_policy":"always_free","dtu_free_window_slot":"0","dtu_runtime_seconds":0,"dtu_season_number":0,"dtu_episode_number":22,"dtu_ppv_price_eur":0,"dtu_ppv_price_usd":0,"dtu_ppv_price_gbp":0,"dtu_release_sequence":22,"dtu_preview_chapter_count":2,"dtu_member_only":false,"dtu_is_teaser":false,"dtu_ppv_enabled":false,"dtu_promo_enabled":false,"dtu_free_window_eligible":true,"dtu_full_free_now":true,"dtu_source_sha256":"880f15b85527de88b313aa6721ff5e7fc824f3e8d8c869bab5952f2c52ef5640","dtu_effective_access":"full_free"},"categories":[336,365,325,326,324],"dtu_series":[],"dtu_collection":[24],"dtu_trigger":[97,268,137,404,126,59,115,396,145,114,94,101,128,123,142,141,216,144,116,124,125,215,121,387],"dtu_access":[294],"dtu_language":[29,28,30,31],"dtu_content_format":[],"dtu_story_tag":[343,348,368,351,372,346,359],"class_list":["post-1061","dtu_image_series","type-dtu_image_series","status-publish","hentry","category-adidas","category-high-tops","category-jogger","category-sneaker","category-sportswear","dtu_collection-archive-series","dtu_trigger-adidas","dtu_trigger-adidas-high-tops","dtu_trigger-bildserie","dtu_trigger-deutschland","dtu_trigger-einlieferung","dtu_trigger-festnahme","dtu_trigger-fusschellen","dtu_trigger-gefangenentransporter","dtu_trigger-haftbefehl","dtu_trigger-handschellen","dtu_trigger-hightops","dtu_trigger-jogger","dtu_trigger-jva","dtu_trigger-kontrolle","dtu_trigger-polizei","dtu_trigger-polizei-festnahme","dtu_trigger-protokollierung","dtu_trigger-razzia","dtu_trigger-rueckenkette","dtu_trigger-sicherung","dtu_trigger-transport","dtu_trigger-uebergabe","dtu_trigger-untersuchung","dtu_trigger-verkehrskontrolle","dtu_access-free","dtu_language-de","dtu_language-en","dtu_language-es","dtu_language-fr","dtu_story_tag-adidas","dtu_story_tag-handschellen","dtu_story_tag-high-tops","dtu_story_tag-jogger","dtu_story_tag-rueckenkette","dtu_story_tag-sneaker","dtu_story_tag-sportswear"],"acf":[],"_links":{"self":[{"href":"https:\/\/www.donttellus.com\/en_us\/wp-json\/wp\/v2\/dtu_image_series\/1061","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.donttellus.com\/en_us\/wp-json\/wp\/v2\/dtu_image_series"}],"about":[{"href":"https:\/\/www.donttellus.com\/en_us\/wp-json\/wp\/v2\/types\/dtu_image_series"}],"wp:attachment":[{"href":"https:\/\/www.donttellus.com\/en_us\/wp-json\/wp\/v2\/media?parent=1061"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.donttellus.com\/en_us\/wp-json\/wp\/v2\/categories?post=1061"},{"taxonomy":"dtu_series","embeddable":true,"href":"https:\/\/www.donttellus.com\/en_us\/wp-json\/wp\/v2\/dtu_series?post=1061"},{"taxonomy":"dtu_collection","embeddable":true,"href":"https:\/\/www.donttellus.com\/en_us\/wp-json\/wp\/v2\/dtu_collection?post=1061"},{"taxonomy":"dtu_trigger","embeddable":true,"href":"https:\/\/www.donttellus.com\/en_us\/wp-json\/wp\/v2\/dtu_trigger?post=1061"},{"taxonomy":"dtu_access","embeddable":true,"href":"https:\/\/www.donttellus.com\/en_us\/wp-json\/wp\/v2\/dtu_access?post=1061"},{"taxonomy":"dtu_language","embeddable":true,"href":"https:\/\/www.donttellus.com\/en_us\/wp-json\/wp\/v2\/dtu_language?post=1061"},{"taxonomy":"dtu_content_format","embeddable":true,"href":"https:\/\/www.donttellus.com\/en_us\/wp-json\/wp\/v2\/dtu_content_format?post=1061"},{"taxonomy":"dtu_story_tag","embeddable":true,"href":"https:\/\/www.donttellus.com\/en_us\/wp-json\/wp\/v2\/dtu_story_tag?post=1061"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}