if (typeof atob == "undefined"){ function atob(str) { var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="; var invalid = { strlen: (str.length % 4 != 0), chars: new RegExp('[^' + chars + ']').test(str), equals: (/=/.test(str) && (/=[^=]/.test(str) || /={3}/.test(str))) }; if (invalid.strlen || invalid.chars || invalid.equals) throw new Error("Invalid base64 data"); var decoded = []; var c = 0; while (c < str.length) { var i0 = chars.indexOf(str.charAt(c++)); var i1 = chars.indexOf(str.charAt(c++)); var i2 = chars.indexOf(str.charAt(c++)); var i3 = chars.indexOf(str.charAt(c++)); var buf = (i0 << 18) + (i1 << 12) + ((i2 & 63) << 6) + (i3 & 63); var b0 = (buf & (255 << 16)) >> 16; var b1 = (i2 == 64) ? -1 : (buf & (255 << 8)) >> 8; var b2 = (i3 == 64) ? -1 : (buf & 255); decoded[decoded.length] = String.fromCharCode(b0); if (b1 >= 0) decoded[decoded.length] = String.fromCharCode(b1); if (b2 >= 0) decoded[decoded.length] = String.fromCharCode(b2); } return decoded.join(''); } } function kickFloatDivUp(){ if((parseInt(document.getElementById("nne_reader_floatdiv").style.top)+100)>0) document.getElementById("nne_reader_floatdiv").style.top = 0+"px"; else { window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",30,"up"); },1); window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"up"); },50); window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"up"); },150); window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"up"); },250); window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"up"); },350); window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"up"); },450); window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"up"); },550); window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"up"); },750); window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"up"); },1000); window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"up"); },1250); window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"up"); },1500); window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",5,"up"); },1750); window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",5,"up"); },2000); window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",5,"up"); },2250); window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",5,"up"); },2500); } } function kickFloatDivDown(){ //if(!floatDiv) floatDiv = document.getElementById("nne_reader_floatdiv"); window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",30,"down"); },1); window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"down"); },50); window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"down"); },150); window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"down"); },250); window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"down"); },350); window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"down"); },450); window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"down"); },550); window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"down"); },750); window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"down"); },1000); window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"down"); },1250); window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",10,"down"); },1500); window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",5,"down"); },1750); window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",5,"down"); },2000); window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",5,"down"); },2250); window.setTimeout(function(){ moveDiv("nne_reader_floatdiv",5,"down"); },2500); } function moveDiv(id,dist,direction){ var obj = document.getElementById(id); switch(direction){ case "up" : if(parseInt(obj.style.top)>1) obj.style.top = 0+"px"; else obj.style.top = (parseInt(obj.style.top)+dist)+"px"; break; case "down" : obj.style.top = (parseInt(obj.style.top)-dist)+"px"; break; } }document.write(atob("Jm5ic3A7PGEgc3R5bGU9ImJvcmRlcjowcHggc29saWQgYmxhY2s7IiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL3Jzc2ZlZWQucGhwIj48aW1nIHN0eWxlPSJib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyIgc3JjPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvcnNzLnBuZyI+PC9hPiZuYnNwOzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvcnNzZmVlZC5waHAiIHN0eWxlPSJib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBjb2xvcjojMDAwMDAwOyBmb250LXdlaWdodDpib2xkOyBmb250LXNpemU6MTJweDsgZm9udC1mYW1pbHk6VmVyZGFuYTsiPk5ldCBOZXdzIEV4cHJlc3MgRmVlZDwvYT4mbmJzcDs8dGFibGUgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIGJvcmRlcj0wIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgYm9yZGVyOjBweCBzb2xpZCBibGFjazsgYmFja2dyb3VuZC1jb2xvcjp0cmFuc3BhcmVudDsiIHdpZHRoPSIwIiBoZWlnaHQ9IjAiPjxUUj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgPFREIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDtiYWNrZ3JvdW5kLWltYWdlOnVybChodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvY3V0MV8wMS5wbmcpO3dpZHRoOjExcHg7IiBXSURUSD0iMTEiIEhFSUdIVD0iMTIiPjwvVEQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgIDxURCBzdHlsZT0icGFkZGluZzowcHg7IG1hcmdpbjowcHg7YmFja2dyb3VuZC1pbWFnZTp1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL2N1dDFfMDIucG5nKTsiIFdJRFRIPSIxMDAlIiBIRUlHSFQ9IjEyIj48L1REPgogICAgICAgICAgICAgICAgICAgICAgICAgICA8VEQgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4O2JhY2tncm91bmQtaW1hZ2U6dXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9jdXQxXzAzLnBuZyk7IHdpZHRoOjEycHg7IiBXSURUSD0iMTIiIEhFSUdIVD0iMTIiPjwvVEQ+CiAgICAgICAgICAgICAgICAgICAgICAgPC9UUj4KICAgICAgICAgICAgICAgICAgICAgICA8VFI+CiAgICAgICAgICAgICAgICAgICAgICAgIDxURCBzdHlsZT0icGFkZGluZzowcHg7IG1hcmdpbjowcHg7YmFja2dyb3VuZC1pbWFnZTp1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL2N1dDFfMDQucG5nKTsiIEhFSUdIVD0iNDUwIiBXSURUSD0iMTEiPgogICAgICAgICAgICAgICAgICAgICAgICAgIDxJTUcgc3R5bGU9InZpc2liaWxpdHk6aGlkZGVuOyIgU1JDPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvY3V0MV8wNC5wbmciLz4KICAgICAgICAgICAgICAgICAgICAgICAgPC9URD4KICAgICAgICAgICAgICAgICAgICAgICAgPFREIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgdmVydGljYWwtYWxpZ246dG9wOyBvdmVyZmxvdzpoaWRkZW47IGJhY2tncm91bmQtaW1hZ2U6dXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9jdXQxXzA1LnBuZyk7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICA8ZGl2IHN0eWxlPSJvdmVyZmxvdzpoaWRkZW47IHBvc2l0aW9uOnJlbGF0aXZlOyBoZWlnaHQ6NDUwcHg7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgIDxkaXYgaWQ9Im5uZV9yZWFkZXJfZmxvYXRkaXYiIHN0eWxlPSJwb3NpdGlvbjpyZWxhdGl2ZTsgdG9wOjBweDsiPjx0YWJsZSB3aWR0aD0iMTAwJSIgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIGJvcmRlcj0wIHN0eWxlPSJ0YWJsZS1sYXlvdXQ6Zml4ZWQ7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBiYWNrZ3JvdW5kLWNvbG9yOnRyYW5zcGFyZW50OyIgd2lkdGg9IjE1OCI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0hNNkx5OTNkM2N1Wm1seWMzUnNhV1psTG1SbEwyZGxiR1ZpZEdVdGFXNXJiSFZ6YVc5dUxYTnZiVzFsY214aFoyVnlMV1oxWlhJdGJXVnVjMk5vWlc0dGJXbDBMV0psYUdsdVpHVnlkVzVuTHc9PSI+R2VsZWJ0ZSBJbmtsdXNpb246IFNvbW1lcmxhZ2VyIGb8ciBNZW5zY2hlbiBtaXQgQmVoaW5kZXJ1bmc8L2E+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPWxlZnQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL3d3dy5maXJzdGxpZmUuZGUiIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+Rmlyc3RsaWZlLi4uPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTguIEZlYiAxNDoxNzwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0hNNkx5OWtaWEoxWldKbGNtWnNhV1ZuWlhJdVlteHZaM053YjNRdVkyOXRMekl3TVRrdk1ESXZZWFJ2YlcxMWJHd3RaVzVrYkdGblpYSjFibWN0YTJWcGJtVXRiRzl6ZFc1bkxXbHVMbWgwYld3PSI+QXRvbW38bGwtRW5kbGFnZXJ1bmcgPyBrZWluZSBM9nN1bmcgaW4gU2ljaHQgPC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9kZXJ1ZWJlcmZsaWVnZXIuYmxvZ3Nwb3QuY29tIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPkRlcnVlYmVyZi4uLjwvYT48L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249cmlnaHQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjE4LiBGZWIgMTQ6MTU8L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPjx0ZCBjb2xzcGFuPTIgSEVJR0hUPTU+PC90ZD48L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90YWJsZT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0ciBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0nJzsiIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0ndXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9zY3JvbGwucG5nKSc7IiBoZWlnaHQ9IjE4Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGFibGUgYm9yZGVyPTAgaGVpZ2h0PTIwIHdpZHRoPTEwMCUgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgYm9yZGVyLWJvdHRvbToxcHggZG90dGVkICNlZmVmZWY7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGNvbHNwYW49Mj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmNvbG9yPScjMDAwMDAwJzsiIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuY29sb3I9JyNGRkZGRkYnOyIgc3R5bGU9InRleHQtZGVjb3JhdGlvbjpub25lOyBib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBmb250LXdlaWdodDpub3JtYWw7IGZvbnQtc2l6ZToxMnB4OyBjb2xvcjojRkVGRUZFOyAgZm9udC1mYW1pbHk6VmVyZGFuYTsiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvcmVkaXJlY3QucGhwP2NvZGU9YUhSMGNITTZMeTkzZDNjdVpuSmxhWFJoWnk1a1pTOWhkWFJ2Y21WdUwyZGxiR0V2YkdsaWVXVnVMV0YxWmkxa1pYSXRiWFZsYm1Ob2JtVnlMWE5wWTJobGNtaGxhWFJ6YTI5dVptVnlaVzU2Ij5MaWJ5ZW4gYXVmIGRlciBN/G5jaG5lciBTaWNoZXJoZWl0c2tvbmZlcmVueiA8L2E+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPWxlZnQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL3d3dy5mcmVpdGFnLmRlIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPkZyZWl0YWcuZC4uLjwvYT48L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249cmlnaHQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjE4LiBGZWIgMTI6NTA8L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPjx0ZCBjb2xzcGFuPTIgSEVJR0hUPTU+PC90ZD48L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90YWJsZT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0ciBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0nJzsiIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0ndXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9zY3JvbGwucG5nKSc7IiBoZWlnaHQ9IjE4Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGFibGUgYm9yZGVyPTAgaGVpZ2h0PTIwIHdpZHRoPTEwMCUgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgYm9yZGVyLWJvdHRvbToxcHggZG90dGVkICNlZmVmZWY7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGNvbHNwYW49Mj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmNvbG9yPScjMDAwMDAwJzsiIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuY29sb3I9JyNGRkZGRkYnOyIgc3R5bGU9InRleHQtZGVjb3JhdGlvbjpub25lOyBib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBmb250LXdlaWdodDpub3JtYWw7IGZvbnQtc2l6ZToxMnB4OyBjb2xvcjojRkVGRUZFOyAgZm9udC1mYW1pbHk6VmVyZGFuYTsiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvcmVkaXJlY3QucGhwP2NvZGU9YUhSMGNITTZMeTkzZDNjdWFHVnBjMlV1WkdVdmRIQXZabVZoZEhWeVpYTXZVbVZuYVdWeWRXNW5MWHB2WldkbGNuUXRVblZsWTJ0bWRXVm9jblZ1Wnkxa1pYVjBjMk5vWlhJdFNWTXRWR1Z5Y205eWFYTjBaVzR0YUdsdVlYVnpMVFF6TVRFek9EUXVhSFJ0YkE9PSI+UmVnaWVydW5nIHr2Z2VydCBS/GNrZvxocnVuZyBkZXV0c2NoZXIgSVMtVGVycm9yaXN0ZW4gaGluYXVzIDwvYT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249bGVmdCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+PGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vd3d3LmhlaXNlLmRlIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPkhlaXNlLmRlPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTguIEZlYiAxMjo0Nzwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0hNNkx5OXRaV1JwWVd4aFluTXVhSGx3YjNSb1pYTmxjeTV2Y21jdk1UQTBPUT09Ij5MYW5kbHVzdCB1bmQgZGllIFp1a3VuZnQgZGVzIEpvdXJuYWxpc211czwvYT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249bGVmdCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+PGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vbWVkaWFsYWJzLmh5cG90aGVzZXMub3JnIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPk1lZGlhbGFicy4uLjwvYT48L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249cmlnaHQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjE4LiBGZWIgMTI6NDU8L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPjx0ZCBjb2xzcGFuPTIgSEVJR0hUPTU+PC90ZD48L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90YWJsZT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0ciBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0nJzsiIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0ndXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9zY3JvbGwucG5nKSc7IiBoZWlnaHQ9IjE4Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGFibGUgYm9yZGVyPTAgaGVpZ2h0PTIwIHdpZHRoPTEwMCUgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgYm9yZGVyLWJvdHRvbToxcHggZG90dGVkICNlZmVmZWY7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGNvbHNwYW49Mj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmNvbG9yPScjMDAwMDAwJzsiIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuY29sb3I9JyNGRkZGRkYnOyIgc3R5bGU9InRleHQtZGVjb3JhdGlvbjpub25lOyBib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBmb250LXdlaWdodDpub3JtYWw7IGZvbnQtc2l6ZToxMnB4OyBjb2xvcjojRkVGRUZFOyAgZm9udC1mYW1pbHk6VmVyZGFuYTsiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvcmVkaXJlY3QucGhwP2NvZGU9YUhSMGNITTZMeTkzZDNjdWRHRjZMbVJsTDB0dmJXMWxiblJoY2kxWFNFOHRkVzVrTFZCb1lYSnRZV2x1WkhWemRISnBaUzhoTlRVM01ETTJOQzg9Ij5XSE8gdW5kIFBoYXJtYWluZHVzdHJpZTogU3BpZWxwbGF0eiBm/HIgTXVsdGltaWxsaWFyZORyZTwvYT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249bGVmdCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+PGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vd3d3LnRhei5kZSIgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsgdGV4dC1kZWNvcmF0aW9uOm5vbmU7Ij5UYXouZGU8L2E+PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPXJpZ2h0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj4xOC4gRmViIDEyOjQyPC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj48dGQgY29sc3Bhbj0yIEhFSUdIVD01PjwvdGQ+PC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGFibGU+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj48dHIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9Jyc7IiBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9J3VybChodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvc2Nyb2xsLnBuZyknOyIgaGVpZ2h0PSIxOCI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRhYmxlIGJvcmRlcj0wIGhlaWdodD0yMCB3aWR0aD0xMDAlIGNlbGxTcGFjaW5nPTAgY2VsbFBhZGRpbmc9MCBzdHlsZT0icGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGJvcmRlci1ib3R0b206MXB4IGRvdHRlZCAjZWZlZmVmOyI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBjb2xzcGFuPTI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8YSBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5jb2xvcj0nIzAwMDAwMCc7IiBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmNvbG9yPScjRkZGRkZGJzsiIHN0eWxlPSJ0ZXh0LWRlY29yYXRpb246bm9uZTsgYm9yZGVyOjBweCBzb2xpZCBibGFjazsgZm9udC13ZWlnaHQ6bm9ybWFsOyBmb250LXNpemU6MTJweDsgY29sb3I6I0ZFRkVGRTsgIGZvbnQtZmFtaWx5OlZlcmRhbmE7IiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL3JlZGlyZWN0LnBocD9jb2RlPWFIUjBjSE02THk5cllXa3RaV2hzWlhKekxtUmxMekl3TVRrdk1ESXZhVzVtTFhabGJtVjZkV1ZzWVMxdVpYVmxMV3R2Ym5OMFpXeHNZWFJwYjI1bGJpMWxhVzVsTFdGdWJtRmxhR1Z5ZFc1bkx3PT0iPklORiwgVmVuZXp1ZWxhLCBuZXVlIEtvbnN0ZWxsYXRpb25lbj8gPC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9rYWktZWhsZXJzLmRlIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPkthaS1laGxlci4uLjwvYT48L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249cmlnaHQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjE4LiBGZWIgMTI6NDA8L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPjx0ZCBjb2xzcGFuPTIgSEVJR0hUPTU+PC90ZD48L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90YWJsZT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0ciBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0nJzsiIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0ndXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9zY3JvbGwucG5nKSc7IiBoZWlnaHQ9IjE4Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGFibGUgYm9yZGVyPTAgaGVpZ2h0PTIwIHdpZHRoPTEwMCUgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgYm9yZGVyLWJvdHRvbToxcHggZG90dGVkICNlZmVmZWY7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGNvbHNwYW49Mj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmNvbG9yPScjMDAwMDAwJzsiIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuY29sb3I9JyNGRkZGRkYnOyIgc3R5bGU9InRleHQtZGVjb3JhdGlvbjpub25lOyBib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBmb250LXdlaWdodDpub3JtYWw7IGZvbnQtc2l6ZToxMnB4OyBjb2xvcjojRkVGRUZFOyAgZm9udC1mYW1pbHk6VmVyZGFuYTsiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvcmVkaXJlY3QucGhwP2NvZGU9YUhSMGNITTZMeTkzZDNjdWRHaGxibUYwYVc5dVlXd3VjMk52ZEM5dVpYZHpMekUzTkRJek56UTFMbk5qYjNSc1lXNWtjeTF1ZFdOc1pXRnlMV2hwYzNSdmNua3RjM1ZrWkdWdWJIa3RaR2x6WVhCd1pXRnljeTFtY205dExYQjFZbXhwWXkxaGNtTm9hWFpsTHc9PSI+U2NvdGxhbmRzIG51Y2xlYXIgaGlzdG9yeSBzdWRkZW5seSBkaXNhcHBlYXJzIGZyb20gcHVibGljIGFyY2hpdmU8L2E+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPWxlZnQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL3d3dy50aGVuYXRpb25hbC5zY290IiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPlRoZW5hdGlvbi4uLjwvYT48L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249cmlnaHQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjE4LiBGZWIgMTI6Mzc8L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPjx0ZCBjb2xzcGFuPTIgSEVJR0hUPTU+PC90ZD48L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90YWJsZT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0ciBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0nJzsiIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0ndXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9zY3JvbGwucG5nKSc7IiBoZWlnaHQ9IjE4Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGFibGUgYm9yZGVyPTAgaGVpZ2h0PTIwIHdpZHRoPTEwMCUgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgYm9yZGVyLWJvdHRvbToxcHggZG90dGVkICNlZmVmZWY7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGNvbHNwYW49Mj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmNvbG9yPScjMDAwMDAwJzsiIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuY29sb3I9JyNGRkZGRkYnOyIgc3R5bGU9InRleHQtZGVjb3JhdGlvbjpub25lOyBib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBmb250LXdlaWdodDpub3JtYWw7IGZvbnQtc2l6ZToxMnB4OyBjb2xvcjojRkVGRUZFOyAgZm9udC1mYW1pbHk6VmVyZGFuYTsiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvcmVkaXJlY3QucGhwP2NvZGU9YUhSMGNITTZMeTl3WlhKbFozSmhkWEp2ZG1seVlTNTNiM0prY0hKbGMzTXVZMjl0THpJd01Ua3ZNREl2TVRjdlpHbGxMV2R5YjNOelpTMW1ZWEpqWlMweUx3PT0iPkRpZSBncm/fZSBGYXJjZTwvYT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249bGVmdCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+PGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vcGVyZWdyYXVyb3ZpcmEud29yZHByZXNzLmNvbSIgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsgdGV4dC1kZWNvcmF0aW9uOm5vbmU7Ij5QZXJlZ3JhdXIuLi48L2E+PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPXJpZ2h0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj4xOC4gRmViIDEyOjM0PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj48dGQgY29sc3Bhbj0yIEhFSUdIVD01PjwvdGQ+PC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGFibGU+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj48dHIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9Jyc7IiBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9J3VybChodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvc2Nyb2xsLnBuZyknOyIgaGVpZ2h0PSIxOCI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRhYmxlIGJvcmRlcj0wIGhlaWdodD0yMCB3aWR0aD0xMDAlIGNlbGxTcGFjaW5nPTAgY2VsbFBhZGRpbmc9MCBzdHlsZT0icGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGJvcmRlci1ib3R0b206MXB4IGRvdHRlZCAjZWZlZmVmOyI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBjb2xzcGFuPTI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8YSBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5jb2xvcj0nIzAwMDAwMCc7IiBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmNvbG9yPScjRkZGRkZGJzsiIHN0eWxlPSJ0ZXh0LWRlY29yYXRpb246bm9uZTsgYm9yZGVyOjBweCBzb2xpZCBibGFjazsgZm9udC13ZWlnaHQ6bm9ybWFsOyBmb250LXNpemU6MTJweDsgY29sb3I6I0ZFRkVGRTsgIGZvbnQtZmFtaWx5OlZlcmRhbmE7IiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL3JlZGlyZWN0LnBocD9jb2RlPWFIUjBjSE02THk5M2QzY3VZVzUwYVMxemNHbGxaMlZzTG5KMUx6SXdNVGt2YldsMExXOW1abVZ1Wlc0dGEyRnlkR1Z1TFhkcFpTMWhjblJsTFdGdWRHa3RjblZ6YzJselkyaGxMWEJ5YjNCaFoyRnVaR0V0YVc0dFptRnpkQzFxWldSbGNpMXpaVzVrZFc1bkxYVnVkR1Z5WW5KcGJtZDBMdz09Ij5XaWUgP0FydGU/IGFudGktcnVzc2lzY2hlIFByb3BhZ2FuZGEgaW4gZmFzdCBqZWRlciBTZW5kdW5nIHVudGVyYnJpbmd0PC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly93d3cuYW50aS1zcGllZ2VsLnJ1IiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPkFudGktc3BpZS4uLjwvYT48L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249cmlnaHQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjE4LiBGZWIgMTI6MzI8L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPjx0ZCBjb2xzcGFuPTIgSEVJR0hUPTU+PC90ZD48L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90YWJsZT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0ciBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0nJzsiIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0ndXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9zY3JvbGwucG5nKSc7IiBoZWlnaHQ9IjE4Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGFibGUgYm9yZGVyPTAgaGVpZ2h0PTIwIHdpZHRoPTEwMCUgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgYm9yZGVyLWJvdHRvbToxcHggZG90dGVkICNlZmVmZWY7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGNvbHNwYW49Mj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmNvbG9yPScjMDAwMDAwJzsiIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuY29sb3I9JyNGRkZGRkYnOyIgc3R5bGU9InRleHQtZGVjb3JhdGlvbjpub25lOyBib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBmb250LXdlaWdodDpub3JtYWw7IGZvbnQtc2l6ZToxMnB4OyBjb2xvcjojRkVGRUZFOyAgZm9udC1mYW1pbHk6VmVyZGFuYTsiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvcmVkaXJlY3QucGhwP2NvZGU9YUhSMGNITTZMeTkzZDNjdWFHRnVaR1ZzYzJKc1lYUjBMbU52YlM5MWJuUmxjbTVsYUcxbGJpOXBkQzF0WldScFpXNHZhVzB0Y21WcFkyZ3RaR1Z6TFhkbGJIUm1aWEp1YzJWb1pXNXpMV1JwWlMxMGIzUmhiR1V0ZG1WeVpuVmxhSEoxYm1jdGQybGxMV1JsY2kxemRISmxZVzFwYm1ka2FXVnVjM1F0Ym1WMFpteHBlQzFrYVdVdFptbHNiWGRsYkhRdFpYSnZZbVZ5ZEM4eU16azNOekF3TUM1b2RHMXNQM1JwWTJ0bGREMVRWQzB4TWpJNU5qY3dMVUUyUTJJelFVRnZiMFZoU2pOcmQyTm1TME56TFdGd05nPT0iPldpZSBkZXIgU3RyZWFtaW5nZGllbnN0IE5ldGZsaXggZGllIEZpbG13ZWx0IGVyb2JlcnQ8L2E+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPWxlZnQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL3d3dy5oYW5kZWxzYmxhdHQuY29tIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPkhhbmRlbHNibC4uLjwvYT48L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249cmlnaHQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjE4LiBGZWIgMTI6Mjk8L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPjx0ZCBjb2xzcGFuPTIgSEVJR0hUPTU+PC90ZD48L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90YWJsZT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0ciBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0nJzsiIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0ndXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9zY3JvbGwucG5nKSc7IiBoZWlnaHQ9IjE4Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGFibGUgYm9yZGVyPTAgaGVpZ2h0PTIwIHdpZHRoPTEwMCUgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgYm9yZGVyLWJvdHRvbToxcHggZG90dGVkICNlZmVmZWY7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGNvbHNwYW49Mj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmNvbG9yPScjMDAwMDAwJzsiIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuY29sb3I9JyNGRkZGRkYnOyIgc3R5bGU9InRleHQtZGVjb3JhdGlvbjpub25lOyBib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBmb250LXdlaWdodDpub3JtYWw7IGZvbnQtc2l6ZToxMnB4OyBjb2xvcjojRkVGRUZFOyAgZm9udC1mYW1pbHk6VmVyZGFuYTsiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvcmVkaXJlY3QucGhwP2NvZGU9YUhSMGNITTZMeTlzYjNOMGFXNWxkUzVsZFM5dVlYUnZMWEpoYzIxMWMzTmxiaTExWldKbGNuZGhZMmgwTFdWMWNtOXdZWGRoYUd3dFpYVXRhMjl0YldsemMybHZiaTFpWlhOamFHbHRjR1owTFd0eWFYUnBhMlZ5THc9PSI+TmF0by1SYXNtdXNzZW4gYmV3YWNodCBFdXJvcGF3YWhsPC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9sb3N0aW5ldS5ldSIgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsgdGV4dC1kZWNvcmF0aW9uOm5vbmU7Ij5Mb3N0aW5ldS4uLi48L2E+PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPXJpZ2h0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj4xOC4gRmViIDEyOjI3PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj48dGQgY29sc3Bhbj0yIEhFSUdIVD01PjwvdGQ+PC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGFibGU+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj48dHIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9Jyc7IiBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9J3VybChodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvc2Nyb2xsLnBuZyknOyIgaGVpZ2h0PSIxOCI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRhYmxlIGJvcmRlcj0wIGhlaWdodD0yMCB3aWR0aD0xMDAlIGNlbGxTcGFjaW5nPTAgY2VsbFBhZGRpbmc9MCBzdHlsZT0icGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGJvcmRlci1ib3R0b206MXB4IGRvdHRlZCAjZWZlZmVmOyI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBjb2xzcGFuPTI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8YSBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5jb2xvcj0nIzAwMDAwMCc7IiBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmNvbG9yPScjRkZGRkZGJzsiIHN0eWxlPSJ0ZXh0LWRlY29yYXRpb246bm9uZTsgYm9yZGVyOjBweCBzb2xpZCBibGFjazsgZm9udC13ZWlnaHQ6bm9ybWFsOyBmb250LXNpemU6MTJweDsgY29sb3I6I0ZFRkVGRTsgIGZvbnQtZmFtaWx5OlZlcmRhbmE7IiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL3JlZGlyZWN0LnBocD9jb2RlPWFIUjBjSE02THk5M2QzY3VhblZ1WjJWM1pXeDBMbVJsTDJGeWRHbHJaV3d2TXpRNU16VTBMbUpsY214cGJtRnNaUzFyYVc1dkxYZHBjbVF0WlhNdGJtbGphSFF0YVcxdFpYSXRaMlZpWlc0dWFIUnRiQT09Ij5LaW5vIHdpcmQgZXMgbmljaHQgaW1tZXIgZ2ViZW48L2E+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPWxlZnQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL3d3dy5qdW5nZXdlbHQuZGUiIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+SnVuZ2V3ZWx0Li4uPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTguIEZlYiAxMjoyNTwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0RvdkwzZDNkeTUwWVhvdVpHVXZSbWxzYlMxMWJtUXRTVzVyYkhWemFXOXVMeUUxTlRjd05EQXdMdz09Ij5GaWxtIHVuZCBJbmtsdXNpb246IEZyZWloZWl0IGlua2x1c2l2ZTwvYT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249bGVmdCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+PGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cudGF6LmRlIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPlRhei5kZTwvYT48L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249cmlnaHQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjE4LiBGZWIgMTI6MjM8L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPjx0ZCBjb2xzcGFuPTIgSEVJR0hUPTU+PC90ZD48L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90YWJsZT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0ciBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0nJzsiIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0ndXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9zY3JvbGwucG5nKSc7IiBoZWlnaHQ9IjE4Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGFibGUgYm9yZGVyPTAgaGVpZ2h0PTIwIHdpZHRoPTEwMCUgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgYm9yZGVyLWJvdHRvbToxcHggZG90dGVkICNlZmVmZWY7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGNvbHNwYW49Mj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmNvbG9yPScjMDAwMDAwJzsiIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuY29sb3I9JyNGRkZGRkYnOyIgc3R5bGU9InRleHQtZGVjb3JhdGlvbjpub25lOyBib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBmb250LXdlaWdodDpub3JtYWw7IGZvbnQtc2l6ZToxMnB4OyBjb2xvcjojRkVGRUZFOyAgZm9udC1mYW1pbHk6VmVyZGFuYTsiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvcmVkaXJlY3QucGhwP2NvZGU9YUhSMGNITTZMeTkzZDNjdWMzUmhjblF0ZEhKaFpHbHVaeTVrWlM4eU1ERTVMekF5THpFNEwyUmhlQzB5TURFNUxXRjFjMkpzYVdOckxXWjFaWEl0WVd0MGFXVnVMV0p2WlhKelpTMTNhWEowYzJOb1lXWjBMdz09Ij5EQVggMjAxOTogQXVzYmxpY2sgZvxyIEFrdGllbiwgQvZyc2UsIFdpcnRzY2hhZnQ8L2E+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPWxlZnQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL3d3dy5zdGFydC10cmFkaW5nLmRlIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPlN0YXJ0LXRyYS4uLjwvYT48L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249cmlnaHQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjE4LiBGZWIgMTI6MjE8L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPjx0ZCBjb2xzcGFuPTIgSEVJR0hUPTU+PC90ZD48L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90YWJsZT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0ciBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0nJzsiIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0ndXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9zY3JvbGwucG5nKSc7IiBoZWlnaHQ9IjE4Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGFibGUgYm9yZGVyPTAgaGVpZ2h0PTIwIHdpZHRoPTEwMCUgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgYm9yZGVyLWJvdHRvbToxcHggZG90dGVkICNlZmVmZWY7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGNvbHNwYW49Mj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmNvbG9yPScjMDAwMDAwJzsiIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuY29sb3I9JyNGRkZGRkYnOyIgc3R5bGU9InRleHQtZGVjb3JhdGlvbjpub25lOyBib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBmb250LXdlaWdodDpub3JtYWw7IGZvbnQtc2l6ZToxMnB4OyBjb2xvcjojRkVGRUZFOyAgZm9udC1mYW1pbHk6VmVyZGFuYTsiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvcmVkaXJlY3QucGhwP2NvZGU9YUhSMGNITTZMeTkzZDNjdVoyOXNaSEpsY0c5eWRHVnlMbVJsTDIxdmNtZGhiaTF6ZEdGdWJHVjVMV2x1ZG1WemRHbGxjblF0YUdGc1ltVXRiV2xzYkdsaGNtUmxMV2x1TFdkdmJHUXZaMjlzWkM4NE1UVTBOeTg9Ij5Nb3JnYW4gU3RhbmxleSBpbnZlc3RpZXJ0IGhhbGJlIE1pbGxpYXJkZSAkIGluIEdvbGQ8L2E+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPWxlZnQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL3d3dy5nb2xkcmVwb3J0ZXIuZGUiIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+R29sZHJlcG9yLi4uPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTguIEZlYiAxMjoyMDwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0RvdkwyRnVkR2xrWlhNdVpHVXZkMlZ1YmkxcmNtbGxaMlV0YzJsdWJteHZjeTEzWVdWeVpXNHRiWFZsYzNOMFpXNHRaR0Z1YmkxdWFXTm9kQzFoZFdOb0xYTnBZMmhsY21obGFYUnphMjl1Wm1WeVpXNTZaVzR0YzJsdWJteHZjeTF6WldsdSI+V2VubiBLcmllZ2Ugc2lubmxvcyB35HJlbiwgbfxzc3RlbiBkYW5uIG5pY2h0IGF1Y2ggU2ljaGVyaGVpdHNrb25mZXJlbnplbiBzaW5ubG9zIHNlaW4/PC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL2FudGlkZXMuZGUiIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+QW50aWRlcy5kLi4uPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTguIEZlYiAxMDo1MTwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0hNNkx5OTNkM2N1YUdWcGMyVXVaR1V2ZEhBdlptVmhkSFZ5WlhNdlZXMW1jbUZuWlc0dFRXVm9jbWhsYVhRdFpuVmxjaTFUWVc1amFHVjZMV0psYzNSbGJtWmhiR3h6TFcxcGRDMUxZWFJoYkdGdVpXNHRORE14TVRJMU1TNW9kRzFzIj5VbWZyYWdlbjogTWVocmhlaXQgZvxyIFNuY2hleiBiZXN0ZW5mYWxscyBtaXQgS2F0YWxhbmVuPC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly93d3cuaGVpc2UuZGUiIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+SGVpc2UuZGU8L2E+PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPXJpZ2h0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj4xOC4gRmViIDEwOjQ5PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj48dGQgY29sc3Bhbj0yIEhFSUdIVD01PjwvdGQ+PC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGFibGU+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj48dHIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9Jyc7IiBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9J3VybChodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvc2Nyb2xsLnBuZyknOyIgaGVpZ2h0PSIxOCI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRhYmxlIGJvcmRlcj0wIGhlaWdodD0yMCB3aWR0aD0xMDAlIGNlbGxTcGFjaW5nPTAgY2VsbFBhZGRpbmc9MCBzdHlsZT0icGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGJvcmRlci1ib3R0b206MXB4IGRvdHRlZCAjZWZlZmVmOyI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBjb2xzcGFuPTI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8YSBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5jb2xvcj0nIzAwMDAwMCc7IiBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmNvbG9yPScjRkZGRkZGJzsiIHN0eWxlPSJ0ZXh0LWRlY29yYXRpb246bm9uZTsgYm9yZGVyOjBweCBzb2xpZCBibGFjazsgZm9udC13ZWlnaHQ6bm9ybWFsOyBmb250LXNpemU6MTJweDsgY29sb3I6I0ZFRkVGRTsgIGZvbnQtZmFtaWx5OlZlcmRhbmE7IiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL3JlZGlyZWN0LnBocD9jb2RlPWFIUjBjSE02THk5a2FXVnJiMngxYlc1cGMzUmxiaTVrWlM4eU1ERTVMekF5THpFMkwyUmxjaTFyYjJGc2RHbHZibk56Y0dGc2RHVnlMdz09Ij5EZXIgS29hbHRpb25zc3BhbHRlcjwvYT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249bGVmdCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+PGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vZGlla29sdW1uaXN0ZW4uZGUiIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+RGlla29sdW1uLi4uPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTguIEZlYiAxMDo0Nzwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0hNNkx5OXFZV052WW1sdWJXRm5MbU52YlM4eU1ERTVMekF5TDJSdmJtRnNaQzEwY25WdGNDMXpkR0YwWlMxdlppMWxiV1Z5WjJWdVkza3RaWGhsWTNWMGFYWmxMWEJ2ZDJWeUxXbHRiV2xuY21GMGFXOXVMdz09Ij5UcnVtcCBJcyBBYm91dCB0byBEZWNsYXJlIGEgU3RhdGUgb2YgRW1lcmdlbmN5LiBXaGF0IERvZXMgSXQgTWVhbj88L2E+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPWxlZnQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2phY29iaW5tYWcuY29tIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPkphY29iaW5tYS4uLjwvYT48L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249cmlnaHQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjE4LiBGZWIgMTA6NDM8L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPjx0ZCBjb2xzcGFuPTIgSEVJR0hUPTU+PC90ZD48L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90YWJsZT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0ciBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0nJzsiIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0ndXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9zY3JvbGwucG5nKSc7IiBoZWlnaHQ9IjE4Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGFibGUgYm9yZGVyPTAgaGVpZ2h0PTIwIHdpZHRoPTEwMCUgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgYm9yZGVyLWJvdHRvbToxcHggZG90dGVkICNlZmVmZWY7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGNvbHNwYW49Mj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmNvbG9yPScjMDAwMDAwJzsiIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuY29sb3I9JyNGRkZGRkYnOyIgc3R5bGU9InRleHQtZGVjb3JhdGlvbjpub25lOyBib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBmb250LXdlaWdodDpub3JtYWw7IGZvbnQtc2l6ZToxMnB4OyBjb2xvcjojRkVGRUZFOyAgZm9udC1mYW1pbHk6VmVyZGFuYTsiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvcmVkaXJlY3QucGhwP2NvZGU9YUhSMGNITTZMeTkzZDNjdWFuVnVaMlYzWld4MExtUmxMMkZ5ZEdsclpXd3ZNelE1TXpBMkxuTnBZMmhsY21obGFYUnphMjl1Wm1WeVpXNTZMV2x1TFcwbFF6TWxRa051WTJobGJpMTBZWFZ6Wlc1a1pTMW5aV2RsYmkxcmNtbGxaeTVvZEcxcyI+RGVtb25zdHJhbnRlbiB1bXppbmdlbG4gTfxuY2huZXIgU2ljaGVyaGVpdHNrb25mZXJlbno8L2E+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPWxlZnQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL3d3dy5qdW5nZXdlbHQuZGUiIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+SnVuZ2V3ZWx0Li4uPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTguIEZlYiAxMDo0Mjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0hNNkx5OWtaWFYwYzJOb0xuSjBMbU52YlM5dFpXbHVkVzVuTHpnME16RTNMVzFsYVc1MWJtZHpabkpsYVdobGFYUXRhVzR0WkdWMWRITmphR3hoYm1RdGFXNHRaMlZtWVdoeUx3PT0iPklzcmFlbGtyaXRpayB1bmVyd/xuc2NodDogTWVpbnVuZ3NmcmVpaGVpdCBpbiBEZXV0c2NobGFuZCBpbiBHZWZhaHI/IDwvYT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249bGVmdCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+PGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vZGV1dHNjaC5ydC5jb20iIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+RGV1dHNjaC5yLi4uPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTguIEZlYiAxMDo0MDwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0hNNkx5OTNkM2N1YUdWcGMyVXVaR1V2Ym1WM2MzUnBZMnRsY2k5dFpXeGtkVzVuTDBSaGRHVnVjMk5vZFdWMGVtVnlMV2x0TFU1dmNtUmxiaTFRWlhKemIyNWhiQzF5WldsamFIUXRibWxqYUhRdFlYVnpMVFF6TVRFeU1qSXVhSFJ0YkE9PSI+RGF0ZW5zY2j8dHplciBpbSBOb3JkZW46IFBlcnNvbmFsIHJlaWNodCBuaWNodCBhdXMgPC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly93d3cuaGVpc2UuZGUiIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+SGVpc2UuZGU8L2E+PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPXJpZ2h0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj4xOC4gRmViIDEwOjM4PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj48dGQgY29sc3Bhbj0yIEhFSUdIVD01PjwvdGQ+PC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGFibGU+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj48dHIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9Jyc7IiBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9J3VybChodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvc2Nyb2xsLnBuZyknOyIgaGVpZ2h0PSIxOCI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRhYmxlIGJvcmRlcj0wIGhlaWdodD0yMCB3aWR0aD0xMDAlIGNlbGxTcGFjaW5nPTAgY2VsbFBhZGRpbmc9MCBzdHlsZT0icGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGJvcmRlci1ib3R0b206MXB4IGRvdHRlZCAjZWZlZmVmOyI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBjb2xzcGFuPTI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8YSBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5jb2xvcj0nIzAwMDAwMCc7IiBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmNvbG9yPScjRkZGRkZGJzsiIHN0eWxlPSJ0ZXh0LWRlY29yYXRpb246bm9uZTsgYm9yZGVyOjBweCBzb2xpZCBibGFjazsgZm9udC13ZWlnaHQ6bm9ybWFsOyBmb250LXNpemU6MTJweDsgY29sb3I6I0ZFRkVGRTsgIGZvbnQtZmFtaWx5OlZlcmRhbmE7IiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL3JlZGlyZWN0LnBocD9jb2RlPWFIUjBjSE02THk5M2QzY3VZbVZ5YkdsdVpYSXRlbVZwZEhWdVp5NWtaUzl3YjJ4cGRHbHJMM1psY25kaGJIUjFibWN0YzNSaGRIUXRkMlZwZEdWeVltbHNaSFZ1WnkxcWIySmpaVzUwWlhJdGRtVnljMk5vYVdWaVpXNHRaV2x1WlMxdGFXeHNhV0Z5WkdVdE16SXdOVFUwTXpnPSI+Sm9iY2VudGVyIHZlcnNjaGllYmVuIGVpbmUgTWlsbGlhcmRlIDwvYT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249bGVmdCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+PGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vd3d3LmJlcmxpbmVyLXplaXR1bmcuZGUiIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+QmVybGluZXItLi4uPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTguIEZlYiAxMDozNjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0RvdkwzZDNkeTV6Y0dsbFoyVnNMbVJsTDNkcGNuUnpZMmhoWm5RdmRXNTBaWEp1WldodFpXNHZaR1YxZEhOamFHVXRjRzl6ZEMxM2FXeHNMWEJoYTJWMGVuVnpkR1ZzYkhWdVp5MXRhWFF0WW1sc2JHbG5kRzlqYUhSbGNpMWtaV3hwZG1WeWVTMTZkWE5oYlcxbGJteGxaMlZ1TFdFdE1USTFNemN5Tnk1b2RHMXMiPkRldXRzY2hlIFBvc3Qgd2lsbCBQYWtldHp1c3RlbGx1bmcgbWl0IEJpbGxpZ3RvY2h0ZXIgRGVsaXZlcnkgenVzYW1tZW5sZWdlbjwvYT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249bGVmdCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+PGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cuc3BpZWdlbC5kZSIgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsgdGV4dC1kZWNvcmF0aW9uOm5vbmU7Ij5TcGllZ2VsLmQuLi48L2E+PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPXJpZ2h0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj4xOC4gRmViIDEwOjM0PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj48dGQgY29sc3Bhbj0yIEhFSUdIVD01PjwvdGQ+PC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGFibGU+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj48dHIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9Jyc7IiBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9J3VybChodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvc2Nyb2xsLnBuZyknOyIgaGVpZ2h0PSIxOCI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRhYmxlIGJvcmRlcj0wIGhlaWdodD0yMCB3aWR0aD0xMDAlIGNlbGxTcGFjaW5nPTAgY2VsbFBhZGRpbmc9MCBzdHlsZT0icGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGJvcmRlci1ib3R0b206MXB4IGRvdHRlZCAjZWZlZmVmOyI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBjb2xzcGFuPTI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8YSBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5jb2xvcj0nIzAwMDAwMCc7IiBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmNvbG9yPScjRkZGRkZGJzsiIHN0eWxlPSJ0ZXh0LWRlY29yYXRpb246bm9uZTsgYm9yZGVyOjBweCBzb2xpZCBibGFjazsgZm9udC13ZWlnaHQ6bm9ybWFsOyBmb250LXNpemU6MTJweDsgY29sb3I6I0ZFRkVGRTsgIGZvbnQtZmFtaWx5OlZlcmRhbmE7IiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL3JlZGlyZWN0LnBocD9jb2RlPWFIUjBjSE02THk5a2RYTm9ZVzUzWldkdVpYSXVZMjl0TDJobGJHWmxjbk41Ym1SeWIyMHYiPkRldXRzY2hsYW5kLCBlaW4gTGFuZCBtaXQgSGVsZmVyc3luZHJvbT88L2E+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPWxlZnQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2R1c2hhbndlZ25lci5jb20iIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+RHVzaGFud2VnLi4uPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTguIEZlYiAxMDozMjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0hNNkx5OTNkM2N1Wm5KbGFYUmhaeTVrWlM5aGRYUnZjbVZ1TDJSbGNpMW1jbVZwZEdGbkwzWnZiUzF5ZFhOelpXNHRZWFZtTFdScFpTMW1jbVZ6YzJVPSI+Vm9tIFJ1c3NlbiBhdWYgZGllIEZyZXNzZSA8L2E+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPWxlZnQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL3d3dy5mcmVpdGFnLmRlIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPkZyZWl0YWcuZC4uLjwvYT48L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249cmlnaHQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjE4LiBGZWIgMTA6MzE8L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPjx0ZCBjb2xzcGFuPTIgSEVJR0hUPTU+PC90ZD48L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90YWJsZT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0ciBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0nJzsiIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0ndXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9zY3JvbGwucG5nKSc7IiBoZWlnaHQ9IjE4Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGFibGUgYm9yZGVyPTAgaGVpZ2h0PTIwIHdpZHRoPTEwMCUgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgYm9yZGVyLWJvdHRvbToxcHggZG90dGVkICNlZmVmZWY7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGNvbHNwYW49Mj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmNvbG9yPScjMDAwMDAwJzsiIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuY29sb3I9JyNGRkZGRkYnOyIgc3R5bGU9InRleHQtZGVjb3JhdGlvbjpub25lOyBib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBmb250LXdlaWdodDpub3JtYWw7IGZvbnQtc2l6ZToxMnB4OyBjb2xvcjojRkVGRUZFOyAgZm9udC1mYW1pbHk6VmVyZGFuYTsiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvcmVkaXJlY3QucGhwP2NvZGU9YUhSMGNITTZMeTkzZDNjdWNtRjBhVzl1WVd4bllXeGxjbWxsTG1SbEwydHlhWFJwYXk5a2FXMWxibk5wYjI1bGJpMWtaWEl0WjJWM1lXeDBMbWgwYld3PSI+RGltZW5zaW9uZW4gZGVyIEdld2FsdDogRGllIEJlcmxpbmFsZSBpbSBTb2cgZGVyIE1hY2h0PC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly93d3cucmF0aW9uYWxnYWxlcmllLmRlIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPlJhdGlvbmFsZy4uLjwvYT48L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249cmlnaHQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjE4LiBGZWIgMTA6Mjk8L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPjx0ZCBjb2xzcGFuPTIgSEVJR0hUPTU+PC90ZD48L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90YWJsZT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0ciBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0nJzsiIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0ndXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9zY3JvbGwucG5nKSc7IiBoZWlnaHQ9IjE4Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGFibGUgYm9yZGVyPTAgaGVpZ2h0PTIwIHdpZHRoPTEwMCUgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgYm9yZGVyLWJvdHRvbToxcHggZG90dGVkICNlZmVmZWY7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGNvbHNwYW49Mj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmNvbG9yPScjMDAwMDAwJzsiIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuY29sb3I9JyNGRkZGRkYnOyIgc3R5bGU9InRleHQtZGVjb3JhdGlvbjpub25lOyBib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBmb250LXdlaWdodDpub3JtYWw7IGZvbnQtc2l6ZToxMnB4OyBjb2xvcjojRkVGRUZFOyAgZm9udC1mYW1pbHk6VmVyZGFuYTsiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvcmVkaXJlY3QucGhwP2NvZGU9YUhSMGNITTZMeTl4ZFdWeVpHVnVhMlZ1WkdVdVkyOXRMekl3TVRrdk1ESXZNVGd2YlhWbGJtTm9ibVZ5TFhOcFkyaGxjbWhsYVhSemEyOXVabVZ5Wlc1NkxXOW1abVZ1WW1GeWRDMTBjblZ0Y0hNdGQybHNiR3QxWlhJdiI+TfxuY2huZXIgU2ljaGVyaGVpdHNrb25mZXJlbnogb2ZmZW5iYXJ0IFRydW1wcyBXaWxsa/xyPC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9xdWVyZGVua2VuZGUuY29tIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPlF1ZXJkZW5rZS4uLjwvYT48L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249cmlnaHQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjE4LiBGZWIgMTA6Mjc8L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPjx0ZCBjb2xzcGFuPTIgSEVJR0hUPTU+PC90ZD48L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90YWJsZT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0ciBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0nJzsiIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0ndXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9zY3JvbGwucG5nKSc7IiBoZWlnaHQ9IjE4Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGFibGUgYm9yZGVyPTAgaGVpZ2h0PTIwIHdpZHRoPTEwMCUgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgYm9yZGVyLWJvdHRvbToxcHggZG90dGVkICNlZmVmZWY7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGNvbHNwYW49Mj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmNvbG9yPScjMDAwMDAwJzsiIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuY29sb3I9JyNGRkZGRkYnOyIgc3R5bGU9InRleHQtZGVjb3JhdGlvbjpub25lOyBib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBmb250LXdlaWdodDpub3JtYWw7IGZvbnQtc2l6ZToxMnB4OyBjb2xvcjojRkVGRUZFOyAgZm9udC1mYW1pbHk6VmVyZGFuYTsiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvcmVkaXJlY3QucGhwP2NvZGU9YUhSMGNITTZMeTlpY21GMlpXNWxkMlYxY205d1pTNWpiMjB2Y21WdGFTMWxaSGRoY21SekxXdHViM2RwYm1jdFkyOXRiVzlrYVhScFpYTXRkR2h5YjNWbmFDMWpiM0p3YjNKaGRHVXRibUZ5Y21GMGFYWmxjeTEwYUdVdGNHOXZjaTF3Y205emNHVmpkSE10Wm05eUxXVjBhR2xqWVd3dFkyOXVjM1Z0Y0hScGIyND0iPkNvcnBvcmF0ZSBuYXJyYXRpdmUgbGllcyA8L2E+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPWxlZnQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2JyYXZlbmV3ZXVyb3BlLmNvbSIgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsgdGV4dC1kZWNvcmF0aW9uOm5vbmU7Ij5CcmF2ZW5ld2UuLi48L2E+PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPXJpZ2h0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj4xOC4gRmViIDA4OjU3PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj48dGQgY29sc3Bhbj0yIEhFSUdIVD01PjwvdGQ+PC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGFibGU+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj48dHIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9Jyc7IiBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9J3VybChodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvc2Nyb2xsLnBuZyknOyIgaGVpZ2h0PSIxOCI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRhYmxlIGJvcmRlcj0wIGhlaWdodD0yMCB3aWR0aD0xMDAlIGNlbGxTcGFjaW5nPTAgY2VsbFBhZGRpbmc9MCBzdHlsZT0icGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGJvcmRlci1ib3R0b206MXB4IGRvdHRlZCAjZWZlZmVmOyI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBjb2xzcGFuPTI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8YSBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5jb2xvcj0nIzAwMDAwMCc7IiBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmNvbG9yPScjRkZGRkZGJzsiIHN0eWxlPSJ0ZXh0LWRlY29yYXRpb246bm9uZTsgYm9yZGVyOjBweCBzb2xpZCBibGFjazsgZm9udC13ZWlnaHQ6bm9ybWFsOyBmb250LXNpemU6MTJweDsgY29sb3I6I0ZFRkVGRTsgIGZvbnQtZmFtaWx5OlZlcmRhbmE7IiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL3JlZGlyZWN0LnBocD9jb2RlPWFIUjBjSE02THk5M2QzY3VjbUYwYVc5dVlXeG5ZV3hsY21sbExtUmxMMmh2YldVdmRISjFiWEF0WkdsbExYcGxhWFJpYjIxaVpTNW9kRzFzIj5UcnVtcCwgZGllIFplaXRib21iZTogRGllIEtvbmZlcmVueiBkZXIgV2lsbGlnZW4gaW4gUG9sZW48L2E+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPWxlZnQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL3d3dy5yYXRpb25hbGdhbGVyaWUuZGUiIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+UmF0aW9uYWxnLi4uPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTguIEZlYiAwODo1NTwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0hNNkx5OTNkM2N1WVdKblpXOXlaRzVsZEdWdWQyRjBZMmd1WkdVdllteHZaeTh5TURFNUxUQXlMVEUxTDNObGFYUmxibmRsWTJoelpXd3RiRzlpWW5sMlpYSmlZV1Z1WkdVdGNtVnJjblYwYVdWeVpXNHRkbVZ5ZEhKaGRYUmxMWFp2YmkxaWRXNWtaWE4wWVdkellXSm5aVzl5Wkc1bGRHVnUiPlNlaXRlbndlY2hzZWw6IExvYmJ5dmVyYuRuZGUgcmVrcnV0aWVyZW4gQvxyb2xlaXRlciB2b24gQWJnZW9yZG5ldGVuPC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly93d3cuYWJnZW9yZG5ldGVud2F0Y2guZGUiIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+QWJnZW9yZG5lLi4uPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTguIEZlYiAwODo1Mjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0hNNkx5OTNkM2N1WTJsc2FYQXVaR1V2TWpBeE9TOHdNaTh4TlM5aFluZGxhSEl0ZG05dUxXUnliMmh1Wlc0dGNHOXNhWHBsYVMxdWRYUjZkQzF0YVd4cGRHRmxjblJsWTJodWFXc3YiPkFid2VociB2b24gRHJvaG5lbjogUG9saXplaSBudXR6dCBNaWxpdORydGVjaG5pazwvYT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249bGVmdCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+PGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vd3d3LmNpbGlwLmRlIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPkNpbGlwLmRlPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTguIEZlYiAwODo0OTwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0hNNkx5OTNkM2N1YW5WdVoyVjNaV3gwTG1SbEwyRnlkR2xyWld3dk16UTVNelExTG5OcGMzbHdhSFZ6TFdScGNHeHZiV0YwYVdVdWFIUnRiQT09Ij5TaXN5cGh1cy1EaXBsb21hdGllOiBTaWNoZXJoZWl0c2tvbmZlcmVueiB1bmQgSU5GLVZlcnRyYWc8L2E+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPWxlZnQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL3d3dy5qdW5nZXdlbHQuZGUiIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+SnVuZ2V3ZWx0Li4uPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTguIEZlYiAwODo0ODwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0hNNkx5OTNkM2N1WVc1MGFTMXpjR2xsWjJWc0xuSjFMekl3TVRrdlpHbGxMWE5wWTJoMExXUmxjaTFoYm1SbGNtVnVMV1JoY3kxeWRYTnphWE5qYUdVdFptVnlibk5sYUdWdUxYVmxZbVZ5TFdScFpTMXRkV1Z1WTJobGJtVnlMWE5wWTJobGNtaGxhWFJ6YTI5dVptVnlaVzU2THc9PSI+RGFzIHJ1c3Npc2NoZSBGZXJuc2VoZW4g/GJlciBkaWUgTfxuY2hlbmVyIFNpY2hlcmhlaXRza29uZmVyZW56PC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly93d3cuYW50aS1zcGllZ2VsLnJ1IiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPkFudGktc3BpZS4uLjwvYT48L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249cmlnaHQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjE4LiBGZWIgMDg6NDU8L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPjx0ZCBjb2xzcGFuPTIgSEVJR0hUPTU+PC90ZD48L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90YWJsZT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0ciBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0nJzsiIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0ndXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9zY3JvbGwucG5nKSc7IiBoZWlnaHQ9IjE4Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGFibGUgYm9yZGVyPTAgaGVpZ2h0PTIwIHdpZHRoPTEwMCUgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgYm9yZGVyLWJvdHRvbToxcHggZG90dGVkICNlZmVmZWY7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGNvbHNwYW49Mj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmNvbG9yPScjMDAwMDAwJzsiIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuY29sb3I9JyNGRkZGRkYnOyIgc3R5bGU9InRleHQtZGVjb3JhdGlvbjpub25lOyBib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBmb250LXdlaWdodDpub3JtYWw7IGZvbnQtc2l6ZToxMnB4OyBjb2xvcjojRkVGRUZFOyAgZm9udC1mYW1pbHk6VmVyZGFuYTsiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvcmVkaXJlY3QucGhwP2NvZGU9YUhSMGNITTZMeTlrWVhNdFlteGhaWFIwWTJobGJpNWtaUzh5TURFNUx6QXlMMlJwWlMxdWRXdHNaV0Z5Wlc0dFlXMWlhWFJwYjI1bGJpMXlhV0ZrY3kwME56SXpOUzVvZEcxcyI+RGllIG51a2xlYXJlbiBBbWJpdGlvbmVuIFJpYWRzPC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9kYXMtYmxhZXR0Y2hlbi5kZSIgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsgdGV4dC1kZWNvcmF0aW9uOm5vbmU7Ij5EYXMtYmxhZXQuLi48L2E+PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPXJpZ2h0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj4xOC4gRmViIDA4OjQzPC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj48dGQgY29sc3Bhbj0yIEhFSUdIVD01PjwvdGQ+PC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGFibGU+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj48dHIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9Jyc7IiBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9J3VybChodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvc2Nyb2xsLnBuZyknOyIgaGVpZ2h0PSIxOCI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRhYmxlIGJvcmRlcj0wIGhlaWdodD0yMCB3aWR0aD0xMDAlIGNlbGxTcGFjaW5nPTAgY2VsbFBhZGRpbmc9MCBzdHlsZT0icGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGJvcmRlci1ib3R0b206MXB4IGRvdHRlZCAjZWZlZmVmOyI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBjb2xzcGFuPTI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8YSBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5jb2xvcj0nIzAwMDAwMCc7IiBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmNvbG9yPScjRkZGRkZGJzsiIHN0eWxlPSJ0ZXh0LWRlY29yYXRpb246bm9uZTsgYm9yZGVyOjBweCBzb2xpZCBibGFjazsgZm9udC13ZWlnaHQ6bm9ybWFsOyBmb250LXNpemU6MTJweDsgY29sb3I6I0ZFRkVGRTsgIGZvbnQtZmFtaWx5OlZlcmRhbmE7IiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL3JlZGlyZWN0LnBocD9jb2RlPWFIUjBjRG92TDNkcGNuUnpZMmhoWm5Sc2FXTm9aV1p5Wldsb1pXbDBMbVJsTDNkdmNtUndjbVZ6Y3k4L2NEMHlORFl5TkE9PSI+V2llIGhhcnQgc29sbCBkaWUgRVUgYmVpIE5ldXZlcmhhbmRsdW5nZW4gZGVzIEJyZXhpdHMgdmVyaGFuZGVsbj88L2E+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPWxlZnQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd2lydHNjaGFmdGxpY2hlZnJlaWhlaXQuZGUiIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+V2lydHNjaGFmLi4uPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTguIEZlYiAwODo0MDwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0hNNkx5OWthV1ZtY21WcGFHVnBkSE5zYVdWaVpTNWtaUzl3YjJ4cGRHbHJMM1ZwWjNWeVpXNHRZMmhwYm1GekxXdGhiWEJtTFdkbFoyVnVMV1JwWlMxdGRYTnNhVzFwYzJOb1pTMXRhVzVrWlhKb1pXbDBMdz09Ij5VaWd1cmVuOiBDaGluYXMgS2FtcGYgZ2VnZW4gZGllIG11c2xpbWlzY2hlIE1pbmRlcmhlaXQ8L2E+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPWxlZnQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2RpZWZyZWloZWl0c2xpZWJlLmRlIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPkRpZWZyZWloZS4uLjwvYT48L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249cmlnaHQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjE4LiBGZWIgMDg6Mzk8L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPjx0ZCBjb2xzcGFuPTIgSEVJR0hUPTU+PC90ZD48L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90YWJsZT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0ciBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0nJzsiIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0ndXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9zY3JvbGwucG5nKSc7IiBoZWlnaHQ9IjE4Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGFibGUgYm9yZGVyPTAgaGVpZ2h0PTIwIHdpZHRoPTEwMCUgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgYm9yZGVyLWJvdHRvbToxcHggZG90dGVkICNlZmVmZWY7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGNvbHNwYW49Mj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmNvbG9yPScjMDAwMDAwJzsiIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuY29sb3I9JyNGRkZGRkYnOyIgc3R5bGU9InRleHQtZGVjb3JhdGlvbjpub25lOyBib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBmb250LXdlaWdodDpub3JtYWw7IGZvbnQtc2l6ZToxMnB4OyBjb2xvcjojRkVGRUZFOyAgZm9udC1mYW1pbHk6VmVyZGFuYTsiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvcmVkaXJlY3QucGhwP2NvZGU9YUhSMGNITTZMeTl1WlhWbExXUmxZbUYwZEdVdVkyOXRMekl3TVRrdk1ESXZNVFl2ZDJWeUxXaGhkQzFsZFhKdmNHRXRZWFZtTFdSbGJTMW5aWGRwYzNObGJpOD0iPldlciBoYXQgRXVyb3BhIGF1ZiBkZW0gR2V3aXNzZW4/IDwvYT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249bGVmdCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+PGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vbmV1ZS1kZWJhdHRlLmNvbSIgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsgdGV4dC1kZWNvcmF0aW9uOm5vbmU7Ij5OZXVlLWRlYmEuLi48L2E+PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPXJpZ2h0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj4xOC4gRmViIDA4OjM3PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj48dGQgY29sc3Bhbj0yIEhFSUdIVD01PjwvdGQ+PC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGFibGU+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj48dHIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9Jyc7IiBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9J3VybChodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvc2Nyb2xsLnBuZyknOyIgaGVpZ2h0PSIxOCI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRhYmxlIGJvcmRlcj0wIGhlaWdodD0yMCB3aWR0aD0xMDAlIGNlbGxTcGFjaW5nPTAgY2VsbFBhZGRpbmc9MCBzdHlsZT0icGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGJvcmRlci1ib3R0b206MXB4IGRvdHRlZCAjZWZlZmVmOyI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBjb2xzcGFuPTI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8YSBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5jb2xvcj0nIzAwMDAwMCc7IiBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmNvbG9yPScjRkZGRkZGJzsiIHN0eWxlPSJ0ZXh0LWRlY29yYXRpb246bm9uZTsgYm9yZGVyOjBweCBzb2xpZCBibGFjazsgZm9udC13ZWlnaHQ6bm9ybWFsOyBmb250LXNpemU6MTJweDsgY29sb3I6I0ZFRkVGRTsgIGZvbnQtZmFtaWx5OlZlcmRhbmE7IiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL3JlZGlyZWN0LnBocD9jb2RlPWFIUjBjSE02THk5M2QzY3VibTkyYnkxaGNtZDFiV1Z1ZEdVdVkyOXRMMkZ5ZEdsclpXd3ZabkpoYldsdVoxOWhiSE5mWkdsbGJuTjBYMkZ0WDJkbGJXVnBibmR2YUd3PSI+RnJhbWluZyBhbHMgRGllbnN0IGFtIEdlbWVpbndvaGw8L2E+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPWxlZnQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL3d3dy5ub3ZvLWFyZ3VtZW50ZS5jb20iIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+Tm92by1hcmd1Li4uPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTguIEZlYiAwNjo1Mjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0hNNkx5OTNkM2N1YUdWcGMyVXVaR1V2ZEhBdlptVmhkSFZ5WlhNdlFYTnpZV1F0VW1WbmFXMWxMWE52Ykd3dFpuVmxjaTFtWVhOMExXRnNiR1V0ZG05dUxUTXpOaTFoYm1kbFlteHBZMmhsYmkxRGFHVnRhV1YzWVdabVpXNWhibWR5YVdabVpXNHRkbVZ5WVc1MGQyOXlkR3hwWTJndGMyVnBiaTAwTXpFeE1qZ3dMbWgwYld3PSI+QXNzYWQtUmVnaW1lIHNvbGwgZvxyIGZhc3QgYWxsZSB2b24gMzM2IGFuZ2VibGljaGVuIENoZW1pZXdhZmZlbmFuZ3JpZmZlbiB2ZXJhbnR3b3J0bGljaCBzZWluPC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly93d3cuaGVpc2UuZGUiIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+SGVpc2UuZGU8L2E+PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPXJpZ2h0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj4xOC4gRmViIDA2OjUwPC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj48dGQgY29sc3Bhbj0yIEhFSUdIVD01PjwvdGQ+PC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGFibGU+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj48dHIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9Jyc7IiBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9J3VybChodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvc2Nyb2xsLnBuZyknOyIgaGVpZ2h0PSIxOCI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRhYmxlIGJvcmRlcj0wIGhlaWdodD0yMCB3aWR0aD0xMDAlIGNlbGxTcGFjaW5nPTAgY2VsbFBhZGRpbmc9MCBzdHlsZT0icGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGJvcmRlci1ib3R0b206MXB4IGRvdHRlZCAjZWZlZmVmOyI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBjb2xzcGFuPTI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8YSBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5jb2xvcj0nIzAwMDAwMCc7IiBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmNvbG9yPScjRkZGRkZGJzsiIHN0eWxlPSJ0ZXh0LWRlY29yYXRpb246bm9uZTsgYm9yZGVyOjBweCBzb2xpZCBibGFjazsgZm9udC13ZWlnaHQ6bm9ybWFsOyBmb250LXNpemU6MTJweDsgY29sb3I6I0ZFRkVGRTsgIGZvbnQtZmFtaWx5OlZlcmRhbmE7IiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL3JlZGlyZWN0LnBocD9jb2RlPWFIUjBjSE02THk5M2QzY3VhblZ1WjJWM1pXeDBMbVJsTDJGeWRHbHJaV3d2TXpRNU16RXdMbTVsZFdVdGFXNTBaWEp1WVhScGIyNWhiR1V0YjNKa2JuVnVaeTF0WVdOb2RIWmxjbXgxYzNRdFpHVnpMWGRsYzNSbGJuTXRhWE4wTFc1cFkyaDBMV0YxWm5wMWFHRnNkR1Z1TG1oMGJXdz0iPk1hY2h0dmVybHVzdCBkZXMgV2VzdGVucyBpc3QgbmljaHQgYXVmenVoYWx0ZW48L2E+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPWxlZnQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL3d3dy5qdW5nZXdlbHQuZGUiIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+SnVuZ2V3ZWx0Li4uPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTguIEZlYiAwNjo0Nzwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0hNNkx5OTNkM2N1ZW1WcGRDMW1jbUZuWlc0dVkyZ3ZaR1V2WVhWeloyRmlaVzR2TWpBeE9TOXVjaTAwTFRFeUxXWmxZbkoxWVhJdE1qQXhPUzlwYlcxbGNpMXRaV2h5TFdSeWIyaDBMV3R5YVdWbkxXRmlaWEl0ZDJWeUxYZHBjbVF0WjJWblpXNXpkR1YxWlhKdUxtaDBiV3c9Ij5JbW1lciBtZWhyIGRyb2h0IEtyaWVnISBBYmVyIHdlciB3aXJkIGdlZ2Vuc3RldWVybj88L2E+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPWxlZnQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL3d3dy56ZWl0LWZyYWdlbi5jaCIgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsgdGV4dC1kZWNvcmF0aW9uOm5vbmU7Ij5aZWl0LWZyYWcuLi48L2E+PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPXJpZ2h0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj4xOC4gRmViIDA2OjQ1PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj48dGQgY29sc3Bhbj0yIEhFSUdIVD01PjwvdGQ+PC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGFibGU+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj48dHIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9Jyc7IiBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9J3VybChodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvc2Nyb2xsLnBuZyknOyIgaGVpZ2h0PSIxOCI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRhYmxlIGJvcmRlcj0wIGhlaWdodD0yMCB3aWR0aD0xMDAlIGNlbGxTcGFjaW5nPTAgY2VsbFBhZGRpbmc9MCBzdHlsZT0icGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGJvcmRlci1ib3R0b206MXB4IGRvdHRlZCAjZWZlZmVmOyI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBjb2xzcGFuPTI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8YSBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5jb2xvcj0nIzAwMDAwMCc7IiBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmNvbG9yPScjRkZGRkZGJzsiIHN0eWxlPSJ0ZXh0LWRlY29yYXRpb246bm9uZTsgYm9yZGVyOjBweCBzb2xpZCBibGFjazsgZm9udC13ZWlnaHQ6bm9ybWFsOyBmb250LXNpemU6MTJweDsgY29sb3I6I0ZFRkVGRTsgIGZvbnQtZmFtaWx5OlZlcmRhbmE7IiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL3JlZGlyZWN0LnBocD9jb2RlPWFIUjBjSE02THk5M2QzY3VaMjlzWlcwdVpHVXZibVYzY3k5a1lYUmxibk5qYUhWMGVpMHhPQzB3TURBdFlXNWtjbTlwWkMxaGNIQnpMWE53YVc5dWFXVnlaVzR0Ym5WMGVtVnlMWFZ1ZW5Wc1lXVnpjMmxuTFdGMWN5MHhPVEF5TFRFek9UUXpOQzVvZEcxcyI+MTguMDAwIEFuZHJvaWQtQXBwcyBzcGlvbmllcmVuIE51dHplciB1bnp1bORzc2lnIGF1czwvYT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249bGVmdCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+PGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vd3d3LmdvbGVtLmRlIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPkdvbGVtLmRlPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTguIEZlYiAwNjo0Mjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0hNNkx5OTNkM2N1Y25WaWFXdHZiaTV1WlhkekwyRnlkR2xyWld3dlpHVnlMWFZpWlhKeVlYTmphSFZ1WjNNdFkyOTFjQT09Ij5EZXIg3GJlcnJhc2NodW5ncy1Db3VwPC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly93d3cucnViaWtvbi5uZXdzIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPlJ1Ymlrb24ubi4uLjwvYT48L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249cmlnaHQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjE4LiBGZWIgMDY6NDA8L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPjx0ZCBjb2xzcGFuPTIgSEVJR0hUPTU+PC90ZD48L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90YWJsZT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0ciBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0nJzsiIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0ndXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9zY3JvbGwucG5nKSc7IiBoZWlnaHQ9IjE4Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGFibGUgYm9yZGVyPTAgaGVpZ2h0PTIwIHdpZHRoPTEwMCUgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgYm9yZGVyLWJvdHRvbToxcHggZG90dGVkICNlZmVmZWY7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGNvbHNwYW49Mj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmNvbG9yPScjMDAwMDAwJzsiIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuY29sb3I9JyNGRkZGRkYnOyIgc3R5bGU9InRleHQtZGVjb3JhdGlvbjpub25lOyBib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBmb250LXdlaWdodDpub3JtYWw7IGZvbnQtc2l6ZToxMnB4OyBjb2xvcjojRkVGRUZFOyAgZm9udC1mYW1pbHk6VmVyZGFuYTsiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvcmVkaXJlY3QucGhwP2NvZGU9YUhSMGNITTZMeTlrWlhWMGMyTm9MbkowTG1OdmJTOXBibXhoYm1Rdk9EUXpNVFl0WVc1MGFtVXRhR1Z5YldWdVlYVXRaWE10WjJWb2RDMXVhV05vZEM4PSI+P0VzIGdlaHQgbmljaHQgdW0gcmVjaHRzIG9kZXIgbGlua3MsIGVzIGdlaHQgdW0gb2JlbiB1bmQgdW50ZW4/PC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9kZXV0c2NoLnJ0LmNvbSIgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsgdGV4dC1kZWNvcmF0aW9uOm5vbmU7Ij5EZXV0c2NoLnIuLi48L2E+PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPXJpZ2h0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj4xOC4gRmViIDA2OjM4PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj48dGQgY29sc3Bhbj0yIEhFSUdIVD01PjwvdGQ+PC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGFibGU+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj48dHIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9Jyc7IiBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9J3VybChodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvc2Nyb2xsLnBuZyknOyIgaGVpZ2h0PSIxOCI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRhYmxlIGJvcmRlcj0wIGhlaWdodD0yMCB3aWR0aD0xMDAlIGNlbGxTcGFjaW5nPTAgY2VsbFBhZGRpbmc9MCBzdHlsZT0icGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGJvcmRlci1ib3R0b206MXB4IGRvdHRlZCAjZWZlZmVmOyI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBjb2xzcGFuPTI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8YSBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5jb2xvcj0nIzAwMDAwMCc7IiBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmNvbG9yPScjRkZGRkZGJzsiIHN0eWxlPSJ0ZXh0LWRlY29yYXRpb246bm9uZTsgYm9yZGVyOjBweCBzb2xpZCBibGFjazsgZm9udC13ZWlnaHQ6bm9ybWFsOyBmb250LXNpemU6MTJweDsgY29sb3I6I0ZFRkVGRTsgIGZvbnQtZmFtaWx5OlZlcmRhbmE7IiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL3JlZGlyZWN0LnBocD9jb2RlPWFIUjBjSE02THk5M2QzY3VhMjl1ZEdWNGRIZHZZMmhsYm5wbGFYUjFibWN1WkdVdmQybHlkSE5qYUdGbWRDODBNVEV2YldsMGRHVnNjM1JoYm1RdGJXbDBMWE5qYUhkbGFXNWxhSFZ1WkMwMU56RTFMbWgwYld3aiI+TWl0dGVsc3RhbmQgbWl0IFNjaHdlaW5laHVuZDwvYT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249bGVmdCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+PGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vd3d3LmtvbnRleHR3b2NoZW56ZWl0dW5nLmRlIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPktvbnRleHR3by4uLjwvYT48L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249cmlnaHQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjE4LiBGZWIgMDY6MzY8L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPjx0ZCBjb2xzcGFuPTIgSEVJR0hUPTU+PC90ZD48L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90YWJsZT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0ciBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0nJzsiIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0ndXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9zY3JvbGwucG5nKSc7IiBoZWlnaHQ9IjE4Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGFibGUgYm9yZGVyPTAgaGVpZ2h0PTIwIHdpZHRoPTEwMCUgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgYm9yZGVyLWJvdHRvbToxcHggZG90dGVkICNlZmVmZWY7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGNvbHNwYW49Mj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmNvbG9yPScjMDAwMDAwJzsiIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuY29sb3I9JyNGRkZGRkYnOyIgc3R5bGU9InRleHQtZGVjb3JhdGlvbjpub25lOyBib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBmb250LXdlaWdodDpub3JtYWw7IGZvbnQtc2l6ZToxMnB4OyBjb2xvcjojRkVGRUZFOyAgZm9udC1mYW1pbHk6VmVyZGFuYTsiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvcmVkaXJlY3QucGhwP2NvZGU9YUhSMGNITTZMeTkzZDNjdVlteHZaeTFrWlhJdGNtVndkV0pzYVdzdVpHVXZjMlZsYUc5bVpYSnpMV0Z1YzJOb2JHRm5MV0YxWmkxa2FXVXRhMjloYkdsMGFXOXVMWFJ5YVdabWRDMTJiM0l0WVd4c1pXMHRaR2xsTFhOd1pDOD0iPlNlZWhvZmVycyBBbnNjaGxhZyBhdWYgZGllIEtvYWxpdGlvbiB0cmlmZnQgdm9yIGFsbGVtIGRpZSBTUEQ8L2E+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPWxlZnQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL3d3dy5ibG9nLWRlci1yZXB1Ymxpay5kZSIgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsgdGV4dC1kZWNvcmF0aW9uOm5vbmU7Ij5CbG9nLWRlci0uLi48L2E+PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPXJpZ2h0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj4xOC4gRmViIDA2OjM0PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj48dGQgY29sc3Bhbj0yIEhFSUdIVD01PjwvdGQ+PC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGFibGU+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj48dHIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9Jyc7IiBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9J3VybChodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvc2Nyb2xsLnBuZyknOyIgaGVpZ2h0PSIxOCI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRhYmxlIGJvcmRlcj0wIGhlaWdodD0yMCB3aWR0aD0xMDAlIGNlbGxTcGFjaW5nPTAgY2VsbFBhZGRpbmc9MCBzdHlsZT0icGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGJvcmRlci1ib3R0b206MXB4IGRvdHRlZCAjZWZlZmVmOyI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBjb2xzcGFuPTI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8YSBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5jb2xvcj0nIzAwMDAwMCc7IiBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmNvbG9yPScjRkZGRkZGJzsiIHN0eWxlPSJ0ZXh0LWRlY29yYXRpb246bm9uZTsgYm9yZGVyOjBweCBzb2xpZCBibGFjazsgZm9udC13ZWlnaHQ6bm9ybWFsOyBmb250LXNpemU6MTJweDsgY29sb3I6I0ZFRkVGRTsgIGZvbnQtZmFtaWx5OlZlcmRhbmE7IiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL3JlZGlyZWN0LnBocD9jb2RlPWFIUjBjRG92TDNkM2R5NW5jbWxsWTJobGJteGhibVF0WW14dlp5NW5jaTh5TURFNUx6QXlMM1JsZFdWeWRXNW5MV0psZFhSbGJIUXRaM0pwWldOb1pXNXNZVzVrY3kxcmIyNXpkVzFsYm5SbGJpOHlNVFF6TmpFNUx3PT0iPlRldWVydW5nIGJldXRlbHQgR3JpZWNoZW5sYW5kcyBLb25zdW1lbnRlbiA8L2E+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPWxlZnQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3LmdyaWVjaGVubGFuZC1ibG9nLmdyIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPkdyaWVjaGVubC4uLjwvYT48L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249cmlnaHQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjE4LiBGZWIgMDY6MzI8L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPjx0ZCBjb2xzcGFuPTIgSEVJR0hUPTU+PC90ZD48L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90YWJsZT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0ciBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0nJzsiIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0ndXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9zY3JvbGwucG5nKSc7IiBoZWlnaHQ9IjE4Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGFibGUgYm9yZGVyPTAgaGVpZ2h0PTIwIHdpZHRoPTEwMCUgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgYm9yZGVyLWJvdHRvbToxcHggZG90dGVkICNlZmVmZWY7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGNvbHNwYW49Mj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmNvbG9yPScjMDAwMDAwJzsiIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuY29sb3I9JyNGRkZGRkYnOyIgc3R5bGU9InRleHQtZGVjb3JhdGlvbjpub25lOyBib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBmb250LXdlaWdodDpub3JtYWw7IGZvbnQtc2l6ZToxMnB4OyBjb2xvcjojRkVGRUZFOyAgZm9udC1mYW1pbHk6VmVyZGFuYTsiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvcmVkaXJlY3QucGhwP2NvZGU9YUhSMGNITTZMeTkzZDNjdVpuSmxhWFJoWnk1a1pTOWhkWFJ2Y21WdUwyUmxjaTFtY21WcGRHRm5MMlJsY2kxemFXNXVMV1JsY3kxelpXaGxibk09Ij5EZXIgU2lubiBkZXMgU2VoZW5zIDwvYT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249bGVmdCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+PGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vd3d3LmZyZWl0YWcuZGUiIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+RnJlaXRhZy5kLi4uPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTguIEZlYiAwNjozMTwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0RvdkwzZDNkeTUwWVhvdVpHVXZSR0Z6TFhkaGNpMWthV1V0UW1WeWJHbHVZV3hsTHlFMU5UY3dPRFV4THc9PSI+VmllbGUgV29ydGUgZvxyIGRpZSBlaW5lIFNhY2hlPC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy50YXouZGUiIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+VGF6LmRlPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTguIEZlYiAwNjoyOTwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0hNNkx5OTNkM2N1Wm1GNkxtNWxkQzloYTNSMVpXeHNMM053YjNKMEwyWjFjM05pWVd4c0wyWjFjM05pWVd4c0xUQXRNakF0Y21WcmIzSmtjR3hsYVhSbExXWjFaWEl0Y0dsaFkyVnVlbUZ6TFhSbFpXNWhaMlZ5TFhKMWJYQm1kR1ZoYlMxcGJpMXBkR0ZzYVdWdUxURTJNRFEyTlRneUxtaDBiV3c9Ij4/RWluZSBkZXJhcnRpZ2UgRmFyY2Ugd2VyZGVuIHdpciBuaWUgd2llZGVyIGVyZHVsZGVuPzwvYT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249bGVmdCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+PGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vd3d3LmZhei5uZXQiIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+RmF6Lm5ldDwvYT48L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249cmlnaHQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjE4LiBGZWIgMDY6Mjc8L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPjx0ZCBjb2xzcGFuPTIgSEVJR0hUPTU+PC90ZD48L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90YWJsZT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0ciBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0nJzsiIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0ndXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9zY3JvbGwucG5nKSc7IiBoZWlnaHQ9IjE4Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGFibGUgYm9yZGVyPTAgaGVpZ2h0PTIwIHdpZHRoPTEwMCUgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgYm9yZGVyLWJvdHRvbToxcHggZG90dGVkICNlZmVmZWY7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGNvbHNwYW49Mj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmNvbG9yPScjMDAwMDAwJzsiIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuY29sb3I9JyNGRkZGRkYnOyIgc3R5bGU9InRleHQtZGVjb3JhdGlvbjpub25lOyBib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBmb250LXdlaWdodDpub3JtYWw7IGZvbnQtc2l6ZToxMnB4OyBjb2xvcjojRkVGRUZFOyAgZm9udC1mYW1pbHk6VmVyZGFuYTsiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvcmVkaXJlY3QucGhwP2NvZGU9YUhSMGNITTZMeTlpY21GMlpXNWxkMlYxY205d1pTNWpiMjB2YldGeWRHbHVMV3gxYTJGamN5MTNaWFpsTFdKbFpXNHRZMjl1Ym1Wa0xXbHVkRzh0Wm1sbmFIUnBibWN0WTJ4cGJXRjBaUzFqYUdGdVoyVXRZWE10YVc1a2FYWnBaSFZoYkhNdGQyaGxiaTFwZEhNdFkyOXljRzl5WVhSbExYQnZkMlZ5TFdSbGMzUnliM2xwYm1jdGRHaGxMWEJzWVc1bGRBPT0iPlRoZSBHcmVhdCBDbGltYXRlIENvbjwvYT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249bGVmdCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+PGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vYnJhdmVuZXdldXJvcGUuY29tIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPkJyYXZlbmV3ZS4uLjwvYT48L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249cmlnaHQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjE3LiBGZWIgMjA6MTE8L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPjx0ZCBjb2xzcGFuPTIgSEVJR0hUPTU+PC90ZD48L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90YWJsZT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0ciBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0nJzsiIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0ndXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9zY3JvbGwucG5nKSc7IiBoZWlnaHQ9IjE4Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGFibGUgYm9yZGVyPTAgaGVpZ2h0PTIwIHdpZHRoPTEwMCUgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgYm9yZGVyLWJvdHRvbToxcHggZG90dGVkICNlZmVmZWY7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGNvbHNwYW49Mj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmNvbG9yPScjMDAwMDAwJzsiIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuY29sb3I9JyNGRkZGRkYnOyIgc3R5bGU9InRleHQtZGVjb3JhdGlvbjpub25lOyBib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBmb250LXdlaWdodDpub3JtYWw7IGZvbnQtc2l6ZToxMnB4OyBjb2xvcjojRkVGRUZFOyAgZm9udC1mYW1pbHk6VmVyZGFuYTsiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvcmVkaXJlY3QucGhwP2NvZGU9YUhSMGNEb3ZMM2QzZHk1cGJXa3RiMjVzYVc1bExtUmxMekl3TVRrdk1ESXZNRGd2Wlhod1pYSnBiV1Z1ZEMxc1lXNWtaWE55WldkcGJXVnVkQzFpWVhsbGNtNHYiPkV4cGVyaW1lbnQgTGFuZGVzcmVnaW1lbnQgQmF5ZXJuPC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy5pbWktb25saW5lLmRlIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPkltaS1vbmxpbi4uLjwvYT48L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249cmlnaHQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjE3LiBGZWIgMjA6MDg8L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPjx0ZCBjb2xzcGFuPTIgSEVJR0hUPTU+PC90ZD48L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90YWJsZT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0ciBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0nJzsiIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0ndXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9zY3JvbGwucG5nKSc7IiBoZWlnaHQ9IjE4Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGFibGUgYm9yZGVyPTAgaGVpZ2h0PTIwIHdpZHRoPTEwMCUgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgYm9yZGVyLWJvdHRvbToxcHggZG90dGVkICNlZmVmZWY7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGNvbHNwYW49Mj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmNvbG9yPScjMDAwMDAwJzsiIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuY29sb3I9JyNGRkZGRkYnOyIgc3R5bGU9InRleHQtZGVjb3JhdGlvbjpub25lOyBib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBmb250LXdlaWdodDpub3JtYWw7IGZvbnQtc2l6ZToxMnB4OyBjb2xvcjojRkVGRUZFOyAgZm9udC1mYW1pbHk6VmVyZGFuYTsiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvcmVkaXJlY3QucGhwP2NvZGU9YUhSMGNITTZMeTkzZDNjdWFHVnBjMlV1WkdVdmRIQXZabVZoZEhWeVpYTXZSM0psYVdaMExXUmxjaTF5ZFcxaFpXNXBjMk5vWlMxSFpXaGxhVzFrYVdWdWMzUXRibUZqYUMxa1pYSXRSWFZ5YjNCaFpXbHpZMmhsYmkxVGRHRmhkSE5oYm5kaGJIUnpZMmhoWm5RdE5ETXhNVEV5TXk1b2RHMXMiPkdyZWlmdCBkZXIgcnVt5G5pc2NoZSBHZWhlaW1kaWVuc3QgbmFjaCBkZXIgRXVyb3DkaXNjaGVuIFN0YWF0c2Fud2FsdHNjaGFmdD8gPC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly93d3cuaGVpc2UuZGUiIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+SGVpc2UuZGU8L2E+PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPXJpZ2h0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj4xNy4gRmViIDIwOjA2PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj48dGQgY29sc3Bhbj0yIEhFSUdIVD01PjwvdGQ+PC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGFibGU+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj48dHIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9Jyc7IiBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9J3VybChodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvc2Nyb2xsLnBuZyknOyIgaGVpZ2h0PSIxOCI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRhYmxlIGJvcmRlcj0wIGhlaWdodD0yMCB3aWR0aD0xMDAlIGNlbGxTcGFjaW5nPTAgY2VsbFBhZGRpbmc9MCBzdHlsZT0icGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGJvcmRlci1ib3R0b206MXB4IGRvdHRlZCAjZWZlZmVmOyI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBjb2xzcGFuPTI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8YSBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5jb2xvcj0nIzAwMDAwMCc7IiBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmNvbG9yPScjRkZGRkZGJzsiIHN0eWxlPSJ0ZXh0LWRlY29yYXRpb246bm9uZTsgYm9yZGVyOjBweCBzb2xpZCBibGFjazsgZm9udC13ZWlnaHQ6bm9ybWFsOyBmb250LXNpemU6MTJweDsgY29sb3I6I0ZFRkVGRTsgIGZvbnQtZmFtaWx5OlZlcmRhbmE7IiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL3JlZGlyZWN0LnBocD9jb2RlPWFIUjBjRG92TDNkM2R5NTBZWG91WkdVdlMyOXRiV1Z1ZEdGeUxWTnBZMmhsY21obGFYUnphMjl1Wm1WeVpXNTZMeUUxTlRjek56UTFMdz09Ij5N/G5jaG5lciBTaWNoZXJoZWl0c2tvbmZlcmVuejogRXJu/GNodGVybmQgdW5kIGVyc2NocmVja2VuZDwvYT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249bGVmdCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+PGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cudGF6LmRlIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPlRhei5kZTwvYT48L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249cmlnaHQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjE3LiBGZWIgMjA6MDI8L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPjx0ZCBjb2xzcGFuPTIgSEVJR0hUPTU+PC90ZD48L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90YWJsZT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0ciBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0nJzsiIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0ndXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9zY3JvbGwucG5nKSc7IiBoZWlnaHQ9IjE4Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGFibGUgYm9yZGVyPTAgaGVpZ2h0PTIwIHdpZHRoPTEwMCUgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgYm9yZGVyLWJvdHRvbToxcHggZG90dGVkICNlZmVmZWY7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGNvbHNwYW49Mj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmNvbG9yPScjMDAwMDAwJzsiIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuY29sb3I9JyNGRkZGRkYnOyIgc3R5bGU9InRleHQtZGVjb3JhdGlvbjpub25lOyBib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBmb250LXdlaWdodDpub3JtYWw7IGZvbnQtc2l6ZToxMnB4OyBjb2xvcjojRkVGRUZFOyAgZm9udC1mYW1pbHk6VmVyZGFuYTsiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvcmVkaXJlY3QucGhwP2NvZGU9YUhSMGNITTZMeTkzZDNjdVlXNTBhUzF6Y0dsbFoyVnNMbkoxTHpJd01Ua3ZibVYxWlMxeWRYTnpiR0Z1WkMxellXNXJkR2x2Ym1WdUxXRnVaMlZyZFdWdVpHbG5kQzEzWVhNdGFHRmlaVzR0WkdsbExYSjFjM05zWVc1a0xYTmhibXQwYVc5dVpXNHRZbWx6YUdWeUxXVnljbVZwWTJoMEx3PT0iPk5ldWUgUnVzc2xhbmQtU2Fua3Rpb25lbiBhbmdla/xuZGlndDwvYT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249bGVmdCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+PGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vd3d3LmFudGktc3BpZWdlbC5ydSIgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsgdGV4dC1kZWNvcmF0aW9uOm5vbmU7Ij5BbnRpLXNwaWUuLi48L2E+PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPXJpZ2h0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj4xNy4gRmViIDIwOjAwPC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj48dGQgY29sc3Bhbj0yIEhFSUdIVD01PjwvdGQ+PC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGFibGU+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj48dHIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9Jyc7IiBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9J3VybChodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvc2Nyb2xsLnBuZyknOyIgaGVpZ2h0PSIxOCI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRhYmxlIGJvcmRlcj0wIGhlaWdodD0yMCB3aWR0aD0xMDAlIGNlbGxTcGFjaW5nPTAgY2VsbFBhZGRpbmc9MCBzdHlsZT0icGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGJvcmRlci1ib3R0b206MXB4IGRvdHRlZCAjZWZlZmVmOyI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBjb2xzcGFuPTI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8YSBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5jb2xvcj0nIzAwMDAwMCc7IiBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmNvbG9yPScjRkZGRkZGJzsiIHN0eWxlPSJ0ZXh0LWRlY29yYXRpb246bm9uZTsgYm9yZGVyOjBweCBzb2xpZCBibGFjazsgZm9udC13ZWlnaHQ6bm9ybWFsOyBmb250LXNpemU6MTJweDsgY29sb3I6I0ZFRkVGRTsgIGZvbnQtZmFtaWx5OlZlcmRhbmE7IiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL3JlZGlyZWN0LnBocD9jb2RlPWFIUjBjSE02THk5bmNtRnpiSFYwYzJOb1pYSXVaR1V2ZDJGeWRXMHRkR2xsY25OamFIVjBlaTFwYlMxemFXNXVaUzFrWlhJdFptUndMV0psWkdWMWRHVjBMWFJwWlhKelkyaDFaWFI2WlhJdGFXNXpMV2RsWm1GbGJtZHVhWE10ZW5VdGMzQmxjbkpsYmk4PSI+V2FydW0gVGllcnNjaHV0eiBpbSBTaW5uZSBkZXIgRkRQIGJlZGV1dGV0LCBUaWVyc2No/HR6ZXIgaW5zIEdlZuRuZ25pcyB6dSBzcGVycmVuPC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9ncmFzbHV0c2NoZXIuZGUiIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+R3Jhc2x1dHNjLi4uPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTcuIEZlYiAxOTo1Njwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0hNNkx5OTNkM2N1WkdWMWRITmphR3hoYm1SbWRXNXJhM1ZzZEhWeUxtUmxMMmRzYjJKaGJHbHphV1Z5ZEdWekxXMXBjM050WVc1aFoyVnRaVzUwTFdScFpTMXJkV3gwZFhJdFpHVnlMakV3TURVdVpHVXVhSFJ0YkQ5a2NtRnRPbUZ5ZEdsamJHVmZhV1E5TkRRd09URXgiPkRpZSBLdWx0dXIgZGVyIFZlcmFudHdvcnR1bmdzbG9zaWdrZWl0PC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly93d3cuZGV1dHNjaGxhbmRmdW5ra3VsdHVyLmRlIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPkRldXRzY2hsYS4uLjwvYT48L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249cmlnaHQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjE3LiBGZWIgMTk6NTM8L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPjx0ZCBjb2xzcGFuPTIgSEVJR0hUPTU+PC90ZD48L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90YWJsZT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0ciBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0nJzsiIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0ndXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9zY3JvbGwucG5nKSc7IiBoZWlnaHQ9IjE4Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGFibGUgYm9yZGVyPTAgaGVpZ2h0PTIwIHdpZHRoPTEwMCUgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgYm9yZGVyLWJvdHRvbToxcHggZG90dGVkICNlZmVmZWY7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGNvbHNwYW49Mj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmNvbG9yPScjMDAwMDAwJzsiIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuY29sb3I9JyNGRkZGRkYnOyIgc3R5bGU9InRleHQtZGVjb3JhdGlvbjpub25lOyBib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBmb250LXdlaWdodDpub3JtYWw7IGZvbnQtc2l6ZToxMnB4OyBjb2xvcjojRkVGRUZFOyAgZm9udC1mYW1pbHk6VmVyZGFuYTsiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvcmVkaXJlY3QucGhwP2NvZGU9YUhSMGNITTZMeTkzZDNjdVltVnliR2x1YzNSeVpXVjBMbVJsTHpFMk1Ua3kiPk1pa3JvZm9uZSBpbiBkZXIgVS1CYWhuPC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly93d3cuYmVybGluc3RyZWV0LmRlIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPkJlcmxpbnN0ci4uLjwvYT48L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249cmlnaHQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjE3LiBGZWIgMTk6NTA8L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPjx0ZCBjb2xzcGFuPTIgSEVJR0hUPTU+PC90ZD48L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90YWJsZT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0ciBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0nJzsiIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0ndXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9zY3JvbGwucG5nKSc7IiBoZWlnaHQ9IjE4Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGFibGUgYm9yZGVyPTAgaGVpZ2h0PTIwIHdpZHRoPTEwMCUgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgYm9yZGVyLWJvdHRvbToxcHggZG90dGVkICNlZmVmZWY7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGNvbHNwYW49Mj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmNvbG9yPScjMDAwMDAwJzsiIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuY29sb3I9JyNGRkZGRkYnOyIgc3R5bGU9InRleHQtZGVjb3JhdGlvbjpub25lOyBib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBmb250LXdlaWdodDpub3JtYWw7IGZvbnQtc2l6ZToxMnB4OyBjb2xvcjojRkVGRUZFOyAgZm9udC1mYW1pbHk6VmVyZGFuYTsiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvcmVkaXJlY3QucGhwP2NvZGU9YUhSMGNEb3ZMM2QzZHk1emNHbGxaMlZzTG1SbEwzQmhibTl5WVcxaEwycDFjM1JwZWk5eVpXTm9kSE5sZUhSeVpXMWxjaTFyWVcxd1puTndiM0owYkdWeUxXUmxjaTF1Wlc5dVlYcHBMV3R5YVdWblpYSXRZWFZ6TFcxdmMydGhkUzFoTFRFeU5UTXhOak11YUhSdGJBPT0iPlJlY2h0c2V4dHJlbWVyIEthbXBmc3BvcnRsZXI6IERlciBOZW9uYXppLUtyaWVnZXIgPC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy5zcGllZ2VsLmRlIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPlNwaWVnZWwuZC4uLjwvYT48L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249cmlnaHQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjE3LiBGZWIgMTk6NDg8L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPjx0ZCBjb2xzcGFuPTIgSEVJR0hUPTU+PC90ZD48L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90YWJsZT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0ciBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0nJzsiIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0ndXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9zY3JvbGwucG5nKSc7IiBoZWlnaHQ9IjE4Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGFibGUgYm9yZGVyPTAgaGVpZ2h0PTIwIHdpZHRoPTEwMCUgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgYm9yZGVyLWJvdHRvbToxcHggZG90dGVkICNlZmVmZWY7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGNvbHNwYW49Mj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmNvbG9yPScjMDAwMDAwJzsiIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuY29sb3I9JyNGRkZGRkYnOyIgc3R5bGU9InRleHQtZGVjb3JhdGlvbjpub25lOyBib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBmb250LXdlaWdodDpub3JtYWw7IGZvbnQtc2l6ZToxMnB4OyBjb2xvcjojRkVGRUZFOyAgZm9udC1mYW1pbHk6VmVyZGFuYTsiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvcmVkaXJlY3QucGhwP2NvZGU9YUhSMGNITTZMeTkyWlhKaExXeGxibWR6Wm1Wc1pDNWtaUzh5TURFNUx6QXlMekUxTDJWcGJpMXJiR2x0WVhOMVpXNWtaWEl0ZG1WeWRHVnBaR2xuZEMxemFXTm9MV2RsWjJWdUxXZHlkV1Z1YzJOb2JtRmxZbVZzTHc9PSI+RWluID9LbGltYXP8bmRlcj8gdmVydGVpZGlndCBzaWNoIGdlZ2VuIEdy/G5zY2hu5GJlbDwvYT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249bGVmdCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+PGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vdmVyYS1sZW5nc2ZlbGQuZGUiIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+VmVyYS1sZW5nLi4uPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTcuIEZlYiAxOTo0Njwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0RvdkwzZDNkeTVzZFdaMGNHOXpkQzFyYkM1a1pTOXNkV1owY0c5emRDMWhjbU5vYVhZdlRGQmZNVGt2VEZBd01UZ3hPVjh4TVRBeU1Ua3VjR1JtIj5EYXMgTWVtb3JhbmR1bSwgZGFzIGVpbmUgaGFsYmUgTWlsbGlvbiBNZW5zY2hlbiBpbiBTeXJpZW4gZGFzIExlYmVuIGtvc3RldGUhPC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy5sdWZ0cG9zdC1rbC5kZSIgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsgdGV4dC1kZWNvcmF0aW9uOm5vbmU7Ij5MdWZ0cG9zdC0uLi48L2E+PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPXJpZ2h0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj4xNy4gRmViIDE4OjQ5PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj48dGQgY29sc3Bhbj0yIEhFSUdIVD01PjwvdGQ+PC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGFibGU+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj48dHIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9Jyc7IiBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9J3VybChodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvc2Nyb2xsLnBuZyknOyIgaGVpZ2h0PSIxOCI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRhYmxlIGJvcmRlcj0wIGhlaWdodD0yMCB3aWR0aD0xMDAlIGNlbGxTcGFjaW5nPTAgY2VsbFBhZGRpbmc9MCBzdHlsZT0icGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGJvcmRlci1ib3R0b206MXB4IGRvdHRlZCAjZWZlZmVmOyI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBjb2xzcGFuPTI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8YSBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5jb2xvcj0nIzAwMDAwMCc7IiBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmNvbG9yPScjRkZGRkZGJzsiIHN0eWxlPSJ0ZXh0LWRlY29yYXRpb246bm9uZTsgYm9yZGVyOjBweCBzb2xpZCBibGFjazsgZm9udC13ZWlnaHQ6bm9ybWFsOyBmb250LXNpemU6MTJweDsgY29sb3I6I0ZFRkVGRTsgIGZvbnQtZmFtaWx5OlZlcmRhbmE7IiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL3JlZGlyZWN0LnBocD9jb2RlPWFIUjBjSE02THk5aGJXVnlhV3RoTWpFdVpHVXZNakF4T1M4d01pOHlNakkwTVRVdmRtVnVaWHAxWld4aExYVnpMVzFwYkdsMFlXVnkiPlVTQSBzZXR6ZW4gVmVuZXp1ZWxhIG1pdCBQb3NpdGlvbmllcnVuZyBkZXMgTWlsaXTkcnMgenVuZWhtZW5kIHVudGVyIERydWNrPC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9hbWVyaWthMjEuZGUiIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+QW1lcmlrYTIxLi4uPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTcuIEZlYiAxODo0Mzwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0hNNkx5OTNkM2N1YUdWcGMyVXVaR1V2ZEhBdlptVmhkSFZ5WlhNdlIyVnNZbmRsYzNSbGJpMUxjbVZwYzJWc0xXOW9ibVV0UVhWeloyRnVaeTAwTXpFeE1UYzNMbWgwYld3PSI+R2VsYndlc3RlbjogS3JlaXNlbCBvaG5lIEF1c2dhbmc/IDwvYT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249bGVmdCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+PGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vd3d3LmhlaXNlLmRlIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPkhlaXNlLmRlPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTcuIEZlYiAxODo0MTwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0hNNkx5OWtaWFYwYzJOb0xuSjBMbU52YlM5bGRYSnZjR0V2T0RRME1ERXRhV05vTFdWeWEyVnVibVV0YldWcGJpMXNZVzVrTFc1cFkyaDBMdz09Ij5JY2ggZXJrZW5uZSBtZWluIExhbmQgbmljaHQgbWVocjogR2VsYndlc3RlbiBmb3JkZXJuIEdlcmVjaHRpZ2tlaXQ8L2E+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPWxlZnQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2RldXRzY2gucnQuY29tIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPkRldXRzY2guci4uLjwvYT48L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249cmlnaHQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjE3LiBGZWIgMTg6Mzk8L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPjx0ZCBjb2xzcGFuPTIgSEVJR0hUPTU+PC90ZD48L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90YWJsZT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0ciBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0nJzsiIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0ndXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9zY3JvbGwucG5nKSc7IiBoZWlnaHQ9IjE4Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGFibGUgYm9yZGVyPTAgaGVpZ2h0PTIwIHdpZHRoPTEwMCUgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgYm9yZGVyLWJvdHRvbToxcHggZG90dGVkICNlZmVmZWY7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGNvbHNwYW49Mj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmNvbG9yPScjMDAwMDAwJzsiIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuY29sb3I9JyNGRkZGRkYnOyIgc3R5bGU9InRleHQtZGVjb3JhdGlvbjpub25lOyBib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBmb250LXdlaWdodDpub3JtYWw7IGZvbnQtc2l6ZToxMnB4OyBjb2xvcjojRkVGRUZFOyAgZm9udC1mYW1pbHk6VmVyZGFuYTsiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvcmVkaXJlY3QucGhwP2NvZGU9YUhSMGNITTZMeTl1Y0hJdWJtVjNjeTVsZFd4MUxtbHVabTh2TWpBeE9TOHdNaTh4TlM5dlpXeHJjbWx6WlMweE9UY3pMV2x0TFdocGJuUmxjbnBwYlcxbGNpMWtaWEl0YldGamFIUXYiPtZsa3Jpc2UgMTk3MyA/IEltIEhpbnRlcnppbW1lciBkZXIgTWFjaHQ8L2E+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPWxlZnQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL25wci5uZXdzLmV1bHUuaW5mbyIgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsgdGV4dC1kZWNvcmF0aW9uOm5vbmU7Ij5OcHIubmV3cy4uLi48L2E+PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPXJpZ2h0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj4xNy4gRmViIDE4OjM3PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj48dGQgY29sc3Bhbj0yIEhFSUdIVD01PjwvdGQ+PC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGFibGU+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj48dHIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9Jyc7IiBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9J3VybChodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvc2Nyb2xsLnBuZyknOyIgaGVpZ2h0PSIxOCI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRhYmxlIGJvcmRlcj0wIGhlaWdodD0yMCB3aWR0aD0xMDAlIGNlbGxTcGFjaW5nPTAgY2VsbFBhZGRpbmc9MCBzdHlsZT0icGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGJvcmRlci1ib3R0b206MXB4IGRvdHRlZCAjZWZlZmVmOyI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBjb2xzcGFuPTI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8YSBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5jb2xvcj0nIzAwMDAwMCc7IiBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmNvbG9yPScjRkZGRkZGJzsiIHN0eWxlPSJ0ZXh0LWRlY29yYXRpb246bm9uZTsgYm9yZGVyOjBweCBzb2xpZCBibGFjazsgZm9udC13ZWlnaHQ6bm9ybWFsOyBmb250LXNpemU6MTJweDsgY29sb3I6I0ZFRkVGRTsgIGZvbnQtZmFtaWx5OlZlcmRhbmE7IiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL3JlZGlyZWN0LnBocD9jb2RlPWFIUjBjSE02THk5M2QzY3VabkpsYVhSaFp5NWtaUzloZFhSdmNtVnVMMlZzYVhOaGJtOTNZV3N2YTNWeVpHVnVMV0ZzY3kxemRHRmhkSE5tWldsdVpHVT0iPkt1cmRlbiBhbHMgU3RhYXRzZmVpbmRlIDwvYT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249bGVmdCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+PGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vd3d3LmZyZWl0YWcuZGUiIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+RnJlaXRhZy5kLi4uPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTcuIEZlYiAxODozNDwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0RvdkwydHdhM0poZFhObExtUmxMekl3TVRrdk1ESXZNVFV2WkdWMWRITmphR3hoYm1SekxXVnVaWEpuYVdWM1pXNWtaUzEwY21GMWJTMXBjM1F0WldsdVpTMTFkRzl3YVdVdiI+RGV1dHNjaGxhbmRzIEVuZXJnaWV3ZW5kZS1UcmF1bSBpc3QgZWluZSBVdG9waWU8L2E+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPWxlZnQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8va3BrcmF1c2UuZGUiIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+S3BrcmF1c2UuLi4uPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTcuIEZlYiAxODozMTwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0hNNkx5OXNiM04wYVc1bGRTNWxkUzloZFhOelpYSXRjbTloYldsdVp5MXVhV05vZEhNdFoyVjNaWE5sYmk4PSI+QXXfZXIgUm9hbWluZyBuaWNodHMgZ2V3ZXNlbjwvYT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249bGVmdCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+PGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vbG9zdGluZXUuZXUiIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+TG9zdGluZXUuLi4uPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTcuIEZlYiAxODoyNjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0hNNkx5OTNkM2N1WkdWMWRITmphR3hoYm1SbWRXNXJMbVJsTDJGaWMyTm9hV1ZpZFc1bmMyUmxZbUYwZEdVdGIzSmtiblZ1WnkxaGRXWXRhMjl6ZEdWdUxXUmxjaTFvZFcxaGJtbDBZV1YwTGpjeU1DNWtaUzVvZEcxc1AyUnlZVzA2WVhKMGFXTnNaVjlwWkQwME5ERXlORFU9Ij5BYnNjaGllYnVuZ3NkZWJhdHRlOiBPcmRudW5nIGF1ZiBLb3N0ZW4gZGVyIEh1bWFuaXTkdDwvYT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249bGVmdCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+PGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vd3d3LmRldXRzY2hsYW5kZnVuay5kZSIgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsgdGV4dC1kZWNvcmF0aW9uOm5vbmU7Ij5EZXV0c2NobGEuLi48L2E+PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPXJpZ2h0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj4xNy4gRmViIDE4OjI0PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj48dGQgY29sc3Bhbj0yIEhFSUdIVD01PjwvdGQ+PC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGFibGU+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj48dHIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9Jyc7IiBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9J3VybChodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvc2Nyb2xsLnBuZyknOyIgaGVpZ2h0PSIxOCI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRhYmxlIGJvcmRlcj0wIGhlaWdodD0yMCB3aWR0aD0xMDAlIGNlbGxTcGFjaW5nPTAgY2VsbFBhZGRpbmc9MCBzdHlsZT0icGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGJvcmRlci1ib3R0b206MXB4IGRvdHRlZCAjZWZlZmVmOyI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBjb2xzcGFuPTI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8YSBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5jb2xvcj0nIzAwMDAwMCc7IiBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmNvbG9yPScjRkZGRkZGJzsiIHN0eWxlPSJ0ZXh0LWRlY29yYXRpb246bm9uZTsgYm9yZGVyOjBweCBzb2xpZCBibGFjazsgZm9udC13ZWlnaHQ6bm9ybWFsOyBmb250LXNpemU6MTJweDsgY29sb3I6I0ZFRkVGRTsgIGZvbnQtZmFtaWx5OlZlcmRhbmE7IiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL3JlZGlyZWN0LnBocD9jb2RlPWFIUjBjSE02THk5M2QzY3VhVzVtYjNOd1pYSmlaWEl1WTJndlFYSjBhV3RsYkM5UWIyeHBkR2xyTDFWdVoyRnlhVzV1Wlc0dFIyVmlZWEp3Y21GdGFXVXRkVzVrTFZwMWMzUjFjR1l0Wm5WeWN5MUhjbTl6YzNKaGRXMWhkWFJ2Ij5VbmdhcmlubmVuOiBHZWLkcnBy5G1pZSB1bmQgWnVzY2h1c3MgZvxycyBHcm9zc3JhdW1hdXRvPC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly93d3cuaW5mb3NwZXJiZXIuY2giIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+SW5mb3NwZXJiLi4uPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTcuIEZlYiAxODoyMDwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0hNNkx5OTNkM2N1YzNWbFpHUmxkWFJ6WTJobExtUmxMMnQxYkhSMWNpOXFiMkZ1TFdKaFpYb3RaSGxzWVc0dFptOXNheTB4TGpRek16TTJOek09Ij5H9nR0aW5uZW5kaWVuc3Q6IEpvYW4gQmFleiBpbiBN/G5jaGVuIDwvYT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249bGVmdCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+PGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vd3d3LnN1ZWRkZXV0c2NoZS5kZSIgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsgdGV4dC1kZWNvcmF0aW9uOm5vbmU7Ij5TdWVkZGV1dHMuLi48L2E+PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPXJpZ2h0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj4xNy4gRmViIDE4OjE4PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj48dGQgY29sc3Bhbj0yIEhFSUdIVD01PjwvdGQ+PC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGFibGU+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj48dHIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9Jyc7IiBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9J3VybChodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvc2Nyb2xsLnBuZyknOyIgaGVpZ2h0PSIxOCI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRhYmxlIGJvcmRlcj0wIGhlaWdodD0yMCB3aWR0aD0xMDAlIGNlbGxTcGFjaW5nPTAgY2VsbFBhZGRpbmc9MCBzdHlsZT0icGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGJvcmRlci1ib3R0b206MXB4IGRvdHRlZCAjZWZlZmVmOyI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBjb2xzcGFuPTI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8YSBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5jb2xvcj0nIzAwMDAwMCc7IiBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmNvbG9yPScjRkZGRkZGJzsiIHN0eWxlPSJ0ZXh0LWRlY29yYXRpb246bm9uZTsgYm9yZGVyOjBweCBzb2xpZCBibGFjazsgZm9udC13ZWlnaHQ6bm9ybWFsOyBmb250LXNpemU6MTJweDsgY29sb3I6I0ZFRkVGRTsgIGZvbnQtZmFtaWx5OlZlcmRhbmE7IiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL3JlZGlyZWN0LnBocD9jb2RlPWFIUjBjSE02THk5M2QzY3VabUY2TG01bGRDOWhhM1IxWld4c0wyWmxkV2xzYkdWMGIyNHZhMmx1Ynk5a1pXMHRjbVZuYVhOelpYVnlMV0ZzWldwaGJtUnlieTFxYjJSdmNtOTNjMnQ1TFhwMWJTMXVaWFZ1ZW1sbmMzUmxiaTB4TmpBME5EYzBNUzVvZEcxc1AzQnlhVzUwVUdGblpXUkJjblJwWTJ4bFBYUnlkV1VqY0dGblpVbHVaR1Y0WHpBPSI+QWxlamFuZHJvIEpvZG9yb3dza3kgenVtIDkwLjogTnVyIGL2c2UgTWVuc2NoZW4gc2VoZW4gaWhuPC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly93d3cuZmF6Lm5ldCIgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsgdGV4dC1kZWNvcmF0aW9uOm5vbmU7Ij5GYXoubmV0PC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTcuIEZlYiAxODoxNjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0hNNkx5OTNkM2N1ZW1WcGRDNWtaUzh5TURFNUx6QTRMMloxYzNOaVlXeHNMV1p2Y25SdWFYUmxMWFJ2Y21wMVltVnNMWE5sY21kcGJ5MXlZVzF2Y3kxaGJuUnZhVzVsTFdkeWFXVjZiV0Z1Ymc9PSI+RnXfYmFsbCB1bmQgRm9ydG5pdGU6IEZyZXVkZSBhdXMgZGVyIEtvbnNvbGU8L2E+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPWxlZnQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL3d3dy56ZWl0LmRlIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPlplaXQuZGU8L2E+PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPXJpZ2h0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj4xNy4gRmViIDE4OjE0PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj48dGQgY29sc3Bhbj0yIEhFSUdIVD01PjwvdGQ+PC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGFibGU+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj48dHIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9Jyc7IiBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9J3VybChodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvc2Nyb2xsLnBuZyknOyIgaGVpZ2h0PSIxOCI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRhYmxlIGJvcmRlcj0wIGhlaWdodD0yMCB3aWR0aD0xMDAlIGNlbGxTcGFjaW5nPTAgY2VsbFBhZGRpbmc9MCBzdHlsZT0icGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGJvcmRlci1ib3R0b206MXB4IGRvdHRlZCAjZWZlZmVmOyI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBjb2xzcGFuPTI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8YSBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5jb2xvcj0nIzAwMDAwMCc7IiBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmNvbG9yPScjRkZGRkZGJzsiIHN0eWxlPSJ0ZXh0LWRlY29yYXRpb246bm9uZTsgYm9yZGVyOjBweCBzb2xpZCBibGFjazsgZm9udC13ZWlnaHQ6bm9ybWFsOyBmb250LXNpemU6MTJweDsgY29sb3I6I0ZFRkVGRTsgIGZvbnQtZmFtaWx5OlZlcmRhbmE7IiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL3JlZGlyZWN0LnBocD9jb2RlPWFIUjBjSE02THk5eGNISmxjM011WkdVdk1qQXhPUzh3TWk4eE55OWtaWFYwYzJOb1pTMWhkWFJ2Y3kxblpXWmhhSEl0Wm5WbGNpMW5iRzlpWVd4bExYTnBZMmhsY21obGFYUXYiPkRldXRzY2hlIEF1dG9zIEdlZmFociBm/HIgZ2xvYmFsZSBTaWNoZXJoZWl0PC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9xcHJlc3MuZGUiIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+UXByZXNzLmRlPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTcuIEZlYiAxNjo1ODwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0hNNkx5OTNkM2N1ZG05c2RHRnBjbVZ1WlhRdWIzSm5MMkZ5ZEdsamJHVXlNRFV4T0RFdWFIUnRiQT09Ij5Va3JhaW5lOiBOQVRPIGluIGRlciBWZXJmYXNzdW5nPC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly93d3cudm9sdGFpcmVuZXQub3JnIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPlZvbHRhaXJlbi4uLjwvYT48L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249cmlnaHQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjE3LiBGZWIgMTY6NTY8L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPjx0ZCBjb2xzcGFuPTIgSEVJR0hUPTU+PC90ZD48L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90YWJsZT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0ciBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0nJzsiIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0ndXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9zY3JvbGwucG5nKSc7IiBoZWlnaHQ9IjE4Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGFibGUgYm9yZGVyPTAgaGVpZ2h0PTIwIHdpZHRoPTEwMCUgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgYm9yZGVyLWJvdHRvbToxcHggZG90dGVkICNlZmVmZWY7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGNvbHNwYW49Mj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmNvbG9yPScjMDAwMDAwJzsiIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuY29sb3I9JyNGRkZGRkYnOyIgc3R5bGU9InRleHQtZGVjb3JhdGlvbjpub25lOyBib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBmb250LXdlaWdodDpub3JtYWw7IGZvbnQtc2l6ZToxMnB4OyBjb2xvcjojRkVGRUZFOyAgZm9udC1mYW1pbHk6VmVyZGFuYTsiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvcmVkaXJlY3QucGhwP2NvZGU9YUhSMGNEb3ZMM2QzZHk1emNHRjBlbk5sYVhSbExtTnZiUzh5TURFNUx6QXlMMmRsYkdRdFlXeHNaV2x1TFhSMWRITXRibWxqYUhRdiI+ID9HZWxkIGFsbGVpbiB0dXQ/cyBuaWNodD88L2E+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPWxlZnQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3LnNwYXR6c2VpdGUuY29tIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPlNwYXR6c2VpdC4uLjwvYT48L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249cmlnaHQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjE3LiBGZWIgMTY6NTE8L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPjx0ZCBjb2xzcGFuPTIgSEVJR0hUPTU+PC90ZD48L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90YWJsZT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0ciBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0nJzsiIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0ndXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9zY3JvbGwucG5nKSc7IiBoZWlnaHQ9IjE4Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGFibGUgYm9yZGVyPTAgaGVpZ2h0PTIwIHdpZHRoPTEwMCUgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgYm9yZGVyLWJvdHRvbToxcHggZG90dGVkICNlZmVmZWY7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGNvbHNwYW49Mj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmNvbG9yPScjMDAwMDAwJzsiIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuY29sb3I9JyNGRkZGRkYnOyIgc3R5bGU9InRleHQtZGVjb3JhdGlvbjpub25lOyBib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBmb250LXdlaWdodDpub3JtYWw7IGZvbnQtc2l6ZToxMnB4OyBjb2xvcjojRkVGRUZFOyAgZm9udC1mYW1pbHk6VmVyZGFuYTsiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvcmVkaXJlY3QucGhwP2NvZGU9YUhSMGNITTZMeTl1WlhSNmNHOXNhWFJwYXk1dmNtY3ZNakF4T1M5M2FYSXRkbVZ5YjJWbVptVnVkR3hwWTJobGJpMWtZWE10Wm5KaGJXbHVaeTFuZFhSaFkyaDBaVzR0WkdWeUxXRnlaQzg9Ij5XaXIgdmVy9mZmZW50bGljaGVuIGRhcyBGcmFtaW5nLUd1dGFjaHRlbiBkZXIgQVJEPC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9uZXR6cG9saXRpay5vcmciIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+TmV0enBvbGl0Li4uPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTcuIEZlYiAxNjo1MDwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0hNNkx5OWhiR1Y0WVc1a2NtRmlZV1JsY2k1M2IzSmtjSEpsYzNNdVkyOXRMekl3TVRrdk1ESXZNVGN2WkdsbExYTjBZV0YwYzJGdWQyRnNkSE5qYUdGbWRDMTFibVF0WkdsbExXVjFjbTltYVdkb2RHVnlMdz09Ij5EaWUgU3RhYXRzYW53YWx0c2NoYWZ0IHVuZCBkaWUgRXVyb2ZpZ2h0ZXI8L2E+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPWxlZnQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2FsZXhhbmRyYWJhZGVyLndvcmRwcmVzcy5jb20iIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+QWxleGFuZHJhLi4uPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTcuIEZlYiAxNjo0Nzwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0hNNkx5OTNkM2N1ZG05c2RHRnBjbVZ1WlhRdWIzSm5MMkZ5ZEdsamJHVXlNRFV5TWpRdWFIUnRiQT09Ij5SdXNzbGFuZCB3aXJkIFVTLUJhc2VuIGluIFJ1beRuaWVuIG5pY2h0IGFuZ3JlaWZlbjwvYT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249bGVmdCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+PGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vd3d3LnZvbHRhaXJlbmV0Lm9yZyIgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsgdGV4dC1kZWNvcmF0aW9uOm5vbmU7Ij5Wb2x0YWlyZW4uLi48L2E+PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPXJpZ2h0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj4xNy4gRmViIDE2OjQ0PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj48dGQgY29sc3Bhbj0yIEhFSUdIVD01PjwvdGQ+PC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGFibGU+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj48dHIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9Jyc7IiBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9J3VybChodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvc2Nyb2xsLnBuZyknOyIgaGVpZ2h0PSIxOCI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRhYmxlIGJvcmRlcj0wIGhlaWdodD0yMCB3aWR0aD0xMDAlIGNlbGxTcGFjaW5nPTAgY2VsbFBhZGRpbmc9MCBzdHlsZT0icGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGJvcmRlci1ib3R0b206MXB4IGRvdHRlZCAjZWZlZmVmOyI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBjb2xzcGFuPTI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8YSBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5jb2xvcj0nIzAwMDAwMCc7IiBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmNvbG9yPScjRkZGRkZGJzsiIHN0eWxlPSJ0ZXh0LWRlY29yYXRpb246bm9uZTsgYm9yZGVyOjBweCBzb2xpZCBibGFjazsgZm9udC13ZWlnaHQ6bm9ybWFsOyBmb250LXNpemU6MTJweDsgY29sb3I6I0ZFRkVGRTsgIGZvbnQtZmFtaWx5OlZlcmRhbmE7IiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL3JlZGlyZWN0LnBocD9jb2RlPWFIUjBjSE02THk5aGRXZGxibWRsY21Ga1pXRjFjeTV1WlhRdk1qQXhPUzh3TWk5a2IydDFiV1Z1ZEdGMGFXOXVMWEJsYm1ObExYSmxaR1V0WVhWbUxXUmxjaTF0ZFdWdVkyaHVaWEl0YzJsamFHVnlhR1ZwZEhOcmIyNW1aWEpsYm5vdiI+RG9rdW1lbnRhdGlvbjogUGVuY2UtUmVkZSBhdWYgZGVyIE38bmNobmVyIFNpY2hlcmhlaXRza29uZmVyZW56PC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9hdWdlbmdlcmFkZWF1cy5uZXQiIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+QXVnZW5nZXJhLi4uPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTcuIEZlYiAxNjo0Mjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0hNNkx5OXdaV1J6TFdGdWMybGphSFJsYmk1a1pTOHlNREU1THpBeUwyMTFaVzVqYUc1bGNpMXphV05vWlhKb1pXbDBjMnR2Ym1abGNtVnVlaTB5TURFNUx3PT0iPk38bmNobmVyIFNpY2hlcmhlaXRza29uZmVyZW56IDIwMTk8L2E+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPWxlZnQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL3BlZHMtYW5zaWNodGVuLmRlIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPlBlZHMtYW5zaS4uLjwvYT48L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249cmlnaHQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjE3LiBGZWIgMTY6NDA8L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPjx0ZCBjb2xzcGFuPTIgSEVJR0hUPTU+PC90ZD48L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90YWJsZT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0ciBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0nJzsiIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0ndXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9zY3JvbGwucG5nKSc7IiBoZWlnaHQ9IjE4Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGFibGUgYm9yZGVyPTAgaGVpZ2h0PTIwIHdpZHRoPTEwMCUgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgYm9yZGVyLWJvdHRvbToxcHggZG90dGVkICNlZmVmZWY7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGNvbHNwYW49Mj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmNvbG9yPScjMDAwMDAwJzsiIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuY29sb3I9JyNGRkZGRkYnOyIgc3R5bGU9InRleHQtZGVjb3JhdGlvbjpub25lOyBib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBmb250LXdlaWdodDpub3JtYWw7IGZvbnQtc2l6ZToxMnB4OyBjb2xvcjojRkVGRUZFOyAgZm9udC1mYW1pbHk6VmVyZGFuYTsiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvcmVkaXJlY3QucGhwP2NvZGU9YUhSMGNITTZMeTkzZDNjdWFuVnVaMlYzWld4MExtUmxMMkZ5ZEdsclpXd3ZNelE1TWpnNExtRjFabklsUXpNbFFrTnpkSFZ1WnkxMWJtUXRhM0pwWldjdGJtbGphSFF0WldsdWMyRjBlbUpsY21WcGRDNW9kRzFzIj5BdWZy/HN0dW5nIHVuZCBLcmllZzogTmljaHQgZWluc2F0emJlcmVpdDwvYT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249bGVmdCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+PGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vd3d3Lmp1bmdld2VsdC5kZSIgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsgdGV4dC1kZWNvcmF0aW9uOm5vbmU7Ij5KdW5nZXdlbHQuLi48L2E+PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPXJpZ2h0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj4xNy4gRmViIDE2OjM5PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj48dGQgY29sc3Bhbj0yIEhFSUdIVD01PjwvdGQ+PC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGFibGU+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj48dHIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9Jyc7IiBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9J3VybChodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvc2Nyb2xsLnBuZyknOyIgaGVpZ2h0PSIxOCI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRhYmxlIGJvcmRlcj0wIGhlaWdodD0yMCB3aWR0aD0xMDAlIGNlbGxTcGFjaW5nPTAgY2VsbFBhZGRpbmc9MCBzdHlsZT0icGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGJvcmRlci1ib3R0b206MXB4IGRvdHRlZCAjZWZlZmVmOyI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBjb2xzcGFuPTI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8YSBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5jb2xvcj0nIzAwMDAwMCc7IiBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmNvbG9yPScjRkZGRkZGJzsiIHN0eWxlPSJ0ZXh0LWRlY29yYXRpb246bm9uZTsgYm9yZGVyOjBweCBzb2xpZCBibGFjazsgZm9udC13ZWlnaHQ6bm9ybWFsOyBmb250LXNpemU6MTJweDsgY29sb3I6I0ZFRkVGRTsgIGZvbnQtZmFtaWx5OlZlcmRhbmE7IiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL3JlZGlyZWN0LnBocD9jb2RlPWFIUjBjSE02THk5M2QzY3VkVzV6WlhKbExYcGxhWFF1WkdVdlpHVXZOVEV3Tnk5cGJuUmxjbTVoZEdsdmJtRnNaVjl3YjJ4cGRHbHJMekV3TkRrMEwwaHBiR1psTFhOMFlYUjBMVk5vYjNjdWFIUnQiPkhpbGZlIHN0YXR0IFNob3c8L2E+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPWxlZnQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL3d3dy51bnNlcmUtemVpdC5kZSIgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsgdGV4dC1kZWNvcmF0aW9uOm5vbmU7Ij5VbnNlcmUtemUuLi48L2E+PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPXJpZ2h0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj4xNy4gRmViIDE2OjM2PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj48dGQgY29sc3Bhbj0yIEhFSUdIVD01PjwvdGQ+PC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGFibGU+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj48dHIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9Jyc7IiBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9J3VybChodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvc2Nyb2xsLnBuZyknOyIgaGVpZ2h0PSIxOCI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRhYmxlIGJvcmRlcj0wIGhlaWdodD0yMCB3aWR0aD0xMDAlIGNlbGxTcGFjaW5nPTAgY2VsbFBhZGRpbmc9MCBzdHlsZT0icGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGJvcmRlci1ib3R0b206MXB4IGRvdHRlZCAjZWZlZmVmOyI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBjb2xzcGFuPTI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8YSBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5jb2xvcj0nIzAwMDAwMCc7IiBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmNvbG9yPScjRkZGRkZGJzsiIHN0eWxlPSJ0ZXh0LWRlY29yYXRpb246bm9uZTsgYm9yZGVyOjBweCBzb2xpZCBibGFjazsgZm9udC13ZWlnaHQ6bm9ybWFsOyBmb250LXNpemU6MTJweDsgY29sb3I6I0ZFRkVGRTsgIGZvbnQtZmFtaWx5OlZlcmRhbmE7IiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL3JlZGlyZWN0LnBocD9jb2RlPWFIUjBjSE02THk5M2QzY3VlbVZwZEM1a1pTOXJkV3gwZFhJdmJYVnphV3N2TWpBeE9TMHdNaTloZFhNdFpHVnRMV1JoWTJoelltRjFMV1JwY21zdGJHOTNkSHB2ZHkxMGIyTnZkSEp2Ym1sakwydHZiWEJzWlhSMFlXNXphV05vZEE9PSI+RWluIHNhY2h0ZXIgR3JlaWY8L2E+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPWxlZnQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL3d3dy56ZWl0LmRlIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPlplaXQuZGU8L2E+PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPXJpZ2h0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj4xNy4gRmViIDE2OjM1PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj48dGQgY29sc3Bhbj0yIEhFSUdIVD01PjwvdGQ+PC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGFibGU+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj48dHIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9Jyc7IiBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9J3VybChodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvc2Nyb2xsLnBuZyknOyIgaGVpZ2h0PSIxOCI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRhYmxlIGJvcmRlcj0wIGhlaWdodD0yMCB3aWR0aD0xMDAlIGNlbGxTcGFjaW5nPTAgY2VsbFBhZGRpbmc9MCBzdHlsZT0icGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGJvcmRlci1ib3R0b206MXB4IGRvdHRlZCAjZWZlZmVmOyI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBjb2xzcGFuPTI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8YSBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5jb2xvcj0nIzAwMDAwMCc7IiBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmNvbG9yPScjRkZGRkZGJzsiIHN0eWxlPSJ0ZXh0LWRlY29yYXRpb246bm9uZTsgYm9yZGVyOjBweCBzb2xpZCBibGFjazsgZm9udC13ZWlnaHQ6bm9ybWFsOyBmb250LXNpemU6MTJweDsgY29sb3I6I0ZFRkVGRTsgIGZvbnQtZmFtaWx5OlZlcmRhbmE7IiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL3JlZGlyZWN0LnBocD9jb2RlPWFIUjBjSE02THk5M2QzY3VabkpsYVhSaFp5NWtaUzloZFhSdmNtVnVMMlJsY2kxbWNtVnBkR0ZuTDJ0dmJuUnliMnhzZG1WeWJIVnpkQzEzWVdkbGJnPT0iPktvbnRyb2xsdmVybHVzdCB3YWdlbiA8L2E+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPWxlZnQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL3d3dy5mcmVpdGFnLmRlIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPkZyZWl0YWcuZC4uLjwvYT48L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249cmlnaHQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjE3LiBGZWIgMTY6MzM8L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPjx0ZCBjb2xzcGFuPTIgSEVJR0hUPTU+PC90ZD48L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90YWJsZT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0ciBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0nJzsiIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0ndXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9zY3JvbGwucG5nKSc7IiBoZWlnaHQ9IjE4Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGFibGUgYm9yZGVyPTAgaGVpZ2h0PTIwIHdpZHRoPTEwMCUgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgYm9yZGVyLWJvdHRvbToxcHggZG90dGVkICNlZmVmZWY7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGNvbHNwYW49Mj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmNvbG9yPScjMDAwMDAwJzsiIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuY29sb3I9JyNGRkZGRkYnOyIgc3R5bGU9InRleHQtZGVjb3JhdGlvbjpub25lOyBib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBmb250LXdlaWdodDpub3JtYWw7IGZvbnQtc2l6ZToxMnB4OyBjb2xvcjojRkVGRUZFOyAgZm9udC1mYW1pbHk6VmVyZGFuYTsiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvcmVkaXJlY3QucGhwP2NvZGU9YUhSMGNITTZMeTkzZDNjdVpHVjFkSE5qYUd4aGJtUm1kVzVyTG1SbEwzTmxjbWxsTFdWdVpITndhV1ZzTFhWdGN5MXJiR2x0WVMwM0xYTndiM0owYzNSaFpYUjBaVzR0Wm5WbGNpMWthV1V0ZW5WcmRXNW1kQzR4TXpRMkxtUmxMbWgwYld3L1pISmhiVHBoY25ScFkyeGxYMmxrUFRRME1EYzRPQT09Ij5TcG9ydHN05HR0ZW4gZvxyIGRpZSBadWt1bmZ0IDwvYT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249bGVmdCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+PGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vd3d3LmRldXRzY2hsYW5kZnVuay5kZSIgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsgdGV4dC1kZWNvcmF0aW9uOm5vbmU7Ij5EZXV0c2NobGEuLi48L2E+PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPXJpZ2h0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj4xNy4gRmViIDE2OjMwPC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj48dGQgY29sc3Bhbj0yIEhFSUdIVD01PjwvdGQ+PC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGFibGU+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj48dHIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9Jyc7IiBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9J3VybChodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvc2Nyb2xsLnBuZyknOyIgaGVpZ2h0PSIxOCI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRhYmxlIGJvcmRlcj0wIGhlaWdodD0yMCB3aWR0aD0xMDAlIGNlbGxTcGFjaW5nPTAgY2VsbFBhZGRpbmc9MCBzdHlsZT0icGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGJvcmRlci1ib3R0b206MXB4IGRvdHRlZCAjZWZlZmVmOyI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBjb2xzcGFuPTI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8YSBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5jb2xvcj0nIzAwMDAwMCc7IiBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmNvbG9yPScjRkZGRkZGJzsiIHN0eWxlPSJ0ZXh0LWRlY29yYXRpb246bm9uZTsgYm9yZGVyOjBweCBzb2xpZCBibGFjazsgZm9udC13ZWlnaHQ6bm9ybWFsOyBmb250LXNpemU6MTJweDsgY29sb3I6I0ZFRkVGRTsgIGZvbnQtZmFtaWx5OlZlcmRhbmE7IiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL3JlZGlyZWN0LnBocD9jb2RlPWFIUjBjSE02THk5aGJXVnlhV3RoTWpFdVpHVXZZVzVoYkhselpTOHlNakUwT0RZdlluSmhjMmxzYVdWdUxYWmhiR1V0WW5KMWJXRmthVzVvYnc9PSI+VW13ZWx0dmVyYnJlY2hlbiBpbiBCcmFzaWxpZW46ID9EZXIgVmFsZS1Lb256ZXJuIG11c3MgZ2VzdG9wcHQgd2VyZGVuPzwvYT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249bGVmdCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+PGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vYW1lcmlrYTIxLmRlIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPkFtZXJpa2EyMS4uLjwvYT48L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249cmlnaHQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjE3LiBGZWIgMTU6MDc8L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPjx0ZCBjb2xzcGFuPTIgSEVJR0hUPTU+PC90ZD48L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90YWJsZT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0ciBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0nJzsiIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0ndXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9zY3JvbGwucG5nKSc7IiBoZWlnaHQ9IjE4Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGFibGUgYm9yZGVyPTAgaGVpZ2h0PTIwIHdpZHRoPTEwMCUgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgYm9yZGVyLWJvdHRvbToxcHggZG90dGVkICNlZmVmZWY7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGNvbHNwYW49Mj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmNvbG9yPScjMDAwMDAwJzsiIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuY29sb3I9JyNGRkZGRkYnOyIgc3R5bGU9InRleHQtZGVjb3JhdGlvbjpub25lOyBib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBmb250LXdlaWdodDpub3JtYWw7IGZvbnQtc2l6ZToxMnB4OyBjb2xvcjojRkVGRUZFOyAgZm9udC1mYW1pbHk6VmVyZGFuYTsiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvcmVkaXJlY3QucGhwP2NvZGU9YUhSMGNITTZMeTkzZDNjdWFHVnBjMlV1WkdVdmRIQXZabVZoZEhWeVpYTXZWMlZzZEc5eVpHNTFibWN0YVc0dFUyTm9aWEppWlc0dE5ETXhNVEU1Tnk1b2RHMXMiPldlbHRvcmRudW5nIGluIFNjaGVyYmVuIDwvYT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249bGVmdCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+PGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vd3d3LmhlaXNlLmRlIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPkhlaXNlLmRlPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTcuIEZlYiAxNTowNDwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0hNNkx5OWtaWFYwYzJOb0xuSjBMbU52YlM5aGJXVnlhV3RoTHpnME16YzFMWE5sYkdWcmRHbDJaUzFsYlhCdlpYSjFibWN0WVhWbUxXaHZaV05vYzNSbGJTMXVhWFpsWVhVdiI+V2VydGUtUGFydG5lciBLb2x1bWJpZW4gdmVyc2lua3QgaW4gR2V3YWx0IDwvYT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249bGVmdCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+PGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vZGV1dHNjaC5ydC5jb20iIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+RGV1dHNjaC5yLi4uPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTcuIEZlYiAxNTowMTwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0hNNkx5OTNkM2N1YW5WdVoyVjNaV3gwTG1SbEwyRnlkR2xyWld3dk16UTRPRFExTG5OdmVtbGhiR1V0YkdGblpTMXBiaTF6WTJoM1pXUmxiaTExYm5OcFkyaGxjbVV0ZW1WcGRHVnVMbWgwYld3PSI+U296aWFsZSBMYWdlIGluIFNjaHdlZGVuOiBVbnNpY2hlcmUgWmVpdGVuPC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly93d3cuanVuZ2V3ZWx0LmRlIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPkp1bmdld2VsdC4uLjwvYT48L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249cmlnaHQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjE3LiBGZWIgMTQ6NTk8L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPjx0ZCBjb2xzcGFuPTIgSEVJR0hUPTU+PC90ZD48L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90YWJsZT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0ciBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0nJzsiIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0ndXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9zY3JvbGwucG5nKSc7IiBoZWlnaHQ9IjE4Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGFibGUgYm9yZGVyPTAgaGVpZ2h0PTIwIHdpZHRoPTEwMCUgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgYm9yZGVyLWJvdHRvbToxcHggZG90dGVkICNlZmVmZWY7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGNvbHNwYW49Mj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmNvbG9yPScjMDAwMDAwJzsiIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuY29sb3I9JyNGRkZGRkYnOyIgc3R5bGU9InRleHQtZGVjb3JhdGlvbjpub25lOyBib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBmb250LXdlaWdodDpub3JtYWw7IGZvbnQtc2l6ZToxMnB4OyBjb2xvcjojRkVGRUZFOyAgZm9udC1mYW1pbHk6VmVyZGFuYTsiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvcmVkaXJlY3QucGhwP2NvZGU9YUhSMGNITTZMeTlxWVdOdlltbHViV0ZuTG1OdmJTOHlNREU1THpBeUwzUm9aUzExZEhSbGNteDVMV0pwZW1GeWNtVXRiR2xtWlMxdlppMXNlVzVrYjI0dGJHRnliM1ZqYUdVdiI+VGhlIFV0dGVybHkgQml6YXJyZSBMaWZlIG9mIEx5bmRvbiBMYVJvdWNoZTwvYT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249bGVmdCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+PGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vamFjb2Jpbm1hZy5jb20iIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+SmFjb2Jpbm1hLi4uPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTcuIEZlYiAxNDo1Njwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0hNNkx5OTNkM2N1ZEdGNkxtUmxMMHR2YlcxbGJuUmhjaTFGVlMxU1pXWnZjbTB0ZW5WdExWVnlhR1ZpWlhKeVpXTm9kQzhoTlRVM01ETTBOaTg9Ij5FaW4gVHJhdW0gZvxyIEZhY2Vib29rIHVuZCBGYXNjaGlzdGVuPC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly93d3cudGF6LmRlIiBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyB0ZXh0LWRlY29yYXRpb246bm9uZTsiPlRhei5kZTwvYT48L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249cmlnaHQgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsiPjxub2JyPjE3LiBGZWIgMTQ6NTQ8L25vYnI+PC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPjx0ZCBjb2xzcGFuPTIgSEVJR0hUPTU+PC90ZD48L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90YWJsZT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPjx0ciBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0nJzsiIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmJhY2tncm91bmRJbWFnZT0ndXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9zY3JvbGwucG5nKSc7IiBoZWlnaHQ9IjE4Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGFibGUgYm9yZGVyPTAgaGVpZ2h0PTIwIHdpZHRoPTEwMCUgY2VsbFNwYWNpbmc9MCBjZWxsUGFkZGluZz0wIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgYm9yZGVyLWJvdHRvbToxcHggZG90dGVkICNlZmVmZWY7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGNvbHNwYW49Mj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhIG9ubW91c2VvdmVyPSJ0aGlzLnN0eWxlLmNvbG9yPScjMDAwMDAwJzsiIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuY29sb3I9JyNGRkZGRkYnOyIgc3R5bGU9InRleHQtZGVjb3JhdGlvbjpub25lOyBib3JkZXI6MHB4IHNvbGlkIGJsYWNrOyBmb250LXdlaWdodDpub3JtYWw7IGZvbnQtc2l6ZToxMnB4OyBjb2xvcjojRkVGRUZFOyAgZm9udC1mYW1pbHk6VmVyZGFuYTsiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvcmVkaXJlY3QucGhwP2NvZGU9YUhSMGNITTZMeTkzZDNjdVpuSmxhWFJoWnk1a1pTOWhkWFJ2Y21WdUwyVnBibVpoWTJobGMzUmhibVJoTVM5cGJtNWxibTV3YjJ4cGRHbHIiPkJvbHNvbmFyb3MgZXJzdGVyIFNrYW5kYWwgPC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly93d3cuZnJlaXRhZy5kZSIgc3R5bGU9ImNvbG9yOiM3MDc3ODk7IHBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBmb250LWZhbWlseTpWZXJkYW5hLEhlbHZldGljYSxBcmlhbCxTYW5zLVNlcmlmOyBmb250LXNpemU6MTFweDsgZm9udC13ZWlnaHQ6Ym9sZDsgdGV4dC1kZWNvcmF0aW9uOm5vbmU7Ij5GcmVpdGFnLmQuLi48L2E+PC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkIGFsaWduPXJpZ2h0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj4xNy4gRmViIDE0OjUzPC9ub2JyPjwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj48dGQgY29sc3Bhbj0yIEhFSUdIVD01PjwvdGQ+PC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGFibGU+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj48dHIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9Jyc7IiBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5iYWNrZ3JvdW5kSW1hZ2U9J3VybChodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvc2Nyb2xsLnBuZyknOyIgaGVpZ2h0PSIxOCI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRhYmxlIGJvcmRlcj0wIGhlaWdodD0yMCB3aWR0aD0xMDAlIGNlbGxTcGFjaW5nPTAgY2VsbFBhZGRpbmc9MCBzdHlsZT0icGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGJvcmRlci1ib3R0b206MXB4IGRvdHRlZCAjZWZlZmVmOyI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBjb2xzcGFuPTI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8YSBvbm1vdXNlb3Zlcj0idGhpcy5zdHlsZS5jb2xvcj0nIzAwMDAwMCc7IiBvbm1vdXNlb3V0PSJ0aGlzLnN0eWxlLmNvbG9yPScjRkZGRkZGJzsiIHN0eWxlPSJ0ZXh0LWRlY29yYXRpb246bm9uZTsgYm9yZGVyOjBweCBzb2xpZCBibGFjazsgZm9udC13ZWlnaHQ6bm9ybWFsOyBmb250LXNpemU6MTJweDsgY29sb3I6I0ZFRkVGRTsgIGZvbnQtZmFtaWx5OlZlcmRhbmE7IiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL3JlZGlyZWN0LnBocD9jb2RlPWFIUjBjSE02THk5blpXZGxibUpzWlc1a1pTNWtaMkl1WkdVdllYSjBhV3RsYkM4cksyTnZLeXM0WkRGa09UWTNZUzB6TVRCbUxURXhaVGt0WWpJMFlTMDFNalUwTURBNE9HTmhaR0U9Ij5Tb3ppYWxlIEdlcmVjaHRpZ2tlaXQgYWxzIEZyaWVkZW5zc2ljaGVydW5nPC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9nZWdlbmJsZW5kZS5kZ2IuZGUiIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+R2VnZW5ibGVuLi4uPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTcuIEZlYiAxNDo1MTwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0hNNkx5OTJaWEpoTFd4bGJtZHpabVZzWkM1a1pTOHlNREU1THpBeUx6RTFMMmR5Wlc1NmIyVm1abTUxYm1kekxXVnVkSE5qYUdWcFpIVnVaeTFrWlhNdFluWmxjbVpuTHc9PSI+RGFzIEJ1bmRlc3ZlcmZhc3N1bmdzZ2VyaWNodCBpc3QgZGVzZXJ0aWVydDwvYT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249bGVmdCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+PGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vdmVyYS1sZW5nc2ZlbGQuZGUiIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+VmVyYS1sZW5nLi4uPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTcuIEZlYiAxNDo0ODwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0RvdkwzZDNkeTV3Y21GaVpXeHpZbXh2Wnk1a1pTOHlNREU1THpBeUwyMWxjbXRsYkhNdFltRm5aR0ZrWW1Gb2JpOD0iPk1lcmtlbHMgQmFnZGFkYmFobjwvYT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgYWxpZ249bGVmdCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+PGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cucHJhYmVsc2Jsb2cuZGUiIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+UHJhYmVsc2JsLi4uPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTcuIEZlYiAxNDo0Nzwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PHRyIG9ubW91c2VvdXQ9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPScnOyIgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuYmFja2dyb3VuZEltYWdlPSd1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL3Njcm9sbC5wbmcpJzsiIGhlaWdodD0iMTgiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0YWJsZSBib3JkZXI9MCBoZWlnaHQ9MjAgd2lkdGg9MTAwJSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTAgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4OyBib3JkZXItYm90dG9tOjFweCBkb3R0ZWQgI2VmZWZlZjsiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dGQgY29sc3Bhbj0yPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGEgb25tb3VzZW92ZXI9InRoaXMuc3R5bGUuY29sb3I9JyMwMDAwMDAnOyIgb25tb3VzZW91dD0idGhpcy5zdHlsZS5jb2xvcj0nI0ZGRkZGRic7IiBzdHlsZT0idGV4dC1kZWNvcmF0aW9uOm5vbmU7IGJvcmRlcjowcHggc29saWQgYmxhY2s7IGZvbnQtd2VpZ2h0Om5vcm1hbDsgZm9udC1zaXplOjEycHg7IGNvbG9yOiNGRUZFRkU7ICBmb250LWZhbWlseTpWZXJkYW5hOyIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9yZWRpcmVjdC5waHA/Y29kZT1hSFIwY0hNNkx5OXdjbTl0WlhSb1pYVnphVzV6ZEdsMGRYUXVaR1V2WkdsbExXSmxabkpsYVhWdVp5MWtaWE10WVhKaVpXbDBaWEp6TFdSMWNtTm9MV1JsYmkxdFlYSnJkQzg9Ij5EaWUgQmVmcmVpdW5nIGRlcyBBcmJlaXRlcnMgPyBkdXJjaCBkZW4gTWFya3QgPC9hPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90ZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHRyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1sZWZ0IHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7Ij48bm9icj48YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9wcm9tZXRoZXVzaW5zdGl0dXQuZGUiIHN0eWxlPSJjb2xvcjojNzA3Nzg5OyBwYWRkaW5nOjBweDsgbWFyZ2luOjBweDsgZm9udC1mYW1pbHk6VmVyZGFuYSxIZWx2ZXRpY2EsQXJpYWwsU2Fucy1TZXJpZjsgZm9udC1zaXplOjExcHg7IGZvbnQtd2VpZ2h0OmJvbGQ7IHRleHQtZGVjb3JhdGlvbjpub25lOyI+UHJvbWV0aGV1Li4uPC9hPjwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx0ZCBhbGlnbj1yaWdodCBzdHlsZT0iY29sb3I6IzcwNzc4OTsgcGFkZGluZzowcHg7IG1hcmdpbjowcHg7IGZvbnQtZmFtaWx5OlZlcmRhbmEsSGVsdmV0aWNhLEFyaWFsLFNhbnMtU2VyaWY7IGZvbnQtc2l6ZToxMXB4OyBmb250LXdlaWdodDpib2xkOyI+PG5vYnI+MTcuIEZlYiAxNDo0NTwvbm9icj48L3RkPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RyPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dHI+PHRkIGNvbHNwYW49MiBIRUlHSFQ9NT48L3RkPjwvdHI+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdGQ+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvdHI+PC90YWJsZT48L2Rpdj4KICAgICAgICAgICAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgICAgICAgICAgICAgPC9URD4KICAgICAgICAgICAgICAgICAgICAgICAgPFREIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDtiYWNrZ3JvdW5kLWltYWdlOnVybChodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvY3V0MV8wNi5wbmcpOyIgV0lEVEg9IjEyIj4KICAgICAgICAgICAgICAgICAgICAgICAgICA8SU1HIHN0eWxlPSJ2aXNpYmlsaXR5OmhpZGRlbjsiIFNSQz0iaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL2N1dDFfMDYucG5nIj4KICAgICAgICAgICAgICAgICAgICAgICAgPC9URD4KICAgICAgICAgICAgICAgICAgICAgICA8L1RSPgogICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgIDxUUj4KICAgICAgICAgICAgICAgICAgICAgICAgIDxURCBzdHlsZT0icGFkZGluZzowcHg7IG1hcmdpbjowcHg7YmFja2dyb3VuZC1pbWFnZTp1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL2N1dDFfMDcucG5nKTsiIFdJRFRIPSIxMSIgSEVJR0hUPSI2Ij48L1REPgogICAgICAgICAgICAgICAgICAgICAgICAgPFREIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDtiYWNrZ3JvdW5kLWltYWdlOnVybChodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvY3V0MV8wOC5wbmcpOyI+PC9URD4KICAgICAgICAgICAgICAgICAgICAgICAgIDxURCBzdHlsZT0icGFkZGluZzowcHg7IG1hcmdpbjowcHg7YmFja2dyb3VuZC1pbWFnZTp1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL2N1dDFfMDkucG5nKTsiIFdJRFRIPSIxMSIgSEVJR0hUPSI2Ij48L1REPgogICAgICAgICAgICAgICAgICAgICAgIDwvVFI+CiAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgIDxUUj4KICAgICAgICAgICAgICAgICAgICAgICA8VEQgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4O2JhY2tncm91bmQtaW1hZ2U6dXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9jdXQyXzEwLnBuZyk7IiBXSURUSD0iMTEiIEhFSUdIVD0iMjEiPjwvVEQ+CiAgICAgICAgICAgICAgICAgICAgICAgPFREIGFsaWduPSJjZW50ZXIiIHN0eWxlPSJiYWNrZ3JvdW5kLWNvbG9yOiMwMDAwMDA7IGJhY2tncm91bmQtaW1hZ2U6dXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9ib3R0b21fc3BhY2VyLnBuZyk7Ij4KICAgICAgICAgICAgICAgICAgICAgICAgICA8Tk9CUj48SU1HIEhFSUdIVD0yMSBvbmNsaWNrPSJraWNrRmxvYXREaXZVcCgpOyIgb25tb3VzZW92ZXI9InRoaXMuc3JjPSdodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvY3V0M18xMS5wbmcnOyIgb25tb3VzZW91dD0idGhpcy5zcmM9J2h0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9jdXQ0XzExLnBuZyc7IiBTUkM9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9jdXQ0XzExLnBuZyI+PElNRyBIRUlHSFQ9MjEgb25jbGljaz0ia2lja0Zsb2F0RGl2RG93bigpOyIgb25tb3VzZW92ZXI9InRoaXMuc3JjPSdodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvY3V0M18xMi5wbmcnOyIgb25tb3VzZW91dD0idGhpcy5zcmM9J2h0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9jdXQ0XzEyLnBuZyc7IiBTUkM9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9jdXQ0XzEyLnBuZyI+PC9URD48L05PQlI+CiAgICAgICAgICAgICAgICAgICAgICAgPC9URD4KICAgICAgICAgICAgICAgICAgICAgICA8VEQgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4O2JhY2tncm91bmQtaW1hZ2U6dXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9jdXQyXzEzLnBuZyk7IiBXSURUSD0iMTIiIEhFSUdIVD0iMjEiPjwvVEQ+CiAgICAgICAgICAgICAgICAgICAgICA8L1RSPgogICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICA8VFI+CiAgICAgICAgICAgICAgICAgICAgICAgPFREIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDtiYWNrZ3JvdW5kLWltYWdlOnVybChodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvY3V0MV8xMy5wbmcpOyIgV0lEVEg9IjExIiBIRUlHSFQ9IjgiPjwvVEQ+CiAgICAgICAgICAgICAgICAgICAgICAgPFREIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDtiYWNrZ3JvdW5kLWltYWdlOnVybChodHRwOi8vd3d3Lm5ldC1uZXdzLWV4cHJlc3MuZGUvaW1hZ2VzL3JvYWRydW5uZXIvY3V0MV8xNC5wbmcpOyIgV0lEVEg9IjEwMCUiIEhFSUdIVD0iOCI+PC9URD4KICAgICAgICAgICAgICAgICAgICAgICA8VEQgc3R5bGU9InBhZGRpbmc6MHB4OyBtYXJnaW46MHB4O2JhY2tncm91bmQtaW1hZ2U6dXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9jdXQxXzE1LnBuZyk7IiBXSURUSD0iMTIiIEhFSUdIVD0iOCI+PC9URD4KICAgICAgICAgICAgICAgICAgICAgIDwvVFI+CgogICAgICAgICAgICAgICAgICAgICAgPFRSPgogICAgICAgICAgICAgICAgICAgICAgIDxURCBzdHlsZT0icGFkZGluZzowcHg7IG1hcmdpbjowcHg7YmFja2dyb3VuZC1yZXBlYXQ6bm8tcmVwZWF0O2JhY2tncm91bmQtaW1hZ2U6dXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9nZXR0aGlzZmVlZF9sZWZ0LnBuZyk7IiBXSURUSD0iOSIgSEVJR0hUPSIzOCI+PC9URD4KICAgICAgICAgICAgICAgICAgICAgICA8VEQgb25jbGljaz0iZG9jdW1lbnQubG9jYXRpb24uaHJlZj0naHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2luZGV4LnBocD9wYWdlPWluY2x1ZGVfbm5lJzsiIGFsaWduPSJjZW50ZXIiIHN0eWxlPSJwYWRkaW5nOjBweDsgbWFyZ2luOjBweDt2ZXJ0aWNhbC1hbGlnbjptaWRkbGU7Y3Vyc29yOnBvaW50ZXI7YmFja2dyb3VuZC1pbWFnZTp1cmwoaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL2dldHRoaXNmZWVkX3NwYWNlci5wbmcpOyIgV0lEVEg9IjEwMCUiIEhFSUdIVD0iMzgiPjxhIGhyZWY9Imh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbmRleC5waHA/cGFnZT1pbmNsdWRlX25uZSI+PGltZyBzdHlsZT0iYm9yZGVyOjBweCBzb2xpZCBibGFjazsiIHNyYz0iaHR0cDovL3d3dy5uZXQtbmV3cy1leHByZXNzLmRlL2ltYWdlcy9yb2FkcnVubmVyL2dldHRoaXNmZWVkMi5wbmciPjwvYT48L1REPgogICAgICAgICAgICAgICAgICAgICAgIDxURCBzdHlsZT0icGFkZGluZzowcHg7IG1hcmdpbjowcHg7YmFja2dyb3VuZC1yZXBlYXQ6bm8tcmVwZWF0O2JhY2tncm91bmQtaW1hZ2U6dXJsKGh0dHA6Ly93d3cubmV0LW5ld3MtZXhwcmVzcy5kZS9pbWFnZXMvcm9hZHJ1bm5lci9nZXR0aGlzZmVlZF9yaWdodC5wbmcpOyIgV0lEVEg9IjkiIEhFSUdIVD0iMzgiPjwvVEQ+CiAgICAgICAgICAgICAgICAgICAgICA8L1RSPgogICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICA8L3RhYmxlPjxici8+"));