Graduate Universities

Explore UK universities below or take our new Find Your UK University Quiz to quickly find the best matches for you!

Search Graduate Universities

Academic matches are based on minimum US entry requirements.

Relevant work experience may benefit your application depending on the programme/university, especially if you have a low GPA. GRE’s are not required for UK admission. GMAT’s may be required for MBA programmes.

Based in England’s historic capital city, London Metropolitan University has a rich history of education with its roots dating back to 1848. Taking its current form following a merger of two well-renowned universities in 2002, it offers a wide range of courses across two London campuses. London Metropolitan University boasts an active and involved population of international students, and offers advice and assistance with accommodation, funding and careers, as well as academic and wellbeing support.

eyJtYXBfb3B0aW9ucyI6eyJjZW50ZXJfbGF0IjoiNTUuOTEwNjIxNSIsImNlbnRlcl9sbmciOiItMy4zMTY2MTE2Iiwiem9vbSI6NSwibWFwX3R5cGVfaWQiOiJST0FETUFQIiwiY2VudGVyX2J5X25lYXJlc3QiOmZhbHNlLCJmaXRfYm91bmRzIjp0cnVlLCJjZW50ZXJfY2lyY2xlX2ZpbGxjb2xvciI6IiM4Q0FFRjIiLCJjZW50ZXJfY2lyY2xlX3N0cm9rZWNvbG9yIjoiIzhDQUVGMiIsInNob3dfY2VudGVyX2NpcmNsZSI6ZmFsc2UsInNob3dfY2VudGVyX21hcmtlciI6ZmFsc2UsImNlbnRlcl9tYXJrZXJfaWNvbiI6Imh0dHBzOi8vd3d3LndwbGVhZmxldC5jb20vd3AtY29udGVudC9wbHVnaW5zL3dwLWxlYWZsZXQtbWFwcy1wcm8vYXNzZXRzL2ltYWdlcy8vZGVmYXVsdF9tYXJrZXIucG5nIiwiZHJhZ2dhYmxlIjp0cnVlLCJzY3JvbGxfd2hlZWwiOiJmYWxzZSIsImdlc3R1cmUiOiJhdXRvIiwibWFya2VyX2RlZmF1bHRfaWNvbiI6Imh0dHBzOi8vdGhldWtzdHVkeWV4cGVydC5jb20vd3AtY29udGVudC9wbHVnaW5zL3dwLWdvb2dsZS1tYXAtZ29sZC9hc3NldHMvaW1hZ2VzL2ljb25zL21hcmtlcl9kZWZhdWx0X2ljb24ucG5nIiwiaW5mb3dpbmRvd19zZXR0aW5nIjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZ1wiPlxuICAgIHttYXJrZXJfaW1hZ2V9PC9wPlxuPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmdcIj5cbjxkaXYgY2xhc3M9XCJmYy1pdGVtLXBhZGRpbmctY29udGVudF8yMFwiPlxuPGRpdiBjbGFzcz1cImZjLWl0ZW0tbWV0YSBmYy1pdGVtLXNlY29uZGFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlIGZjLXRleHQtY2VudGVyXCI+e21hcmtlcl9jYXRlZ29yeX08L2Rpdj5cbjxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLXRleHQtY2VudGVyXCI+e21hcmtlcl90aXRsZX08L2Rpdj5cbjxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2VcIj5cbiAgICAgICAgICAgICAgICB7bWFya2VyX21lc3NhZ2V9PGJyIC8+XG48c3Ryb25nPkNvdXJzZSAtIDwvc3Ryb25nPiB7Y291cnNlfTxiciAvPlxuPHN0cm9uZz5UeXBlIG9mIENvbGxlZ2UgLSA8L3N0cm9uZz4ge3R5cGUtb2YtY29sbGVnZX08YnIgLz5cbjxzdHJvbmc+UHJvZ3JhbSBUeXBlIC0gPC9zdHJvbmc+IHtwcm9ncmFtLXR5cGV9XG4gICAgICAgICAgICA8L2Rpdj5cbjwvcD48L2Rpdj5cbjwvcD48L2Rpdj5cbjwvZGl2PlxuIiwiaW5mb3dpbmRvd19nZW90YWdzX3NldHRpbmciOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICB7cG9zdF9mZWF0dXJlZF9pbWFnZX1cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tcGFkZGluZy1jb250ZW50XzIwXCI+XHJcbjxhIGhyZWY9XCJ7cG9zdF9saW5rfVwiIGNsYXNzPVwiZmMtaXRlbS10aXRsZSBmYy1pdGVtLXByaW1hcnktdGV4dC1jb2xvciBmYy10ZXh0LWNlbnRlclwiPntwb3N0X3RpdGxlfTwvYT5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tY29udGVudCBmYy1pdGVtLWJvZHktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZVwiPlxyXG4gICAgICAgICAgICAgICAge3Bvc3RfZXhjZXJwdH1cclxuICAgICAgICAgICAgPC9kaXY+XHJcbiAgICAgICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuPC9kaXY+IiwiaW5mb3dpbmRvd19za2luIjp7Im5hbWUiOiJ1ZGluZSIsInR5cGUiOiJpbmZvd2luZG93Iiwic291cmNlY29kZSI6IiZsdDtkaXYgY2xhc3M9JnF1b3Q7ZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nJnF1b3Q7Jmd0O1xyXG4gICAge21hcmtlcl9pbWFnZX1cclxuICAgICZsdDtkaXYgY2xhc3M9JnF1b3Q7ZmMtaXRlbWNvbnRlbnQtcGFkZGluZyZxdW90OyZndDtcclxuICAgICAgICAmbHQ7ZGl2IGNsYXNzPSZxdW90O2ZjLWl0ZW0tcGFkZGluZy1jb250ZW50XzIwJnF1b3Q7Jmd0O1xyXG4gICAgICAgICAgICAmbHQ7ZGl2IGNsYXNzPSZxdW90O2ZjLWl0ZW0tbWV0YSBmYy1pdGVtLXNlY29uZGFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlIGZjLXRleHQtY2VudGVyJnF1b3Q7Jmd0O3ttYXJrZXJfY2F0ZWdvcnl9Jmx0Oy9kaXYmZ3Q7XHJcbiAgICAgICAgICAgICZsdDtkaXYgY2xhc3M9JnF1b3Q7ZmMtaXRlbS10aXRsZSBmYy1pdGVtLXByaW1hcnktdGV4dC1jb2xvciBmYy10ZXh0LWNlbnRlciZxdW90OyZndDt7bWFya2VyX3RpdGxlfSZsdDsvZGl2Jmd0O1xyXG4gICAgICAgICAgICAmbHQ7ZGl2IGNsYXNzPSZxdW90O2ZjLWl0ZW0tY29udGVudCBmYy1pdGVtLWJvZHktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZSZxdW90OyZndDtcclxuICAgICAgICAgICAgICAgIHttYXJrZXJfbWVzc2FnZX0mbHQ7YnImZ3Q7XHJcbiZsdDtzdHJvbmcmZ3Q7Q291cnNlIC0gJmx0Oy9zdHJvbmcmZ3Q7IHtjb3Vyc2V9Jmx0O2JyJmd0O1xyXG4mbHQ7c3Ryb25nJmd0O1R5cGUgb2YgQ29sbGVnZSAtICZsdDsvc3Ryb25nJmd0OyB7dHlwZS1vZi1jb2xsZWdlfSZsdDticiZndDtcclxuJmx0O3N0cm9uZyZndDtQcm9ncmFtIFR5cGUgLSAmbHQ7L3N0cm9uZyZndDsge3Byb2dyYW0tdHlwZX1cclxuICAgICAgICAgICAgJmx0Oy9kaXYmZ3Q7XHJcblxyXG4gICAgICAgICZsdDsvZGl2Jmd0O1xyXG4gICAgJmx0Oy9kaXYmZ3Q7XHJcbiZsdDsvZGl2Jmd0OyJ9LCJpbmZvd2luZG93X3Bvc3Rfc2tpbiI6eyJuYW1lIjoidWRpbmUiLCJ0eXBlIjoicG9zdCIsInNvdXJjZWNvZGUiOiImbHQ7ZGl2IGNsYXNzPSZxdW90O2ZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZyZxdW90OyZndDtcclxuICAgIHtwb3N0X2ZlYXR1cmVkX2ltYWdlfVxyXG4gICAgJmx0O2RpdiBjbGFzcz0mcXVvdDtmYy1pdGVtY29udGVudC1wYWRkaW5nJnF1b3Q7Jmd0O1xyXG4gICAgICAgICZsdDtkaXYgY2xhc3M9JnF1b3Q7ZmMtaXRlbS1wYWRkaW5nLWNvbnRlbnRfMjAmcXVvdDsmZ3Q7XHJcbiZsdDthIGhyZWY9JnF1b3Q7e3Bvc3RfbGlua30mcXVvdDsgY2xhc3M9JnF1b3Q7ZmMtaXRlbS10aXRsZSBmYy1pdGVtLXByaW1hcnktdGV4dC1jb2xvciBmYy10ZXh0LWNlbnRlciZxdW90OyZndDt7cG9zdF90aXRsZX0mbHQ7L2EmZ3Q7XHJcbiAgICAgICAgICAgICZsdDtkaXYgY2xhc3M9JnF1b3Q7ZmMtaXRlbS1jb250ZW50IGZjLWl0ZW0tYm9keS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlJnF1b3Q7Jmd0O1xyXG4gICAgICAgICAgICAgICAge3Bvc3RfZXhjZXJwdH1cclxuICAgICAgICAgICAgJmx0Oy9kaXYmZ3Q7XHJcbiAgICAgICAgJmx0Oy9kaXYmZ3Q7XHJcbiAgICAmbHQ7L2RpdiZndDtcclxuJmx0Oy9kaXYmZ3Q7In0sImluZm93aW5kb3dfZHJvcF9hbmltYXRpb24iOmZhbHNlLCJjbG9zZV9pbmZvd2luZG93X29uX21hcF9jbGljayI6dHJ1ZSwiZGVmYXVsdF9pbmZvd2luZG93X29wZW4iOmZhbHNlLCJpbmZvd2luZG93X29wZW5fZXZlbnQiOiJjbGljayIsImxpc3RpbmdfaW5mb3dpbmRvd19vcGVuX2V2ZW50IjoiY2xpY2siLCJpc19tb2JpbGUiOmZhbHNlLCJpbmZvd2luZG93X2ZpbHRlcl9vbmx5IjpmYWxzZSwiaW5mb3dpbmRvd19jbGlja19jaGFuZ2Vfem9vbSI6MCwiaW5mb3dpbmRvd19jbGlja19jaGFuZ2VfY2VudGVyIjp0cnVlLCJmdWxsX3NjcmVlbl9jb250cm9sIjp0cnVlLCJzZWFyY2hfY29udHJvbCI6dHJ1ZSwiZXhjbHVkZV9maWVsZHMiOlsieyVfY3VzdG9tX3ByaW9yaXR5X21ldGFfa2V5JX0iLCJ7cG9zdF9mZWF0dXJlZF9pbWFnZX0iLCJ7cG9zdF9saW5rfSJdLCJ6b29tX2NvbnRyb2wiOnRydWUsIm1hcF90eXBlX2NvbnRyb2wiOnRydWUsInN0cmVldF92aWV3X2NvbnRyb2wiOnRydWUsImxvY2F0ZW1lX2NvbnRyb2wiOnRydWUsIm1vYmlsZV9zcGVjaWZpYyI6ZmFsc2UsInpvb21fbW9iaWxlIjo1LCJkcmFnZ2FibGVfbW9iaWxlIjp0cnVlLCJzY3JvbGxfd2hlZWxfbW9iaWxlIjp0cnVlLCJmdWxsX3NjcmVlbl9jb250cm9sX3Bvc2l0aW9uIjoiQk9UVE9NX0xFRlQiLCJzZWFyY2hfY29udHJvbF9wb3NpdGlvbiI6IkJPVFRPTV9MRUZUIiwibG9jYXRlbWVfY29udHJvbF9wb3NpdGlvbiI6IkJPVFRPTV9MRUZUIiwiem9vbV9jb250cm9sX3Bvc2l0aW9uIjoiQk9UVE9NX0xFRlQiLCJtYXBfdHlwZV9jb250cm9sX3Bvc2l0aW9uIjoiQk9UVE9NX0xFRlQiLCJtYXBfdHlwZV9jb250cm9sX3N0eWxlIjoiSE9SSVpPTlRBTF9CQVIiLCJzdHJlZXRfdmlld19jb250cm9sX3Bvc2l0aW9uIjoiQk9UVE9NX0xFRlQiLCJtYXBfY29udHJvbCI6ZmFsc2UsInNjcmVlbnMiOnsic21hcnRwaG9uZXMiOnsibWFwX3pvb21fbGV2ZWxfbW9iaWxlIjoiNSJ9LCJpcGFkcyI6eyJtYXBfem9vbV9sZXZlbF9tb2JpbGUiOiI1In0sImxhcmdlLXNjcmVlbnMiOnsibWFwX3pvb21fbGV2ZWxfbW9iaWxlIjoiNSJ9fSwibWFwX2luZm93aW5kb3dfY3VzdG9taXNhdGlvbnMiOmZhbHNlLCJpbmZvd2luZG93X3dpZHRoIjoiMTAwJSIsImluZm93aW5kb3dfYm9yZGVyX2NvbG9yIjoicmdiYSgwLCAwLCAwLCAwLjA5ODAzOTIpIiwiaW5mb3dpbmRvd19iZ19jb2xvciI6IiNmZmYiLCJzaG93X2luZm93aW5kb3dfaGVhZGVyIjpmYWxzZSwibWluX3pvb20iOiIxIiwibWF4X3pvb20iOiIxOSIsInpvb21fbGV2ZWxfYWZ0ZXJfc2VhcmNoIjoiNSIsInVybF9maWx0ZXJzIjp0cnVlLCJkb3VibGVjbGlja3pvb20iOnRydWUsImN1cnJlbnRfcG9zdF9vbmx5IjpmYWxzZSwic2VhcmNoX3BsYWNlaG9sZGVyIjoiRW50ZXIgYSBzZWFyY2ggdGVybSAoaS5lLiBkZWdyZWUgaW50ZXJlc3QsIGNpdHksIGNvdW50cnksIGV0Yy4pLi4uIiwiYm91bmRfbWFwX2FmdGVyX2ZpbHRlciI6ZmFsc2UsImRpc3BsYXlfcmVzZXRfYnV0dG9uIjpmYWxzZSwibWFwX3Jlc2V0X2J1dHRvbl90ZXh0IjoiUmVzZXQiLCJoZWlnaHQiOiI2NTAifSwicGxhY2VzIjpbeyJzb3VyY2UiOiJwb3N0IiwidGl0bGUiOiJIZXJpb3QtV2F0dCBVbml2ZXJzaXR5IiwiaW5mb3dpbmRvd19jb250ZW50IjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZ1wiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJIZXJpb3QgV2F0dCBVbml2ZXJzaXR5XCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIxNThcIiBzcmM9XCJodHRwczovL3RoZXVrc3R1ZHlleHBlcnQuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDI0LzEyL0hlcmlvdC1XYXR0LWxvZ28tMzAweDE1OC5wbmdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tcGFkZGluZy1jb250ZW50XzIwXCI+XHJcbjxhIGhyZWY9XCJodHRwczovL3RoZXVrc3R1ZHlleHBlcnQuY29tL3VuaXZlcnNpdGllcy9oZXJpb3Qtd2F0dC11bml2ZXJzaXR5L1wiIGNsYXNzPVwiZmMtaXRlbS10aXRsZSBmYy1pdGVtLXByaW1hcnktdGV4dC1jb2xvciBmYy10ZXh0LWNlbnRlclwiPkhlcmlvdC1XYXR0IFVuaXZlcnNpdHk8L2E+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2VcIj5cclxuICAgICAgICAgICAgICAgIEhlcmlvdC1XYXR0IFVuaXZlcnNpdHkgaXMgdmFsdWVkIGZvciBpdHMgcGlvbmVlcmluZyByZXNlYXJjaCwgaW5mb3JtZWQgYnkgdGhlIGdsb2JhbCBuZWVkcyBvZiBidXNpbmVzcyBhbmQgaW5kdXN0cnkuIFdlIGFyZSBzcGVjaWFsaXN0cyBpbiBidXNpbmVzcywgZW5naW5lZXJpbmcsIGRlc2lnbiBhbmQgdGhlIHBoeXNpY2FsLCBzb2NpYWwgYW5kIGxpZmUgc2NpZW5jZXMuXHJcbiAgICAgICAgICAgIDwvZGl2PlxyXG4gICAgICAgIDwvZGl2PlxyXG4gICAgPC9kaXY+XHJcbjwvZGl2PiIsImNvbnRlbnQiOiJIZXJpb3QtV2F0dCBVbml2ZXJzaXR5IGlzIHZhbHVlZCBmb3IgaXRzIHBpb25lZXJpbmcgcmVzZWFyY2gsIGluZm9ybWVkIGJ5IHRoZSBnbG9iYWwgbmVlZHMgb2YgYnVzaW5lc3MgYW5kIGluZHVzdHJ5LiBXZSBhcmUgc3BlY2lhbGlzdHMgaW4gYnVzaW5lc3MsIGVuZ2luZWVyaW5nLCBkZXNpZ24gYW5kIHRoZSBwaHlzaWNhbCwgc29jaWFsIGFuZCBsaWZlIHNjaWVuY2VzLiIsImFkZHJlc3MiOiJUaGUgQXZlbnVlLCBDdXJyaWUgRUgxNCA0QVMsIFVLIiwibG9jYXRpb24iOnsibGF0IjoiNTUuOTEwNjIxNSIsInN0YXRlIjoiU2NvdGxhbmQiLCJjb3VudHJ5IjoiVW5pdGVkIEtpbmdkb20iLCJsbmciOiItMy4zMTY2MTE2Iiwib25jbGlja19hY3Rpb24iOiJtYXJrZXIiLCJyZWRpcmVjdF9wZXJtYWxpbmsiOiJodHRwczovL3RoZXVrc3R1ZHlleHBlcnQuY29tL3VuaXZlcnNpdGllcy9oZXJpb3Qtd2F0dC11bml2ZXJzaXR5LyIsInpvb20iOjUsImV4dHJhX2ZpZWxkcyI6eyJwb3N0X2V4Y2VycHQiOiJIZXJpb3QtV2F0dCBVbml2ZXJzaXR5IGlzIHZhbHVlZCBmb3IgaXRzIHBpb25lZXJpbmcgcmVzZWFyY2gsIGluZm9ybWVkIGJ5IHRoZSBnbG9iYWwgbmVlZHMgb2YgYnVzaW5lc3MgYW5kIGluZHVzdHJ5LiBXZSBhcmUgc3BlY2lhbGlzdHMgaW4gYnVzaW5lc3MsIGVuZ2luZWVyaW5nLCBkZXNpZ24gYW5kIHRoZSBwaHlzaWNhbCwgc29jaWFsIGFuZCBsaWZlIHNjaWVuY2VzLiIsInBvc3RfY29udGVudCI6IjxmaWd1cmU+PGltZyBzcmM9XCJodHRwczovL3RoZXVrc3R1ZHlleHBlcnQuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDI0LzEyL0hhcmlvdC1XYXR0LVVuaXZlcnNpdHkucG5nXCIgYWx0PVwiSGVyaW90IFdhdHQgVW5pdmVyc2l0eVwiIC8+PC9maWd1cmU+XHJcbjxmaWd1cmU+PGltZyBzcmM9XCJodHRwczovL3RoZXVrc3R1ZHlleHBlcnQuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDI0LzEyL0hhcmlvdC1XYXR0LVVuaXZlcnNpdHktMS5wbmdcIiBhbHQ9XCJIZXJpb3QgV2F0dCBVbml2ZXJzaXR5XCIgLz48L2ZpZ3VyZT5cclxuPGZpZ3VyZT48aW1nIHNyYz1cImh0dHBzOi8vdGhldWtzdHVkeWV4cGVydC5jb20vd3AtY29udGVudC91cGxvYWRzLzIwMjQvMTIvSGFyaW90LVdhdHQtVW5pdmVyc2l0eS0yLnBuZ1wiIGFsdD1cIkhlcmlvdCBXYXR0IFVuaXZlcnNpdHlcIiAvPjwvZmlndXJlPlxyXG48ZmlndXJlPjxpbWcgc3JjPVwiaHR0cHM6Ly90aGV1a3N0dWR5ZXhwZXJ0LmNvbS93cC1jb250ZW50L3VwbG9hZHMvMjAyNC8xMi9IYXJpb3QtV2F0dC1Vbml2ZXJzaXR5LTMucG5nXCIgYWx0PVwiSGVyaW90IFdhdHQgVW5pdmVyc2l0eVwiIC8+PC9maWd1cmU+XHJcbjxmaWd1cmU+PGltZyBzcmM9XCJodHRwczovL3RoZXVrc3R1ZHlleHBlcnQuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDI0LzEyL0hhcmlvdC1XYXR0LVVuaXZlcnNpdHktNC5wbmdcIiBhbHQ9XCJIZXJpb3QgV2F0dCBVbml2ZXJzaXR5XCIgLz48L2ZpZ3VyZT5cclxuPGZpZ3VyZT48aW1nIHNyYz1cImh0dHBzOi8vdGhldWtzdHVkeWV4cGVydC5jb20vd3AtY29udGVudC91cGxvYWRzLzIwMjQvMTIvSGFyaW90LVdhdHQtVW5pdmVyc2l0eS01LnBuZ1wiIGFsdD1cIkhlcmlvdCBXYXR0IFVuaXZlcnNpdHlcIiAvPjwvZmlndXJlPlxyXG48YSBocmVmPVwiI2NvbnRhY3QtZm9ybVwiPlxyXG5Db250YWN0IEhlcmlvdC1XYXR0IFVuaXZlcnNpdHlcclxuPC9hPlxyXG5cclxuPHN0cm9uZz5Mb2NhdGlvbjo8L3N0cm9uZz4gVGhlIEF2ZW51ZSwgRWRpbmJ1cmdoLCBFSDE0IDRBU1xyXG5cclxuPHN0cm9uZz5XZWJzaXRlOjwvc3Ryb25nPiA8YSBocmVmPVwiaHR0cHM6Ly93d3cuaHcuYWMudWsvXCI+aHR0cHM6Ly93d3cuaHcuYWMudWsvPC9hPlxyXG48aDM+T3ZlcnZpZXc8L2gzPlxyXG5IZXJpb3QtV2F0dCBVbml2ZXJzaXR5IGlzIHZhbHVlZCBmb3IgaXRzIHBpb25lZXJpbmcgcmVzZWFyY2gsIGluZm9ybWVkIGJ5IHRoZSBnbG9iYWwgbmVlZHMgb2YgYnVzaW5lc3MgYW5kIGluZHVzdHJ5LiBXaXRoIGEgcmljaCBoZXJpdGFnZSBzdHJldGNoaW5nIGJhY2sgdG8gMTgyMSwgd2UgYXJlIGEgdHJ1bHkgZ2xvYmFsIHVuaXZlcnNpdHkgYnJpbmdpbmcgdG9nZXRoZXIgc2Nob2xhcnMgd2hvIGFyZSBsZWFkZXJzIGluIGlkZWFzIGFuZCBzb2x1dGlvbnMgZGVsaXZlcmluZyBpbm5vdmF0aW9uLCBlZHVjYXRpb25hbCBleGNlbGxlbmNlIGFuZCBncm91bmQtYnJlYWtpbmcgcmVzZWFyY2guXHJcblxyXG5XZSBhcmUgc3BlY2lhbGlzdHMgaW4gYnVzaW5lc3MsIGVuZ2luZWVyaW5nLCBkZXNpZ24gYW5kIHRoZSBwaHlzaWNhbCwgc29jaWFsIGFuZCBsaWZlIHNjaWVuY2VzIFx1MjAxMyBzdWJqZWN0cyB3aGljaCBtYWtlIGEgcmVhbCBpbXBhY3Qgb24gdGhlIHdvcmxkIGFuZCBzb2NpZXR5LlxyXG5cclxuV2l0aCBvdXIgcm9vdHMgaW4gU2NvdGxhbmQsIG91ciBhbWJpdGlvbiBhbmQgcmVhY2ggYXJlIHRydWx5IGludGVybmF0aW9uYWwuIFdlIGFyZSBhIGdsb2JhbCB1bml2ZXJzaXR5IHdpdGggYXJvdW5kIDI3LDAwMCBzdHVkZW50cywgZml2ZSBjYW1wdXNlcyBhbmQgb3ZlciAxMDAgbGVhcm5pbmcgcGFydG5lcnMgYXJvdW5kIHRoZSB3b3JsZC4gV2UgYXJlIG9uZSBvZiBTY290bGFuZFx1MjAxOXMgbW9zdCBpbnRlcm5hdGlvbmFsIHVuaXZlcnNpdGllczsgYXJvdW5kIGEgdGhpcmQgb2YgSGVyaW90LVdhdHQgc3R1ZGVudHMgaW4gRWRpbmJ1cmdoIGFyZSBmcm9tIG91dHNpZGUgdGhlIFVLLlxyXG5cclxuT3VyIGNhbXB1c2VzIGFyZSBiYXNlZCBpbiBzb21lIG9mIHRoZSB3b3JsZFx1MjAxOXMgbW9zdCBpbnNwaXJpbmcgbG9jYXRpb25zIGluIHRoZSBVSywgRHViYWkgYW5kIE1hbGF5c2lhLiBFYWNoIG9mZmVycyBzdXBlcmIgZmFjaWxpdGllcywgc2FmZSBzdXJyb3VuZGluZ3MgYW5kIGFuIGludGVybmF0aW9uYWwgd2VsY29tZS4gV2UgaGF2ZSBidWlsdCBjb25uZWN0ZWQgYW5kIGludGVncmF0ZWQgbGVhcm5pbmcgZW52aXJvbm1lbnRzIGNsb3NlIHRvIHRoZSB2aWJyYW50IGNpdGllcyBvZiBFZGluYnVyZ2gsIER1YmFpIGFuZCBLdWFsYSBMdW1wdXIuXHJcblxyXG48c3Ryb25nPlBvcHVsYXRpb246IDwvc3Ryb25nPjI3LDAwMFxyXG5cclxuPHN0cm9uZz5DYW1wdXMgVHlwZTogPC9zdHJvbmc+U3VidXJiYW5cclxuPGgzPlF1aWNrIEZhY3RzPC9oMz5cclxuPHVsPlxyXG4gXHQ8bGk+T3VyIGhlcml0YWdlIGRhdGVzIGJhY2sgdG8gMTgyMS48L2xpPlxyXG4gXHQ8bGk+V2UgYXJlIHJhbmtlZCAyNTZ0aCBpbiB0aGUgd29ybGQsIDMybmQgaW4gdGhlIFVLIGFuZCA1dGggaW4gU2NvdGxhbmQuIFFTIFdvcmxkIFVuaXZlcnNpdHkgUmFua2luZ3MgMjAyNS48L2xpPlxyXG4gXHQ8bGk+V2UgYXJlIDFzdCBpbiBTY290bGFuZCBhbmQgMm5kIGluIHRoZSBVSyBmb3IgdW5kZXJncmFkdWF0ZSBlbXBsb3lhYmlsaXR5LiBHcmFkdWF0ZSBPdXRjb21lcyBTdXJ2ZXkgMjAyNC48L2xpPlxyXG4gXHQ8bGk+UmFua2VkIDFzdCBpbiB0aGUgVUsgZm9yIHByb2R1Y2luZyBDRU9zLCBNRHMgYW5kIEVudHJlcHJlbmV1cnMuIE5vdnVuYSAyMDIzLjwvbGk+XHJcbiBcdDxsaT44NiUgb2Ygb3VyIHJlc2VhcmNoIG91dHB1dHMgYXJlIHJhbmtlZCB3b3JsZC1sZWFkaW5nIGFuZCBpbnRlcm5hdGlvbmFsbHkgZXhjZWxsZW50LiBSZXNlYXJjaCBFeGNlbGxlbmNlIEZyYW1ld29yayAyMDIxLjwvbGk+XHJcbjwvdWw+XHJcbjxoMz5WaWRlb3M8L2gzPlxyXG5odHRwczovL3d3dy55b3V0dWJlLmNvbS93YXRjaD92PURMY25WT2pIX0dRaHR0cHM6Ly93d3cueW91dHViZS5jb20vd2F0Y2g/dj1RcUFTb3ZnY2VSRWh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL3dhdGNoP3Y9eHRlU3ZiSHlzOTgmYW1wO2xpc3Q9UExOMzhGT18zcDVPU2F2TlN3Zmhxbk1UTlM5TWRJZXNXbCZhbXA7aW5kZXg9MTZodHRwczovL3d3dy55b3V0dWJlLmNvbS93YXRjaD92PWM4eHNwbE9lVEpvaHR0cHM6Ly93d3cueW91dHViZS5jb20vd2F0Y2g/dj1fRm04LUNaRS1PUSZhbXA7bGlzdD1QTE4zOEZPXzNwNU9Td2Fyel9zQ2hTU3Bzc3dDYllaVGQ0aHR0cHM6Ly93d3cueW91dHViZS5jb20vd2F0Y2g/dj1nV2g4OXhOZGxfVVxyXG48aDM+VW5kZXJncmFkdWF0ZSBJbmZvcm1hdGlvbjwvaDM+XHJcbjxoND5VUyBFbnRyeSBSZXF1aXJlbWVudHM8L2g0PlxyXG5XZSBub3JtYWxseSByZXF1aXJlIFVTIGFwcGxpY2FudHMgdG8gaG9sZCBhIGNvbWJpbmF0aW9uIG9mIHRoZSBmb2xsb3dpbmcgcXVhbGlmaWNhdGlvbnMgZm9yIGVudHJ5OiBhcyBhIG1pbmltdW0sIGFwcGxpY2FudHMgbXVzdCBob2xkIGFuIGFjY3JlZGl0ZWQgaGlnaCBzY2hvb2wgZGlwbG9tYSB3aXRoIGEgbWluaW11bSBHUEEgb2YgMy4wIChvbiBhIDQuMCBzY2FsZSwgbWluaW11bSBCIGF2ZXJhZ2UpLCBhbmQgb25lIGxldHRlciBvZiByZWZlcmVuY2UuXHJcblxyXG5JZiBzdWJtaXR0aW5nIHRlc3Qgc2NvcmVzLCB3ZSBhc2sgZm9yIGFueSBvZiB0aGUgZm9sbG93aW5nOlxyXG48dWw+XHJcbiBcdDxsaT5BQ1QgY29tcG9zaXRlIHNjb3JlIG9mIDI2IG9yIGFib3ZlICh3aXRoIG5vIGluZGl2aWR1YWwgc2VjdGlvbiBiZWxvdyAyNCk8L2xpPlxyXG4gXHQ8bGk+U0FUIChyZWFkaW5nICsgbWF0aGVtYXRpY3MpIGNvbWJpbmVkIHNjb3JlIG9mIDEyMDAgKHdpdGggbm8gaW5kaXZpZHVhbCBzY29yZSB1bmRlciA1NTApOyBvciBTQVQgc3ViamVjdHMgdGVzdHMgYXQgYSBzY29yZSBvZiA2MDAgb3IgaGlnaGVyPC9saT5cclxuIFx0PGxpPlR3byBBUCB0ZXN0cyBhdCBncmFkZSA0IG9yIGFib3ZlICh0YWtlbiBpbiBqdW5pb3Igb3Igc2VuaW9yIHllYXIgb2YgaGlnaCBzY2hvb2wpPC9saT5cclxuPC91bD5cclxuSWYgc3RhbmRhcmRpc2VkIHRlc3Qgc2NvcmVzIGFyZSB1bmF2YWlsYWJsZSwgb3VyIGFkbWlzc2lvbnMgdGVhbSB3aWxsIHJldmlldyB5b3VyIGhpZ2ggc2Nob29sIHRyYW5zY3JpcHQgYW5kIGxvb2sgZm9yIHN0cm9uZyBhY2FkZW1pYyBwZXJmb3JtYW5jZSBvdmVyYWxsIGFuZCBpbiByZWxhdGVkIHN1YmplY3RzLlxyXG5cclxuVGhlc2UgZW50cnkgcmVxdWlyZW1lbnRzIGFyZSBtZWFudCB0byBzZXJ2ZSBhcyBhIGd1aWRlIGFuZCBkbyBub3QgZ3VhcmFudGVlIGVudHJ5IG9udG8gYSBIZXJpb3QtV2F0dCBVbml2ZXJzaXR5IGRlZ3JlZSBwcm9ncmFtbWUuXHJcblxyXG48YSB0YWJpbmRleD1cIjBcIj5WaWV3IEFsbCBVbmRlcmdyYWR1YXRlIE1ham9yczwvYT5cclxuPGEgaHJlZj1cImh0dHBzOi8vd3d3Lmh3LmFjLnVrL3N0dWR5L2FwcGx5L3VrL3VuZGVyZ3JhZHVhdGUuaHRtXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5cclxuTW9yZSBJbmZvIG9uIFVuZGVyZ3JhZHVhdGUgRGVncmVlc1xyXG48L2E+XHJcbjxoMz5HcmFkdWF0ZSBJbmZvcm1hdGlvbjwvaDM+XHJcbjxoND5VUyBFbnRyeSBSZXF1aXJlbWVudHM8L2g0PlxyXG5Gb3IgbW9zdCBvZiBvdXIgbWFzdGVycy1sZXZlbCBwcm9ncmFtbWVzLCB3ZSByZXF1aXJlIGEgZ29vZCBmaXJzdCBkZWdyZWUgd2l0aCBhIEdQQSBvZiAzLjAgb3V0IG9mIDQuMCAob3IgZXF1aXZhbGVudCkgb3IgYWJvdmUgaW4gYSByZWxldmFudCBzdWJqZWN0LlxyXG5cclxuRm9yIFBoRCBzdHVkeSwgYSBtYXN0ZXJzLWxldmVsIHF1YWxpZmljYXRpb24gZnJvbSBhIGdvb2QgdW5pdmVyc2l0eSBpcyBub3JtYWxseSByZXF1aXJlZC4gQXBwbGljYW50cyBzaG91bGQgYWxzbyBkZW1vbnN0cmF0ZSBzb21lIGZvcm0gb2YgcmVzZWFyY2ggZXhwZXJpZW5jZS5cclxuXHJcbjxhIHRhYmluZGV4PVwiMFwiPlZpZXcgQWxsIEdyYWR1YXRlIE1ham9yczwvYT5cclxuPGEgaHJlZj1cImh0dHBzOi8vd3d3Lmh3LmFjLnVrL3N0dWR5L2FwcGx5L3VrL3Bvc3RncmFkdWF0ZS5odG1cIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPlxyXG5Nb3JlIEluZm8gb24gR3JhZHVhdGUgRGVncmVlc1xyXG48L2E+XHJcbjxoMz5Tb2NpYWwgTWVkaWE8L2gzPlxyXG48YSBocmVmPVwiaHR0cHM6Ly93d3cuZmFjZWJvb2suY29tL0hlcmlvdFdhdHRVbmkvXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5cclxuRmFjZWJvb2tcclxuPC9hPlxyXG48YSBocmVmPVwiaHR0cHM6Ly94LmNvbS9IZXJpb3RXYXR0VW5pP3JlZl9zcmM9dHdzcmMlNUVnb29nbGUlN0N0d2NhbXAlNUVzZXJwJTdDdHdnciU1RWF1dGhvclwiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+XHJcblR3aXR0ZXJcclxuPC9hPlxyXG48YSBocmVmPVwiaHR0cHM6Ly93d3cuaW5zdGFncmFtLmNvbS9oZXJpb3R3YXR0dW5pLz9obD1lblwiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+XHJcbkluc3RhZ3JhbVxyXG48L2E+XHJcbjxhIGhyZWY9XCJodHRwczovL3d3dy55b3V0dWJlLmNvbS9ASGVyaW90V2F0dFVuaVwiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+XHJcbllvdXR1YmVcclxuPC9hPlxyXG48aDM+QWRkaXRpb25hbCBVbml2ZXJzaXR5IExpbmtzPC9oMz5cclxuPHVsPlxyXG4gXHQ8bGk+PGEgaHJlZj1cImh0dHBzOi8vd3d3Lmh3LmFjLnVrXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5cclxuSG9tZSBQYWdlXHJcbjwvYT48L2xpPlxyXG4gXHQ8bGk+PGEgaHJlZj1cImh0dHBzOi8vd3d3Lmh3LmFjLnVrL3N0dWR5L2ludGVybmF0aW9uYWwtc3R1ZGVudHMuaHRtXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5cclxuVVNBL0ludGVybmF0aW9uYWwgUGFnZVxyXG48L2E+PC9saT5cclxuIFx0PGxpPjxhIGhyZWY9XCJodHRwczovL3d3dy5ody5hYy51ay9zdHVkeS9mZWVzLWFuZC1mdW5kaW5nL3R1aXRpb24tZmVlc1wiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+XHJcbkludGVybmF0aW9uYWwgVHVpdGlvblxyXG48L2E+PC9saT5cclxuIFx0PGxpPjxhIGhyZWY9XCJodHRwczovL3d3dy5ody5hYy51ay9zdHVkeS9mZWVzLWFuZC1mdW5kaW5nL3NjaG9sYXJzaGlwcy1hbmQtYnVyc2FyaWVzXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5cclxuU2Nob2xhcnNoaXBzXHJcbjwvYT48L2xpPlxyXG4gXHQ8bGk+PGEgaHJlZj1cImh0dHBzOi8vd3d3Lmh3LmFjLnVrL3N0dWR5L2ZlZXMtYW5kLWZ1bmRpbmcvZmluYW5jaWFsLXN1cHBvcnQvdXMtZmVkZXJhbC1sb2Fuc1wiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+XHJcbkZBRlNBXHJcbjwvYT48L2xpPlxyXG48L3VsPlxyXG48dWw+XHJcbiBcdDxsaT48YSBocmVmPVwiaHR0cHM6Ly93d3cuaHcuYWMudWsvdmlzaXQtdXMvb25saW5lLWV2ZW50cy1hbmQtd2ViaW5hcnNcIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPlxyXG5WaXJ0dWFsIEV2ZW50c1xyXG48L2E+PC9saT5cclxuIFx0PGxpPjxhIGhyZWY9XCJodHRwczovL3d3dy5ody5hYy51ay9yZXNlYXJjaC5odG1cIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPlxyXG5SZXNlYXJjaFxyXG48L2E+PC9saT5cclxuIFx0PGxpPjxhIGhyZWY9XCJodHRwczovL3d3dy5ody5hYy51ay91ay9lZGluYnVyZ2gvYWNjb21tb2RhdGlvbi5odG1cIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPlxyXG5Ib3VzaW5nL0FjY29tbW9kYXRpb25cclxuPC9hPjwvbGk+XHJcbiBcdDxsaT48YSBocmVmPVwiaHR0cHM6Ly93d3cuaHcuYWMudWsvdWsvc3R1ZGVudHMvY2FyZWVycy5odG1cIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPlxyXG5DYXJlZXJzIE9mZmljZVxyXG48L2E+PC9saT5cclxuIFx0PGxpPjxhIGhyZWY9XCJodHRwczovL3d3dy5od3VuaW9uLmNvbS9nZXQtaW52b2x2ZWQvc29jaWV0aWVzL1wiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+XHJcbkNsdWJzL1NvY2lldGllc1xyXG48L2E+PC9saT5cclxuPC91bD5cclxuPGEgaHJlZj1cImh0dHBzOi8vd3d3Lmh3LmFjLnVrL3N0dWR5L2hvdy10by1hcHBseS5odG1cIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPlxyXG5BUFBMWSBOT1dcclxuPC9hPlxyXG48aDM+UkVRVUVTVCBNT1JFIElORk9STUFUSU9OPC9oMz5cclxuW2NvbnRhY3QtZm9ybS03IGlkPVwiMzA4MFwiIHRpdGxlPVwiVW5pdmVyc2l0eSBvZiBMaW5jb2xuXCJdIiwicG9zdF90aXRsZSI6IkhlcmlvdC1XYXR0IFVuaXZlcnNpdHkiLCJwb3N0X2xpbmsiOiJodHRwczovL3RoZXVrc3R1ZHlleHBlcnQuY29tL3VuaXZlcnNpdGllcy9oZXJpb3Qtd2F0dC11bml2ZXJzaXR5LyIsInBvc3RfZmVhdHVyZWRfaW1hZ2UiOiI8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIkhlcmlvdCBXYXR0IFVuaXZlcnNpdHlcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjE1OFwiIHNyYz1cImh0dHBzOi8vdGhldWtzdHVkeWV4cGVydC5jb20vd3AtY29udGVudC91cGxvYWRzLzIwMjQvMTIvSGVyaW90LVdhdHQtbG9nby0zMDB4MTU4LnBuZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6IlVuaXZlcnNpdGllcyIsInBvc3RfdGFncyI6IkJ1c2luZXNzIEVjb25vbWljcywgQ3JlYXRpdmVwZXJmb3JtaW5nIEFydHMgRGVzaWduLCBFbmdpbmVlcmluZywgSHVtYW5pdGllcywgU29jaWFsIFNjaWVuY2UsIFRlY2hub2xvZ3kgQ29tcHV0ZXIgU2NpZW5jZSIsIiVfY3VzdG9tX3ByaW9yaXR5X21ldGFfa2V5JSI6IjQiLCJ0YXhvbm9teT1jYXRlZ29yeSI6IlVuaXZlcnNpdGllcyIsInRheG9ub215PXBvc3RfdGFnIjoiQnVzaW5lc3MgRWNvbm9taWNzLCBDcmVhdGl2ZXBlcmZvcm1pbmcgQXJ0cyBEZXNpZ24sIEVuZ2luZWVyaW5nLCBIdW1hbml0aWVzLCBTb2NpYWwgU2NpZW5jZSwgVGVjaG5vbG9neSBDb21wdXRlciBTY2llbmNlIiwiY2l0eV9jb3VudHJ5IjoiRWRpbmJ1cmdoLCBTY290bGFuZCJ9LCJpY29uIjoiaHR0cHM6Ly90aGV1a3N0dWR5ZXhwZXJ0LmNvbS93cC1jb250ZW50L3VwbG9hZHMvMjAyNC8wMi9Vbml2ZXJzaXR5LU1hcC1QaW4tMi5wbmcifSwiaWQiOjE4MDczLCJpbmZvd2luZG93X2Rpc2FibGUiOmZhbHNlLCJjYXRlZ29yaWVzIjpbeyJpY29uIjoiaHR0cHM6Ly90aGV1a3N0dWR5ZXhwZXJ0LmNvbS93cC1jb250ZW50L3VwbG9hZHMvMjAyNC8wMi9Vbml2ZXJzaXR5LU1hcC1QaW4tMi5wbmciLCJuYW1lIjoiVW5pdmVyc2l0eSIsImlkIjoiMSIsInR5cGUiOiJjYXRlZ29yeSIsImV4dGVuc2lvbl9maWVsZHMiOnsiY2F0X29yZGVyIjoiMSJ9fV19LHsic291cmNlIjoicG9zdCIsInRpdGxlIjoiTGl2ZXJwb29sIEhvcGUgVW5pdmVyc2l0eSIsImluZm93aW5kb3dfY29udGVudCI6IjxkaXYgY2xhc3M9XCJmYy1pdGVtLWJveCBmYy1pdGVtLW5vLXBhZGRpbmdcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiTGl2ZXJwb29sIEhvcGUgVW5pdmVyc2l0eVwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMTU4XCIgc3JjPVwiaHR0cHM6Ly90aGV1a3N0dWR5ZXhwZXJ0LmNvbS93cC1jb250ZW50L3VwbG9hZHMvMjAyNC8xMi9MSFUtbG9nby0zMDB4MTU4LnBuZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmdcIj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1wYWRkaW5nLWNvbnRlbnRfMjBcIj5cclxuPGEgaHJlZj1cImh0dHBzOi8vdGhldWtzdHVkeWV4cGVydC5jb20vdW5pdmVyc2l0aWVzL2xpdmVycG9vbC1ob3BlLXVuaXZlcnNpdHkvXCIgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLXRleHQtY2VudGVyXCI+TGl2ZXJwb29sIEhvcGUgVW5pdmVyc2l0eTwvYT5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tY29udGVudCBmYy1pdGVtLWJvZHktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZVwiPlxyXG4gICAgICAgICAgICAgICAgTGl2ZXJwb29sIEhvcGUgVW5pdmVyc2l0eSBjb21iaW5lcyB0b3AtcmFua2VkIHN0dWRlbnQgc2F0aXNmYWN0aW9uIHdpdGggYmVhdXRpZnVsIGNhbXB1c2VzIGFuZCB2aWJyYW50IGNpdHkgYWNjZXNzLCB3aXRoIG92ZXIgXHUwMGEzNjAgbWlsbGlvbiBpbnZlc3RlZCBpbiBzdGF0ZS1vZi10aGUtYXJ0IGZhY2lsaXRpZXMgZm9yIGFuIGVucmljaGVkIGxlYXJuaW5nIGVudmlyb25tZW50LlxyXG4gICAgICAgICAgICA8L2Rpdj5cclxuICAgICAgICA8L2Rpdj5cclxuICAgIDwvZGl2PlxyXG48L2Rpdj4iLCJjb250ZW50IjoiTGl2ZXJwb29sIEhvcGUgVW5pdmVyc2l0eSBjb21iaW5lcyB0b3AtcmFua2VkIHN0dWRlbnQgc2F0aXNmYWN0aW9uIHdpdGggYmVhdXRpZnVsIGNhbXB1c2VzIGFuZCB2aWJyYW50IGNpdHkgYWNjZXNzLCB3aXRoIG92ZXIgXHUwMGEzNjAgbWlsbGlvbiBpbnZlc3RlZCBpbiBzdGF0ZS1vZi10aGUtYXJ0IGZhY2lsaXRpZXMgZm9yIGFuIGVucmljaGVkIGxlYXJuaW5nIGVudmlyb25tZW50LiIsImFkZHJlc3MiOiJIb3BlIFBhcmsgU3BvcnRzLCBMaXZlcnBvb2wgTDE2IDlKUSwgVUsiLCJsb2NhdGlvbiI6eyJsYXQiOiI1My4zOTEwMDU3Iiwic3RhdGUiOiJFbmdsYW5kIiwiY291bnRyeSI6IlVuaXRlZCBLaW5nZG9tIiwibG5nIjoiLTIuODg5NjQ3Iiwib25jbGlja19hY3Rpb24iOiJtYXJrZXIiLCJyZWRpcmVjdF9wZXJtYWxpbmsiOiJodHRwczovL3RoZXVrc3R1ZHlleHBlcnQuY29tL3VuaXZlcnNpdGllcy9saXZlcnBvb2wtaG9wZS11bml2ZXJzaXR5LyIsInpvb20iOjUsImV4dHJhX2ZpZWxkcyI6eyJwb3N0X2V4Y2VycHQiOiJMaXZlcnBvb2wgSG9wZSBVbml2ZXJzaXR5IGNvbWJpbmVzIHRvcC1yYW5rZWQgc3R1ZGVudCBzYXRpc2ZhY3Rpb24gd2l0aCBiZWF1dGlmdWwgY2FtcHVzZXMgYW5kIHZpYnJhbnQgY2l0eSBhY2Nlc3MsIHdpdGggb3ZlciBcdTAwYTM2MCBtaWxsaW9uIGludmVzdGVkIGluIHN0YXRlLW9mLXRoZS1hcnQgZmFjaWxpdGllcyBmb3IgYW4gZW5yaWNoZWQgbGVhcm5pbmcgZW52aXJvbm1lbnQuIiwicG9zdF9jb250ZW50IjoiPGZpZ3VyZT48aW1nIHNyYz1cImh0dHBzOi8vdGhldWtzdHVkeWV4cGVydC5jb20vd3AtY29udGVudC91cGxvYWRzLzIwMjQvMTIvVW50aXRsZWQtZGVzaWduLTEwLnBuZ1wiIGFsdD1cIkxpdmVycG9vbCBIb3BlIFVuaXZlcnNpdHlcIiAvPjwvZmlndXJlPlxyXG48ZmlndXJlPjxpbWcgc3JjPVwiaHR0cHM6Ly90aGV1a3N0dWR5ZXhwZXJ0LmNvbS93cC1jb250ZW50L3VwbG9hZHMvMjAyNC8xMi9IQ0EtQnVpbGRpbmdzLnBuZ1wiIGFsdD1cIkxpdmVycG9vbCBIb3BlIFVuaXZlcnNpdHlcIiAvPjwvZmlndXJlPlxyXG48ZmlndXJlPjxpbWcgc3JjPVwiaHR0cHM6Ly90aGV1a3N0dWR5ZXhwZXJ0LmNvbS93cC1jb250ZW50L3VwbG9hZHMvMjAyNC8xMi9MaWJyYXJ5LWFuZC1TdHVkeS1TcGFjZS5wbmdcIiBhbHQ9XCJMaXZlcnBvb2wgSG9wZSBVbml2ZXJzaXR5XCIgLz48L2ZpZ3VyZT5cclxuPGZpZ3VyZT48aW1nIHNyYz1cImh0dHBzOi8vdGhldWtzdHVkeWV4cGVydC5jb20vd3AtY29udGVudC91cGxvYWRzLzIwMjQvMTIvU3R1ZGVudHMtYXQtQ3JlYXRpdmUtQ2FtcHVzLnBuZ1wiIGFsdD1cIkxpdmVycG9vbCBIb3BlIFVuaXZlcnNpdHlcIiAvPjwvZmlndXJlPlxyXG48ZmlndXJlPjxpbWcgc3JjPVwiaHR0cHM6Ly90aGV1a3N0dWR5ZXhwZXJ0LmNvbS93cC1jb250ZW50L3VwbG9hZHMvMjAyNC8xMi9UaHJlZS1HcmFjZXMtYXQtTGl2ZXJwb29sLnBuZ1wiIGFsdD1cIkxpdmVycG9vbCBIb3BlIFVuaXZlcnNpdHlcIiAvPjwvZmlndXJlPlxyXG48ZmlndXJlPjxpbWcgc3JjPVwiaHR0cHM6Ly90aGV1a3N0dWR5ZXhwZXJ0LmNvbS93cC1jb250ZW50L3VwbG9hZHMvMjAyNC8xMi9Xb3JsZC1NdXNldW0tYW5kLVdhbGtlci1BcnQtR2FsbGVyeS5wbmdcIiBhbHQ9XCJMaXZlcnBvb2wgSG9wZSBVbml2ZXJzaXR5XCIgLz48L2ZpZ3VyZT5cclxuPGEgaHJlZj1cIiNjb250YWN0LWZvcm1cIj5cclxuQ29udGFjdCBMaXZlcnBvb2wgSG9wZSBVbml2ZXJzaXR5XHJcbjwvYT5cclxuXHJcbjxzdHJvbmc+TG9jYXRpb246XHUwMGEwPC9zdHJvbmc+SG9wZSBQYXJrLCBUYWdnYXJ0IEF2ZW51ZSwgQ2hpbGR3YWxsLCBMaXZlcnBvb2wsIE1lcnNleXNpZGUsIEwzIDlQQVxyXG5cclxuPHN0cm9uZz5XZWJzaXRlOjwvc3Ryb25nPiA8YSBocmVmPVwiaHR0cHM6Ly93d3cuaG9wZS5hYy51ay9cIj5odHRwczovL3d3dy5ob3BlLmFjLnVrLzwvYT5cclxuPGgzPk92ZXJ2aWV3PC9oMz5cclxuU3R1ZGVudHMgYXQgTGl2ZXJwb29sIEhvcGUgVW5pdmVyc2l0eSBoYXZlIHRoZSBiZXN0IG9mIGJvdGggd29ybGRzOyBsaXZpbmcgYW5kIHN0dWR5aW5nIG9uIGZyaWVuZGx5LCBiZWF1dGlmdWwgY2FtcHVzZXMgd2hpbGUgYWxzbyBoYXZpbmcgdGhlIGFkdmFudGFnZSBvZiBiZWluZyBhIGJ1cyByaWRlIGF3YXkgZnJvbSBvbmUgb2YgRXVyb3BlXHUyMDE5cyBtb3N0IHZpYnJhbnQgYW5kIGN1bHR1cmFsbHkgcmljaCBjaXRpZXMuXHJcblxyXG5EYXRpbmcgYmFjayB0byAxODQ0LCBvdXIgc3R1ZGVudHMgYWx3YXlzIGJlbmVmaXQgZnJvbSBhIGhpZ2gtcXVhbGl0eSB0ZWFjaGluZyBhbmQgcmVzZWFyY2ggZW52aXJvbm1lbnQuIEluIDIwMjMsIHdlIHdlcmUgcHJvdWQgdG8gYmUgYXdhcmRlZCBTaWx2ZXIgaW4gdGhlIEdvdmVybm1lbnRcdTIwMTlzIFRlYWNoaW5nIEV4Y2VsbGVuY2UgRnJhbWV3b3JrIChURUYpLlxyXG5cclxuTGl2ZXJwb29sIEhvcGUgVW5pdmVyc2l0eSBpcyBzcHJlYWQgYWNyb3NzIHR3byBiZWF1dGlmdWxseSBsYW5kc2NhcGVkIHNpdGVzLiBIb3BlIFBhcmsgaXMgbG9jYXRlZCBpbiB0aGUgbGVhZnkgc3VidXJicyBvZiBMaXZlcnBvb2wsIHdoaWxlIG91ciBDcmVhdGl2ZSBDYW1wdXMgc2l0cyBhIHN0b25lXHUyMDE5cyB0aHJvdyBhd2F5IGZyb20gTGl2ZXJwb29sJ3MgY3JlYXRpdmUgYW5kIGN1bHR1cmFsIGh1YnMgYW5kIHRoZSBidXp6IG9mIGEgYnVzeSBjaXR5IGNlbnRyZS4gV2UgaGF2ZSBpbnZlc3RlZCBtb3JlIHRoYW4gXHUwMGEzNjAgbWlsbGlvbiBpbiBuZXcgdW5pdmVyc2l0eSBidWlsZGluZ3MgYW5kIGZhY2lsaXRpZXMgdG8gc3VwcG9ydCB0aGUgY3JlYXRpb24gb2YgYW4gZW5yaWNoZWQgbGVhcm5pbmcgZW52aXJvbm1lbnQuXHJcblxyXG5PdXIgc3R1ZGVudHMgYXJlIGF0IHRoZSBoZWFydCBvZiBvdXIgdW5pdmVyc2l0eSwgZGVtb25zdHJhdGVkIGJ5IG91ciBUb3AgMyByYW5raW5nIGZvciBTdHVkZW50IFNhdGlzZmFjdGlvbiBpbiB0aGUgTm9ydGggV2VzdC4gKENvbXBsZXRlIFVuaXZlcnNpdHkgR3VpZGUgMjAyNClcclxuTGl2ZXJwb29sLCBhIGNpdHkgbGlrZSBubyBvdGhlciwgYm9hc3RzIHdvcmxkLWZhbW91cyBhcmNoaXRlY3R1cmUsIG1hZ25pZmljZW50IG11c2V1bXMsIGFuZCBhIHJpY2ggbXVzaWNhbCBoZXJpdGFnZSB0aGF0IGhhcyBzaGFwZWQgcG9wdWxhciBjdWx0dXJlLiBUaGlzIHZpYnJhbnQgaHViIG9mIGNyZWF0aXZpdHkgaG9zdHMgc3BlY3RhY3VsYXIgZmVzdGl2YWxzLCB0aHJpbGxpbmcgc3BvcnRpbmcgZXZlbnRzLCBhbmQgdW5pcXVlIGFydCwgY29uc2lzdGVudGx5IGRyYXdpbmcgbWlsbGlvbnMgb2YgdmlzaXRvcnMgZWFjaCB5ZWFyLiBJdCdzIG5vIHdvbmRlciB0aGF0IExpdmVycG9vbCB3YXMgcmVjb2duaXplZCBhcyBvbmUgb2YgQnJpdGFpbidzIHRvcCB0cmF2ZWwgZGVzdGluYXRpb25zIChUZWxlZ3JhcGgsIDIwMTgpLlxyXG5cclxuPHN0cm9uZz5Qb3B1bGF0aW9uOiA8L3N0cm9uZz41LDI2MVxyXG5cclxuPHN0cm9uZz5DYW1wdXMgVHlwZTogPC9zdHJvbmc+U3VidXJiYW5cclxuPGgzPlF1aWNrIEZhY3RzPC9oMz5cclxuPHVsPlxyXG4gXHQ8bGk+UmFua2VkIDV0aCBpbiB0aGUgVUsgZm9yIFN0dWRlbnQgU2F0aXNmYWN0aW9uIChUaW1lcyBIaWdoZXIgRWR1Y2F0aW9uIGFuYWx5c2lzIG9mIHRoZSBOYXRpb25hbCBTdHVkZW50IFN1cnZleSAyMDI0KTwvbGk+XHJcbiBcdDxsaT5SYW5rZWQgMXN0IGluIHRoZSBOb3J0aCBXZXN0IGZvciBFZHVjYXRpb24gKFRoZSBHdWFyZGlhbiBVbml2ZXJzaXR5IEd1aWRlIDIwMjQpPC9saT5cclxuIFx0PGxpPlJhbmtlZCAzcmQgaW4gdGhlIE5vcnRoIFdlc3QgYW5kIGpvaW50IDI3dGggaW4gdGhlIFVLIGZvciBTdHVkZW50IFNhdGlzZmFjdGlvbiAoVGhlIENvbXBsZXRlIFVuaXZlcnNpdHkgR3VpZGUgMjAyNCk8L2xpPlxyXG48L3VsPlxyXG48aDM+VmlkZW9zPC9oMz5cclxuaHR0cHM6Ly93d3cueW91dHViZS5jb20vd2F0Y2g/dj1xZGllTUNCbFBlOCZhbXA7dD04c2h0dHBzOi8vd3d3LnlvdXR1YmUuY29tL3dhdGNoP3Y9R09GeFZ1WXlucU0mYW1wO3Q9MzRzaHR0cHM6Ly93d3cueW91dHViZS5jb20vd2F0Y2g/dj1kZ1JoUUd6aDlZZ2h0dHBzOi8vd3d3LnlvdXR1YmUuY29tL3dhdGNoP3Y9dmJTdl9wZ2QyOEVodHRwczovL3d3dy55b3V0dWJlLmNvbS93YXRjaD92PURPdW53WHFiaWowXHJcbjxoMz5VbmRlcmdyYWR1YXRlIEluZm9ybWF0aW9uPC9oMz5cclxuPGg0PlVTIEVudHJ5IFJlcXVpcmVtZW50czwvaDQ+XHJcbllvdSBzaG91bGQgaGF2ZSBhIEhpZ2ggU2Nob29sIERpcGxvbWEgKEdyYWRlIDEyKSB3aXRoIGEgR1BBIG9mIDMuMCBvciBhYm92ZVxyXG53aXRoIG9uZSBvZiB0aGUgZm9sbG93aW5nOlxyXG48dWw+XHJcbiBcdDxsaT4zIEFkdmFuY2VkIFBsYWNlbWVudCBFeGFtcyBhdCBncmFkZSAzIG9yIGFib3ZlPC9saT5cclxuIFx0PGxpPkFDVCB3aXRoIG1pbmltdW0gc2NvcmUgb2YgMjY8L2xpPlxyXG4gXHQ8bGk+U0FUUiBzY29yZSBvZiAxMjAwIGluY2x1ZGluZyBhIG1pbmltdW0gb2YgNjAwIGluIFJlYWRpbmcgYW5kIFdyaXRpbmcsIGFuZCA2MDAgaW4gTWF0aHM8L2xpPlxyXG4gXHQ8bGk+QXNzb2NpYXRlIERlZ3JlZSB3aXRoIGEgR1BBIG9mIDMuMDwvbGk+XHJcbjwvdWw+XHJcbldlIHdpbGwgYWxzbyBjb25zaWRlciBvbmUgeWVhcnMgc3R1ZHkgYXQgYW4gQW1lcmljYW4gVW5pdmVyc2l0eS5cclxuXHJcbjxhIHRhYmluZGV4PVwiMFwiPlZpZXcgQWxsIFVuZGVyZ3JhZHVhdGUgTWFqb3JzPC9hPlxyXG48dWw+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5BY2NvdW50aW5nICZhbXA7IEZpbmFuY2U8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QWNjb3VudGluZyAmYW1wOyBGaW5hbmNlICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QWNjb3VudGluZyAmYW1wOyBGaW5hbmNlIGFuZCBCdXNpbmVzcyBNYW5hZ2VtZW50PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkFjY291bnRpbmcgJmFtcDsgRmluYW5jZSBhbmQgQnVzaW5lc3MgTWFuYWdlbWVudCAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkFjY291bnRpbmcgJmFtcDsgRmluYW5jZSBhbmQgQ29tcHV0ZXIgU2NpZW5jZTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5BY2NvdW50aW5nICZhbXA7IEZpbmFuY2UgYW5kIENvbXB1dGVyIFNjaWVuY2UgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5BY2NvdW50aW5nICZhbXA7IEZpbmFuY2UgYW5kIEVjb25vbWljczwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5BY2NvdW50aW5nICZhbXA7IEZpbmFuY2UgYW5kIEVjb25vbWljcyAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkFjY291bnRpbmcgJmFtcDsgRmluYW5jZSBhbmQgSW5mb3JtYXRpb24gVGVjaG5vbG9neTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5BY2NvdW50aW5nICZhbXA7IEZpbmFuY2UgYW5kIEluZm9ybWF0aW9uIFRlY2hub2xvZ3kgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5BY2NvdW50aW5nICZhbXA7IEZpbmFuY2UgYW5kIExhdzwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5BY2NvdW50aW5nIGFuZCBGaW5hbmNlIGFuZCBMYXcgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5BY2NvdW50aW5nICZhbXA7IEZpbmFuY2UgYW5kIE1hdGhlbWF0aWNzPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkFjY291bnRpbmcgJmFtcDsgRmluYW5jZSBhbmQgTWF0aGVtYXRpY3MgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5BY2NvdW50aW5nICZhbXA7IEZpbmFuY2UgYW5kIFNwb3J0ICZhbXA7IFBoeXNpY2FsIEVkdWNhdGlvbjwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5BY2NvdW50aW5nICZhbXA7IEZpbmFuY2UgYW5kIFNwb3J0ICZhbXA7IFBoeXNpY2FsIEVkdWNhdGlvbiAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkFjdGluZyBhbmQgQ29udGVtcG9yYXJ5IEZhc2hpb24gRGVzaWduPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkFjdGluZyBhbmQgQ29udGVtcG9yYXJ5IEZhc2hpb24gRGVzaWduICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QWN0aW5nIGFuZCBDcmVhdGl2ZSBXcml0aW5nPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkFjdGluZyBhbmQgQ3JlYXRpdmUgV3JpdGluZyAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkFjdGluZyBhbmQgRGlnaXRhbCBDcmVhdGl2aXR5PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkFjdGluZyBhbmQgRGlnaXRhbCBDcmVhdGl2aXR5ICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QWN0aW5nIGFuZCBEcmFtYTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5BY3RpbmcgYW5kIERyYW1hICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QWN0aW5nIGFuZCBFZHVjYXRpb248L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QWN0aW5nIGFuZCBFZHVjYXRpb24gKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5BY3RpbmcgYW5kIEVuZ2xpc2ggTGFuZ3VhZ2U8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QWN0aW5nIGFuZCBFbmdsaXNoIExhbmd1YWdlICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QWN0aW5nIGFuZCBGaWxtICZhbXA7IFZpc3VhbCBDdWx0dXJlPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkFjdGluZyBhbmQgRmlsbSAmYW1wOyBWaXN1YWwgQ3VsdHVyZSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkFjdGluZyBhbmQgSW50ZXJuYXRpb25hbCBSZWxhdGlvbnM8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QWN0aW5nIGFuZCBJbnRlcm5hdGlvbmFsIFJlbGF0aW9ucyAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkFjdGluZyBhbmQgTWVkaWEgJmFtcDsgQ29tbXVuaWNhdGlvbjwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5BY3RpbmcgYW5kIE1lZGlhICZhbXA7IENvbW11bmljYXRpb24gKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5BY3RpbmcgYW5kIE11c2ljPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkFjdGluZyBhbmQgTXVzaWMgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5BY3RpbmcgYW5kIE11c2ljYWwgVGhlYXRyZTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5BY3RpbmcgYW5kIE11c2ljYWwgVGhlYXRyZSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkFjdGluZyBhbmQgUGhpbG9zb3BoeSAmYW1wOyBFdGhpY3M8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QWN0aW5nIGFuZCBQaGlsb3NvcGh5ICZhbXA7IEV0aGljcyAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkFjdGluZyBhbmQgUG9saXRpY3M8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QWN0aW5nIGFuZCBQb2xpdGljcyAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkFjdGluZyBhbmQgUHN5Y2hvbG9neTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5BY3RpbmcgYW5kIFBzeWNob2xvZ3kgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5BY3RpbmcgYW5kIFNvY2lvbG9neTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5BY3RpbmcgYW5kIFNvY2lvbG9neSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkFydCBIaXN0b3J5IGFuZCBTb2Npb2xvZ3k8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QXJ0IEhpc3RvcnkgYW5kIEJ1c2luZXNzIE1hbmFnZW1lbnQ8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QXJ0IEhpc3RvcnkgYW5kIENvbnRlbXBvcmFyeSBDcmFmdDwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5BcnQgSGlzdG9yeSBhbmQgQ29udGVtcG9yYXJ5IEZhc2hpb24gRGVzaWduPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkFydCBIaXN0b3J5IGFuZCBDcmVhdGl2ZSBJbmR1c3RyaWVzIEJ1c2luZXNzIE1hbmFnZW1lbnQ8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QXJ0IEhpc3RvcnkgYW5kIENyZWF0aXZlIFdyaXRpbmc8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QXJ0IEhpc3RvcnkgYW5kIEVhcmx5IENoaWxkaG9vZDwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5BcnQgSGlzdG9yeSBhbmQgRWR1Y2F0aW9uPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkFydCBIaXN0b3J5IGFuZCBGaWxtICZhbXA7IFZpc3VhbCBDdWx0dXJlPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkFydCBIaXN0b3J5IGFuZCBNZWRpYSAmYW1wOyBDb21tdW5pY2F0aW9uPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkFydCBIaXN0b3J5IGFuZCBQaGlsb3NvcGh5ICZhbXA7IEV0aGljczwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5BcnQgSGlzdG9yeSBhbmQgUHN5Y2hvbG9neTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5BcnQgSGlzdG9yeSBhbmQgUmVsaWdpb24sIFRoZW9sb2d5ICZhbXA7IFNwaXJpdHVhbGl0eTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5BcnRpZmljaWFsIEludGVsbGlnZW5jZTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5BcnRpZmljaWFsIEludGVsbGlnZW5jZSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkFydGlmaWNpYWwgSW50ZWxsaWdlbmNlICh3aXRoIFllYXIgaW4gSW5kdXN0cnkpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkFydHMgJmFtcDsgV2VsbGJlaW5nPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkJ1c2luZXNzIE1hbmFnZW1lbnQ8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QnVzaW5lc3MgTWFuYWdlbWVudCAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkJ1c2luZXNzIE1hbmFnZW1lbnQgYW5kIENoaWxkaG9vZCAmYW1wOyBZb3V0aDwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5CdXNpbmVzcyBNYW5hZ2VtZW50IGFuZCBDaGlsZGhvb2QgJmFtcDsgWW91dGggKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5CdXNpbmVzcyBNYW5hZ2VtZW50IGFuZCBDb21wdXRlciBTY2llbmNlPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkJ1c2luZXNzIE1hbmFnZW1lbnQgYW5kIENvbXB1dGVyIFNjaWVuY2UgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5CdXNpbmVzcyBNYW5hZ2VtZW50IGFuZCBEYW5jZTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5CdXNpbmVzcyBNYW5hZ2VtZW50IGFuZCBEYW5jZSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkJ1c2luZXNzIE1hbmFnZW1lbnQgYW5kIERpZ2l0YWwgTWFya2V0aW5nPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkJ1c2luZXNzIE1hbmFnZW1lbnQgYW5kIERpZ2l0YWwgTWFya2V0aW5nICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QnVzaW5lc3MgTWFuYWdlbWVudCBhbmQgRWNvbm9taWNzPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkJ1c2luZXNzIE1hbmFnZW1lbnQgYW5kIEVjb25vbWljcyAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkJ1c2luZXNzIE1hbmFnZW1lbnQgYW5kIEZpbG0gJmFtcDsgVmlzdWFsIEN1bHR1cmU8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QnVzaW5lc3MgTWFuYWdlbWVudCBhbmQgRmlsbSAmYW1wOyBWaXN1YWwgQ3VsdHVyZSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkJ1c2luZXNzIE1hbmFnZW1lbnQgYW5kIEZvb2QgJmFtcDsgTnV0cml0aW9uYWwgU2NpZW5jZXM8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QnVzaW5lc3MgTWFuYWdlbWVudCBhbmQgRm9vZCAmYW1wOyBOdXRyaXRpb25hbCBTY2llbmNlcyAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkJ1c2luZXNzIE1hbmFnZW1lbnQgYW5kIEdlb2dyYXBoeTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5CdXNpbmVzcyBNYW5hZ2VtZW50IGFuZCBHZW9ncmFwaHkgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5CdXNpbmVzcyBNYW5hZ2VtZW50IGFuZCBIaXN0b3J5PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkJ1c2luZXNzIE1hbmFnZW1lbnQgYW5kIEhpc3RvcnkgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5CdXNpbmVzcyBNYW5hZ2VtZW50IGFuZCBIdW1hbiBHZW9ncmFwaHk8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QnVzaW5lc3MgTWFuYWdlbWVudCBhbmQgSHVtYW4gR2VvZ3JhcGh5ICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QnVzaW5lc3MgTWFuYWdlbWVudCBhbmQgSW5mb3JtYXRpb24gVGVjaG5vbG9neTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5CdXNpbmVzcyBNYW5hZ2VtZW50IGFuZCBJbmZvcm1hdGlvbiBUZWNobm9sb2d5ICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QnVzaW5lc3MgTWFuYWdlbWVudCBhbmQgSW50ZXJuYXRpb25hbCBSZWxhdGlvbnM8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QnVzaW5lc3MgTWFuYWdlbWVudCBhbmQgSW50ZXJuYXRpb25hbCBSZWxhdGlvbnMgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5CdXNpbmVzcyBNYW5hZ2VtZW50IGFuZCBMYXc8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QnVzaW5lc3MgTWFuYWdlbWVudCBhbmQgTGF3ICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QnVzaW5lc3MgTWFuYWdlbWVudCBhbmQgTWF0aGVtYXRpY3M8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QnVzaW5lc3MgTWFuYWdlbWVudCBhbmQgTWF0aGVtYXRpY3MgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5CdXNpbmVzcyBNYW5hZ2VtZW50IGFuZCBNdXNpYyBQcm9kdWN0aW9uPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkJ1c2luZXNzIE1hbmFnZW1lbnQgYW5kIE11c2ljIFByb2R1Y3Rpb24gKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5CdXNpbmVzcyBNYW5hZ2VtZW50IGFuZCBNdXNpY2FsIFRoZWF0cmU8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QnVzaW5lc3MgTWFuYWdlbWVudCBhbmQgTXVzaWNhbCBUaGVhdHJlICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QnVzaW5lc3MgTWFuYWdlbWVudCBhbmQgU3BvcnQgJmFtcDsgRXhlcmNpc2UgU2NpZW5jZTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5CdXNpbmVzcyBNYW5hZ2VtZW50IGFuZCBTcG9ydCAmYW1wOyBFeGVyY2lzZSBTY2llbmNlICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QnVzaW5lc3MgTWFuYWdlbWVudCBhbmQgU3BvcnQgJmFtcDsgUGh5c2ljYWwgRWR1Y2F0aW9uPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkJ1c2luZXNzIE1hbmFnZW1lbnQgYW5kIFNwb3J0ICZhbXA7IFBoeXNpY2FsIEVkdWNhdGlvbiAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkJ1c2luZXNzIE1hbmFnZW1lbnQgYW5kIFRvdXJpc208L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QnVzaW5lc3MgTWFuYWdlbWVudCBhbmQgVG91cmlzbSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNoaWxkaG9vZCAmYW1wOyBZb3V0aCBhbmQgQ29udGVtcG9yYXJ5IENyYWZ0PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNoaWxkaG9vZCAmYW1wOyBZb3V0aCBhbmQgQ29udGVtcG9yYXJ5IENyYWZ0ICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q2hpbGRob29kICZhbXA7IFlvdXRoIGFuZCBDcmVhdGl2ZSBXcml0aW5nPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNoaWxkaG9vZCAmYW1wOyBZb3V0aCBhbmQgQ3JlYXRpdmUgV3JpdGluZyAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNoaWxkaG9vZCAmYW1wOyBZb3V0aCBhbmQgRHJhbWE8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q2hpbGRob29kICZhbXA7IFlvdXRoIGFuZCBEcmFtYSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNoaWxkaG9vZCAmYW1wOyBZb3V0aCBhbmQgRWFybHkgQ2hpbGRob29kPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNoaWxkaG9vZCAmYW1wOyBZb3V0aCBhbmQgRWFybHkgQ2hpbGRob29kICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q2hpbGRob29kICZhbXA7IFlvdXRoIGFuZCBFZHVjYXRpb248L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q2hpbGRob29kICZhbXA7IFlvdXRoIGFuZCBFZHVjYXRpb24gKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5DaGlsZGhvb2QgJmFtcDsgWW91dGggYW5kIFBvbGl0aWNzPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNoaWxkaG9vZCAmYW1wOyBZb3V0aCBhbmQgUG9saXRpY3MgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5DaGlsZGhvb2QgJmFtcDsgWW91dGggYW5kIFBzeWNob2xvZ3k8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q2hpbGRob29kICZhbXA7IFlvdXRoIGFuZCBQc3ljaG9sb2d5ICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q2hpbGRob29kICZhbXA7IFlvdXRoIGFuZCBTb2NpYWwgQ2FyZTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5DaGlsZGhvb2QgJmFtcDsgWW91dGggYW5kIFNvY2lhbCBDYXJlICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q2hpbGRob29kICZhbXA7IFlvdXRoIGFuZCBTb2Npb2xvZ3k8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q2hpbGRob29kICZhbXA7IFlvdXRoIGFuZCBTb2Npb2xvZ3kgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5DaGlsZGhvb2QgJmFtcDsgWW91dGggYW5kIFNwb3J0ICZhbXA7IFBoeXNpY2FsIEVkdWNhdGlvbjwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5DaGlsZGhvb2QgJmFtcDsgWW91dGggYW5kIFNwb3J0ICZhbXA7IFBoeXNpY2FsIEVkdWNhdGlvbiAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNoaWxkaG9vZCAmYW1wOyBZb3V0aCBhbmQgUmVsaWdpb24sIFRoZW9sb2d5ICZhbXA7IFNwaXJpdHVhbGl0eTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5DaGlsZGhvb2QgJmFtcDsgWW91dGggYW5kIFJlbGlnaW9uLCBUaGVvbG9neSAmYW1wOyBTcGlyaXR1YWxpdHkgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Db21wdXRlciBTY2llbmNlPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNvbXB1dGVyIFNjaWVuY2UgKHdpdGggRm91bmRhdGlvbiBZZWFyIGFuZCBZZWFyIGluIEluZHVzdHJ5KTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Db21wdXRlciBTY2llbmNlICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q29tcHV0ZXIgU2NpZW5jZSAod2l0aCBZZWFyIGluIEluZHVzdHJ5KTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Db21wdXRlciBTY2llbmNlIGFuZCBDcmVhdGl2ZSBJbmR1c3RyaWVzIEJ1c2luZXNzIE1hbmFnZW1lbnQ8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q29tcHV0ZXIgU2NpZW5jZSBhbmQgQ3JlYXRpdmUgSW5kdXN0cmllcyBCdXNpbmVzcyBNYW5hZ2VtZW50ICh3aXRoIGZvdW5kYXRpb24geWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q29tcHV0ZXIgU2NpZW5jZSBhbmQgQ3JpbWlub2xvZ3k8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q29tcHV0ZXIgU2NpZW5jZSBhbmQgQ3JpbWlub2xvZ3kgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Db21wdXRlciBTY2llbmNlIGFuZCBEaWdpdGFsIE1hcmtldGluZzwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Db21wdXRlciBTY2llbmNlIGFuZCBEaWdpdGFsIE1hcmtldGluZyAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNvbXB1dGVyIFNjaWVuY2UgYW5kIEdlb2dyYXBoeTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Db21wdXRlciBTY2llbmNlIGFuZCBHZW9ncmFwaHkgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Db21wdXRlciBTY2llbmNlIGFuZCBIaXN0b3J5PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNvbXB1dGVyIFNjaWVuY2UgYW5kIEhpc3RvcnkgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Db21wdXRlciBTY2llbmNlIGFuZCBNdXNpYyBQcm9kdWN0aW9uPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNvbXB1dGVyIFNjaWVuY2UgYW5kIE11c2ljIFByb2R1Y3Rpb24gKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Db21wdXRlciBTY2llbmNlIGFuZCBQaGlsb3NvcGh5ICZhbXA7IEV0aGljczwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Db21wdXRlciBTY2llbmNlIGFuZCBQaGlsb3NvcGh5ICZhbXA7IEV0aGljcyAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNvbXB1dGVyIFNjaWVuY2UgYW5kIEdsb2JhbCBQaGlsb3NvcGhpZXMgJmFtcDsgV29ybGR2aWV3czwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Db21wdXRlciBTY2llbmNlIGFuZCBHbG9iYWwgUGhpbG9zb3BoaWVzICZhbXA7IFdvcmxkdmlld3MgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Db25zZXJ2YXRpb24gQmlvbG9neSBhbmQgRGlnaXRhbCBNYXJrZXRpbmc8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q29uc2VydmF0aW9uIEJpb2xvZ3kgYW5kIERpZ2l0YWwgTWFya2V0aW5nICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q29uc2VydmF0aW9uIEJpb2xvZ3kgYW5kIEdlb2dyYXBoeTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Db25zZXJ2YXRpb24gQmlvbG9neSBhbmQgR2VvZ3JhcGh5ICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q29udGVtcG9yYXJ5IENyYWZ0IGFuZCBDb250ZW1wb3JhcnkgRmFzaGlvbiBEZXNpZ248L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q29udGVtcG9yYXJ5IENyYWZ0IGFuZCBDb250ZW1wb3JhcnkgRmFzaGlvbiBEZXNpZ24gKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Db250ZW1wb3JhcnkgQ3JhZnQgYW5kIENyZWF0aXZlIFdyaXRpbmc8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q29udGVtcG9yYXJ5IENyYWZ0IGFuZCBDcmVhdGl2ZSBXcml0aW5nICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q29udGVtcG9yYXJ5IENyYWZ0IGFuZCBEYW5jZTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Db250ZW1wb3JhcnkgQ3JhZnQgYW5kIERhbmNlICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q29udGVtcG9yYXJ5IENyYWZ0IGFuZCBEaWdpdGFsIE1hcmtldGluZzwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Db250ZW1wb3JhcnkgQ3JhZnQgYW5kIERpZ2l0YWwgTWFya2V0aW5nICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q29udGVtcG9yYXJ5IENyYWZ0IGFuZCBFYXJseSBDaGlsZGhvb2Q8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q29udGVtcG9yYXJ5IENyYWZ0IGFuZCBFYXJseSBDaGlsZGhvb2QgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Db250ZW1wb3JhcnkgQ3JhZnQgYW5kIEVuZ2xpc2ggTGFuZ3VhZ2U8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q29udGVtcG9yYXJ5IENyYWZ0IGFuZCBFbmdsaXNoIExhbmd1YWdlICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q29udGVtcG9yYXJ5IENyYWZ0IGFuZCBFbmdsaXNoIExpdGVyYXR1cmU8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q29udGVtcG9yYXJ5IENyYWZ0IGFuZCBFbmdsaXNoIExpdGVyYXR1cmUgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Db250ZW1wb3JhcnkgQ3JhZnQgYW5kIEZpbG0gJmFtcDsgVmlzdWFsIEN1bHR1cmU8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q29udGVtcG9yYXJ5IENyYWZ0IGFuZCBGaWxtICZhbXA7IFZpc3VhbCBDdWx0dXJlICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q29udGVtcG9yYXJ5IENyYWZ0IGFuZCBIZWFsdGggJmFtcDsgV2VsbGJlaW5nPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNvbnRlbXBvcmFyeSBDcmFmdCBhbmQgSGVhbHRoICZhbXA7IFdlbGxiZWluZyAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNvbnRlbXBvcmFyeSBDcmFmdCBhbmQgTXVzaWM8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q29udGVtcG9yYXJ5IENyYWZ0IGFuZCBNdXNpYyAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNvbnRlbXBvcmFyeSBDcmFmdCBhbmQgTXVzaWMgUHJvZHVjdGlvbjwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Db250ZW1wb3JhcnkgQ3JhZnQgYW5kIE11c2ljIFByb2R1Y3Rpb24gKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Db250ZW1wb3JhcnkgQ3JhZnQgYW5kIE11c2ljYWwgVGhlYXRyZTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Db250ZW1wb3JhcnkgQ3JhZnQgYW5kIE11c2ljYWwgVGhlYXRyZSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNvbnRlbXBvcmFyeSBDcmFmdCBhbmQgU3BlY2lhbCBFZHVjYXRpb25hbCBOZWVkczwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Db250ZW1wb3JhcnkgQ3JhZnQgYW5kIFNwZWNpYWwgRWR1Y2F0aW9uYWwgTmVlZHMgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Db250ZW1wb3JhcnkgRmFzaGlvbiBEZXNpZ24gYW5kIENyZWF0aXZlIEluZHVzdHJpZXMgQnVzaW5lc3MgTWFuYWdlbWVudDwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Db250ZW1wb3JhcnkgRmFzaGlvbiBEZXNpZ24gYW5kIENyZWF0aXZlIEluZHVzdHJpZXMgQnVzaW5lc3MgTWFuYWdlbWVudCAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNvbnRlbXBvcmFyeSBGYXNoaW9uIERlc2lnbiBhbmQgRGlnaXRhbCBNYXJrZXRpbmc8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q29udGVtcG9yYXJ5IEZhc2hpb24gRGVzaWduIGFuZCBEaWdpdGFsIE1hcmtldGluZyAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNyZWF0aXZlIEluZHVzdHJpZXMgQnVzaW5lc3MgTWFuYWdlbWVudCBhbmQgQ3JlYXRpdmUgV3JpdGluZzwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5DcmVhdGl2ZSBJbmR1c3RyaWVzIEJ1c2luZXNzIE1hbmFnZW1lbnQgYW5kIENyZWF0aXZlIFdyaXRpbmcgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5DcmVhdGl2ZSBJbmR1c3RyaWVzIEJ1c2luZXNzIE1hbmFnZW1lbnQgYW5kIERhbmNlPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNyZWF0aXZlIEluZHVzdHJpZXMgQnVzaW5lc3MgTWFuYWdlbWVudCBhbmQgRGFuY2UgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5DcmVhdGl2ZSBJbmR1c3RyaWVzIEJ1c2luZXNzIE1hbmFnZW1lbnQgYW5kIEVuZ2xpc2ggTGFuZ3VhZ2U8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q3JlYXRpdmUgSW5kdXN0cmllcyBCdXNpbmVzcyBNYW5hZ2VtZW50IGFuZCBFbmdsaXNoIExhbmd1YWdlICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q3JlYXRpdmUgSW5kdXN0cmllcyBCdXNpbmVzcyBNYW5hZ2VtZW50IGFuZCBFbmdsaXNoIExpdGVyYXR1cmU8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q3JlYXRpdmUgSW5kdXN0cmllcyBCdXNpbmVzcyBNYW5hZ2VtZW50IGFuZCBFbmdsaXNoIExpdGVyYXR1cmUgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5DcmVhdGl2ZSBJbmR1c3RyaWVzIEJ1c2luZXNzIE1hbmFnZW1lbnQgYW5kIEZpbG0gJmFtcDsgVmlzdWFsIEN1bHR1cmU8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q3JlYXRpdmUgSW5kdXN0cmllcyBCdXNpbmVzcyBNYW5hZ2VtZW50IGFuZCBGaWxtICZhbXA7IFZpc3VhbCBDdWx0dXJlICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q3JlYXRpdmUgSW5kdXN0cmllcyBCdXNpbmVzcyBNYW5hZ2VtZW50IGFuZCBNdXNpYzwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5DcmVhdGl2ZSBJbmR1c3RyaWVzIEJ1c2luZXNzIE1hbmFnZW1lbnQgYW5kIE11c2ljICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q3JlYXRpdmUgSW5kdXN0cmllcyBCdXNpbmVzcyBNYW5hZ2VtZW50IGFuZCBNdXNpYyBQcm9kdWN0aW9uPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNyZWF0aXZlIEluZHVzdHJpZXMgQnVzaW5lc3MgTWFuYWdlbWVudCBhbmQgTXVzaWMgUHJvZHVjdGlvbiAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNyZWF0aXZlIEluZHVzdHJpZXMgQnVzaW5lc3MgTWFuYWdlbWVudCBhbmQgTXVzaWNhbCBUaGVhdHJlPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNyZWF0aXZlIEluZHVzdHJpZXMgQnVzaW5lc3MgTWFuYWdlbWVudCBhbmQgTXVzaWNhbCBUaGVhdHJlICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q3JlYXRpdmUgSW5kdXN0cmllcyBCdXNpbmVzcyBNYW5hZ2VtZW50IGFuZCBUb3VyaXNtPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNyZWF0aXZlIEluZHVzdHJpZXMgQnVzaW5lc3MgTWFuYWdlbWVudCBhbmQgVG91cmlzbSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNyZWF0aXZlIFdyaXRpbmcgYW5kIENyaW1pbm9sb2d5PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNyZWF0aXZlIFdyaXRpbmcgYW5kIENyaW1pbm9sb2d5ICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q3JlYXRpdmUgV3JpdGluZyBhbmQgRGFuY2U8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q3JlYXRpdmUgV3JpdGluZyBhbmQgRGFuY2UgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5DcmVhdGl2ZSBXcml0aW5nIGFuZCBEcmFtYTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5DcmVhdGl2ZSBXcml0aW5nIGFuZCBEcmFtYSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNyZWF0aXZlIFdyaXRpbmcgYW5kIEVuZ2xpc2ggTGl0ZXJhdHVyZTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5DcmVhdGl2ZSBXcml0aW5nIGFuZCBFbmdsaXNoIExpdGVyYXR1cmUgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5DcmVhdGl2ZSBXcml0aW5nIGFuZCBHbG9iYWwgUGhpbG9zb3BoeSAmYW1wOyBXb3JsZHZpZXdzPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNyZWF0aXZlIFdyaXRpbmcgYW5kIEdsb2JhbCBQaGlsb3NvcGh5ICZhbXA7IFdvcmxkdmlld3MgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5DcmVhdGl2ZSBXcml0aW5nIGFuZCBIaXN0b3J5PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNyZWF0aXZlIFdyaXRpbmcgYW5kIEhpc3RvcnkgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5DcmVhdGl2ZSBXcml0aW5nIGFuZCBNZWRpYSAmYW1wOyBDb21tdW5pY2F0aW9uPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNyZWF0aXZlIFdyaXRpbmcgYW5kIE1lZGlhICZhbXA7IENvbW11bmljYXRpb24gKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5DcmVhdGl2ZSBXcml0aW5nIGFuZCBQaGlsb3NvcGh5ICZhbXA7IEV0aGljczwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5DcmVhdGl2ZSBXcml0aW5nIGFuZCBQaGlsb3NvcGh5ICZhbXA7IEV0aGljcyAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNyZWF0aXZlIFdyaXRpbmcgYW5kIFBzeWNob2xvZ3k8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q3JlYXRpdmUgV3JpdGluZyBhbmQgUHN5Y2hvbG9neSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNyaW1pbm9sb2d5PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNyaW1pbm9sb2d5ICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q3JpbWlub2xvZ3kgYW5kIERyYW1hPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNyaW1pbm9sb2d5IGFuZCBEcmFtYSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNyaW1pbm9sb2d5IGFuZCBFYXJseSBDaGlsZGhvb2Q8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q3JpbWlub2xvZ3kgYW5kIEVhcmx5IENoaWxkaG9vZCAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNyaW1pbm9sb2d5IGFuZCBFZHVjYXRpb248L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q3JpbWlub2xvZ3kgYW5kIEVkdWNhdGlvbiAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNyaW1pbm9sb2d5IGFuZCBGaWxtICZhbXA7IFZpc3VhbCBDdWx0dXJlPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNyaW1pbm9sb2d5IGFuZCBGaWxtICZhbXA7IFZpc3VhbCBDdWx0dXJlICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q3JpbWlub2xvZ3kgYW5kIEh1bWFuIEJpb2xvZ3k8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q3JpbWlub2xvZ3kgYW5kIEh1bWFuIEJpb2xvZ3kgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5DcmltaW5vbG9neSBhbmQgTGF3PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNyaW1pbm9sb2d5IGFuZCBMYXcgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5DcmltaW5vbG9neSBhbmQgTWVkaWEgJmFtcDsgQ29tbXVuaWNhdGlvbjwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5DcmltaW5vbG9neSBhbmQgTWVkaWEgJmFtcDsgQ29tbXVuaWNhdGlvbiAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNyaW1pbm9sb2d5IGFuZCBNdXNpY2FsIFRoZWF0cmU8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q3JpbWlub2xvZ3kgYW5kIE11c2ljYWwgVGhlYXRyZSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNyaW1pbm9sb2d5IGFuZCBQaGlsb3NvcGh5ICZhbXA7IEV0aGljczwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5DcmltaW5vbG9neSBhbmQgUGhpbG9zb3BoeSAmYW1wOyBFdGhpY3MgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5DcmltaW5vbG9neSBhbmQgUHN5Y2hvbG9neTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5DcmltaW5vbG9neSBhbmQgUHN5Y2hvbG9neSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNyaW1pbm9sb2d5IGFuZCBSZWxpZ2lvbiwgVGhlb2xvZ3kgJmFtcDsgU3Bpcml0dWFsaXR5PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNyaW1pbm9sb2d5IGFuZCBSZWxpZ2lvbiwgVGhlb2xvZ3kgJmFtcDsgU3Bpcml0dWFsaXR5ICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q3JpbWlub2xvZ3kgYW5kIFNvY2lhbCBDYXJlPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNyaW1pbm9sb2d5IGFuZCBTb2NpYWwgQ2FyZSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNyaW1pbm9sb2d5IGFuZCBTb2Npb2xvZ3k8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Q3JpbWlub2xvZ3kgYW5kIFNvY2lvbG9neSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkRhbmNlIGFuZCBEcmFtYTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5EYW5jZSBhbmQgRHJhbWEgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5EYW5jZSBhbmQgRWFybHkgQ2hpbGRob29kPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkRhbmNlIGFuZCBFYXJseSBDaGlsZGhvb2QgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5EYW5jZSBhbmQgRWR1Y2F0aW9uPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkRhbmNlIGFuZCBNdXNpY2FsIFRoZWF0cmU8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RGFuY2UgYW5kIE11c2ljYWwgVGhlYXRyZSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkRhbmNlIGFuZCBQc3ljaG9sb2d5PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkRhbmNlIGFuZCBQc3ljaG9sb2d5ICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RGFuY2UgYW5kIFNwb3J0ICZhbXA7IFBoeXNpY2FsIEVkdWNhdGlvbjwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5EYW5jZSBhbmQgU3BvcnQgJmFtcDsgUGh5c2ljYWwgRWR1Y2F0aW9uICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RGlnaXRhbCBDcmVhdGl2aXR5IGFuZCBEaWdpdGFsIE1hcmtldGluZzwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5EaWdpdGFsIENyZWF0aXZpdHkgYW5kIERpZ2l0YWwgTWFya2V0aW5nICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RGlnaXRhbCBNYXJrZXRpbmcgYW5kIERyYW1hPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkRpZ2l0YWwgTWFya2V0aW5nIGFuZCBEcmFtYSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkRpZ2l0YWwgTWFya2V0aW5nIGFuZCBFYXJseSBDaGlsZGhvb2Q8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RGlnaXRhbCBNYXJrZXRpbmcgYW5kIEVhcmx5IENoaWxkaG9vZCAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkRpZ2l0YWwgTWFya2V0aW5nIGFuZCBFY29ub21pY3M8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RGlnaXRhbCBNYXJrZXRpbmcgYW5kIEVjb25vbWljcyAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkRpZ2l0YWwgTWFya2V0aW5nIGFuZCBFbmdsaXNoIExhbmd1YWdlPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkRpZ2l0YWwgTWFya2V0aW5nIGFuZCBFbmdsaXNoIExhbmd1YWdlICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RGlnaXRhbCBNYXJrZXRpbmcgYW5kIEZpbG0gJmFtcDsgVmlzdWFsIEN1bHR1cmU8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RGlnaXRhbCBNYXJrZXRpbmcgYW5kIEZpbG0gJmFtcDsgVmlzdWFsIEN1bHR1cmUgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5EaWdpdGFsIE1hcmtldGluZyBhbmQgRm9vZCAmYW1wOyBOdXRyaXRpb25hbCBTY2llbmNlczwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5EaWdpdGFsIE1hcmtldGluZyBhbmQgRm9vZCAmYW1wOyBOdXRyaXRpb25hbCBTY2llbmNlcyAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkRpZ2l0YWwgTWFya2V0aW5nIGFuZCBJbmZvcm1hdGlvbiBUZWNobm9sb2d5PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkRpZ2l0YWwgTWFya2V0aW5nIGFuZCBJbmZvcm1hdGlvbiBUZWNobm9sb2d5ICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RGlnaXRhbCBNYXJrZXRpbmcgYW5kIExhdzwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5EaWdpdGFsIE1hcmtldGluZyBhbmQgTGF3ICh3aXRoIEZvdW5kYXRpb24geWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RGlnaXRhbCBNYXJrZXRpbmcgYW5kIE1hdGhlbWF0aWNzPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkRpZ2l0YWwgTWFya2V0aW5nIGFuZCBNYXRoZW1hdGljcyAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkRpZ2l0YWwgTWFya2V0aW5nIGFuZCBNZWRpYSAmYW1wOyBDb21tdW5pY2F0aW9uPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkRpZ2l0YWwgTWFya2V0aW5nIGFuZCBNZWRpYSAmYW1wOyBDb21tdW5pY2F0aW9uICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RGlnaXRhbCBNYXJrZXRpbmcgYW5kIE11c2ljYWwgVGhlYXRyZTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5EaWdpdGFsIE1hcmtldGluZyBhbmQgTXVzaWNhbCBUaGVhdHJlICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RGlnaXRhbCBNYXJrZXRpbmcgYW5kIFBoaWxvc29waHkgJmFtcDsgRXRoaWNzPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkRpZ2l0YWwgTWFya2V0aW5nIGFuZCBQaGlsb3NvcGh5ICZhbXA7IEV0aGljcyAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkRpZ2l0YWwgTWFya2V0aW5nIGFuZCBQb2xpdGljczwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5EaWdpdGFsIE1hcmtldGluZyBhbmQgUG9saXRpY3MgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5EaWdpdGFsIE1hcmtldGluZyBhbmQgUHN5Y2hvbG9neTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5EaWdpdGFsIE1hcmtldGluZyBhbmQgUHN5Y2hvbG9neSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkRpZ2l0YWwgTWFya2V0aW5nIGFuZCBSZWxpZ2lvbiwgVGhlb2xvZ3kgJmFtcDsgU3Bpcml0dWFsaXR5PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkRpZ2l0YWwgTWFya2V0aW5nIGFuZCBSZWxpZ2lvbiwgVGhlb2xvZ3kgJmFtcDsgU3Bpcml0dWFsaXR5ICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RGlnaXRhbCBNYXJrZXRpbmcgYW5kIFNvY2lvbG9neTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5EaWdpdGFsIE1hcmtldGluZyBhbmQgU29jaW9sb2d5ICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RGlnaXRhbCBNYXJrZXRpbmcgYW5kIFNwb3J0ICZhbXA7IFBoeXNpY2FsIEVkdWNhdGlvbiAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkRpZ2l0YWwgTWFya2V0aW5nIGFuZCBTcG9ydCAmYW1wOyBQaHlzaWNhbCBFZHVjYXRpb248L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RHJhbWEgJmFtcDsgVGhlYXRyZTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5EcmFtYSAmYW1wOyBUaGVhdHJlICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RHJhbWEgYW5kIEVuZ2xpc2ggTGFuZ3VhZ2U8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RHJhbWEgYW5kIEVuZ2xpc2ggTGFuZ3VhZ2UgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5EcmFtYSBhbmQgRW5nbGlzaCBMaXRlcmF0dXJlPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkRyYW1hIGFuZCBFbmdsaXNoIExpdGVyYXR1cmUgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5EcmFtYSBhbmQgRmlsbSAmYW1wOyBWaXN1YWwgQ3VsdHVyZTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5EcmFtYSBhbmQgRmlsbSAmYW1wOyBWaXN1YWwgQ3VsdHVyZSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkRyYW1hIGFuZCBIaXN0b3J5PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkRyYW1hIGFuZCBIaXN0b3J5ICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RHJhbWEgYW5kIE11c2ljPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkRyYW1hIGFuZCBNdXNpYyAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkRyYW1hIGFuZCBNdXNpYyBQcm9kdWN0aW9uPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkRyYW1hIGFuZCBNdXNpYyBQcm9kdWN0aW9uICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RHJhbWEgYW5kIE11c2ljYWwgVGhlYXRyZTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5EcmFtYSBhbmQgTXVzaWNhbCBUaGVhdHJlICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RHJhbWEgYW5kIFNvY2lvbG9neTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5EcmFtYSBhbmQgU29jaW9sb2d5ICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RHJhbWEgYW5kIFJlbGlnaW9uLCBUaGVvbG9neSAmYW1wOyBTcGlyaXR1YWxpdHk8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RHJhbWEgYW5kIFJlbGlnaW9uLCBUaGVvbG9neSAmYW1wOyBTcGlyaXR1YWxpdHkgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5FYXJseSBDaGlsZGhvb2Q8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RWFybHkgQ2hpbGRob29kICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RWFybHkgQ2hpbGRob29kIGFuZCBFZHVjYXRpb248L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RWFybHkgQ2hpbGRob29kIGFuZCBFZHVjYXRpb24gKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5FYXJseSBDaGlsZGhvb2QgYW5kIEdsb2JhbCBQaGlsb3NvcGh5ICZhbXA7IFdvcmxkdmlld3M8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RWFybHkgQ2hpbGRob29kIGFuZCBHbG9iYWwgUGhpbG9zb3BoeSAmYW1wOyBXb3JsZHZpZXdzICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RWFybHkgQ2hpbGRob29kIGFuZCBIZWFsdGggJmFtcDsgV2VsbGJlaW5nPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkVhcmx5IENoaWxkaG9vZCBhbmQgSGVhbHRoICZhbXA7IFdlbGxiZWluZyAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkVhcmx5IENoaWxkaG9vZCBhbmQgUHN5Y2hvbG9neTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5FYXJseSBDaGlsZGhvb2QgYW5kIFBzeWNob2xvZ3kgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5FYXJseSBDaGlsZGhvb2QgYW5kIFNvY2lhbCBDYXJlPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkVhcmx5IENoaWxkaG9vZCBhbmQgU29jaWFsIENhcmUgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5FYXJseSBDaGlsZGhvb2QgYW5kIFNwZWNpYWwgRWR1Y2F0aW9uYWwgTmVlZHM8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RWFybHkgQ2hpbGRob29kIGFuZCBTcGVjaWFsIEVkdWNhdGlvbmFsIE5lZWRzICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RWFybHkgRWR1Y2F0aW9uIFByaW1hcnkgKDMtNykgd2l0aCBRVFM8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RWNvbm9taWNzPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkVjb25vbWljcyAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkVjb25vbWljcyBhbmQgSGlzdG9yeTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5FY29ub21pY3MgYW5kIEhpc3RvcnkgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5FY29ub21pY3MgYW5kIFBoaWxvc29waHkgJmFtcDsgRXRoaWNzPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkVjb25vbWljcyBhbmQgUGhpbG9zb3BoeSAmYW1wOyBFdGhpY3MgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5FY29ub21pY3MgYW5kIFBvbGl0aWNzPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkVjb25vbWljcyBhbmQgUG9saXRpY3MgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5FY29ub21pY3MgYW5kIFNwb3J0ICZhbXA7IEV4ZXJjaXNlIFNjaWVuY2U8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RWNvbm9taWNzIGFuZCBTcG9ydCAmYW1wOyBFeGVyY2lzZSBTY2llbmNlICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RWR1Y2F0aW9uPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkVkdWNhdGlvbiAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkVkdWNhdGlvbiBhbmQgRW5nbGlzaCBMYW5ndWFnZTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5FZHVjYXRpb24gYW5kIEVuZ2xpc2ggTGFuZ3VhZ2UgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5FZHVjYXRpb24gYW5kIEVuZ2xpc2ggTGl0ZXJhdHVyZTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5FZHVjYXRpb24gYW5kIEVuZ2xpc2ggTGl0ZXJhdHVyZSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkVkdWNhdGlvbiBhbmQgRm9vZCAmYW1wOyBOdXRyaXRpb25hbCBTY2llbmNlczwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5FZHVjYXRpb24gYW5kIEZvb2QgJmFtcDsgTnV0cml0aW9uYWwgU2NpZW5jZXMgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5FZHVjYXRpb24gYW5kIEdsb2JhbCBQaGlsb3NvcGh5ICZhbXA7IFdvcmxkdmlld3M8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RWR1Y2F0aW9uIGFuZCBHbG9iYWwgUGhpbG9zb3BoeSAmYW1wOyBXb3JsZHZpZXdzICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RWR1Y2F0aW9uIGFuZCBNYXRoZW1hdGljczwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5FZHVjYXRpb24gYW5kIE1hdGhlbWF0aWNzICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RWR1Y2F0aW9uIGFuZCBNdXNpYzwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5FZHVjYXRpb24gYW5kIE11c2ljICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RWR1Y2F0aW9uIGFuZCBNdXNpY2FsIFRoZWF0cmU8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RWR1Y2F0aW9uIGFuZCBNdXNpY2FsIFRoZWF0cmUgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5FZHVjYXRpb24gYW5kIFBzeWNob2xvZ3k8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RWR1Y2F0aW9uIGFuZCBQc3ljaG9sb2d5ICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RWR1Y2F0aW9uIGFuZCBSZWxpZ2lvbiwgVGhlb2xvZ3kgJmFtcDsgU3Bpcml0dWFsaXR5PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkVkdWNhdGlvbiBhbmQgUmVsaWdpb24sIFRoZW9sb2d5ICZhbXA7IFNwaXJpdHVhbGl0eSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkVkdWNhdGlvbiBhbmQgU3BlY2lhbCBFZHVjYXRpb25hbCBOZWVkczwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5FZHVjYXRpb24gYW5kIFNwZWNpYWwgRWR1Y2F0aW9uYWwgTmVlZHMgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5FZHVjYXRpb24gYW5kIFNwb3J0ICZhbXA7IFBoeXNpY2FsIEVkdWNhdGlvbjwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5FZHVjYXRpb24gYW5kIFNwb3J0ICZhbXA7IFBoeXNpY2FsIEVkdWNhdGlvbiAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkVsZWN0cm9uaWMgJmFtcDsgQ29tcHV0ZXIgRW5naW5lZXJpbmc8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RWxlY3Ryb25pYyAmYW1wOyBDb21wdXRlciBFbmdpbmVlcmluZyAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkVsZWN0cm9uaWMgJmFtcDsgQ29tcHV0ZXIgRW5naW5lZXJpbmcgKHdpdGggWWVhciBpbiBJbmR1c3RyeSk8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RW5nbGlzaCBMYW5ndWFnZTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5FbmdsaXNoIExhbmd1YWdlICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RW5nbGlzaCBMYW5ndWFnZSBhbmQgRW5nbGlzaCBMaXRlcmF0dXJlPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkVuZ2xpc2ggTGFuZ3VhZ2UgYW5kIEVuZ2xpc2ggTGl0ZXJhdHVyZSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkVuZ2xpc2ggTGFuZ3VhZ2UgYW5kIEdsb2JhbCBQaGlsb3NvcGh5ICZhbXA7IFdvcmxkdmlld3M8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RW5nbGlzaCBMYW5ndWFnZSBhbmQgR2xvYmFsIFBoaWxvc29waHkgJmFtcDsgV29ybGR2aWV3cyAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkVuZ2xpc2ggTGFuZ3VhZ2UgYW5kIE1lZGlhICZhbXA7IENvbW11bmljYXRpb248L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RW5nbGlzaCBMYW5ndWFnZSBhbmQgTWVkaWEgJmFtcDsgQ29tbXVuaWNhdGlvbiAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkVuZ2xpc2ggTGFuZ3VhZ2UgYW5kIFNwZWNpYWwgRWR1Y2F0aW9uYWwgTmVlZHM8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RW5nbGlzaCBMYW5ndWFnZSBhbmQgU3BlY2lhbCBFZHVjYXRpb25hbCBOZWVkcyAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkVuZ2xpc2ggTGl0ZXJhdHVyZTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5FbmdsaXNoIExpdGVyYXR1cmUgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5FbmdsaXNoIExpdGVyYXR1cmUgYW5kIEZpbG0gJmFtcDsgVmlzdWFsIEN1bHR1cmU8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RW5nbGlzaCBMaXRlcmF0dXJlIGFuZCBGaWxtICZhbXA7IFZpc3VhbCBDdWx0dXJlICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RW5nbGlzaCBMaXRlcmF0dXJlIGFuZCBMYXc8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RW5nbGlzaCBMaXRlcmF0dXJlIGFuZCBMYXcgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5FbmdsaXNoIExpdGVyYXR1cmUgYW5kIE1lZGlhICZhbXA7IENvbW11bmljYXRpb248L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RW5nbGlzaCBMaXRlcmF0dXJlIGFuZCBNZWRpYSAmYW1wOyBDb21tdW5pY2F0aW9uICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RW5nbGlzaCBMaXRlcmF0dXJlIGFuZCBNdXNpYzwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5FbmdsaXNoIExpdGVyYXR1cmUgYW5kIE11c2ljICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RW5nbGlzaCBMaXRlcmF0dXJlIGFuZCBQaGlsb3NvcGh5ICZhbXA7IEV0aGljczwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5FbmdsaXNoIExpdGVyYXR1cmUgYW5kIFBoaWxvc29waHkgJmFtcDsgRXRoaWNzICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RW5nbGlzaCBMaXRlcmF0dXJlIGFuZCBQb2xpdGljczwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5FbmdsaXNoIExpdGVyYXR1cmUgYW5kIFBvbGl0aWNzICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RW5nbGlzaCBMaXRlcmF0dXJlIGFuZCBQc3ljaG9sb2d5PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkVuZ2xpc2ggTGl0ZXJhdHVyZSBhbmQgUHN5Y2hvbG9neSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkVuZ2xpc2ggTGl0ZXJhdHVyZSBhbmQgUmVsaWdpb24sIFRoZW9sb2d5ICZhbXA7IFNwaXJpdHVhbGl0eTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5FbmdsaXNoIExpdGVyYXR1cmUgYW5kIFJlbGlnaW9uLCBUaGVvbG9neSAmYW1wOyBTcGlyaXR1YWxpdHkgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5FbmdsaXNoIExpdGVyYXR1cmUgYW5kIFNvY2lvbG9neTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5FbmdsaXNoIExpdGVyYXR1cmUgYW5kIFNvY2lvbG9neSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkVudmlyb25tZW50YWwgU2NpZW5jZTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5FbnZpcm9ubWVudGFsIFNjaWVuY2UgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5GaWxtICZhbXA7IFZpc3VhbCBDdWx0dXJlIGFuZCBHbG9iYWwgUGhpbG9zb3BoeSAmYW1wOyBXb3JsZHZpZXdzPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkZpbG0gJmFtcDsgVmlzdWFsIEN1bHR1cmUgYW5kIEdsb2JhbCBQaGlsb3NvcGh5ICZhbXA7IFdvcmxkdmlld3MgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5GaWxtICZhbXA7IFZpc3VhbCBDdWx0dXJlIGFuZCBNZWRpYSAmYW1wOyBDb21tdW5pY2F0aW9uPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkZpbG0gJmFtcDsgVmlzdWFsIEN1bHR1cmUgYW5kIE1lZGlhICZhbXA7IENvbW11bmljYXRpb24gKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5GaWxtICZhbXA7IFZpc3VhbCBDdWx0dXJlIGFuZCBNdXNpYyBQcm9kdWN0aW9uPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkZpbG0gJmFtcDsgVmlzdWFsIEN1bHR1cmUgYW5kIE11c2ljIFByb2R1Y3Rpb24gKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5GaWxtICZhbXA7IFZpc3VhbCBDdWx0dXJlIGFuZCBQaGlsb3NvcGh5ICZhbXA7IEV0aGljczwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5GaWxtICZhbXA7IFZpc3VhbCBDdWx0dXJlIGFuZCBQaGlsb3NvcGh5ICZhbXA7IEV0aGljcyAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkZpbG0sIFRWLCBSYWRpbyAmYW1wOyBNZWRpYSBQcm9kdWN0aW9uPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkZpbG0sIFRWLCBSYWRpbyAmYW1wOyBNZWRpYSBQcm9kdWN0aW9uICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RmluZSBBcnQ8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RmluZSBBcnQgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Gb29kICZhbXA7IE51dHJpdGlvbmFsIFNjaWVuY2VzPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkZvb2QgJmFtcDsgTnV0cml0aW9uYWwgU2NpZW5jZXMgYW5kIEhlYWx0aCAmYW1wOyBXZWxsYmVpbmc8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Rm9vZCAmYW1wOyBOdXRyaXRpb25hbCBTY2llbmNlcyBhbmQgSGVhbHRoICZhbXA7IFdlbGxiZWluZyAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkZvb2QgJmFtcDsgTnV0cml0aW9uYWwgU2NpZW5jZXMgYW5kIEh1bWFuIEJpb2xvZ3k8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Rm9vZCAmYW1wOyBOdXRyaXRpb25hbCBTY2llbmNlcyBhbmQgSHVtYW4gQmlvbG9neSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkZvb2QgJmFtcDsgTnV0cml0aW9uYWwgU2NpZW5jZXMgYW5kIE1lZGlhICZhbXA7IENvbW11bmljYXRpb248L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Rm9vZCAmYW1wOyBOdXRyaXRpb25hbCBTY2llbmNlcyBhbmQgTWVkaWEgJmFtcDsgQ29tbXVuaWNhdGlvbiAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkZvb2QgJmFtcDsgTnV0cml0aW9uYWwgU2NpZW5jZXMgYW5kIFBzeWNob2xvZ3k8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Rm9vZCAmYW1wOyBOdXRyaXRpb25hbCBTY2llbmNlcyBhbmQgUHN5Y2hvbG9neSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkZvb2QgJmFtcDsgTnV0cml0aW9uYWwgU2NpZW5jZXMgYW5kIFNwb3J0ICZhbXA7IEV4ZXJjaXNlIFNjaWVuY2U8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Rm9vZCAmYW1wOyBOdXRyaXRpb25hbCBTY2llbmNlcyBhbmQgU3BvcnQgJmFtcDsgRXhlcmNpc2UgU2NpZW5jZSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkdhbWUgQXJ0ICZhbXA7IERlc2lnbjwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5HYW1lIEFydCAmYW1wOyBEZXNpZ24gKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5HZW9ncmFwaHk8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+R2VvZ3JhcGh5ICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+R2VvZ3JhcGh5IGFuZCBSZWxpZ2lvbiwgVGhlb2xvZ3kgJmFtcDsgU3Bpcml0dWFsaXR5PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkdlb2dyYXBoeSBhbmQgUmVsaWdpb24sIFRoZW9sb2d5ICZhbXA7IFNwaXJpdHVhbGl0eSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkdlb2dyYXBoeSBhbmQgU3BvcnQgJmFtcDsgUGh5c2ljYWwgRWR1Y2F0aW9uPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkdlb2dyYXBoeSBhbmQgU3BvcnQgJmFtcDsgUGh5c2ljYWwgRWR1Y2F0aW9uICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+R2xvYmFsIFBoaWxvc29waHkgJmFtcDsgV29ybGR2aWV3cyBhbmQgUHN5Y2hvbG9neSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkdsb2JhbCBQaGlsb3NvcGh5ICZhbXA7IFdvcmxkdmlld3MgYW5kIEludGVybmF0aW9uYWwgUmVsYXRpb25zPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkdsb2JhbCBQaGlsb3NvcGh5ICZhbXA7IFdvcmxkdmlld3MgYW5kIEludGVybmF0aW9uYWwgUmVsYXRpb25zICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+R2xvYmFsIFBoaWxvc29waHkgJmFtcDsgV29ybGR2aWV3cyBhbmQgTWVkaWEgJmFtcDsgQ29tbXVuaWNhdGlvbjwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5HbG9iYWwgUGhpbG9zb3BoeSAmYW1wOyBXb3JsZHZpZXdzIGFuZCBNZWRpYSAmYW1wOyBDb21tdW5pY2F0aW9uICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+R2xvYmFsIFBoaWxvc29waHkgJmFtcDsgV29ybGR2aWV3cyBhbmQgUG9saXRpY3MgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5HbG9iYWwgUGhpbG9zb3BoeSAmYW1wOyBXb3JsZHZpZXdzIGFuZCBQb2xpdGljczwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5HbG9iYWwgUGhpbG9zb3BoeSAmYW1wOyBXb3JsZHZpZXdzIGFuZCBQc3ljaG9sb2d5PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkdsb2JhbCBQaGlsb3NvcGh5ICZhbXA7IFdvcmxkdmlld3MgYW5kIFNvY2lhbCBDYXJlPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkdsb2JhbCBQaGlsb3NvcGh5ICZhbXA7IFdvcmxkdmlld3MgYW5kIFNvY2lhbCBDYXJlICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+R3JhcGhpYyBEZXNpZ248L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+R3JhcGhpYyBEZXNpZ24gKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5IZWFsdGggJmFtcDsgU29jaWFsIENhcmU8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+SGVhbHRoICZhbXA7IFNvY2lhbCBDYXJlICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+SGVhbHRoICZhbXA7IFdlbGxiZWluZyBhbmQgSHVtYW4gQmlvbG9neTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5IZWFsdGggJmFtcDsgV2VsbGJlaW5nIGFuZCBQc3ljaG9sb2d5PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkhlYWx0aCAmYW1wOyBXZWxsYmVpbmcgYW5kIFBzeWNob2xvZ3kgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5IZWFsdGggJmFtcDsgV2VsbGJlaW5nIGFuZCBSZWxpZ2lvbiwgVGhlb2xvZ3kgJmFtcDsgU3Bpcml0dWFsaXR5PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkhlYWx0aCAmYW1wOyB3ZWxsYmVpbmcgYW5kIFJlbGlnaW9uLCBUaGVvbG9neSAmYW1wOyBTcGlyaXR1YWxpdHkgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5IZWFsdGggJmFtcDsgV2VsbGJlaW5nIGFuZCBTb2NpYWwgQ2FyZTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5IZWFsdGggJmFtcDsgV2VsbGJlaW5nIGFuZCBTb2NpYWwgQ2FyZSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkhlYWx0aCAmYW1wOyBXZWxsYmVpbmcgYW5kIFNwb3J0ICZhbXA7IFBoeXNpY2FsIEVkdWNhdGlvbjwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5IZWFsdGggJmFtcDsgV2VsbGJlaW5nIGFuZCBTcG9ydCAmYW1wOyBQaHlzaWNhbCBFZHVjYXRpb24gKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5IaXN0b3J5PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkhpc3RvcnkgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5IaXN0b3J5IGFuZCBMYXc8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+SGlzdG9yeSBhbmQgTGF3ICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+SGlzdG9yeSBhbmQgTWVkaWEgJmFtcDsgQ29tbXVuaWNhdGlvbjwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5IaXN0b3J5IGFuZCBNZWRpYSAmYW1wOyBDb21tdW5pY2F0aW9uICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+SGlzdG9yeSBhbmQgUGhpbG9zb3BoeSAmYW1wOyBFdGhpY3M8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+SGlzdG9yeSBhbmQgUGhpbG9zb3BoeSAmYW1wOyBFdGhpY3MgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5IaXN0b3J5IGFuZCBQb2xpdGljczwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5IaXN0b3J5IGFuZCBQb2xpdGljcyAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkhpc3RvcnkgYW5kIFBzeWNob2xvZ3k8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+SGlzdG9yeSBhbmQgUHN5Y2hvbG9neSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkhpc3RvcnkgYW5kIFJlbGlnaW9uLCBUaGVvbG9neSAmYW1wOyBTcGlyaXR1YWxpdHk8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+SGlzdG9yeSBhbmQgUmVsaWdpb24sIFRoZW9sb2d5ICZhbXA7IFNwaXJpdHVhbGl0eSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkhpc3RvcnkgYW5kIFNvY2lvbG9neTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5IaXN0b3J5IGFuZCBTb2Npb2xvZ3kgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5IdW1hbiBCaW9sb2d5IGFuZCBTcG9ydCAmYW1wOyBFeGVyY2lzZSBTY2llbmNlPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkh1bWFuIEJpb2xvZ3kgYW5kIFNwb3J0ICZhbXA7IEV4ZXJjaXNlIFNjaWVuY2UgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5JbmZvcm1hdGlvbiBUZWNobm9sb2d5IGFuZCBNZWRpYSAmYW1wOyBDb21tdW5pY2F0aW9uPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkluZm9ybWF0aW9uIFRlY2hub2xvZ3kgYW5kIE1lZGlhICZhbXA7IENvbW11bmljYXRpb24gKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5JbmZvcm1hdGlvbiBUZWNobm9sb2d5IGFuZCBNdXNpYyBQcm9kdWN0aW9uPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkluZm9ybWF0aW9uIFRlY2hub2xvZ3kgYW5kIE11c2ljIFByb2R1Y3Rpb24gKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5JbnRlcm5hdGlvbmFsIFJlbGF0aW9ucyBhbmQgUHN5Y2hvbG9neTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5JbnRlcm5hdGlvbmFsIFJlbGF0aW9ucyBhbmQgUHN5Y2hvbG9neSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkludGVybmF0aW9uYWwgUmVsYXRpb25zIGFuZCBUb3VyaXNtPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkludGVybmF0aW9uYWwgUmVsYXRpb25zIGFuZCBUb3VyaXNtICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+TExCIExhdzwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5MYXcgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5MYXcgYW5kIFBoaWxvc29waHkgJmFtcDsgRXRoaWNzPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkxhdyBhbmQgUGhpbG9zb3BoeSAmYW1wOyBFdGhpY3MgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5MYXcgYW5kIFBvbGl0aWNzPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkxhdyBhbmQgUG9saXRpY3MgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5MYXcgYW5kIFBzeWNob2xvZ3k8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+TGF3IGFuZCBQc3ljaG9sb2d5ICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+TWF0aGVtYXRpY3M8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+TWF0aGVtYXRpY3MgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NYXRoZW1hdGljcyAod2l0aCBZZWFyIGluIEluZHVzdHJ5KTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NZWRpYSAmYW1wOyBDb21tdW5pY2F0aW9uIGFuZCBSZWxpZ2lvbiwgVGhlb2xvZ3kgJmFtcDsgU3Bpcml0dWFsaXR5PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPk1lZGlhICZhbXA7IENvbW11bmljYXRpb24gYW5kIFJlbGlnaW9uLCBUaGVvbG9neSAmYW1wOyBTcGlyaXR1YWxpdHkgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NZWRpYSAmYW1wOyBDb21tdW5pY2F0aW9uIGFuZCBTb2Npb2xvZ3k8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+TWVkaWEgJmFtcDsgQ29tbXVuaWNhdGlvbiBhbmQgU29jaW9sb2d5ICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+TWVkaWEgJmFtcDsgQ29tbXVuaWNhdGlvbiBhbmQgU3BlY2lhbCBFZHVjYXRpb25hbCBOZWVkczwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NZWRpYSAmYW1wOyBDb21tdW5pY2F0aW9uIGFuZCBTcGVjaWFsIEVkdWNhdGlvbmFsIE5lZWRzICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+TWVkaWEgJmFtcDsgQ29tbXVuaWNhdGlvbiBhbmQgVG91cmlzbTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NZWRpYSAmYW1wOyBDb21tdW5pY2F0aW9uIGFuZCBUb3VyaXNtICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+TXVzaWM8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+TXVzaWMgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NdXNpYyBhbmQgTXVzaWMgUHJvZHVjdGlvbjwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NdXNpYyBhbmQgTXVzaWMgUHJvZHVjdGlvbiAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPk11c2ljIGFuZCBQb2xpdGljczwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NdXNpYyBhbmQgUG9saXRpY3MgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NdXNpYyBhbmQgUHN5Y2hvbG9neTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NdXNpYyBhbmQgUHN5Y2hvbG9neSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPk11c2ljIFByb2R1Y3Rpb248L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+TXVzaWMgUHJvZHVjdGlvbiAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPk11c2ljIFByb2R1Y3Rpb24gYW5kIE11c2ljYWwgVGhlYXRyZTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NdXNpYyBQcm9kdWN0aW9uIGFuZCBNdXNpY2FsIFRoZWF0cmUgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NdXNpYyBQcm9kdWN0aW9uIGFuZCBQc3ljaG9sb2d5PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPk11c2ljYWwgVGhlYXRyZSBhbmQgUG9saXRpY3M8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+TXVzaWNhbCBUaGVhdHJlIGFuZCBQb2xpdGljcyAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPk11c2ljYWwgVGhlYXRyZSBhbmQgUHN5Y2hvbG9neTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NdXNpY2FsIFRoZWF0cmUgYW5kIFBzeWNob2xvZ3kgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5HbG9iYWwgUGhpbG9zb3BoaWVzICZhbXA7IFdvcmxkdmlld3MgYW5kIFBoaWxvc29waHkgJmFtcDsgRXRoaWNzPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkdsb2JhbCBQaGlsb3NvcGhpZXMgJmFtcDsgV29ybGR2aWV3cyBhbmQgUGhpbG9zb3BoeSAmYW1wOyBFdGhpY3MgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5QaGlsb3NvcGh5ICZhbXA7IEV0aGljcyBhbmQgU29jaW9sb2d5PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPlBoaWxvc29waHkgJmFtcDsgRXRoaWNzIGFuZCBTb2Npb2xvZ3kgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5QaGlsb3NvcGh5ICZhbXA7IEV0aGljcyBhbmQgUmVsaWdpb24sIFRoZW9sb2d5ICZhbXA7IFNwaXJpdHVhbGl0eTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5QaGlsb3NvcGh5ICZhbXA7IEV0aGljcyBhbmQgUmVsaWdpb24sIFRoZW9sb2d5ICZhbXA7IFNwaXJpdHVhbGl0eSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPlBvbGl0aWNzICZhbXA7IEludGVybmF0aW9uYWwgUmVsYXRpb25zPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPlBvbGl0aWNzICZhbXA7IEludGVybmF0aW9uYWwgUmVsYXRpb25zICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+UG9saXRpY3MgYW5kIFJlbGlnaW9uLCBUaGVvbG9neSAmYW1wOyBTcGlyaXR1YWxpdHk8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+UG9saXRpY3MgYW5kIFJlbGlnaW9uLCBUaGVvbG9neSAmYW1wOyBTcGlyaXR1YWxpdHkgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Qb2xpdGljcyBhbmQgU29jaW9sb2d5PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPlBvbGl0aWNzIGFuZCBTb2Npb2xvZ3kgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5QcmltYXJ5IEVkdWNhdGlvbiB3aXRoIFFUUyAoNS0xMSk8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+UHN5Y2hvbG9neTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Qc3ljaG9sb2d5ICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+UHN5Y2hvbG9neSBhbmQgUmVsaWdpb24sIFRoZW9sb2d5ICZhbXA7IFNwaXJpdHVhbGl0eTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Qc3ljaG9sb2d5IGFuZCBSZWxpZ2lvbiwgVGhlb2xvZ3kgJmFtcDsgU3Bpcml0dWFsaXR5ICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+UHN5Y2hvbG9neSBhbmQgU29jaW9sb2d5PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPlBzeWNob2xvZ3kgYW5kIFNvY2lvbG9neSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPlBzeWNob2xvZ3kgYW5kIFNwZWNpYWwgRWR1Y2F0aW9uYWwgTmVlZHM8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+UHN5Y2hvbG9neSBhbmQgU3BlY2lhbCBFZHVjYXRpb25hbCBOZWVkcyAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPlBzeWNob2xvZ3kgYW5kIFNwb3J0ICZhbXA7IEV4ZXJjaXNlIFNjaWVuY2U8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+UHN5Y2hvbG9neSBhbmQgU3BvcnQgJmFtcDsgRXhlcmNpc2UgU2NpZW5jZSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPlBzeWNob2xvZ3kgaW4gQnVzaW5lc3M8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+UHN5Y2hvbG9neSBpbiBCdXNpbmVzcyAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPlBzeWNob2xvZ3kgaW4gRWR1Y2F0aW9uPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPlBzeWNob2xvZ3kgaW4gRWR1Y2F0aW9uICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+UmVsaWdpb24sIFRoZW9sb2d5ICZhbXA7IFNwaXJpdHVhbGl0eSBhbmQgU29jaWFsIENhcmU8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+UmVsaWdpb24sIFdvcmxkdmlld3MgJmFtcDsgU3Bpcml0dWFsaXR5PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPlJlbGlnaW9uLCBXb3JsZHZpZXdzICZhbXA7IFNwaXJpdHVhbGl0eSAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkdsb2JhbCBQaGlsb3NvcGhpZXMgJmFtcDsgV29ybGR2aWV3cyBhbmQgU29jaW9sb2d5PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkdsb2JhbCBQaGlsb3NvcGhpZXMgJmFtcDsgV29ybGR2aWV3cyBhbmQgU29jaW9sb2d5ICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+R2xvYmFsIFBoaWxvc29waGllcyAmYW1wOyBXb3JsZHZpZXdzIGFuZCBTcG9ydCAmYW1wOyBQaHlzaWNhbCBFZHVjYXRpb248L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+R2xvYmFsIFBoaWxvc29waGllcyAmYW1wOyBXb3JsZHZpZXdzIGFuZCBTcG9ydCAmYW1wOyBQaHlzaWNhbCBFZHVjYXRpb24gKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Sb2JvdGljczwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Sb2JvdGljcyAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPlJvYm90aWNzICh3aXRoIFllYXIgaW4gSW5kdXN0cnkgYW5kIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+Um9ib3RpY3MgKHdpdGggWWVhciBpbiBJbmR1c3RyeSk8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+U29jaWFsIENhcmUgYW5kIFJlbGlnaW9uLCBUaGVvbG9neSAmYW1wOyBTcGlyaXR1YWxpdHkgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Tb2NpYWwgQ2FyZSBhbmQgU29jaW9sb2d5PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPlNvY2lhbCBDYXJlIGFuZCBTb2Npb2xvZ3kgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Tb2NpYWwgQ2FyZSBhbmQgU3BlY2lhbCBFZHVjYXRpb25hbCBOZWVkczwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Tb2NpYWwgQ2FyZSBhbmQgU3BlY2lhbCBFZHVjYXRpb25hbCBOZWVkcyAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPlNvY2lhbCBDYXJlIGFuZCBTcG9ydCAmYW1wOyBQaHlzaWNhbCBFZHVjYXRpb248L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+U29jaWFsIENhcmUgYW5kIFNwb3J0ICZhbXA7IFBoeXNpY2FsIEVkdWNhdGlvbiAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPlNvY2lhbCBXb3JrPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPlNvY2lhbCBXb3JrIChNQSkgKFBHKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Tb2Npb2xvZ3k8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+U29jaW9sb2d5ICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+U29mdHdhcmUgRW5naW5lZXJpbmcgQkVuZzwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Tb2Z0d2FyZSBFbmdpbmVlcmluZyBCU2M8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+U29mdHdhcmUgRW5naW5lZXJpbmcgKHdpdGggRm91bmRhdGlvbiBZZWFyIGFuZCBZZWFyIGluIEluZHVzdHJ5KSBCU2M8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+U29mdHdhcmUgRW5naW5lZXJpbmcgKHdpdGggRm91bmRhdGlvbiBZZWFyIGFuZCBZZWFyIGluIEluZHVzdHJ5KSBCRW5nPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPlNvZnR3YXJlIEVuZ2luZWVyaW5nICh3aXRoIEZvdW5kYXRpb24gWWVhcikgQlNjPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPlNvZnR3YXJlIEVuZ2luZWVyaW5nICh3aXRoIEZvdW5kYXRpb24gWWVhcikgQkVuZzwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Tb2Z0d2FyZSBFbmdpbmVlcmluZyAod2l0aCBZZWFyIGluIEluZHVzdHJ5KSBCU2M8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+U29mdHdhcmUgRW5naW5lZXJpbmcgKHdpdGggWWVhciBpbiBJbmR1c3RyeSkgQkVuZzwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5TcGVjaWFsIEVkdWNhdGlvbmFsIE5lZWRzICZhbXA7IERpc2FiaWxpdHkgU3R1ZGllczwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5TcGVjaWFsIEVkdWNhdGlvbmFsIE5lZWRzICZhbXA7IERpc2FiaWxpdHkgU3R1ZGllcyAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPlNwZWNpYWwgRWR1Y2F0aW9uYWwgTmVlZHMgYW5kIFNwb3J0ICZhbXA7IFBoeXNpY2FsIEVkdWNhdGlvbjwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5SZWxpZ2lvbiwgVGhlb2xvZ3kgJmFtcDsgU3Bpcml0dWFsaXR5IGFuZCBTcGVjaWFsIEVkdWNhdGlvbmFsIE5lZWRzPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPlJlbGlnaW9uLCBUaGVvbG9neSAmYW1wOyBTcGlyaXR1YWxpdHkgYW5kIFNwZWNpYWwgRWR1Y2F0aW9uYWwgTmVlZHMgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5TcGVjaWFsIEVkdWNhdGlvbmFsIE5lZWRzIGFuZCBTcG9ydCAmYW1wOyBQaHlzaWNhbCBFZHVjYXRpb24gKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5TcG9ydCAmYW1wOyBFeGVyY2lzZSBOdXRyaXRpb248L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+U3BvcnQgJmFtcDsgRXhlcmNpc2UgTnV0cml0aW9uICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+U3BvcnQgJmFtcDsgRXhlcmNpc2UgU2NpZW5jZTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5TcG9ydCAmYW1wOyBFeGVyY2lzZSBTY2llbmNlICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+U3BvcnQgJmFtcDsgUGh5c2ljYWwgRWR1Y2F0aW9uPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPlNwb3J0ICZhbXA7IFBoeXNpY2FsIEVkdWNhdGlvbiAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPlNwb3J0IE1hbmFnZW1lbnQ8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+U3BvcnQgUHN5Y2hvbG9neTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5TcG9ydCBQc3ljaG9sb2d5ICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+U3BvcnQgUmVoYWJpbGl0YXRpb248L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+VG91cmlzbSBNYW5hZ2VtZW50PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPlRvdXJpc20gTWFuYWdlbWVudCAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPlJlbGlnaW9uLCBUaGVvbG9neSAmYW1wOyBTcGlyaXR1YWxpdHkgYW5kIFNwZWNpYWwgRWR1Y2F0aW9uYWwgTmVlZHM8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+UmVsaWdpb24sIFRoZW9sb2d5ICZhbXA7IFNwaXJpdHVhbGl0eSBhbmQgU3BlY2lhbCBFZHVjYXRpb25hbCBOZWVkcyAod2l0aCBGb3VuZGF0aW9uIFllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkh1bWFuIEJpb2xvZ3kgYW5kIENyaW1pbm9sb2d5ICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+SHVtYW4gQmlvbG9neSBhbmQgSGVhbHRoICZhbXA7IFdlbGxiZWluZyAod2l0aCBGb3VuZGF0aW9uIHllYXIpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkh1bWFuIEJpb2xvZ3kgYW5kIEZvb2QgJmFtcDsgTnV0cml0aW9uYWwgU2NpZW5jZXMgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5Db25zZXJ2YXRpb24gQmlvbG9neSBhbmQgR2VvZ3JhcGh5PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkNvbnNlcnZhdGlvbiBCaW9sb2d5IGFuZCBHZW9ncmFwaHkgKHdpdGggRm91bmRhdGlvbiBZZWFyKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5EaWdpdGFsIENyZWF0aXZpdHkgYW5kIERpZ2l0YWwgTWFya2V0aW5nICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+RGlnaXRhbCBDcmVhdGl2aXR5IGFuZCBNdXNpYyBQcm9kdWN0aW9uICh3aXRoIEZvdW5kYXRpb24gWWVhcik8L2xpPlxyXG48L3VsPlxyXG48YSBocmVmPVwiaHR0cHM6Ly93d3cuaG9wZS5hYy51ay91bmRlcmdyYWR1YXRlL1wiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+XHJcbk1vcmUgSW5mbyBvbiBVbmRlcmdyYWR1YXRlIERlZ3JlZXNcclxuPC9hPlxyXG48aDM+R3JhZHVhdGUgSW5mb3JtYXRpb248L2gzPlxyXG48aDQ+VVMgRW50cnkgUmVxdWlyZW1lbnRzPC9oND5cclxuTm9ybWFsbHkgYSBmaXJzdCBvciBzZWNvbmQgY2xhc3MgZGVncmVlIGZyb20gYSByZWNvZ25pc2VkIEFtZXJpY2FuIFVuaXZlcnNpdHlcclxuPGEgdGFiaW5kZXg9XCIwXCI+VmlldyBBbGwgR3JhZHVhdGUgTWFqb3JzPC9hPlxyXG48dWw+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NU2MgQWR2YW5jZWQgQ29tcHV0ZXIgU2NpZW5jZTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5QRyBDZXJ0IEFkdmFuY2VkIE1lbnRvcmluZyAmYW1wOyBDb2FjaGluZyBcdTIwMTMgT25saW5lPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPk1BIEFkdmFuY2VkIE1lbnRvcmluZyBhbmQgQ29hY2hpbmc8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+TVNjIEFkdmFuY2VkIE11c2N1bG9za2VsZXRhbCAoTVNLKSBQcmFjdGljZTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NU2MgQXBwbGllZCBEZXZlbG9wbWVudGFsIFBzeWNob2xvZ3k8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+TVNjIEJ1c2luZXNzIFN1c3RhaW5hYmlsaXR5PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPlBHIENlcnQgQ2F0aG9saWMgUGFzdG9yYWwgTGVhZGVyc2hpcDwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NU2MgQ29nbml0aW9uIGFuZCBBZXN0aGV0aWNzPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPk1BIENvbnRlbXBvcmFyeSBQZXJmb3JtYW5jZTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NQSBDcmVhdGl2ZSBBcHByb2FjaGVzIHRvIENoaWxkcmVuXHUyMDE5cyBXZWxsYmVpbmc8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+TUEgQ3JlYXRpdmUgTXVzaWMgUHJhY3RpY2U8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+TUEgRGFuY2UgUHJvZmVzc2lvbmFsIFByYWN0aWNlPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPk1TYyBEYXRhIFNjaWVuY2U8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+TVNjIERpZ2l0YWwgTWFya2V0aW5nPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPk1BIERpc2FiaWxpdHkgYW5kIEludGVyZGlzY2lwbGluYXJ5IFByb2Zlc3Npb25hbCBQcmFjdGljZTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NQSBEaXNhYmlsaXR5IFN0dWRpZXM8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+TUEgRWFybHkgQ2hpbGRob29kPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPk1TYyBFY29sb2d5ICZhbXA7IEVudmlyb25tZW50YWwgTWFuYWdlbWVudDwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NQSBFZHVjYXRpb24gKE1BKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5FZEQgRWR1Y2F0aW9uIERvY3RvcmF0ZSAoRWREKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5QRyBDZXJ0IEVkdWNhdGlvbiBMZWFkZXJzaGlwICZhbXA7IE1hbmFnZW1lbnQgXHUyMDEzIE9ubGluZTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NQSBFZHVjYXRpb24gTGVhZGVyc2hpcCBhbmQgTWFuYWdlbWVudDwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NQSBFbmdsaXNoIExpdGVyYXR1cmU8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+TUEgRW5nbGlzaCBMaXRlcmF0dXJlIChNQSBieSBSZXNlYXJjaCk8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+TVJlcyBHcmVlbiBDcmltaW5vbG9neSBhbmQgRW52aXJvbm1lbnRhbCBDcmltZTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NQSBIZWFsdGggJmFtcDsgU29jaWFsIENhcmU8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+REhTQyBIZWFsdGggJmFtcDsgU29jaWFsIENhcmUgRG9jdG9yYXRlIChESFNDKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NQSBIaXN0b3J5PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPk1TYyBJbnRlcm5hdGlvbmFsIEJ1c2luZXNzIE1hbmFnZW1lbnQ8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+TUEgSW50ZXJuYXRpb25hbCBDcmltaW5vbG9neSBhbmQgU2VjdXJpdHkgU3R1ZGllczwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5MTE0gSW50ZXJuYXRpb25hbCBDeWJlciBMYXcgYW5kIFBvbGljeSAoTExNIGJ5IFJlc2VhcmNoKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NUmVzIEludGVybmF0aW9uYWwgVGVycm9yaXNtIGFuZCBFeHRyZW1pc20gU3R1ZGllczwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NQkEgTWFzdGVycyBpbiBCdXNpbmVzcyBBZG1pbmlzdHJhdGlvbjwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5MTE0gTWlncmF0aW9uIGFuZCBSZWZ1Z2VlIExhdyAoTExNIGJ5IFJlc2VhcmNoKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NU2MgTXVzY3Vsb3NrZWxldGFsIChNU0spIFByYWN0aWNlPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPlBHIENlcnQgTXVzY3Vsb3NrZWxldGFsIFByYWN0aWNlIChGaXJzdCBDb250YWN0IFByYWN0aWNlKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5QR0NFIFBHQ0UgUHJpbWFyeSAoMy03KTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5QR0NFIFBHQ0UgUHJpbWFyeSAoNS0xMSk8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+UEdDRSBQR0NFIFNlY29uZGFyeTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NU2MgUGh5c2lvdGhlcmFweTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NQSBQb2xpdGljcyAmYW1wOyBJbnRlcm5hdGlvbmFsIFJlbGF0aW9uczwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NU2MgUHN5Y2hvbG9neTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NU2MgUm9ib3RpY3MgRW5naW5lZXJpbmc8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+TUEgU29jaWFsIFBvbGljeTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NQSBTb2NpYWwgV29yazwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5EU1cgU29jaWFsIFdvcmsgRG9jdG9yYXRlIChEU1cpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPk1BIFNvY2lvLUN1bHR1cmFsIERpc2FiaWxpdHkgU3R1ZGllczwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NQSBTb2Npb2xvZ3k8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+TUEgU3BlY2lhbCBFZHVjYXRpb25hbCBOZWVkcyBhbmQgSW5jbHVzaW9uIFN0dWRpZXM8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+UEcgQ2VydCBTcGVjaWZpYyBMZWFybmluZyBEaWZmaWN1bHRpZXMgKER5c2xleGlhKSBcdTIwMTMgT25saW5lIChQRyBDZXJ0KTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NU2MgU3BvcnRzIE1lZGljaW5lLCBFeGVyY2lzZSBhbmQgSGVhbHRoPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPk1BIFRoZW9sb2d5LCBQaGlsb3NvcGh5ICZhbXA7IFJlbGlnaW9uIChNQSBieSBSZXNlYXJjaCk8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+TUEgVGhlb2xvZ3ksIFBoaWxvc29waHkgJmFtcDsgUmVsaWdpb248L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+TVJlcyBUcmFuc2FjdGlvbmFsIENyaW1lPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPlBHIENlcnQgVW5kZXJzdGFuZGluZyBBdXRpc20gJmFtcDsgSW5jbHVzaXZlIExlYXJuaW5nIFx1MjAxMyBPbmxpbmUgKFBHQ2VydCk8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+TUEgWW91dGggV29yayAmYW1wOyBDb21tdW5pdHkgRGV2ZWxvcG1lbnQ8L2xpPlxyXG48L3VsPlxyXG48YSBocmVmPVwiaHR0cHM6Ly93d3cuaG9wZS5hYy51ay9wb3N0Z3JhZHVhdGUvXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5cclxuTW9yZSBJbmZvIG9uIEdyYWR1YXRlIERlZ3JlZXNcclxuPC9hPlxyXG48aDM+U29jaWFsIE1lZGlhPC9oMz5cclxuPGEgaHJlZj1cImh0dHBzOi8vd3d3LmZhY2Vib29rLmNvbS9MaXZlcnBvb2xIb3BlVW5pdmVyc2l0eVwiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+XHJcbkZhY2Vib29rXHJcbjwvYT5cclxuPGEgaHJlZj1cImh0dHBzOi8veC5jb20vTGl2ZXJwb29sSG9wZVVLXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5cclxuVHdpdHRlclxyXG48L2E+XHJcbjxhIGhyZWY9XCJodHRwczovL3d3dy5pbnN0YWdyYW0uY29tL2xpdmVycG9vbGhvcGV1ay9cIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPlxyXG5JbnN0YWdyYW1cclxuPC9hPlxyXG48YSBocmVmPVwiaHR0cHM6Ly93d3cueW91dHViZS5jb20vbGl2ZXJwb29saG9wZXVuaTFcIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPlxyXG5Zb3V0dWJlXHJcbjwvYT5cclxuPGgzPkFkZGl0aW9uYWwgVW5pdmVyc2l0eSBMaW5rczwvaDM+XHJcbjx1bD5cclxuIFx0PGxpPjxhIGhyZWY9XCJodHRwczovL3d3dy5ob3BlLmFjLnVrL1wiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+XHJcbkhvbWUgUGFnZVxyXG48L2E+PC9saT5cclxuIFx0PGxpPjxhIGhyZWY9XCJodHRwczovL3d3dy5ob3BlLmFjLnVrL2ludGVybmF0aW9uYWwveW91cmNvdW50cnkvdXNhL1wiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+XHJcblVTQS9JbnRlcm5hdGlvbmFsIFBhZ2VcclxuPC9hPjwvbGk+XHJcbiBcdDxsaT48YSBocmVmPVwiaHR0cHM6Ly93d3cuaG9wZS5hYy51ay9pbnRlcm5hdGlvbmFsL2ZlZXNhbmRzY2hvbGFyc2hpcHMvaW50ZXJuYXRpb25hbHR1aXRpb25mZWVzL1wiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+XHJcbkludGVybmF0aW9uYWwgVHVpdGlvblxyXG48L2E+PC9saT5cclxuIFx0PGxpPjxhIGhyZWY9XCJodHRwczovL3d3dy5ob3BlLmFjLnVrL2ludGVybmF0aW9uYWwvZmVlc2FuZHNjaG9sYXJzaGlwcy9cIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPlxyXG5TY2hvbGFyc2hpcHNcclxuPC9hPjwvbGk+XHJcbiBcdDxsaT48YSBocmVmPVwiaHR0cHM6Ly93d3cuaG9wZS5hYy51ay9pbnRlcm5hdGlvbmFsL2ZlZXNhbmRzY2hvbGFyc2hpcHMvZnVuZGluZ2ZvcnVzc3R1ZGVudHMvXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5cclxuRkFGU0FcclxuPC9hPjwvbGk+XHJcbjwvdWw+XHJcbjx1bD5cclxuIFx0PGxpPjxhIGhyZWY9XCJodHRwczovL3d3dy5ob3BlLmFjLnVrL2V2ZW50cy9cIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPlxyXG5WaXJ0dWFsIEV2ZW50c1xyXG48L2E+PC9saT5cclxuIFx0PGxpPjxhIGhyZWY9XCJodHRwczovL3d3dy5ob3BlLmFjLnVrL3Jlc2VhcmNoL1wiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+XHJcblJlc2VhcmNoXHJcbjwvYT48L2xpPlxyXG4gXHQ8bGk+PGEgaHJlZj1cImh0dHBzOi8vd3d3LmhvcGUuYWMudWsvaGFsbHMvXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5cclxuSG91c2luZy9BY2NvbW1vZGF0aW9uXHJcbjwvYT48L2xpPlxyXG4gXHQ8bGk+PGEgaHJlZj1cImh0dHBzOi8vd3d3LmhvcGUuYWMudWsvY2FyZWVycy9cIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPlxyXG5DYXJlZXJzIE9mZmljZVxyXG48L2E+PC9saT5cclxuIFx0PGxpPjxhIGhyZWY9XCJodHRwczovL3d3dy5ob3Blc3UuY29tL2dyb3VwcyNjbHViLXNvY2lldHklMjNhbGxcIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPlxyXG5DbHVicy9Tb2NpZXRpZXNcclxuPC9hPjwvbGk+XHJcbjwvdWw+XHJcbjxhIGhyZWY9XCJodHRwczovL3d3dy5ob3BlLmFjLnVrL1wiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+XHJcbkFQUExZIE5PV1xyXG48L2E+XHJcbjxoMz5SRVFVRVNUIE1PUkUgSU5GT1JNQVRJT048L2gzPlxyXG5bY29udGFjdC1mb3JtLTcgaWQ9XCIzMDgwXCIgdGl0bGU9XCJVbml2ZXJzaXR5IG9mIExpbmNvbG5cIl0iLCJwb3N0X3RpdGxlIjoiTGl2ZXJwb29sIEhvcGUgVW5pdmVyc2l0eSIsInBvc3RfbGluayI6Imh0dHBzOi8vdGhldWtzdHVkeWV4cGVydC5jb20vdW5pdmVyc2l0aWVzL2xpdmVycG9vbC1ob3BlLXVuaXZlcnNpdHkvIiwicG9zdF9mZWF0dXJlZF9pbWFnZSI6IjxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiTGl2ZXJwb29sIEhvcGUgVW5pdmVyc2l0eVwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMTU4XCIgc3JjPVwiaHR0cHM6Ly90aGV1a3N0dWR5ZXhwZXJ0LmNvbS93cC1jb250ZW50L3VwbG9hZHMvMjAyNC8xMi9MSFUtbG9nby0zMDB4MTU4LnBuZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6IlVuaXZlcnNpdGllcyIsInBvc3RfdGFncyI6IkJ1c2luZXNzIEVjb25vbWljcywgQ3JlYXRpdmVwZXJmb3JtaW5nIEFydHMgRGVzaWduLCBFZHVjYXRpb24sIEVuZ2luZWVyaW5nLCBIZWFsdGggTWVkaWNpbmUsIEh1bWFuaXRpZXMsIExpZmUgUGh5c2ljYWwgU2NpZW5jZXMsIFNvY2lhbCBTY2llbmNlLCBUZWNobm9sb2d5IENvbXB1dGVyIFNjaWVuY2UiLCIlX2N1c3RvbV9wcmlvcml0eV9tZXRhX2tleSUiOiI0IiwidGF4b25vbXk9Y2F0ZWdvcnkiOiJVbml2ZXJzaXRpZXMiLCJ0YXhvbm9teT1wb3N0X3RhZyI6IkJ1c2luZXNzIEVjb25vbWljcywgQ3JlYXRpdmVwZXJmb3JtaW5nIEFydHMgRGVzaWduLCBFZHVjYXRpb24sIEVuZ2luZWVyaW5nLCBIZWFsdGggTWVkaWNpbmUsIEh1bWFuaXRpZXMsIExpZmUgUGh5c2ljYWwgU2NpZW5jZXMsIFNvY2lhbCBTY2llbmNlLCBUZWNobm9sb2d5IENvbXB1dGVyIFNjaWVuY2UiLCJjaXR5X2NvdW50cnkiOiJMaXZlcnBvb2wsIEVuZ2xhbmQifSwiaWNvbiI6Imh0dHBzOi8vdGhldWtzdHVkeWV4cGVydC5jb20vd3AtY29udGVudC91cGxvYWRzLzIwMjQvMDIvVW5pdmVyc2l0eS1NYXAtUGluLTIucG5nIn0sImlkIjoxODA2MCwiaW5mb3dpbmRvd19kaXNhYmxlIjpmYWxzZSwiY2F0ZWdvcmllcyI6W3siaWNvbiI6Imh0dHBzOi8vdGhldWtzdHVkeWV4cGVydC5jb20vd3AtY29udGVudC91cGxvYWRzLzIwMjQvMDIvVW5pdmVyc2l0eS1NYXAtUGluLTIucG5nIiwibmFtZSI6IlVuaXZlcnNpdHkiLCJpZCI6IjEiLCJ0eXBlIjoiY2F0ZWdvcnkiLCJleHRlbnNpb25fZmllbGRzIjp7ImNhdF9vcmRlciI6IjEifX1dfSx7InNvdXJjZSI6InBvc3QiLCJ0aXRsZSI6IlVuaXZlcnNpdHkgb2YgSGVydGZvcmRzaGlyZSIsImluZm93aW5kb3dfY29udGVudCI6IjxkaXYgY2xhc3M9XCJmYy1pdGVtLWJveCBmYy1pdGVtLW5vLXBhZGRpbmdcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiVW5pdmVyc2l0eSBvZiBIZXJ0Zm9yZHNoaXJlXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIxNjlcIiBzcmM9XCJodHRwczovL3RoZXVrc3R1ZHlleHBlcnQuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDI0LzEyL2hlcnRmb3JkLXdoaXRlLWxvZ28tMzAweDE2OS5wbmdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tcGFkZGluZy1jb250ZW50XzIwXCI+XHJcbjxhIGhyZWY9XCJodHRwczovL3RoZXVrc3R1ZHlleHBlcnQuY29tL3VuaXZlcnNpdGllcy91bml2ZXJzaXR5LW9mLWhlcnRmb3Jkc2hpcmUvXCIgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLXRleHQtY2VudGVyXCI+VW5pdmVyc2l0eSBvZiBIZXJ0Zm9yZHNoaXJlPC9hPlxyXG4gICAgICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1jb250ZW50IGZjLWl0ZW0tYm9keS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+XHJcbiAgICAgICAgICAgICAgICBUaGUgVW5pdmVyc2l0eSBvZiBIZXJ0Zm9yZHNoaXJlIGhhcyBiZWVuIGFuIGlubm92YXRpdmUsIHZvY2F0aW9uLWZpcnN0IGVkdWNhdGlvbmFsIGZvcmNlIGZvciBtb3JlIHRoYW4gNzAgeWVhcnMuIEhlcnRzIGlzIHRoZSBvbmx5IHVuaXZlcnNpdHkgdG8gYmUgYXdhcmRlZCBhIEtpbmdcdTIwMTlzIEF3YXJkIGZvciBFbnRlcnByaXNlIHRoaXMgeWVhciwgcmVjb2duaXRpb24gZm9yIGhvdyBpdCBoYXMgZ3Jvd24gaXRzIGludGVybmF0aW9uYWwgY29tbXVuaXR5LCBhbmQgYW4gZXh0ZW5zaXZlIG92ZXJzZWFzIHBhcnRuZXIgbmV0d29yayBkZWxpdmVyaW5nIHRoZSBVbml2ZXJzaXR5J3MgZWR1Y2F0aW9uLlxyXG4gICAgICAgICAgICA8L2Rpdj5cclxuICAgICAgICA8L2Rpdj5cclxuICAgIDwvZGl2PlxyXG48L2Rpdj4iLCJjb250ZW50IjoiVGhlIFVuaXZlcnNpdHkgb2YgSGVydGZvcmRzaGlyZSBoYXMgYmVlbiBhbiBpbm5vdmF0aXZlLCB2b2NhdGlvbi1maXJzdCBlZHVjYXRpb25hbCBmb3JjZSBmb3IgbW9yZSB0aGFuIDcwIHllYXJzLiBIZXJ0cyBpcyB0aGUgb25seSB1bml2ZXJzaXR5IHRvIGJlIGF3YXJkZWQgYSBLaW5nXHUyMDE5cyBBd2FyZCBmb3IgRW50ZXJwcmlzZSB0aGlzIHllYXIsIHJlY29nbml0aW9uIGZvciBob3cgaXQgaGFzIGdyb3duIGl0cyBpbnRlcm5hdGlvbmFsIGNvbW11bml0eSwgYW5kIGFuIGV4dGVuc2l2ZSBvdmVyc2VhcyBwYXJ0bmVyIG5ldHdvcmsgZGVsaXZlcmluZyB0aGUgVW5pdmVyc2l0eSdzIGVkdWNhdGlvbi4iLCJhZGRyZXNzIjoiQ29sbGVnZSBMbiwgSGF0ZmllbGQgQUwxMCA5QUIsIFVLIiwibG9jYXRpb24iOnsibGF0IjoiNTEuNzUxNzcxODk5OTk5OTkiLCJzdGF0ZSI6IkVuZ2xhbmQiLCJjb3VudHJ5IjoiVW5pdGVkIEtpbmdkb20iLCJsbmciOiItMC4yMzk5OTk1Iiwib25jbGlja19hY3Rpb24iOiJtYXJrZXIiLCJyZWRpcmVjdF9wZXJtYWxpbmsiOiJodHRwczovL3RoZXVrc3R1ZHlleHBlcnQuY29tL3VuaXZlcnNpdGllcy91bml2ZXJzaXR5LW9mLWhlcnRmb3Jkc2hpcmUvIiwiem9vbSI6NSwiZXh0cmFfZmllbGRzIjp7InBvc3RfZXhjZXJwdCI6IlRoZSBVbml2ZXJzaXR5IG9mIEhlcnRmb3Jkc2hpcmUgaGFzIGJlZW4gYW4gaW5ub3ZhdGl2ZSwgdm9jYXRpb24tZmlyc3QgZWR1Y2F0aW9uYWwgZm9yY2UgZm9yIG1vcmUgdGhhbiA3MCB5ZWFycy4gSGVydHMgaXMgdGhlIG9ubHkgdW5pdmVyc2l0eSB0byBiZSBhd2FyZGVkIGEgS2luZ1x1MjAxOXMgQXdhcmQgZm9yIEVudGVycHJpc2UgdGhpcyB5ZWFyLCByZWNvZ25pdGlvbiBmb3IgaG93IGl0IGhhcyBncm93biBpdHMgaW50ZXJuYXRpb25hbCBjb21tdW5pdHksIGFuZCBhbiBleHRlbnNpdmUgb3ZlcnNlYXMgcGFydG5lciBuZXR3b3JrIGRlbGl2ZXJpbmcgdGhlIFVuaXZlcnNpdHkncyBlZHVjYXRpb24uIiwicG9zdF9jb250ZW50IjoiPGZpZ3VyZT48aW1nIHNyYz1cImh0dHBzOi8vdGhldWtzdHVkeWV4cGVydC5jb20vd3AtY29udGVudC91cGxvYWRzLzIwMjQvMTIvVW5pdmVyc2l0eS1vZi1IZXJ0Zm9yZHNoaXJlLVNjaWVuY2UtQnVpbGRpbmcucG5nXCIgYWx0PVwiVW5pdmVyc2l0eSBvZiBIZXJ0Zm9yZHNoaXJlXCIgLz48L2ZpZ3VyZT5cclxuPGZpZ3VyZT48aW1nIHNyYz1cImh0dHBzOi8vdGhldWtzdHVkeWV4cGVydC5jb20vd3AtY29udGVudC91cGxvYWRzLzIwMjQvMTIvVW5pdmVyc2l0eS1vZi1IZXJ0Zm9yZHNoaXJlLUxhdy1CdWlsZGluZy5wbmdcIiBhbHQ9XCJVbml2ZXJzaXR5IG9mIEhlcnRmb3Jkc2hpcmVcIiAvPjwvZmlndXJlPlxyXG48ZmlndXJlPjxpbWcgc3JjPVwiaHR0cHM6Ly90aGV1a3N0dWR5ZXhwZXJ0LmNvbS93cC1jb250ZW50L3VwbG9hZHMvMjAyNC8xMi9Vbml2ZXJzaXR5LW9mLUhlcnRmb3Jkc2hpcmUtQ29sbGVnZS1MYW5lLUNhbXB1cy5wbmdcIiBhbHQ9XCJVbml2ZXJzaXR5IG9mIEhlcnRmb3Jkc2hpcmVcIiAvPjwvZmlndXJlPlxyXG48ZmlndXJlPjxpbWcgc3JjPVwiaHR0cHM6Ly90aGV1a3N0dWR5ZXhwZXJ0LmNvbS93cC1jb250ZW50L3VwbG9hZHMvMjAyNC8xMi9Vbml2ZXJzaXR5LW9mLUhlcnRmb3Jkc2hpcmUtQWVyaWFsLVNob3QtLnBuZ1wiIGFsdD1cIlVuaXZlcnNpdHkgb2YgSGVydGZvcmRzaGlyZVwiIC8+PC9maWd1cmU+XHJcbjxmaWd1cmU+PGltZyBzcmM9XCJodHRwczovL3RoZXVrc3R1ZHlleHBlcnQuY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDI0LzEyL1VuaXZlcnNpdHktb2YtSGVydGZvcmRzaGlyZS1MZWFybmluZy1SZXNvdXJjZS1DZW50ZXIucG5nXCIgYWx0PVwiVW5pdmVyc2l0eSBvZiBIZXJ0Zm9yZHNoaXJlXCIgLz48L2ZpZ3VyZT5cclxuPGZpZ3VyZT48aW1nIHNyYz1cImh0dHBzOi8vdGhldWtzdHVkeWV4cGVydC5jb20vd3AtY29udGVudC91cGxvYWRzLzIwMjQvMTIvVW5pdmVyc2l0eS1vZi1IZXJ0Zm9yZHNoaXJlLUNhbXB1cy1CZWFjb24tLnBuZ1wiIGFsdD1cIlVuaXZlcnNpdHkgb2YgSGVydGZvcmRzaGlyZVwiIC8+PC9maWd1cmU+XHJcbjxhIGhyZWY9XCIjY29udGFjdC1mb3JtXCI+XHJcbkNvbnRhY3QgVW5pdmVyc2l0eSBvZiBIZXJ0Zm9yZHNoaXJlXHJcbjwvYT5cclxuXHJcbjxzdHJvbmc+TG9jYXRpb246PC9zdHJvbmc+IEhhdGZpZWxkLCBIZXJ0Zm9yZHNoaXJlLCBBTDEwIDlBQiwgVUtcclxuXHJcbjxzdHJvbmc+V2Vic2l0ZTogPC9zdHJvbmc+PGEgaHJlZj1cImh0dHBzOi8vd3d3LmhlcnRzLmFjLnVrL1wiPmh0dHBzOi8vd3d3LmhlcnRzLmFjLnVrLzwvYT5cclxuPGgzPk92ZXJ2aWV3PC9oMz5cclxuVGhlIFVuaXZlcnNpdHkgb2YgSGVydGZvcmRzaGlyZTogUG93ZXJpbmcgcG90ZW50aWFsLiBBY2NlbGVyYXRpbmcgZ3Jvd3RoLlxyXG5XaGV0aGVyIGl0XHUyMDE5cyBpbiBsZWFybmluZywgdGVhY2hpbmcsIG9yIGJ1c2luZXNzIHBhcnRuZXJzaGlwLCB0aGUgVW5pdmVyc2l0eSBvZiBIZXJ0Zm9yZHNoaXJlIHRyYW5zZm9ybXMgYm9sZCBhbWJpdGlvbiBpbnRvIGxpZmUtY2hhbmdpbmcgcmVhbGl0eS5cclxuXHJcbkRlZmluZWQgYnkgdGhlIHNwaXJpdCBvZiBpbm5vdmF0aW9uIGFuZCBlbnRlcnByaXNlLCB0aGUgVW5pdmVyc2l0eSBvZiBIZXJ0Zm9yZHNoaXJlIGhhcyBiZWVuIGFuIGlubm92YXRpdmUsIHZvY2F0aW9uLWZpcnN0IGVkdWNhdGlvbmFsIGZvcmNlIGZvciBtb3JlIHRoYW4gNzAgeWVhcnMuXHJcblxyXG5Gcm9tIG91ciBzdGFydCBhcyBhIGxlYWRpbmcgZWR1Y2F0b3Igd2l0aGluIEJyaXRhaW5cdTIwMTlzIGFlcm9uYXV0aWNhbCBpbmR1c3RyeSB0byBvdXIgZXh0ZW5zaXZlIG9mZmVyaW5nIHRvZGF5LCB3ZSBoYXZlIGFsd2F5cyBzcGVjaWFsaXNlZCBpbiBwcm92aWRpbmcgdGhlIGVudmlyb25tZW50IGFuZCBleHBlcnRpc2UgbmVlZGVkIHRvIHBvd2VyIGV2ZXJ5IGtpbmQgb2YgcG90ZW50aWFsLlxyXG5cclxuRm9yIG91ciB0aHJpdmluZyBjb21tdW5pdHkgb2YgbmVhcmx5IDM1LDAwMCBzdHVkZW50cyBmcm9tIG92ZXIgMTEwIGNvdW50cmllcywgdGhhdCBtZWFucyBoaWdoLXF1YWxpdHkgdGVhY2hpbmcgZnJvbSBleHBlcnRzIGVuZ2FnZWQgaW4gZ3JvdW5kYnJlYWtpbmcgcmVzZWFyY2ggd2l0aCByZWFsLXdvcmxkIGltcGFjdC4gU3R1ZGVudHMgaGF2ZSBhY2Nlc3MgdG8gbW9yZSB0aGFuIDcwMCBjYXJlZXItZm9jdXNlZCBkZWdyZWUgb3B0aW9ucyBhbmQgYSBjaGFuY2UgdG8gc3R1ZHkgYXQgbW9yZSB0aGFuIDE3MCB1bml2ZXJzaXRpZXMgd29ybGR3aWRlLCB1c2luZyBvdXRzdGFuZGluZywgdHJ1ZSB0byBsaWZlIGZhY2lsaXRpZXMuIEhlcnRzIGlzIHRoZSBvbmx5IHVuaXZlcnNpdHkgdG8gYmUgYXdhcmRlZCBhIEtpbmdcdTIwMTlzIEF3YXJkIGZvciBFbnRlcnByaXNlIHRoaXMgeWVhciwgcmVjb2duaXRpb24gZm9yIGhvdyBpdCBoYXMgZ3Jvd24gaXRzIGludGVybmF0aW9uYWwgY29tbXVuaXR5LCBhbmQgYW4gZXh0ZW5zaXZlIG92ZXJzZWFzIHBhcnRuZXIgbmV0d29yayBkZWxpdmVyaW5nIHRoZSBVbml2ZXJzaXR5J3MgZWR1Y2F0aW9uLlxyXG5cclxuPHN0cm9uZz5Qb3B1bGF0aW9uOiA8L3N0cm9uZz4zNiwwMDBcclxuXHJcbjxzdHJvbmc+Q2FtcHVzIFR5cGU6XHUwMGEwPC9zdHJvbmc+U3VidXJiYW5cclxuPGgzPlF1aWNrIEZhY3RzPC9oMz5cclxuPHVsPlxyXG4gXHQ8bGk+MXN0IGluIHRoZSBFYXN0IG9mIEVuZ2xhbmQgZm9yIG92ZXJhbGwgc3R1ZGVudCBzYXRpc2ZhY3Rpb248L2xpPlxyXG4gXHQ8bGk+T25seSB1bml2ZXJzaXR5IHRvIGJlIGF3YXJkZWQgYSBLaW5nXHUyMDE5cyBBd2FyZCBmb3IgRW50ZXJwcmlzZTwvbGk+XHJcbiBcdDxsaT4yNSBtaW51dGVzIGZyb20gTG9uZG9uIEtpbmdzIFguIFRoZSB1bml2ZXJzaXR5IGlzIGJhc2VkIG9uIGEgMTI1IGFjcmUgZ3JlZW4gY2FtcHVzIGluIEhhdGZpZWxkPC9saT5cclxuIFx0PGxpPjk2LjUlIG9mIG91ciBncmFkdWF0ZXMgYXJlIGluIHdvcmsgKG9yIGZ1cnRoZXIgc3R1ZHkpIHdpdGhpbiA2IG1vbnRoczwvbGk+XHJcbiBcdDxsaT43OCUgb2YgcmVzZWFyY2ggcmFua2VkIGFzIHdvcmxkLWxlYWRpbmcgb3IgaW50ZXJuYXRpb25hbGx5IGV4Y2VsbGVudCwgUmVzZWFyY2ggRXhjZWxsZW5jZSBGcmFtZXdvcmsgKFJFRik8L2xpPlxyXG4gXHQ8bGk+VGhlIHZhc3QgbWFqb3JpdHkgb2Ygb3VyIGNvdXJzZXMgaGF2ZSBhIHBsYWNlbWVudC9pbnRlcm5zaGlwIG9wdGlvbjwvbGk+XHJcbjwvdWw+XHJcbjxoMz5WaWRlb3M8L2gzPlxyXG5odHRwczovL3lvdXR1LmJlLy1XYkFETGpXWnhVP3NpPXFfV0pNQWtoMlQ5MlBUREJodHRwczovL3lvdXR1LmJlL2pVVFRHbHVKVGJzP3NpPW5yVU1KSWFvQXRZenlsaW9odHRwczovL3lvdXR1LmJlL1ZJZ3JkNERYR0U0P3NpPW5jWFlDLVBkU3M0TWJJQ1ZodHRwczovL3lvdXR1LmJlL2sya3U0cWVaandjP3NpPW8zUjFjRGNPLU1teU9uUmlodHRwczovL3lvdXR1LmJlL09sODBZMTBNZV84P3NpPW9ybHVyWXJyeGFvT01FTjBodHRwczovL3lvdXR1LmJlL1B3QnRqRkV2OFVVP3NpPTZ3Y0N2M09GeEk0dHZJVFlcclxuPGgzPlVuZGVyZ3JhZHVhdGUgSW5mb3JtYXRpb248L2gzPlxyXG48aDQ+VVMgRW50cnkgUmVxdWlyZW1lbnRzPC9oND5cclxuSGlnaCBTY2hvb2wgRGlwbG9tYSB3aXRoIGEgbWluaW11bSBvdmVyYWxsIGF2ZXJhZ2Ugb2YgMy4wLCB3aXRoIG9uZSBvZiB0aGUgZm9sbG93aW5nO1xyXG5cclxuMiBBZHZhbmNlZCBQbGFjZW1lbnQgKEFQKSB3aXRoIGEgbWluaW11bSBzY29yZSBvZiAzLjBcclxuXHJcbk9SXHJcblxyXG5TQVQgT25lIHdpdGggYSBiYWxhbmNlZCBzY29yZSBvZiAxNjAwIChvbGQgU0FUKSBvciAxMDcwIChuZXcgU0FUKVxyXG5cclxuT1JcclxuXHJcbkFDVCB3aXRoIGEgY29tcG9zaXRlIHNjb3JlIG9mIDIzXHJcbkEgZGVncmVlIHdpdGggYSBzcGVjaWZpYyBBIExldmVsIHN1YmplY3QgcmVxdWlyZW1lbnQgd291bGQgbmVlZCBhbiBob25vdXJzIGNsYXNzL2NvbGxlZ2UgY3JlZGl0IGNsYXNzIGluIHRoYXQgc3BlY2lmaWMgc3ViamVjdC5cclxuXHJcbjxhIHRhYmluZGV4PVwiMFwiPlZpZXcgQWxsIFVuZGVyZ3JhZHVhdGUgTWFqb3JzPC9hPlxyXG48dWw+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgQWNjb3VudGluZyAxMTJcdTIwMTMxMjAgTjQwMDwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgQWNjb3VudGluZyBhbmQgRmluYW5jZSAxMjBcdTIwMTMxMjggTk40MzwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgQnVzaW5lc3MgYW5kIEFjY291bnRpbmcgMTEyXHUyMDEzMTIwIE5ONEQ8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIEJ1c2luZXNzIGFuZCBGaW5hbmNlIDEyMFx1MjAxMzEyOCBOTjEzPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkJTYyAoSG9ucykgRWNvbm9taWNzIGFuZCBGaW5hbmNlIDEyMFx1MjAxMzEyOCBMMU4zPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSBGaW5hbmNlIDEyMFx1MjAxMzEyOCBOMzAwPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIDJEIERpZ2l0YWwgQW5pbWF0aW9uIDExMlx1MjAxMzEyMCBXNjE4PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSAzRCBBbmltYXRpb24gYW5kIFZpc3VhbCBFZmZlY3RzIDExMlx1MjAxMzEyMCBXMjgyPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSAzRCBHYW1lcyBBcnQgJmFtcDsgRGVzaWduIDExMlx1MjAxMzEyMCBXMjgxPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSBDb21pY3MgYW5kIENvbmNlcHQgQXJ0IDExMlx1MjAxMzEyMCBXNjE5PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSBDcmVhdGl2ZSBNZWRpYSBBcnRzIDExMlx1MjAxMzEyMCBXMjg3PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkJTYyAoSG9ucykgQ3JlYXRpdmUgTWVkaWEgVGVjaG5vbG9neSAxMTJcdTIwMTMxMjAgVzI4ODwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSBGaWxtIGFuZCBUZWxldmlzaW9uIFByb2R1Y3Rpb24gMTEyXHUyMDEzMTIwIFc2MDI8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIEdhbWVzIERlc2lnbiBhbmQgRGV2ZWxvcG1lbnQgKHRvcCB1cCkgVzIwMzwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgQXJjaGl0ZWN0dXJlIDEyMFx1MjAxMzEyOCBLMTAwPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIEludGVyaW9yIEFyY2hpdGVjdHVyZSBhbmQgRGVzaWduIDExMlx1MjAxMzEyMCBXMjUxPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSBBZHZlcnRpc2luZyBhbmQgRGlnaXRhbCBNYXJrZXRpbmcgMTEyXHUyMDEzMTIwIE41OTU8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIEJ1c2luZXNzIEFkbWluaXN0cmF0aW9uIDExMlx1MjAxMzEyMCBOMjUyPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIEJ1c2luZXNzIEFkbWluaXN0cmF0aW9uIChPbmxpbmUpIDExMlx1MjAxMzEyMDwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSBCdXNpbmVzcyBBZG1pbmlzdHJhdGlvbiAodG9wLXVwKSAoT25saW5lKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5CU2MgKEhvbnMpIEJ1c2luZXNzIEVjb25vbWljcyAxMTJcdTIwMTMxMjAgTDExMjwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgQnVzaW5lc3MgTWFuYWdlbWVudCAxMTJcdTIwMTMxMjAgTjEwMDwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgQnVzaW5lc3MgTWFuYWdlbWVudCB3aXRoIEluZm9ybWF0aW9uIFN5c3RlbXMgMTEyXHUyMDEzMTIwIE4xNTA8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgQnVzaW5lc3MgTWFuYWdlbWVudCB3aXRoIExlYWRlcnNoaXAgMTEyXHUyMDEzMTIwIE4xNTE8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIEJ1c2luZXNzIGFuZCBIdW1hbiBSZXNvdXJjZSBNYW5hZ2VtZW50IDExMlx1MjAxMzEyMCBONjA3PC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIEJ1c2luZXNzIGFuZCBNYXJrZXRpbmcgMTEyXHUyMDEzMTIwIE5OMU08L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QlNjIChIb25zKSBCdXNpbmVzcyBhbmQgU3BvcnQgTWFuYWdlbWVudCAoT25saW5lKSAxMDRcdTIwMTMxMTI8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QlNjIChIb25zKSBFY29ub21pY3MgMTIwXHUyMDEzMTI4IEwxMDE8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QlNjIChIb25zKSBFY29ub21pY3MgYW5kIEZpbmFuY2UgMTIwXHUyMDEzMTI4IEwxTjM8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgRXZlbnQgTWFuYWdlbWVudCAxMDRcdTIwMTMxMTIgTjgyMDwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSBFdmVudCBNYW5hZ2VtZW50IGFuZCBUb3VyaXNtIDEwNFx1MjAxMzExMiBOODkxPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIEZhc2hpb24gYW5kIEZhc2hpb24gQnVzaW5lc3MgMTEyXHUyMDEzMTIwIFcyMzE8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIEZpbmFuY2UgMTIwXHUyMDEzMTI4IE4zMDA8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpKFNXL1lBQikgSW50ZXJuYXRpb25hbCBCdXNpbmVzcyAxMjBcdTIwMTMxMjggTjEyMDwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgSW50ZXJuYXRpb25hbCBCdXNpbmVzcyBNYW5hZ2VtZW50IChUb3AgVXApIE4xMjg8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIEludGVybmF0aW9uYWwgQnVzaW5lc3Mgd2l0aCBGcmVuY2ggMTIwXHUyMDEzMTI4IE4xMjE8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIEludGVybmF0aW9uYWwgQnVzaW5lc3Mgd2l0aCBHZXJtYW4gMTIwXHUyMDEzMTI4IE4xMjI8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIEludGVybmF0aW9uYWwgQnVzaW5lc3Mgd2l0aCBKYXBhbmVzZSAxMjBcdTIwMTMxMjggTjEyMzwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSBJbnRlcm5hdGlvbmFsIEJ1c2luZXNzIHdpdGggTWFuZGFyaW4gMTIwXHUyMDEzMTI4IE4xMjQ8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIEludGVybmF0aW9uYWwgQnVzaW5lc3Mgd2l0aCBTcGFuaXNoIDEyMFx1MjAxMzEyOCBOMTI1PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSBJbnRlcm5hdGlvbmFsIFRvdXJpc20gTWFuYWdlbWVudCB3aXRoIFBsYWNlbWVudCBZZWFyIDExMlx1MjAxMzEyMCBOODMwPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSBMZWFkZXJzaGlwIGFuZCBQcm9mZXNzaW9uYWwgRGV2ZWxvcG1lbnQ8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIE1hcmtldGluZyAxMTJcdTIwMTMxMjAgTjUwMDwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5CU2MgKEhvbnMpIFNwb3J0cyBCdXNpbmVzcyBNYW5hZ2VtZW50IDEwNFx1MjAxMzExMiBOODgwPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkJTYyAoSG9ucykgQ29tcHV0ZXIgU2NpZW5jZSAxMjBcdTIwMTMxMjggRzQwMDwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJTYyAoSG9ucykgQ29tcHV0ZXIgU2NpZW5jZSAoQXBwbGllZCBEYXRhIFNjaWVuY2UpIChPbmxpbmUpIDEyMFx1MjAxMzEyODwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJTYyAoSG9ucykgQ29tcHV0ZXIgU2NpZW5jZSAoQXBwbGllZCBEYXRhIFNjaWVuY2UpIChUb3AgVXApIChPbmxpbmUpPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkJTYyAoSG9ucykgQ29tcHV0ZXIgU2NpZW5jZSAoQXJ0aWZpY2lhbCBJbnRlbGxpZ2VuY2UpIDEyMFx1MjAxMzEyOCBHRzQ3PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkJTYyAoSG9ucykgQ29tcHV0ZXIgU2NpZW5jZSAoQ3liZXIgU2VjdXJpdHkgYW5kIE5ldHdvcmtzKSAxMjBcdTIwMTMxMjggRzQ5MTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5CU2MgKEhvbnMpIENvbXB1dGVyIFNjaWVuY2UgKE9ubGluZSkgMTIwXHUyMDEzMTI4PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkJTYyAoSG9ucykgQ29tcHV0ZXIgU2NpZW5jZSAoU29mdHdhcmUgRW5naW5lZXJpbmcpIDEyMFx1MjAxMzEyOCBHRzQ2PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPkJTYyAoSG9ucykgQ29tcHV0ZXIgU2NpZW5jZSAoVG9wIFVwKSAoT25saW5lKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5CU2MgKEhvbnMpIENvbXB1dGVyIFNjaWVuY2UgKHRvcC11cCkgRzQwMzwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJTYyAoSG9ucykgRGF0YSBTY2llbmNlIDEyMFx1MjAxMzEyOCBHMjAwPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QlNjIChIb25zKSBJbmZvcm1hdGlvbiBUZWNobm9sb2d5IDEyMCBcdTIwMTMgMTI4IEc1MDE8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CU2MgKEhvbnMpIEluZm9ybWF0aW9uIFRlY2hub2xvZ3kgKE9ubGluZSkgMTIwXHUyMDEzMTI4PC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QlNjIChIb25zKSBJbmZvcm1hdGlvbiBUZWNobm9sb2d5IChUb3AgVXApIChPbmxpbmUpPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QlNjIChIb25zKSBJbmZvcm1hdGlvbiBUZWNobm9sb2d5ICh0b3AtdXApPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TUVuZyAoSG9ucykgUm9ib3RpY3MgYW5kIEFydGlmaWNpYWwgSW50ZWxsaWdlbmNlIDEyOFx1MjAxMzEzNiBINjcyPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QkVuZyAoSG9ucykgUm9ib3RpY3MgYW5kIEFydGlmaWNpYWwgSW50ZWxsaWdlbmNlIDEyMFx1MjAxMzEyOCBINjcxPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QmFjaGVsb3Igb2YgRWR1Y2F0aW9uIEhvbm91cnMgRGVncmVlIFByaW1hcnkgd2l0aCBRVFMgMTEyXHUyMDEzMTIwIFgxMjI8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgRWFybHkgQ2hpbGRob29kIEVkdWNhdGlvbiAxMDRcdTIwMTMxMTIgWDMxMDwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSBFZHVjYXRpb24gMTA0XHUyMDEzMTEyIFgzMDU8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgUHN5Y2hvbG9neSBpbiBFZHVjYXRpb24gMTEyXHUyMDEzMTIwIFgzMTE8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NRW5nIChIb25zKSBBZXJvc3BhY2UgRW5naW5lZXJpbmcgMTI4LTEzNiBINDAxPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QkVuZyAoSG9ucykgQWVyb3NwYWNlIEVuZ2luZWVyaW5nIDEyMFx1MjAxMzEyOCBINDEwPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TUVuZyAoSG9ucykgQWVyb3NwYWNlIEVuZ2luZWVyaW5nIHdpdGggUGlsb3QgU3R1ZGllcyAxMjg/MTM2IEg0OTc8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CRW5nIChIb25zKSBBZXJvc3BhY2UgRW5naW5lZXJpbmcgd2l0aCBQaWxvdCBTdHVkaWVzIDEyMD8xMjggSDQ5NjwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1FbmcgKEhvbnMpIEFlcm9zcGFjZSBFbmdpbmVlcmluZyB3aXRoIFNwYWNlIFRlY2hub2xvZ3kgMTI4XHUyMDEzMTM2IEg0MDI8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CRW5nIChIb25zKSBBZXJvc3BhY2UgRW5naW5lZXJpbmcgd2l0aCBTcGFjZSBUZWNobm9sb2d5IDEyMD8xMjggSDQwMDwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJFbmcgKEhvbnMpIEF1dG9tb3RpdmUgRW5naW5lZXJpbmcgMTIwIFx1MjAxMyAxMjggSDMzMDwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1FbmcgKEhvbnMpIEF1dG9tb3RpdmUgRW5naW5lZXJpbmcgMTI4IFx1MjAxMyAxMzYgSDM0MTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJFbmcgKEhvbnMpIEF1dG9tb3RpdmUgRW5naW5lZXJpbmcgd2l0aCBNb3RvcnNwb3J0IDEyMFx1MjAxMzEyOCBIMzM1PC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TUVuZyAoSG9ucykgQXV0b21vdGl2ZSBFbmdpbmVlcmluZyB3aXRoIE1vdG9yc3BvcnQgMTI4XHUyMDEzMTM2IEgzMzY8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CU2MgKEhvbnMpIEF1dG9tb3RpdmUgVGVjaG5vbG9neSAxMDRcdTIwMTMxMTIgSDM0MjwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1FbmcgKEhvbnMpIENpdmlsIEVuZ2luZWVyaW5nIDEyMFx1MjAxMzEyOCBIMjAwPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QkVuZyAoSG9ucykgQ2l2aWwgRW5naW5lZXJpbmcgMTEyLTEyMCBIMjAxPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QlNjIChIb25zKSBDb21wdXRlciBTY2llbmNlIChBcnRpZmljaWFsIEludGVsbGlnZW5jZSkgMTIwXHUyMDEzMTI4IEdHNDc8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CRW5nIChIb25zKSBFbGVjdHJpY2FsIGFuZCBFbGVjdHJvbmljIEVuZ2luZWVyaW5nIDEyMC0xMjggSDYwMDwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkVuZ2luZWVyaW5nIHdpdGggRm91bmRhdGlvbiBZZWFyIChPYWtsYW5kcyBDb2xsZWdlKSA0OCBIMTAwPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TUVuZyAoSG9ucykgTWVjaGFuaWNhbCBFbmdpbmVlcmluZyAxMjhcdTIwMTMxMzYgSDMwMTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJFbmcgKEhvbnMpIE1lY2hhbmljYWwgRW5naW5lZXJpbmcgMTIwXHUyMDEzMTI4IEgzMDA8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CU2MgKEhvbnMpIE1vdG9yc3BvcnQgVGVjaG5vbG9neSAxMDRcdTIwMTMxMTIgSDMzMTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJFbmcgKEhvbnMpIFJvYm90aWNzIGFuZCBBcnRpZmljaWFsIEludGVsbGlnZW5jZSAxMjBcdTIwMTMxMjggSDY3MTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1FbmcgKEhvbnMpIFJvYm90aWNzIGFuZCBBcnRpZmljaWFsIEludGVsbGlnZW5jZSAxMjhcdTIwMTMxMzYgSDY3MjwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSBFbmdsaXNoIExhbmd1YWdlIGFuZCBBcHBsaWVkIExpbmd1aXN0aWNzIDExMlx1MjAxMzEyMCBRMTUxPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIEVuZ2xpc2ggTGFuZ3VhZ2UgYW5kIENyZWF0aXZlIFdyaXRpbmcgMTEyXHUyMDEzMTIwIFExVzE8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgRW5nbGlzaCBMYW5ndWFnZSBhbmQgSm91cm5hbGlzbSAxMTJcdTIwMTMxMjAgUTFQOTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSBFbmdsaXNoIExhbmd1YWdlIGFuZCBMaW5ndWlzdGljcyAxMTJcdTIwMTMxMjAgUTE1MDwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSBFbmdsaXNoIExhbmd1YWdlIGFuZCBMaXRlcmF0dXJlIDExMlx1MjAxMzEyMCBRMVEzPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIEVuZ2xpc2ggTGFuZ3VhZ2UgYW5kIE1lZGlhIDExMlx1MjAxMzEyMCBRMVA3PC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIEVuZ2xpc2ggTGFuZ3VhZ2Ugd2l0aCBFbmdsaXNoIExhbmd1YWdlIFRlYWNoaW5nIDExMlx1MjAxMzEyMCBRMVgzPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIEVuZ2xpc2ggTGFuZ3VhZ2Ugd2l0aCBGaWxtIDExMlx1MjAxMzEyMCBRMVc2PC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIEVuZ2xpc2ggTGl0ZXJhdHVyZSAxMTJcdTIwMTMxMjAgUTM1MDwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSBFbmdsaXNoIExpdGVyYXR1cmUgYW5kIENyZWF0aXZlIFdyaXRpbmcgMTEyXHUyMDEzMTIwIFEzVzE8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgRW5nbGlzaCBMaXRlcmF0dXJlIGFuZCBKb3VybmFsaXNtIDExMlx1MjAxMzEyMCBRM1A5PC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIEVuZ2xpc2ggTGl0ZXJhdHVyZSBhbmQgTWVkaWEgMTEyXHUyMDEzMTIwIFEzUDc8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgRW5nbGlzaCBMaXRlcmF0dXJlIHdpdGggRmlsbSAxMTJcdTIwMTMxMjAgUTNXNjwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSBIaXN0b3J5IGFuZCBDcmVhdGl2ZSBXcml0aW5nIDExMlx1MjAxMzEyMCBWMVcxPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIEhpc3RvcnkgYW5kIEVuZ2xpc2ggTGFuZ3VhZ2UgMTEyXHUyMDEzMTIwIFYxUTE8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgSGlzdG9yeSBhbmQgRW5nbGlzaCBMaXRlcmF0dXJlIDExMlx1MjAxMzEyMCBWMVEzPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIEhpc3RvcnkgYW5kIEpvdXJuYWxpc20gMTEyXHUyMDEzMTIwIFYxUDk8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgUGhpbG9zb3BoeSBhbmQgQ3JlYXRpdmUgV3JpdGluZyAxMTJcdTIwMTMxMjAgVjVXMTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSBQaGlsb3NvcGh5IGFuZCBFbmdsaXNoIExhbmd1YWdlIDExMlx1MjAxMzEyMCBWNVExPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIFBoaWxvc29waHkgYW5kIEVuZ2xpc2ggTGl0ZXJhdHVyZSAxMTJcdTIwMTMxMjAgVjVRMzwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSBBcmNoaXRlY3R1cmUgMTIwXHUyMDEzMTI4IEsxMDA8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgQ2hhcmFjdGVyIGFuZCBDcmVhdGl2ZSBFZmZlY3RzIDExMlx1MjAxMzEyMCBXNjE0PC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIENvbWljcyBhbmQgQ29uY2VwdCBBcnQgMTEyXHUyMDEzMTIwIFc2MTk8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgQ3JlYXRpdmUgTWVkaWEgQXJ0cyAxMTJcdTIwMTMxMjAgVzI4NzwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSBGYXNoaW9uIGFuZCBGYXNoaW9uIEJ1c2luZXNzIDExMlx1MjAxMzEyMCBXMjMxPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIEdyYXBoaWMgRGVzaWduIDExMlx1MjAxMzEyMCBXMjEwPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIEdyYXBoaWMgRGVzaWduIEFkdmVydGlzaW5nIGFuZCBCcmFuZGluZyAxMTJcdTIwMTMxMjAgVzIxNTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSBJbGx1c3RyYXRpb24gMTEyXHUyMDEzMTIwIFcyMjE8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgSW50ZXJpb3IgQXJjaGl0ZWN0dXJlIGFuZCBEZXNpZ24gMTEyXHUyMDEzMTIwIFcyNTE8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgTW9kZWwgRGVzaWduIGFuZCBTcGVjaWFsIEVmZmVjdHMgMTEyXHUyMDEzMTIwIFc2MTU8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgVmlzdWFsIE1lcmNoYW5kaXNpbmcsIFN0eWxpbmcgYW5kIFByb21vdGlvbiAodG9wIHVwKSBXMjAyPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QlNjIChIb25zKSBCaW9jaGVtaXN0cnkgMTEyXHUyMDEzMTIwIEMxQ1I8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CU2MgKEhvbnMpIEJpb2xvZ2ljYWwgU2NpZW5jZSAxMDRcdTIwMTMxMTIgQzkwMjwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJTYyAoSG9ucykgQmlvbWVkaWNhbCBTY2llbmNlIDExMlx1MjAxMzEyMCBCOTkwPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+SW5pdGlhbCBZZWFyIGZvciBFeHRlbmRlZCBEZWdyZWUgaW4gU2NpZW5jZSBcdTIwMTMgQmlvbWVkaWNhbCBhbmQgSGVhbHRoY2FyZSBTY2llbmNlIChOb3J0aCBIZXJ0Zm9yZHNoaXJlIENvbGxlZ2UpIDQ4IEI5MDQ8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5Jbml0aWFsIFllYXIgZm9yIEV4dGVuZGVkIERlZ3JlZSBpbiBTY2llbmNlIFx1MjAxMyBCaW9tZWRpY2FsIGFuZCBIZWFsdGhjYXJlIFNjaWVuY2UgKEhlcnRmb3JkIFJlZ2lvbmFsIENvbGxlZ2UpIDQ4IEI5MDQ8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5Jbml0aWFsIFllYXIgZm9yIEV4dGVuZGVkIERlZ3JlZSBpbiBTY2llbmNlIFx1MjAxMyBCaW9tZWRpY2FsIGFuZCBIZWFsdGhjYXJlIFNjaWVuY2UgKFdlc3QgSGVydHMgQ29sbGVnZSkgNDggQjkwNDwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkluaXRpYWwgWWVhciBmb3IgRXh0ZW5kZWQgRGVncmVlIGluIFNjaWVuY2UgXHUyMDEzIEJpb21lZGljYWwgYW5kIEhlYWx0aGNhcmUgU2NpZW5jZSAoT2FrbGFuZHMgQ29sbGVnZSkgNDggQjkwNDwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJTYyAoSG9ucykgUGhhcm1hY2V1dGljYWwgU2NpZW5jZSAxMTJcdTIwMTMxMjAgQjIwMjwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJTYyAoSG9ucykgUGhhcm1hY29sb2d5IDEyMFx1MjAxMzEyOCBCMjEwPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QlNjIChIb25zKSBFbnZpcm9ubWVudGFsIE1hbmFnZW1lbnQgYW5kIEVjb2xvZ3kgMTEyLTEyMCBGNzUwPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QlNjIChIb25zKSBHZW9ncmFwaHkgMTEyLTEyMCBGODAwPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+SW5pdGlhbCBZZWFyIGZvciBFeHRlbmRlZCBEZWdyZWUgaW4gU2NpZW5jZSBcdTIwMTMgR2VvZ3JhcGh5ICZhbXA7IEVudmlyb25tZW50YWwgU2NpZW5jZXMgKE9ha2xhbmRzIENvbGxlZ2UpIDQ4IEI5MDY8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5Jbml0aWFsIFllYXIgZm9yIEV4dGVuZGVkIERlZ3JlZSBpbiBTY2llbmNlIFx1MjAxMyBHZW9ncmFwaHkgJmFtcDsgRW52aXJvbm1lbnRhbCBTY2llbmNlcyAoTm9ydGggSGVydGZvcmRzaGlyZSBDb2xsZWdlKSA0OCBCOTA2PC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+SW5pdGlhbCBZZWFyIGZvciBFeHRlbmRlZCBEZWdyZWUgaW4gU2NpZW5jZSBcdTIwMTMgR2VvZ3JhcGh5ICZhbXA7IEVudmlyb25tZW50YWwgU2NpZW5jZXMgKEhlcnRmb3JkIFJlZ2lvbmFsIENvbGxlZ2UpIDQ4IEI5MDY8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5Jbml0aWFsIFllYXIgZm9yIEV4dGVuZGVkIERlZ3JlZSBpbiBTY2llbmNlIFx1MjAxMyBHZW9ncmFwaHkgJmFtcDsgRW52aXJvbm1lbnRhbCBTY2llbmNlcyAoV2VzdCBIZXJ0cyBDb2xsZWdlKSA0OCBCOTA2PC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QlNjIChIb25zKSBEaWFnbm9zdGljIFJhZGlvZ3JhcGh5IGFuZCBJbWFnaW5nIDEyMFx1MjAxMzEyOCBCODIxPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QlNjIChIb25zKSBEaWV0ZXRpY3MgMTI4XHUyMDEzMTM2IEI0MTA8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5Jbml0aWFsIFllYXIgZm9yIEV4dGVuZGVkIERlZ3JlZSBpbiBTY2llbmNlIFx1MjAxMyBCaW9tZWRpY2FsIGFuZCBIZWFsdGhjYXJlIFNjaWVuY2UgKE5vcnRoIEhlcnRmb3Jkc2hpcmUgQ29sbGVnZSkgNDggQjkwNDwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkluaXRpYWwgWWVhciBmb3IgRXh0ZW5kZWQgRGVncmVlIGluIFNjaWVuY2UgXHUyMDEzIEJpb21lZGljYWwgYW5kIEhlYWx0aGNhcmUgU2NpZW5jZSAoSGVydGZvcmQgUmVnaW9uYWwgQ29sbGVnZSkgNDggQjkwNDwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkluaXRpYWwgWWVhciBmb3IgRXh0ZW5kZWQgRGVncmVlIGluIFNjaWVuY2UgXHUyMDEzIEJpb21lZGljYWwgYW5kIEhlYWx0aGNhcmUgU2NpZW5jZSAoV2VzdCBIZXJ0cyBDb2xsZWdlKSA0OCBCOTA0PC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+SW5pdGlhbCBZZWFyIGZvciBFeHRlbmRlZCBEZWdyZWUgaW4gU2NpZW5jZSBcdTIwMTMgQmlvbWVkaWNhbCBhbmQgSGVhbHRoY2FyZSBTY2llbmNlIChPYWtsYW5kcyBDb2xsZWdlKSA0OCBCOTA0PC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+SW5pdGlhbCBZZWFyIGZvciBFeHRlbmRlZCBEZWdyZWUgaW4gU2NpZW5jZSBcdTIwMTMgT3B0b21ldHJ5IDk2IEI1MTE8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NT3B0b20gTWFzdGVyIG9mIE9wdG9tZXRyeSAxMzZcdTIwMTMxNDQgQjUxMDwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1hc3RlciBvZiBQaGFybWFjeSAxMjggXHUyMDEzIDEzNiBCMjMwPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QlNjIChIb25zKSBNaWR3aWZlcnkgKFByZS1yZWdpc3RyYXRpb24pIDEyMFx1MjAxMzEyOCBCNzIwPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QlNjIChIb25zKSBNaWR3aWZlcnkgKFByZS1yZWdpc3RyYXRpb24sIFNob3J0ZW5lZCk8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CU2MgKEhvbnMpIE51cnNpbmcgKEFkdWx0KSAxMTJcdTIwMTMxMjAgQjcwMDwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJTYyAoSG9ucykgTnVyc2luZyAoQ2hpbGQpIDExMlx1MjAxMzEyMCBCNzAyPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QlNjIChIb25zKSBOdXJzaW5nIChMZWFybmluZyBEaXNhYmlsaXRpZXMpIDExMlx1MjAxMzEyMCBCNzYxPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QlNjIChIb25zKSBOdXJzaW5nIChNZW50YWwgSGVhbHRoKSAxMTJcdTIwMTMxMjAgQjcwMTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJTYyAoSG9ucykgUGFyYW1lZGljIFNjaWVuY2UgMTEyIFx1MjAxMyAxMjAgQjc4MDwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJTYyAoSG9ucykgUGh5c2lvdGhlcmFweSAxMjgtMTM2IEIxNjA8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CU2MgKEhvbnMpIFNvY2lhbCBXb3JrIDExMiBcdTIwMTMgMTIwIEw1MDA8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CU2MgKEhvbnMpIFRoZXJhcGV1dGljIFJhZGlvZ3JhcGh5IDExMiBcdTIwMTMgMTIwIEI4MjM8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgSGlzdG9yeSAxMTJcdTIwMTMxMjAgVjE1MDwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSBIaXN0b3J5IGFuZCBDcmVhdGl2ZSBXcml0aW5nIDExMlx1MjAxMzEyMCBWMVcxPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIEhpc3RvcnkgYW5kIEVuZ2xpc2ggTGFuZ3VhZ2UgMTEyXHUyMDEzMTIwIFYxUTE8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgSGlzdG9yeSBhbmQgRW5nbGlzaCBMaXRlcmF0dXJlIDExMlx1MjAxMzEyMCBWMVEzPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIEhpc3RvcnkgYW5kIEpvdXJuYWxpc20gMTEyXHUyMDEzMTIwIFYxUDk8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgSGlzdG9yeSBhbmQgUGhpbG9zb3BoeSAxMTJcdTIwMTMxMjAgVjFWUDwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSBIaXN0b3J5IHdpdGggRmlsbSAxMTJcdTIwMTMxMjAgVjFXNjwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSBQaGlsb3NvcGh5IDExMlx1MjAxMzEyMCBWNTUwPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIFBoaWxvc29waHkgYW5kIENyZWF0aXZlIFdyaXRpbmcgMTEyXHUyMDEzMTIwIFY1VzE8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgUGhpbG9zb3BoeSBhbmQgRW5nbGlzaCBMYW5ndWFnZSAxMTJcdTIwMTMxMjAgVjVRMTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSBQaGlsb3NvcGh5IGFuZCBFbmdsaXNoIExpdGVyYXR1cmUgMTEyXHUyMDEzMTIwIFY1UTM8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgUGhpbG9zb3BoeSBhbmQgSm91cm5hbGlzbSAxMTJcdTIwMTMxMjAgVjVQOTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSBQaGlsb3NvcGh5IGFuZCBNZWRpYSAxMTJcdTIwMTMxMjAgVjVQNzwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSBQaGlsb3NvcGh5IHdpdGggRmlsbSAxMTJcdTIwMTMxMjAgVjVXNjwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSBQaGlsb3NvcGh5LCBSZWxpZ2lvbiBhbmQgRXRoaWNzIDExMlx1MjAxMzEyMCBWNVY4PC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QmFjaGVsb3Igb2YgTGF3cyBMTEIgKEhvbnMpIDEyMD8xMjggTTEwMDwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJhY2hlbG9yIG9mIExhd3MgTExCIChIb25zKSAoQWNjZWxlcmF0ZWQpIDEyOD8xMzYgTTEwMTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSBDcmltaW5vbG9neSBhbmQgQ3JpbWluYWwgSnVzdGljZSAxMTJcdTIwMTMxMjAgTTIxMTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkxhdyB3aXRoIEZvdW5kYXRpb24gWWVhciAoV2VzdCBIZXJ0cyBDb2xsZWdlKSA0OCBNMTAyPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QlNjIChIb25zKSBQcm9mZXNzaW9uYWwgUG9saWNpbmcgMTEyXHUyMDEzMTIwIE0zMDA8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgQ3JlYXRpdmUgV3JpdGluZyBhbmQgRGlnaXRhbCBNZWRpYSBQOTAyPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIERpZ2l0YWwgTWVkaWEgYW5kIENvbW11bmljYXRpb25zIDExMlx1MjAxMzEyMCBQNzAwPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIEVuZ2xpc2ggTGFuZ3VhZ2UgYW5kIEpvdXJuYWxpc20gMTEyXHUyMDEzMTIwIFExUDk8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgRW5nbGlzaCBMYW5ndWFnZSBhbmQgTWVkaWEgMTEyXHUyMDEzMTIwIFExUDc8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgRW5nbGlzaCBMYW5ndWFnZSB3aXRoIEZpbG0gMTEyXHUyMDEzMTIwIFExVzY8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgRW5nbGlzaCBMaXRlcmF0dXJlIGFuZCBKb3VybmFsaXNtIDExMlx1MjAxMzEyMCBRM1A5PC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIEVuZ2xpc2ggTGl0ZXJhdHVyZSBhbmQgTWVkaWEgMTEyXHUyMDEzMTIwIFEzUDc8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgRW5nbGlzaCBMaXRlcmF0dXJlIHdpdGggRmlsbSAxMTJcdTIwMTMxMjAgUTNXNjwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSBIaXN0b3J5IGFuZCBKb3VybmFsaXNtIDExMlx1MjAxMzEyMCBWMVA5PC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIEhpc3RvcnkgYW5kIFBoaWxvc29waHkgMTEyXHUyMDEzMTIwIFYxVlA8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgSGlzdG9yeSB3aXRoIEZpbG0gMTEyXHUyMDEzMTIwIFYxVzY8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgSm91cm5hbGlzbSBhbmQgQ3JlYXRpdmUgV3JpdGluZyAxMTJcdTIwMTMxMjAgUDkwMDwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSBKb3VybmFsaXNtIGFuZCBEaWdpdGFsIE1lZGlhIDExMlx1MjAxMzEyMCBQOTAzPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIE1hc3MgQ29tbXVuaWNhdGlvbnMgMTEyXHUyMDEzMTIwIFAzMDA8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgUGhpbG9zb3BoeSBhbmQgSm91cm5hbGlzbSAxMTJcdTIwMTMxMjAgVjVQOTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSBQaGlsb3NvcGh5IGFuZCBNZWRpYSAxMTJcdTIwMTMxMjAgVjVQNzwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSBQaGlsb3NvcGh5IHdpdGggRmlsbSAxMTJcdTIwMTMxMjAgVjVXNjwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJTYyAoSG9ucykgQXVkaW8gRW5naW5lZXJpbmcgMTEyXHUyMDE0MTIwIFczNzQ8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CU2MgKEhvbnMpIExpdmUgU291bmQsIExpZ2h0aW5nIGFuZCBQZXJmb3JtYW5jZSBUZWNobm9sb2d5IDExMlx1MjAxNDEyMCBXMzc2PC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QlNjIChIb25zKSBNdXNpYyBDb21wb3NpdGlvbiBhbmQgU291bmQgZm9yIEZpbG0gYW5kIEdhbWVzIDExMlx1MjAxNDEyMCBXMzkyPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QlNjIChIb25zKSBNdXNpYyBQcm9kdWN0aW9uIGFuZCBQcm9tb3Rpb24gMTEyXHUyMDE0MTIwIFczNzU8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgUGVyZm9ybWluZyBBcnRzICh0b3AgdXApIFcyMDQ8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CU2MgKEhvbnMpIFNvbmd3cml0aW5nIGFuZCBBcnRpc3QgRGV2ZWxvcG1lbnQgMTEyXHUyMDE0MTIwIFczVDQ8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CU2MgKEhvbnMpIEFzdHJvcGh5c2ljcyAxMjBcdTIwMTMxMjggRjUwMTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1QaHlzIChIb25zKSBBc3Ryb3BoeXNpY3MgMTI4XHUyMDEzMTM2IEY1MTE8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NUGh5cyAoSG9ucykgQXN0cm9waHlzaWNzIHdpdGggU3BhY2UgU2NpZW5jZSAxMjhcdTIwMTMxMzYgRjUxMjwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJTYyAoSG9ucykgQXN0cm9waHlzaWNzIHdpdGggU3BhY2UgU2NpZW5jZSAxMjBcdTIwMTMxMjggRjUwMjwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJTYyAoSG9ucykgRGF0YSBTY2llbmNlIDEyMFx1MjAxMzEyOCBHMjAwPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QlNjIChIb25zKSBGaW5hbmNpYWwgTWF0aGVtYXRpY3MgMTIwXHUyMDEzMTI4IEdOMTM8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5Jbml0aWFsIFllYXIgZm9yIEV4dGVuZGVkIERlZ3JlZSBpbiBTY2llbmNlIFx1MjAxMyBNYXRoZW1hdGljcyAoTm9ydGggSGVydGZvcmRzaGlyZSBDb2xsZWdlKSA0OCBHMTAxPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+SW5pdGlhbCBZZWFyIGZvciBFeHRlbmRlZCBEZWdyZWUgaW4gU2NpZW5jZSBcdTIwMTMgUGh5c2ljYWwgU2NpZW5jZXMgKE5vcnRoIEhlcnRmb3Jkc2hpcmUgQ29sbGVnZSkgNDggRjkwMDwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJTYyAoSG9ucykgTWF0aGVtYXRpY3MgMTIwXHUyMDEzMTI4IEcxMDA8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NUGh5cyAoSG9ucykgUGh5c2ljcyAxMjhcdTIwMTMxMzYgRjMwNDwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJTYyAoSG9ucykgUGh5c2ljcyAxMjBcdTIwMTMxMjggRjMwMDwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJTYyAoSG9ucykgUGh5c2ljcyB3aXRoIFNwYWNlIFNjaWVuY2UgMTIwXHUyMDEzMTI4IEYzMDI8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NUGh5cyAoSG9ucykgUGh5c2ljcyB3aXRoIFNwYWNlIFNjaWVuY2UgMTI4XHUyMDEzMTM2IEYzMDU8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CU2MgKEhvbnMpIEJ1c2luZXNzIEVjb25vbWljcyAxMTJcdTIwMTMxMjAgTDExMjwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJTYyAoSG9ucykgRWNvbm9taWNzIDEyMFx1MjAxMzEyOCBMMTAxPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QlNjIChIb25zKSBFY29ub21pY3MgYW5kIEZpbmFuY2UgMTIwXHUyMDEzMTI4IEwxTjM8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgUG9saXRpY3MgYW5kIEludGVybmF0aW9uYWwgUmVsYXRpb25zIDExMj8xMjAgTDI5MDwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJBIChIb25zKSBTb2Npb2xvZ3kgMTEyXHUyMDEzMTIwIEwzMDA8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CQSAoSG9ucykgU29jaW9sb2d5IGFuZCBQc3ljaG9sb2d5IDExMlx1MjAxMzEyMCBMM0M4PC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+SW5pdGlhbCBZZWFyIGZvciBFeHRlbmRlZCBEZWdyZWUgaW4gU2NpZW5jZSBcdTIwMTMgUHN5Y2hvbG9neSAoV2VzdCBIZXJ0cyBDb2xsZWdlKSA0OCBCOTA1PC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QlNjIChIb25zKSBQc3ljaG9sb2d5IDEyMFx1MjAxMzEyOCBDODAwPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIFBzeWNob2xvZ3kgaW4gRWR1Y2F0aW9uIDExMlx1MjAxMzEyMCBYMzExPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QkEgKEhvbnMpIFNvY2lvbG9neSBhbmQgUHN5Y2hvbG9neSAxMTJcdTIwMTMxMjAgTDNDODwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkJTYyAoSG9ucykgU3BvcnRzIFN0dWRpZXMgd2l0aCBQc3ljaG9sb2d5IDEwNFx1MjAxMzExMiBDNjAzPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QlNjIChIb25zKSBCdXNpbmVzcyBhbmQgU3BvcnQgTWFuYWdlbWVudCAoT25saW5lKSAxMDRcdTIwMTMxMTI8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5Jbml0aWFsIFllYXIgZm9yIEV4dGVuZGVkIERlZ3JlZSBpbiBTY2llbmNlIFx1MjAxMyBTcG9ydHMgKE9ha2xhbmRzIENvbGxlZ2UpIDQ4IEI5MDM8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5Jbml0aWFsIFllYXIgZm9yIEV4dGVuZGVkIERlZ3JlZSBpbiBTY2llbmNlIFx1MjAxMyBTcG9ydHMgKEhlcnRmb3JkIFJlZ2lvbmFsIENvbGxlZ2UpIDQ4IEI5MDM8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CU2MgKEhvbnMpIFNwb3J0IGFuZCBFeGVyY2lzZSBTY2llbmNlIDExMiBcdTIwMTMgMTIwIEM2MDA8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CU2MgKEhvbnMpIFNwb3J0cyBCdXNpbmVzcyBNYW5hZ2VtZW50IDEwNFx1MjAxMzExMiBOODgwPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QlNjIChIb25zKSBTcG9ydHMgQ29hY2hpbmcgMTA0XHUyMDEzMTEyIEM2MTA8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CU2MgKEhvbnMpIFNwb3J0cyBTdHVkaWVzIDEwNFx1MjAxMzExMiBDNjAyPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+QlNjIChIb25zKSBTcG9ydHMgU3R1ZGllcyB3aXRoIFBzeWNob2xvZ3kgMTA0XHUyMDEzMTEyIEM2MDM8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5CU2MgKEhvbnMpIFNwb3J0cyBUaGVyYXB5IDExMlx1MjAxMyAxMjAgQ0I2MzwvbGk+XHJcbjwvdWw+XHJcbjxhIGhyZWY9XCJodHRwczovL3d3dy5oZXJ0cy5hYy51ay9jb3Vyc2VzL3VuZGVyZ3JhZHVhdGUtY291cnNlc1wiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+XHJcbk1vcmUgSW5mbyBvbiBVbmRlcmdyYWR1YXRlIERlZ3JlZXNcclxuPC9hPlxyXG48aDM+R3JhZHVhdGUgSW5mb3JtYXRpb248L2gzPlxyXG48aDQ+VVMgRW50cnkgUmVxdWlyZW1lbnRzPC9oND5cclxuQ29tcGxldGlvbiBvZiBhIDQgeWVhciBiYWNoZWxvcnMgZGVncmVlIHdpdGggR1BBIDIuNSBvdXQgb2YgNFxyXG5cclxuPGEgdGFiaW5kZXg9XCIwXCI+VmlldyBBbGwgR3JhZHVhdGUgTWFqb3JzPC9hPlxyXG48dWw+XHJcbiBcdDxsaT5NU2MgRmluYW5jZSBhbmQgSW52ZXN0bWVudCBCYW5raW5nPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPk1TYyBGaW5hbmNlIGFuZCBJbnZlc3RtZW50IEJhbmtpbmcgd2l0aCBBZHZhbmNlZCBSZXNlYXJjaDwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NU2MgRmluYW5jZSBhbmQgSW52ZXN0bWVudCBCYW5raW5nIHdpdGggRXh0ZW5kZWQgUHJvZmVzc2lvbmFsIFByYWN0aWNlPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPk1BIEFuaW1hdGlvbjwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NQSBDaGFyYWN0ZXIgYW5kIENyZWF0dXJlIEFuaW1hdGlvbiAoT25saW5lKTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1BIENvbmNlcHQgQXJ0PC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TUEgRGlnaXRhbCBNZWRpYSBBcnRzPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPk1BIEZpbG0gUHJvZHVjdGlvbjwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NQSBHYW1lcyBBcnQgYW5kIERlc2lnbjwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NQSBHbG9iYWwgRmlsbSBhbmQgVGVsZXZpc2lvbiAoT25saW5lKTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NQSBTY3JlZW53cml0aW5nPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TUFyY2ggQXJjaGl0ZWN0dXJlIGFuZCBVcmJhbmlzbTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NQSBJbnRlcmlvciBBcmNoaXRlY3R1cmUgYW5kIERlc2lnbjwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NQSBBcnQgVGhlcmFweTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NQSBHcmFwaGljIERlc2lnbiBhbmQgQnJhbmRpbmc8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+TUEgSWxsdXN0cmF0aW9uPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TUEgSW50ZXJpb3IgQXJjaGl0ZWN0dXJlIGFuZCBEZXNpZ248L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+TVNjIENhbmNlciBJbW11bm90aGVyYXB5PC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPk1TYyBDYW5jZXIgSW1tdW5vdGhlcmFweSB3aXRoIFBsYWNlbWVudCBZZWFyPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPk1TYyBDYW5jZXIgSW1tdW5vdGhlcmFweSB3aXRoIEFkdmFuY2VkIFJlc2VhcmNoPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPk1TYyBEcnVnIERpc2NvdmVyeSBhbmQgVG94aWNvbG9neTwvbGk+XHJcbiBcdDxsaSBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCIgYXJpYS1sZXZlbD1cIjFcIj5NU2MgRHJ1ZyBEaXNjb3ZlcnkgYW5kIFRveGljb2xvZ3kgd2l0aCBQbGFjZW1lbnQgWWVhcjwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1TYyBEcnVnIERpc2NvdmVyeSBhbmQgVG94aWNvbG9neSB3aXRoIEFkdmFuY2VkIFJlc2VhcmNoPC9saT5cclxuIFx0PGxpIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIiBhcmlhLWxldmVsPVwiMVwiPk1TYyBNZWRpY2FsIE1pY3JvYmlvbG9neTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1TYyBNZWRpY2FsIE1pY3JvYmlvbG9neSB3aXRoIFBsYWNlbWVudCBZZWFyPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TVNjIE1lZGljYWwgTWljcm9iaW9sb2d5IHdpdGggQWR2YW5jZWQgUmVzZWFyY2g8L2xpPlxyXG4gXHQ8bGkgc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiIGFyaWEtbGV2ZWw9XCIxXCI+TVNjIE1vbGVjdWxhciBCaW90ZWNobm9sb2d5PC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TVNjIE1vbGVjdWxhciBCaW90ZWNobm9sb2d5IHdpdGggUGxhY2VtZW50IFllYXI8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NU2MgTW9sZWN1bGFyIEJpb3RlY2hub2xvZ3kgd2l0aCBBZHZhbmNlZCBSZXNlYXJjaDwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1TYyBQaGFybWFjb3ZpZ2lsYW5jZTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPlBnQ2VydCBQaGFybWFjb3ZpZ2lsYW5jZTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPlBnRGlwIFBoYXJtYWNvdmlnaWxhbmNlPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+UGdEaXAgUGhhcm1hY3kgXHUyMDEzIE92ZXJzZWFzIFBoYXJtYWNpc3RzIEFzc2Vzc21lbnQgUHJvZ3JhbW1lIChPU1BBUCk8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5QZ0RpcCBQaGFybWFjeSBQcmFjdGljZTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1TYyBCdXNpbmVzcyBBbmFseXRpY3MgYW5kIENvbnN1bHRhbmN5PC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TVNjIEJ1c2luZXNzIFBzeWNob2xvZ3k8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NU2MgRmluYW5jZSBhbmQgSW52ZXN0bWVudCBCYW5raW5nPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TVNjIEZpbmFuY2UgYW5kIEludmVzdG1lbnQgQmFua2luZyB3aXRoIEFkdmFuY2VkIFJlc2VhcmNoPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TVNjIEZpbmFuY2UgYW5kIEludmVzdG1lbnQgQmFua2luZyB3aXRoIEV4dGVuZGVkIFByb2Zlc3Npb25hbCBQcmFjdGljZTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkdsb2JhbCBFeGVjdXRpdmUgTWFzdGVyIG9mIEJ1c2luZXNzIEFkbWluaXN0cmF0aW9uIChPbmxpbmUpPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+R2xvYmFsIEV4ZWN1dGl2ZSBNYXN0ZXIgb2YgQnVzaW5lc3MgQWRtaW5pc3RyYXRpb24gd2l0aCBBbGdvcml0aG1pYyBNYXJrZXRpbmcgKE9ubGluZSk8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5HbG9iYWwgRXhlY3V0aXZlIE1hc3RlciBvZiBCdXNpbmVzcyBBZG1pbmlzdHJhdGlvbiB3aXRoIEFydGlmaWNpYWwgSW50ZWxsaWdlbmNlIChPbmxpbmUpPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+R2xvYmFsIEV4ZWN1dGl2ZSBNYXN0ZXIgb2YgQnVzaW5lc3MgQWRtaW5pc3RyYXRpb24gd2l0aCBDeWJlciBTZWN1cml0eSAoT25saW5lKTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPkdsb2JhbCBFeGVjdXRpdmUgTWFzdGVyIG9mIEJ1c2luZXNzIEFkbWluaXN0cmF0aW9uIHdpdGggRGF0YSBTY2llbmNlIChPbmxpbmUpPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+R2xvYmFsIEV4ZWN1dGl2ZSBNYXN0ZXIgb2YgQnVzaW5lc3MgQWRtaW5pc3RyYXRpb24gd2l0aCBTdXN0YWluYWJpbGl0eSAoT25saW5lKTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPlBnRGlwIEh1bWFuIFJlc291cmNlIE1hbmFnZW1lbnQ8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NQSBIdW1hbiBSZXNvdXJjZSBNYW5hZ2VtZW50PC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TUEgSHVtYW4gUmVzb3VyY2UgTWFuYWdlbWVudCB3aXRoIFBsYWNlbWVudCBZZWFyPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TUEgSHVtYW4gUmVzb3VyY2UgTWFuYWdlbWVudCAoR2xvYmFsKTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1BIEh1bWFuIFJlc291cmNlIE1hbmFnZW1lbnQgKFdvcmsgUHN5Y2hvbG9neSk8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NQSBIdW1hbiBSZXNvdXJjZSBNYW5hZ2VtZW50IHdpdGggQWR2YW5jZWQgUmVzZWFyY2g8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NU2MgSW50ZXJuYXRpb25hbCBCdXNpbmVzczwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1TYyBJbnRlcm5hdGlvbmFsIEJ1c2luZXNzIHdpdGggUGxhY2VtZW50IFllYXI8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NU2MgSW50ZXJuYXRpb25hbCBCdXNpbmVzcyB3aXRoIEFkdmFuY2VkIFJlc2VhcmNoPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TVNjIEludGVybmF0aW9uYWwgVG91cmlzbSwgSG9zcGl0YWxpdHkgJmFtcDsgRXZlbnQgTWFuYWdlbWVudCB3aXRoIEFkdiBQcm9qZWN0PC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TVNjIEludGVybmF0aW9uYWwgVG91cmlzbSwgSG9zcGl0YWxpdHkgJmFtcDsgRXZlbnQgTWFuYWdlbWVudCB3aXRoIEV4dCBQcm8gUHJhY3RpY2U8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NU2MgSW50ZXJuYXRpb25hbCBUb3VyaXNtLCBIb3NwaXRhbGl0eSBhbmQgRXZlbnQgTWFuYWdlbWVudDwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1TYyBNYW5hZ2VtZW50PC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TVNjIE1hbmFnZW1lbnQgKE9ubGluZSk8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NU2MgTWFuYWdlbWVudCB3aXRoIERpZ2l0YWwgTWFya2V0aW5nPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TVNjIE1hbmFnZW1lbnQgd2l0aCBMb2dpc3RpY3MgYW5kIFN1cHBseSBDaGFpbiBNYW5hZ2VtZW50PC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TVNjIE1hbmFnZW1lbnQgd2l0aCBTdXN0YWluYWJpbGl0eTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1TYyBNYW51ZmFjdHVyaW5nIE1hbmFnZW1lbnQ8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NU2MgTWFudWZhY3R1cmluZyBNYW5hZ2VtZW50ICgxOC1tb250aCByb3V0ZSk8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NU2MgTWFudWZhY3R1cmluZyBNYW5hZ2VtZW50IHdpdGggQWR2YW5jZWQgUHJvamVjdDwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1TYyBNYW51ZmFjdHVyaW5nIE1hbmFnZW1lbnQgd2l0aCBFeHRlbmRlZCBQcm9mZXNzaW9uYWwgUHJhY3RpY2U8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NYXN0ZXIgb2YgQnVzaW5lc3MgQWRtaW5pc3RyYXRpb248L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NYXN0ZXIgb2YgQnVzaW5lc3MgQWRtaW5pc3RyYXRpb24gKEFkdmVydGlzaW5nIGFuZCBCcmFuZCBNYW5hZ2VtZW50KTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1hc3RlciBvZiBCdXNpbmVzcyBBZG1pbmlzdHJhdGlvbiAoQXJ0aWZpY2lhbCBJbnRlbGxpZ2VuY2UpPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TWFzdGVyIG9mIEJ1c2luZXNzIEFkbWluaXN0cmF0aW9uIChEYXRhIEFuYWx5dGljcyk8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NYXN0ZXIgb2YgQnVzaW5lc3MgQWRtaW5pc3RyYXRpb24gKERpZ2l0YWwgTWFya2V0aW5nKTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1hc3RlciBvZiBCdXNpbmVzcyBBZG1pbmlzdHJhdGlvbiAoRmluVGVjaCk8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NYXN0ZXIgb2YgQnVzaW5lc3MgQWRtaW5pc3RyYXRpb24gKEdsb2JhbCBCdXNpbmVzcyBEZXZlbG9wbWVudCk8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NYXN0ZXIgb2YgQnVzaW5lc3MgQWRtaW5pc3RyYXRpb24gKEhlYWx0aGNhcmUpPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TWFzdGVyIG9mIEJ1c2luZXNzIEFkbWluaXN0cmF0aW9uIChIdW1hbiBSZXNvdXJjZXMpPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TWFzdGVyIG9mIEJ1c2luZXNzIEFkbWluaXN0cmF0aW9uIChMb2dpc3RpY3MgYW5kIFN1cHBseSBDaGFpbiBNYW5hZ2VtZW50KTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1hc3RlciBvZiBCdXNpbmVzcyBBZG1pbmlzdHJhdGlvbiAoUHJvamVjdCBNYW5hZ2VtZW50KTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1hc3RlciBvZiBCdXNpbmVzcyBBZG1pbmlzdHJhdGlvbiAoUmlzayBNYW5hZ2VtZW50IGFuZCBJbnZlc3RtZW50KTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1TYyBQcm9qZWN0IE1hbmFnZW1lbnQ8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NQSBQdWJsaWMgUmVsYXRpb25zIGFuZCBEaWdpdGFsIENvbW11bmljYXRpb25zPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TUEgUHVibGljIFJlbGF0aW9ucyBhbmQgRGlnaXRhbCBDb21tdW5pY2F0aW9ucyB3aXRoIFBsYWNlbWVudCBZZWFyPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TUEgUHVibGljIFJlbGF0aW9ucyBhbmQgRGlnaXRhbCBDb21tdW5pY2F0aW9ucyB3aXRoIEFkdmFuY2VkIFJlc2VhcmNoPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TVNjIFN0cmF0ZWdpYyBNYXJrZXRpbmcgd2l0aCBCcmFuZCBMZWFkZXJzaGlwPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TVNjIFN0cmF0ZWdpYyBNYXJrZXRpbmcgd2l0aCBCcmFuZCBMZWFkZXJzaGlwIHdpdGggUGxhY2VtZW50IFllYXI8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NU2MgU3RyYXRlZ2ljIE1hcmtldGluZyB3aXRoIEJyYW5kIExlYWRlcnNoaXAgKEV4cGVyaWVudGlhbCBMZWFybmluZyk8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NU2MgU3RyYXRlZ2ljIE1hcmtldGluZyB3aXRoIERpZ2l0YWwgTWVkaWEgTWFuYWdlbWVudDwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1TYyBTdHJhdGVnaWMgTWFya2V0aW5nIHdpdGggRGlnaXRhbCBNZWRpYSBNYW5hZ2VtZW50IHdpdGggUGxhY2VtZW50IFllYXI8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NU2MgU3RyYXRlZ2ljIE1hcmtldGluZyB3aXRoIERpZ2l0YWwgTWVkaWEgTWFuYWdlbWVudCAoRXhwZXJpZW50aWFsIExlYXJuaW5nKTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1TYyBTdHJhdGVnaWMgTWFya2V0aW5nIHdpdGggR2xvYmFsIEJ1c2luZXNzIERldmVsb3BtZW50PC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TVNjIFN0cmF0ZWdpYyBNYXJrZXRpbmcgd2l0aCBHbG9iYWwgQnVzaW5lc3MgRGV2ZWxvcG1lbnQgd2l0aCBQbGFjZW1lbnQgWWVhcjwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1TYyBTdHJhdGVnaWMgTWFya2V0aW5nIHdpdGggR2xvYmFsIEJ1c2luZXNzIERldmVsb3BtZW50IChFeHBlcmllbnRpYWwgTGVhcm5pbmcpPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TVNjIFN1cHBseSBDaGFpbiBhbmQgTG9naXN0aWNzIE1hbmFnZW1lbnQ8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NU2MgU3VwcGx5IENoYWluIGFuZCBMb2dpc3RpY3MgTWFuYWdlbWVudCAoMTgtbW9udGggcm91dGUpPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TVNjIFN1cHBseSBDaGFpbiBhbmQgTG9naXN0aWNzIE1hbmFnZW1lbnQgd2l0aCBBZHZhbmNlZCBQcm9qZWN0PC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TVNjIFN1cHBseSBDaGFpbiBhbmQgTG9naXN0aWNzIE1hbmFnZW1lbnQgd2l0aCBFeHRlbmRlZCBQcm9mZXNzaW9uYWwgUHJhY3RpY2U8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NU2MgQWR2YW5jZWQgQ29tcHV0ZXIgU2NpZW5jZTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1TYyBBZHZhbmNlZCBDb21wdXRlciBTY2llbmNlIHdpdGggUGxhY2VtZW50IFllYXI8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NU2MgQWR2YW5jZWQgQ29tcHV0ZXIgU2NpZW5jZSAoT25saW5lKTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1TYyBBZHZhbmNlZCBDb21wdXRlciBTY2llbmNlIHdpdGggUmVzZWFyY2g8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NU2MgQXJ0aWZpY2lhbCBJbnRlbGxpZ2VuY2UgKE9ubGluZSk8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NU2MgQXJ0aWZpY2lhbCBJbnRlbGxpZ2VuY2UgYW5kIFJvYm90aWNzPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TVNjIEFydGlmaWNpYWwgSW50ZWxsaWdlbmNlIGFuZCBSb2JvdGljcyB3aXRoIFBsYWNlbWVudCBZZWFyPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TVNjIEFydGlmaWNpYWwgSW50ZWxsaWdlbmNlIGFuZCBSb2JvdGljcyB3aXRoIEFkdmFuY2VkIFJlc2VhcmNoPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TVNjIENvbXB1dGVyIE5ldHdvcmtzIGFuZCBTeXN0ZW1zIFNlY3VyaXR5PC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TVNjIENvbXB1dGVyIE5ldHdvcmtzIGFuZCBTeXN0ZW1zIFNlY3VyaXR5IHdpdGggUGxhY2VtZW50IFllYXI8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NU2MgQ29tcHV0ZXIgTmV0d29ya3MgYW5kIFN5c3RlbXMgU2VjdXJpdHkgd2l0aCBBZHZhbmNlZCBSZXNlYXJjaDwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1TYyBDb21wdXRlciBTY2llbmNlPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TVNjIENvbXB1dGVyIFNjaWVuY2UgKE9ubGluZSk8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NU2MgQ29tcHV0ZXIgU2NpZW5jZSB3aXRoIEFydGlmaWNpYWwgSW50ZWxsaWdlbmNlIChPbmxpbmUpPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TVNjIENvbXB1dGVyIFNjaWVuY2Ugd2l0aCBDeWJlciBTZWN1cml0eSAoT25saW5lKTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1TYyBDb21wdXRlciBTY2llbmNlIHdpdGggRGF0YSBBbmFseXRpY3MgKE9ubGluZSk8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NU2MgQ29tcHV0ZXIgU2NpZW5jZSB3aXRoIFNvZnR3YXJlIEVuZ2luZWVyaW5nIChPbmxpbmUpPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TVNjIEN5YmVyIFNlY3VyaXR5PC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TVNjIEN5YmVyIFNlY3VyaXR5IHdpdGggUGxhY2VtZW50IFllYXI8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NU2MgQ3liZXIgU2VjdXJpdHkgKE9ubGluZSk8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NU2MgQ3liZXIgU2VjdXJpdHkgd2l0aCBBZHZhbmNlZCBSZXNlYXJjaDwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1TYyBEYXRhIFNjaWVuY2U8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NU2MgRGF0YSBTY2llbmNlIHdpdGggUGxhY2VtZW50IFllYXI8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NU2MgRGF0YSBTY2llbmNlIGFuZCBBbmFseXRpY3M8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NU2MgRGF0YSBTY2llbmNlIGFuZCBBbmFseXRpY3Mgd2l0aCBQbGFjZW1lbnQgWWVhcjwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1TYyBEYXRhIFNjaWVuY2UgYW5kIEFuYWx5dGljcyAoT25saW5lKTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1TYyBEYXRhIFNjaWVuY2UgYW5kIEFuYWx5dGljcyB3aXRoIEFkdmFuY2VkIFJlc2VhcmNoPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TVNjIERhdGEgU2NpZW5jZSB3aXRoIEFkdmFuY2VkIFJlc2VhcmNoPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TVNjIFNvZnR3YXJlIEVuZ2luZWVyaW5nPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TVNjIFNvZnR3YXJlIEVuZ2luZWVyaW5nIHdpdGggUGxhY2VtZW50IFllYXI8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NU2MgU29mdHdhcmUgRW5naW5lZXJpbmcgKE9ubGluZSk8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NU2MgU29mdHdhcmUgRW5naW5lZXJpbmcgd2l0aCBBZHZhbmNlZCBSZXNlYXJjaDwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1BIEVhcmx5IENoaWxkaG9vZCBFZHVjYXRpb248L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NQSBFZHVjYXRpb248L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NQSBFZHVjYXRpb24gd2l0aCBQbGFjZW1lbnQgWWVhcjwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1BIEVkdWNhdGlvbiB3aXRoIEFkdmFuY2VkIFJlc2VhcmNoPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+TUEgTWVudGFsIEhlYWx0aCBhbmQgV2VsbGJlaW5nIGluIEVkdWNhdGlvbiAoMiBZZWFyIFJvdXRlKTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1BIE1lbnRhbCBIZWFsdGggYW5kIFdlbGxiZWluZyBpbiBFZHVjYXRpb24gKDMgWWVhciBSb3V0ZSk8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NU2MgT3V0ZG9vciBFbnZpcm9ubWVudGFsIEVkdWNhdGlvbjwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPlBnQ2VydCBPdXRkb29yIEVudmlyb25tZW50YWwgRWR1Y2F0aW9uPC9saT5cclxuIFx0PGxpIGFyaWEtbGV2ZWw9XCIxXCI+UGdEaXAgT3V0ZG9vciBFbnZpcm9ubWVudGFsIEVkdWNhdGlvbjwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPlBHQ0UgYW5kIFByb2ZHQ0UgaW4gU2Vjb25kYXJ5IEVkdWNhdGlvbiBNb2Rlcm4gRm9yZWlnbiBMYW5ndWFnZXM8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NQSBUZWFjaGluZyBFbmdsaXNoIHRvIFNwZWFrZXJzIG9mIE90aGVyIExhbmd1YWdlczwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1TYyBBZXJvc3BhY2UgRW5naW5lZXJpbmc8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NU2MgQWVyb3NwYWNlIEVuZ2luZWVyaW5nICgxOC1tb250aCByb3V0ZSk8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NU2MgQWVyb3NwYWNlIEVuZ2luZWVyaW5nIHdpdGggQWR2YW5jZWQgUHJvamVjdDwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1TYyBBZXJvc3BhY2UgRW5naW5lZXJpbmcgd2l0aCBFeHRlbmRlZCBQcm9mZXNzaW9uYWwgUHJhY3RpY2U8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NU2MgQXJ0aWZpY2lhbCBJbnRlbGxpZ2VuY2UgYW5kIFJvYm90aWNzIHdpdGggUGxhY2VtZW50IFllYXI8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NU2MgQXJ0aWZpY2lhbCBJbnRlbGxpZ2VuY2UgYW5kIFJvYm90aWNzIHdpdGggQWR2YW5jZWQgUmVzZWFyY2g8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NU2MgQXV0b21vdGl2ZSBFbmdpbmVlcmluZzwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldmVsPVwiMVwiPk1TYyBBdXRvbW90aXZlIEVuZ2luZWVyaW5nICgxOC1tb250aCByb3V0ZSk8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NU2MgQXV0b21vdGl2ZSBFbmdpbmVlcmluZyB3aXRoIEFkdmFuY2VkIFByb2plY3Q8L2xpPlxyXG4gXHQ8bGkgYXJpYS1sZXZlbD1cIjFcIj5NU2MgQXV0b21vdGl2ZSBFbmdpbmVlcmluZyB3aXRoIEV4dGVuZGVkIFByb2Zlc3Npb25hbCBQcmFjdGljZTwvbGk+XHJcbiBcdDxsaSBhcmlhLWxldm