Media labs

Media Innovation Mapping research seeks to understand innovation and the organisational structures that exist with news publishers, content producers, research institutions and clusters and technology providers.

It is a collaboration between the the World Association of Newspapers and News Publishers’ Global Alliance for Media Innovation, the Media Innovation Studio at UCLan, Ubilab at PUCRS university in Brazil, Norway’s NxtMedia innovation cluster and Stibo Accelerator based in Denmark.

The project plans to ‘map’ innovation labs, clusters and a selection of projects globally to establish insights into a number of factors. These include how the media labs are structured, and why they were created, what type of methods they use to innovate, their products and services and stories of their successes and failures.

Want to tell us about your Media Lab? Or to talk to us about the innovation process in your company?
Contact us

eyJtYXBfb3B0aW9ucyI6eyJjZW50ZXJfbGF0IjoiNDguODU2NjE0IiwiY2VudGVyX2xuZyI6IjIuMzUyMjIxOSIsInpvb20iOjIsIm1hcF90eXBlX2lkIjoiUk9BRE1BUCIsImNlbnRlcl9ieV9uZWFyZXN0IjpmYWxzZSwiZml0X2JvdW5kcyI6ZmFsc2UsImNlbnRlcl9jaXJjbGVfZmlsbGNvbG9yIjoiIzhDQUVGMiIsImNlbnRlcl9jaXJjbGVfZmlsbG9wYWNpdHkiOiIuNSIsImNlbnRlcl9jaXJjbGVfc3Ryb2tlY29sb3IiOiIjOENBRUYyIiwiY2VudGVyX2NpcmNsZV9zdHJva2VvcGFjaXR5IjoiLjUiLCJjZW50ZXJfY2lyY2xlX3JhZGl1cyI6IjUiLCJzaG93X2NlbnRlcl9jaXJjbGUiOmZhbHNlLCJzaG93X2NlbnRlcl9tYXJrZXIiOmZhbHNlLCJjZW50ZXJfbWFya2VyX2ljb24iOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3BsdWdpbnMvd3AtZ29vZ2xlLW1hcC1nb2xkL2Fzc2V0cy9pbWFnZXMvL2RlZmF1bHRfbWFya2VyLnBuZyIsImNlbnRlcl9jaXJjbGVfc3Ryb2tld2VpZ2h0IjoiMSIsImRyYWdnYWJsZSI6dHJ1ZSwiZ2VzdHVyZSI6ImF1dG8iLCJtYXJrZXJfZGVmYXVsdF9pY29uIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTgvMDIvbWFya2VyLTEucG5nIiwiaW5mb3dpbmRvd19zZXR0aW5nIjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW1jb250ZW50LXBhZGRpbmcgXCI+XG48ZGl2IGNsYXNzPVwiZmMtaXRlbS10aXRsZVwiPnttYXJrZXJfdGl0bGV9IDxzcGFuIGNsYXNzPVwiZmMtYmFkZ2UgaW5mb1wiPnttYXJrZXJfY2F0ZWdvcnl9PC9zcGFuPjwvZGl2PlxuPGRpdiBjbGFzcz1cImZjLWl0ZW0tY29udGVudCBmYy1pdGVtLWJvZHktdGV4dC1jb2xvclwiPlxuPGRpdiBjbGFzcz1cImZjLWl0ZW0tZmVhdHVyZWQgZmMtbGVmdCBmYy1pdGVtLXRvcF9zcGFjZVwiPlxuICAgICAgICAgICAgICAge21hcmtlcl9pbWFnZX1cbiAgICAgICAgICAgIDwvZGl2PlxuPHA+ICAgICAgICAgICB7bWFya2VyX21lc3NhZ2V9XG4gICAgPC9wPjwvZGl2PlxuPGFkZHJlc3MgY2xhc3M9XCJmYy10ZXh0XCI+e21hcmtlcl9hZGRyZXNzfTwvYWRkcmVzcz5cbjwvZGl2PlxuIiwiaW5mb3dpbmRvd19nZW90YWdzX3NldHRpbmciOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICB7cG9zdF9mZWF0dXJlZF9pbWFnZX1cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1wYWRkaW5nLWNvbnRlbnRfMjBcIj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1tZXRhIGZjLWl0ZW0tc2Vjb25kYXJ5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2UgZmMtdGV4dC1jZW50ZXJcIj57cG9zdF9jYXRlZ29yaWVzfTwvZGl2PlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLXRleHQtY2VudGVyXCI+e3Bvc3RfdGl0bGV9PC9kaXY+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tY29udGVudCBmYy1pdGVtLWJvZHktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZVwiPlxyXG4gICAgICAgICAgICB7cG9zdF9leGNlcnB0fVxyXG4gICAgICAgIDwvZGl2PlxyXG48YSBocmVmPVwie3Bvc3RfbGlua31cIj5SZWFkIG1vcmU8L2E+XHJcbiAgICA8L2Rpdj5cclxuICAgIDwvZGl2PlxyXG48L2Rpdj5cclxuXHJcbiIsImluZm93aW5kb3dfc2tpbiI6eyJuYW1lIjoiZGVmYXVsdCIsInR5cGUiOiJpbmZvd2luZG93Iiwic291cmNlY29kZSI6IjxkaXYgY2xhc3M9XCJmYy1pdGVtLWJveCBmYy1pdGVtY29udGVudC1wYWRkaW5nIFwiPlxyXG5cdDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlXCI+e21hcmtlcl90aXRsZX0gPHNwYW4gY2xhc3M9XCJmYy1iYWRnZSBpbmZvXCI+e21hcmtlcl9jYXRlZ29yeX08L3NwYW4+PC9kaXY+IFxyXG5cdDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3JcIj5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tZmVhdHVyZWQgZmMtbGVmdCBmYy1pdGVtLXRvcF9zcGFjZVwiPlxyXG4gICAgICAgICAgICAgICB7bWFya2VyX2ltYWdlfVxyXG4gICAgICAgICAgICA8L2Rpdj5cclxuICAgICAgICAgICB7bWFya2VyX21lc3NhZ2V9XHJcbiAgICA8L2Rpdj5cclxuICAgIDxhZGRyZXNzIGNsYXNzPVwiZmMtdGV4dFwiPnttYXJrZXJfYWRkcmVzc308L2FkZHJlc3M+XHJcbjwvZGl2PlxyXG4ifSwiaW5mb3dpbmRvd19wb3N0X3NraW4iOnsibmFtZSI6InVkaW5lIiwidHlwZSI6InBvc3QiLCJzb3VyY2Vjb2RlIjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZ1wiPlxyXG4gICAge3Bvc3RfZmVhdHVyZWRfaW1hZ2V9XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZ1wiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tcGFkZGluZy1jb250ZW50XzIwXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tbWV0YSBmYy1pdGVtLXNlY29uZGFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlIGZjLXRleHQtY2VudGVyXCI+e3Bvc3RfY2F0ZWdvcmllc308L2Rpdj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS10aXRsZSBmYy1pdGVtLXByaW1hcnktdGV4dC1jb2xvciBmYy10ZXh0LWNlbnRlclwiPntwb3N0X3RpdGxlfTwvZGl2PlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2VcIj5cclxuICAgICAgICAgICAge3Bvc3RfZXhjZXJwdH1cclxuICAgICAgICA8L2Rpdj5cclxuPGEgaHJlZj1cIntwb3N0X2xpbmt9XCI+UmVhZCBtb3JlPC9hPlxyXG4gICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuPC9kaXY+XHJcblxyXG4ifSwiaW5mb3dpbmRvd19kcm9wX2FuaW1hdGlvbiI6ZmFsc2UsImNsb3NlX2luZm93aW5kb3dfb25fbWFwX2NsaWNrIjp0cnVlLCJkZWZhdWx0X2luZm93aW5kb3dfb3BlbiI6ZmFsc2UsImluZm93aW5kb3dfb3Blbl9ldmVudCI6ImNsaWNrIiwibGlzdGluZ19pbmZvd2luZG93X29wZW5fZXZlbnQiOiJjbGljayIsImlzX21vYmlsZSI6dHJ1ZSwiaW5mb3dpbmRvd19maWx0ZXJfb25seSI6ZmFsc2UsImluZm93aW5kb3dfY2xpY2tfY2hhbmdlX3pvb20iOjAsImluZm93aW5kb3dfY2xpY2tfY2hhbmdlX2NlbnRlciI6ZmFsc2UsImZ1bGxfc2NyZWVuX2NvbnRyb2wiOmZhbHNlLCJzZWFyY2hfY29udHJvbCI6dHJ1ZSwiem9vbV9jb250cm9sIjp0cnVlLCJtYXBfdHlwZV9jb250cm9sIjpmYWxzZSwic3RyZWV0X3ZpZXdfY29udHJvbCI6ZmFsc2UsImxvY2F0ZW1lX2NvbnRyb2wiOmZhbHNlLCJtb2JpbGVfc3BlY2lmaWMiOmZhbHNlLCJ6b29tX21vYmlsZSI6NSwiZHJhZ2dhYmxlX21vYmlsZSI6dHJ1ZSwic2Nyb2xsX3doZWVsX21vYmlsZSI6dHJ1ZSwiZnVsbF9zY3JlZW5fY29udHJvbF9wb3NpdGlvbiI6IlRPUF9SSUdIVCIsInNlYXJjaF9jb250cm9sX3Bvc2l0aW9uIjoiVE9QX0xFRlQiLCJsb2NhdGVtZV9jb250cm9sX3Bvc2l0aW9uIjoiVE9QX0xFRlQiLCJ6b29tX2NvbnRyb2xfcG9zaXRpb24iOiJUT1BfTEVGVCIsIm1hcF90eXBlX2NvbnRyb2xfcG9zaXRpb24iOiJUT1BfUklHSFQiLCJtYXBfdHlwZV9jb250cm9sX3N0eWxlIjoiSE9SSVpPTlRBTF9CQVIiLCJzdHJlZXRfdmlld19jb250cm9sX3Bvc2l0aW9uIjoiVE9QX0xFRlQiLCJtYXBfY29udHJvbCI6ZmFsc2UsInNjcmVlbnMiOnsic21hcnRwaG9uZXMiOnsibWFwX3pvb21fbGV2ZWxfbW9iaWxlIjoiNSJ9LCJpcGFkcyI6eyJtYXBfem9vbV9sZXZlbF9tb2JpbGUiOiI1In0sImxhcmdlLXNjcmVlbnMiOnsibWFwX3pvb21fbGV2ZWxfbW9iaWxlIjoiNSJ9fSwibWFwX2luZm93aW5kb3dfY3VzdG9taXNhdGlvbnMiOmZhbHNlLCJpbmZvd2luZG93X3dpZHRoIjoiMTAwJSIsImluZm93aW5kb3dfYm9yZGVyX2NvbG9yIjoicmdiYSgwLCAwLCAwLCAwLjA5ODAzOTIpIiwiaW5mb3dpbmRvd19iZ19jb2xvciI6IiNmZmYiLCJzaG93X2luZm93aW5kb3dfaGVhZGVyIjpmYWxzZSwibWluX3pvb20iOiIwIiwibWF4X3pvb20iOiIxOSIsInpvb21fbGV2ZWxfYWZ0ZXJfc2VhcmNoIjoxMCwidXJsX2ZpbHRlcnMiOmZhbHNlLCJkb3VibGVjbGlja3pvb20iOnRydWUsImN1cnJlbnRfcG9zdF9vbmx5IjpmYWxzZSwiYm91bmRfbWFwX2FmdGVyX2ZpbHRlciI6ZmFsc2UsImRpc3BsYXlfcmVzZXRfYnV0dG9uIjpmYWxzZSwibWFwX3Jlc2V0X2J1dHRvbl90ZXh0IjoiUmVzZXQiLCJoZWlnaHQiOiI3MDAifSwicGxhY2VzIjpbeyJzb3VyY2UiOiJwb3N0IiwidGl0bGUiOiJXaGF0IGlzIFdBTi1JRlJBXHUyMDE5cyBEYXRhIFNjaWVuY2UgRXhwZXJ0IEdyb3VwPyIsImluZm93aW5kb3dfY29udGVudCI6IjxkaXYgY2xhc3M9XCJmYy1pdGVtLWJveCBmYy1pdGVtLW5vLXBhZGRpbmdcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiV2hhdCBpcyBXQU4tSUZSQVx1MjAxOXMgRGF0YSBTY2llbmNlIEV4cGVydCBHcm91cD9cIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjE3MFwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIzLzExL2RhdGEtU2NpZW5jZS1EYXktUGFyaXMtMTUzNng4NzEtMS0zMDB4MTcwLnBuZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmdcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXBhZGRpbmctY29udGVudF8yMFwiPlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLW1ldGEgZmMtaXRlbS1zZWNvbmRhcnktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZSBmYy10ZXh0LWNlbnRlclwiPkRhdGEgRXhwbG9yYXRpb24sIE1lZGlhIGxhYnM8L2Rpdj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS10aXRsZSBmYy1pdGVtLXByaW1hcnktdGV4dC1jb2xvciBmYy10ZXh0LWNlbnRlclwiPldoYXQgaXMgV0FOLUlGUkFcdTIwMTlzIERhdGEgU2NpZW5jZSBFeHBlcnQgR3JvdXA/PC9kaXY+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tY29udGVudCBmYy1pdGVtLWJvZHktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZVwiPlxyXG4gICAgICAgICAgICBXQU4tSUZSQSBsYXVuY2hlZCB0aGUgRGF0YSBTY2llbmNlIEV4cGVydCBHcm91cCBpbnRlbmRpbmcgdG8gYXJtIHByYWN0aXRpb25lcnMgd2l0aCBpbnNpZ2h0cywgZmVlZGJhY2ssIGFuZCB0b29scyB0byBncm93IGF1ZGllbmNlcywgZGVlcGVuIHVzZXIgZW5nYWdlbWVudCwgYW5kIG9wdGltaXNlIHJlYWRlciByZXZlbnVlcy5cclxuICAgICAgICA8L2Rpdj5cclxuPGEgaHJlZj1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi93aGF0LWlzLXdhbi1pZnJhcy1kYXRhLXNjaWVuY2UtZXhwZXJ0LWdyb3VwL1wiPlJlYWQgbW9yZTwvYT5cclxuICAgIDwvZGl2PlxyXG4gICAgPC9kaXY+XHJcbjwvZGl2PlxyXG5cclxuIiwiY29udGVudCI6IldBTi1JRlJBIGxhdW5jaGVkIHRoZSBEYXRhIFNjaWVuY2UgRXhwZXJ0IEdyb3VwIGludGVuZGluZyB0byBhcm0gcHJhY3RpdGlvbmVycyB3aXRoIGluc2lnaHRzLCBmZWVkYmFjaywgYW5kIHRvb2xzIHRvIGdyb3cgYXVkaWVuY2VzLCBkZWVwZW4gdXNlciBlbmdhZ2VtZW50LCBhbmQgb3B0aW1pc2UgcmVhZGVyIHJldmVudWVzLiIsImFkZHJlc3MiOiJQYXJpcywgRnJhbmNlIiwibG9jYXRpb24iOnsibGF0IjoiNDguODU2NjE0IiwiY2l0eSI6IlBhcmlzIiwic3RhdGUiOiJcdTAwY2VsZS1kZS1GcmFuY2UiLCJjb3VudHJ5IjoiRnJhbmNlIiwibG5nIjoiMi4zNTIyMjE5Iiwib25jbGlja19hY3Rpb24iOiJtYXJrZXIiLCJyZWRpcmVjdF9wZXJtYWxpbmsiOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvd2hhdC1pcy13YW4taWZyYXMtZGF0YS1zY2llbmNlLWV4cGVydC1ncm91cC8iLCJ6b29tIjoyLCJleHRyYV9maWVsZHMiOnsicG9zdF9leGNlcnB0IjoiV0FOLUlGUkEgbGF1bmNoZWQgdGhlIERhdGEgU2NpZW5jZSBFeHBlcnQgR3JvdXAgaW50ZW5kaW5nIHRvIGFybSBwcmFjdGl0aW9uZXJzIHdpdGggaW5zaWdodHMsIGZlZWRiYWNrLCBhbmQgdG9vbHMgdG8gZ3JvdyBhdWRpZW5jZXMsIGRlZXBlbiB1c2VyIGVuZ2FnZW1lbnQsIGFuZCBvcHRpbWlzZSByZWFkZXIgcmV2ZW51ZXMuIiwicG9zdF9jb250ZW50IjoiW3ZjX3Jvd11bdmNfY29sdW1uIHdpZHRoPVwiMS80XCJdW3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvMlwiXVt2Y19jb2x1bW5fdGV4dF1cclxuPGgxPldoYXQgaXMgV0FOLUlGUkFcdTIwMTlzIERhdGEgU2NpZW5jZSBFeHBlcnQgR3JvdXA/PC9oMT5cclxuPGgzPkNvbnZpbmNlZCB0aGF0IGRhdGEgd291bGQgYmUgYSBicmVha3Rocm91Z2ggdG9vbCBpbiBuZXdzcm9vbXMgYW5kIHRoZSBqb3VybmFsaXNtIGluZHVzdHJ5LCBXQU4tSUZSQSBDRU8sIFZpbmNlbnQgUGV5cmVnbmUgbGF1bmNoZWQgdGhlIERhdGEgU2NpZW5jZSBFeHBlcnQgR3JvdXAgaW4gMjAyMiBpbnRlbmRpbmcgdG8gYXJtIHByYWN0aXRpb25lcnMgd2l0aCBpbnNpZ2h0cywgZmVlZGJhY2ssIGFuZCB0b29scyBidWlsdCBhcm91bmQgdGhlIHByaW9yaXRpZXMgb2YgbmV3c3Jvb21zIHRvIGdyb3cgYXVkaWVuY2VzLCBkZWVwZW4gdXNlciBlbmdhZ2VtZW50LCBhbmQgb3B0aW1pc2UgcmVhZGVyIHJldmVudWVzLjwvaDM+XHJcbiZuYnNwO1xyXG5cclxuV2l0aCBvdmVyIDMwMCBtZW1iZXJzIGxvY2F0ZWQgd29ybGR3aWRlIGFuZCB3b3JraW5nIHdpdGhpbiBkaWZmZXJlbnQgbWVkaWEgb3JnYW5pc2F0aW9ucywgdGhpcyBncm91cCBjb25uZWN0cyBhbiBpbnRlcm5hdGlvbmFsIGNvbW11bml0eSBvZiBleHBlcnRzIChyYW5naW5nIGZyb20gZWRpdG9yaWFsIHN0YWZmIHRvIGRhdGEgc2NpZW50aXN0cywgZGF0YSBhbmFseXN0cyBhbmQgZGF0YSBlbmdpbmVlcnMpIHdobyBzaGFyZSByZXNvdXJjZXMsIGV4cGVyaWVuY2VzLCBzdG9yaWVzLCB0b29scywgYW5kIHdheXMgb2YgYWRkcmVzc2luZyByZWN1cnJpbmcgcHJvYmxlbXMuXHUyMDBiXHJcblxyXG4mbmJzcDtcclxuPGJsb2NrcXVvdGU+UGV5cmVnbmUgc2FpZDogPGVtPlx1MjAxY1RoZSBpc3N1ZSBvZiByZWFkZXJzIGVuZ2FnZW1lbnQgaXMgYSBzdWJqZWN0IHRoYXQgaGFzIGFsd2F5cyBmYXNjaW5hdGVkIG1lLiBXaGVuIEkgY3JlYXRlZCB0aGUgRGF0YSBTY2llbmNlIEV4cGVydCBHcm91cCwgdGhlIHF1ZXN0aW9uIEkgaGFkIGluIG1pbmQgd2FzIHRvIGtub3cgaWYgbWVkaWEgY29tcGFuaWVzIHdlcmUgc2VydmluZyB0aGVpciByZWFkZXJzIGNvcnJlY3RseT9cIjwvZW0+PC9ibG9ja3F1b3RlPlxyXG4mbmJzcDtcclxuXHJcbk9uZSBvZiB0aGUgbW9zdCBpbXBvcnRhbnQgaXNzdWVzIGlzIG9mIGNvdXJzZSwgaW1wcm92aW5nIGFuZCBzZWN1cmluZyByZWFkZXIgcmV0ZW50aW9uIGZvciBhIG5ld3MgbWVkaWEgY29tcGFueS4gT25lIHdheSB0byBkbyB0aGlzIGlzIG9mIGNvdXJzZSB0byBzdHVkeSByZWFkZXIgdHJlbmRzLCBldm9sdXRpb25zLCBhbmQgYmVoYXZpb3JzIGluIG9yZGVyIHRvIHByb2R1Y2UgYmV0dGVyIHN1aXRlZCBvciBcdTIwMWNwZXJzb25uYWxpc2VkXHUyMDFkIGFydGljbGVzLiBNb3JlIHNwZWNpZmljYWxseSwgYWZ0ZXIgY29sbGVjdGluZyByYXcgZGF0YSBvbiBob3cgcmVhZGVycyBlbmdhZ2Ugd2l0aCB0aGVpciBjb250ZW50LCBhbmFseXN0cyB3aWxsIHdvcmsgaW4gcGFydG5lcnNoaXAgd2l0aCB0aGUgZWRpdG9yaWFsIHN0YWZmIGluIHRoZSBuZXdzcm9vbSB0byBtYWtlIGFzc3VtcHRpb25zIGFuZCBkZWNpc2lvbnMgdG8gZ3VpZGUgdGhlbSBpbiB0aGUgcHJvZHVjdGlvbiBvZiBjb250ZW50LlxyXG5cclxuJm5ic3A7XHJcbjxibG9ja3F1b3RlPlNhc2NoYSBTY2htaWQsIEhlYWQgb2YgRGF0YSBpbiB0aGUgU3dpc3MgbWVkaWEgXHUyMDFjQmxpY2tcdTIwMWQgYW5kIGFjdGl2ZSBtZW1iZXIgb2YgdGhlIGdyb3VwIGV4cGxhaW5lZDogPGVtPlx1MjAxY3N0dWR5aW5nIGRhdGEgaXMgYSBncmVhdCB3YXkgdG8gZ2V0IHRvIGtub3cgb3VyIHVzZXJzL2N1c3RvbWVycyBhbmQgZXNwZWNpYWxseSB0aGVpciBuZWVkcyBhbmQgaG93IHdlIGNhbiBzYXRpc2Z5IHRob3NlIG5lZWRzLlx1MjAxZDwvZW0+PC9ibG9ja3F1b3RlPlxyXG4mbmJzcDtcclxuPGJsb2NrcXVvdGU+QW5vdGhlciBtZW1iZXIsIENsXHUwMGVkb25hIE1vb25leSwgU3Vic2NyaXB0aW9ucyBhbmQgUmVhZGVyIEluc2lnaHRzIERpcmVjdG9yIGF0XHUwMGEwVGhlIElyaXNoIFRpbWVzIGFkZGVkOiA8ZW0+XHUyMDFjVGhlIHVzZSBvZiBpbnNpZ2h0cyBkZXJpdmVkIGZyb20gZGF0YSBoYXMgYmVjb21lIGEgY3J1Y2lhbCBlbmFibGVyIGluIG91ciBuZXdzcm9vbSwgaGVscGluZyBvdXIgY29udGVudCB0byByZWFjaCB0aGUgcmlnaHQgYXVkaWVuY2UgaW4gdGhlIHJpZ2h0IGZvcm1hdCwgYXQgdGhlIHJpZ2h0IHRpbWUgYW5kIG9uIHRoZSByaWdodCBwbGF0Zm9ybS4gQW5hbHl0aWNzIHByb3BlbHMgb3VyIGV4Y2VsbGVudCBqb3VybmFsaXNtIHRvIGRlbGl2ZXIgc3Ryb25nIHJlc3VsdHMuXHUyMDFkPC9lbT48L2Jsb2NrcXVvdGU+XHJcbiZuYnNwO1xyXG5cclxuTW9yZSBnZW5lcmFsbHksIGl0IGlzIHVuYW5pbW91c2x5IHJlY29nbml6ZWQgdGhhdCB0aGUgc3R1ZHlpbmcgb2YgZGF0YSBoYXMgYmVlbiBoZWxwZnVsIGluIGdpdmluZyB0aGUgaW5kdXN0cnkgYSBwb3NpdGl2ZSBwdXNoIGZvcndhcmQuXHJcblxyXG4mbmJzcDtcclxuXHJcbkNvbmNyZXRlbHksIHRoZSBncm91cCBhaW1zIHRvIGNvbm5lY3QgcGVvcGxlIHdpdGggYSBjb21tb24gaW50ZXJlc3QgKHZpYSByZWd1bGFyIGluLXBlcnNvbiBtZWV0aW5ncywgb25saW5lIGZvcnVtcyBvciBjb25mZXJlbmNlIGNhbGxzKSB0byBoZWxwIGVhY2ggb3RoZXIgd2l0aCB0aGVpciB3b3JrIGluIHRoZWlyIHJlc3BlY3RpdmUgY29tcGFuaWVzLCB0byBoZWxwIG1lbWJlcnMgaW1wcm92ZSB0aGUgd2F5IHRoZXkgYXJlIHdvcmtpbmcgdGhyb3VnaCB0aGUgaW50ZWdyYXRpb24gb2YgZGF0YS5cclxuPGJsb2NrcXVvdGU+PGVtPlx1MjAxY1RoZSBncm91cCBnYXZlIG1lIHVzZWZ1bCBjb250YWN0cyB0byBleGNoYW5nZSBleHBlcmllbmNlcyBhbmQgd2hlbmV2ZXIgSSByZWNlaXZlIGEgc2xhY2sgYWxlcnQgSSBnbyB0byByZWFkIGl0ICEgVGhlIGZhY2UtdG8tZmFjZSBtZWV0aW5ncyBhcmUgZXNwZWNpYWxseSBoZWxwZnVsIGZvciBib3RoIGdldHRpbmcgaW5mb3JtYXRpb24gYW5kIG5ldHdvcmtpbmcuXHUyMDFkPC9lbT4gU2FpZCBUcnVpIExhbmNrcmlldCwgR3JvdXAgRGF0YSAmYW1wOyBJbnNpZ2h0cyBEaXJlY3RvciBhdCBNZWRpYWh1aXMuPC9ibG9ja3F1b3RlPlxyXG4mbmJzcDtcclxuXHJcbkJldHdlZW4gMjAxMCBhbmQgMjAxNSwgdGhlIGpvdXJuYWxpc20gaW5kdXN0cnkgaGFkIGJlZW4gbWFpbmx5IGZvY3VzZWQgb24gYWNxdWlyaW5nIGRpZ2l0YWwgc3Vic2NyaWJlcnMgZHVlIHRvIHRoZSBsYWNrIG9mIGFkdmVydGlzaW5nIHJldmVudWUuIDxlbT5cIlRvIGdldCBuZXcgc3Vic2NyaWJlcnMsIHlvdSBuZWVkIHRvIGZpcnN0IGtub3cgeW91ciBvd24gcmVhZGVyc2hpcDsgeW91IGFsc28gbmVlZCB0byBoYXZlIGdvb2QgcmV0ZW50aW9uIGFuZCBhY3F1aXNpdGlvbiB0YWN0aWNzLFwiPC9lbT4gUGV5cmVnbmUgc2FpZC4gPGVtPlx1MjAxY1RoZXJlZm9yZSwgbWFueSBtZWRpYSBjb21wYW5pZXMgYW5kIG5ld3NwYXBlcnMgZXF1aXBwZWQgdGhlbXNlbHZlcyB3aXRoIGRhdGEgc2NpZW50aXN0cy9zcGVjaWFsaXN0cyB0byByZXNwb25kIHRvIHJlYWRlcnMnIGRlbWFuZHMuXHUyMDFkPC9lbT5cclxuXHJcbiZuYnNwO1xyXG5cclxuQXQgdGhlIGxhc3QgPGEgaHJlZj1cImh0dHBzOi8vd2FuLWlmcmEub3JnL2V2ZW50cy9kYXRhLXNjaWVuY2UtZGF5LTIwMjMvXCI+V0FOLUlGUkEgRGF0YSBTY2llbmNlIERheSBpbiBWaWVubmE8L2E+LCB3aGljaCB0b29rIHBsYWNlIG9uIHRoZSAyNXRoIG9mIEFwcmlsIDIwMjMsIGV2ZXJ5IGdyb3VwIG1lbWJlciB3YXMgaW52aXRlZCB0byBWaWVubmEgZm9yIGFuIGluLXBlcnNvbiBtZWV0aW5nLiBTY2htaWQgaGlnaGxpZ2h0cyB0aGUgaW1wb3J0YW5jZSBvZiB0aGVzZSBzZXNzaW9uczogPGVtPlx1MjAxY1RoZSBkYXRhIFNjaWVuY2UgRGF5cyBhcmUgaW5zcGlyaW5nIGFuZCBnaXZlIHRoZSBvcHBvcnR1bml0eSB0byBkaXNjdXNzIFx1MDBhMHdpdGggbGlrZS1taW5kZWQgcGVvcGxlIHdobyBoYXZlIHNpbWlsYXIgcHJvZmlsZXMsIGludGVyZXN0cyBhbmQgY2hhbGxlbmdlcy4gVGhpcyBpcyB2ZXJ5IHVzZWZ1bCBiZWNhdXNlIHRoZXJlIGFyZSBub3QgbWFueSBwZW9wbGUgbGlrZSB1cyB3aXRoIHRoaXMgdmVyeSBzcGVjaWZpYyBqb2IuXHUyMDFjPC9lbT5cclxuXHJcbiZuYnNwO1xyXG5cclxuRXhwZXJ0cyBpbiB0aGlzIGdyb3VwIHNwYW4gc3BlY2lhbGlzdHMgaW4gbWFjaGluZSBsZWFybmluZywgd2hvIHVzZSBhcnRpZmljaWFsIGludGVsbGlnZW5jZSBvciBhbGdvcml0aG1zIHRvIGVuYWJsZSBwZXJzb25hbGl6YXRpb24sIGRhdGEgZW5naW5lZXJzIGFuZCBjaGllZiBkYXRhIG9mZmljZXJzLiBUaGUgZGF0YSBncm91cCBpcyBnYWluaW5nIHF1aWNrIHVwdGFrZSB3aXRoIGFuIGF2ZXJhZ2Ugd2Vla2x5IHJlZ2lzdHJhdGlvbiByYXRlIG9mIGZpdmUgdG8gdGVuIG5ldyBtZW1iZXJzLiBJZiB5b3UgYXJlIGEgZGF0YSBzY2llbnRpc3Qgd29ya2luZyBpbiB0aGUgbWVkaWEgaW5kdXN0cnksIHRoaXMgZ3JvdXAgd2lsbCBjb25zaWRlcmFibHkgaGVscCB5b3UgZm9yIHRoZSBkZXZlbG9wbWVudCBvZiB5b3VyIGRhdGEgZGVwYXJ0bWVudCBhbmQgeW91ciByZXNlYXJjaC5cclxuXHJcbiZuYnNwO1xyXG5cclxuVG8gZmluZCBvdXQgbW9yZSBhbmQgam9pbiB0aGUgZ3JvdXA6IDxhIGhyZWY9XCJodHRwczovL3dhbi1pZnJhLm9yZy9kYXRhc2NpZW5jZS9cIj5odHRwczovL3dhbi1pZnJhLm9yZy9kYXRhc2NpZW5jZS88L2E+XHJcblxyXG5UaGUgbmV4dCA8YSBocmVmPVwiaHR0cHM6Ly93YW4taWZyYS5vcmcvZXZlbnRzL2RhdGEtc2NpZW5jZS1kYXktMjAyNC9cIj5EYXRhIFNjaWVuY2UgRGF5PC9hPiB3aWxsIGJlIG9uIDIyIEZlYnJ1YXJ5IDIwMjQgaW4gUHJhZ3VlLCBDemVjaCBSZXB1YmxpYy5cclxuXHJcbldyaXR0ZW4gYnkgSmVycnktbW9yZWwgVGFrb3Utbmd1ZWxvLCBTdGVwaGVuIEZvemFyZCBhbmQgSm9obiBNaWxscy5cclxuXHJcbiZuYnNwO1xyXG5cclxuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS80XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddIiwicG9zdF90aXRsZSI6IldoYXQgaXMgV0FOLUlGUkFcdTIwMTlzIERhdGEgU2NpZW5jZSBFeHBlcnQgR3JvdXA/IiwicG9zdF9saW5rIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL3doYXQtaXMtd2FuLWlmcmFzLWRhdGEtc2NpZW5jZS1leHBlcnQtZ3JvdXAvIiwicG9zdF9mZWF0dXJlZF9pbWFnZSI6IjxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiV2hhdCBpcyBXQU4tSUZSQVx1MjAxOXMgRGF0YSBTY2llbmNlIEV4cGVydCBHcm91cD9cIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjE3MFwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIzLzExL2RhdGEtU2NpZW5jZS1EYXktUGFyaXMtMTUzNng4NzEtMS0zMDB4MTcwLnBuZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6IkRhdGEgRXhwbG9yYXRpb24sIE1lZGlhIGxhYnMiLCJwb3N0X3RhZ3MiOiJkYXRhLCBkYXRhIHNjaWVuY2UiLCIlX2VkaXRfbG9jayUiOiIxNjk5MzQzMTIzOjQiLCIlX2VkaXRfbGFzdCUiOiI0IiwiJV95b2FzdF93cHNlb19wcmltYXJ5X2NhdGVnb3J5JSI6IjUxIiwiJV90aHVtYm5haWxfaWQlIjoiMTU3OTgiLCIlc2xpZGVfdGVtcGxhdGUlIjoiZGVmYXVsdCIsIiVfd3BiX3ZjX2pzX3N0YXR1cyUiOiJ0cnVlIiwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6IlBhcmlzLCBGcmFuY2UiLCIlX3dwZ21wX2xvY2F0aW9uX2NpdHklIjoiUGFyaXMiLCIlX3dwZ21wX2xvY2F0aW9uX3N0YXRlJSI6Ilx1MDBjZWxlLWRlLUZyYW5jZSIsIiVfd3BnbXBfbG9jYXRpb25fY291bnRyeSUiOiJGcmFuY2UiLCIlX3dwZ21wX21ldGFib3hfbGF0aXR1ZGUlIjoiNDguODU2NjE0IiwiJV93cGdtcF9tZXRhYm94X2xvbmdpdHVkZSUiOiIyLjM1MjIyMTkiLCIlX3dwZ21wX21ldGFib3hfbG9jYXRpb25fcmVkaXJlY3QlIjoibWFya2VyIiwiJV93cGdtcF9tZXRhYm94X2N1c3RvbV9saW5rJSI6IiIsIiVfd3BnbXBfbWFwX2lkJSI6ImE6MTp7aTowO3M6MTpcIjJcIjt9IiwiJV93cGdtcF9tZXRhYm94X21hcmtlcl9pZCUiOiJOOyIsIiVfd3BnbXBfbWV0YWJveF90YXhvbW9taWVzX3Rlcm1zJSI6Ik47IiwiJV93cGdtcF9leHRlbnNpb25zX2ZpZWxkcyUiOiJOOyIsIiV0d2l0dGVyX3NoYXJlJSI6eyJoYXNodGFncyI6WyJkYXRhICNkYXRhc2NpZW5jZSJdLCJ0ZXh0IjoiV0FOLUlGUkEncyBEYXRhIFNjaWVuY2UgRXhwZXJ0IEdyb3VwIGludGVuZGluZyB0byBhcm0gcHJhY3RpdGlvbmVycyB3aXRoIGluc2lnaHRzLCBmZWVkYmFjaywgYW5kIHRvb2xzIHRvIGdyb3cgYXVkaWVuY2VzLCBkZWVwZW4gdXNlciBlbmdhZ2VtZW50LCBhbmQgb3B0aW1pc2UgcmVhZGVyIHJldmVudWVzLiJ9LCIldHdpdHRlcl9jYXJkJSI6IldoeSBXQU4tSUZSQSBsYXVuY2hlZCB0aGUgRGF0YSBTY2llbmNlIEV4cGVydCBHcm91cCBmb3IgbmV3cyA/LCBXQU4tSUZSQSBsYXVuY2hlZCB0aGUgRGF0YSBTY2llbmNlIEV4cGVydCBHcm91cCBpbnRlbmRpbmcgdG8gYXJtIHByYWN0aXRpb25lcnMgd2l0aCBpbnNpZ2h0cywgZmVlZGJhY2ssIGFuZCB0b29scyB0byBncm93IGF1ZGllbmNlcywgZGVlcGVuIHVzZXIgZW5nYWdlbWVudCwgYW5kIG9wdGltaXNlIHJlYWRlciByZXZlbnVlcy4iLCIlX3lvYXN0X3dwc2VvX21ldGFkZXNjJSI6IldBTi1JRlJBIGxhdW5jaGVkIHRoZSBEYXRhIFNjaWVuY2UgRXhwZXJ0IEdyb3VwIGludGVuZGluZyB0byBhcm0gcHJhY3RpdGlvbmVycyB3aXRoIGluc2lnaHRzLCBmZWVkYmFjaywgYW5kIHRvb2xzIHRvIGdyb3cgYXVkaWVuY2VzLCBkZWVwZW4gdXNlciBlbmdhZ2VtZW50LCBhbmQgb3B0aW1pc2UgcmVhZGVyIHJldmVudWVzLiIsIiVfeW9hc3Rfd3BzZW9fY29udGVudF9zY29yZSUiOiIzMCIsIiVfeW9hc3Rfd3BzZW9fZXN0aW1hdGVkLXJlYWRpbmctdGltZS1taW51dGVzJSI6IjMiLCJ0YXhvbm9teT1jYXRlZ29yeSI6IkRhdGEgRXhwbG9yYXRpb24sIE1lZGlhIGxhYnMiLCJ0YXhvbm9teT1wb3N0X3RhZyI6ImRhdGEsIGRhdGEgc2NpZW5jZSJ9LCJpY29uIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTgvMDIvbWFya2VyLTEucG5nIn0sImlkIjoxNTc5NiwiaW5mb3dpbmRvd19kaXNhYmxlIjpmYWxzZX0seyJzb3VyY2UiOiJwb3N0IiwidGl0bGUiOiJJbnRlcnZpZXcgJiM4MjExOyBPdWVzdCBNXHUwMGU5ZGlhbGFiOiBGb2N1cyBvbiBsb2NhbCBpbm5vdmF0aW9uIGtleSB0byBzdGF5aW5nIFx1MjAxY3Jvb3RlZCBpbiByZWFsaXR5XHUyMDFkIiwiaW5mb3dpbmRvd19jb250ZW50IjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZ1wiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJJbnRlcnZpZXcgJiM4MjExOyBPdWVzdCBNXHUwMGU5ZGlhbGFiOiBGb2N1cyBvbiBsb2NhbCBpbm5vdmF0aW9uIGtleSB0byBzdGF5aW5nIFx1MjAxY3Jvb3RlZCBpbiByZWFsaXR5XHUyMDFkXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIxNTVcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAyMy8wNy9PdWVzdE1lZGlhTGFiLTMwMHgxNTUuanBlZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmdcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXBhZGRpbmctY29udGVudF8yMFwiPlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLW1ldGEgZmMtaXRlbS1zZWNvbmRhcnktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZSBmYy10ZXh0LWNlbnRlclwiPk1lZGlhIGxhYnM8L2Rpdj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS10aXRsZSBmYy1pdGVtLXByaW1hcnktdGV4dC1jb2xvciBmYy10ZXh0LWNlbnRlclwiPkludGVydmlldyAmIzgyMTE7IE91ZXN0IE1cdTAwZTlkaWFsYWI6IEZvY3VzIG9uIGxvY2FsIGlubm92YXRpb24ga2V5IHRvIHN0YXlpbmcgXHUyMDFjcm9vdGVkIGluIHJlYWxpdHlcdTIwMWQ8L2Rpdj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1jb250ZW50IGZjLWl0ZW0tYm9keS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+XHJcbiAgICAgICAgICAgIFRoZSBjb2xsYWJvcmF0aXZlIG1lZGlhIGxhYiBiYXNlZCBpbiBOYW50ZXMsIEZyYW5jZSwgd29ya3MgY2xvc2VseSB3aXRoIGxvY2FsIHB1Ymxpc2hlcnMgYW5kIGlubm92YXRpdmUgcGxheWVycyBpbiB0aGVpciByZWdpb24uIERpcmVjdCBjb250YWN0IHdpdGggbG9jYWwgcGxheWVycyBoZWxwcyB0aGUgbGFiIHN0YXkgZm9jdXNlZCBvbiB0aGUgcmVhbCBpc3N1ZXMgdGhhdCBjb21wYW5pZXMgaW4gdGhlaXIgbmV0d29yayBkZWFsIHdpdGguXHJcbiAgICAgICAgPC9kaXY+XHJcbjxhIGhyZWY9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvaW50ZXJ2aWV3LW91ZXN0LW1lZGlhbGFiLWZvY3VzLW9uLWxvY2FsLWlubm92YXRpb24ta2V5LXRvLXN0YXlpbmctcm9vdGVkLWluLXJlYWxpdHkvXCI+UmVhZCBtb3JlPC9hPlxyXG4gICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuPC9kaXY+XHJcblxyXG4iLCJjb250ZW50IjoiVGhlIGNvbGxhYm9yYXRpdmUgbWVkaWEgbGFiIGJhc2VkIGluIE5hbnRlcywgRnJhbmNlLCB3b3JrcyBjbG9zZWx5IHdpdGggbG9jYWwgcHVibGlzaGVycyBhbmQgaW5ub3ZhdGl2ZSBwbGF5ZXJzIGluIHRoZWlyIHJlZ2lvbi4gRGlyZWN0IGNvbnRhY3Qgd2l0aCBsb2NhbCBwbGF5ZXJzIGhlbHBzIHRoZSBsYWIgc3RheSBmb2N1c2VkIG9uIHRoZSByZWFsIGlzc3VlcyB0aGF0IGNvbXBhbmllcyBpbiB0aGVpciBuZXR3b3JrIGRlYWwgd2l0aC4iLCJhZGRyZXNzIjoiMjggQmQgQmVub25pIEdvdWxsaW4sIDQ0MjAwIE5hbnRlcywgRnJhbmNlIiwibG9jYXRpb24iOnsibGF0IjoiNDcuMjAxNzgxOCIsImNpdHkiOiJOYW50ZXMiLCJzdGF0ZSI6IlBheXMgZGUgbGEgTG9pcmUiLCJjb3VudHJ5IjoiRnJhbmNlIiwibG5nIjoiLTEuNTUzMjAwNCIsIm9uY2xpY2tfYWN0aW9uIjoibWFya2VyIiwicmVkaXJlY3RfcGVybWFsaW5rIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL2ludGVydmlldy1vdWVzdC1tZWRpYWxhYi1mb2N1cy1vbi1sb2NhbC1pbm5vdmF0aW9uLWtleS10by1zdGF5aW5nLXJvb3RlZC1pbi1yZWFsaXR5LyIsInpvb20iOjIsImV4dHJhX2ZpZWxkcyI6eyJwb3N0X2V4Y2VycHQiOiJUaGUgY29sbGFib3JhdGl2ZSBtZWRpYSBsYWIgYmFzZWQgaW4gTmFudGVzLCBGcmFuY2UsIHdvcmtzIGNsb3NlbHkgd2l0aCBsb2NhbCBwdWJsaXNoZXJzIGFuZCBpbm5vdmF0aXZlIHBsYXllcnMgaW4gdGhlaXIgcmVnaW9uLiBEaXJlY3QgY29udGFjdCB3aXRoIGxvY2FsIHBsYXllcnMgaGVscHMgdGhlIGxhYiBzdGF5IGZvY3VzZWQgb24gdGhlIHJlYWwgaXNzdWVzIHRoYXQgY29tcGFuaWVzIGluIHRoZWlyIG5ldHdvcmsgZGVhbCB3aXRoLiIsInBvc3RfY29udGVudCI6Ilt2Y19yb3cgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIl1bdmNfY29sdW1uIHdpZHRoPVwiMS80XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvMlwiXVt2Y19jb2x1bW5fdGV4dF1cclxuPGgxPkludGVydmlldyAtIE91ZXN0IE1cdTAwZTlkaWFsYWI6IEZvY3VzIG9uIGxvY2FsIGlubm92YXRpb24ga2V5IHRvIHN0YXlpbmcgXHUyMDFjcm9vdGVkIGluIHJlYWxpdHlcdTIwMWQ8L2gxPlxyXG48aDQ+PC9oND5cclxuPGg0PjwvaDQ+XHJcbjxoMz48ZW0+VGhlIGNvbGxhYm9yYXRpdmUgbWVkaWEgbGFiIGJhc2VkIGluIE5hbnRlcywgRnJhbmNlLCB3b3JrcyBjbG9zZWx5IHdpdGggbG9jYWwgcHVibGlzaGVycyBhbmQgaW5ub3ZhdGl2ZSBwbGF5ZXJzIGluIHRoZWlyIHJlZ2lvbi4gRGlyZWN0IGNvbnRhY3Qgd2l0aCBsb2NhbCBwbGF5ZXJzIGhlbHBzIHRoZSBsYWIgc3RheSBmb2N1c2VkIG9uIHRoZSByZWFsIGlzc3VlcyB0aGF0IGNvbXBhbmllcyBpbiB0aGVpciBuZXR3b3JrIGRlYWwgd2l0aC48L2VtPjwvaDM+XHJcbiZuYnNwO1xyXG5cclxuSW4gMjAxOCwgd2UgPGEgaHJlZj1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9vdWVzdC1tZWRpYWxhYi1hLWNsdXN0ZXItYW5kLWluZGVwZW5kZW50LW1lZGlhLWxhYi10aGF0LXN1cHBvcnRzLXRoZS1yZWdpb25hbC1kaWdpdGFsLXRyYW5zaXRpb24vXCI+c3Bva2UgdG8gSnVsaWVuIEtvc3RyXHUwMGU4Y2hlPC9hPiB3aG8gaGVhZHMgdGhlIDxhIGhyZWY9XCJodHRwczovL3d3dy5vdWVzdG1lZGlhbGFiLmZyL1wiPk91ZXN0IE1cdTAwZTlkaWFsYWI8L2E+IGluIE5hbnRlcywgRnJhbmNlLiBXZSBjYXVnaHQtdXAgd2l0aCBoaW0gdGhpcyBzdW1tZXIgdG8gYXNrIGhpbSBob3cgdGhpbmdzIGhhdmUgbW92ZWQgZm9yd2FyZCBzaW5jZSBvdXIgbGFzdCBjb252ZXJzYXRpb248ZW0+LjwvZW0+XHJcbjxoND48c3Ryb25nPldBTi1JRlJBOiBKdWxpZW4sIGl0XHUyMDE5cyBnb29kIHRvIHNwZWFrIHRvIHlvdSBhZ2Fpbi4gSG93IGhhdmUgdGhpbmdzIGV2b2x2ZWQgc2luY2UgMjAxOD88L3N0cm9uZz48L2g0PlxyXG48c3Ryb25nPktvc3RyXHUwMGU4Y2hlOjwvc3Ryb25nPiBUaGFua3MhIEJldHdlZW4gMjAxMiBhbmQgMjAxOCwgT3Vlc3QgTVx1MDBlOWRpYWxhYiBoYWQgYXMgaXRzIHNjb3BlIG9mIGFjdGlvbiB0aGUgV2VzdCBvZiBGcmFuY2UgKEJyaXR0YW55IGFuZCBQYXlzIGRlIGxhIExvaXJlKSBhbmQgYnJvdWdodCB0b2dldGhlciByZWdpb25hbCBtZWRpYSwgY29tbXVuaWNhdGlvbiBvcmdhbmlzYXRpb25zIGFuZCBjb250ZW50IGNyZWF0b3JzIGluIGdlbmVyYWwgb24gdGhlIGlzc3VlcyBvZiBkaWdpdGFsIGNoYW5nZS5cclxuXHJcblNpbmNlIDIwMTksIHdlIGhhdmUgaGFkIGEgbmF0aW9uYWwgc2NvcGUgYW5kIHdlIGZvY3VzIG91ciBhY3Rpb25zIG9uIHRoZSBkZXZlbG9wbWVudCwgaW5ub3ZhdGlvbiBhbmQgdHJhbnNpdGlvbnMgb2YgbG9jYWwgbWVkaWEsIG5vIG1hdHRlciB3aGVyZSB0aGV5IGFyZSBsb2NhdGVkLlxyXG5cclxuV2UgcGl2b3RlZCBmb3IgdHdvIG1haW4gcmVhc29uczpcclxuPHVsPlxyXG4gXHQ8bGk+VG8gc3RheSByZWxldmFudCBpbiB3aGF0IHdlIGhhdmUgdG8gb2ZmZXIgdG8gbG9jYWwgbWVkaWEgd2hvIGRvIG5vdCBoYXZlIHRoZSBzYW1lIG1lYW5zIG9yIHByb2JsZW1zIGFzIG5hdGlvbmFsIG9uZXMuPC9saT5cclxuIFx0PGxpPlRvIGZpbmQgYSBiYWxhbmNlZCBidXNpbmVzcyBtb2RlbDogdGhlIGxvY2FsIGF1dGhvcml0eSBcdTIwMWNSXHUwMGU5Z2lvbiBQYXlzIGRlIExvaXJlXHUyMDFkLCB3aGljaCBoYWQgc3VwcG9ydGVkIHVzIGR1cmluZyB0aGUgZWFybHkgeWVhcnMsIHdhcyBkd2luZGxpbmcgaXRzIGZpbmFuY2lhbCBzdXBwb3J0IGFuZCBpdCB3YXMgZGlmZmljdWx0IHRvIGZpbmQgcHJpdmF0ZSBwYXJ0bmVycyBpZiB5b3Ugb25seSBvcGVyYXRlIGF0IGEgcmVnaW9uYWwgc2NhbGUuPC9saT5cclxuPC91bD5cclxuJm5ic3A7XHJcbjxoND48c3Ryb25nPkFyZSB5b3Ugd2hlcmUgeW91IGV4cGVjdGVkPzwvc3Ryb25nPjwvaDQ+XHJcblllcyBhbmQgbm8uXHJcblxyXG5ObywgYmVjYXVzZSB3aGVuIHdlIGxhdW5jaGVkIE91ZXN0IE1cdTAwZTlkaWFsYWIgaW4gMjAxMiwgd2UgdGhvdWdodCB0aGF0IG91ciBsYWIgd291bGQgZGlyZWN0bHkgaW5pdGlhdGUgb3IgZXZlbiBjYXJyeSBvdXQgY29sbGFib3JhdGl2ZSBSJmFtcDtEIHByb2plY3RzIGFtb25nIGl0cyBtZW1iZXJzLiBCdXQgdGhlIG1lZGlhIGhhdmUgbm90IG5lY2Vzc2FyaWx5IG5lZWRlZCB0byBzZXQgdXAgY29sbGVjdGl2ZSBwcm9qZWN0cyBvciBwcmVmZXJyZWQgZ29pbmcgc29sbywgYW5kIHRoZXkgbmVlZGVkIHRvIGV4cGVyaW1lbnQgb3IgZm9sbG93IHRyYWluaW5nIGluIHRoZSBzaG9ydGVyIHRlcm0uXHJcblxyXG5ZZXMsIGJlY2F1c2Ugd2UgaGF2ZSBkZXZlbG9wZWQgYSBxdWFsaXRhdGl2ZSBtb25pdG9yaW5nIG9mIHRoZSBtZWRpYSBzZWN0b3IsIHdlIGFyZSBlc3RhYmxpc2hlZCBhbmQgcmVjb2duaXNlZCBmb3Igb3VyIHRyYWluaW5nIGNvdXJzZSBhbmQgd29ya3Nob3BzIGluIGRpZ2l0YWwgam91cm5hbGlzbSBhbmQgd2Ugc3VjY2VlZGVkIGluIGRldmVsb3Bpbmcgc2hhcmluZyBhbmQgbXV0dWFsIGFpZCBiZXR3ZWVuIGxvY2FsIG1lZGlhLCB1bml2ZXJzaXRpZXMgYW5kIHNvbWUgYWdlbmNpZXMgb3Igc3RhcnR1cHMgbmFtZWx5IGR1cmluZyB0aGUgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmZlc3RpdmFsLWluZm9sb2NhbGUuZnIvXCI+RmVzdGl2YWwgZGUgbFx1MjAxOWluZm8gbG9jYWxlPC9hPiBhbmQgb3VyIGhhY2thdGhvbnMuXHJcblxyXG4mbmJzcDtcclxuPGg0PjxzdHJvbmc+SG93IGNvbGxhYm9yYXRpdmUgYXJlIHlvdSB3aXRoIG90aGVyIG1lZGlhIGxhYnM/PC9zdHJvbmc+PC9oND5cclxuV2UgbWFpbmx5IGV4Y2hhbmdlIHdpdGggYSBmZXcgZnJhbmNvcGhvbmUgbWVkaWEgbGFicyBvciBtZWRpYSBzdGFydHVwcy9hY2NlbGVyYXRvcnMuIEkgYW0gdGhpbmtpbmcgaW4gcGFydGljdWxhciBvZiBPRkY3IChTaXBhIE91ZXN0LUZyYW5jZSBncm91cCksIExhIGNvbXBhZ25pZSBSb3RhdGl2ZSAoQ2VudHJlLUZyYW5jZSBncm91cCksIHRoZSBtZWRpYWxhYiBvZiBGcmFuY2UgVFx1MDBlOWxcdTAwZTl2aXNpb25zIG9yIGV2ZW4gSU1JIGluIFN3aXR6ZXJsYW5kLlxyXG5cclxuJm5ic3A7XHJcbjxoND48c3Ryb25nPldoYXQgZG8geW91IHNlZSBmb3IgdGhlIGZ1dHVyZSBvZiB0aGUgbGFiIGFuZCBvdGhlcnMgaW4gZ2VuZXJhbD88L3N0cm9uZz48L2g0PlxyXG5JIHRoaW5rIHdlIG5lZWQgdG8gY29uZHVjdCBtb3JlIHN0dWRpZXMvc3VydmV5cywgdG8gYmV0dGVyIHVuZGVyc3RhbmQgdGhlIHJlbGF0aW9uc2hpcCBiZXR3ZWVuIGNpdGl6ZW5zIGFuZCBsb2NhbCBuZXdzIG9yIGlkZW50aWZ5IGFueSBmdXJ0aGVyIGdvb2QgcHJhY3RpY2VzIHRvIGlubm92YXRlICh3aGV0aGVyIGF0IHRoZSBlZGl0b3JpYWwgb3IgYnVzaW5lc3MgbGV2ZWwpLiBXZSBhbHNvIG5lZWQgdG8gcGF5IG1vcmUgYXR0ZW50aW9uIHRvIHRoZSBuZXcgbG9jYWwgYWN0b3JzIGFuZCBjb250ZW50IGNyZWF0b3JzIChibG9nZ2VycywgWW91dHViZXJzLCBzdHJlYW1lcnMsIEluc3RhZ3JhbW1lcnMsIFRpa3Rva2VycywgaW5mbHVlbmNlcnMsIGV0Yy4pIGFuZCB0aGVpciByZWxhdGlvbnNoaXAgdG8gdGhlIGF1ZGllbmNlLlxyXG5cclxuJm5ic3A7XHJcbjxoND48c3Ryb25nPkhvdyBkbyB5b3UgbWVhc3VyZSB5b3VyIHN1Y2Nlc3M/PC9zdHJvbmc+PC9oND5cclxuV2l0aCB0aGUgbnVtYmVyIG9mIHBlb3BsZSB3aG8gcmVnaXN0ZXIgdG8gb3VyIG5ld3NsZXR0ZXJzICgyLDUwMCksIG51bWJlciBvZiBwYXJ0aWNpcGFudHMgYXQgdGhlIEZlc3RpdmFsIGRlIGxcdTIwMTlpbmZvIGxvY2FsZSBldmVyeSB5ZWFyICg0MDApIG9yIGZvbGxvd2luZyBvdXIgdHJhaW5pbmcgYW5kIHdvcmtzaG9wcyAoMSw1MDAgdG8gMiwwMDAgcGVyIHllYXIpLiBBbmQgYmV5b25kIHRoZSB2b2x1bWUgb2YgcGVvcGxlLCBieSB0aGUgc2F0aXNmYWN0aW9uIHJhdGUgb2YgcGVvcGxlIHdobyBwYXJ0aWNpcGF0ZSBpbiBvdXIgYWN0aW9ucy5cclxuXHJcbiZuYnNwO1xyXG48aDQ+PHN0cm9uZz5BbmQgaG93IGFib3V0IHlvdXIgc3RhZmYgdHVybm92ZXI/IERpZCB5b3UgZ2FpbiBtb3JlIGVtcGxveWVlcz88L3N0cm9uZz48L2g0PlxyXG5XZSBhcmUgc3RpbGwgNCBlbXBsb3llZXMgd2l0aGluIG91ciBub24tcHJvZml0IG9yZ2FuaXNhdGlvbiAodHdvIGZ1bGwtdGltZSBhbmQgdHdvIHBhcnQtdGltZSksIGFuZCBJIGhvcGUgdG8gYmUgYWJsZSB0byBjcmVhdGUgYSBuZXcgam9iIHBvc2l0aW9uIG5leHQgeWVhci5cclxuXHJcbiZuYnNwO1xyXG48aDQ+PHN0cm9uZz5Ib3cgZG8geW91IGZpbmFuY2UgdGhlIHByb2plY3RzPzwvc3Ryb25nPjwvaDQ+XHJcbkl0IGRlcGVuZHMgb24gdGhlIHByb2plY3RzLiBPdXIgaGFja2F0aG9ucyBhcmUgZm9yIGV4YW1wbGUgZnVuZGVkIGJ5IHRoZSBtZW1iZXJzaGlwIG9mIHRoZSBtZWRpYSBhbmQgc2Nob29scywgYW5kIHNvbWUgc3Vic2lkaWVzIGZyb20gdGhlIGNpdHkgb2YgTmFudGVzLiBGb3IgdGhlIGZlc3RpdmFsLCBwYXJ0IG9mIHRoZSBpbmNvbWUgY29tZXMgZnJvbSB0aGUgdGlja2V0aW5nLCB0aGUgb3RoZXIgcGFydCBmcm9tIHNwb25zb3JzIGxpa2UgdGhlIEdvb2dsZSBOZXdzIEluaXRpYXRpdmUsIFFpb3RhIG9yIFJpY2NvYm9ubyBJbXByaW1ldXJzLiBBbmQgZm9yIHRyYWluaW5nLCB0aGVyZSBhcmUgc3BlY2lmaWMgZnVuZHMgd2l0aGluIGNvbXBhbmllcy4gR2xvYmFsbHksIG91ciBzZWxmLWZpbmFuY2luZyByZWFjaGVkIDg1JSB3aXRoIGNvbnRyaWJ1dGlvbnMgYW5kIHNlcnZpY2VzIGFuZCBzdWJzaWRpZXMgMTUlIG9mIG91ciBhbm51YWwgYnVkZ2V0LlxyXG5cclxuJm5ic3A7XHJcbjxoND48c3Ryb25nPldoYXQgZG8geW91IHdpc2ggeW91IGhhZCBkb25lIGRpZmZlcmVudGx5Pzwvc3Ryb25nPjwvaDQ+XHJcblRoZXJlIGFyZSBhbHdheXMgdGhpbmdzIHRvIGltcHJvdmUsIGJ1dCBvdmVyYWxsLCB3ZSBoYXZlIGJlZW4gYWJsZSB0byBtYWludGFpbiBhIGdvb2QgZHluYW1pYywgYnkgYWx3YXlzIHRlc3RpbmcvbGF1bmNoaW5nIG5ldyBhY3Rpb25zLiBJIGhhdmUgbm8gcmVncmV0cyBhYm91dCB0aGUgcHJvamVjdHMgd2UgaGF2ZSBkZXZlbG9wZWQsIGV4Y2VwdCBwZXJoYXBzIHdpdGggTk1jdWJlLCBvdXIgbWVkaWEgaW5jdWJhdG9yIHRoYXQgd2Ugc2V0IHVwIGluIHBhcnRuZXJzaGlwIHdpdGggQXVkZW5jaWEsIHRoZSBVbml2ZXJzaXR5IG9mIE5hbnRlcyBhbmQgYW5vdGhlciBjbHVzdGVyLiBXZSBjb2FjaGVkIDE1IGVudHJlcHJlbmV1cnMgb2YgdGhlIG1lZGlhIHNlY3RvciBmb3IgYSB5ZWFyIGFuZCBvdXIgcHJvZ3JhbW1lIGhlbHBlZCB0aGVtIHRvIGdldCBvdXQgb2YgaXNvbGF0aW9uLCB0byBncm93IG9yIHBpdm90LiBCdXQgd2Ugd2VyZSB1bmFibGUgdG8gZmluZCBwcml2YXRlIHBhcnRuZXJzIGluIHRoZSByZWdpb25zIHRvIHN1c3RhaW4gdGhlIHN5c3RlbSBhbmQgYXZvaWQgZGVwZW5kaW5nIG9ubHkgb24gdGhlIHB1YmxpYyBhdXRob3JpdGllc1x1MjAxOSBzdWJzaWRpZXMuXHJcblxyXG4mbmJzcDtcclxuPGg0PjxzdHJvbmc+RG8geW91IHN0YXkgaW4gdG91Y2ggd2l0aCB0aGUgcHJvamVjdHMgdGhhdCBoYXZlIGdvbmUgdGhyb3VnaCB5b3VyIGxhYnM/IElmIHNvLCB3aGF0IGlzIHlvdXIgcmVsYXRpb25zaGlwIHdpdGggdGhlbT88L3N0cm9uZz48L2g0PlxyXG5SZWxhdGlvbnMgYXJlIGdvb2QuIFNvbWUgYmVjb21lIG1lbWJlcnMsIG90aGVycyBiZWNvbWUgb2NjYXNpb25hbCB1c2VycyBvZiB0aGUgbGFiLCBieSBwYXJ0aWNpcGF0aW5nIGluIG91ciB3b3Jrc2hvcHMsIGhhY2thdGhvbnMgb3IgZXZlbnRzLiBUaGUgbGluayBpcyByYXJlbHkgYnJva2VuLlxyXG5cclxuJm5ic3A7XHJcbjxoND48c3Ryb25nPkhhcyB5b3VyIHByb2Nlc3Mgb3IgYXBwcm9hY2ggdG8gaW5ub3ZhdGlvbiBjaGFuZ2VkPzwvc3Ryb25nPjwvaDQ+XHJcbk5vdCByZWFsbHkuIFdlIGFsd2F5cyByZWx5IG9uIG1ldGhvZHMgaW5zcGlyZWQgYnkgZGVzaWduIHRoaW5raW5nIGFuZCB1c2VyLWNlbnRyaWMgbWV0aG9kcy4gTW9yZSBmcmVxdWVudCB1c2UgaXMgbWFkZSBvZiBkZXNpZ24gZmljdGlvbiwgaW4gcGFydGljdWxhciBieSB3b3JraW5nIHdpdGggdGhlIGFnZW5jeSBEZXNpZ24gRnJpY3Rpb24sIHdoaWNoIGlzIGEgbWVtYmVyLiBBbmQgbmVjZXNzYXJpbHksIHdpdGggdGhlIG5ldyBuYXRpb25hbCBzY29wZSBvZiB0aGUgbGFiIGFuZCB0aGUgQ292aWQgcGVyaW9kLCB3ZSBoYXZlIGRpZ2l0aXplZCBzZXZlcmFsIGV2ZW50cyBvciB3b3Jrc2hvcHMsIGFuZCBoYXZlIGZyZXF1ZW50IG9ubGluZSBjb25mZXJlbmNlcywgdXNpbmcgdG9vbHMgbGlrZSBNaXJvIG9yIEphbWJvYXJkLlxyXG5cclxuJm5ic3A7XHJcbjxoND48c3Ryb25nPldoYXQgb3V0c2lkZSBwcmVzc3VyZXMgZG8geW91IGZhY2UsIGlmIGFueT88L3N0cm9uZz48L2g0PlxyXG5BIG51bWJlciBvZiBhY3RvcnMgYXJlIGluIGNyaXNpcyBvciBkaWZmaWN1bHR5IGluIHRoZSBtZWRpYSBzZWN0b3IuIEl0XHUyMDE5cyBhbHdheXMgYmVlbiB0aGUgY2FzZSBzaW5jZSB3ZSBzdGFydGVkIGJ1dCB0aGUgcmVjZW50IHJpc2UgaW4gdGhlIGNvc3Qgb2YgcmF3IG1hdGVyaWFscywgcGFwZXIgaW4gcGFydGljdWxhciwgYWdncmF2YXRlcyB0aGUgc2l0dWF0aW9uLiBPbiB0aGUgc2lkZSBvZiB0aGUgcHVibGljIGF1dGhvcml0aWVzLCB0aGVyZSBpcyBvZnRlbiBhIHRlbmRlbmN5IHRvIGRlY3JlYXNlIHN1YnNpZGllcywgb3IgdG8gb25seSBzdXBwb3J0IHByb2plY3RzIGF0IGxhdW5jaCwgYW5kIG5vdCB0aGUgb3BlcmF0aW9uIG9mIHRoZSBsYWIuIEZvcnR1bmF0ZWx5LCBOYW50ZXMgTVx1MDBlOXRyb3BvbGUgaGFzIHN1cHBvcnRlZCB1cyBmcm9tIHRoZSBiZWdpbm5pbmcgYW5kIHRoZXkgd2VyZSBhbHdheXMgdGhlcmUgd2hlbiB3ZSBuZWVkZWQgdGhlbS5cclxuXHJcbiZuYnNwO1xyXG48aDQ+PHN0cm9uZz5BcmUgdGhlcmUgbmV3IHBhcnRuZXJzPzwvc3Ryb25nPjwvaDQ+XHJcblllcy4gV2l0aCB0aGUgRmVzdGl2YWwgZGUgbFx1MjAxOWluZm8gbG9jYWxlIGluIHBhcnRpY3VsYXIsIHdlIGhhdmUgZGV2ZWxvcGVkIGFyb3VuZCAzMCBuZXcgcGFydG5lcnNoaXBzLiBPdXIgbWFpbiBwcml2YXRlIHBhcnRuZXIgdG9kYXkgaXMgdGhlIEdvb2dsZSBOZXdzIEluaXRpYXRpdmUuXHJcblxyXG4mbmJzcDtcclxuPGg0PjxzdHJvbmc+V2hhdCBoYXMgYmVlbiB0aGUgaW1wYWN0IG9mIENvdmlkIG9uIHRoZSBsYWIgKGhhdmUgeW91IGRvd25zaXplZCAvIGhvdyBhcmUgZXZlbnRzIGhhbmRsZWQgLyB0aGUgYW1vdW50IG9mIHdvcmsgZG9uZSBmYWNlIHRvIGZhY2UpPzwvc3Ryb25nPjwvaDQ+XHJcbkluIHRoaW5rIGxpa2UgbWFueSBzaW1pbGFyIGluaXRpYXRpdmVzLCBwYXJ0aWFsIHVuZW1wbG95bWVudCBhdCB0aGUgc3RhcnQgdGhlbiBwcm9ncmVzc2l2ZSBkaWdpdGl6YXRpb24gb2Ygb3VyIHNlcnZpY2VzLlxyXG5cclxuJm5ic3A7XHJcbjxoND48c3Ryb25nPkJpZ2dlc3QgaGl0cz8gQmlnZ2VzdCBmYWlsdXJlcz8gV2hhdCBkaWQgeW91IGxlYXJuIGZyb20gdGhlc2U/PC9zdHJvbmc+PC9oND5cclxuU3VjY2VzczogdGhlIEZlc3RpdmFsIGRlIGxcdTIwMTlpbmZvIGxvY2FsZSwgd2hpY2ggaGFzIGVzdGFibGlzaGVkIGl0c2VsZiBpbiBsZXNzIHRoYW4gNSB5ZWFycyBhcyBhIEIyQiBldmVudCBvZiByZWZlcmVuY2UgZm9yIHRoZSBzZWN0b3IuXHJcblxyXG5GYWlsdXJlOiBJIGRvbid0IHdhbnQgdG8gYXBwZWFyIGxhY2tpbmcgaW4gbW9kZXN0eSwgYnV0IEkgZG9uJ3Qgc2VlIGFueSBiaWcgZmFpbHVyZXMuIFNvbWV0aW1lcyB3ZSBoYXZlIG5vdCBiZWVuIGFibGUgdG8gc3VzdGFpbiBzb21lIG9mIG91ciBpbml0aWF0aXZlcywgbGlrZSBvdXIgbWVkaWEgaW5jdWJhdG9yLiBPdGhlciB0aW1lcywgd2UgdGVybWluYXRlZCBhIHByb2plY3QgdG9vIHNvb24uIEZvciBleGFtcGxlLCBpbiAyMDE2LCB3ZSBsYXVuY2hlZCBhIHRyYWluaW5nIGNvdXJzZSBvbiB2aXJ0dWFsIHJlYWxpdHkgYW5kIDM2MC1kZWdyZWUgdmlkZW8gd2hpY2ggbmV2ZXIgc3RhcnRlZC4gRGVzcGl0ZSB0aGUgaW50ZXJlc3QgYWJvdXQgdGhlIHN1YmplY3QsIHdlIHdlcmUgcHJvYmFibHkgdG9vIGZhciBhaGVhZCBvZiB0aGUgbWF0dXJpdHkgb2YgdGhpcyB0ZWNobm9sb2d5IGFuZCB0aGUgcmVhbCBvcHBvcnR1bml0aWVzIGZvciBtZWRpYSBwcm9mZXNzaW9uYWxzLiBCdXQgYXMgYSBsYWIsIG91ciByb2xlIGlzIGFsc28gdG8gYmUgYSBsaXR0bGUgb3V0IG9mIHBoYXNlIGFuZCBpdCdzIG5vcm1hbCB0byBjcmFzaCBmcm9tIHRpbWUgdG8gdGltZS4gQWZ0ZXIgYWxsLCBpdCB3b3VsZCBiZSBuaWNlIHRvIGhhdmUgdGhlIGx1eHVyeSBvZiBjcmFzaGluZyBhIGxpdHRsZSBtb3JlIG9mdGVuIDstKVxyXG5cclxuJm5ic3A7XHJcbjxoND48c3Ryb25nPldoeSBkbyB5b3UgdGhpbmsgaW5ub3ZhdGlvbiBpbiBhIGNpdHktYmFzZWQgY2x1c3RlciBpcyB0aGUgd2F5IHRvIGdvPzwvc3Ryb25nPjwvaDQ+XHJcbkkgZG9uJ3Qga25vdyBpZiB0aGlzIGlzIHRoZSBvbmx5IHdheSB0byBnbywgYnV0IEknbSBjZXJ0YWluIHRoYXQgdGhpcyBhbGxvd3MgdXMgdG8gYmUgcm9vdGVkIGluIHJlYWxpdHkuIFdlIGhhdmUgZGlyZWN0IGNvbnRhY3Qgd2l0aCB0aGUgbG9jYWwgbWVkaWEgYW5kIGlubm92YXRpdmUgcGxheWVycyBpbiBvdXIgdGVycml0b3J5LCBhbmQgdGhpcyBjb250aW51ZXMgdG8gZmVlZCBvdXIgdGhpbmtpbmcgYW5kIHBsYW5zLCBrZWVwaW5nIGEgcmVhbCBhbmNob3IgYW5kIGF3YXJlbmVzcyBvZiB0aGUgcmVhbGl0aWVzIG9mIHRoZSBtZWRpYSBzZWN0b3IuXHJcblxyXG4mbmJzcDtcclxuXHJcbmJ5IEVyaW4gV2lsc29uLCBTdGVwaGVuIEZvemFyZCBhbmQgSm9obiBNaWxsc1svdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XSIsInBvc3RfdGl0bGUiOiJJbnRlcnZpZXcgJiM4MjExOyBPdWVzdCBNXHUwMGU5ZGlhbGFiOiBGb2N1cyBvbiBsb2NhbCBpbm5vdmF0aW9uIGtleSB0byBzdGF5aW5nIFx1MjAxY3Jvb3RlZCBpbiByZWFsaXR5XHUyMDFkIiwicG9zdF9saW5rIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL2ludGVydmlldy1vdWVzdC1tZWRpYWxhYi1mb2N1cy1vbi1sb2NhbC1pbm5vdmF0aW9uLWtleS10by1zdGF5aW5nLXJvb3RlZC1pbi1yZWFsaXR5LyIsInBvc3RfZmVhdHVyZWRfaW1hZ2UiOiI8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIkludGVydmlldyAmIzgyMTE7IE91ZXN0IE1cdTAwZTlkaWFsYWI6IEZvY3VzIG9uIGxvY2FsIGlubm92YXRpb24ga2V5IHRvIHN0YXlpbmcgXHUyMDFjcm9vdGVkIGluIHJlYWxpdHlcdTIwMWRcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjE1NVwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIzLzA3L091ZXN0TWVkaWFMYWItMzAweDE1NS5qcGVnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+IiwicG9zdF9jYXRlZ29yaWVzIjoiTWVkaWEgbGFicyIsInBvc3RfdGFncyI6IkZyYW5jZSwgTWVkaWEgbGFicywgTmFudGVzIiwiJV9lZGl0X2xvY2slIjoiMTY5OTM0MzAxODo0IiwiJV9lZGl0X2xhc3QlIjoiNCIsIiVzbGlkZV90ZW1wbGF0ZSUiOiJkZWZhdWx0IiwiJV93cGJfdmNfanNfc3RhdHVzJSI6InRydWUiLCIlX3dwZ21wX2xvY2F0aW9uX2FkZHJlc3MlIjoiMjggQmQgQmVub25pIEdvdWxsaW4sIDQ0MjAwIE5hbnRlcywgRnJhbmNlIiwiJV93cGdtcF9sb2NhdGlvbl9jaXR5JSI6Ik5hbnRlcyIsIiVfd3BnbXBfbG9jYXRpb25fc3RhdGUlIjoiUGF5cyBkZSBsYSBMb2lyZSIsIiVfd3BnbXBfbG9jYXRpb25fY291bnRyeSUiOiJGcmFuY2UiLCIlX3dwZ21wX21ldGFib3hfbGF0aXR1ZGUlIjoiNDcuMjAxNzgxOCIsIiVfd3BnbXBfbWV0YWJveF9sb25naXR1ZGUlIjoiLTEuNTUzMjAwNCIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiMlwiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6Ik47IiwiJV93cGdtcF9tZXRhYm94X3RheG9tb21pZXNfdGVybXMlIjoiTjsiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6Ik47IiwiJV95b2FzdF93cHNlb19jb250ZW50X3Njb3JlJSI6IjYwIiwiJV95b2FzdF93cHNlb19lc3RpbWF0ZWQtcmVhZGluZy10aW1lLW1pbnV0ZXMlIjoiNiIsIiVfdGh1bWJuYWlsX2lkJSI6IjE1Nzc3IiwiJV93cGNmX2JlbG9uZ3NfcGFnZV9pZCUiOiI5OCIsIiVfeW9hc3Rfd3BzZW9fcHJpbWFyeV9jYXRlZ29yeSUiOiIxNDIiLCIlX3lvYXN0X3dwc2VvX21ldGFkZXNjJSI6Ik91ZXN0IE1lZGlhbGFiIHdvcmtzIHdpdGggbG9jYWwgcHVibGlzaGVycyBhbmQgaW5ub3ZhdG9ycyBpbiB0aGVpciByZWdpb24gdG8gc3RheSBmb2N1c2VkIG9uIHRoZSByZWFsIGlzc3VlcyB0aGF0IGNvbXBhbmllcyBkZWFsIHdpdGguIiwidGF4b25vbXk9Y2F0ZWdvcnkiOiJNZWRpYSBsYWJzIiwidGF4b25vbXk9cG9zdF90YWciOiJGcmFuY2UsIE1lZGlhIGxhYnMsIE5hbnRlcyJ9LCJpY29uIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTgvMDIvbWFya2VyLTEucG5nIn0sImlkIjoxNTc3MiwiaW5mb3dpbmRvd19kaXNhYmxlIjpmYWxzZX0seyJzb3VyY2UiOiJwb3N0IiwidGl0bGUiOiIyNi0yNyBKQU5VQVJZIDIwMjMgXHUyMDEzIE1FRElBIExBQiBEQVlTICM2IEhhbWJ1cmciLCJpbmZvd2luZG93X2NvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIjI2LTI3IEpBTlVBUlkgMjAyMyBcdTIwMTMgTUVESUEgTEFCIERBWVMgIzYgSGFtYnVyZ1wiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMTM5XCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMjMvMDMvTUxENi1hbGwtU2NyZWVuLWUxNjc5OTM0OTIyMzY2LTMwMHgxMzkucG5nXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZ1wiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tcGFkZGluZy1jb250ZW50XzIwXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tbWV0YSBmYy1pdGVtLXNlY29uZGFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlIGZjLXRleHQtY2VudGVyXCI+TWVkaWEgbGFiczwvZGl2PlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLXRleHQtY2VudGVyXCI+MjYtMjcgSkFOVUFSWSAyMDIzIFx1MjAxMyBNRURJQSBMQUIgREFZUyAjNiBIYW1idXJnPC9kaXY+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tY29udGVudCBmYy1pdGVtLWJvZHktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZVwiPlxyXG4gICAgICAgICAgICBUaGUgc2l4dGggV0FOLUlGUkEgTWVkaWEgTGFicyBEYXlzIGluIEhhbWJ1cmcgYnJvdWdodCB0b2dldGhlciBtZWRpYSBsYWJzLCBhY2FkZW1pY3MgYW5kIHN0YXJ0LXVwcyB0byB0YWxrIGlubm92YXRpb24gcHJvY2Vzc2VzLCBXZWIzIGFuZCBBSS5cclxuICAgICAgICA8L2Rpdj5cclxuPGEgaHJlZj1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9tZWRpYS1sYWItZGF5cy1oYW1idXJnL1wiPlJlYWQgbW9yZTwvYT5cclxuICAgIDwvZGl2PlxyXG4gICAgPC9kaXY+XHJcbjwvZGl2PlxyXG5cclxuIiwiY29udGVudCI6IlRoZSBzaXh0aCBXQU4tSUZSQSBNZWRpYSBMYWJzIERheXMgaW4gSGFtYnVyZyBicm91Z2h0IHRvZ2V0aGVyIG1lZGlhIGxhYnMsIGFjYWRlbWljcyBhbmQgc3RhcnQtdXBzIHRvIHRhbGsgaW5ub3ZhdGlvbiBwcm9jZXNzZXMsIFdlYjMgYW5kIEFJLiIsImFkZHJlc3MiOiJIYW1idXJnLCBHZXJtYW55IiwibG9jYXRpb24iOnsibGF0IjoiNTMuNTQ4ODI4MiIsImNpdHkiOiJIYW1idXJnIiwic3RhdGUiOiJIYW1idXJnIiwiY291bnRyeSI6Ikdlcm1hbnkiLCJsbmciOiI5Ljk4NzE3MDI5OTk5OTk5OSIsIm9uY2xpY2tfYWN0aW9uIjoibWFya2VyIiwicmVkaXJlY3RfcGVybWFsaW5rIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL21lZGlhLWxhYi1kYXlzLWhhbWJ1cmcvIiwiem9vbSI6MiwiZXh0cmFfZmllbGRzIjp7InBvc3RfZXhjZXJwdCI6IlRoZSBzaXh0aCBXQU4tSUZSQSBNZWRpYSBMYWJzIERheXMgaW4gSGFtYnVyZyBicm91Z2h0IHRvZ2V0aGVyIG1lZGlhIGxhYnMsIGFjYWRlbWljcyBhbmQgc3RhcnQtdXBzIHRvIHRhbGsgaW5ub3ZhdGlvbiBwcm9jZXNzZXMsIFdlYjMgYW5kIEFJLiIsInBvc3RfY29udGVudCI6Ilt2Y19yb3ddW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNFwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxoMT48c3Ryb25nPk1lZGlhIExhYiBEYXlzICM2IGhlYWRzIHRvIEhhbWJ1cmdcdTAwYTA8L3N0cm9uZz48L2gxPlxyXG48aDQ+VGhlIHNpeHRoIGVkaXRpb24gb2YgV0FOLUlGUkFcdTIwMTlzIE1lZGlhIExhYnMgRGF5cywgdGhpcyB5ZWFyIGhlbGQgaW4gSGFtYnVyZyBvbiBKYW51YXJ5IDI2PHN1cD50aDwvc3VwPiBhbmQgMjc8c3VwPnRoPC9zdXA+LCBicm91Z2h0IHRvZ2V0aGVyIG1lZGlhIGxhYnMsIGFjYWRlbWljcyBhbmQgc3RhcnQtdXBzLCBmb2N1c2luZyBvbiB0aGVtZXMgbGlrZSBpbm5vdmF0aW9uIHByb2Nlc3NlcywgV2ViMyBvciBBSSwgaW5jbHVkaW5nIHRoZSBjdXJyZW50IG9wcG9ydHVuaXRpZXMgYW5kIGJhcnJpZXJzIGZhY2luZyB0aGUgaW5kdXN0cnkuPC9oND5cclxuRGF5IG9uZSBvcGVuZWQgd2l0aCBhIGZvY3VzIG9uIEhhbWJ1cmc6IHRoZSBjaXR5IG9mIGNvbnRlbnQgYW5kIHRlY2guIEhhbWJ1cmcgaGFzIGEgcmVwdXRhdGlvbiBmb3IgaXRzIGNyZWF0aXZpdHkgd2hlbiBpdCBjb21lcyB0byBtZWRpYSBhbmQgdGVjaG5vbG9neSBhbmQgYXMgYSByZXN1bHQgdGhpcyBhcmVhIGhhcyBiZWNvbWUgYSBwb3B1bGFyIHByb2Zlc3Npb25hbCBhc3BpcmF0aW9uIGZvciBtYW55IHlvdW5nIHBlb3BsZS5cclxuXHJcblBhcnRpY2lwYW50cyBoZWFyZCBmcm9tIHBhbmVsbGlzdHMgaG93IEhhbWJ1cmcgaXMgYSBidXJnZW9uaW5nIG1lZGlhIGh1YiBhbmQgdGhlIHByb2dyZXNzaW9uIG9mIEdlcm1hbi1iYXNlZCBtZWRpYSBzdGFydC11cHMuIFNwZWFrZXJzIGluY2x1ZGVkIFBhdWxhIExhdXRlcmJhY2gsIENvbW11bmljYXRpb25zIE1hbmFnZXIgYXQgPGEgaHJlZj1cImh0dHBzOi8vd3d3Lm5leHRtZWRpYS1oYW1idXJnLmRlXCI+bmV4dE1lZGlhIEhhbWJ1cmc8L2E+LCBtYW5hZ2VyIHBhcnRuZXIgQ2hyaXN0b3BoIEhcdTAwZmNuaW5nIG9mIDxhIGhyZWY9XCJodHRwczovL25tYS52Y1wiPk5NQSBWZW50dXJlIENhcGl0YWw8L2E+LCBCZXJuZHQgUlx1MDBmNnR0Z2VyLCBEZXB1dHkgQ2hpZWYgRWRpdG9yIDxhIGhyZWY9XCJodHRwczovL3d3dy5hYmVuZGJsYXR0LmRlXCI+SGFtYnVyZ2VyIEFiZW5kYmxhdHQ8L2E+IGFuZCBTb3BoaWEgQm95c2VuLCBQcm9kdWN0IGFuZCBQcm9qZWN0IE1hbmFnZXIgYXQgc29mdHdhcmUgc3RhcnQtdXAgPGEgaHJlZj1cImh0dHBzOi8vYm90dGFsay5pb1wiPkJvdFRhbGs8L2E+LlxyXG5cclxuPGltZyBjbGFzcz1cIndwLWltYWdlLTE1NzYxIHNpemUtbWVkaXVtIGFsaWduY2VudGVyXCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMjMvMDMvTUxENi1zaWduLXNjcmVlbi0yMjZ4MzAwLnBuZ1wiIGFsdD1cIlwiIHdpZHRoPVwiMjI2XCIgaGVpZ2h0PVwiMzAwXCIgLz5TcGVha2VycyBkaXNjdXNzZWQgaG93IHN0YXJ0LXVwcyBhcmUgdGhlIGVzc2VudGlhbCBjYXRhbHlzdCBmb3IgbWVkaWEgaW5ub3ZhdGlvbiBhbmQgaG93IHRoZWlyIGNvbXBhbmllcyBpbnZlc3QgYW5kIGNhcGl0YWxpc2Ugb24gc3VwcG9ydGluZyBlYXJseSBzdGFydC11cHMsIG1hbnkgdGhyb3VnaCBtZWRpYSBpbmN1YmF0b3JzIHdoaWNoIGFjdCB0byBzdXBwb3J0IHRoZXNlIGdyb3dpbmcgY29tcGFuaWVzLiBUaGUgd29yayBvZiBzdGFydC11cHMgaXMgc2xvd2x5IHN0YXJ0aW5nIHRvIGV4cGFuZCB0byBpbmNsdWRlIG90aGVyIHNlY3RvcnMgYW5kIGZvc3RlciBjb2xsYWJvcmF0aW9uLCBwYXJ0aWN1bGFybHkgd2l0aCBOTUEgVmVudHVyZSBDYXBpdGFsLCB0aGVpciB3b3JrIHNlZWtzIHRvIGNvbm5lY3Qgc3RhcnQtdXBzIGFuZCBjb3Jwb3JhdGVzIHRvIGZvc3RlciBjb2xsYWJvcmF0aW9uIGFuZCBpbm5vdmF0aW9uLlxyXG5cclxuU3RhcnQtdXAgQm90VGFsayB3YXMgZmVhdHVyZWQgYXMgYW4gaW5ub3ZhdGlvbiBjYXNlIHN0dWR5LiBCb3RUYWxrIGlzIGFuIGF1ZGlvIGNvbnRlbnQgbWFuYWdlbWVudCBzeXN0ZW0gdGhhdCBwcm92aWRlcyBleGNlbGxlbnQgcXVhbGl0eSB0ZXh0LXRvLXNwZWVjaCBhdXRvbWF0aW9uLiBUaGUgc29mdHdhcmUgd2FzIGJvcm5lIG91dCBvZiB0aGUgcmlzZSBvZiB0aGUgcGFuZGVtaWMgd2hpY2ggZXF1YXRlZCB0byB0aGUgcmlzZSBvZiB0aGUgcG9kY2FzdCBhbmQgYWltcyB0byB3b3JrIG9uIG1ha2luZyB0ZXh0LXRvLXNwZWVjaCB0byBiZSBhcyBodW1hbiBhcyBwb3NzaWJsZS4gVGhleSBjdXJyZW50bHkgaGF2ZSAxMCwwMDAgbGluZ3Vpc3RpYyBydWxlcywgYW5kIG1vcmUgdGhhbiAyMCwwMDAgd29yZHMgaW4gdGhlaXIgZGljdGlvbmFyeSwgYWltaW5nIHRvIGJyaW5nIHBvZGNhc3RzIGFuZCB0ZXh0LXRvLXNwZWVjaCB0b2dldGhlci5cclxuXHJcbkFmdGVybm9vbiBkaXNjdXNzaW9ucyBhbHNvIGNvdmVyZWQgaG93IG1lZGlhIGxhYnMgYW5kIGFjY2VsZXJhdG9ycyBhcmUgbm93IHJlY3J1aXRpbmcgeW91bmcgcHJvZmVzc2lvbmFscyBhbmQgc3R1ZGVudHMgdG8gaW5zcGlyZSBvdXQtb2YtdGhlLWJveCB0aGlua2luZyBhbmQgY29udHJpYnV0ZSB0byBtZWRpYSBpbm5vdmF0aW9uIHRocm91Z2ggY29sbGFib3JhdGlvbnMgd2l0aCBsb2NhbCBVbml2ZXJzaXRpZXMuIEtpbSBTdmVuZHNlbiwgQ2hpZWYgTWFya2V0aW5nIE9mZmljZXIgYXQgPGEgaHJlZj1cImh0dHBzOi8vd3d3LnN0aWJvZHguY29tXCI+U3RpYm8gRFg8L2E+IFx1MjAxMyBvdXIgaG9zdHMgZm9yIHRoZSB0d28tZGF5IGV2ZW50IC0gZGlzY3Vzc2VkIGhvdyB0aGUgY29tcGFueSBjb250cmlidXRlcyB0byBzdWNoIG1lZGlhIGlubm92YXRpb24uIFN0aWJvIFN5c3RlbXMgb3ducyBhbmQgcnVucyBpdHMgb3duIG1lZGlhIGxhYiwgdGhlIDxhIGhyZWY9XCJodHRwczovL3d3dy5zdGlib2FjY2VsZXJhdG9yLmNvbVwiPlN0aWJvIEFjY2VsZXJhdG9yPC9hPiBpbiBBYXJodXMsIERlbm1hcmsuXHUwMGEwIFRoZSBhY2NlbGVyYXRvciB3YXMgZXN0YWJsaXNoZWQgaW4gMjAxNCBhbmQgaXMgY3VycmVudGx5IHJ1bm5pbmcgaXRzIDE4dGggc2Vhc29uIHRvIGhlbHAgdGhlIG5leHQgZ2VuZXJhdGlvbiBvZiBzdHVkZW50cyBhc3BpcmluZyB0byB3b3JrIGluIG1lZGlhIGlubm92YXRpb24uXHJcbjxwIHN0eWxlPVwidGV4dC1hbGlnbjogY2VudGVyO1wiPjxpbWcgY2xhc3M9XCJhbGlnbmNlbnRlciB3cC1pbWFnZS0xNTc1OCBzaXplLWZ1bGxcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAyMy8wMy9NTEQ2LUtpbS1zY2FsZWQuanBnXCIgYWx0PVwiXCIgd2lkdGg9XCIyNTYwXCIgaGVpZ2h0PVwiMTQ0MFwiIC8+PC9wPlxyXG48cCBzdHlsZT1cInRleHQtYWxpZ246IGxlZnQ7XCI+VGhlIGludHJvZHVjdGlvbiBvbiBzdGFydC11cHMgd2FzIHN1cHBsZW1lbnRlZCBieSBjYXNlIHN0dWRpZXMgb24gbmV3IGxhYnMgZnJvbSB0aGUgV0FOLUlGUkEgY29tbXVuaXR5LiBUaGUgZmlyc3QgZXhhbXBsZSBjYW1lIGZyb20gSGVsZ2UgTy4gU3ZlbGEsIENFTyBvZiA8YSBocmVmPVwiaHR0cHM6Ly9tZWRpYWNpdHliZXJnZW4ubm9cIj5NZWRpYSBDaXR5IEJlcmdlbjwvYT4gaW4gTm9yd2F5LiBUaGVpciB3b3JrIHJldm9sdmVzIGFyb3VuZCB0d28gbWFpbiBwaWxsYXJzOjwvcD5cclxuXHJcbjx1bD5cclxuIFx0PGxpPjxzdHJvbmc+QSBzdXN0YWluYWJsZSBkZW1vY3JhY3k6PC9zdHJvbmc+IEEgZnVuZGFtZW50YWwgZm9yY2UgdG8gZW1wb3dlciBpbXBvcnRhbnQgc3RvcmllcywgZW5zdXJlIGFuIGluZm9ybWVkIHBvcHVsYXRpb24sIGFuZCBzdHJlbmd0aGVuIGRlbW9jcmFjeS4gQSB3ZWxsLXdvcmtpbmcgZWNvc3lzdGVtIHRvIGZ1ZWwgZWRpdG9yaWFsIGlubm92YXRpb24sIHByb21vdGUgbWVkaWEgZGl2ZXJzaXR5IGFuZCBmaWdodCBmaWx0ZXIgYnViYmxlcyBhbmQgZmFsc2UgaW5mb3JtYXRpb24uPC9saT5cclxuIFx0PGxpPjxzdHJvbmc+QSB3b3JsZC1sZWFkaW5nIHRlY2hub2xvZ3kgaHViOjwvc3Ryb25nPiBNZWRpYSBDaXR5IEJlcmdlbiBpcyBhIGxlYWRpbmcsIGludGVybmF0aW9uYWwgaHViIGZvciBtZWRpYSBhbmQgdGVjaG5vbG9neSBpbm5vdmF0aW9uLjwvbGk+XHJcbjwvdWw+XHJcblRoZSBzZWNvbmQgY2FzZSBzdHVkeSBjYW1lIGZyb20gSm9lcmcgUGZlaWZmZXIsIFByb2R1Y3QgTWFuYWdlciBhdCA8YSBocmVmPVwiaHR0cHM6Ly93d3cuYnIuZGUvZXh0cmEvYWktYXV0b21hdGlvbi1sYWIvaW5kZXguaHRtbFwiPkJSIEFJICsgQXV0b21hdGlvbiBMYWIgYXQgQmF5ZXJyaXNjaGUgUnVuZGZ1bms8L2E+LiBIaXMgcHJlc2VudGF0aW9uIGRpc2N1c3NlZCB1c2VyLWNlbnRyaWMgam91cm5hbGlzbSB3aXRoIGFsZ29yaXRobXMuIEpvdXJuYWxpc3RzIGNhbiB1c2UgYWxnb3JpdGhtcyBpbiB0aGUgbmV3c3Jvb20gdG86XHJcbjx1bD5cclxuIFx0PGxpPlN1cHBvcnQgZWRpdG9ycyBpbiB0aGVpciB3b3JrIHByb2Nlc3NlczwvbGk+XHJcbiBcdDxsaT5QZXJzb25hbGlzZSBzZXJ2aWNlcyBmb3IgdXNlcnM8L2xpPlxyXG4gXHQ8bGk+T3BlbiB1cCBsYXJnZSBhbW91bnRzIG9mIGRhdGE8L2xpPlxyXG4gXHQ8bGk+U3VwcG9ydCByZXNlYXJjaDwvbGk+XHJcbjwvdWw+XHJcblRoZSB1c2Ugb2YgYWxnb3JpdGhtcyBjYW4gY29udHJpYnV0ZSBtb3JlIHRvIHRoZSBjb25zdW1wdGlvbiBvZiBwZXJzb25hbGlzZWQgY29udGVudCwgcmVhY2hpbmcgYSBmcmFnbWVudGVkIGF1ZGllbmNlIGFzIGEgcHVibGljIHNlcnZpY2UgYnJvYWRjYXN0ZXIgYW5kIHByb3ZpZGluZyBjb25zdW1lcnMgd2l0aCBoeXBlci1yZWdpb25hbCBuZXdzIG9mZmVyaW5nIG1vcmUgcmVsZXZhbnQgdG8gdGhlaXIgbG9jYWwgYXJlYS5cclxuXHJcblRoZSBmaW5hbCBzcGVha2VyIGluIHRoaXMgc2Vzc2lvbiB3YXMgQWxleGFuZHJhIEZvbHdhcnNraSwgVGVhbSBMZWFkIGF0IHRoZSA8YSBocmVmPVwiaHR0cHM6Ly93d3cuaW5uby1sYWIuYXRcIj5NZWRpYSBJbm5vdmF0aW9uIExhYjwvYT4gYXQgV2llbmVyIFplaXR1bmcuIFRoZWlyIG1lZGlhIGxhYiBpcyBmb3JtZWQgb2YgYXBwcm94aW1hdGVseSBlaWdodCBtZWRpYSBzdGFydC11cHMgd2hpY2ggYXJlIHN1cHBvcnRlZCBmb3IgbmluZSBtb250aHMuIFRoZSBsYWIgd29ya3MgYXMgYW4gaW5jdWJhdG9yIGFuZCBhY2NlbGVyYXRvciwgcHJvdmlkaW5nIHdvcmtzaG9wcyBhbmQgaW5kaXZpZHVhbCBjb2FjaGluZyBpbiB0ZXJtcyBvZiBzdXBwb3J0LiBUaGlzIGlzIHByb3ZpZGVkIGJ5IGl0cyBBbHVtbmkgcHJvZ3JhbW1lIHdoaWNoIG9mZmVycyB3b3Jrc2hvcCBzZXNzaW9ucyBhbmQgbW9yZSBuZXR3b3JraW5nIG9wcG9ydHVuaXRpZXMuXHJcblxyXG5UaGUgZGF5IGVuZGVkIHdpdGggYSBGT0NVUyBzZXNzaW9uOiBXZWIzIGZvciBOZXdzIE1lZGlhOiBkZWZpbml0aW9ucywgb3Bwb3J0dW5pdGllcywgc3RhdGUgb2YgcGxheT9cclxuXHJcbkhhbnMgQnJvcnNlbiwgRXVyb3BlYW4gQmxvY2tjaGFpbiBDZW50ZXIgYXQgdGhlIElUIFVuaXZlcnNpdHkgb2YgQ29wZW5oYWdlbiwgaW50cm9kdWNlZCBXZWIzIC0gYSBuZXcgaXRlcmF0aW9uIG9mIHRoZSBXb3JsZCBXaWRlIFdlYiB3aGljaCBpbmNvcnBvcmF0ZXMgY29uY2VwdHMgc3VjaCBhcyBkZWNlbnRyYWxpemF0aW9uLCBibG9ja2NoYWluIHRlY2hub2xvZ2llcywgYW5kIHRva2VuLWJhc2VkIGVjb25vbWljcy4gVGhlIGNvcmUgaWRlYXMgb2Ygd2ViMyBhcmU6XHJcbjx1bD5cclxuIFx0PGxpPldlYjMgaXMgZGVjZW50cmFsaXNlZCBhbmQgY2Vuc29yIHByb29mPC9saT5cclxuIFx0PGxpPldlYjMgaXMgb3BlbiBhbmQgdHJhbnNwYXJlbnQ8L2xpPlxyXG4gXHQ8bGk+V2ViMyBpcyB1c2VyLWNlbnRyaWMgYW5kIGVuYWJsZXMgZGlnaXRhbCBvd25lcnNoaXAgb2YgYXNzZXRzIGFuZCBpZGVudGl0aWVzLjwvbGk+XHJcbjwvdWw+XHJcblRoZSByZXN0IG9mIHRoZSB0YWxrIGRpc2N1c3NlZCB0aGUgZWxlbWVudHMgb2YgV2ViMyBpbmNsdWRpbmcgYW4gb3ZlcnZpZXcgb2Ygc2VydmljZXMgc3Vycm91bmRpbmcgYmxvY2tjaGFpbiB0ZWNobm9sb2d5LCBhbmQgYSBsb29rIGF0IHBvc3NpYmxlIHVzZXMgaW5jbHVkaW5nIGNyeXB0by13YWxsZXRzLCBORlRzIChub24tZnVuZ2libGUgdG9rZW5zKSwgREFPcyAoZGVjZW50cmFsaXNlZCBhdXRvbm9tb3VzIG9yZ2FuaXNhdGlvbikgYW5kIGRlY2VudHJhbGlzZWQgc3RvcmFnZS5cclxuXHJcblJhXHUwMGZhbCBKYXJhbWlsbG8sIFByb2plY3QgTWFuYWdlciBhdCA8YSBocmVmPVwiaHR0cHM6Ly93d3cuY29nZW5jeWxhYi5jb21cIj5Db2dlbmN5PC9hPiwgYW4gaW50ZXJuYXRpb25hbCBjb2FsaXRpb24gb2YgY29udGVudCBtYWtlcnMsIGRlc2lnbmVycyBhbmQgYnVpbGRlcnMgc3VwcG9ydGVkIGJ5IFdBTi1JRlJBIGRldmVsb3BlZCBmdXJ0aGVyIHRoZXNlIGNvbnZlcnNhdGlvbnMuIENvZ2VuY3kgcnVucyBwcm9qZWN0cyB0aGF0IGFpbSB0byBoYXZlIGEgbWVhbmluZ2Z1bCBpbXBhY3QgYW5kIGJyaW5nIGNsYXJpdHkgYW5kIGxvZ2ljIHRvIGhlbHAgc29sdmUgY29tcGxleCBwcm9ibGVtcy4gSGUgcHJlc2VudGVkIHRoZSBjb25jZXB0IG9mIGNyZWF0aW5nIGEgZGVjZW50cmFsaXNlZCBkaWdpdGFsIGlkZW50aXR5IHdoaWNoIHRoZW4gc3BhcmtlZCBhIGRlYmF0ZSBhYm91dCB0aGUgb3Bwb3J0dW5pdGllcyBvZiBXZWIzIHRlY2hub2xvZ2llcyBmb3IgbmV3cyBtZWRpYSBpbiB0aGUgZnV0dXJlLlxyXG5cclxuPGltZyBjbGFzcz1cImFsaWduY2VudGVyIHdwLWltYWdlLTE1NzU5IHNpemUtZnVsbFwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIzLzAzL01MRDYtVmlvbGFpbmUtc2NhbGVkLmpwZ1wiIGFsdD1cIlwiIHdpZHRoPVwiMjU2MFwiIGhlaWdodD1cIjE0NDBcIiAvPlxyXG5cclxuVG8gYmVnaW4gZGF5IHR3bywgZGlzY3Vzc2lvbnMgZm9jdXNlZCBvbiBob3cgdG8gY3JlYXRlIGlubm92YXRpb24sIGFuZCB3aGVyZSB0aGUgcGxhY2UgaXMgZm9yIGlubm92YXRpb24gaW4gYSBtZWRpYSBvcmdhbmlzYXRpb24/XHJcblxyXG5MaW5hIFRpbW0sIENFTyBvZiBNZWRpZW4uQmF5ZXJuOyBKb2FjaGltIERyZXlrbHVmdCwgTWVtYmVyIG9mIHRoZSBib2FyZCBvZiBtYW5hZ2VtZW50IGZvciBOT1ogRGlnaXRhbCwgYW5kIEhlbmRyaWsgTGVobWFubiwgSGVhZCBvZiB0aGUgVGFnZXNzcGllZ2VsIElubm92YXRpb24gTGFiIGZvcm1lZCBhIHBhbmVsIHRvIGZvY3VzIGluIG9uIHRoaXMga2V5IHF1ZXN0aW9uLCBjb3ZlcmluZyBzdWNjZXNzZnVsIGFuZCBub3Qtc28tc3VjY2Vzc2Z1bCBleGFtcGxlcy5cclxuXHJcbk1lZGllbiBCYXllcm4gc3VwcG9ydHMgbnVtZXJvdXMgc3RhcnQtdXBzIGFuZCB0cmllZCBhIG1lbWJlcnNoaXAgY29ubmVjdGlvbiBhbmQgZW50cmVwcmVuZXVyc2hpcCBwcm9ncmFtbWUgd2hpY2ggd2FzIHVuc3VjY2Vzc2Z1bC4gSW4gdGhlIGZ1dHVyZSwgTGluYSBUaW1tIHNhaWQgdGhleSB3YW50IHRvIGZvY3VzIG9uIGhvdyB0byBjYXRlciBmb3IgY29uc3VtZXJzIGJldHRlciB3aGVuIGl0IGNvbWVzIHRvIG1lZGlhL25ld3MvaW5ub3ZhdGlvbi5cclxuXHJcbk5PWiBEaWdpdGFsIHdhbnRlZCB0byBjcmVhdGUgYSBZb3VUdWJlIGNoYW5uZWwgYW5kIGluY29ycG9yYXRlIHRoaXMgaW50byBhIHN1Y2Nlc3NmdWwgYnVzaW5lc3MgbW9kZWwsIGJ1dCBpdCBmYWlsZWQgZHVlIHRvIGEgbGFjayBvZiBpbnRlcmVzdCBmcm9tIHdpdGhpbi4gSm9hY2hpbSBhbHNvIHRhbGtlZCBhYm91dCB0aGUgZmFpbHVyZSBvZiBsYWJzIGJlY2F1c2Ugb2YgaW5ub3ZhdGlvbiAtIHNvbWUgcGVvcGxlIGFyZSBpZGVhcyBwZW9wbGUgYW5kIG5vdCBwcm9kdWN0IGRldmVsb3BlcnMvYnVzaW5lc3NwZW9wbGUuXHJcblxyXG5GaW5hbGx5LCBIZW5kcmlrIExlaG1hbm4gdGFsa2VkIGFib3V0IHdhbnRpbmcgdG8gZ2V0IGludG8gcG9kY2FzdHMgd2hpY2ggd291bGQgaGF2ZSByZXF1aXJlZCBtaW5pbWFsIGNvc3RzLCBidXQgdGhlIHBsYW4gZGlkIG5vdCBtb3ZlIGZvcndhcmQgYXQgdGhlIHRpbWUuXHJcblxyXG5BZnRlciB0aGlzIHBhbmVsLCB0aGUgY29uZmVyZW5jZSBjb250aW51ZWQgd2l0aCBhbm90aGVyIEZPQ1VTIHNlc3Npb24gb24gdGhlIGxhdGVzdCBpbiBmYWN0LWNoZWNraW5nLCBsZWQgYnkgTmF0aGFsaWUgR2FsbGV0LCBKb3VybmFsaXN0LCBNXHUwMGU5ZGlhTGFiIGRlIGxcdTIwMTlpbmZvcm1hdGlvbiwgRnJhbmNlIFRWLiBUaGVpciBmYWN0LWNoZWNraW5nIHRlYW1zIGhlbHAgam91cm5hbGlzdHMgYXMgd2VsbCBhcyB0aGUgcHVibGljIHRvIGluZm9ybSB3aXRoIHJlbGlhYmxlIGNvbnRlbnQgYW5kIHRoZSBwdWJsaWMgdG8gc2hhcmUgYXV0aGVudGljIGluZm9ybWF0aW9uLiBPbmUgb2YgdGhlaXIgbmV4dCBwcm9qZWN0cyBpcyB0byBwYXJ0bmVyIHdpdGggTm9yd2VnaWFuIGZhY3RjaGVja2luZyBpbml0aWF0aXZlIHRvIGNyZWF0ZSBhIHNlYXJjaCBlbmdpbmUgZm9yIGZhY3QtY2hlY2tlZCBpbWFnZXMvdmlkZW9zLiBJbiBhbm90aGVyIHJlbGF0ZWQgcHJvamVjdCwgPGEgaHJlZj1cImh0dHBzOi8vd3d3LnZlcmFhaS5ldS9ob21lXCI+VmVyYS5haTwvYT4sIERlbmlzIFRleXNzb3UsIEhlYWQgb2YgTWVkaWFMYWIgQUZQIGlzIGZvY3VzaW5nIG9uIGRpc2luZm9ybWF0aW9uIGFuYWx5c2lzIGFuZCBBSS1zdXBwb3J0ZWQgdmVyaWZpY2F0aW9uIHRvb2xzIGFuZCBzZXJ2aWNlcy4gVmVyYS5haSBpcyBhbiBFVSBmdW5kZWQgcHJvamVjdCB3aXRoIHRoZSBpbnZvbHZlbWVudCBvZiA4IHJlc2VhcmNoIHBhcnRuZXJzLCAyIGNvbW1lcmNpYWwgb3JnYW5pc2F0aW9ucyB3aXRoIHJlbGV2YW50IHByb2R1Y3RzIGFuZCAyIGdsb2JhbCBuZXdzIGFuZCBmYWN0LWNoZWNraW5nIHByb3ZpZGVycy5cclxuXHJcbk1vdmluZyB0byBzdGFydC11cHMsIEFuZHkgVGF5bG9yLCBDRU8gYW5kIEZvdW5kZXIgb2YgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmJ3bGIuY28udWsvXCI+QWNjb3JkaW9uPC9hPiwgaW50cm9kdWNlZCBob3cgaGlzIHByb2R1Y3QgYWxsb3dzIHVzZXJzIHRvIGF1dG9tYXRpY2FsbHkgc2hvcnRlZCBwbGF5IHRpbWVzIGZvciBwb2RjYXN0cyBhbmQgdmlkZW8gbWVkaWEuIFRheWxvciBwaXRjaGVkIHRoYXQgdGhlIHRlY2hub2xvZ3kgYWxsb3dzIGxpc3RlbmVycyB0byBhZGp1c3QgdGhlIGxlbmd0aCBvZiB0aGVpciBkZXNpcmVkIGNvbnRlbnQgd2l0aG91dCBjb21wcm9taXNpbmcgb24gc3RydWN0dXJlLCB0b25lIG9yIGxpc3RlbmFiaWxpdHkuIENocmlzdG9waGVyIEJyZW5uYW4sIENoaWVmIFByb2R1Y3QgT2ZmaWNlciBhdCA8YSBocmVmPVwiaHR0cDovL292ZXJ0b25lLmFpL1wiPk92ZXJ0b25lLmFpPC9hPiwgZXhwbGFpbmVkIHRoYXQgaGlzIHByb2R1Y3QgYWltcyB0byBoaWdobGlnaHQgXHUyMDE4cXVhbGl0eVx1MjAxOSBqb3VybmFsaXNtLiBVc2luZyBBSSBhbGdvcml0aG1zIGFuZCBuYXR1cmFsIGxhbmd1YWdlIHByb2Nlc3NpbmcgaXQgZm9jdXNzZXMgb24gdGhlIHF1YWxpdGllcyBvZiB0aGUgdGV4dCBpdHNlbGYsIHJhdGhlciB0aGFuIHRlcnRpYXJ5IG1ldHJpY3Mgc3VjaCBhcyBjbGlja3MgYW5kIHNoYXJlcy4gSXQgaGlnaGxpZ2h0cyBvcmlnaW5hbCByZXBvcnRpbmcsIGdvb2Qgc291cmNpbmcgYW5kIHRoZSBlZmZlY3RpdmVuZXNzIG9mIGhvdyBpZGVhcyBhcmUgZXhwbG9yZWQgYW5kIGV4cHJlc3NlZC4gT3ZlcnRvbmUuYWkgd2FudHMgY29udGVudCB0byBiZSBhc3Nlc3NlZCBvbiBpdHMgYWN0dWFsIHF1YWxpdHkgcmF0aGVyIHRoYW4gY2xpY2stYmFzZWQgbWV0cmljcy5cclxuXHJcblRoZSBlbmQgb2YgdGhlIHNlY29uZCBhbmQgZmluYWwgZGF5IHdhcyBtYXJrZWQgd2l0aCB0aGUgY2xvc2luZyBkaXNjdXNzaW9uIG9uIGxhcmdlIGxhbmd1YWdlIG1vZGVscywgaW5jbHVkaW5nIENoYXRHUFQgYW5kIGl0cyBzaWJsaW5ncy4gTGFuZ3VhZ2UgbW9kZWxzIGxpa2UgQ2hhdEdQVCBhcmUgcGFydGljdWxhcmx5IHRvcGljYWwgYXQgdGhlIG1vbWVudCBnaXZlbiB0aGVpciBwb3B1bGFyaXR5IGZvciBwcm9kdWNpbmcgYWNjdXJhdGUgY29udGVudC4gVGhlIGlkZWEgYmVoaW5kIHRoaXMga2luZCBvZiBzb2Z0d2FyZSBpcyB0byBidWlsZCBhIHN0cnVjdHVyZSBzaW1pbGFyIHRvIHRoZSBodW1hbiBicmFpbiB3aGljaCBjYW4gZ2VuZXJhdGUgdGV4dCBvbiBhbnkgdG9waWMuIFRoZSBzb2Z0d2FyZSBpbmNvcnBvcmF0ZXMgaW5mb3JtYXRpb24gZnJvbSBzb3VyY2VzIGxpa2Ugd2Vic2l0ZXMsIHNvY2lhbCBtZWRpYSBhbmQgc2NpZW50aWZpYyBwdWJsaWNhdGlvbnMuIFRoZSBwb3RlbnRpYWwgb2YgQ2hhdEdQVCBpbiBvdXIgaW5kdXN0cmllcyBjb3VsZCBiZSB0bzpcclxuPHVsPlxyXG4gXHQ8bGk+SW1wcm92ZSBlZmZpY2llbmN5IGluIGNvbnRlbnQgY3JlYXRpb248L2xpPlxyXG4gXHQ8bGk+Rm9jdXMgam91cm5hbGlzdGljIGF0dGVudGlvbiBvbiBJbnZlc3RpZ2F0aW9uPC9saT5cclxuIFx0PGxpPlJlZHVjZSBjb3N0cyBmb3IgZW5nYWdpbmcgdmlld2Vycy9yZWFkZXJzPC9saT5cclxuPC91bD5cclxuQ2hhdEdQVCBpcyBhbHJlYWR5IHByb3ZpbmcgZWZmZWN0aXZlIGluIHRoZSBmaWVsZCBvZiBtZWRpYSB3aGVuIGl0IGNvbWVzIHRvIHdyaXRpbmcgYW5kIGNyZWF0aW5nIGNvcHkgYW5kIGNvbnRlbnQuIENoYXRHUFQgaXMgYW4gZXh0cmFwb2xhdGlvbiBvZiBhIGNsYXNzIG9mIG1hY2hpbmUgbGVhcm5pbmcgTmF0dXJhbCBMYW5ndWFnZSBQcm9jZXNzaW5nIG1vZGVscyBrbm93biBhcyBMYXJnZSBMYW5ndWFnZSBNb2RlbCAoTExNcykuIExMTXMgZGlnZXN0IGh1Z2UgcXVhbnRpdGllcyBvZiB0ZXh0IGRhdGEgYW5kIGluZmVyIHJlbGF0aW9uc2hpcHMgYmV0d2VlbiB3b3JkcyB3aXRoaW4gdGhlIHRleHQuXHJcblxyXG5UaGUgZmluYWwgdGhvdWdodCBvZiB0aGUgY29uZmVyZW5jZSBjYW1lIGZyb20gUm9sZiBEeXJuZXMgU3ZlbmRzZW4sIGNoYWlyIG9mIHRoZSBHQU1JIGJvYXJkLCB3aG8gaGlnaGxpZ2h0ZWQgaG93IGltcG9ydGFudCB0aGVzZSBjb252ZXJzYXRpb25zIGFyZSBmb3IgdGhlIGluZHVzdHJ5IGFuZCBob3cgaW1wb3J0YW50IGl0IGlzIHRvIGV4Y2hhbmdlIGFuZCBuZXR3b3JrIHdpdGggb3VyIHBlZXJzIGFuZCBsaWtlLW1pbmRlZCBwZW9wbGUuXHJcblxyXG48c3BhbiBzdHlsZT1cInRleHQtZGVjb3JhdGlvbjogdW5kZXJsaW5lO1wiPjxzdHJvbmc+TWVkaWEgTGFicyBEYXkgIzcgd2lsbCB0YWtlIHBsYWNlIGluIEJlcmdlbiBpbiB0aGUgYXV0dW1uIFx1MjAxMyBqb2luIG91ciBHbG9iYWwgQWxsaWFuY2UgZm9yIE1lZGlhIElubm92YXRpb24gdG8gYmUgdGhlcmUgdG9vXHUyMDI2PC9zdHJvbmc+PC9zcGFuPlxyXG5cclxuJm5ic3A7XHJcblxyXG5Xcml0dGVuIGJ5IEVyaW4gV2lsc29uLlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XSIsInBvc3RfdGl0bGUiOiIyNi0yNyBKQU5VQVJZIDIwMjMgXHUyMDEzIE1FRElBIExBQiBEQVlTICM2IEhhbWJ1cmciLCJwb3N0X2xpbmsiOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvbWVkaWEtbGFiLWRheXMtaGFtYnVyZy8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCIyNi0yNyBKQU5VQVJZIDIwMjMgXHUyMDEzIE1FRElBIExBQiBEQVlTICM2IEhhbWJ1cmdcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjEzOVwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIzLzAzL01MRDYtYWxsLVNjcmVlbi1lMTY3OTkzNDkyMjM2Ni0zMDB4MTM5LnBuZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6Ik1lZGlhIGxhYnMiLCJwb3N0X3RhZ3MiOiJIYW1idXJnLCBNZWRpYSBsYWJzIiwiJV9lZGl0X2xvY2slIjoiMTY4OTg1Mzg1NTo0IiwiJV9lZGl0X2xhc3QlIjoiNCIsIiVfeW9hc3Rfd3BzZW9fcHJpbWFyeV9jYXRlZ29yeSUiOiIxNDIiLCIlX3RodW1ibmFpbF9pZCUiOiIxNTc2MCIsIiVzbGlkZV90ZW1wbGF0ZSUiOiJkZWZhdWx0IiwiJV93cGJfdmNfanNfc3RhdHVzJSI6InRydWUiLCIlX3dwZ21wX2xvY2F0aW9uX2FkZHJlc3MlIjoiSGFtYnVyZywgR2VybWFueSIsIiVfd3BnbXBfbG9jYXRpb25fY2l0eSUiOiJIYW1idXJnIiwiJV93cGdtcF9sb2NhdGlvbl9zdGF0ZSUiOiJIYW1idXJnIiwiJV93cGdtcF9sb2NhdGlvbl9jb3VudHJ5JSI6Ikdlcm1hbnkiLCIlX3dwZ21wX21ldGFib3hfbGF0aXR1ZGUlIjoiNTMuNTQ4ODI4MiIsIiVfd3BnbXBfbWV0YWJveF9sb25naXR1ZGUlIjoiOS45ODcxNzAyOTk5OTk5OTkiLCIlX3dwZ21wX21ldGFib3hfbG9jYXRpb25fcmVkaXJlY3QlIjoibWFya2VyIiwiJV93cGdtcF9tZXRhYm94X2N1c3RvbV9saW5rJSI6IiIsIiVfd3BnbXBfbWFwX2lkJSI6ImE6MTp7aTowO3M6MTpcIjJcIjt9IiwiJV93cGdtcF9tZXRhYm94X21hcmtlcl9pZCUiOiJOOyIsIiVfd3BnbXBfbWV0YWJveF90YXhvbW9taWVzX3Rlcm1zJSI6Ik47IiwiJV93cGdtcF9leHRlbnNpb25zX2ZpZWxkcyUiOiJOOyIsIiVfeW9hc3Rfd3BzZW9fY29udGVudF9zY29yZSUiOiIzMCIsIiVfeW9hc3Rfd3BzZW9fZXN0aW1hdGVkLXJlYWRpbmctdGltZS1taW51dGVzJSI6IjciLCIlX3dwX29sZF9kYXRlJSI6IjIwMjMtMDMtMjciLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza3clIjoiTWVkaWEgTGFiIiwiJV95b2FzdF93cHNlb190aXRsZSUiOiJNRURJQSBMQUIgREFZUyAjNiBIYW1idXJnIG9uIGlubm92YXRpb24sIFdlYjMgYW5kIEFJIiwiJV95b2FzdF93cHNlb19tZXRhZGVzYyUiOiJUaGUgc2l4dGggV0FOLUlGUkEgTWVkaWEgTGFiIERheXMgaW4gSGFtYnVyZyBicm91Z2h0IHRvZ2V0aGVyIG1lZGlhIGxhYnMsIGFjYWRlbWljcyBhbmQgc3RhcnQtdXBzIHRvIHRhbGsgaW5ub3ZhdGlvbiBwcm9jZXNzZXMsIFdlYjMgYW5kIEFJLiIsIiVfeW9hc3Rfd3BzZW9fbGlua2RleCUiOiI2NyIsIiVfd3Bfb2xkX3NsdWclIjoiMjYtMjctamFudWFyeS0yMDIzLW1lZGlhLWxhYi1kYXlzLTYtaGFtYnVyZyIsInRheG9ub215PWNhdGVnb3J5IjoiTWVkaWEgbGFicyIsInRheG9ub215PXBvc3RfdGFnIjoiSGFtYnVyZywgTWVkaWEgbGFicyJ9LCJpY29uIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTgvMDIvbWFya2VyLTEucG5nIn0sImlkIjoxNTc1NywiaW5mb3dpbmRvd19kaXNhYmxlIjpmYWxzZX0seyJzb3VyY2UiOiJwb3N0IiwidGl0bGUiOiJJbmhvbGxhbmQmIzgyMTc7cyBTdXN0YWluYWJsZSBNZWRpYSBMYWI6IGltYWdpbmluZyBzb2NpYWxseSwgZW52aXJvbm1lbnRhbGx5IGFuZCB0ZWNobmljYWxseSBzdXN0YWluYWJsZSBpbmZyYXN0cnVjdHVyZSIsImluZm93aW5kb3dfY29udGVudCI6IjxkaXYgY2xhc3M9XCJmYy1pdGVtLWJveCBmYy1pdGVtLW5vLXBhZGRpbmdcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiQSBwaG90b2dyYXBoIG9mIEhvbGxhbmQgd2l0aCBncmFwaGljcyBvZiAmIzAzOTtuZXR3b3JrIGNvbm5lY3Rpb25zJiMwMzk7IGxpbmtpbmcgZGlmZmVyZW50IGFyZWFzXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIxNTRcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAyMi8wOC9TdXN0YWluYWJsZS1NZWRpYS1MYWItMzAweDE1NC5wbmdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1wYWRkaW5nLWNvbnRlbnRfMjBcIj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1tZXRhIGZjLWl0ZW0tc2Vjb25kYXJ5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2UgZmMtdGV4dC1jZW50ZXJcIj5HcmVlbiBtZWRpYSwgSW5ub3ZhdGlvbiBDYXNlPC9kaXY+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tdGl0bGUgZmMtaXRlbS1wcmltYXJ5LXRleHQtY29sb3IgZmMtdGV4dC1jZW50ZXJcIj5JbmhvbGxhbmQmIzgyMTc7cyBTdXN0YWluYWJsZSBNZWRpYSBMYWI6IGltYWdpbmluZyBzb2NpYWxseSwgZW52aXJvbm1lbnRhbGx5IGFuZCB0ZWNobmljYWxseSBzdXN0YWluYWJsZSBpbmZyYXN0cnVjdHVyZTwvZGl2PlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2VcIj5cclxuICAgICAgICAgICAgSW5ob2xsYW5kJ3MgU3VzdGFpbmFibGUgTWVkaWEgTGFiIGlzIGxlYWRpbmcgdGhlIHdheSBvbiBpbWFnaW5pbmcgc29jaWFsbHksIGVudmlyb25tZW50YWxseSBhbmQgdGVjaG5pY2FsbHkgc3VzdGFpbmFibGUgaW5mcmFzdHJ1Y3R1cmUuXHJcbiAgICAgICAgPC9kaXY+XHJcbjxhIGhyZWY9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvc3VzdGFpbmFibGUtbWVkaWEtbGFiL1wiPlJlYWQgbW9yZTwvYT5cclxuICAgIDwvZGl2PlxyXG4gICAgPC9kaXY+XHJcbjwvZGl2PlxyXG5cclxuIiwiY29udGVudCI6IkluaG9sbGFuZCdzIFN1c3RhaW5hYmxlIE1lZGlhIExhYiBpcyBsZWFkaW5nIHRoZSB3YXkgb24gaW1hZ2luaW5nIHNvY2lhbGx5LCBlbnZpcm9ubWVudGFsbHkgYW5kIHRlY2huaWNhbGx5IHN1c3RhaW5hYmxlIGluZnJhc3RydWN0dXJlLiIsImFkZHJlc3MiOiJQcmluc2VncmFjaHQgMjcsIDI1MTIgRVcgRGVuIEhhYWcsIE5ldGhlcmxhbmRzIiwibG9jYXRpb24iOnsibGF0IjoiNTIuMDc0OTU4NiIsImNpdHkiOiJEZW4gSGFhZyIsInN0YXRlIjoiWnVpZC1Ib2xsYW5kIiwiY291bnRyeSI6Ik5ldGhlcmxhbmRzIiwibG5nIjoiNC4zMDY1MDgzMDAwMDAwMDEiLCJvbmNsaWNrX2FjdGlvbiI6Im1hcmtlciIsInJlZGlyZWN0X3Blcm1hbGluayI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9zdXN0YWluYWJsZS1tZWRpYS1sYWIvIiwiem9vbSI6MiwiZXh0cmFfZmllbGRzIjp7InBvc3RfZXhjZXJwdCI6IkluaG9sbGFuZCdzIFN1c3RhaW5hYmxlIE1lZGlhIExhYiBpcyBsZWFkaW5nIHRoZSB3YXkgb24gaW1hZ2luaW5nIHNvY2lhbGx5LCBlbnZpcm9ubWVudGFsbHkgYW5kIHRlY2huaWNhbGx5IHN1c3RhaW5hYmxlIGluZnJhc3RydWN0dXJlLiIsInBvc3RfY29udGVudCI6Ilt2Y19yb3ddW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNFwiXVt2Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxoMT5JbmhvbGxhbmQncyBTdXN0YWluYWJsZSBNZWRpYSBMYWI6IGltYWdpbmluZyBzb2NpYWxseSwgZW52aXJvbm1lbnRhbGx5IGFuZCB0ZWNobmljYWxseSBzdXN0YWluYWJsZSBpbmZyYXN0cnVjdHVyZTwvaDE+XHJcblRoZSA8YSBocmVmPVwiaHR0cHM6Ly93d3cuc3VzdGFpbmFibGVtZWRpYWxhYi5ldS9cIj5TdXN0YWluYWJsZSBNZWRpYSBMYWI8L2E+IGF0IHRoZSA8YSBocmVmPVwiaHR0cHM6Ly93d3cuaW5ob2xsYW5kLm5sL2luaG9sbGFuZGNvbS9cIj5JbmhvbGxhbmQgVW5pdmVyc2l0eSBvZiBBcHBsaWVkIFNjaWVuY2VzPC9hPiBpbiB0aGUgSGFndWUgd2FzIGZvdW5kZWQgaW4gMjAyMSwgYW5kIGlzIGxlZCBieSBzb2NpYWwgc2NpZW50aXN0IGFuZCBQcm9mZXNzb3Igb2YgTWVkaWEsIFRlY2hub2xvZ3kgYW5kIFNvY2lldHkgQmVuIFdhZ25lci5cclxuXHJcbkhlIGhhcyB3b3JrZWQgb24gaHVtYW4tcmlnaHRzIHRlY2hub2xvZ3kgZm9yIG1vcmUgdGhhbiBhIGRlY2FkZSwgaW5jbHVkaW5nIHNlcnZpbmcgYXMgZm91bmRpbmcgRGlyZWN0b3Igb2YgdGhlIENlbnRlciBmb3IgSW50ZXJuZXQgYW5kIEh1bWFuIFJpZ2h0cyBhdCBFdXJvcGVhbiBVbml2ZXJzaXR5IFZpYWRyaW5hIGFuZCBhcyBEaXJlY3RvciBvZiB0aGUgU3VzdGFpbmFibGUgQ29tcHV0aW5nIExhYiBhdCBWaWVubmEgVW5pdmVyc2l0eSBvZiBFY29ub21pY3MuXHJcblxyXG5cIkkgYWN0dWFsbHkgc2VlIHN1c3RhaW5hYmlsaXR5IGFzIGEgd2F5IG9mIG1haW5zdHJlYW1pbmcgaWRlYXMgYXJvdW5kIGh1bWFuIHJpZ2h0cyxcIiBXYWduZXIgZXhwbGFpbnMuIFwiQmVjYXVzZSBsb3RzIG9mIHBlb3BsZSBnZXQgY2hhbGxlbmdlZCBvciBmZWVsIGFueGlldHkgd2hlbiB0aGV5J3JlIGRlYWxpbmcgd2l0aCB0aGluZ3MgcmVsYXRlZCB0byBodW1hbiByaWdodHMsIGl0J3MgYSBzaGFtZSwgYnV0IGl0J3MgYSByZWFsaXR5LiBTbyBmaW5kaW5nIHNvbWUgY29udGV4dCB0aGF0IGFsbG93IHVzIHRvIGNvbW11bmljYXRlIHRoaW5ncyB0aGF0IG1hdHRlciwgYnV0IGFyZSBub3Qgc28gZGlyZWN0bHkgY29uZnJvbnRhdGlvbmFsLCBtZWFucyB0aGV5IGNhbiBiZSBiZXR0ZXIgaW50ZWdyYXRlZCBpbiBwZW9wbGUncyBldmVyeWRheSBsaXZlcy5cIlxyXG5cclxuSW5ob2xsYW5kIGhhcyBleHBlcnRpc2UgaW4gbWVkaWEgcmVzZWFyY2gsIGJ1dCB0aGUgdW5pdmVyc2l0eSB3YXMga2VlbiB0byBidWlsZCBzdXN0YWluYWJpbGl0eSBpbnRvIGl0cyB3b3JrIGhlcmUsIGFuZCB0aHJvdWdoIHRoZSAnbGl2aW5nIGxhYicgaWRlYSB0aGV5IGhvcGVkIHRvIHRvIGVuZ2FnZSBwZW9wbGUgb24gdGhlc2UgaXNzdWVzIGluIGRpZmZlcmVudCB3YXlzLlxyXG5cclxuXHUyMDFjSSBwcmV2aW91c2x5IHdvcmtlZCBpbiBhIHN1c3RhaW5hYmxlIGNvbXB1dGluZyBsYWIsIHdoaWNoIGlzIGFsbCBhYm91dCBzdXN0YWluYWJsZSB0ZWNobm9sb2d5LCBzbyB0aGVyZSB3YXMgYW4gaW50ZXJlc3Rpbmcgb3ZlcmxhcCB0byBleHBsb3JlLFwiIGhlIHNheXMuIFwiQW5kIHdlXHUyMDE5cmUgbm93IHN0YXJ0aW5nIHRvIGNyZWF0ZSBhIGJvZHkgb2YgbGl0ZXJhdHVyZSBpbiB0aGlzIGFyZWEsIHNvIHdlIGhhdmUgY29uY2VwdHMgdGhhdCB3ZSBjYW4gdGFsayBhYm91dC5cdTIwMWRcclxuXHJcblRoZSBsYWIgaXNcdTAwYTBjdXJyZW50bHkgd29ya2luZyB3aXRoIHRoZSBNdW5pY2lwYWxpdHkgb2YgVGhlIEhhZ3VlLCA8YSBocmVmPVwiaHR0cHM6Ly9oaXZvcy5vcmcvXCI+SGl2b3M8L2E+LCBhbiBpbnRlcm5hdGlvbmFsLWRldmVsb3BtZW50IE5HTyBhbmQgPGEgaHJlZj1cImh0dHBzOi8vZ3JlZW5ob3N0Lm5ldC9cIj5HcmVlbmhvc3Q8L2E+LCB3aGljaCBpcyBhIER1dGNoIGNvbXBhbnkgdGhhdCBwcm92aWRlcyBldGhpY2FsIHdlYi1ob3N0aW5nLlxyXG5cclxuXCJUaGVzZSBwcm9qZWN0cyBhcmUgYWxsIGFib3V0IGJ1aWxkaW5nIG1vcmUgc3VzdGFpbmFibGUgdGVjaG5vbG9naWNhbCBpbmZyYXN0cnVjdHVyZXMsIHN1cHBvcnRpbmcgY3JlYXRpdmUgYnVzaW5lc3NlcyBhbmQgYXJ0aXN0cyB0byBiZSBhYmxlIHRvIGFjY2VzcyB0aGVtLCBhbmQgdGhlbiBjb21tdW5pY2F0aW5nIHRvIHRoZSBwdWJsaWMgd2h5IGl0J3MgYmV0dGVyIHRvIHVzZSB0aGVtLlxyXG5cclxuXCJCeSBzdXN0YWluYWJsZSBpbmZyYXN0cnVjdHVyZSwgd2UgbWVhbiBzb2NpZXRhbGx5LCBlbnZpcm9ubWVudGFsbHkgYW5kIHRlY2huaWNhbGx5LiBBbGwgdGhyZWUgcGFydHMgb2YgdGhhdCBzdGFjay4gU28gbm90IGJlaW5nIHBhdGNoZWQgZXZlcnkgZml2ZSBtaW51dGVzIGFuZCBjb25zdGFudGx5IGZhbGxpbmcgYXBhcnQuIE5vdCBoYXZpbmcgbmVnYXRpdmUgc29jaWV0YWwgaW1wYWN0cyBieSBiZWluZyBsYXJnZSBtdWx0aW5hdGlvbmFsIGNvbmdsb21lcmF0ZXMsIHdoaWNoIGFyZSBzbyBtb25vcG9saXN0aWMgdGhhdCB5b3UgY2FuJ3QgdHJ1c3QgdGhlbSB0byB1c2UgeW91ciBkYXRhLiBBbmQgYWxzbyBoYXZpbmcgYSByZWFzb25hYmxlIGVudmlyb25tZW50YWwgZm9vdHByaW50LlwiXHJcblxyXG5JbiBGZWJydWFyeSB0aGlzIHllYXIsIDxhIGhyZWY9XCJodHRwczovL3d3dy5zdXN0YWluYWJsZW1lZGlhbGFiLmV1LzIwMjIvMDQvMjAvd2hhdC13b3VsZC1zdXN0YWluYWJsZS1tZWRpYS1mZWVsLWxpa2UvXCI+dGhlIGxhYiBoZWFyZCBmcm9tIEtheSBNZXNlYmVyZywgZnJvbSBBUlRFPC9hPiwgdGhlIEV1cm9wZWFuIHB1YmxpYy1zZXJ2aWNlIGNoYW5uZWwsIGFuIGV2ZW50IHRoYXQgaGlnaGxpZ2h0ZWQgdG8gV2FnbmVyIHRoYXQgXCJ0aGVyZVx1MjAxOXMgYSBjb252ZXJzYXRpb24gdGhhdCBuZWVkcyB0byBiZSBoYWQgYWJvdXQgYmVoYXZpb3VyIGNoYW5nZVwiLlxyXG5cclxuXCJUaGV5IHdlcmUgYmFzaWNhbGx5IHNheWluZyB0aGF0IHRoZSBvbGQgSGVydHppYW4gbW9kZWwgZm9yIHRlbGV2aXNpb24gaXMgbXVjaCBtb3JlIHN1c3RhaW5hYmxlIHRoYW4gdGhlIHN0cmVhbWluZyB3b3JsZCwgYmVjYXVzZSBzdHJlYW1pbmcgcmVxdWlyZXMgYWxsIHRoZXNlIGRhdGEgY2VudGVycyBhbmQgYWxsIG9mIHRoZXNlIG90aGVyIHRoaW5ncy4gV2UgYWN0dWFsbHkgaGFkIGFsbCBvZiB0aGVzZSByZWFsbHkgZWZmaWNpZW50IHRlY2hub2xvZ2llcyB0aGF0IHdlIHN0b3BwZWQgdXNpbmcsIGJ1dCBvZiBjb3Vyc2UsIG5vdyB0aGV5J3JlIG5vdCB2ZXJ5IGNvbXBhdGlibGUgd2l0aCBzdHJlYW1pbmcgYmVoYXZpb3VyIG9mIHVzZXJzIHRvZGF5LlxyXG5cclxuXCJBbmQgd2UncmUgYWN0dWFsbHkgdmVyeSBnb29kIGF0IGRldmVsb3BpbmcgdGVjaG5vbG9naWVzIHRoYXQgcmVkdWNlIGVuZXJneSBjb25zdW1wdGlvbiwgYnV0IHRoZW4gd2Ugc3RhcnQgdXNpbmcgbW9yZSBvZiB0aGVtLiBMaWtlIGhhdmluZyBtb3JlIGVmZmljaWVudCBlbmdpbmVzIGFuZCB0aGVuIGRyaXZpbmcgYmlnIFNVVnMuIElmIHdlIGp1c3QgaGFkIHRoZSBzYW1lIHNpemVkIGNhcnMgd2UgZGlkIDUwIHllYXJzIGFnbyBhbmQgdGhlIGVuZ2luZXMgd2UgaGF2ZSBub3csIHdlJ2QgYmUgbXVjaCBtb3JlIGVmZmljaWVudC5cclxuXHJcblx1MjAxY0kgdGhpbmsgcGFydCBvZiB0aGUgcHJvYmxlbSB3aXRoIG1lZGlhIHRlY2hub2xvZ2llcyB0b2RheSBpcyB0aGF0IHRoZSBzdGFjayBpcyBzZXQgdXAgaW4gc3VjaCBhIHdheSB0aGF0IGVhY2ggYWRkaXRpb25hbCB2aWV3ZXIgaGFzIGEgc2lnbmlmaWNhbnQgYWRkaXRpb25hbCBjb3N0LCBpdFx1MjAxOXMgZW5lcmd5IGludGVuc2l2ZS4gSSBkb24ndCB0aGluayB0aGF0IGl0IGhhcyB0byBiZSB0aGF0IHdheS4gVGhlIGluZnJhc3RydWN0dXJlcyB0aGF0IHdlJ3ZlIGJ1aWx0IGhhdmUgbGVkIHRvIGEgc2V0IG9mIGNob2ljZXMgdGhhdCBkZSBmYWN0byBtYWtlIGl0IHRoYXQgd2F5LlxyXG5cclxuXHUyMDFjU28gd2UgaGF2ZSB0byBhY2tub3dsZWRnZSB0aGF0IGFuZCBzYXkgXHUyMDE4dGhhdCdzIGEgcHJvYmxlbSBiZWNhdXNlIHlvdSdyZSBjcmVhdGluZyB0aGVzZSB0cmFkZS1vZmZzLCBiZXR3ZWVuIHRoaW5ncyBsaWtlIGVjb25vbWljIGFuZCBlbnZpcm9ubWVudGFsIGlzc3VlcywgYnV0IHRoZSB0cmFkZS1vZmZzIGFyZSBub3QgdGVjaG5pY2FsbHkgbmVjZXNzYXJ5XHUyMDE5LiBJdCdzIG1vcmUgdGhhdCB0aGV5J3ZlIGJlY29tZSBuZWNlc3NhcnkgYnkgdmlydHVlIG9mIGEgcGF0aCBkZXBlbmRlbmN5Llx1MjAxZFxyXG48aDM+Q2hhbGxlbmdpbmcgY29uc3VtZXIgYW5kIGNvcnBvcmF0ZSBiZWhhdmlvdXI8L2gzPlxyXG5XYWduZXIgc3VnZ2VzdHMgb3VyIGN1cnJlbnQsIHVuc3VzdGFpbmFibGUgcGF0aCBpcyBiYXNlZCBvbiBtaXN1bmRlcnN0YW5kaW5ncywgYm90aCBhdCBhIGNvcnBvcmF0ZSwgYW5kIGEgY29uc3VtZXIsIGxldmVsLlxyXG5cclxuXCJUaGUgaWRlYSB0aGF0IHlvdSB3b3VsZCBoYXZlIHRvIHVzZSBhbHdheXMgdGhlIGhpZ2hlc3QsIGJlc3QsIG1vc3QtYWR2YW5jZWQsIGZhbmN5IHNldHRpbmcgdG8gc2VsbCB0aGUgcHJvZHVjdCBpcyBqdXN0IHZlcnkgaW5ncmFpbmVkIGluIHRoZSBwcm92aWRlcnMuIEEgbG90IG9mIHRoZSB0aW1lLCBpdCdzIGFib3V0IHNldHRpbmcgZGVmYXVsdHMgZm9yIHBlb3BsZSBzbyB0aGF0IHRoZXkgaGF2ZSB0aGUgY2hvaWNlLCBidXQgbWFraW5nIHRoZSBjaG9pY2UsIGJ5IGRlZmF1bHQsIG1vcmUgcmVhc29uYWJsZS5cclxuXHJcblx1MjAxY0kgZmluZCBpdCBhYnN1cmQgd2hlbiBJIG9wZW4gYW55IHN0cmVhbWluZyBhcHAgb24gbXkgcGhvbmUsIGFuZCBJXHUyMDE5dmUgZG9uZSB0aGlzIG9uIHRoZSBwaG9uZXMgb2YgY29sbGVhZ3VlcyBhcyB3ZWxsLCBhbmQgdGhlIGRlZmF1bHQgY2hvaWNlIGlzIHN0cmVhbWluZyBIRCB3aXRoIG1heGltdW0gYmFuZHdpZHRoLiBJIGhhdmUgbm9ybWFsIGV5ZXNpZ2h0LCBhbmQgSSBjYW4ndCB0ZWxsIHRoZSBkaWZmZXJlbmNlIG9uIG15IHBob25lIGJldHdlZW4gbWF4aW11bSBIRCBhbmQgc3RhbmRhcmQgZGVmaW5pdGlvbiwgYmVjYXVzZSB0aGUgc2NyZWVuIGlzIHRpbnkuIEFuZCwgd2hlbiB5b3UncmUgbG9va2luZyBhdCB2aWRlbyBzdHJlYW1pbmcsIGNoYW5naW5nIHRoaXMgd291bGQgcmVkdWNlIHRoZSBkYXRhIGludm9sdmVkIGJ5IGEgZmFjdG9yIG9mIDEwLlxyXG5cclxuXCJTaW1pbGFybHksIGEgbG90IG9mIGNhcnMgaGF2ZSBhbiBcdTIwMThlY29cdTIwMTkgc2V0dGluZywgYnV0IGl0J3Mgbm90IHNlbGVjdGVkIGJ5IGRlZmF1bHQsIHNvIG5vYm9keSBib3RoZXJzIHRvIHVzZSBpdC4gSWYgaGF2ZSB0byBjaGFuZ2UgaW50byBcdTIwMThzcG9ydHNcdTIwMTkgbW9kZSwgbW9zdCBwZW9wbGUgd291bGQgcHJvYmFibHkganVzdCBub3QgY2hhbmdlIGl0LiBTbyBpdCdzIGFib3V0IHNldHRpbmcgdGhpbmdzIHVwIHNvIGl0J3MgZWFzeSB0byBkbyB0aGUgcmlnaHQgdGhpbmcuXHJcblxyXG5cdTIwMWNDb21wYW5pZXMgYXJlIGJ1aWxkaW5nIHRoZWlyIGJ1c2luZXNzIG1vZGVscyBiYXNlZCBvbiBhc3N1bXB0aW9ucyB0aGF0IEkgdGhpbmsgYXJlIGZhbHNlIGFib3V0IGNvbnN1bWVyIGJlaGF2aW91ci4gVGhleSBhc3N1bWUgdGhhdCBpZiB5b3UgYW5ub3kgb3IgZnJ1c3RyYXRlIHlvdXIgY3VzdG9tZXJzIHRvbyBtdWNoLCB0aGVuIHRoZXkncmUgbm90IGdvaW5nIHRvIGJlIHdpbGxpbmcgdG8gdXNlIHRoZSBwcm9kdWN0LiBJIHRoaW5rIGFjdHVhbGx5IGEgbG90IG9mIHRoZSByZXNlYXJjaCBzdWdnZXN0cyB0aGF0IGNvbnN1bWVycyBhcmUgcGVyZmVjdGx5IHdpbGxpbmcgdG8gZG8gdGhpbmdzIGxpa2UgdGhpcy4gVGhleSBqdXN0IGV4cGVjdCBzb21lIGtpbmQgb2YgdHJhbnNwYXJlbnQganVzdGlmaWNhdGlvbiBvbiB0aGUgd2F5IGFuZCB0aGVuIHRoZXkncmUgaGFwcHkgdG8gYmUgcGFydCBvZiBpdC5cIlxyXG5cclxuQW5kIGhlIHNheXMgdGhlc2UgYXNzdW1wdGlvbnMgY3JlZXAgaW50byBtZWRpYSBjb21wYW5pZXMsIHRvby4gXCJNYW55IG1lZGlhIGNvbXBhbmllcyBiZWxpZXZlIHlvdVx1MjAxOXJlIHRoZXJlIHRvIG1ha2UgdGhlIGNvbnN1bWVyIGhhcHB5IG9yIHRvIGVudGVydGFpbiB0aGVtLCB0byBtYWtlIHRoZWlyIGxpdmVzIGVhc2llci4gVGhhdCdzIGhvdyB3ZSBkZXNpZ24gb3VyIHByb2R1Y3RzLiBUaGF0J3MgaG93IHdlIGVuZ2luZWVyIG91ciBzeXN0ZW1zLiBUaGF0J3MgaG93IHdlIHRoaW5rIGFib3V0IHRoZSB3b3JsZC5cclxuXHJcblx1MjAxY0J1dCBpZiB3ZSB0aGluayBhYm91dCB0aGUgd29ybGQgbGlrZSB0aGF0LCB3ZSdsbCBuZXZlciBiZSBhYmxlIHRvIGNoYW5nZSBvdXIgY2FyYm9uIGZvb3RwcmludHMuIFNvIGl0IGJlY29tZXMgYSB2ZXJ5IHJlYWwgcXVlc3Rpb24gb2YgXHUyMDE4aG93IGRvIHlvdSB0YWtlIHRoZSB1c2VyIHdpdGggeW91IG9uIGEgam91cm5leSwgc28gdGhhdCB0aGV5J3JlIHdpbGxpbmcgdG8gbWFrZSB0aGVzZSBiZWhhdmlvdXJhbCBjaGFuZ2VzLCBhZnRlciB0aGV5J3ZlIGFscmVhZHkgYm91Z2h0IHlvdXIgZGV2aWNlcywgYWZ0ZXIgdGhleSd2ZSBhbHJlYWR5IGJlY29tZSBmYW5zIG9mIHlvdXIgcHJvZ3JhbW1lP1x1MjAxOS5cclxuXHJcblx1MjAxY1lvdSBkb24ndCB3YW50IHRvIGNvbXBsZXRlbHkgZnJ1c3RyYXRlIHRoZW0uIFlvdSBkb24ndCB3YW50IHRvIG5vdCBoYXZlIGEgbWFya2V0IGFueW1vcmUuIEJ1dCB5b3UgYWxzbyBoYXZlIGEgcmVzcG9uc2liaWxpdHkgdG8gZmluZCB3YXlzIHRvIG1ha2UgdGhhdCBiZWhhdmlvdXIgYWRhcHQuXHUyMDFkXHJcblxyXG5IZSBwb2ludHMgb3V0IHRoaXMgY2hhbGxlbmdlIG1heSBiZSBlYXNpZXIgdG8gdGFja2xlIGRlcGVuZGluZyBvbiB5b3VyIGF1ZGllbmNlLiBcdTIwMWNJJ2QgYmUgcmVhbGx5IGludGVyZXN0ZWQgaW4gaG93IEZveCBOZXdzIGlzIGdvaW5nIHRvIGRlYWwgd2l0aCBpdHMgY2FyYm9uIGZvb3RwcmludCxcdTIwMWQgaGUgc3VnZ2VzdHMuIFx1MjAxY0knbSBub3Qgc2F5aW5nIEkgaGF2ZSBhbiBhbnN3ZXIgdG8gaXQsIGJ1dCBpdCdzIGp1c3QgdGhhdCwgaWYgeW91IGdvIGRvd24gdGhhdCBwYXRoLCB0aGF0IGluZXZpdGFibHkgbWVhbnMgdGhhdCB5b3UgbmVlZCB0byBlbmdhZ2Ugd2l0aCBhIGRpZmZlcmVudCBpZGVhIG9mIHlvdXIgY29uc3VtZXJzLlxyXG5cclxuXCJJdCdzIGFsbCBhIHF1ZXN0aW9uIGFib3V0IHRoZSBiZWhhdmlvdXJzIHdlJ3ZlIGNyZWF0ZWQgYW5kIHdoZXRoZXIgaXQncyBwb3NzaWJsZSwgd2l0aCB0aGVzZSBuZXcgYmVoYXZpb3VycywgdG8gYWRhcHQgdGhlIHRlY2hub2xvZ2llcyB0byBiZSBtb3JlIHN1c3RhaW5hYmxlLCBvciB3aGV0aGVyIHdlXHUyMDE5bGwgdGhlbiBqdXN0IGNyZWF0ZSBuZXcgbW9yZSBlY29sb2dpY2FsbHkgY29zdGx5IGJ1c2luZXNzIG1vZGVscyB0byBhZGFwdCBhZ2Fpbi4gVGhlcmUncyBkZWZpbml0ZWx5IGEgY3ljbGUgZ29pbmcgb24gdGhlcmUuXHUyMDFkXHJcblxyXG5XYWduZXIgYWxzbyBwb2ludHMgdG8gYW4gaXNzdWUgd2l0aCBcdTIwMWNsYWcgdGltZVx1MjAxZCBpbiB0ZXJtcyBvZiBwcm9kdWN0IGRldmVsb3BtZW50LiBcdTIwMWNUaGUgc3R1ZmYgdGhhdCB3ZSdyZSB1c2luZyByaWdodCBub3cgaXMgYmFzaWNhbGx5IGJhc2VkIG9uIHRoaW5ncyB0aGF0IHdlcmUgaW1hZ2luZWQgMTAgeWVhcnMgYWdvLiBBbmQgMTAgeWVhcnMgYWdvLCBpbiB0aGUgZWNvbm9taWMgY2lyY2xlcyB0aGF0IHdlcmUgYnVpbGRpbmcgdGhlc2UgcHJvZHVjdHMsIHN1c3RhaW5hYmlsaXR5IGp1c3Qgd2Fzbid0IHRoYXQgbXVjaCBvZiBhIHRoaW5nLiBBbmQgaWYgaXQgd2FzLCBpdCB3YXMgdmVyeSBtdWNoIGFib3V0IG51ZGdpbmcgcGVvcGxlIHRvIGRvIHRoZSByaWdodCB0aGluZywgcmF0aGVyIHRoYW4gYnVpbGRpbmcgaW5mcmFzdHJ1Y3R1cmUgdGhhdCBlbmFibGVzIHBlb3BsZSB0byBkbyB0aGUgcmlnaHQgdGhpbmcgYnkgZGVmYXVsdC5cdTIwMWRcclxuPGgzPk5pY2hlIGNvbXBhbmllcyBudWRnaW5nIHRoZSBtYXJrZXQgdG8gZG8gYmV0dGVyPC9oMz5cclxuVGhlIFN1c3RhaW5hYmxlIE1lZGlhIExhYiBoYXMgYW4gdXBjb21pbmcgcHJvamVjdCB3aXRoIHJhZGljYWwgRHV0Y2ggc21hcnRwaG9uZSBtYW51ZmFjdHVyZXIgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmZhaXJwaG9uZS5jb20vZW4vXCI+RmFpcnBob25lPC9hPiBcdTIwMTMgdGhhdCBzYXlzIGl0J3Mgd29ya2luZyAnZm9yIHBlb3BsZSBhbmQgcGxhbmV0Jy5cclxuXHJcblwiVGhleSdyZSBvbmUgb2YgdGhlIGNvbXBhbmllcyB3ZSB1c2UgYXMgYSBncmVhdCBleGFtcGxlIGZvciB0aGUgd2F5IHRoZXlcdTIwMTlyZSBkb2luZyB0aGlzLFwiIFdhZ25lciBleHBsYWlucy4gXCJJIGRvbid0IHRoaW5rIGl0J3MgYWJvdXQgdGhlbSBvdXRydW5uaW5nIHRoZSBBcHBsZXMgb2YgdGhpcyB3b3JsZC4gV2hlbiB5b3UgcmVhbGx5IGdldCBkb3duIHRvIGl0LCB0aGV5J3JlIHByZXR0eSBjbGVhciB0aGF0IHRoZWlyIHByb2R1Y3QgZG9lc24ndCBoYXZlIHRvIGJlIHRoZSBkb21pbmFudCBwcm9kdWN0IHRvIGJlIHN1Y2Nlc3NmdWwuXHJcblxyXG5cIldoYXQgdGhleSd2ZSBkb25lIGlzIGNyZWF0ZWQgYSBuaWNoZSBwcm9kdWN0LCB3aGljaCBpcyB2ZXJ5IHN1Y2Nlc3NmdWwsIGJ1dCB0aGV5J3ZlIGFsc28gcHVzaGVkIGV2ZXJ5Ym9keSBlbHNlIGluIHRoZSBpbmR1c3RyeSB0byBsb29rIGxvbmcgYW5kIGhhcmQgYXQgdGhlbXNlbHZlcyB0byBzZWUgaWYgdGhleSBjYW4gZG8gYmV0dGVyLiBBIGxvdCBvZiB0aGUgc291cmNpbmcgb2YgbWluZXJhbHMgZm9yIGlQaG9uZXMgYW5kIGluIG90aGVyIHByb2R1Y3RzIGhhcyBnb3R0ZW4gbXVjaCwgbXVjaCBiZXR0ZXIgYmVjYXVzZSBvZiB0aGUgc3RhbmRhcmRzIEZhaXJwaG9uZSBoYXMgc2V0LCB0aGV5J3ZlIHNob3duIHRoYXQgaXQncyBwb3NzaWJsZS5cdTIwMWRcclxuXHJcbkFza2VkIGFib3V0IHdoZXRoZXIgdGhlcmUncyBhIHJlYWwgYW5zd2VyIHRvIHRoZSBpc3N1ZXMgb2YgaHVtYW4tcmlnaHRzIGFidXNlcyBpbiB0aGUgZWxlY3Ryb25pY3Mgc3VwcGx5IGNoYWluLCBoZSBhZGRzIFwiSSBkb24ndCB0aGluayB0aGF0IHRoZXJlJ3MgYW55IGVhc3ksIGJpbmFyeSBhbnN3ZXIgdG8gYW55IG9mIHRoZXNlIHF1ZXN0aW9uc1wiLlxyXG5cclxuXCJXaWxsIHRoZXJlIGFsd2F5cyBiZSBjb25mbGljdHMgYWJvdXQgdGhpcz8gRGVmaW5pdGVseS4gRG9lcyB0aGlzIG1lYW4gdGhhdCBpdCdzIHdvcnRobGVzcyB0byBzdHJpdmUgZm9yIGltcHJvdmluZyB0aGUgc2l0dWF0aW9uPyBObywgSSB0aGluayBpdCBzdGlsbCBtYWtlcyBhIGxvdCBvZiBzZW5zZS4gQW5kIHRoYXQncyB3aHkgSSB0aGluayB3aGF0IEZhaXJwaG9uZSBpcyBkb2luZyBpcyByZWFsbHkgdmFsdWFibGUsIGJlY2F1c2UgaXQgc2hvd3MgdGhhdCBtdWNoIG1vcmUgaXMgcG9zc2libGUuIEFuZCB3aGF0IEZhaXJwaG9uZSBoYXMgZG9uZSBpcyBtYXRlcmlhbGx5IGltcHJvdmVkIHRoZSBsaXZlcyBvZiB0ZW5zIG9mIHRob3VzYW5kcyBvZiBwZW9wbGUuXHUwMGEwIFRoZXJlJ3Mgbm8gcXVlc3Rpb24gYWJvdXQgaXQuIEFuZCBub3QganVzdCBpbiB0aGVpciBvd24gc3VwcGx5IGNoYWluLCBidXQgaW4gc3VwcGx5IGNoYWlucyBhY3Jvc3MgdGhlIHdvcmxkLlwiXHJcblxyXG5CdXQsIGhlIHNheXMsIGxvb2tpbmcgYXQgc3VwcGx5IGNoYWlucyBhbG9uZSBpcyBpbnN1ZmZpY2llbnQgXHUyMDEzIFwieW91IG5lZWQgdG8gc2VlIHRoZSBwaG9uZSBpbiBpdHMgd2hvbGUgZWNvc3lzdGVtIGNvbnRlbnQgXHUyMDEzIHRoZSBjb250ZW50IHRoYXQncyBvbiB0aGUgcGhvbmUsIHRoZSB0ZWNobm9sb2d5IGluIHRoZSBwaG9uZSwgaG93IHRoZSBwaG9uZSBpcyB1c2VkXCIuXHJcblxyXG5cdTIwMWNUaGF0J3Mgd2hhdCB3ZSBjYWxsIHRoZXNlIFx1MjAxOHNvY2lhbC10ZWNobmljYWxcdTIwMTkgc3lzdGVtcyxcIiBoZSBleHBsYWlucy4gXCJZb3UgY2FuJ3QganVzdCBzZWUgdGhlIHRlY2hub2xvZ3kuIEl0J3MgYWJvdXQgdGhlIHBlb3BsZSBhbmQgaG93IHRoZXkgdXNlIGl0LiBBbmQgdGhhdCBpbnRlcmFjdGlvbiBjcmVhdGVzIHRoZSBpbnRlcmVzdGluZyBwaGVub21lbmEgdGhhdCBJIHRoaW5rIGlzIHdvcnRoIGxvb2tpbmcgYXQuXHJcblxyXG5cdTIwMWNJZiB5b3UncmUgaWYgeW91J3JlIGxvb2tpbmcgYXQgeW91ciBjYXJib24gZm9vdHByaW50IGFzIGEgdGVsZXZpc2lvbiBzdGF0aW9uLCB0aGUgdmFzdCBtYWpvcml0eSBvZiB5b3VyIGNhcmJvbiBmb290cHJpbnQgaXMgcGVvcGxlIHdhdGNoaW5nIHlvdXIgcHJvZHVjdC4gSXQncyBub3QgdGhlIHByb2R1Y3Rpb24gY29zdCBpdHNlbGYsIHNvIHRoYXRcdTIwMTlzIGFsbCBvZiB5b3VyIHZpZXdlcnMgYnV5aW5nIHRlbGV2aXNpb25zIGFuZCB0dXJuaW5nIHRoZW0gb24gYW5kIHdhdGNoaW5nIHlvdXIgdGVsZXZpc2lvbiBzaG93cy5cclxuXHJcblx1MjAxY1NvIGlmIHlvdSB3YW50IHRvIGNoYW5nZSBvciBpbXByb3ZlIHlvdXIgY2FyYm9uIGZvb3RwcmludCBcdTIwMTMgeW91IGluZXZpdGFibHkgaGF2ZSB0byB3b3JrIG9uIGluZmx1ZW5jaW5nIHlvdXIgdmlld2VyIGJlaGF2aW91ci4gQW5kIHRoZSBzYW1lIGdvZXMgZm9yIHRoZSBwaG9uZSBtYW51ZmFjdHVyZXJzIGFuZCBldmVyeWJvZHkgZWxzZSBcdTIwMTMgdG8gc3RhcnQgaW5mbHVlbmNpbmcgbm90IGp1c3QgdGhlIHRlY2hub2xvZ3kgYW5kIHRoZSB0ZWNobm9sb2dpY2FsIHNvbHV0aW9ucyBcdTIwMTMgYnV0IGFsc28gaHVtYW4gYmVoYXZpb3VyLiBPdGhlcndpc2UsIHRoZXJlJ3Mgbm8gd2F5IHRvIGdldCBhbnkgbWVhbmluZ2Z1bCBlZmZlY3Qgb24gY2FyYm9uIGZvb3RwcmludHMuXHUyMDFkXHJcbjxoMz5BIHN1c3RhaW5hYmxlIGZ1dHVyZT88L2gzPlxyXG5Mb29raW5nIHRvIHRoZSBmdXR1cmUgb2YgdGhlIGxhYiwgV2FnbmVyIGV4cGxhaW5zIHRoYXQgaGUgdGhpbmtzIHRoZSBuZXh0IDEwIHllYXJzIGlzIGdvaW5nIHRvIGJyaW5nIG1hbnkgbW9yZSBGYWlycGhvbmUtbGlrZSB2ZW50dXJlcy5cclxuXHJcblx1MjAxY0kgd291bGQgYXNzdW1lIHRoZXJlJ2xsIGJlIGRvemVucyBvZiB0aGVzZSBjb21wYW5pZXMsIHRoZXknbGwgYWxsIGJlIHN1cGVyIHN1Y2Nlc3NmdWwgYXJvdW5kIHRoZXNlIHRoaW5ncyB0aGF0IHRoZSBiaWcgY29tcGFuaWVzIGFyZW4ndCBhYmxlIHRvIGNvdmVyLiBBbmQgdGhhdCdsbCBob3BlZnVsbHkgY3JlYXRlIGVjb3N5c3RlbXMgdGhhdCBhcmUgdmVyeSBkaWZmZXJlbnQgZnJvbSB3aGF0IHdlIGhhdmUgbm93LiBBbmQgdGhlbiB0aGVyZSdsbCBiZSBvcHBvcnR1bml0aWVzIHRoYXQgYXJlIG5vdCBiYXNlZCBvbiByZWx5aW5nIG9uIHRoZXNlIGxhcmdlIGNvbXBhbmllcy5cclxuXHJcblx1MjAxY0Zyb20gd2hhdCBJJ3ZlIHNlZW4sIHRoZSBsYXJnZXIgdGhlIGluZHVzdHJ5LCB0aGUgbGVzcyB0aGV5IHVuZGVyc3RhbmQuIFNvIGxvdHMgb2YgdGhlIHNtYWxsIG9uZXMgc2VlIHRoZXNlIHRoaW5ncyBhcyBhIGNvbXBldGl0aXZlIGFkdmFudGFnZSwgYW5kIHJlYWxseSBhcmUgaW50ZXJlc3RlZCBhbmQgZXhjaXRlZCBpbiBkb2luZyB0aGVzZSB0aGluZ3MuIFRoZSBiaWcgb25lcyBqdXN0IGhhdmUgdG9vIG11Y2ggdG8gbG9zZSBpZiB0aGV5IGdvIGRvd24gdGhhdCBwYXRoLCBiZWNhdXNlIGluaXRpYWxseSBpdCBjaGFsbGVuZ2VzIHRvbyBtdWNoIG9mIHRoZWlyIG1vZGVscyBvZiBzY2FsZSBhbmQgdGhlIGhhcm1mdWwgd2F5cyB0aGV5IGRvIHRoZWlyIGJ1c2luZXNzLlxyXG5cclxuXHUyMDFjSSB3b3VsZG4ndCBleHBlY3QgYSBsb3Qgb2YgY2hhbmdlIGFtb25nIG11bHRpbmF0aW9uYWxzLCBidXQgaXRcdTIwMTlzIGFsc28gb24gdXMsIGlmIHdlJ3JlIGdvaW5nIHRvIGFsbG93IHRoZW0gdG8gYmUgdGhlIG9ubHkgcGxheWVycyBpbiB0aGUgZ2FtZSwgcmlnaHQgPyBJZiB0aGV5J3JlIHRoZSBvbmx5IHBlb3BsZSB3aG8gbWFrZSB0aGUgZGVjaXNpb25zLCB0aGVuIHdlIGhhdmUgYSBwcm9ibGVtIHJlZ2FyZGxlc3MsIG5vdCBqdXN0IGFib3V0IHN1c3RhaW5hYmlsaXR5LiBTbyB0aGF0IG5lZWRzIHRvIGNoYW5nZS5cclxuXHJcblx1MjAxY0kgYmVsaWV2ZSB0aGF0IGl0J3MgcG9zc2libGUgdG8gc3RyaXZlIHRvd2FyZHMgdGhpcyBraW5kIG9mIHN1c3RhaW5hYmlsaXR5IFx1MjAxMyBJIGRvbid0IHlldCBrbm93IHdoYXQgaXQnbGwgbWVhbiB0byBnZXQgdGhlcmUuXHUyMDFkXHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+Q09OVEFDVDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5CZW4gV2FnbmVyLCBQcm9mZXNzb3Igb2YgTWVkaWEsIFRlY2hub2xvZ3kgYW5kIFNvY2lldHkgYXQgSW5ob2xsYW5kIGF0IExhYiBEaXJlY3RvciBhdCB0aGUgU3VzdGFpbmFibGUgTWVkaWEgTGFiLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5Ud2l0dGVyOjwvc3Bhbj4gPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vYmVud2FnbmVfclwiPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5AQmVuV2FnbmVfcjwvc3Bhbj48L2E+Wy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS80XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddIiwicG9zdF90aXRsZSI6IkluaG9sbGFuZCYjODIxNztzIFN1c3RhaW5hYmxlIE1lZGlhIExhYjogaW1hZ2luaW5nIHNvY2lhbGx5LCBlbnZpcm9ubWVudGFsbHkgYW5kIHRlY2huaWNhbGx5IHN1c3RhaW5hYmxlIGluZnJhc3RydWN0dXJlIiwicG9zdF9saW5rIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL3N1c3RhaW5hYmxlLW1lZGlhLWxhYi8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJBIHBob3RvZ3JhcGggb2YgSG9sbGFuZCB3aXRoIGdyYXBoaWNzIG9mICYjMDM5O25ldHdvcmsgY29ubmVjdGlvbnMmIzAzOTsgbGlua2luZyBkaWZmZXJlbnQgYXJlYXNcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjE1NFwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIyLzA4L1N1c3RhaW5hYmxlLU1lZGlhLUxhYi0zMDB4MTU0LnBuZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6IkdyZWVuIG1lZGlhLCBJbm5vdmF0aW9uIENhc2UiLCJwb3N0X3RhZ3MiOiJBUlRFLCBCZW4gV2FnbmVyLCBHcmVlbmhvc3QsIEhpdm9zLCBJbmhvbGxhbmQsIEtheSBNZXNlYmVyZywgU3VzdGFpbmFibGUgaW5mcmFzdHJ1Y3R1cmUsIFN1c3RhaW5hYmxlIE1lZGlhIExhYiwgVGhlIEhhZ3VlIiwiJV9lZGl0X2xvY2slIjoiMTY4OTg1Mzg5NDo0IiwiJV9lZGl0X2xhc3QlIjoiOTMzIiwiJV9vZW1iZWRfODJjNTE0M2VjMzE3NjM1YzFmOWNhYjNmOGQ5MWEwNjclIjoie3t1bmtub3dufX0iLCIlX3lvYXN0X3dwc2VvX3ByaW1hcnlfY2F0ZWdvcnklIjoiNjkiLCIlc2xpZGVfdGVtcGxhdGUlIjoiZGVmYXVsdCIsIiVfd3BiX3ZjX2pzX3N0YXR1cyUiOiJ0cnVlIiwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6IlByaW5zZWdyYWNodCAyNywgMjUxMiBFVyBEZW4gSGFhZywgTmV0aGVybGFuZHMiLCIlX3dwZ21wX2xvY2F0aW9uX2NpdHklIjoiRGVuIEhhYWciLCIlX3dwZ21wX2xvY2F0aW9uX3N0YXRlJSI6Ilp1aWQtSG9sbGFuZCIsIiVfd3BnbXBfbG9jYXRpb25fY291bnRyeSUiOiJOZXRoZXJsYW5kcyIsIiVfd3BnbXBfbWV0YWJveF9sYXRpdHVkZSUiOiI1Mi4wNzQ5NTg2IiwiJV93cGdtcF9tZXRhYm94X2xvbmdpdHVkZSUiOiI0LjMwNjUwODMwMDAwMDAwMSIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiMlwiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6Ik47IiwiJV93cGdtcF9tZXRhYm94X3RheG9tb21pZXNfdGVybXMlIjoiTjsiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6Ik47IiwiJV95b2FzdF93cHNlb19mb2N1c2t3JSI6IlN1c3RhaW5hYmxlIG1lZGlhIGxhYiIsIiVfeW9hc3Rfd3BzZW9fdGl0bGUlIjoiU3VzdGFpbmFibGUgTWVkaWEgTGFiOiBzb2NpYWwsIGVudmlyb25tZW50YWwgYW5kIHRlY2huaWNhbCBzdXN0YWluYWJpbGl0eSIsIiVfeW9hc3Rfd3BzZW9fbGlua2RleCUiOiI3MSIsIiVfeW9hc3Rfd3BzZW9fY29udGVudF9zY29yZSUiOiIzMCIsIiVfeW9hc3Rfd3BzZW9fZXN0aW1hdGVkLXJlYWRpbmctdGltZS1taW51dGVzJSI6IjkiLCIlX3RodW1ibmFpbF9pZCUiOiIxNTczOSIsIiVfeW9hc3Rfd3BzZW9fbWV0YWRlc2MlIjoiSW5ob2xsYW5kJ3MgU3VzdGFpbmFibGUgTWVkaWEgTGFiIGlzIGxlYWRpbmcgdGhlIHdheSBvbiBpbWFnaW5pbmcgc29jaWFsbHksIGVudmlyb25tZW50YWxseSBhbmQgdGVjaG5pY2FsbHkgc3VzdGFpbmFibGUgaW5mcmFzdHJ1Y3R1cmUuIiwidGF4b25vbXk9Y2F0ZWdvcnkiOiJHcmVlbiBtZWRpYSwgSW5ub3ZhdGlvbiBDYXNlIiwidGF4b25vbXk9cG9zdF90YWciOiJBUlRFLCBCZW4gV2FnbmVyLCBHcmVlbmhvc3QsIEhpdm9zLCBJbmhvbGxhbmQsIEtheSBNZXNlYmVyZywgU3VzdGFpbmFibGUgaW5mcmFzdHJ1Y3R1cmUsIFN1c3RhaW5hYmxlIE1lZGlhIExhYiwgVGhlIEhhZ3VlIn0sImljb24iOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxOC8wMi9tYXJrZXItMS5wbmcifSwiaWQiOjE1NzM1LCJpbmZvd2luZG93X2Rpc2FibGUiOmZhbHNlfSx7InNvdXJjZSI6InBvc3QiLCJ0aXRsZSI6IkdBTUkgQnJpZWZpbmcgIzQ6IE1lZGlhIExhYnMgc2Vzc2lvbiAoMTcuMDIuMjIpIiwiaW5mb3dpbmRvd19jb250ZW50IjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZ1wiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJHQU1JIEJyaWVmaW5nICM0OiBNZWRpYSBMYWJzIHNlc3Npb24gKDE3LjAyLjIyKVwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMTEwXCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMjIvMDMvQ2FwdHVyZS1kZVx1MDMwMWNyYW4tMjAyMi0wMy0xNC1hXHUwMzAwLTExLjMxLjE2LTMwMHgxMTAucG5nXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZ1wiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tcGFkZGluZy1jb250ZW50XzIwXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tbWV0YSBmYy1pdGVtLXNlY29uZGFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlIGZjLXRleHQtY2VudGVyXCI+TWVkaWEgbGFiczwvZGl2PlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLXRleHQtY2VudGVyXCI+R0FNSSBCcmllZmluZyAjNDogTWVkaWEgTGFicyBzZXNzaW9uICgxNy4wMi4yMik8L2Rpdj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1jb250ZW50IGZjLWl0ZW0tYm9keS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+XHJcbiAgICAgICAgICAgIFxyXG4gICAgICAgIDwvZGl2PlxyXG48YSBocmVmPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL2dhbWktYnJpZWZpbmctNC1tZWRpYS1sYWJzLXNlc3Npb24tMTctMDItMjIvXCI+UmVhZCBtb3JlPC9hPlxyXG4gICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuPC9kaXY+XHJcblxyXG4iLCJhZGRyZXNzIjoiUGFyaXMsIEZyYW5jZSIsImxvY2F0aW9uIjp7ImxhdCI6IjQ4Ljg1NjYxNCIsImNpdHkiOiJQYXJpcyIsInN0YXRlIjoiXHUwMGNlbGUtZGUtRnJhbmNlIiwiY291bnRyeSI6IkZyYW5jZSIsImxuZyI6IjIuMzUyMjIxOSIsIm9uY2xpY2tfYWN0aW9uIjoicG9zdCIsInJlZGlyZWN0X3Blcm1hbGluayI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9nYW1pLWJyaWVmaW5nLTQtbWVkaWEtbGFicy1zZXNzaW9uLTE3LTAyLTIyLyIsInpvb20iOjIsImV4dHJhX2ZpZWxkcyI6eyJwb3N0X2V4Y2VycHQiOiIiLCJwb3N0X2NvbnRlbnQiOiJbdmNfcm93XVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMi8zXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48aDE+R0FNSSBCcmllZmluZyAjNDogTWVkaWEgTGFicyBzZXNzaW9uICgxNy4wMi4yMik8L2gxPlxyXG48aDQ+PC9oND5cclxuPGg0Pk1lZGlhIGxhYnMsIGlubm92YXRpb24gbmV0d29ya3MsIGFjY2VsZXJhdG9ycyBhbmQgc3RhcnQtdXBzIGZyb20gYWNyb3NzIEV1cm9wZSwgdGhlIGZvdXJ0aCBlZGl0aW9uIG9mIEdBTUlcdTIwMTlzIHJlZ3VsYXIgb25saW5lIGJyaWVmaW5ncyBjb3ZlcmVkIGEgZGl2ZXJzZSByYW5nZSBvZiBpbm5vdmF0aW9ucyBhbmQgd2F5cyB0byBpbm5vdmF0ZS48L2g0PlxyXG4mbmJzcDtcclxuXHJcblRoZXNlIGluY2x1ZGVkIG5ldyBhcHByb2FjaGVzIHRvIGJyb2FkY2FzdCB0ZWNobm9sb2d5LCBBSS1wb3dlcmVkIHBvZGNhc3QgZXhwZXJpZW5jZXMsIG9wZW4gaW5ub3ZhdGlvbiBuZXR3b3JrcyB0aGF0IHN1cHBvcnRlZCBtZWRpYSBhbmQgZGF0YS1qb3VybmFsaXNtIHBvd2VyZWQgYnkgdGhlIGludGVybmV0IG9mIHRoaW5ncy5cclxuPHVsPlxyXG4gXHQ8bGk+Tm9yd2F5XHUyMDE5cyBOUktiZXRhIGRlbW9uc3RyYXRlZCBob3cgaXQgZGVsaXZlcnMgdGVjaG5vbG9neSBpbm5vdmF0aW9uIGFuZCBtYXJrZXQgaW5zaWdodHMgdG8gdGhlIGNvdW50cnlcdTIwMTlzIHB1YmxpYyBicm9hZGNhc3Rlci48L2xpPlxyXG4gXHQ8bGk+RGVyIFRhZ2Vzc3BpZWdlbFx1MjAxOXMgSW5ub3ZhdGlvbiBMYWIgZGVzY3JpYmVkIGhvdyBpdCB1c2VzIHRoZSBwb3dlciBvZiBhdWRpZW5jZXMgYW5kIGludGVyYWN0aXZlIHZpc3VhbGlzYXRpb24gdG8gY29uZHVjdCBhbmQgY29udmV5IGRhdGEgam91cm5hbGlzbS48L2xpPlxyXG4gXHQ8bGk+RnJhbmNlXHUyMDE5cyBMYSBWb2l4IGR1IE5vcmQgKExWRE4pXHUyMDE5cyBpbmN1YmF0b3IgXHUyMDEzIExhIEZhYnJpcSBcdTIwMTMgb3V0bGluZWQgc29tZSBvZiB0aGUgc3VjY2VzcyBwcm9kdWN0cyBpdCBoYWQgZGV2ZWxvcGVkLjwvbGk+XHJcbiBcdDxsaT5UaGUgc2Vzc2lvbiBhbHNvIGludHJvZHVjZWQgdGhlIDFLdWJhYm9yIG9wZW4gaW5ub3ZhdGlvbiBuZXR3b3JrIGFuZCBpdHMgU3lsbGFidXMgbWVkaWEgYWNjZWxlcmF0b3IgYWxzbyBsaW5rZWQgdG8gTFZETjwvbGk+XHJcbiBcdDxsaT5wb2RjYXN0IHN0YXJ0LXVwIEJ3bGIgc2hvd2VkIGl0cyBBQ0NPUkRJT04gcHJvZHVjdCwgd2hpY2ggYWxsb3dzIHVzZXJzIHRvIGNoYW5nZSB0aGUgZHVyYXRpb24gb2YgcG9kY2FzdHMgYnV0IHdpdGhvdXQgbG9zaW5nIHRoZSBlc3NlbmNlIGFuZCBpbnRlZ3JpdHkgb2YgdGhlIGNvbnRlbnQuPC9saT5cclxuPC91bD5cclxuJm5ic3A7XHJcbjxoMz48c3Ryb25nPk5SS2JldGE6IFImYW1wO0QsIFRlY2hub2xvZ3kgSm91cm5hbGlzbSwgSW5zaWdodHM8L3N0cm9uZz48L2gzPlxyXG5BbmRlcnMgSG9mc2V0aCwgc3RyYXRlZ2ljIGFkdmlzb3IgYW5kIGpvdXJuYWxpc3QgYXQgTlJLYmV0YSBsYWIgd2l0aGluIHRoZSBOb3J3ZWdpYW4gQnJvYWRjYXN0aW5nIENvcnBvcmF0aW9uLCBraWNrZWQgb2ZmIHRoZSBzZXNzaW9uIGJ5IGV4cGxhaW5pbmcgTlJLYmV0YVx1MjAxOXMgY29yZSBhY3Rpdml0aWVzLiBBIHRlYW0gb2Ygc2V2ZW4gY29uZHVjdCByZXNlYXJjaCBhbmQgZGV2ZWxvcG1lbnQgYXJvdW5kIG5ldyB0ZWNoLCBwcm9kdWN0cyBhbmQgcHJvY2Vzc2VzIFx1MjAxMyBjcmVhdGluZyBuZXcgYXBwcm9hY2hlcyB0byBicm9hZGNhc3QgbWVkaWEuIEhvZnNldGggZGlzY3Vzc2VkIGEgcmFuZ2Ugb2YgaW5pdGlhdGl2ZXMgdGhhdCBmb3JtZWQgcGFydCBvZiB0aGVpciBSJmFtcDtEIHdvcmsuIFRoZXNlIGluY2x1ZGVkIGF1ZGlvIHNlbnNpdGl2ZSBjYW1lcmFzIGRldmVsb3BlZCBpbiBob3VzZSB1c2luZyBBcmR1aW5vIGJvYXJkIGFuZCBHby1Qcm8gY2FtZXJhcyB0aGF0IGFyZSBhYmxlIHRvIGRldGVjdCBhdWRpbyBmcm9tIHNwZWNpZmljIHNwZWFrZXJzLCBhbmQgZm9ybSB0aGVyZSBhdXRvbWF0ZWQgdmlkZW8gYWx3YXlzIHNob3dpbmcgdGhlIHNwZWFrZXIuIEhvZnNldGggc2FpZCB0aGlzIHRlY2ggaGFzIGJlZW4gdXNlZCBvbiB0aGUgbWFpbiBicm9hZGNhc3QgY2hhbm5lbCBhbmQgYWNyb3NzIHRoZSB3ZWIuXHJcblxyXG5UaGUgc2Vjb25kIGFjdGl2aXR5IHRoZSBsYWIgcnVucyBpcyB0ZWNobm9sb2d5IGpvdXJuYWxpc207IGNyZWF0aW5nIGVkaXRvcmlhbCBtYXRlcmlhbCBmb3IgcHVibGljIG91dHB1dC4gSG9mc2V0aCBkZXNjcmliZWQgYSBwcm9qZWN0IHdoZXJlIHRoZSB0ZWFtIHB1cmNoYXNlZCBhIGJpZyBkYXRhIHNldCB0byB1bmRlcnN0YW5kIGhvdyBpbmRpdmlkdWFsc1x1MjAxOSBkYXRhIGNvdWxkIGJlIHVzZWQgYnkgdGhpcmQgcGFydGllcy5cclxuXHJcbiZuYnNwO1xyXG5cclxuPGltZyBjbGFzcz1cIiB3cC1pbWFnZS0xNTcxMiBhbGlnbmNlbnRlclwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIyLzAzL0FuZGVycy1Ib2ZzZXRoLTMwMHgxNjkucG5nXCIgYWx0PVwiXCIgd2lkdGg9XCI1NTZcIiBoZWlnaHQ9XCIzMTNcIiAvPlxyXG5cclxuJm5ic3A7XHJcbjxibG9ja3F1b3RlPlx1MjAxYzxlbT5XZSBmb3VuZCB2dWxuZXJhYmxlIHRhcmdldHMgbGlrZSBwb2xpdGljaWFucyB3aXRoIG1pbGl0YXJ5IHBlb3BsZSB3aG8gY291bGQgaGF2ZSBiZWVuIHRhcmdldGVkIGFuZCBibGFja21haWxlZCwgYW5kIHdlIGNvdWxkIGZpbmQgcGVvcGxlIGxpa2UgbWUgYW5kIHlvdSdkIHNlZSB0aGVtIGdvIHRvIHdvcmssIGdvIHRvIGhvc3BpdGFsIGFuZCBzZWUgdGhlbSBtZWV0aW5nIHBlb3BsZS5cdTIwMWQ8L2VtPlxyXG5cclxuJm5ic3A7PC9ibG9ja3F1b3RlPlxyXG5XaGVuIHNwZWFraW5nIHRvIGFuIGluZGl2aWR1YWwgd2hvXHUyMDE5cyBkYXRhIGhhZCBiZWVuIGNhcHR1cmVkIGFuZCBhbmFseXNlZCwgSG9mc2V0aCBzYWlkIFx1MjAxY2hlIHdhcyByZWFsbHkgc3VycHJpc2VkIGFuZCBxdWl0ZSBmcmVha2VkIG91dCB3aGVuIHdlIGZvdW5kIGhpbSBhbmQgdG9sZCBoaW0gdGhhdCB3ZSBrbm93IGV4YWN0bHkgd2hlcmUgeW91IHdlcmUgdHdvIHllYXJzIGFnby5cdTIwMWRcclxuXHJcblNwZWFraW5nIGJyb2FkbHkgYWJvdXQgdGhlc2UgYWN0aXZpdGllcywgSG9mc2V0aCBleHBsYWluZWQgdGhleSBhcmUgXHUyMDFjcmVhbGx5IGFib3V0IHNlZWluZyB3aGVyZSB0aGUgdGVjaG5pY2FsIHBvc3NpYmlsaXRpZXMgYXJlIGFsaWduaW5nIHdpdGggeW91ciBnb2FscyBhbmQgY2hhcnRpbmcgd2hhdCB0aGluZ3MgeW91IGNhbiBkbyB3aXRoIHRoZW0gdG8gaGVscCB5b3UgcmVhY2ggeW91ciBnb2FscyBiZXR0ZXIuXHUyMDFkXHJcblxyXG5UaGUgbGFiIGFsc28gY3JlYXRlcyBpbnNpZ2h0cyB0byBiZW5lZml0IHRoZSBicm9hZGNhc3RlciBtb3JlIHN0cmF0ZWdpY2FsbHkuIERpc2N1c3NpbmcgdGhlIGJ1enogYXJvdW5kIGFwcHMgc3VjaCBhcyBDbHViaG91c2UsIEhvZnNldGggc2FpZCB0aGUgbGFiIG5hdmlnYXRlcyBmYWRzIFx1MjAxMyBlbmFibGluZyB0aGVpciBvcmdhbmlzYXRpb24gdG8gcHJvdGVjdCB0aGVpciByZXNvdXJjZXMgYW5kIGNvbmNlbnRyYXRlIG9uIGZ1dHVyZSB0cmVuZHMgdGhhdCBjYW4gcHJvdmlkZSByZWFsIGJlbmVmaXQuXHJcbjxibG9ja3F1b3RlPiZuYnNwO1xyXG5cclxuPGVtPlx1MjAxY1tPdXJdIHB1cnBvc2UgaXMgcmVhbGx5IGhlbHBpbmcgTlJLIHRvIGNhcnJ5IHRoYXQgcHVibGljIHNlcnZpY2UgW3JvbGVdIGludG8gdGhlIDIxc3QgY2VudHVyeSBiZWNhdXNlIHdlIG5lZWQgdG8gdW5kZXJzdGFuZCB0aGluZ3MgYW5kIGRvIHRoZSByaWdodCBzdHVmZiBhbmQgbm90IGRvIHRvbyBtdWNoIG9mIHRoZSB3cm9uZyBzdHVmZiBpZiB3ZSB3YW50IHRvIGJlIGFyb3VuZCBpbiA1MCB5ZWFycy5cdTIwMWQ8L2VtPjwvYmxvY2txdW90ZT5cclxuJm5ic3A7XHJcblxyXG5SZWFkIGEgZnVsbCBhcnRpY2xlIGFib3V0IE5SS2JldGEgPGEgaHJlZj1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9wdWJsaWMtc2VydmljZS1tZWRpYS1pbm5vdmF0aW9uLTIxc3QtY2VudHVyeS9cIj5oZXJlPC9hPlxyXG5cclxuJm5ic3A7XHJcbjxoMz48c3Ryb25nPkRlciBUYWdlc3NwaWVnZWwgSW5ub3ZhdGlvbiBMYWI6IG5ldyBmb3JtcyBvZiBzdG9yeXRlbGxpbmc7IGVtcG93ZXJpbmcgam91cm5hbGlzbTwvc3Ryb25nPjwvaDM+XHJcbkEgdGVhbSBvZiBqb3VybmFsaXN0cywgZGVzaWduZXJzIGFuZCBjb2RlcnMsIERlciBUYWdlc3NwaWVnZWxcdTIwMTlzIElubm92YXRpb24gbGFiIGlzIGludm9sdmVkIGluIGEgcmFuZ2Ugb2YgZGF0YSBqb3VybmFsaXNtIGFuZCB0ZWNoIGRldmVsb3BtZW50IHByb2plY3RzLiBBdCB0aGUgaGVhcnQgb2YgdGhlIGxhYiBpcyBjb2xsYWJvcmF0aW9uLCBib3RoIHdpdGhpbiB0aGVpciBvcmdhbmlzYXRpb24gYW5kIGJleW9uZCBpdC5cclxuXHJcbkhlbmRyaWsgTGVobWFubiwgaGVhZCBvZiB0aGUgbGFiLCBleHBsYWluZWQgdGhhdCBvbmUgb2YgdGhlIGtleSBtb3RpdmF0aW5nIGZhY3RvcnMgZm9yIHRoZSBsYWIgd2FzIHRvIGNyZWF0ZSBcdTIwMThlbXBvd2VyaW5nIGpvdXJuYWxpc21cdTIwMTkuXHJcblxyXG5UaGlzIGluY2x1ZGVzIGVxdWlwcGluZyBjb2xsZWFndWVzIGluIERlciBUYWdlc3NwaWVnZWwgd2l0aCB0b29scyB0byBjcmVhdGUgam91cm5hbGlzbSBpbiBhIGRhdGEtZHJpdmVuIGFnZSwgZW1wb3dlcmluZyBjaXRpemVucyBpbiBhIGNvbXBsZXggZGlnaXRhbCBlY29zeXN0ZW0sIGludm9sdmluZyB1c2VycyBpbiByZXNlYXJjaCwgY29sbGFib3JhdGluZyB3aXRoIHNjaWVudGlzdHMgYW5kIHN0YXJ0LXVwcywgdHJhbnNsYXRpbmcgZ2xvYmFsIHByb2JsZW1zIGludG8gbG9jYWwgYW5kIHBlcnNvbmFsIHN0b3JpZXMgYW5kIGNyZWF0aW5nIHN0b3JpZXMgdGhhdCBjb25uZWN0IHdpdGggcGVvcGxlIGVtb3Rpb25hbGx5IGFuZCBwb2xpdGljYWxseS5cclxuXHJcbkxlaG1hbm4gcHJvdmlkZWQgYSByYW5nZSBvZiBwcm9qZWN0IGV4YW1wbGVzIHRvIG91dGxpbmUgdGhlaXIgd29yay4gUmFkbWVzc2VyIHVzZWQgdGhlIFx1MjAxOGpvdXJuYWxpc20gb2YgdGhpbmdzXHUyMDE5IFx1MjAxMyBhIHRha2Ugb24gdGhlIGludGVybmV0IG9mIHRoaW5ncywgdG8gZXhwbG9yZSBzYWZldHkgZm9yIGN5Y2xpc3RzLiBUaGUgdGVhbSBjcmVhdGVkIDEwMCBzZW5zb3JzIGFuZCBkaXN0cmlidXRlZCB0aGVtIGFtb25nIGNpdGl6ZW5zIGZvciB1c2Ugb24gdGhlaXIgYmlrZXMuIFRoZSBzZW5zb3JzIGNvdWxkIGRldGVjdCBob3cgY2xvc2UgY2FycyB3ZXJlIHRvIHRoZSBiaWtlcy4gVGhlIGluaXRpYWwgcGhhc2Ugb2YgdGhlIHByb2plY3QgcmVjb3JkZWQgMTYsMDAwIGV2ZW50cyBhbmQgZm91bmQgdGhhdCA1NiUgYnJva2Ugc2FmZSBwYXNzaW5nIHJ1bGVzLiBUaGUgc2Vuc29ycyB3ZXJlIG9wZW4gc291cmNlZCBhbmQgYXJlIG5vdyB1c2VkIGluIG90aGVyIGNpdGllcyB3aXRoaW4gR2VybWFueSBhbmQgYmV5b25kLlxyXG5cclxuJm5ic3A7XHJcblxyXG48aW1nIGNsYXNzPVwiIHdwLWltYWdlLTE1NzEzIGFsaWduY2VudGVyXCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMjIvMDMvSGVuZHJpay0yLTMwMHgxNjkucG5nXCIgYWx0PVwiXCIgd2lkdGg9XCI1NTJcIiBoZWlnaHQ9XCIzMTFcIiAvPlxyXG48YmxvY2txdW90ZT4mbmJzcDtcclxuXHJcbjxlbT5cdTIwMWNUaGUgcmVzdWx0cyB3ZXJlIHZlcnkgdW5pcXVlIGFuZCB3ZSBwcm9kdWNlZCB0aGlzIG1hcCBvZiBpdCAtIHlvdSBjb3VsZCBsb29rIGZvciB5b3VyIGFkZHJlc3MgaW4gYW5kIHZpc3VhbGl6ZSBhcmVhcyBpbiB0aGUgY2l0eSB3aGVyZSBpdCB3YXMgZXNwZWNpYWxseSBkYW5nZXJvdXMuIEl0IGNoYW5nZWQgYSBsb3Qgb2YgdGhlIGRpc2NvdXJzZSBpbiBHZXJtYW55LiBJdCBsZWQgdG8gYSBjaGFuZ2UgaW4gdGhlIGxhdyBvbiB0aGUgbmF0aW9uYWwgbGV2ZWwsIG5vdCBvbmx5IHRoYXQgcHJvamVjdCwgYnV0IHRoZSB3aWRlciBkaXNjdXNzaW9uIGFyb3VuZCBpdC5cdTIwMWQ8L2VtPjwvYmxvY2txdW90ZT5cclxuJm5ic3A7XHJcblxyXG48c3Ryb25nPlNwZWN0cnVtIG9mIHByb2plY3RzPC9zdHJvbmc+XHJcblxyXG5UaGUgbGFiIGxlYWRlciBhbHNvIHRhbGtlZCBhYm91dCB0aGUgYnJlYWR0aCBvZiBwcm9qZWN0IHRoZXlcdTIwMTl2ZSBiZWVuIGludm9sdmVkIGluLiBUaGVzZSByYW5nZSBhY3Jvc3MgV2VtIEdlaFx1MDE0ZHJ0IEJlcmxpbj8gYW4gaW50ZXJuYXRpb25hbCBpbnZlc3RpZ2F0aW9uIG9mIHByb3BlcnR5IGludmVzdG1lbnQgYW5kIG93bmVyc2hpcCBcdTIwMTMgc3RhcnRpbmcgaW4gQmVybGluLCBhbmQgbGF0ZXIgZXhwYW5kaW5nIHRvIG11bHRpcGxlIGNpdGllcy4gSW50ZXJhY3RpdmUgdG9vbHMgdGhhdCBhbGxvdyByZWFkZXJzIHRvIHVuZGVyc3RhbmQgZW52aXJvbm1lbnRhbCBpbXBhY3QgXHUyMDEzIHN1Y2ggYXMgYSBjYWxjdWxhdG9yIHRoYXQgbGV0cyB1c2VycyB0byB1bmRlcnN0YW5kIGhvdyBlY28tZnJpZW5kbHkgKG9yIG5vdCkgdGhlaXIgbWVhbHMgYXJlLlxyXG5cclxuPHN0cm9uZz5Db3ZpZDwvc3Ryb25nPlxyXG5cclxuVGhlIHRlYW0gaGF2ZSBiZWVuIGludm9sdmVkIGluIENvdmlkIGNvdmVyYWdlIGF0IERlciBUYWdlc3NwaWVnZWwgaW4gYSBudW1iZXIgb2Ygd2F5cy4gT25lIGV4YW1wbGUgTGVobWFuIHByb3ZpZGVkIHdhcyBhIENvdmlkIHRyYWNraW5nIG1hcCBpbml0aWFsbHkgY3JlYXRlZCBhdCB0aGUgYmVnaW5uaW5nIG9mIHRoZSBwYW5kZW1pYy4gTGVobWFubiBleHBsYWluZWQgdGhhdCBpdCdzIGJlZW4gdGhlIG1vc3Qgc3VjY2Vzc2Z1bCBhcnRpY2xlIERlciBUYWdlc3NwaWVnZWwgaGFzIGV2ZXIgaGFkLlxyXG48YmxvY2txdW90ZT48ZW0+XHUyMDFjSXQgaGFzIGEgZmV3IGRvemVuIG1pbGxpb24gdmlld3MuIEV2ZXJ5IGRheSwgaXQncyBhbW9uZyB0aGUgdG9wIHZpZXdlZCBhcnRpY2xlcywgYW5kIHRoZSBtYWluIGZ1bmN0aW9uIG9mIHRoaXMgaXMgdGhhdCBwZW9wbGUgYXJlIGFibGUgdG8gbG9vayBmb3IgdGhlaXIgYXJlYSBhbmQgc2VlIHRoZSByZXN1bHRzIGFuZCBsb29rIGZvciBjZXJ0YWluIGNvdW50cmllcyBhbmQgYWxzbyBzZWUgdGhlIHJlc3VsdHMuIEFsc28sIGl0IGhhcyBjb21wYXJpc29uIGZlYXR1cmVzIHdoZXJlIHdlIGRldmVsb3AgZGlmZmVyZW50IGtpbmQgb2YgZGF0YSB2aXN1YWxpc2F0aW9ucyBhbmQgeW91IGNhbiBoaWdobHkgY3VzdG9taXplIGl0LiBcdTIwMjYgV2UgdHJhY2tlZCBbdXNlXSBhbmQgaXQncyBhYm91dCAxMCBjbGljcyBwZXIgdmlzaXQsIHNvIHBlb3BsZSB1c2UgMTAgZGlmZmVyZW50IHRvb2xzIGFuZCAxMCBraW5kIG9mIGlucHV0cyB0byB2aXNpdCwgd2hpY2ggbm9ybWFsbHkgd291bGQgYmUgdW5saWtlbHkuIFRoZSBlbmdhZ2VtZW50IG9uIHRoaXMgd2Vic2l0ZSBpcyByZWFsbHkgaGlnaFx1MjAxZDwvZW0+PC9ibG9ja3F1b3RlPlxyXG4mbmJzcDtcclxuXHJcblJlYWQgbW9yZSBhYm91dCBEZXIgVGFnZXNzcGllZ2VsIGlubm92YXRpb24gbGFiIDxhIGhyZWY9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvZGVyLXRhZ2Vzc3BpZWdlbC1pbnRlcmRpc2NpcGxpbmFyeS1hbmQtYXVkaWVuY2UtZW5nYWdlZC1pbm5vdmF0aW9uL1wiPmhlcmU8L2E+XHJcblxyXG4mbmJzcDtcclxuPGgzPjxzdHJvbmc+TmV3IGluY3ViYXRvcjogbmV3IHNvbHV0aW9ucyBhdCBMYSBWb2l4IGR1IE5vcmQ8L3N0cm9uZz48L2gzPlxyXG5OZXh0IHVwIHdhcyBMdWNpZSBEZWxvcm1lLCB0aGUgaGVhZCBvZiB0aGUgTGEgRmFicmlxIGluY3ViYXRvciBhdCBsYSBWb2l4IGR1IE5vcmQgaW4gTGlsbGUuIExhIFZvaXggZHUgTm9yZCBpcyBhbiA4MC15ZWFyLW9sZCBuZXdzcGFwZXIgYW5kIHdlYnNpdGUsIHdoaWNoIHJlYWNoZXMgb25lIG1pbGxpb24gcmVhZGVycyBhIGRheS4gRGVsb3JtZSBkZXNjcmliZWQgaGVyIGFuZCB0aGUgb3JnYW5pc2F0aW9uXHUyMDE5cyBpbm5vdmF0aW9uIGpvdXJuZXksIHdoaWNoIGJlZ2FuIHNpeCB5ZWFycyBhZ28gd2l0aCBhIGRlc2lnbiB0aGlua2luZyBwcm9jZXNzLiBUaGlzIHNhdyAyMCBlbXBsb3llZXMgdGFraW5nIG9uZSBkYXkgYSB3ZWVrIGZvciBmaXZlIHdlZWtzIHRvIGNyZWF0ZSBuZXcgcHJvZHVjdHMgYW5kIHNlcnZpY2VzLCBhbmQgdGhlIGNyZWF0aW9uIG9mIGFuIGluY3ViYXRvci5cclxuXHJcbkRlbG9ybWUgZXhwbGFpbmVkIHRoZSBpbmN1YmF0b3IgaXMgY2VudHJlZCBvbiBhIHNpbXBsZSBjb25jZXB0IC0gXHUyMDFjZXZlcnlvbmUgaW4gdGhlIGNvbXBhbnkgY2FuIGhhdmUgYSB2ZXJ5IGdvb2QgaWRlYS4gQW5kIGl0IHdvdWxkIGJlIHNvIGdyZWF0IHRvIHB1c2ggaXQgYW5kIHRvIGhlbHAgW2l0IHRvIGJlXSBkZXZlbG9wZWQuXHUyMDFkXHUwMGEwIFRoZSBpbmN1YmF0b3Igc3VwcG9ydHMgYSByYW5nZSBvZiBhY3Rpdml0aWVzIFx1MjAxY0l0J3Mgbm90IG9ubHkgbmV3IHByb2R1Y3RzLCBuZXcgbWVkaXVtcywgaXQncyBhbHNvIG5ldyBwcm9jZXNzZXMsIG5ldyB3YXlzIHRvIHNhdmUgdGltZSBvciBtb25leS4gSXQncyBqdXN0IHRoZSBvcHBvcnR1bml0eSwgdGhlIHRpbWUgYW5kIHRoZSBtb25leSB0byBhY2hpZXZlIHRob3NlIGlkZWFzLFx1MjAxZCBzaGUgZXhwbGFpbmVkLlxyXG5cclxuJm5ic3A7XHJcblxyXG48aW1nIGNsYXNzPVwiIHdwLWltYWdlLTE1NzE0IGFsaWduY2VudGVyXCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMjIvMDMvTHVjaWUtRGVsb3JtZS0zMDB4MTY5LnBuZ1wiIGFsdD1cIlwiIHdpZHRoPVwiNTUwXCIgaGVpZ2h0PVwiMzEwXCIgLz5cclxuXHJcbiZuYnNwO1xyXG5cclxuQSByYW5nZSBvZiBwcm9kdWN0cyBoYXZlIGJlZW4gZGV2ZWxvcGVkIHRocm91Z2ggdGhlIGluY3ViYXRvciBzaW5jZSBpdCBzdGFydGVkLlxyXG48dWw+XHJcbiBcdDxsaT48c3Ryb25nPlZvemVyPC9zdHJvbmc+OiBhbiBcdTIwMTh1cmJhbiBwdXJlIHBsYXllclx1MjAxOSB0aGF0IGNyZWF0ZXMgY29udGVudCBmb3IgbWlsbGVubmlhbHMgd2l0aG91dCBhbnkgcHJpbnQgcHJvZHVjdC4gSW5jdWJhdGVkIGZvciBzaXggbW9udGhzLCB0aGUgcHJvZHVjdCBub3cgaGFzIDI1MCwwMDAgcmVhZGVycyBhbmQgaGFzIGEgdmlhYmxlIGJ1c2luZXNzIG1vZGVsLCBzdGFmZmVkIHdpdGggZm91ciB0ZWFtIG1lbWJlcnMuPC9saT5cclxuIFx0PGxpPjxzdHJvbmc+UGlnZW9uIE1hc3RlcjogPC9zdHJvbmc+Tm9ydGggb2YgRnJhbmNlIHNlZXMgYSBsYXJnZSBjb21tdW5pdHkgb2YgcGlnZW9uIGZhbmNpZXJzLiBUaGlzIGlzIGFuIGF1Y3Rpb24gc2FsZXMgcGxhdGZvcm0gYW5kIG1lZGlhIHNpdGUuIENvbnRlbnQgaXMgY3JlYXRlZCBieSBqb3VybmFsaXN0cyBmcm9tIGFjcm9zcyB0aGUgbmV3cyBvcmdhbmlzYXRpb248L2xpPlxyXG4gXHQ8bGk+PHN0cm9uZz5UYSBWb2l4OiA8L3N0cm9uZz5haW1lZCBhdCB0ZWVuYWdlZCByZWFkZXJzIGFuZCBwcm92aWRlcyBuZXdzIGNvbnRlbnQgb24gSW5zdGFncmFtIGFuZCBTbmFwY2hhdCBhbmQgbWVkaWEgZWR1Y2F0aW9uIHdpdGhpbiBzY2hvb2xzIFx1MjAxMyBkZWxpdmVyaW5nIGluZm9ybWF0aW9uIGFyb3VuZCBmYWtlIG5ld3MgYW5kIGhvdyB0byBzb3VyY2UgdmFsaWQgaW5mb3JtYXRpb24gd2l0aGluIG91ciBkaWdpdGFsIGVjb3N5c3RlbS48L2xpPlxyXG48L3VsPlxyXG4mbmJzcDtcclxuXHJcbkRlbG9ybWUgYWxzbyB0YWxrZWQgYWJvdXQgTGEgRmFicmlxIDIuMCwgd2hpY2ggbm93IGhhcyBhIHRlYW0gb2YgZWlnaHQgdGFrZW4gZnJvbSBhY3Jvc3MgdGhlIG9yZ2FuaXNhdGlvbiwgYW5kIHN1cHBvcnRzIG5ldyBpZGVhcyBhbmQgcHJvZHVjdHMgYW5kIHByb3ZpZGVzIGRlc2lnbiB0aGlua2luZyB0cmFpbmluZy5cclxuPGJsb2NrcXVvdGU+Jm5ic3A7XHJcblxyXG48ZW0+XHUyMDFjV2UgbWFuYWdlZCB0byBvcmdhbml6ZSBhIHZlcnkgY29vbCBkZXNpZ24gdGhpbmtpbmcgdHJhaW5pbmcuIFRoYXQgd2FzIHZlcnkgZ29vZCBmb3IgdXMgYmVjYXVzZSB5b3UgY2FuIGJlIGEgdmVyeSBnb29kIGpvdXJuYWxpc3QsIHlvdSBjYW4gYmUgYSB2ZXJ5IGdvb2Qgd2ViIGFuYWx5c3QsIGJ1dCB5b3UgbmVlZCB0cmFpbmluZyBpbiBkZXNpZ24gdGhpbmtpbmcgaWYgeW91IHdhbnQgdG8gd29yayBpbiBhbiBpbmN1YmF0b3IuIFNvIHRoaXMgaXMgd2hhdCB3ZSBkaWQgXHUyMDI2IGFsbCB0aGUgZWlnaHQgZ29vZCBjb2FjaGVzIGFyZSBub3cgd2VsbCB0cmFpbmVkLiBUaGlzIGlzIHRoZSBiZXN0IHdheSBmb3IgdXMgdG8gaGVscCBwZW9wbGUgaW5jdWJhdGUgd2l0aGluIExhIEZhYnJpcS5cdTIwMWQ8L2VtPjwvYmxvY2txdW90ZT5cclxuJm5ic3A7XHJcbjxoMz48c3Ryb25nPk5hdGlvbmFsIGFuZCBpbnRlcm5hdGlvbmFsIG9wZW4gaW5ub3ZhdGlvbiBuZXR3b3Jrczwvc3Ryb25nPjwvaDM+XHJcblNwZWFraW5nIG5leHQgd2FzIFBhb2xhIFZpbGxhbGJhLCBoZWFkIG9mIEFjY1x1MDBlOWxcdTAwZTlyYXRldXIgU3lsbGFidXMgTVx1MDBlOWRpYSwgMUt1YmF0b3IgTGEgVm9peCBkdSBOb3JkLiBWaWxsYWxiYSBleHBsYWluZWQgdGhlIGxpbmsgYmV0d2VlbiBoZXIgb3JnYW5pc2F0aW9uIGFuZCBMYSBGYWJyaXEuXHJcblxyXG4xS3ViYXRvciBpcyBhbiBvcGVuIGlubm92YXRpb24gbmV0d29yaywgdGhlIGZpcnN0IGluIEZyYW5jZSwgYW5kIGhhcyBhIHJhbmdlIG9mIGluY3ViYXRvcnMgYWNyb3NzIHRoZSBjb3VudHJ5IFx1MjAxMyBpbmNsdWRpbmcgd2l0aCBsYSBWb2l4IER1IE5vcmQgXHUyMDEzIGFuZCBiZXlvbmQuIFdvcmtpbmcgaW4gY291bnRyaWVzIHN1Y2ggYXMgQ2hpbmEsIEJ1cmtpbmEgRmFzbyBhbmQgU2VuZWdhbC5cclxuXHJcbiZuYnNwO1xyXG48YmxvY2txdW90ZT48ZW0+XHUyMDFjV2UgZmFjaWxpdGF0ZSBpbm5vdmF0aW9uIGF0IGRpZmZlcmVudCBsZXZlbHMgZnJvbSB0aGUgcGVyc29uIGxvb2tpbmcgdG8gZXhwbG9yZSBlbnRlcnByaXNlIHNoYXBlIHRocm91Z2ggaW5mb3JtYXRpb24gd2hlcmUgd2UgZmluYW5jZSBhbmQgaW52ZXN0IGluIHN0YXJ0dXBzIGFuZCBhY2NlbGVyYXRpb24sIGFuZCBhbGwgdGhlIHdheSB0byB3b3JraW5nIHdpdGggY29ycG9yYXRlIGdyb3VwcyBhbmQgaGVscGluZyB0aGVtIHRhY2tsZSBkaWdpdGFsIHRyYW5zZm9ybWF0aW9uLiBXZSB3YW50IHRvIG1ha2UgaXQgcG9zc2libGUgZm9yIGFsbCBvZiB0aGVtIHRvIGJlbmVmaXQgZnJvbSBvdXIgbmV0d29yaywgaGF2ZSBhY2Nlc3MgdG8gZGlmZmVyZW50IHJlc291cmNlcyBhbmQgaGVscCBzdGFydHVwcyBiZWNvbWUgbmF0aW9ud2lkZSBhIGxvdCBmYXN0ZXIuXHUyMDFkPC9lbT5cclxuXHJcbiZuYnNwOzwvYmxvY2txdW90ZT5cclxuPGltZyBjbGFzcz1cIiB3cC1pbWFnZS0xNTcxNSBhbGlnbmNlbnRlclwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIyLzAzL1Bhb2xhLVZpbGxhbGJhLTMwMHgxNjcucG5nXCIgYWx0PVwiXCIgd2lkdGg9XCI1MjhcIiBoZWlnaHQ9XCIyOTRcIiAvPlxyXG5cclxuJm5ic3A7XHJcblxyXG5WaWxsYWxiYSBvdXRsaW5lZCB0aGUgdHlwZSBvZiBhY3Rpdml0eSB0aGUgbmV0d29yayBjcmVhdGVzIGluIG9yZGVyIHRvIGJ1aWxkIHRoaXMgaW5ub3ZhdGlvbjpcclxuPGJsb2NrcXVvdGU+Jm5ic3A7XHJcblxyXG48ZW0+XHUyMDFjV2UgaGF2ZSBpbm5vdmF0aW9uLCBjaGFsbGVuZ2VzLCBlbnRyZXByZW5ldXJzaGlwLCBleHRyYSBwYXJ0bmVyc2hpcCBoYWNrYXRob25zIGFuZCBkaWZmZXJlbnQgZGVzaWduLiBBbmQgeWVzLCBkZXNpZ24gdGhpbmtpbmcgYm9vdGNhbXBzIGZvciB0aGVtLiBBbmQgdGhlIG90aGVyIG9uZSB0aGF0IHdlIGhhdmUgaXMgdmVyeSBzcGVjaWZpYywgd2hpY2ggaXMgdGhlIG9wZW4gaW5ub3ZhdGlvbiBhY2NlbGVyYXRvcnMuIDwvZW0+PGVtPltPdXJdIGFtYml0aW9uIGlzIHRvIGNyZWF0ZSBhbiBpbm5vdmF0aW9uIG5ldHdvcmsgZm9yIG1lZGlhIGdyb3VwcyB3aGVyZSB3aGF0IHdlIGRvIHdpdGggb25lIG1lZGlhIGFuZCBvbmUgc3RhcnR1cCBtYXkgYmUgcmVwbGljYXRlZCBpbiBvdGhlciBsb2NhbCBuZXdzcGFwZXJzLiBUaGlzIHdvcmtzIGluIEZyYW5jZSBiZWNhdXNlIHRoZXNlIG1lZGlhIGdyb3VwcyBhcmUgbm90IGluIGNvbXBldGl0aW9uIHdpdGggZWFjaCBvdGhlci5cdTIwMWQ8L2VtPjwvYmxvY2txdW90ZT5cclxuJm5ic3A7XHJcblxyXG5UYWxraW5nIGFib3V0IHRoZSBTeWxsYWJ1cyBNZWRpYSBhY2NlbGVyYXRvciBhdCBMYSBWb2l4IGR1IE5vcmQsIFZpbGxhbGJhIGV4cGxhaW5lZCB0aGF0IHRoaXMgYWNjZWxlcmF0b3IgZW5hYmxlcyB0aGUgcHVibGlzaGVyIHRvIGNvbm5lY3Qgd2l0aCBzdGFydC11cCB0byBhY2NlbGVyYXRlIGl0cyBkaWdpdGFsIHRyYW5zZm9ybWF0aW9uIHRocm91Z2ggaWRlbnRpZnlpbmcgaW5ub3ZhdGlvbiBzb2x1dGlvbnMgdG8gdGhlIGNoYWxsZW5nZXMgdGhleSBmYWNlLlxyXG5cclxuU3lsbGFidXMgbWVkaWEgd29ya3MgaW4gdHdvIHdheXMuIElkZW50aWZ5aW5nIHRyZW5kcyBhbmQgb3Bwb3J0dW5pdGllcyBleHRlcm5hbGx5IG9yIGlkZW50aWZ5aW5nIGludGVybmFsIG5lZWRzIHdpdGhpbiB0aGUgcHVibGlzaGVyLCBhbmQgdGhlbiB3b3JraW5nIHdpdGggc3RhcnQtdXBzIHRvIGhlbHAgY29ubmVjdCB0aGVtIHRvIGEgY2hhbGxlbmdlLiBUaGVzZSBzdGFydC11cHMgY2FuIGhlbHAgc2hvcnRlbiB0aGUgdGltZSB0byBtYXJrZXQgdG8gaGVscCBuZXcgc29sdXRpb25zLiBUaGUgc3RhcnQtdXBzIGNhbiBhbHNvIHRha2UgYWR2YW50YWdlIG9mIHRyYWluaW5nIGFuZCBkZXZlbG9wbWVudCBvcHBvcnR1bml0aWVzIHZpYSB0aGUgYWNjZWxlcmF0b3IgYW5kIG5ldHdvcmsuXHJcblxyXG5UaGUgcHJvZ3JhbW1lcyBsYXN0IGJldHdlZW4gNiBhbmQgMTIgbW9udGhzLCBhbmQgaXQgaGFzIHdvcmtlZCB3aXRoIGEgcmFuZ2Ugb2Ygb3JnYW5pc2F0aW9ucyBzcGFubmluZyBlZHVjYXRpb24sIGFkdmVydGlzaW5nIGFuZCBjb250ZW50IGNyZWF0aW9uLiBJdCB0ZXN0cyBwcm9kdWN0cyBhbmQgYnVzaW5lc3MgbW9kZWxzIHF1aWNrbHkgYW5kIGVmZmVjdGl2ZWx5LiBUaGVyZSBhcmUgdGhyZWUgbWFpbiBhcmVhcyB0aGF0IHRoZSBuZXR3b3JrIGZvY3Vzc2VzIG9uOlxyXG48dWw+XHJcbiBcdDxsaT48c3Ryb25nPkRpdmVyc2lmaWNhdGlvbjwvc3Ryb25nPjogbmV3IGJ1c2luZXNzIG1vZGVscywgbmV3IHByb2R1Y3RzIGFuZCBzb2x1dGlvbnM8L2xpPlxyXG4gXHQ8bGk+PHN0cm9uZz5OZXcgdHlwZXMgb2YgY29udGVudDo8L3N0cm9uZz4gZXhwbG9yaW5nIG5ldyBjaGFubmVscyBzdWNoIGFzIHBvZGNhc3RzLCB2aXJ0dWFsIHJlYWxpdHkgYW5kIGF1Z21lbnRlZCByZWFsaXR5PC9saT5cclxuIFx0PGxpPjxzdHJvbmc+TmV3IHRvb2xzIGFuZCBzb2x1dGlvbnM8L3N0cm9uZz46IGludGVybmFsIHN5c3RlbXMgdGhhdCBhbGxvdyBwdWJsaXNoZXJzIHRvIGluY3JlYXNlIGVmZmljaWVuY3ksIHVuZGVyc3RhbmQgYXVkaWVuY2UgZGF0YSBhbmQvY3JlYXRlIGJldHRlciBjb250ZW50PC9saT5cclxuPC91bD5cclxuJm5ic3A7XHJcblxyXG5Ud28gc3VjY2Vzc2Z1bCBleGFtcGxlcyBhcmUgXHUyMDE4UmVtYXRjaFx1MjAxOSwgd2hpY2ggY29sbGVjdHMgdmlkZW8gaGlnaGxpZ2h0cyBmcm9tIGFtYXRldXIgc3BvcnRzIGFuZCBhbXBsaWZpZXMgdGhlc2Ugb24gc29jaWFsIGNoYW5uZWxzLiBDbHVicyB1cGxvYWQgZGlyZWN0bHkgdG8gdGhlIGFwcCBhbmQgam91cm5hbGlzdHMgY2FuIHVzZSB0aGUgY29udGVudCBvbiBzcGVjaWFsIHByb2dyYW1taW5nIGFuZCBvdXRwdXRzLiBcdTIwMThUcnVzdHlcdTIwMTkgaXMgYSBkeW5hbWljIGpvYiBib2FyZCBzb2x1dGlvbiB0aGF0IGlzIHN0aWxsIGJlaW5nIGFjY2VsZXJhdGVkIGluIGNvbmp1bmN0aW9uIHdpdGggTGEgVm9peCBkdSBOb3JkLiBJdCBhbGxvd3MgdGhvc2UgaG9zdGluZyBqb2JzIHBhZ2VzIHRvIGN1c3RvbWlzZSB0aGVpciB3ZWJzaXRlcyBhbmQgb2ZmZXIgZGlmZmVyZW50IHNlcnZpY2VzLlxyXG5cclxuJm5ic3A7XHJcbjxoMz48c3Ryb25nPkJ3bGI6IEFDQ09SRElPTjwvc3Ryb25nPjwvaDM+XHJcbkZpbmFsbHksIEFuZHkgVGF5bG9yIGludHJvZHVjZWQgaGlzIHN0YXJ0LXVwIEJ3bGIuIEJhc2VkIGluIFdhbGVzLCBCd2xiXHUyMDE5cyBBQ0NPUkRJT04gY3JlYXRlcyBcdTIwMWNzbWFydCBwb2RjYXN0c1x1MjAxZCwgd2hpY2ggc2VlcyB0aGUgYXVkaW8gYWRqdXN0ZWQgdG8gZml0IHRoZSB0aW1lIHVzZXJzIGhhdmUgYXZhaWxhYmxlLiBUYXlsb3Igc3VnZ2VzdGVkIHRoYXQgdGhpcyBpbmNyZWFzZXMgdGhlIFx1MjAxY2Ftb3VudCBvZiBjb250cm9sIGFuZCBjb252ZW5pZW5jZSB0aGF0IHRoZSBsaXN0ZW5lcnMgY2FuIGhhdmUgaW4gdGhlIGZ1dHVyZVx1MjAxZC4gVXNpbmcgQUkgdGVjaCwgQndsYiBhaW1zIHRvIHByb3ZpZGUgc2hvcnRlbmVkIHBvZGNhc3RzIHRoYXQgc3RpbGwgcmV0YWluIHRoZSBjb3JlIHN0b3J5LiBFc3NlbnRpYWxseSwgc3VwZXJmbHVvdXMgZWxlbWVudHMgYXJlIHJlbW92ZWQgc28gdGhlIGVzc2VuY2Ugb2YgdGhlIHBvZGNhc3RzIGFyZSByZXRhaW5lZC4gVXNlcnMgY2FuIGRlZmluZSBob3cgbXVjaCB0aW1lIHRoZXkgaGF2ZSwgYW5kIHRoZSBhdWRpbyBpcyBlZGl0ZWQgdG8gdGhlIHJpZ2h0IHBsYXkgdGltZS5cclxuXHJcbiZuYnNwO1xyXG48YmxvY2txdW90ZT48ZW0+VGF5bG9yIGV4cGxhaW5zOiBcdTIwMWNXZSB0aGluayB0aGF0IHRoZXJlIG5lZWRzIHRvIGJlIGEgYnJlYWt0aHJvdWdoIGluIGF1ZGlvLCBzcGVjaWZpY2FsbHkgaW4gcG9kY2FzdGluZywgd2hlcmUgbGlzdGVuZXJzIGdldCBhIGxvdCBtb3JlIGNvbnRyb2wgYW5kIGNvbnZlbmllbmNlIGluIHRoZSBzYW1lIHdheSB0aGV5IGhhdmUgd2l0aCB2aXN1YWwgbWVkaWEuIFNvIHRoaXMgaXMgd2hhdCBhY2NvcmRpb24gYWltcyB0byBkbywgaXQgZ2l2ZXMgdGhlIGxpc3RlbmVyIGEgY2hhbmNlIHRvIGFkanVzdCB0aGUgZHVyYXRpb24gb2YgYW55IHBvZGNhc3QgZXBpc29kZSB3aXRob3V0IGxvc2luZyBzdHJ1Y3R1cmUsIHRvbmUgb3IgbGlzdGVuYWJpbGl0eS5cdTIwMWQ8L2VtPjwvYmxvY2txdW90ZT5cclxuJm5ic3A7XHJcblxyXG48aW1nIGNsYXNzPVwiIHdwLWltYWdlLTE1NzE2IGFsaWduY2VudGVyXCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMjIvMDMvQndsYi0zMDB4MTQxLnBuZ1wiIGFsdD1cIlwiIHdpZHRoPVwiNTc1XCIgaGVpZ2h0PVwiMjcwXCIgLz5cclxuXHJcbkJ3bGIgaXMgd29ya2luZyBvbiBmdWxsIGF1dG9tYXRpb24gYW5kIGlzIGludGVyZXN0aW5nIGluIHdvcmtpbmcgd2l0aCBzbWFsbCwgbWVkaXVtIG9yIGxhcmdlIG9yZ2FuaXNhdGlvbnMgdG8gdGFrZSB0aGUgcHJvZHVjdCB0byB0aGUgbmV4dCBsZXZlbC4gVGhlIGtleSBlbGVtZW50IGJlaGluZCB0aGUgcHJvZHVjdCBpcyB0aGUgZXhwZXJpZW5jZSBcdTIwMTMgY3JlYXRpbmcgYSBzZWFtbGVzcyBhdWRpbyBleHBlcmllbmNlIGV2ZW4gdGhvdWdoIGl0IGlzIGNvbmRlbnNlZC5cclxuXHJcblx1MjAxY0l0J2xsIHN0aWxsIHNvdW5kIGxpa2UgdGhlIHBvZGNhc3QgeW91IGtub3cgYW5kIGxvdmUsXHUyMDFkIFRheWxvciBhZGRlZC5cclxuXHJcbiZuYnNwO1xyXG5cclxuPGVtPjxzcGFuIHN0eWxlPVwidGV4dC1kZWNvcmF0aW9uOiB1bmRlcmxpbmU7XCI+PHN0cm9uZz5UaGUgbmV4dCBHQU1JIEJyaWVmaW5nIHdpbGwgdGFrZSBwbGFjZSBvbmxpbmUgYmVmb3JlIHRoZSBzdW1tZXIgYW5kIGhvcGVmdWxseSBhIG5ldyBlZGl0aW9uIG9mIHRoZSBcdTIwMWNpbi1wZXJzb25cdTIwMWQgTWVkaWEgTGFicyBkYXlzIHdpbGwgYmUgdGFraW5nIHBsYWNlIGxhdGVyIGluIHRoZSB5ZWFyXHUyMDI2PC9zdHJvbmc+PC9zcGFuPjwvZW0+XHJcblxyXG5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW5dW3ZjX2NvbHVtbl90ZXh0XVxyXG5cclxuPHNwYW4gc3R5bGU9XCJib3JkZXItdG9wLWxlZnQtcmFkaXVzOiAycHg7IGJvcmRlci10b3AtcmlnaHQtcmFkaXVzOiAycHg7IGJvcmRlci1ib3R0b20tcmlnaHQtcmFkaXVzOiAycHg7IGJvcmRlci1ib3R0b20tbGVmdC1yYWRpdXM6IDJweDsgdGV4dC1pbmRlbnQ6IDIwcHg7IHdpZHRoOiBhdXRvOyBwYWRkaW5nOiAwcHggNHB4IDBweCAwcHg7IHRleHQtYWxpZ246IGNlbnRlcjsgZm9udC1zdHlsZTogbm9ybWFsOyBmb250LXZhcmlhbnQtY2Fwczogbm9ybWFsOyBmb250LXdlaWdodDogYm9sZDsgZm9udC1zdHJldGNoOiBub3JtYWw7IGZvbnQtc2l6ZTogMTFweDsgbGluZS1oZWlnaHQ6IDIwcHg7IGZvbnQtZmFtaWx5OiAnSGVsdmV0aWNhIE5ldWUnLCBIZWx2ZXRpY2EsIHNhbnMtc2VyaWY7IGNvbG9yOiAjZmZmZmZmOyBiYWNrZ3JvdW5kLWltYWdlOiB1cmwoZGF0YTppbWFnZS9zdmcreG1sOyBiYXNlNjQscGhuMnp5YjRid3h1Y3owaWFocjBjZG92bDNkM2R5NTNteTV2Y21jdm1qYXdtYzl6ZG1jaWlnaGxhd2RvZGQwaW16YndlY2lnZDJsa2RnZzlpam13Y2hnaWloenB6eGRjYjNnOWlpMHhpYzB4aWRteGlkbXhpajQ4eno0OGNnZjBhY2JrcHNqbm1qa3VuZHE1bGRlMGxqeTJtaWJkbWprdW5kcTVsZGl5bGpjeW1pYXltaTQ0bmpnc21qa3VtanUyaWRlMGxqYzFsZGk1bGppMW5pYmRuaTQybXppc21qa3VtanUyaWRhdW1kdXhsZGl5bGpjeW1pYXdsamExbXN3eG5jNDJuamlncXphdW1kdXhsZHl1bmpheGlkeXVuam15bGRhdW1keTNpZGUwbGpjMWxkYXVtZHkzaWVteW1pNDRuamdzbWM0d25qY2dtamt1bmRxNWxkeXVuamF4aWRpNWxqcTBvc3d4bmM0Mm5qaWlpZ3pwYmd3OWlpbm16bXlpaWhuMGNtOXJ6dDBpaTJ6bXppaWdjM3J5YjJ0bGx4ZHB6aHJvcHNpeGlqNDhsM2JoZGdnK3BoYmhkZ2dnemQwaXR0ZTBsamN6bXl3eGxqeTRuaWJkbnk0MW10eXNtczQyb2R5Z21zNDJuanVzbnk0MG90dWdtczQybmp1c210cXVuanl5aWVteGxqeTJuc3d5bWM0eG50a2duczR4bWRrc21qcXVvZHUwaWRrdW90Y3Ntanl1bnpxMGllbTVsamcxbml3eW5zNDNtdGdnb3M0M250bXNtanF1bXRxemlkZXdsamF4bml3eW15NHdtamlncXpld2xqaTFteXd5bWk0d21zYXhtczQxbmRnc210eXVudGN5aWRleGxqdTBvY3d4bmk0MW56aWdxemV4bGp1MG9jd3huaTQxbnppZ210ZXVtdHUzbGRlMWxqYzVuc2F4bXM0eG50Y3NtdHF1bmpxMmllbXhtczR4bnRjc210aXVvZHF5aWRleWxqaXhtc3d4bXM0MG90dWdtdG11bnRpeWxkZXhsanE1bnNiZG10cXVuam0zbGRleGxqcTVuc2F4bnM0eG56dXNtdGl1bXppMmlkZTFsamUzbnN3eG15NHptam1ncXplMWxqZTNuc3d4bmM0MG16eWdtdHF1bmR5eWxkZTJsamVnbXRxdW1ka3psZGUzbGp5MG15YmRtdG11bnpnMWxkZTRsamt6bnNheG5jNDNuZHVzbXRrdW90ZzRpZGUybGpheW9jd3hvczQ1b2RnZ3F6ZTRsam0xbXN3eG9zNDVvZGdnbWphdW10bTJsZGUzbGp1MW5pYXltYzR4bXp5c210cXVtZHEyaWVteW1jNHhtenlzbXRhdW90bTVpZGUzbGpnNG9jdzRsamMybnlheG5jNDJuemdzb2M0M25qY2dxemV3bGprMW9zdzRsamMybnlhNGxqYzNueXd4bXM0MW16eWdvYzQzbnpjc210cXVtems0aWVtNGxqYzNueXd4bnM0MW10bWdvczR5bXN3eG5pNDNtZGtnb3M0M25ka3NtdGN1bXp1NWllbTVsamcxbml3eG55NDBvZGdnb3M0NG56aXNtdGN1bmlhNWxqZzBsZGUzbGpjem1zYmRvczQzbmRlc210Z3VtdHF4aWRrdW50aXNtdGt1bWRpemlka3VuZGMzbGRlNWxqaXdteWJkb3M0MG1pd3hvczQwbmNhNWxqaTRvY3d4b3M0MG90ZWdvczR3bmN3eG9zNHpuenlncXpjdW5kYTRsZGU0bGp5eW1pYTJsam00bnl3eG5pNHludGlnbmk0em9kY3NtdHF1bXpxNWllbTJsam00bnl3eG1jNHludHlnb3M0em9kbXNuaTQwb3RjZ210dXVtZGl5bGR5dW5kazNpZW14b3M0MW50dXNuaTQwb3RjZ21qbXVtZGM0bGRrdW56YTFpZGl6bGphM29jd3hteTQ1b3RlZ3F6aXpsamEzb2N3eG9jNDBuam1nbWphdW1qbTVsZGl5bGphMm1pYXhuaTR5b3Rjc21qaXVtZHl5aWVteG5jNDVuem1zbWppdW1keXlpZGV6bGpjeW9jd3ltczR6bnprZ210bXVtemF5bGRpd2xqdTNtaWJkbXRtdW16YXlsZGl3bGp1M21pYXhtaTQybmRjc21qbXVtZHVnbXRpdW5kZzRsZGl6bGp5MW55YmRtdGl1bXRremxkaTBsamM0bmNheG1zNHpvdHlzbWp5dW10azJpZGV3bGpnMm15d3lueTR3bnRnZ3F6ZXlsamE0bml3eW55NDBtenFnbXRtdW16ZzJsZGkzbGp5em55YXhuYzQzbXptc21qY3Vuam0zaWVteW1zNDVuc3d5bnk0Mm16Y2dtamN1b2RheGxkaXhsamd5b2NheW55NDRtZGVzbXRxdW5qeXlpZW15bnk0NG1kZXNueTQwb3R1Z21qZXVvdHVzbXM0Mm9keWdtdHF1bnptemxkZXVuamcyaWlibWF3eHNwc2lqeW1xd29kZmppajQ4bDNiaGRnZytwYzlucGp3dmMzem5wZz09KTsgYmFja2dyb3VuZC1zaXplOiAxNHB4IDE0cHg7IGJhY2tncm91bmQtY29sb3I6ICNiZDA4MWM7IHBvc2l0aW9uOiBhYnNvbHV0ZTsgb3BhY2l0eTogMTsgei1pbmRleDogODY3NTMwOTsgZGlzcGxheTogbm9uZTsgY3Vyc29yOiBwb2ludGVyOyBib3JkZXI6IG5vbmU7IC13ZWJraXQtZm9udC1zbW9vdGhpbmc6IGFudGlhbGlhc2VkOyBiYWNrZ3JvdW5kLXBvc2l0aW9uOiAzcHggNTAlOyBiYWNrZ3JvdW5kLXJlcGVhdDogbm8tcmVwZWF0IG5vLXJlcGVhdDtcIj5TYXZlPC9zcGFuPjxzcGFuIHN0eWxlPVwiYm9yZGVyLXRvcC1sZWZ0LXJhZGl1czogMnB4OyBib3JkZXItdG9wLXJpZ2h0LXJhZGl1czogMnB4OyBib3JkZXItYm90dG9tLXJpZ2h0LXJhZGl1czogMnB4OyBib3JkZXItYm90dG9tLWxlZnQtcmFkaXVzOiAycHg7IHRleHQtaW5kZW50OiAyMHB4OyB3aWR0aDogYXV0bzsgcGFkZGluZzogMHB4IDRweCAwcHggMHB4OyB0ZXh0LWFsaWduOiBjZW50ZXI7IGZvbnQtc3R5bGU6IG5vcm1hbDsgZm9udC12YXJpYW50LWNhcHM6IG5vcm1hbDsgZm9udC13ZWlnaHQ6IGJvbGQ7IGZvbnQtc3RyZXRjaDogbm9ybWFsOyBmb250LXNpemU6IDExcHg7IGxpbmUtaGVpZ2h0OiAyMHB4OyBmb250LWZhbWlseTogJ0hlbHZldGljYSBOZXVlJywgSGVsdmV0aWNhLCBzYW5zLXNlcmlmOyBjb2xvcjogI2ZmZmZmZjsgYmFja2dyb3VuZC1pbWFnZTogdXJsKGRhdGE6aW1hZ2Uvc3ZnK3htbDsgYmFzZTY0LHBobjJ6eWI0Ynd4dWN6MGlhaHIwY2RvdmwzZDNkeTUzbXk1dmNtY3ZtamF3bWM5emRtY2lpZ2hsYXdkb2RkMGltemJ3ZWNpZ2QybGtkZ2c5aWptd2NoZ2lpaHpwenhkY2IzZzlpaTB4aWMweGlkbXhpZG14aWo0OHp6NDhjZ2YwYWNia3Bzam5tamt1bmRxNWxkZTBsankybWliZG1qa3VuZHE1bGRpeWxqY3ltaWF5bWk0NG5qZ3Ntamt1bWp1MmlkZTBsamMxbGRpNWxqaTFuaWJkbmk0Mm16aXNtamt1bWp1MmlkYXVtZHV4bGRpeWxqY3ltaWF3bGphMW1zd3huYzQybmppZ3F6YXVtZHV4bGR5dW5qYXhpZHl1bmpteWxkYXVtZHkzaWRlMGxqYzFsZGF1bWR5M2llbXltaTQ0bmpnc21jNHduamNnbWprdW5kcTVsZHl1bmpheGlkaTVsanEwb3N3eG5jNDJuamlpaWd6cGJndzlpaW5tem15aWlobjBjbTlyenQwaWkyem16aWlnYzNyeWIydGxseGRwemhyb3BzaXhpajQ4bDNiaGRnZytwaGJoZGdnZ3pkMGl0dGUwbGpjem15d3hsank0bmliZG55NDFtdHlzbXM0Mm9keWdtczQybmp1c255NDBvdHVnbXM0Mm5qdXNtdHF1bmp5eWllbXhsankybnN3eW1jNHhudGtnbnM0eG1ka3NtanF1b2R1MGlka3VvdGNzbWp5dW56cTBpZW01bGpnMW5pd3luczQzbXRnZ29zNDNudG1zbWpxdW10cXppZGV3bGpheG5pd3lteTR3bWppZ3F6ZXdsamkxbXl3eW1pNHdtc2F4bXM0MW5kZ3NtdHl1bnRjeWlkZXhsanUwb2N3eG5pNDFuemlncXpleGxqdTBvY3d4bmk0MW56aWdtdGV1bXR1M2xkZTFsamM1bnNheG1zNHhudGNzbXRxdW5qcTJpZW14bXM0eG50Y3NtdGl1b2RxeWlkZXlsaml4bXN3eG1zNDBvdHVnbXRtdW50aXlsZGV4bGpxNW5zYmRtdHF1bmptM2xkZXhsanE1bnNheG5zNHhuenVzbXRpdW16aTJpZGUxbGplM25zd3hteTR6bWptZ3F6ZTFsamUzbnN3eG5jNDBtenlnbXRxdW5keXlsZGUybGplZ210cXVtZGt6bGRlM2xqeTBteWJkbXRtdW56ZzFsZGU0bGprem5zYXhuYzQzbmR1c210a3VvdGc0aWRlMmxqYXlvY3d4b3M0NW9kZ2dxemU0bGptMW1zd3hvczQ1b2RnZ21qYXVtdG0ybGRlM2xqdTFuaWF5bWM0eG16eXNtdHF1bWRxMmllbXltYzR4bXp5c210YXVvdG01aWRlM2xqZzRvY3c0bGpjMm55YXhuYzQybnpnc29jNDNuamNncXpld2xqazFvc3c0bGpjMm55YTRsamMzbnl3eG1zNDFtenlnb2M0M256Y3NtdHF1bXprNGllbTRsamMzbnl3eG5zNDFtdG1nb3M0eW1zd3huaTQzbWRrZ29zNDNuZGtzbXRjdW16dTVpZW01bGpnMW5pd3hueTQwb2RnZ29zNDRuemlzbXRjdW5pYTVsamcwbGRlM2xqY3ptc2Jkb3M0M25kZXNtdGd1bXRxeGlka3VudGlzbXRrdW1kaXppZGt1bmRjM2xkZTVsaml3bXliZG9zNDBtaXd4b3M0MG5jYTVsamk0b2N3eG9zNDBvdGVnb3M0d25jd3hvczR6bnp5Z3F6Y3VuZGE0bGRlNGxqeXltaWEybGptNG55d3huaTR5bnRpZ25pNHpvZGNzbXRxdW16cTVpZW0ybGptNG55d3htYzR5bnR5Z29zNHpvZG1zbmk0MG90Y2dtdHV1bWRpeWxkeXVuZGszaWVteG9zNDFudHVzbmk0MG90Y2dtam11bWRjNGxka3VuemExaWRpemxqYTNvY3d4bXk0NW90ZWdxeml6bGphM29jd3hvYzQwbmptZ21qYXVtam01bGRpeWxqYTJtaWF4bmk0eW90Y3Ntaml1bWR5eWllbXhuYzQ1bnptc21qaXVtZHl5aWRlemxqY3lvY3d5bXM0em56a2dtdG11bXpheWxkaXdsanUzbWliZG10bXVtemF5bGRpd2xqdTNtaWF4bWk0Mm5kY3Ntam11bWR1Z210aXVuZGc0bGRpemxqeTFueWJkbXRpdW10a3psZGkwbGpjNG5jYXhtczR6b3R5c21qeXVtdGsyaWRld2xqZzJteXd5bnk0d250Z2dxemV5bGphNG5pd3lueTQwbXpxZ210bXVtemcybGRpM2xqeXpueWF4bmM0M216bXNtamN1bmptM2llbXltczQ1bnN3eW55NDJtemNnbWpjdW9kYXhsZGl4bGpneW9jYXlueTQ0bWRlc210cXVuanl5aWVteW55NDRtZGVzbnk0MG90dWdtamV1b3R1c21zNDJvZHlnbXRxdW56bXpsZGV1bmpnMmlpYm1hd3hzcHNpanltcXdvZGZqaWo0OGwzYmhkZ2crcGM5bnBqd3ZjM3pucGc9PSk7IGJhY2tncm91bmQtc2l6ZTogMTRweCAxNHB4OyBiYWNrZ3JvdW5kLWNvbG9yOiAjYmQwODFjOyBwb3NpdGlvbjogYWJzb2x1dGU7IG9wYWNpdHk6IDE7IHotaW5kZXg6IDg2NzUzMDk7IGRpc3BsYXk6IG5vbmU7IGN1cnNvcjogcG9pbnRlcjsgYm9yZGVyOiBub25lOyAtd2Via2l0LWZvbnQtc21vb3RoaW5nOiBhbnRpYWxpYXNlZDsgYmFja2dyb3VuZC1wb3NpdGlvbjogM3B4IDUwJTsgYmFja2dyb3VuZC1yZXBlYXQ6IG5vLXJlcGVhdCBuby1yZXBlYXQ7XCI+U2F2ZTwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiYm9yZGVyLXRvcC1sZWZ0LXJhZGl1czogMnB4OyBib3JkZXItdG9wLXJpZ2h0LXJhZGl1czogMnB4OyBib3JkZXItYm90dG9tLXJpZ2h0LXJhZGl1czogMnB4OyBib3JkZXItYm90dG9tLWxlZnQtcmFkaXVzOiAycHg7IHRleHQtaW5kZW50OiAyMHB4OyB3aWR0aDogYXV0bzsgcGFkZGluZzogMHB4IDRweCAwcHggMHB4OyB0ZXh0LWFsaWduOiBjZW50ZXI7IGZvbnQtc3R5bGU6IG5vcm1hbDsgZm9udC12YXJpYW50LWNhcHM6IG5vcm1hbDsgZm9udC13ZWlnaHQ6IGJvbGQ7IGZvbnQtc3RyZXRjaDogbm9ybWFsOyBmb250LXNpemU6IDExcHg7IGxpbmUtaGVpZ2h0OiAyMHB4OyBmb250LWZhbWlseTogJ0hlbHZldGljYSBOZXVlJywgSGVsdmV0aWNhLCBzYW5zLXNlcmlmOyBjb2xvcjogI2ZmZmZmZjsgYmFja2dyb3VuZC1pbWFnZTogdXJsKGRhdGE6aW1hZ2Uvc3ZnK3htbDsgYmFzZTY0LHBobjJ6eWI0Ynd4dWN6MGlhaHIwY2RvdmwzZDNkeTUzbXk1dmNtY3ZtamF3bWM5emRtY2lpZ2hsYXdkb2RkMGltemJ3ZWNpZ2QybGtkZ2c5aWptd2NoZ2lpaHpwenhkY2IzZzlpaTB4aWMweGlkbXhpZG14aWo0OHp6NDhjZ2YwYWNia3Bzam5tamt1bmRxNWxkZTBsankybWliZG1qa3VuZHE1bGRpeWxqY3ltaWF5bWk0NG5qZ3Ntamt1bWp1MmlkZTBsamMxbGRpNWxqaTFuaWJkbmk0Mm16aXNtamt1bWp1MmlkYXVtZHV4bGRpeWxqY3ltaWF3bGphMW1zd3huYzQybmppZ3F6YXVtZHV4bGR5dW5qYXhpZHl1bmpteWxkYXVtZHkzaWRlMGxqYzFsZGF1bWR5M2llbXltaTQ0bmpnc21jNHduamNnbWprdW5kcTVsZHl1bmpheGlkaTVsanEwb3N3eG5jNDJuamlpaWd6cGJndzlpaW5tem15aWlobjBjbTlyenQwaWkyem16aWlnYzNyeWIydGxseGRwemhyb3BzaXhpajQ4bDNiaGRnZytwaGJoZGdnZ3pkMGl0dGUwbGpjem15d3hsank0bmliZG55NDFtdHlzbXM0Mm9keWdtczQybmp1c255NDBvdHVnbXM0Mm5qdXNtdHF1bmp5eWllbXhsankybnN3eW1jNHhudGtnbnM0eG1ka3NtanF1b2R1MGlka3VvdGNzbWp5dW56cTBpZW01bGpnMW5pd3luczQzbXRnZ29zNDNudG1zbWpxdW10cXppZGV3bGpheG5pd3lteTR3bWppZ3F6ZXdsamkxbXl3eW1pNHdtc2F4bXM0MW5kZ3NtdHl1bnRjeWlkZXhsanUwb2N3eG5pNDFuemlncXpleGxqdTBvY3d4bmk0MW56aWdtdGV1bXR1M2xkZTFsamM1bnNheG1zNHhudGNzbXRxdW5qcTJpZW14bXM0eG50Y3NtdGl1b2RxeWlkZXlsaml4bXN3eG1zNDBvdHVnbXRtdW50aXlsZGV4bGpxNW5zYmRtdHF1bmptM2xkZXhsanE1bnNheG5zNHhuenVzbXRpdW16aTJpZGUxbGplM25zd3hteTR6bWptZ3F6ZTFsamUzbnN3eG5jNDBtenlnbXRxdW5keXlsZGUybGplZ210cXVtZGt6bGRlM2xqeTBteWJkbXRtdW56ZzFsZGU0bGprem5zYXhuYzQzbmR1c210a3VvdGc0aWRlMmxqYXlvY3d4b3M0NW9kZ2dxemU0bGptMW1zd3hvczQ1b2RnZ21qYXVtdG0ybGRlM2xqdTFuaWF5bWM0eG16eXNtdHF1bWRxMmllbXltYzR4bXp5c210YXVvdG01aWRlM2xqZzRvY3c0bGpjMm55YXhuYzQybnpnc29jNDNuamNncXpld2xqazFvc3c0bGpjMm55YTRsamMzbnl3eG1zNDFtenlnb2M0M256Y3NtdHF1bXprNGllbTRsamMzbnl3eG5zNDFtdG1nb3M0eW1zd3huaTQzbWRrZ29zNDNuZGtzbXRjdW16dTVpZW01bGpnMW5pd3hueTQwb2RnZ29zNDRuemlzbXRjdW5pYTVsamcwbGRlM2xqY3ptc2Jkb3M0M25kZXNtdGd1bXRxeGlka3VudGlzbXRrdW1kaXppZGt1bmRjM2xkZTVsaml3bXliZG9zNDBtaXd4b3M0MG5jYTVsamk0b2N3eG9zNDBvdGVnb3M0d25jd3hvczR6bnp5Z3F6Y3VuZGE0bGRlNGxqeXltaWEybGptNG55d3huaTR5bnRpZ25pNHpvZGNzbXRxdW16cTVpZW0ybGptNG55d3htYzR5bnR5Z29zNHpvZG1zbmk0MG90Y2dtdHV1bWRpeWxkeXVuZGszaWVteG9zNDFudHVzbmk0MG90Y2dtam11bWRjNGxka3VuemExaWRpemxqYTNvY3d4bXk0NW90ZWdxeml6bGphM29jd3hvYzQwbmptZ21qYXVtam01bGRpeWxqYTJtaWF4bmk0eW90Y3Ntaml1bWR5eWllbXhuYzQ1bnptc21qaXVtZHl5aWRlemxqY3lvY3d5bXM0em56a2dtdG11bXpheWxkaXdsanUzbWliZG10bXVtemF5bGRpd2xqdTNtaWF4bWk0Mm5kY3Ntam11bWR1Z210aXVuZGc0bGRpemxqeTFueWJkbXRpdW10a3psZGkwbGpjNG5jYXhtczR6b3R5c21qeXVtdGsyaWRld2xqZzJteXd5bnk0d250Z2dxemV5bGphNG5pd3lueTQwbXpxZ210bXVtemcybGRpM2xqeXpueWF4bmM0M216bXNtamN1bmptM2llbXltczQ1bnN3eW55NDJtemNnbWpjdW9kYXhsZGl4bGpneW9jYXlueTQ0bWRlc210cXVuanl5aWVteW55NDRtZGVzbnk0MG90dWdtamV1b3R1c21zNDJvZHlnbXRxdW56bXpsZGV1bmpnMmlpYm1hd3hzcHNpanltcXdvZGZqaWo0OGwzYmhkZ2crcGM5bnBqd3ZjM3pucGc9PSk7IGJhY2tncm91bmQtc2l6ZTogMTRweCAxNHB4OyBiYWNrZ3JvdW5kLWNvbG9yOiAjYmQwODFjOyBwb3NpdGlvbjogYWJzb2x1dGU7IG9wYWNpdHk6IDE7IHotaW5kZXg6IDg2NzUzMDk7IGRpc3BsYXk6IG5vbmU7IGN1cnNvcjogcG9pbnRlcjsgYm9yZGVyOiBub25lOyAtd2Via2l0LWZvbnQtc21vb3RoaW5nOiBhbnRpYWxpYXNlZDsgYmFja2dyb3VuZC1wb3NpdGlvbjogM3B4IDUwJTsgYmFja2dyb3VuZC1yZXBlYXQ6IG5vLXJlcGVhdCBuby1yZXBlYXQ7XCI+U2F2ZTwvc3Bhbj48c3BhbiBzdHlsZT1cImJvcmRlci10b3AtbGVmdC1yYWRpdXM6IDJweDsgYm9yZGVyLXRvcC1yaWdodC1yYWRpdXM6IDJweDsgYm9yZGVyLWJvdHRvbS1yaWdodC1yYWRpdXM6IDJweDsgYm9yZGVyLWJvdHRvbS1sZWZ0LXJhZGl1czogMnB4OyB0ZXh0LWluZGVudDogMjBweDsgd2lkdGg6IGF1dG87IHBhZGRpbmc6IDBweCA0cHggMHB4IDBweDsgdGV4dC1hbGlnbjogY2VudGVyOyBmb250LXN0eWxlOiBub3JtYWw7IGZvbnQtdmFyaWFudC1jYXBzOiBub3JtYWw7IGZvbnQtd2VpZ2h0OiBib2xkOyBmb250LXN0cmV0Y2g6IG5vcm1hbDsgZm9udC1zaXplOiAxMXB4OyBsaW5lLWhlaWdodDogMjBweDsgZm9udC1mYW1pbHk6ICdIZWx2ZXRpY2EgTmV1ZScsIEhlbHZldGljYSwgc2Fucy1zZXJpZjsgY29sb3I6ICNmZmZmZmY7IGJhY2tncm91bmQtaW1hZ2U6IHVybChkYXRhOmltYWdlL3N2Zyt4bWw7IGJhc2U2NCxwaG4yenliNGJ3eHVjejBpYWhyMGNkb3ZsM2QzZHk1M215NXZjbWN2bWphd21jOXpkbWNpaWdobGF3ZG9kZDBpbXpid2VjaWdkMmxrZGdnOWlqbXdjaGdpaWh6cHp4ZGNiM2c5aWkweGljMHhpZG14aWRteGlqNDh6ejQ4Y2dmMGFjYmtwc2pubWprdW5kcTVsZGUwbGp5Mm1pYmRtamt1bmRxNWxkaXlsamN5bWlheW1pNDRuamdzbWprdW1qdTJpZGUwbGpjMWxkaTVsamkxbmliZG5pNDJtemlzbWprdW1qdTJpZGF1bWR1eGxkaXlsamN5bWlhd2xqYTFtc3d4bmM0Mm5qaWdxemF1bWR1eGxkeXVuamF4aWR5dW5qbXlsZGF1bWR5M2lkZTBsamMxbGRhdW1keTNpZW15bWk0NG5qZ3NtYzR3bmpjZ21qa3VuZHE1bGR5dW5qYXhpZGk1bGpxMG9zd3huYzQybmppaWlnenBiZ3c5aWlubXpteWlpaG4wY205cnp0MGlpMnptemlpZ2MzcnliMnRsbHhkcHpocm9wc2l4aWo0OGwzYmhkZ2crcGhiaGRnZ2d6ZDBpdHRlMGxqY3pteXd4bGp5NG5pYmRueTQxbXR5c21zNDJvZHlnbXM0Mm5qdXNueTQwb3R1Z21zNDJuanVzbXRxdW5qeXlpZW14bGp5Mm5zd3ltYzR4bnRrZ25zNHhtZGtzbWpxdW9kdTBpZGt1b3Rjc21qeXVuenEwaWVtNWxqZzFuaXd5bnM0M210Z2dvczQzbnRtc21qcXVtdHF6aWRld2xqYXhuaXd5bXk0d21qaWdxemV3bGppMW15d3ltaTR3bXNheG1zNDFuZGdzbXR5dW50Y3lpZGV4bGp1MG9jd3huaTQxbnppZ3F6ZXhsanUwb2N3eG5pNDFuemlnbXRldW10dTNsZGUxbGpjNW5zYXhtczR4bnRjc210cXVuanEyaWVteG1zNHhudGNzbXRpdW9kcXlpZGV5bGppeG1zd3htczQwb3R1Z210bXVudGl5bGRleGxqcTVuc2JkbXRxdW5qbTNsZGV4bGpxNW5zYXhuczR4bnp1c210aXVtemkyaWRlMWxqZTNuc3d4bXk0em1qbWdxemUxbGplM25zd3huYzQwbXp5Z210cXVuZHl5bGRlMmxqZWdtdHF1bWRremxkZTNsankwbXliZG10bXVuemcxbGRlNGxqa3puc2F4bmM0M25kdXNtdGt1b3RnNGlkZTJsamF5b2N3eG9zNDVvZGdncXplNGxqbTFtc3d4b3M0NW9kZ2dtamF1bXRtMmxkZTNsanUxbmlheW1jNHhtenlzbXRxdW1kcTJpZW15bWM0eG16eXNtdGF1b3RtNWlkZTNsamc0b2N3NGxqYzJueWF4bmM0Mm56Z3NvYzQzbmpjZ3F6ZXdsamsxb3N3NGxqYzJueWE0bGpjM255d3htczQxbXp5Z29jNDNuemNzbXRxdW16azRpZW00bGpjM255d3huczQxbXRtZ29zNHltc3d4bmk0M21ka2dvczQzbmRrc210Y3VtenU1aWVtNWxqZzFuaXd4bnk0MG9kZ2dvczQ0bnppc210Y3VuaWE1bGpnMGxkZTNsamN6bXNiZG9zNDNuZGVzbXRndW10cXhpZGt1bnRpc210a3VtZGl6aWRrdW5kYzNsZGU1bGppd215YmRvczQwbWl3eG9zNDBuY2E1bGppNG9jd3hvczQwb3RlZ29zNHduY3d4b3M0em56eWdxemN1bmRhNGxkZTRsanl5bWlhMmxqbTRueXd4bmk0eW50aWduaTR6b2Rjc210cXVtenE1aWVtMmxqbTRueXd4bWM0eW50eWdvczR6b2Rtc25pNDBvdGNnbXR1dW1kaXlsZHl1bmRrM2llbXhvczQxbnR1c25pNDBvdGNnbWptdW1kYzRsZGt1bnphMWlkaXpsamEzb2N3eG15NDVvdGVncXppemxqYTNvY3d4b2M0MG5qbWdtamF1bWptNWxkaXlsamEybWlheG5pNHlvdGNzbWppdW1keXlpZW14bmM0NW56bXNtaml1bWR5eWlkZXpsamN5b2N3eW1zNHpuemtnbXRtdW16YXlsZGl3bGp1M21pYmRtdG11bXpheWxkaXdsanUzbWlheG1pNDJuZGNzbWptdW1kdWdtdGl1bmRnNGxkaXpsankxbnliZG10aXVtdGt6bGRpMGxqYzRuY2F4bXM0em90eXNtanl1bXRrMmlkZXdsamcybXl3eW55NHdudGdncXpleWxqYTRuaXd5bnk0MG16cWdtdG11bXpnMmxkaTNsanl6bnlheG5jNDNtem1zbWpjdW5qbTNpZW15bXM0NW5zd3lueTQybXpjZ21qY3VvZGF4bGRpeGxqZ3lvY2F5bnk0NG1kZXNtdHF1bmp5eWllbXlueTQ0bWRlc255NDBvdHVnbWpldW90dXNtczQyb2R5Z210cXVuem16bGRldW5qZzJpaWJtYXd4c3BzaWp5bXF3b2RmamlqNDhsM2JoZGdnK3BjOW5wand2YzN6bnBnPT0pOyBiYWNrZ3JvdW5kLXNpemU6IDE0cHggMTRweDsgYmFja2dyb3VuZC1jb2xvcjogI2JkMDgxYzsgcG9zaXRpb246IGFic29sdXRlOyBvcGFjaXR5OiAxOyB6LWluZGV4OiA4Njc1MzA5OyBkaXNwbGF5OiBub25lOyBjdXJzb3I6IHBvaW50ZXI7IGJvcmRlcjogbm9uZTsgLXdlYmtpdC1mb250LXNtb290aGluZzogYW50aWFsaWFzZWQ7IGJhY2tncm91bmQtcG9zaXRpb246IDNweCA1MCU7IGJhY2tncm91bmQtcmVwZWF0OiBuby1yZXBlYXQgbm8tcmVwZWF0O1wiPlNhdmU8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImJvcmRlci10b3AtbGVmdC1yYWRpdXM6IDJweDsgYm9yZGVyLXRvcC1yaWdodC1yYWRpdXM6IDJweDsgYm9yZGVyLWJvdHRvbS1yaWdodC1yYWRpdXM6IDJweDsgYm9yZGVyLWJvdHRvbS1sZWZ0LXJhZGl1czogMnB4OyB0ZXh0LWluZGVudDogMjBweDsgd2lkdGg6IGF1dG87IHBhZGRpbmc6IDBweCA0cHggMHB4IDBweDsgdGV4dC1hbGlnbjogY2VudGVyOyBmb250LXN0eWxlOiBub3JtYWw7IGZvbnQtdmFyaWFudC1jYXBzOiBub3JtYWw7IGZvbnQtd2VpZ2h0OiBib2xkOyBmb250LXN0cmV0Y2g6IG5vcm1hbDsgZm9udC1zaXplOiAxMXB4OyBsaW5lLWhlaWdodDogMjBweDsgZm9udC1mYW1pbHk6ICdIZWx2ZXRpY2EgTmV1ZScsIEhlbHZldGljYSwgc2Fucy1zZXJpZjsgY29sb3I6ICNmZmZmZmY7IGJhY2tncm91bmQtaW1hZ2U6IHVybChkYXRhOmltYWdlL3N2Zyt4bWw7IGJhc2U2NCxwaG4yenliNGJ3eHVjejBpYWhyMGNkb3ZsM2QzZHk1M215NXZjbWN2bWphd21jOXpkbWNpaWdobGF3ZG9kZDBpbXpid2VjaWdkMmxrZGdnOWlqbXdjaGdpaWh6cHp4ZGNiM2c5aWkweGljMHhpZG14aWRteGlqNDh6ejQ4Y2dmMGFjYmtwc2pubWprdW5kcTVsZGUwbGp5Mm1pYmRtamt1bmRxNWxkaXlsamN5bWlheW1pNDRuamdzbWprdW1qdTJpZGUwbGpjMWxkaTVsamkxbmliZG5pNDJtemlzbWprdW1qdTJpZGF1bWR1eGxkaXlsamN5bWlhd2xqYTFtc3d4bmM0Mm5qaWdxemF1bWR1eGxkeXVuamF4aWR5dW5qbXlsZGF1bWR5M2lkZTBsamMxbGRhdW1keTNpZW15bWk0NG5qZ3NtYzR3bmpjZ21qa3VuZHE1bGR5dW5qYXhpZGk1bGpxMG9zd3huYzQybmppaWlnenBiZ3c5aWlubXpteWlpaG4wY205cnp0MGlpMnptemlpZ2MzcnliMnRsbHhkcHpocm9wc2l4aWo0OGwzYmhkZ2crcGhiaGRnZ2d6ZDBpdHRlMGxqY3pteXd4bGp5NG5pYmRueTQxbXR5c21zNDJvZHlnbXM0Mm5qdXNueTQwb3R1Z21zNDJuanVzbXRxdW5qeXlpZW14bGp5Mm5zd3ltYzR4bnRrZ25zNHhtZGtzbWpxdW9kdTBpZGt1b3Rjc21qeXVuenEwaWVtNWxqZzFuaXd5bnM0M210Z2dvczQzbnRtc21qcXVtdHF6aWRld2xqYXhuaXd5bXk0d21qaWdxemV3bGppMW15d3ltaTR3bXNheG1zNDFuZGdzbXR5dW50Y3lpZGV4bGp1MG9jd3huaTQxbnppZ3F6ZXhsanUwb2N3eG5pNDFuemlnbXRldW10dTNsZGUxbGpjNW5zYXhtczR4bnRjc210cXVuanEyaWVteG1zNHhudGNzbXRpdW9kcXlpZGV5bGppeG1zd3htczQwb3R1Z210bXVudGl5bGRleGxqcTVuc2JkbXRxdW5qbTNsZGV4bGpxNW5zYXhuczR4bnp1c210aXVtemkyaWRlMWxqZTNuc3d4bXk0em1qbWdxemUxbGplM25zd3huYzQwbXp5Z210cXVuZHl5bGRlMmxqZWdtdHF1bWRremxkZTNsankwbXliZG10bXVuemcxbGRlNGxqa3puc2F4bmM0M25kdXNtdGt1b3RnNGlkZTJsamF5b2N3eG9zNDVvZGdncXplNGxqbTFtc3d4b3M0NW9kZ2dtamF1bXRtMmxkZTNsanUxbmlheW1jNHhtenlzbXRxdW1kcTJpZW15bWM0eG16eXNtdGF1b3RtNWlkZTNsamc0b2N3NGxqYzJueWF4bmM0Mm56Z3NvYzQzbmpjZ3F6ZXdsamsxb3N3NGxqYzJueWE0bGpjM255d3htczQxbXp5Z29jNDNuemNzbXRxdW16azRpZW00bGpjM255d3huczQxbXRtZ29zNHltc3d4bmk0M21ka2dvczQzbmRrc210Y3VtenU1aWVtNWxqZzFuaXd4bnk0MG9kZ2dvczQ0bnppc210Y3VuaWE1bGpnMGxkZTNsamN6bXNiZG9zNDNuZGVzbXRndW10cXhpZGt1bnRpc210a3VtZGl6aWRrdW5kYzNsZGU1bGppd215YmRvczQwbWl3eG9zNDBuY2E1bGppNG9jd3hvczQwb3RlZ29zNHduY3d4b3M0em56eWdxemN1bmRhNGxkZTRsanl5bWlhMmxqbTRueXd4bmk0eW50aWduaTR6b2Rjc210cXVtenE1aWVtMmxqbTRueXd4bWM0eW50eWdvczR6b2Rtc25pNDBvdGNnbXR1dW1kaXlsZHl1bmRrM2llbXhvczQxbnR1c25pNDBvdGNnbWptdW1kYzRsZGt1bnphMWlkaXpsamEzb2N3eG15NDVvdGVncXppemxqYTNvY3d4b2M0MG5qbWdtamF1bWptNWxkaXlsamEybWlheG5pNHlvdGNzbWppdW1keXlpZW14bmM0NW56bXNtaml1bWR5eWlkZXpsamN5b2N3eW1zNHpuemtnbXRtdW16YXlsZGl3bGp1M21pYmRtdG11bXpheWxkaXdsanUzbWlheG1pNDJuZGNzbWptdW1kdWdtdGl1bmRnNGxkaXpsankxbnliZG10aXVtdGt6bGRpMGxqYzRuY2F4bXM0em90eXNtanl1bXRrMmlkZXdsamcybXl3eW55NHdudGdncXpleWxqYTRuaXd5bnk0MG16cWdtdG11bXpnMmxkaTNsanl6bnlheG5jNDNtem1zbWpjdW5qbTNpZW15bXM0NW5zd3lueTQybXpjZ21qY3VvZGF4bGRpeGxqZ3lvY2F5bnk0NG1kZXNtdHF1bmp5eWllbXlueTQ0bWRlc255NDBvdHVnbWpldW90dXNtczQyb2R5Z210cXVuem16bGRldW5qZzJpaWJtYXd4c3BzaWp5bXF3b2RmamlqNDhsM2JoZGdnK3BjOW5wand2YzN6bnBnPT0pOyBiYWNrZ3JvdW5kLXNpemU6IDE0cHggMTRweDsgYmFja2dyb3VuZC1jb2xvcjogI2JkMDgxYzsgcG9zaXRpb246IGFic29sdXRlOyBvcGFjaXR5OiAxOyB6LWluZGV4OiA4Njc1MzA5OyBkaXNwbGF5OiBub25lOyBjdXJzb3I6IHBvaW50ZXI7IGJvcmRlcjogbm9uZTsgLXdlYmtpdC1mb250LXNtb290aGluZzogYW50aWFsaWFzZWQ7IGJhY2tncm91bmQtcG9zaXRpb246IDNweCA1MCU7IGJhY2tncm91bmQtcmVwZWF0OiBuby1yZXBlYXQgbm8tcmVwZWF0O1wiPlNhdmU8L3NwYW4+PHNwYW4gc3R5bGU9XCJib3JkZXItdG9wLWxlZnQtcmFkaXVzOiAycHg7IGJvcmRlci10b3AtcmlnaHQtcmFkaXVzOiAycHg7IGJvcmRlci1ib3R0b20tcmlnaHQtcmFkaXVzOiAycHg7IGJvcmRlci1ib3R0b20tbGVmdC1yYWRpdXM6IDJweDsgdGV4dC1pbmRlbnQ6IDIwcHg7IHdpZHRoOiBhdXRvOyBwYWRkaW5nOiAwcHggNHB4IDBweCAwcHg7IHRleHQtYWxpZ246IGNlbnRlcjsgZm9udC1zdHlsZTogbm9ybWFsOyBmb250LXZhcmlhbnQtY2Fwczogbm9ybWFsOyBmb250LXdlaWdodDogYm9sZDsgZm9udC1zdHJldGNoOiBub3JtYWw7IGZvbnQtc2l6ZTogMTFweDsgbGluZS1oZWlnaHQ6IDIwcHg7IGZvbnQtZmFtaWx5OiAnSGVsdmV0aWNhIE5ldWUnLCBIZWx2ZXRpY2EsIHNhbnMtc2VyaWY7IGNvbG9yOiAjZmZmZmZmOyBiYWNrZ3JvdW5kLWltYWdlOiB1cmwoZGF0YTppbWFnZS9zdmcreG1sOyBiYXNlNjQscGhuMnp5YjRid3h1Y3owaWFocjBjZG92bDNkM2R5NTNteTV2Y21jdm1qYXdtYzl6ZG1jaWlnaGxhd2RvZGQwaW16YndlY2lnZDJsa2RnZzlpam13Y2hnaWloenB6eGRjYjNnOWlpMHhpYzB4aWRteGlkbXhpajQ4eno0OGNnZjBhY2JrcHNqbm1qa3VuZHE1bGRlMGxqeTJtaWJkbWprdW5kcTVsZGl5bGpjeW1pYXltaTQ0bmpnc21qa3VtanUyaWRlMGxqYzFsZGk1bGppMW5pYmRuaTQybXppc21qa3VtanUyaWRhdW1kdXhsZGl5bGpjeW1pYXdsamExbXN3eG5jNDJuamlncXphdW1kdXhsZHl1bmpheGlkeXVuam15bGRhdW1keTNpZGUwbGpjMWxkYXVtZHkzaWVteW1pNDRuamdzbWM0d25qY2dtamt1bmRxNWxkeXVuamF4aWRpNWxqcTBvc3d4bmM0Mm5qaWlpZ3pwYmd3OWlpbm16bXlpaWhuMGNtOXJ6dDBpaTJ6bXppaWdjM3J5YjJ0bGx4ZHB6aHJvcHNpeGlqNDhsM2JoZGdnK3BoYmhkZ2dnemQwaXR0ZTBsamN6bXl3eGxqeTRuaWJkbnk0MW10eXNtczQyb2R5Z21zNDJuanVzbnk0MG90dWdtczQybmp1c210cXVuanl5aWVteGxqeTJuc3d5bWM0eG50a2duczR4bWRrc21qcXVvZHUwaWRrdW90Y3Ntanl1bnpxMGllbTVsamcxbml3eW5zNDNtdGdnb3M0M250bXNtanF1bXRxemlkZXdsamF4bml3eW15NHdtamlncXpld2xqaTFteXd5bWk0d21zYXhtczQxbmRnc210eXVudGN5aWRleGxqdTBvY3d4bmk0MW56aWdxemV4bGp1MG9jd3huaTQxbnppZ210ZXVtdHUzbGRlMWxqYzVuc2F4bXM0eG50Y3NtdHF1bmpxMmllbXhtczR4bnRjc210aXVvZHF5aWRleWxqaXhtc3d4bXM0MG90dWdtdG11bnRpeWxkZXhsanE1bnNiZG10cXVuam0zbGRleGxqcTVuc2F4bnM0eG56dXNtdGl1bXppMmlkZTFsamUzbnN3eG15NHptam1ncXplMWxqZTNuc3d4bmM0MG16eWdtdHF1bmR5eWxkZTJsamVnbXRxdW1ka3psZGUzbGp5MG15YmRtdG11bnpnMWxkZTRsamt6bnNheG5jNDNuZHVzbXRrdW90ZzRpZGUybGpheW9jd3hvczQ1b2RnZ3F6ZTRsam0xbXN3eG9zNDVvZGdnbWphdW10bTJsZGUzbGp1MW5pYXltYzR4bXp5c210cXVtZHEyaWVteW1jNHhtenlzbXRhdW90bTVpZGUzbGpnNG9jdzRsamMybnlheG5jNDJuemdzb2M0M25qY2dxemV3bGprMW9zdzRsamMybnlhNGxqYzNueXd4bXM0MW16eWdvYzQzbnpjc210cXVtems0aWVtNGxqYzNueXd4bnM0MW10bWdvczR5bXN3eG5pNDNtZGtnb3M0M25ka3NtdGN1bXp1NWllbTVsamcxbml3eG55NDBvZGdnb3M0NG56aXNtdGN1bmlhNWxqZzBsZGUzbGpjem1zYmRvczQzbmRlc210Z3VtdHF4aWRrdW50aXNtdGt1bWRpemlka3VuZGMzbGRlNWxqaXdteWJkb3M0MG1pd3hvczQwbmNhNWxqaTRvY3d4b3M0MG90ZWdvczR3bmN3eG9zNHpuenlncXpjdW5kYTRsZGU0bGp5eW1pYTJsam00bnl3eG5pNHludGlnbmk0em9kY3NtdHF1bXpxNWllbTJsam00bnl3eG1jNHludHlnb3M0em9kbXNuaTQwb3RjZ210dXVtZGl5bGR5dW5kazNpZW14b3M0MW50dXNuaTQwb3RjZ21qbXVtZGM0bGRrdW56YTFpZGl6bGphM29jd3hteTQ1b3RlZ3F6aXpsamEzb2N3eG9jNDBuam1nbWphdW1qbTVsZGl5bGphMm1pYXhuaTR5b3Rjc21qaXVtZHl5aWVteG5jNDVuem1zbWppdW1keXlpZGV6bGpjeW9jd3ltczR6bnprZ210bXVtemF5bGRpd2xqdTNtaWJkbXRtdW16YXlsZGl3bGp1M21pYXhtaTQybmRjc21qbXVtZHVnbXRpdW5kZzRsZGl6bGp5MW55YmRtdGl1bXRremxkaTBsamM0bmNheG1zNHpvdHlzbWp5dW10azJpZGV3bGpnMm15d3lueTR3bnRnZ3F6ZXlsamE0bml3eW55NDBtenFnbXRtdW16ZzJsZGkzbGp5em55YXhuYzQzbXptc21qY3Vuam0zaWVteW1zNDVuc3d5bnk0Mm16Y2dtamN1b2RheGxkaXhsamd5b2NheW55NDRtZGVzbXRxdW5qeXlpZW15bnk0NG1kZXNueTQwb3R1Z21qZXVvdHVzbXM0Mm9keWdtdHF1bnptemxkZXVuamcyaWlibWF3eHNwc2lqeW1xd29kZmppajQ4bDNiaGRnZytwYzlucGp3dmMzem5wZz09KTsgYmFja2dyb3VuZC1zaXplOiAxNHB4IDE0cHg7IGJhY2tncm91bmQtY29sb3I6ICNiZDA4MWM7IHBvc2l0aW9uOiBhYnNvbHV0ZTsgb3BhY2l0eTogMTsgei1pbmRleDogODY3NTMwOTsgZGlzcGxheTogbm9uZTsgY3Vyc29yOiBwb2ludGVyOyBib3JkZXI6IG5vbmU7IC13ZWJraXQtZm9udC1zbW9vdGhpbmc6IGFudGlhbGlhc2VkOyBiYWNrZ3JvdW5kLXBvc2l0aW9uOiAzcHggNTAlOyBiYWNrZ3JvdW5kLXJlcGVhdDogbm8tcmVwZWF0IG5vLXJlcGVhdDtcIj5TYXZlPC9zcGFuPlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dWy92Y19yb3ddIiwicG9zdF90aXRsZSI6IkdBTUkgQnJpZWZpbmcgIzQ6IE1lZGlhIExhYnMgc2Vzc2lvbiAoMTcuMDIuMjIpIiwicG9zdF9saW5rIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL2dhbWktYnJpZWZpbmctNC1tZWRpYS1sYWJzLXNlc3Npb24tMTctMDItMjIvIiwicG9zdF9mZWF0dXJlZF9pbWFnZSI6IjxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiR0FNSSBCcmllZmluZyAjNDogTWVkaWEgTGFicyBzZXNzaW9uICgxNy4wMi4yMilcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjExMFwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIyLzAzL0NhcHR1cmUtZGVcdTAzMDFjcmFuLTIwMjItMDMtMTQtYVx1MDMwMC0xMS4zMS4xNi0zMDB4MTEwLnBuZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6Ik1lZGlhIGxhYnMiLCJwb3N0X3RhZ3MiOiIiLCIlX2VkaXRfbG9jayUiOiIxNjc5OTM0ODc3OjQiLCIlX2VkaXRfbGFzdCUiOiI0IiwiJV95b2FzdF93cHNlb19wcmltYXJ5X2NhdGVnb3J5JSI6IjE0MiIsIiVfdGh1bWJuYWlsX2lkJSI6IjE1NzE3IiwiJXNsaWRlX3RlbXBsYXRlJSI6ImRlZmF1bHQiLCIlX3dwYl92Y19qc19zdGF0dXMlIjoidHJ1ZSIsIiVfd3BnbXBfbG9jYXRpb25fYWRkcmVzcyUiOiJQYXJpcywgRnJhbmNlIiwiJV93cGdtcF9sb2NhdGlvbl9jaXR5JSI6IlBhcmlzIiwiJV93cGdtcF9sb2NhdGlvbl9zdGF0ZSUiOiJcdTAwY2VsZS1kZS1GcmFuY2UiLCIlX3dwZ21wX2xvY2F0aW9uX2NvdW50cnklIjoiRnJhbmNlIiwiJV93cGdtcF9tZXRhYm94X2xhdGl0dWRlJSI6IjQ4Ljg1NjYxNCIsIiVfd3BnbXBfbWV0YWJveF9sb25naXR1ZGUlIjoiMi4zNTIyMjE5IiwiJV93cGdtcF9tZXRhYm94X2xvY2F0aW9uX3JlZGlyZWN0JSI6InBvc3QiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiMlwiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6Ik47IiwiJV93cGdtcF9tZXRhYm94X3RheG9tb21pZXNfdGVybXMlIjoiTjsiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6Ik47IiwiJV95b2FzdF93cHNlb19jb250ZW50X3Njb3JlJSI6IjMwIiwiJV95b2FzdF93cHNlb19lc3RpbWF0ZWQtcmVhZGluZy10aW1lLW1pbnV0ZXMlIjoiMTEiLCJ0YXhvbm9teT1jYXRlZ29yeSI6Ik1lZGlhIGxhYnMiLCJ0YXhvbm9teT1wb3N0X3RhZyI6IiJ9LCJpY29uIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTgvMDIvbWFya2VyLTEucG5nIn0sImlkIjoxNTcxMSwiaW5mb3dpbmRvd19kaXNhYmxlIjpmYWxzZX0seyJzb3VyY2UiOiJwb3N0IiwidGl0bGUiOiJGQVNUbGFiOiBGdXR1cmUgQXJ0cywgU2NpZW5jZSBhbmQgVGVjaG5vbG9neSBMYWJvcmF0b3J5IiwiaW5mb3dpbmRvd19jb250ZW50IjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZ1wiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJGQVNUbGFiOiBGdXR1cmUgQXJ0cywgU2NpZW5jZSBhbmQgVGVjaG5vbG9neSBMYWJvcmF0b3J5XCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMjRcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAyMi8wMi9GYXN0TGFiLU96LTMwMHgyMjQuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZ1wiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tcGFkZGluZy1jb250ZW50XzIwXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tbWV0YSBmYy1pdGVtLXNlY29uZGFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlIGZjLXRleHQtY2VudGVyXCI+TWVkaWEgbGFiczwvZGl2PlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLXRleHQtY2VudGVyXCI+RkFTVGxhYjogRnV0dXJlIEFydHMsIFNjaWVuY2UgYW5kIFRlY2hub2xvZ3kgTGFib3JhdG9yeTwvZGl2PlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2VcIj5cclxuICAgICAgICAgICAgXHJcbiAgICAgICAgPC9kaXY+XHJcbjxhIGhyZWY9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvZmFzdGxhYi1mdXR1cmUtYXJ0cy1zY2llbmNlLWFuZC10ZWNobm9sb2d5LWxhYm9yYXRvcnkvXCI+UmVhZCBtb3JlPC9hPlxyXG4gICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuPC9kaXY+XHJcblxyXG4iLCJhZGRyZXNzIjoiTmV3Y2FzdGxlIE5TVywgQXVzdHJhbGlhIiwibG9jYXRpb24iOnsibGF0IjoiLTMyLjkyODI3MTIiLCJjaXR5IjoiTmV3Y2FzdGxlIiwic3RhdGUiOiJOZXcgU291dGggV2FsZXMiLCJjb3VudHJ5IjoiQXVzdHJhbGlhIiwibG5nIjoiMTUxLjc4MTY4MDIiLCJvbmNsaWNrX2FjdGlvbiI6Im1hcmtlciIsInJlZGlyZWN0X3Blcm1hbGluayI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9mYXN0bGFiLWZ1dHVyZS1hcnRzLXNjaWVuY2UtYW5kLXRlY2hub2xvZ3ktbGFib3JhdG9yeS8iLCJ6b29tIjoyLCJleHRyYV9maWVsZHMiOnsicG9zdF9leGNlcnB0IjoiIiwicG9zdF9jb250ZW50IjoiW3ZjX3Jvd11bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjIvM1wiXVt2Y19jb2x1bW5fdGV4dF08ZW0+T3VyIGxhdGVzdCBtZWRpYSBsYWIgcGllY2UgY29tZXMgZnJvbSBQcm9mZXNzb3IgUGF1bCBFZ2dsZXN0b25lLCBIZWFkIG9mIFNjaG9vbCBvZiB0aGUgQ3JlYXRpdmUgSW5kdXN0cmllcyBpbiB0aGUgQ29sbGVnZSBvZiBIdW1hbiBhbmQgU29jaWFsIEZ1dHVyZXMgYXQgdGhlIFVuaXZlcnNpdHkgb2YgTmV3Y2FzdGxlLCBBdXN0cmFsaWEuIEVnZ2xlc3RvbmUgaXMgYSBmb3VuZGluZyBtZW1iZXIgb2YgdGhlIEdsb2JhbCBBbGxpYW5jZSBmb3IgTWVkaWEgSW5ub3ZhdGlvbiBhbmQgZm9ybWVybHkgZm91bmRlciBvZiB0aGUgTWVkaWEgSW5ub3ZhdGlvbiBTdHVkaW8gYXQgdGhlIFVuaXZlcnNpdHkgb2YgQ2VudHJhbCBMYW5jYXNoaXJlLiBIZXJlLCBoZSBkZXNjcmliZXMgRkFTVGxhYjogYSBuZXcgaHViIGZvciBjcmVhdGl2ZSBhbmQgdHJhbnNkaXNjaXBsaW5hcnkgaW5ub3ZhdGlvbiBhbmQgY3JlYXRpb24uIEVnZ2xlc3RvbmUgb3V0bGluZXMgaXRzIGFpbXMsIHdvcmsgYW5kIGZ1dHVyZSBpbXBhY3QsIGFuZCBzaGFyZXMgdGhvdWdodHMgYXJvdW5kIGhvdyB0aGUgbmV3cyBtZWRpYSBjb3VsZCBiZW5lZml0IGZyb20gY29sbGFib3JhdGl2ZSBhbmQgY29tbXVuaXR5LWJhc2VkIGFwcHJvYWNoZXMgdG8gcmVhbCB3b3JsZCBjaGFsbGVuZ2VzIHRoZXkgZmFjZSwgYW5kIGNyZWF0ZSBzdXN0YWluYWJsZSBhbmQgdGhyaXZpbmcgb3BlcmF0aW9ucyBpbiB0aGUgZnV0dXJlLi4uPC9lbT5cclxuXHJcbiZuYnNwO1xyXG48aDE+PHN0cm9uZz5JbWFnaW5pbmcgYmV0dGVyOlx1MDBhMCA8L3N0cm9uZz48c3Ryb25nPkZ1dHVyZSBBcnRzLCBTY2llbmNlIGFuZCBUZWNobm9sb2d5IGxhYm9yYXRvcnkgPC9zdHJvbmc+PC9oMT5cclxuVGhlIEZ1dHVyZSBBcnRzLCBTY2llbmNlIGFuZCBUZWNobm9sb2d5IExhYm9yYXRvcnkgLSBGQVNUbGFiIC0gaXMgaG9tZSB0byBncmVhdCBpZGVhcyBpbnNwaXJlZCBieSBicmluZ2luZyB0b2dldGhlciB0aGUgYnJpZ2h0ZXN0IHBlb3BsZSB0byBmaWd1cmUgb3V0IGhvdyB0byBtYWtlIHRoaW5ncyBiZXR0ZXIuIFdlIGtub3cgdGhhdCBpbWFnaW5hdGlvbiBpcyB0aGUgZm91bmRhdGlvbiBvZiBjcmVhdGl2aXR5IGFuZCBpbm5vdmF0aW9uLiBXZSBjZWxlYnJhdGUgdGhlIHVuaXF1ZSBxdWFsaXR5IG9mIG91ciBodW1hbml0eSB0aHJvdWdoIG91ciBjcmVhdGl2ZSBhYmlsaXR5IHRvIGltYWdpbmUgdGhpbmdzIHRoYXQgZG9uXHUyMDE5dCBleGlzdCB5ZXQgYW5kIG91ciBjYXBhYmlsaXRpZXMgdG8gdHVybiB3aGF0IHdlXHUyMDE5dmUgaW1hZ2luZWQgaW50byBzb21ldGhpbmcgcmVhbC4gU29tZXRoaW5nIGJldHRlci5cclxuXHJcbldlIGFyZSBhbGl2ZSBpbiBhIHRpbWUgd2hlbiB0aGUgd29ybGQgYXMgd2Uga25ldyBpdCwgdG9nZXRoZXIgd2l0aCBvdXIgZmFpdGggaW4gdGhlIGZ1dHVyZSwgaXMgZGlzYXBwZWFyaW5nLiBOZXcgdW5jZXJ0YWludGllcyBmb3IgaW5kaXZpZHVhbHMsIHNvY2lldHkgYW5kIHRoZSBwbGFuZXQgYXJlIG5vdyBoYWxsbWFya3Mgb2YgdGhlIHNvLWNhbGxlZCBBbnRocm9wb2NlbmUgLSB0aGUgXHUyMDE4TmV3IE5vcm1hbFx1MjAxOS4gSWYgd2UgYXJlIHRvIGF0dGFpbiBzdXN0YWluYWJsZSBlY29ub21pYyBncm93dGggYWxvbmdzaWRlIGJhbGFuY2VkIHNvY2lhbCBhbmQgZW52aXJvbm1lbnRhbCBkZXZlbG9wbWVudCwgd2UgbmVlZCB0byByYWRpY2FsbHkgcmV0aGluayBob3cgYnVzaW5lc3NlcywgZ292ZXJubWVudCBhbmQgTkdPcyBjYW4gY3JlYXRlIHZhbHVlIHRocm91Z2ggY3JlYXRpdml0eSBhbmQgaW5ub3ZhdGlvbi4gQ3JlYXRpdml0eSB0aGF0IGlzXHUwMGEwcm9vdGVkIGluIHN1c3RhaW5hYmxlIHNvY2lhbCwgZWNvbm9taWMsIGVudmlyb25tZW50YWwsIGFuZCBjdWx0dXJhbCBwcmFjdGljZXMuXHJcbjxoMj5PcGVuIHRvIGNvbGxhYm9yYXRpb24gd2l0aCBtZWRpYS4uLjwvaDI+XHJcblRoaXMgaXMgcG90ZW50aWFsbHkgZnVydGl2ZSBncm91bmQgZm9yIG5ld3MgbWVkaWEgb3JnYW5pc2F0aW9ucyB0cmFkaXRpb25hbGx5IGNoYXJnZWQgd2l0aCBob2xkaW5nIHRob3NlIGluIHBvd2VyIHRvIGFjY291bnQgYW5kIHByb3ZpZGluZyB1cyB3aXRoIHRoZSBpbmZvcm1hdGlvbiBuZWVkZWQgdG8gbWFrZSBpbmZvcm1lZCBkZWNpc2lvbnMuIEl0IHByb3ZpZGVzIGFuIG9wcG9ydHVuaXR5IGZvciBhIGpvdXJuYWxpc20gdGhhdCByZWNvZ25pc2VzIGl0cyBvd24gZXhpc3RlbnRpYWwgY3Jpc2VzIGFuZCBjYW5ub3QgYmUgc2VwYXJhdGVkIGZyb20gdGhlIG5lZWQgdG8gY3JlYXRlIGEgc3VzdGFpbmFibGUgc29jaWV0eSwgZWNvbG9naWNhbGx5LCBlY29ub21pY2FsbHksIGFuZCBzb2NpYWxseS4gSXQgY2FsbHMgZm9yIGEgam91cm5hbGlzbSB0aGF0IHVuZGVyc3RhbmRzIGFuZCBhY2NlcHRzIGl0cyBcdTIwMThzb2NpYWwgbGljZW5jZVx1MjAxOSBcdTIwMTMgdGhhdCBpbXBsaWNpdCBiYXNpYyBwZXJtaXNzaW9uIHNvY2lldHkgZ2l2ZXMgdG8gYW55IGNvcnBvcmF0ZSBvcmdhbmlzYXRpb24gdG8gY29uZHVjdCBpdHMgYWN0aXZpdGllcyBcdTIwMTMgd2lsbCBiZSBpbmNyZWFzaW5nbHkgdGhyZWF0ZW5lZCBpZiBpdCBmYWlscyB0byBhZGVxdWF0ZWx5IGFkZHJlc3MgdGhlIHN1c3RhaW5hYmlsaXR5IGNoYWxsZW5nZXMgZmFjaW5nIGh1bWFuaXR5LlxyXG5cclxuV2hpbHN0IHRoaXMgaXMgY2hhbGxlbmdpbmcgZm9yIHRyYWRpdGlvbmFsIGpvdXJuYWxpc20gcm9vdGVkIGluIHRoZSBuZXdzIHZhbHVlcyBvZiBwcm94aW1pdHksIGltbWVkaWFjeSwgbmVnYXRpdml0eSwgYW5kIHNlbnNhdGlvbmFsaXNtLCBGQVNUTGFiIGlzIGNvbW1pdHRlZCB0byB3b3JraW5nIHdpdGggbWVkaWEgY29tcGFuaWVzIGluIEF1c3RyYWxpYSBhbmQgaW50ZXJuYXRpb25hbGx5IHRvIGV4cGFuZCBpdHMgcm9sZSBhbmQgaW4gZG9pbmcgc28gaXRzIHBvdGVudGlhbCByZWxldmFuY2UgaW4gc29jaWV0eSBieSBoZWxwaW5nIG5ld3Mgb3JnYW5pc2F0aW9ucyByZWltYWdpbmUgaG93IHRoZXkgbWlnaHQgYWN0aXZlbHkgY29udHJpYnV0ZSB0byB0aGUgc3VzdGFpbmFibGUgdHJhbnNmb3JtYXRpb24gb2Ygc29jaWV0eS4gV2Uga25vdyB0aGlzIGlzIHBvc3NpYmxlIHdpdGhvdXQgY29tcHJvbWlzaW5nIGNvbW1pdG1lbnQgdG8gdGhlIHB1cnN1aXQgb2YgdHJ1dGggd2hpbHN0IG9mZmVyaW5nIG1lZGlhIGNvbXBhbmllcyBhIGNoYW5jZSB0byByZW5ldyBpdHMgc29jaWFsIGxpY2VuY2Ugd2l0aCB0aGUgcHVibGljLlxyXG48aDI+YnV0IG5vdCBvbmx5Li4uPC9oMj5cclxuRkFTVGxhYiB3YXMgY3JlYXRlZCB0byBleHBsb3JlIHRoZSBwb3RlbnRpYWwgb2YgaHVtYW4gZW1vdGlvbiwgaGFwcGluZXNzIGFuZCBwbGF5LCBvcGVuIGRvb3JzIGZvciBub24tdHJhZGl0aW9uYWwgY29sbGFib3JhdG9ycywgYW5kIGNvbW1lcmNpYWxpc2UgbGF0ZXJhbCB0aGlua2luZy5cdTAwYTAgVW5pcXVlIGluIEF1c3RyYWxpYSwgd2UgYXJlIGEgdHJhbnNsYXRpb25hbCByZXNlYXJjaCBodWIsIHNwZWNpYWxpc2luZyBpbiBwcm92aWRpbmcgb3Bwb3J0dW5pdGllcyBmb3IgY29tbXVuaXR5IGFuZCBpbmR1c3RyeSBwYXJ0bmVycyB0byBwYXJ0aWNpcGF0ZSBpbiByZXNlYXJjaCBwcm9qZWN0cyB0aGF0IHByb3ZpZGUgdGFuZ2libGUgb3V0Y29tZXMgYW5kIHNvbHV0aW9ucyB0byByZWFsLXdvcmxkIHByb2JsZW1zIHF1aWNrbHkuXHJcblxyXG5PdXIgd29yayBzbyBmYXIgZGVtb25zdHJhdGVzIHRoYXQgYWxsIG9yZ2FuaXNhdGlvbnMgLSBzb2NpYWwgZW50ZXJwcmlzZXMsIGZvciBwcm9maXQgYnVzaW5lc3NlcyBvciBnb3Zlcm5tZW50IGRlcGFydG1lbnRzIC0gY2FuIGJlbmVmaXQgZnJvbSBGQVNUTGFiXHUyMDE5cyB1bmlxdWUgZXRob3MuXHJcblxyXG5PdXIgcmVzZWFyY2ggYnJpbmdzIHRvZ2V0aGVyIGFjYWRlbWljcywgcHJhY3RpdGlvbmVycyBhbmQgaW5kdXN0cnkgcGFydG5lcnMgZnJvbSBhIHJhbmdlIG9mIGRpZmZlcmVudCBmaWVsZHMuIFdlIHdvcmsgam9pbnRseSB0byBkZXZlbG9wIGFuZCB1c2Ugbm92ZWwgY29uY2VwdHVhbCBhbmQgbWV0aG9kb2xvZ2ljYWwgYXBwcm9hY2hlcyB0aGF0IGxldmVyYWdlIGRpc2NpcGxpbmUtc3BlY2lmaWMgcGVyc3BlY3RpdmVzLCB0aGVvcmllcywgbWV0aG9kcywgYW5kIHRyYW5zbGF0aW9uYWwgc3RyYXRlZ2llcyB0aGF0IGRlbGl2ZXIgaW5ub3ZhdGl2ZSByZXNwb25zZXMgdG8gcmVhbCB3b3JsZCBwcm9ibGVtcy5cclxuXHJcbjxpbWcgY2xhc3M9XCIgd3AtaW1hZ2UtMTU3MDEgYWxpZ25jZW50ZXJcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAyMi8wMi9GYXN0TGFiLU96LTMwMHgyMjQuanBnXCIgYWx0PVwiXCIgd2lkdGg9XCIzNjBcIiBoZWlnaHQ9XCIyNjlcIiAvPlxyXG5cclxuV2UgZG8gdGhpcyBmcm9tIG91ciBob21lIGluIFx1MjAxOFFcdTIwMTkgYnVpbGRpbmcgb24gdGhlIHF1YXlzaWRlIG9mIE5ld2Nhc3RsZVx1MjAxOXMgSG9uZXlzdWNrbGUgRHJpdmUuIEJ1aWx0IHVzaW5nXHUwMGEwc3VzdGFpbmFibHlcdTAwYTBzb3VyY2VkLCBjcm9zcy1sYW1pbmF0ZWRcdTAwYTB0aW1iZXIsIHRoZSBmYWNpbGl0eSBpcyBlbmNhc2VkIGluIDM0NCBTYWdlIHRoZXJtYWwgZ2xhc3MgcGFuZWxzIFx1MjAxMyB0aGUgbGFyZ2VzdCBpbnN0YWxsYXRpb24gb2YgdGhpcyBoaWdobHkgdGVjaG5pY2FsIGFuZCBlbnZpcm9ubWVudGFsbHkgZnJpZW5kbHkgbWF0ZXJpYWwgaW4gdGhlIHNvdXRoZXJuIGhlbWlzcGhlcmUuIEl0cyBvcGVuIHN0cnVjdHVyZSBlbmFibGVzIGEgZmx1aWQgZXhjaGFuZ2Ugb2YgaWRlYXMgYWNyb3NzIGEgcG9yb3VzIHNwYWNlLiBJbnRlcmFjdGl2ZSBkaXNwbGF5cyBhbmQgbW9uaXRvcnMgZG90dGVkIHRocm91Z2hvdXQgZW5hYmxlIEZBU1RMYWIgdG8gZXhwYW5kIGNvbGxhYm9yYXRpb24gYmV5b25kIGl0cyBnbGFzcyBzaGVsbCB0byB2aXNpdG9ycywgY29sbGVhZ3VlcywgYW5kIHRoZSB3aWRlciBjb21tdW5pdHkuIEl0XHUyMDE5cyBhIHNwYWNlIHRoYXQgZW1ib2RpZXMgb3VyIHZpc2lvbiBvZiBob3cgdG8gZG8gXHUyMDE4UiZhbXA7RFx1MjAxOSB3aXRob3V0IHRoZSB1c3VhbCBwaHlzaWNhbCBib3VuZGFyaWVzIGFuZCB3aXRoIGJyaWxsaWFudCBmYWNpbGl0aWVzIHRvIHdvcmtzaG9wLCBpbnZlbnQsIGNyZWF0ZSBhbmQgbWFrZS5cclxuXHJcbldlIGhhdmUgYmVlbiBidWlsZGluZyBhIHZpYnJhbnQgY3VsdHVyZSBvZiBcdTIwMThsZWFybmluZyBieSBkb2luZ1x1MjAxOSBjcmVhdGluZyBzZXZlcmFsIHBhdGh3YXlzIGZvciBvcmdhbmlzYXRpb25zLCByZXNlYXJjaGVycyBhbmQgY3JlYXRpdmVzIHRvIGVuZ2FnZSB3aXRoIHVzIGFuZCBlYWNoIG90aGVyLiBXb3JraW5nIHdpdGggZXh0ZXJuYWwgcmVzZWFyY2ggcGFydG5lcnMgdXNpbmcgb3VyIG93biBibGVuZGVkIGxlYXJuaW5nIG1vZGVsIHdlXHUyMDE5dmUgZGV2ZWxvcGVkIGEgbG93LWNvc3Qgc2VyaWVzIG9mIGNvbmNlbnRyYXRlZCBsZWFybmluZyBldmVudHMgdGhhdCBlbmFibGUgc3R1ZGVudHMgYW5kIHJlc2VhcmNoZXJzIHRvIHNlZSB0aGUgcG9zaXRpdmUgaW1wYWN0IHRoYXQgdGhleSBhcmUgbWFraW5nIHRocm91Z2ggcmVzZWFyY2ggYW5kIGRldmVsb3BtZW50LiBPdXIgYXBwcm9hY2ggZW5zdXJlcyB0aGV5IGFyZSBwYXJ0IG9mIGEgcHJvY2VzcyBvZiBjaGFuZ2UgYXMgd2VsbCBhcyBkZXZlbG9waW5nIHRoZWlyIGxlYXJuaW5nIGFuZCBleHBlcmllbmNlLlxyXG5cclxuPGltZyBjbGFzcz1cIiB3cC1pbWFnZS0xNTcwMiBhbGlnbmNlbnRlclwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIyLzAyL0ZMLU96LTItMzAweDE2OS5qcGdcIiBhbHQ9XCJcIiB3aWR0aD1cIjM1N1wiIGhlaWdodD1cIjIwMVwiIC8+XHJcblxyXG5EZWxpdmVyaW5nIGNoYW5nZSBuZWVkcyBza2lsbHMgaW4gZW1wYXRoeS4gT3VyIHJlc2VhcmNoZXJzIGFuZCBvdXIgc3R1ZGVudHMgZGV2ZWxvcCB0aGVpciBhYmlsaXRpZXMgdG8gd29yayBhY3Jvc3Mgc2VjdG9ycyBhbmQgY3VsdHVyZXMgYnJpbmdpbmcgZGlmZmVyZW50IHBlcnNwZWN0aXZlcyBhcyB0aGV5IGJ1aWxkIHJlbGF0aW9uc2hpcHMgYW5kIHBsYW4gd29ya3Nob3AgaW50ZXJhY3Rpb25zIHRoYXQgc3VwcG9ydCBjaGFuZ2UuIFdlIHVuZGVyc3RhbmQgdGhlIG5lZWQgdG8gaW5jbHVkZSBjb21tdW5pdGllcywgc3Rha2Vob2xkZXJzIGFuZCB3aWRlciBhdWRpZW5jZXMgaW4gY2hhbmdlIHVzaW5nIGNyZWF0aXZlIGNvbW11bmljYXRpb24gc2tpbGxzIHRvIGVuZ2FnZSBhbmQgaW5mbHVlbmNlIHRoZW0gaW4gdGhlIHByb2Nlc3MuXHJcblxyXG5UaGUgQ2x5ZGUgU3RyZWV0IFByZWNpbmN0IG9mZmVycyBhIGdyb3VuZGVkIGV4YW1wbGUgb2YgaG93IHdlIGFyZSBoZWxwaW5nIHRvIG1ha2UgdGhpcyBoYXBwZW4gbG9jYWxseSBieSBhZG9wdGluZyBhIFx1MjAxOGJvdHRvbS11cFx1MjAxOSBhcHByb2FjaCB0byB0aGUgZGV2ZWxvcG1lbnQgb2YgYSBjcmVhdGl2ZSBlY29zeXN0ZW0gd2l0aGluIHdoaWNoIGFydGlzdHMgbWFpbnRhaW4gYSB0aHJpdmluZywgc3VzdGFpbmFibGUgcHJhY3RpY2UsIGFuZCBjaXRpemVucyBhcmUgaW1icmljYXRlZCBhcyBjby1jcmVhdG9ycyBvZiBjb21tdW5pdHkgZmFjaWxpdGllcyBhbmQgbGl2ZWFibGUgY2l0eSBsYW5kc2NhcGVzLiBUaGUgQ2x5ZGUgU3RyZWV0IFByZWNpbmN0IGlzIGEgbGFyZ2UgaW5kdXN0cmlhbCB3YXJlaG91c2UgY29tcGxleCBjbG9zZSB0byB0aGUgVW5pdmVyc2l0eSBvZiBOZXdjYXN0bGVcdTIwMTlzIENpdHkgYW5kIENhbGxhZ2hhbiBjYW1wdXNlcy4gVGhlIHByZXZpb3VzbHkgYWJhbmRvbmVkIHNpdGUgbm93IGFjY29tbW9kYXRlcyA2NSBhcnRpc3RzIGFuZCBjcmVhdGl2ZSBwcmFjdGl0aW9uZXJzIGRyYXduIGZyb20gYWNyb3NzIHRoZSBicm9hZCByYW5nZSBvZiBjcmVhdGl2ZSBpbmR1c3RyaWVzLCBzdWNoIGFzIGpld2VsbGVyeSBhbmQgZmFzaGlvbiBkZXNpZ24sIG11c2ljIHJlY29yZGluZyBhbmQgcHJvZHVjdGlvbiwgZmFicmljYXRpb24sIG11bHRpLW1lZGlhLCBwZXJmb3JtaW5nIGFuZCB2aXN1YWwgYXJ0cywgZGVzaWduIGFuZCBpbGx1c3RyYXRpb24sIGxlYWQgbGlnaHRpbmcsIGJvb2tiaW5kaW5nLCBzdG9uZSBtYXNvbnJ5LCBmaWxtLCB0ZWNobm9sb2d5IGFuZCBleHBlcmltZW50YWwgZWxlY3Ryb25pYyBhcnQuIFRoZSBvcmdhbmljIGRldmVsb3BtZW50IG9mIHRoaXMgZWNvc3lzdGVtLCB3aXRoIGFydGlzdHMgd29ya2luZyBhbG9uZ3NpZGUgd2FzdGUgcmVzY3VlIG5vdC1mb3ItcHJvZml0IG9yZ2FuaXNhdGlvbnMgYW5kIGNhciBoaXJlIGJ1c2luZXNzZXMsIGhhcyBlbnN1cmVkIGFuIGlubm92YXRpdmUgYW5kIHN1c3RhaW5hYmxlIGV4YW1wbGUgb2YgYSBcdTIwMThjcmVhdGl2ZSBlY29ub215XHUyMDE5LiBXaGlsZSB0aGUgY3VsdHVyYWwgYW5kIGdlb3BvbGl0aWNhbCBjb250ZXh0IG9mIGlzIGxvY2FsaXNlZCB0byBGQVNUTGFiXHUyMDE5cyBBdXN0cmFsaWFuIGhvbWUgY2l0eSBvZiBOZXdjYXN0bGUsIHRoaXMgYXJlYVx1MjAxOXMgZXZvbHV0aW9uIGZyb20gYSBjb2FsLXBvcnQgdG93YXJkcyBhIGNvc21vcG9saXRhbiBjaXR5IGlzIHBhcnQgb2YgYSBicm9hZGVyIHRyZW5kIG9mIGluZHVzdHJpYWwgdG93bnMgbmF2aWdhdGluZyB0aGVpciBvd24gcHJvZ3Jlc3Npb24gdG93YXJkcyB0aHJpdmluZywgbGl2ZWFibGUgY2l0aWVzLlxyXG5cclxuJm5ic3A7XHJcblxyXG48c3Ryb25nPjxpbWcgY2xhc3M9XCIgd3AtaW1hZ2UtMTU3MDMgYWxpZ25jZW50ZXJcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAyMi8wMi9GTC1PejMtMzAweDIyNS5qcGdcIiBhbHQ9XCJcIiB3aWR0aD1cIjQwNVwiIGhlaWdodD1cIjMwNFwiIC8+PC9zdHJvbmc+XHJcblxyXG4mbmJzcDtcclxuPGgyPlBhcnRuZXJpbmcgaW4gcmVzZWFyY2ggd2l0aCByZWFsLXdvcmxkIGltcGFjdDo8L2gyPlxyXG5JbiBhIHBvc3QtaW5kdXN0cmlhbCBlcmEsIGNvbXBldGl0aW9uIGlzIG5vdCBqdXN0IGFib3V0IHRoZSBwdXJzdWl0IG9mIGVmZmljaWVuY3kuIEF0dGFpbmluZyBzdXN0YWluYWJsZSBlY29ub21pYyBncm93dGggYW5kIGJhbGFuY2VkIHNvY2lhbCBhbmQgZW52aXJvbm1lbnRhbCBkZXZlbG9wbWVudCBuZWVkcyBhIHBhcmFkaWdtIHNoaWZ0IG9uIGhvdyBidXNpbmVzc2VzLCBnb3Zlcm5tZW50IGFuZCBOR09zIGNhbiBjcmVhdGUgdmFsdWUgdGhyb3VnaCBjcmVhdGl2aXR5IGFuZCBpbm5vdmF0aW9uLiBUaGlzIGxldmVsIG9mIGlubm92YXRpb24gaW52b2x2ZXMgYnJlYWtpbmcgZnJlZSBmcm9tIGNvbnZlbnRpb25hbCB0aGlua2luZyBhYm91dCB3aGF0IGtpbmQgb2YgcmVzZWFyY2hlcnMgc2hvdWxkIGJlIGludm9sdmVkIGluIHByb2JsZW0gc29sdmluZyBwYXJ0aWN1bGFyIGlzc3Vlcy5cclxuXHJcbkZBU1RMYWIgaXMgY29tbWl0dGVkIHRvIHJlc2VhcmNoIHRoYXQgZGVsaXZlcnMgcmVhbCB3b3JsZCBpbXBhY3QuIFdlIHdvcmsgd2l0aCBjb21wYW5pZXMgYW5kIG9yZ2FuaXNhdGlvbnMgb24gbGl2ZSBwcm9qZWN0IGJyaWVmcyBkZXZlbG9wZWQgdG8gYWRkcmVzcyBhIGJ1c2luZXNzIG5lZWQuIE9mIGNvdXJzZSwgZXZlcnkgc2VjdG9yIGhhcmJvdXJzIHRoZSBwcmV0ZW5jZSB0aGF0IGl0cyBwcmFjdGljZSBpcyBzb21laG93IFx1MjAxOHNwZWNpYWxcdTIwMTk7IGl0cyBpbmR1c3RyeSB1bmlxdWU7IHRoZSBjaGFsbGVuZ2VzIGl0IGZhY2VzIHNwZWNpZmljIGFuZCBwYXJ0aWN1bGFyIHRvIHRoZW0uIEluIHRoYXQgc2Vuc2UgdGhlIG1lZGlhIGluZHVzdHJ5IGlzIG5vIGRpZmZlcmVudCBhcnJpdmluZyB3aXRoIHRoZSBzYW1lIHByZWNvbmNlcHRpb25zIGNvbW1vbiBhY3Jvc3MgYWxsIGJ1c2luZXNzZXMuIE1vc3QgYXJlIG5vdCBleHBlY3RpbmcgcmVzZWFyY2hlcnMgdG8gY3JlYXRlIHByb3RvdHlwZSBtZWRpYSBwcm9kdWN0cyBtb2RlbGxpbmcgYW5kIG1lYXN1cmluZyBodW1hbiByZXNwb25zZXMgdG8gdGhlbTsgdGhleSBhcmUgdW5wcmVwYXJlZCBmb3IgdGhlIGNyZWF0aXZlIGluZHVzdHJpZXMgc3R1ZGVudCB0ZWFtcyBjaGFyZ2VkIHdpdGggcXVpY2tseSBhc3Nlc3NpbmcgdGhlIHZpYWJpbGl0eSBvZiBhIHByb3Bvc2VkIHByb2plY3Q7IHRoZXlcdTIwMTlyZSBub3QgcmVhZHkgdG8gcmVjZWl2ZSB0aGUgaW5zaWdodHMgZnJvbSBkaWdpdGFsIG5hdGl2ZXMgY3JpdGlxdWluZyB0aGVpciBjdXJyZW50IG9mZmVyaW5ncy4gQW5kIHRoZXkgYXJlIGNlcnRhaW5seSBub3QgdGhpbmtpbmcgdGhleSBtaWdodCBiZW5lZml0IGZyb20gd29ya2luZyBkaXJlY3RseSBpbiBwYXJ0bmVyc2hpcCB3aXRoIHJlc2VhcmNoZXJzIHdobyBxdWlja2x5IGRlbW9uc3RyYXRlIHRoYXQgd2hhdCB0aGV5IGRvIGFuZCB0aGUgd2F5IHRoYXQgdGhleSBkbyBpdCBhZGRzIHZhbHVlLiBBbmQgQXVzdHJhbGlhIGlzIG5vdCBhbG9uZSBpbiBvZmZlcmluZyBjb21wYW5pZXMgdGF4IGluY2VudGl2ZXMgZm9yIGVuZ2FnaW5nIHVuaXZlcnNpdHkgYWNhZGVtaWNzIGxpa2UgdGhvc2UgaW4gb3VyIEZBU1RMYWIgdGVhbSBpbiBSZXNlYXJjaCBhbmQgRGV2ZWxvcG1lbnQgcHJvamVjdHMuXHJcblxyXG5PdXIgcmVzZWFyY2ggZm9jdXNlcyBvbiBodW1hbiBjZW50cmVkIGludGVyYWN0aW9ucy5cdTAwYTAgSXQgaGFybmVzc2VzIGh1bWFuIGltYWdpbmF0aW9uLCBlbXBhdGh5LCBjb29wZXJhdGlvbiwgY28tZGVzaWduLCBkZXNpZ24gdGhpbmtpbmcsIHZpc3VhbGl6YXRpb24sIHBsYXlmdWxuZXNzIGFuZCBjcmVhdGl2aXR5LiBJdCBlbmFibGVzIGEgYmV0dGVyIHVuZGVyc3RhbmRpbmcgb2YgdGhlIHVuZGVybHlpbmcgc3lzdGVtcyBvZiBjcmVhdGl2aXR5LCBhbmQgbW90aXZhdGlvbnMgb2YgaHVtYW5zLiBJdCBwcm92aWRlcyBuZXcgb3Bwb3J0dW5pdGllcyB0byByZXNwb25kIHRvIHNvbWUgb2Ygb3VyIG1vc3QgaW1wb3J0YW50IGNoYWxsZW5nZXMgXHUyMDEzIGxpa2UgaGVhbHRoY2FyZS5cclxuXHJcbldlIGtub3cgdGhhdCBoZWFsdGhjYXJlIGNvc3RzIGFyZSByYXBpZGx5IHJpc2luZyBnbG9iYWxseSBkdWUgdG8gYWdlaW5nIHBvcHVsYXRpb25zLCB0aGUgaW5jcmVhc2luZyBwcmV2YWxlbmNlIG9mIGNocm9uaWMgZGlzZWFzZXMsIGltcHJvdmVkIHN1cnZpdmFsIHJhdGVzIGZyb20gYWN1dGUgdHJhdW1hLCByaXNpbmcgdHJlYXRtZW50IGNvc3RzLCBhbmQgdGhlIHdpZGVuaW5nIGdhcCBpbiBhY2Nlc3MgdG8gY2FyZSBiZXR3ZWVuIHJ1cmFsIGFuZCB1cmJhbiBjb21tdW5pdGllcy4gSGVhbHRoY2FyZSBjb3N0cyBpbiBBdXN0cmFsaWEgYWxvbmUgYXJlIGZvcmVjYXN0IHRvIHJlYWNoICQzNiBiaWxsaW9uIGJ5IDIwMjguXHJcblxyXG5MZWQgYnkgY29sbGVhZ3VlcyBhdCB0aGUgVW5pdmVyc2l0eSBvZiBOZXcgU291dGggV2FsZXMsIEZBU1RMYWIgaXMgYSBsZWFkIHJlc2VhcmNoIHBhcnRuZXIgb24gYSAkMjRtIEF1c3RyYWxpYW4gUmVzZWFyY2ggQ291bmNpbCBIdWIgRm9yIENvbm5lY3RlZCBTZW5zb3JzLiBPdXIgcm9sZSBpcyB0byBjby1kZXNpZ24gdGhpbmtpbmcgd2l0aCBhbmFseXRpY2FsIHJpZ29yIHRoYXQgZW5hYmxlcyB0aGUgSHViIHRlYW0gdG8gZ2V0IHRvIGNyZWF0aXZlIG5ldyBtZWRpY2FsIHByb2R1Y3RzIGFuZCBzZXJ2aWNlcyBxdWlja2x5LiBXb3JraW5nIGFjcm9zcyB0aGUgSHViLCBvdXIgd29yayBpcyB0byBkZXNpZ24gZm9yIGh1bWFucyBhbmQgZGV2ZWxvcCB0aGUgbmV4dFx1MjAxMGdlbmVyYXRpb24gdWx0cmFcdTIwMTBsaWdodHdlaWdodCBhbmQgc29mdCB3ZWFyYWJsZSBtZWRpY2FsIHNlbnNvciBkZXZpY2VzLlxyXG5cclxuV2hldGhlciB3b3JraW5nIHdpdGggY29tbXVuaXRpZXMsIGluZHVzdHJ5LCBOR09cdTIwMTlzIG9yIGdvdmVybm1lbnRzIHRoZSBGQVNUTGFiIHRlYW0ga25vd3MgdGhhdCBpbWFnaW5hdGlvbiBpcyB0aGUgZm91bmRhdGlvbiBvZiBjcmVhdGl2aXR5IGFuZCBpbm5vdmF0aW9uLiBPdXIgZXhwZXJpZW5jZSwgZXhwZXJ0aXNlIGFuZCB3b3JrIHdpdGggb3VyIHBhcnRuZXJzIGFuZCBjbGllbnRzIGNvbnRpbnVlcyB0byBkZW1vbnN0cmF0ZSB0aGF0IHdlIGNhbiBhbGwgaW1hZ2luZSBcdTIwMThiZXR0ZXJcdTIwMTkgXHUyMDEzIGFuZCBvbmNlIHdlIGhhdmUsIHdlIGNhbiBjaGFuZ2UgdGhpbmdzIHNvIHRoZXkgYXJlLiBCZXR0ZXIgZm9yIGFsbCBvZiB1cyBhbmQgZm9yIHRoZSBwbGFuZXQgd2VcdTIwMTlyZSBjdXN0b2RpYW5zIG9mLlxyXG5cclxuJm5ic3A7XHJcbjxoMj5DT05UQUNUIFBPSU5UOjwvaDI+XHJcbjxlbT5JZiB5b3UgYXJlIGludGVyZXN0ZWQgaW4gaGVscGluZyB5b3VyIG9yZ2FuaXNhdGlvbiBhY3RpdmVseSBjb250cmlidXRlIHRvIHRoZSBzdXN0YWluYWJsZSB0cmFuc2Zvcm1hdGlvbiBvZiBzb2NpZXR5IFx1MjAxMyBvciB5b3VcdTIwMTlkIGp1c3QgbGlrZSB0byBsZWFybiBhIGxpdHRsZSBtb3JlIGFib3V0IEZBU1RMYWIgVGhpbmtpbmcgeW91IGNhbiBjb250YWN0IG1lIGRpcmVjdGx5IGF0OjwvZW0+XHJcblxyXG4mbmJzcDtcclxuXHJcbjxhIGhyZWY9XCJtYWlsdG86UGF1bC5lZ2dsZXN0b25lQG5ld2Nhc3RsZS5lZHUuYXVcIj5QYXVsLmVnZ2xlc3RvbmVAbmV3Y2FzdGxlLmVkdS5hdTwvYT5cclxuXHJcblQ6ICs2MSAyIDQ5ODUgNDU0NVxyXG5NOiArNjEgKDApIDQwOCA1NDcgOTkyXHJcblxyXG48YSBocmVmPVwiaHR0cHM6Ly9mYXN0bGFiLnNvY2kub3JnLmF1XCI+aHR0cHM6Ly9mYXN0bGFiLnNvY2kub3JnLmF1PC9hPlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbl1bdmNfY29sdW1uX3RleHRdXHJcblxyXG48c3BhbiBzdHlsZT1cImJvcmRlci10b3AtbGVmdC1yYWRpdXM6IDJweDsgYm9yZGVyLXRvcC1yaWdodC1yYWRpdXM6IDJweDsgYm9yZGVyLWJvdHRvbS1yaWdodC1yYWRpdXM6IDJweDsgYm9yZGVyLWJvdHRvbS1sZWZ0LXJhZGl1czogMnB4OyB0ZXh0LWluZGVudDogMjBweDsgd2lkdGg6IGF1dG87IHBhZGRpbmc6IDBweCA0cHggMHB4IDBweDsgdGV4dC1hbGlnbjogY2VudGVyOyBmb250LXN0eWxlOiBub3JtYWw7IGZvbnQtdmFyaWFudC1jYXBzOiBub3JtYWw7IGZvbnQtd2VpZ2h0OiBib2xkOyBmb250LXN0cmV0Y2g6IG5vcm1hbDsgZm9udC1zaXplOiAxMXB4OyBsaW5lLWhlaWdodDogMjBweDsgZm9udC1mYW1pbHk6ICdIZWx2ZXRpY2EgTmV1ZScsIEhlbHZldGljYSwgc2Fucy1zZXJpZjsgY29sb3I6ICNmZmZmZmY7IGJhY2tncm91bmQtaW1hZ2U6IHVybChkYXRhOmltYWdlL3N2Zyt4bWw7IGJhc2U2NCxwaG4yenliNGJ3eHVjejBpYWhyMGNkb3ZsM2QzZHk1M215NXZjbWN2bWphd21jOXpkbWNpaWdobGF3ZG9kZDBpbXpid2VjaWdkMmxrZGdnOWlqbXdjaGdpaWh6cHp4ZGNiM2c5aWkweGljMHhpZG14aWRteGlqNDh6ejQ4Y2dmMGFjYmtwc2pubWprdW5kcTVsZGUwbGp5Mm1pYmRtamt1bmRxNWxkaXlsamN5bWlheW1pNDRuamdzbWprdW1qdTJpZGUwbGpjMWxkaTVsamkxbmliZG5pNDJtemlzbWprdW1qdTJpZGF1bWR1eGxkaXlsamN5bWlhd2xqYTFtc3d4bmM0Mm5qaWdxemF1bWR1eGxkeXVuamF4aWR5dW5qbXlsZGF1bWR5M2lkZTBsamMxbGRhdW1keTNpZW15bWk0NG5qZ3NtYzR3bmpjZ21qa3VuZHE1bGR5dW5qYXhpZGk1bGpxMG9zd3huYzQybmppaWlnenBiZ3c5aWlubXpteWlpaG4wY205cnp0MGlpMnptemlpZ2MzcnliMnRsbHhkcHpocm9wc2l4aWo0OGwzYmhkZ2crcGhiaGRnZ2d6ZDBpdHRlMGxqY3pteXd4bGp5NG5pYmRueTQxbXR5c21zNDJvZHlnbXM0Mm5qdXNueTQwb3R1Z21zNDJuanVzbXRxdW5qeXlpZW14bGp5Mm5zd3ltYzR4bnRrZ25zNHhtZGtzbWpxdW9kdTBpZGt1b3Rjc21qeXVuenEwaWVtNWxqZzFuaXd5bnM0M210Z2dvczQzbnRtc21qcXVtdHF6aWRld2xqYXhuaXd5bXk0d21qaWdxemV3bGppMW15d3ltaTR3bXNheG1zNDFuZGdzbXR5dW50Y3lpZGV4bGp1MG9jd3huaTQxbnppZ3F6ZXhsanUwb2N3eG5pNDFuemlnbXRldW10dTNsZGUxbGpjNW5zYXhtczR4bnRjc210cXVuanEyaWVteG1zNHhudGNzbXRpdW9kcXlpZGV5bGppeG1zd3htczQwb3R1Z210bXVudGl5bGRleGxqcTVuc2JkbXRxdW5qbTNsZGV4bGpxNW5zYXhuczR4bnp1c210aXVtemkyaWRlMWxqZTNuc3d4bXk0em1qbWdxemUxbGplM25zd3huYzQwbXp5Z210cXVuZHl5bGRlMmxqZWdtdHF1bWRremxkZTNsankwbXliZG10bXVuemcxbGRlNGxqa3puc2F4bmM0M25kdXNtdGt1b3RnNGlkZTJsamF5b2N3eG9zNDVvZGdncXplNGxqbTFtc3d4b3M0NW9kZ2dtamF1bXRtMmxkZTNsanUxbmlheW1jNHhtenlzbXRxdW1kcTJpZW15bWM0eG16eXNtdGF1b3RtNWlkZTNsamc0b2N3NGxqYzJueWF4bmM0Mm56Z3NvYzQzbmpjZ3F6ZXdsamsxb3N3NGxqYzJueWE0bGpjM255d3htczQxbXp5Z29jNDNuemNzbXRxdW16azRpZW00bGpjM255d3huczQxbXRtZ29zNHltc3d4bmk0M21ka2dvczQzbmRrc210Y3VtenU1aWVtNWxqZzFuaXd4bnk0MG9kZ2dvczQ0bnppc210Y3VuaWE1bGpnMGxkZTNsamN6bXNiZG9zNDNuZGVzbXRndW10cXhpZGt1bnRpc210a3VtZGl6aWRrdW5kYzNsZGU1bGppd215YmRvczQwbWl3eG9zNDBuY2E1bGppNG9jd3hvczQwb3RlZ29zNHduY3d4b3M0em56eWdxemN1bmRhNGxkZTRsanl5bWlhMmxqbTRueXd4bmk0eW50aWduaTR6b2Rjc210cXVtenE1aWVtMmxqbTRueXd4bWM0eW50eWdvczR6b2Rtc25pNDBvdGNnbXR1dW1kaXlsZHl1bmRrM2llbXhvczQxbnR1c25pNDBvdGNnbWptdW1kYzRsZGt1bnphMWlkaXpsamEzb2N3eG15NDVvdGVncXppemxqYTNvY3d4b2M0MG5qbWdtamF1bWptNWxkaXlsamEybWlheG5pNHlvdGNzbWppdW1keXlpZW14bmM0NW56bXNtaml1bWR5eWlkZXpsamN5b2N3eW1zNHpuemtnbXRtdW16YXlsZGl3bGp1M21pYmRtdG11bXpheWxkaXdsanUzbWlheG1pNDJuZGNzbWptdW1kdWdtdGl1bmRnNGxkaXpsankxbnliZG10aXVtdGt6bGRpMGxqYzRuY2F4bXM0em90eXNtanl1bXRrMmlkZXdsamcybXl3eW55NHdudGdncXpleWxqYTRuaXd5bnk0MG16cWdtdG11bXpnMmxkaTNsanl6bnlheG5jNDNtem1zbWpjdW5qbTNpZW15bXM0NW5zd3lueTQybXpjZ21qY3VvZGF4bGRpeGxqZ3lvY2F5bnk0NG1kZXNtdHF1bmp5eWllbXlueTQ0bWRlc255NDBvdHVnbWpldW90dXNtczQyb2R5Z210cXVuem16bGRldW5qZzJpaWJtYXd4c3BzaWp5bXF3b2RmamlqNDhsM2JoZGdnK3BjOW5wand2YzN6bnBnPT0pOyBiYWNrZ3JvdW5kLXNpemU6IDE0cHggMTRweDsgYmFja2dyb3VuZC1jb2xvcjogI2JkMDgxYzsgcG9zaXRpb246IGFic29sdXRlOyBvcGFjaXR5OiAxOyB6LWluZGV4OiA4Njc1MzA5OyBkaXNwbGF5OiBub25lOyBjdXJzb3I6IHBvaW50ZXI7IGJvcmRlcjogbm9uZTsgLXdlYmtpdC1mb250LXNtb290aGluZzogYW50aWFsaWFzZWQ7IGJhY2tncm91bmQtcG9zaXRpb246IDNweCA1MCU7IGJhY2tncm91bmQtcmVwZWF0OiBuby1yZXBlYXQgbm8tcmVwZWF0O1wiPlNhdmU8L3NwYW4+PHNwYW4gc3R5bGU9XCJib3JkZXItdG9wLWxlZnQtcmFkaXVzOiAycHg7IGJvcmRlci10b3AtcmlnaHQtcmFkaXVzOiAycHg7IGJvcmRlci1ib3R0b20tcmlnaHQtcmFkaXVzOiAycHg7IGJvcmRlci1ib3R0b20tbGVmdC1yYWRpdXM6IDJweDsgdGV4dC1pbmRlbnQ6IDIwcHg7IHdpZHRoOiBhdXRvOyBwYWRkaW5nOiAwcHggNHB4IDBweCAwcHg7IHRleHQtYWxpZ246IGNlbnRlcjsgZm9udC1zdHlsZTogbm9ybWFsOyBmb250LXZhcmlhbnQtY2Fwczogbm9ybWFsOyBmb250LXdlaWdodDogYm9sZDsgZm9udC1zdHJldGNoOiBub3JtYWw7IGZvbnQtc2l6ZTogMTFweDsgbGluZS1oZWlnaHQ6IDIwcHg7IGZvbnQtZmFtaWx5OiAnSGVsdmV0aWNhIE5ldWUnLCBIZWx2ZXRpY2EsIHNhbnMtc2VyaWY7IGNvbG9yOiAjZmZmZmZmOyBiYWNrZ3JvdW5kLWltYWdlOiB1cmwoZGF0YTppbWFnZS9zdmcreG1sOyBiYXNlNjQscGhuMnp5YjRid3h1Y3owaWFocjBjZG92bDNkM2R5NTNteTV2Y21jdm1qYXdtYzl6ZG1jaWlnaGxhd2RvZGQwaW16YndlY2lnZDJsa2RnZzlpam13Y2hnaWloenB6eGRjYjNnOWlpMHhpYzB4aWRteGlkbXhpajQ4eno0OGNnZjBhY2JrcHNqbm1qa3VuZHE1bGRlMGxqeTJtaWJkbWprdW5kcTVsZGl5bGpjeW1pYXltaTQ0bmpnc21qa3VtanUyaWRlMGxqYzFsZGk1bGppMW5pYmRuaTQybXppc21qa3VtanUyaWRhdW1kdXhsZGl5bGpjeW1pYXdsamExbXN3eG5jNDJuamlncXphdW1kdXhsZHl1bmpheGlkeXVuam15bGRhdW1keTNpZGUwbGpjMWxkYXVtZHkzaWVteW1pNDRuamdzbWM0d25qY2dtamt1bmRxNWxkeXVuamF4aWRpNWxqcTBvc3d4bmM0Mm5qaWlpZ3pwYmd3OWlpbm16bXlpaWhuMGNtOXJ6dDBpaTJ6bXppaWdjM3J5YjJ0bGx4ZHB6aHJvcHNpeGlqNDhsM2JoZGdnK3BoYmhkZ2dnemQwaXR0ZTBsamN6bXl3eGxqeTRuaWJkbnk0MW10eXNtczQyb2R5Z21zNDJuanVzbnk0MG90dWdtczQybmp1c210cXVuanl5aWVteGxqeTJuc3d5bWM0eG50a2duczR4bWRrc21qcXVvZHUwaWRrdW90Y3Ntanl1bnpxMGllbTVsamcxbml3eW5zNDNtdGdnb3M0M250bXNtanF1bXRxemlkZXdsamF4bml3eW15NHdtamlncXpld2xqaTFteXd5bWk0d21zYXhtczQxbmRnc210eXVudGN5aWRleGxqdTBvY3d4bmk0MW56aWdxemV4bGp1MG9jd3huaTQxbnppZ210ZXVtdHUzbGRlMWxqYzVuc2F4bXM0eG50Y3NtdHF1bmpxMmllbXhtczR4bnRjc210aXVvZHF5aWRleWxqaXhtc3d4bXM0MG90dWdtdG11bnRpeWxkZXhsanE1bnNiZG10cXVuam0zbGRleGxqcTVuc2F4bnM0eG56dXNtdGl1bXppMmlkZTFsamUzbnN3eG15NHptam1ncXplMWxqZTNuc3d4bmM0MG16eWdtdHF1bmR5eWxkZTJsamVnbXRxdW1ka3psZGUzbGp5MG15YmRtdG11bnpnMWxkZTRsamt6bnNheG5jNDNuZHVzbXRrdW90ZzRpZGUybGpheW9jd3hvczQ1b2RnZ3F6ZTRsam0xbXN3eG9zNDVvZGdnbWphdW10bTJsZGUzbGp1MW5pYXltYzR4bXp5c210cXVtZHEyaWVteW1jNHhtenlzbXRhdW90bTVpZGUzbGpnNG9jdzRsamMybnlheG5jNDJuemdzb2M0M25qY2dxemV3bGprMW9zdzRsamMybnlhNGxqYzNueXd4bXM0MW16eWdvYzQzbnpjc210cXVtems0aWVtNGxqYzNueXd4bnM0MW10bWdvczR5bXN3eG5pNDNtZGtnb3M0M25ka3NtdGN1bXp1NWllbTVsamcxbml3eG55NDBvZGdnb3M0NG56aXNtdGN1bmlhNWxqZzBsZGUzbGpjem1zYmRvczQzbmRlc210Z3VtdHF4aWRrdW50aXNtdGt1bWRpemlka3VuZGMzbGRlNWxqaXdteWJkb3M0MG1pd3hvczQwbmNhNWxqaTRvY3d4b3M0MG90ZWdvczR3bmN3eG9zNHpuenlncXpjdW5kYTRsZGU0bGp5eW1pYTJsam00bnl3eG5pNHludGlnbmk0em9kY3NtdHF1bXpxNWllbTJsam00bnl3eG1jNHludHlnb3M0em9kbXNuaTQwb3RjZ210dXVtZGl5bGR5dW5kazNpZW14b3M0MW50dXNuaTQwb3RjZ21qbXVtZGM0bGRrdW56YTFpZGl6bGphM29jd3hteTQ1b3RlZ3F6aXpsamEzb2N3eG9jNDBuam1nbWphdW1qbTVsZGl5bGphMm1pYXhuaTR5b3Rjc21qaXVtZHl5aWVteG5jNDVuem1zbWppdW1keXlpZGV6bGpjeW9jd3ltczR6bnprZ210bXVtemF5bGRpd2xqdTNtaWJkbXRtdW16YXlsZGl3bGp1M21pYXhtaTQybmRjc21qbXVtZHVnbXRpdW5kZzRsZGl6bGp5MW55YmRtdGl1bXRremxkaTBsamM0bmNheG1zNHpvdHlzbWp5dW10azJpZGV3bGpnMm15d3lueTR3bnRnZ3F6ZXlsamE0bml3eW55NDBtenFnbXRtdW16ZzJsZGkzbGp5em55YXhuYzQzbXptc21qY3Vuam0zaWVteW1zNDVuc3d5bnk0Mm16Y2dtamN1b2RheGxkaXhsamd5b2NheW55NDRtZGVzbXRxdW5qeXlpZW15bnk0NG1kZXNueTQwb3R1Z21qZXVvdHVzbXM0Mm9keWdtdHF1bnptemxkZXVuamcyaWlibWF3eHNwc2lqeW1xd29kZmppajQ4bDNiaGRnZytwYzlucGp3dmMzem5wZz09KTsgYmFja2dyb3VuZC1zaXplOiAxNHB4IDE0cHg7IGJhY2tncm91bmQtY29sb3I6ICNiZDA4MWM7IHBvc2l0aW9uOiBhYnNvbHV0ZTsgb3BhY2l0eTogMTsgei1pbmRleDogODY3NTMwOTsgZGlzcGxheTogbm9uZTsgY3Vyc29yOiBwb2ludGVyOyBib3JkZXI6IG5vbmU7IC13ZWJraXQtZm9udC1zbW9vdGhpbmc6IGFudGlhbGlhc2VkOyBiYWNrZ3JvdW5kLXBvc2l0aW9uOiAzcHggNTAlOyBiYWNrZ3JvdW5kLXJlcGVhdDogbm8tcmVwZWF0IG5vLXJlcGVhdDtcIj5TYXZlPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJib3JkZXItdG9wLWxlZnQtcmFkaXVzOiAycHg7IGJvcmRlci10b3AtcmlnaHQtcmFkaXVzOiAycHg7IGJvcmRlci1ib3R0b20tcmlnaHQtcmFkaXVzOiAycHg7IGJvcmRlci1ib3R0b20tbGVmdC1yYWRpdXM6IDJweDsgdGV4dC1pbmRlbnQ6IDIwcHg7IHdpZHRoOiBhdXRvOyBwYWRkaW5nOiAwcHggNHB4IDBweCAwcHg7IHRleHQtYWxpZ246IGNlbnRlcjsgZm9udC1zdHlsZTogbm9ybWFsOyBmb250LXZhcmlhbnQtY2Fwczogbm9ybWFsOyBmb250LXdlaWdodDogYm9sZDsgZm9udC1zdHJldGNoOiBub3JtYWw7IGZvbnQtc2l6ZTogMTFweDsgbGluZS1oZWlnaHQ6IDIwcHg7IGZvbnQtZmFtaWx5OiAnSGVsdmV0aWNhIE5ldWUnLCBIZWx2ZXRpY2EsIHNhbnMtc2VyaWY7IGNvbG9yOiAjZmZmZmZmOyBiYWNrZ3JvdW5kLWltYWdlOiB1cmwoZGF0YTppbWFnZS9zdmcreG1sOyBiYXNlNjQscGhuMnp5YjRid3h1Y3owaWFocjBjZG92bDNkM2R5NTNteTV2Y21jdm1qYXdtYzl6ZG1jaWlnaGxhd2RvZGQwaW16YndlY2lnZDJsa2RnZzlpam13Y2hnaWloenB6eGRjYjNnOWlpMHhpYzB4aWRteGlkbXhpajQ4eno0OGNnZjBhY2JrcHNqbm1qa3VuZHE1bGRlMGxqeTJtaWJkbWprdW5kcTVsZGl5bGpjeW1pYXltaTQ0bmpnc21qa3VtanUyaWRlMGxqYzFsZGk1bGppMW5pYmRuaTQybXppc21qa3VtanUyaWRhdW1kdXhsZGl5bGpjeW1pYXdsamExbXN3eG5jNDJuamlncXphdW1kdXhsZHl1bmpheGlkeXVuam15bGRhdW1keTNpZGUwbGpjMWxkYXVtZHkzaWVteW1pNDRuamdzbWM0d25qY2dtamt1bmRxNWxkeXVuamF4aWRpNWxqcTBvc3d4bmM0Mm5qaWlpZ3pwYmd3OWlpbm16bXlpaWhuMGNtOXJ6dDBpaTJ6bXppaWdjM3J5YjJ0bGx4ZHB6aHJvcHNpeGlqNDhsM2JoZGdnK3BoYmhkZ2dnemQwaXR0ZTBsamN6bXl3eGxqeTRuaWJkbnk0MW10eXNtczQyb2R5Z21zNDJuanVzbnk0MG90dWdtczQybmp1c210cXVuanl5aWVteGxqeTJuc3d5bWM0eG50a2duczR4bWRrc21qcXVvZHUwaWRrdW90Y3Ntanl1bnpxMGllbTVsamcxbml3eW5zNDNtdGdnb3M0M250bXNtanF1bXRxemlkZXdsamF4bml3eW15NHdtamlncXpld2xqaTFteXd5bWk0d21zYXhtczQxbmRnc210eXVudGN5aWRleGxqdTBvY3d4bmk0MW56aWdxemV4bGp1MG9jd3huaTQxbnppZ210ZXVtdHUzbGRlMWxqYzVuc2F4bXM0eG50Y3NtdHF1bmpxMmllbXhtczR4bnRjc210aXVvZHF5aWRleWxqaXhtc3d4bXM0MG90dWdtdG11bnRpeWxkZXhsanE1bnNiZG10cXVuam0zbGRleGxqcTVuc2F4bnM0eG56dXNtdGl1bXppMmlkZTFsamUzbnN3eG15NHptam1ncXplMWxqZTNuc3d4bmM0MG16eWdtdHF1bmR5eWxkZTJsamVnbXRxdW1ka3psZGUzbGp5MG15YmRtdG11bnpnMWxkZTRsamt6bnNheG5jNDNuZHVzbXRrdW90ZzRpZGUybGpheW9jd3hvczQ1b2RnZ3F6ZTRsam0xbXN3eG9zNDVvZGdnbWphdW10bTJsZGUzbGp1MW5pYXltYzR4bXp5c210cXVtZHEyaWVteW1jNHhtenlzbXRhdW90bTVpZGUzbGpnNG9jdzRsamMybnlheG5jNDJuemdzb2M0M25qY2dxemV3bGprMW9zdzRsamMybnlhNGxqYzNueXd4bXM0MW16eWdvYzQzbnpjc210cXVtems0aWVtNGxqYzNueXd4bnM0MW10bWdvczR5bXN3eG5pNDNtZGtnb3M0M25ka3NtdGN1bXp1NWllbTVsamcxbml3eG55NDBvZGdnb3M0NG56aXNtdGN1bmlhNWxqZzBsZGUzbGpjem1zYmRvczQzbmRlc210Z3VtdHF4aWRrdW50aXNtdGt1bWRpemlka3VuZGMzbGRlNWxqaXdteWJkb3M0MG1pd3hvczQwbmNhNWxqaTRvY3d4b3M0MG90ZWdvczR3bmN3eG9zNHpuenlncXpjdW5kYTRsZGU0bGp5eW1pYTJsam00bnl3eG5pNHludGlnbmk0em9kY3NtdHF1bXpxNWllbTJsam00bnl3eG1jNHludHlnb3M0em9kbXNuaTQwb3RjZ210dXVtZGl5bGR5dW5kazNpZW14b3M0MW50dXNuaTQwb3RjZ21qbXVtZGM0bGRrdW56YTFpZGl6bGphM29jd3hteTQ1b3RlZ3F6aXpsamEzb2N3eG9jNDBuam1nbWphdW1qbTVsZGl5bGphMm1pYXhuaTR5b3Rjc21qaXVtZHl5aWVteG5jNDVuem1zbWppdW1keXlpZGV6bGpjeW9jd3ltczR6bnprZ210bXVtemF5bGRpd2xqdTNtaWJkbXRtdW16YXlsZGl3bGp1M21pYXhtaTQybmRjc21qbXVtZHVnbXRpdW5kZzRsZGl6bGp5MW55YmRtdGl1bXRremxkaTBsamM0bmNheG1zNHpvdHlzbWp5dW10azJpZGV3bGpnMm15d3lueTR3bnRnZ3F6ZXlsamE0bml3eW55NDBtenFnbXRtdW16ZzJsZGkzbGp5em55YXhuYzQzbXptc21qY3Vuam0zaWVteW1zNDVuc3d5bnk0Mm16Y2dtamN1b2RheGxkaXhsamd5b2NheW55NDRtZGVzbXRxdW5qeXlpZW15bnk0NG1kZXNueTQwb3R1Z21qZXVvdHVzbXM0Mm9keWdtdHF1bnptemxkZXVuamcyaWlibWF3eHNwc2lqeW1xd29kZmppajQ4bDNiaGRnZytwYzlucGp3dmMzem5wZz09KTsgYmFja2dyb3VuZC1zaXplOiAxNHB4IDE0cHg7IGJhY2tncm91bmQtY29sb3I6ICNiZDA4MWM7IHBvc2l0aW9uOiBhYnNvbHV0ZTsgb3BhY2l0eTogMTsgei1pbmRleDogODY3NTMwOTsgZGlzcGxheTogbm9uZTsgY3Vyc29yOiBwb2ludGVyOyBib3JkZXI6IG5vbmU7IC13ZWJraXQtZm9udC1zbW9vdGhpbmc6IGFudGlhbGlhc2VkOyBiYWNrZ3JvdW5kLXBvc2l0aW9uOiAzcHggNTAlOyBiYWNrZ3JvdW5kLXJlcGVhdDogbm8tcmVwZWF0IG5vLXJlcGVhdDtcIj5TYXZlPC9zcGFuPjxzcGFuIHN0eWxlPVwiYm9yZGVyLXRvcC1sZWZ0LXJhZGl1czogMnB4OyBib3JkZXItdG9wLXJpZ2h0LXJhZGl1czogMnB4OyBib3JkZXItYm90dG9tLXJpZ2h0LXJhZGl1czogMnB4OyBib3JkZXItYm90dG9tLWxlZnQtcmFkaXVzOiAycHg7IHRleHQtaW5kZW50OiAyMHB4OyB3aWR0aDogYXV0bzsgcGFkZGluZzogMHB4IDRweCAwcHggMHB4OyB0ZXh0LWFsaWduOiBjZW50ZXI7IGZvbnQtc3R5bGU6IG5vcm1hbDsgZm9udC12YXJpYW50LWNhcHM6IG5vcm1hbDsgZm9udC13ZWlnaHQ6IGJvbGQ7IGZvbnQtc3RyZXRjaDogbm9ybWFsOyBmb250LXNpemU6IDExcHg7IGxpbmUtaGVpZ2h0OiAyMHB4OyBmb250LWZhbWlseTogJ0hlbHZldGljYSBOZXVlJywgSGVsdmV0aWNhLCBzYW5zLXNlcmlmOyBjb2xvcjogI2ZmZmZmZjsgYmFja2dyb3VuZC1pbWFnZTogdXJsKGRhdGE6aW1hZ2Uvc3ZnK3htbDsgYmFzZTY0LHBobjJ6eWI0Ynd4dWN6MGlhaHIwY2RvdmwzZDNkeTUzbXk1dmNtY3ZtamF3bWM5emRtY2lpZ2hsYXdkb2RkMGltemJ3ZWNpZ2QybGtkZ2c5aWptd2NoZ2lpaHpwenhkY2IzZzlpaTB4aWMweGlkbXhpZG14aWo0OHp6NDhjZ2YwYWNia3Bzam5tamt1bmRxNWxkZTBsankybWliZG1qa3VuZHE1bGRpeWxqY3ltaWF5bWk0NG5qZ3Ntamt1bWp1MmlkZTBsamMxbGRpNWxqaTFuaWJkbmk0Mm16aXNtamt1bWp1MmlkYXVtZHV4bGRpeWxqY3ltaWF3bGphMW1zd3huYzQybmppZ3F6YXVtZHV4bGR5dW5qYXhpZHl1bmpteWxkYXVtZHkzaWRlMGxqYzFsZGF1bWR5M2llbXltaTQ0bmpnc21jNHduamNnbWprdW5kcTVsZHl1bmpheGlkaTVsanEwb3N3eG5jNDJuamlpaWd6cGJndzlpaW5tem15aWlobjBjbTlyenQwaWkyem16aWlnYzNyeWIydGxseGRwemhyb3BzaXhpajQ4bDNiaGRnZytwaGJoZGdnZ3pkMGl0dGUwbGpjem15d3hsank0bmliZG55NDFtdHlzbXM0Mm9keWdtczQybmp1c255NDBvdHVnbXM0Mm5qdXNtdHF1bmp5eWllbXhsankybnN3eW1jNHhudGtnbnM0eG1ka3NtanF1b2R1MGlka3VvdGNzbWp5dW56cTBpZW01bGpnMW5pd3luczQzbXRnZ29zNDNudG1zbWpxdW10cXppZGV3bGpheG5pd3lteTR3bWppZ3F6ZXdsamkxbXl3eW1pNHdtc2F4bXM0MW5kZ3NtdHl1bnRjeWlkZXhsanUwb2N3eG5pNDFuemlncXpleGxqdTBvY3d4bmk0MW56aWdtdGV1bXR1M2xkZTFsamM1bnNheG1zNHhudGNzbXRxdW5qcTJpZW14bXM0eG50Y3NtdGl1b2RxeWlkZXlsaml4bXN3eG1zNDBvdHVnbXRtdW50aXlsZGV4bGpxNW5zYmRtdHF1bmptM2xkZXhsanE1bnNheG5zNHhuenVzbXRpdW16aTJpZGUxbGplM25zd3hteTR6bWptZ3F6ZTFsamUzbnN3eG5jNDBtenlnbXRxdW5keXlsZGUybGplZ210cXVtZGt6bGRlM2xqeTBteWJkbXRtdW56ZzFsZGU0bGprem5zYXhuYzQzbmR1c210a3VvdGc0aWRlMmxqYXlvY3d4b3M0NW9kZ2dxemU0bGptMW1zd3hvczQ1b2RnZ21qYXVtdG0ybGRlM2xqdTFuaWF5bWM0eG16eXNtdHF1bWRxMmllbXltYzR4bXp5c210YXVvdG01aWRlM2xqZzRvY3c0bGpjMm55YXhuYzQybnpnc29jNDNuamNncXpld2xqazFvc3c0bGpjMm55YTRsamMzbnl3eG1zNDFtenlnb2M0M256Y3NtdHF1bXprNGllbTRsamMzbnl3eG5zNDFtdG1nb3M0eW1zd3huaTQzbWRrZ29zNDNuZGtzbXRjdW16dTVpZW01bGpnMW5pd3hueTQwb2RnZ29zNDRuemlzbXRjdW5pYTVsamcwbGRlM2xqY3ptc2Jkb3M0M25kZXNtdGd1bXRxeGlka3VudGlzbXRrdW1kaXppZGt1bmRjM2xkZTVsaml3bXliZG9zNDBtaXd4b3M0MG5jYTVsamk0b2N3eG9zNDBvdGVnb3M0d25jd3hvczR6bnp5Z3F6Y3VuZGE0bGRlNGxqeXltaWEybGptNG55d3huaTR5bnRpZ25pNHpvZGNzbXRxdW16cTVpZW0ybGptNG55d3htYzR5bnR5Z29zNHpvZG1zbmk0MG90Y2dtdHV1bWRpeWxkeXVuZGszaWVteG9zNDFudHVzbmk0MG90Y2dtam11bWRjNGxka3VuemExaWRpemxqYTNvY3d4bXk0NW90ZWdxeml6bGphM29jd3hvYzQwbmptZ21qYXVtam01bGRpeWxqYTJtaWF4bmk0eW90Y3Ntaml1bWR5eWllbXhuYzQ1bnptc21qaXVtZHl5aWRlemxqY3lvY3d5bXM0em56a2dtdG11bXpheWxkaXdsanUzbWliZG10bXVtemF5bGRpd2xqdTNtaWF4bWk0Mm5kY3Ntam11bWR1Z210aXVuZGc0bGRpemxqeTFueWJkbXRpdW10a3psZGkwbGpjNG5jYXhtczR6b3R5c21qeXVtdGsyaWRld2xqZzJteXd5bnk0d250Z2dxemV5bGphNG5pd3lueTQwbXpxZ210bXVtemcybGRpM2xqeXpueWF4bmM0M216bXNtamN1bmptM2llbXltczQ1bnN3eW55NDJtemNnbWpjdW9kYXhsZGl4bGpneW9jYXlueTQ0bWRlc210cXVuanl5aWVteW55NDRtZGVzbnk0MG90dWdtamV1b3R1c21zNDJvZHlnbXRxdW56bXpsZGV1bmpnMmlpYm1hd3hzcHNpanltcXdvZGZqaWo0OGwzYmhkZ2crcGM5bnBqd3ZjM3pucGc9PSk7IGJhY2tncm91bmQtc2l6ZTogMTRweCAxNHB4OyBiYWNrZ3JvdW5kLWNvbG9yOiAjYmQwODFjOyBwb3NpdGlvbjogYWJzb2x1dGU7IG9wYWNpdHk6IDE7IHotaW5kZXg6IDg2NzUzMDk7IGRpc3BsYXk6IG5vbmU7IGN1cnNvcjogcG9pbnRlcjsgYm9yZGVyOiBub25lOyAtd2Via2l0LWZvbnQtc21vb3RoaW5nOiBhbnRpYWxpYXNlZDsgYmFja2dyb3VuZC1wb3NpdGlvbjogM3B4IDUwJTsgYmFja2dyb3VuZC1yZXBlYXQ6IG5vLXJlcGVhdCBuby1yZXBlYXQ7XCI+U2F2ZTwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiYm9yZGVyLXRvcC1sZWZ0LXJhZGl1czogMnB4OyBib3JkZXItdG9wLXJpZ2h0LXJhZGl1czogMnB4OyBib3JkZXItYm90dG9tLXJpZ2h0LXJhZGl1czogMnB4OyBib3JkZXItYm90dG9tLWxlZnQtcmFkaXVzOiAycHg7IHRleHQtaW5kZW50OiAyMHB4OyB3aWR0aDogYXV0bzsgcGFkZGluZzogMHB4IDRweCAwcHggMHB4OyB0ZXh0LWFsaWduOiBjZW50ZXI7IGZvbnQtc3R5bGU6IG5vcm1hbDsgZm9udC12YXJpYW50LWNhcHM6IG5vcm1hbDsgZm9udC13ZWlnaHQ6IGJvbGQ7IGZvbnQtc3RyZXRjaDogbm9ybWFsOyBmb250LXNpemU6IDExcHg7IGxpbmUtaGVpZ2h0OiAyMHB4OyBmb250LWZhbWlseTogJ0hlbHZldGljYSBOZXVlJywgSGVsdmV0aWNhLCBzYW5zLXNlcmlmOyBjb2xvcjogI2ZmZmZmZjsgYmFja2dyb3VuZC1pbWFnZTogdXJsKGRhdGE6aW1hZ2Uvc3ZnK3htbDsgYmFzZTY0LHBobjJ6eWI0Ynd4dWN6MGlhaHIwY2RvdmwzZDNkeTUzbXk1dmNtY3ZtamF3bWM5emRtY2lpZ2hsYXdkb2RkMGltemJ3ZWNpZ2QybGtkZ2c5aWptd2NoZ2lpaHpwenhkY2IzZzlpaTB4aWMweGlkbXhpZG14aWo0OHp6NDhjZ2YwYWNia3Bzam5tamt1bmRxNWxkZTBsankybWliZG1qa3VuZHE1bGRpeWxqY3ltaWF5bWk0NG5qZ3Ntamt1bWp1MmlkZTBsamMxbGRpNWxqaTFuaWJkbmk0Mm16aXNtamt1bWp1MmlkYXVtZHV4bGRpeWxqY3ltaWF3bGphMW1zd3huYzQybmppZ3F6YXVtZHV4bGR5dW5qYXhpZHl1bmpteWxkYXVtZHkzaWRlMGxqYzFsZGF1bWR5M2llbXltaTQ0bmpnc21jNHduamNnbWprdW5kcTVsZHl1bmpheGlkaTVsanEwb3N3eG5jNDJuamlpaWd6cGJndzlpaW5tem15aWlobjBjbTlyenQwaWkyem16aWlnYzNyeWIydGxseGRwemhyb3BzaXhpajQ4bDNiaGRnZytwaGJoZGdnZ3pkMGl0dGUwbGpjem15d3hsank0bmliZG55NDFtdHlzbXM0Mm9keWdtczQybmp1c255NDBvdHVnbXM0Mm5qdXNtdHF1bmp5eWllbXhsankybnN3eW1jNHhudGtnbnM0eG1ka3NtanF1b2R1MGlka3VvdGNzbWp5dW56cTBpZW01bGpnMW5pd3luczQzbXRnZ29zNDNudG1zbWpxdW10cXppZGV3bGpheG5pd3lteTR3bWppZ3F6ZXdsamkxbXl3eW1pNHdtc2F4bXM0MW5kZ3NtdHl1bnRjeWlkZXhsanUwb2N3eG5pNDFuemlncXpleGxqdTBvY3d4bmk0MW56aWdtdGV1bXR1M2xkZTFsamM1bnNheG1zNHhudGNzbXRxdW5qcTJpZW14bXM0eG50Y3NtdGl1b2RxeWlkZXlsaml4bXN3eG1zNDBvdHVnbXRtdW50aXlsZGV4bGpxNW5zYmRtdHF1bmptM2xkZXhsanE1bnNheG5zNHhuenVzbXRpdW16aTJpZGUxbGplM25zd3hteTR6bWptZ3F6ZTFsamUzbnN3eG5jNDBtenlnbXRxdW5keXlsZGUybGplZ210cXVtZGt6bGRlM2xqeTBteWJkbXRtdW56ZzFsZGU0bGprem5zYXhuYzQzbmR1c210a3VvdGc0aWRlMmxqYXlvY3d4b3M0NW9kZ2dxemU0bGptMW1zd3hvczQ1b2RnZ21qYXVtdG0ybGRlM2xqdTFuaWF5bWM0eG16eXNtdHF1bWRxMmllbXltYzR4bXp5c210YXVvdG01aWRlM2xqZzRvY3c0bGpjMm55YXhuYzQybnpnc29jNDNuamNncXpld2xqazFvc3c0bGpjMm55YTRsamMzbnl3eG1zNDFtenlnb2M0M256Y3NtdHF1bXprNGllbTRsamMzbnl3eG5zNDFtdG1nb3M0eW1zd3huaTQzbWRrZ29zNDNuZGtzbXRjdW16dTVpZW01bGpnMW5pd3hueTQwb2RnZ29zNDRuemlzbXRjdW5pYTVsamcwbGRlM2xqY3ptc2Jkb3M0M25kZXNtdGd1bXRxeGlka3VudGlzbXRrdW1kaXppZGt1bmRjM2xkZTVsaml3bXliZG9zNDBtaXd4b3M0MG5jYTVsamk0b2N3eG9zNDBvdGVnb3M0d25jd3hvczR6bnp5Z3F6Y3VuZGE0bGRlNGxqeXltaWEybGptNG55d3huaTR5bnRpZ25pNHpvZGNzbXRxdW16cTVpZW0ybGptNG55d3htYzR5bnR5Z29zNHpvZG1zbmk0MG90Y2dtdHV1bWRpeWxkeXVuZGszaWVteG9zNDFudHVzbmk0MG90Y2dtam11bWRjNGxka3VuemExaWRpemxqYTNvY3d4bXk0NW90ZWdxeml6bGphM29jd3hvYzQwbmptZ21qYXVtam01bGRpeWxqYTJtaWF4bmk0eW90Y3Ntaml1bWR5eWllbXhuYzQ1bnptc21qaXVtZHl5aWRlemxqY3lvY3d5bXM0em56a2dtdG11bXpheWxkaXdsanUzbWliZG10bXVtemF5bGRpd2xqdTNtaWF4bWk0Mm5kY3Ntam11bWR1Z210aXVuZGc0bGRpemxqeTFueWJkbXRpdW10a3psZGkwbGpjNG5jYXhtczR6b3R5c21qeXVtdGsyaWRld2xqZzJteXd5bnk0d250Z2dxemV5bGphNG5pd3lueTQwbXpxZ210bXVtemcybGRpM2xqeXpueWF4bmM0M216bXNtamN1bmptM2llbXltczQ1bnN3eW55NDJtemNnbWpjdW9kYXhsZGl4bGpneW9jYXlueTQ0bWRlc210cXVuanl5aWVteW55NDRtZGVzbnk0MG90dWdtamV1b3R1c21zNDJvZHlnbXRxdW56bXpsZGV1bmpnMmlpYm1hd3hzcHNpanltcXdvZGZqaWo0OGwzYmhkZ2crcGM5bnBqd3ZjM3pucGc9PSk7IGJhY2tncm91bmQtc2l6ZTogMTRweCAxNHB4OyBiYWNrZ3JvdW5kLWNvbG9yOiAjYmQwODFjOyBwb3NpdGlvbjogYWJzb2x1dGU7IG9wYWNpdHk6IDE7IHotaW5kZXg6IDg2NzUzMDk7IGRpc3BsYXk6IG5vbmU7IGN1cnNvcjogcG9pbnRlcjsgYm9yZGVyOiBub25lOyAtd2Via2l0LWZvbnQtc21vb3RoaW5nOiBhbnRpYWxpYXNlZDsgYmFja2dyb3VuZC1wb3NpdGlvbjogM3B4IDUwJTsgYmFja2dyb3VuZC1yZXBlYXQ6IG5vLXJlcGVhdCBuby1yZXBlYXQ7XCI+U2F2ZTwvc3Bhbj48c3BhbiBzdHlsZT1cImJvcmRlci10b3AtbGVmdC1yYWRpdXM6IDJweDsgYm9yZGVyLXRvcC1yaWdodC1yYWRpdXM6IDJweDsgYm9yZGVyLWJvdHRvbS1yaWdodC1yYWRpdXM6IDJweDsgYm9yZGVyLWJvdHRvbS1sZWZ0LXJhZGl1czogMnB4OyB0ZXh0LWluZGVudDogMjBweDsgd2lkdGg6IGF1dG87IHBhZGRpbmc6IDBweCA0cHggMHB4IDBweDsgdGV4dC1hbGlnbjogY2VudGVyOyBmb250LXN0eWxlOiBub3JtYWw7IGZvbnQtdmFyaWFudC1jYXBzOiBub3JtYWw7IGZvbnQtd2VpZ2h0OiBib2xkOyBmb250LXN0cmV0Y2g6IG5vcm1hbDsgZm9udC1zaXplOiAxMXB4OyBsaW5lLWhlaWdodDogMjBweDsgZm9udC1mYW1pbHk6ICdIZWx2ZXRpY2EgTmV1ZScsIEhlbHZldGljYSwgc2Fucy1zZXJpZjsgY29sb3I6ICNmZmZmZmY7IGJhY2tncm91bmQtaW1hZ2U6IHVybChkYXRhOmltYWdlL3N2Zyt4bWw7IGJhc2U2NCxwaG4yenliNGJ3eHVjejBpYWhyMGNkb3ZsM2QzZHk1M215NXZjbWN2bWphd21jOXpkbWNpaWdobGF3ZG9kZDBpbXpid2VjaWdkMmxrZGdnOWlqbXdjaGdpaWh6cHp4ZGNiM2c5aWkweGljMHhpZG14aWRteGlqNDh6ejQ4Y2dmMGFjYmtwc2pubWprdW5kcTVsZGUwbGp5Mm1pYmRtamt1bmRxNWxkaXlsamN5bWlheW1pNDRuamdzbWprdW1qdTJpZGUwbGpjMWxkaTVsamkxbmliZG5pNDJtemlzbWprdW1qdTJpZGF1bWR1eGxkaXlsamN5bWlhd2xqYTFtc3d4bmM0Mm5qaWdxemF1bWR1eGxkeXVuamF4aWR5dW5qbXlsZGF1bWR5M2lkZTBsamMxbGRhdW1keTNpZW15bWk0NG5qZ3NtYzR3bmpjZ21qa3VuZHE1bGR5dW5qYXhpZGk1bGpxMG9zd3huYzQybmppaWlnenBiZ3c5aWlubXpteWlpaG4wY205cnp0MGlpMnptemlpZ2MzcnliMnRsbHhkcHpocm9wc2l4aWo0OGwzYmhkZ2crcGhiaGRnZ2d6ZDBpdHRlMGxqY3pteXd4bGp5NG5pYmRueTQxbXR5c21zNDJvZHlnbXM0Mm5qdXNueTQwb3R1Z21zNDJuanVzbXRxdW5qeXlpZW14bGp5Mm5zd3ltYzR4bnRrZ25zNHhtZGtzbWpxdW9kdTBpZGt1b3Rjc21qeXVuenEwaWVtNWxqZzFuaXd5bnM0M210Z2dvczQzbnRtc21qcXVtdHF6aWRld2xqYXhuaXd5bXk0d21qaWdxemV3bGppMW15d3ltaTR3bXNheG1zNDFuZGdzbXR5dW50Y3lpZGV4bGp1MG9jd3huaTQxbnppZ3F6ZXhsanUwb2N3eG5pNDFuemlnbXRldW10dTNsZGUxbGpjNW5zYXhtczR4bnRjc210cXVuanEyaWVteG1zNHhudGNzbXRpdW9kcXlpZGV5bGppeG1zd3htczQwb3R1Z210bXVudGl5bGRleGxqcTVuc2JkbXRxdW5qbTNsZGV4bGpxNW5zYXhuczR4bnp1c210aXVtemkyaWRlMWxqZTNuc3d4bXk0em1qbWdxemUxbGplM25zd3huYzQwbXp5Z210cXVuZHl5bGRlMmxqZWdtdHF1bWRremxkZTNsankwbXliZG10bXVuemcxbGRlNGxqa3puc2F4bmM0M25kdXNtdGt1b3RnNGlkZTJsamF5b2N3eG9zNDVvZGdncXplNGxqbTFtc3d4b3M0NW9kZ2dtamF1bXRtMmxkZTNsanUxbmlheW1jNHhtenlzbXRxdW1kcTJpZW15bWM0eG16eXNtdGF1b3RtNWlkZTNsamc0b2N3NGxqYzJueWF4bmM0Mm56Z3NvYzQzbmpjZ3F6ZXdsamsxb3N3NGxqYzJueWE0bGpjM255d3htczQxbXp5Z29jNDNuemNzbXRxdW16azRpZW00bGpjM255d3huczQxbXRtZ29zNHltc3d4bmk0M21ka2dvczQzbmRrc210Y3VtenU1aWVtNWxqZzFuaXd4bnk0MG9kZ2dvczQ0bnppc210Y3VuaWE1bGpnMGxkZTNsamN6bXNiZG9zNDNuZGVzbXRndW10cXhpZGt1bnRpc210a3VtZGl6aWRrdW5kYzNsZGU1bGppd215YmRvczQwbWl3eG9zNDBuY2E1bGppNG9jd3hvczQwb3RlZ29zNHduY3d4b3M0em56eWdxemN1bmRhNGxkZTRsanl5bWlhMmxqbTRueXd4bmk0eW50aWduaTR6b2Rjc210cXVtenE1aWVtMmxqbTRueXd4bWM0eW50eWdvczR6b2Rtc25pNDBvdGNnbXR1dW1kaXlsZHl1bmRrM2llbXhvczQxbnR1c25pNDBvdGNnbWptdW1kYzRsZGt1bnphMWlkaXpsamEzb2N3eG15NDVvdGVncXppemxqYTNvY3d4b2M0MG5qbWdtamF1bWptNWxkaXlsamEybWlheG5pNHlvdGNzbWppdW1keXlpZW14bmM0NW56bXNtaml1bWR5eWlkZXpsamN5b2N3eW1zNHpuemtnbXRtdW16YXlsZGl3bGp1M21pYmRtdG11bXpheWxkaXdsanUzbWlheG1pNDJuZGNzbWptdW1kdWdtdGl1bmRnNGxkaXpsankxbnliZG10aXVtdGt6bGRpMGxqYzRuY2F4bXM0em90eXNtanl1bXRrMmlkZXdsamcybXl3eW55NHdudGdncXpleWxqYTRuaXd5bnk0MG16cWdtdG11bXpnMmxkaTNsanl6bnlheG5jNDNtem1zbWpjdW5qbTNpZW15bXM0NW5zd3lueTQybXpjZ21qY3VvZGF4bGRpeGxqZ3lvY2F5bnk0NG1kZXNtdHF1bmp5eWllbXlueTQ0bWRlc255NDBvdHVnbWpldW90dXNtczQyb2R5Z210cXVuem16bGRldW5qZzJpaWJtYXd4c3BzaWp5bXF3b2RmamlqNDhsM2JoZGdnK3BjOW5wand2YzN6bnBnPT0pOyBiYWNrZ3JvdW5kLXNpemU6IDE0cHggMTRweDsgYmFja2dyb3VuZC1jb2xvcjogI2JkMDgxYzsgcG9zaXRpb246IGFic29sdXRlOyBvcGFjaXR5OiAxOyB6LWluZGV4OiA4Njc1MzA5OyBkaXNwbGF5OiBub25lOyBjdXJzb3I6IHBvaW50ZXI7IGJvcmRlcjogbm9uZTsgLXdlYmtpdC1mb250LXNtb290aGluZzogYW50aWFsaWFzZWQ7IGJhY2tncm91bmQtcG9zaXRpb246IDNweCA1MCU7IGJhY2tncm91bmQtcmVwZWF0OiBuby1yZXBlYXQgbm8tcmVwZWF0O1wiPlNhdmU8L3NwYW4+Wy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd10iLCJwb3N0X3RpdGxlIjoiRkFTVGxhYjogRnV0dXJlIEFydHMsIFNjaWVuY2UgYW5kIFRlY2hub2xvZ3kgTGFib3JhdG9yeSIsInBvc3RfbGluayI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9mYXN0bGFiLWZ1dHVyZS1hcnRzLXNjaWVuY2UtYW5kLXRlY2hub2xvZ3ktbGFib3JhdG9yeS8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJGQVNUbGFiOiBGdXR1cmUgQXJ0cywgU2NpZW5jZSBhbmQgVGVjaG5vbG9neSBMYWJvcmF0b3J5XCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMjRcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAyMi8wMi9GYXN0TGFiLU96LTMwMHgyMjQuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+IiwicG9zdF9jYXRlZ29yaWVzIjoiTWVkaWEgbGFicyIsInBvc3RfdGFncyI6ImFjYWRlbWljIExhYiwgYWNhZGVtaWMgcmVzZWFyY2gsIGluZHVzdHJ5IGNvbGxhYm9yYXRpb24sIG11bHRpZGlzY2lwbGluYXJ5IiwiJV9lZGl0X2xvY2slIjoiMTY1MjM2MDY1Mjo5MzMiLCIlX2VkaXRfbGFzdCUiOiI5MzMiLCIlc2xpZGVfdGVtcGxhdGUlIjoiIiwiJV93cGJfdmNfanNfc3RhdHVzJSI6InRydWUiLCIlX3dwZ21wX2xvY2F0aW9uX2FkZHJlc3MlIjoiTmV3Y2FzdGxlIE5TVywgQXVzdHJhbGlhIiwiJV93cGdtcF9sb2NhdGlvbl9jaXR5JSI6Ik5ld2Nhc3RsZSIsIiVfd3BnbXBfbG9jYXRpb25fc3RhdGUlIjoiTmV3IFNvdXRoIFdhbGVzIiwiJV93cGdtcF9sb2NhdGlvbl9jb3VudHJ5JSI6IkF1c3RyYWxpYSIsIiVfd3BnbXBfbWV0YWJveF9sYXRpdHVkZSUiOiItMzIuOTI4MjcxMiIsIiVfd3BnbXBfbWV0YWJveF9sb25naXR1ZGUlIjoiMTUxLjc4MTY4MDIiLCIlX3dwZ21wX21ldGFib3hfbG9jYXRpb25fcmVkaXJlY3QlIjoibWFya2VyIiwiJV93cGdtcF9tZXRhYm94X2N1c3RvbV9saW5rJSI6IiIsIiVfd3BnbXBfbWFwX2lkJSI6ImE6MTp7aTowO3M6MTpcIjJcIjt9IiwiJV93cGdtcF9tZXRhYm94X21hcmtlcl9pZCUiOiJOOyIsIiVfd3BnbXBfbWV0YWJveF90YXhvbW9taWVzX3Rlcm1zJSI6Ik47IiwiJV93cGdtcF9leHRlbnNpb25zX2ZpZWxkcyUiOiJOOyIsIiVfeW9hc3Rfd3BzZW9fY29udGVudF9zY29yZSUiOiIzMCIsIiVfeW9hc3Rfd3BzZW9fZXN0aW1hdGVkLXJlYWRpbmctdGltZS1taW51dGVzJSI6IjgiLCIlX3lvYXN0X3dwc2VvX3ByaW1hcnlfY2F0ZWdvcnklIjoiMTQyIiwiJV90aHVtYm5haWxfaWQlIjoiMTU3MDEiLCJ0YXhvbm9teT1jYXRlZ29yeSI6Ik1lZGlhIGxhYnMiLCJ0YXhvbm9teT1wb3N0X3RhZyI6ImFjYWRlbWljIExhYiwgYWNhZGVtaWMgcmVzZWFyY2gsIGluZHVzdHJ5IGNvbGxhYm9yYXRpb24sIG11bHRpZGlzY2lwbGluYXJ5In0sImljb24iOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxOC8wMi9tYXJrZXItMS5wbmcifSwiaWQiOjE1Njk5LCJpbmZvd2luZG93X2Rpc2FibGUiOmZhbHNlfSx7InNvdXJjZSI6InBvc3QiLCJ0aXRsZSI6IkRlciBUYWdlc3NwaWVnZWw6IGludGVyZGlzY2lwbGluYXJ5IGFuZCBhdWRpZW5jZS1lbmdhZ2VkIGlubm92YXRpb24iLCJpbmZvd2luZG93X2NvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIkRlciBUYWdlc3NwaWVnZWw6IGludGVyZGlzY2lwbGluYXJ5IGFuZCBhdWRpZW5jZS1lbmdhZ2VkIGlubm92YXRpb25cIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjExOFwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIxLzEwL1RTLW1hdWVyLTMwMHgxMTguanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZ1wiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tcGFkZGluZy1jb250ZW50XzIwXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tbWV0YSBmYy1pdGVtLXNlY29uZGFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlIGZjLXRleHQtY2VudGVyXCI+TWVkaWEgbGFiczwvZGl2PlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLXRleHQtY2VudGVyXCI+RGVyIFRhZ2Vzc3BpZWdlbDogaW50ZXJkaXNjaXBsaW5hcnkgYW5kIGF1ZGllbmNlLWVuZ2FnZWQgaW5ub3ZhdGlvbjwvZGl2PlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2VcIj5cclxuICAgICAgICAgICAgXHJcbiAgICAgICAgPC9kaXY+XHJcbjxhIGhyZWY9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvZGVyLXRhZ2Vzc3BpZWdlbC1pbnRlcmRpc2NpcGxpbmFyeS1hbmQtYXVkaWVuY2UtZW5nYWdlZC1pbm5vdmF0aW9uL1wiPlJlYWQgbW9yZTwvYT5cclxuICAgIDwvZGl2PlxyXG4gICAgPC9kaXY+XHJcbjwvZGl2PlxyXG5cclxuIiwiYWRkcmVzcyI6IkFza2FuaXNjaGVyIFBsLiAzLCAxMDk2MyBCZXJsaW4sIEdlcm1hbnkiLCJsb2NhdGlvbiI6eyJsYXQiOiI1Mi41MDQ0MzQ4IiwiY2l0eSI6IktyZWlzZnJlaWUgU3RhZHQgQmVybGluIiwic3RhdGUiOiJCZXJsaW4iLCJjb3VudHJ5IjoiR2VybWFueSIsImxuZyI6IjEzLjM4MDg0NzQiLCJvbmNsaWNrX2FjdGlvbiI6Im1hcmtlciIsInJlZGlyZWN0X3Blcm1hbGluayI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9kZXItdGFnZXNzcGllZ2VsLWludGVyZGlzY2lwbGluYXJ5LWFuZC1hdWRpZW5jZS1lbmdhZ2VkLWlubm92YXRpb24vIiwiem9vbSI6MiwiZXh0cmFfZmllbGRzIjp7InBvc3RfZXhjZXJwdCI6IiIsInBvc3RfY29udGVudCI6Ilt2Y19yb3ddW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIyLzNcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxoMT48c3Ryb25nPkRlciBUYWdlc3NwaWVnZWw6IGludGVyZGlzY2lwbGluYXJ5IGFuZCBhdWRpZW5jZS1lbmdhZ2VkIGlubm92YXRpb24gPC9zdHJvbmc+PC9oMT5cclxuPGgzPkRlciBUYWdlc3NwaWVnZWxcdTIwMTlzIElubm92YXRpb24gTGFiIGlzIGEgaHViIGZvciBpbnRlcmRpc2NpcGxpbmFyeSBjb2xsYWJvcmF0aW9uIC0gcHJvZHVjaW5nIHByb2plY3RzIHNwYW5uaW5nIHNlbnNvciBqb3VybmFsaXNtLCBkYXRhIHZpc3VhbGlzYXRpb24gYW5kIGludGVyYWN0aXZlLCBpbW1lcnNpdmUgc3Rvcnl0ZWxsaW5nLjwvaDM+XHJcbkxlZCBieSBIZW5kcmlrIExlaG1hbm4sIHRoZSBMYWIgZW1lcmdlZCBmcm9tIGEgc2VyaWVzIG9mIGluZGl2aWR1YWwgZGF0YSBqb3VybmFsaXNtIHByb2plY3RzLCBcdTAwYTBhbmQgaGFzIGV4cGFuZGVkIHRvIHByb2R1Y2UgYSByYW5nZSBvZiBzdG9yeXRlbGxpbmcgYW5kIHBsYXRmb3JtcyBpbm5vdmF0aW9ucyBmb3IgRGVyIFRhZ2Vzc3BpZWdlbFx1MjAxOXMgbmV3c3Jvb20gb3BlcmF0aW9ucy5cclxuXHJcblRoZWlyIHdvcmsgaXMgZm91bmRlZCBvbiBpbnRlcmRpc2NpcGxpbmFyeSBjb2xsYWJvcmF0aW9uOiB1bml0aW5nIGRhdGEgYW5hbHlzaXMsIHZpc3VhbCBhbmQgaW1tZXJzaXZlIGpvdXJuYWxpc20sIHVyYmFuIHNvY2lvbG9neSBhbmQgc2NpZW5jZSBqb3VybmFsaXNtIHRvIGNyZWF0ZSBtdWx0aXBsZSBwcm9qZWN0cy4gTGVobWFubiBkZXNjcmliZXMgdGhlIElubm92YXRpb24gTGFiIGFzIG9wZW4gYW5kIGVuZ2FnZWQgd2l0aCBwYXJ0bmVycy4gVGhlc2UgcmFuZ2UgYWNyb3NzIE5HT3MsIHVuaXZlcnNpdGllcywgb3RoZXIgcHVibGlzaGVycywgYXVkaWVuY2VzIGFuZCBjaXRpemVucy4gTWFueSBwcm9qZWN0cyBjb2xsYWJvcmF0ZSB3aXRoIERlciBUYWdlc3NwaWVnZWxcdTIwMTlzIHJlYWRlcnMgdG8gZW5hYmxlIG9yIGZ1cnRoZXIgdGhlIHN0b3J5dGVsbGluZywgZW5zdXJpbmcgdGhlIGxhYiBpcyBcdTIwMThyZWFkZXIgZW5nYWdlZFx1MjAxOSBhbmQgY28tb3B0cyBjaXRpemVucyBpbnRvIHRoZSBqb3VybmFsaXNtIGl0IGNyZWF0ZXMuXHJcblxyXG5TaW5jZSBzdGFydGluZyB3aXRoIGFuIGVtcGhhc2lzIG9uIGRhdGEgam91cm5hbGlzbSwgdGhlIGxhYiBoYXMgZXhwYW5kZWQgdG8gZXhwbG9yZSBhIGdyb3dpbmcgcmFuZ2Ugb2YgdG9waWNzIGFuZCBhcHByb2FjaGVzLiBOb3cgY2xhc3NlZCBhcyBhIG5ld3MgZGVwYXJ0bWVudCBpdCBpdHMgb3duIHJpZ2h0LCBpdCBoYXMgYSBjb3JlIHN0YWZmIG9mIGZpdmUgcGVvcGxlLCBidXQgTGVobWFubiBzdWdnZXN0cyB0aGlzIG51bWJlciBtb3ZlcyBhbmQgc2hpZnRzIGRlcGVuZGluZyBvbiB0aGUgcHJvamVjdHMgdGhlIHRlYW0gaXMgd29ya2luZyBvbi4gXHUwMGEwRm9yIGV4YW1wbGUsIGV4dGVybmFsIGZ1bmRpbmcgaGVscHMgdG8gYm9vc3QgdGhlIHNwZWNpYWxpc3Qgc2tpbGxzIGluIHRoZSBsYWIgd2hlbiB0aGV5XHUyMDE5cmUgcmVxdWlyZWQuPHN0cm9uZz5cdTAwYTA8L3N0cm9uZz5cclxuPGgzPjxzdHJvbmc+Tm90YWJsZSBwcm9qZWN0cyA8L3N0cm9uZz48L2gzPlxyXG5BbHRob3VnaCB0aGUgbGFiIHdhcyBpbml0aWFsbHkgbGF1bmNoZWQgaW4gMjAxOSwgc2V2ZXJhbCBtZW1iZXJzIG9mIHRoZSB0ZWFtIGNvbXBsZXRlZCBhIG51bWJlciBvZiBoaWdoIHByb2ZpbGUgYW5kIGF3YXJkLXdpbm5pbmcgcHJvamVjdHMgZnJvbSAyMDE2IG9ud2FyZHMuIExlaG1hbm4gaGlnaGxpZ2h0cyB0d28gdGhhdCBzaG93Y2FzZSB0aGUgYXNwaXJhdGlvbnMgYW5kIGFjaGlldmVtZW50cyBvZiB0aGUgSW5ub3ZhdGlvbiBMYWIgLSB0aGUgYXdhcmQtd2lubmluZyBkYXRhIC8gY3ljbGluZyBwcm9qZWN0IFJhZG1lc3NlciBhbmQgdGhlIGludmVzdGlnYXRpb24gV2VtIGdlaFx1MDBmNnJ0IEJlcmxpbj9cclxuXHJcblRoYXRcdTIwMTlzIG5vdCByZWFsbHkgdHJ1ZSB1bmZvcnR1bmF0ZWx5LiBcdTIwMWVlbWVyZ2VkIG91dCBvZiBhIHNlcmllcyBvZiBpbmRpdmlkdWFsIGRhdGEgam91cm5hbGlzbSBwcm9qZWN0c1x1MjAxY1xyXG5cclxuJm5ic3A7XHJcblxyXG48aW1nIGNsYXNzPVwiYWxpZ25ub25lIHdwLWltYWdlLTE1NjI2IHNpemUtZnVsbFwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIxLzEwL3JhZG1lc3Nlci5wbmdcIiBhbHQ9XCJcIiB3aWR0aD1cIjEzODRcIiBoZWlnaHQ9XCI3ODVcIiAvPlxyXG5cclxuPHN0cm9uZz48ZW0+UmFkbWVzc2VyPC9lbT48L3N0cm9uZz48ZW0+OiBjcmVhdGluZyBhIG5ldyBzdG9yeXRlbGxpbmcgYXBwcm9hY2ggdG8gQmVybGluXHUyMDE5cyBjeWNsaW5nIHN5c3RlbSwgUmFkbWVzc2VyIHByb3ZpZGVzIGludGVyYWN0aXZlIGNvbnRlbnQgdW5kZXJwaW5uZWQgYnkgZGF0YS4gQXVkaWVuY2VzIG5hdmlnYXRlIGFuZCBpbnRlcmFjdCB3aXRoIHRoZSByaWNoIG11bHRpbWVkaWEgY29udGVudC4gSW5zaWdodHMgaW5jbHVkZSBzcGVjaWZpYyBkYW5nZXIgYXJlYXMgZm9yIGN5Y2xpc3RzIFx1MjAxMyBzdWNoIGFzIHN0cmVldHMgd2hlcmUgY2FycyBwYXNzIG1vc3QgY2xvc2VseSB0byBjeWNsaXN0cy4gQSBrZXkgZWxlbWVudCBvZiB0aGUgcHJvamVjdCB3YXMgdG8gd29yayB3aXRoIGF1ZGllbmNlcyB0byBjcmVhdGUgXHUyMDE4c3dhcm0gaW50ZWxsaWdlbmNlXHUyMDE5LCB3aGVyZSB1c2VycyBiZWNhbWUgZGF0YSBjb2xsZWN0b3JzLiBTb21lIDIsNTAwIHBlb3BsZSB2b2x1bnRlZXJlZCBmb3IgdGhlIHByb2plY3QsIHdpdGggMTAwIHBlb3BsZSB0YWtpbmcgc2Vuc29ycyBhbmQgdXNpbmcgdGhlbS4gVGhleSB0cmFja2VkIGNpdHkgcm91dGVzIGFuZCB0aGVpciBleHBlcmllbmNlcyBvZiBzYWZldHkgd2hpbGUgcmlkaW5nIGFyb3VuZCB0aGUgY2l0eS4gUmFkbWVzc2VyIGFsc28gbG9va2VkIGF0IHNvbHV0aW9ucyBcdTIwMTMgd2hhdCBjYW4gQmVybGluIGxlYXJuIGZyb20gY2l0aWVzIHN1Y2ggYXMgQ29wZW5oYWdlbi5cdTAwYTA8L2VtPlxyXG5cclxuJm5ic3A7XHJcblxyXG48ZW0+PGltZyBjbGFzcz1cImFsaWdubm9uZSBzaXplLWxhcmdlIHdwLWltYWdlLTE1NjI3XCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMjEvMTAvR2Vob3J0LUJlcmxpbi0xMDI0eDYyNi5wbmdcIiBhbHQ9XCJcIiB3aWR0aD1cIjEwMjRcIiBoZWlnaHQ9XCI2MjZcIiAvPjwvZW0+XHJcblxyXG48c3Ryb25nPjxlbT5XZW0gZ2VoXHUwMGY2cnQgQmVybGluPC9lbT48L3N0cm9uZz48ZW0+PzogV29ya2luZyB3aXRoIGFuIGVuZ2FnZWQgYXVkaWVuY2UgYW5kIGluIGNvb3BlcmF0aW9uIHdpdGggaW5kZXBlbmRlbnQgYW5kIG5vbi1mb3ItcHJvZml0IHJlc2VhcmNoIGNlbnRyZSBDT1JSRUNUSVYsIGFuZCBhIHJhbmdlIG9mIHBhcnRuZXJzLCBXZW0gZ2VoXHUwMGY2cnQgQmVybGluPyBleHBsb3JlcyBwcm9wZXJ0eSBvd25lcnNoaXAgdGhyb3VnaG91dCB0aGUgY2l0eS4gSXQgYXNrcyB3aGljaCBwcm9wZXJ0eSBvd25lcnMgaGF2ZSBhIHNpZ25pZmljYW50IGltcGFjdCBvbiB0aGUgaG91c2luZyBtYXJrZXQgYW5kIHdoaWNoIG93bmVycyBwb3RlbnRpYWxseSBhY3QgaWxsZWdhbGx5IG9yIHF1ZXN0aW9uYWJseT8gQXVkaWVuY2VzIGVuZ2FnZWQgd2l0aCB0aGUgcHJvamVjdCB0aHJvdWdoIGNvbXBsZXRpbmcgc3VydmV5cywgYW5kIHRoZSBwaWVjZSBjcmVhdGVkIGEgcmFuZ2Ugb2YgaW50ZXJhY3RpdmUgY29udGVudCBleHBsb3JpbmcgdGhlIGVtZXJnZW50IG1hcmtldCwgb3duZXJzaGlwIHN0cnVjdHVyZSBhbmQgaG93IDEyIGhvdXNpbmcgY29tcGFuaWVzIG93biAyNTAsMDAwIGFwYXJ0bWVudHMgdGhyb3VnaG91dCB0aGUgY2l0eS4gSW50ZXJlc3RpbmdseSwgc2l4IG9mIHRoZXNlIGNvbXBhbmllcyBhcmUgcHVibGljIGNvbXBhbmllcyB3aG8gc2hhcmUgdGhlIHNhbWUgaW52ZXN0b3JzLiBUaGUgaW52ZXN0aWdhdGlvbiBjb250aW51ZWQgYmV5b25kIHRoZSBsYWIgYXMgQ09SUkVDVElWIGNvbnRpbnVlZCB0byB3b3JrIHdpdGggbmV3IGxvY2FsIG1lZGlhIHBhcnRuZXJzLiA8L2VtPlxyXG5cclxuJm5ic3A7XHJcblxyXG48aW1nIGNsYXNzPVwiYWxpZ25ub25lIHNpemUtZnVsbCB3cC1pbWFnZS0xNTYyOFwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIxLzEwL0NpdGllcy00LXJlbnQucG5nXCIgYWx0PVwiXCIgd2lkdGg9XCIxMzg0XCIgaGVpZ2h0PVwiOTIyXCIgLz5cclxuXHJcbjxzdHJvbmc+PGVtPkNpdGllcyA0IFJlbnQ8L2VtPjwvc3Ryb25nPjxlbT46IENvbnRpbnVlZCBhcyBhIGZvbGxvdy11cCB0bzxzdHJvbmc+IFdlbSBnZWhcdTAwZjZydCBCZXJsaW4/Ljwvc3Ryb25nPiBcdTAwYTBUaGUgaW52ZXN0aWdhdGlvbiwgY29uZHVjdGVkIHR3byB5ZWFycyBhZnRlciB0aGUgaW5pdGlhbCBwcm9qZWN0LCBjcm9zc2VkIDE2IGNpdGllcyBhY3Jvc3MgRXVyb3BlLCBzb21lIG9mIHdoaWNoIGFyZSBzdGlsbCB5ZXQgdG8gcmVwb3J0LiBMZWhtYW5uIGV4cGxhaW5zIHRoYXQgdGhlIExhYiBoYWQgYSBmdXJ0aGVyIHJvbGUgdG8gY3JlYXRlIGEgaGFybW9uaXNlZCB2aXN1YWwgaWRlbnRpdHkgd2l0aGluIHRoaXMgcHJvamVjdCB0aGF0IHdvdWxkIGJlIHNoYXJlZCBiZXR3ZWVuIGFsbCB0aGUgcGFydG5lcnMuIFRoZSBwcm9qZWN0IHRyYWNrZWQgdGhlIHJpc2luZyBpbnZlc3RtZW50cywgY29zdHMgb2YgbGl2aW5nIGFuZCBob3cgdGhlIGludmVzdG1lbnRcdTIwMTNyZW50YWwgY3ljbGUgaXMgbWFraW5nIGNpdGllcyBpbmNyZWFzaW5nbHkgdW5hZmZvcmRhYmxlLiA8L2VtPlxyXG5cclxuQmV5b25kIHRoZXNlIHR3byBwcm9qZWN0cywgdGhlIGxhYiBlbmdhZ2VzIGluIGEgPGEgaHJlZj1cImh0dHBzOi8vaW50ZXJha3Rpdi50YWdlc3NwaWVnZWwuZGUvXCI+dmFyaWV0eSBvZiB3b3JrPC9hPiBzcGFubmluZyBpbW1lcnNpdmUgYW5kIGludGVyYWN0aXZlIGNvbnRlbnQuIEluIGV4cGxvcmluZyB0aGVzZSBwbGF0Zm9ybXMsIGVhY2ggY29tYmluaW5nIGRhdGEsIGRhdGEgdmlzdWFsaXNhdGlvbnMgYW5kIHJpY2ggbWVkaWEsIHRoZSBJbm5vdmF0aW9uIExhYiBoYXMgZ2VuZXJhdGVkIGl0cyBvd24gY29kZSBiYXNlIGZvciBcdTIwMThsaW5lYXJcdTIwMTkgY29udGVudC5cclxuXHJcbkxlaG1hbm4gZXhwbGFpbnMgaXQgXHUyMDFjYmVjYW1lIG9uZSBvZiBvdXIgbWFpbiBbYWN0aXZpdGllc107IHRvIGRldmVsb3Agb3VyIG93biBraW5kIG9mIGNvZGUgYmFzZSBmb3IgbGluZWFyIHN0b3J5dGVsbGluZyB0aGF0IGEgQ01TIGNhbid0IGRvXHUyMDFkLiBJbiB0aGlzIHdheSB0aGUgbGFiIGhhcyBhIFx1MjAxY2ZvcmVydW5uZXIgZnVuY3Rpb24gYmVjYXVzZSB3ZSBjYW4gZG8gdGhpbmdzIHRoYXQgbm8gb25lIGNhbiBkbyBhbHJlYWR5IHdpdGggdGhlIHJlZ3VsYXIgQ01TLlx1MjAxZCBIZSBhZGRzIHRoaXMgYXBwcm9hY2ggaGFzIGFuIFx1MjAxOGVtcG93ZXJpbmdcdTIwMTkgZWZmZWN0IGZvciBzb21lIGluIHRoZSBuZXdzcm9vbSwgYWxsb3dpbmcgam91cm5hbGlzbSBpbiBuZXcgd2F5cy5cclxuPGgzPjxzdHJvbmc+SW50ZXJkaXNjaXBsaW5hcnkgY2FwYWNpdHkgZm9yIGlubm92YXRpb24gPC9zdHJvbmc+PC9oMz5cclxuVG8gY3JlYXRlIHRoZXNlIHBpZWNlcywgYW5kIHRoZSBkYXRhIHRoYXQgdW5kZXJwaW5zIHRoZW0sIHRoZSBMYWIgaGFzIGEgc21hbGwgZ3JvdXAgb2YgZml2ZSBzdGFmZiB3aG8gYnJpbmcgYSByYW5nZSBvZiBza2lsbHMgdG8gdGhlIGlubm92YXRpb24gd29yay4gVGhlc2UgaW5jbHVkZSBtdWx0aW1lZGlhIHN0b3J5dGVsbGluZywgZGF0YSBhbmFseXNpcywgY29kaW5nIGFuZCBkZXNpZ24uIEJ1dCBMZWhtYW5uIGRlc2NyaWJlcyB0aGlzIHRlYW0gYXMgZmxleGlibGUsIGV4cGFuZGluZyB0byBwdWxsIGluIGRpZmZlcmVudCByYW5nZXMgb2YgZXhwZXJ0aXNlIGRlcGVuZGluZyBvbiB0aGUgcHJvamVjdFx1MjAxOXMgcmVxdWlyZW1lbnRzIGFuZCBhdmFpbGFibGUgZnVuZGluZy5cclxuXHJcblRoaXMgYXBwcm9hY2ggYWxzbyB0YWtlcyBhZHZhbnRhZ2Ugb2YgcmVsYXRpb25zaGlwcyB3aXRoIGEgcmFuZ2Ugb2YgcGFydG5lcnMgYWNyb3NzIG5vdC1mb3ItcHJvZml0IG9yZ2FuaXNhdGlvbnMgYW5kIHVuaXZlcnNpdGllcy4gVGhlc2UgY29sbGFib3JhdGlvbnMgYm90aCBpbnNwaXJlIG5ldyBpZGVhcyBhbmQgaGVscCB0byBkZWxpdmVyIHByb2plY3RzIHRoYXQgbWFrZSBpdCBiZXlvbmQgdGhlIGNvbmNlcHQgb3IgZnVuZGluZyBzdGFnZS5cclxuXHJcbjxpbWcgY2xhc3M9XCJhbGlnbm5vbmUgc2l6ZS1mdWxsIHdwLWltYWdlLTE1NjI5XCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMjEvMTAvVFMtcGljLTQucG5nXCIgYWx0PVwiXCIgd2lkdGg9XCIxMzg0XCIgaGVpZ2h0PVwiMTIxNlwiIC8+XHJcblxyXG4mbmJzcDtcclxuPGgzPjxzdHJvbmc+SW5ub3ZhdGlvbiBpbiB0aGUgdGltZSBvZiBDb3ZpZCA8L3N0cm9uZz48L2gzPlxyXG5UaGUgQ292aWQgMTkgcGFuZGVtaWMgY29uc3VtZWQgbXVjaCBvZiB0aGUgbGFiXHUyMDE5cyB0aW1lLiBMZWhtYW5uIHN1Z2dlc3RzIHRoZSBkYXRhIHdvcmsgY29uZHVjdGVkIGJ5IHRoZSBsYWIgaGFzIHBsYWNlZCBpdCBzcXVhcmVseSB3aXRoaW4gdGhlIG9wZXJhdGlvbnMgb2YgRGVyIFRhZ2Vzc3BpZWdlbFx1MjAxOXMgbmV3c3Jvb20uIFRoaXMgd29yayBoYXMgcmFuZ2VkIGZyb20gY3JlYXRpbmcgZGF0YS1kcml2ZW4gcGllY2VzIGFuZCB2aXN1YWxpc2F0aW9ucyBvbiB0aGUgcGFuZGVtaWMgYXMgaXQgaGFzIHVuZm9sZGVkLCBidXQgYWxzbyBpbiBwcm92aWRpbmcgZXNzZW50aWFsIHNlcnZpY2VzIHRvIHRoZSBlZGl0b3JpYWwgdGVhbXMgbW9yZSBicm9hZGx5LlxyXG5cclxuTGVobWFubiBleHBsYWluczogXHUyMDFjQ292aWQgW3NhdyB1c10gYmVjb21lIHBhcnQgb2YgdGhlIGNvcmUgb2YgdGhlIG5ld3Nyb29tXHUyMDI2IEV2ZXJ5b25lIG5lZWRzIHRvIGdldCBkYXRhIGV2ZXJ5IGRheS4gU28sIHdlIGRldmVsb3BlZCBhbiBpbnRlcm5hbCB0b29sIHRoYXQganVzdCBhbGxvd3MgdGhlIHByaW50IGVkaXRvcnMgdG8gZXhwb3J0IGdyYXBoaWNzIHRoYXQgYXJlIGxpdmUgYXQgdGhlIHRpbWUgdGhleSBuZWVkIHRoZW0gYW5kIHRoZSBzYW1lIGZvcm1hdFx1MjAyNiBzbyBbdGhpc10gaGFzIHJlYWxseSBwdXNoZWQgdXMgdG8gdGhlIGNvcmUgb2YgdGhlIG5ld3Nyb29tXHUyMDFkLlxyXG5cclxuQSBmdXJ0aGVyIGVsZW1lbnQgdG8gdGhlIGxhYiBpcyBob3cgaXRcdTIwMTlzIGJ1aWxkaW5nIHVwIGtub3dsZWRnZSBhbmQgZXhwZXJpZW5jZSB0aHJvdWdoIHRoZSBwcm9qZWN0cyBpdCBydW5zLiBMZWhtYW4gc3VnZ2VzdHMgdGhhdCBvdmVyIHRpbWUsIHRoZXNlIGxlYXJuaW5ncyBcdTIwMTMgZnJvbSBib3RoIHN1Y2Nlc3NmdWwgYW5kIHVuc3VjY2Vzc2Z1bCBwcm9qZWN0cyAtIGZsb3cgaW50byBmdXR1cmUgYWN0aXZpdGllcy4gRm9yIGV4YW1wbGUsIGEgcHJvamVjdCB1c2luZyBhdWdtZW50ZWQgcmVhbGl0eSB0byBleHBsb3JlIEdlcm1hbiByZS11bmlmaWNhdGlvbiBwcm92aWRlZCBpbnNpZ2h0cyBpbnRvIEFSIHRlY2gsIHRoYXQgTGVobWFubiBmZWVscyBjYW4gYmUgZGVwbG95ZWQgaW4gcHJvamVjdHMgdGhhdCB1dGlsaXNlIGF1Z21lbnRlZCByZWFsaXR5IGluIHRoZSBmdXR1cmUuIFRoZXNlIGluc2lnaHRzIGFsc28gc3Bhbm5lZCBjb21tZXJjaWFsIGNvbmNlcm5zLCBzdWNoIGFzIGhvdyBBUiBjb3VsZCBnZW5lcmF0ZSByZXZlbnVlIHN0cmVhbXMuXHJcbjxoMz48c3Ryb25nPldoYXQgbmV4dD88L3N0cm9uZz48L2gzPlxyXG5Mb29raW5nIHRvIHRoZSBmdXR1cmUsIExlaG1hbm4gc3VnZ2VzdHMgdGhhdCB0aGUgTGFiIHdpbGwgY29udGludWUgdG8gd29yayBvbiBzb21lIG9mIHRoZSBrZXkgYXJlYXMgaXRcdTIwMTlzIGRldmVsb3BlZCBvdmVyIHJlY2VudCB5ZWFycyBhcyBzdWNoIHVyYmFuIHBsYW5uaW5nLCByZXNpZGVudGlhbCBvd25lcnNoaXAsIHRyYWZmaWMsIHNvY2lhbCBuZXR3b3JrcyBhbmQgdG8gZW5nYWdlIHJlYWRlcnMgdG8gaGVscCB0aGVtIHRlbGwgdGhlIHN0b3JpZXMgdGhleSBjb3Zlci5cclxuXHJcblx1MjAxY1VyYmFuIHRyYWZmaWMsIHRoZSBtb2JpbGl0eSByZXZvbHV0aW9uLCBob3VzaW5nLiBCZWNhdXNlIGl0J3MgZ29pbmcgdG8gYmUgYSBuZXcgZXhwcmVzc2lvbiBvZiBvdXIgdGltZXMuXHUyMDFkXHJcblxyXG5OZXcgcHJvamVjdHMgaW52b2x2aW5nIGNsaW1hdGUgY2hhbmdlIGFuZCBwb2xpY3kgaW4gQWZyaWNhLCBtYWNoaW5lIGxlYXJuaW5nIGFuZCB0byBmb2N1cyBvbiBhZHZhbmNlZCBkYXRhIGFuYWx5c2lzIGFuZCB2aXN1YWxpc2F0aW9uLlxyXG5cclxuJm5ic3A7XHJcblxyXG5DT05UQUNUIFBPSU5UXHJcbjxpbWcgY2xhc3M9XCJhbGlnbm5vbmUgc2l6ZS1tZWRpdW0gd3AtaW1hZ2UtMTU2MzBcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAyMS8xMC9oZW5kcmlrX2xlaG1hbm4tMzAweDIwMC5qcGdcIiBhbHQ9XCJcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjIwMFwiIC8+XHJcblxyXG5IZW5kcmlrIExlaG1hbm4sIGhlYWQgb2YgRGVyIFRhZ2Vzc3BpZWdlbCBJbm5vdmF0aW9uIExhYlxyXG5cclxuVHdpdHRlcjogPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vcGxhdGVhdXRvblwiPkBwbGF0ZWF1dG9uPC9hPlxyXG5cclxuJm5ic3A7XHJcblxyXG4mbmJzcDtcclxuXHJcbiZuYnNwO1xyXG5cclxuPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vYmxhY2t0YXJtYWNcIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPlx1MjAwZjwvYT5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMi8zXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48aDM+QXV0aG9yPC9oMz5cclxuW3NpbXBsZS1hdXRob3ItYm94XVsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XSIsInBvc3RfdGl0bGUiOiJEZXIgVGFnZXNzcGllZ2VsOiBpbnRlcmRpc2NpcGxpbmFyeSBhbmQgYXVkaWVuY2UtZW5nYWdlZCBpbm5vdmF0aW9uIiwicG9zdF9saW5rIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL2Rlci10YWdlc3NwaWVnZWwtaW50ZXJkaXNjaXBsaW5hcnktYW5kLWF1ZGllbmNlLWVuZ2FnZWQtaW5ub3ZhdGlvbi8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJEZXIgVGFnZXNzcGllZ2VsOiBpbnRlcmRpc2NpcGxpbmFyeSBhbmQgYXVkaWVuY2UtZW5nYWdlZCBpbm5vdmF0aW9uXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIxMThcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAyMS8xMC9UUy1tYXVlci0zMDB4MTE4LmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6Ik1lZGlhIGxhYnMiLCJwb3N0X3RhZ3MiOiIiLCIlX2VkaXRfbG9jayUiOiIxNjQ2MDY2MTg0OjQiLCIlX2VkaXRfbGFzdCUiOiI0IiwiJV9vZW1iZWRfOGQ4MjAxZjIyN2MzNGU3ODU0YzU1Yzk2Zjk5YTZmZjMlIjoie3t1bmtub3dufX0iLCIlc2xpZGVfdGVtcGxhdGUlIjoiZGVmYXVsdCIsIiVfd3BiX3ZjX2pzX3N0YXR1cyUiOiJ0cnVlIiwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6IkFza2FuaXNjaGVyIFBsLiAzLCAxMDk2MyBCZXJsaW4sIEdlcm1hbnkiLCIlX3dwZ21wX2xvY2F0aW9uX2NpdHklIjoiS3JlaXNmcmVpZSBTdGFkdCBCZXJsaW4iLCIlX3dwZ21wX2xvY2F0aW9uX3N0YXRlJSI6IkJlcmxpbiIsIiVfd3BnbXBfbG9jYXRpb25fY291bnRyeSUiOiJHZXJtYW55IiwiJV93cGdtcF9tZXRhYm94X2xhdGl0dWRlJSI6IjUyLjUwNDQzNDgiLCIlX3dwZ21wX21ldGFib3hfbG9uZ2l0dWRlJSI6IjEzLjM4MDg0NzQiLCIlX3dwZ21wX21ldGFib3hfbG9jYXRpb25fcmVkaXJlY3QlIjoibWFya2VyIiwiJV93cGdtcF9tZXRhYm94X2N1c3RvbV9saW5rJSI6IiIsIiVfd3BnbXBfbWFwX2lkJSI6ImE6MTp7aTowO3M6MTpcIjJcIjt9IiwiJV93cGdtcF9tZXRhYm94X21hcmtlcl9pZCUiOiJOOyIsIiVfd3BnbXBfbWV0YWJveF90YXhvbW9taWVzX3Rlcm1zJSI6Ik47IiwiJV93cGdtcF9leHRlbnNpb25zX2ZpZWxkcyUiOiJOOyIsIiVfeW9hc3Rfd3BzZW9fY29udGVudF9zY29yZSUiOiIzMCIsIiVfeW9hc3Rfd3BzZW9fZXN0aW1hdGVkLXJlYWRpbmctdGltZS1taW51dGVzJSI6IjYiLCIlX3lvYXN0X3dwc2VvX3ByaW1hcnlfY2F0ZWdvcnklIjoiMTQyIiwiJV90aHVtYm5haWxfaWQlIjoiMTU2MzMiLCJ0YXhvbm9teT1jYXRlZ29yeSI6Ik1lZGlhIGxhYnMiLCJ0YXhvbm9teT1wb3N0X3RhZyI6IiJ9LCJpY29uIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTgvMDIvbWFya2VyLTEucG5nIn0sImlkIjoxNTYyNSwiaW5mb3dpbmRvd19kaXNhYmxlIjpmYWxzZX0seyJzb3VyY2UiOiJwb3N0IiwidGl0bGUiOiJGdXR1cmUgTWVkaWEgSHViczogYnVpbGRpbmcgYSBtZWRpYSBpbm5vdmF0aW9uIG5ldHdvcmsgaW4gdGhlIGhlYXJ0IG9mIEV1cm9wZSIsImluZm93aW5kb3dfY29udGVudCI6IjxkaXYgY2xhc3M9XCJmYy1pdGVtLWJveCBmYy1pdGVtLW5vLXBhZGRpbmdcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiRnV0dXJlIE1lZGlhIEh1YnM6IGJ1aWxkaW5nIGEgbWVkaWEgaW5ub3ZhdGlvbiBuZXR3b3JrIGluIHRoZSBoZWFydCBvZiBFdXJvcGVcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjEwMFwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIxLzA4LzE1MDB4NTAwLTMwMHgxMDAuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZ1wiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tcGFkZGluZy1jb250ZW50XzIwXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tbWV0YSBmYy1pdGVtLXNlY29uZGFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlIGZjLXRleHQtY2VudGVyXCI+TWVkaWEgbGFiczwvZGl2PlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLXRleHQtY2VudGVyXCI+RnV0dXJlIE1lZGlhIEh1YnM6IGJ1aWxkaW5nIGEgbWVkaWEgaW5ub3ZhdGlvbiBuZXR3b3JrIGluIHRoZSBoZWFydCBvZiBFdXJvcGU8L2Rpdj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1jb250ZW50IGZjLWl0ZW0tYm9keS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+XHJcbiAgICAgICAgICAgIEFuIGludGVybmF0aW9uYWwgbmV0d29yayBvZiBzYW5kYm94ZXMsIGlubm92YXRpb24gbGFicyBhbmQgYWNjZWxlcmF0b3JzIGFsbG93cyBpdHMgbWVkaWEgb3JnYW5pc2F0aW9uIG1lbWJlcnMgdG8gZXhjaGFuZ2UgbGVhcm5pbmdzIGZyb20gdGhlaXIgaW5ub3ZhdGlvbiBwcm9qZWN0cyBhbmQgbWFrZSBjb25uZWN0aW9ucyB3aXRoIHRoZSBzdGFydHVwIGVjb3N5c3RlbS5cclxuICAgICAgICA8L2Rpdj5cclxuPGEgaHJlZj1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9mdXR1cmUtbWVkaWEtaHVicy1idWlsZGluZy1hLW1lZGlhLWlubm92YXRpb24tbmV0d29yay1pbi10aGUtaGVhcnQtb2YtZXVyb3BlL1wiPlJlYWQgbW9yZTwvYT5cclxuICAgIDwvZGl2PlxyXG4gICAgPC9kaXY+XHJcbjwvZGl2PlxyXG5cclxuIiwiY29udGVudCI6IkFuIGludGVybmF0aW9uYWwgbmV0d29yayBvZiBzYW5kYm94ZXMsIGlubm92YXRpb24gbGFicyBhbmQgYWNjZWxlcmF0b3JzIGFsbG93cyBpdHMgbWVkaWEgb3JnYW5pc2F0aW9uIG1lbWJlcnMgdG8gZXhjaGFuZ2UgbGVhcm5pbmdzIGZyb20gdGhlaXIgaW5ub3ZhdGlvbiBwcm9qZWN0cyBhbmQgbWFrZSBjb25uZWN0aW9ucyB3aXRoIHRoZSBzdGFydHVwIGVjb3N5c3RlbS4iLCJhZGRyZXNzIjoiQnJ1c3NlbHMsIEJlbGdpdW0iLCJsb2NhdGlvbiI6eyJsYXQiOiI1MC44NTAzMzk2IiwiY2l0eSI6IkJydXNzZWxzIiwic3RhdGUiOiJCcnVzc2VscyIsImNvdW50cnkiOiJCZWxnaXVtIiwibG5nIjoiNC4zNTE3MTAzIiwib25jbGlja19hY3Rpb24iOiJtYXJrZXIiLCJyZWRpcmVjdF9wZXJtYWxpbmsiOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvZnV0dXJlLW1lZGlhLWh1YnMtYnVpbGRpbmctYS1tZWRpYS1pbm5vdmF0aW9uLW5ldHdvcmstaW4tdGhlLWhlYXJ0LW9mLWV1cm9wZS8iLCJ6b29tIjoyLCJleHRyYV9maWVsZHMiOnsicG9zdF9leGNlcnB0IjoiQW4gaW50ZXJuYXRpb25hbCBuZXR3b3JrIG9mIHNhbmRib3hlcywgaW5ub3ZhdGlvbiBsYWJzIGFuZCBhY2NlbGVyYXRvcnMgYWxsb3dzIGl0cyBtZWRpYSBvcmdhbmlzYXRpb24gbWVtYmVycyB0byBleGNoYW5nZSBsZWFybmluZ3MgZnJvbSB0aGVpciBpbm5vdmF0aW9uIHByb2plY3RzIGFuZCBtYWtlIGNvbm5lY3Rpb25zIHdpdGggdGhlIHN0YXJ0dXAgZWNvc3lzdGVtLiIsInBvc3RfY29udGVudCI6Ilt2Y19yb3ddW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIyLzNcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxoMT5GdXR1cmUgTWVkaWEgSHViczogYnVpbGRpbmcgYSBtZWRpYSBpbm5vdmF0aW9uIG5ldHdvcmsgaW4gdGhlIGhlYXJ0IG9mIEV1cm9wZTwvaDE+XHJcbjxzdHJvbmc+QW4gaW50ZXJuYXRpb25hbCBuZXR3b3JrIG9mIHNhbmRib3hlcywgaW5ub3ZhdGlvbiBsYWJzIGFuZCBhY2NlbGVyYXRvcnMgYWxsb3dzIGl0cyBtZWRpYSBvcmdhbmlzYXRpb24gbWVtYmVycyB0byBleGNoYW5nZSBsZWFybmluZ3MgZnJvbSB0aGVpciBpbm5vdmF0aW9uIHByb2plY3RzIGFuZCBtYWtlIGNvbm5lY3Rpb25zIHdpdGggdGhlIHN0YXJ0dXAgZWNvc3lzdGVtLjwvc3Ryb25nPlxyXG48dWw+XHJcbiBcdDxsaT48c3Ryb25nPlRoZSBGdXR1cmUgTWVkaWEgSHVicyBpcyBhIGdyb3VwIG9mIGNvbW11bml0aWVzIHRoYXQgY29ubmVjdCBtZWRpYSBjb21wYW5pZXMgYWNyb3NzIEV1cm9wZSwgaGVscGluZyB0aGVtIGdhaW4gbmV3IGV4cGVydGlzZSBieSBzaGFyaW5nIGluc2lnaHRzLjwvc3Ryb25nPjwvbGk+XHJcbiBcdDxsaT48c3Ryb25nPlRoZSBuZXR3b3JrIGlzIGFsc28gY2xvc2VseSBjb25uZWN0ZWQgdG8gdGhlIG1lZGlhIHN0YXJ0dXAgc2NlbmUgYW5kIGZhY2lsaXRhdGVzIGNvbGxhYm9yYXRpb25zIGJldHdlZW4gbWVkaWEgb3JnYW5pc2F0aW9ucyBhbmQgc3RhcnR1cHMuPC9zdHJvbmc+PC9saT5cclxuIFx0PGxpPjxzdHJvbmc+SW4gdGhlIGZ1dHVyZSwgRnV0dXJlIE1lZGlhIEh1YnMgYWltcyB0byBleHBhbmQgaXRzIG5ldHdvcmsgYWxzbyBvdXRzaWRlIEV1cm9wZSwgYW5kIHBsYW5zIHRvIGJ1aWxkIGEgY2VudHJlIGZvciBtZWRpYSBpbm5vdmF0aW9uIGluIHRoZSBoZWFydCBvZiBCcnVzc2Vscy48L3N0cm9uZz48L2xpPlxyXG48L3VsPlxyXG5NZWRpYSBjb21wYW5pZXMgYXJlIGluY3JlYXNpbmdseSBzaGFyaW5nIGxlYXJuaW5ncyB3aXRoIG9uZSBhbm90aGVyLCBidXQgdGhpcyBrbm93bGVkZ2Utc2hhcmluZyBwcm9jZXNzIHRlbmRzIHRvIGhhcHBlbiBvbiBhbiBhZC1ob2MgYmFzaXMuIE1vcmVvdmVyLCBtYW55IG1lZGlhIG9yZ2FuaXNhdGlvbnMgc2VlIGdyZWF0IHBvdGVudGlhbCBpbiBjb2xsYWJvcmF0aW5nIHdpdGggc3RhcnR1cHMsIGJ1dCB0aGUgdmVudWVzIHdoZXJlIHRoZSB0d28gd29ybGRzIGNhbiBjb25uZWN0IGFyZSByYXJlLlxyXG5cclxuVGhpcyBpcyB0aGUgZ2FwIHRoYXQgdGhlIDxhIGhyZWY9XCJodHRwczovL2Z1dHVyZW1lZGlhaHVicy5jb20vXCI+RnV0dXJlIE1lZGlhIEh1YnM8L2E+IGFpbXMgdG8gZmlsbC4gVGhlIEJydXNzZWxzLWJhc2VkIGluaXRpYXRpdmUgaXMgYnVpbGRpbmcgYSBwbGF0Zm9ybSB0aGF0IG9mZmVycyBzeXN0ZW1hdGljIG9wcG9ydHVuaXRpZXMgZm9yIG1lZGlhIGxhYnMsIHNhbmRib3hlcyBhbmQgYWNjZWxlcmF0b3JzIHRvIHNoYXJlIGluc2lnaHRzIGFuZCBzZXQgdXAgbmV3IGNvbGxhYm9yYXRpb25zLlxyXG5cclxuXHUyMDFjV2Ugd2FudCB0byBib29zdCBpbm5vdmF0aW9uIHdpdGhpbiBFdXJvcGUgYW5kIGFjY2VsZXJhdGUgdGhlIGRldmVsb3BtZW50IG9mIHRoZSBtZWRpYSBpbmR1c3RyeSBieSBjb25uZWN0aW5nIGl0cyBkaWZmZXJlbnQgYWN0b3JzIHRvZ2V0aGVyLFx1MjAxZCBzYXlzIFNhcmFoIEdlZXJvbXMsIEhlYWQgb2YgRnV0dXJlIE1lZGlhIEh1YnMuXHJcbjxoMz5Gcm9tIGEgc21hbGwgY29tbXVuaXR5IHRvIGEgZ3JvdXAgb2YgaHViczwvaDM+XHJcblRoZSByb2FkIHRvIHRoZSBGdXR1cmUgTWVkaWEgSHVicyBzdGFydGVkIHdpdGhpbiB0aGUgRVUgSG9yaXpvbiAyMDIwIHByb2plY3QgPGEgaHJlZj1cImh0dHBzOi8vd3d3Lm1lZGlhcm9hZC5ldS9cIj5NZWRpYVJvYWQ8L2E+LCB3aGljaCBzZXQgdXAgYSBzbWFsbCBpbnRlcm5hdGlvbmFsIGNvbW11bml0eSBvZiBtZWRpYSBjb21wYW5pZXMgd2l0aCB0aGUgZ29hbCBvZiBzdHJlbmd0aGVuaW5nIHRoZWlyIGNvbGxhYm9yYXRpb25zIHdpdGggc3RhcnR1cHMuXHJcblxyXG5NZWRpYVJvYWQgZW5kZWQgaW4gMjAxOSwgYnV0IHRoZSBmZWVkYmFjayBmcm9tIHRoZSBwYXJ0aWNpcGFudHMgd2FzIHNvIHBvc2l0aXZlIHRoYXQgVlJULCB0aGUgRHV0Y2gtbGFuZ3VhZ2UgcHVibGljIGJyb2FkY2FzdGVyIGluIEJlbGdpdW0sIGRlY2lkZWQgdG8gbWFpbnRhaW4gYW5kIGV4cGFuZCB0aGUgY29tbXVuaXR5LCB0aXRsZWQgPHN0cm9uZz5TYW5kYm94IEh1Yjwvc3Ryb25nPi4gU29vbiBhZnRlciwgUlRCRiwgQmVsZ2l1bVx1MjAxOXMgRnJlbmNoLWxhbmd1YWdlIHB1YmxpYyBicm9hZGNhc3RlciwgYWxzbyBqb2luZWQgdG8gY29sbGFib3JhdGUgb24gdGhlIGluaXRpYXRpdmUuXHJcblxyXG5Jbml0aWFsbHkgYSBncm91cCBvZiBwdWJsaWMgbWVkaWEgY29tcGFuaWVzLCB0b2RheSBTYW5kYm94IEh1YiBhbHNvIHdlbGNvbWVzIGNvbW1lcmNpYWwgY29tcGFuaWVzIGFzIGl0cyBtZW1iZXJzLiBJdCBoYXMgb3ZlciAyMCBtZW1iZXJzIGF0IHRoZSBtb21lbnQsIGFuZCB0aGUgc3BsaXQgYmV0d2VlbiBwdWJsaWMgYW5kIGNvbW1lcmNpYWwgZmlybXMgaXMgY2xvc2UgdG8gNTBcdTIwMTM1MC5cclxuXHJcblNhbmRib3ggSHViLCBob3dldmVyLCB3YXMgb25seSB0aGUgYmVnaW5uaW5nLiBJbiB0aGUgc3ByaW5nIG9mIDIwMjAsIGEgcGFyYWxsZWwgbmV0d29yayBjYWxsZWQgPHN0cm9uZz5WaWRlbyBTbmFja2JhciBIdWI8L3N0cm9uZz4gd2FzIGxhdW5jaGVkLCBmb2N1c2luZyBvbiBpbm5vdmF0aXZlIGNvbnRlbnQgY3JlYXRpb24gZXNwZWNpYWxseSB3aXRoIHJlZ2FyZCB0byB2aWRlbyBzdHJlYW1pbmcuXHJcblxyXG5Tb29uIGFmdGVyLCA8c3Ryb25nPk9wZW4gTGFicyBIdWI8L3N0cm9uZz4gd2FzIGFsc28gbGF1bmNoZWQsIGFpbWluZyB0byBzdXBwb3J0IGFyaXNpbmcgdGFsZW50cyBpbiB0aGUgbWVkaWEgaW5kdXN0cnkgYW5kIG51cnR1cmUgdGhlIGRldmVsb3BtZW50IG9mIGRpZ2l0YWwgc2tpbGxzLiBGaW5hbGx5LCA8c3Ryb25nPkdhbWUgSHViPC9zdHJvbmc+LCB3aGljaCBjb25uZWN0cyBnYW1pbmcgYW5kIGVzcG9ydHMgZXhwZXJ0cywgd2FzIGFkZGVkIGluIE1hcmNoIDIwMjEgdG8gdGhlIEZ1dHVyZSBNZWRpYSBIdWJzXHUyMDE5cyBwb3J0Zm9saW8gb2YgY29tbXVuaXRpZXMuXHJcblxyXG5cdTIwMWNXZSBuZXZlciBoYWQgdGhlIGFtYml0aW9uIHRvIGJ1aWxkIGEgZ3JvdXAgb2YgaHVicyxcdTIwMWQgc2F5cyBHZWVyb21zLiBcdTIwMWNXZSBqdXN0IGdyZXcgaW50byB0aGF0IGJlY2F1c2UgdGhlcmUgd2FzIHNvIG11Y2ggaW50ZXJlc3QuIFdlIGNvdWxkIHNlZSB0aGF0IHRoZXJlIHdlcmUgc28gbWFueSBwZW9wbGUgd29ya2luZyBvbiBpbm5vdmF0aW9uLCBidXQgdGhleSBkaWRuJ3Qga25vdyB0aGUgcmlnaHQgcGVvcGxlIGluIG90aGVyIG1lZGlhIG9yZ2FuaXNhdGlvbnMuXHUyMDFkXHJcbjxoMz5MZWFybmluZyB0aHJvdWdoIGV4Y2hhbmdlIGFuZCBzaGFyaW5nPC9oMz5cclxuVGhlc2UgY29tbXVuaXRpZXMgZW5hYmxlIHRoZSBwYXJ0aWNpcGF0aW5nIG1lZGlhIGNvbXBhbmllcyB0byBzaGFyZSBsZWFybmluZ3MsIG1haW5seSB0aHJvdWdoIHRoZSBtZW1iZXItZXhjbHVzaXZlIG1vbnRobHkgY2FsbHMuIFRoZXNlIGluY2x1ZGUgYSBzaG9ydCByb3VuZHRhYmxlIGFib3V0IHRoZSBtb3N0IHJlY2VudCBwcm9qZWN0cyBhbmQgZXhwZXJpZW5jZXMgYW1vbmcgdGhlIG1lbWJlcnMsIGZvbGxvd2VkIGJ5IG1vcmUgZm9jdXNlZCBwcmVzZW50YXRpb25zIG9uIHNwZWNpZmljIHRvcGljcy4gQW4gZXh0ZXJuYWwgc3BlYWtlciBtaWdodCBhbHNvIGpvaW4gdG8gZGlzY3VzcyBhbiBpc3N1ZSB0aGF0IGlzIG9mIHBhcnRpY3VsYXIgaW50ZXJlc3QgdG8gdGhlIGdyb3VwLlxyXG5cclxuRWFjaCBtZWV0aW5nIGlzIHJlY29yZGVkIGFuZCBkb2N1bWVudGVkLCBhbmQgdGhlIG1hdGVyaWFscyBhcmUgc2hhcmVkIHdpdGggdGhlIGNvbW11bml0eSBtZW1iZXJzLiBBIGRlZGljYXRlZCBTbGFjayBjaGFubmVsIGlzIGFsc28gYXZhaWxhYmxlIGZvciBtZWRpYSBjb21wYW5pZXMgdG8gcmVxdWVzdCBpbmZvcm1hdGlvbiwgc2hhcmUgc29sdXRpb25zIGFuZCBoaWdobGlnaHQgaW50ZXJlc3RpbmcgZXZlbnRzLlxyXG5cclxuR2Vlcm9tcyBwb2ludHMgb3V0IHRoYXQgdGhlcmUgYXJlIGNsZWFyIGFkdmFudGFnZXMgdGhhdCBjb21lIGZyb20ga25vd2xlZGdlIHNoYXJpbmc6IFx1MjAxY0l0J3Mgb25seSBieSBleGNoYW5naW5nIGV4cGVyaWVuY2VzIHRoYXQgeW91IGZpbmQga25vd2xlZGdlIGFuZCByZWxldmFudCBpbnNpZ2h0cyBmb3IgeW91ciBvcmdhbmlzYXRpb24uIElmIHlvdSBkb24ndCBzaGFyZSB5b3Vyc2VsZiwgeW91IGRvbid0IGdldCBhbnl0aGluZyBiYWNrLlx1MjAxZFxyXG5cclxuRW1icmFjaW5nIHRoYXQgbWluZHNldCBjYW4gdGFrZSB0aW1lIGhvd2V2ZXIsIGFuZCBHZWVyb21zIHNheXMgdGhhdCBpbiB0aGUgYmVnaW5uaW5nIG1hbnkgY29tcGFuaWVzIFx1MjAxMyBlc3BlY2lhbGx5IGluIGNvbW1lcmNpYWwgbWVkaWEgXHUyMDEzIHdlcmUgaGVzaXRhbnQgYWJvdXQgc2hhcmluZyBpbmZvcm1hdGlvbiB3aXRoIG9yZ2FuaXNhdGlvbnMgdGhhdCB0aGV5IHRyYWRpdGlvbmFsbHkgY29uc2lkZXIgdGhlaXIgY29tcGV0aXRvcnMuXHJcblxyXG5cdTIwMWNXZSBzYXkgdGhhdCB3ZSBjYW4gY29tcGV0ZSBvbiBjb250ZW50LCBidXQgd2UgbmVlZCB0byBjb2xsYWJvcmF0ZSBvciBhdCBsZWFzdCBleGNoYW5nZSBvbiB0ZWNobm9sb2d5LCBiZWNhdXNlIHdlJ3JlIGFsbCBzbWFsbCBhbmQgdG9vIGxvY2FsIGlmIHdlIHdhbnQgdG8gc3VjY2VlZCBhbmQgc3Vydml2ZS4gT3RoZXJ3aXNlIHdlIHdpbGwgYmUgZWF0ZW4gYnkgdGhlIEdvb2dsZXMgYW5kIHRoZSBGYWNlYm9va3MuXHUyMDFkXHJcblxyXG5BbHRob3VnaCBwdWJsaWMgYW5kIGNvbW1lcmNpYWwgbWVkaWEgY29tcGFuaWVzIGNhbiBoYXZlIGRpZmZlcmVudCBwb2ludHMgb2YgdmlldywgR2Vlcm9tcyBlbXBoYXNpc2VzIHRoYXQgdGhlIHR3byB3b3JsZHMgY2FuIGhhdmUgdmVyeSBmcnVpdGZ1bCBleGNoYW5nZXMgYW5kIHBhcnRuZXJzaGlwczogXHUyMDFjWW91IGp1c3QgbmVlZCB0byBsb29rIGFuZCBjb25jZW50cmF0ZSBvbiB0aGUgd2luLXdpbi5cdTIwMWRcclxuPGgzPlByb2JsZW0tc29sdmluZyB0aHJvdWdoIGNvbGxhYm9yYXRpb25zIHdpdGggc3RhcnR1cHM8L2gzPlxyXG5JbiBhZGRpdGlvbiB0byBrbm93bGVkZ2Ugc2hhcmluZywgdGhlIEZ1dHVyZSBNZWRpYSBIdWJzIGFsc28gYWltcyB0byBoZWxwIG1lZGlhIGNvbXBhbmllcyBlbmdhZ2UgbW9yZSBlZmZlY3RpdmVseSB3aXRoIHRoZSBzdGFydHVwIGVjb3N5c3RlbS4gRm9yIGluc3RhbmNlLCBpdCBjb2xsZWN0cyBpbmZvcm1hdGlvbiBhYm91dCBzdGFydHVwcyB0aGF0IGhhdmUgb24tZ29pbmcgcHJvamVjdHMgd2l0aCB0aGUgY29tbXVuaXR5XHUyMDE5cyBtZWRpYSBvcmdhbmlzYXRpb24gbWVtYmVycywgYW5kIGRvY3VtZW50cyBsZWFybmluZ3MgZnJvbSB0aG9zZSBjb2xsYWJvcmF0aW9ucywgR2Vlcm9tcyBleHBsYWlucy4gXHUyMDFjU28gYXMgYSBtZW1iZXIgeW91IGhhdmUgYSBjbGVhciB2aWV3IG9uIEV1cm9wZWFuIHN0YXJ0dXBzIHRoYXQgYXJlIGFjdHVhbGx5IHdvcmtpbmcgd2l0aCBtZWRpYSBvcmdhbmlzYXRpb25zLlx1MjAxZFxyXG5cclxuQmVmb3JlIHRoZSBwYW5kZW1pYyBlbmRlZCBwaHlzaWNhbCBldmVudHMsIHRoZSBTYW5kYm94IEh1YiBhbHNvIG9yZ2FuaXNlZCBldmVudHMgd2hlcmUgc3RhcnR1cHMgY291bGQgcGl0Y2ggdGhlaXIgc29sdXRpb25zIHRvIHRoZSBIdWJcdTIwMTlzIG1lbWJlcnMuIFRvIGhlbHAgc2ltaWxhciBjb25uZWN0aW9ucyB0YWtlIHBsYWNlIHZpcnR1YWxseSwgdGhlIEh1YiBpcyBub3cgaW4gdGhlIHByb2Nlc3Mgb2YgY29sbGVjdGluZyBpbmZvcm1hdGlvbiBmcm9tIG1lZGlhIGNvbXBhbmllcyBhYm91dCB0aGVpciBjdXJyZW50IGNoYWxsZW5nZXMgYW5kIGlzc3VlcyB0aGF0IHN0YXJ0dXBzIG1pZ2h0IGJlIGFibGUgdG8gaGVscCB0aGVtIHdpdGguXHJcblxyXG5cdTIwMWNUaGUgZmFjdCB0aGF0IHdlIHN0YXJ0IGZyb20gYSBwcm9ibGVtLCBzb21ldGhpbmcgdGhleSdyZSBoYXZpbmcgZGlmZmljdWx0aWVzIHdpdGgsIGFsbG93cyB1cyB0byBiZSBtb3JlIHN1Y2Nlc3NmdWwsXHUyMDFkIEdlZXJvbXMgc2F5cy4gXHUyMDFjV2UncmUgbG9va2luZyBmb3Igc29sdXRpb25zLCBmb3IgdGhpbmdzIHRoZXkgYXJlIHN0cnVnZ2xpbmcgd2l0aCwgYW5kIGlmIHdlIGZpbmQgdGhlbSwgd2UgY2FuIHJlYWxseSBoZWxwIHRoZW0gZ28gZm9yd2FyZCBpbiB0aGVpciB0cmFuc2Zvcm1hdGlvbiBwcm9jZXNzLlx1MjAxZFxyXG5cclxuVGhlIEZ1dHVyZSBNZWRpYSBIdWJzIGlzIGFsc28gcGFydCBvZiB0d28gRVUgZnVuZGVkIHByb2plY3RzLCA8YSBocmVmPVwiaHR0cHM6Ly9tZWRpYW1vdG9yZXVyb3BlLmV1L1wiPk1lZGlhTW90b3JFdXJvcGU8L2E+IGFuZCA8YSBocmVmPVwiaHR0cHM6Ly93d3cuc3RhZGllbS5ldS9cIj5TVEFESUVNPC9hPiwgd2hpY2ggaGVscCBzdGFydHVwcyBzY2FsZSB0aHJvdWdoIGl0cyBjb2FjaGluZyBhbmQgZnVuZGluZyBwcm9ncmFtbWVzLCB3aGlsZSB0YWNrbGluZyBtZWRpYSBjaGFsbGVuZ2VzIGFuZCBpbnRyb2R1Y2luZyBlbWVyZ2luZyB0ZWNobm9sb2dpZXMgaW4gdGhlIG1lZGlhIGFuZCBjcmVhdGl2ZSBzZWN0b3IuXHJcbjxoMz5CdWlsZGluZyBpbiBhbmQgb3V0c2lkZSBFdXJvcGU8L2gzPlxyXG5UaGUgRnV0dXJlIE1lZGlhIEh1YnNcdTIwMTlzIGxvbmctdGVybSBwbGFuIGlzIHRvIHN0cmVuZ3RoZW4gaXRzIHJvbGUgaW4gRXVyb3BlIGJ5IGNyZWF0aW5nIGEgY2VudHJlIGZvciBtZWRpYSBpbm5vdmF0aW9uIGluIEJydXNzZWxzLiBUaGUgY29uc3RydWN0aW9uIG9mIHRoZSA8YSBocmVmPVwiaHR0cDovL21lZGlhcGFyay5icnVzc2Vscy9cIj5NZWRpYXBhcmsuQnJ1c3NlbHM8L2E+IGNsdXN0ZXIgaXMgdW5kZXJ3YXksIGFuZCB3aGVuIGZpbmlzaGVkIGl0IHdpbGwgaG91c2Ugb3ZlciA2MCBtZWRpYSBjb21wYW5pZXMgYW5kIDUsMDAwIHByb2Zlc3Npb25hbHMgY2xvc2UgdG8gRXVyb3BlYW4gaW5zdGl0dXRpb25zLiBUaGUgRnV0dXJlIE1lZGlhIEh1YnMgd2lsbCBhbHNvIG1vc3QgbGlrZWx5IGJlIGluY2x1ZGVkLCBnaXZpbmcgaXQgYSBmcm9udC1zZWF0IHZpZXcgdG8gdGhlIEV1cm9wZWFuIG5ld3MgbWVkaWEgc2NlbmUuXHJcblxyXG5HZWVyb21zIHNheXMgdGhlIG5ldHdvcmsgYWxzbyBob3BlcyB0byBleHBhbmQgb3V0c2lkZSBFdXJvcGUgaW4gdGhlIGZ1dHVyZTogXHUyMDFjV2UgYmVsaWV2ZSB0aGF0IGlmIHlvdSB3YW50IHRvIGhhdmUgYSBzdHJvbmcgRXVyb3BlYW4gbmV0d29yaywgeW91IGFsc28gbmVlZCB0byBrbm93IHdoYXQgaGFwcGVucyBpbiBvdGhlciBjb250aW5lbnRzLFx1MjAxZCBzaGUgc2F5cy4gXHUyMDFjV2UncmUgbWFraW5nIHRoZSBmaXJzdCBjb25uZWN0aW9ucyBhbmQgc2VlaW5nIHdoYXQgb3Bwb3J0dW5pdGllcyB0aGVyZSBhcmUuXHUyMDFkXHJcblxyXG5XaGVuIHRyYXZlbGxpbmcgc3RvcHBlZCwgdGhpcyBuYXR1cmFsbHkgaGluZGVyZWQgdGhlIEh1Ylx1MjAxOXMgYW1iaXRpb25zLCBib3RoIGluIGFuZCBvdXRzaWRlIEV1cm9wZTogXHUyMDFjV2UgdXN1YWxseSBpbnZpdGUgbmV3IG1lbWJlcnMgdG8gY29tZSB0byBCcnVzc2VscyBhbmQgc2VlIGhvdyB3ZSB3b3JrLiBOb3QgYmVpbmcgYWJsZSB0byBkbyB0aGF0IG1lYW5zIHRoZSBkeW5hbWljIGluIHRoZSBncm91cCBpcyB2ZXJ5IGRpZmZlcmVudC4gTmV3IHBlb3BsZSBhcmUgc29tZXRpbWVzIG1vcmUgcmVzZXJ2ZWQgaW4gc3BlYWtpbmcsIGJ1dCBpZiB0aGV5IGhhZCBtZXQgZHVyaW5nIGEgdHJpcCwgdGhlIGR5bmFtaWMgd291bGQgYmUgY29tcGxldGVseSBkaWZmZXJlbnQuXHUyMDFkXHJcblxyXG5UaGlzIGV4cGVyaWVuY2UgaGFzIGJyb3VnaHQgaG9tZSB0aGUgaW1wb3J0YW5jZSBvZiB0aGUgY2FzdWFsIGNoYXRzIHRoYXQgaGFwcGVuIGR1cmluZyBwaHlzaWNhbCBldmVudHMsIEdlZXJvbXMgc2F5czogXHUyMDFjSVx1MjAxOXZlIGxlYXJuZWQgdGhhdCB0aG9zZSBpbmZvcm1hbCBjb252ZXJzYXRpb25zIGFyZSB2ZXJ5IGltcG9ydGFudC4gSWYgeW91IGludmVzdCBpbiB0aG9zZSwgaXQgd2lsbCBoZWxwIG1ha2Ugc3VyZSB0aGF0IHRoZSBmb3JtYWwgY29udmVyc2F0aW9ucyBhcmUgYWxzbyBtb3JlIHN1Y2Nlc3NmdWwuXHUyMDFkXHJcblxyXG4tLVxyXG5cclxuQ09OVEFDVFxyXG48aW1nIGNsYXNzPVwiYWxpZ25ub25lIHdwLWltYWdlLTE1NjE0IHNpemUtdGh1bWJuYWlsXCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMjEvMDgvU2FyYWhHZWVyb21zMTVfMC0xNTB4MTUwLmpwZ1wiIGFsdD1cIlwiIHdpZHRoPVwiMTUwXCIgaGVpZ2h0PVwiMTUwXCIgLz5cclxuU2FyYWggR2Vlcm9tcywgUGFydG5lcnNoaXBzICZhbXA7IEhlYWQgb2YgRnV0dXJlIE1lZGlhIEh1YnMsIFZSVFxyXG5MaW5rZWRJbjogPGEgaHJlZj1cImh0dHBzOi8vd3d3LmxpbmtlZGluLmNvbS9pbi9zYXJhaGdlZXJvbXMvXCI+U2FyYWggR2Vlcm9tczwvYT5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMi8zXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48aDM+QXV0aG9yPC9oMz5cclxuW3NpbXBsZS1hdXRob3ItYm94XVsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XSIsInBvc3RfdGl0bGUiOiJGdXR1cmUgTWVkaWEgSHViczogYnVpbGRpbmcgYSBtZWRpYSBpbm5vdmF0aW9uIG5ldHdvcmsgaW4gdGhlIGhlYXJ0IG9mIEV1cm9wZSIsInBvc3RfbGluayI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9mdXR1cmUtbWVkaWEtaHVicy1idWlsZGluZy1hLW1lZGlhLWlubm92YXRpb24tbmV0d29yay1pbi10aGUtaGVhcnQtb2YtZXVyb3BlLyIsInBvc3RfZmVhdHVyZWRfaW1hZ2UiOiI8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIkZ1dHVyZSBNZWRpYSBIdWJzOiBidWlsZGluZyBhIG1lZGlhIGlubm92YXRpb24gbmV0d29yayBpbiB0aGUgaGVhcnQgb2YgRXVyb3BlXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIxMDBcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAyMS8wOC8xNTAweDUwMC0zMDB4MTAwLmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6Ik1lZGlhIGxhYnMiLCJwb3N0X3RhZ3MiOiIiLCIlX2VkaXRfbG9jayUiOiIxNjM0ODk2ODM0OjQiLCIlX2VkaXRfbGFzdCUiOiI5MzEiLCIlX3lvYXN0X3dwc2VvX3ByaW1hcnlfY2F0ZWdvcnklIjoiMTQyIiwiJV90aHVtYm5haWxfaWQlIjoiMTU2MTUiLCIlc2xpZGVfdGVtcGxhdGUlIjoiZGVmYXVsdCIsIiVfd3BiX3ZjX2pzX3N0YXR1cyUiOiJ0cnVlIiwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6IkJydXNzZWxzLCBCZWxnaXVtIiwiJV93cGdtcF9sb2NhdGlvbl9jaXR5JSI6IkJydXNzZWxzIiwiJV93cGdtcF9sb2NhdGlvbl9zdGF0ZSUiOiJCcnVzc2VscyIsIiVfd3BnbXBfbG9jYXRpb25fY291bnRyeSUiOiJCZWxnaXVtIiwiJV93cGdtcF9tZXRhYm94X2xhdGl0dWRlJSI6IjUwLjg1MDMzOTYiLCIlX3dwZ21wX21ldGFib3hfbG9uZ2l0dWRlJSI6IjQuMzUxNzEwMyIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiMlwiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6Ik47IiwiJV93cGdtcF9tZXRhYm94X3RheG9tb21pZXNfdGVybXMlIjoiTjsiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6Ik47IiwiJV95b2FzdF93cHNlb19jb250ZW50X3Njb3JlJSI6IjMwIiwiJV95b2FzdF93cHNlb19lc3RpbWF0ZWQtcmVhZGluZy10aW1lLW1pbnV0ZXMlIjoiNiIsInRheG9ub215PWNhdGVnb3J5IjoiTWVkaWEgbGFicyIsInRheG9ub215PXBvc3RfdGFnIjoiIn0sImljb24iOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxOC8wMi9tYXJrZXItMS5wbmcifSwiaWQiOjE1NjEzLCJpbmZvd2luZG93X2Rpc2FibGUiOmZhbHNlfSx7InNvdXJjZSI6InBvc3QiLCJ0aXRsZSI6IkFsbGlhbmNlIFByZXNzZTogYmFsYW5jaW5nIGVjb25vbWljIGFuZCBlbnZpcm9ubWVudGFsIHN1Y2Nlc3MgaW4gdGhlIEZyZW5jaCBwcmVzcyIsImluZm93aW5kb3dfY29udGVudCI6IjxkaXYgY2xhc3M9XCJmYy1pdGVtLWJveCBmYy1pdGVtLW5vLXBhZGRpbmdcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiVGhlIGJsdWUgaW1hZ2Ugd2l0aCB3aGl0ZSB3cml0aW5nIGV4cGxhaW5zIChpbiBGcmVuY2gpIHRoZSBBbGxpYW5jZSBQcmVzc2UmIzAzOTtzIGVudmlyb25tZW50YWwgY29tbWl0bWVudCwgaXQgc2F5czogRWNvbG9naWNhbCB0cmFuc2l0aW9uIGFuZCBhZHZlcnRpc2luZyAtIHRoZSBuZXdzIHByZXNzIGNvbnRpbnVlcyBpdHMgY29tbWl0bWVudFwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMTAwXCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMjEvMDYvQWxsaWFuY2UtZGUtbGEtUHJlc3NlLWRJbmZvcm1hdGlvbi1HZVx1MDMwMW5lXHUwMzAxcmFsZXMtZWNvbG9naWNhbC10cmFuc2l0aW9uLWNhbXBhaWduLXdpZGUtdjMtMzAweDEwMC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1wYWRkaW5nLWNvbnRlbnRfMjBcIj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1tZXRhIGZjLWl0ZW0tc2Vjb25kYXJ5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2UgZmMtdGV4dC1jZW50ZXJcIj5HcmVlbiBtZWRpYSwgSW5ub3ZhdGlvbiBDYXNlPC9kaXY+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tdGl0bGUgZmMtaXRlbS1wcmltYXJ5LXRleHQtY29sb3IgZmMtdGV4dC1jZW50ZXJcIj5BbGxpYW5jZSBQcmVzc2U6IGJhbGFuY2luZyBlY29ub21pYyBhbmQgZW52aXJvbm1lbnRhbCBzdWNjZXNzIGluIHRoZSBGcmVuY2ggcHJlc3M8L2Rpdj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1jb250ZW50IGZjLWl0ZW0tYm9keS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+XHJcbiAgICAgICAgICAgIEFsbGlhbmNlIFByZXNzZSBoYXMgbWFkZSBhIGZvdXItcG9pbnQgY29tbWl0bWVudCB0byB0YWNrbGUgZW52aXJvbm1lbnRhbCBpc3N1ZXMgXHUyMDEzIGZvY3Vzc2VkIG9uIGNvbmNlcm5zIGFib3V0IGFkdmVydGlzaW5nLlxyXG4gICAgICAgIDwvZGl2PlxyXG48YSBocmVmPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL2FsbGlhbmNlLXByZXNzZS9cIj5SZWFkIG1vcmU8L2E+XHJcbiAgICA8L2Rpdj5cclxuICAgIDwvZGl2PlxyXG48L2Rpdj5cclxuXHJcbiIsImNvbnRlbnQiOiJBbGxpYW5jZSBQcmVzc2UgaGFzIG1hZGUgYSBmb3VyLXBvaW50IGNvbW1pdG1lbnQgdG8gdGFja2xlIGVudmlyb25tZW50YWwgaXNzdWVzIFx1MjAxMyBmb2N1c3NlZCBvbiBjb25jZXJucyBhYm91dCBhZHZlcnRpc2luZy4iLCJhZGRyZXNzIjoiNjkgUnVlIGR1IENoZXZhbGVyZXQsIDc1MDEzIFBhcmlzLCBGcmFuY2UiLCJsb2NhdGlvbiI6eyJsYXQiOiI0OC44Mjg0OTE4OTk5OTk5OSIsImNpdHkiOiJQYXJpcyIsInN0YXRlIjoiXHUwMGNlbGUtZGUtRnJhbmNlIiwiY291bnRyeSI6IkZyYW5jZSIsImxuZyI6IjIuMzc2MjE2NTk5OTk5OTk5Iiwib25jbGlja19hY3Rpb24iOiJtYXJrZXIiLCJyZWRpcmVjdF9wZXJtYWxpbmsiOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvYWxsaWFuY2UtcHJlc3NlLyIsInpvb20iOjIsImV4dHJhX2ZpZWxkcyI6eyJwb3N0X2V4Y2VycHQiOiJBbGxpYW5jZSBQcmVzc2UgaGFzIG1hZGUgYSBmb3VyLXBvaW50IGNvbW1pdG1lbnQgdG8gdGFja2xlIGVudmlyb25tZW50YWwgaXNzdWVzIFx1MjAxMyBmb2N1c3NlZCBvbiBjb25jZXJucyBhYm91dCBhZHZlcnRpc2luZy4iLCJwb3N0X2NvbnRlbnQiOiJbdmNfcm93XVt2Y19jb2x1bW4gd2lkdGg9XCIxLzRcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS8yXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48aDE+QWxsaWFuY2UgUHJlc3NlOiBiYWxhbmNpbmcgZWNvbm9taWMgYW5kIGVudmlyb25tZW50YWwgc3VjY2VzcyBpbiB0aGUgRnJlbmNoIHByZXNzPC9oMT5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkJlY2F1c2UgaXRcdTIwMTlzIHNlZW4gYXMgcGVyZm9ybWluZyBhIHZpdGFsIHJvbGUgZm9yIGRlbW9jcmFjeSwgRnJhbmNlXHUyMDE5cyBcdTIwMThpbmZvcm1hdGlvbiBwcmVzc1x1MjAxOSBoYXMgc3BlY2lhbCByaWdodHNcdTAwYTAgXHUyMDEzIGxpZ2h0ZXIgdGF4ZXMsIGxvdyB0YXJpZmZzIGZvciBwb3N0YWwgZGlzdHJpYnV0aW9uLCBndWFyYW50ZWVkIHNwYWNlIGluIG5ld3NzdGFuZHMgYW5kIGRpcmVjdCBmdW5kaW5nIGZyb20gdGhlIHN0YXRlLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5CdXQsIGFzIGV2ZXIsIHRob3NlIHJpZ2h0cyBjb21lIHdpdGggcmVzcG9uc2liaWxpdGllcyBcdTIwMTMgYW5kIHJpZ2h0IG5vdywgdGhlIG9yZ2FuaXNhdGlvbiB0aGF0IHJlcHJlc2VudHMgc29tZSAzMDAgcHVibGlzaGVycyBhY3Jvc3MgdGhlIGNvdW50cnkgXHUyMDEzIGlzIHdvcmtpbmcgb3V0IGhvdyB0byB0YWNrbGUgdGhvc2UgcmVsYXRpbmcgdG8gZW52aXJvbm1lbnRhbCBzdXN0YWluYWJpbGl0eS48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+UGllcnJlIFBldGlsbGF1bHQgaXMgdGhlIGRpcmVjdG9yIGdlbmVyYWwgb2YgdGhlIEFsbGlhbmNlIGRlIGxhIFByZXNzZSBkJ0luZm9ybWF0aW9uIEdcdTAwZTluXHUwMGU5cmFsZS4gSGUgZXhwbGFpbnMgdGhhdCB0aGUgcHJlc3MgaW4gRnJhbmNlIGhhcyBmb3IgYSBudW1iZXIgb2YgeWVhcnMgYmVlbiBvYmxpZ2VkIHRvIHN1cHBvcnQgYW4gXHUyMDE4ZWNvLWNvbnRyaWJ1dGlvbiBzeXN0ZW1cdTIwMTkgdG8gaGVscCBtaXRpZ2F0ZSBpdHMgcGFwZXIgd2FzdGUuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY0Jhc2ljYWxseSB5b3UgaGF2ZSwgYXMgYW4gaW5kdXN0cnksIHRvIGZ1bmQgdGhlIHJlY3ljbGluZyBvZiB5b3VyIHdhc3RlLFx1MjAxZCBQZXRpbGxhdWx0IGV4cGxhaW5zLiBcdTIwMWNBbmQgZm9yIGEgbmV3c3BhcGVyLCBpdCdzIHBhcGVyLiBXZSBoYXZlIHRvIGZ1bmQgYSBzcGVjaWZpYyBjb21wYW55LCBpdCdzIG1vcmUgb3IgbGVzcyBhbiBhc3NvY2lhdGlvbiB3b3JraW5nIGFzIGEgY29tcGFueSwgd2hpY2ggb3JnYW5pc2VzIHRoZSByZWN5Y2xpbmcgb2YgcGFwZXJzIGluIGNpdGllcy5cdTAwYTA8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjQW5kLCBhbHNvLCB3ZSBoYXZlIHRvIGhlbHAgdGhlIHB1YmxpYyBiZWNvbWUgbW9yZSBjb25zY2lvdXMgb2YgdGhlIG5lY2Vzc2l0eSBvZiByZWN5Y2xpbmcuXHUyMDFkXHUwMGEwPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlRoZSBBbGxpYW5jZSBQcmVzc2UgbWVtYmVyc2hpcCBmdW5kcyA8YSBocmVmPVwiaHR0cHM6Ly93d3cuY2l0ZW8uY29tL1wiPkNJVEVPPC9hPiB3aXRoIHVwd2FyZHMgb2YgXHUyMGFjMjIgbWlsbGlvbiBwZXIgeWVhciwgbWFpbmx5IHZpYSBhZHZlcnRpc2VtZW50cyBhYm91dCByZWN5Y2xpbmcuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY1dlIHJ1biB0aGVpciBhZHMgdG8gdGhlIHB1YmxpYyBzYXlpbmcsIFx1MjAxOHlvdSd2ZSBnb3QgdG8gcmVjeWNsZSBwYXBlci4gQmUgY2FyZWZ1bCwgeW91J3ZlIGdvdCB0byBwdXQgaXQgaW4gdGhlIHllbGxvdyBiaW5cdTIwMTkgYW5kIHRoZXNlIGtpbmRzIG9mIHRoaW5ncy4gU29tZSBvZiB0aGUgbWVzc2FnZXMgYXJlIHZlcnkgZ2VuZXJhbC4gU29tZSBvZiB0aGVtIGFyZSByZWFsbHkgZm9jdXNzZWQgb24gcmVjeWNsaW5nIHBhcGVyLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNXZSBoYXZlIGEgbG90IG9mIG90aGVyIHNwZWNpZmljIGxlZ2lzbGF0aXZlIG9ibGlnYXRpb25zIGFuZCwgYW1vbmcgdGhlbSwgd2UgaGF2ZSB0byB1c2UgcmVjeWNsZWQgcGFwZXIsIGF0IGRpZmZlcmVudCBsZXZlbHMsIGRlcGVuZGluZyBvbiB0aGUga2luZCBvZiBwdWJsaWNhdGlvbi4gRm9yIGluc3RhbmNlLCBtYWdhemluZXMgY2FuXHUyMDE5dCB1c2UgdGhlIHNhbWUgYW1vdW50IG9mIHJlY3ljbGVkIHBhcGVyIGFzIHdlIGRvIHdpdGggYSBkYWlseSBuZXdzcGFwZXIuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY1dlIGhhdmUgdG8gc3RvcCB1c2luZyBwbGFzdGljIGNvdmVycywgYmVnaW5uaW5nIGluIDIwMjIsIHN0b3AgdXNpbmcgbWluZXJhbCBpbmtzIGJlZ2lubmluZyBpbiAyMDIzIGFuZCB3ZSBhbHNvIGhhdmUgdG8gZ3JhZHVhbGx5IHJhaXNlIHRoZSByYXRlcyBvZiByZWN5Y2xlZCBwYXBlci5cdTIwMWQ8L3NwYW4+XHJcbjxoMz48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+QWR2ZXJ0aXNpbmcgaXNzdWVzPC9zcGFuPjwvaDM+XHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5JbiBNYXJjaCAyMDIxLCB0aGUgb3JnYW5pc2F0aW9uIFBldGlsbGF1bHQgbGVhZHMgbWFkZSBhIG5ldywgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmFsbGlhbmNlcHJlc3NlLmZyL2FjdHVhbGl0ZS90cmFuc2l0aW9uLWVjb2xvZ2lxdWUtZXQtcHVibGljaXRlLWxhLXByZXNzZS1kaW5mb3JtYXRpb24tcG91cnN1aXQtc29uLWVuZ2FnZW1lbnQvXCI+Zm91ci1wb2ludCBjb21taXRtZW50PC9hPiB0byBcdTIwMThlY29sb2dpY2FsIHRyYW5zaXRpb25cdTIwMTksIHBhcnRpY3VsYXJseSByZWxhdGVkIHRvIGFkdmVydGlzaW5nLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5UaGlzIGhhcyBiZWVuIHNwdXJyZWQgb24gYnkgdGhlIDxhIGhyZWY9XCJodHRwczovL3d3dy5ueXRpbWVzLmNvbS8yMDIxLzA1LzE5L2J1c2luZXNzL21hY3Jvbi1mcmFuY2UtY2xpbWF0ZS1iaWxsLmh0bWxcIj53aWRlLXJhbmdpbmcgZW52aXJvbm1lbnRhbCBiaWxsPC9hPiBnb2luZyB0aHJvdWdoIHRoZSBGcmVuY2ggcGFybGlhbWVudCwgd2hpY2ggY29udGFpbnMgc2V2ZXJhbCBjbGF1c2VzIGRlc2lnbmVkIHRvIGxpbWl0IHRoZSBoYXJtZnVsIGVmZmVjdHMgb2YgdGhpcyBwYXJ0IG9mIHRoZSBtZWRpYSBpbmR1c3RyeS48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjVGhlIGNvbW1pdG1lbnRzIHdlXHUyMDE5dmUgbWFkZSBhcmUgcmVhbGx5IGZvY3VzZWQgb24gYWR2ZXJ0aXNpbmcgYmVjYXVzZSB0aGF0J3MgYSBkZWJhdGUgcmlnaHQgbm93IGluIEZyYW5jZS4gVGhlcmUgaXMgYSBzdHJvbmcgY3VycmVudCBhZHZvY2F0aW5nIGZvciBmb3JiaWRkaW5nIHNvbWUgaW5kdXN0cmllcyBmcm9tIGFkdmVydGlzaW5nLCBuYW1lbHkgY2FycywgYWlybGluZXMsIHRoaXMga2luZCBvZiB0aGluZy5cdTAwYTA8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjSSByZW1lbWJlciB0aGUgZGlzY3Vzc2lvbnMgd2UgaGFkIHdpdGggRnJlbmNoIHBvbGljeW1ha2VycyBhbmQgd2UgdG9sZCB0aGVtLCBcdTIwMTh5b3UgY2FuIHN1cHByZXNzIGFkdmVydGlzaW5nLCBidXQgeW91IHdvblx1MjAxOXQgc3VwcHJlc3MgdGhlIG5lZWQgZm9yIGEgY2FyLCBmb3IgaW5zdGFuY2UuIEFuZCB0aGV5IHNhaWQgXHUyMDE4RnJlbmNoIGRvbid0IG5lZWQgYSBjYXJcdTIwMTkuIEFuZCB3ZSBhbnN3ZXJlZCAnZXZlbiBvdXRzaWRlIFBhcmlzP1x1MjAxOS4gU28gdGhleSBzYWlkLCBcdTIwMThvaCwgeWVhaCwgb2theSwgb3V0c2lkZSBQYXJpcy4uLiBtYXliZVx1MjAxOS5cdTAwYTA8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjU28gdGhlIGZhY3QgdGhhdCB5b3UgZG9uJ3QgbmVlZCBhIGNhciwgeW91IGRvbid0IG5lZWQgYWR2ZXJ0aXNpbmcsIHlvdSBkb24ndCBuZWVkIGFueXRoaW5nLCB0aGF0XHUyMDE5cyBhIHZpZXcgdGhhdCBpcyBkZXRhY2hlZCBmcm9tIHJlYWxpdHkuIFdlXHUyMDE5cmUgdGFraW5nIHRoaW5ncyBieSB0aGUgd3JvbmcgZW5kLCBhZHZlcnRpc2luZyBpcyBhdCB0aGUgZW5kIG9mIHRoZSBjaGFpbi4gWW91IGNhbiBzdXBwcmVzcyBhZHZlcnRpc2luZywgYnV0IHBlb3BsZSB3aWxsIG5lZWQgY2Fycy4gVGhlIHBvaW50IGlzIHRvIGdpdmUgdGhlbSBjYXJzIHRoYXQgZG8gbm90IHBvbGx1dGUuXHUwMGEwPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY0J1dCBpbiBGcmFuY2UgdGhpcyBpZGVhIGlzIHF1aXRlIHBvcHVsYXIsXHUyMDFkIGhlIGFkZHMsIFx1MjAxY2Jhbm5pbmcgc29tZSBhZHZlcnRzLCBzb21lIGluZHVzdHJpZXMgZnJvbSBhZHZlcnRpc2luZy5cdTIwMWQ8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+T2YgY291cnNlIGZvciBwdWJsaXNoZXJzLCBhZHZlcnRpc2luZyByZXByZXNlbnRzIGEgc2lnbmlmaWNhbnQgcHJvcG9ydGlvbiBvZiByZXZlbnVlcyBcdTIwMTMgYW4gYXZlcmFnZSBvZiAzNSBwZXJjZW50IGFjcm9zcyB0aGUgQWxsaWFuY2UgUHJlc3NlIG1lbWJlcnNoaXAgXHUyMDEzIGhlIGV4cGxhaW5zLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNTbyBvZiBjb3Vyc2UsIHB1Ymxpc2hlcnMgYXJlIG5vdCByZWFsbHkgb2theSB3aXRoIHRoaXMuIFNvbWUgb2YgdGhlbSwgdGhlIHNtYWxsZXN0IG9uZXMsIGhlYXZpbHkgcmVseSBvbiBhZHZlcnRpc2luZyBcdTIwMTMgYW5kIGVzcGVjaWFsbHkgY2FyIGFkdmVydGlzaW5nIFx1MjAxMyB0byBmdW5kIHRoZW1zZWx2ZXMuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY1RoZXkncmUgYWxyZWFkeSwgZnJhbmtseSBzcGVha2luZywgaW4gYmFkIHNoYXBlIGVjb25vbWljYWxseS4gSW4gdGhlIGxhc3QgMTAgeWVhcnMsIGFkdmVydGlzaW5nIHJldmVudWVzIHdlcmUgY3V0IGJ5IGhhbGYgZm9yIG5ld3NwYXBlcnMsIHdoaWNoIGlzIG5vdCB0aGUgY2FzZSBmb3IgVFYgb3IgcmFkaW8uIEFuZCBzbyBmb3JiaWRkaW5nIGV2ZW4gbW9yZSBhZHZlcnRpc2luZywgaXMgdmVyeSwgdmVyeSwgdmVyeSB3b3JyeWluZyBmb3Igc29tZSBvZiB0aGVtLlx1MDBhMDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNTbyB3aGF0IHdlJ3JlIHRyeWluZyB0byBkbyBpcyB0byBtYWtlIGl0IHVuZGVyc3Rvb2QgdGhhdCwgXHUyMDE4T0ssIGFkdmVydGlzaW5nIGlzIG1heWJlIG5vdCB0aGUgYmVzdCB0aGluZyBpbiB0aGUgd29ybGQsIGJ1dCBpdCdzIGFic29sdXRlbHkgbmVjZXNzYXJ5IHRvIGZ1bmQgbmV3c3BhcGVyc1x1MjAxOS5cdTAwYTA8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjV2UgbmV2ZXIgc2F3IG5ld3NwYXBlcnMgaGF2aW5nIGEgZnVuY3Rpb25pbmcgYnVzaW5lc3MgbW9kZWwgd2l0aG91dCBhZHZlcnRpc2luZy5cdTIwMWQ8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+UGV0aWxsYXVsdCwgaW5ldml0YWJseSwgcmVsYXRlcyBzb21lIG9mIHRoZXNlIGlzc3VlcyBiYWNrIHRvIHNvY2lhbCBtZWRpYSBnaWFudHMuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY0kgc2VlIGV2ZXJ5d2hlcmUgcGVvcGxlIHNheWluZywgXHUyMDE4eW91IGRvbid0IG5lZWQgYWR2ZXJ0aXNpbmcsIHRoYXQncyBub3QgZm9yIHlvdSwgcmVseSBvbiBzdWJzY3JpcHRpb25zLiBUaGF0J3MgZ29vZCBtb25leSwgb25saW5lIHN1YnNjcmlwdGlvbnNcdTIwMTkuXHUwMGEwPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY0FjdHVhbGx5LCB0aGVyZSBpcyBhbiBhZ2VuZGEgYmVoaW5kIHRoaXMsIHdoaWNoIGlzIFx1MjAxOGxldCdzIGtlZXAgYWxsIHRoZSBhZHZlcnRpc2luZyBtb25leSBmb3IgR29vZ2xlIGFuZCBGYWNlYm9va1x1MjAxOS4gV2UgaGF2ZSB0aGVzZSBiaWcgcGxhdGZvcm1zIHRyeWluZyB0bywgbGV0J3Mgc2F5LCBwdXNoIHVzIG91dCBvZiBvbmxpbmUgYWR2ZXJ0aXNpbmcsIGFuZCB0cnlpbmcgPC9zcGFuPjxpPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5hbmQgc3VjY2VlZGluPC9zcGFuPjwvaT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+ZyBpbiBnZXR0aW5nIGFsbCB0aGUgdmFsdWUuXHUwMGEwPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY1dlJ3JlIHZlcnkgaGFwcHkgdG8gc2VsbCBvbmxpbmUgc3Vic2NyaXB0aW9ucywgYnV0IHdlIHNlbGwgaXQgYXQgYSByYXRlIHRoYXQgaXMgdGhyZWUgdGltZXMgbGVzcyB0aGFuIGluIHRoZSBwYXBlciB3b3JsZCBhbmQsIHlldCwgdGhlIGpvdXJuYWxpc3QgdGhhdCB3cm90ZSB0aGUgYXJ0aWNsZSBpcyBwYWlkIHRoZSBzYW1lLiBTbyB0aGUgY29zdCBpcyB0aGUgc2FtZSwgYnV0IHRoZSByZXZlbnVlIGlzIG5vdCB0aGUgc2FtZS4gQW5kIHNvIHdlIGNhbid0IGFmZm9yZCB0byBnZXQgcmlkIG9mIGFkdmVydGlzaW5nIHJpZ2h0IG5vdy4gUmVhbGx5IG5vdC5cdTIwMWQ8L3NwYW4+XHJcbjxoMz48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+TWFraW5nIHRoZSB0cmFuc2l0aW9uPC9zcGFuPjwvaDM+XHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5BcyBwYXJ0IG9mIGl0cyBwbGFuLCB0aGUgQWxsaWFuY2UgUHJlc3NlIGhhcyBjb21taXR0ZWQgdG8gcmV2aWV3aW5nIGFkcyBmb3IgdGhlaXIgZW52aXJvbm1lbnRhbCBjcmVkZW50aWFscywgcXVhbnRpZnlpbmcgaXRzIG1lbWJlcnNoaXAncyBlbnZpcm9ubWVudGFsIGNvdmVyYWdlLCB0cmFpbmluZyBhZHZlcnRpc2luZyBleGVjcyBvbiB0aGlzIGFuZCBzdXBwb3J0aW5nIHRob3NlIHdobyB0YWtlIHRoZSBlbnZpcm9ubWVudCBzZXJpb3VzbHksIHBhcnRpY3VsYXJseSB0aHJvdWdoIGFuIGF3YXJkIHdpdGggcHVibGljaXR5IHByaXplcy48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjV2UgYXJlIGFscmVhZHkgc2VsZi1yZWd1bGF0aW5nIGFkdmVydGlzaW5nLCB3aXRoIHRoZSBzdXBwb3J0IG9mIHRoZSA8YSBocmVmPVwiaHR0cHM6Ly93d3cuYWFjYy5mci9cIj5BQUNDPC9hPiwgYSBwcm9mZXNzaW9uYWwgYXNzb2NpYXRpb24gZm9yIG1lZGlhIGFkdmVydGlzZW1lbnQsIGFkdmVydGlzaW5nIGFnZW5jaWVzIGFuZCBzbyBvbiwgd2hpY2ggaGFzIGJlZW4gc2VsZi1yZWd1bGF0aW5nIGFkdmVydGlzZW1lbnRzIGZvciBhdCBsZWFzdCBhIGRlY2FkZS48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjQW5kIHNvIHdlIHdpbGwgbG9vayBhdCBldmVyeSBhZCBiZWZvcmUgcHVibGljYXRpb24gYW5kLCBpZiBuZWVkZWQsIHRlbGwgdGhlIEFBQ0MgdG8gY2hlY2sgd2hhdCBpcyBzYWlkIGluIHRoZSBhZHMgcmVnYXJkaW5nIGVudmlyb25tZW50YWwgaXNzdWVzLiBUaGF0IG1lYW5zIG5vdCB1c2luZyBlbnZpcm9ubWVudGFsIGFyZ3VtZW50cyBpZiB0aGV5XHUyMDE5cmUgbm90IHRydWUgb3Igbm90IGp1c3RpZmllZC4gQW5kIG9uIHRoZSBvdGhlciBlbmQsIG5vdCBydW5uaW5nIGFkcyB0aGF0IGFyZSBjbGVhcmx5LCBsZXQncyBzYXksIFx1MjAxOGFudGktZW52aXJvbm1lbnRcdTIwMTkuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY1RoZXJlIGlzIGFsc28gYSBjb21taXRtZW50IHRvIHRyYWluIHBlb3BsZSBhYm91dCBhZHZlcnRpc2luZywgcHJlc3MgYW5kIHRoZSBlbnZpcm9ubWVudCwgYW5kIHRoaXMgaXMgdGFyZ2V0ZWQgdG8gYWR2ZXJ0aXNpbmcgcHJvZmVzc2lvbmFscy4gV2UgYXJlIHdvcmtpbmcgd2l0aCB0aGUgQUNQTSwgd2hpY2ggaXMgYSBjZXJ0aWZpY2F0aW9uIGFnZW5jeSBmb3IgcHJlc3MgYW5kIG1lZGlhIGluIEZyYW5jZSwgdG8gaW5jbHVkZSBpbiBvdXIgVG9tb3Jyb3cncyBQcmVzcyBwcm9ncmFtbWUgYSBzcGVjaWZpYyBtb2R1bGUgZm9yIHByZXNzIGFuZCB0aGUgZW52aXJvbm1lbnQuXHUwMGEwPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlBlcmhhcHMgdGhlIG1vc3QgY2hhbGxlbmdpbmcgb2YgdGhlIGZvdXIgYWN0aXZpdGllcyBpcyBkZXNpZ25lZCB0byBoZWxwIHRoZSBwcmVzcyBwcm92ZSBpdHMgd29ydGggaGVyZSBcdTIwMTMgcHV0dGluZyBtZWFuaW5nZnVsIG51bWJlciBvbiBpdHMgZW52aXJvbm1lbnRhbCByZXBvcnRpbmcgXHUyMDEzIGFuZCBpdCdzIHBlcmhhcHMgYSBwZXJ2ZXJzZSByZXN1bHQgb2YgdGhlIGpvdXJuYWxpc20gZG9uZSBoZXJlIHRoYXQgRnJlbmNoIHBlb3BsZSBhcmUgY29uY2VybmVkIGFib3V0IHRoZSBpbXBhY3Qgb2YgYWR2ZXJ0aXNpbmcuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY1Nob3dpbmcgdGhhdCB3ZSBuZWVkIHRoaXMgbW9uZXkgdG8gbGl2ZSBhbmQgdG8gY2Fycnkgb24gaXMgZWFzeSwgYnV0IHNob3dpbmcgdGhhdCB3ZSBicmluZyBhIHZhbHVhYmxlIGNvbnRyaWJ1dGlvbiB0byB0aGUgcHVibGljIGRlYmF0ZSBpcyBub3Qgc28gZWFzeSxcdTIwMWQgUGV0aWxsYXVsdCBhY2tub3dsZWRnZXMuIFx1MjAxY0FuZCB0aGF0XHUyMDE5cyB3aGF0IHdlXHUyMDE5cmUgdHJ5aW5nIHRvIGRvLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNXZSB3YW50IHRvIGJlIGFibGUgdG8gc2F5IFx1MjAxOG9rYXksIHdlIGtub3cgdGhhdCBpdCdzIHNldmVyYWwgaHVuZHJlZHMgb2YgYXJ0aWNsZXMgYWJvdXQgZW52aXJvbm1lbnRhbCBpc3N1ZXMgcGVyIGRheVx1MjAxOS4gU28gd2UncmUgdHJ5aW5nIHRvIGdldCBhIG51bWJlciBhbmQgdGhlbiB0byB1c2UgdGhhdCBudW1iZXIsIHRvIHNob3cgdGhlIHZhbHVlIHdlIGJyaW5nLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNOZXdzcGFwZXJzIGFyZSBvbmUgb2YgdGhlIG1haW4gY2hhbm5lbHMgdG8gY29tbXVuaWNhdGUgYW5kIHRvIGluZmx1ZW5jZSB0aGUgcHVibGljIG9uIGVudmlyb25tZW50YWwgaXNzdWVzIGFuZCB0byBiZSByZWFsaXN0aWMsIGluIHRoZSBwYXN0IGRlY2FkZSwgbW9zdCBvZiB0aGlzIHdvcmsgd2FzIGRvbmUsIGVzcGVjaWFsbHksIGJ5IHRoZSBpbmZvcm1hdGlvbiBwcmVzcy5cdTAwYTA8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjV2UgY29udHJpYnV0ZWQgYSBsb3QgdG8gcmFpc2UgdGhlc2UgaXNzdWVzLiBBbmQgbm93IHdlIGhhdmUgdGhlc2UgcG9saWN5bWFrZXJzIHR1cm5pbmcgdG8gdXMgYW5kIHNheWluZywgXHUyMDE4b2theSwgeW91IHdvbid0IGJlIGFibGUgdG8gZG8gYWR2ZXJ0aXNpbmcgZm9yIGNhcnMgYW55bW9yZSBhbmQgd2Ugc2F5LCBcdTIwMThva2F5LCBsZXQncyByZWd1bGF0ZSBjYXIgc2VsbGluZyBpZiB0aGlzIGlzIGEgcHJvYmxlbSwgYnV0IG5vdCBhZHZlcnRpc2luZy4gVGhpcyBtYWtlcyBubyBzZW5zZVx1MjAxOS5cdTAwYTA8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjU28gd2hhdCB3ZSB3YW50IHRvIHNob3cgaXMgdGhhdCB3ZSBjYW4gYmUgdmlydHVvdXMgb24gYWR2ZXJ0aXNpbmcsIGV2ZW4gZm9yIHBvbGx1dGluZyBwcm9kdWN0cywgYW5kIHRoYXQgd2UgdHJ5IHRvIGJlIG9iamVjdGl2ZSBhYm91dCB3aGF0IHdlIGJyaW5nIGluIHRlcm1zIG9mIGVudmlyb25tZW50YWwgY29uc2Npb3VzbmVzcy5cdTIwMWQ8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+VGhlIEFsbGlhbmNlIGhhcyBhbHNvIGNyZWF0ZWQgYSBjb3Jwb3JhdGUgc29jaWFsIHJlc3BvbnNpYmlsaXR5IHdvcmtpbmcgZ3JvdXAgc28gaXQgY2FuIHVuZGVyc3RhbmQgaG93IHB1Ymxpc2hlcnMgYXJlIGFscmVhZHkgZG9pbmcgaW4gdGhpcyBhcmVhLCBpbmNsdWRpbmcgbG9va2luZyBhdCB0aGUgaW5kdXN0cnlcdTIwMTlzIGNhcmJvbiBmb290cHJpbnQuIFRoZSBmb3JtZXIgdGVsZWNvbXMgZXhlY3V0aXZlIHNheXMgc29tZSBvZiB0aGVtIGFyZSB2ZXJ5IGFkdmFuY2VkLCBidXQgc29tZSBhcmUgbm90IGF0IGFsbCwgd2hpY2ggaXMgd2h5IHRoZXkgYXJlblx1MjAxOXQgY3VycmVudGx5IGdvaW5nIHRvIGJlIHRhY2tsaW5nIGRpZ2l0YWwuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY0ZpcnN0IG9mIGFsbCwgd2UgZG9uJ3QgZ2VuZXJhdGUgdmFsdWUgdGhyb3VnaCBzbWFydHBob25lcyBvciBXaS1GaSB0aGVtc2VsdmVzLFx1MjAxZCBoZSBleHBsYWlucy4gXHUyMDFjU29tZSBvZiBvdXIgbmV3c3BhcGVycyBhcmUgdmVyeSBkaWdpdGFsaXNlZCwgYnV0IHRoYXQncyB0aGUgY2FzZSBvZiB1c3VhbGx5IHRoZSBiaWcgbmF0aW9uYWwgbmV3c3BhcGVycywgZm9yIGluc3RhbmNlLCBMZSBNb25kZSBoYXMgbW9zdCBvZiBpdHMgc3Vic2NyaWJlcnMgdGhyb3VnaCBkaWdpdGFsIHJpZ2h0IG5vdy48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjQnV0IHRoYXQncyBhYnNvbHV0ZWx5IG5vdCB0aGUgY2FzZSB3aXRoIG1vc3Qgb2Ygb3VyIG1lbWJlcnMgXHUyMDEzIHRoZSBzbWFsbGVzdCBuZXdzcGFwZXJzLCBlc3BlY2lhbGx5IHRoZSBtb3JlIHRoYW4gMjAwIHJlZ2lvbmFsIHdlZWtseSBuZXdzcGFwZXJzIFx1MjAxMyBzb21lIG9mIHRoZW0gaGF2ZSBhbG1vc3Qgbm8gZGlnaXRhbCBmb290cHJpbnQuIE91ciBlY29ub215IGlzIHN0aWxsIG1haW5seSBiYXNlZCBvbiBwYXBlci48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjRnJvbSB0aGlzIGdyb3VwLCB3ZSB3aWxsIHNoYXJlIHdoYXQgaXMgZG9hYmxlIGJ5IHRoZSBtYWpvcml0eSBvZiB0aGVtIGFuZCBvbmUgb2YgdGhlIHdvcmsgc3RyZWFtcyB3ZSBoYXZlIGlzIHRoZSBlbnZpcm9ubWVudGFsIGZvb3RwcmludC4gQnV0IHdlIGFyZSBhdCB0aGUgYmVnaW5uaW5nLlx1MjAxZDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5DT05UQUNUPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlBpZXJyZSBQZXRpbGxhdWx0LCBEaXJlY3RvciBHZW5lcmFsIGF0IEFsbGlhbmNlIGRlIGxhIFByZXNzZSBkJ0luZm9ybWF0aW9uIEdcdTAwZTluXHUwMGU5cmFsZTwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5Ud2l0dGVyOjwvc3Bhbj4gPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vcHBldGlsbGF1bHQ/bGFuZz1lblwiPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5AUFBldGlsbGF1bHQ8L3NwYW4+PC9hPlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XSIsInBvc3RfdGl0bGUiOiJBbGxpYW5jZSBQcmVzc2U6IGJhbGFuY2luZyBlY29ub21pYyBhbmQgZW52aXJvbm1lbnRhbCBzdWNjZXNzIGluIHRoZSBGcmVuY2ggcHJlc3MiLCJwb3N0X2xpbmsiOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvYWxsaWFuY2UtcHJlc3NlLyIsInBvc3RfZmVhdHVyZWRfaW1hZ2UiOiI8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIlRoZSBibHVlIGltYWdlIHdpdGggd2hpdGUgd3JpdGluZyBleHBsYWlucyAoaW4gRnJlbmNoKSB0aGUgQWxsaWFuY2UgUHJlc3NlJiMwMzk7cyBlbnZpcm9ubWVudGFsIGNvbW1pdG1lbnQsIGl0IHNheXM6IEVjb2xvZ2ljYWwgdHJhbnNpdGlvbiBhbmQgYWR2ZXJ0aXNpbmcgLSB0aGUgbmV3cyBwcmVzcyBjb250aW51ZXMgaXRzIGNvbW1pdG1lbnRcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjEwMFwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIxLzA2L0FsbGlhbmNlLWRlLWxhLVByZXNzZS1kSW5mb3JtYXRpb24tR2VcdTAzMDFuZVx1MDMwMXJhbGVzLWVjb2xvZ2ljYWwtdHJhbnNpdGlvbi1jYW1wYWlnbi13aWRlLXYzLTMwMHgxMDAuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+IiwicG9zdF9jYXRlZ29yaWVzIjoiR3JlZW4gbWVkaWEsIElubm92YXRpb24gQ2FzZSIsInBvc3RfdGFncyI6IkFBQ0MsIEFDUE0sIEFkdmVydGlzaW5nLCBBbGxpYW5jZSBkZSBsYSBQcmVzc2UgZCdJbmZvcm1hdGlvbiBHXHUwMGU5blx1MDBlOXJhbGUsIEFsbGlhbmNlIFByZXNzZSwgQnJhaW5wcmludCwgQ0lURU8sIENsaW1hdGUgYmlsbCwgQ29ycG9yYXRlIHNvY2lhbCByZXNwb25zaWJpbGl0eSwgUGllcnJlIFBldGlsbGF1bHQsIFJlY3ljbGluZyIsIiVfZWRpdF9sb2NrJSI6IjE2NjEyNjI0NjI6OTMzIiwiJV9lZGl0X2xhc3QlIjoiOTMzIiwiJV90aHVtYm5haWxfaWQlIjoiMTU2MDkiLCIlc2xpZGVfdGVtcGxhdGUlIjoiZGVmYXVsdCIsIiVfd3BiX3ZjX2pzX3N0YXR1cyUiOiJ0cnVlIiwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6IjY5IFJ1ZSBkdSBDaGV2YWxlcmV0LCA3NTAxMyBQYXJpcywgRnJhbmNlIiwiJV93cGdtcF9sb2NhdGlvbl9jaXR5JSI6IlBhcmlzIiwiJV93cGdtcF9sb2NhdGlvbl9zdGF0ZSUiOiJcdTAwY2VsZS1kZS1GcmFuY2UiLCIlX3dwZ21wX2xvY2F0aW9uX2NvdW50cnklIjoiRnJhbmNlIiwiJV93cGdtcF9tZXRhYm94X2xhdGl0dWRlJSI6IjQ4LjgyODQ5MTg5OTk5OTk5IiwiJV93cGdtcF9tZXRhYm94X2xvbmdpdHVkZSUiOiIyLjM3NjIxNjU5OTk5OTk5OSIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiMlwiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6Ik47IiwiJV93cGdtcF9tZXRhYm94X3RheG9tb21pZXNfdGVybXMlIjoiTjsiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6Ik47IiwiJV95b2FzdF93cHNlb19mb2N1c2t3JSI6IkFsbGlhbmNlIFByZXNzZSIsIiVfeW9hc3Rfd3BzZW9fdGl0bGUlIjoiQWxsaWFuY2UgUHJlc3NlOiBiYWxhbmNpbmcgZWNvbm9taWNzIGFuZCB0aGUgZW52aXJvbm1lbnQgaW4gRnJlbmNoIG5ld3MiLCIlX3lvYXN0X3dwc2VvX21ldGFkZXNjJSI6IkFsbGlhbmNlIFByZXNzZSBoYXMgbWFkZSBhIGZvdXItcG9pbnQgY29tbWl0bWVudCB0byB0YWNrbGUgZW52aXJvbm1lbnRhbCBpc3N1ZXMgXHUyMDEzIGZvY3Vzc2VkIG9uIGNvbmNlcm5zIGFib3V0IGFkdmVydGlzaW5nLiIsIiVfeW9hc3Rfd3BzZW9fbGlua2RleCUiOiI3MSIsIiVfeW9hc3Rfd3BzZW9fY29udGVudF9zY29yZSUiOiIzMCIsIiVfeW9hc3Rfd3BzZW9fZXN0aW1hdGVkLXJlYWRpbmctdGltZS1taW51dGVzJSI6IjciLCIlX3lvYXN0X3dwc2VvX3ByaW1hcnlfY2F0ZWdvcnklIjoiNjkiLCIldHdpdHRlcl9zaGFyZSUiOiJBbGxpYW5jZSBQcmVzc2U6IGJhbGFuY2luZyBlY29ub21pY3MgYW5kIHRoZSBlbnZpcm9ubWVudCBpbiBGcmVuY2ggbmV3cyIsIiV0d2l0dGVyX2NhcmQlIjoiQWxsaWFuY2UgUHJlc3NlOiBiYWxhbmNpbmcgZWNvbm9taWNzIGFuZCB0aGUgZW52aXJvbm1lbnQgaW4gRnJlbmNoIG5ldyIsIiVfeW9hc3Rfd3BzZW9fb3BlbmdyYXBoLXRpdGxlJSI6IkFsbGlhbmNlIFByZXNzZTogYmFsYW5jaW5nIGVjb25vbWljcyBhbmQgdGhlIGVudmlyb25tZW50IGluIEZyZW5jaCBuZXdzIiwiJV95b2FzdF93cHNlb19vcGVuZ3JhcGgtaW1hZ2UlIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMjEvMDEvU2NyZWVuLVNob3QtMjAyMS0wNi0yMS1hdC0xMC41Mi41Ni5wbmciLCIlX3lvYXN0X3dwc2VvX29wZW5ncmFwaC1pbWFnZS1pZCUiOiIxNTYwMyIsIiVfeW9hc3Rfd3BzZW9fdHdpdHRlci10aXRsZSUiOiJBbGxpYW5jZSBQcmVzc2U6IGJhbGFuY2luZyBlY29ub21pY3MgYW5kIHRoZSBlbnZpcm9ubWVudCBpbiBGcmVuY2ggbmV3cyIsIiVfeW9hc3Rfd3BzZW9fdHdpdHRlci1pbWFnZSUiOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAyMS8wMS9TY3JlZW4tU2hvdC0yMDIxLTA2LTIxLWF0LTEwLjUyLjU2LnBuZyIsIiVfeW9hc3Rfd3BzZW9fdHdpdHRlci1pbWFnZS1pZCUiOiIxNTYwMyIsInRheG9ub215PWNhdGVnb3J5IjoiR3JlZW4gbWVkaWEsIElubm92YXRpb24gQ2FzZSIsInRheG9ub215PXBvc3RfdGFnIjoiQUFDQywgQUNQTSwgQWR2ZXJ0aXNpbmcsIEFsbGlhbmNlIGRlIGxhIFByZXNzZSBkJ0luZm9ybWF0aW9uIEdcdTAwZTluXHUwMGU5cmFsZSwgQWxsaWFuY2UgUHJlc3NlLCBCcmFpbnByaW50LCBDSVRFTywgQ2xpbWF0ZSBiaWxsLCBDb3Jwb3JhdGUgc29jaWFsIHJlc3BvbnNpYmlsaXR5LCBQaWVycmUgUGV0aWxsYXVsdCwgUmVjeWNsaW5nIn0sImljb24iOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxOC8wMi9tYXJrZXItMS5wbmcifSwiaWQiOjE1NjAyLCJpbmZvd2luZG93X2Rpc2FibGUiOmZhbHNlfSx7InNvdXJjZSI6InBvc3QiLCJ0aXRsZSI6IkJCQyBGdXR1cmUgUGxhbmV0OiBzdXN0YWluYWJsZSBkZXZlbG9wbWVudCBpbiBhIHNvbHV0aW9ucyBuZXdzcm9vbSIsImluZm93aW5kb3dfY29udGVudCI6IjxkaXYgY2xhc3M9XCJmYy1pdGVtLWJveCBmYy1pdGVtLW5vLXBhZGRpbmdcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiQSBzY3JlZW5zaG90IG9mIHRoZSBCQkMgRnV0dXJlIFBsYW5ldCB3ZWJzaXRlIGZyb250IHBhZ2UsIGluY2x1ZGluZyBhIHN0b3J5IGFib3V0IExhZ29zIGluIE5pZ2VyaWEsIHdoaWNoIGlzIG9mdGVuIGZsb29kZWRcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjEzNlwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIxLzAxL1NjcmVlbi1TaG90LTIwMjEtMDItMTYtYXQtMTQuNTEuMzEtMzAweDEzNi5wbmdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1wYWRkaW5nLWNvbnRlbnRfMjBcIj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1tZXRhIGZjLWl0ZW0tc2Vjb25kYXJ5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2UgZmMtdGV4dC1jZW50ZXJcIj5HcmVlbiBtZWRpYSwgSW5ub3ZhdGlvbiBDYXNlPC9kaXY+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tdGl0bGUgZmMtaXRlbS1wcmltYXJ5LXRleHQtY29sb3IgZmMtdGV4dC1jZW50ZXJcIj5CQkMgRnV0dXJlIFBsYW5ldDogc3VzdGFpbmFibGUgZGV2ZWxvcG1lbnQgaW4gYSBzb2x1dGlvbnMgbmV3c3Jvb208L2Rpdj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1jb250ZW50IGZjLWl0ZW0tYm9keS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+XHJcbiAgICAgICAgICAgIEJCQyBGdXR1cmUgUGxhbmV0IGlzIGNhbGN1bGF0aW5nIGl0cyBkaWdpdGFsIGZvb3RwcmludCBhbmQgY3V0dGluZyBmbHlpbmcsIHdoaWNoIGhhcyBjdXQgY29zdHMgYW5kIGluY3JlYXNlZCBkaXZlcnNpdHkgaW4gdGhlIG5ld3Nyb29tLlxyXG4gICAgICAgIDwvZGl2PlxyXG48YSBocmVmPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL2JiYy1mdXR1cmUtcGxhbmV0L1wiPlJlYWQgbW9yZTwvYT5cclxuICAgIDwvZGl2PlxyXG4gICAgPC9kaXY+XHJcbjwvZGl2PlxyXG5cclxuIiwiY29udGVudCI6IkJCQyBGdXR1cmUgUGxhbmV0IGlzIGNhbGN1bGF0aW5nIGl0cyBkaWdpdGFsIGZvb3RwcmludCBhbmQgY3V0dGluZyBmbHlpbmcsIHdoaWNoIGhhcyBjdXQgY29zdHMgYW5kIGluY3JlYXNlZCBkaXZlcnNpdHkgaW4gdGhlIG5ld3Nyb29tLiIsImFkZHJlc3MiOiJCcm9hZGNhc3RpbmcgSG91c2UsIFBvcnRsYW5kIFBsLCBNYXJ5bGVib25lLCBMb25kb24gVzFBIDFBQSwgVUsiLCJsb2NhdGlvbiI6eyJsYXQiOiI1MS41MTg4ODg0Iiwic3RhdGUiOiJFbmdsYW5kIiwiY291bnRyeSI6IlVuaXRlZCBLaW5nZG9tIiwibG5nIjoiLTAuMTQzOTMwNyIsIm9uY2xpY2tfYWN0aW9uIjoibWFya2VyIiwicmVkaXJlY3RfcGVybWFsaW5rIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL2JiYy1mdXR1cmUtcGxhbmV0LyIsInpvb20iOjIsImV4dHJhX2ZpZWxkcyI6eyJwb3N0X2V4Y2VycHQiOiJCQkMgRnV0dXJlIFBsYW5ldCBpcyBjYWxjdWxhdGluZyBpdHMgZGlnaXRhbCBmb290cHJpbnQgYW5kIGN1dHRpbmcgZmx5aW5nLCB3aGljaCBoYXMgY3V0IGNvc3RzIGFuZCBpbmNyZWFzZWQgZGl2ZXJzaXR5IGluIHRoZSBuZXdzcm9vbS4iLCJwb3N0X2NvbnRlbnQiOiJbdmNfcm93XVt2Y19jb2x1bW4gd2lkdGg9XCIxLzRcIl1bdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS8yXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48aDE+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkJCQyBGdXR1cmUgUGxhbmV0OiBzdXN0YWluYWJsZSBkZXZlbG9wbWVudCBpbiBhIHNvbHV0aW9ucyBuZXdzcm9vbTwvc3Bhbj48L2gxPlxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+RnV0dXJlIFBsYW5ldCB3YXM8L3NwYW4+IDxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5sYXVuY2hlZCBpbiBGZWJydWFyeSAyMDIwIGFzIGEgbmV3IHN1Yi1zaXRlIG9mIHRoZSBVSyBwdWJsaWMtc2VydmljZSBicm9hZGNhc3Rlclx1MjAxOXMgY29tbWVyY2lhbCBhcm0gQkJDLmNvbS48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+SXQgb2ZmZXJzIGl0cyBnbG9iYWwgYXVkaWVuY2UgYSBcdTIwMThzb2x1dGlvbnMgam91cm5hbGlzbVx1MjAxOSB0YWtlIG9uIGEgd2hvbGUgcGxhbmV0XHUyMDE5cyB3b3J0aCBvZiBlbnZpcm9ubWVudGFsIGlzc3VlcyAtIHdoZXRoZXIgdGhhdFx1MjAxOXMgdGhlPC9zcGFuPjxhIGhyZWY9XCJodHRwczovL3d3dy5iYmMuY29tL2Z1dHVyZS9hcnRpY2xlLzIwMjEwMTEyLXRoZS12YXN0LWJpY3ljbGUtZ3JhdmV5YXJkcy1vZi1jaGluYVwiPiA8c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+cHJvcyBhbmQgY29ucyBvZiBiaWtlLXNoYXJlIHNjaGVtZXM8L3NwYW4+PC9hPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj4gb3IgdGhlPC9zcGFuPjxhIGhyZWY9XCJodHRwczovL3d3dy5iYmMuY29tL2Z1dHVyZS9hcnRpY2xlLzIwMjEwMTE5LXdoeS1zYXZpbmctd2hhbGVzLWNhbi1oZWxwLWZpZ2h0LWNsaW1hdGUtY2hhbmdlXCI+IDxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5jb250cmlidXRpb24gdGhhdCB3aGFsZXMgbWFrZSB0byBjb250cm9sbGluZyB0aGUgdGVtcGVyYXR1cmUgb2YgdGhlIG9jZWFuPC9zcGFuPjwvYT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+Ljwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNJIHRoaW5rIHBlb3BsZSBzb21ldGltZXMgZ2V0IHRoZSB3cm9uZyBpZGVhIGFib3V0IHNvbHV0aW9ucyBqb3VybmFsaXNtLFx1MjAxZCBleHBsYWlucyB0aGUgc2l0ZVx1MjAxOXMgZWRpdG9yIE1hcnRoYSBIZW5yaXF1ZXMuIFx1MjAxY1RoZXkgdGhpbmsgaXQncyBhYm91dCBzdWNjZXNzIHN0b3JpZXMgb3IgdGhhdCBpdCdzIGFib3V0IFx1MjAxOGZlZWwgZ29vZFx1MjAxOSBzdG9yaWVzLiBTb21ldGltZXMgYSBzdWNjZXNzIHN0b3J5IGlzIGEgc29sdXRpb25zIHN0b3J5LCBidXQgdGhhdCdzIG5vdCB0aGUgd2hvbGUgb2YgaXQgYXQgYWxsLiBJdCdzIGFib3V0IGFzc2Vzc2luZyBzb2x1dGlvbnMgaW4gdGhlIHJvdW5kIGFuZCBmaW5kaW5nIGV2aWRlbmNlLWJhc2VkIHdheXMgdGhhdCB3ZSBjYW4gdGFja2xlIHRoZXNlIGNyaXNlcy5cdTIwMWQ8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+Tm90IG9ubHkgaXMgdGhlcmUgYSBncm93aW5nIGJvZHkgb2YgYWNhZGVtaWMgbGl0ZXJhdHVyZSBvbiB3aGF0IGlzIGFuZCBpc25cdTIwMTl0IHNvbHV0aW9ucyBqb3VybmFsaXNtLCBhbmQgd2h5IHNvbHV0aW9ucyBtYXR0ZXIsIGJ1dCB0aGVyZSBhcmUgYWxzbyBvcmdhbmlzYXRpb25zIGluY2x1ZGluZyB0aGU8L3NwYW4+PGEgaHJlZj1cImh0dHBzOi8vd3d3LnNvbHV0aW9uc2pvdXJuYWxpc20ub3JnL1wiPiA8c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+U29sdXRpb25zIEpvdXJuYWxpc20gTmV0d29yazwvc3Bhbj48L2E+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPiB0aGF0IHByb3ZpZGUgcmVzb3VyY2VzIGFuZCB0cmFpbmluZyBpbiB0aGlzIGFyZWEuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY0l0XHUyMDE5cyBlc3NlbnRpYWxseSBhYm91dCBhdWRpZW5jZSxcdTIwMWQgSGVucmlxdWVzIGV4cGxhaW5zLiBcdTIwMWNBbmQgaW4gYSB3YXksIGl0J3MgcXVpdGUgY29tbW9uIHNlbnNlLiBJZiB5b3UgaGF2ZSBhIHRvdGFsbHkgXHUyMDE4ZG9vbSBhbmQgZ2xvb21cdTIwMTkgbmFycmF0aXZlIGFib3V0IHRoaXMgY3Jpc2lzLCB0aGVuIGl0IGZlZWxzIGluc3VybW91bnRhYmxlLCBhbmQgaXQncyBqdXN0IGEgcmVhbGx5IGhhcmQgdGhpbmcgdG8gZW5nYWdlIHdpdGggYW5kIGlzIHByb2JhYmx5IGNvdW50ZXJwcm9kdWN0aXZlLiBUaGlzIGlzIG5vIGxvbmdlciBhIHNvcnQgb2YgZGViYXRlIGFib3V0IHdoZXRoZXIgY2xpbWF0ZSBjaGFuZ2UgZXhpc3RzXHUyMDI2IG5vdywgdGhlIGltcG9ydGFudCB0aGluZyBpcyB3aGF0IHlvdSBkbyBhYm91dCBpdC5cdTIwMWQ8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+QW5kLCB3aGF0IHlvdSBkbyBhYm91dCBpdCBhdCBGdXR1cmUgUGxhbmV0IGdvZXMgYmV5b25kIHNpbXBseSBzZWVraW5nIG91dCB0aGUgdmVyeSBiZXN0IHNvbHV0aW9ucywgaXRcdTIwMTlzIGFsc28gYWJvdXQgZ2V0dGluZyBhbiBhbGlnbm1lbnQgYmV0d2VlbiBlZGl0b3JpYWwgdmFsdWVzIGFuZCB3b3JraW5nIHByYWN0aWNlcy48L3NwYW4+XHJcbjxoMz48Yj5GZXdlciBmbGlnaHRzLCBncmVhdGVyIGRpdmVyc2l0eTwvYj48L2gzPlxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjSXQgbWlnaHQgc2VlbSBsaWtlIGEgZmFpcmx5IHNtYWxsIGFtb3VudCBvZiBlbWlzc2lvbnMsIHNlbmRpbmcgYSByZXBvcnRlciBmcm9tIG9uZSBjb3VudHJ5IHRvIGFub3RoZXIgdG8gY292ZXIgYSBzdG9yeSwgYW5kIHdoZW4gdGhlcmUncyBhYnNvbHV0ZWx5IG5vIHdheSB0byBpdCB3aXRob3V0IGZseWluZywgSSB3b3VsZCBzYXkgdGhlIGVkaXRvcmlhbCBqdXN0aWZpY2F0aW9uIG9mIGNvdmVyaW5nIGEgcmVhbGx5IGltcG9ydGFudCBlbnZpcm9ubWVudGFsIHN0b3J5IHdvdWxkIHdpbiBvdXQsXCIgSGVucmlxdWVzIGFja25vd2xlZGdlcy5cdTAwYTA8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjQnV0IEkgdGhpbmsgYSBsb3Qgb2YgcHVibGljYXRpb25zIGZhbGwgYmFjayBvbiB0aGF0IGNydXRjaCBhbmQgdGhhdCBoaXN0b3JpYyB3YXkgb2YgZG9pbmcgdGhpbmdzLCB3aXRob3V0IHRoaW5raW5nIG9mIHRoZSBhbHRlcm5hdGl2ZXMgYW5kIG9mIHRoZSBiZW5lZml0cyBvZiB0aGlua2luZyBpbiBhIG1vcmUgc3VzdGFpbmFibGUgd2F5Llx1MjAxZDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5CeSBjb21taXR0aW5nIHRvIHRyeWluZyBub3QgdG8gZmx5IHBlb3BsZSBvdXQgZnJvbSBMb25kb24sIGR1cmluZyBhIDEwLW1vbnRoIHBlcmlvZCBzaGUgY2FsY3VsYXRlcyB0aGlzIHNhdyB0aGUgcHVibGljYXRpb24gY3V0IGl0cyBwb3RlbnRpYWwgY2FyYm9uIHVzYWdlIGZyb20gMjYuNSB0b25uZXMsIHRvIGxlc3MgdGhhbiBoYWxmIGEgdG9ubmUgdXNlZC48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjVGhlcmUncyBvYnZpb3VzbHkgdGhlIGJlbmVmaXRzIG9mIHRoZSBlbWlzc2lvbnMgaWYgeW91IGRvbid0IGZseSByZXBvcnRlcnMgYXJvdW5kLCBidXQgaXQgZ2l2ZXMgeW91IHRoYXQgZXh0cmEgaW1wZXR1cyB0byBleHBhbmQgeW91ciBwb29sIG9mIHdyaXRlcnMgYW5kIHRvIHdvcmsgd2l0aCBtb3JlIGxvY2FsIHJlcG9ydGVycyBhcm91bmQgdGhlIHdvcmxkLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cIkFuZCB0aGVyZSBhcmUganVzdCBzbyBtYW55IGJlbmVmaXRzIGJleW9uZCBjYXJib24gZW1pc3Npb25zIHRvIGRvaW5nIHRoYXQuIFlvdSBzdXJmYWNlIHZvaWNlcyB0aGF0IHlvdSB3b3VsZG4ndCBvdGhlcndpc2UgaGVhci4gWW91IGdldCBhIHJlYWxseSBncm91bmRlZCBwZXJzcGVjdGl2ZSwgd2hpY2ggaXMgYSB2YXN0IGltcHJvdmVtZW50IHRvIHNvbWVvbmUgYmVpbmcgcGFyYWNodXRlZCBpbiBhbmQgd2hvIG9ubHkgaGFzIGEgZmV3IGRheXMgdG8gdHJ5IGFuZCBnZXQgdGhlaXIgaGVhZCBhcm91bmQgdGhlIHNpdHVhdGlvbi5cdTAwYTA8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjQW5kIGFsc28sIGVzcGVjaWFsbHkgYXMgd2VcdTIwMTlyZSBhIHZlcnkgZ2xvYmFsIHB1YmxpY2F0aW9uLCB3ZSBzZWUgYWxsIHRoZSBiZW5lZml0cyBpbiB0ZXJtcyBvZiBkaXZlcnNpdHkgLSA2MCBwZXIgY2VudCBvZiBvdXIgd3JpdGVycyBvbiBGdXR1cmUgUGxhbmV0IGFyZSBibGFjayBvciBtaW5vcml0eSBldGhuaWMgcmVwb3J0ZXJzLlx1MDBhMDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNBbmQgd2Ugd29yayB3aXRoIGEgbG90IG9mIHJlcG9ydGVycyBpbiB0aGUgR2xvYmFsIFNvdXRoLiBUaGF0J3MgcGFydGljdWxhcmx5IGltcG9ydGFudCBpbiB0ZXJtcyBvZiBjbGltYXRlIGNoYW5nZSwgYmVjYXVzZSwgd2hlbiB5b3UncmUgd3JpdGluZyBzdG9yaWVzIGFib3V0IHNvbHV0aW9ucyB0aGF0IGFyZSBiZWluZyBicm91Z2h0IGludG8gZWZmZWN0IG9uIHRoZSBmcm9udCBsaW5lcyBvZiBjbGltYXRlIGNoYW5nZSwgaXQgbWF0dGVycyB0byBhY3R1YWxseSBoYXZlIHZvaWNlcyBmcm9tIHRob3NlIGNvbW11bml0aWVzIHRlbGxpbmcgdGhvc2Ugc3Rvcmllcy5cdTAwYTA8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjU28sIHlvdSBrbm93LCBmcm9tIHRoZSBvdXRzZXQsIHRoZXJlIHdhcyB0aGlzIGtpbmQgb2YgbmV0IG9mIGJlbmVmaXRzIHRvIHRoaW5raW5nIGFib3V0IHN1c3RhaW5hYmlsaXR5IGluIHRlcm1zIG9mIG91ciBlbWlzc2lvbnMgYW5kIHdoYXQgdGhhdCB3aWxsIGFsc28gZG8gc29ydCBvZiBlZGl0b3JpYWxseSBmb3IgdGhlIHB1YmxpY2F0aW9uLiBJdFx1MjAxOXMgYWxzbyBtb3JlIGZpbmFuY2lhbGx5IHN1c3RhaW5hYmxlIGFzIHdlbGwsIGJlY2F1c2UgeW91IGNhbiBjb3ZlciBtb3JlIHN0b3JpZXMgZm9yIHRoZSBzYW1lIGFtb3VudCBvZiBidWRnZXQuXHUyMDFkPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlRoaXMgY29tYmluYXRpb24gb2YgZW52aXJvbm1lbnRhbCwgc29jaWFsLCBjdWx0dXJhbCBhbmQgZWNvbm9taWMgYmVuZWZpdHMgPC9zcGFuPjxhIGhyZWY9XCJodHRwczovL2VuLnVuZXNjby5vcmcvdGhlbWVzL2VkdWNhdGlvbi1zdXN0YWluYWJsZS1kZXZlbG9wbWVudC93aGF0LWlzLWVzZC9zZFwiPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5tZWV0cyB0aGUgdmVyeSBkZWZpbml0aW9uIG9mIHN1c3RhaW5hYmxlIGRldmVsb3BtZW50PC9zcGFuPjwvYT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+IGNvbW1pdHRlZCB0byBieSBnb3Zlcm5tZW50cyBhbmQgY29tcGFuaWVzIGFyb3VuZCB0aGUgd29ybGQuIEFuZCBIZW5yaXF1ZXMgYmVsaWV2ZXMgaXRcdTIwMTlzIGFsc28gd2hlcmUgeW91XHUyMDE5cmUgbGlrZWx5IHRvIGZpbmQgaW5ub3ZhdGlvbi48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjSSB0aGluayBhIGxvdCBvZiBwdWJsaWNhdGlvbnMgbWlnaHQgYmUgcHV0IG9mZiBiZWNhdXNlIGl0IGZlZWxzIGxpa2UgeW91J3JlIHB1dHRpbmcgcmVzdHJpY3Rpb25zIG9uIHlvdXJzZWxmLiBZb3UncmUgdGhpbmtpbmcsXHUyMDE4d2UncmUgYWxyZWFkeSBleHRyZW1lbHkgYnVzeSBwZW9wbGUsIHNvIGhvdyBhcmUgd2UgZ29pbmcgdG8gY29wZSB3aXRoIHRoaXMgZXh0cmEgd29yayBvZiBtYWtpbmcgc3VyZSB3ZSBtYWtlIHRpbWUgdG8gbmV0d29yayB3aXRoIHJlcG9ydGVycyBiZXlvbmQgb3VyIGV4aXN0aW5nIGVjaG8gY2hhbWJlcnM/XHUyMDE5LiBCdXQsIEkgdGhpbmsgYnkgaW1wb3NpbmcgdGhvc2UgYm91bmRhcmllcyBhbmQgY2hhbGxlbmdlcywgeW91IGZpbmQgdGhhdCdzIHRoZSB3YXkgdGhhdCB5b3Ugd2lsbCByZWFsbHkgc29ydCBvZiBwdXNoIHlvdXJzZWxmIGludG8gZG9pbmcgc29tZXRoaW5nIG5ldy5cdTIwMWQ8L3NwYW4+XHJcbjxoMz48Yj5EaWdpdGFsIGZvb3RwcmludDwvYj48L2gzPlxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+RXZlcnkgc3RvcnkgYXQgRnV0dXJlIFBsYW5ldCBhbHNvPC9zcGFuPjxhIGhyZWY9XCJodHRwczovL3d3dy5iYmMuY29tL2Z1dHVyZS9hcnRpY2xlLzIwMjAwMTMxLXdoeS1hbmQtaG93LWRvZXMtZnV0dXJlLXBsYW5ldC1jb3VudC1jYXJib25cIj4gPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPmNvbWVzIHdpdGggYW4gZXN0aW1hdGUgb2YgdGhlIGVtaXNzaW9ucyBwZXIgcGFnZSB2aWV3LDwvc3Bhbj48L2E+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPiByZWxhdGl2ZWx5IHNtYWxsIGF0IG9uZSB0byB0aHJlZSBncmFtcywgYnV0IG5vIGVhc3kgdGFzayB0byBiZWdpbiB3aXRoLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNPdXIgZGlnaXRhbCBjYXJib24gZW1pc3Npb25zLCB0aGF0J3Mgc29tZXRoaW5nIGZhaXJseSBjb250YWluZWRcdTIwMjYgW2l0XHUyMDE5c10gdGhlIGVuZXJneSBuZWNlc3NhcnkgdG8gdHJhbnNmZXIgZGF0YSBvdmVyIHRoZSB3aXJlIGFuZCB0aGUgZW5lcmd5IGludGVuc2l0eSBvZiB0aGUgYXBwbGlhbmNlIHVzZWQgYW5kIHNvIG9uLiBCdXQgZXZlbiBpbiB0aGF0IHN5c3RlbSwgeW91IGhhdmUgdG8gbWFrZSBzbyBtYW55IGFzc3VtcHRpb25zLCBiZWNhdXNlIHRoZSBkZXZpY2UgdGhhdCBzb21lb25lJ3MgdXNpbmcgaXMgZGlmZmVyZW50LCBhbmQgdGhlIGVuZXJneSBpbnRlbnNpdHkgY291bGQgYmUgZGlmZmVyZW50IGluIGRpZmZlcmVudCBwYXJ0cyBvZiB0aGUgd29ybGQgYW5kIHNvIG9uLlx1MDBhMDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNTbyBldmVuIHdpdGggdGhhdCBraW5kIG9mIGNvbnRhaW5lZCBzeXN0ZW0sIGdldHRpbmcgYSBnb29kIGVzdGltYXRlIGlzIHJlbWFya2FibHkgZGlmZmljdWx0Llx1MDBhMCBXaGVuIHdlIGxhdW5jaGVkLCBJIGFsc28gd2FzIHJlYWxseSBrZWVuIHRvIGluY2x1ZGUgc3RydWN0dXJhbCBlbWlzc2lvbnMgaW50byB0aGUgY2FsY3VsYXRpb24uIFNvLCBmb3IgZXhhbXBsZSwgb3VyIHRlYW0gc2l0dGluZyBpbiBCQkMgb2ZmaWNlcywgXHUyMDE4d2hhdCBhbW91bnQgb2YgcG93ZXIgc2hvdWxkIGJlIHRha2VuIGludG8gYWNjb3VudCBmb3IgdGhhdD9cdTIwMTkuIEJ1dCBpdCBnZXRzIHJlbWFya2FibHkgY29tcGxpY2F0ZWQgdmVyeSBxdWlja2x5IGFuZCByZWFsbHkgZGlmZmljdWx0IHRvIHF1YW50aWZ5LiBTbyByYXRoZXIgdGhhbiBnaXZlIGEgc29ydCBvZiBib2RnZWQgZXN0aW1hdGlvbiwgd2UgZGVjaWRlZCwgYXMgeW91XHUyMDE5bGw8L3NwYW4+PGEgaHJlZj1cImh0dHBzOi8vd3d3LmJiYy5jb20vZnV0dXJlL2FydGljbGUvMjAyMDAxMzEtd2h5LWFuZC1ob3ctZG9lcy1mdXR1cmUtcGxhbmV0LWNvdW50LWNhcmJvblwiPiA8c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+cmVhZCBpbiB0aGUgYXJ0aWNsZTwvc3Bhbj48L2E+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPiwgdGhlcmUgYXJlIHNvbWUgcGxhY2VzIHdoZXJlIHdlIGp1c3QgZHJhdyB0aGUgbGluZS48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjVGhlIHZhc3QgbWFqb3JpdHkgb2YgdGhlIHdyaXRlcnMgZm9yIEZ1dHVyZSBQbGFuZXQgYXJlIGZyZWVsYW5jZXJzLiBTbyBpdCB3b3VsZCBmZWVsIGxpa2UgYSBiaXQgb2YgYW4gaW1wb3NpdGlvbiB0byBzYXkgXHUyMDE4YW5kIGhhdmUgeW91IHVwZGF0ZWQgeW91ciBkZXZpY2UgcmVjZW50bHk/XHUyMDE5LiBCdXQgd2l0aGluIHRoZSBzdGFmZiwgd2UgZG8gaGF2ZSBjb252ZXJzYXRpb25zIGFib3V0IHdoaWNoIGZvcm1zIG9mIGNvbW11bmljYXRpb24sIGVzcGVjaWFsbHkgd2hlbiB3ZSdyZSB3b3JraW5nIHJlbW90ZWx5LCBzaG91bGQgd2UgYmUgdXNpbmcuIFx1MjAxOFNob3VsZCB3ZSBiZSBzZW5kaW5nIG9uZS1saW5lIGVtYWlscz8gSG93IGRvZXMgdGhhdCBtZWFzdXJlIHVwIGFnYWluc3QgYSBTbGFjayBtZXNzYWdlIG9yIGEgV2hhdHNBcHAgbWVzc2FnZT9cdTIwMTkuXHUyMDFkPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPk5vIG9uZVx1MjAxOXMgc29sdmVkIHRoaXMgeWV0LCBhbHRob3VnaCB0aGU8L3NwYW4+PGEgaHJlZj1cImh0dHBzOi8vZGltcGFjdC5vcmcvYWJvdXRcIj4gPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkRJTVBBQ1Q8L3NwYW4+PC9hPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj4gdGVhbSBhdCB0aGUgVW5pdmVyc2l0eSBvZiBCcmlzdG9sLCBhbG9uZyB3aXRoIDEwIG1lZGlhIG9yZ2FuaXNhdGlvbnMgaW5jbHVkaW5nIHRoZSBCQkMsIGlzIGF0dGVtcHRpbmcgdG8gYW5zd2VyIHNvbWUgb3V0c3RhbmRpbmcgcXVlc3Rpb25zIGFyb3VuZCB0aGUgZW5lcmd5IGludGVuc2l0eSBvZiBtZWRpYSBjb25zdW1wdGlvbi48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+QW5vdGhlciBjaGFsbGVuZ2UgbWFueSBwdWJsaXNoZXJzIGhhdmUgaXMgd2l0aCBhZHZlcnRpc2luZyAtIHByZXNlbnQgb24gQkJDLmNvbSBzaXRlcyB3aGVuIHZpZXdlZCBmcm9tIG91dHNpZGUgdGhlIFVLLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNXZSBoYXZlIGJlZW4gcGFydGljdWxhcmx5IGNhcmVmdWwsIGZvciBleGFtcGxlLCBub3QgaGF2aW5nIGFuIGFpcmxpbmUgYnV5aW5nIG91dCBvdXIgYWRzIGZvciBhIHllYXIuIFdlIG5lZWQgdG8gYmUgY2FyZWZ1bCBhcm91bmQgZ3JlZW53YXNoaW5nLiBUaGUgQkJDIGhhcyBjb21wbGlhbmNlIGd1aWRhbmNlIHRvIG1ha2Ugc3VyZSB0aGF0IGFueSBhZHZlcnRpc2VyIHRoYXQgd2Ugd29yayB3aXRoIG1ha2VzIHNlbnNlIGZvciB0aGUgcHVibGljYXRpb24uXHUwMGEwPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY0J1dCBhbGwgcHVibGljYXRpb25zIGZhY2UgY2hhbGxlbmdlcyBhcm91bmQgdGhlaXIgYWR2ZXJ0aXNlcnMuIEFuZCBJIHRoaW5rLCBlc3BlY2lhbGx5IHdoZW4geW91J3JlIGNvdmVyaW5nIGVudmlyb25tZW50IGpvdXJuYWxpc20sIHRoZSBtb3N0IHN1c3RhaW5hYmxlLCBlY28tZnJpZW5kbHkgYnJhbmRzIHRoYXQgYXJlIG91dCB0aGVyZSBtYXkgbm90IGJlIHRoZSBvbmVzIHdpdGggdGhlIHB1cmNoYXNpbmcgcG93ZXIgZm9yIHRoZSBhZHZlcnRpc2luZyBzcGFjZS5cdTIwMWQ8L3NwYW4+XHJcbjxoMz48Yj5TeXN0ZW1pYyBjaGFuZ2U8L2I+PC9oMz5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlRoZSBzb2x1dGlvbnMgYXBwcm9hY2ggbWFrZXMgdGhlIHNpdGUgZGlzdGluY3RpdmUgZnJvbSB0aGUgbW9yZSBzdHJhaWdodCBlbnZpcm9ubWVudCBmZWF0dXJlcyBmb3VuZCBvbiBCQkMgRnV0dXJlLCB0aGUgcGFyZW50IHNpdGUgdGhhdFx1MjAxOXMgYmVlbiBkb2luZyBzY2llbmNlLCBoZWFsdGgsIHRlY2hub2xvZ3kgYW5kIGVudmlyb25tZW50IGZlYXR1cmVzIGZvciBpdHMgaW50ZXJuYXRpb25hbCBhdWRpZW5jZSBmb3I8L3NwYW4+PGEgaHJlZj1cImh0dHBzOi8vd3d3LmJiYy5jby51ay9tZWRpYWNlbnRyZS93b3JsZHdpZGUvMjIwMjEyZnV0dXJlXCI+IDxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5hbG1vc3QgYSBkZWNhZGU8L3NwYW4+PC9hPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj4uXHUwMGEwPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkl0IGlzIGFsc28gXHUyMDFjbm90IG5ld3NcdTIwMWQgSGVucmlxdWVzIHNheXMuIFx1MjAxY091ciByZW1pdCBpcyB0byB0YWtlIGEgc3RlcCBiYWNrIGZyb20gdGhlIG5ld3MgY3ljbGUgYW5kIGdpdmUgdGhlIGF1ZGllbmNlIGFkZGl0aW9uYWwgcGVyc3BlY3RpdmUgdGhhdCB0aGV5IG1pZ2h0IG5vdCBnZXQgZnJvbSB0aGUgMjQvNyBjb3ZlcmFnZSBvZiBjdXJyZW50IGFmZmFpcnMgLSB3ZSBsb29rIGF0IHN5c3RlbWljIGNoYW5nZS48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjU28gdGhhdCdzIGNoYW5nZXMgdGhyb3VnaCBpbmR1c3RyaWVzIGFuZCBsYXJnZS1zY2FsZSBwcm9jZXNzZXMgcmF0aGVyIHRoYW4sIGZvciBleGFtcGxlLCBcdTIwMThzaG91bGQgSSBidXkgYmFtYm9vIHRvaWxldCBwYXBlciBvciBzb3J0IG9mIGNvbnZlbnRpb25hbCB0b2lsZXQgcGFwZXI/XHUyMDE5Ljwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNJIHRoaW5rLCB5b3Uga25vdywgaWYgYW55dGhpbmcsIENPVklEIGhhcyBzaG93biB1cyB0aGF0IHRha2luZyBhIHN5c3RlbWljIGFwcHJvYWNoLCB0aGF0J3MgcmVhbGx5IHRoZSB3YXkgdGhhdCB5b3UgYXJlIGdvaW5nIHRvIGxlYWQgdG8gYW55IGxhcmdlLXNjYWxlIGNoYW5nZSBpbiB0ZXJtcyBvZiBjbGltYXRlIGNoYW5nZS4gWW91IG9mdGVuIGhhdmUgdGhlIGlkZWEgdGhhdCB0aGVzZSByZWFsbHkgYmlnIGNoYW5nZXMgdG8gb3VyIGxpdmVzIGxlYWQgdG8gYSBiaWcgaW1wYWN0IG9uIHRoZSBlbnZpcm9ubWVudC4gQnV0IGl0J3MgYWN0dWFsbHkgYSByZW1hcmthYmx5IHNtYWxsIGJsaXAgaW4gdGhlIHNjaGVtZSBvZiB0aGluZ3MuXHUyMDFkPC9zcGFuPlxyXG48aDM+PGI+Q29uc2lkZXJpbmcgYWN0aW9uPC9iPjwvaDM+XHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5BbHRob3VnaCBzb2x1dGlvbnMgam91cm5hbGlzbSwgYW5kIHRyYWRpdGlvbmFsIGpvdXJuYWxpc20sIGRvblx1MjAxOXQgdHlwaWNhbGx5IGFpbSB0byBnZXQgaW52b2x2ZWQgd2l0aCB0aGUgYWN0aW9uLCBIZW5yaXF1ZXMgc2F5cyB0aGF0IGluIDIwMjEsIEZ1dHVyZSBQbGFuZXQgbWF5IHRha2UgYSBtb3JlIGFjdGl2ZSByb2xlIGluIFx1MjAxOGNpdGl6ZW4gc2NpZW5jZVx1MjAxOSBwcm9qZWN0cyB3aXRoIGV4dGVybmFsIHBhcnRuZXJzLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5UaGUgQkJDIGl0c2VsZiBsZWQgdGhlIHdheSBvbiBkb2luZyBzby1jYWxsZWQgXHUyMDE4c2Vuc29yIGpvdXJuYWxpc21cdTIwMTkgaW4gaXRzIGVudmlyb25tZW50YWwgcmVwb3J0aW5nLDwvc3Bhbj48YSBocmVmPVwiaHR0cDovL25ld3MuYmJjLmNvLnVrLzEvaGkvbWFnYXppbmUvNzUzMjYwMy5zdG1cIj4gPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPm1lYXN1cmluZyBhaXIgcXVhbGl0eSBsaXZlPC9zcGFuPjwvYT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+IGF0IHRoZSAyMDA4IEJlaWppbmcgT2x5bXBpY3MuIE1hbnkgbW9yZSBtZWRpYSBvcmdhbmlzYXRpb25zIGhhdmUgZ29uZSBvbiB0byBpbmNsdWRlIHRoZWlyIGF1ZGllbmNlcyBkaXJlY3RseSBpbiBzdWNoIGRhdGEgY29sbGVjdGlvbiwgcGVyaGFwcyBtb3N0IG5vdGFibHkgV05ZQyB3aXRoIGl0czwvc3Bhbj48YSBocmVmPVwiaHR0cHM6Ly9jdXJyZW50Lm9yZy8yMDE2LzA3L3dueWNzLWxhdGVzdC1zZW5zb3Itam91cm5hbGlzbS1wcm9qZWN0LXplcm9lcy1pbi1vbi1oZWF0LWlzbGFuZC1oYXJsZW0vXCI+IDxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5IYXJsZW0gSGVhdCBQcm9qZWN0PC9zcGFuPjwvYT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+LDwvc3Bhbj48YSBocmVmPVwiaHR0cHM6Ly9wcm9qZWN0LndueWMub3JnL2NpY2FkYXMvXCI+IDxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5DaWNhZGEgVHJhY2tlcjwvc3Bhbj48L2E+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPiBhbmQ8L3NwYW4+PGEgaHJlZj1cImh0dHBzOi8vZ290aGFtaXN0LmNvbS9uZXdzL2NsaW1hdGUtY2hhbmdlLW1pZ2h0LWJlLW1lc3NpbmctdXAtc25vd2ZsYWtlcy1hcy13ZS1rbm93LXRoZW0tYnV0LXlvdS1jYW4taGVscFwiPiA8c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+WC1Tbm93PC9zcGFuPjwvYT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+LCBhbGwgc2Vla2luZyB0byBoZWxwIGNpdGl6ZW5zIGJlIHBhcnQgb2YgdGhlIHNvbHV0aW9uLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5DT05UQUNUPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPk1hcnRoYSBIZW5yaXF1ZXMsIEVkaXRvciBhdCBCQkMgRnV0dXJlIFBsYW5ldDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5Ud2l0dGVyOjwvc3Bhbj4gPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vbWFydGhhX3Jvc2FtdW5kP1wiPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5ATWFydGhhX1Jvc2FtdW5kPC9zcGFuPjwvYT5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzRcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd10iLCJwb3N0X3RpdGxlIjoiQkJDIEZ1dHVyZSBQbGFuZXQ6IHN1c3RhaW5hYmxlIGRldmVsb3BtZW50IGluIGEgc29sdXRpb25zIG5ld3Nyb29tIiwicG9zdF9saW5rIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL2JiYy1mdXR1cmUtcGxhbmV0LyIsInBvc3RfZmVhdHVyZWRfaW1hZ2UiOiI8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIkEgc2NyZWVuc2hvdCBvZiB0aGUgQkJDIEZ1dHVyZSBQbGFuZXQgd2Vic2l0ZSBmcm9udCBwYWdlLCBpbmNsdWRpbmcgYSBzdG9yeSBhYm91dCBMYWdvcyBpbiBOaWdlcmlhLCB3aGljaCBpcyBvZnRlbiBmbG9vZGVkXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIxMzZcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAyMS8wMS9TY3JlZW4tU2hvdC0yMDIxLTAyLTE2LWF0LTE0LjUxLjMxLTMwMHgxMzYucG5nXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+IiwicG9zdF9jYXRlZ29yaWVzIjoiR3JlZW4gbWVkaWEsIElubm92YXRpb24gQ2FzZSIsInBvc3RfdGFncyI6IkJCQyBGdXR1cmUgUGxhbmV0LCBDYXJib24gZW1pc3Npb25zLCBEaWdpdGFsIGZvb3RwcmludCwgRGl2ZXJzaXR5LCBGbHlpbmcsIE1hcnRoYSBIZW5yaXF1ZXMsIFNvbHV0aW9ucyBqb3VybmFsaXNtIiwiJV9lZGl0X2xvY2slIjoiMTYzNzY3Njg1Nzo5MzMiLCIlX2VkaXRfbGFzdCUiOiI5MzMiLCIlc2xpZGVfdGVtcGxhdGUlIjoiZGVmYXVsdCIsIiVfd3BiX3ZjX2pzX3N0YXR1cyUiOiJ0cnVlIiwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6IkJyb2FkY2FzdGluZyBIb3VzZSwgUG9ydGxhbmQgUGwsIE1hcnlsZWJvbmUsIExvbmRvbiBXMUEgMUFBLCBVSyIsIiVfd3BnbXBfbG9jYXRpb25fY2l0eSUiOiIiLCIlX3dwZ21wX2xvY2F0aW9uX3N0YXRlJSI6IkVuZ2xhbmQiLCIlX3dwZ21wX2xvY2F0aW9uX2NvdW50cnklIjoiVW5pdGVkIEtpbmdkb20iLCIlX3dwZ21wX21ldGFib3hfbGF0aXR1ZGUlIjoiNTEuNTE4ODg4NCIsIiVfd3BnbXBfbWV0YWJveF9sb25naXR1ZGUlIjoiLTAuMTQzOTMwNyIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiMlwiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6Ik47IiwiJV93cGdtcF9tZXRhYm94X3RheG9tb21pZXNfdGVybXMlIjoiTjsiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6Ik47IiwiJV95b2FzdF93cHNlb19jb250ZW50X3Njb3JlJSI6IjMwIiwiJV95b2FzdF93cHNlb19lc3RpbWF0ZWQtcmVhZGluZy10aW1lLW1pbnV0ZXMlIjoiNyIsIiVfdGh1bWJuYWlsX2lkJSI6IjE1NTI1IiwiJV95b2FzdF93cHNlb19wcmltYXJ5X2NhdGVnb3J5JSI6IjY5IiwiJV95b2FzdF93cHNlb19mb2N1c2t3JSI6IkJCQyBmdXR1cmUgcGxhbmV0IiwiJV95b2FzdF93cHNlb19saW5rZGV4JSI6IjcxIiwiJV95b2FzdF93cHNlb190aXRsZSUiOiJCQkMgRnV0dXJlIFBsYW5ldDogc3VzdGFpbmFibGUgZGV2ZWxvcG1lbnQgaW4gYSBzb2x1dGlvbnMgbmV3c3Jvb20iLCIlX3lvYXN0X3dwc2VvX21ldGFkZXNjJSI6IkJCQyBGdXR1cmUgUGxhbmV0IGlzIGNhbGN1bGF0aW5nIGl0cyBkaWdpdGFsIGZvb3RwcmludCBhbmQgY3V0dGluZyBmbHlpbmcsIHdoaWNoIGhhcyBjdXQgY29zdHMgYW5kIGluY3JlYXNlZCBkaXZlcnNpdHkgaW4gdGhlIG5ld3Nyb29tLiIsIiVfeW9hc3Rfd3BzZW9fb3BlbmdyYXBoLXRpdGxlJSI6IkJCQyBGdXR1cmUgUGxhbmV0OiBzdXN0YWluYWJsZSBkZXZlbG9wbWVudCBpbiBhIHNvbHV0aW9ucyBuZXdzcm9vbSIsIiVfeW9hc3Rfd3BzZW9fb3BlbmdyYXBoLWRlc2NyaXB0aW9uJSI6IkJCQyBGdXR1cmUgUGxhbmV0IGlzIGNhbGN1bGF0aW5nIGl0cyBkaWdpdGFsIGZvb3RwcmludCBhbmQgY3V0dGluZyBmbHlpbmcsIHdoaWNoIGhhcyBjdXQgY29zdHMgYW5kIGluY3JlYXNlZCBkaXZlcnNpdHkgaW4gdGhlIG5ld3Nyb29tLiIsIiVfeW9hc3Rfd3BzZW9fb3BlbmdyYXBoLWltYWdlJSI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIxLzAxL1NjcmVlbi1TaG90LTIwMjEtMDEtMjYtYXQtMTUuMDYuMjIucG5nIiwiJV95b2FzdF93cHNlb19vcGVuZ3JhcGgtaW1hZ2UtaWQlIjoiMTU0OTQiLCIlX3lvYXN0X3dwc2VvX3R3aXR0ZXItdGl0bGUlIjoiQkJDIEZ1dHVyZSBQbGFuZXQ6IHN1c3RhaW5hYmxlIGRldmVsb3BtZW50IGluIGEgc29sdXRpb25zIG5ld3Nyb29tIiwiJV95b2FzdF93cHNlb190d2l0dGVyLWRlc2NyaXB0aW9uJSI6IkJCQyBGdXR1cmUgUGxhbmV0IGlzIGNhbGN1bGF0aW5nIGl0cyBkaWdpdGFsIGZvb3RwcmludCBhbmQgY3V0dGluZyBmbHlpbmcsIHdoaWNoIGhhcyBjdXQgY29zdHMgYW5kIGluY3JlYXNlZCBkaXZlcnNpdHkgaW4gdGhlIG5ld3Nyb29tLiIsIiVfeW9hc3Rfd3BzZW9fdHdpdHRlci1pbWFnZSUiOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAyMS8wMS9TY3JlZW4tU2hvdC0yMDIxLTAxLTI2LWF0LTE1LjA2LjIyLnBuZyIsIiVfeW9hc3Rfd3BzZW9fdHdpdHRlci1pbWFnZS1pZCUiOiIxNTQ5NCIsInRheG9ub215PWNhdGVnb3J5IjoiR3JlZW4gbWVkaWEsIElubm92YXRpb24gQ2FzZSIsInRheG9ub215PXBvc3RfdGFnIjoiQkJDIEZ1dHVyZSBQbGFuZXQsIENhcmJvbiBlbWlzc2lvbnMsIERpZ2l0YWwgZm9vdHByaW50LCBEaXZlcnNpdHksIEZseWluZywgTWFydGhhIEhlbnJpcXVlcywgU29sdXRpb25zIGpvdXJuYWxpc20ifSwiaWNvbiI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE4LzAyL21hcmtlci0xLnBuZyJ9LCJpZCI6MTU0OTIsImluZm93aW5kb3dfZGlzYWJsZSI6ZmFsc2V9LHsic291cmNlIjoicG9zdCIsInRpdGxlIjoiU2NoaWJzdGVkOiBhZnRlciB0d28gY2VudHVyaWVzIG9mIGlubm92YXRpb24gJiM4MjExOyBwZW9wbGUgYW5kIHBsYW5ldCBhcmUgbm93IHRoZSBsZWFkIHN0b3J5IiwiaW5mb3dpbmRvd19jb250ZW50IjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZ1wiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJMb2dvIG9mIHRoZSBTZWNvbmQgSGFuZCBFZmZlY3QgbWFya2V0cGxhY2VzIHdvcmsgb24gYW4gaW1hZ2Ugb2YgYSBmb3Jlc3Qgd2l0aCBoaWxscyBhbmQgdGhlIHNreSBpbiB0aGUgYmFja2dyb3VuZFwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMTczXCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMjAvMTIvU2NyZWVuLVNob3QtMjAyMC0xMi0wOC1hdC0yMi4xNy4xMS0zMDB4MTczLnBuZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmdcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXBhZGRpbmctY29udGVudF8yMFwiPlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLW1ldGEgZmMtaXRlbS1zZWNvbmRhcnktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZSBmYy10ZXh0LWNlbnRlclwiPkdyZWVuIG1lZGlhPC9kaXY+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tdGl0bGUgZmMtaXRlbS1wcmltYXJ5LXRleHQtY29sb3IgZmMtdGV4dC1jZW50ZXJcIj5TY2hpYnN0ZWQ6IGFmdGVyIHR3byBjZW50dXJpZXMgb2YgaW5ub3ZhdGlvbiAmIzgyMTE7IHBlb3BsZSBhbmQgcGxhbmV0IGFyZSBub3cgdGhlIGxlYWQgc3Rvcnk8L2Rpdj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1jb250ZW50IGZjLWl0ZW0tYm9keS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+XHJcbiAgICAgICAgICAgIFNpbmNlIGEgc2hha2UtdXAgYXQgdGhlIHRvcCwgSGVhZCBvZiBTdXN0YWluYWJpbGl0eSwgQnJpdHQgTmlsc2VuLCBpcyBtYWtpbmcgc3VyZSB0aGUgY29tcGFueSBpcyBsZWFkaW5nIG9uIGRpdmVyc2l0eSBhbmQgdGhlIGVudmlyb25tZW50LlxyXG4gICAgICAgIDwvZGl2PlxyXG48YSBocmVmPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL3NjaGlic3RlZC1wZW9wbGUtcGxhbmV0L1wiPlJlYWQgbW9yZTwvYT5cclxuICAgIDwvZGl2PlxyXG4gICAgPC9kaXY+XHJcbjwvZGl2PlxyXG5cclxuIiwiY29udGVudCI6IlNpbmNlIGEgc2hha2UtdXAgYXQgdGhlIHRvcCwgSGVhZCBvZiBTdXN0YWluYWJpbGl0eSwgQnJpdHQgTmlsc2VuLCBpcyBtYWtpbmcgc3VyZSB0aGUgY29tcGFueSBpcyBsZWFkaW5nIG9uIGRpdmVyc2l0eSBhbmQgdGhlIGVudmlyb25tZW50LiIsImFkZHJlc3MiOiJBa2Vyc2dhdGEgNTUsIDAxODAgT3NsbywgTm9yd2F5IiwibG9jYXRpb24iOnsibGF0IjoiNTkuOTE1MzU1MDAwMDAwMDEiLCJzdGF0ZSI6Ik9zbG8iLCJjb3VudHJ5IjoiTm9yd2F5IiwibG5nIjoiMTAuNzQzMjIwMyIsIm9uY2xpY2tfYWN0aW9uIjoibWFya2VyIiwicmVkaXJlY3RfcGVybWFsaW5rIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL3NjaGlic3RlZC1wZW9wbGUtcGxhbmV0LyIsInpvb20iOjIsImV4dHJhX2ZpZWxkcyI6eyJwb3N0X2V4Y2VycHQiOiJTaW5jZSBhIHNoYWtlLXVwIGF0IHRoZSB0b3AsIEhlYWQgb2YgU3VzdGFpbmFiaWxpdHksIEJyaXR0IE5pbHNlbiwgaXMgbWFraW5nIHN1cmUgdGhlIGNvbXBhbnkgaXMgbGVhZGluZyBvbiBkaXZlcnNpdHkgYW5kIHRoZSBlbnZpcm9ubWVudC4iLCJwb3N0X2NvbnRlbnQiOiJbdmNfcm93XVt2Y19jb2x1bW4gd2lkdGg9XCIxLzRcIl1bdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS8yXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48aDE+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlNjaGlic3RlZDogYWZ0ZXIgdHdvIGNlbnR1cmllcyBvZiBpbm5vdmF0aW9uIC0gcGVvcGxlIGFuZCBwbGFuZXQgYXJlIG5vdyB0aGUgbGVhZCBzdG9yeTwvc3Bhbj48L2gxPlxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+QXMgYSBmaW5hbmNlIHBlcnNvbiBieSBiYWNrZ3JvdW5kLCBCcml0dCBOaWxzZW4gbWF5IG5vdCBiZSBjb25zaWRlcmVkIHlvdXIgYXZlcmFnZSBlY293YXJyaW9yLCBvciBpbmRlZWQsIHlvdXIgdHlwaWNhbCBpbm5vdmF0b3IuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkJ1dCBpdCBpcyBwcmVjaXNlbHkgaGVyIHVuZGVyc3RhbmRpbmcgb2YgdGhlIG51bWJlcnMgdGhhdCBoYXMgaGVscGVkIE5vcndlZ2lhbiBtZWRpYSBnaWFudCA8L3NwYW4+PGEgaHJlZj1cImh0dHBzOi8vc2NoaWJzdGVkLmNvbS9cIj48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+U2NoaWJzdGVkPC9zcGFuPjwvYT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+IHB1dCBlbnZpcm9ubWVudGFsIHN1c3RhaW5hYmlsaXR5IGF0IHRoZSBjZW50cmUgb2YgdGhlIG9yZ2FuaXNhdGlvbi48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjWW91IGRvbid0IGhhdmUgYSBzZXBhcmF0ZSBzdHJhdGVneSBmb3Igc3VzdGFpbmFiaWxpdHksIGl0IG5lZWRzIHRvIGJlIGFuY2hvcmVkIGluLFx1MjAxZCBzaGUgZXhwbGFpbnMsIGFsdGhvdWdoIG5vIGRvdWJ0IHNpbWlsYXIgb3JnYW5pc2F0aW9ucyBoYXZlblx1MjAxOXQgZ290IHRoYXQgZmFyIHlldC48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+U2NoaWJzdGVkIGhhcyBhbG1vc3QgMjAwIHllYXJzIG9mIHdvcmsgdW5kZXIgaXRzIGJlbHQgLSBhbmQgYWZ0ZXIgYmVjb21pbmcgYSBwdWJsaWMgbGltaXRlZCBjb21wYW55IGluIHRoZSAxOTgwcywgdGhlbiBnZXR0aW5nIGxpc3RlZCBvbiB0aGUgc3RvY2sgZXhjaGFuZ2UgaW4gMTk5MiAtIGl0cyByZXB1dGF0aW9uIGhhcyBncm93biBvdXRzaWRlIG9mIGl0cyBuYXRpdmUgY291bnRyeS48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+QSBkZWNhZGUgaW50byBidXlpbmcgbmV3IG1lZGlhIGNvbXBhbmllcyBhbmQgY3JlYXRpbmcgaXRzIG93biwgZXZlbiB3aGlsZSB0aGUgRG90Y29tIEJ1YmJsZSBleHBhbmRlZCBhbmQgc3Vic2VxdWVudGx5IGJ1cnN0LCBpbiAyMDA3LCBIYXJ2YXJkIEJ1c2luZXNzIFNjaG9vbCBwcm9mZXNzb3IgQmhhcmF0IEFuYW5kIDwvc3Bhbj48YSBocmVmPVwiaHR0cHM6Ly93d3cubnl0aW1lcy5jb20vMjAwNy8wMi8xOC9idXNpbmVzcy93b3JsZGJ1c2luZXNzLzE4aWh0LXBhcGVycy40NjMzNTMxLmh0bWxcIj48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+dG9sZCB0aGUgPC9zcGFuPjxpPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5OZXcgWW9yayBUaW1lczwvc3Bhbj48L2k+PC9hPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj4gdGhpcyBjb21wYW55IHdhcyBcdTIwMWNzb21ldGhpbmcgcXVpdGUgc3BlY2lhbFx1MjAxZC48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+SW4gMjAwMSwgZm9yIGV4YW1wbGUsIGFmdGVyIDE2MCB5ZWFycyBkZWxpdmVyaW5nIG5ld3NwYXBlcnMsIFNjaGlic3RlZCBsYXVuY2hlZCBpdHMgRGlzdHJpYnV0aW9uIElubm92YXRpb24gY29tcGFueS4gSXQgaGFzLCA8L3NwYW4+PGEgaHJlZj1cImh0dHBzOi8vc2NoaWJzdGVkLmNvbS8yMDIwLzAzLzIzL21pbmltaXppbmctdGhlLWVudmlyb25tZW50YWwtaW1wYWN0L1wiPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5tb3N0IHJlY2VudGx5PC9zcGFuPjwvYT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+LCBiZWVuIHVzaW5nIEFJIGFuZCBtYWNoaW5lLWxlYXJuaW5nIHRvIGxlYXJuIGV2ZW4gbW9yZSBhYm91dCBnZXR0aW5nIG5ld3MgdG8geW91ciBkb29yIC0gbm90IGxlYXN0LCBob3cgdG8gZG8gaXQgYmV0dGVyIHdoaWxlIHByb3RlY3RpbmcgdGhlIHBsYW5ldC48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+U2NoaWJzdGVkXHUyMDE5cyBjb3JlIG5ld3MgbWVkaWEgYnVzaW5lc3Mgbm93IGV4dGVuc2l2ZWx5IGNvdmVycyBib3RoIE5vcndheSBhbmQgU3dlZGVuIC0gbmluZSBuZXdzIGJyYW5kcyBhbG9uZyB3aXRoIHRoZWlyIGFzc29jaWF0ZWQgbXVsdGltZWRpYSBvZmZlcmluZ3MgLSBzdHlsZWQgYXMgU2NoaWJzdGVkIE5vcndheSBhbmQgU2NoaWJzdGVkIFN3ZWRlbiByZXNwZWN0aXZlbHkuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkFuZCB0aGUgY29tcGFueSBoYXMgYmVlbiBzdWNjZXNzZnVsLCBjb21wYXJlZCB0byBtYW55IGludGVybmF0aW9uYWwgY291bnRlcnBhcnRzLCBhdCBjb252ZXJ0aW5nIHBlb3BsZSBpbnRvIG9ubGluZSBzdWJzY3JpYmVycy5cdTAwYTA8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjSXQgbG9va2VkIHJlYWxseSBkYXJrIGF0IG9uZSBwb2ludCxcdTIwMWQgTmlsc2VuIGFkbWl0cywgXHUyMDFjYnV0IHRoYXQgaGFzIGJlZW4gYSBodWdlIHN1Y2Nlc3MuIFdlIGhhdmUgYSBsb3Qgb2Ygb25saW5lIHN1YnNjcmliZXJzIGFuZCBpdCdzIGluY3JlYXNpbmcuXHUyMDFkIFNoZSBwdXRzIHNvbWUgb2YgdGhpcyBkb3duIHRvIGEgcmVsYXRpdmVseSBzdHJvbmcgbGV2ZWwgb2YgdHJ1c3QgaW4gbmV3cyBtZWRpYSBpbiB0aGUgTm9yZGljIGNvdW50cmllcy48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjT2YgY291cnNlLCB3ZSdyZSBzdGlsbCByZWxpYW50IG9uIHRoZSBhZHZlcnRpc2luZyBwYXJ0LiBCdXQgd2UgYXJlIHRyeWluZyB0byB0dXJuIGFyb3VuZCB0aGUgYnVzaW5lc3Mgc28gdGhhdCB0aGUgb25saW5lIG5ld3NwYXBlciB3aWxsIGJlIGEgc3RhbmRhbG9uZSwgZmluYW5jaWFsbHkgc2FmZSBidXNpbmVzcy4gU28gdGhhdCBpcyBpbXBvcnRhbnQuXHUyMDFkPC9zcGFuPlxyXG48aDM+SW52ZXN0bWVudHMgYW5kIG1hcmtldHBsYWNlczwvaDM+XHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5BbG9uZyB3aXRoIGl0cyA8L3NwYW4+PGEgaHJlZj1cImh0dHBzOi8vc2NoaWJzdGVkLmNvbS9hYm91dC93aG8td2UtYXJlL25leHQvXCI+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPk5leHQgcG9ydGZvbGlvPC9zcGFuPjwvYT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+IG9mIGludmVzdG1lbnRzIGluIGV2ZXJ5dGhpbmcgZnJvbSBjb25zdW1lciBmaW5hbmNlIHRvIGRhdGluZyBhcHBzLCBTY2hpYnN0ZWQgaGFzIGZvdW5kIGdyZWF0ZXIgc3VjY2VzcyB3aXRoIG1hcmtldHBsYWNlcyB0aGFuIHNvbWV0aGluZyBsaWtlIHRoZSBVS1x1MjAxOXMgPC9zcGFuPjxhIGhyZWY9XCJodHRwczovL3d3dy50aGVndWFyZGlhbi5jb20vbWVkaWEvMjAxNC9qYW4vMjIvZ3VhcmRpYW5tZWRpYWdyb3VwLXRoZWd1YXJkaWFuXCI+PGk+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkd1YXJkaWFuIDwvc3Bhbj48L2k+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPmRpZCBpbiBpdHMgZm9ybWVyIG93bmVyc2hpcDwvc3Bhbj48L2E+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPiBvZiB1c2VkIGNhciBleGNoYW5nZSBBdXRvdHJhZGVyLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj48aW1nIGNsYXNzPVwiYWxpZ25ub25lIHNpemUtZnVsbCB3cC1pbWFnZS0xNTQ3MVwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIwLzEyL1NjcmVlbi1TaG90LTIwMjAtMTItMDEtYXQtMTAuMTQuMjMucG5nXCIgYWx0PVwiVGhlIGxvZ29zIG9mIG5pbmUgU2NoaWJzdGVkIE5leHQgcG9ydGZvbGlvIGNvbXBhbmllc1wiIHdpZHRoPVwiMTIxNFwiIGhlaWdodD1cIjU3NFwiIC8+SXRzIGxhdGVzdCBiaWcgZGVhbCBoYXMgc2VlbiBtYXJrZXRwbGFjZSBncm91cCBBZGV2aW50YSBzcGluIG91dCBvZiBTY2hpYnN0ZWQsIHdoaWxlIDwvc3Bhbj48YSBocmVmPVwiaHR0cHM6Ly93d3cuYWRldmludGEuY29tL25ld3MvYWRldmludGEtc2lnbnMtYWdyZWVtZW50LXRvLWFjcXVpcmUtZWJheS1jbGFzc2lmaWVkcy1ncm91cC9cIj48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+YnV5aW5nIHVwIGVCYXlcdTIwMTlzIENsYXNzaWZpZWRzIGJ1c2luZXNzPC9zcGFuPjwvYT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+LCB3aGljaCBpbmNsdWRlcyB3ZWJzaXRlcyBsaWtlIEd1bXRyZWUsIGZvciBhcm91bmQgJDkgYmlsbGlvbi48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+V2hlbiB0aGUgdHJhbnNhY3Rpb24gaXMgZmluYWxpc2VkIGVhcmx5IG5leHQgeWVhciwgTmlsc2VuIHNheXMgQWRldmludGEgd2lsbCBiZSB0aGUgXHUyMDFjd29ybGQncyBsYXJnZXN0IG1hcmtldHBsYWNlXHUyMDFkLiBCdXQgdGhpcyBpc25cdTIwMTl0IHNpbXBseSBhIHN0b3J5IG9mIGRpdmVyc2lmaWNhdGlvbi48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjV2UgYXJlIHRyeWluZyB0byBoYXZlIHBlb3BsZSBtb3ZlIGludG8gY2lyY3VsYXIgY29uc3VtcHRpb24gaW5zdGVhZCBvZiBiZWluZyBpbiB0aGUgbGluZWFyIGVsZW1lbnQuIE90aGVyIHRoaW5ncyB3ZSBhcmUgdGhpbmtpbmcgYWJvdXQgYXJlLCBpcyBpdCBwb3NzaWJsZSB0byBraW5kIG9mIG1ha2UgYSBcdTIwMThjaXJjdWxhcml0eSBpbmRleFx1MjAxOSwgb3IgYSBraW5kIG9mIGEgc3RhbXAgb24gbmV3IHByb2R1Y3RzIG9yIHVzZWQgcHJvZHVjdHM/IFRoZW4gaWYgeW91IGhhdmUgdG8gYnV5IG5ldyB0aGluZ3MsIHlvdSBzaG91bGQgYXQgbGVhc3QgYnV5IHF1YWxpdHkgYW5kIGtub3cgXHUyMDE4dGhpcyBpcyB0aGUgdmFsdWUgdGhhdCB5b3UgY2FuIHNlbGwgaXQgZm9yIGFmdGVyIHRocmVlIG9yIGZvdXIgeWVhcnNcdTIwMTksIGZvciBleGFtcGxlLlx1MDBhMDwvc3Bhbj5cclxuXHJcblx1MjAxY09uIDEyIG9mIG91ciBtYXJrZXRwbGFjZXMgaW4gMjAxOSwgd2UgaGF2ZSBjYWxjdWxhdGVkIHRoZSBlZmZlY3Qgb24gdGhlIGVudmlyb25tZW50IGFuZCBhbHNvIG9uIGhvdyBtYW55IG1hdGVyaWFscyB3ZSBhcmUgc2F2aW5nIGJ5IHRyYWRpbmcgc2Vjb25kIGhhbmQsIGluc3RlYWQgb2YgaGF2aW5nIHRvIHByb2R1Y2UgYSBuZXcgb25lIGFuZCB0aHJvd2luZyBhd2F5IGEgdXNlZCBvbmUuXCJcclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNJZiB5b3Ugd2FudCB0byBidXksIGZvciBleGFtcGxlLCBhIHNvZmEgYW5kIHRoZW4gYSBtZXNzYWdlIGNvbWVzIHVwIFx1MjAxOE9LLCBpZiB5b3UgYnV5IHRoaXMgc29mYSwgeW91IHdpbGwgc2F2ZSB0aGlzIG11Y2ggQ08yIGVtaXNzaW9uIGFuZCB0aGlzIGVxdWFscyB0aGUgcHJvZHVjdGlvbiBvZiB0aHJlZSBzd2VhdGVyc1x1MjAxOSwgZm9yIGV4YW1wbGUuIEFuZCB0aGVuLCBvbiB0aGVpciBhY2NvdW50LCB0aGV5IHdpbGwgYWNjdW11bGF0ZSB0aGUgZWZmZWN0IGFuZCBob3cgbXVjaCB0aGV5IGhhdmUgc2F2ZWQuXHUyMDFkPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkFuZCB5ZXQgc3RpbGwsIE5pbHNlbiBleHBsYWlucywgdW50aWwgdGhyZWUgeWVhcnMgYWdvLCBzdXN0YWluYWJpbGl0eSB3YXMgXHUyMDFjc29tZXRoaW5nIG9uIHRoZSBzaWRlXHUyMDFkLiBcdTIwMWNJdCB3YXMgbW9yZSBsaWtlIGEgY29tcGxpYW5jZSBpc3N1ZSwgZm9sbG93aW5nIGxhd3Mgb3IgcmVndWxhdGlvbnMgYW5kIGNvbW1pdG1lbnRzLiBXZSBhcmUgYSBwYXJ0aWNpcGFudCBpbiB0aGUgVS5OLiBHbG9iYWwgQ29tcGFjdCBhbmQgYWxsIHRoYXQgc3R1ZmYuXHUyMDFkPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlRoYXQgd2FzIHVudGlsIHRoZSBhdXR1bW4gb2YgMjAxNywgd2hlbiB0d28gZGl2ZXJzaXR5IGNoYWxsZW5nZXMgc3RydWNrIGF0IG9uY2UuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY1dlIGhhZCBhIHJlb3JnYW5pc2F0aW9uIGluIFNjaGlic3RlZCwgd2hlcmUgYXQgdGhhdCBwb2ludCB3ZSBoYWQgcHV0IGludG8gdHdvIGJ1c2luZXNzIGFyZWFzLCBtZWRpYSBhbmQgbWFya2V0cGxhY2VzLiBBbmQgd2hlbiB0aGV5IHNldCB0aGVpciBtYW5hZ2VtZW50IHRlYW1zIGluIHRob3NlIHR3byBidXNpbmVzcyBhcmVhcywgYW5kIGFsc28gb24gdGhlIGdyb3VwIGxldmVsLCBpdCBoYWQgYSByZWFsbHkgbG93IGZlbWFsZSByYXRpby5cdTAwYTA8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjQW5kIGl0IHdhcyBhIHJlYWxseSBodWdlIHVwcm9hciwgYm90aCBpbnRlcm5hbGx5IGFuZCBleHRlcm5hbGx5LiBcdTIwMThIb3cgaXMgaXQgcG9zc2libGUgaW4gMjAxNyB0byBkbyBzdWNoIGEgc3R1cGlkIHRoaW5nPyBUaGlzIGlzIE5vcndheSFcdTIwMTkuXHUwMGEwPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY0FuZCwgYXQgdGhlIHNhbWUgdGltZSwgI01lVG9vIGhpdC4gQW5kIG9uIHRoaXMgc2lkZSwgb2YgY291cnNlLCB3ZSBzZXQgdGhlIGFnZW5kYSB3aXRoIG91ciBuZXdzcGFwZXJzLlx1MjAxZDwvc3Bhbj5cclxuPGgzPkluY2VudGl2aXNpbmcgZGl2ZXJzaXR5PC9oMz5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkluIERlY2VtYmVyIDIwMTcsIFNjaGlic3RlZCBzZXQgZ29hbHMgZm9yIGdlbmRlciBlcXVhbGl0eSAtIGEgcmF0aW8gb2YgNDA6NjAgZWl0aGVyIHdheSBvbiB0aGUgdGhyZWUgaGlnaGVzdCBtYW5hZ2VtZW50IGxldmVscyBieSB0aGUgZW5kIG9mIDIwMjAgLSA8L3NwYW4+PGk+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPnRoYXQgaGFkIGNvbnNlcXVlbmNlcy5cdTAwYTA8L3NwYW4+PC9pPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY0ZvciAyMDE4LCB0aGV5IHNldCBzaG9ydC10ZXJtIGdvYWxzIGFuZCB0aGF0IHdhcyBsaWtlIFx1MjAxOHdlIHNob3VsZCBoYXZlIGEgbmV3IHJlY3J1aXRtZW50IHBvbGljeVx1MjAxOSwgXHUyMDE4d2Ugc2hvdWxkIGhhdmUgYSBkaXZlcnNpdHkgYW5kIGluY2x1c2lvbiBwb2xpY3lcdTIwMTksIFx1MjAxOHdlIHNob3VsZCBoYXZlIHVuY29uc2Npb3VzIGJpYXMgdHJhaW5pbmcgZm9yIG1hbmFnZXJzIGFuZCByZWNydWl0ZXJzXHUyMDE5LCBcdTIwMTh3ZSBzaG91bGQgZXN0YWJsaXNoIHNvbWUgbmV0d29ya3MgZm9yIHdvbWVuXHUyMDE5Llx1MDBhMDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNBbmQgYWxzbyBpbiB0aGUgYnVzaWVzdCBidXNpbmVzcyBhcmVhcywgdGhpcyB3YXMgbW9yZSBkZXRhaWxlZCBsaWtlLCBcdTIwMTh0aGlzIGlzIGhvdyBtYW55IG1lbiBhbmQgd29tZW4gc2hvdWxkIGJlIG9uIHRoZSBsb25nIGxpc3QsIHRoZSBzaG9ydCBsaXN0IGFuZCBob3cgbWFueSBzaG91bGQgYmUgaGlyZWRcdTIwMTkgYW5kIHNvIG9uLiBSZWFsbHkgZGV0YWlsZWQuXHUwMGEwPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY0J1dCB0aGUgc21hcnQgdGhpbmcgd2FzIHRoYXQgdGhleSBwdXQgaXQgYXMgcGFydCBvZiB0aGUgdG9wIG1hbmFnZW1lbnQncyBpbmNlbnRpdmVzLlx1MjAxZDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5UaGUgcmVzdWx0IHdhcyB0aGF0LCBpbiBvbmUgeWVhciwgYWNyb3NzIGFsbCB0aGUgbWFuYWdlbWVudCBncm91cHMgaW4gdGhlaXIgY29tcGFuaWVzLCB0aGUgcGVyY2VudGFnZSBvZiB3b21lbiBsZWFkZXJzIHdlbnQgZnJvbSAzNCB0byAzOSBwZXIgY2VudC48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+VW50aWwgdGhpcyBwb2ludCwgZW52aXJvbm1lbnRhbCBzdXN0YWluYWJpbGl0eSBpc3N1ZXMgaGFkIGJlZW4gb3duZWQgYnkgdGhlIGdyb3VwXHUyMDE5cyBjb21tdW5pY2F0aW9ucyB0ZWFtLCBtZWFuaW5nIGl0IHdhcyBjb25zaWRlcmVkIHBhcnQgb2YgQ29ycG9yYXRlIFNvY2lhbCBSZXNwb25zaWJpbGl0eSwgXHUyMDFjdGhlIHNwZWVjaCB5b3UgaGF2ZSBhdCB0aGUgcGFydHlcdTIwMWQuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkJ1dCB3aGVuIE5pbHNlbiBiZWNhbWUgU2NoaWJzdGVkXHUyMDE5cyBHcm91cCBDb21wbGlhbmNlIE9mZmljZXIsIGFuZCBub3cgdWx0aW1hdGVseSB0aGUgSGVhZCBvZiBTdXN0YWluYWJpbGl0eSwgc2hlIGdvdCBzZXJpb3VzLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5IZXIgZmlyc3Qgc3RlcCB3YXMgdG8gbWFrZSBzdXJlIHRoZSBjb21wYW55XHUyMDE5cyBTdXN0YWluYWJpbGl0eSBSZXBvcnQgMjAxNyBtZXQgdGhlIEdsb2JhbCBSZXBvcnRpbmcgSW5pdGlhdGl2ZSdzIChHUkkpIHN0YW5kYXJkcyBvbiBtZWFzdXJlbWVudCBhbmQgdHJhbnNwYXJlbmN5LiBEb2luZyB0aGlzIG1lYW50IFNjaGlic3RlZFx1MjAxOXMgcHJvc3BlY3QgYXMgYW4gaW52ZXN0bWVudCBpbXByb3ZlZCwgYXMgdGhlIHBlcmNlcHRpb24gb2YgdGhlaXIgRW52aXJvbm1lbnRhbCwgU29jaWFsIGFuZCBHb3Zlcm5hbmNlIChFU0cpIHJpc2sgd2VudCBkb3duLlx1MDBhMDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNJIHdlbnQgdG8gdGhlIENFT1x1MjAyNiBhbmQgdGhhdCB3YXMgd2hlbiBjb21pbmcgZnJvbSBmaW5hbmNlIHdhcyB2ZXJ5IGhhbmR5IGJlY2F1c2UgSSBzcGVhayB0aGVpciBsYW5ndWFnZS4gSSBrbm93IHdlIGhhdmUgdG8gZWFybiBtb25leSwgYnV0IHdlIGhhdmUgdG8gZG8gaXQgaW4gYW5vdGhlciB3YXkuXHUwMGEwPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY0FuZCBzbyBJIGNvdWxkIHRlbGwgdGhlbSB0aGF0IFx1MjAxOGlmIHdlIGRvbid0IGhhdmUgc3VzdGFpbmFiaWxpdHkgaGlnaCB1cCBvbiBvdXIgYWdlbmRhLCB0aGUgaW52ZXN0b3JzIHdpbGwgbm90IGJlIGludGVyZXN0ZWQsIHBvdGVudGlhbCByZWNydWl0cyB3aWxsIG5vdCBiZSBpbnRlcmVzdGVkLCBhbmQgeW91IHdpbGwgbG9zZSB0aGUgYmVzdCBwZW9wbGUgeW91IGhhdmVcdTIwMTkuXHUyMDFkPC9zcGFuPlxyXG48aDM+U2VlaW5nIG9wcG9ydHVuaXRpZXM8L2gzPlxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjSSBjb3VsZCBraW5kIG9mIGdvIHRocm91Z2ggYW5kIFtzaG93IHRoYXRdIHRoZSByaXNrIG9mIG5vdCB0aGlua2luZyBhYm91dCB0aGlzIGlzIGh1Z2UuIExvb2sgYXQgaG93IEZhY2Vib29rIGlzIGhhdmluZyBzY2FuZGFscyB3aXRoIENhbWJyaWRnZS4gSXQncyBub3QgYWxsIGNvbXBhbmllcyB0aGF0IGNhbiB0YWtlIHRoYXQga2luZCBvZiBzY2FuZGFsLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNCdXQgbXkgbWFpbiBwb2ludCBpbiB0aG9zZSBjb252ZXJzYXRpb25zIHdhcyB0aGF0LCBcdTIwMTh5ZXMsIHdlIGhhdmUgdG8gY29tcGx5IHdpdGggbGF3cyBhbmQgcmVndWxhdGlvbnMgYW5kIGFsbCB0aGVzZSB0aGluZ3MuIEJ1dCB0aGF0IGdvZXMgd2l0aG91dCBzYXlpbmcgYmVjYXVzZSB0aGF0IGlzIGtpbmQgb2YgYSBcdTIwMThob3VzZWNsZWFuaW5nXHUyMDE5LiBXaGF0IHdlIG5lZWQgdG8gZG8gaXMgbG9vayBhdCBvcHBvcnR1bml0aWVzXHUyMDE5Llx1MDBhMDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNXZSBjYW4gYWN0dWFsbHkgZWFybiBtb25leSBhbmQgYXQgdGhlIHNhbWUgdGltZSBiZSBzdXN0YWluYWJsZSwgdGFrZSBnb29kIGNhcmUgb2YgdGhlIGVudmlyb25tZW50IGFuZCBzb2NpZXR5LiBCdXQgd2UganVzdCBoYXZlIHRvIG9wZW4gb3VyIGV5ZXMuXHUyMDFkPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkEgeWVhciBsYXRlciwgS3Jpc3RpbiBTa29nZW4gTHVuZCwgYW4gZXhwZXJpZW5jZWQgZXhlY3V0aXZlIHdobyBoYWQgaW4gdGhlIGVhcmx5IDIwMDBzIGxlZCB0aGUgU2NoaWJzdGVkLW93bmVkIEFmdGVucG9zdGVuLCBqb2luZWQgYXMgdGhlIGdyb3VwXHUyMDE5cyBmaXJzdCBmZW1hbGUgQ0VPLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNXaGVuIHNoZSBwcmVzZW50ZWQgdGhlIDwvc3Bhbj48YSBocmVmPVwiaHR0cHM6Ly9zY2hpYnN0ZWQuY29tL3N1c3RhaW5hYmlsaXR5L1wiPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5zdHJhdGVneSBmb3IgU2NoaWJzdGVkPC9zcGFuPjwvYT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+LCB3ZSBoYXZlIGEgcHlyYW1pZCwgYW5kIG9uIHRvcCB3ZSBoYXZlIFx1MjAxOHB1cnBvc2VcdTIwMTksIFx1MjAxOG1ha2Ugc3VyZSBpdCBtYXR0ZXJzXHUyMDE5LiBBbmQgSSB3YXMgc28gaGFwcHkgSSBjb3VsZCBqdXN0IGNyeSBiZWNhdXNlIDwvc3Bhbj48aT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+dGhhdCBpcyBzdXN0YWluYWJpbGl0eTwvc3Bhbj48L2k+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPi4gSXQncyBhbGwgYWJvdXQgbWFraW5nIHN1cmUgdGhhdCBzdXN0YWluYWJpbGl0eSBpcyBpbiB0aGUgY29yZSBvZiBvdXIgYnVzaW5lc3MuIEl0IGlzIGtpbmQgb2YgdGhlIFx1MjAxOGhpZ2hlciBza3lcdTIwMTkgeW91J3JlIGxvb2tpbmcgdG93YXJkcyBpbiBldmVyeXRoaW5nIHlvdSBkby5cdTIwMWQ8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+U28gaW4gYXV0dW1uIDIwMTksIFNjaGlic3RlZCB0b29rIGEgYmlnIGxvb2sgYXQgd2hhdCBtYXR0ZXJlZC48L3NwYW4+XHJcbjxoMz5XaGF0IG1hdHRlcnM/PC9oMz5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY1dlIGRpZCBhIGxvdCBvZiBiZW5jaG1hcmtpbmcgYWdhaW5zdCBvdXIgcGVlcnMgYW5kIG90aGVycywgYW5kIHdlIGxvb2tlZCBhdCB0aGUgcmlza3MgYW5kIG9wcG9ydHVuaXRpZXMuIEFuZCB3ZSBkaWQgYSBsb3Qgb2Ygc3Rha2Vob2xkZXIgZGlhbG9ndWVzLiBXZSBhc2tlZCBhIGxvdCBvZiBxdWVzdGlvbnMsIGdvdCBhIGxvdCBvZiBhbnN3ZXJzLCBhbmQgd2UgYXNrZWQgb3VyIHVzZXJzLCByZWFkZXJzLCBvdXIgYWR2ZXJ0aXNlcnMsIGludmVzdG9ycyBhbmQgdGhlIGJvYXJkLiBBbmQgd2UgaGFkIGxpa2UgMyw1MDAgYW5zd2VycyB0byB0aGlzLlx1MDBhMDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNBbmQgdGhlbiB3ZSBraW5kIG9mIGNvbGxlY3RlZCB0aGF0IGludG8gb25lIHJlc3VsdC4gQW5kIHRoZW4gSSBhc2tlZCB0aGUgZXhlY3V0aXZlIHRlYW0sIFx1MjAxOHdoYXQgZG8geW91IHRoaW5rIGFib3V0IHRoaXM/XHUyMDE5LiBJIGdvdCA5MCBtaW51dGVzIHdpdGggdGhlIGV4ZWN1dGl2ZSB0ZWFtLCB3aGljaCBJIHdhcyB2ZXJ5IHBsZWFzZWQgdG8gZ2V0LCBhbmQga2luZCBvZiBsYW5kZWQgb24gXHUyMDE4T0ssIHRoZXNlIGFyZSB0aGUgYXNwZWN0cyBvZiBzdXN0YWluYWJpbGl0eSB0aGF0IGlzIGltcG9ydGFudCBmb3IgU2NoaWJzdGVkXHUyMDE5Llx1MjAxZDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5Gb3IgdGhlIGNvbXBhbnlcdTIwMTlzIDwvc3Bhbj48YSBocmVmPVwiaHR0cHM6Ly9zdGF0aWMuc2NoaWJzdGVkLmNvbS93cC1jb250ZW50L3VwbG9hZHMvMjAyMC8wNC8wMzE1NTQ0Ny9TdXN0YWluYWJpbGl0eS1SZXBvcnQtMjAxOS5wZGZcIj48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+U3VzdGFpbmFiaWxpdHkgUmVwb3J0IDIwMTk8L3NwYW4+PC9hPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj4gdGhlbiwgdGhlIGdyb3VwIHVzZWQgYm90aCBHUkkgYW5kIHRoZSBTdXN0YWluYWJpbGl0eSBBY2NvdW50aW5nIFN0YW5kYXJkcyBCb2FyZCAoU0FTQikgcmVwb3J0aW5nIHN0YW5kYXJkcyB0byBkZXZpc2UgYSBoaWVyYXJjaHkgb2Ygc3VzdGFpbmFiaWxpdHkgaXNzdWVzIHRoYXQgd2VyZSBjb2xsYWJvcmF0aXZlbHkgZGVjaWRlZCB0byBiZSBtYXRlcmlhbCB0byB0aGUgYnVzaW5lc3MuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPjxpbWcgY2xhc3M9XCJhbGlnbm5vbmUgc2l6ZS1mdWxsIHdwLWltYWdlLTE1NDcyXCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMjAvMTIvU2NyZWVuLVNob3QtMjAyMC0xMi0wMS1hdC0xMC4wMS4wOS5wbmdcIiBhbHQ9XCJTY2hpYnN0ZWQncyBQeXJhbWlkIG9mIHN1c3RhaW5hYmlsaXR5IHByaW9yaXRpZXM6IGF0IHRoZSBib3R0b20sIGh5Z2llbmUgYXNwZWN0czsgaW4gdGhlIG1pZGRsZSwgZm9jdXMgYXNwZWN0czsgYXQgdGhlIHRvcCwgdW5pcXVlIGFzcGVjdHNcIiB3aWR0aD1cIjExMjdcIiBoZWlnaHQ9XCI0OTdcIiAvPlx1MjAxY0FuZCB0aGV5IGFyZSB0aGUgcmVzcG9uc2liaWxpdHkgb2YgdGhlIGV4ZWN1dGl2ZSB0ZWFtLFx1MjAxZCBOaWxzZW4gZXhwbGFpbnMuIFx1MjAxY1NvIEkgaGF2ZSBoYWQgbWVldGluZ3Mgd2l0aCBldmVyeSBvbmUgb2YgdGhlbSBhbmQgc2V0IGxvbmctdGVybSBhbWJpdGlvbnMsIHNob3J0LXRlcm0gdGFyZ2V0cywgYWN0aW9uIHBsYW5zLCBLUElzIHRvIG1lYXN1cmUgYW5kIHNvIG9uLlx1MDBhMDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNTbyBpdCdzIG5vdCBteSBnb2Fscy4gSXQncyBub3QgbXkgYW1iaXRpb25zIGZvciBzdXN0YWluYWJpbGl0eSwgaXQgaXMgb3V0IGluIHRoZSBidXNpbmVzcyBhcmVhcyBhbmQgaW4gdGhlIGdyb3VwIGZ1bmN0aW9ucy5cdTIwMWQ8L3NwYW4+XHJcbjxoMz5UYWNrbGluZyB0aGUgc3VwcGx5IGNoYWluPC9oMz5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkF0IHRoZSBib3R0b20sIHNvLWNhbGxlZCBcdTIwMThoeWdpZW5lIGlzc3Vlc1x1MjAxOSBhcmUgdGhpbmdzIGxpa2Ugc3VwcGx5LWNoYWluIG1hbmFnZW1lbnQuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY1NvIG5vdyB3ZSBoYXZlIGEgc3VwcGxpZXIgY29kZSBvZiBjb25kdWN0LCB3aGljaCBpcyBhbHNvIHJlZmxlY3Rpbmcgb3VyIG93biA8L3NwYW4+PGEgaHJlZj1cImh0dHBzOi8vc2NoaWJzdGVkLmNvbS9hYm91dC0yL1wiPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5Db2RlIG9mIENvbmR1Y3Q8L3NwYW4+PC9hPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj4sXHUyMDFkIE5pbHNlbiBzYXlzLiBcdTIwMWNBbmQgaXQncywgb2YgY291cnNlLCBpbiBhbGlnbm1lbnQgd2l0aCBodW1hbiByaWdodHNcdTIwMjYgYW5kIGFsbCB0aG9zZSBpbnRlcm5hdGlvbmFsIHN0YW5kYXJkcy5cdTAwYTA8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjQW5kIHRoZSB0aGlua2luZyBpcyBub3cgdGhhdCwgd2hlbmV2ZXIgd2Ugc2lnbiBhIGNvbnRyYWN0IHdpdGggYSBuZXcgc3VwcGxpZXIgb3Igd2UgcmVuZXcgYSBjb250cmFjdCwgdGhpcyB3aWxsIGJlIHBhcnQgb2YgdGhlIGFncmVlbWVudHMuIFdlIGFyZSBtYXBwaW5nIHRoZSByaXNrIGZvciB0aG9zZSBjb21wYW5pZXMsIHdoZXJlIGFyZSB0aGUgaGlnaGVzdCByaXNrcywgYW5kIHRoYXQgY291bGQgYmUgY291bnRyeS1yZWxhdGVkIGFzIHdlbGwuIEFuZCB3aGljaCBjb21wYW5pZXMgc2hvdWxkIHdlIGdvIGZvciBmaXJzdC48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+VGhlIGNvbXBhbnkgaGFzIHNvZnR3YXJlIHRoYXQgaWRlbnRpZmllcyBoaWdoLXJpc2sgYXJlYXMsIGZsYWdzIHRoZW0gd2l0aCBzdXBwbGllcnMgc28gdGhleSBrbm93IHdoYXQgbmVlZHMgdG8gY2hhbmdlLCBhbmQgdGhleSBoZWxwIHRoZW0gY2hhbmdlIHRoZWlyIHByYWN0aWNlcyAtIG9yIHRoZXkgc3RvcCB1c2luZyB0aGVtLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5PbmUgbWFya2V0cGxhY2UgcHJlc2VudGluZyBhIHN1c3RhaW5hYmlsaXR5IHJpc2sgaXMgaXRzIGh1Z2Ugb25lIGluIHVzZWQgY2Fycy4gXHUyMDFjSXQgd2lsbCBhdCBzb21lIHBvaW50IGRpc2FwcGVhcixcdTIwMWQgc2hlIGFja25vd2xlZGdlcy4gXHUyMDFjU28gd2VcdTIwMTlyZSBzZWVpbmcgdGhvc2UgYnVzaW5lc3Mgb3Bwb3J0dW5pdGllcyBtb3ZpbmcgaW50byByZW50YWwsIGxlYXNpbmcsIHNoYXJpbmcsIHRoYXQga2luZHMgb2YgYnVzaW5lc3Mgd2l0aCBjYXJzLCBmb3IgZXhhbXBsZS48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+QW4gYXJlYSB0aGF0IGhhcyBiZWVuIGNoYWxsZW5naW5nIGZvciB0aGUgZW50aXJlIGluZHVzdHJ5LCBkdWUgdG8gaXRzIGNvbXBsZXhpdHksIGlzIG1lYXN1cmluZyB0aGUgZW52aXJvbm1lbnRhbCBpbXBhY3Qgb2YgZGlnaXRhbCBuZXR3b3JrcywgYnV0IFNjaGlic3RlZCBpcyBjdXJyZW50bHkgdGVzdGluZyBhIG5ldyB0b29sIHRoYXQgaGFzIGp1c3QgYmVlbiBjcmVhdGVkIGJ5IHRoZSA8L3NwYW4+PGEgaHJlZj1cImh0dHA6Ly93d3cuYnJpc3RvbC5hYy51ay9uZXdzLzIwMjAvamFudWFyeS9kaW1wYWN0Lmh0bWxcIj48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+RElNUEFDVDwvc3Bhbj48L2E+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPiBjb2xsYWJvcmF0aW9uIG91dCBvZiB0aGUgVW5pdmVyc2l0eSBvZiBCcmlzdG9sIGluIHRoZSBVSy48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjSG93IGFyZSB5b3UgY2FsY3VsYXRpbmcgdGhlIGVsZWN0cmljaXR5IHlvdSBhcmUgdXNpbmcgZnJvbSB3aGVuIHdlIGhhdmUgbWFkZSBhIHByb2R1Y3QgYW5kIHVudGlsIGl0J3MgcmVhZCBvciBzdHJlYW1lZCBvciBoZWFyZCBvciB3aGF0ZXZlciB0aGUgdXNlcnMgYXJlIGRvaW5nPyBOb2JvZHkgaGFzIGJlZW4gYWJsZSB0byBkbyB0aGlzIGJlY2F1c2UgaXQncyB0b28gY29tcGxpY2F0ZWQsIE5pbHNlbiBhZGRzLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5BIHJlbWFpbmluZyBwcm9ibGVtIGZvciBhbnkgbmV3cyBtZWRpYSBvcmdhbmlzYXRpb24gaXMgdGhlIHJlbGlhbmNlIG9mIGRpZ2l0YWwgbWVkaWEgdGVjaG5vbG9naWVzIHRoYXQgYXBwZWFyIHRvIGJlIGluaGVyZW50bHkgYmFkIGZvciB0aGUgcGxhbmV0LiBXZSBhcmUgbHVja3kgaW4gdGhlIE5vcmRpY3MgdGhvdWdoLCB3aXRoIG91ciBoaWdoIHNoYXJlIG9mIHJlbmV3YWJsZSBlbmVyZ3kuPC9zcGFuPlxyXG48aDM+UmVzcG9uc2libGUgbWFya2V0aW5nPC9oMz5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPldoaWxlIHN0aWxsIHJlbGlhbnQgb24gYWR2ZXJ0aXNpbmcsIFx1MjAxOHJlc3BvbnNpYmxlIG1hcmtldGluZ1x1MjAxOSBhbHNvIG1ha2VzIGl0IG9udG8gdGhlIGNvbXBhbnlcdTIwMTlzIHN1c3RhaW5hYmlsaXR5IHB5cmFtaWQgYXMgYW4gXHUyMDE4Zm9jdXMgYXNwZWN0XHUyMDE5Ljwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNXZSBoYWQgRXh0aW5jdGlvbiBSZWJlbGxpb24gcmFsbHlpbmcgb3V0c2lkZSBvdXIgb2ZmaWNlcyBiZWNhdXNlIHdlIGhhdmUgYSB2ZXJ5IHBvcHVsYXIgcG9kY2FzdCBpbiBvbmUgb2Ygb3VyIG5ld3NwYXBlcnMgLSBhbmQgb25lIG9mIHRoZSBsYXJnZXN0IG9pbCBjb21wYW5pZXMgaW4gTm9yd2F5IGhhZCB0aHJlZSBwb2RjYXN0cyB3aXRoIHRoYXQgbmV3c3BhcGVyIGJyYW5kLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNXZSBtYXkgaGF2ZSBhZHZlcnRpc2luZyBmb3IgQmxhY2sgRnJpZGF5LCBidXQgb24gdGhlIG90aGVyIHNpZGUsIHdlIGFyZSB0cnlpbmcgdG8gbWFrZSBwZW9wbGUgcmVkdWNlIHRoZWlyIGNvbnN1bXB0aW9uIGFuZCBnbyBpbnRvIG1vcmUgY2lyY3VsYXIgY29uc3VtcHRpb24uIFdlIGhhdmUgYWR2ZXJ0aXNpbmcgZm9yIGdhbWJsaW5nLiBBbmQgb24gdGhlIG90aGVyIHNpZGUsIHdlIGFyZSB3cml0aW5nIGFib3V0IGdhbWJsZSBhZGRpY3RzLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNTbyB3aGF0IHdlIHdhbnQgdG8gZG8gaXMgbWFwIGFsbCB0aG9zZSBkaWxlbW1hcyBhbmQgc2VlIGlmIHdlIG5lZWQgYSBwb2xpY3kgdG8gcmVndWxhdGUgd2hhdCBraW5kIG9mIGFkdmVydGlzaW5nIGNhbiB3ZSBhY3R1YWxseSBkby5cdTIwMWQ8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+U2hlIHBvaW50cyB0byB0aGUgPC9zcGFuPjxhIGhyZWY9XCJodHRwczovL3d3dy50aGVndWFyZGlhbi5jb20vbWVkaWEvMjAyMC9qYW4vMjkvZ3VhcmRpYW4tdG8tYmFuLWFkdmVydGlzaW5nLWZyb20tZm9zc2lsLWZ1ZWwtZmlybXMtY2xpbWF0ZS1jcmlzaXNcIj48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+VUsgR3VhcmRpYW5cdTIwMTlzIGRlY2lzaW9uIHRvIHJlamVjdCBmb3NzaWwgZnVlbCBhZHZlcnRpc2luZzwvc3Bhbj48L2E+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPiBpbiBpdHMgYmlkIGZvciBzdXN0YWluYWJpbGl0eSAtIGJ1dCBhbHNvIGFja25vd2xlZGdlcyBOb3J3YXlcdTIwMTlzIGFsbW9zdCBzeW5vbnltb3VzIGxpbmsgd2l0aCBmb3NzaWwgZnVlbHMuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY0kgd2FudCB0aGUgcGVvcGxlIGludm9sdmVkIGJlaW5nIGFibGUgdG8gc2F5LCBcdTIwMThPSywgeWVzLCB3ZSBkbyB0aGlzIDwvc3Bhbj48aT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+YmVjYXVzZTwvc3Bhbj48L2k+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxOSwgXHUyMDE4d2UgY2FuIGhhdmUgYWR2ZXJ0aXNpbmcgZm9yIHRoaXMgPC9zcGFuPjxpPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5iZWNhdXNlPC9zcGFuPjwvaT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDE5LiBXZSBoYXZlIHRvIGRlY2lkZSwgYW5kIHRoaXMgaXMgbm90IGVhc3kgYmVjYXVzZSB3ZSBoYXZlIGRpZmZlcmVudCB0eXBlcyBvZiBjb21wYW5pZXMgYW5kIHNvIG9uLCBidXQgd2UgbmVlZCB0byBoYXZlIGEgY29uc2Npb3VzIHJlbGF0aW9uc2hpcCBhY3Jvc3MgdGhlIGdyb3VwIHRvIHdoYXQgd2UncmUgYWN0dWFsbHkgZG9pbmcuIEFuZCB0aGF0IGlzIGl0IGluIGl0c2VsZiBpcyBzb21ldGhpbmcgbmV3Llx1MjAxZDwvc3Bhbj5cclxuPGgzPk1lYXN1cmluZyAnYnJhaW5wcmludCc8L2gzPlxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+QnV0LCBwZXJoYXBzIG1vc3QgaW50ZXJlc3RpbmcsIGlzIHRoZSBjb21wYW55XHUyMDE5cyBjb25zaWRlcmF0aW9uIG9mIGl0cyBcdTIwMWNicmFpbnByaW50XHUyMDFkLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNPbiB0aGUgdG9wLCB5b3UgaGF2ZSB3aGF0IHdlIGNhbGwgXHUyMDE4dW5pcXVlIGFzcGVjdHNcdTIwMTkuIEFuZCB0aGlzIGlzIHJlYWxseSBvdXIgYnVzaW5lc3MuIFRoaXMgaXMgb3VyIGpvdXJuYWxpc20uIFRoaXMgaXMgb3VyIG1hcmtldHBsYWNlcyBhbmQgdGhpcyBpcyBvdXIgTmV4dCBjb21wYW5pZXMuIEFuZCB0aGUgdGhpbmcgd2l0aCB0aGUgcHlyYW1pZCBpcyB0aGF0IHRoZSBoaWdoZXIgdXAgaW4gdGhlIHB5cmFtaWQgeW91IGdldCwgdGhlIGhpZ2hlciBpcyB0aGUgcG9zaXRpdmUgaW1wYWN0IG9uIHNvY2lldHkgYW5kIHRoZSBlbnZpcm9ubWVudC48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjV2UgYXJlIHRoZSBraW5kIG9mIGNvbXBhbnkgdGhhdCBoYXMgbXVjaCBtb3JlIFx1MjAxOGJyYWlucHJpbnRcdTIwMTkgdGhhbiB3ZSBoYXZlIGZvb3RwcmludC4gV2UgYWZmZWN0IHBlb3BsZSdzIG1pbmRzLiBXZSBhcmUgbW92aW5nIHRoZW0gYW5kIHdlIGFyZSBnaXZpbmcgdGhlbSB0aGUgcG93ZXIgdG8gdGFrZSBiZXR0ZXIgZGVjaXNpb25zLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNXaGF0IHdlIGRvIHdpdGggb3VyIG93biBlbWlzc2lvbnMsIGlzIG9mIGNvdXJzZSBpbXBvcnRhbnQsIGJ1dCB3ZSBhcmUgcmVhbGx5IGdvb2QgYXQgbWVhc3VyaW5nIGVudmlyb25tZW50YWwgZWZmZWN0cy4gT3VyIG93biBlbWlzc2lvbnMgYXJlIHF1aXRlIHNtYWxsIGNvbXBhcmVkIHRvIHdoYXQgd2UgYXJlIGFibGUgdG8gYWNjb21wbGlzaCBieSBvZmZlcmluZyBtYXJrZXRwbGFjZXMgZm9yIHNlY29uZC1oYW5kIHRyYWRlLlx1MDBhMDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNXZSBoYXZlIDwvc3Bhbj48YSBocmVmPVwiaHR0cHM6Ly9zY2hpYnN0ZWQuY29tL3NlY29uZGhhbmRlZmZlY3QvXCI+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPmRvbmUgdGhhdCBjYWxjdWxhdGlvbiB0byBzZWUgaG93IG11Y2ggaXMgdGhhdCBlZmZlY3Qgb24gc29jaWV0eTwvc3Bhbj48L2E+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPiBhbmQgZm9yIDIwMTksIHRoZSBjYWxjdWxhdGlvbiBzaG93cyB0aGF0IGZvciAxMiBvZiBvdXIgbWFya2V0cGxhY2VzLCB3ZSBoYXZlIHBvdGVudGlhbGx5IHNhdmVkIENPMmUgZW1pc3Npb24gZXF1YWwgdG8gNTAgcGVyY2VudCBvZiB0aGUgdG90YWwgZW1pc3Npb25zIGluIE5vcndheSBmb3Igb25lIHllYXIuIEh1Z2UgZmlndXJlcy48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+PGltZyBjbGFzcz1cImFsaWdubm9uZSBzaXplLWZ1bGwgd3AtaW1hZ2UtMTU0NzNcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAyMC8xMi9TY3JlZW4tU2hvdC0yMDIwLTEyLTAyLWF0LTExLjA3LjM3LnBuZ1wiIGFsdD1cIkluZm9ncmFwaGljIHNob3dpbmcgU2NoaWJzdGVkJ3MgZW1pc3Npb25zIHNhdmluZ3MgZnJvbSBpdHMgbWFya2V0cGxhY2VzIGluIDIwMTkgLSBlcXVhbCB0byA1MCUgb2YgTm9yd2F5J3MgZW50aXJlIGVtaXNzaW9ucyB0aGF0IHllYXJcIiB3aWR0aD1cIjU5NFwiIGhlaWdodD1cIjM1MVwiIC8+PC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY1dlIGFyZSBub3QgZ29vZCBhdCBtZWFzdXJpbmcgb3VyIGVmZmVjdCBvbiBzb2NpZXR5LiBMaWtlIFx1MjAxOGhvdyBkbyB5b3UgbWVhc3VyZSB5b3VyIGpvdXJuYWxpc20/XHUyMDE5LiBcdTIwMThIb3cgZG8geW91IG1lYXN1cmUgdGhlIGNvbnRlbnQgaW1wYWN0P1x1MjAxOS4gU28gdGhhdCBpcyBhIHByb2plY3Qgd2UncmUgc3RhcnRpbmcgbm93Llx1MjAxZDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5CdXQsIG9mIGNvdXJzZSwgaGVyZSB0aGVyZSBhcmUgY29uc2lkZXJhdGlvbnMgYWJvdXQgb2JqZWN0aXZpdHkuXHUwMGEwPC9zcGFuPlxyXG5cclxuXHUyMDFjSXQgaXMgYSBkaXNjdXNzaW9uLiBcdTIwMThTaG91bGQgd2UgYmUganVzdCBtaXJyb3JzLCBvciBzaG91bGQgd2UgYmUgbW92ZXJzIHRvIGtpbmQgb2YgbnVkZ2Ugc29jaWV0eSB0b3dhcmRzIHNvbWV0aGluZyB0aGF0IHdlIHRoaW5rIGlzIGZvciB0aGUgYmVzdD9cdTIwMTkgQW5kIGl0XHUyMDE5cyBhIGRpZmZpY3VsdCBkaXNjdXNzaW9uIGJlY2F1c2UgdGhlIG5ld3NwYXBlcnMgYXJlIHN1cHBvc2VkIHRvIGJlIG9iamVjdGl2ZS5cclxuXHJcblx1MjAxY09mIGNvdXJzZSwgdGhpcyBpcyBwYXJ0IG9mIHdoYXQgd2UgYXJlIGRvaW5nLCBiZWNhdXNlLCBlc3BlY2lhbGx5IG9uIG91ciBtYXJrZXRwbGFjZXMsIHdoZXJlIHdlIGZhY2lsaXRhdGUgc2Vjb25kLWhhbmQgdHJhZGUsIHdlIGFyZSBudWRnaW5nIHBlb3BsZSBhIGxvdC4gXHUyMDE4SG93IGNhbiB5b3UgdGFrZSBjYXJlIG9mIHlvdXIgdGhpbmdzP1x1MjAxOSBXZSBoYXZlIHdyaXR0ZW4gYm9va3MgYWJvdXQgaXRcdTIwMjYgU28gd2UgaGF2ZSBcdTIwMThoZXJlIGFyZSBzb21lIHRpcHMgb24gaG93IHlvdSBjYW4gdGFrZSBjYXJlIG9mIHlvdXIgdGhpbmdzXHUyMDE5Llx1MjAxZFxyXG48aDM+TWFraW5nIGNoYW5nZW1ha2VyczwvaDM+XHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5HaXZlbiB0aGF0IE5pbHNlbiBoYXMgb25seSBqdXN0IG1hZGUgaGVyIGZpcnN0IHRlYW0gaGlyZSwgdGhpcyBhbGwgc291bmRzIGxpa2UgYSBsb3Qgb2Ygd29yaywgc28gc2hlXHUyMDE5cyBjcmVhdGVkIGEgU3VzdGFpbmFiaWxpdHkgQ2hhbmdlbWFrZXIgUHJvZ3JhbW1lIGF0IFNjaGlic3RlZCB3aGVyZSAxNSBwZW9wbGUgZnJvbSBhY3Jvc3MgdGhlIGdyb3VwLCBnZW5kZXJzLCBidXNpbmVzcyBmdW5jdGlvbiBhbmQgY291bnRyeSwgZ2V0IHRvIHVzZSAxMCBwZXIgY2VudCBvZiB0aGVpciB0aW1lIHRvIHdvcmsgb24gc3VzdGFpbmFiaWxpdHkuXHUwMGEwPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY0FuZCB0aGVuIHdlJ3JlIGxvb2tpbmcgaW50byBsaWtlIFx1MjAxOHdoYXQgYXJlIHRoZSBidXNpbmVzcyBvcHBvcnR1bml0aWVzIHdpdGhpbiB0aGUgY2lyY3VsYXIgZWNvbm9teVx1MjAxOSwgXHUyMDE4d2hhdCBhcmUgbmV3IGJ1c2luZXNzIG9wcG9ydHVuaXRpZXMgd2l0aGluIG5ld3MgbWVkaWE/XHUyMDE5Llx1MjAxZDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5TaGUgZG9lcyBub3QgYmVsaWV2ZSB0aGF0IGZpbmFuY2lhbCBhbmQgZW52aXJvbm1lbnRhbCBzdXN0YWluYWJpbGl0eSBhcmUgbXV0dWFsbHkgZXhjbHVzaXZlLCBcdTIwMWNidXQgeW91IG5lZWQgdG8gZ3JvdyBpbiBhIGRpZmZlcmVudCB3YXkgYW5kIHlvdSBuZWVkIHRvIG1lYXN1cmUgZGlmZmVyZW50bHlcdTIwMWQuXHUwMGEwPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY0l0J3Mgbm90IGVub3VnaCB0byBqdXN0IGxvb2sgaW50byB0aGUgZmluYW5jaWFsIHRlcm1zIGJlY2F1c2UgdGhlbiB5b3UgYXJlIG5vdCBwcmljaW5nIHRoZSBleHRlcm5hbGl0aWVzLFx1MjAxZCBzaGUgYWdyZWVzLiBcdTIwMWNZb3UgaGF2ZSB0byBwdXQgdGhlIHByaWNlcyBvZiBldmVyeXRoaW5nLCBvZiBzb2NpZXR5IGFuZCBlbnZpcm9ubWVudCwgaW50byB0aGUgY2FsY3VsYXRpb24uIEFuZCB0aGVuIHlvdSBjYW4gc3RhcnQgbG9va2luZyBhdCwgXHUyMDE4T0ssIHdoYXQgYXJlIHRoZSB0ZXJtcyBvZiBncm93dGgsIHRoZW4/XHUyMDE5Llx1MjAxZDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5EZXNwaXRlIGFsbCBvZiBTY2hpYnN0ZWRcdTIwMTlzIHN1Y2Nlc3MsIHNoZSBzYXlzIGl0IHdpbGwgdGFrZSBldmVuIHRoZW0gYSBsb3Qgb2YgdGltZSB0byBiZWNvbWUgbWF0dXJlIGluIHRoZXNlIGFyZWFzLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5UaGUgY29tcGFueVx1MjAxOXMgZGl2ZXJzaXR5IHdvcmsgc28gZmFyLCBpbmNsdWRpbmcgPC9zcGFuPjxhIGhyZWY9XCJodHRwczovL3NjaGlic3RlZC5jb20vMjAyMC8wMy8yNC9yZWFjaGluZy1kaXZlcnNpdHktaW4tdGhlLW5ld3MvXCI+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPnVzaW5nIEFJIHRvIHVuZGVyc3RhbmQ8L3NwYW4+PC9hPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj4gd2hldGhlciB1c2luZyBpbWFnZXMgdGhhdCBhcmUgbW9yZSByZXByZXNlbnRhdGl2ZSBvZiByZWFkZXJzIGNhbiBpbmNyZWFzZSBzdWJzY3JpcHRpb25zIChpdCBjYW4hKSwgaGFzIGJlZW4gcXVpdGUgbGltaXRlZCB0byBnZW5kZXIuXHUwMGEwPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPk5pbHNlbiBkb2VzIHB1dCBhIGxhcmdlIGFtb3VudCBvZiB0aGlzIHByb2dyZXNzIGRvd24gdG8gS3Jpc3RpbiBTa29nZW4gTHVuZFx1MjAxOXMgbGVhZGVyc2hpcCwgYnV0IGluc3BpcmluZyBsZWFkZXJzIGFyZW5cdTIwMTl0IHF1aXRlIGVub3VnaC48L3NwYW4+XHJcblxyXG5OZXh0LCBOaWxzZW4gc2F5cywgXHUyMDFjaXRcdTIwMTlzIGFib3V0IGhvdyBjYW4geW91IGdpdmUgeW91ciBsZWFkZXJzLCB5b3VyIG1hbmFnZXJzIHRoZSByaWdodCB0b29sIGluIG9yZGVyIHRvIHVubG9jayB0aGUgcG90ZW50aWFsIHRoYXQgd2UgaGF2ZSBpbiBhIGRpdmVyc2Ugd29ya2ZvcmNlLCB0byBjcmVhdGUgaW5ub3ZhdGlvbiwgdG8gY3JlYXRlIHZhbHVlP1x1MjAxZC5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNCZWNhdXNlIHRoaXMgaXMgYWxsIGFib3V0IG1pbmQgc2hpZnRpbmcgYW5kIHlvdSBoYXZlIHRvIHN0YXJ0IHRoaW5raW5nIGRpZmZlcmVudGx5LiBZb3UgY2FuJ3QgbG9vayBhdCBpdCBhcyBhIGNvbXBsaWFuY2UsIHRoYXQgeW91IGp1c3QgXHUyMDE4ZG8gbm8gaGFybVx1MjAxOSBhbmQgZ2l2ZSBzb21lIG1vbmV5IHRvIGNoYXJpdHkgYW5kIHlvdSdyZSBvZmYgdGhlIGhvb2suIFRoaXMgaXMgYWxsIGFib3V0IHRha2luZyBpdCBpbnRvIHlvdXIgY29yZS48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjSSBsb3ZlIHRoZSBleHByZXNzaW9uLCBJIGhlYXJkIGl0IHRoZSBvdGhlciBkYXksIHRoYXQgXHUyMDE4ZGl2ZXJzaXR5IGlzIGhhdmluZyBhIHNlYXQgYXQgdGhlIHRhYmxlIGFuZCBpbmNsdXNpb24gaXMgaGF2aW5nIGEgdm9pY2UgYW5kIGJlbG9uZ2luZyBpcyBiZWluZyBoZWFyZFx1MjAxOSwgc28gaWYgeW91IGNhbiBnZXQgaW50byB0aGF0IHR5cGUgb2YgY3VsdHVyZSBhbmQgbWFrZSBzdXJlIHRoYXQgcGVvcGxlIGFyZSBoZWFyZCwgdGhlbiB5b3Ugd2lsbCBoYXZlIHRoZSByaWdodCB0aGlua2luZy5cdTIwMWQ8L3NwYW4+XHJcblxyXG5DT05UQUNUXHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+PGltZyBjbGFzcz1cImFsaWdubm9uZSBzaXplLWZ1bGwgd3AtaW1hZ2UtMTU0NzRcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAyMC8xMi9Ccml0dC1OaWxzZW4tLmpwZWdcIiBhbHQ9XCJCcml0dCBOaWxzZW5cIiB3aWR0aD1cIjEyMFwiIGhlaWdodD1cIjEyMFwiIC8+PC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkJyaXR0IE5pbHNlbiwgSGVhZCBvZiBTdXN0YWluYWJpbGl0eSBhdCBTY2hpYnN0ZWQ8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+VHdpdHRlcjogPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vbmlsc2VuYnJpdHRcIj5ATmlsc2VuQnJpdHQ8L2E+IDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL1NjaGlic3RlZEdyb3VwXCI+QFNjaGlic3RlZEdyb3VwPC9hPjwvc3Bhbj5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzRcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd10iLCJwb3N0X3RpdGxlIjoiU2NoaWJzdGVkOiBhZnRlciB0d28gY2VudHVyaWVzIG9mIGlubm92YXRpb24gJiM4MjExOyBwZW9wbGUgYW5kIHBsYW5ldCBhcmUgbm93IHRoZSBsZWFkIHN0b3J5IiwicG9zdF9saW5rIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL3NjaGlic3RlZC1wZW9wbGUtcGxhbmV0LyIsInBvc3RfZmVhdHVyZWRfaW1hZ2UiOiI8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIkxvZ28gb2YgdGhlIFNlY29uZCBIYW5kIEVmZmVjdCBtYXJrZXRwbGFjZXMgd29yayBvbiBhbiBpbWFnZSBvZiBhIGZvcmVzdCB3aXRoIGhpbGxzIGFuZCB0aGUgc2t5IGluIHRoZSBiYWNrZ3JvdW5kXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIxNzNcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAyMC8xMi9TY3JlZW4tU2hvdC0yMDIwLTEyLTA4LWF0LTIyLjE3LjExLTMwMHgxNzMucG5nXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+IiwicG9zdF9jYXRlZ29yaWVzIjoiR3JlZW4gbWVkaWEiLCJwb3N0X3RhZ3MiOiJBZGV2aW50YSwgQnJpdHQgTmlsc2VuLCBOb3J3YXksIFNjaGlic3RlZCwgU3dlZGVuIiwiJV9lZGl0X2xvY2slIjoiMTYzNzgzOTQ5Mjo5MzMiLCIlX2VkaXRfbGFzdCUiOiI5MzMiLCIlc2xpZGVfdGVtcGxhdGUlIjoiZGVmYXVsdCIsIiVfd3BiX3ZjX2pzX3N0YXR1cyUiOiJ0cnVlIiwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6IkFrZXJzZ2F0YSA1NSwgMDE4MCBPc2xvLCBOb3J3YXkiLCIlX3dwZ21wX2xvY2F0aW9uX2NpdHklIjoiIiwiJV93cGdtcF9sb2NhdGlvbl9zdGF0ZSUiOiJPc2xvIiwiJV93cGdtcF9sb2NhdGlvbl9jb3VudHJ5JSI6Ik5vcndheSIsIiVfd3BnbXBfbWV0YWJveF9sYXRpdHVkZSUiOiI1OS45MTUzNTUwMDAwMDAwMSIsIiVfd3BnbXBfbWV0YWJveF9sb25naXR1ZGUlIjoiMTAuNzQzMjIwMyIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiMlwiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6Ik47IiwiJV93cGdtcF9tZXRhYm94X3RheG9tb21pZXNfdGVybXMlIjoiTjsiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6Ik47IiwiJV9rbGVvX3RyYW5zcGFyZW50X21lbnVfY29sb3IlIjoid2hpdGUiLCIlX2tsZW9fdGl0bGVfY29sb3IlIjoiIyIsIiVfa2xlb190aXRsZV9iZyUiOiIsIHJlcGVhdCwgaW5oZXJpdCwgc2Nyb2xsLCBsZWZ0IHRvcCIsIiVfa2xlb190aXRsZV9iZ19jb2xvciUiOiIjIiwiJV95b2FzdF93cHNlb19jb250ZW50X3Njb3JlJSI6IjMwIiwiJV9rbGVvX3RpdGxlX2NoZWNrYm94JSI6IjEiLCIlX3RodW1ibmFpbF9pZCUiOiIxNTQ3NiIsIiVfeW9hc3Rfd3BzZW9fZm9jdXNrdyUiOiJTY2hpYnN0ZWQiLCIlX3lvYXN0X3dwc2VvX3RpdGxlJSI6IlNjaGlic3RlZDogYWZ0ZXIgdHdvIGNlbnR1cmllcyBvZiBpbm5vdmF0aW9uIC0gcGVvcGxlIGFuZCBwbGFuZXQgYXJlIG5leHQiLCIlX3lvYXN0X3dwc2VvX21ldGFkZXNjJSI6IlNpbmNlIGEgc2hha2UtdXAgYXQgdGhlIHRvcCwgSGVhZCBvZiBTdXN0YWluYWJpbGl0eSwgQnJpdHQgTmlsc2VuLCBpcyBtYWtpbmcgc3VyZSB0aGUgY29tcGFueSBpcyBsZWFkaW5nIG9uIGRpdmVyc2l0eSBhbmQgdGhlIGVudmlyb25tZW50LiIsIiVfeW9hc3Rfd3BzZW9fbGlua2RleCUiOiI2OCIsIiVfeW9hc3Rfd3BzZW9fcHJpbWFyeV9jYXRlZ29yeSUiOiIzNDciLCIlc2JnX3NlbGVjdGVkX3NpZGViYXIlIjoiMCIsIiVzYmdfc2VsZWN0ZWRfc2lkZWJhcl9yZXBsYWNlbWVudCUiOiIwIiwiJV95b2FzdF93cHNlb19lc3RpbWF0ZWQtcmVhZGluZy10aW1lLW1pbnV0ZXMlIjoiIiwidGF4b25vbXk9Y2F0ZWdvcnkiOiJHcmVlbiBtZWRpYSIsInRheG9ub215PXBvc3RfdGFnIjoiQWRldmludGEsIEJyaXR0IE5pbHNlbiwgTm9yd2F5LCBTY2hpYnN0ZWQsIFN3ZWRlbiJ9LCJpY29uIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTgvMDIvbWFya2VyLTEucG5nIn0sImlkIjoxNTQ2NSwiaW5mb3dpbmRvd19kaXNhYmxlIjpmYWxzZX0seyJzb3VyY2UiOiJwb3N0IiwidGl0bGUiOiJMZW5mZXN0IEluc3RpdHV0ZTogd29ya2luZyB3aXRoIHRoZSBQaGlsbHkgSW5xdWlyZXIgYXMgYSAmIzgyMTY7dGVzdCBraXRjaGVuJiM4MjE3OyBmb3IgQ09WSUQgaW5ub3ZhdGlvbiBhbmQgbW9yZSIsImluZm93aW5kb3dfY29udGVudCI6IjxkaXYgY2xhc3M9XCJmYy1pdGVtLWJveCBmYy1pdGVtLW5vLXBhZGRpbmdcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiVGhpcyBpcyBhbiBpbWFnZSBvZiBhIGxpbmUgb2YgY2FycyBxdWV1ZWQgdXAgZm9yIHBlb3BsZSB0cnlpbmcgdG8gZ2V0IGEgY29yb25hdmlydXMgdGVzdCBpbiBQaGlsYWRlbHBoaWEgdGFrZW4gYnkgVGltIFRhaSBvZiB0aGUgUGhpbGFkZWxwaGlhIElucXVpcmVyXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMDJcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAyMC8xMC9Db3JvbmF2aXJ1cy1UZXN0aW5nLVRpbS1UYWktUGhpbGFkZWxwaGlhLUlucXVpcmVyLTMwMHgyMDIucG5nXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZ1wiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tcGFkZGluZy1jb250ZW50XzIwXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tbWV0YSBmYy1pdGVtLXNlY29uZGFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlIGZjLXRleHQtY2VudGVyXCI+TWVkaWEgbGFiczwvZGl2PlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLXRleHQtY2VudGVyXCI+TGVuZmVzdCBJbnN0aXR1dGU6IHdvcmtpbmcgd2l0aCB0aGUgUGhpbGx5IElucXVpcmVyIGFzIGEgJiM4MjE2O3Rlc3Qga2l0Y2hlbiYjODIxNzsgZm9yIENPVklEIGlubm92YXRpb24gYW5kIG1vcmU8L2Rpdj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1jb250ZW50IGZjLWl0ZW0tYm9keS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+XHJcbiAgICAgICAgICAgIFRoZSBMZW5mZXN0IEluc3RpdHV0ZSB3YXMgY3JlYXRlZCB0aHJvdWdoIGEgcGhpbGFudGhyb3BpYyBkb25hdGlvbiBmcm9tIG1lZGlhIHR5Y29vbiBHZXJyeSBMZW5mZXN0LCBnaWZ0ZWQgYWxvbmdzaWRlIGhpcyBvd25lcnNoaXAgb2YgdGhlIFBoaWxhZGVscGhpYSBJbnF1aXJlci4gRWRpdG9yaWFsIGFuZCBkaWdpdGFsIHN0cmF0ZWd5IG1hbmFnZXIgSm9zZXBoIExpY2h0ZXJtYW4gZXhwbGFpbnMgd2hhdCB0aGF0IGhhcyBtZWFudC5cclxuICAgICAgICA8L2Rpdj5cclxuPGEgaHJlZj1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9sZW5mZXN0LWluc3RpdHV0ZS1waGlsbHktaW5xdWlyZXIvXCI+UmVhZCBtb3JlPC9hPlxyXG4gICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuPC9kaXY+XHJcblxyXG4iLCJjb250ZW50IjoiVGhlIExlbmZlc3QgSW5zdGl0dXRlIHdhcyBjcmVhdGVkIHRocm91Z2ggYSBwaGlsYW50aHJvcGljIGRvbmF0aW9uIGZyb20gbWVkaWEgdHljb29uIEdlcnJ5IExlbmZlc3QsIGdpZnRlZCBhbG9uZ3NpZGUgaGlzIG93bmVyc2hpcCBvZiB0aGUgUGhpbGFkZWxwaGlhIElucXVpcmVyLiBFZGl0b3JpYWwgYW5kIGRpZ2l0YWwgc3RyYXRlZ3kgbWFuYWdlciBKb3NlcGggTGljaHRlcm1hbiBleHBsYWlucyB3aGF0IHRoYXQgaGFzIG1lYW50LiIsImFkZHJlc3MiOiI4MDEgTWFya2V0IFN0LCBQaGlsYWRlbHBoaWEsIFBBIDE5MTA3LCBVU0EiLCJsb2NhdGlvbiI6eyJsYXQiOiIzOS45NTE0NDU5IiwiY2l0eSI6IlBoaWxhZGVscGhpYSIsInN0YXRlIjoiUGVubnN5bHZhbmlhIiwiY291bnRyeSI6IlVuaXRlZCBTdGF0ZXMiLCJsbmciOiItNzUuMTU0MDc3Mzk5OTk5OTkiLCJvbmNsaWNrX2FjdGlvbiI6Im1hcmtlciIsInJlZGlyZWN0X3Blcm1hbGluayI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9sZW5mZXN0LWluc3RpdHV0ZS1waGlsbHktaW5xdWlyZXIvIiwiem9vbSI6MiwiZXh0cmFfZmllbGRzIjp7InBvc3RfZXhjZXJwdCI6IlRoZSBMZW5mZXN0IEluc3RpdHV0ZSB3YXMgY3JlYXRlZCB0aHJvdWdoIGEgcGhpbGFudGhyb3BpYyBkb25hdGlvbiBmcm9tIG1lZGlhIHR5Y29vbiBHZXJyeSBMZW5mZXN0LCBnaWZ0ZWQgYWxvbmdzaWRlIGhpcyBvd25lcnNoaXAgb2YgdGhlIFBoaWxhZGVscGhpYSBJbnF1aXJlci4gRWRpdG9yaWFsIGFuZCBkaWdpdGFsIHN0cmF0ZWd5IG1hbmFnZXIgSm9zZXBoIExpY2h0ZXJtYW4gZXhwbGFpbnMgd2hhdCB0aGF0IGhhcyBtZWFudC4iLCJwb3N0X2NvbnRlbnQiOiJbdmNfcm93XVt2Y19jb2x1bW4gd2lkdGg9XCIxLzRcIl1bdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS8yXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48aDE+TGVuZmVzdCBJbnN0aXR1dGU6IHdvcmtpbmcgd2l0aCB0aGUgUGhpbGx5IElucXVpcmVyIGFzIGEgXHUyMDE4dGVzdCBraXRjaGVuXHUyMDE5IGZvciBDT1ZJRCBpbm5vdmF0aW9uIGFuZCBtb3JlPC9oMT5cclxuPGk+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPihMZWFkIGltYWdlIGNyZWRpdDogVGltIFRhaSwgUGhpbGFkZWxwaGlhIElucXVpcmVyKTwvc3Bhbj48L2k+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+VGhlIFVTXHUyMDE5PC9zcGFuPjxhIGhyZWY9XCJodHRwczovL3d3dy5sZW5mZXN0aW5zdGl0dXRlLm9yZy9cIj4gPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkxlbmZlc3QgSW5zdGl0dXRlPC9zcGFuPjwvYT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+IG9ubHkgb3BlbmVkIGl0cyBkb29ycyBpbiAyMDE2IC0gYW5kIHlldCB0aGUgbmFtZSBvZiBpdHMgYmVuZWZhY3RvciwgR2VycnkgTGVuZmVzdCAtIG5vIGRvdWJ0IGVjaG9lcyBpbiBoaXMgbG9jYWwgUGVubnN5bHZhbmlhIGFuZCBiZXlvbmQuIEEgPC9zcGFuPjxhIGhyZWY9XCJodHRwczovL2VuLndpa2lwZWRpYS5vcmcvd2lraS9HZXJyeV9MZW5mZXN0XCI+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPldpa2lwZWRpYSBwYWdlPC9zcGFuPjwvYT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+IGFib3V0IGhpbSAob2YgY291cnNlLCBpdFx1MjAxOXMgbm90IGEgXHUyMDE4cGFwZXIgb2YgcmVjb3JkXHUyMDE5KSBza2lwcyBxdWlja2x5IGZyb20gc29tZSBvZiBoaXMgYmlnIGFjaGlldmVtZW50cyB0byB0aGUgbGF0ZXIgeWVhcnMgb2YgaGlzIGxpZmUsIGFmdGVyIGhlXHUyMDE5ZCBtYWRlIGFuZCBzdGFydGVkIHRvIGdpdmUgYXdheSBoaXMgZm9ydHVuZS5cdTAwYTA8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+QnV0IHRoZSBlYXJseSB5ZWFycyBvZiB0aGlzIG1lZGlhIHR5Y29vblx1MjAxOXMgbGlmZSBhcmU8L3NwYW4+PGEgaHJlZj1cImh0dHBzOi8vd3d3LnBoaWxhbnRocm9weXJvdW5kdGFibGUub3JnL2FsbWFuYWMvcGVvcGxlL2hhbGwtb2YtZmFtZS9kZXRhaWwvZ2VycnktbGVuZmVzdFwiPiA8c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+cGVyaGFwcyB3b3J0aCByZW1hcmtpbmcgb24gZXZlbiBtb3JlPC9zcGFuPjwvYT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+IC0gaGUgZXhwZXJpZW5jZWQgdHJhZ2VkeSBhbmQgdGhlbiBoYXJkc2hpcCwgYW5kIHRoZW4gaGUgdG9vayB0byBzZWEuIEFuZCBpdCB3YXMgb25seSBhZnRlciBoZSByZXRyYWluZWQgYXMgYSBsYXd5ZXIgdGhhdCBoZSBoYWQgYSBjaGFuY2UgbWVldGluZyB3aXRoIGFub3RoZXIgbWVkaWEgdHljb29uLCBXYWx0ZXIgQW5uZXJiZXJnLCB0aGF0IGxlZCB0byBoaW0gdGFraW5nIGEgYmV0IG9uIGNhYmxlIC0gd2hpY2ggcGFpZCBvZmYuXHUwMGEwPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkFuZCB0aGUgcmVzdCB3b3VsZCBiZSBoaXN0b3J5LCBidXQgaXQgbGl2ZXMgb24gaW4gdGhlPC9zcGFuPjxhIGhyZWY9XCJodHRwczovL3d3dy5waGlsYW50aHJvcHlyb3VuZHRhYmxlLm9yZy9hbG1hbmFjL3Blb3BsZS9oYWxsLW9mLWZhbWUvZGV0YWlsL2dlcnJ5LWxlbmZlc3RcIj4gPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPmh1Z2UgdmFyaWV0eSBvZiBwaGlsYW50aHJvcGljIHdvcmsgaGUgZGlkPC9zcGFuPjwvYT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+LCBub3QgbGVhc3QsIGxlYXZpbmcgbW9yZSB0aGFuICQyMCBtaWxsaW9uIHRvIHdoYXQgaXMgbm93IHRoZTwvc3Bhbj48YSBocmVmPVwiaHR0cHM6Ly93d3cubGVuZmVzdGluc3RpdHV0ZS5vcmcvXCI+IDxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5MZW5mZXN0IEluc3RpdHV0ZSBmb3IgSm91cm5hbGlzbTwvc3Bhbj48L2E+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPiwgZ2lmdGVkIGFsb25nc2lkZSB0aGUgb3duZXJzaGlwIG9mIHdoYXQgcmVtYWlucyB0aGUgPC9zcGFuPjxpPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5mb3ItcHJvZml0IFBoaWxhZGVscGhpYSBJbnF1aXJlci48L3NwYW4+PC9pPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlRoZTwvc3Bhbj48aT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+IElucXVpcmVyPC9zcGFuPjwvaT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+IHN0aWxsIHByaW50cyBzZXZlbiBkYXlzIGEgd2VlaywgYW5kIGFkZHMgZ3JhbnRzIGZyb20gdGhlIExlbmZlc3QgSW5zdGl0dXRlIHRvIGl0cyBkaWdpdGFsIHN1YnNjcmlwdGlvbiBvZmZlciBhbmQgYSBuZXdlciBkb25hdGlvbiBcdTIwMThhc2tcdTIwMTksIHdoaWNoIGFsbCBtYWtlIGl0IGxvb2sgbGlrZSBhIHdlbGwtcm91bmRlZCBsb2NhbCBwYXBlciBmaWdodGluZyBmaXQgZm9yIGl0cyBmdXR1cmUuPC9zcGFuPlxyXG48aDM+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlVuaXF1ZSBidXNpbmVzcyBzdHJ1Y3R1cmU8L3NwYW4+PC9oMz5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPldoYXQgbWF5IGJlIHVuaXF1ZSBhYm91dCB0aGUgTGVuZmVzdCBJbnN0aXR1dGUncyByZWxhdGlvbnNoaXAgd2l0aCB0aGUgPC9zcGFuPjxpPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5JbnF1aXJlcjwvc3Bhbj48L2k+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPiBpcyBpdHMgYnVzaW5lc3Mgc3RydWN0dXJlIC0gYSBub3QtZm9yLXByb2ZpdCBzdXBwb3J0aW5nIGEgZm9yLXByb2ZpdCAtIHZlcnN1cyB0aG9zZSBuZXdzcm9vbXMgdGhhdCBhcmUgbm93IGV4Y2x1c2l2ZWx5IG5vdC1mb3ItcHJvZml0LCBvciB0aG9zZSBwdWJsaXNoZXJzIHRoYXQgYXJlIG93bmVkIGJ5IGEgZm91bmRhdGlvbiwgYW5kIGFyZSB0aGVtc2VsdmVzIG5vdC1mb3ItcHJvZml0Ljwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5Kb3NlcGggTGljaHRlcm1hbiwgdGhlIExlbmZlc3QgSW5zdGl0dXRlJ3MgbWFuYWdlciBvZiBlZGl0b3JpYWwgYW5kIGRpZ2l0YWwgc3RyYXRlZ3ksIGtub3dzIGhpcyB3YXkgYXJvdW5kIHN1Y2ggam91cm5hbGlzbSBpbm5vdmF0aW9uLiBIZSBjdXJyZW50bHkgcHJvZHVjZXMgYSBuZXdzbGV0dGVyIG9uIHRoZSB0b3BpYyBmb3IgdGhlIG9yZ2FuaXNhdGlvbiw8L3NwYW4+PGEgaHJlZj1cImh0dHBzOi8vd3d3LmxlbmZlc3RpbnN0aXR1dGUub3JnL3NvbHV0aW9uLXNldC9cIj4gPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlNvbHV0aW9uIFNldDwvc3Bhbj48L2E+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPiwgYW5kIHByZXZpb3VzbHkgd29ya2VkIGF0IHRoZSBOaWVtYW4gSm91cm5hbGlzbSBMYWIgYXQgSGFydmFyZCBVbml2ZXJzaXR5Llx1MDBhMDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNXZSd2ZSB0YWxrZWQgaW4gdGhlIHBhc3QgYWJvdXQgdGhlPC9zcGFuPjxpPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj4gSW5xdWlyZXIgPC9zcGFuPjwvaT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+YXMgYSBcdTIwMTh0ZXN0IGtpdGNoZW5cdTIwMTksIGEgcGxhY2UgdG8gdGVzdCBuZXcgaWRlYXMgYW5kIGRldmVsb3AgbmV3IG1vZGVscyBmb3IgbG9jYWwgbmV3cyxcIiBMaWNodGVybWFuIGV4cGxhaW5zLiBcIkFuZCB0aGVuIHdlIGNhbiBob3BlZnVsbHkgZXhwb3J0IHRoZW0gYW5kIHNoYXJlIGxlc3NvbnMgd2l0aCBvdGhlciBsb2NhbCBuZXdzIG9yZ2FuaXNhdGlvbnMuIFNvIEkgdGhpbmsgdGhhdCdzIGRlZmluaXRlbHkgYW4gYXNzZXQgb2YgTGVuZmVzdCBhbmQgd2hhdCBtYWtlcyBpdCB1bmlxdWUuXCI8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjQW5kIHNvLCBmb3IgZXhhbXBsZSwgYXMgQ09WSUQgcmVhbGx5IHRvb2sgb2ZmIHRoZXkgdG9vayBkb3duIHRoZSBwYXl3YWxsIGZvciBtdWNoIG9mIHRoZSBDT1ZJRCBjb3ZlcmFnZSBhbmQgY3JlYXRlZCBhIGxhbmRpbmcgcGFnZSBhbmQgdGhlIHRvcCBvZiB0aGUgbGFuZGluZyBwYWdlIGhhZCBib3RoIFx1MjAxOHN1YnNjcmliZVx1MjAxOSBhbmQgXHUyMDE4ZG9uYXRlXHUyMDE5IGxpbmtzLCBzbyBmb2xrcyBjb3VsZCBzdXBwb3J0IHRoZSA8L3NwYW4+PGk+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPklucXVpcmVyPC9zcGFuPjwvaT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+IGluIGEgd2F5IHRoYXQgbWFkZSBzZW5zZSBmb3IgdGhlbS48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+SW4gd2hhdCBpcyBjbGVhcmx5IExlbmZlc3Qtc3R5bGUsIHRoZXNlIENPVklEIGlubm92YXRpb25zIGFyZTwvc3Bhbj48YSBocmVmPVwiaHR0cHM6Ly93d3cubGVuZmVzdGluc3RpdHV0ZS5vcmcvc29sdXRpb24tc2V0L2FsbC1mYWN0cy1uby1wYW5pYy1ob3ctdGhlLXBoaWxhZGVscGhpYS1pbnF1aXJlci1pcy1jb3ZlcmluZy1jb3JvbmF2aXJ1cy9cIj4gPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPmFsbCBjYXB0dXJlZCBoZXJlIGluIGZ1bGw8L3NwYW4+PC9hPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj4gZm9yIG90aGVycyB0byBsZWFybiBmcm9tIC0gYWxvbmcgd2l0aCBhIGRvbmF0aW9uIGRyaXZlLCB0aGV5IGxhdW5jaGVkIGEgbmV3c2xldHRlciwgZGlkIGEgcm91bmR0YWJsZSBmb3IgbG9jYWwgcGVvcGxlLCBhbmQgb25lIHJlcG9ydGVyIGhhZCBhIHN0cm9rZSBvZiBnZW5pdXMgd2hlbiBhdHRlbXB0aW5nIHNvY2lhbGx5IGRpc3RhbmNlZCBuZXdzLWdhdGhlcmluZy48L3NwYW4+XHJcblxyXG5bY2FwdGlvbiBpZD1cImF0dGFjaG1lbnRfMTU0MzZcIiBhbGlnbj1cImFsaWdubm9uZVwiIHdpZHRoPVwiNTQ5XCJdPGltZyBjbGFzcz1cInNpemUtZnVsbCB3cC1pbWFnZS0xNTQzNlwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIwLzEwL1NjcmVlbi1TaG90LTIwMjAtMTAtMTktYXQtMTAuMTEuNTgucG5nXCIgYWx0PVwiVGhpcyBpcyBhIHNjcmVlbiBncmFiIG9mIGEgdHdlZXQgYnkgQG1vbGx5ZWljaGVsLCBUZWFtIE5vdyBlZGl0b3IgQFBoaWxseUlucXVpcmVyLCBwcmFpc2luZyBvbmUgb2YgaGVyIHJlcG9ydGVycyBmb3IgaGl0dGluZyB0aGUgc3RyZWV0cyB3aXRoIGEgaHVnZSBoYW5kd3JpdHRlbiBzaWduIGFza2luZyBmb3IgcGVvcGxlJ3MgY29udHJpYnV0aW9uc1wiIHdpZHRoPVwiNTQ5XCIgaGVpZ2h0PVwiNTkyXCIgLz4gU29jaWFsbHkgZGlzdGFuY2VkIG5ld3MtZ2F0aGVyaW5nWy9jYXB0aW9uXVxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY0J1dCwgd2UncmUgc3RpbGwgYSByZWxhdGl2ZWx5IHlvdW5nIG9yZ2FuaXNhdGlvbiBhbmQgaXQncyBhIHVuaXF1ZSByZWxhdGlvbnNoaXAgYmVjYXVzZSB3ZSdyZSB0aGUgbm9uLWNvbnRyb2xsaW5nIG93bmVycyxcIiBoZSBhZGRzLiBcIlRoZXkgaGF2ZSBhIHNlcGFyYXRlIGJ1c2luZXNzIHN0YWZmLCBzZXBhcmF0ZSBsZWFkZXJzaGlwLCBhbnN3ZXIgdG8gdGhlaXIgb3duIGJvYXJkLiBUaGUgbmV3c3Jvb20gaXMgdG90YWxseSBpbmRlcGVuZGVudC4gQW5kIHNvIGl0J3MgYWJvdXQgZmlndXJpbmcgb3V0IHRoZSBiZXN0IHdheXMgdG8gY29sbGFib3JhdGUgdGhhdCB3b3JrcyBmb3IgZXZlcnlvbmUuIEFuZCBzbyBpdCdzIHN0aWxsIHZlcnkgbXVjaCBhIHdvcmsgaW4gcHJvZ3Jlc3MuXCI8L3NwYW4+XHJcbjxoMz48Yj5Mb2NhbCBMYWI8L2I+PC9oMz5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPldoYXQgYWRkcyB0byBpdHMgZGlzdGluY3RpdmVuZXNzIGlzIHRoZTwvc3Bhbj48YSBocmVmPVwiaHR0cHM6Ly93d3cubGVuZmVzdGluc3RpdHV0ZS5vcmcvbGVuZmVzdC1sb2NhbC1sYWIvXCI+IDxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5MZW5mZXN0IExvY2FsIExhYjwvc3Bhbj48L2E+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPiwgd2hpY2ggZGlyZWN0bHkgc3VwcG9ydHMgaW5ub3ZhdGlvbiBhdCB0aGUgbmV3c3BhcGVyLCBsZWQgYnkgU2FyYWggU2NobWFsYmFjaCwgYnV0IGFsc28gc2VuZHMgaXRzIHdvcmsgb3V0IGludG8gdGhlIHdvcmxkIHNvIG90aGVycyBjYW4gYmVuZWZpdCBmcm9tIHdoYXQgdGhleSBoYXZlIGxlYXJuZWQuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY1RoZXlcdTIwMTlyZSBhIHNvcnQgb2YgYSBzbWFsbCBwcm9kdWN0IFVYIHJlc2VhcmNoIHRlYW0gYW5kIHRoZSBpZGVhIGlzIHRvIHRyeSBhbmQgdGhpbmsgYWJvdXQgYW5kIGlkZW50aWZ5IHdheXMgdG8gZW5nYWdlIHdpdGggbG9jYWwgYXVkaWVuY2VzIGluIG5ldyBhbmQgaW5ub3ZhdGl2ZSB3YXlzLFx1MjAxZCBMaWNodGVybWFuIGV4cGxhaW5zLlx1MDBhMDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNJIHRoaW5rIG9uZSBvZiB0aGUgdGhpbmdzIGxvY2FsIG5ld3Mgb3JnYW5pc2F0aW9ucyBzdHJ1Z2dsZSB3aXRoIGlzIHRoZXkgZ2V0IHNvIGNhdWdodCB1cCBpbiB0aGUgZGF5LXRvLWRheSBjb3ZlcmFnZSwgaW4gdGhlIGRheS10by1kYXkgcHJvZHVjdCBkZXZlbG9wbWVudCBjeWNsZSwgdGhhdCBpdCdzIGRpZmZpY3VsdCB0byB0YWtlIGEgc3RlcCBiYWNrIGFuZCB0aGluayBhYm91dCB0cnlpbmcgbmV3IHRoaW5ncywgcnVubmluZyBleHBlcmltZW50cywgZG9pbmcgdGhpbmdzIGZvciB0aGUgc2FrZSBvZiBsZWFybmluZyBhbmQga25vd2xlZGdlIGFuZCBhZHZhbmNpbmcgdGhlIGZpZWxkLlx1MDBhMDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNTbyB0aGUgTGVuZmVzdCBMb2NhbCBMYWJcdTIwMTlzIGdvYWwgaXMgdG8gYmUgYWJsZSB0byBkbyB0aGF0IHR5cGUgb2YgcmVzZWFyY2ggYW5kIGRvIHRoYXQgdHlwZSBvZiBpbm5vdmF0aW9uIGF3YXkgZnJvbSB0aGUgZGF5LXRvLWRheSBjb25zdHJhaW50cyBvZiBydW5uaW5nIHRoZSBuZXdzIG9yZ2FuaXNhdGlvbi5cdTIwMWRcdTAwYTA8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+VGhlIExhYiB0ZWFtIGlzIGFibGUgdG8gd29yayBjbG9zZWx5IHdpdGggdGhlIDwvc3Bhbj48aT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+UGhpbGx5IElucXVpcmVyPC9zcGFuPjwvaT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+LCB3aXRoIGFjY2VzcyB0byB0aGVpciBuZXdzcm9vbSBhbmQgam91cm5hbGlzdHMuIExpY2h0ZXJtYW4gc2F5cyB0aGlzIG1lYW5zIHRoZXlcdTIwMTlyZSBvZnRlbiBcdTIwMWN0cnlpbmcgdG8gcHJlc2VudCB0aGUgam91cm5hbGlzbSBpbiBkaWZmZXJlbnQgd2F5cyBhbmQgcG90ZW50aWFsbHkgbWFrZSBpdCBtb3JlIGFjY2Vzc2libGUgb3IgdXRpbGlzZSBkaWZmZXJlbnQgZnVuY3Rpb25hbGl0aWVzXHUyMDFkLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5UaGVpciBsYXRlc3QgZXhwZXJpbWVudCBvbiBkb2luZyBsb2NhbCBuZXdzIGF0IHNjYWxlIGlzIHRoZSBmaXJzdCBvZiBhIG51bWJlciBvZiBoeXBlcmxvY2FsIG5ld3NsZXR0ZXJzLCB3aGljaCBpczwvc3Bhbj48YSBocmVmPVwiaHR0cHM6Ly93d3cubGVuZmVzdGluc3RpdHV0ZS5vcmcvbGVuZmVzdC1sb2NhbC1sYWIvdGhlLWxlbmZlc3QtbG9jYWwtbGFiLWFuZC10aGUtcGhpbGFkZWxwaGlhLWlucXVpcmVyLWxhdW5jaC10aGUtaG9vay1hLWh5cGVybG9jYWwtZW1haWwtbmV3c2xldHRlci1zZXJ2aW5nLWZpc2h0b3duL1wiPiA8c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+bGF1bmNoaW5nPC9zcGFuPjwvYT4gPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPnRvIGNvdmVyIGEgbmVpZ2hib3VyaG9vZCBpbiBQaGlsYWRlbHBoaWEgY2FsbGVkIEZpc2h0b3duLCBzdXBwb3J0ZWQgYnkgdGhlPC9zcGFuPjxhIGhyZWY9XCJodHRwczovL3d3dy5sZW5mZXN0aW5zdGl0dXRlLm9yZy9uZXdzLXRlY2hub2xvZ3ktaW5ub3ZhdGlvbi9sZW5mZXN0LWxvY2FsLWxhYi10aGUtcGhpbGFkZWxwaGlhLWlucXVpcmVyLXJlY2VpdmUtZ29vZ2xlLWduaS1pbm5vdmF0aW9uLWNoYWxsZW5nZS1zdXBwb3J0LXRvLWJ1aWxkLWF1dG9tYXRlZC1uZWlnaGJvcmhvb2QtbmV3c2xldHRlcnMvXCI+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPiBHb29nbGUgTmV3cyBJbml0aWF0aXZlPC9zcGFuPjwvYT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+Ljwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNUaGV5XHUyMDE5cmUgdHJ5aW5nIHRvIHNlZSBpZiB0aGVyZSBhcmUgd2F5cyB0byBjb3ZlciBuZWlnaGJvdXJob29kcyBpbiBtb3JlIGF1dG9tYXRlZCB3YXlzLFx1MjAxZCBMaWNodGVybWFuIGV4cGxhaW5zLiBcdTIwMWNBcyBcdTIwMThtZXRybyBuZXdzcm9vbXNcdTIwMTkgaGF2ZSBzaHJ1bmssIHRoZXkndmUgaGFkIHRvIHNvcnQgb2YgXHUyMDE4cmVnaW9uYWxpc2VcdTIwMTkgdGhlaXIgY292ZXJhZ2UgYW5kIGFyZSBub3QgYWJsZSB0byBwcm92aWRlIGFzIHRhcmdldGVkLCBvbi10aGUtZ3JvdW5kIHJlcG9ydGluZy5cdTAwYTA8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjQW5kIHNvIHRoZSBpZGVhIHdpdGggPC9zcGFuPjxpPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5UaGUgSG9vazwvc3Bhbj48L2k+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPiBpcyB0byBiZSBhYmxlIHRvIGNvbWJpbmUgb3JpZ2luYWwgcmVwb3J0aW5nIHdpdGggdGhlIDwvc3Bhbj48aT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+SW5xdWlyZXJcdTIwMTlzPC9zcGFuPjwvaT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+IGV4aXN0aW5nIHJlcG9ydGluZywgYW5kIHB1YmxpYyBkYXRhIHNvdXJjZXMsIGFuZCBjb21waWxlIGl0IGluIGEgd2F5IHRoYXQgaXMgdmFsdWFibGUgYW5kIGludGVyZXN0aW5nIGFuZCB1c2VyLWZyaWVuZGx5LCBhbmQgYWxzbyBwb3RlbnRpYWxseSBzdXN0YWluYWJsZS4gU28gdGhleSdyZSBhbHNvIHdvcmtpbmcgd2l0aCB0aGUgPC9zcGFuPjxpPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5JbnF1aXJlciA8L3NwYW4+PC9pPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj50byBzZWxsIGFkcyBpbiB0aGUgbmV3c2xldHRlciwgYmVjYXVzZSBpZiBtb3N0IG9mIHRoZSByZWFkZXJzIGFyZSBnb2luZyB0byBiZSBpbiB0aGUgbmVpZ2hib3VyaG9vZHMsIGlmIHlvdVx1MjAxOXJlIGEgbG9jYWwgYnVzaW5lc3MsIHRoYXQncyBhIGdvb2QgYXVkaWVuY2UgeW91IHdhbnQgdG8gcmVhY2guXHUyMDFkXHUwMGEwPC9zcGFuPlxyXG48aDM+PGI+Q29sbGFib3JhdGl2ZSwgZXhwZXJpbWVudGFsLCBvcGVuPC9iPjwvaDM+XHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5UaGUgVVggbGVhZCBvbiB0aGUgcHJvamVjdCwgRmF5ZSBUZW5nLCBwcm92aWRlcyBhPC9zcGFuPjxhIGhyZWY9XCJodHRwczovL3d3dy5sZW5mZXN0aW5zdGl0dXRlLm9yZy9sZW5mZXN0LWxvY2FsLWxhYi9wYXJ0LTEtZXhwbG9yZS1hLXN0ZXAtYnktc3RlcC1ndWlkZS10by11c2luZy11eC1yZXNlYXJjaC1mb3ItbG9jYWwtbmV3cy1wcm9kdWN0LWRldmVsb3BtZW50L1wiPiA8c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+cmVhbGx5IHRob3JvdWdoIGFuZCByZWZyZXNoaW5nbHkgdHJhbnNwYXJlbnQgYWNjb3VudDwvc3Bhbj48L2E+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPiBvZiB3aGF0IHlvdSBtaWdodCB3YW50IHRvIGRvIGJlZm9yZSB0cnlpbmcgdGhlIHNhbWUgdGhpbmcuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPk11Y2ggb2Ygd2hhdCB0aGUgTGVuZmVzdCBJbnN0aXR1dGUgZG9lcyBpcyBjb2xsYWJvcmF0aXZlLCBtdWNoIGlzIGV4cGVyaW1lbnRhbCBhbmQgbXVjaCBpcyBvcGVuLiBUaGUgTGFiPC9zcGFuPjxhIGhyZWY9XCJodHRwczovL3d3dy5sZW5mZXN0aW5zdGl0dXRlLm9yZy9sZW5mZXN0LWxvY2FsLWxhYi90aGUtbGVuZmVzdC1sYWItYW5kLXRoZS1icm93bi1pbnN0aXR1dGUtYXJlLXBhcnRuZXJpbmctb24tYS1wcm9qZWN0LXRvLW1hcC1sb2NhbC1uZXdzL1wiPiA8c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+YWxzbyB3b3JrZWQgd2l0aDwvc3Bhbj48L2E+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPiB0aGU8L3NwYW4+PGEgaHJlZj1cImh0dHBzOi8vYnJvd24uY29sdW1iaWEuZWR1L1wiPiA8c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+QnJvd24gSW5zdGl0dXRlIGZvciBNZWRpYSBJbm5vdmF0aW9uPC9zcGFuPjwvYT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+IHRvIHVzZSBhcnRpZmljaWFsIGludGVsbGlnZW5jZSB0byBtYXAgb3V0IHRoZSBraW5kcyBvZiBwbGFjZXMgdGhhdCBnZXQgY292ZXJlZCBpbiB0aGUgbmV3cyBQaGlsYWRlbHBoaWEgLSBhbmQgdGhlIGtpbmRzIG9mIHN0b3JpZXMgdGhhdCBnZXQgd3JpdHRlbi5cdTAwYTA8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+V2hlbiB0aGV5IHNldCBvdXQsIHRoZXkgYXNrZWQ6PC9zcGFuPlxyXG5cclxuW2NhcHRpb24gaWQ9XCJhdHRhY2htZW50XzE1NDM1XCIgYWxpZ249XCJhbGlnbm5vbmVcIiB3aWR0aD1cIjc5MlwiXTxpbWcgY2xhc3M9XCIgd3AtaW1hZ2UtMTU0MzVcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAyMC8xMC9TY3JlZW4tU2hvdC0yMDIwLTEwLTE2LWF0LTE2LjU0LjExLnBuZ1wiIGFsdD1cIlRoaXMgaXMgYSBzY3JlZW4gZ3JhYiBvZiBhIGxpc3Qgb2YgcXVlc3Rpb25zIGZyb20gdGhlIEJyb3duIGNvbGxhYm9yYXRpb24uIEl0IHJlYWRzOiBIb3cgZG9lcyBsb2NhbCBuZXdzIGNvdmVyYWdlIGxheSBvdXQgYWNyb3NzIGEgcmVnaW9uPyBJZiB0aGVyZSBhcmUgZ2FwcywgaG93IGNhbiB0aGV5IGJlIGZpbGxlZD8gU2hvdWxkIHRoZXkgYmU/IERvZXMgdGhlIHNlbnRpbWVudCwgbGVuZ3RoLCBvciBmcmVxdWVuY3kgb2YgbG9jYWwgbmV3cyBjb3ZlcmFnZSB2YXJ5IGJ5IGdlb2dyYXBoeT8gSWYgc28sIHdoYXQgbWlnaHQgdGhlIHVuZGVybHlpbmcgcmVhc29ucyBiZT8gQXJlIHRoZXJlIHRvb2xzIHRoYXQgY2FuIGJlIGJ1aWx0IHRvIHNvbHZlIGFueSBpc3N1ZXMgdGhhdCB0aGUgbWFwIG1heSB1bmNvdmVyPyBBcmUgdGhlcmUgd2F5cyB0byBwcm92aWRlIGF1dG9tYXRpYyBsb2NhbCBhbmdsZXMgdG8gbmF0aW9uYWwgc3Rvcmllcz8gV2hhdCB0eXBlcyBvZiBnZW9ncmFwaHkgZXhpc3QgaW4gbmV3cz8gUG9pbnRzLCBsaW5lcywgcG9seWdvbnM/IEhvdyBhcmUgc3RvcmllcyB3aXRoIHZhcmlvdXMgbG9jYXRpb25zIGV2YWx1YXRlZCBhbmQgcHJlc2VudGVkIG9uIHRoZSBtYXA/IENhbiB3ZSBwcmVkaWN0IHdoZXJlIG5ld3MgaXMgaGFwcGVuaW5nIGJ1dCBpdCBpc25cdTIwMTl0IGdldHRpbmcgY292ZXJlZD8gRG9lcyB0aGUgcXVhbnRpdHkgb2YgbG9jYWwgbmV3cyByZXBvcnRpbmcgc2NhbGUgaW4gcHJvcG9ydGlvbiB0byB0aGUgcG9wdWxhdGlvbiBvZiBhbiBhcmVhPyBJZiBub3QsIHdoeT8gV2hhdCB0cmVuZHMgd2l0aGluIG5ld3MgY292ZXJhZ2UgY2FuIG9ubHkgYmUgZXhwbGFpbmVkIGJ5IHBhaXJpbmcgdGltZSBhbmQgZ2VvZ3JhcGh5P1wiIHdpZHRoPVwiNzkyXCIgaGVpZ2h0PVwiMzk1XCIgLz4gV2hhdCBjYW4gYmUgbGVhcm5lZCBmcm9tIHNlZWluZyBhIHNldCBvZiBhcnRpY2xlIGxvY2F0aW9ucyBvbiBhIG1hcD9bL2NhcHRpb25dXHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjQW5kIHRoZXkndmUgYmVlbiBhYmxlIHRvIHVzZSB0aGUgdW5kZXJseWluZyB0ZWNobm9sb2d5IHRvIGNyZWF0ZSBhIENPVklEIGxhbmRpbmcgcGFnZSxcdTIwMWQgTGljaHRlcm1hbiBleHBsYWlucywgXHUyMDFjc28gaWYgeW91IHdhbnQgbG9jYWxpc2VkIENPVklEIGNvdmVyYWdlIGFib3V0IHlvdXIgY291bnR5LCBmb3IgZXhhbXBsZSwgeW91IGNhbiBnbyB0aGVyZSBhbmQgaXRcdTIwMTlsbCBwdWxsIGluIGF1dG9tYXRpY2FsbHkgYWxsIHRoZSBDT1ZJRCBzdG9yaWVzIHRoYXQgYXJlIHdyaXR0ZW4uIFNvIHRoYXQgbWVhbnMgbW9yZSBsb2NhbGlzZWQgY292ZXJhZ2Ugb2Ygc2Nob29scyBvciByZXN0YXVyYW50IG9wZW5pbmdzIGFuZCB0aGluZ3MgbGlrZSB0aGF0Llx1MjAxZFx1MDBhMDwvc3Bhbj5cclxuPGgzPjxiPkRpdmVyc2l0eSwgZXF1aXR5LCBpbmNsdXNpb248L2I+PC9oMz5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkluIGEgc2ltaWxhciB2ZWluLCB0aGUgTGFiIGhhcyBtYXBwZWQgcmVzdGF1cmFudCByZXZpZXdzIGFuZCBwdWJsaWMgYXJ0LCBhbmQgYWxzbyBjb21taXR0ZWQgdG8gbWFrZSBzdXJlIHRoaXMgaXMgYSB0b29sIHRoYXQgY2FuIGJlIHVzZWQgaW4gYW55IG5ld3Nyb29tLlx1MDBhMDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNCdXQgaXRcdTIwMTlzIGFsc28gdGhpbmtpbmcgYWJvdXQgZGl2ZXJzaXR5LCBlcXVpdHkgYW5kIGluY2x1c2lvbiBpc3N1ZXMsIGluIG1ha2luZyBzdXJlIHRoYXQgY292ZXJhZ2UgaXMgcmVwcmVzZW50YXRpdmUgb2YgY29tbXVuaXRpZXMsXHUyMDFkIExpY2h0ZXJtYW4gYWRkcy4gXHUyMDFjSSBkbyB0aGluayBqb3VybmFsaXN0cyBuZWVkIHRvIGRvIGEgYmV0dGVyIGpvYiBvZiBhbXBsaWZ5aW5nIHZvaWNlcyBhbmQgbWFraW5nIHN1cmUgdGhhdCB3ZSdyZSByZXByZXNlbnRhdGl2ZSBvZiBjb21tdW5pdGllcy4gSXRcdTIwMTlzIHRoZSByaWdodCBtb3JhbCB0aGluZyB0byBkbywgYnV0IGpvdXJuYWxpc3RzIHNvcnQgb2YgaGF2ZSB0aGlzIHNlbnNlIG9mIGR1dHkgdG8gdGhlIHB1YmxpYyBhbmQgd2UgbmVlZCB0byBtYWtlIHN1cmUgd2UncmUgYWN0dWFsbHkgc2VydmluZyB0aGUgcHVibGljLlx1MDBhMDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNBbmQgdGhlcmUncyBhIHJlYWwgYnVzaW5lc3MgaW1wZXJhdGl2ZSwgYWxzbywgaW4gdGhhdCBpZiB5b3UgYXJlIGdvaW5nIHRvIGJlY29tZSBtb3JlIGRlcGVuZGVudCBvbiByZWFkZXIgcmV2ZW51ZXMsIGZvciBleGFtcGxlLCB3aGV0aGVyIGl0J3MgdGhyb3VnaCBzdWJzY3JpcHRpb25zIG9yIGRvbmF0aW9ucyBvciBtZW1iZXJzaGlwLCB3aGF0ZXZlciBpdCBtYXkgYmUsIHBlb3BsZSBhcmUgZ29pbmcgdG8gd2FudCB0byBzZWUgdGhlbXNlbHZlcyBpbiB0aGUgY292ZXJhZ2UgaWYgdGhleSdyZSBnb2luZyB0byBjb250cmlidXRlIHRvIGl0IGFuZCBzdXBwb3J0IHRoZSBqb3VybmFsaXNtLiBTbyBJIHRoaW5rIHRoYXQncyBzb21ldGhpbmcgd29ydGgga2VlcGluZyBpbiBtaW5kIGFzIHdlbGwuXHUyMDFkPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkxpY2h0ZXJtYW4gaXMga2VlbiB0byB0YWxrIFx1MjAxOG1lbWJlcnNoaXAsIGRvbmF0aW9uLCBzdWJzY3JpcHRpb24sIG9yIG5vdD9cdTIwMTksIGFzIDwvc3Bhbj48YSBocmVmPVwiaHR0cHM6Ly93d3cubGVuZmVzdGluc3RpdHV0ZS5vcmcvbmV3cy10ZWNobm9sb2d5LWlubm92YXRpb24vdGhlLWxlbmZlc3QtaW5zdGl0dXRlLWlzLXBhcnRuZXJpbmctd2l0aC10aGUtbWVtYmVyc2hpcC1wdXp6bGUtcHJvamVjdC10by1jcmVhdGUtYS1ndWlkZS10by1tZW1iZXJzaGlwLW1vZGVscy1pbi1uZXdzL1wiPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5lYXJsaWVyIHRoaXMgeWVhcjwvc3Bhbj48L2E+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPiB0aGUgTGVuZmVzdCBJbnN0aXR1dGUgcGFydG5lcmVkIHdpdGg8L3NwYW4+PGEgaHJlZj1cImh0dHBzOi8vbWVtYmVyc2hpcHB1enpsZS5vcmcvXCI+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPk1lbWJlcnNoaXAgUHV6emxlIFByb2plY3Q8L3NwYW4+PC9hPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj4gKE1QUCkgdG8gY3JlYXRlIHRoZSBHb29nbGUgTmV3cyBJbml0aWF0aXZlLWJhY2tlZCBNZW1iZXJzaGlwIEd1aWRlLCBNUFAncyBsYXRlc3QgZWZmb3J0IHRvIHRyeSB0byBoZWxwIGFuc3dlciB0aGUgaW5kdXN0cnlcdTIwMTlzIHF1ZXN0aW9ucyBvbiB0aGlzIGluY3JlYXNpbmdseSBkeW5hbWljIHJldmVudWUgc3RyZWFtLlx1MDBhMDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5UaGUgdGVhbSwgaGVhZGVkIGJ5IEpheSBSb3NlbiBvZiBOZXcgWW9yayBVbml2ZXJzaXR5LCB3aXRoIHRoZSByZXNlYXJjaCBkaXJlY3RlZCBieSBFbGl6YWJldGggSGFuc2VuIGZyb20gdGhlIFRvdyBDZW50ZXIgZm9yIERpZ2l0YWwgSm91cm5hbGlzbSBhdCBDb2x1bWJpYSwgYW5kIG1hbmFnZWQgYnkgQXJpZWwgWmlydWxuaWNrLCB3aG9cdTIwMTlzIGFsc28gaGVhZCBvZiBNUFBcdTIwMTlzPC9zcGFuPjxhIGhyZWY9XCJodHRwOi8vd3d3Lm1lbWJlcnNoaXBwdXp6bGUub3JnL2Z1bmRcIj48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+IE1lbWJlcnNoaXAgaW4gTmV3cyBGdW5kPC9zcGFuPjwvYT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+LDwvc3Bhbj48YSBocmVmPVwiaHR0cHM6Ly93d3cubGVuZmVzdGluc3RpdHV0ZS5vcmcvbmV3cy10ZWNobm9sb2d5LWlubm92YXRpb24vdGhlLWxlbmZlc3QtaW5zdGl0dXRlLWlzLXBhcnRuZXJpbmctd2l0aC10aGUtbWVtYmVyc2hpcC1wdXp6bGUtcHJvamVjdC10by1jcmVhdGUtYS1ndWlkZS10by1tZW1iZXJzaGlwLW1vZGVscy1pbi1uZXdzL1wiPiA8c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+c2V0IG91dCB0byBhc2s8L3NwYW4+PC9hPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj4sIGFuZCB3aGVyZSBwb3NzaWJsZSwgYW5zd2VyOjwvc3Bhbj5cclxuXHJcbltjYXB0aW9uIGlkPVwiYXR0YWNobWVudF8xNTQzNFwiIGFsaWduPVwiYWxpZ25ub25lXCIgd2lkdGg9XCI4NDFcIl08aW1nIGNsYXNzPVwic2l6ZS1mdWxsIHdwLWltYWdlLTE1NDM0XCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMjAvMTAvU2NyZWVuLVNob3QtMjAyMC0xMC0xNi1hdC0xNi4wNC40MS5wbmdcIiBhbHQ9XCJUaGlzIGlzIGEgc2NyZWVuIGdyYWIgb2YgYSBzZXQgb2YgcXVlc3Rpb25zIGZyb20gdGhlIE1lbWJlcnNoaXAgUHV6emxlIHJlc2VhcmNoIHByb2plY3QsIHdoaWNoIHJlYWRzOiBXaGF0IGlzIHRoZSB2YWx1ZSBwcm9wb3NpdGlvbiBmb3IgY3JlYXRpbmcgYSBtZW1iZXJzaGlwIHByb2dyYW0gV2hhdCBtb3RpdmF0ZXMgcGVvcGxlIHRvIGJlY29tZSBtZW1iZXJzPyBXaGF0IGNvc3RzIHNob3VsZCBuZXdzIG9yZ2FuaXphdGlvbnMgcGxhbiBmb3IsIGFuZCB3aGF0IHJldmVudWUgY2FuIHRoZXkgZXhwZWN0PyBXaGF0IHRvb2xzIGFuZCB0ZWNobm9sb2d5IGRvIG5ld3Mgb3JnYW5pemF0aW9ucyBuZWVkIHRvIHJ1biBhIG1lbWJlcnNoaXAgcHJvZ3JhbT8gSG93IGRvZXMgYSBuZXdzIG9yZ2FuaXphdGlvbiBsYXVuY2ggYW5kIGdyb3cgYSBtZW1iZXJzaGlwIHByb2dyYW0/IFdoYXQgZG9lcyBpdCB0YWtlIHRvIGRldmVsb3AgYSBtZW1iZXItZm9jdXNlZCBjdWx0dXJlIGluIHRoZSBuZXdzcm9vbT8gSG93IGRvZXMgYSBuZXdzIG9yZ2FuaXphdGlvbiByZXRhaW4gbWVtYmVycyBhbmQgbWVhc3VyZSB0aGUgc3VjY2VzcyBvZiBpdHMgbWVtYmVyc2hpcCBwcm9ncmFtPyBXaGF0IGRvZXMgbWVtYmVyc2hpcCBtZWFuIGZvciBuZXdzIG9yZ2FuaXphdGlvbnMgdGhhdCBzZXJ2ZSBjb21tdW5pdGllcyB1bmRlcnNlcnZlZCBieSBtYWluc3RyZWFtIG1lZGlhIGluc3RpdHV0aW9ucz9cIiB3aWR0aD1cIjg0MVwiIGhlaWdodD1cIjM3NlwiIC8+IFdoYXQgZG8gd2UgbmVlZCB0byBrbm93IGJlZm9yZSB3ZSBkbyBtZW1iZXJzaGlwIHByb2dyYW1tZXM/Wy9jYXB0aW9uXVxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlRoZSByZXN1bHQgaXMgdGhlIGh1Z2VseSBjb21wcmVoZW5zaXZlPC9zcGFuPjxhIGhyZWY9XCJodHRwczovL21lbWJlcnNoaXBndWlkZS5vcmcvXCI+IDxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5NZW1iZXJzaGlwIEd1aWRlPC9zcGFuPjwvYT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+LDwvc3Bhbj48YSBocmVmPVwiaHR0cHM6Ly93d3cubGVuZmVzdGluc3RpdHV0ZS5vcmcvbmV3cy10ZWNobm9sb2d5LWlubm92YXRpb24vbWVtYmVyc2hpcC1ndWlkZS1sYXVuY2gtbWVtYmVyc2hpcC1wdXp6bGUvXCI+IDxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5sYXVuY2hlZCBpbiBTZXB0ZW1iZXIgMjAyMDwvc3Bhbj48L2E+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPiwgcHJvdmlkaW5nIHdoYXQgTGljaHRlcm1hbiBzYXlzIHRoZSB0ZWFtIGNvbnNpZGVycyBcdTIwMWNhIHRhY3RpY2FsLCBwcmFjdGljYWwgZ3VpZGUgZm9yIGltcGxlbWVudGluZyBtZW1iZXJzaGlwIHByb2dyYW1tZXNcdTIwMWQuXHUwMGEwPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkFmdGVyIG1vcmUgdGhhbiB0aHJlZSB5ZWFycyBvZiBcdTIwMThwdWJsaWMgcmVzZWFyY2hcdTIwMTkgYnkgdGhlIE1lbWJlcnNoaXAgUHV6emxlIFByb2plY3QgaXRzZWxmLCB0aGUgR3VpZGUgYnJpbmdzIHRvZ2V0aGVyIG1vcmUgdGhhbiAzMCBjYXNlIHN0dWRpZXMgYW5kIGludGVydmlld3Mgd2l0aCA1MCBuZXdzcm9vbXMuXHUwMGEwPC9zcGFuPlxyXG48aDM+PGI+TWVtYmVyc2hpcCwgZG9uYXRpb24sIHN1YnNjcmlwdGlvbjwvYj48L2gzPlxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+TGljaHRlcm1hbiBleHBsYWlucyB0aGF0IHRoZSBwcm9qZWN0IFx1MjAxY2xvb2tzIGF0IGV2ZXJ5IHN0ZXAgb2YgeW91ciBtZW1iZXJzaGlwIGpvdXJuZXksIGZyb20gZGVjaWRpbmcgaWYgbWVtYmVyc2hpcCBpcyByaWdodCBmb3IgeW91IC0gPC9zcGFuPjxpPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5iZWNhdXNlIGl0IGlzbid0IG5lY2Vzc2FyaWx5IGZvciBldmVyeSBvcmdhbmlzYXRpb248L3NwYW4+PC9pPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj4gLSB0byB0aGVuIGxhdW5jaGluZyBhbmQgaW1wbGVtZW50aW5nIGEgbWVtYmVyc2hpcCBwcm9ncmFtbWUsIGFuZCBjb250aW51aW5nIHRvIGl0ZXJhdGUgYW5kIGdyb3cgb24gaXRcdTIwMWQuXHUwMGEwPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkV4cGxhaW5pbmcgc29tZSBrZXkgdGFrZWF3YXlzIGZyb20gdGhlIEd1aWRlLCBoZSBzYXlzOiBcdTIwMWNtZW1iZXJzaGlwIGlzIGRpZmZlcmVudCBmcm9tIHN1YnNjcmlwdGlvbiwgPC9zcGFuPjxpPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5uZWNlc3NhcmlseTwvc3Bhbj48L2k+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPi4gSWYgeW91J3JlIGEgc3Vic2NyaWJlciwgeW91IHBheSB0byBnZXQgYWNjZXNzLiBTbyB0aGVyZSBpcyBhIHBheXdhbGwgYW5kIGl0J3MgcmVhbGx5IG1vcmUgdHJhbnNhY3Rpb25hbC48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XCJXaXRoIG1lbWJlcnNoaXAsIHlvdSdyZSBmZWVsaW5nIGxpa2UgeW91J3JlIGpvaW5pbmcgYSBtb3ZlbWVudCwgeW91J3JlIHBhcnQgb2YgYSBjYXVzZS4gWW91J3JlIGdpdmluZyBub3Qgb25seSB5b3VyIG1vbmV5LCBidXQgcG90ZW50aWFsbHkgdGltZSBhbmQgaWRlYXMsIGFuZCBvdGhlciBzb3J0IG9mIHRoaW5ncy4gWW91IGFjY2VzcyBpdCBiZWNhdXNlIGl0J3Mgc29tZXRoaW5nIHRvIGJlbGlldmUgaW4gYW5kIHNvbWV0aGluZyB0aGF0IHlvdSB0aGluayBpcyBiZW5lZmljaWFsIHRvIHlvdXIgY29tbXVuaXR5LCBvciBzb2NpZXR5IG1vcmUgYnJvYWRseS5cdTIwMWRcdTAwYTA8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+QnV0IGhlIGFja25vd2xlZGdlZCB0aGVyZVx1MjAxOXMgbG90cyB0byBiZSBsZWFybmVkIGZyb20gb2xkZXIgc3Vic2NyaXB0aW9uIG1vZGVscywgYW5kIHRoYXQgdGhlcmUgaXMgbXVjaCB0byBiZSBzYWlkIGZvciBcdTIwMThkb2luZyBhIG51bWJlciBvZiB0aGluZ3MgdG8gbWFrZSBtb25leVx1MjAxOS5cdTAwYTA8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjPC9zcGFuPjxpPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5UaGUgR3VhcmRpYW48L3NwYW4+PC9pPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj4gaXMgYSByZWFsbHkgZ29vZCBleGFtcGxlLCB5b3UgY2FuIHNvcnQgb2YgcHV0IG11bHRpcGxlIG1vZGVscyB0b2dldGhlciwgc28gc3Vic2NyaXB0aW9uIGFuZCBtZW1iZXJzaGlwIGFyZW4ndCBtdXR1YWxseSBleGNsdXNpdmUuIEFuZCB5b3UgY2FuIGluY29ycG9yYXRlIFx1MjAxOG1lbWJlcmZ1bCByb3V0aW5lc1x1MjAxOSBhbmQgc3RhcnQgdG8gYnVpbGQgdG93YXJkIGRldmVsb3BpbmcgdGhhdCBsb3lhbCBhdWRpZW5jZSBhbmQgbWFraW5nIHBlb3BsZSBvcGVuIHRvIHRoZSBpZGVhIG9mIG1lbWJlcnNoaXAsIGFuZCBiZWluZyBlbmdhZ2VkIHdpdGggdGhlIGNvdmVyYWdlIGJlZm9yZSBsYXVuY2hpbmcgYSBzcGVjaWZpYyBtZW1iZXJzaGlwIHByb2dyYW1tZS4gU28geW91J3JlIGFibGUgdG8gc29ydCBvZiBkbyBpdCBpbiBzdGFnZXMgYW5kIG1lZXQgeW91ciBhdWRpZW5jZSB3aGVyZSB0aGV5IGFyZS5cdTIwMWQ8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+T25lIHB1Ymxpc2hlciBpbnRlcnZpZXdlZCBmb3IgdGhlIHByb2plY3QsIExpY2h0ZXJtYW4gZXhwbGFpbnMsIHdoZW4gY29uc2lkZXJpbmcgd2hldGhlciBwZW9wbGUgd291bGQgYmUgd2lsbGluZyBhbmQgYWJsZSB0byBwYXkgb25saW5lIHRvIGpvaW4sIHJlYWxpc2VkIHRoZXkgaGFkIGEgbGFyZ2UgcGFydCBvZiB0aGVpciBhdWRpZW5jZSB3aG8gd291bGRuXHUyMDE5dCBvciBjb3VsZG5cdTIwMTl0LiBcdTIwMWNUaGV5IGhhZCB0byByZXRoaW5rIHRoZWlyIHN0cmF0ZWd5IHRvIHNldCBpdCB1cCBmb3IgbWFpbGluZyBhbmQgdGhpbmdzIGxpa2UgdGhhdFx1MjAyNiBUaGV5IGhhdmUgY2hlcXVlcywgd2hpY2ggaXMgc29tZXRoaW5nIHlvdSBtaWdodCBuZWVkIHRvIHRoaW5rIGFib3V0LiBCdXQsIHRoZW4sIG9uY2UgeW91IGtub3cgeW91IGhhdmUgYW4gYXVkaWVuY2Ugd2hvJ3MgZ29pbmcgdG8gcGF5IG9ubGluZSwgeW91IGNhbiBzZXQgdXAgcmVjdXJyaW5nIHBheW1lbnRzIGFuZCBvcHRpbWlzZSB5b3VyIGNoZWNrb3V0IGZsb3cgYW5kIGRvIGFsbCB0aGVzZSBlLWNvbW1lcmNlIHN0cmF0ZWdpZXMgdG8gcmVhbGx5IGJlIGFibGUgdG8gZG8gdGhhdCB3ZWxsLlx1MjAxZDwvc3Bhbj5cclxuPGgzPjxiPkRpZ2l0YWwgbWFya2V0ZXJzIHdpdGggYSBnb29kIHRlY2ggc3RhY2s8L2I+PC9oMz5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkhlIGVtcGhhc2lzZWQgdGhlIG5lZWQgdG8gXHUyMDE4dGhpbmsgbGlrZSBkaWdpdGFsIG1hcmtldGVyc1x1MjAxOSBhbmQgdGhhdCwgd2hlcmUgYSBsb3Qgb2YgbmV3c3Jvb21zLCBsZWdhY3kgb3IgbGVkIGJ5IGEgdGVhbSBvZiBqb3VybmFsaXN0cyBpbiBhIHN0YXJ0dXAsIGNhbiBmYWlsIHRvIGFwcHJlY2lhdGUgYSBnb29kIHRlY2ggc3RhY2suPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY1RoZXkgbWF5IHRoaW5rIHRoYXQgaXQncyBqdXN0IHBhcnQgb2YgYSB3ZWJzaXRlIGFuZCBwdWJsaXNoLCBidXQgbm90IG9ubHkgZG8geW91IG5lZWQgYSB3ZWJzaXRlLCB5b3UgbmVlZCBhIENSTSB0byBiZSBhYmxlIHRvIHRyYWNrIHlvdXIgbWVtYmVycyBhbmQgdGhlIHdheSB0aGV5J3JlIGludGVyYWN0aW5nIHdpdGggeW91LCBhbmQgdG8gYmUgYWJsZSB0byBoYW5kbGUgcGF5bWVudHMuIFlvdSBuZWVkIGFuIGVtYWlsIHNlcnZpY2UgcHJvdmlkZXIuIFlvdSBuZWVkIHRvIGhhdmUgQVBJcyBjb25uZWN0aW5nIGFsbCBvZiB0aG9zZS4gQW5kLCBpZiB5b3UncmUgZ29pbmcgdG8gZG8gZXZlbnRzLCB5b3UgbmVlZCBhIHBsYXRmb3JtIGJlaW5nIGFibGUgdG8gZG8gZXZlbnRzIG9uIGFuZCB0aGluZ3MgbGlrZSB0aGF0LiBBbmQgc28gaXQgZ2V0cyBtb3JlIGNvbXBsaWNhdGVkIGFuZCB5b3Ugd2FudCBhbGwgdGhvc2UgdGhpbmdzIHRvIGJlIGFibGUgdG8gdGFsayB0b2dldGhlci5cdTIwMWQ8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+SGUgZW1waGFzaXNlZCBtZW1iZXJzaGlwIGlzblx1MjAxOXQgYSBzaWx2ZXIgYnVsbGV0IGFuZCBwb2ludGVkIHRvIHZlcnkgc3VjY2Vzc2Z1bCBvcmdhbmlzYXRpb25zIGxpa2UgUHJvUHVibGljYSwgd2hpY2ggYWN0aXZlbHkgc2Vla3MgZG9uYXRpb25zIGJ1dCBkb2VzIG5vdCBoYXZlIGEgbWVtYmVyc2hpcCBwcm9ncmFtLCBpbnN0ZWFkIGl0IHNlZWtzIHJlYWRlciBpbnB1dCBvbiBwYXJ0aWN1bGFyIGludmVzdGlnYXRpb25zLiBMaWtld2lzZSwgdGhlIDwvc3Bhbj48aT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+TmV3IFlvcmsgVGltZXM8L3NwYW4+PC9pPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj4gaXMgdGhlPC9zcGFuPjxpPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj4gTmV3IFlvcmsgVGltZXMsPC9zcGFuPjwvaT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+IGFuZCBpdHMgc3Vic2NyaXB0aW9uIG1vZGVsIHdvcmtzIGp1c3QgZmluZS48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+U29tZXRoaW5nIGxpa2U8L3NwYW4+PGEgaHJlZj1cImh0dHBzOi8vYmxhY2tiYWxsYWQuY28udWsvXCI+IDxpPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5CbGFjayBCYWxsYWQ8L3NwYW4+PC9pPjwvYT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+LCBhbHNvIGluIHRoZSBHdWlkZSwgbGF1bmNoZWQgYSBTbGFjayBjb21tdW5pdHkgZm9yIEJsYWNrIHdvbWVuLiBcdTIwMWNUbyBkbyB0aGF0IGludGVudGlvbmFsbHkgaXMgYSBncmVhdCBzZXJ2aWNlIHRvIHRoZW0gYW5kIGEgZ3JlYXQgZXhhbXBsZSBvZiB3aHkgcmVwcmVzZW50YXRpdmUgbWVkaWEgaXMgc28gZXNzZW50aWFsLCB5b3UncmUgYWJsZSB0byBoYXZlIGNvbnZlcnNhdGlvbnMgdGhhdCB5b3Ugd291bGRuJ3QgYmUgYWJsZSB0byBoYXZlIG90aGVyd2lzZS4gQW5kIHRoZW4sIGJlY2F1c2UgPC9zcGFuPjxpPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5CbGFjayBCYWxsYWQ8L3NwYW4+PC9pPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj4gaGFzIHN1Y2ggYSBmb290aG9sZCBpbiB0aGF0IGNvbW11bml0eSBhbmQgaXMgYWJsZSB0byByZWFsbHkgaWRlbnRpZnkgdGhhdCBhbmQgYmUgcmVwcmVzZW50YXRpdmUsIHRoZW4gdGhlcmUncyBhIGJ1c2luZXNzIG9wcG9ydHVuaXR5IHRoZXJlIGFzIHdlbGwsIHdoZXRoZXIgaXQncyBtYXJrZXRpbmcgb3IgYWR2ZXJ0aXNpbmcgb3IgbWVtYmVyc2hpcCwgd2hpY2ggdGhleSd2ZSBpbnZlc3RlZCBpbi5cIjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5NUFAsIExlbmZlc3QsIGFuZCBUZXhhcyBUcmlidW5lXHUyMDE5cyBSZXZMYWIgYXJlIGFsc28gb2ZmZXJpbmcgYSBmcmVlLDwvc3Bhbj48YSBocmVmPVwiaHR0cHM6Ly93d3cubGVuZmVzdGluc3RpdHV0ZS5vcmcvbGVuZmVzdC1uZXdzLXBoaWxhbnRocm9weS1uZXR3b3JrL21lbWJlcnNoaXAtMTAxL1wiPiA8c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+TWVtYmVyc2hpcCAxMDE8L3NwYW4+PC9hPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj4gdHJhaW5pbmcgY291cnNlIGZvciBuZXdzcm9vbXMgdGhyb3VnaCBpdHM8L3NwYW4+PGEgaHJlZj1cImh0dHBzOi8vd3d3LmxlbmZlc3RpbnN0aXR1dGUub3JnL2xlbmZlc3QtbmV3cy1waGlsYW50aHJvcHktbmV0d29yay9cIj4gPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkxlbmZlc3QgTmV3cyBQaGlsYW50aHJvcHkgTmV0d29yazwvc3Bhbj48L2E+LCB3aGljaCBmZWVscyBsaWtlIGFub3RoZXIgb3Bwb3J0dW5pdHkgdG8gZXh0ZW5kIHRoZSBsZWdhY3kgb2YgdGhpcyB3b3JrLlxyXG48aDM+PGI+Q29tbXVuaXR5IGxpc3RlbmluZzwvYj48L2gzPlxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+VGhyb3VnaCB0aGUgS25pZ2h0LUxlbmZlc3QgTG9jYWwgTmV3cyBUcmFuc2Zvcm1hdGlvbiBGdW5kLCBhIGpvaW50IGluaXRpYXRpdmUgd2l0aCB0aGUgS25pZ2h0IEZvdW5kYXRpb24sIGl0IGhhcyBhbHNvIHJlY2VudGx5IGludmVzdGVkIGluIHRoZTwvc3Bhbj48YSBocmVmPVwiaHR0cHM6Ly93d3cubGVuZmVzdGluc3RpdHV0ZS5vcmcvY292aWQxOWZ1bmQvXCI+IDxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5QaGlsYWRlbHBoaWEgQ09WSUQtMTkgQ29tbXVuaXR5IEluZm9ybWF0aW9uIEZ1bmQ8L3NwYW4+PC9hPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj4gc3VwcG9ydGluZyBhbG1vc3QgMjAgbmV3cyBvcmdhbmlzYXRpb25zIHRvIGhlbHAgZ2V0IGluZm9ybWF0aW9uIHRvIHRob3NlIHRoYXQgbmVlZCBpdCBsb2NhbGx5LCBhbmQgYTwvc3Bhbj48YSBocmVmPVwiaHR0cHM6Ly93d3cubGVuZmVzdGluc3RpdHV0ZS5vcmcvY29tbXVuaXR5LWxpc3RlbmluZy1lbmdhZ2VtZW50LWZ1bmQvXCI+IDxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5Db21tdW5pdHkgTGlzdGVuaW5nIGFuZCBFbmdhZ2VtZW50IEZ1bmQ8L3NwYW4+PC9hPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj4sIGFyb3VuZCB1bmRlcnN0YW5kaW5nIHJlYWwgaW5mb3JtYXRpb24gbmVlZHMuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlRoZSBMZW5mZXN0IEluc3RpdHV0ZSdzIG93biB3ZWJzaXRlIGlzIHVuc3VycHJpc2luZ2x5IGZ1bGwgb2YgYWNjZXNzaWJsZTwvc3Bhbj48YSBocmVmPVwiaHR0cHM6Ly93d3cubGVuZmVzdGluc3RpdHV0ZS5vcmcvY29yb25hdmlydXMvXCI+IDxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj50b29scyBhbmQgZ3VpZGVzIGFib3V0IGRvaW5nIGpvdXJuYWxpc20gaW4gdGltZXMgb2YgQ09WSUQ8L3NwYW4+PC9hPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj4sIGZyb20gZGF5LXRvLWRheSByZXBvcnRpbmcsIHRvIHNlbGYtY2FyZSBmb3Igam91cm5hbGlzdHMuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY09uZSBvZiB0aGUgZ29vZCB0aGluZ3MgdGhhdCdzIGNvbWUgb3V0IG9mIHRoZSBjb252ZXJzYXRpb25zIHJlY2VudGx5IGFyb3VuZCBDT1ZJRCwgaXMgdGhpbmtpbmcgYWJvdXQgd2hhdCBhY3R1YWwgaW5mb3JtYXRpb24gY29tbXVuaXRpZXMgbmVlZCB0byBtZWV0IHRoZWlyIG5lZWRzLFwiIExpY2h0ZXJtYW4gYWNrbm93bGVkZ2VzLiBcIkknbSBpbiwgZm9yIGV4YW1wbGUsIGEgdmVyeSBmb3J0dW5hdGUgcGxhY2UgdGhhdCBJIGhhdmUgYSBqb2Igd2hlcmUgSSBjYW4gd29yayBmcm9tIGhvbWUuLi4gU28gdGhlIGluZm9ybWF0aW9uIEkgbmVlZCBmb3IgbXkgZGF5LXRvLWRheSBsaWZlIGlzIHByb2JhYmx5IHZlcnkgZGlmZmVyZW50IGZyb20gc29tZW9uZSB3aG8gaXMgYSBmcm9udGxpbmUgd29ya2VyIGFuZCBzdGlsbCBoYXZpbmcgdG8gZ28gaW50byB3b3JrIGV2ZXJ5IGRheSBhdCB0aGUgc3VwZXJtYXJrZXQgb3IgZHJpdmluZyBhIGJ1cy5cdTIwMWQ8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+QW5kIHRoZSBuZXh0IHRoaW5nIHRoYXRcdTIwMTlzIGhpZ2ggdXAgb24gdGhlIGxpc3QgYXQgdGhlIExlbmZlc3QgSW5zdGl0dXRlIGlzIGRldmVsb3BpbmcgYSBzdGFuZGFyZCBsZWFybmluZyBhbmQgaW1wYWN0IGZyYW1ld29yayBmb3IgdGhlIHdvcmsgdGhleSBkby4gXHUyMDFjUHV0dGluZyBpbiBoeXBvdGhlc2VzIGFuZCBtYWtpbmcgc3VyZSB0aGUgZGF0YSBjb2xsZWN0aW9uIGlzIHRoZXJlIGFuZCBzZWVpbmcgaG93IHRoZSBhY3R1YWwgcmVzdWx0cyBhbGlnbiB3aXRoIHRoZSBoeXBvdGhlc2VzLFx1MjAxZCBMaWNodGVybWFuIGV4cGxhaW5zLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5UaGlzIGZlZWxzIGxpa2UgdGhlIGZpbmFsIHBpZWNlIG9mIHRoZSBwdXp6bGUsIHRvIGVuc3VyZSBhIGxvY2FsIGxlZ2FjeSBmb3IgR2VycnkgTGVuZmVzdCwgYnkgbWFraW5nIHN1cmUgaGlzIG1vbmV5IGlzIHdvcmtpbmcgdG8gZW5zdXJlIHRoZSBmdXR1cmUgb2YgbG9jYWwgbmV3cywgaW4gUGhpbGFkZWxwaGlhIGFuZCBiZXlvbmQuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkNPTlRBQ1Q8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+PGltZyBjbGFzcz1cImFsaWdubm9uZSBzaXplLWZ1bGwgd3AtaW1hZ2UtMTU0NDhcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAyMC8xMC9Kb3NlcGgtTGljaHRlcm1hbi5qcGdcIiBhbHQ9XCJUaGlzIGlzIGFuIGltYWdlIG9mIEpvc2VwaCBMaWNodGVybWFuLCB3aG8gaXMgaW50ZXJ2aWV3ZWQgaW4gdGhpcyBhcnRpY2xlIGFuZCB3b3JrcyBhdCB0aGUgTGVuZmVzdCBJbnN0aXR1dGVcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjMwMFwiIC8+PC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkpvc2VwaCBMaWNodGVybWFuLCB0aGUgTGVuZmVzdCBJbnN0aXR1dGUncyBtYW5hZ2VyIG9mIGVkaXRvcmlhbCBhbmQgZGlnaXRhbCBzdHJhdGVneTwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5Ud2l0dGVyOjwvc3Bhbj48YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS95bGljaHRlcm1hblwiPiA8c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+QHlsaWNodGVybWFuPC9zcGFuPjwvYT48YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9sZW5mZXN0aW5zdFwiPiA8c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+QGxlbmZlc3RpbnN0PC9zcGFuPjwvYT5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzRcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd10iLCJwb3N0X3RpdGxlIjoiTGVuZmVzdCBJbnN0aXR1dGU6IHdvcmtpbmcgd2l0aCB0aGUgUGhpbGx5IElucXVpcmVyIGFzIGEgJiM4MjE2O3Rlc3Qga2l0Y2hlbiYjODIxNzsgZm9yIENPVklEIGlubm92YXRpb24gYW5kIG1vcmUiLCJwb3N0X2xpbmsiOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvbGVuZmVzdC1pbnN0aXR1dGUtcGhpbGx5LWlucXVpcmVyLyIsInBvc3RfZmVhdHVyZWRfaW1hZ2UiOiI8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIlRoaXMgaXMgYW4gaW1hZ2Ugb2YgYSBsaW5lIG9mIGNhcnMgcXVldWVkIHVwIGZvciBwZW9wbGUgdHJ5aW5nIHRvIGdldCBhIGNvcm9uYXZpcnVzIHRlc3QgaW4gUGhpbGFkZWxwaGlhIHRha2VuIGJ5IFRpbSBUYWkgb2YgdGhlIFBoaWxhZGVscGhpYSBJbnF1aXJlclwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAyXCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMjAvMTAvQ29yb25hdmlydXMtVGVzdGluZy1UaW0tVGFpLVBoaWxhZGVscGhpYS1JbnF1aXJlci0zMDB4MjAyLnBuZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6Ik1lZGlhIGxhYnMiLCJwb3N0X3RhZ3MiOiJDT1ZJRCwgTGVuZmVzdCBJbnN0aXR1dGUsIExlbmZlc3QgTG9jYWwgTGFiLCBsb2NhbCBqb3VybmFsaXNtLCBQaGlsYWRlbHBoaWEsIFBoaWxhZGVscGhpYSBJbnF1aXJlciIsIiVfZWRpdF9sb2NrJSI6IjE2MTIyMDk1MTc6MSIsIiVfZWRpdF9sYXN0JSI6IjkzMyIsIiVzbGlkZV90ZW1wbGF0ZSUiOiJkZWZhdWx0IiwiJV93cGJfdmNfanNfc3RhdHVzJSI6InRydWUiLCIlX3dwZ21wX2xvY2F0aW9uX2FkZHJlc3MlIjoiODAxIE1hcmtldCBTdCwgUGhpbGFkZWxwaGlhLCBQQSAxOTEwNywgVVNBIiwiJV93cGdtcF9sb2NhdGlvbl9jaXR5JSI6IlBoaWxhZGVscGhpYSIsIiVfd3BnbXBfbG9jYXRpb25fc3RhdGUlIjoiUGVubnN5bHZhbmlhIiwiJV93cGdtcF9sb2NhdGlvbl9jb3VudHJ5JSI6IlVuaXRlZCBTdGF0ZXMiLCIlX3dwZ21wX21ldGFib3hfbGF0aXR1ZGUlIjoiMzkuOTUxNDQ1OSIsIiVfd3BnbXBfbWV0YWJveF9sb25naXR1ZGUlIjoiLTc1LjE1NDA3NzM5OTk5OTk5IiwiJV93cGdtcF9tZXRhYm94X2xvY2F0aW9uX3JlZGlyZWN0JSI6Im1hcmtlciIsIiVfd3BnbXBfbWV0YWJveF9jdXN0b21fbGluayUiOiIiLCIlX3dwZ21wX21hcF9pZCUiOiJhOjE6e2k6MDtzOjE6XCIyXCI7fSIsIiVfd3BnbXBfbWV0YWJveF9tYXJrZXJfaWQlIjoiTjsiLCIlX3dwZ21wX21ldGFib3hfdGF4b21vbWllc190ZXJtcyUiOiJOOyIsIiVfd3BnbXBfZXh0ZW5zaW9uc19maWVsZHMlIjoiTjsiLCIlX2tsZW9fdHJhbnNwYXJlbnRfbWVudV9jb2xvciUiOiJ3aGl0ZSIsIiVfa2xlb190aXRsZV9jb2xvciUiOiIjIiwiJV9rbGVvX3RpdGxlX2JnJSI6IiwgcmVwZWF0LCBpbmhlcml0LCBzY3JvbGwsIGxlZnQgdG9wIiwiJV9rbGVvX3RpdGxlX2JnX2NvbG9yJSI6IiMiLCIlX3lvYXN0X3dwc2VvX2NvbnRlbnRfc2NvcmUlIjoiMzAiLCIlX2tsZW9fdGl0bGVfY2hlY2tib3glIjoiMSIsIiVfdGh1bWJuYWlsX2lkJSI6IjE1NDQ0IiwiJV95b2FzdF93cHNlb19wcmltYXJ5X2NhdGVnb3J5JSI6IjE0MiIsIiVfeW9hc3Rfd3BzZW9fZm9jdXNrdyUiOiJMZW5mZXN0IEluc3RpdHV0ZSIsIiVfeW9hc3Rfd3BzZW9fbWV0YWRlc2MlIjoiVGhyb3VnaCBpdHMgdW5pcXVlIHJlbGF0aW9uc2hpcCB3aXRoIHRoZSBsb2NhbCBuZXdzcGFwZXIsIHRoZSBMZW5mZXN0IEluc3RpdHV0ZSBpcyBhYmxlIHRvIHRlc3QgYW5kIHNoYXJlIHJlYWwtbGlmZSBqb3VybmFsaXNtIGlubm92YXRpb24gd2l0aCB0aGUgaW5kdXN0cnkuIiwiJV95b2FzdF93cHNlb19saW5rZGV4JSI6IjY3IiwiJV93cF9vbGRfc2x1ZyUiOiJsZW5mZXN0LWluc3RpdHV0ZS13b3JraW5nLXdpdGgtdGhlLXBoaWxseS1pbnF1aXJlci1hcy1hLXRlY2gta2l0Y2hlbi1mb3ItY292aWQtaW5ub3ZhdGlvbi1hbmQtbW9yZSIsIiVzYmdfc2VsZWN0ZWRfc2lkZWJhciUiOiIwIiwiJXNiZ19zZWxlY3RlZF9zaWRlYmFyX3JlcGxhY2VtZW50JSI6IjAiLCJ0YXhvbm9teT1jYXRlZ29yeSI6Ik1lZGlhIGxhYnMiLCJ0YXhvbm9teT1wb3N0X3RhZyI6IkNPVklELCBMZW5mZXN0IEluc3RpdHV0ZSwgTGVuZmVzdCBMb2NhbCBMYWIsIGxvY2FsIGpvdXJuYWxpc20sIFBoaWxhZGVscGhpYSwgUGhpbGFkZWxwaGlhIElucXVpcmVyIn0sImljb24iOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxOC8wMi9tYXJrZXItMS5wbmcifSwiaWQiOjE1NDMzLCJpbmZvd2luZG93X2Rpc2FibGUiOmZhbHNlfSx7InNvdXJjZSI6InBvc3QiLCJ0aXRsZSI6IlRoZSBNZWRpYSBBcmNoYWVvbG9neSBMYWI6IGxldHRpbmcgcGVvcGxlIGRpc2NvdmVyIGRpZmZlcmVudCBwb3NzaWJpbGl0aWVzIGZvciBpbm5vdmF0aW9uIiwiaW5mb3dpbmRvd19jb250ZW50IjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZ1wiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJUaGUgTWVkaWEgQXJjaGFlb2xvZ3kgTGFiOiBsZXR0aW5nIHBlb3BsZSBkaXNjb3ZlciBkaWZmZXJlbnQgcG9zc2liaWxpdGllcyBmb3IgaW5ub3ZhdGlvblwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMTY3XCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMjAvMDYvTWVkaWEtQXJjaGFlb2xvZ3ktTGFiLTMwMHgxNjcuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZ1wiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tcGFkZGluZy1jb250ZW50XzIwXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tbWV0YSBmYy1pdGVtLXNlY29uZGFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlIGZjLXRleHQtY2VudGVyXCI+TWVkaWEgbGFicywgUmVzZWFyY2ggcHJvamVjdHM8L2Rpdj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS10aXRsZSBmYy1pdGVtLXByaW1hcnktdGV4dC1jb2xvciBmYy10ZXh0LWNlbnRlclwiPlRoZSBNZWRpYSBBcmNoYWVvbG9neSBMYWI6IGxldHRpbmcgcGVvcGxlIGRpc2NvdmVyIGRpZmZlcmVudCBwb3NzaWJpbGl0aWVzIGZvciBpbm5vdmF0aW9uPC9kaXY+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tY29udGVudCBmYy1pdGVtLWJvZHktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZVwiPlxyXG4gICAgICAgICAgICBTaW5jZSAyMDA5LCB0aGUgTWVkaWEgQXJjaGFlb2xvZ3kgTGFiIGluIGF0IHRoZSBVbml2ZXJzaXR5IG9mIENvbG9yYWRvLCBCb3VsZGVyLCBoYXMgYmVlbiB3ZWxjb21pbmcgc3R1ZGVudHMgYW5kIHRoZSBwdWJsaWMgdG8gZ2V0IHRoZWlyIGhhbmRzIG9uIHRoZSBub3QtbGF0ZXN0IG1lZGlhIHRlY2hub2xvZ2llcyB0byBoZWxwIHRoZW0gYXNrIGRpZmZlcmVudCBxdWVzdGlvbnMgYWJvdXQgaW5ub3ZhdGlvbi5cclxuICAgICAgICA8L2Rpdj5cclxuPGEgaHJlZj1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi90aGUtbWVkaWEtYXJjaGFlb2xvZ3ktbGFiLWxldHRpbmctcGVvcGxlLWRpc2NvdmVyLWRpZmZlcmVudC1wb3NzaWJpbGl0aWVzLWZvci1pbm5vdmF0aW9uL1wiPlJlYWQgbW9yZTwvYT5cclxuICAgIDwvZGl2PlxyXG4gICAgPC9kaXY+XHJcbjwvZGl2PlxyXG5cclxuIiwiY29udGVudCI6IlNpbmNlIDIwMDksIHRoZSBNZWRpYSBBcmNoYWVvbG9neSBMYWIgaW4gYXQgdGhlIFVuaXZlcnNpdHkgb2YgQ29sb3JhZG8sIEJvdWxkZXIsIGhhcyBiZWVuIHdlbGNvbWluZyBzdHVkZW50cyBhbmQgdGhlIHB1YmxpYyB0byBnZXQgdGhlaXIgaGFuZHMgb24gdGhlIG5vdC1sYXRlc3QgbWVkaWEgdGVjaG5vbG9naWVzIHRvIGhlbHAgdGhlbSBhc2sgZGlmZmVyZW50IHF1ZXN0aW9ucyBhYm91dCBpbm5vdmF0aW9uLiIsImFkZHJlc3MiOiIxMzIwIEdyYW5kdmlldyBBdmUsIEJvdWxkZXIsIENPIDgwMzAyLCBVU0EiLCJsb2NhdGlvbiI6eyJsYXQiOiI0MC4wMTEzMzAzIiwiY2l0eSI6IkJvdWxkZXIiLCJzdGF0ZSI6IkNvbG9yYWRvIiwiY291bnRyeSI6IlVuaXRlZCBTdGF0ZXMiLCJsbmciOiItMTA1LjI3NTQ2OTIiLCJvbmNsaWNrX2FjdGlvbiI6Im1hcmtlciIsInJlZGlyZWN0X3Blcm1hbGluayI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi90aGUtbWVkaWEtYXJjaGFlb2xvZ3ktbGFiLWxldHRpbmctcGVvcGxlLWRpc2NvdmVyLWRpZmZlcmVudC1wb3NzaWJpbGl0aWVzLWZvci1pbm5vdmF0aW9uLyIsInpvb20iOjIsImV4dHJhX2ZpZWxkcyI6eyJwb3N0X2V4Y2VycHQiOiJTaW5jZSAyMDA5LCB0aGUgTWVkaWEgQXJjaGFlb2xvZ3kgTGFiIGluIGF0IHRoZSBVbml2ZXJzaXR5IG9mIENvbG9yYWRvLCBCb3VsZGVyLCBoYXMgYmVlbiB3ZWxjb21pbmcgc3R1ZGVudHMgYW5kIHRoZSBwdWJsaWMgdG8gZ2V0IHRoZWlyIGhhbmRzIG9uIHRoZSBub3QtbGF0ZXN0IG1lZGlhIHRlY2hub2xvZ2llcyB0byBoZWxwIHRoZW0gYXNrIGRpZmZlcmVudCBxdWVzdGlvbnMgYWJvdXQgaW5ub3ZhdGlvbi4iLCJwb3N0X2NvbnRlbnQiOiJbdmNfcm93XVt2Y19jb2x1bW4gd2lkdGg9XCIxLzRcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS8yXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48aDE+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlRoZSBNZWRpYSBBcmNoYWVvbG9neSBMYWI6IGxldHRpbmcgcGVvcGxlIGRpc2NvdmVyIGRpZmZlcmVudCBwb3NzaWJpbGl0aWVzIGZvciBpbm5vdmF0aW9uPC9zcGFuPjwvaDE+XHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5UaGUgPC9zcGFuPjxhIGhyZWY9XCJodHRwczovL21lZGlhYXJjaGFlb2xvZ3lsYWIuY29tL1wiPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5NZWRpYSBBcmNoYWVvbG9neSBMYWI8L3NwYW4+PC9hPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj4gKE1BTCkgaXMgYSBjb21tdW5pdHktZHJpdmVuLCBwdWJsaWMgcmVzZWFyY2ggc3BhY2UgaW4gdGhlIGJhc2VtZW50IG9mIGFuIHVuYXNzdW1pbmcgaG91c2Ugb24gdGhlIFVuaXZlcnNpdHkgb2YgQ29sb3JhZG9cdTIwMTlzIEJvdWxkZXIgY2FtcHVzLlx1MDBhMDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5BbG9uZyB3aXRoIGl0cyBuYW1lLCBhbmQgaXRzIGNvbnRlbnRzLCB0aGlzIGRlY2FkZS1vbGQgcHJvamVjdCBtYWtlcyBmb3Igc3VjaCBhIGxvY2FsIGN1cmlvc2l0eSBpdCB3YXMgcmVjZW50bHkgbmFtZWQgYXMgYSBsZXNzZXIta25vd24gcGxhY2UgZm9yIHRyYXZlbGxlcnMgdG8gZGlzY292ZXIgb24gPC9zcGFuPjxhIGhyZWY9XCJodHRwczovL3d3dy5hdGxhc29ic2N1cmEuY29tL3BsYWNlcy9tZWRpYS1hcmNoYWVvbG9neS1sYWJcIj48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+QXRsYXMgT2JzY3VyYTwvc3Bhbj48L2E+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPi5cdTAwYTA8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+T3BlbmVkIGluIDIwMDksIGl0XHUyMDE5cyBub3cgaG9tZSB0byBhIGNhdGFsb2d1ZSBvZiBtb3JlIHRoYW4gMSwwMDAgXHUyMDFjPC9zcGFuPjxpPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5zby1jYWxsZWQ8L3NwYW4+PC9pPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj4gb2Jzb2xldGVcdTIwMWQgbWVkaWEgdGVjaG5vbG9naWVzLCBpdHMgZm91bmRlciwgTG9yaSBFbWVyc29uIGV4cGxhaW5zLlx1MDBhMDwvc3Bhbj5cclxuPGRpdiBjbGFzcz1cIm1jZVRlbXBcIj48L2Rpdj5cclxuXHJcbltjYXB0aW9uIGlkPVwiYXR0YWNobWVudF8xNTQxMVwiIGFsaWduPVwiYWxpZ25ub25lXCIgd2lkdGg9XCIzMDBcIl08aW1nIGNsYXNzPVwic2l6ZS1tZWRpdW0gd3AtaW1hZ2UtMTU0MTFcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAyMC8wNi9TY3JlZW4tU2hvdC0yMDIwLTA2LTAzLWF0LTA5LjMwLjM4LTMwMHgyMjYucG5nXCIgYWx0PVwiXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMjZcIiAvPiBNQUw6IHRoZSBvcmlnaW5hbCBOaW50ZW5kbyBFbnRlcnRhaW5tZW50IFN5c3RlbVsvY2FwdGlvbl1cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5FdmVyeXRoaW5nIGZyb20gXHUyMDE4bWFnaWMgbGFudGVybnNcdTIwMTkgdGhhdCByZXByZXNlbnQgc29tZSBvZiB0aGUgZWFybGllc3QgYXR0ZW1wdHMgYXQgY3JlYXRpbmcgdmlydHVhbCByZWFsaXRpZXMsIHRvIHNvbWUgb2YgdGhlIGZpcnN0IGRlc2t0b3AgY29tcHV0ZXJzIGFuZCBnYW1lcyBjb25zb2xlcywgYWxvbmcgd2l0aCBhbGwgbWFubmVyIG9mIHNvZnR3YXJlIGFuZCBtZWRpYSByZWNvcmRpbmdzLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNFdmVyeXRoaW5nIGluIHRoZSBMYWIgd29ya3MgYW5kIGlzIG1lYW50IHRvIGJlIHBsYXllZCB3aXRoLCB0dXJuZWQgb24sIHJlc2VhcmNoZWQgYW5kIGV2ZW4gdXNlZCB0byBjcmVhdGUgYXJ0LFx1MjAxZCBFbWVyc29uIHNheXMuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkFzIGFzc29jaWF0ZSBwcm9mZXNzb3IgaW4gdGhlIDwvc3Bhbj48YSBocmVmPVwiaHR0cDovL2VuZ2xpc2guY29sb3JhZG8uZWR1L1wiPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5FbmdsaXNoPC9zcGFuPjwvYT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+IGRlcGFydG1lbnQsIGFsb25nIHdpdGggdGhlIG5lYXItdW5pcXVlIEludGVybWVkaWEgQXJ0cywgV3JpdGluZyBhbmQgUGVyZm9ybWFuY2UgcHJvZ3JhbW1lLCBkdXJpbmcgdGVybS10aW1lIEVtZXJzb24gdXNlcyB0aGUgTGFiIHRvIGdldCBtb3JlIHRoYW4gMjAwIHN0dWRlbnRzIGV2ZXJ5IHdlZWsgdGhpbmtpbmcgYWJvdXQgXHUyMDE4dGhlIHBvc3NpYmxlXHUyMDE5Llx1MDBhMDwvc3Bhbj5cclxuPGgzPkFza2luZyBob3cgYW5kIHdoeTwvaDM+XHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5XaGV0aGVyIHRoYXRcdTIwMTlzIDwvc3Bhbj48YSBocmVmPVwiaHR0cHM6Ly9saXRlcmFyeWluZnJhc3RydWN0dXJlcy53b3JkcHJlc3MuY29tL1wiPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5hbmFseXNpbmc8L3NwYW4+PC9hPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj4gdGhlIFx1MjAxOGhvd1x1MjAxOSBvZiBsaXRlcmFyeSBwcm9kdWN0aW9uIGluIGhlciBFbmdsaXNoIGNsYXNzZXMgLSBsb29raW5nIGF0IHRoZSBoYXJkd2FyZSBhbmQgdGhlIHNvZnR3YXJlIHRoYXQgZ290IHRoZSB3b3JkcyBvbnRvIHRoZSBwYWdlIC0gb3IgXHUyMDFjcHVyc3VpbmcgZGVhZCBlbmRzIGluIHRlY2hub2xvZ2ljYWwgZGV2ZWxvcG1lbnRcdTIwMWQuIEJ1dCB0aGUgTGFiIGlzIG9wZW4gdG8gYWxsLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5JdCBvZnRlbiBnZXRzIGRvbmF0aW9ucywgd2hldGhlciB0aGF0XHUyMDE5cyBhIDwvc3Bhbj48YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9tZWRpYXJjaGFlb2xvZ3kvc3RhdHVzLzk4NTYzMjQ4OTQxNzc5NzYzMlwiPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj50ZWxlcGhvbmUgc3dpdGNoYm9hcmQgdXNlZCBieSB0aGUgU3Rhc2k8L3NwYW4+PC9hPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj4sIHRoZSBvcmlnaW5hbCBKYXBhbmVzZSB2ZXJzaW9uIG9mIHRoZSBOaW50ZW5kbyBFbnRlcnRhaW5tZW50IFN5c3RlbSwgPC9zcGFuPjxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL21lZGlhcmNoYWVvbG9neS9zdGF0dXMvMTA1NTI4NjkxNzYyMzc3NTIzMlwiPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj50aGUgRmFtaWNvbTwvc3Bhbj48L2E+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPiwgb3IgYSA8L3NwYW4+PGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vbWVkaWFyY2hhZW9sb2d5L3N0YXR1cy8xMTAxNjAxMjQ0MjA3MDcxMjM0XCI+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkZyaWRlbiBtZWNoYW5pY2FsIGNhbGN1bGF0b3I8L3NwYW4+PC9hPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj4uIFRoZXJlXHUyMDE5cyBldmVuIGFuIG9wZW4gPC9zcGFuPjxhIGhyZWY9XCJodHRwczovL21lZGlhYXJjaGFlb2xvZ3lsYWIuY29tL3dpc2hsaXN0L1wiPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj53aXNobGlzdDwvc3Bhbj48L2E+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPiwgaW5jbHVkaW5nIGEgY2FsbG91dCBmb3IgZGVza3RvcCBhbmQgbGFwdG9wIGNvbXB1dGVycyBmcm9tIG91dHNpZGUgTm9ydGggQW1lcmljYSBhbmQgdGhlIFVLLjwvc3Bhbj5cclxuXHJcbltjYXB0aW9uIGlkPVwiYXR0YWNobWVudF8xNTQxNlwiIGFsaWduPVwiYWxpZ25ub25lXCIgd2lkdGg9XCIyODlcIl08aW1nIGNsYXNzPVwic2l6ZS1tZWRpdW0gd3AtaW1hZ2UtMTU0MTZcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAyMC8wNi9TY3JlZW4tU2hvdC0yMDIwLTA2LTAzLWF0LTEyLjA3LjMwLTI4OXgzMDAucG5nXCIgYWx0PVwiXCIgd2lkdGg9XCIyODlcIiBoZWlnaHQ9XCIzMDBcIiAvPiBNQUw6IFwiLi4uIGRpc2NvdmVyZWQgaW4gYSBoZWFwIG9mIGRpc2NhcmRlZCB0ZWNoIG9mIHN1cnZlaWxsYW5jZSBhbmQgYnVyZWF1Y3JhY3kgc2hvcnRseSBhZnRlciB0aGUgQmVybGluIHdhbGwgY2FtZSBkb3duXCJbL2NhcHRpb25dXHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjVGhlIExhYiBpcyByZWFsbHkgaW50ZXJlc3RpbmcgYmVjYXVzZSB5b3UgY2FuIG1ha2Ugd2hhdGV2ZXIgeW91IHdhbnQgb2YgdGhlIGNvbGxlY3Rpb24uIEF0IGZpcnN0IGdsYW5jZSwgeW91IG1pZ2h0IHRoaW5rIHRoYXQgaXRcdTIwMTlzIG9ubHkgZm9yIHBlb3BsZSBpbnRlcmVzdGVkIGluIHRoZSBoaXN0b3J5IG9mIGNvbXB1dGluZy4gPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlwiQnV0LCBhcyBpdCB0dXJucyBvdXQsIHRoZSBjb2xsZWN0aW9uIGNhbiBiZSB1c2VkIHRvIGV4cGxvcmUgdXNlciBpbnRlcmZhY2VzLCB0aGUgaGlzdG9yeSBvZiBmb250cyBhbmQgdHlwZWZhY2VzLCB0aGUgaGlzdG9yeSBvZiBzb3VuZCByZWNvcmRpbmcsIGVhcmx5IGRpZ2l0YWwgYXJ0LCBkaWdpdGFsIGxpdGVyYXR1cmUsIGV2ZW4gYSBiaXQgb2YgZmlsbSAtIHRoZSBsaXN0IGdvZXMgb24uPC9zcGFuPlxyXG48aDM+QWdhaW5zdCBcInBsYW5uZWQgb2Jzb2xlc2NlbmNlXCI8L2gzPlxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjVGhlIExhYiBpcyByZWFsbHkgd29ya2luZyBhZ2FpbnN0IHRoaXMgbm90aW9uIG9mIHBsYW5uZWQgb2Jzb2xlc2NlbmNlIC0gaW4gYSB3YXksIHdlXHUyMDE5cmUgaW5zdGlsbGluZyBzdHVkZW50cyB3aXRoIGEgY3JpdGljYWxpdHkgdGhhdCBpc25cdTIwMTl0IGF2YWlsYWJsZSBhdCBvdGhlciBwbGFjZXMuIDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cIkp1c3QgdHJ5aW5nIHRvIGdldCB0aGVtIHRoaW5raW5nIGFib3V0IHRoZSB2YWx1ZSBvZiBhIGNvbXB1dGVyIGZyb20gMTk3NiwgdGhhdCB3b3JrcyBieSBzd2l0Y2hlcyBhbmQgaGFzIG5vIHZpc3VhbCBvdXRwdXQgYXQgYWxsLCB0cnlpbmcgdG8gZ2V0IHRoZW0gdG8gdGhpbmsgXHUyMDE4d2VsbCwgd2hhdCBjb3VsZCB0aGlzIHRoaW5nIGJlIGdvb2QgZm9yPyBIb3cgY2FuIHdlIHZhbHVlIHRoaXMgdGhpbmc/XHUyMDE5Llx1MDBhMDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNXZVx1MjAxOXJlIHRyeWluZyB0byBpbnN0aWwgdGhlbSB3aXRoIGEgcG9saXRpY3MgdGhhdCBJIGhvcGUgdGhleSB0YWtlIHdpdGggdGhlbSB0byB0aGVzZSB0ZWNoIGNvbXBhbmllcyBvciBzdGFydHVwIGNvbXBhbmllcy5cdTIwMWQ8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+UmVjZW50IFBoRCBncmFkdWF0ZSBsaWJpIHN0cmllZ2wgdXNlZCB0aGUgTGFiIHRvIGRlc2lnbiB3b3Jrc2hvcHMgZm9yIHVuZGVyZ3JhZHVhdGUgc3R1ZGVudHMgdG8gZ2V0IHRoZW0gdG8gdGhpbmsgYWJvdXQgaG93IHRvIHRha2UgYXBhcnQgZGlnaXRhbCBkZXZpY2VzLCBwdXQgdGhlbSBiYWNrIHRvZ2V0aGVyIGFuZCBob3cgdG8gZml4IHRoZW0uIEFub3RoZXIsIE1heWEgTGl2aW8sIGhhcyBiZWVuIHdvcmtpbmcgY2xvc2VseSB3aXRoIEVtZXJzb24gdG8gPGEgaHJlZj1cImh0dHBzOi8vd2hhdGlzYWZlbWluaXN0bGFiLm9ubGluZS9cIj5leHBsb3JlIHRoZSBwb3RlbnRpYWw8L2E+IG9mIGEgXHUyMDE4ZmVtaW5pc3QgbGFiXHUyMDE5Ljwvc3Bhbj5cclxuXHJcbltjYXB0aW9uIGlkPVwiYXR0YWNobWVudF8xNTQxMlwiIGFsaWduPVwiYWxpZ25ub25lXCIgd2lkdGg9XCIzMDBcIl08YSBocmVmPVwiaHR0cHM6Ly9sb3JpZW1lcnNvbmRvdG5ldC5maWxlcy53b3JkcHJlc3MuY29tLzIwMTkvMTEvdG93YXJkcy1mZW1pbmlzdC1sYWJzX2NyaXRpY2FsLW1ha2Vycy1yZWFkZXJfbWF5YS1saXZpby1hbmQtbG9yaS1lbWVyc29uLnBkZlwiPjxpbWcgY2xhc3M9XCJ3cC1pbWFnZS0xNTQxMiBzaXplLW1lZGl1bVwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIwLzA2L1NjcmVlbi1TaG90LTIwMjAtMDYtMDMtYXQtMDkuNDAuMzAtMzAweDE3Mi5wbmdcIiBhbHQ9XCJcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjE3MlwiIC8+PC9hPiBNYXlhIExpdmlvIGFuZCBMb3JpIEVtZXJzb246IFRvd2FyZHMgZmVtaW5pc3QgbGFic1svY2FwdGlvbl1cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNUaGUgdGVybSBcdTIwMThmZW1pbmlzdCBsYWJcdTIwMTkgaXMgYSBoYW5keSB1bWJyZWxsYSB0ZXJtIHRvIGdldCBwZW9wbGUgdG8gdGhpbmsgaGFyZGVyIGFib3V0IGFsbCBvZiB0aG9zZSBsaXR0bGUsIGV2ZXJ5ZGF5IGFjdGl2aXRpZXMgdGhhdCBtYWtlIHVwIHRoZSBsYWIuIDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cIldlIHRyeSB0byB0aGluayBhYm91dCBcdTIwMTh3aGF0XHUyMDE5cyB0aGUgaW5mcmFzdHJ1Y3R1cmUgb2YgeW91ciBsYWI/IEhvdyBpcyB0aGF0IGluZnJhc3RydWN0dXJlIHByb2hpYml0aW5nIHBlb3BsZSBmcm9tIGVpdGhlciB3YW50aW5nIHRvIGVudGVyLCBvciBwaHlzaWNhbGx5IGJlaW5nIGFibGUgdG8gZW50ZXI/IFdoYXRcdTIwMTlzIGEgZmVtaW5pc3QgYnVkZ2V0IGxvb2sgbGlrZT9cdTIwMTkuXHUwMGEwPC9zcGFuPlxyXG48aDM+QSB0cmFuc3BhcmVudCBhbmQgZmFpciBsYWI/PC9oMz5cclxuPGk+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY1x1MjAxOEhvdyBkbyB5b3U8L3NwYW4+PC9pPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj4gZmlndXJlIG91dCB3aG8gdG8gYWNjZXB0IG1vbmV5IGZyb20gYW5kIG9uIHdoYXQgdGVybXM/IEhvdyBkbyB5b3UgY29tZSB1cCB3aXRoIGJ1ZGdldHMgdGhhdCBhcmUgdHJhbnNwYXJlbnQsIGFuZCB0aGF0IGFyZSBmYWlyLCB0aGF0IGFyZSBiYXNlZCBvbiBub3Rpb25zIG9mIGVxdWl0eT9cdTIwMTkuXHUwMGEwPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY0luZnJhc3RydWN0dXJlIGFzaWRlLCBcdTIwMThob3cgZG8geW91IHJ1biBhIG1lZXRpbmcgaW4gYSBsYWIgdGhhdFx1MjAxOXMgaW5jbHVzaXZlLCBwb3RlbnRpYWxseSBub24taGllcmFyY2hpY2FsLCB0aGF0XHUyMDE5cyBub3QgYnVpbHQgb24gdHJhZGl0aW9uYWwgbm90aW9ucyBvZiBhdXRob3JpdHk/IEhvdyBkbyB5b3UgZ2l2ZSBjcmVkaXQgYW5kIGF0dHJpYnV0aW9uIGluIHRlcm1zIG9mIHRoZSBvdXRwdXRzIG9mIHlvdXIgbGFiP1x1MjAxOS5cdTAwYTA8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjSXQgc291bmRzIGxpa2UgYSB2ZXJ5IHNtYWxsIHRoaW5nIGJ1dCBpZiB5b3Ugd2VyZSBnb2luZyB0byBwdWJsaXNoIGFuIGFydGljbGUgd2l0aCBhIGdyb3VwIG9mIHBlb3BsZSwgaWYgeW91IGFjdHVhbGx5IGJlbGlldmUgaW4gZmVtaW5pc3QgcHJpbmNpcGxlcywgd2h5IHdvdWxkIHlvdSBoYXZlIHRoZSBsYWIgZGlyZWN0b3IgbGlzdGVkIGZpcnN0IGFuZCBldmVyeW9uZSBlbHNlIGxpc3RlZCBzZWNvbmQsIHRoaXJkLCBmb3VydGg/IEkgbWVhbiwgaXRcdTIwMTlzIHZlcnkgYWRtaW5pc3RyYXRpdmUsIGJ1cmVhdWNyYXRpYywgYm9yaW5nIHRoaW5ncyB0aGF0IGhhdmUgYSBsb3Qgb2Ygc2lnbmlmaWNhbmNlIHRvIHRoZW0sIGFzIGl0IHR1cm5zIG91dC5cdTIwMWQ8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+QXMgYSBmb3VuZGVyIHdob1x1MjAxOXMgc3RpbGwgYXQgdGhlIGhlbG0sIEVtZXJzb24gaXMgcmF0aGVyIHByb3VkIHRoZSBMYWIgaGFzIGxhc3RlZC5cdTAwYTA8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjSW4gdGhlIGFydHMgYW5kIGh1bWFuaXRpZXMsIGxhYnMgZG9uXHUyMDE5dCB1c3VhbGx5IGxhc3QgdGhhdCBsb25nLCBwcm9iYWJseSBmb3IgZnVuZGluZyByZWFzb25zLiBJIHRoaW5rIGFsc28sIGF0IHNvbWUgcG9pbnQsIEkgcmVhbGlzZWQgdGhhdCB0aGUgTGFiIHdhcyBhdCBpdHMgYmVzdCBhbmQgd2FzIG9ubHkgZ29pbmcgdG8gc3Vydml2ZSB3aGVuIGl0IHR1cm5lZCBpbnRvIGEgcHJvamVjdCB0aGF0IHdhc25cdTIwMTl0IGFib3V0IG1lIGFuZCBteSByZXNlYXJjaCBpbnRlcmVzdHMuIEl0IHR1cm5lZCBpbnRvIGEgY29tbXVuYWwgZW50ZXJwcmlzZS5cdTIwMWQ8L3NwYW4+XHJcbjxoMz5Qb3dlcmVkIGJ5IHZvbHVudGVlcnM8L2gzPlxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+VGhhdCBtZWFucyBhbiBcdTIwMWNhcm15XHUyMDFkIG9mIDEyIHZvbHVudGVlcnMsIHRoZSA8L3NwYW4+PGk+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPk1hbCBQYWxzPC9zcGFuPjwvaT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+LCBzb21lIGZyb20gY2FtcHVzLCBvdGhlcnMgZnJvbSB0ZWNobm9sb2d5IGNvbXBhbmllcyBvciBnb3Zlcm5tZW50LCB1c3VhbGx5IHdpdGggYSBjb21iaW5hdGlvbiBvZiBpbnRlcmVzdCBpbiBlZHVjYXRpb24gYW5kIHZpbnRhZ2UgY29tcHV0aW5nLCBoZWxwaW5nIHdpdGggZXZlcnl0aGluZyBmcm9tIGNsZWFuaW5nIHRvIGNhdGFsb2d1aW5nLiBJdFx1MjAxOXMgdXN1YWxseSBvcGVuIGZvciBmaXZlIGhvdXJzLCBmaXZlIG9yIHNpeCBkYXlzIGEgd2VlaywgdG8gYW55b25lIHRoYXQgd2FudHMgdG8gZHJvcCBieS4gXHUyMDFjV2UgcmVhbGx5IHRyeSB0byBrZWVwIHRoZSBMYWIgYW4gb3BlbiwgcG9yb3VzLCB3ZWxjb21pbmcsIGluY2x1c2l2ZSBzcGFjZSxcdTIwMWQgc2hlIGFkZHMuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlRoZSBMYWIgaGFzIGhvc3RlZCBhcnRpc3RzLSBhbmQgcmVzZWFyY2hlcnMtaW4tcmVzaWRlbmNlIHNpbmNlIDIwMTMsIGZ1bmRpbmcgdGhlbXNlbHZlcyB0byBjb21lIGZvciBhIHdlZWsgb3IgdHdvIHRvIHNwZW5kIGRvaW5nIHdoYXRldmVyIHRoZXkgd2FudCAtIHdoZXRoZXIgdGhhdFx1MjAxOXMgPC9zcGFuPjxhIGhyZWY9XCJodHRwczovL21lZGlhYXJjaGFlb2xvZ3lsYWIuY29tL2Jsb2cvc29mdC1jb21wdXRlcnMtY3JvY2hldC1wYXR0ZXJucy1ieS1zYXJhaC1yb29uZXkvXCI+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPmNyZWF0aW5nIHNvZnQgY3JvY2hldCBwYXR0ZXJucyBvdXQgb2YgaGFyZCBjb21wdXRlcnM8L3NwYW4+PC9hPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj4gdG8gXCJpbnNwaXJlIGNvbXB1dGVyIHVzZXJzIHRvICdsb29rIHVuZGVyIHRoZSBob29kJyBvZiB0aGVpciBvd24gbWFjaGluZXNcIiwgb3JcdTAwYTBkZWx2aW5nIGludG8gdGhlIDwvc3Bhbj48YSBocmVmPVwiaHR0cDovL21lZGlhYXJjaGFlb2xvZ3lsYWIuY29tL3Bhc3QtYXJ0aXN0LWluLXJlc2lkZW5jZS9hcnRpc3Qtam9lbC1zd2Fuc29uL1wiPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5tZWFuaW5ncyBjcmVhdGVkIGJ5IG91ciBrZXlib2FyZHM8L3NwYW4+PC9hPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj4uPC9zcGFuPlxyXG5cclxuW2NhcHRpb24gaWQ9XCJhdHRhY2htZW50XzE1NDA3XCIgYWxpZ249XCJhbGlnbm5vbmVcIiB3aWR0aD1cIjIxNlwiXTxpbWcgY2xhc3M9XCJzaXplLW1lZGl1bSB3cC1pbWFnZS0xNTQwN1wiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIwLzA2L1NjcmVlbi1TaG90LTIwMjAtMDYtMDMtYXQtMDkuMTguNTItMjE2eDMwMC5wbmdcIiBhbHQ9XCJcIiB3aWR0aD1cIjIxNlwiIGhlaWdodD1cIjMwMFwiIC8+IFNhcmFoIFJvb25leTogU29mdCBDb21wdXRlcnNbL2NhcHRpb25dXHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+QnVpbGRpbmcgb24gaGVyIGV4cGVyaWVuY2Ugd2l0aCB0aGUgTUFMLCBFbWVyc29uIHJlY2VudGx5IHRlYW1lZCB1cCB3aXRoIGZlbGxvdyByZXNlYXJjaGVycyBEYXJyZW4gV2Vyc2hsZXIgYW5kIEp1c3NpIFBhcmlra2EgdG8gYnJpbmcgdG9nZXRoZXIgd2hhdCB0aGV5IGFsbCBrbm93IGFib3V0IHRoZSB0aGluZyB3ZSBjYWxsIFx1MjAxOG1lZGlhIGxhYnNcdTIwMTkgaW4gPC9zcGFuPjxhIGhyZWY9XCJodHRwczovL21hbmlmb2xkLnVtbi5lZHUvcHJvamVjdHMvdGhlLWxhYi1ib29rXCI+PGk+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlRIRSBMQUIgQk9PSzwvc3Bhbj48L2k+PC9hPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj4sIG91dCBpbiBlYXJseSAyMDIxLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNJIHdhcyByZWFsbHkga2VlbiBvbiBnaXZpbmcgYSBsb25nIGhpc3Rvcnkgb2YgbWVkaWEgbGFicyAtIHNvIHRoYXQgd2UgYXJlblx1MjAxOXQgY29udGludWFsbHkgbGl2aW5nIGluIHRoaXMgcHJlc2VudCBtb21lbnQsIG92ZXIgYW5kIG92ZXIgYWdhaW4sIHdoZXJlIHBlb3BsZSBhcmUgbGlrZSBcdTIwMThJXHUyMDE5bSBnb2luZyB0byBzdGFydCBhIGxhYiFcdTIwMTkuIEkgdGhpbmsgdGhleSBtYXR0ZXIgYXMgYSBzdWJqZWN0IGFyZWEgLSByZWFsbHkgdG8gdHJ5IHRvIHRyYWNrIGhvdyBwZW9wbGUgYXJlIGFwcHJvcHJpYXRpbmcgdGhlIHRlcm0gLSA8L3NwYW4+PGk+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPnNvbWV0aW1lcyBmb3IgZ29vZCBhbmQgc29tZXRpbWVzIGZvciBpbGw8L3NwYW4+PC9pPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj4uPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY0FzIHdlIGZvdW5kIG91dCAtIGEgbGFiIGNhbiBiZSBhYnNvbHV0ZWx5IGFueXRoaW5nLiBXZSBjYW1lIHVwIHdpdGggZXhhbXBsZXMgb2YgY29tcGFuaWVzIGNhbGxpbmcgYSBsaW5lIG9mIGdyb29taW5nIHByb2R1Y3RzIFx1MjAxOGxhYnNcdTIwMTksIGZhc2hpb24gZGlzcGxheXMgaW4gZGVwYXJ0bWVudCBzdG9yZXMgLSBcdTIwMThhIGxhYlx1MjAxOS4gSSBoYXZlIGEgY29sbGVhZ3VlIHdobyB3YXMgdGhpbmtpbmcgYWJvdXQgZ2V0dGluZyBhIGdyb3VwIG9mIHBlb3BsZSB0b2dldGhlciB0byByZWFkIC0gc2hlIHdhbnRlZCB0byBjYWxsIGl0IGEgXHUyMDE4bGFiXHUyMDE5Llx1MjAxZDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5XaGF0IEVtZXJzb24gYW5kIGhlciBmZWxsb3cgYXV0aG9ycyB0cmllZCB0byBkbywgZGV0YWlsZWQgb24gdGhlaXIgPC9zcGFuPjxhIGhyZWY9XCJodHRwOi8vd2hhdGlzYW1lZGlhbGFiLmNvbS9cIj48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+V2hhdCBJcyBBIE1lZGlhIExhYiB3ZWJzaXRlPC9zcGFuPjwvYT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+LCB3YXMgdW5kZXJzdGFuZCB3aHkgcGVvcGxlIG9mdGVuIGFuZCBjb250aW51YWxseSB3YW50IHRvIHVzZSB0aGlzIHdvcmQuXHUwMGEwPC9zcGFuPlxyXG48aDM+V2h5ICdtZWRpYSBsYWInPzwvaDM+XHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNUaGVyZVx1MjAxOXMgcGxlbnR5IG9mIGV4YW1wbGVzIG9mIFx1MjAxOGFudGktbGFiXHUyMDE5IGxhYnMgYW5kIHRoZXJlIGFyZSBhbHNvIHBsZW50eSBvZiBleGFtcGxlcyBvZiBsYWJzIHRoYXQgYXBwZWFyIHRvIGJlIHB1cmVseSBhcHByb3ByaWF0aW5nIHRoZSBpZGVhIHRvIGxlZ2l0aW1pc2Ugd2hhdCB0aGV5XHUyMDE5cmUgdHJ5aW5nIHRvIGRvLCBieSBhZGRpbmcgYSB2ZW5lZXIgb2Ygc2NpZW50aWZpY2l0eS48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjV2UgaGF2ZSBhIGZpbmFsIGNoYXB0ZXIgY2FsbGVkIFx1MjAxOHRlY2huaXF1ZXNcdTIwMTkgd2hlcmUgd2Ugd2VyZSB0cnlpbmcgdG8gY2F0YWxvZ3VlIGtleSB0ZWNobmlxdWVzIHRoYXQgcGVvcGxlIHNlZW0gdG8gYmUgdXNpbmcgaW4gbWVkaWEgbGFicyBhbmQgZ2l2aW5nIHBlb3BsZSB0aGUgY3JpdGljYWwgYXBwYXJhdHVzIHRvIHRoaW5rIGFib3V0IC0gXHUyMDE4d2h5IGFyZSB5b3Ugb2JzZXNzZWQgd2l0aCBmYWJyaWNhdGluZyBvciAzRCBwcmludGluZz8gQXJlIHlvdSB0aGlua2luZyBhYm91dCB0aGUgbGFyZ2VyIGNpcmN1bXN0YW5jZSBhYm91dCB0aGUgc3BhY2UgdGhhdCBpdCB0YWtlcyBwbGFjZSBpbj9cdTIwMTkuXHUyMDFkPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY0VuIHJvdXRlIHRvIHByb3ZpZGluZyB0aGUgbG9uZ2VyIGhpc3RvcnksIHlvdSBzdGFydCB0byBzZWUgaG93IHRoZXJlIGhhdmUgYmVlbiBzb21lIHByb2JsZW1hdGljIG1hbmFnZXJpYWwgdGVjaG5pcXVlcyBpbnZvbHZlZCBpbiB0aGUgcnVubmluZyBvZiBzb21lIGxhYnMuIFRoYXQgbWF5YmUgcGVvcGxlIGRvblx1MjAxOXQga25vdyBhYm91dCBvciB0aGV5IGhhdmVuXHUyMDE5dCB0aG91Z2h0IGFib3V0Llx1MjAxZDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5BbmQsIGFzIGl0IGhhcHBlbnMsIHRoZXkgY2hhcnRlZCB0aGUgcHJvYmxlbSByaWdodCBiYWNrIHRvIHRoZSAxOXRoIGNlbnR1cnkgbGFiIG9mIFRob21hcyBFZGlzb24sIHRoZSBub3ctd29ybGQtZmFtb3VzIGJyYW5kLCA8L3NwYW4+PGEgaHJlZj1cImh0dHBzOi8vd3d3Lm1lbmxvcGFya211c2V1bS5vcmcvaGlzdG9yeVwiPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5NZW5sbyBQYXJrPC9zcGFuPjwvYT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+Ljwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNBIGxvdCBvZiB0aGVzZSBsYWJzIGhhdmUgYSBkaXNjb25uZWN0IGJldHdlZW4gaG93IHRoZXkgbWFya2V0IHRoZW1zZWx2ZXMsIGhvdyB0aGV5IHRhbGsgYWJvdXQgdGhlbXNlbHZlcywgaG93IHRoZXkgYXBwZWFyLCBvciB0cnkgdG8gYXBwZWFyLCB0byB0aGUgcHVibGljIC0gYW5kIHdoYXQgYWN0dWFsbHkgZ29lcyBvbi4gU28gdGhlcmVcdTIwMTlzIGEgbG90IG9mIHRhbGsgYWJvdXQgXHUyMDE4aW5ub3ZhdGlvblx1MjAxOSwgXHUyMDE4ZmxleGliaWxpdHlcdTIwMTksIFx1MjAxOGNvbGxhYm9yYXRpb25cdTIwMTksIFx1MjAxOGludGVyZGlzY2lwbGluYXJpdHlcdTIwMTkgb3IgXHUyMDE4PC9zcGFuPjxpPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5hbnRpLWRpc2NpcGxpbmFyaXR5PC9zcGFuPjwvaT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDE5LiA8L3NwYW4+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlxyXG48L3NwYW4+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlxyXG48L3NwYW4+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY1NvbWVob3cgYSBsb3Qgb2YgdGhhdCByaGV0b3JpYyBnZXRzIGZlZCBpbnRvIHRoZSBzcGFjZSBpdHNlbGYsIGFuZCBqdXN0IGVuZHMgdXAgY3JlYXRpbmcgbW9yZSBvZiB0aGUgc2FtZSwgYW5kIGFjdHVhbGx5IGNyZWF0aW5nIHByb2JsZW1hdGljIGhpZXJhcmNoaWVzLiBPciBcdTIwMThpbm5vdmF0aXZlIG5ldyB0ZWNobm9sb2dpZXNcdTIwMTkgdGhhdCBsYWNrIGEgcG9saXRpY3MsIG9yIGxhY2sgdW5kZXJzdGFuZGluZyBvZiBob3cgdGhlIHRlY2hub2xvZ3kgcmVsYXRlcyB0byBwZW9wbGUgYW5kIHRoZSB3b3JsZC5cdTIwMWQ8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+UmVmbGVjdGluZyBvbiB0aGUgQ09WSUQtMTkgcGFuZGVtaWMsIHdpdGggdGhlIE1BTCBoYXZpbmcgdG8gZ2V0IGJ5IG9ubGluZSwgc2hlIGFkZHM6IFx1MjAxY0lmIEkgaGFkIHRvIGdlbmVyYWxpc2UgYWJvdXQgbGFicywgSSB3b3VsZCBzYXksIGxhYnMgYXJlIGFsbCBhYm91dCBoYW5kcy1vbiB3b3JrLCBzbyBpZiB5b3UgY2FuXHUyMDE5dCBkbyB0aGUgaGFuZHMtb24gd29yaywgeW91IHJlYWxseSBjYW5cdTIwMTl0IGJlIGluIHRoZSBsYWIsIHlvdSBjYW5cdTIwMTl0IGRvIGxhYiB3b3JrIGF0IGFsbC5cdTIwMWQ8L3NwYW4+XHJcblxyXG5bY2FwdGlvbiBpZD1cImF0dGFjaG1lbnRfMTU0MDlcIiBhbGlnbj1cImFsaWdubm9uZVwiIHdpZHRoPVwiMzAwXCJdPGltZyBjbGFzcz1cInNpemUtbWVkaXVtIHdwLWltYWdlLTE1NDA5XCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMjAvMDYvU2NyZWVuLVNob3QtMjAyMC0wNi0wMy1hdC0wOS4yOC4zNS0zMDB4MTY4LnBuZ1wiIGFsdD1cIlwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMTY4XCIgLz4gTUFMWy9jYXB0aW9uXVxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkVtZXJzb25cdTIwMTlzIExhYiwgYXMgb3Bwb3NlZCB0byBFZGlzb25cdTIwMTlzLCBhcyBpdHMgbmFtZSBzdWdnZXN0cywgaXMgYWxzbyBhc3NvY2lhdGVkIHdpdGggdGhlIHJlc2VhcmNoIGZpZWxkIG9mIG1lZGlhIGFyY2hhZW9sb2d5Ljwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNHZW5lcmFsbHkgc3BlYWtpbmcsIGl0XHUyMDE5cyBpbnRlcmVzdGVkIGluIGdldHRpbmcgYXQgdGhlIGxpZmUsIGV2ZW4gdGhlIFx1MjAxOGNvbnNjaW91c25lc3NcdTIwMTkgb2YgbWVkaWEgLSB0cnlpbmcgdG8gY3V0IG91dCBodW1hbiBwZXJzcGVjdGl2ZSB0byB1bmRlcnN0YW5kIHRoZSBsaWZlIG9mIHRoZSBtYWNoaW5lLiBBbmQgdGhlbiB1bmRlcnN0YW5kIGhvdyB0aGUgbGlmZSBvZiB0aGUgbWFjaGluZSBkZXRlcm1pbmVzIHdoYXQgYW5kIGhvdyB5b3VcdTIwMTlyZSBhYmxlIHRvIGNyZWF0ZS5cdTAwYTA8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjVGhlIG90aGVyIGJyYW5jaCBvZiBtZWRpYSBhcmNoYWVvbG9neSBpcyBpbnRlcmVzdGVkIGluIHB1cnN1aW5nIGRlYWQgZW5kcyBpbiB0ZWNobm9sb2dpY2FsIGRldmVsb3BtZW50IC0gc28gdGhlcmVcdTIwMTlzIGEgcGFydCBvZiBpdCB0aGF0XHUyMDE5cyBpbnRlcmVzdGVkIGluIHRoZSByZWFsbSBvZiB0aGUgaW1hZ2luYXRpb24gLSBcdTIwMThob3cgd291bGQgaGF2ZSB0aGluZ3MgYmVlbiBkaWZmZXJlbnQgaWYgd2UgaGFkIHB1cnN1ZWQgdGhpcyBsaXR0bGUgYnJhbmNoIG9mZiB0aGUgbWFpbiBsaW5lPyBPciBob3cgY291bGQgdGhpbmdzIDwvc3Bhbj48aT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+c3RpbGwgPC9zcGFuPjwvaT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+YmUgZGlmZmVyZW50P1x1MjAxOS5cdTIwMWQ8L3NwYW4+XHJcbjxoMz5DaGFuZ2luZyB0aGUgY3JpdGVyaWEgZm9yIGlubm92YXRpb248L2gzPlxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+RW1lcnNvbiBpcyB3cml0aW5nIGFub3RoZXIgYm9vayBvbiB0aGlzIHRoZW1lLCB0aXRsZWQgPC9zcGFuPjxhIGhyZWY9XCJodHRwczovL2xvcmllbWVyc29uLm5ldC9jYXRlZ29yeS9vdGhlci1uZXR3b3Jrcy9cIj48aT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+T3RoZXIgTmV0d29ya3M8L3NwYW4+PC9pPjwvYT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+LiBcdTIwMWNJdFx1MjAxOXMgc29tZXRoaW5nIEkgYnJpbmcgaW50byB0aGUgY2xhc3Nyb29tIGFuZCB0cnkgdG8gZXhwbG9yZSAtIG90aGVyIGNvbmZpZ3VyYXRpb25zIGFuZCBuZXR3b3JrcyB0aGF0IGV4aXN0ZWQgYmVmb3JlIHRoZSBpbnRlcm5ldCBiZWNhbWUgd2hhdCBpdCBpcyAtIEkgdHJ5IHRvIGdldCBzdHVkZW50cyB0byByZWltYWdpbmUgaG93IHRoaW5ncyBjb3VsZCBiZSBkaWZmZXJlbnQuIFx1MjAxOFdoYXQgd291bGQgYSBkaWZmZXJlbnQgaW50ZXJuZXQgbG9vayBsaWtlP1x1MjAxOS5cdTAwYTA8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+T25lIHJlYWwgZXhhbXBsZSBzaGUgZGVzY3JpYmVzIGFyZSBidWxsZXRpbiBib2FyZCBzeXN0ZW1zIHRoYXQgd2VyZSBhcm91bmQgaW4gdGhlIDE5ODBzIGFuZCB0aGUgZWFybHkgMTk5MHMsIG1hZGUgdXAgb2YganVzdCBhIGZldyBodW5kcmVkIHBlb3BsZSBpbiBhIHNtYWxsIGFyZWEgd2hvIHdhbnRlZCB0byBzaGFyZSAtIGFuZCBhdm9pZCBsb25nLWRpc3RhbmNlIGNhbGwgY2hhcmdlcy48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjV2hpY2ggSSB0aGluayBwcm9kdWNlcyBzb21ldGhpbmcgcXVpdGUgd29uZGVyZnVsIGFuZCBub3QgY29tbWVyY2lhbCwgYW5kIG11Y2ggbW9yZSBvcmllbnRlZCB0b3dhcmRzIGNvbW11bml0eS4gSW50ZXJlc3RpbmdseSBlbm91Z2gsIHRoZSBvbmxpbmUgaW50ZXJhY3Rpb25zIGxlZCB0byBpbi1wZXJzb24gaW50ZXJhY3Rpb25zLCB3aGljaCBJIHRoaW5rIGlzIHF1aXRlIGRpZmZlcmVudCBmcm9tIHdoYXQgd2UgaGF2ZSBub3dhZGF5cy5cdTAwYTA8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjVGhhdFx1MjAxOXMgc29tZXRoaW5nIElcdTIwMTl2ZSBiZWVuIHRyeWluZyB0byBnZXQgbXkgc3R1ZGVudHMgdG8gdGhpbmsgYWJvdXQgLSBcdTIwMTh3aGF0IGlmIHdlIGNoYW5nZSBvdXIgY3JpdGVyaWEgZm9yIHRlY2hub2xvZ2ljYWwgcHJvZ3Jlc3Mgb3IgZGV2ZWxvcG1lbnQgb3IgaW5ub3ZhdGlvbj8gQW5kIHdlXHUyMDE5cmUgbm90IGp1c3Qgb2JzZXNzZWQgd2l0aCBzcGVlZCBhbmQgZWZmaWNpZW5jeSBhbmQgaGF2aW5nIHRoaW5ncyByaWdodCBub3c/XHUyMDE5Ljwvc3Bhbj5cclxuXHJcbltjYXB0aW9uIGlkPVwiYXR0YWNobWVudF8xNTQxNFwiIGFsaWduPVwiYWxpZ25ub25lXCIgd2lkdGg9XCIzMDBcIl08aW1nIGNsYXNzPVwic2l6ZS1tZWRpdW0gd3AtaW1hZ2UtMTU0MTRcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAyMC8wNi9TY3JlZW4tU2hvdC0yMDIwLTA2LTAzLWF0LTEyLjAzLjE5LTMwMHgxNzEucG5nXCIgYWx0PVwiXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIxNzFcIiAvPiBNQUxbL2NhcHRpb25dXHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjXHUyMDE4V2hhdCBpZiB3ZSBjaGFuZ2UgdGhlIGNyaXRlcmlhIGFuZCBtb3ZlIHRvd2FyZHMgc29tZXRoaW5nIHRoYXRcdTIwMTlzIHNsb3dlciwgbW9yZSBtZXRob2RpY2FsIGFuZCBtb3JlIGNvb3BlcmF0aXZlbHkgbWluZGVkIC0gc28gdGhhdCB3ZSBhY3R1YWxseSBvd24gdGhlIG5ldHdvcmsgaW5mcmFzdHJ1Y3R1cmUsIHJhdGhlciB0aGFuIGhhdmluZyBhIG1ham9yIGNvbmdsb21lcmF0aW9uIG93biBpdD9cdTIwMTkuXHUyMDFkPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkFza2VkIGlmIGhlciBzdHVkZW50cyBsaWtlIHRoZSBpZGVhLCBzaGUgc2F5cyB0aGV5IFx1MjAxY2xvdmUgaXQsIGluIHByaW5jaXBsZVx1MjAxZC4gQnV0IHRoZXlcdTIwMTlyZSBhcyBib3VuZCB1cCBpbiB0aGUgc3BlZWQgb2YgdGhpbmdzIGFzIGFueW9uZSBlbHNlLCBrZWVuIHRvIGdldCB0aGluZ3MgZG9uZSBhbmQgZ2V0IGEgam9iLjwvc3Bhbj5cclxuPGgzPkJleW9uZCBtYW48L2gzPlxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjT25lIGRyYXdiYWNrIHRvIHRoZSB3YXkgdGhlIGh1bWFuaXRpZXMgaGF2ZSB0aG91Z2h0IGFib3V0IHRoZW1zZWx2ZXMgaGFzIGJlZW4gdGhlIHRvdGFsaXNpbmcgcHVzaCB0byBhbHdheXMgcHV0IHRoZSBodW1hbiBmcm9udCBhbmQgY2VudHJlIC0gYWJvdmUgYW5kIGJleW9uZCB0aGUgZW52aXJvbm1lbnQsIG5vbmh1bWFuIGFuaW1hbHMsIGFsbCBzb3J0cyBvZiB0aGluZ3MgLSBhbmQgb2YgY291cnNlIHRoaXMgbm90aW9uIG9mIGh1bWFuIGlzIGFsc28gYWx3YXlzIGFsbW9zdCBcdTIwMTh3aGl0ZSBtYWxlXHUyMDE5Llx1MDBhMDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNTbyBhbnl0aGluZyB0aGF0IHVuc2V0dGxlcyB0aGF0IHBlcnNwZWN0aXZlLCB3aGljaCBtZWRpYSBhcmNoYWVvbG9neSB0cmllcyB0byBkbywgSSB0aGluayBpcyBhYnNvbHV0ZWx5IHdvcnRod2hpbGUuIEFuZCwgeW91IGtub3csIHdlXHUyMDE5cmUgc3RhcmluZyBkb3duIHRoZSBiYXJyZWwgb2YgYW4gYXBvY2FseXBzZSBhbmQgSSBkb25cdTIwMTl0IHRoaW5rIHRoYXQgeWV0IG1vcmUgaHVtYW5pc20gaXMgZ29pbmcgdG8gaGVscCB1cyB3aXRoIHRoYXQgcHJvYmxlbS48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjU28gbWVkaWEgYXJjaGFlb2xvZ3kgYW5kIGl0cyBtZXRob2Qgb2YgdHJ5aW5nIHRvIGdldCBvdXRzaWRlIG9mIHRoZSBodW1hbiBJIHRoaW5rIGlzIHJlYWxseSBpbXBvcnRhbnQgYW5kIGNhbiBiZSByZWFsbHkgZWZmZWN0aXZlLlx1MjAxZDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5CdXQgc2hlIGFkbWl0cyBpdCBoYXMgaXRzIHByb2JsZW1zLiBcdTIwMWNJIHRoaW5rIGl0IGNhbiBhbHNvIGJlIHJlYWxseSBwcm9ibGVtYXRpYyBpZiBwZW9wbGUgYXR0ZW1wdCB0byBiZWxpZXZlIHRoYXRcdTIwMTlzIHBvc3NpYmxlIC0gSSBkb25cdTIwMTl0IHRoaW5rIGl0XHUyMDE5cyBwb3NzaWJsZSB0byBnZXQgb3V0c2lkZSBvZiB5b3VyIGh1bWFuIHBlcnNwZWN0aXZlLlx1MDBhMDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNBbm90aGVyLCByZWxhdGVkIHByb2JsZW0sIHdpdGggbWVkaWEgYXJjaGFlb2xvZ3kgaXMgdGhhdCBpdCBjYW4gYmUgdmVyeSwgZGVlcGx5IGFwb2xpdGljYWwgLSBpdCB0YWtlcyBpdHMgaW50ZXJlc3QgaW4gaGFyZHdhcmUgc28gc2VyaW91c2x5IHRoYXQgaXQgY2FuIGNvbXBsZXRlbHkgbmVnbGVjdCB0aGUgcG9saXRpY3Mgb2YgaHVtYW5zIGdvaW5nIG9uIGFsbCBhcm91bmQgdGhlbSAtIGFuZCwgYWdhaW4sIG5lZ2xlY3RzIHBvd2VyIGFuZCB0aGUgZmFjdCB0aGlzIHdoaXRlIG1hbGUgcGVyc3BlY3RpdmUgZG9taW5hdGVzIGV2ZXJ5dGhpbmcuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY1lvdVx1MjAxOWxsIG5vdGljZSB3aGVuIGRvaW5nIHJlc2VhcmNoIGluIG1lZGlhIGFyY2hhZW9sb2d5IHRoZXJlIGFyZSBoYXJkbHkgYW55IHdvbWVuIG1lbnRpb25lZCAtIGFzIGl0IHR1cm5zIG91dCwgdGhlcmUgYXJlIGxvdHMgb2Ygd29tZW4gZG9pbmcgbWVkaWEgYXJjaGFlb2xvZ3ktbGlrZSB3b3JrIC0gYnV0IGEgY29tYmluYXRpb24gb2YgdGhlIHdheSBwZW9wbGUgYXJlIGRlZmluaW5nIG1lZGlhIGFyY2hhZW9sb2d5LCBhbmQgdGhlaXIgb3duIGJsaW5kc3BvdHMgYWJvdXQgdGhlIHBlb3BsZSB3aG8gdGhleSB0ZW5kIHRvIGZvY3VzLCB3aGljaCBhcmUgdGhlIHdoaXRlLCBtYWxlIEdlcm1hbiB0aGVvcmlzdHMsIGV4Y2x1ZGUgYWxsIG9mIHRob3NlIHdvbWVuLlwiPC9zcGFuPlxyXG5cclxuW2NhcHRpb24gaWQ9XCJhdHRhY2htZW50XzE1NDE4XCIgYWxpZ249XCJhbGlnbm5vbmVcIiB3aWR0aD1cIjMwMFwiXTxpbWcgY2xhc3M9XCJzaXplLW1lZGl1bSB3cC1pbWFnZS0xNTQxOFwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIwLzA2L1NjcmVlbi1TaG90LTIwMjAtMDYtMDMtYXQtMTIuMTMuMTgtMzAweDE3MC5wbmdcIiBhbHQ9XCJcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjE3MFwiIC8+IE1BTDogc2NhdmVuZ2VyIGh1bnQgZXZlbnQgZm9yIHRlZW5zIGludm9sdmVkIGluIHRoZSBDVSBTY2llbmNlIERpc2NvdmVyeSBwcm9ncmFtWy9jYXB0aW9uXVxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkVtZXJzb24gc2F5cyBzaGVcdTIwMTlzIGJlZW4gbHVja3kgdG8gY2FydmUgb3V0IGEgc3BhY2UgaW4gaGVyIGluc3RpdHV0aW9uIHRvIGRvIGhlciB3b3JrLiBcdTIwMWNQZW9wbGUgZGlkblx1MjAxOXQgcmVhbGx5IHJlYWxpc2Ugd2hhdCB3ZSB3ZXJlIGRvaW5nIHVudGlsIHRoZSBNQUwgYmVjYW1lIGVzdGFibGlzaGVkLlx1MjAxZCBUaGUgbGFiIGhhcyBhIGxvbmdzdGFuZGluZyBzdXBwb3J0ZXIgaW4gdGhlIHNoYXBlIG9mIGEgbG9jYWwgdmVudHVyZSBjYXBpdGFsaXN0IGFuZCBnZXRzIHNvbWUgdW5pdmVyc2l0eSBmdW5kaW5nIC0gYnV0IHNoZSBiZWxpZXZlcyBpdHMgdW51c3VhbCBzdHlsZSBtZWFucyBtb25leSBpc25cdTIwMTl0IGFsd2F5cyBmb3J0aGNvbWluZy48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjSXQgZG9lcyBzZWVtIGxpa2UsIHRoZSBiaWdnZXIgeW91ciBidWRnZXQgdGhlIG1vcmUgZnJlZWRvbSB5b3UgaGF2ZSB0byBpbm5vdmF0ZSBpbiBhIG1vcmUgb3Blbi1lbmRlZCB3YXkgLSBidXQgdGhlbiB0aGUgcHJvYmxlbSBpcyAtIHRyeWluZyB0byBmaWd1cmUgb3V0IHdoZXJlIHRoZSBtb25leSBjb21lcyBmcm9tLiBJXHUyMDE5bSBqdXN0IGd1ZXNzaW5nIHRoZXJlXHUyMDE5cyBubyB3YXkgdG8gaGF2ZSBhIGJ1ZGdldCB0aGF0IGJpZyBhbmQgbWFrZSBzdXJlIHRoYXQgYWxsIG9mIHlvdXIgZnVuZGluZyBpcyBldGhpY2FsbHkgc291cmNlZC5cdTIwMWQ8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+WW91IGNhbiBleHBsb3JlIHRoZSBNZWRpYSBBcmNoYWVvbG9neSBMYWIgPC9zcGFuPjxhIGhyZWY9XCJodHRwczovL21lZGlhYXJjaGFlb2xvZ3lsYWIuY29tL1wiPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5oZXJlPC9zcGFuPjwvYT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+Ljwvc3Bhbj5cclxuPGRpdiBjbGFzcz1cIndwYl9jb2x1bW4gdmNfY29sdW1uX2NvbnRhaW5lciB2Y19jb2wtc20tOFwiPlxyXG48ZGl2IGNsYXNzPVwidmNfY29sdW1uLWlubmVyIFwiPlxyXG48ZGl2IGNsYXNzPVwid3BiX3dyYXBwZXJcIj5cclxuPGRpdiBjbGFzcz1cImtsZW9fdGV4dF9jb2x1bW4gd3BiX2NvbnRlbnRfZWxlbWVudCBcIj5cclxuPGRpdiBjbGFzcz1cIndwYl93cmFwcGVyXCI+XHJcblxyXG5DT05UQUNUXHJcblxyXG48aW1nIGNsYXNzPVwiYWxpZ25ub25lIHNpemUtbWVkaXVtIHdwLWltYWdlLTE1NDI5XCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMjAvMDYvSU1HXzY3NDYtMzAweDIyNS5qcGdcIiBhbHQ9XCJcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjIyNVwiIC8+XHJcblxyXG5Mb3JpIEVtZXJzb24sIGZvdW5kaW5nIGRpcmVjdG9yIG9mIHRoZSBNZWRpYSBBcmNoYWVvbG9neSBMYWIgYXQgdGhlIFVuaXZlcnNpdHkgb2YgQ29sb3JhZG9cclxuXHJcblR3aXR0ZXI6IDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2xvcmllbWVyc29uXCI+QGxvcmllbWVyc29uPC9hPiA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9tZWRpYXJjaGFlb2xvZ3lcIj5AbWVkaWFyY2hhZW9sb2d5PC9hPi5cclxuXHJcbjwvZGl2PlxyXG48L2Rpdj5cclxuPC9kaXY+XHJcbjwvZGl2PlxyXG48L2Rpdj5cclxuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS80XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddIiwicG9zdF90aXRsZSI6IlRoZSBNZWRpYSBBcmNoYWVvbG9neSBMYWI6IGxldHRpbmcgcGVvcGxlIGRpc2NvdmVyIGRpZmZlcmVudCBwb3NzaWJpbGl0aWVzIGZvciBpbm5vdmF0aW9uIiwicG9zdF9saW5rIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL3RoZS1tZWRpYS1hcmNoYWVvbG9neS1sYWItbGV0dGluZy1wZW9wbGUtZGlzY292ZXItZGlmZmVyZW50LXBvc3NpYmlsaXRpZXMtZm9yLWlubm92YXRpb24vIiwicG9zdF9mZWF0dXJlZF9pbWFnZSI6IjxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiVGhlIE1lZGlhIEFyY2hhZW9sb2d5IExhYjogbGV0dGluZyBwZW9wbGUgZGlzY292ZXIgZGlmZmVyZW50IHBvc3NpYmlsaXRpZXMgZm9yIGlubm92YXRpb25cIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjE2N1wiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIwLzA2L01lZGlhLUFyY2hhZW9sb2d5LUxhYi0zMDB4MTY3LmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6Ik1lZGlhIGxhYnMsIFJlc2VhcmNoIHByb2plY3RzIiwicG9zdF90YWdzIjoiQm91bGRlciwgQ29sb3JhZG8sIEZlbWluaXN0IGxhYiwgTG9yaSBFbWVyc29uLCBNZWRpYSBhcmNoYWVvbG9neSwgTWVkaWEgQXJjaGFlb2xvZ3kgTGFiLCBtZWRpYSB0ZWNobm9sb2d5LCBUSEUgTEFCIEJPT0ssIFVuaXZlcnNpdHksIFVuaXZlcnNpdHkgb2YgQ29sb3JhZG8iLCIlX2VkaXRfbG9jayUiOiIxNjEyMjA5MjgxOjEiLCIlX2VkaXRfbGFzdCUiOiI5MzMiLCIlc2xpZGVfdGVtcGxhdGUlIjoiZGVmYXVsdCIsIiVfd3BiX3ZjX2pzX3N0YXR1cyUiOiJ0cnVlIiwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6IjEzMjAgR3JhbmR2aWV3IEF2ZSwgQm91bGRlciwgQ08gODAzMDIsIFVTQSIsIiVfd3BnbXBfbG9jYXRpb25fY2l0eSUiOiJCb3VsZGVyIiwiJV93cGdtcF9sb2NhdGlvbl9zdGF0ZSUiOiJDb2xvcmFkbyIsIiVfd3BnbXBfbG9jYXRpb25fY291bnRyeSUiOiJVbml0ZWQgU3RhdGVzIiwiJV93cGdtcF9tZXRhYm94X2xhdGl0dWRlJSI6IjQwLjAxMTMzMDMiLCIlX3dwZ21wX21ldGFib3hfbG9uZ2l0dWRlJSI6Ii0xMDUuMjc1NDY5MiIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiMlwiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6Ik47IiwiJV93cGdtcF9tZXRhYm94X3RheG9tb21pZXNfdGVybXMlIjoiTjsiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6Ik47IiwiJV9rbGVvX3RyYW5zcGFyZW50X21lbnVfY29sb3IlIjoid2hpdGUiLCIlX2tsZW9fdGl0bGVfY29sb3IlIjoiIyIsIiVfa2xlb190aXRsZV9iZyUiOiIsIHJlcGVhdCwgaW5oZXJpdCwgc2Nyb2xsLCBsZWZ0IHRvcCIsIiVfa2xlb190aXRsZV9iZ19jb2xvciUiOiIjIiwiJV95b2FzdF93cHNlb19jb250ZW50X3Njb3JlJSI6IjMwIiwiJV95b2FzdF93cHNlb19wcmltYXJ5X2NhdGVnb3J5JSI6IjE0MiIsIiVfdGh1bWJuYWlsX2lkJSI6IjE1NDI2IiwiJV9rbGVvX3RpdGxlX2NoZWNrYm94JSI6IjEiLCIlc2JnX3NlbGVjdGVkX3NpZGViYXIlIjoiMCIsIiVzYmdfc2VsZWN0ZWRfc2lkZWJhcl9yZXBsYWNlbWVudCUiOiIwIiwidGF4b25vbXk9Y2F0ZWdvcnkiOiJNZWRpYSBsYWJzLCBSZXNlYXJjaCBwcm9qZWN0cyIsInRheG9ub215PXBvc3RfdGFnIjoiQm91bGRlciwgQ29sb3JhZG8sIEZlbWluaXN0IGxhYiwgTG9yaSBFbWVyc29uLCBNZWRpYSBhcmNoYWVvbG9neSwgTWVkaWEgQXJjaGFlb2xvZ3kgTGFiLCBtZWRpYSB0ZWNobm9sb2d5LCBUSEUgTEFCIEJPT0ssIFVuaXZlcnNpdHksIFVuaXZlcnNpdHkgb2YgQ29sb3JhZG8ifSwiaWNvbiI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE4LzAyL21hcmtlci0xLnBuZyJ9LCJpZCI6MTU0MDYsImluZm93aW5kb3dfZGlzYWJsZSI6ZmFsc2V9LHsic291cmNlIjoicG9zdCIsInRpdGxlIjoiVlJUIFNhbmRib3g6IGxlYWRpbmcgdGhlIHdheSBvbiBzdGFydHVwIGFuZCBtZWRpYSBjb2xsYWJvcmF0aW9uIGluIEV1cm9wZSIsImluZm93aW5kb3dfY29udGVudCI6IjxkaXYgY2xhc3M9XCJmYy1pdGVtLWJveCBmYy1pdGVtLW5vLXBhZGRpbmdcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiVlJUIFNhbmRib3g6IGxlYWRpbmcgdGhlIHdheSBvbiBzdGFydHVwIGFuZCBtZWRpYSBjb2xsYWJvcmF0aW9uIGluIEV1cm9wZVwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMTY3XCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMjAvMDUvVlJULVNhbmRib3gtMzAweDE2Ny5wbmdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1wYWRkaW5nLWNvbnRlbnRfMjBcIj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1tZXRhIGZjLWl0ZW0tc2Vjb25kYXJ5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2UgZmMtdGV4dC1jZW50ZXJcIj5NZWRpYSBsYWJzPC9kaXY+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tdGl0bGUgZmMtaXRlbS1wcmltYXJ5LXRleHQtY29sb3IgZmMtdGV4dC1jZW50ZXJcIj5WUlQgU2FuZGJveDogbGVhZGluZyB0aGUgd2F5IG9uIHN0YXJ0dXAgYW5kIG1lZGlhIGNvbGxhYm9yYXRpb24gaW4gRXVyb3BlPC9kaXY+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tY29udGVudCBmYy1pdGVtLWJvZHktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZVwiPlxyXG4gICAgICAgICAgICBWUlQgaXMgdGhlIHB1YmxpYy1zZXJ2aWNlIGJyb2FkY2FzdGVyIGZvciBCZWxnaXVtJ3MgRmxlbWlzaCBjb21tdW5pdHkgLSBidXQgaXQgYWxzbyB3ZWxjb21lcyBzdGFydHVwcyBhbmQgc2NhbGV1cHMgdGhyb3VnaCBpdHMgZG9vcnMgd2l0aCB0aGUgcHJvbWlzZSBvZiBleHBlcmllbmNlLCBleHBvc3VyZSBhbmQgZXZlbiwgcGVyaGFwcywgYmVjb21pbmcgYW4gaW50ZXJuYXRpb25hbCBleHBvcnRcclxuICAgICAgICA8L2Rpdj5cclxuPGEgaHJlZj1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi92cnQtc2FuZGJveC1sZWFkaW5nLXRoZS13YXktb24tc3RhcnR1cC1hbmQtbWVkaWEtY29sbGFib3JhdGlvbi1pbi1ldXJvcGUvXCI+UmVhZCBtb3JlPC9hPlxyXG4gICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuPC9kaXY+XHJcblxyXG4iLCJjb250ZW50IjoiVlJUIGlzIHRoZSBwdWJsaWMtc2VydmljZSBicm9hZGNhc3RlciBmb3IgQmVsZ2l1bSdzIEZsZW1pc2ggY29tbXVuaXR5IC0gYnV0IGl0IGFsc28gd2VsY29tZXMgc3RhcnR1cHMgYW5kIHNjYWxldXBzIHRocm91Z2ggaXRzIGRvb3JzIHdpdGggdGhlIHByb21pc2Ugb2YgZXhwZXJpZW5jZSwgZXhwb3N1cmUgYW5kIGV2ZW4sIHBlcmhhcHMsIGJlY29taW5nIGFuIGludGVybmF0aW9uYWwgZXhwb3J0IiwiYWRkcmVzcyI6IkF1Z3VzdGUgUmV5ZXJzbGFhbiA1MiBCLCAxMDQzIFNjaGFhcmJlZWssIEJlbGdpdW0iLCJsb2NhdGlvbiI6eyJsYXQiOiI1MC44NTI3Mzc5IiwiY2l0eSI6IlNjaGFhcmJlZWsiLCJzdGF0ZSI6IkJydXNzZWxzIEhvb2Zkc3RlZGVsaWprIEdld2VzdCIsImNvdW50cnkiOiJCZWxnaXVtIiwibG5nIjoiNC40MDIzMzExIiwib25jbGlja19hY3Rpb24iOiJtYXJrZXIiLCJyZWRpcmVjdF9wZXJtYWxpbmsiOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvdnJ0LXNhbmRib3gtbGVhZGluZy10aGUtd2F5LW9uLXN0YXJ0dXAtYW5kLW1lZGlhLWNvbGxhYm9yYXRpb24taW4tZXVyb3BlLyIsInpvb20iOjIsImV4dHJhX2ZpZWxkcyI6eyJwb3N0X2V4Y2VycHQiOiJWUlQgaXMgdGhlIHB1YmxpYy1zZXJ2aWNlIGJyb2FkY2FzdGVyIGZvciBCZWxnaXVtJ3MgRmxlbWlzaCBjb21tdW5pdHkgLSBidXQgaXQgYWxzbyB3ZWxjb21lcyBzdGFydHVwcyBhbmQgc2NhbGV1cHMgdGhyb3VnaCBpdHMgZG9vcnMgd2l0aCB0aGUgcHJvbWlzZSBvZiBleHBlcmllbmNlLCBleHBvc3VyZSBhbmQgZXZlbiwgcGVyaGFwcywgYmVjb21pbmcgYW4gaW50ZXJuYXRpb25hbCBleHBvcnQiLCJwb3N0X2NvbnRlbnQiOiJbdmNfcm93XVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMi8zXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48aDE+VlJUIFNhbmRib3g6IGxlYWRpbmcgdGhlIHdheSBvbiBzdGFydHVwIGFuZCBtZWRpYSBjb2xsYWJvcmF0aW9uIGluIEV1cm9wZTwvaDE+XHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5WUlRcdTIwMTlzIHJlbWl0IGlzIHRlY2huaWNhbGx5IGxpbWl0ZWQgdG8gdGhlIDYuNSBtaWxsaW9uIER1dGNoIHNwZWFrZXJzIG9mIG5vcnRoZXJuIEJlbGdpdW0gLSBidXQgdGhlIHB1YmxpYy1zZXJ2aWNlIGJyb2FkY2FzdGVyIGhhcyBzcGVudCB5ZWFycyBnb2luZyBhYm92ZSBhbmQgYmV5b25kIGluIHRoZSBuYW1lIG9mIG1lZGlhIGlubm92YXRpb24uPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPjxhIGhyZWY9XCJodHRwczovL3NhbmRib3gudnJ0LmJlL1wiPlZSVCBTYW5kYm94PC9hPiwgb25lIG9mIGEgbnVtYmVyIG9mIGl0cyA8YSBocmVmPVwiaHR0cHM6Ly9pbm5vdmF0aWUudnJ0LmJlL2luZGV4LnBocC9lblwiPmlubm92YXRpb24gYnJhbmQ8L2E+cywgaGFzIGZvciBmaXZlIHllYXJzIGJlZW4gYWN0aW5nIGFzIGEgXHUyMDFjZnJvbnQgZG9vciBmb3Igc3RhcnR1cHMgYW5kIHNjYWxlIHVwcyBpbiBtZWRpYVx1MjAxZCwgYWNjb3JkaW5nIHRvIGl0cyBoZWFkIFBldGVyIGRlIFBhZXBlLCBhIGZvcm1lciByYWRpbyBwcm9kdWNlciBhbmQgcHJlc2VudGVyLlx1MDBhMDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNFdmVyeWJvZHkgd2hvIHRoaW5rcyB0aGF0IGl0IG1pZ2h0IGJlIGludGVyZXN0aW5nIHRvIHdvcmsgd2l0aCBWUlQgY2FuIGp1c3Qga25vY2sgb24gdGhlIGRvb3IgYW5kIHNheSBcdTIwMThPSywgdGhpcyBpcyB3aG8gSSBhbSBhbmQgSSB3b3VsZCBsaWtlIHRvIHdvcmsgdG9nZXRoZXIgd2l0aCB5b3UsIHdpdGggdGhpcyBicmFuZFx1MjAxOVx1MjAxZCwgaGUgZXhwbGFpbnMuIFwiQW5kIG9mIGNvdXJzZSwgYXMgYSBjb21wYW55LCB3ZVx1MjAxOXJlIGdsYWQgdGhhdCB3ZSBjYW4gd29yayB3aXRoIHRoZSBtb3N0IHByb21pc2luZyBtZWRpYSBzdGFydHVwcy5cIjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5BZnRlciBnZXR0aW5nIGxvdHMgb2YgYXBwcm9hY2hlcyBmcm9tIHN0YXJ0dXBzIGFuZCBzY2FsZXVwcyBrZWVuIHRvIHRlc3QgdGhlaXIgY29udGVudCBvciB0ZWNoIHNvbHV0aW9ucywgZGUgUGFlcGUgc2V0IHVwIGEgXHUyMDE4bWF0Y2htYWtpbmdcdTIwMTkgc2VydmljZS4gTm93LCBoZSBzaXRzIGRvd24gd2l0aCBtb3JlIHRoYW4gMTAwIGNvbXBhbmllcyBlYWNoIHllYXIsIGFzIHdlbGwgYXMgc3RhZmYgZnJvbSBWUlRcdTIwMTlzIDExIFRWLCByYWRpbyBhbmQgT1RUIGJyYW5kcywgdG8gdW5kZXJzdGFuZCB3aGF0IGVhY2ggd291bGQgd2FudCBmcm9tIGEgbWF0Y2guPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY1dlIG9mZmVyIHN0YXJ0dXBzIGEgdGVzdCBmb3IgdGhyZWUgdG8gZm91ciBtb250aHMuIFdoeT8gQmVjYXVzZSBpdCdzIHZlcnkgY2xlYXIuIEl0J3MgdmVyeSBzaG9ydC4gSXQgaXMgZG9hYmxlIGZvciB0aGUgYnJhbmQgb24gdGhlIFZSVCBzaWRlIGFuZCBmb3IgdGhlIHN0YXJ0dXAuIFRoYXQgYWxzbyBtZWFucyBzb21ldGltZXMgeW91IGhhdmUgdG8gZGVmaW5lIGEgdXNlIGNhc2UgdGhhdFx1MjAxOXMgcmF0aGVyIGJhc2ljLiBTbyB0aGF0J3MgYSBiaXQgb2YgYSBjaGFsbGVuZ2UuXHUyMDFkPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkluIG90aGVyIG9yZ2FuaXNhdGlvbnMsIHRoaXMga2luZCBvZiBjb2xsYWJvcmF0aW9uIG1pZ2h0IHRha2UgZm91ciB0byBzaXggbW9udGhzIHRvIGdldCBzdGFydGVkLCBvbmNlIHlvdSBnZXQgeW91ciBmb290IGluIHRoZSBkb29yLCBvZiBjb3Vyc2UuIEJ1dCBWUlQgU2FuZGJveCBhaW1zIHRvIGdldCBzdGFydGVkIGluIGZvdXIgdG8gc2l4IHdlZWtzLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNXZSBpZGVudGlmeSB3aGF0IGEgc3RhcnR1cCBpcyBkb2luZy4gVGhlbiB3ZSB0cnkgdG8gZmlndXJlIG91dCwgXHUyMDE4T0ssIHdoYXQgY2FuIGl0IG1lYW4gZm9yIHRoZSBicmFuZHMgdGhhdCB3ZSBoYXZlP1x1MjAxOS4gVGhlbiB3ZSBvcmdhbmlzZSBcdTIwMThkYXRpbmdcdTIwMTkgYW5kIGdpdmUgYW4gTU9UIHRvIHRoZSBicmFuZHMuIFRoZSBzdGFydHVwIG5lZWRzIHRvIGhhdmUgc29tZXRoaW5nIHRoYXQgd29ya3MgYW5kIGNhbiBiZSBpbXBsZW1lbnRlZCByaWdodCBhd2F5Llx1MjAxZDwvc3Bhbj5cclxuPGgzPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5NYXRjaG1ha2Vycywgbm90IHByb2plY3QgbWFrZXJzPC9zcGFuPjwvaDM+XHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5FdmVyeSB5ZWFyIHVwIHRvIDIwIGNvbXBhbmllcywgaGFsZiBGbGVtaXNoLCBoYWxmIGludGVybmF0aW9uYWwsIHRoYXQgYXJlIHdvcmtpbmcgaW4gbWVkaWEgY29udGVudCwgdGVjaCBvciBlZHRlY2ggdGVzdCBhIG1pbmltdW0tdmlhYmxlIHByb2R1Y3Qgd2l0aCBvbmUgb2YgVlJUXHUyMDE5cyB0ZWFtcywgYSB3b3JrZm9yY2Ugb2YgMiwwMDAuIE9uZSBzdWNoIG1hdGNoIGhhcyBzZWVuIHN0YXJ0dXBzIHdvcmtpbmcgd2l0aCBTdHVkaW8gQnJ1c3NlbHMsIFZSVFx1MjAxOXMgeW91dGggcmFkaW8gY2hhbm5lbCwgb24gYW4gZW5kLW9mLXllYXIgbXVsdGltZWRpYSBldmVudCB0aGF0IHJlYWNoZXMgbW9yZSB0aGFuIDEgbWlsbGlvbiBwZW9wbGUgZXZlcnkgZGF5Ljwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5BbG9uZ3NpZGUgYSBzcGVjaWZpYyBjYWxsIGluIHRoZSBcdTIwMWNkaWZmaWN1bHRcdTIwMWQgYXJlYSBvZiBlZHRlY2gsIHdoaWNoIHN1cHBvcnRzIFZSVFx1MjAxOXMgd2lkZXIgc3RyYXRlZ2ljIGdvYWwgdG8gZ2V0IGdvb2QgY29udGVudCBpbnRvIGVkdWNhdGlvbiwgVlJUIGlzIG9uIHRoZSBodW50IGZvciBjb21wYW5pZXMgd29ya2luZyBvbiBcdTIwMThpbnRlcmFjdGlvbiBhbmQgY28tY3JlYXRpb25cdTIwMTksIFx1MjAxOHBlcnNvbmFsaXNhdGlvbiwgZGF0YSBhbmQgQS5JXHUyMDE5LCBcdTIwMThmaWdodGluZyBmYWtlIG5ld3NcdTIwMTkgYW5kIFx1MjAxOGFjY2Vzc2liaWxpdHlcdTIwMTkuIFRoZSBsYXR0ZXIgaXMgYW5vdGhlciBrZXkgZm9jdXMgZm9yIHRoZSBwdWJsaWMtc2VydmljZSBicm9hZGNhc3RlciwgZGVzaWduZWQgdG8gaGVscCBpdCByZWFjaCBldmVyeSBGbGVtaXNoIHBlcnNvbi48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjV2UgYXJlIG5vdCBwcm9qZWN0IG1ha2Vycy4gV2UgbGluayB0aGUgc3RhcnR1cCB0byBhIGJyYW5kLCBhbmQgdGhlbiwgaWYgd2UgaGF2ZSBmb3VuZCB0aGUgcmlnaHQgdXNlIGNhc2UgYW5kIHRoZSByaWdodCBtYXRjaCwgaXQncyB0aGUgcGVvcGxlIG9mIHRoZSBicmFuZCBhbmQgdGhlIHN0YXJ0dXAgdGhhdCB3b3JrIHRvZ2V0aGVyLiBBbmQgd2UgYXJlIGp1c3QgaW4gYmV0d2VlbiB0byBndWlkZSBpdCBhIGxpdHRsZSBiaXQuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY1RoYXQgYWxzbyBtZWFucyBzb21ldGltZXMgd2Ugc2VlIHRoaW5ncyBmYWxsaW5nIGFwYXJ0LiBCdXQgd2UgYXJlIG5vdCB0aGVyZSB0byBhbHdheXMgY29udmluY2UgcGVvcGxlIHRvIGZ1cnRoZXIgd29yayBvbiB0aGVzZSBwcm9qZWN0cy5cdTIwMWQ8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+VGhlIFNhbmRib3ggaGFzIGEgcGh5c2ljYWwgc3BhY2Ugd2hlcmUgc3RhcnR1cHMgY2FuIGJhc2UgdGhlbXNlbHZlcyBhbmQgd2hlcmUgVlJUIHN0YWZmIGNhbiBtYWtlIHN1Z2dlc3Rpb25zIGZvciBuZXcgcHJvamVjdHMuIFx1MjAxY1RoYXQgd29ya3MgdmVyeSB3ZWxsIGFuZCBpdFx1MjAxOXMgdmVyeSBuaWNlIHRvIHNlZSB0aGF0IHdlIGFyZSBzb3J0IG9mIGEgY2VudHJhbCBpbm5vdmF0aW9uIHBsYWNlIHdoZXJlIGFsbCBvZiB0aGUgYnJhbmRzIGNvbWUgYW5kIGtub3csIFx1MjAxOE9LLCB0aGlzIGlzIHdoZXJlIHdlIGNhbiBkaXNjdXNzIG5ldyBwbGFucyB3aXRoIHN0YXJ0dXBzJy5cdTIwMWRcdTAwYTA8L3NwYW4+XHJcbjxoMz48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+Q2xvc2VkIHdhbGxldDwvc3Bhbj48L2gzPlxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+VlJUIFNhbmRib3ggb3BlcmF0ZXMgYSBcdTIwMThjbG9zZWQgd2FsbGV0XHUyMDE5IG1vZGVsIC0gc3RhcnR1cHMgZG9uXHUyMDE5dCBnZXQgY2FzaCwgYnV0IHRoZXkgZ2V0IGV4cGVyaWVuY2UgaW4gYSBcdTIwMThzYWZlIGVudmlyb25tZW50XHUyMDE5LCBleHBlcnQgY29hY2hpbmcsIGV4cG9zdXJlIGFuZCwgc29tZXRpbWVzLCBhIGRlYWwgd2l0aCBWUlQgLSBvciwgZXZlbiwgaGVscCBnZXR0aW5nIHRoZWlyIG5leHQgcGFpZCBnaWcuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY1RoZSBzdGFydHVwcyBoYXZlIGFjY2VzcyB0byBvdXIgaW50ZXJuYWwgbmV0d29yaywgbm90IG9ubHkgcGVvcGxlLCBidXQgdGhleSBhbHNvIGdldCB0byBzZWUgaG93IHdlIHdvcmsgYW5kIG91ciB0ZWNobm9sb2dpY2FsIHN0YWNrLiBUaGF0J3MgYWxzbyBhIHJlYXNvbiB3aHkgdGhleSBhcmUgdmVyeSBrZWVuIHRvIGNvbWUuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY0FuZCB5b3UgaGF2ZSB0aGUgZGlzc2VtaW5hdGlvbi4gVGhhdCBtZWFucyB0aGF0IHdlIHRyeSB0byBzZWUsIGFmdGVyIGZvdXIgbW9udGhzLCBcdTIwMTh3aGF0IGRpZCB3ZSBsZWFybj8gQ2FuIHdlIHNwcmVhZCB0aGUgdGhpbmdzIHRoYXQgd2UgbGVhcm5lZD9cdTIwMTkuIFdlIHF1ZXN0aW9uIHRoZSBwZW9wbGUgdmVyeSB3ZWxsIG9uIHRoZSBWUlQgc2lkZSBhbmQgc3RhcnR1cCBzaWRlIHRvIHVuZGVyc3RhbmQgXHUyMDE4d2hhdCBkaWQgdGhleSBsZWFybiBhbmQgd2hhdCBkbyB0aGV5IHdhbnQgdG8gZG8gYWZ0ZXIgdGhpcz9cdTIwMTkuXHUyMDFkPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlRvIGZ1cnRoZXIgYW1wbGlmeSB0aGlzLCBkZSBQYWVwZVx1MjAxOXMgdGVhbSBydW5zIHR3byBsYXJnZSBldmVudHMgZWFjaCB5ZWFyIC0gb25lIGZvciB0aGUgbG9jYWwgbWVkaWEgY2lyY3VpdCBhbmQgb25lLCBpbnRlZ3JhdGVkIGludG8gTWVkaWEgRmFzdCBGb3J3YXJkLCB0aGF0IGhvc3RzIDIsMDAwIHBhcnRpY2lwYW50cyBmcm9tIGFjcm9zcyBFdXJvcGUgYW5kIG9mZmVycyBhIFx1MjAxOHN0YXJ0dXAgc3RyZWV0XHUyMDE5IHNob3djYXNlIGZvciBtb3JlIHRoYW4gNjAgY29tcGFuaWVzLiA8L3NwYW4+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkFsb25nIHdpdGggb2ZmZXJpbmcgc3RhcnR1cHMgdGhlIG9wcG9ydHVuaXR5IHRvIHRyYXZlbCB0byBvdGhlciBldmVudHMgYWNyb3NzIHRoZSB3b3JsZCwgdGhpcyB0YWtlcyB0aGUgYnVsayBvZiBoaXMgXHUyMGFjMTYwLDAwMCB5ZWFybHkgYnVkZ2V0LCBwbHVzIGEgc21hbGwgdGVhbSwgZXF1aXZhbGVudCB0byBmb3VyIGZ1bGwtdGltZSB3b3JrZXJzLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj48aW1nIGNsYXNzPVwiYWxpZ25ub25lIHdwLWltYWdlLTE1Mzk1IHNpemUtbGFyZ2VcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAyMC8wNS9WUlQtU2FuZGJveC1zdGFydHVwLTEwMjR4NTcyLnBuZ1wiIGFsdD1cIlwiIHdpZHRoPVwiMTAyNFwiIGhlaWdodD1cIjU3MlwiIC8+PC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPk9uZSBzdWNjZXNzZnVsIFNhbmRib3ggcHJvamVjdCwgVGhlb3BsYXllciwgaGFzIGJlY29tZSB0aGUgZGVmYXVsdCBtZWRpYSBwbGF5ZXIgYWNyb3NzIGFsbCBWUlRcdTIwMTlzIHdlYnNpdGVzLiBcdTIwMWNUaGV5IHRlc3RlZCBmb3VyIHllYXJzIGFnbyB3aXRoIGEgbWluaW11bS12aWFibGUgcHJvZHVjdC4gVGhleSBhcmUgbm93IGEgY29tcGFueSB3aXRoIGFib3V0IDEyMCBwZW9wbGUgYW5kIGhhdmUgb2ZmaWNlcyBpbiBOZXcgWW9yayBhbmQgU2FuIEZyYW5jaXNjby5cdTIwMWQ8L3NwYW4+XHJcbjxoMz48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+U3RhcnR1cHMgY2hhbmdpbmcgbWVkaWEgcHJhY3RpY2U8L3NwYW4+PC9oMz5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkFub3RoZXIsIFZvaXp1cHAsIGhhcyBjcmVhdGVkIGZ1bmRhbWVudGFsIGNoYW5nZSBhdCB0aGUgYnJvYWRjYXN0ZXIgYnkgb2ZmZXJpbmcgYW4gYXBwLWJhc2VkIGludGVncmF0aW9uLCBhbG9uZ3NpZGUgYSBkYXRhIGRhc2hib2FyZCB0aGF0LCBmb3IgdGhlIGZpcnN0IHRpbWUsIGVuYWJsZXMgcmFkaW8gdGVhbXMgdG8gc2VlIHdob1x1MjAxOXMgbGlzdGVuaW5nLCBmb3IgaG93IGxvbmcsIGFuZCBtb3JlLCBzbyB0aGV5IGNhbiB0YWtlIHRoYXQgZGF0YSBpbnRvIHRoZSBkaXNjdXNzaW9ucyBhcm91bmQgdGhlIHNob3dzIHRoZXkgbWFrZS48L3NwYW4+XHJcbjxibG9ja3F1b3RlPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNTb21ldGltZXMgcGVvcGxlIHNheSwgXHUyMDE4eW91J3JlIGFsd2F5cyB0ZXN0aW5nIHdpdGggc3RhcnR1cHMsIGFuZCBvbiBhIHZlcnkgc21hbGwgc2NhbGUgLSB3aGF0IGlzIHRoZSBpbXBvcnRhbmNlIGZvciBhIGJpZyBjb21wYW55IGFzIFZSVD9cdTIwMTkuIEFuZCB0aGVuIEkgZ2l2ZSB0aGVtIHRoZSBleGFtcGxlIG9mIFZvaXp1cHAsIGhvdyB5b3UgY2FuIG1ha2Ugbm90IG9ubHkgdGhlIHRlY2hub2xvZ2ljYWwgY2hhbmdlLCBidXQgYWxzbyBhIGNoYW5nZSBpbiBtaW5kcywgaG93IHBlb3BsZSBtYWtlIHRoZWlyIHJhZGlvIHByb2dyYW1tZXMgb3IgVFYgcHJvZ3JhbW1lcy5cdTAwYTA8L3NwYW4+PC9ibG9ja3F1b3RlPlxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjQW5kLCBvZiBjb3Vyc2UsIHlvdSBoYXZlIHRvIGFjY2VsZXJhdGUgd2l0aCBvdGhlciB0ZWFtcyBhbmQgdGhlbiBzYXksIFx1MjAxOE9LLCBob3cgY2FuIHdlIGZpbmQgYSBidWRnZXQgdG8gbWFrZSBpdCBiaWdnZXI/XHUyMDE5LiBCdXQgdGhlIHN0YXJ0IGNvbWVzIGZyb20gb3IgY2FuIGNvbWUgZnJvbSBhIHN0YXJ0dXAuIFNvIHRoYXQncyB3aHkgSSB0aGluayB0aGF0IG9mdGVuIGl0IHdvcmtzIHZlcnkgd2VsbC5cdTIwMWQ8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+QWZ0ZXIgdHdvIHllYXJzIHRlc3Rpbmcgd2l0aCBGbGVtaXNoIHN0YXJ0dXBzLCBhbmQgd2l0aCBpbnRlcm5hdGlvbmFsIGludGVyZXN0IGNvbWluZyBpbiwgZGUgUGFlcGUgZGVjaWRlZCB0byBzZWUgYWJvdXQgbWFraW5nIHRoZSBTYW5kYm94IGJpZ2dlciAtIGFuZCBpcyBub3cgZm9jdXNlZCBvbiBiZWluZyBhYmxlIHRvIG9mZmVyIHN0YXJ0dXBzIGFuZCBzY2FsZXVwcyB0aGUgY2hhbmNlIHRvIHRydWx5IGdvIGdsb2JhbC5cdTAwYTA8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjT0ssIGNhbiB3ZSByZXByb2R1Y2UgdGhpcyBtb2RlbCB0byBvdGhlciBtZWRpYSBjb21wYW5pZXM/LFx1MjAxZCBoZSBhc2tlZC4gXHUyMDFjV2Ugd2VudCB0byB0aGUgQkJDIGFuZCBNZWRpYSBDaXR5IEJlcmdlbiBhbmQgUmVkIEJ1bGwgTWVkaWEgSG91c2UuIFdlIGV4cGxhaW5lZCBob3cgd2Ugd29yayBhbmQgd2h5IHdlIHRob3VnaHQgaXQgd2FzIGEgZ29vZCBpZGVhLiBBbmQsIGFjdHVhbGx5LCB0aGV5IGRlY2lkZWQgdmVyeSBmYXN0IHRvIGRvIGl0LiBJdCdzIG5vdCBhbiBleGFjdCBjb3B5LCBidXQgdGhlIGlkZWEgb2YgaW5ub3ZhdGluZyB0b2dldGhlciB3aXRoIHN0YXJ0dXBzIGFuZCBzY2FsZXVwcywgbGVhcm5pbmcgdmVyeSBmYXN0IGFuZCBzaGFyaW5nIHRoaXMgZXhwZXJ0aXNlLiBUaGF0J3Mgd2hhdCB0aGVzZSBjb21wYW5pZXMgZG8uXHUyMDFkPC9zcGFuPlxyXG48aDM+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlNjYWxpbmcgdXAgdGhlIG9wcG9ydHVuaXR5PC9zcGFuPjwvaDM+XHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5UaGV5IG5vdyBoYXZlIDE4IHB1YmxpYyBhbmQgcHJpdmF0ZSBtZWRpYSBjb21wYW5pZXMgaW4gdGhlIDxhIGhyZWY9XCJodHRwczovL3NhbmRib3gudnJ0LmJlL21lZGlhLWlubm92YXRpb25cIj5TYW5kYm94IEh1YjwvYT4sIHdobyBtZWV0IG1vbnRobHkgdG8gc2hhcmUgd2hhdCB0aGV5XHUyMDE5cmUgbGVhcm5pbmcuIFx1MjAxY0FsbW9zdCBldmVyeSBjb3VudHJ5IGluIEV1cm9wZSBpcyByZXByZXNlbnRlZC4gQWZ0ZXIgYSBzdGFydHVwIGNvbGxhYm9yYXRpb24gd2l0aCBWUlQsIHdlIGludHJvZHVjZSBzdGFydHVwcyB0byBhbm90aGVyIG1lZGlhIHBhcnR5IGxpa2UgTlBPIFt0aGUgRHV0Y2ggcHVibGljIGJyb2FkY2FzdGVyXS4gQW5kIHRoZW4gdGhleSBkbyBhIHRlc3QgdGhlcmUgb3IgdGhleSBqdXN0IGdldCBhIHBhaWQgaW50cm9kdWN0aW9uIGFuZCB0aGVuIHRoZXkgYXJlIGxhdW5jaGVkIEV1cm9wZWFuLlx1MjAxZDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj48aW1nIGNsYXNzPVwiYWxpZ25ub25lIHdwLWltYWdlLTE1Mzk0IHNpemUtbGFyZ2VcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAyMC8wNS9TYW5kYm94LUh1Yi0xMDI0eDU3Mi5wbmdcIiBhbHQ9XCJcIiB3aWR0aD1cIjEwMjRcIiBoZWlnaHQ9XCI1NzJcIiAvPjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5UaGUgZmluYWwgcGllY2Ugb2YgdGhlIHB1enpsZSwgaXQgc2VlbXMsIHdhcyBmb3VuZCBqdXN0IG92ZXIgYSB5ZWFyIGFnbyB3aXRoIHRoZSBjcmVhdGlvbiBvZiBhIFx1MjBhYzEwIG1pbGxpb24sIGpvaW50LXZlbnR1cmUgaW5ub3ZhdGlvbiBmdW5kLCBNZWRpYSBJbnZlc3QgVmxhYW5kZXJlbiBbTWVkaWEgSW52ZXN0IEZsYW5kZXJzXSwgd2l0aCBsb2NhbCBpbnZlc3RtZW50IGZpcm0gUE1WLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNPZiBjb3Vyc2UsIGEgZnVuZCBpcyBhIG5ldyB3YXkgb2YgYnJpbmdpbmcgY2FzaCBpbiBmb3IgVlJULiBCdXQgdGhlIG1haW4gcmVhc29uIHdlIHRob3VnaHQgaXQgd2FzIGEgZ29vZCBpZGVhIHdhcyBiZWNhdXNlLCBpZiB0aGVzZSBzdGFydHVwcyB3YW50ZWQgdG8gZ3JvdyBpbnRlcm5hdGlvbmFsbHksIHRoZXkgd291bGQgbmVlZCBpbnZlc3RtZW50IG1vbmV5IHRvIGdyb3cuXHUwMGEwPC9zcGFuPlxyXG48YmxvY2txdW90ZT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjSWYgeW91IGNvbXBhcmUgaXQgd2l0aCBmaW50ZWNoLCBmb3IgZXhhbXBsZSwgdGhlcmUsIGl0J3MgdmVyeSBlYXN5IHRvIGZpbmQgbW9uZXksIGJ1dCBpbiBtZWRpYSwgaXQncyByYXRoZXIgZGlmZmljdWx0IHRvIGZpbmQgXHUyMGFjMSBtaWxsaW9uLiBTbyB0aGlzIGlzIGEgZnVuZCB0aGF0IGNhbiBoZWxwIHRoZW0uIEl0J3MgbWFpbmx5IGZvciBwcm9mZXNzaW9uYWxpc2luZyB0aGUgZWNvc3lzdGVtLiBUaGUgbGFzdCBvbmUgd2UgZnVuZGVkIGlzIGFjdHVhbGx5IFRoZW9wbGF5ZXIuIFRoZXkgaGFkIGEgcm91bmQgb2YgXHUyMGFjNiBtaWxsaW9uIGFuZCB3ZSBwdXQgaXQgaW4gXHUyMGFjMSBtaWxsaW9uLlx1MjAxZDwvc3Bhbj48L2Jsb2NrcXVvdGU+XHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5TbyB3aHkgaXMgYSBwdWJsaWMtc2VydmljZSBicm9hZGNhc3RlciBmcm9tIHRoZSBub3J0aCBvZiBCZWxnaXVtIHNvIGtlZW4gb24gYnVpbGRpbmcgYSBzdHJvbmdlciBtZWRpYSBpbm5vdmF0aW9uIGVjb3N5c3RlbSBhY3Jvc3MgRXVyb3BlPzwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNJdCdzIHNvbWV0aGluZyB0aGF0IGlzIGluIG91ciBETkEuIFdlIHJlYWxseSB3YW50IHRvIGJlIG9uZSBvZiB0aGUgbW9zdCBpbm5vdmF0aXZlIG1lZGlhIGNvbXBhbmllcyBvZiBFdXJvcGUuIFRoZSBmYWN0IHRoYXQgd2UgYXJlIHZlcnkgY2VudHJhbCBhbmQgdGhhdCB3ZSBoYXZlIHRvIG5ldHdvcmsgaXMsIG9mIGNvdXJzZSwgb25lIG9mIHRoZSB0aGluZ3MgdGhhdCB3ZSBhcmUgZG9pbmcgYWxyZWFkeSBmb3IgMzAsIDQwIHllYXJzLiBTbyB0aGF0J3Mgbm90aGluZyBuZXcuXHUwMGEwPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY1doYXQgaXMgbmV3IGlzIHRoYXQgd2UsIGZyb20gYSBwZXJzcGVjdGl2ZSBvZiB0aGUgc3RhcnR1cHMsIGZvciB0aGVtIGl0IHdhcyB2ZXJ5IGltcG9ydGFudCB0byBpbW1lZGlhdGVseSB3b3JrIGluIGFuIGludGVybmF0aW9uYWwgZW52aXJvbm1lbnQuIEFuZCB0aGF0IG1lYW50IHRoYXQgd2UgaGFkIHRvLCBmb3IgZXhhbXBsZSwgY29tbXVuaWNhdGUgaW4gRW5nbGlzaC4gVGhhdCBzb3VuZHMgdmVyeSBlYXN5LiBCdXQgd2UgaGFkIHRvIHN0cnVnZ2xlIHRvIG1ha2UgdGhhdCBoYXBwZW4uXHUyMDFkPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkhlXHUyMDE5cyBhbHNvIHZlcnkga2VlbiB0byBtYWtlIHN1cmUgRXVyb3BlIGhhcyB0aGUgY29tcGFuaWVzIGl0IG5lZWRzIHRvIGNvbXBldGUgd2l0aCB0aGUgVVMgYW5kIEFzaWEuIDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5BbmQsIHdoaWxlIGRlIFBhZXBlIGFkbWl0cyB0aGlzIGlubm92YXRpb24gd29yayBoYXNuXHUyMDE5dCwgc28gZmFyLCBzcHVycmVkIGEgaHVnZSBpbmNyZWFzZSBpbiB0aGUgbnVtYmVyIG9mIGxvY2FsIG1lZGlhIHN0YXJ0dXBzLCBWUlRcdTIwMTlzIGFwcHJvYWNoIGlzIHNvdWdodCBhZnRlciBpbiBtb3JlIHVuZXhwZWN0ZWQgcGxhY2VzLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNBIGxvdCBvZiBvdGhlciBjb21wYW5pZXMsIGFuZCBub3Qgb25seSBtZWRpYSBjb21wYW5pZXMsIGFyZSBjb21pbmcgYW5kIGxvb2tpbmcgdG8gdXMsIGZvciBleGFtcGxlLCB0aGUgbmF0aW9uYWwgbG90dGVyeSBjb21wYW55IGFuZCBCUG9zdCwgdGhlIGNvbXBhbnkgdGhhdCBkZWxpdmVycyB0aGUgcG9zdCBpbiBCZWxnaXVtLiBTbyB3aGF0IEkgc2VlIGlzIHRoYXQgcGVvcGxlIGFyZSBub3cgbW9yZSBhbmQgbW9yZSBjb252aW5jZWQgdGhhdCB0aGUgd2F5IHRoYXQgd2UgaW5ub3ZhdGUgbWlnaHQgYmUgYSB1c2VmdWwgd2F5IHRvIGlubm92YXRlLiBXZSBuZXZlciBwcmV0ZW5kIHRoYXRcdTIwMTlzIHRoZSBvbmx5IG9uZSB3YXksIG9yIHRoZSBvbmx5IGdvb2Qgd2F5LiBXZSBqdXN0IGV4cGxhaW4gaG93IHdlIGRvIGl0Llx1MjAxZDwvc3Bhbj5cclxuXHJcbiZuYnNwO1xyXG5cclxuQ09OVEFDVFxyXG5cclxuPGltZyBjbGFzcz1cIndwLWltYWdlLTE1Mzk4IHNpemUtbWVkaXVtXCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMjAvMDUvUGV0ZXItZGUtUGFlcGUtZTE1ODg5MzMwODgxMjgtMzAweDI3Ni5qcGVnXCIgYWx0PVwiXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyNzZcIiAvPlxyXG5cclxuUGV0ZXIgZGUgUGFlcGUsIGhlYWQgb2YgVlJUIFNhbmRib3hcclxuVHdpdHRlcjpcdTAwYTA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9wZXRlcmRlcGFlcGVcIj5AcGV0ZXJkZXBhZXBlPC9hPlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbl1bdmNfY29sdW1uX3RleHRdXHJcblxyXG48c3BhbiBzdHlsZT1cImJvcmRlci10b3AtbGVmdC1yYWRpdXM6IDJweDsgYm9yZGVyLXRvcC1yaWdodC1yYWRpdXM6IDJweDsgYm9yZGVyLWJvdHRvbS1yaWdodC1yYWRpdXM6IDJweDsgYm9yZGVyLWJvdHRvbS1sZWZ0LXJhZGl1czogMnB4OyB0ZXh0LWluZGVudDogMjBweDsgd2lkdGg6IGF1dG87IHBhZGRpbmc6IDBweCA0cHggMHB4IDBweDsgdGV4dC1hbGlnbjogY2VudGVyOyBmb250LXN0eWxlOiBub3JtYWw7IGZvbnQtdmFyaWFudC1jYXBzOiBub3JtYWw7IGZvbnQtd2VpZ2h0OiBib2xkOyBmb250LXN0cmV0Y2g6IG5vcm1hbDsgZm9udC1zaXplOiAxMXB4OyBsaW5lLWhlaWdodDogMjBweDsgZm9udC1mYW1pbHk6ICdIZWx2ZXRpY2EgTmV1ZScsIEhlbHZldGljYSwgc2Fucy1zZXJpZjsgY29sb3I6ICNmZmZmZmY7IGJhY2tncm91bmQtaW1hZ2U6IHVybChkYXRhOmltYWdlL3N2Zyt4bWw7IGJhc2U2NCxwaG4yenliNGJ3eHVjejBpYWhyMGNkb3ZsM2QzZHk1M215NXZjbWN2bWphd21jOXpkbWNpaWdobGF3ZG9kZDBpbXpid2VjaWdkMmxrZGdnOWlqbXdjaGdpaWh6cHp4ZGNiM2c5aWkweGljMHhpZG14aWRteGlqNDh6ejQ4Y2dmMGFjYmtwc2pubWprdW5kcTVsZGUwbGp5Mm1pYmRtamt1bmRxNWxkaXlsamN5bWlheW1pNDRuamdzbWprdW1qdTJpZGUwbGpjMWxkaTVsamkxbmliZG5pNDJtemlzbWprdW1qdTJpZGF1bWR1eGxkaXlsamN5bWlhd2xqYTFtc3d4bmM0Mm5qaWdxemF1bWR1eGxkeXVuamF4aWR5dW5qbXlsZGF1bWR5M2lkZTBsamMxbGRhdW1keTNpZW15bWk0NG5qZ3NtYzR3bmpjZ21qa3VuZHE1bGR5dW5qYXhpZGk1bGpxMG9zd3huYzQybmppaWlnenBiZ3c5aWlubXpteWlpaG4wY205cnp0MGlpMnptemlpZ2MzcnliMnRsbHhkcHpocm9wc2l4aWo0OGwzYmhkZ2crcGhiaGRnZ2d6ZDBpdHRlMGxqY3pteXd4bGp5NG5pYmRueTQxbXR5c21zNDJvZHlnbXM0Mm5qdXNueTQwb3R1Z21zNDJuanVzbXRxdW5qeXlpZW14bGp5Mm5zd3ltYzR4bnRrZ25zNHhtZGtzbWpxdW9kdTBpZGt1b3Rjc21qeXVuenEwaWVtNWxqZzFuaXd5bnM0M210Z2dvczQzbnRtc21qcXVtdHF6aWRld2xqYXhuaXd5bXk0d21qaWdxemV3bGppMW15d3ltaTR3bXNheG1zNDFuZGdzbXR5dW50Y3lpZGV4bGp1MG9jd3huaTQxbnppZ3F6ZXhsanUwb2N3eG5pNDFuemlnbXRldW10dTNsZGUxbGpjNW5zYXhtczR4bnRjc210cXVuanEyaWVteG1zNHhudGNzbXRpdW9kcXlpZGV5bGppeG1zd3htczQwb3R1Z210bXVudGl5bGRleGxqcTVuc2JkbXRxdW5qbTNsZGV4bGpxNW5zYXhuczR4bnp1c210aXVtemkyaWRlMWxqZTNuc3d4bXk0em1qbWdxemUxbGplM25zd3huYzQwbXp5Z210cXVuZHl5bGRlMmxqZWdtdHF1bWRremxkZTNsankwbXliZG10bXVuemcxbGRlNGxqa3puc2F4bmM0M25kdXNtdGt1b3RnNGlkZTJsamF5b2N3eG9zNDVvZGdncXplNGxqbTFtc3d4b3M0NW9kZ2dtamF1bXRtMmxkZTNsanUxbmlheW1jNHhtenlzbXRxdW1kcTJpZW15bWM0eG16eXNtdGF1b3RtNWlkZTNsamc0b2N3NGxqYzJueWF4bmM0Mm56Z3NvYzQzbmpjZ3F6ZXdsamsxb3N3NGxqYzJueWE0bGpjM255d3htczQxbXp5Z29jNDNuemNzbXRxdW16azRpZW00bGpjM255d3huczQxbXRtZ29zNHltc3d4bmk0M21ka2dvczQzbmRrc210Y3VtenU1aWVtNWxqZzFuaXd4bnk0MG9kZ2dvczQ0bnppc210Y3VuaWE1bGpnMGxkZTNsamN6bXNiZG9zNDNuZGVzbXRndW10cXhpZGt1bnRpc210a3VtZGl6aWRrdW5kYzNsZGU1bGppd215YmRvczQwbWl3eG9zNDBuY2E1bGppNG9jd3hvczQwb3RlZ29zNHduY3d4b3M0em56eWdxemN1bmRhNGxkZTRsanl5bWlhMmxqbTRueXd4bmk0eW50aWduaTR6b2Rjc210cXVtenE1aWVtMmxqbTRueXd4bWM0eW50eWdvczR6b2Rtc25pNDBvdGNnbXR1dW1kaXlsZHl1bmRrM2llbXhvczQxbnR1c25pNDBvdGNnbWptdW1kYzRsZGt1bnphMWlkaXpsamEzb2N3eG15NDVvdGVncXppemxqYTNvY3d4b2M0MG5qbWdtamF1bWptNWxkaXlsamEybWlheG5pNHlvdGNzbWppdW1keXlpZW14bmM0NW56bXNtaml1bWR5eWlkZXpsamN5b2N3eW1zNHpuemtnbXRtdW16YXlsZGl3bGp1M21pYmRtdG11bXpheWxkaXdsanUzbWlheG1pNDJuZGNzbWptdW1kdWdtdGl1bmRnNGxkaXpsankxbnliZG10aXVtdGt6bGRpMGxqYzRuY2F4bXM0em90eXNtanl1bXRrMmlkZXdsamcybXl3eW55NHdudGdncXpleWxqYTRuaXd5bnk0MG16cWdtdG11bXpnMmxkaTNsanl6bnlheG5jNDNtem1zbWpjdW5qbTNpZW15bXM0NW5zd3lueTQybXpjZ21qY3VvZGF4bGRpeGxqZ3lvY2F5bnk0NG1kZXNtdHF1bmp5eWllbXlueTQ0bWRlc255NDBvdHVnbWpldW90dXNtczQyb2R5Z210cXVuem16bGRldW5qZzJpaWJtYXd4c3BzaWp5bXF3b2RmamlqNDhsM2JoZGdnK3BjOW5wand2YzN6bnBnPT0pOyBiYWNrZ3JvdW5kLXNpemU6IDE0cHggMTRweDsgYmFja2dyb3VuZC1jb2xvcjogI2JkMDgxYzsgcG9zaXRpb246IGFic29sdXRlOyBvcGFjaXR5OiAxOyB6LWluZGV4OiA4Njc1MzA5OyBkaXNwbGF5OiBub25lOyBjdXJzb3I6IHBvaW50ZXI7IGJvcmRlcjogbm9uZTsgLXdlYmtpdC1mb250LXNtb290aGluZzogYW50aWFsaWFzZWQ7IGJhY2tncm91bmQtcG9zaXRpb246IDNweCA1MCU7IGJhY2tncm91bmQtcmVwZWF0OiBuby1yZXBlYXQgbm8tcmVwZWF0O1wiPlNhdmU8L3NwYW4+PHNwYW4gc3R5bGU9XCJib3JkZXItdG9wLWxlZnQtcmFkaXVzOiAycHg7IGJvcmRlci10b3AtcmlnaHQtcmFkaXVzOiAycHg7IGJvcmRlci1ib3R0b20tcmlnaHQtcmFkaXVzOiAycHg7IGJvcmRlci1ib3R0b20tbGVmdC1yYWRpdXM6IDJweDsgdGV4dC1pbmRlbnQ6IDIwcHg7IHdpZHRoOiBhdXRvOyBwYWRkaW5nOiAwcHggNHB4IDBweCAwcHg7IHRleHQtYWxpZ246IGNlbnRlcjsgZm9udC1zdHlsZTogbm9ybWFsOyBmb250LXZhcmlhbnQtY2Fwczogbm9ybWFsOyBmb250LXdlaWdodDogYm9sZDsgZm9udC1zdHJldGNoOiBub3JtYWw7IGZvbnQtc2l6ZTogMTFweDsgbGluZS1oZWlnaHQ6IDIwcHg7IGZvbnQtZmFtaWx5OiAnSGVsdmV0aWNhIE5ldWUnLCBIZWx2ZXRpY2EsIHNhbnMtc2VyaWY7IGNvbG9yOiAjZmZmZmZmOyBiYWNrZ3JvdW5kLWltYWdlOiB1cmwoZGF0YTppbWFnZS9zdmcreG1sOyBiYXNlNjQscGhuMnp5YjRid3h1Y3owaWFocjBjZG92bDNkM2R5NTNteTV2Y21jdm1qYXdtYzl6ZG1jaWlnaGxhd2RvZGQwaW16YndlY2lnZDJsa2RnZzlpam13Y2hnaWloenB6eGRjYjNnOWlpMHhpYzB4aWRteGlkbXhpajQ4eno0OGNnZjBhY2JrcHNqbm1qa3VuZHE1bGRlMGxqeTJtaWJkbWprdW5kcTVsZGl5bGpjeW1pYXltaTQ0bmpnc21qa3VtanUyaWRlMGxqYzFsZGk1bGppMW5pYmRuaTQybXppc21qa3VtanUyaWRhdW1kdXhsZGl5bGpjeW1pYXdsamExbXN3eG5jNDJuamlncXphdW1kdXhsZHl1bmpheGlkeXVuam15bGRhdW1keTNpZGUwbGpjMWxkYXVtZHkzaWVteW1pNDRuamdzbWM0d25qY2dtamt1bmRxNWxkeXVuamF4aWRpNWxqcTBvc3d4bmM0Mm5qaWlpZ3pwYmd3OWlpbm16bXlpaWhuMGNtOXJ6dDBpaTJ6bXppaWdjM3J5YjJ0bGx4ZHB6aHJvcHNpeGlqNDhsM2JoZGdnK3BoYmhkZ2dnemQwaXR0ZTBsamN6bXl3eGxqeTRuaWJkbnk0MW10eXNtczQyb2R5Z21zNDJuanVzbnk0MG90dWdtczQybmp1c210cXVuanl5aWVteGxqeTJuc3d5bWM0eG50a2duczR4bWRrc21qcXVvZHUwaWRrdW90Y3Ntanl1bnpxMGllbTVsamcxbml3eW5zNDNtdGdnb3M0M250bXNtanF1bXRxemlkZXdsamF4bml3eW15NHdtamlncXpld2xqaTFteXd5bWk0d21zYXhtczQxbmRnc210eXVudGN5aWRleGxqdTBvY3d4bmk0MW56aWdxemV4bGp1MG9jd3huaTQxbnppZ210ZXVtdHUzbGRlMWxqYzVuc2F4bXM0eG50Y3NtdHF1bmpxMmllbXhtczR4bnRjc210aXVvZHF5aWRleWxqaXhtc3d4bXM0MG90dWdtdG11bnRpeWxkZXhsanE1bnNiZG10cXVuam0zbGRleGxqcTVuc2F4bnM0eG56dXNtdGl1bXppMmlkZTFsamUzbnN3eG15NHptam1ncXplMWxqZTNuc3d4bmM0MG16eWdtdHF1bmR5eWxkZTJsamVnbXRxdW1ka3psZGUzbGp5MG15YmRtdG11bnpnMWxkZTRsamt6bnNheG5jNDNuZHVzbXRrdW90ZzRpZGUybGpheW9jd3hvczQ1b2RnZ3F6ZTRsam0xbXN3eG9zNDVvZGdnbWphdW10bTJsZGUzbGp1MW5pYXltYzR4bXp5c210cXVtZHEyaWVteW1jNHhtenlzbXRhdW90bTVpZGUzbGpnNG9jdzRsamMybnlheG5jNDJuemdzb2M0M25qY2dxemV3bGprMW9zdzRsamMybnlhNGxqYzNueXd4bXM0MW16eWdvYzQzbnpjc210cXVtems0aWVtNGxqYzNueXd4bnM0MW10bWdvczR5bXN3eG5pNDNtZGtnb3M0M25ka3NtdGN1bXp1NWllbTVsamcxbml3eG55NDBvZGdnb3M0NG56aXNtdGN1bmlhNWxqZzBsZGUzbGpjem1zYmRvczQzbmRlc210Z3VtdHF4aWRrdW50aXNtdGt1bWRpemlka3VuZGMzbGRlNWxqaXdteWJkb3M0MG1pd3hvczQwbmNhNWxqaTRvY3d4b3M0MG90ZWdvczR3bmN3eG9zNHpuenlncXpjdW5kYTRsZGU0bGp5eW1pYTJsam00bnl3eG5pNHludGlnbmk0em9kY3NtdHF1bXpxNWllbTJsam00bnl3eG1jNHludHlnb3M0em9kbXNuaTQwb3RjZ210dXVtZGl5bGR5dW5kazNpZW14b3M0MW50dXNuaTQwb3RjZ21qbXVtZGM0bGRrdW56YTFpZGl6bGphM29jd3hteTQ1b3RlZ3F6aXpsamEzb2N3eG9jNDBuam1nbWphdW1qbTVsZGl5bGphMm1pYXhuaTR5b3Rjc21qaXVtZHl5aWVteG5jNDVuem1zbWppdW1keXlpZGV6bGpjeW9jd3ltczR6bnprZ210bXVtemF5bGRpd2xqdTNtaWJkbXRtdW16YXlsZGl3bGp1M21pYXhtaTQybmRjc21qbXVtZHVnbXRpdW5kZzRsZGl6bGp5MW55YmRtdGl1bXRremxkaTBsamM0bmNheG1zNHpvdHlzbWp5dW10azJpZGV3bGpnMm15d3lueTR3bnRnZ3F6ZXlsamE0bml3eW55NDBtenFnbXRtdW16ZzJsZGkzbGp5em55YXhuYzQzbXptc21qY3Vuam0zaWVteW1zNDVuc3d5bnk0Mm16Y2dtamN1b2RheGxkaXhsamd5b2NheW55NDRtZGVzbXRxdW5qeXlpZW15bnk0NG1kZXNueTQwb3R1Z21qZXVvdHVzbXM0Mm9keWdtdHF1bnptemxkZXVuamcyaWlibWF3eHNwc2lqeW1xd29kZmppajQ4bDNiaGRnZytwYzlucGp3dmMzem5wZz09KTsgYmFja2dyb3VuZC1zaXplOiAxNHB4IDE0cHg7IGJhY2tncm91bmQtY29sb3I6ICNiZDA4MWM7IHBvc2l0aW9uOiBhYnNvbHV0ZTsgb3BhY2l0eTogMTsgei1pbmRleDogODY3NTMwOTsgZGlzcGxheTogbm9uZTsgY3Vyc29yOiBwb2ludGVyOyBib3JkZXI6IG5vbmU7IC13ZWJraXQtZm9udC1zbW9vdGhpbmc6IGFudGlhbGlhc2VkOyBiYWNrZ3JvdW5kLXBvc2l0aW9uOiAzcHggNTAlOyBiYWNrZ3JvdW5kLXJlcGVhdDogbm8tcmVwZWF0IG5vLXJlcGVhdDtcIj5TYXZlPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJib3JkZXItdG9wLWxlZnQtcmFkaXVzOiAycHg7IGJvcmRlci10b3AtcmlnaHQtcmFkaXVzOiAycHg7IGJvcmRlci1ib3R0b20tcmlnaHQtcmFkaXVzOiAycHg7IGJvcmRlci1ib3R0b20tbGVmdC1yYWRpdXM6IDJweDsgdGV4dC1pbmRlbnQ6IDIwcHg7IHdpZHRoOiBhdXRvOyBwYWRkaW5nOiAwcHggNHB4IDBweCAwcHg7IHRleHQtYWxpZ246IGNlbnRlcjsgZm9udC1zdHlsZTogbm9ybWFsOyBmb250LXZhcmlhbnQtY2Fwczogbm9ybWFsOyBmb250LXdlaWdodDogYm9sZDsgZm9udC1zdHJldGNoOiBub3JtYWw7IGZvbnQtc2l6ZTogMTFweDsgbGluZS1oZWlnaHQ6IDIwcHg7IGZvbnQtZmFtaWx5OiAnSGVsdmV0aWNhIE5ldWUnLCBIZWx2ZXRpY2EsIHNhbnMtc2VyaWY7IGNvbG9yOiAjZmZmZmZmOyBiYWNrZ3JvdW5kLWltYWdlOiB1cmwoZGF0YTppbWFnZS9zdmcreG1sOyBiYXNlNjQscGhuMnp5YjRid3h1Y3owaWFocjBjZG92bDNkM2R5NTNteTV2Y21jdm1qYXdtYzl6ZG1jaWlnaGxhd2RvZGQwaW16YndlY2lnZDJsa2RnZzlpam13Y2hnaWloenB6eGRjYjNnOWlpMHhpYzB4aWRteGlkbXhpajQ4eno0OGNnZjBhY2JrcHNqbm1qa3VuZHE1bGRlMGxqeTJtaWJkbWprdW5kcTVsZGl5bGpjeW1pYXltaTQ0bmpnc21qa3VtanUyaWRlMGxqYzFsZGk1bGppMW5pYmRuaTQybXppc21qa3VtanUyaWRhdW1kdXhsZGl5bGpjeW1pYXdsamExbXN3eG5jNDJuamlncXphdW1kdXhsZHl1bmpheGlkeXVuam15bGRhdW1keTNpZGUwbGpjMWxkYXVtZHkzaWVteW1pNDRuamdzbWM0d25qY2dtamt1bmRxNWxkeXVuamF4aWRpNWxqcTBvc3d4bmM0Mm5qaWlpZ3pwYmd3OWlpbm16bXlpaWhuMGNtOXJ6dDBpaTJ6bXppaWdjM3J5YjJ0bGx4ZHB6aHJvcHNpeGlqNDhsM2JoZGdnK3BoYmhkZ2dnemQwaXR0ZTBsamN6bXl3eGxqeTRuaWJkbnk0MW10eXNtczQyb2R5Z21zNDJuanVzbnk0MG90dWdtczQybmp1c210cXVuanl5aWVteGxqeTJuc3d5bWM0eG50a2duczR4bWRrc21qcXVvZHUwaWRrdW90Y3Ntanl1bnpxMGllbTVsamcxbml3eW5zNDNtdGdnb3M0M250bXNtanF1bXRxemlkZXdsamF4bml3eW15NHdtamlncXpld2xqaTFteXd5bWk0d21zYXhtczQxbmRnc210eXVudGN5aWRleGxqdTBvY3d4bmk0MW56aWdxemV4bGp1MG9jd3huaTQxbnppZ210ZXVtdHUzbGRlMWxqYzVuc2F4bXM0eG50Y3NtdHF1bmpxMmllbXhtczR4bnRjc210aXVvZHF5aWRleWxqaXhtc3d4bXM0MG90dWdtdG11bnRpeWxkZXhsanE1bnNiZG10cXVuam0zbGRleGxqcTVuc2F4bnM0eG56dXNtdGl1bXppMmlkZTFsamUzbnN3eG15NHptam1ncXplMWxqZTNuc3d4bmM0MG16eWdtdHF1bmR5eWxkZTJsamVnbXRxdW1ka3psZGUzbGp5MG15YmRtdG11bnpnMWxkZTRsamt6bnNheG5jNDNuZHVzbXRrdW90ZzRpZGUybGpheW9jd3hvczQ1b2RnZ3F6ZTRsam0xbXN3eG9zNDVvZGdnbWphdW10bTJsZGUzbGp1MW5pYXltYzR4bXp5c210cXVtZHEyaWVteW1jNHhtenlzbXRhdW90bTVpZGUzbGpnNG9jdzRsamMybnlheG5jNDJuemdzb2M0M25qY2dxemV3bGprMW9zdzRsamMybnlhNGxqYzNueXd4bXM0MW16eWdvYzQzbnpjc210cXVtems0aWVtNGxqYzNueXd4bnM0MW10bWdvczR5bXN3eG5pNDNtZGtnb3M0M25ka3NtdGN1bXp1NWllbTVsamcxbml3eG55NDBvZGdnb3M0NG56aXNtdGN1bmlhNWxqZzBsZGUzbGpjem1zYmRvczQzbmRlc210Z3VtdHF4aWRrdW50aXNtdGt1bWRpemlka3VuZGMzbGRlNWxqaXdteWJkb3M0MG1pd3hvczQwbmNhNWxqaTRvY3d4b3M0MG90ZWdvczR3bmN3eG9zNHpuenlncXpjdW5kYTRsZGU0bGp5eW1pYTJsam00bnl3eG5pNHludGlnbmk0em9kY3NtdHF1bXpxNWllbTJsam00bnl3eG1jNHludHlnb3M0em9kbXNuaTQwb3RjZ210dXVtZGl5bGR5dW5kazNpZW14b3M0MW50dXNuaTQwb3RjZ21qbXVtZGM0bGRrdW56YTFpZGl6bGphM29jd3hteTQ1b3RlZ3F6aXpsamEzb2N3eG9jNDBuam1nbWphdW1qbTVsZGl5bGphMm1pYXhuaTR5b3Rjc21qaXVtZHl5aWVteG5jNDVuem1zbWppdW1keXlpZGV6bGpjeW9jd3ltczR6bnprZ210bXVtemF5bGRpd2xqdTNtaWJkbXRtdW16YXlsZGl3bGp1M21pYXhtaTQybmRjc21qbXVtZHVnbXRpdW5kZzRsZGl6bGp5MW55YmRtdGl1bXRremxkaTBsamM0bmNheG1zNHpvdHlzbWp5dW10azJpZGV3bGpnMm15d3lueTR3bnRnZ3F6ZXlsamE0bml3eW55NDBtenFnbXRtdW16ZzJsZGkzbGp5em55YXhuYzQzbXptc21qY3Vuam0zaWVteW1zNDVuc3d5bnk0Mm16Y2dtamN1b2RheGxkaXhsamd5b2NheW55NDRtZGVzbXRxdW5qeXlpZW15bnk0NG1kZXNueTQwb3R1Z21qZXVvdHVzbXM0Mm9keWdtdHF1bnptemxkZXVuamcyaWlibWF3eHNwc2lqeW1xd29kZmppajQ4bDNiaGRnZytwYzlucGp3dmMzem5wZz09KTsgYmFja2dyb3VuZC1zaXplOiAxNHB4IDE0cHg7IGJhY2tncm91bmQtY29sb3I6ICNiZDA4MWM7IHBvc2l0aW9uOiBhYnNvbHV0ZTsgb3BhY2l0eTogMTsgei1pbmRleDogODY3NTMwOTsgZGlzcGxheTogbm9uZTsgY3Vyc29yOiBwb2ludGVyOyBib3JkZXI6IG5vbmU7IC13ZWJraXQtZm9udC1zbW9vdGhpbmc6IGFudGlhbGlhc2VkOyBiYWNrZ3JvdW5kLXBvc2l0aW9uOiAzcHggNTAlOyBiYWNrZ3JvdW5kLXJlcGVhdDogbm8tcmVwZWF0IG5vLXJlcGVhdDtcIj5TYXZlPC9zcGFuPjxzcGFuIHN0eWxlPVwiYm9yZGVyLXRvcC1sZWZ0LXJhZGl1czogMnB4OyBib3JkZXItdG9wLXJpZ2h0LXJhZGl1czogMnB4OyBib3JkZXItYm90dG9tLXJpZ2h0LXJhZGl1czogMnB4OyBib3JkZXItYm90dG9tLWxlZnQtcmFkaXVzOiAycHg7IHRleHQtaW5kZW50OiAyMHB4OyB3aWR0aDogYXV0bzsgcGFkZGluZzogMHB4IDRweCAwcHggMHB4OyB0ZXh0LWFsaWduOiBjZW50ZXI7IGZvbnQtc3R5bGU6IG5vcm1hbDsgZm9udC12YXJpYW50LWNhcHM6IG5vcm1hbDsgZm9udC13ZWlnaHQ6IGJvbGQ7IGZvbnQtc3RyZXRjaDogbm9ybWFsOyBmb250LXNpemU6IDExcHg7IGxpbmUtaGVpZ2h0OiAyMHB4OyBmb250LWZhbWlseTogJ0hlbHZldGljYSBOZXVlJywgSGVsdmV0aWNhLCBzYW5zLXNlcmlmOyBjb2xvcjogI2ZmZmZmZjsgYmFja2dyb3VuZC1pbWFnZTogdXJsKGRhdGE6aW1hZ2Uvc3ZnK3htbDsgYmFzZTY0LHBobjJ6eWI0Ynd4dWN6MGlhaHIwY2RvdmwzZDNkeTUzbXk1dmNtY3ZtamF3bWM5emRtY2lpZ2hsYXdkb2RkMGltemJ3ZWNpZ2QybGtkZ2c5aWptd2NoZ2lpaHpwenhkY2IzZzlpaTB4aWMweGlkbXhpZG14aWo0OHp6NDhjZ2YwYWNia3Bzam5tamt1bmRxNWxkZTBsankybWliZG1qa3VuZHE1bGRpeWxqY3ltaWF5bWk0NG5qZ3Ntamt1bWp1MmlkZTBsamMxbGRpNWxqaTFuaWJkbmk0Mm16aXNtamt1bWp1MmlkYXVtZHV4bGRpeWxqY3ltaWF3bGphMW1zd3huYzQybmppZ3F6YXVtZHV4bGR5dW5qYXhpZHl1bmpteWxkYXVtZHkzaWRlMGxqYzFsZGF1bWR5M2llbXltaTQ0bmpnc21jNHduamNnbWprdW5kcTVsZHl1bmpheGlkaTVsanEwb3N3eG5jNDJuamlpaWd6cGJndzlpaW5tem15aWlobjBjbTlyenQwaWkyem16aWlnYzNyeWIydGxseGRwemhyb3BzaXhpajQ4bDNiaGRnZytwaGJoZGdnZ3pkMGl0dGUwbGpjem15d3hsank0bmliZG55NDFtdHlzbXM0Mm9keWdtczQybmp1c255NDBvdHVnbXM0Mm5qdXNtdHF1bmp5eWllbXhsankybnN3eW1jNHhudGtnbnM0eG1ka3NtanF1b2R1MGlka3VvdGNzbWp5dW56cTBpZW01bGpnMW5pd3luczQzbXRnZ29zNDNudG1zbWpxdW10cXppZGV3bGpheG5pd3lteTR3bWppZ3F6ZXdsamkxbXl3eW1pNHdtc2F4bXM0MW5kZ3NtdHl1bnRjeWlkZXhsanUwb2N3eG5pNDFuemlncXpleGxqdTBvY3d4bmk0MW56aWdtdGV1bXR1M2xkZTFsamM1bnNheG1zNHhudGNzbXRxdW5qcTJpZW14bXM0eG50Y3NtdGl1b2RxeWlkZXlsaml4bXN3eG1zNDBvdHVnbXRtdW50aXlsZGV4bGpxNW5zYmRtdHF1bmptM2xkZXhsanE1bnNheG5zNHhuenVzbXRpdW16aTJpZGUxbGplM25zd3hteTR6bWptZ3F6ZTFsamUzbnN3eG5jNDBtenlnbXRxdW5keXlsZGUybGplZ210cXVtZGt6bGRlM2xqeTBteWJkbXRtdW56ZzFsZGU0bGprem5zYXhuYzQzbmR1c210a3VvdGc0aWRlMmxqYXlvY3d4b3M0NW9kZ2dxemU0bGptMW1zd3hvczQ1b2RnZ21qYXVtdG0ybGRlM2xqdTFuaWF5bWM0eG16eXNtdHF1bWRxMmllbXltYzR4bXp5c210YXVvdG01aWRlM2xqZzRvY3c0bGpjMm55YXhuYzQybnpnc29jNDNuamNncXpld2xqazFvc3c0bGpjMm55YTRsamMzbnl3eG1zNDFtenlnb2M0M256Y3NtdHF1bXprNGllbTRsamMzbnl3eG5zNDFtdG1nb3M0eW1zd3huaTQzbWRrZ29zNDNuZGtzbXRjdW16dTVpZW01bGpnMW5pd3hueTQwb2RnZ29zNDRuemlzbXRjdW5pYTVsamcwbGRlM2xqY3ptc2Jkb3M0M25kZXNtdGd1bXRxeGlka3VudGlzbXRrdW1kaXppZGt1bmRjM2xkZTVsaml3bXliZG9zNDBtaXd4b3M0MG5jYTVsamk0b2N3eG9zNDBvdGVnb3M0d25jd3hvczR6bnp5Z3F6Y3VuZGE0bGRlNGxqeXltaWEybGptNG55d3huaTR5bnRpZ25pNHpvZGNzbXRxdW16cTVpZW0ybGptNG55d3htYzR5bnR5Z29zNHpvZG1zbmk0MG90Y2dtdHV1bWRpeWxkeXVuZGszaWVteG9zNDFudHVzbmk0MG90Y2dtam11bWRjNGxka3VuemExaWRpemxqYTNvY3d4bXk0NW90ZWdxeml6bGphM29jd3hvYzQwbmptZ21qYXVtam01bGRpeWxqYTJtaWF4bmk0eW90Y3Ntaml1bWR5eWllbXhuYzQ1bnptc21qaXVtZHl5aWRlemxqY3lvY3d5bXM0em56a2dtdG11bXpheWxkaXdsanUzbWliZG10bXVtemF5bGRpd2xqdTNtaWF4bWk0Mm5kY3Ntam11bWR1Z210aXVuZGc0bGRpemxqeTFueWJkbXRpdW10a3psZGkwbGpjNG5jYXhtczR6b3R5c21qeXVtdGsyaWRld2xqZzJteXd5bnk0d250Z2dxemV5bGphNG5pd3lueTQwbXpxZ210bXVtemcybGRpM2xqeXpueWF4bmM0M216bXNtamN1bmptM2llbXltczQ1bnN3eW55NDJtemNnbWpjdW9kYXhsZGl4bGpneW9jYXlueTQ0bWRlc210cXVuanl5aWVteW55NDRtZGVzbnk0MG90dWdtamV1b3R1c21zNDJvZHlnbXRxdW56bXpsZGV1bmpnMmlpYm1hd3hzcHNpanltcXdvZGZqaWo0OGwzYmhkZ2crcGM5bnBqd3ZjM3pucGc9PSk7IGJhY2tncm91bmQtc2l6ZTogMTRweCAxNHB4OyBiYWNrZ3JvdW5kLWNvbG9yOiAjYmQwODFjOyBwb3NpdGlvbjogYWJzb2x1dGU7IG9wYWNpdHk6IDE7IHotaW5kZXg6IDg2NzUzMDk7IGRpc3BsYXk6IG5vbmU7IGN1cnNvcjogcG9pbnRlcjsgYm9yZGVyOiBub25lOyAtd2Via2l0LWZvbnQtc21vb3RoaW5nOiBhbnRpYWxpYXNlZDsgYmFja2dyb3VuZC1wb3NpdGlvbjogM3B4IDUwJTsgYmFja2dyb3VuZC1yZXBlYXQ6IG5vLXJlcGVhdCBuby1yZXBlYXQ7XCI+U2F2ZTwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiYm9yZGVyLXRvcC1sZWZ0LXJhZGl1czogMnB4OyBib3JkZXItdG9wLXJpZ2h0LXJhZGl1czogMnB4OyBib3JkZXItYm90dG9tLXJpZ2h0LXJhZGl1czogMnB4OyBib3JkZXItYm90dG9tLWxlZnQtcmFkaXVzOiAycHg7IHRleHQtaW5kZW50OiAyMHB4OyB3aWR0aDogYXV0bzsgcGFkZGluZzogMHB4IDRweCAwcHggMHB4OyB0ZXh0LWFsaWduOiBjZW50ZXI7IGZvbnQtc3R5bGU6IG5vcm1hbDsgZm9udC12YXJpYW50LWNhcHM6IG5vcm1hbDsgZm9udC13ZWlnaHQ6IGJvbGQ7IGZvbnQtc3RyZXRjaDogbm9ybWFsOyBmb250LXNpemU6IDExcHg7IGxpbmUtaGVpZ2h0OiAyMHB4OyBmb250LWZhbWlseTogJ0hlbHZldGljYSBOZXVlJywgSGVsdmV0aWNhLCBzYW5zLXNlcmlmOyBjb2xvcjogI2ZmZmZmZjsgYmFja2dyb3VuZC1pbWFnZTogdXJsKGRhdGE6aW1hZ2Uvc3ZnK3htbDsgYmFzZTY0LHBobjJ6eWI0Ynd4dWN6MGlhaHIwY2RvdmwzZDNkeTUzbXk1dmNtY3ZtamF3bWM5emRtY2lpZ2hsYXdkb2RkMGltemJ3ZWNpZ2QybGtkZ2c5aWptd2NoZ2lpaHpwenhkY2IzZzlpaTB4aWMweGlkbXhpZG14aWo0OHp6NDhjZ2YwYWNia3Bzam5tamt1bmRxNWxkZTBsankybWliZG1qa3VuZHE1bGRpeWxqY3ltaWF5bWk0NG5qZ3Ntamt1bWp1MmlkZTBsamMxbGRpNWxqaTFuaWJkbmk0Mm16aXNtamt1bWp1MmlkYXVtZHV4bGRpeWxqY3ltaWF3bGphMW1zd3huYzQybmppZ3F6YXVtZHV4bGR5dW5qYXhpZHl1bmpteWxkYXVtZHkzaWRlMGxqYzFsZGF1bWR5M2llbXltaTQ0bmpnc21jNHduamNnbWprdW5kcTVsZHl1bmpheGlkaTVsanEwb3N3eG5jNDJuamlpaWd6cGJndzlpaW5tem15aWlobjBjbTlyenQwaWkyem16aWlnYzNyeWIydGxseGRwemhyb3BzaXhpajQ4bDNiaGRnZytwaGJoZGdnZ3pkMGl0dGUwbGpjem15d3hsank0bmliZG55NDFtdHlzbXM0Mm9keWdtczQybmp1c255NDBvdHVnbXM0Mm5qdXNtdHF1bmp5eWllbXhsankybnN3eW1jNHhudGtnbnM0eG1ka3NtanF1b2R1MGlka3VvdGNzbWp5dW56cTBpZW01bGpnMW5pd3luczQzbXRnZ29zNDNudG1zbWpxdW10cXppZGV3bGpheG5pd3lteTR3bWppZ3F6ZXdsamkxbXl3eW1pNHdtc2F4bXM0MW5kZ3NtdHl1bnRjeWlkZXhsanUwb2N3eG5pNDFuemlncXpleGxqdTBvY3d4bmk0MW56aWdtdGV1bXR1M2xkZTFsamM1bnNheG1zNHhudGNzbXRxdW5qcTJpZW14bXM0eG50Y3NtdGl1b2RxeWlkZXlsaml4bXN3eG1zNDBvdHVnbXRtdW50aXlsZGV4bGpxNW5zYmRtdHF1bmptM2xkZXhsanE1bnNheG5zNHhuenVzbXRpdW16aTJpZGUxbGplM25zd3hteTR6bWptZ3F6ZTFsamUzbnN3eG5jNDBtenlnbXRxdW5keXlsZGUybGplZ210cXVtZGt6bGRlM2xqeTBteWJkbXRtdW56ZzFsZGU0bGprem5zYXhuYzQzbmR1c210a3VvdGc0aWRlMmxqYXlvY3d4b3M0NW9kZ2dxemU0bGptMW1zd3hvczQ1b2RnZ21qYXVtdG0ybGRlM2xqdTFuaWF5bWM0eG16eXNtdHF1bWRxMmllbXltYzR4bXp5c210YXVvdG01aWRlM2xqZzRvY3c0bGpjMm55YXhuYzQybnpnc29jNDNuamNncXpld2xqazFvc3c0bGpjMm55YTRsamMzbnl3eG1zNDFtenlnb2M0M256Y3NtdHF1bXprNGllbTRsamMzbnl3eG5zNDFtdG1nb3M0eW1zd3huaTQzbWRrZ29zNDNuZGtzbXRjdW16dTVpZW01bGpnMW5pd3hueTQwb2RnZ29zNDRuemlzbXRjdW5pYTVsamcwbGRlM2xqY3ptc2Jkb3M0M25kZXNtdGd1bXRxeGlka3VudGlzbXRrdW1kaXppZGt1bmRjM2xkZTVsaml3bXliZG9zNDBtaXd4b3M0MG5jYTVsamk0b2N3eG9zNDBvdGVnb3M0d25jd3hvczR6bnp5Z3F6Y3VuZGE0bGRlNGxqeXltaWEybGptNG55d3huaTR5bnRpZ25pNHpvZGNzbXRxdW16cTVpZW0ybGptNG55d3htYzR5bnR5Z29zNHpvZG1zbmk0MG90Y2dtdHV1bWRpeWxkeXVuZGszaWVteG9zNDFudHVzbmk0MG90Y2dtam11bWRjNGxka3VuemExaWRpemxqYTNvY3d4bXk0NW90ZWdxeml6bGphM29jd3hvYzQwbmptZ21qYXVtam01bGRpeWxqYTJtaWF4bmk0eW90Y3Ntaml1bWR5eWllbXhuYzQ1bnptc21qaXVtZHl5aWRlemxqY3lvY3d5bXM0em56a2dtdG11bXpheWxkaXdsanUzbWliZG10bXVtemF5bGRpd2xqdTNtaWF4bWk0Mm5kY3Ntam11bWR1Z210aXVuZGc0bGRpemxqeTFueWJkbXRpdW10a3psZGkwbGpjNG5jYXhtczR6b3R5c21qeXVtdGsyaWRld2xqZzJteXd5bnk0d250Z2dxemV5bGphNG5pd3lueTQwbXpxZ210bXVtemcybGRpM2xqeXpueWF4bmM0M216bXNtamN1bmptM2llbXltczQ1bnN3eW55NDJtemNnbWpjdW9kYXhsZGl4bGpneW9jYXlueTQ0bWRlc210cXVuanl5aWVteW55NDRtZGVzbnk0MG90dWdtamV1b3R1c21zNDJvZHlnbXRxdW56bXpsZGV1bmpnMmlpYm1hd3hzcHNpanltcXdvZGZqaWo0OGwzYmhkZ2crcGM5bnBqd3ZjM3pucGc9PSk7IGJhY2tncm91bmQtc2l6ZTogMTRweCAxNHB4OyBiYWNrZ3JvdW5kLWNvbG9yOiAjYmQwODFjOyBwb3NpdGlvbjogYWJzb2x1dGU7IG9wYWNpdHk6IDE7IHotaW5kZXg6IDg2NzUzMDk7IGRpc3BsYXk6IG5vbmU7IGN1cnNvcjogcG9pbnRlcjsgYm9yZGVyOiBub25lOyAtd2Via2l0LWZvbnQtc21vb3RoaW5nOiBhbnRpYWxpYXNlZDsgYmFja2dyb3VuZC1wb3NpdGlvbjogM3B4IDUwJTsgYmFja2dyb3VuZC1yZXBlYXQ6IG5vLXJlcGVhdCBuby1yZXBlYXQ7XCI+U2F2ZTwvc3Bhbj48c3BhbiBzdHlsZT1cImJvcmRlci10b3AtbGVmdC1yYWRpdXM6IDJweDsgYm9yZGVyLXRvcC1yaWdodC1yYWRpdXM6IDJweDsgYm9yZGVyLWJvdHRvbS1yaWdodC1yYWRpdXM6IDJweDsgYm9yZGVyLWJvdHRvbS1sZWZ0LXJhZGl1czogMnB4OyB0ZXh0LWluZGVudDogMjBweDsgd2lkdGg6IGF1dG87IHBhZGRpbmc6IDBweCA0cHggMHB4IDBweDsgdGV4dC1hbGlnbjogY2VudGVyOyBmb250LXN0eWxlOiBub3JtYWw7IGZvbnQtdmFyaWFudC1jYXBzOiBub3JtYWw7IGZvbnQtd2VpZ2h0OiBib2xkOyBmb250LXN0cmV0Y2g6IG5vcm1hbDsgZm9udC1zaXplOiAxMXB4OyBsaW5lLWhlaWdodDogMjBweDsgZm9udC1mYW1pbHk6ICdIZWx2ZXRpY2EgTmV1ZScsIEhlbHZldGljYSwgc2Fucy1zZXJpZjsgY29sb3I6ICNmZmZmZmY7IGJhY2tncm91bmQtaW1hZ2U6IHVybChkYXRhOmltYWdlL3N2Zyt4bWw7IGJhc2U2NCxwaG4yenliNGJ3eHVjejBpYWhyMGNkb3ZsM2QzZHk1M215NXZjbWN2bWphd21jOXpkbWNpaWdobGF3ZG9kZDBpbXpid2VjaWdkMmxrZGdnOWlqbXdjaGdpaWh6cHp4ZGNiM2c5aWkweGljMHhpZG14aWRteGlqNDh6ejQ4Y2dmMGFjYmtwc2pubWprdW5kcTVsZGUwbGp5Mm1pYmRtamt1bmRxNWxkaXlsamN5bWlheW1pNDRuamdzbWprdW1qdTJpZGUwbGpjMWxkaTVsamkxbmliZG5pNDJtemlzbWprdW1qdTJpZGF1bWR1eGxkaXlsamN5bWlhd2xqYTFtc3d4bmM0Mm5qaWdxemF1bWR1eGxkeXVuamF4aWR5dW5qbXlsZGF1bWR5M2lkZTBsamMxbGRhdW1keTNpZW15bWk0NG5qZ3NtYzR3bmpjZ21qa3VuZHE1bGR5dW5qYXhpZGk1bGpxMG9zd3huYzQybmppaWlnenBiZ3c5aWlubXpteWlpaG4wY205cnp0MGlpMnptemlpZ2MzcnliMnRsbHhkcHpocm9wc2l4aWo0OGwzYmhkZ2crcGhiaGRnZ2d6ZDBpdHRlMGxqY3pteXd4bGp5NG5pYmRueTQxbXR5c21zNDJvZHlnbXM0Mm5qdXNueTQwb3R1Z21zNDJuanVzbXRxdW5qeXlpZW14bGp5Mm5zd3ltYzR4bnRrZ25zNHhtZGtzbWpxdW9kdTBpZGt1b3Rjc21qeXVuenEwaWVtNWxqZzFuaXd5bnM0M210Z2dvczQzbnRtc21qcXVtdHF6aWRld2xqYXhuaXd5bXk0d21qaWdxemV3bGppMW15d3ltaTR3bXNheG1zNDFuZGdzbXR5dW50Y3lpZGV4bGp1MG9jd3huaTQxbnppZ3F6ZXhsanUwb2N3eG5pNDFuemlnbXRldW10dTNsZGUxbGpjNW5zYXhtczR4bnRjc210cXVuanEyaWVteG1zNHhudGNzbXRpdW9kcXlpZGV5bGppeG1zd3htczQwb3R1Z210bXVudGl5bGRleGxqcTVuc2JkbXRxdW5qbTNsZGV4bGpxNW5zYXhuczR4bnp1c210aXVtemkyaWRlMWxqZTNuc3d4bXk0em1qbWdxemUxbGplM25zd3huYzQwbXp5Z210cXVuZHl5bGRlMmxqZWdtdHF1bWRremxkZTNsankwbXliZG10bXVuemcxbGRlNGxqa3puc2F4bmM0M25kdXNtdGt1b3RnNGlkZTJsamF5b2N3eG9zNDVvZGdncXplNGxqbTFtc3d4b3M0NW9kZ2dtamF1bXRtMmxkZTNsanUxbmlheW1jNHhtenlzbXRxdW1kcTJpZW15bWM0eG16eXNtdGF1b3RtNWlkZTNsamc0b2N3NGxqYzJueWF4bmM0Mm56Z3NvYzQzbmpjZ3F6ZXdsamsxb3N3NGxqYzJueWE0bGpjM255d3htczQxbXp5Z29jNDNuemNzbXRxdW16azRpZW00bGpjM255d3huczQxbXRtZ29zNHltc3d4bmk0M21ka2dvczQzbmRrc210Y3VtenU1aWVtNWxqZzFuaXd4bnk0MG9kZ2dvczQ0bnppc210Y3VuaWE1bGpnMGxkZTNsamN6bXNiZG9zNDNuZGVzbXRndW10cXhpZGt1bnRpc210a3VtZGl6aWRrdW5kYzNsZGU1bGppd215YmRvczQwbWl3eG9zNDBuY2E1bGppNG9jd3hvczQwb3RlZ29zNHduY3d4b3M0em56eWdxemN1bmRhNGxkZTRsanl5bWlhMmxqbTRueXd4bmk0eW50aWduaTR6b2Rjc210cXVtenE1aWVtMmxqbTRueXd4bWM0eW50eWdvczR6b2Rtc25pNDBvdGNnbXR1dW1kaXlsZHl1bmRrM2llbXhvczQxbnR1c25pNDBvdGNnbWptdW1kYzRsZGt1bnphMWlkaXpsamEzb2N3eG15NDVvdGVncXppemxqYTNvY3d4b2M0MG5qbWdtamF1bWptNWxkaXlsamEybWlheG5pNHlvdGNzbWppdW1keXlpZW14bmM0NW56bXNtaml1bWR5eWlkZXpsamN5b2N3eW1zNHpuemtnbXRtdW16YXlsZGl3bGp1M21pYmRtdG11bXpheWxkaXdsanUzbWlheG1pNDJuZGNzbWptdW1kdWdtdGl1bmRnNGxkaXpsankxbnliZG10aXVtdGt6bGRpMGxqYzRuY2F4bXM0em90eXNtanl1bXRrMmlkZXdsamcybXl3eW55NHdudGdncXpleWxqYTRuaXd5bnk0MG16cWdtdG11bXpnMmxkaTNsanl6bnlheG5jNDNtem1zbWpjdW5qbTNpZW15bXM0NW5zd3lueTQybXpjZ21qY3VvZGF4bGRpeGxqZ3lvY2F5bnk0NG1kZXNtdHF1bmp5eWllbXlueTQ0bWRlc255NDBvdHVnbWpldW90dXNtczQyb2R5Z210cXVuem16bGRldW5qZzJpaWJtYXd4c3BzaWp5bXF3b2RmamlqNDhsM2JoZGdnK3BjOW5wand2YzN6bnBnPT0pOyBiYWNrZ3JvdW5kLXNpemU6IDE0cHggMTRweDsgYmFja2dyb3VuZC1jb2xvcjogI2JkMDgxYzsgcG9zaXRpb246IGFic29sdXRlOyBvcGFjaXR5OiAxOyB6LWluZGV4OiA4Njc1MzA5OyBkaXNwbGF5OiBub25lOyBjdXJzb3I6IHBvaW50ZXI7IGJvcmRlcjogbm9uZTsgLXdlYmtpdC1mb250LXNtb290aGluZzogYW50aWFsaWFzZWQ7IGJhY2tncm91bmQtcG9zaXRpb246IDNweCA1MCU7IGJhY2tncm91bmQtcmVwZWF0OiBuby1yZXBlYXQgbm8tcmVwZWF0O1wiPlNhdmU8L3NwYW4+Wy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd10iLCJwb3N0X3RpdGxlIjoiVlJUIFNhbmRib3g6IGxlYWRpbmcgdGhlIHdheSBvbiBzdGFydHVwIGFuZCBtZWRpYSBjb2xsYWJvcmF0aW9uIGluIEV1cm9wZSIsInBvc3RfbGluayI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi92cnQtc2FuZGJveC1sZWFkaW5nLXRoZS13YXktb24tc3RhcnR1cC1hbmQtbWVkaWEtY29sbGFib3JhdGlvbi1pbi1ldXJvcGUvIiwicG9zdF9mZWF0dXJlZF9pbWFnZSI6IjxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiVlJUIFNhbmRib3g6IGxlYWRpbmcgdGhlIHdheSBvbiBzdGFydHVwIGFuZCBtZWRpYSBjb2xsYWJvcmF0aW9uIGluIEV1cm9wZVwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMTY3XCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMjAvMDUvVlJULVNhbmRib3gtMzAweDE2Ny5wbmdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj4iLCJwb3N0X2NhdGVnb3JpZXMiOiJNZWRpYSBsYWJzIiwicG9zdF90YWdzIjoiQmVsZ2l1bSwgRmxhbmRlcnMsIFBldGVyIGRlIFBhZXBlLCBTYW5kYm94LCBTYW5kYm94IEh1YiwgVlJULCBWUlQgU2FuZGJveCIsIiVfZWRpdF9sb2NrJSI6IjE2MzQ4MTc5NTY6OTMxIiwiJV9lZGl0X2xhc3QlIjoiOTMzIiwiJXNsaWRlX3RlbXBsYXRlJSI6ImRlZmF1bHQiLCIlX3dwYl92Y19qc19zdGF0dXMlIjoidHJ1ZSIsIiVfd3BnbXBfbG9jYXRpb25fYWRkcmVzcyUiOiJBdWd1c3RlIFJleWVyc2xhYW4gNTIgQiwgMTA0MyBTY2hhYXJiZWVrLCBCZWxnaXVtIiwiJV93cGdtcF9sb2NhdGlvbl9jaXR5JSI6IlNjaGFhcmJlZWsiLCIlX3dwZ21wX2xvY2F0aW9uX3N0YXRlJSI6IkJydXNzZWxzIEhvb2Zkc3RlZGVsaWprIEdld2VzdCIsIiVfd3BnbXBfbG9jYXRpb25fY291bnRyeSUiOiJCZWxnaXVtIiwiJV93cGdtcF9tZXRhYm94X2xhdGl0dWRlJSI6IjUwLjg1MjczNzkiLCIlX3dwZ21wX21ldGFib3hfbG9uZ2l0dWRlJSI6IjQuNDAyMzMxMSIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiMlwiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6Ik47IiwiJV93cGdtcF9tZXRhYm94X3RheG9tb21pZXNfdGVybXMlIjoiTjsiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6Ik47IiwiJV9rbGVvX3RyYW5zcGFyZW50X21lbnVfY29sb3IlIjoid2hpdGUiLCIlX2tsZW9fdGl0bGVfY29sb3IlIjoiIyIsIiVfa2xlb190aXRsZV9iZyUiOiIsIHJlcGVhdCwgaW5oZXJpdCwgc2Nyb2xsLCBsZWZ0IHRvcCIsIiVfa2xlb190aXRsZV9iZ19jb2xvciUiOiIjIiwiJV95b2FzdF93cHNlb19jb250ZW50X3Njb3JlJSI6IjMwIiwiJV95b2FzdF93cHNlb19wcmltYXJ5X2NhdGVnb3J5JSI6IjE0MiIsIiVfdGh1bWJuYWlsX2lkJSI6IjE1MzkzIiwiJV9rbGVvX3RpdGxlX2NoZWNrYm94JSI6IjEiLCIlc2JnX3NlbGVjdGVkX3NpZGViYXIlIjoiMCIsIiVzYmdfc2VsZWN0ZWRfc2lkZWJhcl9yZXBsYWNlbWVudCUiOiIwIiwidGF4b25vbXk9Y2F0ZWdvcnkiOiJNZWRpYSBsYWJzIiwidGF4b25vbXk9cG9zdF90YWciOiJCZWxnaXVtLCBGbGFuZGVycywgUGV0ZXIgZGUgUGFlcGUsIFNhbmRib3gsIFNhbmRib3ggSHViLCBWUlQsIFZSVCBTYW5kYm94In0sImljb24iOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxOC8wMi9tYXJrZXItMS5wbmcifSwiaWQiOjE1MzkxLCJpbmZvd2luZG93X2Rpc2FibGUiOmZhbHNlfSx7InNvdXJjZSI6InBvc3QiLCJ0aXRsZSI6IkFsdGluZ2V0OiByb2JvdCwgZW5nYWdlbWVudCBhbmQgY29uc3RydWN0aXZlIHBvbGl0aWNhbCBqb3VybmFsaXNtIGlubm92YXRpb24iLCJpbmZvd2luZG93X2NvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIkFsdGluZ2V0OiByb2JvdCwgZW5nYWdlbWVudCBhbmQgY29uc3RydWN0aXZlIHBvbGl0aWNhbCBqb3VybmFsaXNtIGlubm92YXRpb25cIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjE0M1wiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIwLzA0L1NjcmVlbi1TaG90LTIwMjAtMDQtMDEtYXQtMTIuNDcuMDYtMzAweDE0My5wbmdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1wYWRkaW5nLWNvbnRlbnRfMjBcIj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1tZXRhIGZjLWl0ZW0tc2Vjb25kYXJ5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2UgZmMtdGV4dC1jZW50ZXJcIj5NZWRpYSBsYWJzPC9kaXY+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tdGl0bGUgZmMtaXRlbS1wcmltYXJ5LXRleHQtY29sb3IgZmMtdGV4dC1jZW50ZXJcIj5BbHRpbmdldDogcm9ib3QsIGVuZ2FnZW1lbnQgYW5kIGNvbnN0cnVjdGl2ZSBwb2xpdGljYWwgam91cm5hbGlzbSBpbm5vdmF0aW9uPC9kaXY+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tY29udGVudCBmYy1pdGVtLWJvZHktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZVwiPlxyXG4gICAgICAgICAgICBBbHRpbmdldCBpcyBidWlsZGluZyBlbmdhZ2VkIGNvbW11bml0aWVzIGFyb3VuZCBwb2xpdGljcyBhY3Jvc3MgRGVubWFyayBhbmQgU3dlZGVuIC0gYW5kIG1ha2luZyBtb25leSBmcm9tIGl0IHRvIGV4cGVyaW1lbnQuXHJcbiAgICAgICAgPC9kaXY+XHJcbjxhIGhyZWY9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvYWx0aW5nZXQtcm9ib3QtZW5nYWdlbWVudC1hbmQtY29uc3RydWN0aXZlLXBvbGl0aWNhbC1qb3VybmFsaXNtLWlubm92YXRpb24vXCI+UmVhZCBtb3JlPC9hPlxyXG4gICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuPC9kaXY+XHJcblxyXG4iLCJjb250ZW50IjoiQWx0aW5nZXQgaXMgYnVpbGRpbmcgZW5nYWdlZCBjb21tdW5pdGllcyBhcm91bmQgcG9saXRpY3MgYWNyb3NzIERlbm1hcmsgYW5kIFN3ZWRlbiAtIGFuZCBtYWtpbmcgbW9uZXkgZnJvbSBpdCB0byBleHBlcmltZW50LiIsImFkZHJlc3MiOiJDb3BlbmhhZ2VuLCBEZW5tYXJrIiwibG9jYXRpb24iOnsibGF0IjoiNTUuNjc2MDk2OCIsImNpdHkiOiJDb3BlbmhhZ2VuIiwiY291bnRyeSI6IkRlbm1hcmsiLCJsbmciOiIxMi41NjgzMzcyIiwib25jbGlja19hY3Rpb24iOiJtYXJrZXIiLCJyZWRpcmVjdF9wZXJtYWxpbmsiOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvYWx0aW5nZXQtcm9ib3QtZW5nYWdlbWVudC1hbmQtY29uc3RydWN0aXZlLXBvbGl0aWNhbC1qb3VybmFsaXNtLWlubm92YXRpb24vIiwiem9vbSI6MiwiZXh0cmFfZmllbGRzIjp7InBvc3RfZXhjZXJwdCI6IkFsdGluZ2V0IGlzIGJ1aWxkaW5nIGVuZ2FnZWQgY29tbXVuaXRpZXMgYXJvdW5kIHBvbGl0aWNzIGFjcm9zcyBEZW5tYXJrIGFuZCBTd2VkZW4gLSBhbmQgbWFraW5nIG1vbmV5IGZyb20gaXQgdG8gZXhwZXJpbWVudC4iLCJwb3N0X2NvbnRlbnQiOiJbdmNfcm93XVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMi8zXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48aDE+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPjxiPkFsdGluZ2V0OiByb2JvdCwgZW5nYWdlbWVudCBhbmQgY29uc3RydWN0aXZlIHBvbGl0aWNhbCBqb3VybmFsaXNtIGlubm92YXRpb248L2I+PC9zcGFuPjwvaDE+XHJcbjxzcGFuIGxhbmc9XCJlbi1VU1wiPktyaXN0b2ZmZXIgSGVjcXVldCBpcyBoZWFkIG9mIHRoZSByYXRoZXIgbW9kZXN0bHkgbmFtZWQgXHUyMDE4cHJvamVjdHMgZGVwYXJ0bWVudFx1MjAxOSBhdFx1MDBhMDwvc3Bhbj48YSBocmVmPVwiaHR0cHM6Ly93d3cuYWx0aW5nZXQuZGsvXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXIgbm9yZWZlcnJlclwiIGRhdGEtYXV0aD1cIk5vdEFwcGxpY2FibGVcIj48c3BhbiBsYW5nPVwiZW4tVVNcIj5BbHRpbmdldDwvc3Bhbj48L2E+PHNwYW4gbGFuZz1cImVuLVVTXCI+IFx1MjAxMyBhbmQgd2l0aCBvbmx5IHR3byBmdWxsLXRpbWUgc3RhZmYsXHUwMGEwb24gdGhlIGZhY2Ugb2YgaXQsIGl0IG1pZ2h0IGFwcGVhciBhIHJhdGhlciBtb2Rlc3Qgb3BlcmF0aW9uLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5CZWhpbmQgdGhlIHNjZW5lcyB0aG91Z2gsIEhlY3F1ZXQgaGFzIHNwZW50IDEwIHllYXJzIGZ1bmRyYWlzaW5nIGZvciB0aGlzIFx1MjAxOG1lZGlhIGxhYlx1MjAxOSB0byBleGlzdCB3aXRoaW4gRGVubWFya1x1MjAxOXMgZGlnaXRhbC1maXJzdCwgcG9saXRpY3MtZmlyc3QgQWx0aW5nZXQgLSB0aGUgRGFuaXNoIGVxdWl2YWxlbnQgb2YgUG9saXRpY28uPC9zcGFuPlxyXG5cclxuXHUyMDFjSSBmdW5kcmFpc2VkIG15IG93biBwb3NpdGlvbi4gVGhhdFx1MjAxOXMgaG93IGl0IGRldmVsb3BlZCxcdTIwMWQgaGUgc2F5cywgZXhwbGFpbmluZyB0aGF0IGhlIGpvaW5lZCB0aGUgYnVzaW5lc3MgYSBkZWNhZGUgYWdvIGFzIGFuIGludGVybi4gTm93IGhlIGhlYWRzIGEgc21hbGwgdGVhbSB3aXRoIGEgcG9ydGZvbGlvIG9mIGRpZmZlcmVudCBlZGl0b3JpYWwgaW5ub3ZhdGlvbiBwcm9qZWN0cy4gXHUyMDFjSXRcdTIwMTlzIDEwMCBwZXIgY2VudCBmaW5hbmNlZCBieSBleHRlcm5hbCBmdW5kaW5nLlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY0l0cyByYWlzb24gZCdcdTAwZWF0cmUgaXMgdG8gZGV2ZWxvcCBkaWdpdGFsIGVkaXRvcmlhbCBwcm9qZWN0cyB0aGF0IHN1cHBvcnQgdGhlIGV4aXN0aW5nIGJ1c2luZXNzIGFuZCBpdCBhbHNvIHdvcmtzIHRvIGRldmVsb3AgbmV3IGVkaXRvcmlhbCBwcm9kdWN0cyB0aGF0IGhhdmUgZWNvbm9taWMgcG90ZW50aWFsLlx1MjAxZDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5FZGl0b3JpYWwgc3RhZmYgYXQgQWx0aW5nZXQgd29yayBhbG9uZyBwb2xpdGljYWwgdmVydGljYWxzIC0gd2hpY2ggYXJlIGNob3NlbiB0byBiZSBjbG9zZWx5IGFsaWduZWQgdG8gZ292ZXJubWVudCBkZXBhcnRtZW50cyAtIHdoZXRoZXIgdGhhdFx1MjAxOXMgZWR1Y2F0aW9uIG9yIGFncmljdWx0dXJlLiBGcm9tIGhlcmUsIHRoZXkgY29udHJpYnV0ZSB0byBhIGNvbW1vbiBmcm9udHBhZ2UgdGhhdFx1MjAxOXMgZmluYW5jZWQgYnkgYWR2ZXJ0aXNpbmcgYW5kIGhhcyBtb3JlIHRoYW4gMTAwLDAwMCBEYW5pc2ggc3Vic2NyaWJlcnMuXHUwMGEwPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlRoZSBpbi1kZXB0aCByZXBvcnRpbmcgd2l0aGluIGVhY2ggdmVydGljYWwgaXMgdGhlbiBwYWlkIGZvciBieSBzdWJzY3JpYmVycywgcmVwcmVzZW50aW5nIHVwIHRvIDgwIHBlciBjZW50IG9mIHJldmVudWVzLCBmcm9tIHBvbGl0aWNhbCBwcm9mZXNzaW9uYWxzLCBwb2xpdGljaWFucyBhbmQgb3RoZXIgaW50ZXJlc3QgZ3JvdXBzLiBcdTIwMWNBbGwgb3JnYW5pc2F0aW9ucyBvciBwZXJzb25zIHdobyBuZWVkIGluZmx1ZW5jZSBpbiB0aGlzIHNwZWNpZmljIHBvbGljeSBhcmVhXHUyMDFkLCBIZWNxdWV0IGV4cGxhaW5zLjwvc3Bhbj5cclxuPGgzPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5GaW5kaW5nIGEgbmljaGU8L3NwYW4+PC9oMz5cclxuPHNwYW4gbGFuZz1cImVuLVVTXCI+VGhlIG1vc3QgcmVndWxhciBpbm5vdmF0aW9uIHdvcmsgaGlzIHRlYW0gZG9lcyBpcyBsZWFkaW5nIHRoZSBkZXZlbG9wbWVudCBvZiBcdTIwMThWb3RlciBBZHZpY2UgQXBwbGljYXRpb25zXHUyMDE5IChWQUFzKSB0aGF0IGhlbHAgcGVvcGxlIG1ha2UgZGVjaXNpb25zIGFib3V0IHdobyB0byB2b3RlIGZvci5cdTAwYTA8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+SGVyZSwgQWx0aW5nZXQgaGFzIGEgYmlnIGZvY3VzIG9uIGNvbGxhYm9yYXRpb24gYW5kIHRoYXQgbWVhbnMgd29ya2luZyB3aXRoIHNvbWUgb2YgdGhlIE5vcmRpY3NcdTIwMTkgYmlnZ2VzdCBtZWRpYSBwbGF5ZXJzLCBpbmNsdWRpbmcgdGhlIHB1YmxpYy1zZXJ2aWNlIGJyb2FkY2FzdGVycyBpbiBEZW5tYXJrIGFuZCBTd2VkZW4sIERSIGFuZCBTVFYsIGFzIHdlbGwgYXMgdGhlIE5vcndlZ2lhbiBwcmVzcyBhZ2VuY3kgTlRCLiBBcyBpbm5vdmF0aW9uIHByb2plY3RzIGdvLCB0aGVzZSBoYXZlIGxvbmcgbGVhZCB0aW1lcyBhbmQgYXJlIGVhc2lseSBtYXBwZWQgYXMgdGhleSBhbGlnbiB0byByZWd1bGFyIHBvbGl0aWNhbCBjeWNsZXMuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY1NWVCBhbmQgRFIgYXJlIHByZXR0eSBwb3dlcmZ1bCBiZWNhdXNlIHBlb3BsZSB0cnVzdCB0aGVtLCB0aGV5IGFyZSBldmVyeXdoZXJlIGFuZCB0aGV5XHUyMDE5cmUgZnJlZS4gV2UgYXJlIHN0cmljdGx5IG5ldXRyYWwsIG90aGVyd2lzZSB3ZSB3b3VsZG5cdTIwMTl0IGJlIGFibGUgdG8gc2VydmUgb3VyIHJlYWRlcnMgd2l0aCB0aGUgcHVycG9zZSB0aGF0IHdlIGhhdmUuIFRoYXRcdTIwMTlzIGEgZ29vZCBiYXNlIGZvciB1cyB0byBidWlsZCBhIFZBQSBiZWNhdXNlIHdlIGRvblx1MjAxOXQgaGF2ZSBhbnkgYmlhcy4gSWYgd2Ugd291bGQgaGF2ZSwgd2Ugd291bGRuXHUyMDE5dCBoYXZlIGEgYnVzaW5lc3MuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY1RoZSBtb3N0IGltcG9ydGFudCB0aGluZyBoZXJlIGlzIHRvIGJlIHZlcnkgY2FyZWZ1bC4gV2UgaGF2ZSBhIGJpZyBkaWFsb2d1ZSB3aXRoIG91ciBjdXN0b21lcnMgb24gaG93IHRvIG1ha2Ugc3VyZSB0aGUgVkFBcyBhcmUgcG9saXRpY2FsbHkgbmV1dHJhbC4gV2UgaGF2ZSBhIHN0cmljdCBzeXN0ZW0gb2YgdGVzdGluZyAtIGluY2x1ZGluZyBvdXIgam91cm5hbGlzdHMgb24gZWFjaCB2ZXJ0aWNhbCAtIHNvIHdlIGhhdmUgYSBiaWcgYmF0dGVyeSBvZiBjb21wZXRlbmNlLlx1MDBhMDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNUaGVuIHdlIGFsc28gaGF2ZSBzY2llbnRpc3RzIHRoYXQgbG9vayB0aHJvdWdoIHN0YXRlbWVudHMgYW5kIHdlIHRlc3Qgb24gdXNlcnMgYXMgd2VsbC4gV2UgbWFrZSB0ZXN0cyBhbmQgc2ltdWxhdGlvbnMgLSBib3RoIGJlZm9yZSBhbmQgYWZ0ZXIgLSBhbmQgdGhhdFx1MjAxOXMgcHJldHR5IGltcG9ydGFudCB3b3JrLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5BZnRlciBhbHJlYWR5IGV4cGFuZGluZyBpdHMgYnVzaW5lc3MgaW50byBTd2VkZW4sIGl0XHUyMDE5cyB0aGVzZSBWQUFzIHRoYXQgcHJlc2VudCBhbiBvcHBvcnR1bml0eSBmb3IgQWx0aW5nZXQgdG8gZXhwYW5kIGludG8gb3RoZXIgY291bnRyaWVzLCBIZWNxdWV0IHNheXMuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY0l0XHUyMDE5cyBhbHNvIGEgaHVnZSBkYXRhc2V0IG9uIGFsbCB0aGUgY2FuZGlkYXRlcyAtIHdoYXQgdGhleSB0aGluayBhYm91dCB0aGUgcG9saXRpY2FsIHN0YW5jZXMgLSBzbyBpdFx1MjAxOXMgdmVyeSBnb29kIGZvciBkYXRhIGpvdXJuYWxpc20uXHUyMDFkPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPldoZW4gaGVcdTIwMTlzIG5vdCBoZWxwaW5nIG5lZ290aWF0ZSB0aGUgbmV4dCBsb25nLXRlcm0gZGVhbCBmb3IgYSBWQUEsIGhlXHUyMDE5cyB3b3JraW5nIHVwIG90aGVyIGVkaXRvcmlhbCBpbm5vdmF0aW9uIHByb2plY3RzIHRoYXQgY291bGQgdWx0aW1hdGVseSBzdXBwb3J0IHRoZSBib3R0b20tbGluZS4gSGVjcXVldCBoYXMgd29uIGZ1bmRpbmcgZnJvbSBHb29nbGUgRE5JLCBhbmQgdmFyaW91cyBuYXRpb25hbCBhbmQgRXVyb3BlYW4gcG9saXRpY2FsIGJvZGllcywgdG8gY29udGludWUgdGhpcyB3b3JrLlx1MDBhMDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNJdFx1MjAxOXMgYmFzZWQgb24gZGlhbG9ndWUgd2l0aCB0aGUgZWRpdG9yaWFsIHRlYW0gLSBzb21ldGltZXMgaXRcdTIwMTlzIG1lIHB1c2hpbmcgdGhlIGlkZWEsIHNvbWV0aW1lcyBpdFx1MjAxOXMgdGhlIG90aGVyIHdheSBhcm91bmQuIFF1aXRlIGEgaGVhdnkgZm9jdXMgbm93IGlzIHRvIHN1cHBvcnQgb3VyIGV4aXN0aW5nIGpvdXJuYWxpc20gd2l0aCBkYXRhLCBkaXNjb3ZlcmluZyBkYXRhLCBjb3ZlcmluZyBzdGF0aXN0aWNzIG9uIHBvbGl0aWNhbCBwYXJ0aWVzIGFuZCBwb2xscywgYnV0IGFsc28gcHJvZHVjaW5nIHNlbWktYXV0by1nZW5lcmF0ZWQgY29udGVudC4gV2hlbiB3ZVx1MjAxOXJlIHdvcmtpbmcgb24gcm9ib3Qgam91cm5hbGlzbSBpdFx1MjAxOXMgdmVyeSBzaG9ydCB0ZXJtIC0gaXQgYWxsIGRlcGVuZHMgb24gd2hhdFx1MjAxOXMgYWxzbyBvbiB0aGUgdGFibGUuXHUwMGEwPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY1dlIGFsc28gd29yayBhIGxvdCB3aXRoIHN0cnVjdHVyZWQgam91cm5hbGlzbSAtIG9uZSBiaWcgcHJvamVjdCBoZXJlIGlzIGNhbGxlZCB0aGUgXHUyMDE4ZGVjaXNpb24gY2hhaW5cdTIwMTksIHdoaWNoIHdlIGhhdmUgd29ya2VkIG91dCBpbiBib3RoIFN3ZWRlbiBhbmQgRGVubWFyayB3aXRoIHN1cHBvcnQgZnJvbSBETkkuXHUwMGEwPC9zcGFuPlxyXG48aDM+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPk9wZW5pbmcgdXAgZ292ZXJubWVudCBkYXRhPC9zcGFuPjwvaDM+XHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNJdFx1MjAxOXMgYmFzZWQgb24gcHVibGljIG9wZW4gZGF0YSBmcm9tIHRoZSBnb3Zlcm5tZW50IGFuZCBwYXJsaWFtZW50cyBpbiBEZW5tYXJrIGFuZCBTd2VkZW4uIEZyb20gaXQsIHdlIG1ha2UgdGhpcyBcdTIwMThsZWdpc2xhdGl2ZSBjaGFpblx1MjAxOSB0byBjcmVhdGUgYXV0by1nZW5lcmF0ZWQsIG1pbmktYXJ0aWNsZXMgZnJvbSBhbGwgdGhlIGxlZ2lzbGF0aXZlIHN0ZXBzIGluIHRoZSBwYXJsaWFtZW50LiA8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XCJUaGV5IHNwZW5kIGEgbG90IG9mIG1vbmV5IHRvIG1ha2UgdGhlaXIgb3BlbiBkYXRhIGF2YWlsYWJsZSwgc28gdGhleVx1MjAxOXJlIHNvIGhhcHB5IHdoZW4gZmluYWxseSBzb21lb25lIHVzZXMgaXQuXHUyMDFkPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlRoZSByZXN1bHQgaXMgYSB2aXN1YWwgdGltZWxpbmUgdGhhdCB1cGRhdGVzIHdoZW4gYSBnaXZlbiBwaWVjZSBvZiBsZWdpc2xhdGlvbiB0YWtlcyBhbm90aGVyIHN0ZXAgdGhyb3VnaCB0aGUgcmVsZXZhbnQgcHJvY2VzcywgY29tcGxlbWVudGVkIGJ5IGxvbmdlciBwaWVjZXMgd3JpdHRlbiBieSBBbHRpbmdldCBqb3VybmFsaXN0cy48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+PGltZyBjbGFzcz1cImFsaWdubm9uZSB3cC1pbWFnZS0xNTM2MyBzaXplLW1lZGl1bVwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIwLzA0L0FsdGluZ2V0LURlY2lzaW9uLUNoYWluLTMwMHgxOTEucG5nXCIgYWx0PVwiXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIxOTFcIiAvPjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNPZiBjb3Vyc2UsIHdlIG5vdyBhdXRvbWF0ZSBzb21lIHByb2Nlc3NlcyB0aGF0IHdlIGRpZCBtYW51YWxseSBiZWZvcmUsIHdoaWNoIGlzIHZlcnkgZ29vZCwgYnV0IHdlIGFsc28gcHV0IGFuIGV4dHJhIGRpbWVuc2lvbiB0byBvdXIgam91cm5hbGlzbS4gV2hlbiB5b3UgcmVhZCBhbiBhcnRpY2xlIC0gZXZlbiB0aG91Z2ggeW91XHUyMDE5dmUgcmVhZCB0aGUgZnVsbCBhcnRpY2xlIC0gaXRcdTIwMTlzIG5vdCB0aGUgZW5kIHByb2R1Y3QuIEl0XHUyMDE5cyBwYXJ0IG9mIGEgYmlnZ2VyIHdob2xlLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNUaGUgbGF0ZXN0IHRoaW5nIGluIHRoZSBTd2VkaXNoIHZlcnNpb24gaXMgLSB3aGVuIGxvZ2dpbmcgaW4sIHlvdSBjYW4gc3Vic2NyaWJlIHRvIG9uZSBvZiB0aGVzZSBzdHJpbmdzIC0gc28gZXZlcnkgdGltZSB0aGVyZSBpcyBhIG5ldyBhcnRpY2xlIG9yIGEgbmV3IGVsZW1lbnQgZnJvbSB0aGUgZGF0YSwgeW91IGdldCBhIG5vdGlmaWNhdGlvbi4gU28geW91XHUyMDE5cmUgYWx3YXlzIGFsZXJ0IG9uIHRoZSBzcGVjaWZpYyBsYXcgcHJvcG9zYWwgdGhhdCB5b3UgZm9sbG93Llx1MDBhMDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNJbiBTd2VkZW4gaXQgaGFzIHBhcnRpY3VsYXIgdmFsdWUgYmVjYXVzZSB0aGVyZVx1MjAxOXMgbm8gb3RoZXIgcGxhY2Ugd2hlcmUgeW91IGJpbmQgdG9nZXRoZXIgZGF0YSBmcm9tIHRoZSBnb3Zlcm5tZW50IGFuZCB0aGUgcGFybGlhbWVudC5cdTIwMWQ8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+QWx0aW5nZXQgd29ya2VkIHdpdGggZGF0YSBqb3VybmFsaXNtIGV4cGVydHMgSm91cm5hbGlzbSsrIGR1cmluZyB0aGUgZGV2ZWxvcG1lbnQgcGhhc2Ugb2YgdGhpcyBwcm9kdWN0LCBcdTIwMWNmb3IgdGhlaXIgY29tcGV0ZW5jZSBvbiBvcGVuIGRhdGFcdTIwMWQsIGJ1dCBmdXJ0aGVyIGRldmVsb3BtZW50cyBhcmUgZG9uZSBpbiBob3VzZS48L3NwYW4+XHJcbjxoMz48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+R2V0dGluZyBkaWFsb2d1ZSB3aXRoIHJlYWRlcnM8L3NwYW4+PC9oMz5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkhlY3F1ZXQgYWxzbyB3b24gR29vZ2xlIEROSSBmdW5kaW5nIGZvciBwdXJzdWluZyBtb3JlIFx1MjAxOGVuZ2FnZWQgam91cm5hbGlzbVx1MjAxOSBhbW9uZyBqb3VybmFsaXN0cyBhbmQgcmVhZGVycyAtIHdoaWNoIHdpbGwgc2VlIHRoZW0gYnVpbGRpbmcgYSBuZXcgZGlnaXRhbCBwbGF0Zm9ybS48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjQSBmZXcgeWVhcnMgYWdvIHdlIGludHJvZHVjZWQgdmVyeSBvcmdhbmlzZWQgZGViYXRlIGVudHJpZXMgaW4gdGhlIHZlcnRpY2FscyAtIGFuZCBpdFx1MjAxOXMgbm93IG1vcmUgb3IgbGVzcyBnZXR0aW5nIGhhbGYgb2YgdGhlIHRyYWZmaWMgLSBiZWNhdXNlIGl0IHJlYWxseSB0dXJuZWQgaW50byBjcmVhdGluZyB0aGUgcG9saXRpY2FsIGNvbW11bml0eSBhcm91bmQgdGhlc2Ugc2VjdG9ycy4gVGhpcyBpcyBqdXN0IGFzIGltcG9ydGFudCBhcyB0aGUgam91cm5hbGlzbS48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjV2hlbiB3ZSBoYXZlIGEgZGViYXRlLCBvbiBob3cgdG8gdHJlYXQgZ3JvdW5kd2F0ZXIgaW4gdGhlIGZhcm1pbmcgc2VjdG9yIGZvciBleGFtcGxlLCB3ZSB0YWtlIGV4cGVydHMsIHRoZSBnb3Zlcm5tZW50LCB0aGUgb3Bwb3NpdGlvbiwgdGhlIGZhcm1lcnMgdGhlbXNlbHZlcywgdGhlIGVudmlyb25tZW50YWwgb3JnYW5pc2F0aW9ucyAtIHRoZSB3aG9sZSBzcGVjdHJlIG9mIGludGVyZXN0IGdyb3Vwcy4gV2UgY3JlYXRlIHRoZSBwbGF0Zm9ybSBmb3IgdGhlbSB0byBoYXZlIGFuIG9yZGVybHkgZGlzY3Vzc2lvbi5cdTAwYTA8L3NwYW4+XHJcblxyXG48Yj48aW1nIGNsYXNzPVwiYWxpZ25ub25lIHNpemUtbWVkaXVtIHdwLWltYWdlLTE1MzY0XCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMjAvMDQvQWx0aW5nZXQtRGViYXRlLTMwMHgxNjMucG5nXCIgYWx0PVwiXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIxNjNcIiAvPjwvYj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNCZWZvcmUsIHdlIHNwZW50IGEgbG90IG9mIHRpbWUgcGVyc3VhZGluZyB0aGVtIHRvIHBhcnRpY2lwYXRlLCBidXQgbm93IHRoZXkgbW9yZSBvciBsZXNzIGNvbWUgdGhlbXNlbHZlcyB0byBiZSBhIHBhcnQgb2YgdGhlIGRpc2N1c3Npb24uIFRoZXkgaGF2ZSB0byBiZSBhdCBBbHRpbmdldCB0byBzdGF5IGluZm9ybWVkIGJlY2F1c2UgYWxsIHRoZSBvdGhlcnMgZG8gaXQuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY0l0XHUyMDE5cyBoYXJkIHRvIGZpbmQgdGhpcyBraW5kIG9mIGRpYWxvZ3VlIGFueXdoZXJlIGVsc2UgdW5sZXNzIHlvdSBtZWV0IHRoZSBwZXJzb24gbGl2ZSBpbiB0aGUgcGFybGlhbWVudCBidWlsZGluZy4gPC9zcGFuPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5UaGV5IGRvIGl0IGJlY2F1c2UgdGhleSBuZWVkIHRvIC0gaWYgdGhleSBuZWVkIHBvbGl0aWNhbCBpbmZsdWVuY2UsIHRoZW4gdGhleSBoYXZlIHRvIHJlYWQgb3VyIG5ld3NwYXBlci5cdTAwYTA8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+QWx0aW5nZXQgaGFzIGFsc28gdGFrZW4gYSBzdGVwIGludG8gY29uc3RydWN0aXZlIGpvdXJuYWxpc20sIHdoaWNoIGlzIHJlc3VsdGluZyBpbiB0aGUgY3JlYXRpb24gb2YgYSBjaXZpbCBzb2NpZXR5IFx1MjAxOGtub3dsZWRnZSBjZW50ZXJcdTIwMTkuIEhlY3F1ZXQgZ290IHRoZSBpbml0aWFsIHdvcmsgdG8gc3RhcnQgc2VydmluZyB0aGlzIGF1ZGllbmNlIHByaXZhdGVseSBmdW5kZWQgZm9yIHRocmVlIHllYXJzLCBkZXNwaXRlIGl0IG5vdCBiZWluZyBhIHN0YW5kYXJkIEFsdGluZ2V0IHZlcnRpY2FsLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNJdFx1MjAxOXMgYSBob21lcGFnZSB3aGVyZSB3ZSBnYXRoZXIgaW5mb3JtYXRpb24gYWJvdXQgd2hhdCBjaXZpbCBzb2NpZXR5IGRvZXMgLSB3ZSBoYXZlIGEgZGF0YWJhc2Ugb24gdGhlIHNjaWVuY2Ugb2YgY2l2aWwgc29jaWV0eSAtIGJ1dCB0aGUgbW9zdCBpbXBvcnRhbnQgdGhpbmcgaXMgb3VyIHRvb2xib3guIEl0XHUyMDE5cyBhIHdlZWtseSBuZXdzbGV0dGVyIHdpdGggY29uc3RydWN0aXZlIGpvdXJuYWxpc20gYXJ0aWNsZXMgb24gdGhpbmdzIGxpa2UgXHUyMDE4aG93IHRvIHJ1biB5b3VyIG9yZ2FuaXNhdGlvbiB3aGVuIHlvdSBoYXZlIGNvcm9uYXZpcnVzXHUyMDE5LiBJdFx1MjAxOXMgbm90IG5ld3MsIGJ1dCBhIG5ld3NsZXR0ZXIgd2l0aCB0b29scy48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjV2UgYWxzbyB1c2UgdGhlIFx1MjAxOGtub3dsZWRnZSBjZW50ZXJcdTIwMTkgdG8gdHJ5IG91dCB0aGluZ3MsIHRlc3Qgc29tZSBuZXcgZGVzaWducywgb3IgaWRlYXMgc3VjaCBhcyBcdTIwMThob3cgd2UgY2FuIGRvIG9ubGluZSBlZHVjYXRpb24/XHUyMDE5LCB0aGluZ3Mgd2UgaGF2ZW5cdTIwMTl0IHRyaWVkIGluIG90aGVyIHBhcnRzIG9mIHRoZSBvcmdhbmlzYXRpb24sIGJ1dCB3ZSBjYW4gdHJ5IGl0IHRoZXJlIGJlY2F1c2Ugd2UgaGF2ZSBmdW5kaW5nLlwiPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPjxpbWcgY2xhc3M9XCJhbGlnbm5vbmUgc2l6ZS1tZWRpdW0gd3AtaW1hZ2UtMTUzNjVcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAyMC8wNC9BbHRpbmdldC1DaXZpbC1Tb2NpZXR5LVRvb2xib3gtMjkyeDMwMC5wbmdcIiBhbHQ9XCJcIiB3aWR0aD1cIjI5MlwiIGhlaWdodD1cIjMwMFwiIC8+PC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkp1c3QgbGF1bmNoaW5nIGluIDIwMjAgaXMgYSBwb2xpdGljYWwgZWR1Y2F0aW9uIHJlc291cmNlIGZvciB0ZWFjaGVycyB0byBzaGFyZSBBbHRpbmdldCBjb250ZW50IHdpdGggcHVwaWxzLiBUaGlzIGlzIHRoZSByZXN1bHQgb2YgYSB0aHJlZS15ZWFyIGZ1bmRlZCBwcm9qZWN0IFx1MjAxMyB5b3V0aCBtZWRpYSBvbiBwb2xpdGljcyBhbmQgc29jaWV0eSBmb2N1c2VkIG9uIGdldHRpbmcgMTMgdG8gMTgteWVhci1vbGRzIG1vcmUgZW5nYWdlZC48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+T25lIG9mIHRoZSBuZXh0IHRoaW5ncyB0byB0aWNrIG9mZiBoaXMgdG8tZG8gbGlzdCBpcyBhIHJlYnJhbmQsIEhlY3F1ZXQgZXhwbGFpbnMsIHRha2luZyBvbiB0aGUgYWxsLWltcG9ydGFudCBcdTIwMThtZWRpYSBsYWJcdTIwMTkgbmFtZXRhZyB0byBtYWtlIHN1cmUgcGVvcGxlIGFjcm9zcyB0aGUgb3JnYW5pc2F0aW9uIGtub3cgd2hhdCBwcm9qZWN0IHdvcmsgaXMgYmVpbmcgZG9uZSAtIGFuZCB3aHkuPC9zcGFuPlxyXG48aDM+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkludGVybmFsIG5lZ290aWF0aW9uPC9zcGFuPjwvaDM+XHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5BbHRpbmdldCBsYXVuY2hlZCBpbiAyMDAwIGFuZCBoYXMgZ3Jvd24gZnJvbSBjb3ZlcmluZyBzaXggdmVydGljYWxzIGFsbGllZCB0byBEYW5pc2ggcG9saXRpY2FsIGRlcGFydG1lbnRzIHRvIHJlcG9ydGluZyBvbiBtb3JlIHRoYW4gMjAgYWNyb3NzIHR3byBuYXRpb25zLiBTaW5jZSBIZWNxdWV0IHN0YXJ0ZWQsIHRoZSBzdGFmZiBoYXMgZ3Jvd24gZnJvbSBhcm91bmQgMjAgdG8gMTUwIGFuZCBBbHRpbmdldCBhbHNvIGJvdWdodCB0aGUgb2xkZXIgU2NhbmRpbmF2aWFuIHBvbGl0aWNhbCB0aXRsZSBNb25kYXkgTW9ybmluZywgaW50ZWdyYXRpbmcgSVQsIHNhbGVzIGFuZCBtb3JlIGZvciBncmVhdGVyIGVmZmljaWVuY3kuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY1dlXHUyMDE5cmUgaW4gdGhlIHByb2Nlc3Mgb2YgcmVicmFuZGluZyBhcyB3ZVx1MjAxOXZlIGhhZCBzaGlmdGluZyBsZWFkZXJzaGlwIGFuZCB0aGUgb3JnYW5pc2F0aW9uIGhhcyBncm93biBhIGxvdC4gTWVkaWEgbGFiIHdvdWxkIHByb2JhYmx5IGJlIHRoZSBiZXN0IHRlcm0gZnJvbSB3aGF0IHdlIGRvIC0gYnV0IGlmIHRoYXRcdTIwMTlzIGFjY2VwdGVkIGluIHRoZSByZXN0IG9mIHRoZSBvcmdhbmlzYXRpb24gaXMgdW5zdXJlLiBUaGF0XHUyMDE5cyBob3cgd2VcdTIwMTlyZSBiZWdpbm5pbmcgdG8gcmVicmFuZCBvdXJzZWx2ZXMgaW50ZXJuYWxseSBhbmQsIHdoZW4gd2UgaGF2ZSB0byBleHBsYWluIHdoYXQgd2UgZG8sIHRoYXRcdTIwMTlzIG1vc3Qgb2Z0ZW4gdGhlIHRlcm0gdGhhdCBjb21lcyB1cC5cdTIwMWQ8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+QnV0IGhlXHUyMDE5cyBhbHNvIGtlZW4gdG8gZ2V0IGEgZGV2ZWxvcGVyIGludG8gaGlzIHRlYW0gbG9uZy10ZXJtLlx1MDBhMDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNXZSBhcmUgcHJldHR5IGFnaWxlIGFuZCBzdGFmZmluZyBkZXBlbmRzIGEgbG90IG9uIHRoZSBwcm9qZWN0LiBUaGUgcmVhc29uIHdoeSBpdFx1MjAxOXMgcG9zc2libGUgZm9yIG1lIHRvIGdldCB0aGluZ3MgZG9uZSBpcyB0aGF0IEkgaGF2ZSBhIGJ1ZGdldC4gSSBjYW4gcHJpb3JpdGlzZSB0aGUgSVQgdGVhbSB0byBtYWtlIGEgY2VydGFpbiB0aGluZyBpbiBhIGNlcnRhaW4gYW1vdW50IG9mIHRpbWUgYW5kIHRoZXkgd2lsbCBwcmlvcml0aXNlIHRoaXMgYmVjYXVzZSBJIGhhdmUgYSBidWRnZXQuXHUwMGEwPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY0J1dCB3ZVx1MjAxOXJlIG9mdGVuIGRlbGF5ZWQgYmVjYXVzZSBvZiBhIGJvdHRsZW5lY2sgXHUyMDEzIGRldmVsb3BlcnMgYXJlIGFsd2F5cyBpbiBkZW1hbmQuIEkgdGhpbmsgdGhhdCBpdCB3aWxsIGhlbHAgYSBsb3QgaW4gZGlnaXRhbCBkZXZlbG9wbWVudCwgdG8gd29yayBtb3JlIGNsb3NlbHkgd2l0aCBkZXZlbG9wZXJzLCB0byBoYXZlIG1vcmUgc3BhY2UgdG8gZXhwZXJpbWVudC5cdTIwMWQ8L3NwYW4+XHJcblxyXG4mbmJzcDtcclxuXHJcbkNPTlRBQ1RcclxuXHJcbjxpbWcgY2xhc3M9XCJhbGlnbm5vbmUgc2l6ZS1tZWRpdW0gd3AtaW1hZ2UtMTUzNjhcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAyMC8wNC9LcmlzdG9mZmVyLUhlY3F1ZXQtMzAweDIyNS5qcGdcIiBhbHQ9XCJcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjIyNVwiIC8+XHJcblxyXG5LcmlzdG9mZmVyIEhlY3F1ZXQsIGhlYWQgb2YgcHJvamVjdHNcclxuVHdpdHRlcjogPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vaGVjcXVldGtcIj5AaGVjcXVldGs8L2E+Wy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddIiwicG9zdF90aXRsZSI6IkFsdGluZ2V0OiByb2JvdCwgZW5nYWdlbWVudCBhbmQgY29uc3RydWN0aXZlIHBvbGl0aWNhbCBqb3VybmFsaXNtIGlubm92YXRpb24iLCJwb3N0X2xpbmsiOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvYWx0aW5nZXQtcm9ib3QtZW5nYWdlbWVudC1hbmQtY29uc3RydWN0aXZlLXBvbGl0aWNhbC1qb3VybmFsaXNtLWlubm92YXRpb24vIiwicG9zdF9mZWF0dXJlZF9pbWFnZSI6IjxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiQWx0aW5nZXQ6IHJvYm90LCBlbmdhZ2VtZW50IGFuZCBjb25zdHJ1Y3RpdmUgcG9saXRpY2FsIGpvdXJuYWxpc20gaW5ub3ZhdGlvblwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMTQzXCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMjAvMDQvU2NyZWVuLVNob3QtMjAyMC0wNC0wMS1hdC0xMi40Ny4wNi0zMDB4MTQzLnBuZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6Ik1lZGlhIGxhYnMiLCJwb3N0X3RhZ3MiOiJhdXRvbWF0aW9uLCBjb25zdHJ1Y3RpdmUgam91cm5hbGlzbSwgRGVubWFyaywgZW5nYWdlZCBqb3VybmFsaXNtLCBHb29nbGUgRE5JLCBwb2xpdGljYWwgam91cm5hbGlzbSwgU3dlZGVuIiwiJV9lZGl0X2xvY2slIjoiMTU4ODkzMzI2ODo5MzMiLCIlX2VkaXRfbGFzdCUiOiI5MzMiLCIlc2xpZGVfdGVtcGxhdGUlIjoiZGVmYXVsdCIsIiVfd3BiX3ZjX2pzX3N0YXR1cyUiOiJ0cnVlIiwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6IkNvcGVuaGFnZW4sIERlbm1hcmsiLCIlX3dwZ21wX2xvY2F0aW9uX2NpdHklIjoiQ29wZW5oYWdlbiIsIiVfd3BnbXBfbG9jYXRpb25fc3RhdGUlIjoiIiwiJV93cGdtcF9sb2NhdGlvbl9jb3VudHJ5JSI6IkRlbm1hcmsiLCIlX3dwZ21wX21ldGFib3hfbGF0aXR1ZGUlIjoiNTUuNjc2MDk2OCIsIiVfd3BnbXBfbWV0YWJveF9sb25naXR1ZGUlIjoiMTIuNTY4MzM3MiIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiMlwiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6Ik47IiwiJV93cGdtcF9tZXRhYm94X3RheG9tb21pZXNfdGVybXMlIjoiTjsiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6Ik47IiwiJV9rbGVvX3RyYW5zcGFyZW50X21lbnVfY29sb3IlIjoid2hpdGUiLCIlX2tsZW9fdGl0bGVfY29sb3IlIjoiIyIsIiVfa2xlb190aXRsZV9iZyUiOiIsIHJlcGVhdCwgaW5oZXJpdCwgc2Nyb2xsLCBsZWZ0IHRvcCIsIiVfa2xlb190aXRsZV9iZ19jb2xvciUiOiIjIiwiJV95b2FzdF93cHNlb19jb250ZW50X3Njb3JlJSI6IjMwIiwiJV95b2FzdF93cHNlb19wcmltYXJ5X2NhdGVnb3J5JSI6IjE0MiIsIiVfa2xlb190aXRsZV9jaGVja2JveCUiOiIxIiwiJV90aHVtYm5haWxfaWQlIjoiMTUzNjEiLCIlX3dwX29sZF9zbHVnJSI6ImFsdGluZ2V0LWF1dG9tYXRpb24tZW5nYWdlbWVudC1hbmQtY29uc3RydWN0aXZlLXBvbGl0aWNhbC1qb3VybmFsaXNtLWlubm92YXRpb24iLCIlc2JnX3NlbGVjdGVkX3NpZGViYXIlIjoiMCIsIiVzYmdfc2VsZWN0ZWRfc2lkZWJhcl9yZXBsYWNlbWVudCUiOiIwIiwidGF4b25vbXk9Y2F0ZWdvcnkiOiJNZWRpYSBsYWJzIiwidGF4b25vbXk9cG9zdF90YWciOiJhdXRvbWF0aW9uLCBjb25zdHJ1Y3RpdmUgam91cm5hbGlzbSwgRGVubWFyaywgZW5nYWdlZCBqb3VybmFsaXNtLCBHb29nbGUgRE5JLCBwb2xpdGljYWwgam91cm5hbGlzbSwgU3dlZGVuIn0sImljb24iOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxOC8wMi9tYXJrZXItMS5wbmcifSwiaWQiOjE1MzU2LCJpbmZvd2luZG93X2Rpc2FibGUiOmZhbHNlfSx7InNvdXJjZSI6InBvc3QiLCJ0aXRsZSI6Ik1lZGlhTGFiIEVBRklUOiBDb2xvbWJpYW4gcGVyc3BlY3RpdmUgb24gbWVkaWEgaW5ub3ZhdGlvbiIsImluZm93aW5kb3dfY29udGVudCI6IjxkaXYgY2xhc3M9XCJmYy1pdGVtLWJveCBmYy1pdGVtLW5vLXBhZGRpbmdcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiTWVkaWFMYWIgRUFGSVQ6IENvbG9tYmlhbiBwZXJzcGVjdGl2ZSBvbiBtZWRpYSBpbm5vdmF0aW9uXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMDBcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAyMC8wMy9Xb3Jrc2hvcF9Gb3RvXzEtMzAweDIwMC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1wYWRkaW5nLWNvbnRlbnRfMjBcIj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1tZXRhIGZjLWl0ZW0tc2Vjb25kYXJ5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2UgZmMtdGV4dC1jZW50ZXJcIj5NZWRpYSBsYWJzPC9kaXY+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tdGl0bGUgZmMtaXRlbS1wcmltYXJ5LXRleHQtY29sb3IgZmMtdGV4dC1jZW50ZXJcIj5NZWRpYUxhYiBFQUZJVDogQ29sb21iaWFuIHBlcnNwZWN0aXZlIG9uIG1lZGlhIGlubm92YXRpb248L2Rpdj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1jb250ZW50IGZjLWl0ZW0tYm9keS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+XHJcbiAgICAgICAgICAgIE1lZGlhIGlubm92YXRpb24gbWV0aG9kb2xvZ2llcyBhcmUgb2Z0ZW4gY3JlYXRlZCBpbiB3ZWxsLWRldmVsb3BlZCBtZWRpYSBtYXJrZXRzLCBidXQgZG8gdGhleSBmdW5jdGlvbiBlcXVhbGx5IHdlbGwgaW4gZGlmZmVyZW50IGNvbnRleHRzIGFyb3VuZCB0aGUgd29ybGQ/IFdlIHNwb2tlIHRvIGEgQ29sb21iaWFuIHVuaXZlcnNpdHkgbWVkaWEgbGFiIHRvIGZpbmQgb3V0IGhvdyBpdCBhcHByb2FjaGVzIGl0cyBpbm5vdmF0aW9uIHByb2plY3RzLlxyXG4gICAgICAgIDwvZGl2PlxyXG48YSBocmVmPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL21lZGlhbGFiLWVhZml0LWNvbG9tYmlhbi1wZXJzcGVjdGl2ZS1vbi1tZWRpYS1pbm5vdmF0aW9uL1wiPlJlYWQgbW9yZTwvYT5cclxuICAgIDwvZGl2PlxyXG4gICAgPC9kaXY+XHJcbjwvZGl2PlxyXG5cclxuIiwiY29udGVudCI6Ik1lZGlhIGlubm92YXRpb24gbWV0aG9kb2xvZ2llcyBhcmUgb2Z0ZW4gY3JlYXRlZCBpbiB3ZWxsLWRldmVsb3BlZCBtZWRpYSBtYXJrZXRzLCBidXQgZG8gdGhleSBmdW5jdGlvbiBlcXVhbGx5IHdlbGwgaW4gZGlmZmVyZW50IGNvbnRleHRzIGFyb3VuZCB0aGUgd29ybGQ/IFdlIHNwb2tlIHRvIGEgQ29sb21iaWFuIHVuaXZlcnNpdHkgbWVkaWEgbGFiIHRvIGZpbmQgb3V0IGhvdyBpdCBhcHByb2FjaGVzIGl0cyBpbm5vdmF0aW9uIHByb2plY3RzLiIsImFkZHJlc3MiOiJDYXJyZXJhIDQ5LCBuXHUwMGZhbWVybyA3IHN1ciA1MCwgTWVkZWxsXHUwMGVkbiwgQW50aW9xdWlhLCBDb2xvbWJpYSIsImxvY2F0aW9uIjp7ImxhdCI6IjYuMTk5NTQ3OTk5OTk5OTk5IiwiY2l0eSI6Ik1lZGVsbFx1MDBlZG4iLCJzdGF0ZSI6IkFudGlvcXVpYSIsImNvdW50cnkiOiJDb2xvbWJpYSIsImxuZyI6Ii03NS41NzkzNCIsIm9uY2xpY2tfYWN0aW9uIjoibWFya2VyIiwicmVkaXJlY3RfcGVybWFsaW5rIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL21lZGlhbGFiLWVhZml0LWNvbG9tYmlhbi1wZXJzcGVjdGl2ZS1vbi1tZWRpYS1pbm5vdmF0aW9uLyIsInpvb20iOjIsImV4dHJhX2ZpZWxkcyI6eyJwb3N0X2V4Y2VycHQiOiJNZWRpYSBpbm5vdmF0aW9uIG1ldGhvZG9sb2dpZXMgYXJlIG9mdGVuIGNyZWF0ZWQgaW4gd2VsbC1kZXZlbG9wZWQgbWVkaWEgbWFya2V0cywgYnV0IGRvIHRoZXkgZnVuY3Rpb24gZXF1YWxseSB3ZWxsIGluIGRpZmZlcmVudCBjb250ZXh0cyBhcm91bmQgdGhlIHdvcmxkPyBXZSBzcG9rZSB0byBhIENvbG9tYmlhbiB1bml2ZXJzaXR5IG1lZGlhIGxhYiB0byBmaW5kIG91dCBob3cgaXQgYXBwcm9hY2hlcyBpdHMgaW5ub3ZhdGlvbiBwcm9qZWN0cy4iLCJwb3N0X2NvbnRlbnQiOiJbdmNfcm93XVt2Y19jb2x1bW4gd2lkdGg9XCIxLzRcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS8yXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48aDE+TWVkaWFMYWIgRUFGSVQ6IENvbG9tYmlhbiBwZXJzcGVjdGl2ZSBvbiBtZWRpYSBpbm5vdmF0aW9uPC9oMT5cclxuPGVtPk1lZGlhIGlubm92YXRpb24gbWV0aG9kb2xvZ2llcyBhcmUgb2Z0ZW4gY3JlYXRlZCBpbiB3ZWxsLWRldmVsb3BlZCBtZWRpYSBtYXJrZXRzLCBidXQgZG8gdGhleSBmdW5jdGlvbiBlcXVhbGx5IHdlbGwgaW4gZGlmZmVyZW50IGNvbnRleHRzIGFyb3VuZCB0aGUgd29ybGQ/IFdlIHNwb2tlIHRvIGEgQ29sb21iaWFuIHVuaXZlcnNpdHkgbWVkaWEgbGFiIHRvIGZpbmQgb3V0IGhvdyBpdCBhcHByb2FjaGVzIGl0cyBpbm5vdmF0aW9uIHByb2plY3RzLjwvZW0+XHJcblxyXG5UaGUgPGEgaHJlZj1cImh0dHA6Ly93d3cuZWFmaXQuZWR1LmNvL21lZGlhbGFiL1BhZ2luYXMvaW5pY2lvLmFzcHhcIj5NZWRpYUxhYiBFQUZJVDwvYT4gaXMgcGFydCBvZiB0aGUgZGVwYXJ0bWVudCBvZiBjb21tdW5pY2F0aW9uIHN0dWRpZXMgYXQgVW5pdmVyc2lkYWQgRUFGSVQsIGxvY2F0ZWQgYXQgdGhlIHVuaXZlcnNpdHlcdTIwMTlzIGNhbXB1cyBpbiBNZWRlbGxcdTAwZWRuLCBDb2xvbWJpYS4gVGhlIGxhYiB3YXMgZm91bmRlZCBpbiAyMDA5LCB3aXRoIG1vZGVzdCByZXNvdXJjZXMgKHNlY29uZC1oYW5kIGNvbXB1dGVycyBhbmQgb25lIHRlYWNoZXIpLCB0byBleHBsb3JlIGRpZ2l0YWwgY29udmVyZ2VuY2UuIFRoaXMgZmlyc3QgaXRlcmF0aW9uIG9mIHRoZSBsYWIgaW52ZXN0aWdhdGVkIHZpcnR1YWwgd29ybGRzIChTZWNvbmQgTGlmZSBhdCB0aGUgdGltZSkgYW5kIGVtZXJnaW5nIG1lZGlhIGZvcm1hdHMsIHN1Y2ggYXMgdmlkZW8gYmxvZ3MgYW5kIGxpdmUgYmxvZ2dpbmcuXHJcblxyXG5cdTIwMWNJbiB0aGUgYmVnaW5uaW5nIGl0IHdhcyB2ZXJ5IGluZm9ybWFsLCBhbmQgdGhlIGFjdGl2aXRpZXMgYW5kIHRvcGljcyB3ZXJlIGJhc2VkIG9uIHBlb3BsZVx1MjAxOXMgcGVyc29uYWwgaW50ZXJlc3RzLFx1MjAxZCBzYXlzIE1hclx1MDBlZGEgSXNhYmVsIFZpbGxhIE1vbnRveWEsIENvb3JkaW5hdG9yIG9mIHRoZSBtYXN0ZXJcdTIwMTlzIGRlZ3JlZSBpbiBUcmFuc21lZGlhIENvbW11bmljYXRpb24gYXQgVW5pdmVyc2lkYWQgRUFGSVQuXHJcblxyXG5JbiAyMDEyIHRoZSBsYWJcdTIwMTlzIHN0YXR1cyB3aXRoaW4gdGhlIHVuaXZlcnNpdHkgd2FzIGZvcm1hbGlzZWQsIGFuZCBpdCB3YXMgZ2l2ZW4gYSBkZWRpY2F0ZWQgcm9vbSBhdCB0aGUgY2FtcHVzLiBUaGUgc2FtZSB5ZWFyIGl0IHN0YXJ0ZWQgaXRzIG93biBZb3VUdWJlIGNoYW5uZWwgPGEgaHJlZj1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL3VzZXIvbWVkaWFsYWJlYWZpdFwiPk1lZGlhTGFiIFRWPC9hPiwgYW5kIGxhdW5jaGVkIHByb2plY3RzIGV4cGxvcmluZyBtZWRpYSBsaXRlcmFjeSBhbmQgdHJhbnNtZWRpYSBzdG9yeXRlbGxpbmcuIFRoZSB5ZWFyIGFmdGVyIHRoZSBFQUZJVCB1bml2ZXJzaXR5IGxhdW5jaGVkIGFuIE1BIGluIHRyYW5zbWVkaWEgY29tbXVuaWNhdGlvbnMsIGNsb3NlbHkgbGlua2VkIHRvIHRoZSBNZWRpYUxhYi5cclxuXHJcbkN1cnJlbnRseSB0aGUgbGFiIGhhcyB0d28gY2xhc3Nyb29tcyBkZWRpY2F0ZWQgdG8gc3R1ZGVudHNcdTIwMTkgd29yaywgd2l0aCBhIG5ldyByZXNlYXJjaCBzcGFjZSBvcGVuaW5nIGluIDIwMjAuIEEgbmV3IEJBIG9uIGludGVyYWN0aXZlIGRlc2lnbiwgYWxzbyBjb25uZWN0ZWQgdG8gdGhlIGxhYiwgd2lsbCBhbHNvIHN0YXJ0IHRoaXMgeWVhci5cclxuXHJcblRvZGF5IHRoZSBsYWIgb3JnYW5pc2VzIGl0cyB3b3JrIGJhc2VkIG9uIGZvdXIgc3RyYXRlZ2ljIHBpbGxhcnM6XHJcbjx1bD5cclxuIFx0PGxpPjxzdHJvbmc+UmVzZWFyY2g8L3N0cm9uZz4gaW50byBuZXcgdGVjaG5vbG9naWVzLCB0aGVpciBhcHBsaWNhdGlvbnMsIGFuZCBuZXcgbWV0aG9kb2xvZ2llczwvbGk+XHJcbiBcdDxsaT48c3Ryb25nPlRlYWNoaW5nIGFuZCBsZWFybmluZzwvc3Ryb25nPiB1c2luZyBuZXcsIGRlY2VudHJhbGl6ZWQsIG9wZW4gYW5kIGNvbGxhYm9yYXRpdmUgbWV0aG9kczwvbGk+XHJcbiBcdDxsaT5UcmFuc21lZGlhIDxzdHJvbmc+Y29udGVudCBjcmVhdGlvbjwvc3Ryb25nPiBmb3IgbmV3IHBsYXRmb3JtczwvbGk+XHJcbiBcdDxsaT48c3Ryb25nPlNvY2lhbCBpbm5vdmF0aW9uPC9zdHJvbmc+IHRoYXQgYWltcyB0byBjcmVhdGUgc29sdXRpb25zIHRvIGNpdGl6ZW5zXHUyMDE5IHByb2JsZW1zLjwvbGk+XHJcbjwvdWw+XHJcblRoZSBsYXN0IHBpbGxhciByZWxhdGVzIHRvIHNvY2lldGFsIGlzc3VlcyB0aGF0IGV4cGxvcmUgdG9waWNzIG91dHNpZGUgdGhlIHRyYWRpdGlvbmFsIG1lZGlhIHNwaGVyZTogXHUyMDFjV2UgZG9uJ3QgdGhpbmsgdGhhdCB0ZWNobm9sb2d5IHBlciBzZSBpcyBpbXBvcnRhbnQuIFJhdGhlciwgdGVjaG5vbG9neSBleGlzdHMgZm9yIHBlb3BsZSxcdTIwMWQgVmlsbGEgTW9udG95YSBzYXlzLiBcdTIwMWNTbyB3ZSB3b3JrIHdpdGggcmVhbCBwZW9wbGUgb24gcmVhbCBwcm9ibGVtcyB0byBkZXZlbG9wIHJlYWwgc29sdXRpb25zIGZvciB0aGVtLlx1MjAxZFxyXG48aDM+SW52ZXN0aWdhdGluZyBkcnVnIHRyYWZmaWM8L2gzPlxyXG5HaXZlbiB0aGUgbGFiXHUyMDE5cyBzdGF0dXMgd2l0aGluIFVuaXZlcnNpZGFkIEVBRklULCB0aGUgdW5pdmVyc2l0eVx1MjAxOXMgc3R1ZGVudHMgYXJlIGhlYXZpbHkgaW52b2x2ZWQgaW4gdGhlIHdvcmsgb2YgTWVkaWFMYWI6IG92ZXIgMjAwIHN0dWRlbnRzIHBhcnRpY2lwYXRlIGluIHRoZSBsYWJcdTIwMTlzIHByb2plY3RzLlsvdmNfY29sdW1uX3RleHRdW3ZjX2dhbGxlcnkgdHlwZT1cImdyaWRcIiBpbWFnZXM9XCIxNTM0NiwxNTM0N1wiXVt2Y19jb2x1bW5fdGV4dF1Tb21lIG9mIHRoZSBpbml0aWF0aXZlcyByZWxhdGUgdG8gdGhlIE1lZGlhTGFiXHUyMDE5cyBleHBlcnRpc2UgaW4gdHJhbnNtZWRpYS4gRm9yIGluc3RhbmNlLCBUaWdvVW5lLCBhIHRlbGVjb21tdW5pY2F0aW9ucyBjb21wYW55LCBjb250cmFjdGVkIHRoZSBsYWIgaW4gMjAxNyB0byBkZXZlbG9wIGEgdHJhbnNtZWRpYSBzdHJhdGVneSBpbiBvcmRlciB0byByZWRlc2lnbiBpdHMgc29jaWFsIHJlc3BvbnNpYmlsaXR5IHN0cmF0ZWd5IGFpbWVkIGF0IHRoZSBjcmVhdGl2ZSBhbmQgcmVzcG9uc2libGUgdXNlIG9mIHRlY2hub2xvZ3kgaW4gQ29sb21iaWEuIFx1MjAxY1dlIGRldmVsb3BlZCBhIGJpZyBzdHJhdGVneSBmb3IgdGhlIHdob2xlIGNvdW50cnksIGFuZCBpdFx1MjAxOXMgYmVlbiBvbmUgb2Ygb3VyIGJpZ2dlc3QgcHJvamVjdHMgc28gZmFyLFx1MjAxZCBWaWxsYSBNb250b3lhIHNheXMuXHJcblxyXG5UaGUgbGFiIGFsc28gd29ya3Mgb24gam91cm5hbGlzdGljIHByb2plY3RzLCBzb21ldGltZXMgaW4gY29sbGFib3JhdGlvbiB3aXRoIHRoZSB1bml2ZXJzaXR5XHUyMDE5cyBjb3Vyc2VzIG9uIGRpZ2l0YWwgam91cm5hbGlzbSBhcyBwYXJ0IG9mIHRoZSBiYWNoZWxvclx1MjAxOXMgZGVncmVlIG9uIENvbW11bmljYXRpb25zLiBGb3IgaW5zdGFuY2UsIGEgcHJvamVjdCBjYWxsZWQgPGEgaHJlZj1cImh0dHA6Ly93d3cuZWFmaXQuZWR1LmNvL21lZGlhbGFiL2xpbmVhcy1hY2Npb24vUGFnaW5hcy9OYXJjb3RvdXItJUUyJTgwJTkzLUVsLWxhZG8tQi1kZS1sYS1oaXN0b3JpYS1kZWwtbmFyY290ciVDMyVBMWZpY28tZW4tTWVkZWxsJUMzJUFEbi5hc3B4XCI+TmFyY290b3VyPC9hPiBpbnZlc3RpZ2F0ZWQgZHJ1ZyB0cmFmZmljIGFuZCB0aGUgaW1wYWN0IG9mIGRydWcgZ2FuZ3MgaW4gdGhlIGNpdHkgb2YgTWVkZWxsXHUwMGVkbi5cclxuXHJcbkZvciB0aGlzIHByb2plY3QsIHRoZSBsYWIgY29sbGFib3JhdGVkIHdpdGggbG9jYWwgYW5kIG5hdGlvbmFsIG5ld3MgcHVibGlzaGVycyBpbiB0aGUgY291bnRyeSwgc3VjaCBhcyB0aGUgbmV3c3BhcGVyIEVsIENvbG9tYmlhbm8gYW5kIHRoZSByYWRpbyBzdGF0aW9uIENhcmFjb2wuIFx1MjAxY1RoZXJlIGFyZSBhIGxvdCBvZiB2aWN0aW1zIGFuZCBmYW1pbGllcyB3aXRoIHRyYWdpYyBzdG9yaWVzLCBhbmQgd2Ugd2FudGVkIHRvIHRlbGwgdGhlaXIgc3RvcmllcyB1c2luZyBuZXcgdGVjaG5vbG9naWVzLFx1MjAxZCBWaWxsYSBNb250b3lhIHNheXMuXHJcblxyXG5UaGUgbGFiIGFpbXMgdG8gcHJvZHVjZSBzaW1pbGFyIGludmVzdGlnYXRpdmUgc3RvcmllcyBldmVyeSB5ZWFyLCBvZnRlbiB3aXRoIHN1cHBvcnQgZnJvbSBleHRlcm5hbCBtZWRpYSBjb21wYW5pZXMuIEFsdGhvdWdoIHN1Y2ggY29sbGFib3JhdGlvbnMgYXJlIGltcG9ydGFudCwgVmlsbGEgTW9udG95YSBzYXlzIHRoYXQgdGhlIGRpZmZlcmVuY2VzIGJldHdlZW4gY29tbWVyY2lhbCBtZWRpYSBjb21wYW5pZXMgYW5kIGFuIGFjYWRlbWljIHJlc2VhcmNoIGxhYiBjYW4gc29tZXRpbWVzIGdldCBpbiB0aGUgd2F5LlxyXG5cclxuXHUyMDFjTWVkaWEgY29tcGFuaWVzIGluIHRoZSByZWdpb24gYXJlIGp1c3Qgd2FraW5nIHVwIHRvIHRoZSBjb252ZXJnZW5jZSBhbmQgZGlnaXRhbGlzYXRpb24sXHUyMDFkIHNoZSBzYXlzLiBcdTIwMWNUaGV5IGFsc28gbmVlZCB0byBtb3ZlIGZhc3QsIGFuZCBhcyBhbiBhY2FkZW1pYyBsYWIgd2UgZG9uXHUyMDE5dCBuZWNlc3NhcmlseSBoYXZlIGVub3VnaCByZXNvdXJjZXMgdG8gZG8gdGhhdC5cdTIwMWRcclxuPGgzPk1hcHBpbmcgbWVkaWEgbGFicyBhcm91bmQgdGhlIHdvcmxkPC9oMz5cclxuSW4gb3JkZXIgdG8gZXhwbG9yZSB0aGUgaGlnaGx5IGNvbXBsZXggZWNvc3lzdGVtIG9mIG1lZGlhIGlubm92YXRpb24sIHRoZSBNZWRpYUxhYiBFQUZJVCBoYXMgYW4gb25nb2luZyBwcm9qZWN0IHRvIGlkZW50aWZ5IGFuZCBjYXRlZ29yaXNlIG1lZGlhIGxhYnMgZ2xvYmFsbHkuIEN1cnJlbnRseSBpdHMgPGEgaHJlZj1cImh0dHA6Ly93d3cuZWFmaXQuZWR1LmNvL21lZGlhbGFiL3Byb3llY3Rvcy1lbi1jdXJzby9QYWdpbmFzL3Npc3RlbWF0aXphY2lvbi1tZWRpYWxhYi1lYWZpdC5hc3B4XCI+ZGF0YWJhc2U8L2E+IGluY2x1ZGVzIG92ZXIgMTUwIGxhYnMsIGNhdGVnb3Jpc2VkIGluIHRocmVlIGdyb3VwcyAoYWNhZGVtaWMsIGNvbW1lcmNpYWwgYW5kIHNvY2lhbCkgYW5kIGNsYXNzaWZpZWQgYmFzZWQgb24gdGhlaXIgYWN0aXZpdGllcyAocmFuZ2luZyBmcm9tIHJlc2VhcmNoIGFuZCB0cmFpbmluZyB0byBwcm9kdWN0IGRldmVsb3BtZW50IGFuZCBjb25zdWx0YXRpb24pLlxyXG5cclxuVGhpcyBtYXBwaW5nIGluaXRpYXRpdmUgaXMgYmFzZWQgb24gb25saW5lIHJlc2VhcmNoLCBhY2NvbXBhbmllZCBieSBpbnRlcnZpZXdzIHdpdGggdGhlIGlkZW50aWZpZWQgbGFicy4gTWVkaWFMYWIgRUFGSVQgaXMgcHJlcGFyaW5nIHRvIHB1Ymxpc2ggYSBwYXBlciBhYm91dCB0aGUgcmVzdWx0cyBsYXRlciB0aGlzIHllYXIsIGJ1dCBzb21lIGZpbmRpbmdzIGFscmVhZHkgZ2l2ZSBhbiBpbmRpY2F0aW9uIG9mIHRoZSBzdGF0ZSBvZiB0aGUgZ2xvYmFsIG5ldHdvcmsgb2YgbWVkaWEgbGFicy5cclxuXHJcbkdlb2dyYXBoaWNhbGx5LCB0aGUgbWFqb3JpdHkgb2YgbWVkaWEgbGFicyBhcmUgYmFzZWQgaW4gRXVyb3BlLCBmb2xsb3dlZCBieSBOb3J0aCBBbWVyaWNhLiBIb3dldmVyLCB0aGUgcmVzZWFyY2ggZmluZHMgdGhhdCBtZWRpYSBpbm5vdmF0aW9uIHVuaXRzIGFyZSBhIGdsb2JhbCBwaGVub21lbm9uLCBhbmQgbGFicyBhcmUgaW5jcmVhc2luZ2x5IGFsc28gYXBwZWFyaW5nIGluIExhdGluIEFtZXJpY2EsIEFzaWEsIEFmcmljYSwgYW5kIE9jZWFuaWEuXHJcblxyXG5UaGUgc3R1ZHkgYWxzbyBmb3VuZCB0aGF0IHRoZSBtYWpvcml0eSBvZiBsYWJzIHdvcmxkd2lkZSBvcGVyYXRlIGluIGFuIGFjYWRlbWljIGNvbnRleHQsIGFsdGhvdWdoIHN1cnByaXNpbmdseSBhY2FkZW1pYyBtZWRpYSBsYWJzIGFyZSBub3QgcHJvbWluZW50IGluIHRoZSBsaXRlcmF0dXJlLiBOb25ldGhlbGVzcywgbW9zdCBsYWJzIGNvbmNlbnRyYXRlIG9uIGNvbnRlbnQgcHJvZHVjdGlvbiBhbmQgdGVjaG5vbG9neSBkZXZlbG9wbWVudCwgd2l0aCByZXNlYXJjaCBhbmQgdGVhY2hpbmcgdGFraW5nIGEgbGVzcyBpbXBvcnRhbnQgcm9sZS5cclxuXHJcbkFzIGZvciBtZWRpYSBsYWJzIG9wZXJhdGluZyBpbiBhIGNvbW1lcmNpYWwgY29udGV4dCwgdGhleSBtb3N0bHkgZm9jdXMgb24gZGV2ZWxvcGluZyBuZXcgcHJvZHVjdHMgYW5kIGJ1c2luZXNzIG1vZGVscyB0byBhZGFwdCB0byB0aGUgY2hhbmdpbmcgbmV3cyBlbnZpcm9ubWVudCBhbmQgZGlnaXRhbCBjb252ZXJnZW5jZSwgd2hpbGUgYWxzbyBkZXZlbG9waW5nIG5ldyBmb3JtYXRzIHRoYXQgYWltIHRvIGF0dHJhY3QgbmV3IGF1ZGllbmNlcy5cclxuXHJcbkZpbmFsbHksIHNvY2lhbCBsYWJzLCB1c3VhbGx5IHJhbiBieSBnb3Zlcm5tZW50cyBvciBub24tZ292ZXJubWVudGFsIG9yZ2FuaXNhdGlvbnMsIHRyeSB0byByZXNwb25kIHRvIGNoYWxsZW5nZXMgaW4gdGhlaXIgY29tbXVuaXRpZXMsIGZvciBleGFtcGxlIGJ5IG9yZ2FuaXNpbmcgbGl2aW5nIGxhYnMgYW5kIGhhY2tlcnNwYWNlcywgVmlsbGEgTW9udG95YSBleHBsYWlucy4gVHlwaWNhbGx5IHRoZSBhaW0gaXMgdG8gYWRkcmVzcyBzb2NpZXRhbCBpc3N1ZXMgc3VjaCBhcyBwcm9tb3RpbmcgbWVkaWEgbGl0ZXJhY3kgYnkgZW1wbG95aW5nIG5ldyB0ZWNobm9sb2dpZXMgYW5kIGJyaW5naW5nIGRpZmZlcmVudCBwcm9mZXNzaW9uYWxzIHRvZ2V0aGVyLiBFeGFtcGxlcyBpbmNsdWRlIDxhIGhyZWY9XCJodHRwczovL3d3dy5tZWRpYWxhYi1wcmFkby5lcy9cIj5NZWRpYWxhYiBQcmFkbzwvYT4gaW4gTWFkcmlkIGFuZCB0aGUgPGEgaHJlZj1cImh0dHBzOi8vd3d3Lm1pbnRpYy5nb3YuY28vcG9ydGFsL2luaWNpby9FbmdsaXNoLW92ZXJ2aWV3L1ZpdmUtRGlnaXRhbC9cIj5WaXZlIERpZ2l0YWw8L2E+IGluaXRpYXRpdmUsIHdoaWNoIGhhcyBzZXQgdXAgbWFueSBsYWJzIGluIHRoZSBDb2xvbWJpYW4gY291bnRyeXNpZGUuXHJcbjxoMz5Db2xvbWJpYW4gcGVyc3BlY3RpdmUgb24gaW5ub3ZhdGlvbjwvaDM+XHJcbkluIHRlcm1zIG9mIGlubm92YXRpb24gbWV0aG9kb2xvZ2llcywgVmlsbGEgTW9udG95YSBzYXlzIHRoYXQgdGhlIE1lZGlhTGFiIEVBRklUIHVzZXMgYSB2YXJpZXR5IG9mIG1ldGhvZHMgb24gYSBjYXNlLWJ5LWNhc2UgYmFzaXMuIEhvd2V2ZXIsIGJhc2VkIG9uIGhlciBleHBlcmllbmNlLCBtZXRob2RvbG9naWVzIHRoYXQgYXJlIGNyZWF0ZWQgaW4gZmlyc3Qtd29ybGQgY291bnRyaWVzIGRvIG5vdCBhbHdheXMgd29yayBpbiBkaWZmZXJlbnQgZW52aXJvbm1lbnRzLlxyXG5cclxuXHUyMDFjSW4gZGV2ZWxvcGluZyBjb3VudHJpZXMgc3VjaCBhcyBDb2xvbWJpYSwgd2UgaGF2ZSBhIGxvdCBvZiBwcm9ibGVtcyB3aXRoIG1ldGhvZG9sb2dpZXMuIFdlIGRvbid0IGhhdmUgdGhlIHNhbWUgcmVzb3VyY2VzLCBvciB0aGUgc2FtZSBjb250ZXh0LCB0aGF0IGlzIHNvbWV0aW1lcyBuZWVkZWQgZm9yIHRoZSBtZXRob2RvbG9neSB0byBiZSBhcHBsaWVkLlx1MjAxZFsvdmNfY29sdW1uX3RleHRdW3ZjX2dhbGxlcnkgdHlwZT1cImdyaWRcIiBpbWFnZXM9XCIxNTM0OCwxNTM0OVwiXVt2Y19jb2x1bW5fdGV4dF1UaGlzIG1lYW5zIHRoYXQgbWV0aG9kb2xvZ2llcyBuZWVkIHRvIGJlIGFkYXB0ZWQgYW5kIG5ldyB3b3JraW5nIG1ldGhvZHMgY3JlYXRlZDogXHUyMDFjV2UgdXNlIGEgbG90IG9mIGxlZ29zIGFuZCBwb3N0LWl0cywgYW5kIGFsdGhvdWdoIHdlIHVzZSBhZ2lsZSBtZXRob2RvbG9naWVzLCBmb3IgZXhhbXBsZSwgSSBkb25cdTIwMTl0IHRoaW5rIHRoZXkgYXJlIGFwcGxpZWQgaW4gYSBcdTIwMThwdXJlXHUyMDE5IHdheSxcdTIwMWQgc2hlIHNheXMuIFx1MjAxY1RoZXkgYXJlIGFwcGxpZWQgaW4gYSBtb3JlIExhdGluIEFtZXJpY2FuIHdheSFcdTIwMWRcclxuXHJcbkFjY29yZGluZyB0byBWaWxsYSBNb250b3lhLCBoZXIgY291bnRlcnBhcnRzIGluIGRldmVsb3BlZCBjb3VudHJpZXMgdGVuZCB0byBoYXZlIGZvY3VzZWQgbGluZXMgb2YgcmVzZWFyY2gsIGFuZCB3ZXN0ZXJuIGxhYnMgb2Z0ZW4gY29uY2VudHJhdGUgb24gbmFycm93bHkgZGVmaW5lZCB0b3BpY3MuIFx1MjAxY1dlIGhhdmUgdG8gd29yayBpbiBhIG1vcmUgcmVhY3RpdmUgbWFubmVyLiBXZSBoYXZlIHRvIGFkYXB0IGJhc2VkIG9uIG91ciBmdW5kaW5nIHNvdXJjZXMsIHNvIHdlIGhhdmUgdG8gYmUgYWJsZSB0byB3b3JrIGluIG1hbnkgY29udGV4dHMsXHUyMDFkIHNoZSBzYXlzLiBcdTIwMWNJdFx1MjAxOXMgaW1wb3J0YW50IHRvIGJlIHJlYWxseSBtdWx0aWZhY2V0ZWQgYW5kIGFibGUgdG8gd29yayBpbiBtYW55IGZpZWxkcywgYW5kIGl0IG1ha2VzIGl0IHJlYWxseSBkaWZmaWN1bHQgdG8gc3BlY2lhbGl6ZS5cdTIwMWRcclxuXHJcbkFzIGZvciBNZWRpYUxhYlx1MjAxOXMgZnV0dXJlIHBsYW5zLCBWaWxsYSBNb250b3lhIGlzIHBhcnRpY3VsYXJseSBpbnRlcmVzdGVkIGluIHZpcnR1YWwgcmVhbGl0eSBhbmQgaG93IFZSIGNhbiBjaGFuZ2UgdGhlIHJlbGF0aW9uc2hpcCBiZXR3ZWVuIHRoZSBjb250ZW50IGFuZCB0aGUgY29uc3VtZXIuIFx1MjAxY0l0J3MgYSBiaWcgc2hpZnQgaW4gdGhlIG5hcnJhdGl2ZSBzdHlsZSwgYmVjYXVzZSBpdCBmb3JjZXMgeW91IHRvIHB1dCB5b3Vyc2VsZiBpbiB0aGUgYXVkaWVuY2VcdTIwMTlzIHNob2VzIHdoZW4geW91IGNvbnN0cnVjdCBzdG9yaWVzIGluIFZSLlx1MjAxZFxyXG5cclxuRmluYWxseSwgdGhlIG1vZGVzdCBiZWdpbm5pbmdzIG9mIHRoZSBNZWRpYUxhYiBFQUZJVCBoYXZlIHRhdWdodCBWaWxsYSBNb250b3lhIHRoYXQgYSBkZWRpY2F0ZWQgc3BhY2UgYW5kIHJlc291cmNlcyBhcmUgc2Vjb25kYXJ5IHdoZW4gaXQgY29tZXMgdG8gc3RhcnRpbmcgYSBtZWRpYSBsYWIgXHUyMDEzIHdoYXQgeW91IG5lZWQgaXMgdGhlIHJpZ2h0IGF0dGl0dWRlLCBhbiBvcGVuIG1pbmQgYW5kIGEgd2lzaCB0byBkZXZlbG9wIG5ldyB0aGluZ3MuXHJcblxyXG5cdTIwMWNJIHRoaW5rIHRoYXQgaXRcdTIwMTlzIGEgbWlzdGFrZSB0byBzdGFydCB3aXRoIHdvcnJ5aW5nIGFib3V0IHRoZSBwbGFjZSBvciB0aGUgYnVkZ2V0LiBJdFx1MjAxOXMgbXVjaCBtb3JlIGltcG9ydGFudCB0byB0aGluayBhYm91dCB0aGUgbWVhbmluZyBvZiB3aGF0IHlvdSBhcmUgZG9pbmcuXHUyMDFkXHJcblxyXG5TaGUgc2F5cyB0aGF0IG1hbnkgbGFicyBmb2N1cyBleGNlc3NpdmVseSBvbiB0aGUgdGVjaG5vbG9neSB3aGVuIHNvbHZpbmcgcHJvYmxlbXMsIGJ1dCBvZnRlbiB0aGUgc291cmNlIG9mIHRoZSBwcm9ibGVtIGFyaXNlcyBmcm9tIGh1bWFuIGlzc3Vlcy4gXHUyMDFjTXkgYWR2aWNlIGlzIG5vdCB0byBzdGFydCB3aXRoIHRlY2hub2xvZ3kgYnV0IHRvIHB1dCB5b3VyIGZvY3VzIG9uIHRoZSBodW1hbiBwcm9ibGVtLiBBbmQgdGhlbiB1c2UgdGVjaG5vbG9neSB0byBzb2x2ZSB0aGF0IHByb2JsZW0uXHUyMDFkXHJcblxyXG5DT05UQUNUIFBPSU5UXHJcblxyXG48aW1nIGNsYXNzPVwiYWxpZ25ub25lIHNpemUtbWVkaXVtIHdwLWltYWdlLTE1MzQ0XCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMjAvMDMvbWFyaWEtaXNhYmVsLXZpbGxhLTIwMTYtMS0yMDB4MzAwLmpwZ1wiIGFsdD1cIlwiIHdpZHRoPVwiMjAwXCIgaGVpZ2h0PVwiMzAwXCIgLz5cclxuXHJcbk1hclx1MDBlZGEgSXNhYmVsIFZpbGxhIE1vbnRveWEsIENvb3JkaW5hdG9yIG9mIHRoZSBtYXN0ZXJcdTIwMTlzIGRlZ3JlZSBpbiBUcmFuc21lZGlhIENvbW11bmljYXRpb24sIFVuaXZlcnNpZGFkIEVBRklUXHJcblxyXG5MaW5rZWRJbjogPGEgaHJlZj1cImh0dHBzOi8vY28ubGlua2VkaW4uY29tL2luL21hciVDMyVBRGEtaXNhYmVsLXZpbGxhLW1vbnRveWEtMDg2NTA1MzFcIj5NYXJcdTAwZWRhIElzYWJlbCBWaWxsYSBNb250b3lhPC9hPlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNFwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxoMz5BdXRob3I8L2gzPlxyXG5bc2ltcGxlLWF1dGhvci1ib3hdWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS80XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddIiwicG9zdF90aXRsZSI6Ik1lZGlhTGFiIEVBRklUOiBDb2xvbWJpYW4gcGVyc3BlY3RpdmUgb24gbWVkaWEgaW5ub3ZhdGlvbiIsInBvc3RfbGluayI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9tZWRpYWxhYi1lYWZpdC1jb2xvbWJpYW4tcGVyc3BlY3RpdmUtb24tbWVkaWEtaW5ub3ZhdGlvbi8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJNZWRpYUxhYiBFQUZJVDogQ29sb21iaWFuIHBlcnNwZWN0aXZlIG9uIG1lZGlhIGlubm92YXRpb25cIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjIwMFwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIwLzAzL1dvcmtzaG9wX0ZvdG9fMS0zMDB4MjAwLmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6Ik1lZGlhIGxhYnMiLCJwb3N0X3RhZ3MiOiIiLCIlX2VkaXRfbG9jayUiOiIxNjE1Mjk4OTA2OjkzMSIsIiVfZWRpdF9sYXN0JSI6IjkzMSIsIiVfdGh1bWJuYWlsX2lkJSI6IjE1MzQ1IiwiJXNsaWRlX3RlbXBsYXRlJSI6ImRlZmF1bHQiLCIlX3dwYl92Y19qc19zdGF0dXMlIjoidHJ1ZSIsIiVfd3BnbXBfbG9jYXRpb25fYWRkcmVzcyUiOiJDYXJyZXJhIDQ5LCBuXHUwMGZhbWVybyA3IHN1ciA1MCwgTWVkZWxsXHUwMGVkbiwgQW50aW9xdWlhLCBDb2xvbWJpYSIsIiVfd3BnbXBfbG9jYXRpb25fY2l0eSUiOiJNZWRlbGxcdTAwZWRuIiwiJV93cGdtcF9sb2NhdGlvbl9zdGF0ZSUiOiJBbnRpb3F1aWEiLCIlX3dwZ21wX2xvY2F0aW9uX2NvdW50cnklIjoiQ29sb21iaWEiLCIlX3dwZ21wX21ldGFib3hfbGF0aXR1ZGUlIjoiNi4xOTk1NDc5OTk5OTk5OTkiLCIlX3dwZ21wX21ldGFib3hfbG9uZ2l0dWRlJSI6Ii03NS41NzkzNCIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiMlwiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6Ik47IiwiJV93cGdtcF9tZXRhYm94X3RheG9tb21pZXNfdGVybXMlIjoiTjsiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6Ik47IiwiJV9rbGVvX3RyYW5zcGFyZW50X21lbnVfY29sb3IlIjoid2hpdGUiLCIlX2tsZW9fdGl0bGVfY2hlY2tib3glIjoiMSIsIiVfa2xlb190aXRsZV9jb2xvciUiOiIjIiwiJV9rbGVvX3RpdGxlX2JnJSI6IiwgcmVwZWF0LCBpbmhlcml0LCBzY3JvbGwsIGxlZnQgdG9wIiwiJV9rbGVvX3RpdGxlX2JnX2NvbG9yJSI6IiMiLCIlX3lvYXN0X3dwc2VvX2NvbnRlbnRfc2NvcmUlIjoiMzAiLCIlX3lvYXN0X3dwc2VvX3ByaW1hcnlfY2F0ZWdvcnklIjoiMTQyIiwiJXNiZ19zZWxlY3RlZF9zaWRlYmFyJSI6IjAiLCIlc2JnX3NlbGVjdGVkX3NpZGViYXJfcmVwbGFjZW1lbnQlIjoiMCIsIiVfeW9hc3Rfd3BzZW9fZXN0aW1hdGVkLXJlYWRpbmctdGltZS1taW51dGVzJSI6IiIsInRheG9ub215PWNhdGVnb3J5IjoiTWVkaWEgbGFicyIsInRheG9ub215PXBvc3RfdGFnIjoiIn0sImljb24iOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxOC8wMi9tYXJrZXItMS5wbmcifSwiaWQiOjE1MzQzLCJpbmZvd2luZG93X2Rpc2FibGUiOmZhbHNlfSx7InNvdXJjZSI6InBvc3QiLCJ0aXRsZSI6Ik5SS2JldGE6IHB1YmxpYyBzZXJ2aWNlIG1lZGlhIGlubm92YXRpb24gZm9yIHRoZSAyMXN0IGNlbnR1cnkiLCJpbmZvd2luZG93X2NvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIk5SS2JldGE6IHB1YmxpYyBzZXJ2aWNlIG1lZGlhIGlubm92YXRpb24gZm9yIHRoZSAyMXN0IGNlbnR1cnlcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjE4MVwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIwLzAzL05SS2JldGEtVmVubi1EaWFncmFtLTMwMHgxODEuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZ1wiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tcGFkZGluZy1jb250ZW50XzIwXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tbWV0YSBmYy1pdGVtLXNlY29uZGFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlIGZjLXRleHQtY2VudGVyXCI+TWVkaWEgbGFiczwvZGl2PlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLXRleHQtY2VudGVyXCI+TlJLYmV0YTogcHVibGljIHNlcnZpY2UgbWVkaWEgaW5ub3ZhdGlvbiBmb3IgdGhlIDIxc3QgY2VudHVyeTwvZGl2PlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2VcIj5cclxuICAgICAgICAgICAgTlJLYmV0YSBoYXMgc3BlbnQgbW9yZSB0aGFuIGEgZGVjYWRlIGRldmVsb3BpbmcgaXRzIGV4cGVydGlzZSB3aGVyZSBtZWRpYSwgdGVjaG5vbG9neSBhbmQgc29jaWV0eSBtZWV0IC0gdG8gaGVscCBOb3J3YXkncyBwdWJsaWMgc2VydmljZSBicm9hZGNhc3RlciwgYW5kIG5vdyB0aGUgd2lkZXIgTm9yd2VnaWFuIG1lZGlhIC0gZ2l2ZSB0aGUgcGVvcGxlIHdoYXQgdGhleSBuZWVkLlxyXG4gICAgICAgIDwvZGl2PlxyXG48YSBocmVmPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL3B1YmxpYy1zZXJ2aWNlLW1lZGlhLWlubm92YXRpb24tMjFzdC1jZW50dXJ5L1wiPlJlYWQgbW9yZTwvYT5cclxuICAgIDwvZGl2PlxyXG4gICAgPC9kaXY+XHJcbjwvZGl2PlxyXG5cclxuIiwiY29udGVudCI6Ik5SS2JldGEgaGFzIHNwZW50IG1vcmUgdGhhbiBhIGRlY2FkZSBkZXZlbG9waW5nIGl0cyBleHBlcnRpc2Ugd2hlcmUgbWVkaWEsIHRlY2hub2xvZ3kgYW5kIHNvY2lldHkgbWVldCAtIHRvIGhlbHAgTm9yd2F5J3MgcHVibGljIHNlcnZpY2UgYnJvYWRjYXN0ZXIsIGFuZCBub3cgdGhlIHdpZGVyIE5vcndlZ2lhbiBtZWRpYSAtIGdpdmUgdGhlIHBlb3BsZSB3aGF0IHRoZXkgbmVlZC4iLCJhZGRyZXNzIjoiQmpcdTAwZjhybnN0amVybmUgQmpcdTAwZjhybnNvbnMgcGxhc3MgMSwgMDM0MCBPc2xvLCBOb3J3YXkiLCJsb2NhdGlvbiI6eyJsYXQiOiI1OS45MzU1MTMwMDAwMDAwMSIsInN0YXRlIjoiT3NsbyIsImNvdW50cnkiOiJOb3J3YXkiLCJsbmciOiIxMC43MjA2MTA1Iiwib25jbGlja19hY3Rpb24iOiJtYXJrZXIiLCJyZWRpcmVjdF9wZXJtYWxpbmsiOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvcHVibGljLXNlcnZpY2UtbWVkaWEtaW5ub3ZhdGlvbi0yMXN0LWNlbnR1cnkvIiwiem9vbSI6MiwiZXh0cmFfZmllbGRzIjp7InBvc3RfZXhjZXJwdCI6Ik5SS2JldGEgaGFzIHNwZW50IG1vcmUgdGhhbiBhIGRlY2FkZSBkZXZlbG9waW5nIGl0cyBleHBlcnRpc2Ugd2hlcmUgbWVkaWEsIHRlY2hub2xvZ3kgYW5kIHNvY2lldHkgbWVldCAtIHRvIGhlbHAgTm9yd2F5J3MgcHVibGljIHNlcnZpY2UgYnJvYWRjYXN0ZXIsIGFuZCBub3cgdGhlIHdpZGVyIE5vcndlZ2lhbiBtZWRpYSAtIGdpdmUgdGhlIHBlb3BsZSB3aGF0IHRoZXkgbmVlZC4iLCJwb3N0X2NvbnRlbnQiOiJbdmNfcm93XVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMi8zXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48aDE+TlJLYmV0YTogcHVibGljIHNlcnZpY2UgbWVkaWEgaW5ub3ZhdGlvbiBmb3IgdGhlIDIxc3QgY2VudHVyeTwvaDE+XHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5BcyBtZWRpYSBsYWJzIGdvLCA8L3NwYW4+PGEgaHJlZj1cImh0dHBzOi8vbnJrYmV0YS5uby9cIj48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+TlJLYmV0YTwvc3Bhbj48L2E+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPiwgZnJvbSB0aGUgTm9yd2VnaWFuIHB1YmxpYyBzZXJ2aWNlIGJyb2FkY2FzdGVyLCBwaXRjaGVzIGl0c2VsZiBsZXNzIGFzIGEgPC9zcGFuPjxpPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5sYWI8L3NwYW4+PC9pPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj4sIG1vcmUgYXMgYW4gaW5ub3ZhdGlvbiBzZXJ2aWNlIGZvciAzLDUwMCBzdGFmZiB3b3JraW5nIG9uIGJlaGFsZiBvZiA1LjMgbWlsbGlvbiBwZW9wbGUgc3ByZWFkIGFjcm9zcyB0aGUgY291bnRyeVx1MjAxOXMgdmFzdCwgbW91bnRhaW5vdXMgZ2VvZ3JhcGh5Ljwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5BbmRlcnMgSG9mc2V0aCBoYXMgd29ya2VkIGluIHRoaXMgdGVhbSBmb3IgYSBkZWNhZGUgYW5kIGhlXHUyMDE5cyBzdGlsbCBhIHBhcnQtdGltZSBqb3VybmFsaXN0IGZvciB0aGUgPGEgaHJlZj1cImh0dHBzOi8vbnJrYmV0YS5uby9cIj5ucmtiZXRhLm5vPC9hPiBibG9nLCB3aGVyZSBOUktcdTIwMTlzIGluc2lnaHQgYW5kIGlubm92YXRpb24gdGVhbSBzdGFydGVkLCBidXQgbm93IGhlIGFsc28gYWN0cyBhcyBhbiBpbnRlcm5hbCwgc3RyYXRlZ2ljIGFkdmlzb3IgdG8gdGhlIG9jdG9nZW5hcmlhbiBvcmdhbmlzYXRpb24uXHUwMGEwPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY1RoZSBpbml0aWFsIG9wcG9ydHVuaXR5IHdhcyBnaXZlbiB0byB1cyBpbiBhcm91bmQgMjAwNi4gSXQgc3RhcnRlZCBvdXQgYXMgYSBibG9nIGJlY2F1c2UgdGhhdCB3YXMgc29tZXRoaW5nIHBlb3BsZSBkaWQgaW4gMjAwNi4gU2V2ZXJhbCBvZiB1cyBoYWQgcHJpdmF0ZSBibG9ncyB3cml0aW5nIGFib3V0IHRoaW5ncyB3ZSB3ZXJlIHRoaW5raW5nIGFib3V0IGFuZCBkb2luZy4gVGhlIHF1ZXN0aW9uIHdhcyBhc2tlZCAtIFx1MjAxOHNob3VsZG5cdTIwMTl0IHRoaXMgYmUgc29tZXRoaW5nIHRoYXQgaXMgcGFydCBvZiBvdXIgb3JnYW5pc2F0aW9uP1x1MjAxOS5cdTAwYTA8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjV2UgZXhwZXJpbWVudGVkIGEgbG90IHdpdGggcHVibGlzaGluZyBpbiB0aGUgZWFybHkgZGF5cy4gU2xvd2x5IHRoYXRcdTIwMTlzIG1hdHVyZWQgaW50byBhIHRlY2hub2xvZ3kgYW5kIG1lZGlhIHZlcnRpY2FsIGZvciBOUksgYW5kIG5vdyB3ZVx1MjAxOXJlIHNwZWNpYWxpc2luZyAtIHNvbWUgb2Ygb3VyIHRlYW0gYXJlIHdyaXRpbmcsIHNvbWUgZG9pbmcgUiZhbXA7RCwgc29tZSBhZHZpc2luZyB0aGUgb3JnYW5pc2F0aW9uLiBJdCBtYWRlIHNlbnNlIHRoYXQgaXQgaGFwcGVuZWQgbGlrZSB0aGF0IDE1IHllYXJzIGFnbywgYnV0IG1heWJlIHdvdWxkblx1MjAxOXQgcGxheSBvdXQgdGhlIHNhbWUgdG9kYXkuXHUwMGEwPC9zcGFuPlxyXG48aDM+QXNraW5nIHRvdWdoIHF1ZXN0aW9uczwvaDM+XHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNPdXIgcmVtaXQgaXMgdG8gYXNrIHVuY29tZm9ydGFibGUgcXVlc3Rpb25zLCBpbiBhIGNvbnN0cnVjdGl2ZSB3YXksIG9mIGNvdXJzZS4gV2UgdW5kZXJzdGFuZCB0aGUgcG9pbnQgb2YgcHVibGljIHNlcnZpY2UuIFdlIHVuZGVyc3RhbmQgaG93IHRoZSBtZWRpYSB3b3JrcywgaG93IGEgbG90IG9mIHRlY2hub2xvZ3kgd29ya3MgYW5kIG91ciByb2xlIGluIHNvY2lldHkuIFdlIGFyZSBhYmxlIHRvIHNheSB0aGluZ3MgdGhhdCB3ZSBuZWVkIHRvIHNheSBhbmQga25vdyB3aG8gdG8gc2F5IGl0IHRvLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWM8L3NwYW4+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPldoZW4gcGVvcGxlIGFzayBtZSB3aGF0IEkgZG8sIHRoZSBzaG9ydCBhbnN3ZXIgaXMgLSBJIHRyeSB0byB1bmRlcnN0YW5kIGNoYW5nZSBvbiBiZWhhbGYgb2YgdGhlIE5vcndlZ2lhbiBCcm9hZGNhc3RpbmcgQ29ycG9yYXRpb24uXHUyMDFkPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkhvZnNldGgsIHdobyB3YXMgdGhlIDxhIGhyZWY9XCJodHRwczovL3JldXRlcnNpbnN0aXR1dGUucG9saXRpY3Mub3guYWMudWsvcGVvcGxlL2FuZGVycy1ob2ZzZXRoXCI+aW5hdWd1cmFsIEdvb2dsZSBEaWdpdGFsIE5ld3MgRmVsbG93PC9hPiBhdCB0aGUgUmV1dGVycyBJbnN0aXR1dGUgYXQgT3hmb3JkIFVuaXZlcnNpdHkgYmFjayBpbiAyMDE2LCBlc2NoZXdzIHRoZSBcdTIwMThtZWRpYSBsYWJcdTIwMTkgbGFiZWwuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY1dlIHVzZWQgdG8gY2FsbCBvdXJzZWx2ZXMgdGhlIFx1MjAxOHNhbmRib3hcdTIwMTkgb2YgTlJLLiBEb2luZyB0aGluZ3MgdGhhdCBtYXliZSBzaG91bGRuXHUyMDE5dCBiZSBkb25lIGJ5IHRoZSB3aWRlciBvcmdhbmlzYXRpb24gYmVmb3JlIGJlaW5nIHRlc3RlZCBmaXJzdC5cdTAwYTA8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjV2Ugd2VyZSBuZXZlciBidWlsdC4gV2Ugd2VyZSBqdXN0IGdpdmVuIHBlcm1pc3Npb24gdG8gZG8gdGhpbmdzIGEgbG9uZyB0aW1lIGFnby4gQW5kIHRoZSBvcmdhbmlzYXRpb24gc2VlcyBpdCBtYWtlcyBzZW5zZSB0byBsZXQgdXMgZG8gb3VyIHRoaW5nLiBCdXQgd2UgZG8gaGF2ZSBhIHNtYWxsIHBoeXNpY2FsIHNwYWNlIGFuZCBhIHB1Ymxpc2hpbmcgcGxhdGZvcm0uXHUyMDFkPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkhlIGFsc28gZW1waGFzaXNlcyB0aGF0IHRoZWlyIHRlYW0gb2Ygc2V2ZW4gd29ya3MgYXQgdGhlIGludGVyc2VjdGlvbiBvZiB0ZWNobm9sb2d5LCBtZWRpYSA8L3NwYW4+PGk+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPmFuZCBzb2NpZXR5PC9zcGFuPjwvaT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+LCB0aGUgbGF0dGVyIGRlZXBseSBpbmZvcm1lZCBieSB0aGUgcHVibGljIHNlcnZpY2UgcmVtaXQgb2YgdGhlIHdpZGVyIG9yZ2FuaXNhdGlvbi48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjVGhlIHJlYXNvbiB3ZVx1MjAxOXJlIGhlcmUgaXMgZm9yIHRoZSBhdWRpZW5jZSAtIGEgYmlnIG1lYXN1cmVtZW50IGZvciB1cyBpcyAtIFx1MjAxOHdoYXQgZG9lcyB0aGUgYXVkaWVuY2Ugd2FudD9cdTIwMTksIG5vdCBcdTIwMTh3aGF0IGRvIHdlIHdhbnQ/XHUyMDE5Llx1MDBhMDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNJdFx1MjAxOXMgYSBWZW5uIGRpYWdyYW0gLSB0ZWNobm9sb2d5IGhhcyBubyB2YWx1ZSBpbiBpdHNlbGYsIG5laXRoZXIgZG9lcyBtZWRpYSAtIHdoZXJlIHRoZXkgbWVldCBzb2NpZXR5IGlzIHdoZXJlIHRoZXkgY2hhbmdlIHRoaW5ncyBhbmQgd2hlcmUgd2Ugd29yay48L3NwYW4+XHJcblxyXG5bY2FwdGlvbiBpZD1cImF0dGFjaG1lbnRfMTUzMTlcIiBhbGlnbj1cImFsaWdubm9uZVwiIHdpZHRoPVwiMzAwXCJdPGltZyBjbGFzcz1cInNpemUtbWVkaXVtIHdwLWltYWdlLTE1MzE5XCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMjAvMDMvU2NyZWVuLVNob3QtMjAyMC0wMy0xNi1hdC0wOS41NC4xNC0zMDB4MTgwLnBuZ1wiIGFsdD1cIlwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMTgwXCIgLz4gV2hlcmUgTlJLYmV0YSB3b3Jrc1svY2FwdGlvbl1cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNOUksgaW4gZ2VuZXJhbCBpcyBpbiBhIHZlcnkgZ29vZCBwb3NpdGlvbiBhcyBtZWRpYSBjb21wYW5pZXMgZ28gLSBpdCByZWFjaGVzIDg5IHBlciBjZW50IG9mIHRoZSBwb3B1bGF0aW9uIGRhaWx5IC0gaW5jbHVkaW5nIHBlb3BsZSBpbiB0aGVpciB0ZWVucyBhbmQgMjBzLCBhbmQgd2UgYXJlIGJyb2FkbHkgdHJ1c3RlZCBieSBhIGxvdCBvZiB0aGUgcG9wdWxhdGlvbi5cdTAwYTA8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjVGhlIG1haW4gYm9udXMgb2YgdGhpcyBpcyBcdTIwMTMgc29tZXRoaW5nIG91ciBoZWFkIG9mIGNvbW1pc3Npb25zIHNhaWQgYSBmZXcgd2Vla3MgYmFjayBcdTIwMTMgd2UgZG9uXHUyMDE5dCBuZWVkIHRvIHBhbmljIGFib3V0IGxvc2luZyBvdXIgYXVkaWVuY2UsIHdlIGhhdmUgdGhlIG9wcG9ydHVuaXR5IHRvIHRoaW5rPC9zcGFuPiA8c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDE4d2UgaGF2ZSB0aGVpciBhdHRlbnRpb24sIGhvdyBzaG91bGQgd2UgdXNlIGl0P1x1MjAxOS48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjMTAgeWVhcnMgYWdvIHRoZXJlIHdhcyBhIGJpZyBzdGF0dXMgZGlmZmVyZW5jZSBiZXR3ZWVuIGJlaW5nIGluIFRWIGFuZCBvbmxpbmUgbmV3cywgYnV0IHRoYXQgaGFzIGZsaXBwZWQgMTgwIGRlZ3JlZXMuIFdlIGhhdmUgY2hhbGxlbmdlcyB3aXRoIHRoZSB0cmFuc2Zvcm1hdGlvbiBmcm9tIGxpbmVhciB0byBvbmxpbmUgY29udGVudCwgYnV0IG5vdCBvbiBhIGxldmVsIHdpdGggbWFueSBvdGhlciBwdWJsaWMgc2VydmljZSBicm9hZGNhc3RlcnMuPC9zcGFuPlxyXG48aDM+RGVjb3VwbGluZyBmdW5kaW5nIGZyb20gcGxhdGZvcm1zPC9oMz5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY1doYXQgd2UgZGlkIGluIE5SSyBzZXZlcmFsIHllYXJzIGFnbyB3YXMgdG8gc3RvcCBzYXlpbmcgbW9uZXkgd2FzIHRpZWQgdG8gc3BlY2lmaWMgcGxhdGZvcm1zIC0gbm93IHlvdVx1MjAxOXZlIGdvdCBvbmUgYnVkZ2V0IGZvciB3aGF0IHlvdSBuZWVkIHRvIGRvLCBhbmQgeW91IGNhbiBkbyB0aGUgdGhpbmcgdGhhdFx1MjAxOXMgYmVzdCBvbiB3aGF0ZXZlciBwbGF0Zm9ybS5cdTAwYTA8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjRnJvbSB0b3AgbWFuYWdlbWVudCBhbGwgdGhlIHdheSBkb3duLCB3ZSBoYXZlIHBlb3BsZSB3aG8gdW5kZXJzdGFuZCB0aGUgY2hhbmdlcyB0aGF0IG5lZWQgdG8gYmUgbWFkZSBhbmQgd2UgYXJlIGFkdmlzaW5nIG9uIHRoaW5ncyB3aGVyZSB3ZSBtaWdodCBoYXZlIHNvbWV0aGluZyB0byBzYXkuXHUyMDFkPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkluIHRlcm1zIG9mIGhvdyB0aGV5IFx1MjAxOGRvIGlubm92YXRpb25cdTIwMTksIHRoZSB0ZWFtIGlzIG5vdCB3ZWRkZWQgdG8gc3ByaW50cyBvciBoYWNrcywgYnV0IGlzIHRoZSBmaXJzdCBwb3J0IG9mIGNhbGwgZm9yIHVuZGVyc3RhbmRpbmcgXHUyMDFjc2hpbnkgbmV3IHRoaW5nc1x1MjAxZCB2aWEgaXRzIHJpc2sgbWFuYWdlbWVudCBwcm9ncmFtbWUuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY1dlIHN0YXJ0ZWQgdGhpcyBhIGZldyB5ZWFycyBiYWNrLCBjZW50cmFsbHkgYW5hbHlzaW5nIGNoYW5nZXMgaW4gdGVjaG5vbG9neSwgc29jaWV0eSBhbmQgbWVkaWEsIGFuZCBjb250ZXh0dWFsaXNpbmcgZWFybHkgd2hhdCBjb3VsZCB0aGV5IG1lYW4gZm9yIG91ciBtaXNzaW9uIGFzIGEgcHVibGljIHNlcnZpY2UgYnJvYWRjYXN0ZXIuIFx1MjAxOFdoYXQgd2lsbCB3ZSBuZWVkIHRvIGtub3cgdG8gaGFuZGxlIGl0P1x1MjAxOS4gXHUyMDE4SXMgaXQgc29tZXRoaW5nIHdlIGNhbiBkaWUgZnJvbT9cdTIwMTkuIFNvIHdlIGRvblx1MjAxOXQgaGF2ZSB0byBoYW5kbGUgdGhpbmdzIGFmdGVyIHRoZXlcdTIwMTlyZSBhIHByb2JsZW0uXHUwMGEwPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY1dlIGhhdmUgYSBzbWFsbCBncm91cCB3aGVyZSB3ZSBtZWV0IGZyZXF1ZW50bHkgdG8gZGlzY3VzcyB0aGVzZSBpbnNpZ2h0cyAtIGFuZCB3ZSB1bmRlcnN0YW5kIG5vdCBqdXN0IGhvdyBwdWJsaXNoaW5nLCB0ZXh0IG9yIGZpbG1pbmcgd29ya3MsIGJ1dCB3ZSBoYXZlIGEgbGFyZ2VyIG91dGxvb2sgb24gaG93IGl0IHdpbGwgdG91Y2ggdXMgYXQgZGlmZmVyZW50IGxldmVscyBvZiB0aGUgb3JnYW5pc2F0aW9uLCBhbmQgd2UgaGF2ZSB0aGUgcmlnaHQgcGVvcGxlIHRvIGFzay5cdTAwYTA8L3NwYW4+XHJcblxyXG5bY2FwdGlvbiBpZD1cImF0dGFjaG1lbnRfMTUzMjBcIiBhbGlnbj1cImFsaWdubm9uZVwiIHdpZHRoPVwiMzAwXCJdPGltZyBjbGFzcz1cInNpemUtbWVkaXVtIHdwLWltYWdlLTE1MzIwXCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMjAvMDMvUmlzay1NYW5hZ2VtZW50LWF0LU5SSy0zMDB4MTYzLnBuZ1wiIGFsdD1cIlwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMTYzXCIgLz4gSG93IE5SSyBkb2VzIGlubm92YXRpb24gc3RyYXRlZ3lbL2NhcHRpb25dXHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjRnJvbSB0aW1lIHRvIHRpbWUsIG5ldyB0aGluZ3MgaGFwcGVuIGFuZCB5b3UgaGF2ZSBhIGdlbmVyYWwgcGFuaWMgYWJvdXQgdHJ5aW5nIHRvIFx1MjAxOGJlIGZpcnN0XHUyMDE5LiBXZSB0YWtlIGNhcmUgb2YgdW5kZXJzdGFuZGluZyB0aG9zZSBjaGFuZ2VzIC0gc3VjaCBhcyBob3cgdG8gaGFuZGxlIHNtYXJ0IHNwZWFrZXJzIG9yIHZpcnR1YWwgcmVhbGl0eSAtIGFuZCB3ZSB0cnkgdG8gdW5kZXJzdGFuZCBhbmQgY29udGV4dHVhbGlzZSB0aG9zZSB0aGluZ3MgZWFybHkuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY1doZW4gdGhlIGZpcnN0IHNtYXJ0IHNwZWFrZXJzIHdlcmUgbGF1bmNoZWQgaW4gTm9yd2F5IGluIDIwMTgsIHdlIGhhZCBhbHJlYWR5IHNhaWQgXHUyMDE4aG93IGNhbiB0aGlzIGFmZmVjdCB1cz9cdTIwMTkuIFx1MjAxOFdoYXQgd2lsbCBuZWVkIHRvIGNoYW5nZSBmb3IgdXMgdG8gdXNlIHRoaXMgaW4gYSBnb29kIHdheT9cdTIwMTkuIElmIHRoZXkgaGFkIGNoYW5nZWQgdGhlIG1hcmtldCwgd2VcdTIwMTlkIGhhdmUgYWxyZWFkeSBrbm93biBpdCB3b3VsZCBodXJ0IFx1MjAxOGhlcmVcdTIwMTksIFx1MjAxOGhlcmVcdTIwMTkgYW5kIFx1MjAxOGhlcmVcdTIwMTkuXHUwMGEwPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY1dpdGggdGhpbmdzIGxpa2UgVmlydHVhbCBSZWFsaXR5IG9yIDM2MFx1MDBiMCB2aWRlbywgcGVvcGxlIHdlcmUgdGFsa2luZyBhYm91dCBob3cgdGhleSB3ZXJlIGdvaW5nIHRvIHNhdmUgcHVibGlzaGluZy4gQnV0IHdlIHNhaWQgXHUyMDE4bm8gd2VcdTIwMTlyZSBub3QgZG9pbmcgdGhhdCBhbnltb3JlLCB3ZVx1MjAxOXJlIGhhbmRsaW5nIHRob3NlIHRoaW5ncyBpbiBzbWFsbCBwcm9qZWN0cyB0aGF0IGFyZSBjcm9zcy1mdW5jdGlvbmFsIGFuZCB3aWxsIGJlIGtpbGxlZCBhZnRlciB3ZSB1bmRlcnN0YW5kIGFuZCB3ZVx1MjAxOWxsIGtub3cgZW5vdWdoIHRvIG1vdmUgb25cdTIwMTkuPC9zcGFuPlxyXG48aDM+RnJvbSBpbnNpZ2h0cyB0byBSJmFtcDtEPC9oMz5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPldlIGNvdWxkIGFzc3VyZSBvdXIgb3JnYW5pc2F0aW9uIHRoYXQgVlIgd291bGQgbm90IGNoYW5nZSB1cyBhcyBtZWRpYSBpbiB0aGUgZm9yZXNlZWFibGUgZnV0dXJlLiA8L3NwYW4+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkFzIGFuIG9yZ2FuaXNhdGlvbiwgdGhpcyBoZWxwcyB1cyBmb2N1cyBvbiA8L3NwYW4+PGk+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPmRvaW5nIHdoYXQgd2U8L3NwYW4+PC9pPiA8aT48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+aGF2ZSB0byBkbzwvc3Bhbj48L2k+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPiwgcmF0aGVyIHRoYW4gYmxlZWRpbmcgdG8gZGVhdGggb24gYSBsb3Qgb2YgdXNlbGVzcyB0aGluZ3MuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY09uZSBleGFtcGxlIG9mIHNvbWV0aGluZyB3ZVx1MjAxOXZlIGJlZW4gdGFsa2luZyBhYm91dCBvdmVyIHRoZSBwYXN0IHR3byB5ZWFycyBpcyBUaWtUb2suIEl0XHUyMDE5cyBpbGx1c3RyYXRpdmUgb2YgY2hhbmdlcyBvZiBob3cgcGFydHMgb2YgdGhlIGF1ZGllbmNlIGFyZSBjb25zdW1pbmcgY29udGVudCBhbmQgaG93IHVzZXJzIGdlbmVyYXRlIHRoZSBjb250ZW50IHRoZW1zZWx2ZXMsIGV2ZW4gdGhvdWdoIHRoYXRcdTIwMTlzIHJlYWxseSBhIHByZXZpb3VzIGRlY2FkZSBpZGVhLlx1MDBhMDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNXZSBhc2sgb3Vyc2VsdmVzLCBcdTIwMTh3aGF0IHBhcnRzIG9mIHRlY2hub2xvZ2ljYWwgaW5ub3ZhdGlvbiBkbyB5b3UgbGVhdmUgdG8gbGFyZ2UgY29tcGFuaWVzIGluc3RlYWQgb2YgZG9pbmcgaXQgeW91cnNlbHZlcz9cdTIwMTkuIFRoZSBpUGhvbmUgd2FzIGxhdW5jaGVkIDEzIHllYXJzIGFnbyBhbmQgdGhlIG1lZGlhIGlubm92YXRlZCBhIGxvdCBmb3Igc21hcnRwaG9uZXMgaW4gdGhlIGVhcmx5IHllYXJzLiBUb2RheSBhIGxvdCBvZiBleHBsb2l0YXRpb24gb2YgbW9yZSBhZHZhbmNlZCBmZWF0dXJlcyBoYXZlIGJlZW4gbGVmdCB0byBTaWxpY29uIFZhbGxleSBhbmQgQ2hpbmEuIEhhdmluZyBzdWZmaWNpZW50IGNvbnRyb2wgb2YgdGhpbmdzIGxpa2UgdGhpcyBoZWxwcyB1cyBrbm93IHdoYXQgd2lsbCByZWFsbHkgbWF0dGVyLlx1MjAxZDwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5BbG9uZ3NpZGUgaW5zaWdodHMgZm9yIHJpc2sgbWFuYWdlbWVudCwgc29tZSBvZiB0aGUgTlJLYmV0YSB0ZWFtIGlzIGNoYXJnZWQgd2l0aCBtYWtpbmcgaW5ub3ZhdGlvbiBoYXBwZW4gaW50ZXJuYWxseS48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjV2UgaGF2ZSBhIGZldyBwZW9wbGUgZG9pbmcgbW9yZSBoYXJkY29yZSBSJmFtcDtEIG9uIHRlY2hub2xvZ3kgZm9yIGJyb2FkY2FzdCBhbmQgZGlnaXRhbC4gT25lIG9mIG91ciBiaWdnZXN0IHN1Y2Nlc3NlcyBoZXJlIHdhcyBhIHNpbXBsZSBhdXRvbWF0aWMgcmlnIGJ1aWx0IGJ5IG9uZSBvZiBteSBjb2xsZWFndWVzIHRoYXQgaGFzIG1hZGUgaXQgcG9zc2libGUgdG8gY292ZXIgYWxsIHRoZSBtaWNyb3Bob25lcyBpbiBhIHJhZGlvIHN0dWRpbyB3aXRoIG9uZSBjYW1lcmEgZWFjaCwgYW5kIHNvIGF1dG9tYXRpY2FsbHkgbWFrZSBhIFRWIHByb2dyYW1tZSB3aXRob3V0IGFueW9uZSBtYW5uaW5nIGNhbWVyYXMgb3IgZWRpdGluZy5cdTAwYTA8L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjQmVmb3JlLCB0aGlzIHdvdWxkIHRha2UgYSBsb3Qgb2YgcGVvcGxlLCBzbyBpdCBoZWxwZWQgdXMgbW92ZSByZXNvdXJjZXMgdG8gd2hlcmUgdGhleSB3b3VsZCBtYWtlIG1vcmUgZGlmZmVyZW5jZS4gSXQgYWxzbyBzaG93ZWQgdGhhdCB3ZSBkaWRuJ3QgYWx3YXlzIG5lZWQgdG8gYnV5IGJpZywgZXhwZW5zaXZlIHByb3ByaWV0YXJ5IHN5c3RlbXMgZm9yIG1ha2luZyBUVi4gTm93IHRoZSBOUksgaGFzIHN0YXJ0ZWQgYnVpbGRpbmcgdGhpbmdzIG91cnNlbHZlcyBmb3IgYSBmcmFjdGlvbiBvZiB0aGUgY29zdC4gU28gaXRcdTIwMTlzIGNoYW5nZWQgaG93IHdlIHdvcmtlZCwgaW4gbW92aW5nIHJlc291cmNlcywgYW5kIGhlbHBlZCB1cyBwcm9kdWNlIGEgbG90IG9mIGdvb2QgVFYgY29udGVudCBmcm9tIHRoaW5ncyB0aGF0IHdlcmUgcHJldmlvdXNseSBhdWRpbyBvbmx5Ljwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNBbm90aGVyIHRoaW5nLCB3aGljaCBnb3QgdXMgaW50ZXJuYXRpb25hbCBhdHRlbnRpb24sIHdhcyB0aGUgPC9zcGFuPjxhIGhyZWY9XCJodHRwczovL3d3dy5uaWVtYW5sYWIub3JnLzIwMTcvMDgvcmVtZW1iZXItdGhhdC1ub3J3ZWdpYW4tc2l0ZS10aGF0LW1ha2VzLXJlYWRlcnMtdGFrZS1hLXF1aXotYmVmb3JlLWNvbW1lbnRpbmctaGVyZXMtYW4tdXBkYXRlLW9uLWl0L1wiPjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMThRdWl6IHRvIENvbW1lbnRcdTIwMTkgcHJvamVjdDwvc3Bhbj48L2E+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPiB3aGVyZSB3ZSB3ZXJlIHRlc3RpbmcgcGVvcGxlXHUyMDE5cyB1bmRlcnN0YW5kaW5nIG9mIGEgc3RvcnkgdGhleVx1MjAxOWQgcmVhZCBiZWZvcmUgdGhleSBjb3VsZCBjb21tZW50LiBXaGF0IGl0IGRpZCBhdCB0aGUgdGltZSB3aGVuIGl0IHdhcyByZWxlYXNlZCB3YXMgYWRkcmVzcyBzb21lIGRlZXAgdW5kZXJseWluZyBpc3N1ZXMgaW4gbWFueSBzb2NpZXRpZXMgYXJvdW5kIGRpc2luZm9ybWF0aW9uIGluIG9ubGluZSBkZWJhdGUuXHUyMDFkPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPk5SSyBpcyBhbHNvIGNyZWRpdGVkIHdpdGggcGlvbmVlcmluZyBzby1jYWxsZWQgPC9zcGFuPjxhIGhyZWY9XCJodHRwczovL2VuLndpa2lwZWRpYS5vcmcvd2lraS9TbG93X3RlbGV2aXNpb25cIj48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDE4c2xvdyBUVjwvc3Bhbj48L2E+PHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxOSBvciBcdTIwMThtYXJhdGhvblx1MjAxOSBicm9hZGNhc3RpbmcgcHJvamVjdHMgLSB3aGljaCB0aGlzIHllYXIgd2lsbCBzZWUgdGhlbSBjb3ZlcmluZyBhIGZpdmUtd2VlayBjeWNsaW5nIHRyaXAgd2l0aCB0aGUgZnVsbCBraXQgY2FycmllZCBvbiBiaWtlcy48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+PGltZyBjbGFzcz1cImFsaWdubm9uZSBzaXplLW1lZGl1bSB3cC1pbWFnZS0xNTMyMVwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIwLzAzL1NjcmVlbi1TaG90LTIwMjAtMDMtMDktYXQtMTEuMDYuMTktMjY3eDMwMC5wbmdcIiBhbHQ9XCJcIiB3aWR0aD1cIjI2N1wiIGhlaWdodD1cIjMwMFwiIC8+PC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlRoZSBOUktiZXRhIHRlYW0gZG9lcyBsb29rIG91dHNpZGUgdGhlIG9yZ2FuaXNhdGlvbiBmb3IgaW5zaWdodHMsIGJ1dCBvbmx5IHNvIGZhciBhcyBpdCBuZWVkcyB0by48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjTW9yZSBhbmQgbW9yZSwgd2VcdTIwMTlyZSBkZXZlbG9waW5nIGludG8gc29tZXRoaW5nIHRoYXRcdTIwMTlzIGxldmVyYWdpbmcgZW5lcmd5IGZyb20gb3RoZXIgcGFydHMgb2YgdGhlIG9yZ2FuaXNhdGlvbiwgc28gd2UgZG9uXHUyMDE5dCBkbyBldmVyeXRoaW5nIG91cnNlbHZlcy4gUGVvcGxlIGNvbWUgdG8gdXMgYW5kIHNheSBcdTIwMThJXHUyMDE5bSBzdHJ1Z2dsaW5nIHdpdGggZG9pbmcgdGhpcyBvciB0aGF0XHUyMDE5LiBBbmQgd2Ugc2F5IFx1MjAxOG1heWJlIHlvdSBzaG91bGQgdGFsayB0byB0aGF0IHBlcnNvbiBvdmVyIHRoZXJlP1x1MjAxOS4gV2VcdTIwMTlyZSBub3QgZG9pbmcgaW5ub3ZhdGlvbiBpbiBhIHNtYWxsLCBjbG9zZWQgZ3JvdXAuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY1dlIGRvIHNwZWFrIHRvIG91ciBuZXR3b3JrcyAtIGF0IHRoZSBCQkMgYW5kIG90aGVycyAtIGFuZCB3ZSByZWd1bGFybHkgb2JzZXJ2ZSB0aGUgY3V0dGluZy1lZGdlIG9mIHdoYXQgcGVvcGxlIGFyZSBkaXNjdXNzaW5nIGluIHRoZSBidXNpbmVzcy4gV2VcdTIwMTlyZSBwcm9iYWJseSBzcGVuZGluZyBhIGxvdCBsZXNzIHRoYW4gbWFueSBvdGhlcnMgb24gaW5zaWdodCBhbmQgcmVzZWFyY2guIE9uZSBvZiB0aGUgZmV3IHRoaW5ncyB3ZSBzcGVuZCBtb25leSBkb2luZyBpcyBnb2luZyB0byBhIGZldyBjb25mZXJlbmNlcyBhIHllYXIgdG8gY29udGV4dHVhbGlzZSB3aGF0IHRoZSBtZWRpYSBidXNpbmVzcyBpcyBkaXNjdXNzaW5nLjwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNOUksgZGlkIGdldCBhIG5ldyByZW1pdCBhIGZldyB5ZWFycyBiYWNrIGFuZCBvbmUgb2YgdGhlIHRoaW5ncyB3ZSB3ZXJlIHRvbGQgdG8gZG8gd2FzIGhhdmUgYSByZXNwb25zaWJpbGl0eSBmb3IgbWVkaWEgZGl2ZXJzaXR5IGluIE5vcndheS4gQW5kIGl0XHUyMDE5cyBlbmRlZCB1cCB3aXRoIHVzIGJlaW5nIG1vcmUgb3BlbiB0byBjb29wZXJhdGlvbiwgcGFydGljdWxhcmx5IHNoYXJpbmcgYWxsIHRoZSBpbnNpZ2h0cyBmcm9tIE5SS2JldGEuIFdlIGhhdmUgYSBcdTIwMThyZWNlbnQgaW5zaWdodHNcdTIwMTkgdGFsaywgd2hpY2ggaXMgYXJvdW5kIGFuIGhvdXIgbG9uZywgYW5kIGxhc3QgaGFsZi15ZWFyIHdlIHByZXNlbnRlZCBpdCBhcm91bmQgMzAgdGltZXMgLSBoYWxmIHdpdGhpbiBOUksgYW5kIGhhbGYgdG8gb3RoZXJzIG91dHNpZGUuIFdlIHRlbGwgb3RoZXIgTm9yd2VnaWFuIG1lZGlhIGV2ZXJ5dGhpbmcgd2UgdGVsbCBzZW5pb3IgbWFuYWdlbWVudCBhdCBOUksuXHUwMGEwPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY1lvdSBjb3VsZCB0aGluayB0aGlzIGhhcyB0byBiZSBzdXBlciBzZWNyZXQgYmVjYXVzZSBwZW9wbGUgd2lsbCBzdGVhbCBpdCAtIGJ1dCB5b3UgaGF2ZSB0byBoYXZlIGFuIG9yZ2FuaXNhdGlvbiB0aGF0IHdpbGwgYWN0IG9uIHRoZXNlIGluc2lnaHRzIC0gc28gYXMgbG9uZyBhcyB3ZSBoYXZlIHRoaXMgb3JnYW5pc2F0aW9uLCB3ZSBzaG91bGRuXHUyMDE5dCBiZSB3b3JyaWVkLiBZb3VcdTIwMTlyZSBtb3JlIGNvbXBldGluZyBhZ2FpbnN0IG90aGVyIGtpbmRzIG9mIGJ1c2luZXNzIHRoYW4gbWVkaWEuPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkdsYWRseSwgaGlzIHRlYW1cdTIwMTlzIHdvcmsgaXNuXHUyMDE5dCBtZWFzdXJlZCBpbiBhIGNvbnZlbnRpb25hbCBzZW5zZSwgSG9mc2V0aCBleHBsYWlucy48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjV2VcdTIwMTlyZSBub3QgbWVhc3VyZWQgYnkgaGFyZCBtZWFzdXJlcyAtIHdlXHUyMDE5cmUgbWVhc3VyZWQgYnkgd2hhdCB0aGUgb3JnYW5pc2F0aW9uIHBlcmNlaXZlcyB0aGF0IHdlIGNhbiBoZWxwIHRoZW0gYWNoaWV2ZS4gU28sIGFzIGxvbmcgYXMgbW9zdCBwZW9wbGUgaW4gdGhlIG9yZ2FuaXNhdGlvbiBzZWUgdXMgYXMgYSBmb3JjZSBmb3IgZ29vZCwgSSB0aGluayB3ZVx1MjAxOXJlIGdvb2QuIFRoZSBpbXBvcnRhbnQgdGhpbmcgaXMgdGhhdCB3ZVx1MjAxOXJlIGFibGUgdG8gZGVsaXZlciwgdG8gYW5zd2VyIG1vc3QgcXVlc3Rpb25zIGFueW9uZSBcdTIwMTMgZnJvbSB0aGUgRGlyZWN0b3IgR2VuZXJhbCB0byBhIHN0cmF5IGpvdXJuYWxpc3Qgc29tZXdoZXJlIFx1MjAxMyBtaWdodCBhc2sgdXMuPC9zcGFuPlxyXG48aDM+VGhlIG5leHQgNTAgeWVhcnMgb2YgcHVibGljIHNlcnZpY2U8L2gzPlxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjQSBnb29kIHdheSB0byB3b3JrIHdpdGggaW5zaWdodCBhbmQgaW5ub3ZhdGlvbiBpcyB0byBzcGVuZCBlbm91Z2ggdGltZSBhbmFseXNpbmcgdGhlIGluc2lnaHQgYmVmb3JlIGFjdGluZyBvbiBpdC4gQW4gaW1wb3J0YW50IHJlYXNvbiB3ZVx1MjAxOXJlIGFibGUgdG8gZG8gdGhpbmdzIGlzIHRoYXQgd2Ugc2VwYXJhdGUgdGhlIHRoaW5raW5nIGFuZCB0aGUgYW5hbHlzaW5nLCBmcm9tIHRoZSBwb3dlciBzdHJ1Y3R1cmVzIGFuZCBidWRnZXRzLCBzbyB3ZVx1MjAxOXJlIGFibGUgdG8gdGhpbmsgcXVpdGUgY29sZGx5IGFib3V0IHdoYXQgdGhpbmdzIG1lYW4uIFdlIGRpc2N1c3Mgbm90IGZyb20gdGhlIHBlcnNwZWN0aXZlIG9mIHNlbGYtcHJlc2VydmF0aW9uLCBidXQgXHUyMDE4d2hhdCB3b3VsZCBpdCBtZWFuIGZvciBvdXIgYnVzaW5lc3MgaW4gNTAgeWVhcnM/XHUyMDE5IGFuZCBcdTIwMThob3cgZG8gd2UgZ2V0IHdoZXJlIHdlIHdhbnQgdG8gYmU/XHUyMDE5Ljwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNXZSBoYXZlIGJlZW4gZG9pbmcgYSBsb3Qgb2YgdGhpbmdzIGZvciByZWFzb25zIHdlIHVuZGVyc3RhbmQsIHNvIGFmdGVyIGhhdmluZyB0cmllZCBzb21ldGhpbmcgdGhhdCBzZWVtZWQgYSBiaXQgcmlza3kgdGhlIGZpcnN0IHRpbWUsIHRoZW4gcmVwZWF0aW5nIGFuZCBkb2luZyB0aGF0LCBhbmQgY2hhbmdpbmcgYW5kIG1vdmluZyBmb3J3YXJkcywgd2VcdTIwMTl2ZSBiZWVuIGFibGUgdG8gc2hpZnQgb3VyIGJhbGFuY2UuXHUwMGEwPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPkFuZCB3aGF0XHUyMDE5cyBuZXh0IGZvciBpbm5vdmF0aW9uIGF0IE5SSywgYW5kIGZvciBIb2ZzZXRoXHUyMDE5cyB3b3JrPzwvc3Bhbj5cclxuXHJcbjxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5cdTIwMWNJXHUyMDE5bSBnb2luZyB0byBkbyB0aGUgc2FtZSB0aGluZyBJIGRpZCBsYXN0IHllYXIuIFRoZSBpbnNpZ2h0IHdvcmsgaXMgYSBvbmUteWVhciBjeWNsZSB3aGVyZSB3ZSBzdGFydCB0byBhbWFzcyBhbGwgdGhlIGNoYW5nZXMgdGhhdCBoYXZlIGhhcHBlbmVkIHNpbmNlIGxhc3QgeWVhci4gVGhlbiB3ZSBjaGV3IG9uIHRoYXQuIFRoZW4gd2VcdTIwMTlsbCBtYWtlIG91ciBwcmVzZW50YXRpb25zIGZvciBwZW9wbGUgYWNyb3NzIE5SSy48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjSVx1MjAxOXZlIGJlZW4gZG9pbmcgdGhpcyBmb3IgMTAgeWVhcnMgLSBhbmQgdGhlcmUgaGF2ZSBvbmx5IGJlZW4gdHdvIHJlYWxseSBiaWcgY2hhbmdlcyBpbiB0aGF0IHRpbWUuIE9uZSBpcyB0aGUgbW9iaWxlIHBob25lIGFuZCBwYXJ0aWN1bGFybHkgd2hlbiB0aGUgaVBob25lIGFycml2ZWQgaW4gMjAwNyAtIGlmIHlvdSBnbyBvbnRvIFdheWJhY2sgTWFjaGluZSBhbmQgc2VlIDEwLXllYXItb2xkIHdlYiBwYWdlcyAtIHRoYXQgY2hhbmdlZCBhIGxvdC4gQW5kIHRoZSBvdGhlciBpcyBwbGF0Zm9ybXMgYW5kIHNvY2lhbCBtZWRpYSBhbmQgdGhvc2UgdGhpbmdzIGJlaW5nIFZDLWJhY2tlZCwgbWVhbmluZyB0aGV5IGNhbWUgaW50byB0aGlzIHdpdGggYSBjb21wbGV0ZWx5IGRpZmZlcmVudCBzZXQgb2YgZXRoaWNzIHRvIHdoYXQgd2UgaGF2ZS48L3NwYW4+XHJcblxyXG48c3BhbiBzdHlsZT1cImZvbnQtd2VpZ2h0OiA0MDA7XCI+XHUyMDFjUHVibGljIHNlcnZpY2UgaXMgYW4gaWRlYSB0aGF0IHlvdSB1c2VkIHRvIGJlIGFibGUgdG8gZ2V0IGdvdmVybm1lbnRzIHRvIGJ1aWxkIGFuIG9yZ2FuaXNhdGlvbiBhcm91bmQgNTAgb3IgMTAwIHllYXJzIGFnbywgYnV0IHlvdSBjb3VsZG5cdTIwMTl0IGRvIHRoYXQgdG9kYXkuIEl0XHUyMDE5cyBzb21ldGhpbmcgd2UgbmVlZCB0byB0YWtlIGNhcmUgb2YuIFRoZSBsb25nLXRlcm0gc3Vydml2YWwgb2YgcHVibGljIHNlcnZpY2UgbWVkaWEgZGVwZW5kcyBvbiBicm9hZCBwdWJsaWMgdHJ1c3QsIGxvdmUsIGFuZCBkYWlseSByZWxldmFuY2UuXHUwMGEwPC9zcGFuPlxyXG5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MjAxY091ciBwdXJwb3NlIGluIHRoaXMgaXMgaGVscGluZyB0aGUgTlJLIGFkYXB0IGFuZCBzdGF5IHJlbGV2YW50IHRvIHRoZSBhdWRpZW5jZSwgYW5kIHRoZWlyIG5lZWRzIGFuZCB1c2FnZSBwYXR0ZXJucyB0aHJvdWdoIGEgcGVyaW9kIG9mIG1hc3NpdmUgY2hhbmdlLiBTbyBldmVyeXRoaW5nIHdlIGRvIHdlIGNvbnNpZGVyIHdpdGhpbiB0aGUgcGVyc3BlY3RpdmUgb2YgaGVscGluZyBzZWN1cmUgYW5kIGZhY2lsaXRhdGUgdGhlIHB1YmxpYyBzZXJ2aWNlIG1pc3Npb24gb2YgdGhlIE5SSzogVG8gaW5mb3JtLCBlZHVjYXRlLCBhbmQgZW50ZXJ0YWluIE5vcndheS5cdTIwMWQ8L3NwYW4+XHJcblxyXG4mbmJzcDtcclxuXHJcbkNPTlRBQ1RcclxuXHJcbltjYXB0aW9uIGlkPVwiYXR0YWNobWVudF8xNTMyNFwiIGFsaWduPVwiYWxpZ25ub25lXCIgd2lkdGg9XCIzMDBcIl08aW1nIGNsYXNzPVwid3AtaW1hZ2UtMTUzMjQgc2l6ZS1tZWRpdW1cIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAyMC8wMy9BbmRlcnMtSG9mc2V0aC0zMDB4MjAwLmpwZ1wiIGFsdD1cIlwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgLz4gQW5kZXJzIEhvZnNldGgsIFBob3RvIEtpbSBFcmxhbmRzZW4sIE5SSyAyMDIwWy9jYXB0aW9uXVxyXG5cclxuQW5kZXJzIEhvZnNldGgsIGpvdXJuYWxpc3QgYW5kIHN0cmF0ZWdpYyBhZHZpc29yXHJcblR3aXR0ZXI6IDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2FuZG9yYW5kXCI+QGFuZG9yYW5kPC9hPlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XSIsInBvc3RfdGl0bGUiOiJOUktiZXRhOiBwdWJsaWMgc2VydmljZSBtZWRpYSBpbm5vdmF0aW9uIGZvciB0aGUgMjFzdCBjZW50dXJ5IiwicG9zdF9saW5rIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL3B1YmxpYy1zZXJ2aWNlLW1lZGlhLWlubm92YXRpb24tMjFzdC1jZW50dXJ5LyIsInBvc3RfZmVhdHVyZWRfaW1hZ2UiOiI8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIk5SS2JldGE6IHB1YmxpYyBzZXJ2aWNlIG1lZGlhIGlubm92YXRpb24gZm9yIHRoZSAyMXN0IGNlbnR1cnlcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjE4MVwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIwLzAzL05SS2JldGEtVmVubi1EaWFncmFtLTMwMHgxODEuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+IiwicG9zdF9jYXRlZ29yaWVzIjoiTWVkaWEgbGFicyIsInBvc3RfdGFncyI6IkNvbGxhYm9yYXRpb24sIGluc2lnaHRzLCBQdWJsaWMgc2VydmljZSwgUiZhbXA7RCIsIiVfZWRpdF9sb2NrJSI6IjE1ODg5MzMxNzQ6OTMzIiwiJV9lZGl0X2xhc3QlIjoiOTMzIiwiJXNsaWRlX3RlbXBsYXRlJSI6ImRlZmF1bHQiLCIlX3dwYl92Y19qc19zdGF0dXMlIjoidHJ1ZSIsIiVfd3BnbXBfbG9jYXRpb25fYWRkcmVzcyUiOiJCalx1MDBmOHJuc3RqZXJuZSBCalx1MDBmOHJuc29ucyBwbGFzcyAxLCAwMzQwIE9zbG8sIE5vcndheSIsIiVfd3BnbXBfbG9jYXRpb25fY2l0eSUiOiIiLCIlX3dwZ21wX2xvY2F0aW9uX3N0YXRlJSI6Ik9zbG8iLCIlX3dwZ21wX2xvY2F0aW9uX2NvdW50cnklIjoiTm9yd2F5IiwiJV93cGdtcF9tZXRhYm94X2xhdGl0dWRlJSI6IjU5LjkzNTUxMzAwMDAwMDAxIiwiJV93cGdtcF9tZXRhYm94X2xvbmdpdHVkZSUiOiIxMC43MjA2MTA1IiwiJV93cGdtcF9tZXRhYm94X2xvY2F0aW9uX3JlZGlyZWN0JSI6Im1hcmtlciIsIiVfd3BnbXBfbWV0YWJveF9jdXN0b21fbGluayUiOiIiLCIlX3dwZ21wX21hcF9pZCUiOiJhOjE6e2k6MDtzOjE6XCIyXCI7fSIsIiVfd3BnbXBfbWV0YWJveF9tYXJrZXJfaWQlIjoiTjsiLCIlX3dwZ21wX21ldGFib3hfdGF4b21vbWllc190ZXJtcyUiOiJOOyIsIiVfd3BnbXBfZXh0ZW5zaW9uc19maWVsZHMlIjoiTjsiLCIlX2tsZW9fdHJhbnNwYXJlbnRfbWVudV9jb2xvciUiOiJ3aGl0ZSIsIiVfa2xlb190aXRsZV9jaGVja2JveCUiOiIxIiwiJV9rbGVvX3RpdGxlX2NvbG9yJSI6IiMiLCIlX2tsZW9fdGl0bGVfYmclIjoiLCByZXBlYXQsIGluaGVyaXQsIHNjcm9sbCwgbGVmdCB0b3AiLCIlX2tsZW9fdGl0bGVfYmdfY29sb3IlIjoiIyIsIiVfeW9hc3Rfd3BzZW9fY29udGVudF9zY29yZSUiOiIzMCIsIiVfeW9hc3Rfd3BzZW9fcHJpbWFyeV9jYXRlZ29yeSUiOiIxNDIiLCIlX3RodW1ibmFpbF9pZCUiOiIxNTMyNSIsIiVfd3Bfb2xkX3NsdWclIjoiMTUzMTgiLCIlc2JnX3NlbGVjdGVkX3NpZGViYXIlIjoiMCIsIiVzYmdfc2VsZWN0ZWRfc2lkZWJhcl9yZXBsYWNlbWVudCUiOiIwIiwidGF4b25vbXk9Y2F0ZWdvcnkiOiJNZWRpYSBsYWJzIiwidGF4b25vbXk9cG9zdF90YWciOiJDb2xsYWJvcmF0aW9uLCBpbnNpZ2h0cywgUHVibGljIHNlcnZpY2UsIFImYW1wO0QifSwiaWNvbiI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE4LzAyL21hcmtlci0xLnBuZyJ9LCJpZCI6MTUzMTgsImluZm93aW5kb3dfZGlzYWJsZSI6ZmFsc2V9LHsic291cmNlIjoicG9zdCIsInRpdGxlIjoiSEhsYWI6IElubm92YXRpbmcgbmV3IHByb2R1Y3RzIGFuZCBidXNpbmVzcyBvcHBvcnR1bml0aWVzIiwiaW5mb3dpbmRvd19jb250ZW50IjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZ1wiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJISGxhYjogSW5ub3ZhdGluZyBuZXcgcHJvZHVjdHMgYW5kIGJ1c2luZXNzIG9wcG9ydHVuaXRpZXNcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjE2NVwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIwLzAyL0hIbGFiMi0zMDB4MTY1LnBuZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmdcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXBhZGRpbmctY29udGVudF8yMFwiPlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLW1ldGEgZmMtaXRlbS1zZWNvbmRhcnktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZSBmYy10ZXh0LWNlbnRlclwiPk1lZGlhIGxhYnM8L2Rpdj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS10aXRsZSBmYy1pdGVtLXByaW1hcnktdGV4dC1jb2xvciBmYy10ZXh0LWNlbnRlclwiPkhIbGFiOiBJbm5vdmF0aW5nIG5ldyBwcm9kdWN0cyBhbmQgYnVzaW5lc3Mgb3Bwb3J0dW5pdGllczwvZGl2PlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2VcIj5cclxuICAgICAgICAgICAgVGhlIEdlcm1hbiBtZWRpYSBsYWIgZm9jdXNlcyBvbiBpbm5vdmF0aW9uIGF0IHRoZSBidXNpbmVzcyBtb2RlbCBsZXZlbCwgc2Vla2luZyBhbmQgY3JlYXRpbmcgcHJvZHVjdHMgYW5kIGNvbW1lcmNpYWwgb3Bwb3J0dW5pdGllcyB0aGF0IGdvIGJleW9uZCB0aGUgY29udmVudGlvbnMgb2YgdGhlIG5ld3MgaW5kdXN0cnkuXHJcbiAgICAgICAgPC9kaXY+XHJcbjxhIGhyZWY9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvaGhsYWItaW5ub3ZhdGluZy1uZXctcHJvZHVjdHMtYW5kLWJ1c2luZXNzLW9wcG9ydHVuaXRpZXMvXCI+UmVhZCBtb3JlPC9hPlxyXG4gICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuPC9kaXY+XHJcblxyXG4iLCJjb250ZW50IjoiVGhlIEdlcm1hbiBtZWRpYSBsYWIgZm9jdXNlcyBvbiBpbm5vdmF0aW9uIGF0IHRoZSBidXNpbmVzcyBtb2RlbCBsZXZlbCwgc2Vla2luZyBhbmQgY3JlYXRpbmcgcHJvZHVjdHMgYW5kIGNvbW1lcmNpYWwgb3Bwb3J0dW5pdGllcyB0aGF0IGdvIGJleW9uZCB0aGUgY29udmVudGlvbnMgb2YgdGhlIG5ld3MgaW5kdXN0cnkuIiwiYWRkcmVzcyI6IkJhcm5lcnN0cmFcdTAwZGZlIDE0LCAyMjc2NSBIYW1idXJnLCBHZXJtYW55IiwibG9jYXRpb24iOnsibGF0IjoiNTMuNTU3MjAyMiIsImNpdHkiOiJIYW1idXJnIiwic3RhdGUiOiJIYW1idXJnIiwiY291bnRyeSI6Ikdlcm1hbnkiLCJsbmciOiI5LjkzMTgwMTQiLCJvbmNsaWNrX2FjdGlvbiI6Im1hcmtlciIsInJlZGlyZWN0X3Blcm1hbGluayI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9oaGxhYi1pbm5vdmF0aW5nLW5ldy1wcm9kdWN0cy1hbmQtYnVzaW5lc3Mtb3Bwb3J0dW5pdGllcy8iLCJ6b29tIjoyLCJleHRyYV9maWVsZHMiOnsicG9zdF9leGNlcnB0IjoiVGhlIEdlcm1hbiBtZWRpYSBsYWIgZm9jdXNlcyBvbiBpbm5vdmF0aW9uIGF0IHRoZSBidXNpbmVzcyBtb2RlbCBsZXZlbCwgc2Vla2luZyBhbmQgY3JlYXRpbmcgcHJvZHVjdHMgYW5kIGNvbW1lcmNpYWwgb3Bwb3J0dW5pdGllcyB0aGF0IGdvIGJleW9uZCB0aGUgY29udmVudGlvbnMgb2YgdGhlIG5ld3MgaW5kdXN0cnkuIiwicG9zdF9jb250ZW50IjoiW3ZjX3Jvd11bdmNfY29sdW1uIHdpZHRoPVwiMS80XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvMlwiXVt2Y19jb2x1bW5fdGV4dF1cclxuPGgxPkhIbGFiOiBJbm5vdmF0aW5nIG5ldyBwcm9kdWN0cyBhbmQgYnVzaW5lc3Mgb3Bwb3J0dW5pdGllczwvaDE+XHJcbjxlbT5UaGUgR2VybWFuIG1lZGlhIGxhYiBmb2N1c2VzIG9uIGlubm92YXRpb24gYXQgdGhlIGJ1c2luZXNzIG1vZGVsIGxldmVsLCBzZWVraW5nIGFuZCBjcmVhdGluZyBwcm9kdWN0cyBhbmQgY29tbWVyY2lhbCBvcHBvcnR1bml0aWVzIHRoYXQgZ28gYmV5b25kIHRoZSBjb252ZW50aW9ucyBvZiB0aGUgbmV3cyBpbmR1c3RyeS48L2VtPlxyXG5cclxuRm9yIG92ZXIgYSBodW5kcmVkIHllYXJzLCB0aGUgbmV3c3BhcGVyIGJ1c2luZXNzIHdhcyBtb3N0bHkgYSBzdGFibGUgaW5kdXN0cnkuIFRoZSBidXNpbmVzcyBtb2RlbCB3YXMgYmFzZWQgb24gcmVhZGVycyBhbmQgYWR2ZXJ0aXNlcnMsIGFuZCBmZXcgcHVibGlzaGVycyBuZWVkZWQgdG8gdGhpbmsgYWJvdXQgY3JlYXRpbmcgY29tbWVyY2lhbCBvZmZlcmluZ3Mgb3V0c2lkZSB0aGVzZSB0d28gcmV2ZW51ZSBzb3VyY2VzLlxyXG5cclxuQnV0IG5vdywgdGhlIG5ld3MgbWVkaWEgaW5kdXN0cnkgaGFzIGFuIHVyZ2VudCBuZWVkIHRvIHJldGhpbmsgaXRzIGJ1c2luZXNzIGFwcHJvYWNoLiBBcyBkaWdpdGFsIGlubm92YXRpb25zIG11bHRpcGx5IGFuZCB0aGUgYXVkaWVuY2VcdTIwMTlzIG1lZGlhIGNvbnN1bXB0aW9uIGhhYml0cyBjaGFuZ2UsIG5ld3MgcHVibGlzaGVycyBhcmUgY29uZnJvbnRlZCB3aXRoIGEgdml0YWwgbmVlZCB0byBjcmVhdGUgbmV3IHByb2R1Y3RzIHRoYXQgc3VpdCB0aGUgcmFkaWNhbGx5IGNoYW5nZWQgbWFya2V0LlxyXG5cclxuVGhpcywgaW4gYSBudXRzaGVsbCwgaXMgdGhlIHZpc2lvbiB0aGF0IGRyaXZlcyB0aGUgd29yayBvZiA8YSBocmVmPVwiaHR0cHM6Ly93d3cuaGhsYWIuZGUvXCI+SEhsYWI8L2E+LCB0aGUgcmVzZWFyY2ggYW5kIGRldmVsb3BtZW50IHVuaXQgb2YgTk9aIE1lZGllbiBhbmQgbWg6biBNZWRpZW4uXHJcblxyXG5UaGUgdHdvIG5vcnRoIEdlcm1hbiByZWdpb25hbCBwdWJsaXNoZXJzIGpvaW5lZCBmb3JjZXMgaW4gMjAxNiwgd2hlbiB0aGUgZm9ybWVyIGFjcXVpcmVkIHRoZSBsYXR0ZXIuIFRvZ2V0aGVyLCB0aGUgY29tcGFuaWVzIGRlY2lkZWQgdG8gY3JlYXRlIGEgam9pbnQgbWVkaWEgaW5ub3ZhdGlvbiB1bml0IHRhc2tlZCB3aXRoIGZpbmRpbmcgaW5ub3ZhdGl2ZSBjb21tZXJjaWFsIG9wcG9ydHVuaXRpZXMuIFRodXMgSEhsYWIgd2FzIGJvcm4gaW4gSmFudWFyeSAyMDE4IGluIEhhbWJ1cmcuIChUaGUgXHUyMDFjSEhcdTIwMWQgaW4gSEhsYWIgc3RhbmRzIGZvciBcIkhhbnNlc3RhZHQgSGFtYnVyZ1wiLCBvciBcIkhhbnNlYXRpYyBDaXR5IG9mIEhhbWJ1cmdcIiwgYW4gYWJicmV2aWF0aW9uIHVzZWQgaW4gY2FyIHJlZ2lzdHJhdGlvbiBwbGF0ZXMgaW4gSGFtYnVyZy4pXHJcbjxoMz5Qcm9kdWN0cyBiYXNlZCBvbiBkaWdpdGFsaXNhdGlvbjwvaDM+XHJcblRoZSBsYWIgaWRlbnRpZmllZCBvbmUgc3VjaCBvcHBvcnR1bml0eSB3aGVuIGl0IHJlYWxpc2VkIHRoYXQgc21hbGwgYW5kIG1lZGl1bS1zaXplZCBjb21wYW5pZXMgYXJlIG9mdGVuIHN0cnVnZ2xpbmcgdG8ga2VlcCB1cCB3aXRoIG5ldyBkaWdpdGFsIHRvb2xzLlxyXG5cclxuRGlnaXRhbGlzYXRpb24gaGFzIHRyYW5zZm9ybWVkIGhvdyBiaWcgY29tcGFuaWVzIG9wZXJhdGUsIGJ1dCBTTUVzIHRlbmQgdG8gbGFnIGJlaGluZCB3aXRoIHRoZWlyIGRpZ2l0YWwgdHJhbnNmb3JtYXRpb24uIE1vcmVvdmVyLCB3aGlsZSBsYXJnZSBidXNpbmVzc2VzIGhhdmUgYWNjZXNzIHRvIHVzZWZ1bCBuZXR3b3Jrcywgc21hbGxlciBmaXJtcyBiYXNlZCBvdXRzaWRlIHRoZSBtZXRyb3BvbGl0YW4gYXJlYXMgb2Z0ZW4gbGFjayBzdWNoIGNvbm5lY3Rpb25zLlxyXG5cclxuVGhpcyByZWFsaXNhdGlvbiBsZWFkIEhIbGFiIHRvIGRldmVsb3AgTkVUWmZlbGQgXHUyMDEzIGEgQjJCIHZlcnRpY2FsIHRoYXQgcHJvdmlkZXMgYm90aCBpbmZvcm1hdGlvbiBhbmQgbmV0d29ya2luZyBvcHBvcnR1bml0aWVzIGFib3V0IGRpZ2l0YWwgdHJhbnNmb3JtYXRpb24gZm9yIHNtYWxsIGFuZCBtaWRzaXplIGNvbXBhbmllcy4gQmFzZWQgb24gYSBzdWJzY3JpcHRpb24gbW9kZWwsIE5FVFpmZWxkIHVzZXJzIGdldCBhY2Nlc3MgdG8gcmVsYXRlZCBuZXdzIGFuZCBjYXNlIHN0dWRpZXMsIGFzIHdlbGwgYXMgbmV0d29ya2luZyBvcHBvcnR1bml0aWVzIHdoZXJlIHRoZXkgY2FuIGxlYXJuIGZyb20gb3RoZXIgY29tcGFuaWVzLiAoTkVUWmZlbGQgd2lsbCBiZSBkaXNjdXNzZWQgbW9yZSBpbiBkZXRhaWwgYmVsb3cuKVxyXG5cclxuQW5vdGhlciBwcm9kdWN0IGlkZWEgY29uY2VpdmVkIGJ5IHRoZSBsYWIgaXMgYSB2aXJhbCBhZHZlcnRpc2luZyBhZ2VuY3ksIGFpbWluZyB0byBjb25uZWN0IHBlb3BsZSB3aXRoIGEgc3Ryb25nIHNvY2lhbCBtZWRpYSBwcmVzZW5jZSBhbmQgYWR2ZXJ0aXNlcnMuIE1hbnkgc29jaWFsIG1lZGlhIGluZmx1ZW5jZXJzIGhhdmUgYSBzaWduaWZpY2FudCBmb2xsb3dpbmcgYnV0IGFyZSBub3Qgb24gdGhlIGFkdmVydGlzZXJzXHUyMDE5IHJhZGFyLiBNZWFud2hpbGUsIHNvbWUgYWR2ZXJ0aXNlcnMgZG9uXHUyMDE5dCBrbm93IGhvdyB0byB1c2Ugc29jaWFsIG1lZGlhIHRvIHJlYWNoIGEgc3BlY2lmaWMgYXVkaWVuY2UgYmFzZWQgb24gaW50ZXJlc3QsIGxvY2F0aW9uIG9yIGRlbW9ncmFwaHkuIFRoZSB2aXJhbCBhZHZlcnRpc2luZyBhZ2VuY3kgd291bGQgaGVscCBicmluZyB0aGVzZSB0d28gZ3JvdXBzIHRvZ2V0aGVyLlxyXG5cclxuQm90aCBwcm9kdWN0IGlkZWFzIGhhdmUgbm93IGdvbmUgdGhyb3VnaCB0aGUgbGFiXHUyMDE5cyBkZXZlbG9wbWVudCBwcm9jZXNzLCBhbmQgdGhlIGNvbXBhbnlcdTIwMTlzIG1hbmFnZW1lbnQgaXMgbm93IGFzc2Vzc2luZyB0aGVpciBpbXBsZW1lbnRhdGlvbi5cclxuPGgzPlRoZSByb2FkIHRvIE5FVFpmZWxkPC9oMz5cclxuSXQgbWF5IHNlZW0gcGVjdWxpYXIgdGhhdCBhIHJlZ2lvbmFsIG5ld3NwYXBlciBwdWJsaXNoZXIgd291bGQgY29tZSB1cCB3aXRoIHByb2R1Y3RzIHN1Y2ggYXMgYSBCMkIgdmVydGljYWwgYW5kIGFuIGFkdmVydGlzaW5nIGFnZW5jeS4gSG93ZXZlciwgdGhlIHByb2Nlc3MgdGhhdCBsZWFkIHRvIHRoZSBkZXZlbG9wbWVudCBvZiBORVRaZmVsZCBpcyBhIGdvb2QgaWxsdXN0cmF0aW9uIG9mIGhvdyB0aGUgbGFiIGFwcHJvYWNoZXMgaW5ub3ZhdGlvbiBwcm9qZWN0cy4gSm9hY2hpbSBEcmV5a2x1ZnQsIEhIbGFiXHUyMDE5cyBkaXJlY3Rvciwgc2F5cyB0aGF0IGl0IHN0YXJ0ZWQgd2l0aCBhIHNpbXBsZSByZWFsaXNhdGlvbi5cclxuXHJcblx1MjAxY1dlIG5vdGljZWQgdGhhdCBhbHRob3VnaCB0aGVyZSBhcmUgYSBsb3Qgb2YgZXZlbnRzIGFib3V0IGRpZ2l0YWwgdHJhbnNmb3JtYXRpb24gaW4gYmlnIGNpdGllcywgZmlybXMgYmFzZWQgaW4gc21hbGxlciB0b3ducyByYXJlbHkgcGFydGljaXBhdGUgaW4gdGhlbS4gQW5kIGV2ZW4gaWYgdGhleSBkbywgdGhleSBjYW5cdTIwMTl0IGFsd2F5cyByZWxhdGUgdG8gY29uZmVyZW5jZSBzcGVha2VycyB3aG8gYXJlIG1vc3RseSBmcm9tIGJpZyBjb21wYW5pZXMuXHUyMDFkXHJcblxyXG5bY2FwdGlvbiBpZD1cImF0dGFjaG1lbnRfMTUyNzZcIiBhbGlnbj1cImFsaWduY2VudGVyXCIgd2lkdGg9XCIxMjcwXCJdPGltZyBjbGFzcz1cIndwLWltYWdlLTE1Mjc2IHNpemUtZnVsbFwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIwLzAyL05FVFpmZWxkLnBuZ1wiIGFsdD1cIlwiIHdpZHRoPVwiMTI3MFwiIGhlaWdodD1cIjY4N1wiIC8+IE5FVFpmZWxkOiBEaWdpdGFsIGZ1dHVyZSBvZiBydXJhbCBsaWZlWy9jYXB0aW9uXVxyXG5cclxuVGhpcyBsZWQgSEhsYWIgdG8gZGV2ZWxvcCBhIHByb3RvdHlwZSBldmVudCBhaW1lZCBhdCB0aGlzIHNwZWNpZmljIGF1ZGllbmNlLiBBZnRlciBhIGNvdXBsZSBvZiBzdWNjZXNzZnVsIHRlc3QgY29uZmVyZW5jZXMsIHRoZSBsYWIgcmVhbGlzZWQgaXQgaGFkIHRvIGFjY291bnQgZm9yIGNvbXBldGl0aW9uOiBjaGFtYmVycyBvZiBjb21tZXJjZSBhbmQgb3RoZXIgbm9uLWNvbW1lcmNpYWwgYWN0b3JzIGhvbGQgc2ltaWxhciBldmVudHMsIGFuZCBtb3N0bHkgZm9yIGZyZWUuXHJcblxyXG5ISGxhYiBleHBhbmRlZCB0aGVyZWZvcmUgaXRzIHByb2R1Y3QgY29uY2VwdCB3aXRoIGFuIGluZm9ybWF0aW9uIGNvbXBvbmVudC4gVGhpcyB3YXMgcG9zc2libGUgdGhhbmtzIHRvIHRoZSBleGlzdGluZyBpbmZyYXN0cnVjdHVyZSBvZiB0aGUgbG9jYWwgbmV3c3Jvb21zIHRoYXQgdGhlIHR3byBjb21wYW5pZXMgaGF2ZSBpbiBub3J0aCBHZXJtYW55LlxyXG5cclxuXHUyMDFjV2UgYXBwcm9hY2hlZCBvdXIgZWRpdG9ycy1pbi1jaGllZiBhbmQgZXhwbGFpbmVkIHRoYXQgYSBzdG9yeSBhYm91dCBkaWdpdGFsIHRyYW5zZm9ybWF0aW9uIGluIG9uZSBsb2NhdGlvbiBjb3VsZCBiZSByZWxldmFudCBlbHNld2hlcmUsXHUyMDFkIERyZXlrbHVmdCBzYXlzLiBUaGlzIGFsbG93ZWQgdGhlIGxhYiB0byBhZGQgYSBkYWlseSBmZWVkIG9mIGluZm9ybWF0aW9uIGludG8gdGhlIHByb2R1Y3QsIHdoaWNoIGlzIGNvbXBsaW1lbnRlZCBieSBxdWFydGVybHkgcmVwb3J0cyBhbmQgY2FzZSBzdHVkaWVzLlxyXG5cclxuXHUyMDFjSXQgdG9vayBhbG1vc3QgYSB5ZWFyIGZvciB1cyB0byBmZWVsIHRoYXQgd2UgaGFkIHRoZSByaWdodCBtaXggb2YgaW5mb3JtYXRpb24gYW5kIG5ldHdvcmtpbmcgYXQgdGhlIHJpZ2h0IHByaWNlIHBvaW50LFx1MjAxZCBEcmV5a2x1ZnQgc2F5cy4gXHUyMDFjVGhlIGVuZCByZXN1bHQgaXMgYmFzaWNhbGx5IGEgY2x1Yi4gV2hlbiB5b3Ugam9pbiBORVRaZmVsZCwgeW91IGJ1eSBhIGNsdWIgbWVtYmVyc2hpcC5cdTIwMWRcclxuXHJcbltjYXB0aW9uIGlkPVwiYXR0YWNobWVudF8xNTI3N1wiIGFsaWduPVwiYWxpZ25jZW50ZXJcIiB3aWR0aD1cIjQwMzJcIl08aW1nIGNsYXNzPVwid3AtaW1hZ2UtMTUyNzcgc2l6ZS1mdWxsXCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMjAvMDIvMy1UaGUtTmV0emZlbGQtcHJvamVjdC10ZWFtLWZyb20tdGhlLWxlZnQtU29lbmtlLVNjaGllcmVyLU1hcmxlbmUtQm9yY2hhcmR0LVBoaWxpcHAtRHVkZWsuanBnXCIgYWx0PVwiXCIgd2lkdGg9XCI0MDMyXCIgaGVpZ2h0PVwiMTk2MFwiIC8+IFRoZSBOZXR6ZmVsZCBwcm9qZWN0IHRlYW0gKGZyb20gbGVmdCk6IFNvZW5rZSBTY2hpZXJlciwgTWFybGVuZSBCb3JjaGFyZHQgYW5kIFBoaWxpcHAgRHVkZWtbL2NhcHRpb25dXHJcbjxoMz5BcHByb2FjaCB0byBpbm5vdmF0aW9uPC9oMz5cclxuSEhsYWIgaGFzIGEgc3RhZmYgb2YgMTIsIGhhbGYgb2Ygd2hvbSBhcmUgam91cm5hbGlzdHMuIFx1MjAxY1RoaXMgc3BsaXQgaXMgcGVyZmVjdCxcdTIwMWQgRHJleWtsdWZ0IHNheXMuIFx1MjAxY1dlIG5lZWQgdGhlIGpvdXJuYWxpc3RzXHUyMDE5IGV4cGVydGlzZSwgYnV0IHdlIGFsc28gbmVlZCBwZW9wbGUgd2l0aCBhIGN1c3RvbWVyXHUyMDE5cyBwZXJzcGVjdGl2ZS5cdTIwMWRcclxuXHJcbkFzIG1lbnRpb25lZCwgdGhlIGxhYiB1c3VhbGx5IHN0YXJ0cyBpdHMgaW5ub3ZhdGlvbiBwcm9qZWN0cyB3aGVuIHNvbWVvbmUgaW4gdGhlIHRlYW0gaWRlbnRpZmllcyBhIG5lZWQgdGhhdCB0aGUgbWFya2V0IGRvZXNuXHUyMDE5dCBjYXRlciBmb3IsIGFuZCB0aGVuIHNrZXRjaGVzIGEgcHJvZHVjdCBjb25jZXB0IGJhc2VkIG9uIHRoaXMgbmVlZC4gSWYgdGhlIGNvbmNlcHQgaXMgY29udmluY2luZyBlbm91Z2gsIHRoZSBwcm9qZWN0IGlzIHB1dCBvbiBhIFx1MjAxY2Zhc3QgdHJhY2tcdTIwMWQsIHdoaWNoIGdpdmVzIHRoZSBwcm9qZWN0IHRlYW0gZm91ciB3ZWVrcyB0byBkZXZlbG9wIHRoZSBjb25jZXB0IGZ1cnRoZXIuXHJcblxyXG5BdCB0aGlzIHBvaW50IHRoZSB0ZWFtcyB0ZW5kIHRvIGNvbnNpc3Qgb2YgdGhyZWUgcGVvcGxlLCB1c3VhbGx5IGEgcHJvamVjdCBjb29yZGluYXRvciwgYSB0b3BpYyBleHBlcnQgYW5kIGEgZGV2ZWxvcGVyLiBUaGVyZSBhcmUgdHlwaWNhbGx5IDUgb3IgNiBhY3RpdmUgcHJvZHVjdCBkZXZlbG9wbWVudCBwcm9qZWN0cyBpbiBwYXJhbGxlbC5cclxuXHJcbk9uY2UgZmluaXNoZWQsIHRoZSBwcm9kdWN0IHRlYW0gcHJlc2VudHMgdGhlIHByb3RvdHlwZSB0byB0aGUgbGFiLCBhbmQgdGhlIHdob2xlIHRlYW0gbmVlZHMgdG8gZ2l2ZSB0aGVpciBidXktaW4gaW4gb3JkZXIgZm9yIHRoZSBjb25jZXB0IHRvIGJlIGRldmVsb3BlZCBpbnRvIGEgZnVsbC1mbGVkZ2VkIHByb2R1Y3QuXHJcblxyXG5Ob3QgYWxsIG9mIHRoZSBleHBsb3JlZCBpZGVhcyBhcmUgc3VjY2Vzc2Z1bCwgYnV0IERyZXlrbHVmdCBlbXBoYXNpc2VzIHRoYXQgdGhpcyBpcyBhbiBpbXBvcnRhbnQgcGFydCBvZiB0aGUgcHJvY2Vzcy4gRm9yIGluc3RhbmNlLCBpbiAyMDE3IHRoZSBsYWIgcmFuIGEgcHJvamVjdCBvbiBcdTIwMWNhbWJpZW50IG5ld3NcdTIwMWQsIGV4cGxvcmluZyBkaWZmZXJlbnQgd2F5cyB0byB1c2UgXHUyMDFjSW50ZXJuZXQgb2YgVGhpbmdzXHUyMDFkIGRldmljZXMgZm9yIGpvdXJuYWxpc3RpYyBjb250ZW50LlxyXG5cclxuXHUyMDFjVGhlIGNvbmNsdXNpb24gd2FzIHRoYXQgdGhlcmUgYXJlIGluZGVlZCB3YXlzIG9mIGJyaW5naW5nIG5ld3MgYW5kIGpvdXJuYWxpc20gdG8gdGhlIEludGVybmV0IG9mIFRoaW5ncyxcdTIwMWQgRHJleWtsdWZ0IHNheXMuIFx1MjAxY0J1dCB0aGVyZSBpcyBubyBJbnRlcm5ldCBvZiBUaGluZ3MhIFRoZXJlIGlzIG5vIHNwZWFrZXIgb24gbXkgZnJpZGdlLCBubyBzY3JlZW4gb24gbXkgb3ZlbiwgYW5kIG15IGJhdGhyb29tIG1pcnJvciBpcyBqdXN0IGEgbm9ybWFsIG1pcnJvci5cdTIwMWRcclxuXHJcblRoZSB0ZWFtIHRodXMgY29uY2x1ZGVkIHRoYXQgdGhlIGxpbWl0ZWQgbnVtYmVyIG9mIHNtYXJ0IGhvbWUgYXBwbGlhbmNlcyBpbiB0aGUgbWFya2V0LCBzdWNoIGFzIHNtYXJ0IGxpZ2h0IGJ1bGJzIGFuZCBzcGVha2VycywgZG9uXHUyMDE5dCBvZmZlciBlbm91Z2ggb3Bwb3J0dW5pdGllcyBmb3IgYW4gSW9UIG5ld3MgcHJvZHVjdC4gQnV0IGV2ZW4gaWYgdGhlIHByb2plY3QgZGlkblx1MjAxOXQgcmVzdWx0IGluIGEgbWFya2V0YWJsZSBwcm9kdWN0LCBEcmV5a2x1ZnQgc2F5cyBzdWNoIGluaXRpYXRpdmVzIHN0aWxsIHByb2R1Y2UgbGVhcm5pbmdzIHRoYXQgYXJlIGltcG9ydGFudCBpbiB0aGVtc2VsdmVzLlxyXG48aDM+Rm9jdXMgb24gYWdpbGl0eSBhbmQga25vd2xlZGdlIHRyYW5zbWlzc2lvbjwvaDM+XHJcbkhIbGFiIGluZGVlZCB2YWx1ZXMgaW50ZXJuYWwgbGVhcm5pbmcgaGlnaGx5LCBhbmQgZXZlcnlvbmUgaW4gdGhlIHRlYW0gaXMgZXhwZWN0ZWQgdG8gcmVjb3JkIGFuZCB0cmFuc21pdCB0aGVpciBsZWFybmluZ3MuIFRoZSBsYWIgdXNlcyBleHRlcm5hbCByZXNvdXJjZXMgcmFyZWx5IGZvciB0aGUgc2FtZSByZWFzb24sIHByZWZlcnJpbmcgdG8gYnVpbGQgdXAgaXRzIGludGVybmFsIGtub3dsZWRnZSBhbmQgY29tcGV0ZW5jZXMuIFRlYW0gbWVtYmVycyBhbHNvIHBhcnRpY2lwYXRlIGluIGNvdXJzZXMgb24gZGVzaWduIHRoaW5raW5nLCBsZWFuIHN0YXJ0dXAsIGFuZCBpbm5vdmF0aW9uIGluIHRoZSBtZWRpYSBpbmR1c3RyeSBhdCBpbnN0aXR1dGlvbnMgc3VjaCBhcyBIeXBlciBJc2xhbmQgYW5kIEhhc3NvIFBsYXR0bmVyIEluc3RpdHV0ZS5cclxuXHJcblx1MjAxY0V2ZXJ5Ym9keSBpcyBvYmxpZ2VkIHRvIHdyaXRlIGRvd24gZXZlcnl0aGluZyBoZSBvciBzaGUgZG9lcyBhbmQgbGVhcm5zLiBXZSB3YW50IHRvIGZhaWwgYW5kIGxlYXJuIG91cnNlbHZlcyxcdTIwMWQgRHJleWtsdWZ0IHNheXMuIFx1MjAxY0lmIHlvdSB3YW50IHRvIGxlYXJuIGFuZCBnZXQgYmV0dGVyLCB5b3UgbmVlZCB0d28gdGhpbmdzOiB5b3UgbmVlZCB0byB0YWxrIHdpdGhpbiB0aGUgdGVhbSwgYW5kIHlvdSBuZWVkIGRvY3VtZW50YXRpb24uIFdlIGRvY3VtZW50IGV2ZXJ5dGhpbmcuXHUyMDFkXHJcblxyXG5bY2FwdGlvbiBpZD1cImF0dGFjaG1lbnRfMTUyNzhcIiBhbGlnbj1cImFsaWduY2VudGVyXCIgd2lkdGg9XCI0MjQxXCJdPGltZyBjbGFzcz1cIndwLWltYWdlLTE1Mjc4IHNpemUtZnVsbFwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIwLzAyLzEtSEhMYWItZW1wbG95ZWVzLWRldmVsb3AtYS1wZXJzb25hLWZvci1vbmUtb2Ytb3VyLXRhcmdldC1ncm91cHMuanBnXCIgYWx0PVwiXCIgd2lkdGg9XCI0MjQxXCIgaGVpZ2h0PVwiMjgyOVwiIC8+IEhITGFiIHRlYW0gZGV2ZWxvcGluZyBhIHBlcnNvbmEgZm9yIG9uZSBvZiBpdHMgdGFyZ2V0IGdyb3Vwcy5bL2NhcHRpb25dXHJcblxyXG5BcyBmb3IgdGhlIGlubm92YXRpb24gbWV0aG9kb2xvZ2llcywgdGhlIGxhYiBtYWlubHkgdXNlcyB0aGUgZGVzaWduIHRoaW5raW5nIHByb2Nlc3MsIHNvbWV0aW1lcyBhbHNvIGVtcGxveWluZyB0aGUgbGVhbiBzdGFydC11cCBtZXRob2RvbG9neS4gVGhlIGltcG9ydGFudCB0aGluZywgd2hpY2hldmVyIG1ldGhvZCBpcyB1c2VkLCBpcyBhZ2lsaXR5IGFuZCB0aGUgYWJpbGl0eSB0byBiYWNrdHJhY2suXHJcblxyXG5cdTIwMWNZb3UgY29uc3RhbnRseSBuZWVkIHRvIGFzayB5b3Vyc2VsZiBpZiBpdFx1MjAxOXMgbmVjZXNzYXJ5IHRvIHRha2UgYSBzdGVwIGJhY2ssXHUyMDFkIERyZXlrbHVmdCBzYXlzLCBhZGRpbmcgdGhhdCB0aGUgdGVhbSB1c2VzIHdlbGwtZGVmaW5lZCBLUElzIGFuZCBkYXRhIGFuYWx5c2lzIHRvIGRldGVybWluZSB3aGV0aGVyIGEgZ2l2ZW4gcHJvamVjdCBpcyBvbiB0aGUgcmlnaHQgdHJhY2suXHJcblxyXG5cdTIwMWNJdCByZWFsbHkgaHVydHMgd2hlbiB5b3UgcmVhbGlzZSB0aGF0IHlvdSBoYXZlIHRvIGdvIGJhY2sgYW5kIHN0YXJ0IGFnYWluLiBCdXQgZmVlbGluZyB0aGUgcGFpbiBpcyBhIHZlcnkgZ29vZCB0aGluZyBmb3IgbGVhcm5pbmcuIEFuZCB5b3UgY2FuXHUyMDE5dCBmZWVsIHRoYXQgcGFpbiBmcm9tIGEgYm9vayBvciBhIGNvdXJzZS5cdTIwMWRcclxuPGgzPlNwcmVhZGluZyB0aGUgaW5ub3ZhdGlvbiBzcGlyaXQ8L2gzPlxyXG5ISGxhYiBpcyBwYXJ0IG9mIE5PWiBkaWdpdGFsLCBhIHN1YnNpZGlhcnkgb2YgTk9aIE1lZGllbiB0aGF0IGRyaXZlcyBkaWdpdGFsIHRyYW5zZm9ybWF0aW9uIG9mIE5PWiBNZWRpZW4gYW5kIG1oOm4gTWVkaWVuLiBCdXQgd2hlbiBpdCBjb21lcyB0byB0aGUgcmVsYXRpb25zaGlwIHdpdGggdGhlIGFmZmlsaWF0ZWQgY29tcGFuaWVzLCBEcmV5a2x1ZnQgYWRtaXRzIHRoYXQga25vd2xlZGdlIG9mIHRoZSBsYWJcdTIwMTlzIHdvcmsgZG9lc25cdTIwMTl0IGFsd2F5cyByZWFjaCBvdGhlciBwYXJ0cyBvZiB0aGUgb3JnYW5pc2F0aW9uLlxyXG5cclxuSW4gZmFjdCwgaGUgcmVndWxhcmx5IG1lZXRzIHBlb3BsZSBpbiB0aGUgd2lkZXIgb3JnYW5pc2F0aW9uIHdobyBkbyBub3QgdW5kZXJzdGFuZCB3aGF0IHRoZSBsYWIgZG9lcy4gVGhlIGlubm92YXRpb24gdGVhbSBpcyB0cnlpbmcgdG8gYWRkcmVzcyB0aGlzIHRocm91Z2ggY29tbXVuaWNhdGlvbi5cclxuXHJcblx1MjAxY1RoZSB3b3JraG9yc2Ugb2Ygb3VyIGludGVybmFsIGNvbW11bmljYXRpb24gZWZmb3J0cyBpcyBhIG9uZS1kYXkgY291cnNlIG9uIEluc3RhZ3JhbSBzdG9yeXRlbGxpbmcsXHUyMDFkIERyZXlrbHVmdCBzYXlzLiBcdTIwMWNQZW9wbGUgY29tZSBiZWNhdXNlIHRoZXkgZmVlbCBpdFx1MjAxOXMgdXNlZnVsIGZvciB0aGVpciB3b3JrLiBCdXQgaW4gYWRkaXRpb24gdG8gSW5zdGFncmFtIHN0b3J5dGVsbGluZywgd2UgYWxzbyB0YWxrIGdlbmVyYWxseSBhYm91dCBvdXIgcHJvamVjdHMgYW5kIGhvdyB3ZSB3b3JrLlx1MjAxZFxyXG5cclxuVGhlIGxhYiBhbHNvIGFpbXMgdG8gaWRlbnRpZnkgcGVvcGxlIHdpdGhpbiB0aGUgb3JnYW5pc2F0aW9uIHdobyBmZWVsIHRoYXQgdGhlIGNvbXBhbnkgc2hvdWxkIGJlIG1vdmluZyBmYXN0ZXIgd2l0aCBkaWdpdGFsIGlubm92YXRpb25zLCBicmluZ2luZyB0aGVtIHRvZ2V0aGVyIGZvciBhIHNpeC13ZWVrIHByb2dyYW0uIFRoaXMsIHRoZSBsYWIgaG9wZXMsIHdpbGwgaGVscCB0aGUgcGFydGljaXBhbnRzIHNwcmVhZCBhIG1vcmUgZm9yd2FyZC1sb29raW5nIG1pbmRzZXQgd2l0aGluIHRoZSBjb21wYW55LlxyXG48aDM+TGlua3Mgd2l0aCB0aGUgd2lkZXIgbWVkaWEgaW5ub3ZhdGlvbiBzcGhlcmU8L2gzPlxyXG5BbHRob3VnaCBjb25uZWN0aW5nIHdpdGggdGhlIGJyb2FkZXIgbWVkaWEgaW5ub3ZhdGlvbiBlY29zeXN0ZW0gaXMgY3J1Y2lhbCwgRHJleWtsdWZ0IHNlZXMgYW4gdW5mb3J0dW5hdGUgc2hvcnRjb21pbmcgd2l0aCB0aGUgcmVsYXRlZCBjb25mZXJlbmNlczogXHUyMDFjVGhlIGFwcHJvYWNoIGF0IHRoZXNlIGV2ZW50cyBvZnRlbiBpcywgZXZlcnlib2R5IHNob3VsZCBiZSBhYmxlIHRvIGpvaW4gYW5kIHVuZGVyc3RhbmQgdGhlIGRpc2N1c3Npb25zLiBXaGljaCBtZWFucyB0aGF0IHRoZSBkaXNjdXNzaW9ucyBhcmUgbW9zdGx5IG9uIGEgYmFzaWMgbGV2ZWwuXHUyMDFkXHJcblxyXG5UaGlzIG1pZ2h0IHdvcmsgaW4gdGVybXMgZm9yIGdldHRpbmcgcGVvcGxlIGVuZ2FnZWQsIGJ1dCBEcmV5a2x1ZnQgc2F5cyB0aGF0IHBlb3BsZSB3b3JraW5nIG9uIG1lZGlhIGlubm92YXRpb24gZnVsbCB0aW1lIHdvdWxkIGJlbmVmaXQgZnJvbSBhIG1vcmUgYWR2YW5jZWQgYXBwcm9hY2guIFx1MjAxY0lcdTIwMTlkIHdhbnQgdG8gbWVldCBwZW9wbGUgd2hvIGFscmVhZHkga25vdyB3aGF0IGFnaWxpdHkgaXMsIG9yIHdoYXQgcHJvdG90eXBpbmcgaXMsIG9yIGhvdyBkZXNpZ24gdGhpbmtpbmcgYW5kIGxlYW4gc3RhcnQtdXAgbWV0aG9kb2xvZ2llcyBkaWZmZXIuIEJ1dCB0aGUgb3Bwb3J0dW5pdGllcyBmb3IgdGhpcyBhcmUgcmFyZS5cdTIwMWRcclxuXHJcbkJleW9uZCB0aGUgbWVkaWEgaW5kdXN0cnksIEhIbGFiIGhhcyBhbiBvbmdvaW5nIHJlc2VhcmNoIHByb2dyYW1tZSB3aXRoIHRoZSBVbml2ZXJzaXR5IG9mIEhhbWJ1cmcuIEJ1dCB3aGVuIGl0IGNvbWVzIHRvIHdvcmtpbmcgd2l0aCBzdGFydC11cHMsIERyZXlrbHVmdCBzYXlzIGhlIGlzIGxlc3Mgb3B0aW1pc3RpYyBhYm91dCB0aGVzZSBjb2xsYWJvcmF0aW9ucyB0aGFuIGhlIHVzZWQgdG8gYmUsIGV2ZW4gaWYgSGFtYnVyZyBoYXMgYSBzdHJvbmcgbWVkaWEgc3RhcnQtdXAgc2NlbmUuXHJcblxyXG5cdTIwMWNJIG5vdyBmZWVsIHRoYXQgdGhlcmUgYXJlIG5vdCBzbyBtYW55IGNvbm5lY3Rpb24gcG9pbnRzIHdpdGggc3RhcnQtdXBzIHRoYXQgSSB0aG91Z2h0IHR3byBvciB0aHJlZSB5ZWFycyBhZ28sIGJlY2F1c2UgdGhlaXIgbmVlZHMgYXJlIHZlcnkgZGlmZmVyZW50IGZyb20gb3VycyxcdTIwMWQgaGUgc2F5cy4gXHUyMDFjVGhlaXIgYmFzaWMgbmVlZCBpcyB0byBjb252aW5jZSBpbnZlc3RvcnMsIHNvIHRoYXRcdTIwMTlzIHdoZXJlIHRoZXkgZm9jdXMgdGhlaXIgZW5lcmd5Llx1MjAxZFxyXG5cclxuQWxzbyBkaWZmZXJlbnQgbWV0aG9kcyBzZXBhcmF0ZSB0aGUgdHdvIGZpZWxkcywgYXMgRHJleWtsdWZ0IHNheXMgdGhhdCBzdGFydC11cHMgYXJlIG1vc3RseSBiYXNlZCBvbiBkZXZlbG9waW5nIGFuIGlkZWEsIHdoaWxlIEhIbGFiXHUyMDE5cyBhcHByb2FjaCBpcyBtb3JlIHN5c3RlbWF0aWM6IFx1MjAxY0luIG15IGV4cGVyaWVuY2UsIHdoZW4gaXQgY29tZXMgdG8gc3VjY2Vzc2Z1bCBwcm9kdWN0IGRldmVsb3BtZW50LCBvbmUgb2YgdGhlIGxlYXN0IGltcG9ydGFudCB0aGluZ3MgaXMgdGhlIGlkZWEuXHUyMDFkXHJcbjxoMz5Jbm5vdmF0aW9uIHRoYXQgcmVkdWNlcyBjb3N0czwvaDM+XHJcbkFsdGhvdWdoIHRoZSBuZXdzIGJ1c2luZXNzIG1vZGVsIHNlcnZlZCB0aGUgbmV3c3BhcGVyIGluZHVzdHJ5IHdlbGwgZm9yIGEgbG9uZyB0aW1lLCByZWx5aW5nIG9uIHRoZSBzYW1lIG1vZGVsIGZvciBzdWNoIGEgbG9uZyB0aW1lIGhhcyBtYWRlIHB1Ymxpc2hlcnMgbGVzcyBlZmZlY3RpdmUgYXQgZGV0ZWN0aW5nIG5ld3MgYnVzaW5lc3Mgb3Bwb3J0dW5pdGllcyBhbmQgY3JlYXRpbmcgbmV3IHByb2R1Y3RzLCBEcmV5a2x1ZnQgc2F5cy4gVGhpcyBpcyBhcHBhcmVudCBpbiB0aGUgd2F5IG1hbnkgcHVibGlzaGVycyByZWFjdCB0byBISGxhYlx1MjAxOXMgd29yay5cclxuXHJcblx1MjAxY1doYXQgSSBvZnRlbiBoZWFyIGlzLCBcdTIwMTh3aGF0IHlvdSBkbyBpcyBncmVhdCBidXQgaXRcdTIwMTlzIHZlcnkgZXhwZW5zaXZlLCBhbmQgd2UgY291bGQgbmV2ZXIgYWZmb3JkIGl0Llx1MjAxOSBJIGFsd2F5cyB0cnkgdG8gZXhwbGFpbiB0aGF0IGFjdHVhbGx5LCB3aGF0IHdlIGFyZSBkb2luZyBpcyB0aGUgbGVhc3QgZXhwZW5zaXZlIGFwcHJvYWNoIHlvdSBjYW4gaGF2ZSBmb3Igc3VjY2Vzc2Z1bCBwcm9kdWN0IGRldmVsb3BtZW50Llx1MjAxZFxyXG5cclxuSGUgc2F5cyB0aGF0IHRoZSBtZWRpYSBpbmR1c3RyeSB0ZW5kcyB0byBjcmVhdGUgbmV3IHByb2R1Y3RzIGJ5IHRha2luZyBhbiBpZGVhLCBjcmVhdGluZyBhIHByb2R1Y3QgYmFzZWQgb24gaXQsIHB1dHRpbmcgaXQgdG8gdGhlIG1hcmtldCBcdTIwMTMgYW5kIHRoZW4gbGV0dGluZyB0aGUgbWFya2V0IGRlY2lkZSB3aGV0aGVyIHRoZSBwcm9kdWN0IGlzIHN1Y2Nlc3NmdWwgb3Igbm90LlxyXG5cclxuXHUyMDFjVGhhdFx1MjAxOXMgdGhlIG1vc3QgZXhwZW5zaXZlIGFwcHJvYWNoIHRvIHByb2R1Y3QgZGV2ZWxvcG1lbnQgdGhlcmUgaXMhIEJ5IGNvbnRyYXN0LCBvdXIgcmVzZWFyY2ggYW5kIGRldmVsb3BtZW50IG1ldGhvZHMgYWltIHRvIG1ha2Ugc3VjY2VzcyBhcyBsaWtlbHkgYXMgcG9zc2libGUsXHUyMDFkIERyZXlrbHVmdCBzYXlzLiBcdTIwMWNTbyBpbiB0aGUgZW5kLCB3ZSBkbyBub3QgcHJvZHVjZSBjb3N0cywgd2UgcmVkdWNlIHRoZW0uXHUyMDFkXHJcblxyXG4mbmJzcDtcclxuXHJcbkNPTlRBQ1QgUE9JTlRcclxuXHJcbjxpbWcgY2xhc3M9XCJzaXplLW1lZGl1bSB3cC1pbWFnZS0xNTI3OSBhbGlnbm5vbmVcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAyMC8wMi80LUpvYWNoaW0tRHJleWtsdWZ0LTMwMHgyMDAuanBnXCIgYWx0PVwiXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMDBcIiAvPlxyXG5cclxuSm9hY2hpbSBEcmV5a2x1ZnQsIERpcmVjdG9yLCBISGxhYlxyXG5Ud2l0dGVyOiA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9kcmV5a2x1ZnRcIj5ARHJleWtsdWZ0PC9hPlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNFwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxoMz5BdXRob3I8L2gzPlxyXG5bc2ltcGxlLWF1dGhvci1ib3hdWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS80XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddIiwicG9zdF90aXRsZSI6IkhIbGFiOiBJbm5vdmF0aW5nIG5ldyBwcm9kdWN0cyBhbmQgYnVzaW5lc3Mgb3Bwb3J0dW5pdGllcyIsInBvc3RfbGluayI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9oaGxhYi1pbm5vdmF0aW5nLW5ldy1wcm9kdWN0cy1hbmQtYnVzaW5lc3Mtb3Bwb3J0dW5pdGllcy8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJISGxhYjogSW5ub3ZhdGluZyBuZXcgcHJvZHVjdHMgYW5kIGJ1c2luZXNzIG9wcG9ydHVuaXRpZXNcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjE2NVwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIwLzAyL0hIbGFiMi0zMDB4MTY1LnBuZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6Ik1lZGlhIGxhYnMiLCJwb3N0X3RhZ3MiOiIiLCIlX2VkaXRfbG9jayUiOiIxNjExODIyODU2OjkzMSIsIiVfZWRpdF9sYXN0JSI6IjkzMSIsIiVfdGh1bWJuYWlsX2lkJSI6IjE1MjgwIiwiJXNsaWRlX3RlbXBsYXRlJSI6ImRlZmF1bHQiLCIlX3dwYl92Y19qc19zdGF0dXMlIjoidHJ1ZSIsIiVfd3BnbXBfbG9jYXRpb25fYWRkcmVzcyUiOiJCYXJuZXJzdHJhXHUwMGRmZSAxNCwgMjI3NjUgSGFtYnVyZywgR2VybWFueSIsIiVfd3BnbXBfbG9jYXRpb25fY2l0eSUiOiJIYW1idXJnIiwiJV93cGdtcF9sb2NhdGlvbl9zdGF0ZSUiOiJIYW1idXJnIiwiJV93cGdtcF9sb2NhdGlvbl9jb3VudHJ5JSI6Ikdlcm1hbnkiLCIlX3dwZ21wX21ldGFib3hfbGF0aXR1ZGUlIjoiNTMuNTU3MjAyMiIsIiVfd3BnbXBfbWV0YWJveF9sb25naXR1ZGUlIjoiOS45MzE4MDE0IiwiJV93cGdtcF9tZXRhYm94X2xvY2F0aW9uX3JlZGlyZWN0JSI6Im1hcmtlciIsIiVfd3BnbXBfbWV0YWJveF9jdXN0b21fbGluayUiOiIiLCIlX3dwZ21wX21hcF9pZCUiOiJhOjE6e2k6MDtzOjE6XCIyXCI7fSIsIiVfd3BnbXBfbWV0YWJveF9tYXJrZXJfaWQlIjoiTjsiLCIlX3dwZ21wX21ldGFib3hfdGF4b21vbWllc190ZXJtcyUiOiJOOyIsIiVfd3BnbXBfZXh0ZW5zaW9uc19maWVsZHMlIjoiTjsiLCIlX2tsZW9fdHJhbnNwYXJlbnRfbWVudV9jb2xvciUiOiJ3aGl0ZSIsIiVfa2xlb190aXRsZV9jaGVja2JveCUiOiIxIiwiJV9rbGVvX3RpdGxlX2NvbG9yJSI6IiMiLCIlX2tsZW9fdGl0bGVfYmclIjoiLCByZXBlYXQsIGluaGVyaXQsIHNjcm9sbCwgbGVmdCB0b3AiLCIlX2tsZW9fdGl0bGVfYmdfY29sb3IlIjoiIyIsIiVfeW9hc3Rfd3BzZW9fY29udGVudF9zY29yZSUiOiIzMCIsIiVfeW9hc3Rfd3BzZW9fcHJpbWFyeV9jYXRlZ29yeSUiOiIxNDIiLCIlc2JnX3NlbGVjdGVkX3NpZGViYXIlIjoiMCIsIiVzYmdfc2VsZWN0ZWRfc2lkZWJhcl9yZXBsYWNlbWVudCUiOiIwIiwidGF4b25vbXk9Y2F0ZWdvcnkiOiJNZWRpYSBsYWJzIiwidGF4b25vbXk9cG9zdF90YWciOiIifSwiaWNvbiI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE4LzAyL21hcmtlci0xLnBuZyJ9LCJpZCI6MTUyNzUsImluZm93aW5kb3dfZGlzYWJsZSI6ZmFsc2V9LHsic291cmNlIjoicG9zdCIsInRpdGxlIjoiVlBSTyBNZWRpYWxhYjogYnJpbmdpbmcgc3Rvcnl0ZWxsaW5nIHRvIG5ldyB0ZWNobm9sb2dpZXMiLCJpbmZvd2luZG93X2NvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIlZQUk8gTWVkaWFsYWI6IGJyaW5naW5nIHN0b3J5dGVsbGluZyB0byBuZXcgdGVjaG5vbG9naWVzXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMTZcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxOS8xMS9WUFJPLW1haW4taW1hZ2UtMzAweDIxNi5wbmdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1wYWRkaW5nLWNvbnRlbnRfMjBcIj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1tZXRhIGZjLWl0ZW0tc2Vjb25kYXJ5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2UgZmMtdGV4dC1jZW50ZXJcIj5NZWRpYSBsYWJzPC9kaXY+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tdGl0bGUgZmMtaXRlbS1wcmltYXJ5LXRleHQtY29sb3IgZmMtdGV4dC1jZW50ZXJcIj5WUFJPIE1lZGlhbGFiOiBicmluZ2luZyBzdG9yeXRlbGxpbmcgdG8gbmV3IHRlY2hub2xvZ2llczwvZGl2PlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2VcIj5cclxuICAgICAgICAgICAgVGhlIER1dGNoIGJyb2FkY2FzdGVyXHUyMDE5cyBtZWRpYSBpbm5vdmF0aW9uIGxhYiB1c2VzIG5vdmVsIHRlY2hub2xvZ2llcyB0byBwcm92aWRlIGVuZ2FnaW5nIG5hcnJhdGl2ZSBleHBlcmllbmNlcywgd2hpbGUgYWxzbyBpbmZvcm1pbmcgaXRzIGF1ZGllbmNlIGFib3V0IHRoZSB0ZWNobm9sb2dpZXNcdTIwMTkgcG9zc2libGUgaW1wYWN0IG9uIHRoZWlyIGV2ZXJ5ZGF5IGxpdmVzLlxyXG4gICAgICAgIDwvZGl2PlxyXG48YSBocmVmPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL3Zwcm8tbWVkaWFsYWItYnJpbmdpbmctc3Rvcnl0ZWxsaW5nLXRvLW5ldy10ZWNobm9sb2dpZXMvXCI+UmVhZCBtb3JlPC9hPlxyXG4gICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuPC9kaXY+XHJcblxyXG4iLCJjb250ZW50IjoiVGhlIER1dGNoIGJyb2FkY2FzdGVyXHUyMDE5cyBtZWRpYSBpbm5vdmF0aW9uIGxhYiB1c2VzIG5vdmVsIHRlY2hub2xvZ2llcyB0byBwcm92aWRlIGVuZ2FnaW5nIG5hcnJhdGl2ZSBleHBlcmllbmNlcywgd2hpbGUgYWxzbyBpbmZvcm1pbmcgaXRzIGF1ZGllbmNlIGFib3V0IHRoZSB0ZWNobm9sb2dpZXNcdTIwMTkgcG9zc2libGUgaW1wYWN0IG9uIHRoZWlyIGV2ZXJ5ZGF5IGxpdmVzLiIsImFkZHJlc3MiOiJIaWx2ZXJzdW0sIE5ldGhlcmxhbmRzIiwibG9jYXRpb24iOnsibGF0IjoiNTIuMjI5MTY5NiIsImNpdHkiOiJIaWx2ZXJzdW0iLCJzdGF0ZSI6Ik5vcnRoIEhvbGxhbmQiLCJjb3VudHJ5IjoiTmV0aGVybGFuZHMiLCJsbmciOiI1LjE2Njg5NzQwMDAwMDAzOSIsIm9uY2xpY2tfYWN0aW9uIjoibWFya2VyIiwicmVkaXJlY3RfcGVybWFsaW5rIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL3Zwcm8tbWVkaWFsYWItYnJpbmdpbmctc3Rvcnl0ZWxsaW5nLXRvLW5ldy10ZWNobm9sb2dpZXMvIiwiem9vbSI6MiwiZXh0cmFfZmllbGRzIjp7InBvc3RfZXhjZXJwdCI6IlRoZSBEdXRjaCBicm9hZGNhc3Rlclx1MjAxOXMgbWVkaWEgaW5ub3ZhdGlvbiBsYWIgdXNlcyBub3ZlbCB0ZWNobm9sb2dpZXMgdG8gcHJvdmlkZSBlbmdhZ2luZyBuYXJyYXRpdmUgZXhwZXJpZW5jZXMsIHdoaWxlIGFsc28gaW5mb3JtaW5nIGl0cyBhdWRpZW5jZSBhYm91dCB0aGUgdGVjaG5vbG9naWVzXHUyMDE5IHBvc3NpYmxlIGltcGFjdCBvbiB0aGVpciBldmVyeWRheSBsaXZlcy4iLCJwb3N0X2NvbnRlbnQiOiJbdmNfcm93XVt2Y19jb2x1bW4gd2lkdGg9XCIxLzRcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS8yXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48aDE+VlBSTyBNZWRpYWxhYjogYnJpbmdpbmcgc3Rvcnl0ZWxsaW5nIHRvIG5ldyB0ZWNobm9sb2dpZXM8L2gxPlxyXG48ZW0+VGhlIER1dGNoIGJyb2FkY2FzdGVyXHUyMDE5cyBtZWRpYSBpbm5vdmF0aW9uIGxhYiB1c2VzIG5vdmVsIHRlY2hub2xvZ2llcyB0byBwcm92aWRlIGVuZ2FnaW5nIG5hcnJhdGl2ZSBleHBlcmllbmNlcywgd2hpbGUgYWxzbyBpbmZvcm1pbmcgaXRzIGF1ZGllbmNlIGFib3V0IHRoZSB0ZWNobm9sb2dpZXNcdTIwMTkgcG9zc2libGUgaW1wYWN0IG9uIHRoZWlyIGV2ZXJ5ZGF5IGxpdmVzLjwvZW0+XHJcblxyXG5XaGVuIFZQUk8gTWVkaWFsYWIgc2V0cyBvdXQgdG8gaW52ZXN0aWdhdGUgYW4gZW1lcmdpbmcgdGVjaG5vbG9neSwgaXQgYWltcyB0byBjb25zaWRlciBpdCBmcm9tIGEgbXVsdGl0dWRlIG9mIGFuZ2xlcy4gV2hlbiBpdCB3YW50ZWQgdG8gZXhhbWluZSBzbWFydCBzcGVha2VycyBhbmQgdGhlaXIgc3Rvcnl0ZWxsaW5nIHBvdGVudGlhbCwgZm9yIGluc3RhbmNlLCB0aGUgcHJvamVjdCByZXN1bHRlZCBpbiBhIHJhbmdlIG9mIG91dHB1dHM6XHJcbjx1bD5cclxuIFx0PGxpPlRocmVlIEJsYWNrIE1pcnJvci1pc2ggc2hvcnQgZmlsbXMsIGNyZWF0ZWQgYnkgeW91bmcgZmlsbW1ha2VycywgdGhhdCB2aXN1YWxpemUgcG9zc2libGUgc2NlbmFyaW9zIHJlbGF0ZWQgdG8gc21hcnQgZGV2aWNlcy48L2xpPlxyXG4gXHQ8bGk+QW4gZXhoaWJpdGlvbiB0aGF0IGV4cGxvcmVkIHdoYXQgbGlmZSB3aXRoIG9tbmlwcmVzZW50IHNtYXJ0IGRldmljZXMgbWVhbnMsIGFuZCBob3cgeW91IGNvdWxkIHByb3RlY3QgeW91cnNlbGYgZnJvbSB0aGUgdGVjaG5vbG9neS48L2xpPlxyXG4gXHQ8bGk+QW4gaW50ZXJhY3RpdmUgYXVkaW8gZXhwZXJpZW5jZSB0aGF0IGRlcGljdGVkIGhvdyBhbiBlbGRlcmx5IHBlcnNvbiBhdCB0aGUgZWFybHkgc3RhZ2VzIG9mIGRlbWVudGlhIGNvdWxkIGxpdmUgaW5kZXBlbmRlbnRseSB0aGFua3MgdG8gc21hcnQgZGV2aWNlcy48L2xpPlxyXG48L3VsPlxyXG5Hcm91cGVkIHRvZ2V0aGVyLCB0aGVzZSBlbGVtZW50cyBmb3JtZWQgPGEgaHJlZj1cImh0dHBzOi8vd3d3LnZwcm9icm9hZGNhc3QuY29tL21lZGlhbGFiL25ld3MvMjAxOC9Ib21lLVNtYXJ0LUhvbWUuaHRtbFwiPkhvbWUgU21hcnQgSG9tZTwvYT4sIGEgbXVsdGltZWRpYSBwcm9qZWN0IHRoYXQgd2FzIG5vbWluYXRlZCBpbiB0aGUgRGlnaXRhbCBNZWRpYSBwcm9qZWN0cyBjYXRlZ29yeSBhdCB0aGlzIHllYXJcdTIwMTlzIDxhIGhyZWY9XCJodHRwczovL3d3dy5wcml4ZXVyb3BhLmV1L1wiPlByaXggRXVyb3BhPC9hPiBhd2FyZHMuXHJcblxyXG5MaWtlIG1hbnkgb2YgdGhlIHByb2plY3RzIGJ5IHRoZSBEdXRjaCBicm9hZGNhc3Rlclx1MjAxOXMgaW5ub3ZhdGlvbiBsYWIsIEhvbWUgU21hcnQgSG9tZSBjb21iaW5lZCB0d28gZ29hbHM6IFx1MjAxY09uIHRoZSBvbmUgaGFuZCB3ZSB3YW50IHRvIGNyZWF0aXZlbHkgZXhwbG9yZSB0aGUgcG9zc2liaWxpdGllcyB0aGF0IG5ldyB0ZWNobm9sb2dpZXMgYWxsb3cgZm9yIHN0b3J5dGVsbGluZyxcdTIwMWQgc2F5cyBBbm5lbGllcyBUZXJtZWVyLCBDcmVhdGl2ZSBEaXJlY3RvciBvZiBWUFJPIE1lZGlhbGFiLiBcdTIwMWNPbiB0aGUgb3RoZXIsIHdlIGFpbSB0byByYWlzZSBhd2FyZW5lc3Mgb2YgdGhlIHBvc2l0aXZlIGFuZCBuZWdhdGl2ZSBzaWRlcyBvZiB0aGVzZSB0ZWNobm9sb2dpZXMuXHUyMDFkXHJcblxyXG5cdTIwMWNJbiB0aGlzIGNhc2UgdGhlIHByb2plY3QgYWxsb3dlZCBvdXIgYXVkaWVuY2UgdG8gcmVmbGVjdCBvbiB3aGF0IGl0IHJlYWxseSBtZWFucyB3aGVuIHlvdSBsZXQgc21hcnQgaG9tZSB0ZWNobm9sb2d5IGVudGVyIHlvdXIgaG9tZS5cdTIwMWRcclxuXHJcbltjYXB0aW9uIGlkPVwiYXR0YWNobWVudF8xNTIyMFwiIGFsaWduPVwiYWxpZ25ub25lXCIgd2lkdGg9XCIxMDI0XCJdPGEgaHJlZj1cImh0dHBzOi8vd3d3LnZwcm8ubmwvbWVkaWFsYWIvcHJvamVjdGVuL292ZXJ6aWNodC9ob21lLXNtYXJ0LWhvbWUvaG9tZS1zbWFydC1ob21lLXNob3J0cy5odG1sXCI+PGltZyBjbGFzcz1cIndwLWltYWdlLTE1MjIwIHNpemUtbGFyZ2VcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxOS8xMS9Ib21lLXNtYXJ0LWhvbWUtMTAyNHg1NzYucG5nXCIgYWx0PVwiXCIgd2lkdGg9XCIxMDI0XCIgaGVpZ2h0PVwiNTc2XCIgLz48L2E+IFRoZSBIb21lIFNtYXJ0IEhvbWUgc2hvcnQgZmlsbXMgZXhwbG9yZSBob3cgc21hcnQgc3BlYWtlcnMgY291bGQgaW1wYWN0IG91ciBldmVyeWRheSBsaWZlLlsvY2FwdGlvbl1cclxuPGgzPkxlZ2FjeSBtZWRpYSBvbiBuZXcgcGxhdGZvcm1zPC9oMz5cclxuQXMgYSBwdWJsaWMgYnJvYWRjYXN0ZXIsIFZQUk8gaXMgYXQgdGhlIGhlYXJ0IG9mIGEgcmFwaWRseSBjaGFuZ2luZyBtZWRpYSBzY2VuZSwgd2l0aCBmZXdlciBhbmQgZmV3ZXIgcGVvcGxlIHdhdGNoaW5nIGJyb2FkY2FzdCBUViBvciBsaXN0ZW5pbmcgdG8gdGhlIHJhZGlvLiBUaGlzIHRyZW5kIGlzIGJlaGluZCB0aGUgbWlzc2lvbiBvZiBWUFJPIE1lZGlhbGFiOiBhcyB0cmFkaXRpb25hbCBtZWRpYSBkZWNsaW5lcyBhbmQgYXVkaWVuY2VzIGluY3JlYXNpbmdseSB0dXJuIHRvIG5ldywgZGlnaXRhbCBwbGF0Zm9ybXMgdG8gY29uc3VtZSBtZWRpYSwgd2hhdCBzaG91bGQgdGhlIHJvbGUgb2YgYSBwdWJsaWMgYnJvYWRjYXN0ZXIgYmUgb24gdGhlc2UgcGxhdGZvcm1zP1xyXG5cclxuVGhlIE5ldGhlcmxhbmRzIGhhcyBlaWdodCBwdWJsaWMgYnJvYWRjYXN0ZXJzLCB3aXRoIHRoZSA8ZW0+TmVkZXJsYW5kc2UgUHVibGlla2UgT21yb2VwPC9lbT4gKE5QTykgYWN0aW5nIGFzIGEgZ292ZXJuaW5nIGJvZHkuIEVhY2ggYnJvYWRjYXN0ZXIgaGFzIGEgc29tZXdoYXQgZGlzdGluY3QgcHJvZmlsZSwgd2l0aCBWUFJPIChzaG9ydCBmb3IgPGVtPlZyaWp6aW5uaWcgUHJvdGVzdGFudHNlIFJhZGlvIE9tcm9lcDwvZW0+KSB1c3VhbGx5IHNlZW4gYXMgdGhlIGVkZ3kgYW5kIGNyZWF0aXZlIG9uZSwgZm9jdXNpbmcgb24gZXhwbG9yaW5nIGJvcmRlcnMgYW5kIGxvb2tpbmcgaW50byB0aGUgZnV0dXJlLCBUZXJtZWVyIHNheXMuIFRoaXMgbWFrZXMgaXQgYSBuYXR1cmFsIGhvbWUgZm9yIGFuIGlubm92YXRpb24gbGFiIHRoYXQgZXhhbWluZXMgdGhlIGZ1dHVyZSBvZiBtZWRpYS5cclxuXHJcblRoZSBsYWIgaXMgc2l0dWF0ZWQgd2l0aGluIHRoZSBvcmdhbmlzYXRpb24ncyBpbm5vdmF0aW9uIGFuZCBkaWdpdGFsIG1lZGlhIGRlcGFydG1lbnQsIGFuZCBpdHMgY29yZSB0ZWFtIGNvbnNpc3RzIG9mIFRlcm1lZXIgYW5kIG9uZSBhbm90aGVyIHBlcnNvbiwgYSBwcm9kdWNlci4gV2hlbiBuZWVkZWQsIGhvd2V2ZXIsIHRoZXkgcHVsbCBpbiBkZXNpZ25lcnMsIGRldmVsb3BlcnMgYW5kIHByb2plY3QgbWFuYWdlcnMgZnJvbSBlbHNld2hlcmUgaW4gdGhlIG9yZ2FuaXNhdGlvbiB0byB3b3JrIG9uIHRoZSBpbm5vdmF0aW9uIHByb2plY3RzLlxyXG5cclxuVGhlIGxpbmtzIGJldHdlZW4gdGhlIGxhYiBhbmQgdGhlIHJlc3Qgb2YgdGhlIG9yZ2FuaXNhdGlvbiBhcmUgbG9vc2UsIHdoaWNoIGFjY29yZGluZyB0byBUZXJtZWVyIGlzIGJvdGggYW4gYWR2YW50YWdlIGFuZCBhIGNoYWxsZW5nZTogXHUyMDFjV2Ugd2FudCB0byBiZSB1c2VmdWwgZm9yIFZQUk8sIGJ1dCBhdCB0aGUgc2FtZSB0aW1lIHdlIG5lZWQgdG8gbWFrZSBzdXJlIHdlIGhhdmUgdGhlIGNhcGFjaXR5IGZvciBjcmF6eSBtb29uc2hvdCBwcm9qZWN0cyB0b28sIGJlY2F1c2Ugd2UgbGVhcm4gYSBsb3QgZnJvbSB0aGVtLCBldmVuIGlmIHRoZXkgYXJlblx1MjAxOXQgZGlyZWN0bHkgdXNlZnVsIGZvciB0aGUgb3JnYW5pc2F0aW9uIGluIHRoZSBuZWFyIGZ1dHVyZS5cdTIwMWRcclxuPGgzPk5ldyB0ZWNoIHdpdGggYSBwcmFjdGljYWwgYXBwcm9hY2g8L2gzPlxyXG5XaGVuIHJlYWxpemluZyBpbm5vdmF0aW9uIHByb2plY3RzLCBUZXJtZWVyIHNheXMgdGhlIGxhYiB0YWtlcyBhIHByYWN0aWNhbCBhcHByb2FjaCwgZm9sbG93aW5nIHRoZSBtYXhpbSBcdTIwMWNsZWFybmluZyBieSBkb2luZ1x1MjAxZCwgYW5kIGFsd2F5cyBjcmVhdGluZyBhIGZpbmFsIHByb2R1Y3QgdGhhdCBjYW4gYmUgc2hvd2Nhc2VkIHRvIHRoZSBhdWRpZW5jZS4gRnVuZGluZyBmb3IgcHJvamVjdHMgY29tZXMgcGFydGx5IGZyb20gTlBPLCBwYXJ0bHkgZnJvbSBWUFJPLCBhbmQgcGFydGx5IGZyb20gZXh0ZXJuYWwgc291cmNlcywgZGVwZW5kaW5nIG9uIHByb2plY3QuXHJcblxyXG5XaGVuIGNob29zaW5nIHdoYXQgdGVjaG5vbG9naWVzIHRvIHdvcmsgb24sIHRoZSBsYWIgdHJpZXMgdG8gZm9jdXMgb24gYXJlYXMgdGhhdCBob2xkIHBvdGVudGlhbCBmb3Igbm92ZWwgYXBwcm9hY2hlcyB0byBzdG9yeXRlbGxpbmcgd2hpbGUgYWxzbyByYWlzaW5nIGF3YXJlbmVzcyBvZiB0aGUgY29tcGxleGl0aWVzIHRoYXQgcmVsYXRlIHRvIHRoZSB0ZWNobm9sb2d5LlxyXG5cclxuQ29uc2lkZXIgXHUyMDFjSG90ZWwgU3BpZWtlclx1MjAxZCwgYW5vdGhlciBwcm9qZWN0IHRoYXQgZXhhbWluZWQgdGhlIG5hcnJhdGl2ZSBwb3RlbnRpYWwgb2Ygc21hcnQgc3BlYWtlcnMuIFByZXNlbnRlZCBhdCB0aGlzIHllYXJcdTIwMTlzIER1dGNoIE1lZGlhIFdlZWssIHRoZSBjb29wZXJhdGl2ZSBnYW1lIGFsbG93ZWQgcGxheWVycyB0byBpbnZlc3RpZ2F0ZSBhIGNyaW1lIHRoYXQgdG9vayBwbGFjZSBpbiBhIGZ1dHVyaXN0aWMgaG90ZWwuIFRoZSBwbGF5ZXJzIHdvcmtlZCB0aGUgY2FzZSBieSBsaXN0ZW5pbmcgdG8gdGhlIHJlY29yZGluZ3MgdGhhdCBzbWFydCBzcGVha2VycyBjYXB0dXJlZCBpbiBkaWZmZXJlbnQgcm9vbXMgb2YgdGhlIGhvdGVsLlxyXG5cclxuXHUyMDFjV2Ugd2FudGVkIHRvIGxldCBwZW9wbGUgcGxheSB3aXRoIHRoZSB0ZWNobm9sb2d5IGluIGEgbmV3IHdheSwgYnV0IGFsc28gdGVsbCBhIHN0b3J5IHRoYXQgcmFpc2VzIHF1ZXN0aW9ucyBhYm91dCBwcml2YWN5IGFuZCBkYXRhIHN0b3JhZ2UsXHUyMDFkIHNheXMgVGVybWVlci5cclxuXHJcbltjYXB0aW9uIGlkPVwiYXR0YWNobWVudF8xNTIyNFwiIGFsaWduPVwiYWxpZ25ub25lXCIgd2lkdGg9XCI5NjBcIl08aW1nIGNsYXNzPVwid3AtaW1hZ2UtMTUyMjQgc2l6ZS1mdWxsXCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTkvMTEvSG90ZWwtU3BpZWtlci5qcGdcIiBhbHQ9XCJcIiB3aWR0aD1cIjk2MFwiIGhlaWdodD1cIjUxOVwiIC8+IFRoZSBcdTIwMWNIb3RlbCBTcGlla2VyXHUyMDFkIGdhbWUgdGFza2VkIHRoZSBwbGF5ZXJzIHdpdGggc29sdmluZyBhIGNyaW1lIGJ5IGV4YW1pbmluZyBhdWRpbyBjYXB0dXJlZCBieSBzbWFydCBzcGVha2Vycy5bL2NhcHRpb25dXHJcblxyXG5NYW55IHByb2plY3RzIG1ha2UgZnVsbCB1c2Ugb2YgdGhlIGJyb2FkY2FzdGVyXHUyMDE5cyBtdWx0aW1lZGlhIGNhcGFiaWxpdGllcy4gVlBST1x1MjAxOXMgVFYgZG9jdW1lbnRhcnkgc2VyaWVzIFx1MjAxY1JvYm8gU2FwaWVuc1x1MjAxZCBleHBsb3JlZCBsaWZlIHdpdGggYXJ0aWZpY2lhbCBpbnRlbGxpZ2VuY2UsIGZlYXR1cmluZyBwcm9taW5lbnRseSBhIFBlcHBlciByb2JvdCBhcyBwYXJ0IG9mIHRoZSBwcm9ncmFtbWUuIE9ubGluZSwgdGhlIHNhbWUgY29uY2VwdCB3YXMgZXhwbG9yZWQgZnJvbSBhIGRpZmZlcmVudCBwb2ludCBvZiB2aWV3OiB1c2VycyB3ZXJlIGFibGUgdG8gcGFydGljaXBhdGUgaW4gYSB2ZXJzaW9uIG9mIHRoZSBUdXJpbmcgdGVzdCwgY2FsbGVkIFwiQm90IG9yIE5vdFwiLCB3aGVyZSB0aGV5IGhhZCB0byBndWVzcyB3aGV0aGVyIHRoZXkgd2VyZSBjaGF0dGluZyB3aXRoIGEgcm9ib3Qgb3IgYSBodW1hbi5cclxuXHJcblx1MjAxY1RoZSB0d2lzdCB3YXMgdGhhdCBhZnRlcndhcmRzIHlvdSBnb3QgdG8gcGxheSBhcyB0aGUgYm90LFx1MjAxZCBUZXJtZWVyIHNheXMuIFx1MjAxY1Rha2luZyB0aGlzIHJvbGUgcmVhbGx5IG1hZGUgeW91IHRoaW5rIGFib3V0IHlvdXIgcGVyY2VwdGlvbiBhbmQgZXhwZWN0YXRpb25zIG9mIEFJLlx1MjAxZFxyXG5cclxuW2NhcHRpb24gaWQ9XCJhdHRhY2htZW50XzE1MjI1XCIgYWxpZ249XCJhbGlnbm5vbmVcIiB3aWR0aD1cIjg5NFwiXTxpbWcgY2xhc3M9XCJ3cC1pbWFnZS0xNTIyNSBzaXplLWZ1bGxcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxOS8xMS9Sb2JvLVNhcGllbnMucG5nXCIgYWx0PVwiXCIgd2lkdGg9XCI4OTRcIiBoZWlnaHQ9XCI1MDVcIiAvPiBUaGUgXHUyMDFjUm9ibyBTYXBpZW5zXHUyMDFkIGRvY3VtZW50YXJ5IHNlcmllcyBoYWQgYW4gb25saW5lIGNvdW50ZXJwYXJ0IHRoYXQgcHV0IHRoZSBwbGF5ZXJzIGluIHRoZSByb2xlIG9mIEFJLlsvY2FwdGlvbl1cclxuXHJcbkFydGlmaWNpYWwgaW50ZWxsaWdlbmNlIGlzIGxpa2VseSB0byBpbnNwaXJlIGFsc28gb3RoZXIgcHJvamVjdHMsIGFuZCBUZXJtZWVyIHNheXMgdGhhdCBleHBsb3JpbmcgdGhlIGludGVyc2VjdGlvbiBvZiBBSSBhbmQgY3JlYXRpdml0eSBpcyBhIHBhcnRpY3VsYXJseSBpbnNwaXJpbmcgYXJlYS4gXHUyMDFjSWYgeW91IHNlZSBhIHBpZWNlIG9mIGFydCwgZm9yIGV4YW1wbGUgYSBwYWludGluZywgdGhhdCB5b3UgbGlrZSwgYW5kIGFyZSB0b2xkIGFmdGVyd2FyZHMgdGhhdCBpdCB3YXMgY3JlYXRlZCBieSBhbiBBSSwgd291bGQgaXQgaW1wYWN0IHlvdXIgcmVhY3Rpb24gdG8gaXQ/IFRoaXMgd291bGQgYmUgYSB2ZXJ5IGludGVyZXN0aW5nIHF1ZXN0aW9uIHRvIGV4YW1pbmUuXHUyMDFkXHJcbjxoMz5Ccm9hZCBpbm5vdmF0aW9uIGVjb3N5c3RlbTwvaDM+XHJcbkFzIG1lbnRpb25lZCwgdGhlcmUgYXJlIGVpZ2h0IHB1YmxpYyBicm9hZGNhc3RlcnMgaW4gdGhlIE5ldGhlcmxhbmRzLiBBbGwgb2YgdGhlbSBhcmUgYmFzZWQgaW4gdGhlIGNpdHkgb2YgSGlsdmVyc3VtLCBvZnRlbiBjYWxsZWQgXHUyMDFjbWVkaWEgY2l0eVx1MjAxZCwgYW5kIGVhY2ggaGFzIGl0cyBvd24gbGFiIG9yIHNvbWUgb3RoZXIga2luZCBvZiB1bml0IGRlZGljYXRlZCB0byBpbm5vdmF0aW9uIHByb2plY3RzLiBNb3Jlb3ZlciwgdGhlcmUgYXJlIG1hbnkgbWVkaWEgZmVzdGl2YWxzIGluIHRoZSBjb3VudHJ5LCBzdWNoIGFzIElERkEsIENpbmVraWQgYW5kIFNUUlAgd2hpY2ggb2ZmZXIgYWRkaXRpb25hbCBvcHBvcnR1bml0aWVzIGZvciB0aGUgRHV0Y2ggbWVkaWEgaW5ub3ZhdGlvbiBlY29zeXN0ZW0gdG8gY29tZSB0b2dldGhlciBhbmQgZm9ybSBjb25uZWN0aW9ucy5cclxuXHJcblRoaXMsIGhvd2V2ZXIsIGFsc28gbWFrZXMgaXQgaW1wb3J0YW50IHRvIGNvbnNjaW91c2x5IGJyZWFrIGF3YXkgZnJvbSB0aGUgbWVkaWEgc2NlbmUgYW5kIHRhcCBpbnRvIHRoZSBpbm5vdmF0aW9uIGVmZm9ydHMgdGhhdCBhcmUgdGFraW5nIHBsYWNlIGluIG90aGVyIGluZHVzdHJpZXMsIFRlcm1lZXIgc2F5cy5cclxuPGJsb2NrcXVvdGU+XHUyMDFjSXRcdTIwMTlzIGNydWNpYWwgbm90IHRvIGdldCBzdHVjayBpbiB0aGUgc2FtZSBidWJibGUgd2l0aCBvdGhlciBtZWRpYSBjb21wYW5pZXMuIEluIGZhY3QsIHdoZW4gbG9va2luZyBmb3IgaW5zcGlyYXRpb24sIEkgbW9zdGx5IGxvb2sgYXQgd2hhdCBpcyBoYXBwZW5pbmcgaW4gdGhlIHRlY2gsIGRlc2lnbiwgYW5kIGFydCBzY2VuZXMsIGFuZCB0aGluayBhYm91dCBob3cgd2UgY291bGQgYXBwbHkgdGhvc2UgdHJlbmRzLlx1MjAxZDwvYmxvY2txdW90ZT5cclxuVGhpcyBhdHRpdHVkZSBleHRlbmRzIHRvIHdvcmtpbmcgd2l0aCBwZW9wbGUgZnJvbSBvdGhlciBmaWVsZHMgYW5kIGNvbXBhbmllcywgaW5jbHVkaW5nIHN0YXJ0dXBzLCBhcyBWUFJPIE1lZGlhbGFiIGFpbXMgdG8gYmUgY3Jvc3MtZGlzY2lwbGluYXJ5IGFuZCBvcGVuIHdpdGggaXRzIGNvbGxhYm9yYXRpb25zLiBcdTIwMWNJdFx1MjAxOXMgcmVhbGx5IG9uIGEgY2FzZSBieSBjYXNlIGJhc2lzLiBXZSB0cnkgdG8gZmluZCB0aGUgcmlnaHQgcGVvcGxlIHdpdGggdGhlIHJpZ2h0IGV4cGVydGlzZSwgd2hlcmV2ZXIgdGhleSBtaWdodCBiZS5cdTIwMWRcclxuXHJcblx1MjAxY0EgZGVzaWduZXIgb3Igc29tZW9uZSB3aG8gYnVpbGRzIGludGVyYWN0aXZlIGluc3RhbGxhdGlvbnMgd291bGRuJ3QgbmVjZXNzYXJpbHkgdGhpbmsgb2YgY29taW5nIHRvIFZQUk8gYW5kIHN1Z2dlc3Qgd29ya2luZyB0b2dldGhlcixcdTIwMWQgVGVybWVlciBzYXlzLiBcdTIwMWNXZSB3YW50IHRvIGJlIHRoZSBlbnRyeSBwb2ludCBmb3IgdGhlc2Uga2luZHMgb2YgY29sbGFib3JhdGlvbnMsIGJlY2F1c2Ugd2UgdGhpbmsgd2UgY2FuIGxlYXJuIHNvbWV0aGluZyBmcm9tIGVhY2ggb3RoZXIuXHUyMDFkXHJcbjxoMz5TcHJlYWRpbmcgdGhlIGlubm92YXRpb24gc3Bpcml0IGluLWhvdXNlPC9oMz5cclxuRm91bmRlZCBpbiAyMDE1LCBpdCB0b29rIGEgd2hpbGUgZm9yIFZQUk8gTWVkaWFsYWIgdG8gZmluZCBpdHMgZmVldCBhbmQgZXN0YWJsaXNoIGl0cyByb2xlIHdpdGhpbiB0aGUgYnJvYWRlciBvcmdhbmlzYXRpb24uIFx1MjAxY0luaXRpYWxseSB0aGVyZSB3YXMgYW4gZXhwZWN0YXRpb24gZm9yIHRoZSBtZWRpYSBsYWIgdG8gYmUgcmVhbGx5IGlubm92YXRpdmUsIGJ1dCBhbHNvIGZvciBpdHMgcHJvamVjdHMgdG8gcmVhY2ggYSByZWFsbHkgYmlnIGF1ZGllbmNlLiBBbG9uZyB0aGUgd2F5IHdlXHUyMDE5dmUgZm91bmQgdGhhdCB0aG9zZSB0d28gZ29hbHMgZG9uJ3QgYWx3YXlzIGdvIHRvZ2V0aGVyLFx1MjAxZCBUZXJtZWVyIHNheXMuXHJcblxyXG5JbiBhZGRpdGlvbiB0byBleHBlcmltZW50aW5nIHdpdGggbmV3IHRlY2hub2xvZ2llcywgdGhlIHVuaXQgYWltcyB0byBkaXN0cmlidXRlIGl0cyBsZWFybmluZ3MgdG8gb3RoZXIgcGFydHMgb2YgVlBSTywgd2hlcmUgdGhlIGlkZWFzIGFuZCByZXN1bHRzIGNhbiBiZSBkZXZlbG9wZWQgZnVydGhlci5cclxuXHJcblRoZSBsYWIgdXNlcyBzb2NpYWwgbWVkaWEsIGludHJhbmV0IGFuZCBtb250aGx5IGludGVybmFsIHByZXNlbnRhdGlvbnMgdG8gc2hhcmUgaXRzIGluc2lnaHRzIHdpdGhpbiB0aGUgb3JnYW5pc2F0aW9uLiBJdCBhbHNvIG9yZ2FuaXNlcyByZWd1bGFyIGhhY2thdGhvbnMsIGZvY3VzaW5nIG9uIHRoZSB0b3BpY3MgdGhhdCBWUFJPXHUyMDE5cyBzdGFmZiBhcmUgaW50ZXJlc3RlZCBpbiwgYW5kIGhhcyB1c2VkIEdvb2dsZSBEZXNpZ24gU3ByaW50IGZvciBhIGZldyBwcm9qZWN0cywgVGVybWVlciBzYXlzLiBcdTIwMWNXZSBhbHNvIHRyeSB0byBiZSBvcGVuIGZvciBwZW9wbGUgdG8gd2FsayBpbiBhbmQgZGlzY3VzcyB0aGluZ3MgdGhleVx1MjAxOXJlIGN1cmlvdXMgYWJvdXQuXHUyMDFkWy92Y19jb2x1bW5fdGV4dF1bdmNfZ2FsbGVyeSBpbWFnZXM9XCIxNTIyNiwxNTIzMSwxNTIzMiwxNTIzM1wiXVt2Y19jb2x1bW5fdGV4dF08ZW0+UmVndWxhciBoYWNrYXRob25zIGFyZSBvbmUgb2YgdGhlIG1ldGhvZHMgdGhhdCB0aGUgaW5ub3ZhdGlvbiBsYWIgdXNlcyB0byBzaGFyZSBpdHMgZmluZGluZ3Mgd2l0aCB0aGUgd2lkZXIgb3JnYW5pc2F0aW9uLiAoUGhvdG9zOiBEYXZpZCBNZXVsZW5iZWxkLCBCYXJiYXJhIE1lZG8sIFNhZmFhIEJvdXphbWJvdSwgQW5uYSB2YW4gS29vaWopPC9lbT5cclxuXHJcbiZuYnNwO1xyXG5cclxuXHUyMDFjVGhlcmUgYXJlIHBlb3BsZSB3aG8gYXJlIGtlZW4gb24gaW5ub3ZhdGlvbiBhbmQgd2FudCB0byB0cnkgbmV3IHRoaW5ncy4gQnV0IHRoZXJlIGFyZSBhbHNvIHRob3NlIHdobyBlbmpveSBoZWFyaW5nIGFib3V0IG91ciBwcm9qZWN0cyBidXQgdG9vIG9mdGVuIGp1c3QgZW5kIHVwIGdvaW5nIGJhY2sgdG8gdGhlaXIgZGFpbHkgam9icyBiZWNhdXNlIG9mIGxhY2sgb2YgdGltZSBhbmQgcmVzb3VyY2VzLFx1MjAxZCBzaGUgc2F5cy5cclxuXHJcblx1MjAxY0EgYmlnIGlzc3VlIGlzIHRoYXQgb3RoZXIgZGVwYXJ0bWVudHMgbmVlZCB0byBmaW5kIGFkZGl0aW9uYWwgcmVzb3VyY2VzIGlmIHRoZXkgd2FudCB0byBkZXZlbG9wIG91ciBwcm9qZWN0cyBmdXJ0aGVyLiBNb3N0IHBlb3BsZSBhcmUgYWxyZWFkeSBidXN5IHdpdGggdGhlaXIgdXN1YWwgZHV0aWVzLCBzbyB0aGF0XHUyMDE5cyBhIGJpZyBvYnN0YWNsZS5cdTIwMWRcclxuPGgzPlRpcHMgZm9yIHN0YXJ0ZXJzPC9oMz5cclxuQXMgZm9yIGZ1dHVyZSB0cmVuZHMsIFRlcm1lZXIgc2F5cyB0aGF0IGF1Z21lbnRlZCByZWFsaXR5IGlzIGVtZXJnaW5nIGFzIGEgcGFydGljdWxhcmx5IHByb21pc2luZyBmaWVsZDogXHUyMDFjRXZlcnkgcGhvbmUgdG9kYXkgaGFzIHRoaXMgY2FwYWJpbGl0eSwgYnV0IEkgaGF2ZW4ndCByZWFsbHkgc2VlbiBhbnkgaW50ZXJlc3RpbmcgdXNlIGNhc2VzIGluIHRoZSBtZWRpYS4gQVIgaXMgb25seSBiZWluZyB1c2VkIGZvciBnYW1lcywgb3IgaW4gdGhlIGNvbW1lcmNpYWwgY29udGV4dC4gVGhhdFx1MjAxOXMgYW4gb3Bwb3J0dW5pdHkgSSBzZWUuXHUyMDFkXHJcblxyXG5Db25zZXF1ZW50bHksIHRoZSBsYWIgaXMgbm93IGRldmVsb3BpbmcgYSBzbWFydHBob25lIGludGVyYWN0aXZlIHN0b3J5IHRoYXQgdXNlcyBBUiBlbGVtZW50cywgPGVtPkR1c3RpbjwvZW0+LiBcdTIwMWNZb3UgY291bGQgc2VlIEFSIGFzIGEgbmV3IHB1YmxpYyBzcGFjZSwgYnV0IG9uZSB0aGF0IGlzIG5vdyBiZWluZyBmaWxsZWQgd2l0aCBQb2tlbW9ucyBhbmQgYWR2ZXJ0aXNpbmcuIEkgdGhpbmsgdGhlcmUncyBhbHNvIGEgcm9sZSBmb3IgcHVibGljIGJyb2FkY2FzdGVycywgd2hvIGNvdWxkIGNyZWF0ZSBtb3JlIGhpZ2gtcXVhbGl0eSwgaW5mb3JtYXRpdmUgQVIgY29udGVudC5cdTIwMWRcclxuXHJcbkZpbmFsbHksIGFzIHNvbWVvbmUgd2hvIGhhcyB3b3JrZWQgaW4gdGhlIG1lZGlhIGlubm92YXRpb24gc2NlbmUgZm9yIG1hbnkgeWVhcnMgbm93LCBkb2VzIFRlcm1lZXIgaGF2ZSBhZHZpY2UgZm9yIHNvbWVvbmUgaW50ZXJlc3RlZCBjcmVhdGluZyBhbiBpbm5vdmF0aW9uIHVuaXQ/XHJcbjxibG9ja3F1b3RlPlx1MjAxY0l0J3MgcmVhbGx5IGltcG9ydGFudCB0byBkZXRlcm1pbmUgd2hhdCB0aGUgZ29hbCBvZiB0aGUgbWVkaWEgbGFiIGlzIGZyb20gdGhlIHN0YXJ0LiBXaGF0IGVhc2lseSBoYXBwZW5zIGlzIHRoYXQgZXZlcnlvbmUgaGFzIHRoZWlyIG93biB2aXNpb24gd2hhdCB0aGUgbWVkaWEgbGFiIGlzIGZvci4gSWYgdGhhdCBoYXBwZW5zLCB5b3Ugd29uXHUyMDE5dCBiZSBhYmxlIHRvIHBsZWFzZSBldmVyeW9uZS5cdTIwMWQ8L2Jsb2NrcXVvdGU+XHJcblNoZSBhbHNvIHVuZGVybGluZXMgdGhlIG5lZWQgZm9yIHN0cnVjdHVyZXMgdGhhdCBlbnN1cmUgY3Jvc3MtcG9sbGluYXRpb24gb2YgaWRlYXMgd2l0aGluIHRoZSBvcmdhbmlzYXRpb24uIFx1MjAxY0lmIGZvciBleGFtcGxlIGl0IHdvdWxkIGJlIG1hbmRhdG9yeSB0byBzcGVuZCBvbmUgZGF5IHBlciBtb250aCB3aXRoIHVzIGluIHRoZSBtZWRpYSBsYWIsIGl0IHdvdWxkIG1ha2UgaXQgcGFydCBvZiBldmVyeWJvZHlcdTIwMTlzIGpvYiB0byBlbmdhZ2Ugd2l0aCB0aGUgbGFiLiBPdGhlcndpc2UsIHdoZW4geW91IHB1bGwgaW4gcGVvcGxlIGZyb20gb3RoZXIgYnJhbmNoZXMsIGl0XHUyMDE5cyBlYXNpbHkgc2VlbiBhcyBpZiB5b3VcdTIwMTlyZSAnc3RlYWxpbmcnIHBlb3BsZSBmcm9tIHRoZWlyIGRheSBqb2JzIHRvIGRvIHNvbWV0aGluZyBleHRyYS5cdTIwMWRcclxuXHJcbkxhc3RseSwgaXRcdTIwMTlzIHdvcnRoIGl0IHRvIHRoaW5rIGFib3V0IHNwZWNpYWxpc2luZyBvbiB0b3BpY3MsIHJhdGhlciB0aGFuIGZvY3VzaW5nIG9uIHdoYXQgZXZlcnlvbmUgZWxzZSBpcyBhbHJlYWR5IGRvaW5nLiBcdTIwMWNXZVx1MjAxOXJlIHRyeWluZyB0byBkbyB0aGlzIHdpdGggdGhlIER1dGNoIGJyb2FkY2FzdGVycy4gVGhlIGlkZWEgaXMgdG8gZGVmaW5lIGEgZm9jdXMgYXJlYSBmb3IgZWFjaCBvZiB0aGUgbGFicywgdG8gbGVhcm4gZnJvbSBlYWNoIG90aGVyLCBhbmQgdG8gbWFrZSBzdXJlIHdlXHUyMDE5cmUgbm90IGdldHRpbmcgaW4gZWFjaCBvdGhlclx1MjAxOXMgd2F5Llx1MjAxZFxyXG5cclxuJm5ic3A7XHJcblxyXG5DT05UQUNUIFBPSU5UXHJcblxyXG48aW1nIGNsYXNzPVwiYWxpZ25ub25lIHdwLWltYWdlLTE1MjI3XCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTkvMTEvdW5uYW1lZC00LTMwMHgzMDAuanBnXCIgYWx0PVwiXCIgd2lkdGg9XCIyMDBcIiBoZWlnaHQ9XCIyMDBcIiAvPlxyXG5cclxuQW5uZWxpZXMgVGVybWVlciwgQ3JlYXRpdmUgRGlyZWN0b3IsIFZQUk8gTWVkaWFsYWJcclxuVHdpdHRlcjogPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vQW5uZWxpZXNUZXJtZWVyXCI+QEFubmVsaWVzVGVybWVlcjwvYT5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzRcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW4gd2lkdGg9XCIxLzRcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS8yXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48aDM+QXV0aG9yPC9oMz5cclxuW3NpbXBsZS1hdXRob3ItYm94XVsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XSIsInBvc3RfdGl0bGUiOiJWUFJPIE1lZGlhbGFiOiBicmluZ2luZyBzdG9yeXRlbGxpbmcgdG8gbmV3IHRlY2hub2xvZ2llcyIsInBvc3RfbGluayI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi92cHJvLW1lZGlhbGFiLWJyaW5naW5nLXN0b3J5dGVsbGluZy10by1uZXctdGVjaG5vbG9naWVzLyIsInBvc3RfZmVhdHVyZWRfaW1hZ2UiOiI8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIlZQUk8gTWVkaWFsYWI6IGJyaW5naW5nIHN0b3J5dGVsbGluZyB0byBuZXcgdGVjaG5vbG9naWVzXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMTZcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxOS8xMS9WUFJPLW1haW4taW1hZ2UtMzAweDIxNi5wbmdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj4iLCJwb3N0X2NhdGVnb3JpZXMiOiJNZWRpYSBsYWJzIiwicG9zdF90YWdzIjoiIiwiJV9lZGl0X2xvY2slIjoiMTU4MTQ0MTAzMjo5MzEiLCIlX2VkaXRfbGFzdCUiOiI5MzEiLCIlc2xpZGVfdGVtcGxhdGUlIjoiZGVmYXVsdCIsIiVfd3BiX3ZjX2pzX3N0YXR1cyUiOiJ0cnVlIiwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6IkhpbHZlcnN1bSwgTmV0aGVybGFuZHMiLCIlX3dwZ21wX2xvY2F0aW9uX2NpdHklIjoiSGlsdmVyc3VtIiwiJV93cGdtcF9sb2NhdGlvbl9zdGF0ZSUiOiJOb3J0aCBIb2xsYW5kIiwiJV93cGdtcF9sb2NhdGlvbl9jb3VudHJ5JSI6Ik5ldGhlcmxhbmRzIiwiJV93cGdtcF9tZXRhYm94X2xhdGl0dWRlJSI6IjUyLjIyOTE2OTYiLCIlX3dwZ21wX21ldGFib3hfbG9uZ2l0dWRlJSI6IjUuMTY2ODk3NDAwMDAwMDM5IiwiJV93cGdtcF9tZXRhYm94X2xvY2F0aW9uX3JlZGlyZWN0JSI6Im1hcmtlciIsIiVfd3BnbXBfbWV0YWJveF9jdXN0b21fbGluayUiOiIiLCIlX3dwZ21wX21hcF9pZCUiOiJhOjE6e2k6MDtzOjE6XCIyXCI7fSIsIiVfd3BnbXBfbWV0YWJveF9tYXJrZXJfaWQlIjoiTjsiLCIlX3dwZ21wX21ldGFib3hfdGF4b21vbWllc190ZXJtcyUiOiJOOyIsIiVfd3BnbXBfZXh0ZW5zaW9uc19maWVsZHMlIjoiTjsiLCIlX2tsZW9fdHJhbnNwYXJlbnRfbWVudV9jb2xvciUiOiJ3aGl0ZSIsIiVfa2xlb190aXRsZV9jb2xvciUiOiIjIiwiJV9rbGVvX3RpdGxlX2JnJSI6IiwgcmVwZWF0LCBpbmhlcml0LCBzY3JvbGwsIGxlZnQgdG9wIiwiJV9rbGVvX3RpdGxlX2JnX2NvbG9yJSI6IiMiLCIlX3lvYXN0X3dwc2VvX2NvbnRlbnRfc2NvcmUlIjoiMzAiLCIlX3lvYXN0X3dwc2VvX3ByaW1hcnlfY2F0ZWdvcnklIjoiMTQyIiwiJV90aHVtYm5haWxfaWQlIjoiMTUyMjkiLCIlX2tsZW9fdGl0bGVfY2hlY2tib3glIjoiMSIsIiVzYmdfc2VsZWN0ZWRfc2lkZWJhciUiOiIwIiwiJXNiZ19zZWxlY3RlZF9zaWRlYmFyX3JlcGxhY2VtZW50JSI6IjAiLCJ0YXhvbm9teT1jYXRlZ29yeSI6Ik1lZGlhIGxhYnMiLCJ0YXhvbm9teT1wb3N0X3RhZyI6IiJ9LCJpY29uIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTgvMDIvbWFya2VyLTEucG5nIn0sImlkIjoxNTIxOSwiaW5mb3dpbmRvd19kaXNhYmxlIjpmYWxzZX0seyJzb3VyY2UiOiJwb3N0IiwidGl0bGUiOiJSYWQsIHRoZSBqb3VybmFsaXNtIGxhYm9yYXRvcnkgb2YgUmFkaW8gQ2FuYWRhLCBleHBlcmltZW50cyB3aXRoIGZvcm1hdHMgZm9yIHlvdW5nIHBlb3BsZSIsImluZm93aW5kb3dfY29udGVudCI6IjxkaXYgY2xhc3M9XCJmYy1pdGVtLWJveCBmYy1pdGVtLW5vLXBhZGRpbmdcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiUmFkLCB0aGUgam91cm5hbGlzbSBsYWJvcmF0b3J5IG9mIFJhZGlvIENhbmFkYSwgZXhwZXJpbWVudHMgd2l0aCBmb3JtYXRzIGZvciB5b3VuZyBwZW9wbGVcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjE2OVwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE5LzEwL3JhZC0zMDB4MTY5LmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmdcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXBhZGRpbmctY29udGVudF8yMFwiPlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLW1ldGEgZmMtaXRlbS1zZWNvbmRhcnktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZSBmYy10ZXh0LWNlbnRlclwiPk1lZGlhIGxhYnM8L2Rpdj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS10aXRsZSBmYy1pdGVtLXByaW1hcnktdGV4dC1jb2xvciBmYy10ZXh0LWNlbnRlclwiPlJhZCwgdGhlIGpvdXJuYWxpc20gbGFib3JhdG9yeSBvZiBSYWRpbyBDYW5hZGEsIGV4cGVyaW1lbnRzIHdpdGggZm9ybWF0cyBmb3IgeW91bmcgcGVvcGxlPC9kaXY+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tY29udGVudCBmYy1pdGVtLWJvZHktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZVwiPlxyXG4gICAgICAgICAgICBJbiBNYXkgMjAxNiwgUmFkaW8tQ2FuYWRhIG1hZGUgYSBzdHJvbmcgY29tbWl0bWVudCB0byBpbm5vdmF0aW9uIGJ5IGNyZWF0aW5nIFJhZCwgYSBqb3VybmFsaXNtIGxhYm9yYXRvcnkgdGhhdCBkZXZlbG9wcyBmb3JtYXRzIGZvciB5b3VuZyBwZW9wbGUgd2hvIGdldCBuZXdzIG9uIHRoZSBJbnRlcm5ldC4gU2luY2UgdGhlbiwgdGhlIGxhYiBoYXMgY29tZSBhIGxvbmcgd2F5OiB0d28gbWFqb3IgZGlnaXRhbCBhd2FyZHMsIGEgd2Vla2x5IFlvdVR1YmUgbmV3cyBicm9hZGNhc3QgYW5kIGVmZmVjdGl2ZSBjb2xsYWJvcmF0aW9ucyB3aXRoIHRoZSB2YXJpb3VzIHRlYW1zIGF0IFJhZGlvLUNhbmFkYS5cclxuICAgICAgICA8L2Rpdj5cclxuPGEgaHJlZj1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9yYWQtdGhlLWpvdXJuYWxpc20tbGFib3JhdG9yeS1vZi1yYWRpby1jYW5hZGEtZXhwZXJpbWVudHMtd2l0aC1mb3JtYXRzLWZvci15b3VuZy1wZW9wbGUvXCI+UmVhZCBtb3JlPC9hPlxyXG4gICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuPC9kaXY+XHJcblxyXG4iLCJjb250ZW50IjoiSW4gTWF5IDIwMTYsIFJhZGlvLUNhbmFkYSBtYWRlIGEgc3Ryb25nIGNvbW1pdG1lbnQgdG8gaW5ub3ZhdGlvbiBieSBjcmVhdGluZyBSYWQsIGEgam91cm5hbGlzbSBsYWJvcmF0b3J5IHRoYXQgZGV2ZWxvcHMgZm9ybWF0cyBmb3IgeW91bmcgcGVvcGxlIHdobyBnZXQgbmV3cyBvbiB0aGUgSW50ZXJuZXQuIFNpbmNlIHRoZW4sIHRoZSBsYWIgaGFzIGNvbWUgYSBsb25nIHdheTogdHdvIG1ham9yIGRpZ2l0YWwgYXdhcmRzLCBhIHdlZWtseSBZb3VUdWJlIG5ld3MgYnJvYWRjYXN0IGFuZCBlZmZlY3RpdmUgY29sbGFib3JhdGlvbnMgd2l0aCB0aGUgdmFyaW91cyB0ZWFtcyBhdCBSYWRpby1DYW5hZGEuIiwiYWRkcmVzcyI6IjE0MDAgQm91bGV2YXJkIFJlblx1MDBlOS1MXHUwMGU5dmVzcXVlIEUsIE1vbnRyXHUwMGU5YWwsIFFDIEgyTCAyTTIsIENhbmFkYSIsImxvY2F0aW9uIjp7ImxhdCI6IjQ1LjUxNzU5MDIiLCJjaXR5IjoiTW9udHJcdTAwZTlhbCIsInN0YXRlIjoiUXVcdTAwZTliZWMiLCJjb3VudHJ5IjoiQ2FuYWRhIiwibG5nIjoiLTczLjU1MTM2NDQ5OTk5OTk4Iiwib25jbGlja19hY3Rpb24iOiJtYXJrZXIiLCJyZWRpcmVjdF9wZXJtYWxpbmsiOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvcmFkLXRoZS1qb3VybmFsaXNtLWxhYm9yYXRvcnktb2YtcmFkaW8tY2FuYWRhLWV4cGVyaW1lbnRzLXdpdGgtZm9ybWF0cy1mb3IteW91bmctcGVvcGxlLyIsInpvb20iOjIsImV4dHJhX2ZpZWxkcyI6eyJwb3N0X2V4Y2VycHQiOiJJbiBNYXkgMjAxNiwgUmFkaW8tQ2FuYWRhIG1hZGUgYSBzdHJvbmcgY29tbWl0bWVudCB0byBpbm5vdmF0aW9uIGJ5IGNyZWF0aW5nIFJhZCwgYSBqb3VybmFsaXNtIGxhYm9yYXRvcnkgdGhhdCBkZXZlbG9wcyBmb3JtYXRzIGZvciB5b3VuZyBwZW9wbGUgd2hvIGdldCBuZXdzIG9uIHRoZSBJbnRlcm5ldC4gU2luY2UgdGhlbiwgdGhlIGxhYiBoYXMgY29tZSBhIGxvbmcgd2F5OiB0d28gbWFqb3IgZGlnaXRhbCBhd2FyZHMsIGEgd2Vla2x5IFlvdVR1YmUgbmV3cyBicm9hZGNhc3QgYW5kIGVmZmVjdGl2ZSBjb2xsYWJvcmF0aW9ucyB3aXRoIHRoZSB2YXJpb3VzIHRlYW1zIGF0IFJhZGlvLUNhbmFkYS4iLCJwb3N0X2NvbnRlbnQiOiJbdmNfcm93XVt2Y19jb2x1bW4gd2lkdGg9XCIxLzRcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS8yXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48aDE+UmFkLCB0aGUgam91cm5hbGlzbSBsYWJvcmF0b3J5IG9mIFJhZGlvIENhbmFkYSwgZXhwZXJpbWVudHMgd2l0aCBmb3JtYXRzIGZvciB5b3VuZyBwZW9wbGU8L2gxPlxyXG48ZW0+V2UgYXJlIHJlcHVibGlzaGluZyB0aGlzIGFydGljbGUsIG9yaWdpbmFsbHkgcHVibGlzaGVkIG9uIDxhIGhyZWY9XCJodHRwczovL3d3dy5tZXRhLW1lZGlhLmZyLzIwMTkvMDkvMjcvbGUtcmFkLWxlLWxhYm9yYXRvaXJlLWRlLWpvdXJuYWxpc21lLWRlLXJhZGlvLWNhbmFkYS1leHBlcmltZW50ZS1kZXMtZm9ybWF0cy1wb3VyLWxlcy1qZXVuZXMuaHRtbFwiPk1cdTAwZTl0YS1NZWRpYTwvYT4sIGFzIHBhcnQgb2YgYW4gZWRpdG9yaWFsIHBhcnRuZXJzaGlwIGJldHdlZW4gTVx1MDBlOXRhLU1lZGlhIGFuZCBXQU4tSUZSQS4gVGhlIGFydGljbGUgd2FzIHdyaXR0ZW4gYnkgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vbGF1cmU5MTRcIj5MYXVyZSBEZWxtb2x5PC9hPi48L2VtPlxyXG5cclxuSW4gTWF5IDIwMTYsIFJhZGlvLUNhbmFkYSBtYWRlIGEgc3Ryb25nIGNvbW1pdG1lbnQgdG8gaW5ub3ZhdGlvbiBieSBjcmVhdGluZyBSYWQsIGEgam91cm5hbGlzbSBsYWJvcmF0b3J5IHRoYXQgZGV2ZWxvcHMgZm9ybWF0cyBmb3IgeW91bmcgcGVvcGxlIHdobyBnZXQgbmV3cyBvbiB0aGUgSW50ZXJuZXQuIFRoZSBsYWIgaGFzIGFjaGlldmVkIGEgbG90IHRoZW46IHR3byBtYWpvciBkaWdpdGFsIGF3YXJkcywgYSB3ZWVrbHkgWW91VHViZSBuZXdzIGJyb2FkY2FzdCBhbmQgZWZmZWN0aXZlIGNvbGxhYm9yYXRpb25zIHdpdGggdGhlIHZhcmlvdXMgdGVhbXMgYXQgUmFkaW8tQ2FuYWRhLlxyXG48aDM+UmVqdXZlbmF0aW5nIHRoZSBhdWRpZW5jZSBhbmQgcmVuZXdpbmcgam91cm5hbGlzdGljIGZvcm1hdHM8L2gzPlxyXG5Mb2NhdGVkIG9uIHRoZSBncm91bmQgZmxvb3Igb2YgdGhlIFJhZGlvIENhbmFkYSBUb3dlciwgPGEgaHJlZj1cImh0dHBzOi8vd3d3LnJhZC5jYS9cIj5SYWQ8L2E+IG9wZXJhdGVzIGluIGEgZGVkaWNhdGVkIHNwYWNlLCBzZXBhcmF0ZSBmcm9tIHRoZSByZXN0IG9mIHRoZSBlZGl0b3JpYWwgc3RhZmYuIEl0IGJyaW5ncyB0b2dldGhlciBhIDxzdHJvbmc+bXVsdGlkaXNjaXBsaW5hcnkgdGVhbSBvZiAxNSBtZW1iZXJzPC9zdHJvbmc+OiBqb3VybmFsaXN0cywgbW90aW9uIGRlc2lnbmVycywgY2FtZXJhIG9wZXJhdG9ycywgcHJvZHVjdCBtYW5hZ2VycyBhbmQgVVggZXhwZXJ0cy4gSW5zcGlyZWQgYnkgYWdpbGUgbWV0aG9kcywgdGhlIGxhYiBoYXMgZGV2ZWxvcGVkIGEgc3BlY2lmaWMgZGlnaXRhbCBvZmZlciBhbmQgcmVuZXdlZCBpdHMgYXVkaWVuY2UuXHJcblxyXG48ZW0+XCJXZSBzdGFydGVkIGZyb20gYSBzaW1wbGUgb2JzZXJ2YXRpb246IHBhcnQgb2YgdGhlIHBvcHVsYXRpb24gbm8gbG9uZ2VyIGxpc3RlbnMgdG8gUmFkaW8gQ2FuYWRhIGJ1dCByZWFkcyBvdXIgY29udGVudCBvbmxpbmUuIEhvdyBjYW4gd2UgYWRkcmVzcyB0aGlzIGF1ZGllbmNlIGRpcmVjdGx5P1wiPC9lbT4gZXhwbGFpbnMgSm9oYW5uZSBMYXBpZXJyZSwgRWRpdG9yLWluLUNoaWVmLlxyXG5cclxuUmFkaW8gQ2FuYWRhJ3MgZWRpdG9yaWFsIGxhYiBoYXMgPHN0cm9uZz5zZXZlcmFsIG9iamVjdGl2ZXM8L3N0cm9uZz46XHJcbjx1bD5cclxuIFx0PGxpPnJlbmV3IGpvdXJuYWxpc3RpYyBmb3JtYXRzPC9saT5cclxuIFx0PGxpPmRldmVsb3AgY29udGVudCBvbiBzb2NpYWwgbmV0d29ya3M8L2xpPlxyXG4gXHQ8bGk+YWRkcmVzcyB0aGUgZGlnaXRhbCBjaXRpemVuPC9saT5cclxuIFx0PGxpPi4uLiBhbmQgYSBjaGFsbGVuZ2U6IHJlanV2ZW5hdGUgYXVkaWVuY2VzIHdoaWxlIGNvbnRpbnVpbmcgdG8gYWRkcmVzcyBpdHMgaGlzdG9yaWNhbCBhdWRpZW5jZS48L2xpPlxyXG48L3VsPlxyXG5UaGUgaW5pdGlhdGl2ZSBpcyBoZWFkZWQgYnkgdGhyZWUgd29tZW46IEpvaGFubmUgTGFwaWVycmUsIGVkaXRvci1pbi1jaGllZiwgR2lnaSBIdXluaCwgZGlnaXRhbCBzdHJhdGVnaXN0IGFuZCBDYXJvbGluZSBDaG9pbmlcdTAwZThyZSwgZGlnaXRhbCBwcm9kdWN0IG1hbmFnZXIuXHJcbjxoMz5EaWZmZXJlbnQgZm9ybWF0cyBmb3IgdGhlIHNhbWUgc3ViamVjdDwvaDM+XHJcbjxlbT5cIldlIG9wZXJhdGUgaW4gYnJvYWQgc3ViamVjdHMgZm9yIHdoaWNoIHdlIG9mZmVyIHNldmVyYWwgZm9ybWF0czogdGhlIHJlYWRlciBjYW4gY2hvb3NlIHRoZSBmb3JtYXQgaGUgbGlrZXMgdGhlIG1vc3QuIFRoZXkgY2FuIGNob29zZSB0aGVpciBlbnRyeSBwb2ludCBpbnRvIG91ciBjb250ZW50LFwiPC9lbT4gY29tbWVudHMgSm9oYW5uZSBMYXBpZXJyZS5cclxuXHJcbk1ham9yIHRvcGljcyBzdWNoIGFzIDxhIGhyZWY9XCJodHRwczovL3d3dy5yYWQuY2EvZG9zc2llci9jb250cm9sZS1kdS13ZWJcIj5jb250cm9sIG9mIHRoZSBpbnRlcm5ldDwvYT4sIDxhIGhyZWY9XCJodHRwczovL3d3dy5yYWQuY2EvZG9zc2llci9kZWNyb2lzc2FuY2VcIj5kZWdyb3d0aDwvYT4sIDxhIGhyZWY9XCJodHRwczovL3d3dy5yYWQuY2EvZG9zc2llci9yZXByb2R1Y3Rpb25cIj5yZXByb2R1Y3Rpb248L2E+LCA8YSBocmVmPVwiaHR0cHM6Ly93d3cucmFkLmNhL2Rvc3NpZXIvaW50ZWxsaWdlbmNlLWFydGlmaWNpZWxsZVwiPmFydGlmaWNpYWwgaW50ZWxsaWdlbmNlPC9hPiB0aHVzIGdlbmVyYXRlIHRocmVlIHZpZGVvIGZvcm1hdHM6IGJhc2ljLCBleHBlcmltZW50YXRpb24gYW5kIGFudGljaXBhdGlvbi5cclxuPHVsPlxyXG4gXHQ8bGk+PHN0cm9uZz5CYXNpYzwvc3Ryb25nPjogYW4gXCJleHBsYWluZXJcIiBmb3JtYXQsIGVtYm9kaWVkIGJ5IGEgam91cm5hbGlzdCB3aG8gcHJlc2VudHMgdGhlIHN1YmplY3QgdG8gdGhlIGNhbWVyYSB3aXRoIHZpZGVvIGNsaXBzIGFuZCBncmFwaHMuIEJlbG93IE1hcmllLUV2ZSBNYWhldSB0YWxrcyBhYm91dCB0aGUgZ2VvcG9saXRpY2FsIGFuZCBlY29ub21pYyBpc3N1ZXMgcmVsYXRlZCB0byB0aGUgY29udHJvbCBvZiB0aGUgaW50ZXJuZXQuPC9saT5cclxuPC91bD5cclxuaHR0cHM6Ly93d3cueW91dHViZS5jb20vd2F0Y2g/dj05NG0xeGVMbExPb1xyXG48dWw+XHJcbiBcdDxsaT48c3Ryb25nPkV4cGVyaW1lbnRhdGlvbjwvc3Ryb25nPjogdGhlIHZpZXdlciBmb2xsb3dzIHRoZSBqb3VybmFsaXN0IGluIHRoZSBwcm9jZXNzIG9mIHRha2luZyB1cCBhIGNoYWxsZW5nZSBvciBjb25kdWN0aW5nIGFuIGludmVzdGlnYXRpb24uIEEgXCJqb3VybmFsaXNtIGV4cGVyaWVuY2VcIiBmb3JtYXQgdGhhdCBpcyBwb3B1bGFyIHdpdGggdGhlIHlvdW5nZXIgZ2VuZXJhdGlvbnMuPC9saT5cclxuPC91bD5cclxuQmVsb3csIE9saXZpZXIgQXJib3VyLU1hc3NlLCBkZWNpZGVzIHRvIHRyeSB0aGUgY2hhbGxlbmdlIG9mIHplcm8gd2FzdGUgZm9yIGEgbW9udGguXHJcblxyXG5odHRwczovL3d3dy55b3V0dWJlLmNvbS93YXRjaD92PXhYVFBQcnRwajRzXHJcblxyXG5PciBNYXRoaWV1IFBhcGlsbG9uIGFuZCBOaWNvbGFzIFBoYW0gdHJhdmVsIGFyb3VuZCBNb250cmVhbCwgYSB3b3JsZC1sZWFkaW5nIEFJIGNpdHkgaW4gc2VhcmNoIG9mIHByZWNpc2VseS4uLiBhcnRpZmljaWFsIGludGVsbGlnZW5jZS5cclxuXHJcbmh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL3dhdGNoP3Y9d2RxTXd1X0JUWThcclxuPHVsPlxyXG4gXHQ8bGk+PHN0cm9uZz5BbnRpY2lwYXRpb248L3N0cm9uZz46IGEgZGVjb2RpbmcgZm9ybWF0IGNvbnNpc3Rpbmcgb2YgaW50ZXJ2aWV3cyB3aXRoIGV4cGVydHMuPC9saT5cclxuPC91bD5cclxuPGVtPlwiQXQgUmFkLCB3ZSB0cnkgbm90IHRvIHNldHRsZSBvbiBhIGZvcm1hdCwgYnV0IHRvIGV4cGVyaW1lbnQuIEV2ZW4gdGhlIGV4cGxhaW5lciBmb3JtYXQgaXMgcmV0aG91Z2h0IGV2ZXJ5IHRpbWUsXCI8L2VtPlx1MDBhMGFkZHMgSm9oYW5uZSBMYXBpZXJyZS5cclxuXHJcblRoZXNlIG5ldyB2aWRlbyBmb3JtYXRzIHdlcmUgaW5zcGlyZWQgYnkgWW91VHViZSwgYW5kIHRoZWlyIGR1cmF0aW9uIHJhbmdlcyBmcm9tIGZpdmUgdG8gZmlmdGVlbiBtaW51dGVzLlxyXG5cclxuPGVtPlwiV2UgZG9uJ3QgZ2l2ZSBvdXJzZWx2ZXMgYW55IHRpbWUgY29uc3RyYWludHMuIFdlIHRlbmQgdG8gc2F5IHRoYXQgdmlkZW8gdmlld2luZyB0aW1lIGlzIHNob3J0LCBidXQgaXQgcmVhbGx5IGRlcGVuZHMgb24gdGhlIGRpc3RyaWJ1dGlvbiBwbGF0Zm9ybXMuIE9uIFlvdVR1YmUsIHBlb3BsZSBjYW4gd2F0Y2ggam91cm5hbGlzdHMgY2hhdHRpbmcgaW4gYSBzdHVkaW8gZm9yIGFuIGhvdXIsXCI8L2VtPiBzYXlzIEpvaGFubmUgTGFwaWVycmUuXHJcblxyXG5odHRwczovL3d3dy55b3V0dWJlLmNvbS93YXRjaD92PU1PLS1ZQUJ3OURVXHJcbjxoMz5BbiBhd2FyZC13aW5uaW5nIHByb2dyYW0gd2l0aCBzdXN0YWluYWJsZSBmb3JtYXRzPC9oMz5cclxuPGEgaHJlZj1cImh0dHBzOi8vd3d3LnJhZC5jYS9lbGVjdGlvbnMyMDE4XCI+VGhlIFwiMjMtMjNcIiBwcm9ncmFtPC9hPiB3YXMgc2V0IHVwIGluIHByZXBhcmF0aW9uIGZvciB0aGUgcHJvdmluY2lhbCBlbGVjdGlvbnMgaW4gUXVlYmVjLiBJdCB3b24gdGhlIDxzdHJvbmc+PGEgaHJlZj1cImh0dHBzOi8vY29uY291cnMuaW5mb3ByZXNzZS5jb20vYm9vbWVyYW5nL3Jlc3VsdGF0c1wiPkJvb21lcmFuZyAyMDE4PC9hPiBhd2FyZCBmb3IgYmVzdCBlZGl0b3JpYWwgc3RyYXRlZ3k8L3N0cm9uZz4uIEFjY29yZGluZyB0byB0aGUgcHJlc2lkZW50IG9mIHRoZSBCb29tZXJhbmcganVyeSwgSmVubmlmZXIgVmFydmFyZXNzbywgdGhpcyBlZGl0b3JpYWwgcHJvZHVjdGlvbiA8ZW0+XCJxdWlja2x5IHdvbiBvdmVyIHRoZSBqdXJ5IHdpdGggaXRzIHJlbGV2YW5jZSwgY3JlYXRpdmUgYXBwcm9hY2ggYW5kIHF1YWxpdHkgb2YgZXhlY3V0aW9uLiBUaGlzIGZvcm1hdCBzdWNjZWVkcyBpbiByZWFjaGluZyBhIHlvdW5nIHRhcmdldCBncm91cCwgYm90aCB0aGUgd2VsbC1pbmZvcm1lZCBhbmQgYmVnaW5uZXJzLCBvZnRlbiBwdXQgb2ZmIGJ5IG1vcmUgdHJhZGl0aW9uYWwgbmV3cyBtZWRpYS4gQWxsIGRlbGl2ZXJlZCB3aXRoIGltcGVjY2FibGUgYXJ0aXN0aWMgZGlyZWN0aW9uLCBhIHBsZWFzYW50bHkgb2ZmYmVhdCB0b25lIGFuZCBhbiBleHBlcnRseSB0aG91Z2h0LW91dCBkaWdpdGFsIGltcGxlbWVudGF0aW9uLlx1MjAxZDwvZW0+XHJcblxyXG4yMy0yMyBhbHNvIHdvbiB0aGUgPHN0cm9uZz48YSBocmVmPVwiaHR0cHM6Ly93d3cubnVtaXguY2EvcGFsbWFyZXMvMjAxOS9cIj5OdW1peCAyMDE5PC9hPiBwcml6ZTwvc3Ryb25nPiBpbiB0aGUgXCJsaW5lYXIgcHJvZHVjdGlvblwiIGNhdGVnb3J5LlxyXG5cclxuPHN0cm9uZz5UaGUgc3VjY2VzcyBvZiAyMy0yMyBpcyBleHBsYWluZWQgYnkgdGhlIGFpbSB0byBiZSBhcyBjbG9zZSBhcyBwb3NzaWJsZSB0byB0aGUgcHVibGljLjwvc3Ryb25nPiBJbnNwaXJlZCBieSB0aGUgdGhpcnR5LWRheSBjaGFsbGVuZ2VzIHRoYXQgYXJlIGFsbCB2ZXJ5IHBvcHVsYXIgb25saW5lLCB0aGUgb2JqZWN0aXZlIHdhcyB0byBwcm92aWRlIHJlYWRlcnMgd2l0aCAyMyBwaWVjZXMgb2YgY29udGVudCBhdCBhIHJhdGUgb2Ygb25lIHBlciBkYXkgaW4gb3JkZXIgdG8gcHJlcGFyZSBkaWdpdGFsIGNpdGl6ZW5zIGZvciBhbiBpbmZvcm1lZCB2b3RlIGluIGVhcmx5IE9jdG9iZXIgMjAxOC4gUmFkIGZpcnN0IHN1cnZleWVkIGl0cyBjb21tdW5pdHkgd2l0aCBmb3J0eSBxdWVzdGlvbnMsIGdhdmUgdGhlbSB0aGlydGVlbiBtaW51dGVzIHRvIGFuc3dlciwgYW5kIHJlY2VpdmVkIDEyMDAgcmVzcG9uc2VzLiBJbnNwaXJlZCBieSB0aGUgZmVlZGJhY2ssIHRoZSB0ZWFtIGhhcyBkZXZlbG9wZWQgMyBpbmZvcm1hdGl2ZSwgYWNjZXNzaWJsZSBhbmQgYXR0cmFjdGl2ZSB2aWRlbyBmb3JtYXRzLlxyXG5cclxuPHN0cm9uZz4xLiBcdTIwMWNCYXNpY1wiIGZvcm1hdHMgb24gZWxlY3Rpb25zPC9zdHJvbmc+XHJcblxyXG5UYWtlIHRoZSB2aWRlbyBcIldoeSB2b3RlP1wiOiBhIGZvcm1hdCBpbiB0aGUgc3R5bGUgb2YgYW4gYXVkaXRpb24gdG8gZW5jb3VyYWdlIHlvdW5nIHBlb3BsZSB0byB2b3RlLiBUaGUgYXVkaXRpb25lZCBwZW9wbGUgbWFyY2ggcGFzdDogY29tZWRpYW5zLCB0aGVhdHJlIHBlcmZvcm1lcnMsIGhpcC1ob3AgZGFuY2VycywgVVFBTSBzdHVkZW50cyBpbiBwb2xpdGljYWwgc2NpZW5jZS4gVGhlIHZpZGVvXHUwMGEwIGFkZHJlc3NlcyB0aGUgbGFiJ3MgY29yZSB0YXJnZXQgYXVkaWVuY2UsIHRoZSAxOC0zOSB5ZWFyLW9sZHMgd2hvIG5vdyByZXByZXNlbnQgb25lIHRoaXJkIG9mIHRoZSBRdWViZWMgZWxlY3RvcmF0ZSBhbmQgd2hvc2UgYWJzdGVudGlvbiByYXRlIHJlbWFpbnMgaGlnaC5cclxuXHJcbmh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL3dhdGNoP3Y9Q3RsM3FTTVpjSEVcclxuXHJcbm9yIFwiT25jZSB1cG9uIGEgdGltZSB0aGVyZSB3ZXJlIHBvbGl0aWNhbCBwYXJ0aWVzXCIgYnkgTmljb2xhcyBQaGFtOiBhIHZpZGVvIG1hZGUgZW50aXJlbHkgd2l0aCBQbGF5bW9iaWwgdG95cywgZGVwaWN0aW5nIHRoZSBmb3VyIFF1ZWJlYyBwb2xpdGljYWwgcGFydGllcyByZXByZXNlbnRlZCBpbiB0aGUgTmF0aW9uYWwgQXNzZW1ibHkuXHJcblxyXG5odHRwczovL3d3dy55b3V0dWJlLmNvbS93YXRjaD92PVp1aE5IQ09VTklFXHJcblxyXG48c3Ryb25nPjIuIFx1MjAxY1F1ZXN0XCIgdG9waWNzIG9uIHRoZSBtYWluIHNvY2lhbCBpc3N1ZXMgaW4gUXVlYmVjPC9zdHJvbmc+XHJcbjx1bD5cclxuIFx0PGxpPjxhIGhyZWY9XCJodHRwczovL3lvdXR1LmJlL1R0SGNGZzhMU2tBXCI+SG93IHRvIHNvbHZlIHRoZSByZWN5Y2xpbmcgY3Jpc2lzIGluIFF1ZWJlYz88L2E+PC9saT5cclxuIFx0PGxpPjxhIGhyZWY9XCJodHRwczovL3lvdXR1LmJlL3Q3OFZLNmI1V0xZXCI+SW1wcm92aW5nIHRoZSBmbHVpZGl0eSBvZiB0cmFuc3BvcnQ8L2E+PC9saT5cclxuIFx0PGxpPjxhIGhyZWY9XCJodHRwczovL3lvdXR1LmJlLzdQak5NQ2dibUZVXCI+VG9vIGRpZmZpY3VsdCB0byBzZWUgYSBzaHJpbmsgaW4gUXVlYmVjPzwvYT48L2xpPlxyXG4gXHQ8bGk+PGEgaHJlZj1cImh0dHBzOi8veW91dHUuYmUvbi01NlZGY05VajRcIj5Eb2VzIHRoZSBjdXJyZW50IHNjaG9vbCBzeXN0ZW0gcHJvbW90ZSBpbmVxdWFsaXRpZXM/PC9hPjwvbGk+XHJcbjwvdWw+XHJcbjxzdHJvbmc+My4gQSB3ZWVrbHkgbmV3cyBicm9hZGNhc3Qgb24gWW91VHViZTogbGUgYnVua2VyPC9zdHJvbmc+XHJcblxyXG5MZSBidW5rZXIgaXMgYSB3ZWVrbHkgbmV3cyBicm9hZGNhc3QgcHJlc2VudGVkIGJ5IFJhZCBqb3VybmFsaXN0cyB0aGF0IGNvdmVycyBtb3N0IG9mIHRoZSBuZXdzIG9mIGVhY2ggd2Vlay5cclxuXHJcbjxlbT5cIlRoZSBmb3JtYXQgYWxsb3dzIHVzIHRvIGhpZ2hsaWdodCB0aGUgcGVyc29uYWxpdHkgb2Ygb3VyIGpvdXJuYWxpc3RzLiBZb3VuZ2VyIGdlbmVyYXRpb25zIGxvdmUgdGhpcyBhdXRoZW50aWMgZm9ybWF0LiBUaGlzIGhlbHBzIHRvIGJ1aWxkIGEgcmVsYXRpb25zaGlwIG9mIHRydXN0LiBCdXQgdGhpcyBtb3JlIGZhbWlsaWFyIHRvbmUgZG9lcyBub3QgYWxsb3cgdXMgdG8gY3Jvc3MgdGhlIGxpbmUgaW50byBvcGluaW9uLiBPdXIgam91cm5hbGlzdHMgcmVtYWluIHJpZ29yb3VzIGluIHRoZWlyIGpvdXJuYWxpc3RpYyBwcmFjdGljZXMsXCI8L2VtPiBjb21tZW50cyBKb2hhbm5lIExhcGllcnJlLlxyXG5cclxuUHJvZ3JhbSAyMy0yMyB3YXMgYWJsZSB0byByZWFjaCBpdHMgYXVkaWVuY2UgdGhyb3VnaCBzZXZlcmFsIGRpc3RyaWJ1dGlvbiB0b29sczogRmFjZWJvb2ssIFlvdVR1YmUsIEluc3RhZ3JhbSwgYSBuZXdzbGV0dGVyLCBhIGNoYXRib3QgYW5kIHRocm91Z2ggUmFkaW8gQ2FuYWRhIHNpdGVzOiA8YSBocmVmPVwiaHR0cHM6Ly9pY2kucmFkaW8tY2FuYWRhLmNhL2VsZWN0aW9ucy1xdWViZWMtMjAxOFwiPmljaXJhZGlvY2FuYWRhLmNhPC9hPiwgPGEgaHJlZj1cImh0dHBzOi8vY3VyaW8uY2EvZnIvXCI+Y3VyaW8uY2E8L2E+IGFuZCA8YSBocmVmPVwiaHR0cHM6Ly93d3cucmFkLmNhL1wiPnJhZC5jYTwvYT4uIFRoZSBwcm9ncmFtbWUgd2FzIGFsc28gYWR2ZXJ0aXNlZCBvbiByYWRpbyBhbmQgdGVsZXZpc2lvbi5cclxuXHJcbmh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL3dhdGNoP3Y9X20tSUNqam9ka2NcclxuXHJcblRoaXMgb25saW5lIGNvbW11bmljYXRpb24gc3RyYXRlZ3kgaGFzIGdlbmVyYXRlZCBhbiBvcmdhbmljIHJlYWNoIG9mIGZvdXIgbWlsbGlvbiBwZW9wbGUsIG1vcmUgdGhhbiB0d28gbWlsbGlvbiB2aWV3cywgYW4gYXZlcmFnZSBlbmdhZ2VtZW50IHJhdGUgb2YgOSUsIGFuIGF2ZXJhZ2UgbGlzdGVuaW5nIHRpbWUgb2YgNCBtaW51dGVzIGFuZCAzMCBzZWNvbmRzIG9uIFlvdVR1YmUsIGFuZCBtb3JlIHRoYW4gMTUsMDAwIHN1YnNjcmliZXJzIHRvIHRoZSBuZXdzbGV0dGVyIHNlbnQgb3V0IGV2ZXJ5IG1vcm5pbmcuIEJleW9uZCB0aGVzZSBmaWd1cmVzLCBSYWQncyBqb3VybmFsaXN0cyBhdHRlc3QgdG8gYW4gb25saW5lIGNvbW11bml0eSB0aGF0IGlzIHZlcnkgYWN0aXZlIHRocm91Z2hvdXQgdGhlIGVkaXRvcmlhbCBwcm9jZXNzLlxyXG5cclxuPGVtPlwiSW50ZXJuZXQgdXNlcnMgdGhhbmsgdXMgZm9yIHRoZSByZS1jb250ZXh0dWFsaXphdGlvbiBhbmQgYW5hbHlzaXMgaW4gdGhlaXIgWW91VHViZSBhbmQgRmFjZWJvb2sgY29tbWVudHMsXCI8L2VtPiBleHBsYWlucyBKb2hhbm5lIExhcGllcnJlLlxyXG5cclxuVGhlIGZvcm1hdCBpbnZlbnRlZCBmb3IgUHJvZ3JhbSAyMy0yMyA8YSBocmVmPVwiaHR0cHM6Ly95b3V0dS5iZS9fbS1JQ2pqb2RrYz9saXN0PVBMZFF6SFJwT3pTdTI3Z0N5Z3ZBMldJRGx0TUFlcWJNWVRcIj53YXMgcmVuZXdlZDwvYT4gZm9yIHRoZSBPY3RvYmVyIDIwMTkgZmVkZXJhbCBlbGVjdGlvbjogdHdlbHZlIG1pbnV0ZXMgZXZlcnkgU2F0dXJkYXkgc2luY2UgSnVuZSAyMDE5LiBUaGUgY29tcGxldGUgPGEgaHJlZj1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL3BsYXlsaXN0P2xpc3Q9UExkUXpIUnBPelN1MjdnQ3lndkEyV0lEbHRNQWVxYk1ZVFwiPnBsYXlsaXN0IG9mIHRoZSBicm9hZGNhc3RzPC9hPiBpcyBvbmxpbmUgb24gdGhlIGxhYidzIFlvdVR1YmUgYWNjb3VudC5cclxuPGgzPkNvbGxhYm9yYXRpb25zIHdpdGggVFYgdGVhbXMgYW5kIHJlZ2lvbmFsIG9mZmljZXM8L2gzPlxyXG5UaGUgbW9zdCBjcmVhdGl2ZSBjb2xsYWJvcmF0aW9uIGlzIHdpdGggdGhlIGhlYWQgb2YgUXVlYmVjXHUyMDE5cyBwcm92aW5jaWFsIHBvbGl0aWNhbCBvZmZpY2UsIFNcdTAwZTliYXN0aWVuIEJvdmV0LiBGb3IgdGhlIDIwMTggZWxlY3Rpb25zLCBoZSBhZ3JlZWQgdG8gcGxheSBhbG9uZyBhbmQgc3dhcCBoaXMgdGllIGFuZCBqYWNrZXQgZm9yIGEgUmFkIHQtc2hpcnQgYW5kIGV4cGxhaW4gdGhlIHNvLWNhbGxlZCBcdTIwMWNmaXJzdC1wYXN0LXRoZS1wb3N0XHUyMDFkIGVsZWN0b3JhbCBzeXN0ZW0gaW4gZnJvbnQgb2YgdGhlIGNhbWVyYS5cclxuXHJcbmh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL3dhdGNoP3Y9YWczUGRGQ0RueThcclxuXHJcblRoZSBMYWIgYWxzbyBjb2xsYWJvcmF0ZWQgd2l0aCB0aGUgcmVnaW9uYWwgb2ZmaWNlcywgaW4gcGFydGljdWxhciB0byBwcm9kdWNlIGEgZnVsbCBkb3NzaWVyIG9uIHRoZSA8YSBocmVmPVwiaHR0cHM6Ly93d3cucmFkLmNhL2Rvc3NpZXIvZnJhbmNvcGhvbmllXCI+RnJhbmNvcGhvbmllPC9hPi4gSXQgd2FzIGFuIG9wcG9ydHVuaXR5IGZvciBqb3VybmFsaXN0cyBmcm9tIHRoZSBUb3JvbnRvLCBPdHRhd2EsIE1vbmN0b24gYW5kIFdpbm5pcGVnIHJlZ2lvbnMgdG8gY29tZSB0byBNb250cmVhbCB0byByZWNlaXZlIGludGVuc2l2ZSB0cmFpbmluZyBpbiB0aGUgbmV3IFJhZCBzY3JpcHRzLCBhbmQgdGFrZSBuZXcgcHJhY3RpY2VzIHRvIHRoZSByZWdpb25zLlxyXG5cclxuRmluYWxseSwgc29tZSB0b3BpY3Mgc3VjaCBhcyByZXBvcnRzIG9uIDxhIGhyZWY9XCJodHRwczovL3d3dy5yYWQuY2EvZG9zc2llci9haWRlLW1lZGljYWxlLWEtbW91cmlyXCI+bWVkaWNhbCBhc3Npc3RhbmNlIGluIGR5aW5nPC9hPiAobGVnYWwgaW4gUXVlYmVjIHNpbmNlIGZvdXIgeWVhcnMgYWdvKSB3ZXJlIGJyb2FkY2FzdCBieSB0aGUgVFYgbmV3cyB0ZWFtcy4gVGhlIHN1Y2Nlc3Mgb2YgdGhlIFJhZCBmb3JtYXRzIGhhcyBhbHNvIGxlZCB0byB0ZWxldmlzaW9uIGJyb2FkY2FzdHMgb24gdGhlIHByb2dyYW1taW5nIHNpZGU6IHRoZSBiZXN0IGRvc3NpZXJzIHdlcmUgcHV0IHRvZ2V0aGVyIHRvIGNyZWF0ZSB0d28gc2VyaWVzIHRoYXQgd2VyZSBicm9hZGNhc3QgYXQgQ2hyaXN0bWFzIDIwMTggYW5kIGluIEp1bmUgMjAxOSBvbiB0aGUgPGEgaHJlZj1cImh0dHBzOi8vaWNpLnJhZGlvLWNhbmFkYS5jYS9yZGlcIj5SREk8L2E+IHRlbGV2aXNpb24gY2hhbm5lbC5cclxuPGgzPkFuIGFnaWxlIGJyb2FkY2FzdGVyIHdpdGhpbiBSYWRpbyBDYW5hZGE8L2gzPlxyXG5UaGUgUmFkaW8gQ2FuYWRhIExhYiBpcyBpbnNwaXJlZCBieSB0aGUgbmV3IG1ldGhvZHMgb2Ygc3ByaW50IGRlc2lnbi4gPHN0cm9uZz5UaGUgdGVhbSB3b3JrcyBpdGVyYXRpdmVseTwvc3Ryb25nPiB0byBpbXByb3ZlIGVhY2ggZWRpdG9yaWFsIHByb2R1Y3Rpb24gYmFzZWQgb24gdXNlciBmZWVkYmFjay4gRHVyaW5nIHRoZSBzdWJqZWN0IDxzdHJvbmc+cGl0Y2ggc2Vzc2lvbnM8L3N0cm9uZz4sIGRlc2lnbmVycyBhbmQgZGV2ZWxvcGVycyBhcmUgaW52aXRlZCBhbmQgY2FuIGV4cHJlc3MgdGhlbXNlbHZlcyBvbiBlZGl0b3JpYWwgaXNzdWVzLlxyXG5cclxuVG8gaW5maWx0cmF0ZSB0aGUgQ0JDIExhYiBhbmQgd2F0Y2ggdGhlIHRlYW0gd29yaywgd2F0Y2ggdGhlIGZ1bGwgbWFraW5nLW9mIHZpZGVvIG9mIHRoZSAyMy0yMyBwcm9ncmFtLlxyXG5cclxuaHR0cHM6Ly93d3cueW91dHViZS5jb20vd2F0Y2g/dj1uN2N0Z1RuQ1IzRVxyXG5cclxuTGlzdGVuaW5nIHRvIGl0cyBjb21tdW5pdHksIFJhZCB0ZXN0cywgbGVhcm5zIGFuZCBldm9sdmVzIHdpdGggaW50ZXJuZXQgdXNlcnMuIFJhZCBpcyBhIHJlbmV3ZWQgbmV3cyBleHBlcmllbmNlLCA8c3Ryb25nPmEgbWl4IG9mIG9ubGluZSBzdHlsZXMgYW5kIHRoZSBqb3VybmFsaXN0aWMgcmlnb3VyIG9mIFJhZGlvLUNhbmFkYTwvc3Ryb25nPi4gPGVtPlwiQ2FuYWRpYW5zIGFzc29jaWF0ZSBSYWRpbyBDYW5hZGEgd2l0aCBjcmVkaWJsZSBqb3VybmFsaXNtLiBSYWQgYWxsb3dzIHRoaXMgbWFycmlhZ2Ugb2YgaW5ub3ZhdGlvbiB3aXRoIGNyZWRpYmxlIGpvdXJuYWxpc20sXCI8L2VtPiBjb21tZW50cyBKb2hhbm5lIExhcGllcnJlLlxyXG5cclxuUHJlc2VudCBvbiBGYWNlYm9vaywgWW91VHViZSwgSW5zdGFncmFtIGFuZCBTbmFwY2hhdCwgUmFkIHdhcyBkZXNpZ25lZCB0byBiZWNvbWUgUmFkaW8tQ2FuYWRhJ3Mgam91cm5hbGlzdGljIGNvbnRlbnQgbGFib3JhdG9yeSwgYW5kIHRoZSByZWNpcGUgaXMgd29ya2luZy4gV2UgbG9vayBmb3J3YXJkIHRvIHRoZSBuZXh0IGVkaXRvcmlhbCBwcm9kdWN0aW9ucyBmcm9tIHRoaXMgZmFzdC1wYWNlZCB0ZWFtLlxyXG5cclxuJm5ic3A7XHJcblxyXG4oTWFpbiBpbWFnZSBmcm9tIDxhIGhyZWY9XCJodHRwczovL3d3dy5iZWhhbmNlLm5ldC9nYWxsZXJ5LzUzNjY0MzEzL1JBRC1TdHJhdGVneVwiPkJlaGFuY2U8L2E+KVsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XSIsInBvc3RfdGl0bGUiOiJSYWQsIHRoZSBqb3VybmFsaXNtIGxhYm9yYXRvcnkgb2YgUmFkaW8gQ2FuYWRhLCBleHBlcmltZW50cyB3aXRoIGZvcm1hdHMgZm9yIHlvdW5nIHBlb3BsZSIsInBvc3RfbGluayI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9yYWQtdGhlLWpvdXJuYWxpc20tbGFib3JhdG9yeS1vZi1yYWRpby1jYW5hZGEtZXhwZXJpbWVudHMtd2l0aC1mb3JtYXRzLWZvci15b3VuZy1wZW9wbGUvIiwicG9zdF9mZWF0dXJlZF9pbWFnZSI6IjxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiUmFkLCB0aGUgam91cm5hbGlzbSBsYWJvcmF0b3J5IG9mIFJhZGlvIENhbmFkYSwgZXhwZXJpbWVudHMgd2l0aCBmb3JtYXRzIGZvciB5b3VuZyBwZW9wbGVcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjE2OVwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE5LzEwL3JhZC0zMDB4MTY5LmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6Ik1lZGlhIGxhYnMiLCJwb3N0X3RhZ3MiOiIiLCIlX2VkaXRfbG9jayUiOiIxNTc0NzYyODA0OjkzMSIsIiVfZWRpdF9sYXN0JSI6IjkzMSIsIiVfb2VtYmVkXzZjMDBlYzczNDBhOWZlYzRjNTEyMmI1ZTJiMmVjYmIyJSI6IjxpZnJhbWUgd2lkdGg9XCI1NzdcIiBoZWlnaHQ9XCIzMjVcIiBzcmM9XCJodHRwczovL3d3dy55b3V0dWJlLmNvbS9lbWJlZC94WFRQUHJ0cGo0cz9mZWF0dXJlPW9lbWJlZCZhbXA7d21vZGU9b3BhcXVlJmFtcDtzaG93aW5mbz0wXCIgc3R5bGU9XCJib3JkZXI6IG5vbmVcIiBhbGxvdz1cImFjY2VsZXJvbWV0ZXI7IGF1dG9wbGF5OyBlbmNyeXB0ZWQtbWVkaWE7IGd5cm9zY29wZTsgcGljdHVyZS1pbi1waWN0dXJlXCIgYWxsb3dmdWxsc2NyZWVuPjwvaWZyYW1lPiIsIiVfb2VtYmVkX3RpbWVfNmMwMGVjNzM0MGE5ZmVjNGM1MTIyYjVlMmIyZWNiYjIlIjoiMTU3MDExNDYyMCIsIiVfb2VtYmVkX2Q3NzVlNWVjMGU3ZGJhMzU3YjlhYWRmZGNmMTM3Zjg0JSI6IjxpZnJhbWUgd2lkdGg9XCI1NzdcIiBoZWlnaHQ9XCIzMjVcIiBzcmM9XCJodHRwczovL3d3dy55b3V0dWJlLmNvbS9lbWJlZC9adWhOSENPVU5JRT9mZWF0dXJlPW9lbWJlZCZhbXA7d21vZGU9b3BhcXVlJmFtcDtzaG93aW5mbz0wXCIgc3R5bGU9XCJib3JkZXI6IG5vbmVcIiBhbGxvdz1cImFjY2VsZXJvbWV0ZXI7IGF1dG9wbGF5OyBlbmNyeXB0ZWQtbWVkaWE7IGd5cm9zY29wZTsgcGljdHVyZS1pbi1waWN0dXJlXCIgYWxsb3dmdWxsc2NyZWVuPjwvaWZyYW1lPiIsIiVfb2VtYmVkX3RpbWVfZDc3NWU1ZWMwZTdkYmEzNTdiOWFhZGZkY2YxMzdmODQlIjoiMTU3MDExNDYyMCIsIiVfb2VtYmVkX2Q3ZWY2MzJmYWYzMTM3NGVjZTAxN2FlZDk1OTExMjYxJSI6IjxpZnJhbWUgd2lkdGg9XCI1NzdcIiBoZWlnaHQ9XCIzMjVcIiBzcmM9XCJodHRwczovL3d3dy55b3V0dWJlLmNvbS9lbWJlZC93ZHFNd3VfQlRZOD9mZWF0dXJlPW9lbWJlZCZhbXA7d21vZGU9b3BhcXVlJmFtcDtzaG93aW5mbz0wXCIgc3R5bGU9XCJib3JkZXI6IG5vbmVcIiBhbGxvdz1cImFjY2VsZXJvbWV0ZXI7IGF1dG9wbGF5OyBlbmNyeXB0ZWQtbWVkaWE7IGd5cm9zY29wZTsgcGljdHVyZS1pbi1waWN0dXJlXCIgYWxsb3dmdWxsc2NyZWVuPjwvaWZyYW1lPiIsIiVfb2VtYmVkX3RpbWVfZDdlZjYzMmZhZjMxMzc0ZWNlMDE3YWVkOTU5MTEyNjElIjoiMTU3MDExNDYyMCIsIiVfb2VtYmVkX2IyYjcwZmJlOThiNjk0ODkwNTc2NjVjZDE2NWQ0YmMzJSI6IjxpZnJhbWUgd2lkdGg9XCI1NzdcIiBoZWlnaHQ9XCIzMjVcIiBzcmM9XCJodHRwczovL3d3dy55b3V0dWJlLmNvbS9lbWJlZC9fbS1JQ2pqb2RrYz9mZWF0dXJlPW9lbWJlZCZhbXA7d21vZGU9b3BhcXVlJmFtcDtzaG93aW5mbz0wXCIgc3R5bGU9XCJib3JkZXI6IG5vbmVcIiBhbGxvdz1cImFjY2VsZXJvbWV0ZXI7IGF1dG9wbGF5OyBlbmNyeXB0ZWQtbWVkaWE7IGd5cm9zY29wZTsgcGljdHVyZS1pbi1waWN0dXJlXCIgYWxsb3dmdWxsc2NyZWVuPjwvaWZyYW1lPiIsIiVfb2VtYmVkX3RpbWVfYjJiNzBmYmU5OGI2OTQ4OTA1NzY2NWNkMTY1ZDRiYzMlIjoiMTU3MDExNDYyMCIsIiVfb2VtYmVkXzA0YjFjNGY1NGUzZGUyZWFjNGEwNjlmN2ZlY2JjYWFiJSI6IjxpZnJhbWUgd2lkdGg9XCI1NzdcIiBoZWlnaHQ9XCIzMjVcIiBzcmM9XCJodHRwczovL3d3dy55b3V0dWJlLmNvbS9lbWJlZC9hZzNQZEZDRG55OD9mZWF0dXJlPW9lbWJlZCZhbXA7d21vZGU9b3BhcXVlJmFtcDtzaG93aW5mbz0wXCIgc3R5bGU9XCJib3JkZXI6IG5vbmVcIiBhbGxvdz1cImFjY2VsZXJvbWV0ZXI7IGF1dG9wbGF5OyBlbmNyeXB0ZWQtbWVkaWE7IGd5cm9zY29wZTsgcGljdHVyZS1pbi1waWN0dXJlXCIgYWxsb3dmdWxsc2NyZWVuPjwvaWZyYW1lPiIsIiVfb2VtYmVkXzgwYjRjMWZlNTIwMzk3YmVhMDFjMjY2ODRjZTI2OWEyJSI6IjxpZnJhbWUgd2lkdGg9XCI1NzdcIiBoZWlnaHQ9XCIzMjVcIiBzcmM9XCJodHRwczovL3d3dy55b3V0dWJlLmNvbS9lbWJlZC9NTy0tWUFCdzlEVT9mZWF0dXJlPW9lbWJlZCZhbXA7d21vZGU9b3BhcXVlJmFtcDtzaG93aW5mbz0wXCIgc3R5bGU9XCJib3JkZXI6IG5vbmVcIiBhbGxvdz1cImFjY2VsZXJvbWV0ZXI7IGF1dG9wbGF5OyBlbmNyeXB0ZWQtbWVkaWE7IGd5cm9zY29wZTsgcGljdHVyZS1pbi1waWN0dXJlXCIgYWxsb3dmdWxsc2NyZWVuPjwvaWZyYW1lPiIsIiVfb2VtYmVkX3RpbWVfMDRiMWM0ZjU0ZTNkZTJlYWM0YTA2OWY3ZmVjYmNhYWIlIjoiMTU3MDExNDYyMCIsIiVfb2VtYmVkX3RpbWVfODBiNGMxZmU1MjAzOTdiZWEwMWMyNjY4NGNlMjY5YTIlIjoiMTU3MDExNDYyMCIsIiVfb2VtYmVkX2JjMDBkMDgxYzA0MmI0YTQzYWE2MTFkYjQxNTIxYjA0JSI6IjxpZnJhbWUgd2lkdGg9XCI1NzdcIiBoZWlnaHQ9XCIzMjVcIiBzcmM9XCJodHRwczovL3d3dy55b3V0dWJlLmNvbS9lbWJlZC9uN2N0Z1RuQ1IzRT9mZWF0dXJlPW9lbWJlZCZhbXA7d21vZGU9b3BhcXVlJmFtcDtzaG93aW5mbz0wXCIgc3R5bGU9XCJib3JkZXI6IG5vbmVcIiBhbGxvdz1cImFjY2VsZXJvbWV0ZXI7IGF1dG9wbGF5OyBlbmNyeXB0ZWQtbWVkaWE7IGd5cm9zY29wZTsgcGljdHVyZS1pbi1waWN0dXJlXCIgYWxsb3dmdWxsc2NyZWVuPjwvaWZyYW1lPiIsIiVfb2VtYmVkX3RpbWVfYmMwMGQwODFjMDQyYjRhNDNhYTYxMWRiNDE1MjFiMDQlIjoiMTU3MDExNDYyMSIsIiVfb2VtYmVkXzdiODVmZmM2YjE3Y2Q3OThhMGRkYTdkMTJhMTRlZDM4JSI6IjxpZnJhbWUgd2lkdGg9XCI1NzdcIiBoZWlnaHQ9XCIzMjVcIiBzcmM9XCJodHRwczovL3d3dy55b3V0dWJlLmNvbS9lbWJlZC85NG0xeGVMbExPbz9mZWF0dXJlPW9lbWJlZCZhbXA7d21vZGU9b3BhcXVlJmFtcDtzaG93aW5mbz0wXCIgc3R5bGU9XCJib3JkZXI6IG5vbmVcIiBhbGxvdz1cImFjY2VsZXJvbWV0ZXI7IGF1dG9wbGF5OyBlbmNyeXB0ZWQtbWVkaWE7IGd5cm9zY29wZTsgcGljdHVyZS1pbi1waWN0dXJlXCIgYWxsb3dmdWxsc2NyZWVuPjwvaWZyYW1lPiIsIiVfb2VtYmVkX3RpbWVfN2I4NWZmYzZiMTdjZDc5OGEwZGRhN2QxMmExNGVkMzglIjoiMTU3MDExNDYyMSIsIiVfb2VtYmVkXzI1OGZkYzEwZDViZjZiZGMwNTkzMWFjNTMzMWQ0OWJhJSI6IjxpZnJhbWUgd2lkdGg9XCI1NzdcIiBoZWlnaHQ9XCIzMjVcIiBzcmM9XCJodHRwczovL3d3dy55b3V0dWJlLmNvbS9lbWJlZC9DdGwzcVNNWmNIRT9mZWF0dXJlPW9lbWJlZCZhbXA7d21vZGU9b3BhcXVlJmFtcDtzaG93aW5mbz0wXCIgc3R5bGU9XCJib3JkZXI6IG5vbmVcIiBhbGxvdz1cImFjY2VsZXJvbWV0ZXI7IGF1dG9wbGF5OyBlbmNyeXB0ZWQtbWVkaWE7IGd5cm9zY29wZTsgcGljdHVyZS1pbi1waWN0dXJlXCIgYWxsb3dmdWxsc2NyZWVuPjwvaWZyYW1lPiIsIiVfb2VtYmVkX3RpbWVfMjU4ZmRjMTBkNWJmNmJkYzA1OTMxYWM1MzMxZDQ5YmElIjoiMTU3MDExNDYyMSIsIiVzbGlkZV90ZW1wbGF0ZSUiOiJkZWZhdWx0IiwiJV93cGJfdmNfanNfc3RhdHVzJSI6InRydWUiLCIlX3dwZ21wX2xvY2F0aW9uX2FkZHJlc3MlIjoiMTQwMCBCb3VsZXZhcmQgUmVuXHUwMGU5LUxcdTAwZTl2ZXNxdWUgRSwgTW9udHJcdTAwZTlhbCwgUUMgSDJMIDJNMiwgQ2FuYWRhIiwiJV93cGdtcF9sb2NhdGlvbl9jaXR5JSI6Ik1vbnRyXHUwMGU5YWwiLCIlX3dwZ21wX2xvY2F0aW9uX3N0YXRlJSI6IlF1XHUwMGU5YmVjIiwiJV93cGdtcF9sb2NhdGlvbl9jb3VudHJ5JSI6IkNhbmFkYSIsIiVfd3BnbXBfbWV0YWJveF9sYXRpdHVkZSUiOiI0NS41MTc1OTAyIiwiJV93cGdtcF9tZXRhYm94X2xvbmdpdHVkZSUiOiItNzMuNTUxMzY0NDk5OTk5OTgiLCIlX3dwZ21wX21ldGFib3hfbG9jYXRpb25fcmVkaXJlY3QlIjoibWFya2VyIiwiJV93cGdtcF9tZXRhYm94X2N1c3RvbV9saW5rJSI6IiIsIiVfd3BnbXBfbWFwX2lkJSI6ImE6MTp7aTowO3M6MTpcIjJcIjt9IiwiJV93cGdtcF9tZXRhYm94X21hcmtlcl9pZCUiOiJOOyIsIiVfd3BnbXBfbWV0YWJveF90YXhvbW9taWVzX3Rlcm1zJSI6Ik47IiwiJV93cGdtcF9leHRlbnNpb25zX2ZpZWxkcyUiOiJOOyIsIiVfa2xlb190cmFuc3BhcmVudF9tZW51X2NvbG9yJSI6IndoaXRlIiwiJV9rbGVvX3RpdGxlX2NvbG9yJSI6IiMiLCIlX2tsZW9fdGl0bGVfYmclIjoiLCByZXBlYXQsIGluaGVyaXQsIHNjcm9sbCwgbGVmdCB0b3AiLCIlX2tsZW9fdGl0bGVfYmdfY29sb3IlIjoiIyIsIiVfeW9hc3Rfd3BzZW9fY29udGVudF9zY29yZSUiOiIzMCIsIiVfb2VtYmVkXzM0MzUwMThjNGVjM2I0Y2E1OTQ3NWRlYWYwMjAzOWUwJSI6IjxpZnJhbWUgd2lkdGg9XCIxMjAwXCIgaGVpZ2h0PVwiNjc1XCIgc3JjPVwiaHR0cHM6Ly93d3cueW91dHViZS5jb20vZW1iZWQvOTRtMXhlTGxMT28/ZmVhdHVyZT1vZW1iZWQmYW1wO3dtb2RlPW9wYXF1ZSZhbXA7c2hvd2luZm89MFwiIHN0eWxlPVwiYm9yZGVyOiBub25lXCIgYWxsb3c9XCJhY2NlbGVyb21ldGVyOyBhdXRvcGxheTsgZW5jcnlwdGVkLW1lZGlhOyBneXJvc2NvcGU7IHBpY3R1cmUtaW4tcGljdHVyZVwiIGFsbG93ZnVsbHNjcmVlbj48L2lmcmFtZT4iLCIlX29lbWJlZF90aW1lXzM0MzUwMThjNGVjM2I0Y2E1OTQ3NWRlYWYwMjAzOWUwJSI6IjE1NzAxMTQ5MjYiLCIlX29lbWJlZF8zMTdhNzcyNGRhMDBiNWIwODIyMGNjNTZhMzdjNzY2OCUiOiI8aWZyYW1lIHdpZHRoPVwiMTIwMFwiIGhlaWdodD1cIjY3NVwiIHNyYz1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkL3hYVFBQcnRwajRzP2ZlYXR1cmU9b2VtYmVkJmFtcDt3bW9kZT1vcGFxdWUmYW1wO3Nob3dpbmZvPTBcIiBzdHlsZT1cImJvcmRlcjogbm9uZVwiIGFsbG93PVwiYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGVuY3J5cHRlZC1tZWRpYTsgZ3lyb3Njb3BlOyBwaWN0dXJlLWluLXBpY3R1cmVcIiBhbGxvd2Z1bGxzY3JlZW4+PC9pZnJhbWU+IiwiJV9vZW1iZWRfdGltZV8zMTdhNzcyNGRhMDBiNWIwODIyMGNjNTZhMzdjNzY2OCUiOiIxNTcwMTE0OTI2IiwiJV9vZW1iZWRfMjRlNWQwY2YxM2YyYjM3ZjNmMGQ1NWMzMTEzYTU5NTMlIjoiPGlmcmFtZSB3aWR0aD1cIjEyMDBcIiBoZWlnaHQ9XCI2NzVcIiBzcmM9XCJodHRwczovL3d3dy55b3V0dWJlLmNvbS9lbWJlZC93ZHFNd3VfQlRZOD9mZWF0dXJlPW9lbWJlZCZhbXA7d21vZGU9b3BhcXVlJmFtcDtzaG93aW5mbz0wXCIgc3R5bGU9XCJib3JkZXI6IG5vbmVcIiBhbGxvdz1cImFjY2VsZXJvbWV0ZXI7IGF1dG9wbGF5OyBlbmNyeXB0ZWQtbWVkaWE7IGd5cm9zY29wZTsgcGljdHVyZS1pbi1waWN0dXJlXCIgYWxsb3dmdWxsc2NyZWVuPjwvaWZyYW1lPiIsIiVfb2VtYmVkX3RpbWVfMjRlNWQwY2YxM2YyYjM3ZjNmMGQ1NWMzMTEzYTU5NTMlIjoiMTU3MDExNDkyNiIsIiVfb2VtYmVkXzZhODEyM2Y4NTYwZGE5OTRkZWUzMDlkMGY2ZjNkZThhJSI6IjxpZnJhbWUgd2lkdGg9XCIxMjAwXCIgaGVpZ2h0PVwiNjc1XCIgc3JjPVwiaHR0cHM6Ly93d3cueW91dHViZS5jb20vZW1iZWQvTU8tLVlBQnc5RFU/ZmVhdHVyZT1vZW1iZWQmYW1wO3dtb2RlPW9wYXF1ZSZhbXA7c2hvd2luZm89MFwiIHN0eWxlPVwiYm9yZGVyOiBub25lXCIgYWxsb3c9XCJhY2NlbGVyb21ldGVyOyBhdXRvcGxheTsgZW5jcnlwdGVkLW1lZGlhOyBneXJvc2NvcGU7IHBpY3R1cmUtaW4tcGljdHVyZVwiIGFsbG93ZnVsbHNjcmVlbj48L2lmcmFtZT4iLCIlX29lbWJlZF90aW1lXzZhODEyM2Y4NTYwZGE5OTRkZWUzMDlkMGY2ZjNkZThhJSI6IjE1NzAxMTQ5MjYiLCIlX29lbWJlZF9kNjMyZTAzOTIzNDdkYjk3ZDBlYzMzMmYyZmRiYzAzMSUiOiI8aWZyYW1lIHdpZHRoPVwiMTIwMFwiIGhlaWdodD1cIjY3NVwiIHNyYz1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkL0N0bDNxU01aY0hFP2ZlYXR1cmU9b2VtYmVkJmFtcDt3bW9kZT1vcGFxdWUmYW1wO3Nob3dpbmZvPTBcIiBzdHlsZT1cImJvcmRlcjogbm9uZVwiIGFsbG93PVwiYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGVuY3J5cHRlZC1tZWRpYTsgZ3lyb3Njb3BlOyBwaWN0dXJlLWluLXBpY3R1cmVcIiBhbGxvd2Z1bGxzY3JlZW4+PC9pZnJhbWU+IiwiJV9vZW1iZWRfdGltZV9kNjMyZTAzOTIzNDdkYjk3ZDBlYzMzMmYyZmRiYzAzMSUiOiIxNTcwMTE0OTI2IiwiJV9vZW1iZWRfZGJkMmI2YTE5NDEwZTA2NzM1ZTczN2RkZmVjODJhZmElIjoiPGlmcmFtZSB3aWR0aD1cIjEyMDBcIiBoZWlnaHQ9XCI2NzVcIiBzcmM9XCJodHRwczovL3d3dy55b3V0dWJlLmNvbS9lbWJlZC9adWhOSENPVU5JRT9mZWF0dXJlPW9lbWJlZCZhbXA7d21vZGU9b3BhcXVlJmFtcDtzaG93aW5mbz0wXCIgc3R5bGU9XCJib3JkZXI6IG5vbmVcIiBhbGxvdz1cImFjY2VsZXJvbWV0ZXI7IGF1dG9wbGF5OyBlbmNyeXB0ZWQtbWVkaWE7IGd5cm9zY29wZTsgcGljdHVyZS1pbi1waWN0dXJlXCIgYWxsb3dmdWxsc2NyZWVuPjwvaWZyYW1lPiIsIiVfb2VtYmVkX3RpbWVfZGJkMmI2YTE5NDEwZTA2NzM1ZTczN2RkZmVjODJhZmElIjoiMTU3MDExNDkyNiIsIiVfb2VtYmVkXzFjOGQ0N2MyZTAxNDgxOGVlZTQyY2Y4MDE2MDFjZGMxJSI6IjxpZnJhbWUgd2lkdGg9XCIxMjAwXCIgaGVpZ2h0PVwiNjc1XCIgc3JjPVwiaHR0cHM6Ly93d3cueW91dHViZS5jb20vZW1iZWQvX20tSUNqam9ka2M/ZmVhdHVyZT1vZW1iZWQmYW1wO3dtb2RlPW9wYXF1ZSZhbXA7c2hvd2luZm89MFwiIHN0eWxlPVwiYm9yZGVyOiBub25lXCIgYWxsb3c9XCJhY2NlbGVyb21ldGVyOyBhdXRvcGxheTsgZW5jcnlwdGVkLW1lZGlhOyBneXJvc2NvcGU7IHBpY3R1cmUtaW4tcGljdHVyZVwiIGFsbG93ZnVsbHNjcmVlbj48L2lmcmFtZT4iLCIlX29lbWJlZF90aW1lXzFjOGQ0N2MyZTAxNDgxOGVlZTQyY2Y4MDE2MDFjZGMxJSI6IjE1NzAxMTQ5MjYiLCIlX29lbWJlZF8yY2E1ZWVlMmIzZWMyYjkxY2FkZjNjOGI5NDZkZDQ3ZCUiOiI8aWZyYW1lIHdpZHRoPVwiMTIwMFwiIGhlaWdodD1cIjY3NVwiIHNyYz1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkL2FnM1BkRkNEbnk4P2ZlYXR1cmU9b2VtYmVkJmFtcDt3bW9kZT1vcGFxdWUmYW1wO3Nob3dpbmZvPTBcIiBzdHlsZT1cImJvcmRlcjogbm9uZVwiIGFsbG93PVwiYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGVuY3J5cHRlZC1tZWRpYTsgZ3lyb3Njb3BlOyBwaWN0dXJlLWluLXBpY3R1cmVcIiBhbGxvd2Z1bGxzY3JlZW4+PC9pZnJhbWU+IiwiJV9vZW1iZWRfdGltZV8yY2E1ZWVlMmIzZWMyYjkxY2FkZjNjOGI5NDZkZDQ3ZCUiOiIxNTcwMTE0OTI2IiwiJV9vZW1iZWRfZTQ0YzkzOTNjOWM1ZjU5ZDA2MTE2OTgzYWViMDljMzYlIjoiPGlmcmFtZSB3aWR0aD1cIjEyMDBcIiBoZWlnaHQ9XCI2NzVcIiBzcmM9XCJodHRwczovL3d3dy55b3V0dWJlLmNvbS9lbWJlZC9uN2N0Z1RuQ1IzRT9mZWF0dXJlPW9lbWJlZCZhbXA7d21vZGU9b3BhcXVlJmFtcDtzaG93aW5mbz0wXCIgc3R5bGU9XCJib3JkZXI6IG5vbmVcIiBhbGxvdz1cImFjY2VsZXJvbWV0ZXI7IGF1dG9wbGF5OyBlbmNyeXB0ZWQtbWVkaWE7IGd5cm9zY29wZTsgcGljdHVyZS1pbi1waWN0dXJlXCIgYWxsb3dmdWxsc2NyZWVuPjwvaWZyYW1lPiIsIiVfb2VtYmVkX3RpbWVfZTQ0YzkzOTNjOWM1ZjU5ZDA2MTE2OTgzYWViMDljMzYlIjoiMTU3MDExNDkyNyIsIiVfeW9hc3Rfd3BzZW9fcHJpbWFyeV9jYXRlZ29yeSUiOiIxNDIiLCIlX29lbWJlZF9hY2VkYzU2MzdiYmViMDgwNmJhMjA3MGY1OTEyZjQ4ZSUiOiI8aWZyYW1lIHdpZHRoPVwiNDkzXCIgaGVpZ2h0PVwiMjc3XCIgc3JjPVwiaHR0cHM6Ly93d3cueW91dHViZS5jb20vZW1iZWQveFhUUFBydHBqNHM/ZmVhdHVyZT1vZW1iZWQmYW1wO3dtb2RlPW9wYXF1ZSZhbXA7c2hvd2luZm89MFwiIHN0eWxlPVwiYm9yZGVyOiBub25lXCIgYWxsb3c9XCJhY2NlbGVyb21ldGVyOyBhdXRvcGxheTsgZW5jcnlwdGVkLW1lZGlhOyBneXJvc2NvcGU7IHBpY3R1cmUtaW4tcGljdHVyZVwiIGFsbG93ZnVsbHNjcmVlbj48L2lmcmFtZT4iLCIlX29lbWJlZF8zOGY2NWExZGJhYTkwOThiZjY3Mzc1OWZkYTVjYzcwMCUiOiI8aWZyYW1lIHdpZHRoPVwiNDkzXCIgaGVpZ2h0PVwiMjc3XCIgc3JjPVwiaHR0cHM6Ly93d3cueW91dHViZS5jb20vZW1iZWQvX20tSUNqam9ka2M/ZmVhdHVyZT1vZW1iZWQmYW1wO3dtb2RlPW9wYXF1ZSZhbXA7c2hvd2luZm89MFwiIHN0eWxlPVwiYm9yZGVyOiBub25lXCIgYWxsb3c9XCJhY2NlbGVyb21ldGVyOyBhdXRvcGxheTsgZW5jcnlwdGVkLW1lZGlhOyBneXJvc2NvcGU7IHBpY3R1cmUtaW4tcGljdHVyZVwiIGFsbG93ZnVsbHNjcmVlbj48L2lmcmFtZT4iLCIlX29lbWJlZF90aW1lX2FjZWRjNTYzN2JiZWIwODA2YmEyMDcwZjU5MTJmNDhlJSI6IjE1NzAxMTQ5MzYiLCIlX29lbWJlZF90aW1lXzM4ZjY1YTFkYmFhOTA5OGJmNjczNzU5ZmRhNWNjNzAwJSI6IjE1NzAxMTQ5MzYiLCIlX29lbWJlZF81OTEwMDM5OWNkYWJkNDdiNjI5MDk5OTI3YTIxZmNjMiUiOiI8aWZyYW1lIHdpZHRoPVwiNDkzXCIgaGVpZ2h0PVwiMjc3XCIgc3JjPVwiaHR0cHM6Ly93d3cueW91dHViZS5jb20vZW1iZWQvTU8tLVlBQnc5RFU/ZmVhdHVyZT1vZW1iZWQmYW1wO3dtb2RlPW9wYXF1ZSZhbXA7c2hvd2luZm89MFwiIHN0eWxlPVwiYm9yZGVyOiBub25lXCIgYWxsb3c9XCJhY2NlbGVyb21ldGVyOyBhdXRvcGxheTsgZW5jcnlwdGVkLW1lZGlhOyBneXJvc2NvcGU7IHBpY3R1cmUtaW4tcGljdHVyZVwiIGFsbG93ZnVsbHNjcmVlbj48L2lmcmFtZT4iLCIlX29lbWJlZF9iOGZiM2E2YmNkMGNhZGY4MWRiOGI3OGMzZmJmZmE2YyUiOiI8aWZyYW1lIHdpZHRoPVwiNDkzXCIgaGVpZ2h0PVwiMjc3XCIgc3JjPVwiaHR0cHM6Ly93d3cueW91dHViZS5jb20vZW1iZWQvd2RxTXd1X0JUWTg/ZmVhdHVyZT1vZW1iZWQmYW1wO3dtb2RlPW9wYXF1ZSZhbXA7c2hvd2luZm89MFwiIHN0eWxlPVwiYm9yZGVyOiBub25lXCIgYWxsb3c9XCJhY2NlbGVyb21ldGVyOyBhdXRvcGxheTsgZW5jcnlwdGVkLW1lZGlhOyBneXJvc2NvcGU7IHBpY3R1cmUtaW4tcGljdHVyZVwiIGFsbG93ZnVsbHNjcmVlbj48L2lmcmFtZT4iLCIlX29lbWJlZF90aW1lXzU5MTAwMzk5Y2RhYmQ0N2I2MjkwOTk5MjdhMjFmY2MyJSI6IjE1NzAxMTQ5MzYiLCIlX29lbWJlZF90aW1lX2I4ZmIzYTZiY2QwY2FkZjgxZGI4Yjc4YzNmYmZmYTZjJSI6IjE1NzAxMTQ5MzYiLCIlX29lbWJlZF9hYjJmMzkwNjM1YTc5YmExOWE0MjJkMjc3ZWVjYzAzMSUiOiI8aWZyYW1lIHdpZHRoPVwiNDkzXCIgaGVpZ2h0PVwiMjc3XCIgc3JjPVwiaHR0cHM6Ly93d3cueW91dHViZS5jb20vZW1iZWQvOTRtMXhlTGxMT28/ZmVhdHVyZT1vZW1iZWQmYW1wO3dtb2RlPW9wYXF1ZSZhbXA7c2hvd2luZm89MFwiIHN0eWxlPVwiYm9yZGVyOiBub25lXCIgYWxsb3c9XCJhY2NlbGVyb21ldGVyOyBhdXRvcGxheTsgZW5jcnlwdGVkLW1lZGlhOyBneXJvc2NvcGU7IHBpY3R1cmUtaW4tcGljdHVyZVwiIGFsbG93ZnVsbHNjcmVlbj48L2lmcmFtZT4iLCIlX29lbWJlZF90aW1lX2FiMmYzOTA2MzVhNzliYTE5YTQyMmQyNzdlZWNjMDMxJSI6IjE1NzAxMTQ5MzYiLCIlX29lbWJlZF9mZjViNzgwNmJjMzUyOTc1MzRjZDIzNjViMjc3ZWQ5YiUiOiI8aWZyYW1lIHdpZHRoPVwiNDkzXCIgaGVpZ2h0PVwiMjc3XCIgc3JjPVwiaHR0cHM6Ly93d3cueW91dHViZS5jb20vZW1iZWQvQ3RsM3FTTVpjSEU/ZmVhdHVyZT1vZW1iZWQmYW1wO3dtb2RlPW9wYXF1ZSZhbXA7c2hvd2luZm89MFwiIHN0eWxlPVwiYm9yZGVyOiBub25lXCIgYWxsb3c9XCJhY2NlbGVyb21ldGVyOyBhdXRvcGxheTsgZW5jcnlwdGVkLW1lZGlhOyBneXJvc2NvcGU7IHBpY3R1cmUtaW4tcGljdHVyZVwiIGFsbG93ZnVsbHNjcmVlbj48L2lmcmFtZT4iLCIlX29lbWJlZF90aW1lX2ZmNWI3ODA2YmMzNTI5NzUzNGNkMjM2NWIyNzdlZDliJSI6IjE1NzAxMTQ5MzYiLCIlX29lbWJlZF8zYjkxNzcwMjVjOWE3NDliNTc4NTQ1NDQzZjgxNjExNSUiOiI8aWZyYW1lIHdpZHRoPVwiNDkzXCIgaGVpZ2h0PVwiMjc3XCIgc3JjPVwiaHR0cHM6Ly93d3cueW91dHViZS5jb20vZW1iZWQvWnVoTkhDT1VOSUU/ZmVhdHVyZT1vZW1iZWQmYW1wO3dtb2RlPW9wYXF1ZSZhbXA7c2hvd2luZm89MFwiIHN0eWxlPVwiYm9yZGVyOiBub25lXCIgYWxsb3c9XCJhY2NlbGVyb21ldGVyOyBhdXRvcGxheTsgZW5jcnlwdGVkLW1lZGlhOyBneXJvc2NvcGU7IHBpY3R1cmUtaW4tcGljdHVyZVwiIGFsbG93ZnVsbHNjcmVlbj48L2lmcmFtZT4iLCIlX29lbWJlZF90aW1lXzNiOTE3NzAyNWM5YTc0OWI1Nzg1NDU0NDNmODE2MTE1JSI6IjE1NzAxMTQ5MzYiLCIlX29lbWJlZF83MTJjOWU3N2Y5Njc4NGVlNTU4N2IzMjdlODE1YzBmMiUiOiI8aWZyYW1lIHdpZHRoPVwiNDkzXCIgaGVpZ2h0PVwiMjc3XCIgc3JjPVwiaHR0cHM6Ly93d3cueW91dHViZS5jb20vZW1iZWQvbjdjdGdUbkNSM0U/ZmVhdHVyZT1vZW1iZWQmYW1wO3dtb2RlPW9wYXF1ZSZhbXA7c2hvd2luZm89MFwiIHN0eWxlPVwiYm9yZGVyOiBub25lXCIgYWxsb3c9XCJhY2NlbGVyb21ldGVyOyBhdXRvcGxheTsgZW5jcnlwdGVkLW1lZGlhOyBneXJvc2NvcGU7IHBpY3R1cmUtaW4tcGljdHVyZVwiIGFsbG93ZnVsbHNjcmVlbj48L2lmcmFtZT4iLCIlX29lbWJlZF90aW1lXzcxMmM5ZTc3Zjk2Nzg0ZWU1NTg3YjMyN2U4MTVjMGYyJSI6IjE1NzAxMTQ5MzYiLCIlX29lbWJlZF85ZjQwYzAwNjNkN2QwOTI3ZTZhMjRmNGJiM2ZmNTA3MCUiOiI8aWZyYW1lIHdpZHRoPVwiNDkzXCIgaGVpZ2h0PVwiMjc3XCIgc3JjPVwiaHR0cHM6Ly93d3cueW91dHViZS5jb20vZW1iZWQvYWczUGRGQ0RueTg/ZmVhdHVyZT1vZW1iZWQmYW1wO3dtb2RlPW9wYXF1ZSZhbXA7c2hvd2luZm89MFwiIHN0eWxlPVwiYm9yZGVyOiBub25lXCIgYWxsb3c9XCJhY2NlbGVyb21ldGVyOyBhdXRvcGxheTsgZW5jcnlwdGVkLW1lZGlhOyBneXJvc2NvcGU7IHBpY3R1cmUtaW4tcGljdHVyZVwiIGFsbG93ZnVsbHNjcmVlbj48L2lmcmFtZT4iLCIlX29lbWJlZF90aW1lXzlmNDBjMDA2M2Q3ZDA5MjdlNmEyNGY0YmIzZmY1MDcwJSI6IjE1NzAxMTQ5MzciLCIlX3RodW1ibmFpbF9pZCUiOiIxNTIwNyIsIiVfa2xlb190aXRsZV9jaGVja2JveCUiOiIxIiwiJV9vZW1iZWRfOTIxZmNhMWNhNjY3YTVmN2M4NmUzNTQzMDc4YmNmYmMlIjoiPGlmcmFtZSB3aWR0aD1cIjQ5NFwiIGhlaWdodD1cIjI3OFwiIHNyYz1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkLzk0bTF4ZUxsTE9vP2ZlYXR1cmU9b2VtYmVkJmFtcDt3bW9kZT1vcGFxdWUmYW1wO3Nob3dpbmZvPTBcIiBzdHlsZT1cImJvcmRlcjogbm9uZVwiIGFsbG93PVwiYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGVuY3J5cHRlZC1tZWRpYTsgZ3lyb3Njb3BlOyBwaWN0dXJlLWluLXBpY3R1cmVcIiBhbGxvd2Z1bGxzY3JlZW4+PC9pZnJhbWU+IiwiJV9vZW1iZWRfdGltZV85MjFmY2ExY2E2NjdhNWY3Yzg2ZTM1NDMwNzhiY2ZiYyUiOiIxNTcwMTE4NDM4IiwiJV9vZW1iZWRfYjYyMDg0OGUyYjQwNmUwOTViNzEyOTU3YWNlNjU0NzklIjoiPGlmcmFtZSB3aWR0aD1cIjQ5NFwiIGhlaWdodD1cIjI3OFwiIHNyYz1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkL3dkcU13dV9CVFk4P2ZlYXR1cmU9b2VtYmVkJmFtcDt3bW9kZT1vcGFxdWUmYW1wO3Nob3dpbmZvPTBcIiBzdHlsZT1cImJvcmRlcjogbm9uZVwiIGFsbG93PVwiYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGVuY3J5cHRlZC1tZWRpYTsgZ3lyb3Njb3BlOyBwaWN0dXJlLWluLXBpY3R1cmVcIiBhbGxvd2Z1bGxzY3JlZW4+PC9pZnJhbWU+IiwiJV9vZW1iZWRfdGltZV9iNjIwODQ4ZTJiNDA2ZTA5NWI3MTI5NTdhY2U2NTQ3OSUiOiIxNTcwMTE4NDQxIiwiJV9vZW1iZWRfYjhiODExZTdmYWIwMGI5Y2NlNzBkY2IyNzRmNmM1NjklIjoiPGlmcmFtZSB3aWR0aD1cIjQ5NFwiIGhlaWdodD1cIjI3OFwiIHNyYz1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkL2FnM1BkRkNEbnk4P2ZlYXR1cmU9b2VtYmVkJmFtcDt3bW9kZT1vcGFxdWUmYW1wO3Nob3dpbmZvPTBcIiBzdHlsZT1cImJvcmRlcjogbm9uZVwiIGFsbG93PVwiYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGVuY3J5cHRlZC1tZWRpYTsgZ3lyb3Njb3BlOyBwaWN0dXJlLWluLXBpY3R1cmVcIiBhbGxvd2Z1bGxzY3JlZW4+PC9pZnJhbWU+IiwiJV9vZW1iZWRfMmEwNDgyYzI3YWViYTFkMThjZjg3ZTNkMjgwOThiM2ElIjoiPGlmcmFtZSB3aWR0aD1cIjQ5NFwiIGhlaWdodD1cIjI3OFwiIHNyYz1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkL19tLUlDampvZGtjP2ZlYXR1cmU9b2VtYmVkJmFtcDt3bW9kZT1vcGFxdWUmYW1wO3Nob3dpbmZvPTBcIiBzdHlsZT1cImJvcmRlcjogbm9uZVwiIGFsbG93PVwiYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGVuY3J5cHRlZC1tZWRpYTsgZ3lyb3Njb3BlOyBwaWN0dXJlLWluLXBpY3R1cmVcIiBhbGxvd2Z1bGxzY3JlZW4+PC9pZnJhbWU+IiwiJV9vZW1iZWRfMTA3NmVlNTJlNGQ1YjgyM2EzOTYyZGE1OTRhZDk4M2ElIjoiPGlmcmFtZSB3aWR0aD1cIjQ5NFwiIGhlaWdodD1cIjI3OFwiIHNyYz1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkL243Y3RnVG5DUjNFP2ZlYXR1cmU9b2VtYmVkJmFtcDt3bW9kZT1vcGFxdWUmYW1wO3Nob3dpbmZvPTBcIiBzdHlsZT1cImJvcmRlcjogbm9uZVwiIGFsbG93PVwiYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGVuY3J5cHRlZC1tZWRpYTsgZ3lyb3Njb3BlOyBwaWN0dXJlLWluLXBpY3R1cmVcIiBhbGxvd2Z1bGxzY3JlZW4+PC9pZnJhbWU+IiwiJV9vZW1iZWRfdGltZV9iOGI4MTFlN2ZhYjAwYjljY2U3MGRjYjI3NGY2YzU2OSUiOiIxNTcwMTE4NDQxIiwiJV9vZW1iZWRfNjlhZjMwMmQyMWU3NGUzZWNlODZiMTFiNjQzODJmMDQlIjoiPGlmcmFtZSB3aWR0aD1cIjQ5NFwiIGhlaWdodD1cIjI3OFwiIHNyYz1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkL0N0bDNxU01aY0hFP2ZlYXR1cmU9b2VtYmVkJmFtcDt3bW9kZT1vcGFxdWUmYW1wO3Nob3dpbmZvPTBcIiBzdHlsZT1cImJvcmRlcjogbm9uZVwiIGFsbG93PVwiYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGVuY3J5cHRlZC1tZWRpYTsgZ3lyb3Njb3BlOyBwaWN0dXJlLWluLXBpY3R1cmVcIiBhbGxvd2Z1bGxzY3JlZW4+PC9pZnJhbWU+IiwiJV9vZW1iZWRfdGltZV8yYTA0ODJjMjdhZWJhMWQxOGNmODdlM2QyODA5OGIzYSUiOiIxNTcwMTE4NDQxIiwiJV9vZW1iZWRfMjZlNjY4ZjEwMTU2MTMxMGZkMmI1NDBhYWNhNjI3ZjclIjoiPGlmcmFtZSB3aWR0aD1cIjQ5NFwiIGhlaWdodD1cIjI3OFwiIHNyYz1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkL1p1aE5IQ09VTklFP2ZlYXR1cmU9b2VtYmVkJmFtcDt3bW9kZT1vcGFxdWUmYW1wO3Nob3dpbmZvPTBcIiBzdHlsZT1cImJvcmRlcjogbm9uZVwiIGFsbG93PVwiYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGVuY3J5cHRlZC1tZWRpYTsgZ3lyb3Njb3BlOyBwaWN0dXJlLWluLXBpY3R1cmVcIiBhbGxvd2Z1bGxzY3JlZW4+PC9pZnJhbWU+IiwiJV9vZW1iZWRfdGltZV8xMDc2ZWU1MmU0ZDViODIzYTM5NjJkYTU5NGFkOTgzYSUiOiIxNTcwMTE4NDQxIiwiJV9vZW1iZWRfdGltZV82OWFmMzAyZDIxZTc0ZTNlY2U4NmIxMWI2NDM4MmYwNCUiOiIxNTcwMTE4NDQxIiwiJV9vZW1iZWRfdGltZV8yNmU2NjhmMTAxNTYxMzEwZmQyYjU0MGFhY2E2MjdmNyUiOiIxNTcwMTE4NDQxIiwiJV9vZW1iZWRfODRjMmMwMDYyZWNjZDExNzNmZjZjYjgzMzE5MDE1YTglIjoiPGlmcmFtZSB3aWR0aD1cIjQ5NFwiIGhlaWdodD1cIjI3OFwiIHNyYz1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkL3hYVFBQcnRwajRzP2ZlYXR1cmU9b2VtYmVkJmFtcDt3bW9kZT1vcGFxdWUmYW1wO3Nob3dpbmZvPTBcIiBzdHlsZT1cImJvcmRlcjogbm9uZVwiIGFsbG93PVwiYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGVuY3J5cHRlZC1tZWRpYTsgZ3lyb3Njb3BlOyBwaWN0dXJlLWluLXBpY3R1cmVcIiBhbGxvd2Z1bGxzY3JlZW4+PC9pZnJhbWU+IiwiJV9vZW1iZWRfYTgxOTgxMzM3OWYzNDE1MGQ1MWFiMDQxYzBjMTc0MDQlIjoiPGlmcmFtZSB3aWR0aD1cIjQ5NFwiIGhlaWdodD1cIjI3OFwiIHNyYz1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkL01PLS1ZQUJ3OURVP2ZlYXR1cmU9b2VtYmVkJmFtcDt3bW9kZT1vcGFxdWUmYW1wO3Nob3dpbmZvPTBcIiBzdHlsZT1cImJvcmRlcjogbm9uZVwiIGFsbG93PVwiYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGVuY3J5cHRlZC1tZWRpYTsgZ3lyb3Njb3BlOyBwaWN0dXJlLWluLXBpY3R1cmVcIiBhbGxvd2Z1bGxzY3JlZW4+PC9pZnJhbWU+IiwiJV9vZW1iZWRfdGltZV84NGMyYzAwNjJlY2NkMTE3M2ZmNmNiODMzMTkwMTVhOCUiOiIxNTcwMTE4NDQyIiwiJV9vZW1iZWRfdGltZV9hODE5ODEzMzc5ZjM0MTUwZDUxYWIwNDFjMGMxNzQwNCUiOiIxNTcwMTE4NDQyIiwiJV9vZW1iZWRfNmYzMTYxOTE5ZmVjMDdjMTA3OWU3NmIzMTgyYWEyY2ElIjoiPGlmcmFtZSB3aWR0aD1cIjQ5MlwiIGhlaWdodD1cIjI3N1wiIHNyYz1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkL3hYVFBQcnRwajRzP2ZlYXR1cmU9b2VtYmVkJmFtcDt3bW9kZT1vcGFxdWUmYW1wO3Nob3dpbmZvPTBcIiBzdHlsZT1cImJvcmRlcjogbm9uZVwiIGFsbG93PVwiYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGVuY3J5cHRlZC1tZWRpYTsgZ3lyb3Njb3BlOyBwaWN0dXJlLWluLXBpY3R1cmVcIiBhbGxvd2Z1bGxzY3JlZW4+PC9pZnJhbWU+IiwiJV9vZW1iZWRfdGltZV82ZjMxNjE5MTlmZWMwN2MxMDc5ZTc2YjMxODJhYTJjYSUiOiIxNTcwMTE5MTM5IiwiJV9vZW1iZWRfN2Q3NWFlZDliODgwYjNiZWU0OWJkM2Y3YTEzM2RjNzUlIjoiPGlmcmFtZSB3aWR0aD1cIjQ5MlwiIGhlaWdodD1cIjI3N1wiIHNyYz1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkLzk0bTF4ZUxsTE9vP2ZlYXR1cmU9b2VtYmVkJmFtcDt3bW9kZT1vcGFxdWUmYW1wO3Nob3dpbmZvPTBcIiBzdHlsZT1cImJvcmRlcjogbm9uZVwiIGFsbG93PVwiYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGVuY3J5cHRlZC1tZWRpYTsgZ3lyb3Njb3BlOyBwaWN0dXJlLWluLXBpY3R1cmVcIiBhbGxvd2Z1bGxzY3JlZW4+PC9pZnJhbWU+IiwiJV9vZW1iZWRfdGltZV83ZDc1YWVkOWI4ODBiM2JlZTQ5YmQzZjdhMTMzZGM3NSUiOiIxNTcwMTE5MTM5IiwiJV9vZW1iZWRfODRiMjBjZjVhOTRmMjczYTEyZjBlY2YwYjllNGEzOGIlIjoiPGlmcmFtZSB3aWR0aD1cIjQ5MlwiIGhlaWdodD1cIjI3N1wiIHNyYz1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkL3dkcU13dV9CVFk4P2ZlYXR1cmU9b2VtYmVkJmFtcDt3bW9kZT1vcGFxdWUmYW1wO3Nob3dpbmZvPTBcIiBzdHlsZT1cImJvcmRlcjogbm9uZVwiIGFsbG93PVwiYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGVuY3J5cHRlZC1tZWRpYTsgZ3lyb3Njb3BlOyBwaWN0dXJlLWluLXBpY3R1cmVcIiBhbGxvd2Z1bGxzY3JlZW4+PC9pZnJhbWU+IiwiJV9vZW1iZWRfZGE4NDU5ODgwNGM3ZmM4ZTM2MjhjMGVjMWY5MjM5MDAlIjoiPGlmcmFtZSB3aWR0aD1cIjQ5MlwiIGhlaWdodD1cIjI3N1wiIHNyYz1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkL01PLS1ZQUJ3OURVP2ZlYXR1cmU9b2VtYmVkJmFtcDt3bW9kZT1vcGFxdWUmYW1wO3Nob3dpbmZvPTBcIiBzdHlsZT1cImJvcmRlcjogbm9uZVwiIGFsbG93PVwiYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGVuY3J5cHRlZC1tZWRpYTsgZ3lyb3Njb3BlOyBwaWN0dXJlLWluLXBpY3R1cmVcIiBhbGxvd2Z1bGxzY3JlZW4+PC9pZnJhbWU+IiwiJV9vZW1iZWRfdGltZV9kYTg0NTk4ODA0YzdmYzhlMzYyOGMwZWMxZjkyMzkwMCUiOiIxNTcwMTE5MTM5IiwiJV9vZW1iZWRfdGltZV84NGIyMGNmNWE5NGYyNzNhMTJmMGVjZjBiOWU0YTM4YiUiOiIxNTcwMTE5MTM5IiwiJV9vZW1iZWRfNWJkNjk4Nzc0M2VmNGYzYmVhZTYxODJkZThmNjI3OTIlIjoiPGlmcmFtZSB3aWR0aD1cIjQ5MlwiIGhlaWdodD1cIjI3N1wiIHNyYz1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkL2FnM1BkRkNEbnk4P2ZlYXR1cmU9b2VtYmVkJmFtcDt3bW9kZT1vcGFxdWUmYW1wO3Nob3dpbmZvPTBcIiBzdHlsZT1cImJvcmRlcjogbm9uZVwiIGFsbG93PVwiYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGVuY3J5cHRlZC1tZWRpYTsgZ3lyb3Njb3BlOyBwaWN0dXJlLWluLXBpY3R1cmVcIiBhbGxvd2Z1bGxzY3JlZW4+PC9pZnJhbWU+IiwiJV9vZW1iZWRfdGltZV81YmQ2OTg3NzQzZWY0ZjNiZWFlNjE4MmRlOGY2Mjc5MiUiOiIxNTcwMTE5MTM5IiwiJV9vZW1iZWRfOWE2ZDAzYTk2YzliZGVhZmRlN2RjMmJjZWE4MjViNDElIjoiPGlmcmFtZSB3aWR0aD1cIjQ5MlwiIGhlaWdodD1cIjI3N1wiIHNyYz1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkL243Y3RnVG5DUjNFP2ZlYXR1cmU9b2VtYmVkJmFtcDt3bW9kZT1vcGFxdWUmYW1wO3Nob3dpbmZvPTBcIiBzdHlsZT1cImJvcmRlcjogbm9uZVwiIGFsbG93PVwiYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGVuY3J5cHRlZC1tZWRpYTsgZ3lyb3Njb3BlOyBwaWN0dXJlLWluLXBpY3R1cmVcIiBhbGxvd2Z1bGxzY3JlZW4+PC9pZnJhbWU+IiwiJV9vZW1iZWRfdGltZV85YTZkMDNhOTZjOWJkZWFmZGU3ZGMyYmNlYTgyNWI0MSUiOiIxNTcwMTE5MTM5IiwiJV9vZW1iZWRfMzc5ODQ3NjhkODk5NzUwNmU3NjcyZDdmOWZkYzAyYjYlIjoiPGlmcmFtZSB3aWR0aD1cIjQ5MlwiIGhlaWdodD1cIjI3N1wiIHNyYz1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkL1p1aE5IQ09VTklFP2ZlYXR1cmU9b2VtYmVkJmFtcDt3bW9kZT1vcGFxdWUmYW1wO3Nob3dpbmZvPTBcIiBzdHlsZT1cImJvcmRlcjogbm9uZVwiIGFsbG93PVwiYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGVuY3J5cHRlZC1tZWRpYTsgZ3lyb3Njb3BlOyBwaWN0dXJlLWluLXBpY3R1cmVcIiBhbGxvd2Z1bGxzY3JlZW4+PC9pZnJhbWU+IiwiJV9vZW1iZWRfM2Y1NWNlYzBhYzliOTNjZWE0ZmY2ODhjZWJiN2MzOTAlIjoiPGlmcmFtZSB3aWR0aD1cIjQ5MlwiIGhlaWdodD1cIjI3N1wiIHNyYz1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkL19tLUlDampvZGtjP2ZlYXR1cmU9b2VtYmVkJmFtcDt3bW9kZT1vcGFxdWUmYW1wO3Nob3dpbmZvPTBcIiBzdHlsZT1cImJvcmRlcjogbm9uZVwiIGFsbG93PVwiYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGVuY3J5cHRlZC1tZWRpYTsgZ3lyb3Njb3BlOyBwaWN0dXJlLWluLXBpY3R1cmVcIiBhbGxvd2Z1bGxzY3JlZW4+PC9pZnJhbWU+IiwiJV9vZW1iZWRfdGltZV8zNzk4NDc2OGQ4OTk3NTA2ZTc2NzJkN2Y5ZmRjMDJiNiUiOiIxNTcwMTE5MTM5IiwiJV9vZW1iZWRfdGltZV8zZjU1Y2VjMGFjOWI5M2NlYTRmZjY4OGNlYmI3YzM5MCUiOiIxNTcwMTE5MTM5IiwiJV9vZW1iZWRfMDVkNjM0ZGE4YzY0MWVhYzgzYWNjY2Y1ZGMxZjZlYzUlIjoiPGlmcmFtZSB3aWR0aD1cIjQ5MlwiIGhlaWdodD1cIjI3N1wiIHNyYz1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkL0N0bDNxU01aY0hFP2ZlYXR1cmU9b2VtYmVkJmFtcDt3bW9kZT1vcGFxdWUmYW1wO3Nob3dpbmZvPTBcIiBzdHlsZT1cImJvcmRlcjogbm9uZVwiIGFsbG93PVwiYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGVuY3J5cHRlZC1tZWRpYTsgZ3lyb3Njb3BlOyBwaWN0dXJlLWluLXBpY3R1cmVcIiBhbGxvd2Z1bGxzY3JlZW4+PC9pZnJhbWU+IiwiJV9vZW1iZWRfdGltZV8wNWQ2MzRkYThjNjQxZWFjODNhY2NjZjVkYzFmNmVjNSUiOiIxNTcwMTE5MTM5IiwiJXNiZ19zZWxlY3RlZF9zaWRlYmFyJSI6IjAiLCIlc2JnX3NlbGVjdGVkX3NpZGViYXJfcmVwbGFjZW1lbnQlIjoiMCIsIiVfb2VtYmVkXzc0ZDM5NzZiNGQ3NTI2NGUzOGIwYzBhYzI3NDk5ZmEwJSI6IjxpZnJhbWUgd2lkdGg9XCI0OTFcIiBoZWlnaHQ9XCIyNzZcIiBzcmM9XCJodHRwczovL3d3dy55b3V0dWJlLmNvbS9lbWJlZC9DdGwzcVNNWmNIRT9mZWF0dXJlPW9lbWJlZCZhbXA7d21vZGU9b3BhcXVlJmFtcDtzaG93aW5mbz0wXCIgc3R5bGU9XCJib3JkZXI6IG5vbmVcIiBhbGxvdz1cImFjY2VsZXJvbWV0ZXI7IGF1dG9wbGF5OyBlbmNyeXB0ZWQtbWVkaWE7IGd5cm9zY29wZTsgcGljdHVyZS1pbi1waWN0dXJlXCIgYWxsb3dmdWxsc2NyZWVuPjwvaWZyYW1lPiIsIiVfb2VtYmVkX3RpbWVfNzRkMzk3NmI0ZDc1MjY0ZTM4YjBjMGFjMjc0OTlmYTAlIjoiMTU3MDEyMDI4NiIsIiVfb2VtYmVkX2IwZmExOTYzMjY1M2Y2OWI0NjQ5ZjcyYWE5Y2VkMzljJSI6IjxpZnJhbWUgd2lkdGg9XCI0OTFcIiBoZWlnaHQ9XCIyNzZcIiBzcmM9XCJodHRwczovL3d3dy55b3V0dWJlLmNvbS9lbWJlZC9NTy0tWUFCdzlEVT9mZWF0dXJlPW9lbWJlZCZhbXA7d21vZGU9b3BhcXVlJmFtcDtzaG93aW5mbz0wXCIgc3R5bGU9XCJib3JkZXI6IG5vbmVcIiBhbGxvdz1cImFjY2VsZXJvbWV0ZXI7IGF1dG9wbGF5OyBlbmNyeXB0ZWQtbWVkaWE7IGd5cm9zY29wZTsgcGljdHVyZS1pbi1waWN0dXJlXCIgYWxsb3dmdWxsc2NyZWVuPjwvaWZyYW1lPiIsIiVfb2VtYmVkXzQzY2M1MWIyZmI3ZGQ1MzlmMjg1YTViYTlhZjQ1OGIzJSI6IjxpZnJhbWUgd2lkdGg9XCI0OTFcIiBoZWlnaHQ9XCIyNzZcIiBzcmM9XCJodHRwczovL3d3dy55b3V0dWJlLmNvbS9lbWJlZC9uN2N0Z1RuQ1IzRT9mZWF0dXJlPW9lbWJlZCZhbXA7d21vZGU9b3BhcXVlJmFtcDtzaG93aW5mbz0wXCIgc3R5bGU9XCJib3JkZXI6IG5vbmVcIiBhbGxvdz1cImFjY2VsZXJvbWV0ZXI7IGF1dG9wbGF5OyBlbmNyeXB0ZWQtbWVkaWE7IGd5cm9zY29wZTsgcGljdHVyZS1pbi1waWN0dXJlXCIgYWxsb3dmdWxsc2NyZWVuPjwvaWZyYW1lPiIsIiVfb2VtYmVkXzBjNGRmZDQzNjQ5ZjQ3OWIxYzcxNTJiM2YyNjY5YWZlJSI6IjxpZnJhbWUgd2lkdGg9XCI0OTFcIiBoZWlnaHQ9XCIyNzZcIiBzcmM9XCJodHRwczovL3d3dy55b3V0dWJlLmNvbS9lbWJlZC85NG0xeGVMbExPbz9mZWF0dXJlPW9lbWJlZCZhbXA7d21vZGU9b3BhcXVlJmFtcDtzaG93aW5mbz0wXCIgc3R5bGU9XCJib3JkZXI6IG5vbmVcIiBhbGxvdz1cImFjY2VsZXJvbWV0ZXI7IGF1dG9wbGF5OyBlbmNyeXB0ZWQtbWVkaWE7IGd5cm9zY29wZTsgcGljdHVyZS1pbi1waWN0dXJlXCIgYWxsb3dmdWxsc2NyZWVuPjwvaWZyYW1lPiIsIiVfb2VtYmVkX3RpbWVfYjBmYTE5NjMyNjUzZjY5YjQ2NDlmNzJhYTljZWQzOWMlIjoiMTU3MDEyMDI4NiIsIiVfb2VtYmVkX3RpbWVfNDNjYzUxYjJmYjdkZDUzOWYyODVhNWJhOWFmNDU4YjMlIjoiMTU3MDEyMDI4NiIsIiVfb2VtYmVkX3RpbWVfMGM0ZGZkNDM2NDlmNDc5YjFjNzE1MmIzZjI2NjlhZmUlIjoiMTU3MDEyMDI4NiIsIiVfb2VtYmVkXzdiODJhZjdkYzg0ZGEwZTlhMWIxMGYyODAxYjc3MzkwJSI6IjxpZnJhbWUgd2lkdGg9XCI0OTFcIiBoZWlnaHQ9XCIyNzZcIiBzcmM9XCJodHRwczovL3d3dy55b3V0dWJlLmNvbS9lbWJlZC9fbS1JQ2pqb2RrYz9mZWF0dXJlPW9lbWJlZCZhbXA7d21vZGU9b3BhcXVlJmFtcDtzaG93aW5mbz0wXCIgc3R5bGU9XCJib3JkZXI6IG5vbmVcIiBhbGxvdz1cImFjY2VsZXJvbWV0ZXI7IGF1dG9wbGF5OyBlbmNyeXB0ZWQtbWVkaWE7IGd5cm9zY29wZTsgcGljdHVyZS1pbi1waWN0dXJlXCIgYWxsb3dmdWxsc2NyZWVuPjwvaWZyYW1lPiIsIiVfb2VtYmVkX2MxNDgyODQ5MTdhMDllNDQ0MjlmZDViOGQ4YzcwODE4JSI6IjxpZnJhbWUgd2lkdGg9XCI0OTFcIiBoZWlnaHQ9XCIyNzZcIiBzcmM9XCJodHRwczovL3d3dy55b3V0dWJlLmNvbS9lbWJlZC9adWhOSENPVU5JRT9mZWF0dXJlPW9lbWJlZCZhbXA7d21vZGU9b3BhcXVlJmFtcDtzaG93aW5mbz0wXCIgc3R5bGU9XCJib3JkZXI6IG5vbmVcIiBhbGxvdz1cImFjY2VsZXJvbWV0ZXI7IGF1dG9wbGF5OyBlbmNyeXB0ZWQtbWVkaWE7IGd5cm9zY29wZTsgcGljdHVyZS1pbi1waWN0dXJlXCIgYWxsb3dmdWxsc2NyZWVuPjwvaWZyYW1lPiIsIiVfb2VtYmVkX3RpbWVfN2I4MmFmN2RjODRkYTBlOWExYjEwZjI4MDFiNzczOTAlIjoiMTU3MDEyMDI4NiIsIiVfb2VtYmVkX3RpbWVfYzE0ODI4NDkxN2EwOWU0NDQyOWZkNWI4ZDhjNzA4MTglIjoiMTU3MDEyMDI4NiIsIiVfb2VtYmVkXzUxMzI5NjQ2YjYyMGY2MGVhMmI4NTdmNGM3ZjQyYTg4JSI6IjxpZnJhbWUgd2lkdGg9XCI0OTFcIiBoZWlnaHQ9XCIyNzZcIiBzcmM9XCJodHRwczovL3d3dy55b3V0dWJlLmNvbS9lbWJlZC94WFRQUHJ0cGo0cz9mZWF0dXJlPW9lbWJlZCZhbXA7d21vZGU9b3BhcXVlJmFtcDtzaG93aW5mbz0wXCIgc3R5bGU9XCJib3JkZXI6IG5vbmVcIiBhbGxvdz1cImFjY2VsZXJvbWV0ZXI7IGF1dG9wbGF5OyBlbmNyeXB0ZWQtbWVkaWE7IGd5cm9zY29wZTsgcGljdHVyZS1pbi1waWN0dXJlXCIgYWxsb3dmdWxsc2NyZWVuPjwvaWZyYW1lPiIsIiVfb2VtYmVkX3RpbWVfNTEzMjk2NDZiNjIwZjYwZWEyYjg1N2Y0YzdmNDJhODglIjoiMTU3MDEyMDI4NiIsIiVfb2VtYmVkXzA1Zjg5N2IzMTEzYjA2NzQyNjgyMmEwY2ZlOWQ5YzU3JSI6IjxpZnJhbWUgd2lkdGg9XCI0OTFcIiBoZWlnaHQ9XCIyNzZcIiBzcmM9XCJodHRwczovL3d3dy55b3V0dWJlLmNvbS9lbWJlZC93ZHFNd3VfQlRZOD9mZWF0dXJlPW9lbWJlZCZhbXA7d21vZGU9b3BhcXVlJmFtcDtzaG93aW5mbz0wXCIgc3R5bGU9XCJib3JkZXI6IG5vbmVcIiBhbGxvdz1cImFjY2VsZXJvbWV0ZXI7IGF1dG9wbGF5OyBlbmNyeXB0ZWQtbWVkaWE7IGd5cm9zY29wZTsgcGljdHVyZS1pbi1waWN0dXJlXCIgYWxsb3dmdWxsc2NyZWVuPjwvaWZyYW1lPiIsIiVfb2VtYmVkX3RpbWVfMDVmODk3YjMxMTNiMDY3NDI2ODIyYTBjZmU5ZDljNTclIjoiMTU3MDEyMDI4NyIsIiVfb2VtYmVkXzFjODlmNTQ4NTZiZTBmMzk3NWY3ZWQ3ZGVmMzZmYWQ1JSI6IjxpZnJhbWUgd2lkdGg9XCI0OTFcIiBoZWlnaHQ9XCIyNzZcIiBzcmM9XCJodHRwczovL3d3dy55b3V0dWJlLmNvbS9lbWJlZC9hZzNQZEZDRG55OD9mZWF0dXJlPW9lbWJlZCZhbXA7d21vZGU9b3BhcXVlJmFtcDtzaG93aW5mbz0wXCIgc3R5bGU9XCJib3JkZXI6IG5vbmVcIiBhbGxvdz1cImFjY2VsZXJvbWV0ZXI7IGF1dG9wbGF5OyBlbmNyeXB0ZWQtbWVkaWE7IGd5cm9zY29wZTsgcGljdHVyZS1pbi1waWN0dXJlXCIgYWxsb3dmdWxsc2NyZWVuPjwvaWZyYW1lPiIsIiVfb2VtYmVkX3RpbWVfMWM4OWY1NDg1NmJlMGYzOTc1ZjdlZDdkZWYzNmZhZDUlIjoiMTU3MDEyMDI4NyIsIiVfb2VtYmVkX2UzMzVkOThiNmZiMjU2MzY3MDM4ZTE0MTUwZGJhZGFlJSI6IjxpZnJhbWUgdGl0bGU9XCJRdWkgdGVudGUgZGUgY29udHJcdTAwZjRsZXIgSW50ZXJuZXQ/IHwgQ29udHJcdTAwZjRsZSBkdSB3ZWIgfCBSYWRcIiB3aWR0aD1cIjUwMFwiIGhlaWdodD1cIjI4MVwiIHNyYz1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkLzk0bTF4ZUxsTE9vP2ZlYXR1cmU9b2VtYmVkJmFtcDt3bW9kZT1vcGFxdWUmYW1wO3Nob3dpbmZvPTBcIiBzdHlsZT1cImJvcmRlcjogbm9uZVwiIGFsbG93PVwiYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGNsaXBib2FyZC13cml0ZTsgZW5jcnlwdGVkLW1lZGlhOyBneXJvc2NvcGU7IHBpY3R1cmUtaW4tcGljdHVyZTsgd2ViLXNoYXJlXCIgYWxsb3dmdWxsc2NyZWVuPjwvaWZyYW1lPiIsIiVfb2VtYmVkX3RpbWVfZTMzNWQ5OGI2ZmIyNTYzNjcwMzhlMTQxNTBkYmFkYWUlIjoiMTcwNzQyMjA0MyIsIiVfb2VtYmVkXzMyOWNmZmM4NDdjM2JmNTM0MTA2YzM4MmFhYWQ2OGJlJSI6IjxpZnJhbWUgdGl0bGU9XCJMYSBkXHUwMGU5Y3JvaXNzYW5jZSBcdTAwZTAgXHUwMGU5Y2hlbGxlIGluZGl2aWR1ZWxsZSA6IHJcdTAwZTlkdWlyZSBzb24gZW1wcmVpbnRlIGNhcmJvbmUgfCBEXHUwMGU5Y3JvaXNzYW5jZSB8IFJhZFwiIHdpZHRoPVwiNTAwXCIgaGVpZ2h0PVwiMjgxXCIgc3JjPVwiaHR0cHM6Ly93d3cueW91dHViZS5jb20vZW1iZWQveFhUUFBydHBqNHM/ZmVhdHVyZT1vZW1iZWQmYW1wO3dtb2RlPW9wYXF1ZSZhbXA7c2hvd2luZm89MFwiIHN0eWxlPVwiYm9yZGVyOiBub25lXCIgYWxsb3c9XCJhY2NlbGVyb21ldGVyOyBhdXRvcGxheTsgY2xpcGJvYXJkLXdyaXRlOyBlbmNyeXB0ZWQtbWVkaWE7IGd5cm9zY29wZTsgcGljdHVyZS1pbi1waWN0dXJlOyB3ZWItc2hhcmVcIiBhbGxvd2Z1bGxzY3JlZW4+PC9pZnJhbWU+IiwiJV9vZW1iZWRfdGltZV8zMjljZmZjODQ3YzNiZjUzNDEwNmMzODJhYWFkNjhiZSUiOiIxNzA3NDIyMDQzIiwiJV9vZW1iZWRfODAwMTJhMWYwODkzOTI0ODhkOGJiOTFiYWMwM2YxMjclIjoiPGlmcmFtZSB0aXRsZT1cIkwmIzAzOTtpbnRlbGxpZ2VuY2UgYXJ0aWZpY2llbGxlIFx1MDBlMCBNb250clx1MDBlOWFsIHwgUmFkXCIgd2lkdGg9XCI1MDBcIiBoZWlnaHQ9XCIyODFcIiBzcmM9XCJodHRwczovL3d3dy55b3V0dWJlLmNvbS9lbWJlZC93ZHFNd3VfQlRZOD9mZWF0dXJlPW9lbWJlZCZhbXA7d21vZGU9b3BhcXVlJmFtcDtzaG93aW5mbz0wXCIgc3R5bGU9XCJib3JkZXI6IG5vbmVcIiBhbGxvdz1cImFjY2VsZXJvbWV0ZXI7IGF1dG9wbGF5OyBjbGlwYm9hcmQtd3JpdGU7IGVuY3J5cHRlZC1tZWRpYTsgZ3lyb3Njb3BlOyBwaWN0dXJlLWluLXBpY3R1cmU7IHdlYi1zaGFyZVwiIGFsbG93ZnVsbHNjcmVlbj48L2lmcmFtZT4iLCIlX29lbWJlZF90aW1lXzgwMDEyYTFmMDg5MzkyNDg4ZDhiYjkxYmFjMDNmMTI3JSI6IjE3MDc0MjIwNDMiLCIlX29lbWJlZF84ODljNTViMWVhOTdmM2FhMjUzMTExZjg3ZmQ0MDFhZSUiOiI8aWZyYW1lIHRpdGxlPVwiU2UgYmF0dHJlIHBvdXIgcXVlIGxhIHBsYW5cdTAwZTh0ZSBuZSBjb25zb21tZSBwbHVzIGRlIHZpYW5kZSB8IEFsaW1lbnRhdGlvbiB8IFJhZFwiIHdpZHRoPVwiNTAwXCIgaGVpZ2h0PVwiMjgxXCIgc3JjPVwiaHR0cHM6Ly93d3cueW91dHViZS5jb20vZW1iZWQvTU8tLVlBQnc5RFU/ZmVhdHVyZT1vZW1iZWQmYW1wO3dtb2RlPW9wYXF1ZSZhbXA7c2hvd2luZm89MFwiIHN0eWxlPVwiYm9yZGVyOiBub25lXCIgYWxsb3c9XCJhY2NlbGVyb21ldGVyOyBhdXRvcGxheTsgY2xpcGJvYXJkLXdyaXRlOyBlbmNyeXB0ZWQtbWVkaWE7IGd5cm9zY29wZTsgcGljdHVyZS1pbi1waWN0dXJlOyB3ZWItc2hhcmVcIiBhbGxvd2Z1bGxzY3JlZW4+PC9pZnJhbWU+IiwiJV9vZW1iZWRfdGltZV84ODljNTViMWVhOTdmM2FhMjUzMTExZjg3ZmQ0MDFhZSUiOiIxNzA3NDIyMDQ0IiwiJV9vZW1iZWRfNTk2NWViODkyMDk5MDc3MGMxMGNjMTM3MzRhNzJmN2YlIjoiPGlmcmFtZSB0aXRsZT1cIlBvdXJxdW9pIHZvdGVyPyB8IFByb2dyYW1tZSBSYWQgfCBcdTAwYzlsZWN0aW9ucyBRdVx1MDBlOWJlYyAyMDE4IHwgIDAxIFx1MjAxNCAyM1wiIHdpZHRoPVwiNTAwXCIgaGVpZ2h0PVwiMjgxXCIgc3JjPVwiaHR0cHM6Ly93d3cueW91dHViZS5jb20vZW1iZWQvQ3RsM3FTTVpjSEU/ZmVhdHVyZT1vZW1iZWQmYW1wO3dtb2RlPW9wYXF1ZSZhbXA7c2hvd2luZm89MFwiIHN0eWxlPVwiYm9yZGVyOiBub25lXCIgYWxsb3c9XCJhY2NlbGVyb21ldGVyOyBhdXRvcGxheTsgY2xpcGJvYXJkLXdyaXRlOyBlbmNyeXB0ZWQtbWVkaWE7IGd5cm9zY29wZTsgcGljdHVyZS1pbi1waWN0dXJlOyB3ZWItc2hhcmVcIiBhbGxvd2Z1bGxzY3JlZW4+PC9pZnJhbWU+IiwiJV9vZW1iZWRfdGltZV81OTY1ZWI4OTIwOTkwNzcwYzEwY2MxMzczNGE3MmY3ZiUiOiIxNzA3NDIyMDQ0IiwiJV9vZW1iZWRfMzU3MTAyMGRmNzY2NWIzZWM1MDFlOTBhNDM5Y2Q0MDglIjoiPGlmcmFtZSB0aXRsZT1cIklsIFx1MDBlOXRhaXQgdW5lIGZvaXMgbGVzIHBhcnRpcyBwb2xpdGlxdWVzLi4uIHwgUHJvZ3JhbW1lIFJhZCB8IFx1MDBjOWxlY3Rpb25zIFF1XHUwMGU5YmVjIDIwMTggfCAwMyBcdTIwMTQgMjNcIiB3aWR0aD1cIjUwMFwiIGhlaWdodD1cIjI4MVwiIHNyYz1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkL1p1aE5IQ09VTklFP2ZlYXR1cmU9b2VtYmVkJmFtcDt3bW9kZT1vcGFxdWUmYW1wO3Nob3dpbmZvPTBcIiBzdHlsZT1cImJvcmRlcjogbm9uZVwiIGFsbG93PVwiYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGNsaXBib2FyZC13cml0ZTsgZW5jcnlwdGVkLW1lZGlhOyBneXJvc2NvcGU7IHBpY3R1cmUtaW4tcGljdHVyZTsgd2ViLXNoYXJlXCIgYWxsb3dmdWxsc2NyZWVuPjwvaWZyYW1lPiIsIiVfb2VtYmVkX3RpbWVfMzU3MTAyMGRmNzY2NWIzZWM1MDFlOTBhNDM5Y2Q0MDglIjoiMTcwNzQyMjA0NCIsIiVfb2VtYmVkX2Y5Nzc4NmM5ZWU3MTk5MTY3NjhhY2VjNmE3OTZiYzcyJSI6IjxpZnJhbWUgdGl0bGU9XCJGb25kcyB2ZXJ0LCBDaGluZS1DYW5hZGEsIHRlbnNpb25zIElyYW4tXHUwMGM5dGF0cy1VbmlzIGV0IGFwYXJ0aGVpZCBjbGltYXRpcXVlIHwgQnVua2VyICMwMVwiIHdpZHRoPVwiNTAwXCIgaGVpZ2h0PVwiMjgxXCIgc3JjPVwiaHR0cHM6Ly93d3cueW91dHViZS5jb20vZW1iZWQvX20tSUNqam9ka2M/ZmVhdHVyZT1vZW1iZWQmYW1wO3dtb2RlPW9wYXF1ZSZhbXA7c2hvd2luZm89MFwiIHN0eWxlPVwiYm9yZGVyOiBub25lXCIgYWxsb3c9XCJhY2NlbGVyb21ldGVyOyBhdXRvcGxheTsgY2xpcGJvYXJkLXdyaXRlOyBlbmNyeXB0ZWQtbWVkaWE7IGd5cm9zY29wZTsgcGljdHVyZS1pbi1waWN0dXJlOyB3ZWItc2hhcmVcIiBhbGxvd2Z1bGxzY3JlZW4+PC9pZnJhbWU+IiwiJV9vZW1iZWRfdGltZV9mOTc3ODZjOWVlNzE5OTE2NzY4YWNlYzZhNzk2YmM3MiUiOiIxNzA3NDIyMDQ0IiwiJV9vZW1iZWRfNDFmNzQzN2RiOTNiYmZmYTA5NDNkZGZiNTZiOTgwMzIlIjoiPGlmcmFtZSB0aXRsZT1cIkxlcyBcdTAwZTlsZWN0aW9ucywgY29tbWVudCBcdTAwZTdhIGZvbmN0aW9ubmU/IHwgUHJvZ3JhbW1lIFJhZCB8IFx1MDBjOWxlY3Rpb25zIFF1XHUwMGU5YmVjIDIwMTggfCAwMiBcdTIwMTQgMjNcIiB3aWR0aD1cIjUwMFwiIGhlaWdodD1cIjI4MVwiIHNyYz1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkL2FnM1BkRkNEbnk4P2ZlYXR1cmU9b2VtYmVkJmFtcDt3bW9kZT1vcGFxdWUmYW1wO3Nob3dpbmZvPTBcIiBzdHlsZT1cImJvcmRlcjogbm9uZVwiIGFsbG93PVwiYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGNsaXBib2FyZC13cml0ZTsgZW5jcnlwdGVkLW1lZGlhOyBneXJvc2NvcGU7IHBpY3R1cmUtaW4tcGljdHVyZTsgd2ViLXNoYXJlXCIgYWxsb3dmdWxsc2NyZWVuPjwvaWZyYW1lPiIsIiVfb2VtYmVkX3RpbWVfNDFmNzQzN2RiOTNiYmZmYTA5NDNkZGZiNTZiOTgwMzIlIjoiMTcwNzQyMjA0NCIsIiVfb2VtYmVkX2VmMTdjOGZhZWUzZGYyZjZmNzI3ZmEyNGJkOTI5Zjc0JSI6IjxpZnJhbWUgdGl0bGU9XCJMRSBDQUxNRSBBVkFOVCBMRVMgXHUwMGM5TEVDVElPTlMgfCBWTE9HVUUgUkFEICMwMlwiIHdpZHRoPVwiNTAwXCIgaGVpZ2h0PVwiMjgxXCIgc3JjPVwiaHR0cHM6Ly93d3cueW91dHViZS5jb20vZW1iZWQvbjdjdGdUbkNSM0U/ZmVhdHVyZT1vZW1iZWQmYW1wO3dtb2RlPW9wYXF1ZSZhbXA7c2hvd2luZm89MFwiIHN0eWxlPVwiYm9yZGVyOiBub25lXCIgYWxsb3c9XCJhY2NlbGVyb21ldGVyOyBhdXRvcGxheTsgY2xpcGJvYXJkLXdyaXRlOyBlbmNyeXB0ZWQtbWVkaWE7IGd5cm9zY29wZTsgcGljdHVyZS1pbi1waWN0dXJlOyB3ZWItc2hhcmVcIiBhbGxvd2Z1bGxzY3JlZW4+PC9pZnJhbWU+IiwiJV9vZW1iZWRfdGltZV9lZjE3YzhmYWVlM2RmMmY2ZjcyN2ZhMjRiZDkyOWY3NCUiOiIxNzA3NDIyMDQ0IiwidGF4b25vbXk9Y2F0ZWdvcnkiOiJNZWRpYSBsYWJzIiwidGF4b25vbXk9cG9zdF90YWciOiIifSwiaWNvbiI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE4LzAyL21hcmtlci0xLnBuZyJ9LCJpZCI6MTUxOTYsImluZm93aW5kb3dfZGlzYWJsZSI6ZmFsc2V9LHsic291cmNlIjoicG9zdCIsInRpdGxlIjoiTGUgVGFuayBNZWRpYTogc3RpbXVsYXRvciBvZiBtZWRpYSBlbnRyZXByZW5ldXJzaGlwIiwiaW5mb3dpbmRvd19jb250ZW50IjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZ1wiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJMZSBUYW5rIE1lZGlhOiBzdGltdWxhdG9yIG9mIG1lZGlhIGVudHJlcHJlbmV1cnNoaXBcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjIwMFwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE5LzA3LzFfcmhpeUJmNm1qNFZYOWoyVzBoY3BOUUAyeC0zMDB4MjAwLmpwZWdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1wYWRkaW5nLWNvbnRlbnRfMjBcIj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1tZXRhIGZjLWl0ZW0tc2Vjb25kYXJ5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2UgZmMtdGV4dC1jZW50ZXJcIj5NZWRpYSBsYWJzPC9kaXY+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tdGl0bGUgZmMtaXRlbS1wcmltYXJ5LXRleHQtY29sb3IgZmMtdGV4dC1jZW50ZXJcIj5MZSBUYW5rIE1lZGlhOiBzdGltdWxhdG9yIG9mIG1lZGlhIGVudHJlcHJlbmV1cnNoaXA8L2Rpdj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1jb250ZW50IGZjLWl0ZW0tYm9keS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+XHJcbiAgICAgICAgICAgIExlIFRhbmsgTWVkaWEgaGFzIGJlY29tZSBvbmUgb2YgdGhlIGxlYWRpbmcgYWN0b3JzIGluIG1lZGlhIGVudHJlcHJlbmV1cnNoaXAgaW4gRnJhbmNlLiBVc2luZyB0aGlzIGV4cGVyaWVuY2UgaXQgaXMgbm93IGV4cGFuZGluZyBpdHMgYW1iaXRpb25zLCB3aXRoIGEgMTcwMCBtXHUwMGIyIHNwYWNlIGRlZGljYXRlZCB0byBlbWVyZ2luZyBtZWRpYSBvcGVuaW5nIHNvb24sIGFzIHdlbGwgYXMgb3RoZXIgbmV3IHByb2plY3RzLlxyXG4gICAgICAgIDwvZGl2PlxyXG48YSBocmVmPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL2xlLXRhbmstbWVkaWEtc3RpbXVsYXRvci1vZi1tZWRpYS1lbnRyZXByZW5ldXJzaGlwL1wiPlJlYWQgbW9yZTwvYT5cclxuICAgIDwvZGl2PlxyXG4gICAgPC9kaXY+XHJcbjwvZGl2PlxyXG5cclxuIiwiY29udGVudCI6IkxlIFRhbmsgTWVkaWEgaGFzIGJlY29tZSBvbmUgb2YgdGhlIGxlYWRpbmcgYWN0b3JzIGluIG1lZGlhIGVudHJlcHJlbmV1cnNoaXAgaW4gRnJhbmNlLiBVc2luZyB0aGlzIGV4cGVyaWVuY2UgaXQgaXMgbm93IGV4cGFuZGluZyBpdHMgYW1iaXRpb25zLCB3aXRoIGEgMTcwMCBtXHUwMGIyIHNwYWNlIGRlZGljYXRlZCB0byBlbWVyZ2luZyBtZWRpYSBvcGVuaW5nIHNvb24sIGFzIHdlbGwgYXMgb3RoZXIgbmV3IHByb2plY3RzLiIsImFkZHJlc3MiOiIyMkIgUnVlIGRlcyBUYWlsbGFuZGllcnMsIDc1MDExIFBhcmlzLCBGcmFuY2UiLCJsb2NhdGlvbiI6eyJsYXQiOiI0OC44NTUxOTkxMDAwMDAwMSIsImNpdHkiOiJQYXJpcyIsInN0YXRlIjoiXHUwMGNlbGUtZGUtRnJhbmNlIiwiY291bnRyeSI6IkZyYW5jZSIsImxuZyI6IjIuMzc0OTQ3Mzk5OTk5OTk2NCIsIm9uY2xpY2tfYWN0aW9uIjoibWFya2VyIiwicmVkaXJlY3RfcGVybWFsaW5rIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL2xlLXRhbmstbWVkaWEtc3RpbXVsYXRvci1vZi1tZWRpYS1lbnRyZXByZW5ldXJzaGlwLyIsInpvb20iOjIsImV4dHJhX2ZpZWxkcyI6eyJwb3N0X2V4Y2VycHQiOiJMZSBUYW5rIE1lZGlhIGhhcyBiZWNvbWUgb25lIG9mIHRoZSBsZWFkaW5nIGFjdG9ycyBpbiBtZWRpYSBlbnRyZXByZW5ldXJzaGlwIGluIEZyYW5jZS4gVXNpbmcgdGhpcyBleHBlcmllbmNlIGl0IGlzIG5vdyBleHBhbmRpbmcgaXRzIGFtYml0aW9ucywgd2l0aCBhIDE3MDAgbVx1MDBiMiBzcGFjZSBkZWRpY2F0ZWQgdG8gZW1lcmdpbmcgbWVkaWEgb3BlbmluZyBzb29uLCBhcyB3ZWxsIGFzIG90aGVyIG5ldyBwcm9qZWN0cy4iLCJwb3N0X2NvbnRlbnQiOiJbdmNfcm93XVt2Y19jb2x1bW4gd2lkdGg9XCIxLzRcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS8yXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48aDE+TGUgVGFuayBNZWRpYTogc3RpbXVsYXRvciBvZiBtZWRpYSBlbnRyZXByZW5ldXJzaGlwPC9oMT5cclxuPGVtPldlIGFyZSByZXB1Ymxpc2hpbmcgdGhpcyBhcnRpY2xlLCBvcmlnaW5hbGx5IHB1Ymxpc2hlZCBvbiA8YSBocmVmPVwiaHR0cHM6Ly93d3cubWV0YS1tZWRpYS5mci8yMDE5LzA3LzE3L2xlLXRhbmstbWVkaWEtc3RpbXVsYXRldXItZGUtbGVudHJlcHJlbmV1cmlhdC1tZWRpYS5odG1sXCI+TVx1MDBlOXRhLU1lZGlhPC9hPiwgYXMgcGFydCBvZiBhbiBlZGl0b3JpYWwgcGFydG5lcnNoaXAgYmV0d2VlbiBNXHUwMGU5dGEtTWVkaWEgYW5kIFdBTi1JRlJBLiBUaGUgYXJ0aWNsZSB3YXMgd3JpdHRlbiBieSA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9hbGV4X2JvdW5pb2xcIj5BbGV4YW5kcmUgQm91bmlvbDwvYT4sIEZyYW5jZSBUXHUwMGU5bFx1MDBlOXZpc2lvbnMsIE1lZGlhTGFiLjwvZW0+XHJcblxyXG5TdGFydGVkIHR3byB5ZWFycyBhZ28gYnkgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vdmVyc2FjXCI+Tmljb2xhcyBWYW5icmVtZWVyc2NoPC9hPiBldCA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9NTURQXCI+TWF0aGlldSBNYWlyZSBkdSBQb3NldDwvYT4sIGxlIFRhbmsgTWVkaWEgaGFzIGJlY29tZSBvbmUgb2YgdGhlIGxlYWRpbmcgYWN0b3JzIGluIG1lZGlhIGVudHJlcHJlbmV1cnNoaXAgaW4gRnJhbmNlLiBOb3cgdGhlIGluaXRpYXRpdmUgaXMgZXhwYW5kaW5nIGl0cyBhbWJpdGlvbnMgd2l0aCBhIG11bHRpdHVkZSBvZiBuZXcgcHJvamVjdHMsIGluY2x1ZGluZyBhIDE3MDAgbVx1MDBiMiBzcGFjZSBkZWRpY2F0ZWQgdG8gZW1lcmdpbmcgbWVkaWEuIEludGVydmlldyB3aXRoIE1hdGhpZXUgTWFpcmUgZHUgUG9zZXQuXHJcbjxoMz5BbiBlY29zeXN0ZW0gdG8gc3RydWN0dXJlPC9oMz5cclxuVGhlIHByZXNzIGlzIG5vdCBkb2luZyB3ZWxsLiBTZXZlcmFsIGxhcmdlIG1lZGlhIGdyb3VwcyBoYXZlIGFubm91bmNlZCB2b2x1bnRhcnkgZGVwYXJ0dXJlIHBsYW5zLiBUaGUgY2xpbWF0ZSBpbiB0aGUgbWVkaWEgd29ybGQgaXMsIHRvIHNheSB0aGUgbGVhc3QsIGdsb29teS4gQW5kIHlldCwgbGUgVGFuayBNZWRpYSBzaG93cyBvcHRpbWlzbSB3aXRoIGl0cyBzbG9nYW4gXHUyMDFjdGhlIGZ1dHVyZSBvZiBtZWRpYSBpcyBicmlnaHRcdTIwMWQuIEFjY29yZGluZyB0byBNYXRoaWV1IE1haXJlIGR1IFBvc2V0LCA8c3Ryb25nPml0IGlzIGVzcGVjaWFsbHkgdGhlIGJpZyBwdWJsaXNoZXJzIHRoYXQgYXJlIGRvaW5nIGJhZGx5PC9zdHJvbmc+OiA8ZW0+XHUyMDFjdHJhbnNmb3JtaW5nIHRoZW0gZnJvbSBpbnNpZGUgaXMgZGlmZmljdWx0LFx1MjAxZDwvZW0+IGhlIHNheXMuIEJ1dCBiaWcgcHVibGlzaGVycyBkbyBub3QgcmVwcmVzZW50IHRoZSBlbnRpcmUgbWVkaWEgc3BlY3RydW0gaW4gRnJhbmNlLiBUaGVyZSBpcyBhIDxzdHJvbmc+cmVhbCB2aXRhbGl0eSBpbiBtZWRpYSBlbnRyZXByZW5ldXJzaGlwPC9zdHJvbmc+LiBUaGlzIGlzIG9uZSBvZiB0aGUgb2JzZXJ2YXRpb25zIHRoYXQgaGUgaGFzIG1hZGUgdGhyb3VnaCB0aGUgcHJpc20gb2YgY3Jvd2RmdW5kaW5nLCB3aGljaCBoZSBzZWVzIGFzIGEgPGVtPlx1MjAxY21vbml0b3JpbmcgdG9vbCBmb3IgdmVyeSBpbnRlcmVzdGluZyB0cmVuZHMgYW5kIHdlYWsgc2lnbmFsc1x1MjAxZDwvZW0+LiBXaGV0aGVyIHdlIGNvbnNpZGVyIG1lZGlhIHByb2Zlc3Npb25hbHMsIGVudHJlcHJlbmV1cnMgY29taW5nIGZyb20gb3RoZXIgc2VjdG9ycywgb3IgZW50aHVzaWFzdHMgd2hvIHdhbnQgdG8gYmVjb21lIHByb2Zlc3Npb25hbCwgdGhlcmUgaXMgPHN0cm9uZz5hIHN0cm9uZyBkZW1hbmQ8L3N0cm9uZz4uXHJcblxyXG5UaGUgcHJvYmxlbSB1bnRpbCBub3cgaGFzIGJlZW4gdGhhdCA8c3Ryb25nPnRoaXMgZWNvc3lzdGVtIDxlbT5cdTIwMWNkb2VzIG5vdCBoYXZlIGEgYm9keSwgZG9lcyBub3QgaGF2ZSBhIGNvbW11bml0eVx1MjAxZDwvZW0+PC9zdHJvbmc+LiBUaGVyZSBpcyBubyBzdHJ1Y3R1cmUgd2l0aGluIHdoaWNoIG9uZSBjb3VsZCBzaGFyZSB0aGVpciBleHBlcmllbmNlcy4gSW4gYWRkaXRpb24sIHRoZXJlIGlzIGEgbGFjayBvZiBjb21wZXRlbmNlcy4gVGhlIGZvdW5kZXJzIG9mIGxlIFRhbmsgTWVkaWEgY29uY2x1ZGVkIHRoYXQgdGhlcmUgaXMgPGVtPlx1MjAxY2Egc2hvcnRhZ2Ugb2YgZGlnaXRhbCBleHBlcnRpc2UuIE1hbnkgdXNlIGRpZ2l0YWwgYXMgYSBzdXBwb3J0LCBidXQgZmV3IGFzIGEgdG9vbCB0byBjYXJyeSBvdXQgcmVhbCByZWZsZWN0aW9ucyBvbiB0aGUgaXNzdWVcdTIwMWQ8L2VtPi4gVGhpcyBpcyBhbHNvIHRoZSBjYXNlIHdpdGggZW50cmVwcmVuZXVyaWFsIGV4cGVydGlzZTogPGVtPlx1MjAxY21hbnkgY29tZSBmcm9tIHRoZSBlZGl0b3JpYWwgc2lkZSBhbmQgYXJlIG5vdCB0cmFpbmVkIGZvciBpdFx1MjAxZDwvZW0+LiBMZSBUYW5rIE1lZGlhIHdhcyBib3JuIG9uIHRoZSBiYXNpcyBvZiB0aGVzZSBmaW5kaW5ncywgd2l0aCB0aGUgaW50ZW50aW9uIHRvIG9mZmVyIGEgc3VwcGx5IHRvIHRoaXMgZXhpc3RpbmcgZGVtYW5kLlxyXG5cclxuaHR0cHM6Ly90d2l0dGVyLmNvbS9sZXRhbmttZWRpYS9zdGF0dXMvMTE0NDE1NzgyOTE1NjI5ODc1M1xyXG48aDM+QW4gb3JnYW5pemF0aW9uIG9wZW4gdG8gdGhlIG91dHNpZGU8L2gzPlxyXG5UYWtpbmcgYWZ0ZXIgdGhlIEROQSBvZiB0aGUgcGFyZW50IGNvbXBhbnkgPGEgaHJlZj1cImh0dHBzOi8vd3d3LnNwaW50YW5rLmZyL1wiPlNwaW50YW5rPC9hPiAoXHUyMDFjd2UgYXJlIHdpdGggdGhvc2Ugd2hvIHRyYW5zZm9ybSB0aGUgc29jaWV0eVx1MjAxZCBnb2VzIHRoZSBhZ2VuY3lcdTIwMTlzIHNsb2dhbiksIGxlIFRhbmsgTWVkaWEgaGFzIGV2b2x2ZWQgZm9sbG93aW5nIHRoZSBzYW1lIGd1aWRpbmcgbGluZXMuIE1hdGhpZXUgTWFpcmUgZHUgUG9zZXQgZXhwbGFpbnMgdGhhdCA8ZW0+XHUyMDFjdGhlIGdvYWwgb2YgbGUgVGFuayBNZWRpYSBpcyB0byA8c3Ryb25nPmZvc3RlciB0aGUgZW1lcmdlbmNlIG9mIG5ldyBlbnRyZXByZW5ldXJzaGlwIGluIHRoZSBtZWRpYSwgaGVscCB0aGUgbmV3IG1lZGlhIGdlbmVyYXRpb25zIHRvIGdyb3csIHRvIHN0cnVjdHVyZSB0aGVtc2VsdmVzIGFuZCB0byBmaW5kIHRoZSBrZXlzIHRvIHByb2ZpdGFiaWxpdHkgYW5kIGluZGVwZW5kZW5jZVx1MjAxZDwvc3Ryb25nPjwvZW0+LiBMZSBUYW5rIE1lZGlhIGlzIGJhc2VkIG9uIGZvdXIgcGlsbGFycyA6XHJcbjx1bD5cclxuIFx0PGxpPjxzdHJvbmc+QmVpbmcgYSBtZWRpYTwvc3Ryb25nPjwvbGk+XHJcbjwvdWw+XHJcblRoaXMgYWxsb3dzIGxlIFRhbmsgTWVkaWEgdG8gPHN0cm9uZz50cmFuc21pdCA8ZW0+XHUyMDFjd2hhdCBpcyBnb2luZyBvbiBpbiB0aGUgd29ybGQgb2YgbWVkaWEgY3VycmVudGx5PC9lbT48L3N0cm9uZz48ZW0+LCB0byBicm9hZGNhc3QgYW4gZW5jb3VyYWdpbmcgdmlzaW9uIG9mIHRoZSBlY29zeXN0ZW0sIHdoaWNoIGlzIG9mdGVuIHNhaWQgdG8gYmUgaW4gYSBjcmlzaXMgYnV0IHdoaWNoIHdlIHRoaW5rIGlzIHJhdGhlciBpbiBhIHByb2Nlc3Mgb2YgdHJhbnNmb3JtYXRpb24gYW5kIHdpdGhpbiB3aGljaCBtYW55IHBvc2l0aXZlIHRoaW5ncyBoYXBwZW4uXHUyMDFjPC9lbT4gTGUgVGFuayBNZWRpYSBwcm9kdWNlcyBjb250ZW50IHZpYSBhIDxhIGhyZWY9XCJodHRwczovL21lZGl1bS5jb20vbGV0YW5rLW1lZGlhXCI+YmxvZzwvYT4sIGEgPGEgaHJlZj1cImh0dHBzOi8vc291bmRjbG91ZC5jb20vdXNlci05Nzk0NTg2N1wiPnBvZGNhc3Q8L2E+IGFuZCBhIG5ld3NsZXR0ZXIuXHJcbjx1bD5cclxuIFx0PGxpPjxzdHJvbmc+QmVpbmcgYSBjb21tdW5pdHkgYW5pbWF0b3I8L3N0cm9uZz48L2xpPlxyXG48L3VsPlxyXG5UaGlzIGlzIGEgY2VudHJhbCBwb2ludCBvZiBsZSBUYW5rIE1lZGlhXHUyMDE5cyBhaW0gdG8gPGVtPlx1MjAxY3RyeSB0byA8c3Ryb25nPmJyaW5nIHRvIGxpZmUgdGhpcyBjb21tdW5pdHkgb2YgbWVkaWEgZW50cmVwcmVuZXVycy4gR2l2ZSB0aGVtIHRoZSBwb3NzaWJpbGl0eSB0byBtZWV0IGVhY2ggb3RoZXIsIGV4Y2hhbmdlLCBzaGFyZSB0aGVpciBleHBlcmllbmNlczwvc3Ryb25nPlx1MjAyNiBUaGlzIGlzIG9yZ2FuaXplZCB2aWEgbW9udGhseSBsdW5jaGVzIHdpdGggZW50cmVwcmVuZXVycywgYW5kIGFubnVhbCBhbmQgcXVhcnRlcmx5IGV2ZW50cy5cdTIwMWQ8L2VtPlxyXG48dWw+XHJcbiBcdDxsaT48c3Ryb25nPkEgbWlzc2lvbiB0byBjb25uZWN0PC9zdHJvbmc+PC9saT5cclxuPC91bD5cclxuQmFzZWQgd2l0aGluIHRoZSBjb3dvcmtpbmcgc3BhY2Ugb2YgPGEgaHJlZj1cImh0dHBzOi8vbGV0YW5rLmZyL1wiPlRhbms8L2E+LCBsZSBUYW5rIE1lZGlhIGFscmVhZHkgc2hhcmVzIGl0cyBwcmVtaXNlcyB3aXRoIFNwaW50YW5rIGFuZCBvdGhlciBmaXJtcyAoaW5jbHVkaW5nIG1lZGlhKS4gVGhlIGdvYWwgaXMgdG8gPGVtPjxzdHJvbmc+XHUyMDFjbWFrZSBpdCBwb3NzaWJsZSBmb3IgdGhpcyBjb21tdW5pdHkgdG8gbWVldCB1cCBvbiBhIGRhaWx5IGJhc2lzXHUyMDFkPC9zdHJvbmc+PC9lbT4uIFRoZSBpbml0aWF0aXZlIGhvcGVzIHRvIGdvIGV2ZW4gZnVydGhlciB3aXRoIHRoZSBvcGVuaW5nIDxlbT5cdTIwMWNvZiBhIHNwYWNlIG9mIDE3MDAgbVx1MDBiMiBpbiBQYXJpcyBpbiBtaWQtT2N0b2JlciAvIGVhcmx5IE5vdmVtYmVyIGRlZGljYXRlZCB0byBlbWVyZ2luZyBtZWRpYS4gVGhlcmUgd2lsbCBiZSBhYm91dCAxNzAgd29ya3N0YXRpb25zLCBhIHN0dWRpbyBmb3IgcHJvZHVjaW5nIHZpZGVvIGFuZCBhdWRpbywgZWRpdGluZyBzdGF0aW9ucyBhbmQgYW4gZXZlbnQgcm9vbS5cdTIwMWQ8L2VtPlxyXG5cclxuaHR0cHM6Ly90d2l0dGVyLmNvbS9sZXRhbmttZWRpYS9zdGF0dXMvMTE0NzAyNzE0ODU3MTYzMTYxNlxyXG48dWw+XHJcbiBcdDxsaT48c3Ryb25nPkEgdGFzayB0byBpbmN1YmF0ZSwgYWNjb21wYW55IGFuZCB0cmFpbjwvc3Ryb25nPjwvbGk+XHJcbjwvdWw+XHJcblRoaXMgaXMgdGhlIGhlYXJ0IG9mIGxlIFRhbmsgTWVkaWFcdTIwMTlzIHByb2plY3QsIDxlbT5cdTIwMWNvZmZlcmluZyB0byBhY2NvbXBhbnkgbWVkaWEgZW50cmVwcmVuZXVycywgcmVnYXJkbGVzcyBvZiB0aGVpciBzdGFnZSBvZiBkZXZlbG9wbWVudC4gVGhlIGluY3ViYXRpb24gcHJvZ3JhbW1lIGlzIGZvciBtZWRpYSB0aGF0IGF0IHNvbWUgcG9pbnQgaW4gdGhlaXIgbGlmZXNwYW4gbmVlZCB0byBwcm9mb3VuZGx5IHJldGhpbmsgdGhlaXIgdmFsdWUgcHJvcG9zaXRpb24uIFdoZXRoZXIgdGhleSBhcmUgcHVibGlzaGVycyBpbiB0aGUgbGF1bmNoIHBoYXNlIG9yIHB1Ymxpc2hlcnMgdGhhdCBuZWVkIHRvIHJlaW52ZW50IHRoZW1zZWx2ZXMuXHUyMDFkPC9lbT4gVHdpY2UgYSB5ZWFyLCBsZSBUYW5rIE1lZGlhIGxhdW5jaGVzIGEgPGEgaHJlZj1cImh0dHA6Ly9sZXRhbmttZWRpYS5mci9wcm9ncmFtbWVzXCI+Y2FsbCBmb3IgcHJvamVjdHM8L2E+LiBPbiBhdmVyYWdlLCAzNSBjYW5kaWRhdHVyZXMgYXJlIHJlY2VpdmVkLCBhbmQgYSBqdXJ5IGNvbnNpc3Rpbmcgb2YgbWVtYmVycyBvZiBUYW5rIE1lZGlhIGFuZCBtZWRpYSBlbnRyZXByZW5ldXJzIGludml0ZXMgYSB0aGlyZCBvZiB0aGVtIGZvciBhbiBpbnRlcnZpZXcuXHJcblxyXG5TaW5jZSB0aGUgbGF1bmNoLCA8c3Ryb25nPnRocmVlIGluY3ViYXRpb24gcHJvZ3JhbW1lcyBoYXZlIGFscmVhZHkgdGFrZW4gcGxhY2UgZm9yIGEgdG90YWwgb2YgMTkgaW5jdWJhdGVkIG1lZGlhPC9zdHJvbmc+LiBUaGVyZSBpcyBubyByZXF1aXJlZCB0ZW1wbGF0ZSwgYnV0IGFsbCB0eXBlcyBvZiBtZWRpYSBhcmUgYWNjZXB0ZWQuIEZvciBleGFtcGxlIGR1cmluZyB0aGUgbGFzdCBpbmN1YmF0aW9uIHJvdW5kLCBhIHBvZGNhc3QsIGEgWW91VHViZSB0dXRvcmlhbCBhbmQgZXZlbiBtYWdhemluZXMgZm9sbG93ZWQgdGhlIHByb2dyYW1tZSAoPGEgaHJlZj1cImh0dHA6Ly93d3cuaW50ZXJuZXRhY3R1Lm5ldC9cIj5JbnRlcm5ldCBhY3R1PC9hPiBhbmQgPGEgaHJlZj1cImh0dHBzOi8vd3d3Lmluc3RhZ3JhbS5jb20vYm91Y2hlX21hZ2F6aW5lL1wiPkJvdWNoZSBNYWdhemluZTwvYT4sIHRvIHRha2UgYSBjb3VwbGUgb2YgZXhhbXBsZXMpLiBGb3IgdHdlbHZlIHdlZWtzLCB0aGUgaW5jdWJhdGVkIGNvbXBhbmllcyBmb2xsb3cgdHJhaW5pbmdzLCBtZWV0IHdpdGggc3Rha2Vob2xkZXJzLCBleGNoYW5nZSB3aXRoIG90aGVyIHBhcnRpY2lwYW50cyBhbmQgYXJlIGFjY29tcGFuaWVkIGJ5IGxlIFRhbmsgTWVkaWFcdTIwMTlzIHRlYW1zLiBJbiB0aGUgYXV0dW1uIG9mIDIwMTksIE1hdGhpZXUgTWFpcmUgZHUgUG9zZXQgc2F5cyB0aGF0IHRoZXkgd2FudCB0byBnbyBldmVuIGZ1cnRoZXI6XHJcblxyXG48ZW0+PHN0cm9uZz5cdTIwMWNXZSB3aWxsIGxhdW5jaCBhIGZpcnN0IGNhdGFsb2d1ZSBvZiB0cmFpbmluZ3MgYXJvdW5kIHRvcGljcyBvZiBpbnRyYXByZW5ldXJzaGlwIGFuZCBlbnRyZXByZW5ldXJzaGlwLiBBbmQgYW4gYWdlbmN5IC8gc3R1ZGlvIHRoYXQgYWltcyB0byBhY2NvbXBhbnkgZXhpc3RpbmcgbWVkaWEgaW4gdGhlaXIgY2FwYWNpdHkgdG8gZGV2ZWxvcCBpbnRyYXByZW5ldXJzaGlwIGludGVybmFsbHkgYW5kIGxhdW5jaCBuZXcgcHJvamVjdHMsIHdoaWxlIGNvbm5lY3RpbmcgdG8gdGhpcyBlY29zeXN0ZW0gb2YgbmV3IG1lZGlhIGluIG9yZGVyIHRvIGZpbmQgbW9yZSBhZ2lsaXR5IGFuZCByZXNpbGllbmNlIGluIHRoZWlyIG1vZGVscy5cdTIwMWQ8L3N0cm9uZz48L2VtPlxyXG48aDM+VW5pdGluZyBhIGNvbW11bml0eTwvaDM+XHJcbk1hdGhpZXUgTWFpcmUgZHUgUG9zZXQgY29uZmlybXMgdGhhdCBvbmUgb2YgbGUgVGFuayBNZWRpYVx1MjAxOXMgYW1iaXRpb25zIGlzIDxzdHJvbmc+dW5pdGluZyBhIGNvbW11bml0eTwvc3Ryb25nPi4gPGVtPlx1MjAxY1dlIHdvcmsgYSBsb3Qgb24gdGhlIHNwaXJpdCBvZiBjcmVhdGluZyBjb25uZWN0aW9uc1x1MjAxZDwvZW0+IGFtb25nIHRoZSBpbmN1YmF0ZWQgbWVkaWEuIDxzdHJvbmc+VGhlIG9sZCBhY3RvcnMgbWVldCB0aGUgbmV3IG9uZXMsIGFuZCBzbyBvbjwvc3Ryb25nPi4gRXZlcnl0aGluZyBpcyBkb25lIHRvIGZhY2lsaXRhdGUgZXhjaGFuZ2VzIGJldHdlZW4gY29tcGFuaWVzIGZyb20gYWxsIHNpZGVzLiBUaGlzIGlzIG1hZGUgcG9zc2libGUgYnkgb25lIHRoZSBncmVhdCByaWNoZXMgb2YgaW5jdWJhdGlvbjogPHN0cm9uZz5kaXZlcnNpdHk8L3N0cm9uZz4uIFRoZSBjb21wYW5pZXMgYXJlIGFsbCBhdCBkaWZmZXJlbnQgc3RhZ2VzIG9mIGRldmVsb3BtZW50LCBjb21pbmcgZnJvbSBkaWZmZXJlbnQgYmFja2dyb3VuZHMsIGFuZCBkbyBub3Qgd29yayBvbiB0aGUgc2FtZSB0aGVtZXMgb3IgbWVkaWEgdG9waWNzLiA8ZW0+XHUyMDFjT25lIG9mIHRoZSB0YXNrcyBmb3IgdXMgaXMgdG8gcHV0IHRoZW0gaW4gY29udGFjdC4gVGhleSBhbGwgaGF2ZSBzb21ldGhpbmcgdG8gbGVhcm4gZnJvbSBlYWNoIG90aGVyXHUyMDFkPC9lbT4uXHJcblxyXG48c3Ryb25nPk9yZ2FuaXNpbmcgZXZlbnRzIGlzIGltcG9ydGFudCB0byBsZSBUYW5rIE1lZGlhIGluIGhlbHBpbmcgdG8gY29uc3RydWN0IHRoaXMgY29tbXVuaXR5IG9mIG1lZGlhIGVudHJlcHJlbmV1cnM8L3N0cm9uZz4uIEx1bmNoZXMgd2l0aCBzcGVha2VycyBhcmUgb3JnYW5pc2VkIGV2ZXJ5IG1vbnRoLiBcdTIwMWM8YSBocmVmPVwiaHR0cHM6Ly9tZWRpdW0uY29tL2xldGFuay1tZWRpYS9zb3VzLWwlQzMlQTljdW1lLWwtJUMzJUE5diVDMyVBOW5lbWVudC1xdWktcGFzc2UtbGVzLW0lQzMlQTlkaWFzLSVDMyVBMC1sYS1sb3VwZS0zN2QzYWI4YmViNzBcIj5Tb3VzIGxcdTIwMTlcdTAwZTljdW1lPC9hPlx1MjAxYyAoXHUyMDFjVW5kZXIgdGhlIGZvYW1cdTIwMWQpLCBhIHF1YXJ0ZXJseSBldmVudCwgdGFrZXMgYW4gaW4tZGVwdGggbG9vayBhdCBhIGNoYW5naW5nIG1lZGlhIHRyZW5kLCBhbmQgXHUyMDFjPGEgaHJlZj1cImh0dHBzOi8vd3d3Lmluc3RhZ3JhbS5jb20vYm91Y2hlX21hZ2F6aW5lL1wiPkhvcml6b24ocyk8L2E+XHUyMDFkLCBhbHNvIG9yZ2FuaXNlZCBxdWFydGVybHksIGxvb2tzIGF0IHByb2Zlc3Npb25zIGFuZCBvcmdhbmlzYXRpb25zIGluIHRoZSBtZWRpYS4gT25jZSBhIHllYXIsIGxlIFRhbmsgTWVkaWEgb3JnYW5pc2VzIGEgbWVldGluZyBkZWRpY2F0ZWQgdG8gZ2V0dGluZyBmZWVkYmFjayBmcm9tIG1lZGlhIGVudHJlcHJlbmV1cnMuXHJcblxyXG5odHRwczovL3R3aXR0ZXIuY29tL2xldGFua21lZGlhL3N0YXR1cy8xMTQ0MjA4MTIxMjUxOTc1MTY4XHJcblxyXG5UaHJvdWdoIGFsbCB0aGVzZSBhY3Rpdml0aWVzLCB0aGUgZ29hbCBpcyB0byA8c3Ryb25nPmNyZWF0ZSBhIGNvbW11bml0eSBvZiBtZWRpYSBlbnRyZXByZW5ldXJzIHRoYXQgd2lsbCBncm93IGZyb20geWVhciB0byB5ZWFyPC9zdHJvbmc+LiBFdmVuIGlmIGFsbCBvZiB0aGUgaW5kaXZpZHVhbCBwcm9qZWN0cyB3aWxsIG5vdCBzdWNjZWVkLCB0aGUgY29tbXVuaXR5IHdpbGwgc3RpbGwgYmUgZXN0YWJsaXNoZWQuIFRoaXMgaXMgd2hhdCBNYXRoaWV1IE1haXJlIGR1IFBvc2V0IHVuZGVybGluZXM6IDxlbT5cdTIwMWN0aGVyZSBhcmUgdGVucyBhbmQgdGVucyBvZiBwZW9wbGUgd2hvIG1lZXQsIG5ldHdvcmssIGhlbHAgZWFjaCBvdGhlciwgd2hvbSB3ZSBnaXZlIG5ldyB3YXlzIG9mIHRoaW5raW5nIGFib3V0IHdvcmssIGFuZCB3aG8gd2lsbCBhcHBseSB0aGUgbmV3bHkgbGVhcm5lZCBza2lsbHMgZWxzZXdoZXJlIGluIHRoZSBzcGhlcmUgb2YgZW1lcmdpbmcgbWVkaWFcdTIwMWQ8L2VtPi5cclxuXHJcblBhcnRpY2lwYW50cyB3aWxsIGFsc28gZ2FpbiBza2lsbHMgdGhhdCB3aWxsIGJlIHVzZWZ1bCBhbmQgdmFsdWVkIGZvciB0aGUgc2VjdG9yIGluIHRoZSBtZWRpdW0tdGVybS4gPGVtPlx1MjAxY0l0IHdpbGwgYmUgYSBwb2ludCBvZiBwcmlkZSBpZiB3ZSBjYW4gc2F5IGluIGEgZmV3IHllYXJzIHRoYXQgd2UgaGF2ZSBmb3N0ZXJlZCB0aGUgYmlydGggb2YgYW4gZWNvc3lzdGVtIGFuZCB3ZSBoYXZlIGhlbHBlZCBhIGxvdCBvZiBwZW9wbGUgdG8gd29yayBkaWZmZXJlbnRseSxcdTIwMWQ8L2VtPiBoZSBhZGRzLiBDb250cmlidXRpbmcgdG8gdGhlIGJpcnRoIG9mIHRoaXMgbmV3IGVjb3N5c3RlbSBpcyBhbHNvIGEgYmV0IG9uIHRoZSBmdXR1cmUuIDxlbT5cdTIwMWNJIHRoaW5rIHRoYXQgaW4gMTAgeWVhcnMsIHRoZSBsaXN0IG9mIGZpdmUgbGFyZ2VzdCBGcmVuY2ggcHVibGlzaGVycyB3aWxsIG5vdCBuZWNlc3NhcmlseSBiZSB0aGUgc2FtZSBhcyB0b2RheVx1MjAxZC48L2VtPlxyXG5cclxuJm5ic3A7XHJcblxyXG48ZW0+KE1haW4gaW1hZ2UgZnJvbSA8YSBocmVmPVwiaHR0cHM6Ly9tZWRpdW0uY29tL2xldGFuay1tZWRpYS9sZS10YW5rLW1lZGlhLXVuLTFlci1hdGVsaWVyLXBvdXItbGFuY2VyLWxhLWNvLWNvbnN0cnVjdGlvbi1mOWJkNmU4NTM1NmJcIj5NZWRpdW08L2E+KTwvZW0+Wy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS80XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddIiwicG9zdF90aXRsZSI6IkxlIFRhbmsgTWVkaWE6IHN0aW11bGF0b3Igb2YgbWVkaWEgZW50cmVwcmVuZXVyc2hpcCIsInBvc3RfbGluayI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9sZS10YW5rLW1lZGlhLXN0aW11bGF0b3Itb2YtbWVkaWEtZW50cmVwcmVuZXVyc2hpcC8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJMZSBUYW5rIE1lZGlhOiBzdGltdWxhdG9yIG9mIG1lZGlhIGVudHJlcHJlbmV1cnNoaXBcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjIwMFwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE5LzA3LzFfcmhpeUJmNm1qNFZYOWoyVzBoY3BOUUAyeC0zMDB4MjAwLmpwZWdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj4iLCJwb3N0X2NhdGVnb3JpZXMiOiJNZWRpYSBsYWJzIiwicG9zdF90YWdzIjoiIiwiJV9lZGl0X2xvY2slIjoiMTU3MDEyMTQ2MTo5MzEiLCIlX2VkaXRfbGFzdCUiOiI5MzEiLCIlX29lbWJlZF80NmZhNzM1M2M1YjBkMTM5MzlmM2NiNDQ1ZjA5MDdlYiUiOiI8YmxvY2txdW90ZSBjbGFzcz1cInR3aXR0ZXItdHdlZXRcIiBkYXRhLXdpZHRoPVwiNTUwXCIgZGF0YS1kbnQ9XCJ0cnVlXCI+PHAgbGFuZz1cImZyXCIgZGlyPVwibHRyXCI+QXVqb3VyZCYjMzk7aHVpLCBvbiB2b3VzIHByXHUwMGU5c2VudGUgSG9yaXpvbihzKSwgbm90cmUgXHUwMGU5dlx1MDBlOW5lbWVudCBwb3VyIGludGVycm9nZXIgZXQgY29tcHJlbmRyZSBsZXMgaW1wYWN0cyBkZSBsXHUyMDE5aW5ub3ZhdGlvbiBldCBkdSBudW1cdTAwZTlyaXF1ZSBzdXIgbm9zIG1cdTAwZTl0aWVycyBldCBub3Mgb3JnYW5pc2F0aW9ucy4gPyA8YSBocmVmPVwiaHR0cHM6Ly90LmNvL1EyTVp1S2hVeWpcIj5odHRwczovL3QuY28vUTJNWnVLaFV5ajwvYT48L3A+Jm1kYXNoOyBMZSBUYW5rIG1lZGlhIChAbGV0YW5rbWVkaWEpIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2xldGFua21lZGlhL3N0YXR1cy8xMTQ0MjA4MTIxMjUxOTc1MTY4P3JlZl9zcmM9dHdzcmMlNUV0ZndcIj5KdW5lIDI3LCAyMDE5PC9hPjwvYmxvY2txdW90ZT48c2NyaXB0IGFzeW5jIHNyYz1cImh0dHBzOi8vcGxhdGZvcm0udHdpdHRlci5jb20vd2lkZ2V0cy5qc1wiIGNoYXJzZXQ9XCJ1dGYtOFwiPjwvc2NyaXB0PiIsIiVfb2VtYmVkX3RpbWVfNDZmYTczNTNjNWIwZDEzOTM5ZjNjYjQ0NWYwOTA3ZWIlIjoiMTU2NDU5NTQzOCIsIiVfb2VtYmVkXzQ0YjZkMzU4YzM0MTcxNjUzM2FmYzMzMzA2M2YyOTc2JSI6IjxibG9ja3F1b3RlIGNsYXNzPVwidHdpdHRlci10d2VldFwiIGRhdGEtd2lkdGg9XCI1NTBcIiBkYXRhLWRudD1cInRydWVcIj48cCBsYW5nPVwiZnJcIiBkaXI9XCJsdHJcIj4xIDcwMG0yIGF1IGNcdTAxNTN1ciBkdSAxMWVtZSBcdTAwZTAgUGFyaXMgcG91ciBmYXZvcmlzZXIgbFx1MjAxOVx1MDBlOW1lcmdlbmNlIGRcdTIwMTl1biBub3V2ZWwgZW50cmVwcmVuZXVyaWF0IGRhbnMgbGVzIG1cdTAwZTlkaWFzLiBFc3BhY2UgXHUwMGU5dlx1MDBlOW5lbWVudGllbCwgc3R1ZGlvcyBhdWRpbyBldCB2aWRcdTAwZTlvcywgMTcwIHBvc3RlcyBkZSB0cmF2YWlsLCAxIHJvb2Z0b3Agdlx1MDBlOWdcdTAwZTl0YWxpc1x1MDBlOS4uLjwvcD4mbWRhc2g7IExlIFRhbmsgbWVkaWEgKEBsZXRhbmttZWRpYSkgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vbGV0YW5rbWVkaWEvc3RhdHVzLzExNDcwMjcxNDg1NzE2MzE2MTY/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkp1bHkgNSwgMjAxOTwvYT48L2Jsb2NrcXVvdGU+PHNjcmlwdCBhc3luYyBzcmM9XCJodHRwczovL3BsYXRmb3JtLnR3aXR0ZXIuY29tL3dpZGdldHMuanNcIiBjaGFyc2V0PVwidXRmLThcIj48L3NjcmlwdD4iLCIlX29lbWJlZF90aW1lXzQ0YjZkMzU4YzM0MTcxNjUzM2FmYzMzMzA2M2YyOTc2JSI6IjE1NjQ1OTU0MzgiLCIlX29lbWJlZF9jYTJkYTUwZGM5NDdhZDFkMjZlMjhlMTlmZDFmZTA5YyUiOiI8YmxvY2txdW90ZSBjbGFzcz1cInR3aXR0ZXItdHdlZXRcIiBkYXRhLXdpZHRoPVwiNTUwXCIgZGF0YS1kbnQ9XCJ0cnVlXCI+PHAgbGFuZz1cImZyXCIgZGlyPVwibHRyXCI+XHUwMGFiXHUwMGEwQXUgVGFuayBtZWRpYSwgalx1MjAxOWFpIGFwcHJpcyBcdTAwZTAgY29tcHJlbmRyZSBxdWVscyBcdTAwZTl0YWllbnQgbGVzIHBvaW50cyBmb3J0cyBldCBtZXMgcG9pbnRzIGZhaWJsZXMgcG91ciBhcHByZW5kcmUgXHUwMGUwIHRyYXZhaWxsZXIgZGUgZmFcdTAwZTdvbiBwbHVzIHByYWdtYXRpcXVlLlx1MDBhMFx1MDBiYiA8YSBocmVmPVwiaHR0cHM6Ly90LmNvL0Q0bXQyQm9EMXdcIj5waWMudHdpdHRlci5jb20vRDRtdDJCb0QxdzwvYT48L3A+Jm1kYXNoOyBMZSBUYW5rIG1lZGlhIChAbGV0YW5rbWVkaWEpIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2xldGFua21lZGlhL3N0YXR1cy8xMTQ0MTU3ODI5MTU2Mjk4NzUzP3JlZl9zcmM9dHdzcmMlNUV0ZndcIj5KdW5lIDI3LCAyMDE5PC9hPjwvYmxvY2txdW90ZT48c2NyaXB0IGFzeW5jIHNyYz1cImh0dHBzOi8vcGxhdGZvcm0udHdpdHRlci5jb20vd2lkZ2V0cy5qc1wiIGNoYXJzZXQ9XCJ1dGYtOFwiPjwvc2NyaXB0PiIsIiVfb2VtYmVkX3RpbWVfY2EyZGE1MGRjOTQ3YWQxZDI2ZTI4ZTE5ZmQxZmUwOWMlIjoiMTU2NDU5NTQzOCIsIiVzbGlkZV90ZW1wbGF0ZSUiOiJkZWZhdWx0IiwiJV93cGJfdmNfanNfc3RhdHVzJSI6InRydWUiLCIlX3dwZ21wX2xvY2F0aW9uX2FkZHJlc3MlIjoiMjJCIFJ1ZSBkZXMgVGFpbGxhbmRpZXJzLCA3NTAxMSBQYXJpcywgRnJhbmNlIiwiJV93cGdtcF9sb2NhdGlvbl9jaXR5JSI6IlBhcmlzIiwiJV93cGdtcF9sb2NhdGlvbl9zdGF0ZSUiOiJcdTAwY2VsZS1kZS1GcmFuY2UiLCIlX3dwZ21wX2xvY2F0aW9uX2NvdW50cnklIjoiRnJhbmNlIiwiJV93cGdtcF9tZXRhYm94X2xhdGl0dWRlJSI6IjQ4Ljg1NTE5OTEwMDAwMDAxIiwiJV93cGdtcF9tZXRhYm94X2xvbmdpdHVkZSUiOiIyLjM3NDk0NzM5OTk5OTk5NjQiLCIlX3dwZ21wX21ldGFib3hfbG9jYXRpb25fcmVkaXJlY3QlIjoibWFya2VyIiwiJV93cGdtcF9tZXRhYm94X2N1c3RvbV9saW5rJSI6IiIsIiVfd3BnbXBfbWFwX2lkJSI6ImE6MTp7aTowO3M6MTpcIjJcIjt9IiwiJV93cGdtcF9tZXRhYm94X21hcmtlcl9pZCUiOiJOOyIsIiVfd3BnbXBfbWV0YWJveF90YXhvbW9taWVzX3Rlcm1zJSI6Ik47IiwiJV93cGdtcF9leHRlbnNpb25zX2ZpZWxkcyUiOiJOOyIsIiVfa2xlb190cmFuc3BhcmVudF9tZW51X2NvbG9yJSI6IndoaXRlIiwiJV9rbGVvX3RpdGxlX2NvbG9yJSI6IiMiLCIlX2tsZW9fdGl0bGVfYmclIjoiLCByZXBlYXQsIGluaGVyaXQsIHNjcm9sbCwgbGVmdCB0b3AiLCIlX2tsZW9fdGl0bGVfYmdfY29sb3IlIjoiIyIsIiVfeW9hc3Rfd3BzZW9fY29udGVudF9zY29yZSUiOiIzMCIsIiVfb2VtYmVkX2M5ZGJmZDk5YmM3Yjg0MmE0ZGVkNDQ5YTc0ZWE0ODdiJSI6IjxibG9ja3F1b3RlIGNsYXNzPVwidHdpdHRlci10d2VldFwiIGRhdGEtd2lkdGg9XCI1NTBcIiBkYXRhLWRudD1cInRydWVcIj48cCBsYW5nPVwiZnJcIiBkaXI9XCJsdHJcIj5cdTAwYWJcdTAwYTBBdSBUYW5rIG1lZGlhLCBqXHUyMDE5YWkgYXBwcmlzIFx1MDBlMCBjb21wcmVuZHJlIHF1ZWxzIFx1MDBlOXRhaWVudCBsZXMgcG9pbnRzIGZvcnRzIGV0IG1lcyBwb2ludHMgZmFpYmxlcyBwb3VyIGFwcHJlbmRyZSBcdTAwZTAgdHJhdmFpbGxlciBkZSBmYVx1MDBlN29uIHBsdXMgcHJhZ21hdGlxdWUuXHUwMGEwXHUwMGJiIDxhIGhyZWY9XCJodHRwczovL3QuY28vRDRtdDJCb0Qxd1wiPnBpYy50d2l0dGVyLmNvbS9ENG10MkJvRDF3PC9hPjwvcD4mbWRhc2g7IExlIFRhbmsgbWVkaWEgKEBsZXRhbmttZWRpYSkgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vbGV0YW5rbWVkaWEvc3RhdHVzLzExNDQxNTc4MjkxNTYyOTg3NTM/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkp1bmUgMjcsIDIwMTk8L2E+PC9ibG9ja3F1b3RlPjxzY3JpcHQgYXN5bmMgc3JjPVwiaHR0cHM6Ly9wbGF0Zm9ybS50d2l0dGVyLmNvbS93aWRnZXRzLmpzXCIgY2hhcnNldD1cInV0Zi04XCI+PC9zY3JpcHQ+IiwiJV9vZW1iZWRfdGltZV9jOWRiZmQ5OWJjN2I4NDJhNGRlZDQ0OWE3NGVhNDg3YiUiOiIxNTcwMTE0MDYxIiwiJV9vZW1iZWRfZDU5NmY2MGM5MjIwZDkxM2NiNTg1OGE4MzEwZjIyYWMlIjoiPGJsb2NrcXVvdGUgY2xhc3M9XCJ0d2l0dGVyLXR3ZWV0XCIgZGF0YS13aWR0aD1cIjU1MFwiIGRhdGEtZG50PVwidHJ1ZVwiPjxwIGxhbmc9XCJmclwiIGRpcj1cImx0clwiPjEgNzAwbTIgYXUgY1x1MDE1M3VyIGR1IDExZW1lIFx1MDBlMCBQYXJpcyBwb3VyIGZhdm9yaXNlciBsXHUyMDE5XHUwMGU5bWVyZ2VuY2UgZFx1MjAxOXVuIG5vdXZlbCBlbnRyZXByZW5ldXJpYXQgZGFucyBsZXMgbVx1MDBlOWRpYXMuIEVzcGFjZSBcdTAwZTl2XHUwMGU5bmVtZW50aWVsLCBzdHVkaW9zIGF1ZGlvIGV0IHZpZFx1MDBlOW9zLCAxNzAgcG9zdGVzIGRlIHRyYXZhaWwsIDEgcm9vZnRvcCB2XHUwMGU5Z1x1MDBlOXRhbGlzXHUwMGU5Li4uPC9wPiZtZGFzaDsgTGUgVGFuayBtZWRpYSAoQGxldGFua21lZGlhKSA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9sZXRhbmttZWRpYS9zdGF0dXMvMTE0NzAyNzE0ODU3MTYzMTYxNj9yZWZfc3JjPXR3c3JjJTVFdGZ3XCI+SnVseSA1LCAyMDE5PC9hPjwvYmxvY2txdW90ZT48c2NyaXB0IGFzeW5jIHNyYz1cImh0dHBzOi8vcGxhdGZvcm0udHdpdHRlci5jb20vd2lkZ2V0cy5qc1wiIGNoYXJzZXQ9XCJ1dGYtOFwiPjwvc2NyaXB0PiIsIiVfb2VtYmVkX3RpbWVfZDU5NmY2MGM5MjIwZDkxM2NiNTg1OGE4MzEwZjIyYWMlIjoiMTU3MDExNDA2MSIsIiVfb2VtYmVkXzFlYzM2N2U5NmE4MWNkNjNkYjk2YTk5MGYyODRlMTQwJSI6IjxibG9ja3F1b3RlIGNsYXNzPVwidHdpdHRlci10d2VldFwiIGRhdGEtd2lkdGg9XCI1NTBcIiBkYXRhLWRudD1cInRydWVcIj48cCBsYW5nPVwiZnJcIiBkaXI9XCJsdHJcIj5BdWpvdXJkJiMzOTtodWksIG9uIHZvdXMgcHJcdTAwZTlzZW50ZSBIb3Jpem9uKHMpLCBub3RyZSBcdTAwZTl2XHUwMGU5bmVtZW50IHBvdXIgaW50ZXJyb2dlciBldCBjb21wcmVuZHJlIGxlcyBpbXBhY3RzIGRlIGxcdTIwMTlpbm5vdmF0aW9uIGV0IGR1IG51bVx1MDBlOXJpcXVlIHN1ciBub3MgbVx1MDBlOXRpZXJzIGV0IG5vcyBvcmdhbmlzYXRpb25zLiA/IDxhIGhyZWY9XCJodHRwczovL3QuY28vUTJNWnVLaFV5alwiPmh0dHBzOi8vdC5jby9RMk1adUtoVXlqPC9hPjwvcD4mbWRhc2g7IExlIFRhbmsgbWVkaWEgKEBsZXRhbmttZWRpYSkgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vbGV0YW5rbWVkaWEvc3RhdHVzLzExNDQyMDgxMjEyNTE5NzUxNjg/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkp1bmUgMjcsIDIwMTk8L2E+PC9ibG9ja3F1b3RlPjxzY3JpcHQgYXN5bmMgc3JjPVwiaHR0cHM6Ly9wbGF0Zm9ybS50d2l0dGVyLmNvbS93aWRnZXRzLmpzXCIgY2hhcnNldD1cInV0Zi04XCI+PC9zY3JpcHQ+IiwiJV9vZW1iZWRfdGltZV8xZWMzNjdlOTZhODFjZDYzZGI5NmE5OTBmMjg0ZTE0MCUiOiIxNTcwMTE0MDYxIiwiJV95b2FzdF93cHNlb19wcmltYXJ5X2NhdGVnb3J5JSI6IjE0MiIsIiVfb2VtYmVkXzYyYThhMTMwZjMwZmNhM2E4OWUwYjQxZThlZTBjZjcwJSI6IjxibG9ja3F1b3RlIGNsYXNzPVwidHdpdHRlci10d2VldFwiIGRhdGEtd2lkdGg9XCI0NzVcIiBkYXRhLWRudD1cInRydWVcIj48cCBsYW5nPVwiZnJcIiBkaXI9XCJsdHJcIj5cdTAwYWJcdTAwYTBBdSBUYW5rIG1lZGlhLCBqXHUyMDE5YWkgYXBwcmlzIFx1MDBlMCBjb21wcmVuZHJlIHF1ZWxzIFx1MDBlOXRhaWVudCBsZXMgcG9pbnRzIGZvcnRzIGV0IG1lcyBwb2ludHMgZmFpYmxlcyBwb3VyIGFwcHJlbmRyZSBcdTAwZTAgdHJhdmFpbGxlciBkZSBmYVx1MDBlN29uIHBsdXMgcHJhZ21hdGlxdWUuXHUwMGEwXHUwMGJiIDxhIGhyZWY9XCJodHRwczovL3QuY28vRDRtdDJCb0Qxd1wiPnBpYy50d2l0dGVyLmNvbS9ENG10MkJvRDF3PC9hPjwvcD4mbWRhc2g7IExlIFRhbmsgbWVkaWEgKEBsZXRhbmttZWRpYSkgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vbGV0YW5rbWVkaWEvc3RhdHVzLzExNDQxNTc4MjkxNTYyOTg3NTM/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkp1bmUgMjcsIDIwMTk8L2E+PC9ibG9ja3F1b3RlPjxzY3JpcHQgYXN5bmMgc3JjPVwiaHR0cHM6Ly9wbGF0Zm9ybS50d2l0dGVyLmNvbS93aWRnZXRzLmpzXCIgY2hhcnNldD1cInV0Zi04XCI+PC9zY3JpcHQ+IiwiJV9vZW1iZWRfdGltZV82MmE4YTEzMGYzMGZjYTNhODllMGI0MWU4ZWUwY2Y3MCUiOiIxNTY0NTk2MTIxIiwiJV9vZW1iZWRfNDZlMGM5MjA2YWZiN2Y5MGM4Y2UwNDg4YjNlNWU5M2MlIjoiPGJsb2NrcXVvdGUgY2xhc3M9XCJ0d2l0dGVyLXR3ZWV0XCIgZGF0YS13aWR0aD1cIjQ3NVwiIGRhdGEtZG50PVwidHJ1ZVwiPjxwIGxhbmc9XCJmclwiIGRpcj1cImx0clwiPkF1am91cmQmIzM5O2h1aSwgb24gdm91cyBwclx1MDBlOXNlbnRlIEhvcml6b24ocyksIG5vdHJlIFx1MDBlOXZcdTAwZTluZW1lbnQgcG91ciBpbnRlcnJvZ2VyIGV0IGNvbXByZW5kcmUgbGVzIGltcGFjdHMgZGUgbFx1MjAxOWlubm92YXRpb24gZXQgZHUgbnVtXHUwMGU5cmlxdWUgc3VyIG5vcyBtXHUwMGU5dGllcnMgZXQgbm9zIG9yZ2FuaXNhdGlvbnMuID8gPGEgaHJlZj1cImh0dHBzOi8vdC5jby9RMk1adUtoVXlqXCI+aHR0cHM6Ly90LmNvL1EyTVp1S2hVeWo8L2E+PC9wPiZtZGFzaDsgTGUgVGFuayBtZWRpYSAoQGxldGFua21lZGlhKSA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9sZXRhbmttZWRpYS9zdGF0dXMvMTE0NDIwODEyMTI1MTk3NTE2OD9yZWZfc3JjPXR3c3JjJTVFdGZ3XCI+SnVuZSAyNywgMjAxOTwvYT48L2Jsb2NrcXVvdGU+PHNjcmlwdCBhc3luYyBzcmM9XCJodHRwczovL3BsYXRmb3JtLnR3aXR0ZXIuY29tL3dpZGdldHMuanNcIiBjaGFyc2V0PVwidXRmLThcIj48L3NjcmlwdD4iLCIlX29lbWJlZF90aW1lXzQ2ZTBjOTIwNmFmYjdmOTBjOGNlMDQ4OGIzZTVlOTNjJSI6IjE1NjQ1OTYxMjEiLCIlX29lbWJlZF80MGMzMzJjODI2Yjk2NzViZDdiNzNiNDBmYjQyZTAyMCUiOiI8YmxvY2txdW90ZSBjbGFzcz1cInR3aXR0ZXItdHdlZXRcIiBkYXRhLXdpZHRoPVwiNDc1XCIgZGF0YS1kbnQ9XCJ0cnVlXCI+PHAgbGFuZz1cImZyXCIgZGlyPVwibHRyXCI+MSA3MDBtMiBhdSBjXHUwMTUzdXIgZHUgMTFlbWUgXHUwMGUwIFBhcmlzIHBvdXIgZmF2b3Jpc2VyIGxcdTIwMTlcdTAwZTltZXJnZW5jZSBkXHUyMDE5dW4gbm91dmVsIGVudHJlcHJlbmV1cmlhdCBkYW5zIGxlcyBtXHUwMGU5ZGlhcy4gRXNwYWNlIFx1MDBlOXZcdTAwZTluZW1lbnRpZWwsIHN0dWRpb3MgYXVkaW8gZXQgdmlkXHUwMGU5b3MsIDE3MCBwb3N0ZXMgZGUgdHJhdmFpbCwgMSByb29mdG9wIHZcdTAwZTlnXHUwMGU5dGFsaXNcdTAwZTkuLi48L3A+Jm1kYXNoOyBMZSBUYW5rIG1lZGlhIChAbGV0YW5rbWVkaWEpIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2xldGFua21lZGlhL3N0YXR1cy8xMTQ3MDI3MTQ4NTcxNjMxNjE2P3JlZl9zcmM9dHdzcmMlNUV0ZndcIj5KdWx5IDUsIDIwMTk8L2E+PC9ibG9ja3F1b3RlPjxzY3JpcHQgYXN5bmMgc3JjPVwiaHR0cHM6Ly9wbGF0Zm9ybS50d2l0dGVyLmNvbS93aWRnZXRzLmpzXCIgY2hhcnNldD1cInV0Zi04XCI+PC9zY3JpcHQ+IiwiJV9vZW1iZWRfdGltZV80MGMzMzJjODI2Yjk2NzViZDdiNzNiNDBmYjQyZTAyMCUiOiIxNTY0NTk2MTIxIiwiJV90aHVtYm5haWxfaWQlIjoiMTUxOTIiLCIlX2tsZW9fdGl0bGVfY2hlY2tib3glIjoiMSIsIiVfb2VtYmVkXzZkOWNlZDRlMTZhMmE5M2U4YjMyZjU0ZmZmYjczMTJhJSI6IjxibG9ja3F1b3RlIGNsYXNzPVwidHdpdHRlci10d2VldFwiIGRhdGEtd2lkdGg9XCI0NzdcIiBkYXRhLWRudD1cInRydWVcIj48cCBsYW5nPVwiZnJcIiBkaXI9XCJsdHJcIj5cdTAwYWJcdTAwYTBBdSBUYW5rIG1lZGlhLCBqXHUyMDE5YWkgYXBwcmlzIFx1MDBlMCBjb21wcmVuZHJlIHF1ZWxzIFx1MDBlOXRhaWVudCBsZXMgcG9pbnRzIGZvcnRzIGV0IG1lcyBwb2ludHMgZmFpYmxlcyBwb3VyIGFwcHJlbmRyZSBcdTAwZTAgdHJhdmFpbGxlciBkZSBmYVx1MDBlN29uIHBsdXMgcHJhZ21hdGlxdWUuXHUwMGEwXHUwMGJiIDxhIGhyZWY9XCJodHRwczovL3QuY28vRDRtdDJCb0Qxd1wiPnBpYy50d2l0dGVyLmNvbS9ENG10MkJvRDF3PC9hPjwvcD4mbWRhc2g7IExlIFRhbmsgbWVkaWEgKEBsZXRhbmttZWRpYSkgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vbGV0YW5rbWVkaWEvc3RhdHVzLzExNDQxNTc4MjkxNTYyOTg3NTM/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkp1bmUgMjcsIDIwMTk8L2E+PC9ibG9ja3F1b3RlPjxzY3JpcHQgYXN5bmMgc3JjPVwiaHR0cHM6Ly9wbGF0Zm9ybS50d2l0dGVyLmNvbS93aWRnZXRzLmpzXCIgY2hhcnNldD1cInV0Zi04XCI+PC9zY3JpcHQ+IiwiJV9vZW1iZWRfdGltZV82ZDljZWQ0ZTE2YTJhOTNlOGIzMmY1NGZmZmI3MzEyYSUiOiIxNTY0NTk2Mzk1IiwiJV9vZW1iZWRfNmQ0NTliN2YxMjFlMWY0YTc0YzUzMmQ0NzgzNWZiYmYlIjoiPGJsb2NrcXVvdGUgY2xhc3M9XCJ0d2l0dGVyLXR3ZWV0XCIgZGF0YS13aWR0aD1cIjQ3N1wiIGRhdGEtZG50PVwidHJ1ZVwiPjxwIGxhbmc9XCJmclwiIGRpcj1cImx0clwiPjEgNzAwbTIgYXUgY1x1MDE1M3VyIGR1IDExZW1lIFx1MDBlMCBQYXJpcyBwb3VyIGZhdm9yaXNlciBsXHUyMDE5XHUwMGU5bWVyZ2VuY2UgZFx1MjAxOXVuIG5vdXZlbCBlbnRyZXByZW5ldXJpYXQgZGFucyBsZXMgbVx1MDBlOWRpYXMuIEVzcGFjZSBcdTAwZTl2XHUwMGU5bmVtZW50aWVsLCBzdHVkaW9zIGF1ZGlvIGV0IHZpZFx1MDBlOW9zLCAxNzAgcG9zdGVzIGRlIHRyYXZhaWwsIDEgcm9vZnRvcCB2XHUwMGU5Z1x1MDBlOXRhbGlzXHUwMGU5Li4uPC9wPiZtZGFzaDsgTGUgVGFuayBtZWRpYSAoQGxldGFua21lZGlhKSA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9sZXRhbmttZWRpYS9zdGF0dXMvMTE0NzAyNzE0ODU3MTYzMTYxNj9yZWZfc3JjPXR3c3JjJTVFdGZ3XCI+SnVseSA1LCAyMDE5PC9hPjwvYmxvY2txdW90ZT48c2NyaXB0IGFzeW5jIHNyYz1cImh0dHBzOi8vcGxhdGZvcm0udHdpdHRlci5jb20vd2lkZ2V0cy5qc1wiIGNoYXJzZXQ9XCJ1dGYtOFwiPjwvc2NyaXB0PiIsIiVfb2VtYmVkX3RpbWVfNmQ0NTliN2YxMjFlMWY0YTc0YzUzMmQ0NzgzNWZiYmYlIjoiMTU2NDU5NjM5NSIsIiVfb2VtYmVkX2I3NmM0NWRlMmEwM2RlMzRmYjIwNTJiMDhkYmM5YTA3JSI6IjxibG9ja3F1b3RlIGNsYXNzPVwidHdpdHRlci10d2VldFwiIGRhdGEtd2lkdGg9XCI0NzdcIiBkYXRhLWRudD1cInRydWVcIj48cCBsYW5nPVwiZnJcIiBkaXI9XCJsdHJcIj5BdWpvdXJkJiMzOTtodWksIG9uIHZvdXMgcHJcdTAwZTlzZW50ZSBIb3Jpem9uKHMpLCBub3RyZSBcdTAwZTl2XHUwMGU5bmVtZW50IHBvdXIgaW50ZXJyb2dlciBldCBjb21wcmVuZHJlIGxlcyBpbXBhY3RzIGRlIGxcdTIwMTlpbm5vdmF0aW9uIGV0IGR1IG51bVx1MDBlOXJpcXVlIHN1ciBub3MgbVx1MDBlOXRpZXJzIGV0IG5vcyBvcmdhbmlzYXRpb25zLiA/IDxhIGhyZWY9XCJodHRwczovL3QuY28vUTJNWnVLaFV5alwiPmh0dHBzOi8vdC5jby9RMk1adUtoVXlqPC9hPjwvcD4mbWRhc2g7IExlIFRhbmsgbWVkaWEgKEBsZXRhbmttZWRpYSkgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vbGV0YW5rbWVkaWEvc3RhdHVzLzExNDQyMDgxMjEyNTE5NzUxNjg/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkp1bmUgMjcsIDIwMTk8L2E+PC9ibG9ja3F1b3RlPjxzY3JpcHQgYXN5bmMgc3JjPVwiaHR0cHM6Ly9wbGF0Zm9ybS50d2l0dGVyLmNvbS93aWRnZXRzLmpzXCIgY2hhcnNldD1cInV0Zi04XCI+PC9zY3JpcHQ+IiwiJV9vZW1iZWRfdGltZV9iNzZjNDVkZTJhMDNkZTM0ZmIyMDUyYjA4ZGJjOWEwNyUiOiIxNTY0NTk2Mzk1IiwiJV9vZW1iZWRfMTkyMGZjNTA0YWI4OGFkMmIzYWViNGRkMTIxNGE4ZjAlIjoiPGJsb2NrcXVvdGUgY2xhc3M9XCJ0d2l0dGVyLXR3ZWV0XCIgZGF0YS13aWR0aD1cIjQ3NlwiIGRhdGEtZG50PVwidHJ1ZVwiPjxwIGxhbmc9XCJmclwiIGRpcj1cImx0clwiPlx1MDBhYlx1MDBhMEF1IFRhbmsgbWVkaWEsIGpcdTIwMTlhaSBhcHByaXMgXHUwMGUwIGNvbXByZW5kcmUgcXVlbHMgXHUwMGU5dGFpZW50IGxlcyBwb2ludHMgZm9ydHMgZXQgbWVzIHBvaW50cyBmYWlibGVzIHBvdXIgYXBwcmVuZHJlIFx1MDBlMCB0cmF2YWlsbGVyIGRlIGZhXHUwMGU3b24gcGx1cyBwcmFnbWF0aXF1ZS5cdTAwYTBcdTAwYmIgPGEgaHJlZj1cImh0dHBzOi8vdC5jby9ENG10MkJvRDF3XCI+cGljLnR3aXR0ZXIuY29tL0Q0bXQyQm9EMXc8L2E+PC9wPiZtZGFzaDsgTGUgVGFuayBtZWRpYSAoQGxldGFua21lZGlhKSA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9sZXRhbmttZWRpYS9zdGF0dXMvMTE0NDE1NzgyOTE1NjI5ODc1Mz9yZWZfc3JjPXR3c3JjJTVFdGZ3XCI+SnVuZSAyNywgMjAxOTwvYT48L2Jsb2NrcXVvdGU+PHNjcmlwdCBhc3luYyBzcmM9XCJodHRwczovL3BsYXRmb3JtLnR3aXR0ZXIuY29tL3dpZGdldHMuanNcIiBjaGFyc2V0PVwidXRmLThcIj48L3NjcmlwdD4iLCIlX29lbWJlZF80YTRkMjU5MzExMzU2MzljMzI0NjViNDVkM2UxYWRiOCUiOiI8YmxvY2txdW90ZSBjbGFzcz1cInR3aXR0ZXItdHdlZXRcIiBkYXRhLXdpZHRoPVwiNDc2XCIgZGF0YS1kbnQ9XCJ0cnVlXCI+PHAgbGFuZz1cImZyXCIgZGlyPVwibHRyXCI+QXVqb3VyZCYjMzk7aHVpLCBvbiB2b3VzIHByXHUwMGU5c2VudGUgSG9yaXpvbihzKSwgbm90cmUgXHUwMGU5dlx1MDBlOW5lbWVudCBwb3VyIGludGVycm9nZXIgZXQgY29tcHJlbmRyZSBsZXMgaW1wYWN0cyBkZSBsXHUyMDE5aW5ub3ZhdGlvbiBldCBkdSBudW1cdTAwZTlyaXF1ZSBzdXIgbm9zIG1cdTAwZTl0aWVycyBldCBub3Mgb3JnYW5pc2F0aW9ucy4gPyA8YSBocmVmPVwiaHR0cHM6Ly90LmNvL1EyTVp1S2hVeWpcIj5odHRwczovL3QuY28vUTJNWnVLaFV5ajwvYT48L3A+Jm1kYXNoOyBMZSBUYW5rIG1lZGlhIChAbGV0YW5rbWVkaWEpIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2xldGFua21lZGlhL3N0YXR1cy8xMTQ0MjA4MTIxMjUxOTc1MTY4P3JlZl9zcmM9dHdzcmMlNUV0ZndcIj5KdW5lIDI3LCAyMDE5PC9hPjwvYmxvY2txdW90ZT48c2NyaXB0IGFzeW5jIHNyYz1cImh0dHBzOi8vcGxhdGZvcm0udHdpdHRlci5jb20vd2lkZ2V0cy5qc1wiIGNoYXJzZXQ9XCJ1dGYtOFwiPjwvc2NyaXB0PiIsIiVfb2VtYmVkX3RpbWVfMTkyMGZjNTA0YWI4OGFkMmIzYWViNGRkMTIxNGE4ZjAlIjoiMTU2NDU5NjQ2NSIsIiVfb2VtYmVkX3RpbWVfNGE0ZDI1OTMxMTM1NjM5YzMyNDY1YjQ1ZDNlMWFkYjglIjoiMTU2NDU5NjQ2NSIsIiVfb2VtYmVkX2QyNGE5ZWViMTVkN2ZiNDgwMDM2NGMwMDJkNGNlNWNlJSI6IjxibG9ja3F1b3RlIGNsYXNzPVwidHdpdHRlci10d2VldFwiIGRhdGEtd2lkdGg9XCI0NzZcIiBkYXRhLWRudD1cInRydWVcIj48cCBsYW5nPVwiZnJcIiBkaXI9XCJsdHJcIj4xIDcwMG0yIGF1IGNcdTAxNTN1ciBkdSAxMWVtZSBcdTAwZTAgUGFyaXMgcG91ciBmYXZvcmlzZXIgbFx1MjAxOVx1MDBlOW1lcmdlbmNlIGRcdTIwMTl1biBub3V2ZWwgZW50cmVwcmVuZXVyaWF0IGRhbnMgbGVzIG1cdTAwZTlkaWFzLiBFc3BhY2UgXHUwMGU5dlx1MDBlOW5lbWVudGllbCwgc3R1ZGlvcyBhdWRpbyBldCB2aWRcdTAwZTlvcywgMTcwIHBvc3RlcyBkZSB0cmF2YWlsLCAxIHJvb2Z0b3Agdlx1MDBlOWdcdTAwZTl0YWxpc1x1MDBlOS4uLjwvcD4mbWRhc2g7IExlIFRhbmsgbWVkaWEgKEBsZXRhbmttZWRpYSkgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vbGV0YW5rbWVkaWEvc3RhdHVzLzExNDcwMjcxNDg1NzE2MzE2MTY/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkp1bHkgNSwgMjAxOTwvYT48L2Jsb2NrcXVvdGU+PHNjcmlwdCBhc3luYyBzcmM9XCJodHRwczovL3BsYXRmb3JtLnR3aXR0ZXIuY29tL3dpZGdldHMuanNcIiBjaGFyc2V0PVwidXRmLThcIj48L3NjcmlwdD4iLCIlX29lbWJlZF90aW1lX2QyNGE5ZWViMTVkN2ZiNDgwMDM2NGMwMDJkNGNlNWNlJSI6IjE1NjQ1OTY0NjYiLCIlX29lbWJlZF81MTY2YWUyNzM0YzAzOGQxMmMwMzk2OTExYmYxMDc3MCUiOiI8YmxvY2txdW90ZSBjbGFzcz1cInR3aXR0ZXItdHdlZXRcIiBkYXRhLXdpZHRoPVwiNDczXCIgZGF0YS1kbnQ9XCJ0cnVlXCI+PHAgbGFuZz1cImZyXCIgZGlyPVwibHRyXCI+MSA3MDBtMiBhdSBjXHUwMTUzdXIgZHUgMTFlbWUgXHUwMGUwIFBhcmlzIHBvdXIgZmF2b3Jpc2VyIGxcdTIwMTlcdTAwZTltZXJnZW5jZSBkXHUyMDE5dW4gbm91dmVsIGVudHJlcHJlbmV1cmlhdCBkYW5zIGxlcyBtXHUwMGU5ZGlhcy4gRXNwYWNlIFx1MDBlOXZcdTAwZTluZW1lbnRpZWwsIHN0dWRpb3MgYXVkaW8gZXQgdmlkXHUwMGU5b3MsIDE3MCBwb3N0ZXMgZGUgdHJhdmFpbCwgMSByb29mdG9wIHZcdTAwZTlnXHUwMGU5dGFsaXNcdTAwZTkuLi48L3A+Jm1kYXNoOyBMZSBUYW5rIG1lZGlhIChAbGV0YW5rbWVkaWEpIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2xldGFua21lZGlhL3N0YXR1cy8xMTQ3MDI3MTQ4NTcxNjMxNjE2P3JlZl9zcmM9dHdzcmMlNUV0ZndcIj5KdWx5IDUsIDIwMTk8L2E+PC9ibG9ja3F1b3RlPjxzY3JpcHQgYXN5bmMgc3JjPVwiaHR0cHM6Ly9wbGF0Zm9ybS50d2l0dGVyLmNvbS93aWRnZXRzLmpzXCIgY2hhcnNldD1cInV0Zi04XCI+PC9zY3JpcHQ+IiwiJV9vZW1iZWRfdGltZV81MTY2YWUyNzM0YzAzOGQxMmMwMzk2OTExYmYxMDc3MCUiOiIxNTY0NTk2NjcxIiwiJV9vZW1iZWRfOGQxZmUyZjVlYWY0N2IwYTRiMWE1MmMzYmQ1YTY2YTMlIjoiPGJsb2NrcXVvdGUgY2xhc3M9XCJ0d2l0dGVyLXR3ZWV0XCIgZGF0YS13aWR0aD1cIjQ3M1wiIGRhdGEtZG50PVwidHJ1ZVwiPjxwIGxhbmc9XCJmclwiIGRpcj1cImx0clwiPlx1MDBhYlx1MDBhMEF1IFRhbmsgbWVkaWEsIGpcdTIwMTlhaSBhcHByaXMgXHUwMGUwIGNvbXByZW5kcmUgcXVlbHMgXHUwMGU5dGFpZW50IGxlcyBwb2ludHMgZm9ydHMgZXQgbWVzIHBvaW50cyBmYWlibGVzIHBvdXIgYXBwcmVuZHJlIFx1MDBlMCB0cmF2YWlsbGVyIGRlIGZhXHUwMGU3b24gcGx1cyBwcmFnbWF0aXF1ZS5cdTAwYTBcdTAwYmIgPGEgaHJlZj1cImh0dHBzOi8vdC5jby9ENG10MkJvRDF3XCI+cGljLnR3aXR0ZXIuY29tL0Q0bXQyQm9EMXc8L2E+PC9wPiZtZGFzaDsgTGUgVGFuayBtZWRpYSAoQGxldGFua21lZGlhKSA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9sZXRhbmttZWRpYS9zdGF0dXMvMTE0NDE1NzgyOTE1NjI5ODc1Mz9yZWZfc3JjPXR3c3JjJTVFdGZ3XCI+SnVuZSAyNywgMjAxOTwvYT48L2Jsb2NrcXVvdGU+PHNjcmlwdCBhc3luYyBzcmM9XCJodHRwczovL3BsYXRmb3JtLnR3aXR0ZXIuY29tL3dpZGdldHMuanNcIiBjaGFyc2V0PVwidXRmLThcIj48L3NjcmlwdD4iLCIlX29lbWJlZF90aW1lXzhkMWZlMmY1ZWFmNDdiMGE0YjFhNTJjM2JkNWE2NmEzJSI6IjE1NjQ1OTY2NzIiLCIlX29lbWJlZF9jNGZmYTNlZWI2YWYwYWJmODYxOWE0ZDYzMWMyOGVjMiUiOiI8YmxvY2txdW90ZSBjbGFzcz1cInR3aXR0ZXItdHdlZXRcIiBkYXRhLXdpZHRoPVwiNDczXCIgZGF0YS1kbnQ9XCJ0cnVlXCI+PHAgbGFuZz1cImZyXCIgZGlyPVwibHRyXCI+QXVqb3VyZCYjMzk7aHVpLCBvbiB2b3VzIHByXHUwMGU5c2VudGUgSG9yaXpvbihzKSwgbm90cmUgXHUwMGU5dlx1MDBlOW5lbWVudCBwb3VyIGludGVycm9nZXIgZXQgY29tcHJlbmRyZSBsZXMgaW1wYWN0cyBkZSBsXHUyMDE5aW5ub3ZhdGlvbiBldCBkdSBudW1cdTAwZTlyaXF1ZSBzdXIgbm9zIG1cdTAwZTl0aWVycyBldCBub3Mgb3JnYW5pc2F0aW9ucy4gPyA8YSBocmVmPVwiaHR0cHM6Ly90LmNvL1EyTVp1S2hVeWpcIj5odHRwczovL3QuY28vUTJNWnVLaFV5ajwvYT48L3A+Jm1kYXNoOyBMZSBUYW5rIG1lZGlhIChAbGV0YW5rbWVkaWEpIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2xldGFua21lZGlhL3N0YXR1cy8xMTQ0MjA4MTIxMjUxOTc1MTY4P3JlZl9zcmM9dHdzcmMlNUV0ZndcIj5KdW5lIDI3LCAyMDE5PC9hPjwvYmxvY2txdW90ZT48c2NyaXB0IGFzeW5jIHNyYz1cImh0dHBzOi8vcGxhdGZvcm0udHdpdHRlci5jb20vd2lkZ2V0cy5qc1wiIGNoYXJzZXQ9XCJ1dGYtOFwiPjwvc2NyaXB0PiIsIiVfb2VtYmVkX3RpbWVfYzRmZmEzZWViNmFmMGFiZjg2MTlhNGQ2MzFjMjhlYzIlIjoiMTU2NDU5NjY3MiIsIiVfb2VtYmVkXzIxZWY0YzIwMTE4ZGUxMDRkMmI5MTY0ZGQyZGE5M2VlJSI6IjxibG9ja3F1b3RlIGNsYXNzPVwidHdpdHRlci10d2VldFwiIGRhdGEtd2lkdGg9XCI0ODlcIiBkYXRhLWRudD1cInRydWVcIj48cCBsYW5nPVwiZnJcIiBkaXI9XCJsdHJcIj5cdTAwYWJcdTAwYTBBdSBUYW5rIG1lZGlhLCBqXHUyMDE5YWkgYXBwcmlzIFx1MDBlMCBjb21wcmVuZHJlIHF1ZWxzIFx1MDBlOXRhaWVudCBsZXMgcG9pbnRzIGZvcnRzIGV0IG1lcyBwb2ludHMgZmFpYmxlcyBwb3VyIGFwcHJlbmRyZSBcdTAwZTAgdHJhdmFpbGxlciBkZSBmYVx1MDBlN29uIHBsdXMgcHJhZ21hdGlxdWUuXHUwMGEwXHUwMGJiIDxhIGhyZWY9XCJodHRwczovL3QuY28vRDRtdDJCb0Qxd1wiPnBpYy50d2l0dGVyLmNvbS9ENG10MkJvRDF3PC9hPjwvcD4mbWRhc2g7IExlIFRhbmsgbWVkaWEgKEBsZXRhbmttZWRpYSkgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vbGV0YW5rbWVkaWEvc3RhdHVzLzExNDQxNTc4MjkxNTYyOTg3NTM/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkp1bmUgMjcsIDIwMTk8L2E+PC9ibG9ja3F1b3RlPjxzY3JpcHQgYXN5bmMgc3JjPVwiaHR0cHM6Ly9wbGF0Zm9ybS50d2l0dGVyLmNvbS93aWRnZXRzLmpzXCIgY2hhcnNldD1cInV0Zi04XCI+PC9zY3JpcHQ+IiwiJV9vZW1iZWRfdGltZV8yMWVmNGMyMDExOGRlMTA0ZDJiOTE2NGRkMmRhOTNlZSUiOiIxNTY0NjUyMzgzIiwiJV9vZW1iZWRfZTg0ZjRhNmE3ZGRjMmU1NDQ4NWMwOGM4OTQ1NTk1MDclIjoiPGJsb2NrcXVvdGUgY2xhc3M9XCJ0d2l0dGVyLXR3ZWV0XCIgZGF0YS13aWR0aD1cIjQ4OVwiIGRhdGEtZG50PVwidHJ1ZVwiPjxwIGxhbmc9XCJmclwiIGRpcj1cImx0clwiPjEgNzAwbTIgYXUgY1x1MDE1M3VyIGR1IDExZW1lIFx1MDBlMCBQYXJpcyBwb3VyIGZhdm9yaXNlciBsXHUyMDE5XHUwMGU5bWVyZ2VuY2UgZFx1MjAxOXVuIG5vdXZlbCBlbnRyZXByZW5ldXJpYXQgZGFucyBsZXMgbVx1MDBlOWRpYXMuIEVzcGFjZSBcdTAwZTl2XHUwMGU5bmVtZW50aWVsLCBzdHVkaW9zIGF1ZGlvIGV0IHZpZFx1MDBlOW9zLCAxNzAgcG9zdGVzIGRlIHRyYXZhaWwsIDEgcm9vZnRvcCB2XHUwMGU5Z1x1MDBlOXRhbGlzXHUwMGU5Li4uPC9wPiZtZGFzaDsgTGUgVGFuayBtZWRpYSAoQGxldGFua21lZGlhKSA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9sZXRhbmttZWRpYS9zdGF0dXMvMTE0NzAyNzE0ODU3MTYzMTYxNj9yZWZfc3JjPXR3c3JjJTVFdGZ3XCI+SnVseSA1LCAyMDE5PC9hPjwvYmxvY2txdW90ZT48c2NyaXB0IGFzeW5jIHNyYz1cImh0dHBzOi8vcGxhdGZvcm0udHdpdHRlci5jb20vd2lkZ2V0cy5qc1wiIGNoYXJzZXQ9XCJ1dGYtOFwiPjwvc2NyaXB0PiIsIiVfb2VtYmVkX3RpbWVfZTg0ZjRhNmE3ZGRjMmU1NDQ4NWMwOGM4OTQ1NTk1MDclIjoiMTU2NDY1MjM4MyIsIiVfb2VtYmVkX2Q4Y2E2MDM5YzU1NzhmZjNmZDJlN2UwYzZmMTI2M2I3JSI6IjxibG9ja3F1b3RlIGNsYXNzPVwidHdpdHRlci10d2VldFwiIGRhdGEtd2lkdGg9XCI0ODlcIiBkYXRhLWRudD1cInRydWVcIj48cCBsYW5nPVwiZnJcIiBkaXI9XCJsdHJcIj5BdWpvdXJkJiMzOTtodWksIG9uIHZvdXMgcHJcdTAwZTlzZW50ZSBIb3Jpem9uKHMpLCBub3RyZSBcdTAwZTl2XHUwMGU5bmVtZW50IHBvdXIgaW50ZXJyb2dlciBldCBjb21wcmVuZHJlIGxlcyBpbXBhY3RzIGRlIGxcdTIwMTlpbm5vdmF0aW9uIGV0IGR1IG51bVx1MDBlOXJpcXVlIHN1ciBub3MgbVx1MDBlOXRpZXJzIGV0IG5vcyBvcmdhbmlzYXRpb25zLiA/IDxhIGhyZWY9XCJodHRwczovL3QuY28vUTJNWnVLaFV5alwiPmh0dHBzOi8vdC5jby9RMk1adUtoVXlqPC9hPjwvcD4mbWRhc2g7IExlIFRhbmsgbWVkaWEgKEBsZXRhbmttZWRpYSkgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vbGV0YW5rbWVkaWEvc3RhdHVzLzExNDQyMDgxMjEyNTE5NzUxNjg/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkp1bmUgMjcsIDIwMTk8L2E+PC9ibG9ja3F1b3RlPjxzY3JpcHQgYXN5bmMgc3JjPVwiaHR0cHM6Ly9wbGF0Zm9ybS50d2l0dGVyLmNvbS93aWRnZXRzLmpzXCIgY2hhcnNldD1cInV0Zi04XCI+PC9zY3JpcHQ+IiwiJV9vZW1iZWRfdGltZV9kOGNhNjAzOWM1NTc4ZmYzZmQyZTdlMGM2ZjEyNjNiNyUiOiIxNTY0NjUyMzgzIiwiJV9vZW1iZWRfNDVlY2E3MWU1ZTJlYWNlZWY1N2I1NDc4ODVmZTg0ZDAlIjoiPGJsb2NrcXVvdGUgY2xhc3M9XCJ0d2l0dGVyLXR3ZWV0XCIgZGF0YS13aWR0aD1cIjQ4OFwiIGRhdGEtZG50PVwidHJ1ZVwiPjxwIGxhbmc9XCJmclwiIGRpcj1cImx0clwiPkF1am91cmQmIzM5O2h1aSwgb24gdm91cyBwclx1MDBlOXNlbnRlIEhvcml6b24ocyksIG5vdHJlIFx1MDBlOXZcdTAwZTluZW1lbnQgcG91ciBpbnRlcnJvZ2VyIGV0IGNvbXByZW5kcmUgbGVzIGltcGFjdHMgZGUgbFx1MjAxOWlubm92YXRpb24gZXQgZHUgbnVtXHUwMGU5cmlxdWUgc3VyIG5vcyBtXHUwMGU5dGllcnMgZXQgbm9zIG9yZ2FuaXNhdGlvbnMuID8gPGEgaHJlZj1cImh0dHBzOi8vdC5jby9RMk1adUtoVXlqXCI+aHR0cHM6Ly90LmNvL1EyTVp1S2hVeWo8L2E+PC9wPiZtZGFzaDsgTGUgVGFuayBtZWRpYSAoQGxldGFua21lZGlhKSA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9sZXRhbmttZWRpYS9zdGF0dXMvMTE0NDIwODEyMTI1MTk3NTE2OD9yZWZfc3JjPXR3c3JjJTVFdGZ3XCI+SnVuZSAyNywgMjAxOTwvYT48L2Jsb2NrcXVvdGU+PHNjcmlwdCBhc3luYyBzcmM9XCJodHRwczovL3BsYXRmb3JtLnR3aXR0ZXIuY29tL3dpZGdldHMuanNcIiBjaGFyc2V0PVwidXRmLThcIj48L3NjcmlwdD4iLCIlX29lbWJlZF90aW1lXzQ1ZWNhNzFlNWUyZWFjZWVmNTdiNTQ3ODg1ZmU4NGQwJSI6IjE1NjQ2NTI1MzUiLCIlX29lbWJlZF9hMjBjMzdhMzE0MWNmNTRmNjYwNjI1MTQyMGYzZTNkMCUiOiI8YmxvY2txdW90ZSBjbGFzcz1cInR3aXR0ZXItdHdlZXRcIiBkYXRhLXdpZHRoPVwiNDg4XCIgZGF0YS1kbnQ9XCJ0cnVlXCI+PHAgbGFuZz1cImZyXCIgZGlyPVwibHRyXCI+XHUwMGFiXHUwMGEwQXUgVGFuayBtZWRpYSwgalx1MjAxOWFpIGFwcHJpcyBcdTAwZTAgY29tcHJlbmRyZSBxdWVscyBcdTAwZTl0YWllbnQgbGVzIHBvaW50cyBmb3J0cyBldCBtZXMgcG9pbnRzIGZhaWJsZXMgcG91ciBhcHByZW5kcmUgXHUwMGUwIHRyYXZhaWxsZXIgZGUgZmFcdTAwZTdvbiBwbHVzIHByYWdtYXRpcXVlLlx1MDBhMFx1MDBiYiA8YSBocmVmPVwiaHR0cHM6Ly90LmNvL0Q0bXQyQm9EMXdcIj5waWMudHdpdHRlci5jb20vRDRtdDJCb0QxdzwvYT48L3A+Jm1kYXNoOyBMZSBUYW5rIG1lZGlhIChAbGV0YW5rbWVkaWEpIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2xldGFua21lZGlhL3N0YXR1cy8xMTQ0MTU3ODI5MTU2Mjk4NzUzP3JlZl9zcmM9dHdzcmMlNUV0ZndcIj5KdW5lIDI3LCAyMDE5PC9hPjwvYmxvY2txdW90ZT48c2NyaXB0IGFzeW5jIHNyYz1cImh0dHBzOi8vcGxhdGZvcm0udHdpdHRlci5jb20vd2lkZ2V0cy5qc1wiIGNoYXJzZXQ9XCJ1dGYtOFwiPjwvc2NyaXB0PiIsIiVfb2VtYmVkX3RpbWVfYTIwYzM3YTMxNDFjZjU0ZjY2MDYyNTE0MjBmM2UzZDAlIjoiMTU2NDY1MjUzNSIsIiVfb2VtYmVkXzY2Zjc1YWIyNjcxMzYzNjQyNGEyZTEzYmUwYTdkMmMzJSI6IjxibG9ja3F1b3RlIGNsYXNzPVwidHdpdHRlci10d2VldFwiIGRhdGEtd2lkdGg9XCI0ODhcIiBkYXRhLWRudD1cInRydWVcIj48cCBsYW5nPVwiZnJcIiBkaXI9XCJsdHJcIj4xIDcwMG0yIGF1IGNcdTAxNTN1ciBkdSAxMWVtZSBcdTAwZTAgUGFyaXMgcG91ciBmYXZvcmlzZXIgbFx1MjAxOVx1MDBlOW1lcmdlbmNlIGRcdTIwMTl1biBub3V2ZWwgZW50cmVwcmVuZXVyaWF0IGRhbnMgbGVzIG1cdTAwZTlkaWFzLiBFc3BhY2UgXHUwMGU5dlx1MDBlOW5lbWVudGllbCwgc3R1ZGlvcyBhdWRpbyBldCB2aWRcdTAwZTlvcywgMTcwIHBvc3RlcyBkZSB0cmF2YWlsLCAxIHJvb2Z0b3Agdlx1MDBlOWdcdTAwZTl0YWxpc1x1MDBlOS4uLjwvcD4mbWRhc2g7IExlIFRhbmsgbWVkaWEgKEBsZXRhbmttZWRpYSkgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vbGV0YW5rbWVkaWEvc3RhdHVzLzExNDcwMjcxNDg1NzE2MzE2MTY/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkp1bHkgNSwgMjAxOTwvYT48L2Jsb2NrcXVvdGU+PHNjcmlwdCBhc3luYyBzcmM9XCJodHRwczovL3BsYXRmb3JtLnR3aXR0ZXIuY29tL3dpZGdldHMuanNcIiBjaGFyc2V0PVwidXRmLThcIj48L3NjcmlwdD4iLCIlX29lbWJlZF90aW1lXzY2Zjc1YWIyNjcxMzYzNjQyNGEyZTEzYmUwYTdkMmMzJSI6IjE1NjQ2NTI1MzUiLCIlX29lbWJlZF9jZWM1NWExYTI4ZTg2MDIwNzZjOWE4NmRkZmM5OTA1MiUiOiI8YmxvY2txdW90ZSBjbGFzcz1cInR3aXR0ZXItdHdlZXRcIiBkYXRhLXdpZHRoPVwiNDk0XCIgZGF0YS1kbnQ9XCJ0cnVlXCI+PHAgbGFuZz1cImZyXCIgZGlyPVwibHRyXCI+XHUwMGFiXHUwMGEwQXUgVGFuayBtZWRpYSwgalx1MjAxOWFpIGFwcHJpcyBcdTAwZTAgY29tcHJlbmRyZSBxdWVscyBcdTAwZTl0YWllbnQgbGVzIHBvaW50cyBmb3J0cyBldCBtZXMgcG9pbnRzIGZhaWJsZXMgcG91ciBhcHByZW5kcmUgXHUwMGUwIHRyYXZhaWxsZXIgZGUgZmFcdTAwZTdvbiBwbHVzIHByYWdtYXRpcXVlLlx1MDBhMFx1MDBiYiA8YSBocmVmPVwiaHR0cHM6Ly90LmNvL0Q0bXQyQm9EMXdcIj5waWMudHdpdHRlci5jb20vRDRtdDJCb0QxdzwvYT48L3A+Jm1kYXNoOyBMZSBUYW5rIG1lZGlhIChAbGV0YW5rbWVkaWEpIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2xldGFua21lZGlhL3N0YXR1cy8xMTQ0MTU3ODI5MTU2Mjk4NzUzP3JlZl9zcmM9dHdzcmMlNUV0ZndcIj5KdW5lIDI3LCAyMDE5PC9hPjwvYmxvY2txdW90ZT48c2NyaXB0IGFzeW5jIHNyYz1cImh0dHBzOi8vcGxhdGZvcm0udHdpdHRlci5jb20vd2lkZ2V0cy5qc1wiIGNoYXJzZXQ9XCJ1dGYtOFwiPjwvc2NyaXB0PiIsIiVfb2VtYmVkX3RpbWVfY2VjNTVhMWEyOGU4NjAyMDc2YzlhODZkZGZjOTkwNTIlIjoiMTU3MDExNDA2MyIsIiVfb2VtYmVkX2ZlNDlmMDUzZjYyYjcxNWI2ODE3MDdlYWI4YzEwNWZmJSI6IjxibG9ja3F1b3RlIGNsYXNzPVwidHdpdHRlci10d2VldFwiIGRhdGEtd2lkdGg9XCI0OTRcIiBkYXRhLWRudD1cInRydWVcIj48cCBsYW5nPVwiZnJcIiBkaXI9XCJsdHJcIj4xIDcwMG0yIGF1IGNcdTAxNTN1ciBkdSAxMWVtZSBcdTAwZTAgUGFyaXMgcG91ciBmYXZvcmlzZXIgbFx1MjAxOVx1MDBlOW1lcmdlbmNlIGRcdTIwMTl1biBub3V2ZWwgZW50cmVwcmVuZXVyaWF0IGRhbnMgbGVzIG1cdTAwZTlkaWFzLiBFc3BhY2UgXHUwMGU5dlx1MDBlOW5lbWVudGllbCwgc3R1ZGlvcyBhdWRpbyBldCB2aWRcdTAwZTlvcywgMTcwIHBvc3RlcyBkZSB0cmF2YWlsLCAxIHJvb2Z0b3Agdlx1MDBlOWdcdTAwZTl0YWxpc1x1MDBlOS4uLjwvcD4mbWRhc2g7IExlIFRhbmsgbWVkaWEgKEBsZXRhbmttZWRpYSkgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vbGV0YW5rbWVkaWEvc3RhdHVzLzExNDcwMjcxNDg1NzE2MzE2MTY/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkp1bHkgNSwgMjAxOTwvYT48L2Jsb2NrcXVvdGU+PHNjcmlwdCBhc3luYyBzcmM9XCJodHRwczovL3BsYXRmb3JtLnR3aXR0ZXIuY29tL3dpZGdldHMuanNcIiBjaGFyc2V0PVwidXRmLThcIj48L3NjcmlwdD4iLCIlX29lbWJlZF90aW1lX2ZlNDlmMDUzZjYyYjcxNWI2ODE3MDdlYWI4YzEwNWZmJSI6IjE1NzAxMTQwNjMiLCIlX29lbWJlZF82ZTRlYzk5NDNmZTYwZmQzYmE4YzgwNTM1NmU0OWExOCUiOiI8YmxvY2txdW90ZSBjbGFzcz1cInR3aXR0ZXItdHdlZXRcIiBkYXRhLXdpZHRoPVwiNDk0XCIgZGF0YS1kbnQ9XCJ0cnVlXCI+PHAgbGFuZz1cImZyXCIgZGlyPVwibHRyXCI+QXVqb3VyZCYjMzk7aHVpLCBvbiB2b3VzIHByXHUwMGU5c2VudGUgSG9yaXpvbihzKSwgbm90cmUgXHUwMGU5dlx1MDBlOW5lbWVudCBwb3VyIGludGVycm9nZXIgZXQgY29tcHJlbmRyZSBsZXMgaW1wYWN0cyBkZSBsXHUyMDE5aW5ub3ZhdGlvbiBldCBkdSBudW1cdTAwZTlyaXF1ZSBzdXIgbm9zIG1cdTAwZTl0aWVycyBldCBub3Mgb3JnYW5pc2F0aW9ucy4gPyA8YSBocmVmPVwiaHR0cHM6Ly90LmNvL1EyTVp1S2hVeWpcIj5odHRwczovL3QuY28vUTJNWnVLaFV5ajwvYT48L3A+Jm1kYXNoOyBMZSBUYW5rIG1lZGlhIChAbGV0YW5rbWVkaWEpIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2xldGFua21lZGlhL3N0YXR1cy8xMTQ0MjA4MTIxMjUxOTc1MTY4P3JlZl9zcmM9dHdzcmMlNUV0ZndcIj5KdW5lIDI3LCAyMDE5PC9hPjwvYmxvY2txdW90ZT48c2NyaXB0IGFzeW5jIHNyYz1cImh0dHBzOi8vcGxhdGZvcm0udHdpdHRlci5jb20vd2lkZ2V0cy5qc1wiIGNoYXJzZXQ9XCJ1dGYtOFwiPjwvc2NyaXB0PiIsIiVfb2VtYmVkX3RpbWVfNmU0ZWM5OTQzZmU2MGZkM2JhOGM4MDUzNTZlNDlhMTglIjoiMTU3MDExNDA2MyIsIiVfb2VtYmVkXzVmMDQ4ZDlmMzBmNTg2M2JlZjM3OWQ4MGM0YTVlNTY1JSI6IjxibG9ja3F1b3RlIGNsYXNzPVwidHdpdHRlci10d2VldFwiIGRhdGEtd2lkdGg9XCI0OTJcIiBkYXRhLWRudD1cInRydWVcIj48cCBsYW5nPVwiZnJcIiBkaXI9XCJsdHJcIj5BdWpvdXJkJiMzOTtodWksIG9uIHZvdXMgcHJcdTAwZTlzZW50ZSBIb3Jpem9uKHMpLCBub3RyZSBcdTAwZTl2XHUwMGU5bmVtZW50IHBvdXIgaW50ZXJyb2dlciBldCBjb21wcmVuZHJlIGxlcyBpbXBhY3RzIGRlIGxcdTIwMTlpbm5vdmF0aW9uIGV0IGR1IG51bVx1MDBlOXJpcXVlIHN1ciBub3MgbVx1MDBlOXRpZXJzIGV0IG5vcyBvcmdhbmlzYXRpb25zLiA/IDxhIGhyZWY9XCJodHRwczovL3QuY28vUTJNWnVLaFV5alwiPmh0dHBzOi8vdC5jby9RMk1adUtoVXlqPC9hPjwvcD4mbWRhc2g7IExlIFRhbmsgbWVkaWEgKEBsZXRhbmttZWRpYSkgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vbGV0YW5rbWVkaWEvc3RhdHVzLzExNDQyMDgxMjEyNTE5NzUxNjg/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkp1bmUgMjcsIDIwMTk8L2E+PC9ibG9ja3F1b3RlPjxzY3JpcHQgYXN5bmMgc3JjPVwiaHR0cHM6Ly9wbGF0Zm9ybS50d2l0dGVyLmNvbS93aWRnZXRzLmpzXCIgY2hhcnNldD1cInV0Zi04XCI+PC9zY3JpcHQ+IiwiJV9vZW1iZWRfdGltZV81ZjA0OGQ5ZjMwZjU4NjNiZWYzNzlkODBjNGE1ZTU2NSUiOiIxNTcwMTE0MzE4IiwiJV9vZW1iZWRfODViMGMzZDhiMjI2NDNiMzlhNTAzMDEzYmI3NzU3NWMlIjoiPGJsb2NrcXVvdGUgY2xhc3M9XCJ0d2l0dGVyLXR3ZWV0XCIgZGF0YS13aWR0aD1cIjQ5MlwiIGRhdGEtZG50PVwidHJ1ZVwiPjxwIGxhbmc9XCJmclwiIGRpcj1cImx0clwiPlx1MDBhYlx1MDBhMEF1IFRhbmsgbWVkaWEsIGpcdTIwMTlhaSBhcHByaXMgXHUwMGUwIGNvbXByZW5kcmUgcXVlbHMgXHUwMGU5dGFpZW50IGxlcyBwb2ludHMgZm9ydHMgZXQgbWVzIHBvaW50cyBmYWlibGVzIHBvdXIgYXBwcmVuZHJlIFx1MDBlMCB0cmF2YWlsbGVyIGRlIGZhXHUwMGU3b24gcGx1cyBwcmFnbWF0aXF1ZS5cdTAwYTBcdTAwYmIgPGEgaHJlZj1cImh0dHBzOi8vdC5jby9ENG10MkJvRDF3XCI+cGljLnR3aXR0ZXIuY29tL0Q0bXQyQm9EMXc8L2E+PC9wPiZtZGFzaDsgTGUgVGFuayBtZWRpYSAoQGxldGFua21lZGlhKSA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9sZXRhbmttZWRpYS9zdGF0dXMvMTE0NDE1NzgyOTE1NjI5ODc1Mz9yZWZfc3JjPXR3c3JjJTVFdGZ3XCI+SnVuZSAyNywgMjAxOTwvYT48L2Jsb2NrcXVvdGU+PHNjcmlwdCBhc3luYyBzcmM9XCJodHRwczovL3BsYXRmb3JtLnR3aXR0ZXIuY29tL3dpZGdldHMuanNcIiBjaGFyc2V0PVwidXRmLThcIj48L3NjcmlwdD4iLCIlX29lbWJlZF90aW1lXzg1YjBjM2Q4YjIyNjQzYjM5YTUwMzAxM2JiNzc1NzVjJSI6IjE1NzAxMTQzMTgiLCIlX29lbWJlZF8zYWRmNzVkNDc3YTNhNjRiYjMzMzc0M2M2YzdkMjBlMSUiOiI8YmxvY2txdW90ZSBjbGFzcz1cInR3aXR0ZXItdHdlZXRcIiBkYXRhLXdpZHRoPVwiNDkyXCIgZGF0YS1kbnQ9XCJ0cnVlXCI+PHAgbGFuZz1cImZyXCIgZGlyPVwibHRyXCI+MSA3MDBtMiBhdSBjXHUwMTUzdXIgZHUgMTFlbWUgXHUwMGUwIFBhcmlzIHBvdXIgZmF2b3Jpc2VyIGxcdTIwMTlcdTAwZTltZXJnZW5jZSBkXHUyMDE5dW4gbm91dmVsIGVudHJlcHJlbmV1cmlhdCBkYW5zIGxlcyBtXHUwMGU5ZGlhcy4gRXNwYWNlIFx1MDBlOXZcdTAwZTluZW1lbnRpZWwsIHN0dWRpb3MgYXVkaW8gZXQgdmlkXHUwMGU5b3MsIDE3MCBwb3N0ZXMgZGUgdHJhdmFpbCwgMSByb29mdG9wIHZcdTAwZTlnXHUwMGU5dGFsaXNcdTAwZTkuLi48L3A+Jm1kYXNoOyBMZSBUYW5rIG1lZGlhIChAbGV0YW5rbWVkaWEpIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2xldGFua21lZGlhL3N0YXR1cy8xMTQ3MDI3MTQ4NTcxNjMxNjE2P3JlZl9zcmM9dHdzcmMlNUV0ZndcIj5KdWx5IDUsIDIwMTk8L2E+PC9ibG9ja3F1b3RlPjxzY3JpcHQgYXN5bmMgc3JjPVwiaHR0cHM6Ly9wbGF0Zm9ybS50d2l0dGVyLmNvbS93aWRnZXRzLmpzXCIgY2hhcnNldD1cInV0Zi04XCI+PC9zY3JpcHQ+IiwiJV9vZW1iZWRfdGltZV8zYWRmNzVkNDc3YTNhNjRiYjMzMzc0M2M2YzdkMjBlMSUiOiIxNTcwMTE0MzE4IiwiJXNiZ19zZWxlY3RlZF9zaWRlYmFyJSI6IjAiLCIlc2JnX3NlbGVjdGVkX3NpZGViYXJfcmVwbGFjZW1lbnQlIjoiMCIsIiVfb2VtYmVkX2Q3MzQ3NGNhZmJjMjhlZWQ1ZmUzMjk1MTgyNDA4MDk1JSI6IjxibG9ja3F1b3RlIGNsYXNzPVwidHdpdHRlci10d2VldFwiIGRhdGEtd2lkdGg9XCI1NTBcIiBkYXRhLWRudD1cInRydWVcIj48cCBsYW5nPVwiZnJcIiBkaXI9XCJsdHJcIj5cdTAwYWJcdTAwYTBBdSBUYW5rIG1lZGlhLCBqXHUyMDE5YWkgYXBwcmlzIFx1MDBlMCBjb21wcmVuZHJlIHF1ZWxzIFx1MDBlOXRhaWVudCBsZXMgcG9pbnRzIGZvcnRzIGV0IG1lcyBwb2ludHMgZmFpYmxlcyBwb3VyIGFwcHJlbmRyZSBcdTAwZTAgdHJhdmFpbGxlciBkZSBmYVx1MDBlN29uIHBsdXMgcHJhZ21hdGlxdWUuXHUwMGEwXHUwMGJiIDxhIGhyZWY9XCJodHRwczovL3QuY28vRDRtdDJCb0Qxd1wiPnBpYy50d2l0dGVyLmNvbS9ENG10MkJvRDF3PC9hPjwvcD4mbWRhc2g7IExlIFRhbmsgbWVkaWEgKEBsZXRhbmttZWRpYSkgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vbGV0YW5rbWVkaWEvc3RhdHVzLzExNDQxNTc4MjkxNTYyOTg3NTM/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkp1bmUgMjcsIDIwMTk8L2E+PC9ibG9ja3F1b3RlPjxzY3JpcHQgYXN5bmMgc3JjPVwiaHR0cHM6Ly9wbGF0Zm9ybS50d2l0dGVyLmNvbS93aWRnZXRzLmpzXCIgY2hhcnNldD1cInV0Zi04XCI+PC9zY3JpcHQ+IiwiJV9vZW1iZWRfNTg5ZTgyMWY3MzQ1ZTRlMzMxNzYyYzExYzE0YjFmOTYlIjoiPGJsb2NrcXVvdGUgY2xhc3M9XCJ0d2l0dGVyLXR3ZWV0XCIgZGF0YS13aWR0aD1cIjU1MFwiIGRhdGEtZG50PVwidHJ1ZVwiPjxwIGxhbmc9XCJmclwiIGRpcj1cImx0clwiPkF1am91cmQmIzM5O2h1aSwgb24gdm91cyBwclx1MDBlOXNlbnRlIEhvcml6b24ocyksIG5vdHJlIFx1MDBlOXZcdTAwZTluZW1lbnQgcG91ciBpbnRlcnJvZ2VyIGV0IGNvbXByZW5kcmUgbGVzIGltcGFjdHMgZGUgbFx1MjAxOWlubm92YXRpb24gZXQgZHUgbnVtXHUwMGU5cmlxdWUgc3VyIG5vcyBtXHUwMGU5dGllcnMgZXQgbm9zIG9yZ2FuaXNhdGlvbnMuID8gPGEgaHJlZj1cImh0dHBzOi8vdC5jby9RMk1adUtoVXlqXCI+aHR0cHM6Ly90LmNvL1EyTVp1S2hVeWo8L2E+PC9wPiZtZGFzaDsgTGUgVGFuayBtZWRpYSAoQGxldGFua21lZGlhKSA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9sZXRhbmttZWRpYS9zdGF0dXMvMTE0NDIwODEyMTI1MTk3NTE2OD9yZWZfc3JjPXR3c3JjJTVFdGZ3XCI+SnVuZSAyNywgMjAxOTwvYT48L2Jsb2NrcXVvdGU+PHNjcmlwdCBhc3luYyBzcmM9XCJodHRwczovL3BsYXRmb3JtLnR3aXR0ZXIuY29tL3dpZGdldHMuanNcIiBjaGFyc2V0PVwidXRmLThcIj48L3NjcmlwdD4iLCIlX29lbWJlZF90aW1lX2Q3MzQ3NGNhZmJjMjhlZWQ1ZmUzMjk1MTgyNDA4MDk1JSI6IjE1NzAxMTQ0OTUiLCIlX29lbWJlZF90aW1lXzU4OWU4MjFmNzM0NWU0ZTMzMTc2MmMxMWMxNGIxZjk2JSI6IjE1NzAxMTQ0OTUiLCIlX29lbWJlZF9iYTJkODYwMDdlMjllNWUzZWI2ZDg0MzI2Y2U0YWEyMSUiOiI8YmxvY2txdW90ZSBjbGFzcz1cInR3aXR0ZXItdHdlZXRcIiBkYXRhLXdpZHRoPVwiNTUwXCIgZGF0YS1kbnQ9XCJ0cnVlXCI+PHAgbGFuZz1cImZyXCIgZGlyPVwibHRyXCI+MSA3MDBtMiBhdSBjXHUwMTUzdXIgZHUgMTFlbWUgXHUwMGUwIFBhcmlzIHBvdXIgZmF2b3Jpc2VyIGxcdTIwMTlcdTAwZTltZXJnZW5jZSBkXHUyMDE5dW4gbm91dmVsIGVudHJlcHJlbmV1cmlhdCBkYW5zIGxlcyBtXHUwMGU5ZGlhcy4gRXNwYWNlIFx1MDBlOXZcdTAwZTluZW1lbnRpZWwsIHN0dWRpb3MgYXVkaW8gZXQgdmlkXHUwMGU5b3MsIDE3MCBwb3N0ZXMgZGUgdHJhdmFpbCwgMSByb29mdG9wIHZcdTAwZTlnXHUwMGU5dGFsaXNcdTAwZTkuLi48L3A+Jm1kYXNoOyBMZSBUYW5rIG1lZGlhIChAbGV0YW5rbWVkaWEpIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2xldGFua21lZGlhL3N0YXR1cy8xMTQ3MDI3MTQ4NTcxNjMxNjE2P3JlZl9zcmM9dHdzcmMlNUV0ZndcIj5KdWx5IDUsIDIwMTk8L2E+PC9ibG9ja3F1b3RlPjxzY3JpcHQgYXN5bmMgc3JjPVwiaHR0cHM6Ly9wbGF0Zm9ybS50d2l0dGVyLmNvbS93aWRnZXRzLmpzXCIgY2hhcnNldD1cInV0Zi04XCI+PC9zY3JpcHQ+IiwiJV9vZW1iZWRfdGltZV9iYTJkODYwMDdlMjllNWUzZWI2ZDg0MzI2Y2U0YWEyMSUiOiIxNTcwMTE0NDk1IiwidGF4b25vbXk9Y2F0ZWdvcnkiOiJNZWRpYSBsYWJzIiwidGF4b25vbXk9cG9zdF90YWciOiIifSwiaWNvbiI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE4LzAyL21hcmtlci0xLnBuZyJ9LCJpZCI6MTUxODMsImluZm93aW5kb3dfZGlzYWJsZSI6ZmFsc2V9LHsic291cmNlIjoicG9zdCIsInRpdGxlIjoiV1NKIFImIzAzODtEOiBicmluZ2luZyBkYXRhIHNjaWVuY2UgYW5kIEFJIGNhcGFiaWxpdGllcyB0byB0aGUgbmV3c3Jvb20iLCJpbmZvd2luZG93X2NvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIldTSiBSJiMwMzg7RDogYnJpbmdpbmcgZGF0YSBzY2llbmNlIGFuZCBBSSBjYXBhYmlsaXRpZXMgdG8gdGhlIG5ld3Nyb29tXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMDBcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxOS8wNi9GaWd1cmUtMS0zMDB4MjAwLmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmdcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXBhZGRpbmctY29udGVudF8yMFwiPlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLW1ldGEgZmMtaXRlbS1zZWNvbmRhcnktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZSBmYy10ZXh0LWNlbnRlclwiPk1lZGlhIGxhYnM8L2Rpdj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS10aXRsZSBmYy1pdGVtLXByaW1hcnktdGV4dC1jb2xvciBmYy10ZXh0LWNlbnRlclwiPldTSiBSJiMwMzg7RDogYnJpbmdpbmcgZGF0YSBzY2llbmNlIGFuZCBBSSBjYXBhYmlsaXRpZXMgdG8gdGhlIG5ld3Nyb29tPC9kaXY+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tY29udGVudCBmYy1pdGVtLWJvZHktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZVwiPlxyXG4gICAgICAgICAgICBUaGUgSm91cm5hbFx1MjAxOXMgUiZEIHVuaXQgd29ya3MgYWNyb3NzIHRoZSBuZXdzcm9vbSB0byBkZXZlbG9wIG5ldyBjb21wdXRhdGlvbmFsIGFwcHJvYWNoZXMgdG8gZW1wb3dlciBqb3VybmFsaXN0cyB3aXRoIG1hY2hpbmUgbGVhcm5pbmcgYW5kIGFydGlmaWNpYWwgaW50ZWxsaWdlbmNlIHJlc291cmNlcy5cclxuICAgICAgICA8L2Rpdj5cclxuPGEgaHJlZj1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi93c2otcmQtYnJpbmdpbmctZGF0YS1zY2llbmNlLWFuZC1haS1jYXBhYmlsaXRpZXMtdG8tdGhlLW5ld3Nyb29tL1wiPlJlYWQgbW9yZTwvYT5cclxuICAgIDwvZGl2PlxyXG4gICAgPC9kaXY+XHJcbjwvZGl2PlxyXG5cclxuIiwiY29udGVudCI6IlRoZSBKb3VybmFsXHUyMDE5cyBSJkQgdW5pdCB3b3JrcyBhY3Jvc3MgdGhlIG5ld3Nyb29tIHRvIGRldmVsb3AgbmV3IGNvbXB1dGF0aW9uYWwgYXBwcm9hY2hlcyB0byBlbXBvd2VyIGpvdXJuYWxpc3RzIHdpdGggbWFjaGluZSBsZWFybmluZyBhbmQgYXJ0aWZpY2lhbCBpbnRlbGxpZ2VuY2UgcmVzb3VyY2VzLiIsImFkZHJlc3MiOiJOZXcgWW9yaywgTlksIFVTQSIsImxvY2F0aW9uIjp7ImxhdCI6IjQwLjcxMjc3NTMiLCJjaXR5IjoiTmV3IFlvcmsiLCJzdGF0ZSI6Ik5ldyBZb3JrIiwiY291bnRyeSI6IlVuaXRlZCBTdGF0ZXMiLCJsbmciOiItNzQuMDA1OTcyOCIsIm9uY2xpY2tfYWN0aW9uIjoibWFya2VyIiwicmVkaXJlY3RfcGVybWFsaW5rIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL3dzai1yZC1icmluZ2luZy1kYXRhLXNjaWVuY2UtYW5kLWFpLWNhcGFiaWxpdGllcy10by10aGUtbmV3c3Jvb20vIiwiem9vbSI6MiwiZXh0cmFfZmllbGRzIjp7InBvc3RfZXhjZXJwdCI6IlRoZSBKb3VybmFsXHUyMDE5cyBSJkQgdW5pdCB3b3JrcyBhY3Jvc3MgdGhlIG5ld3Nyb29tIHRvIGRldmVsb3AgbmV3IGNvbXB1dGF0aW9uYWwgYXBwcm9hY2hlcyB0byBlbXBvd2VyIGpvdXJuYWxpc3RzIHdpdGggbWFjaGluZSBsZWFybmluZyBhbmQgYXJ0aWZpY2lhbCBpbnRlbGxpZ2VuY2UgcmVzb3VyY2VzLiIsInBvc3RfY29udGVudCI6Ilt2Y19yb3ddW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIyLzNcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxoMT5XU0ogUiZhbXA7RDogYnJpbmdpbmcgZGF0YSBzY2llbmNlIGFuZCBBSSBjYXBhYmlsaXRpZXMgdG8gdGhlIG5ld3Nyb29tPC9oMT5cclxuPGVtPlRoZSBKb3VybmFsXHUyMDE5cyBSJmFtcDtEIHVuaXQgd29ya3MgYWNyb3NzIHRoZSBuZXdzcm9vbSB0byBkZXZlbG9wIG5ldyBjb21wdXRhdGlvbmFsIGFwcHJvYWNoZXMgdG8gZW1wb3dlciBqb3VybmFsaXN0cyB3aXRoIG1hY2hpbmUgbGVhcm5pbmcgYW5kIGFydGlmaWNpYWwgaW50ZWxsaWdlbmNlIHJlc291cmNlcy4gPC9lbT5cclxuXHJcblRoZSBXYWxsIFN0cmVldCBKb3VybmFsIFJlc2VhcmNoICZhbXA7IERldmVsb3BtZW50IHVuaXQgd2FzIGxhdW5jaGVkIGluIE1hcmNoIDIwMTguIFJlY29nbml6aW5nIHRoZSBpbXBhY3QgYXJ0aWZpY2lhbCBpbnRlbGxpZ2VuY2Ugd2lsbCBwbGF5IGluIGpvdXJuYWxpc20sIHRoZSBXU0ogUiZhbXA7RCAocHJldmlvdXNseSBrbm93biBhcyA8YSBocmVmPVwiaHR0cHM6Ly93d3cuZG93am9uZXMuY29tL3ByZXNzLXJvb20vd2FsbC1zdHJlZXQtam91cm5hbC1hcHBvaW50cy1mcmFuY2VzY28tbWFyY29uaS1yZC1jaGllZi1hbmQtaGVhZC1vZi1tZWRpYS1zY2llbmNlLWxhYi9cIj5XU0ogTWVkaWEgU2NpZW5jZSBMYWI8L2E+KSBpcyBhIG11bHRpZGlzY2lwbGluYXJ5IHRlYW0gd2l0aGluIHRoZSBXYWxsIFN0cmVldCBKb3VybmFsIHNwZWNpZmljYWxseSBmb2N1c2VkIG9uIHN1cHBvcnRpbmcgdGhlIG5ld3Nyb29tLiBSJmFtcDtEIGlzIHBhcnQgb2YgdGhlIHN0cmF0ZWd5IGdyb3VwIGFuZCBjb2xsYWJvcmF0ZXMgd2l0aCBkZXBhcnRtZW50cyBmcm9tIGFjcm9zcyB0aGUgSm91cm5hbC4gQmVzaWRlcyB0aGUgZnVsbC10aW1lIHN0YWZmLCB0aGUgdGVhbSBob3N0cyB2aXNpdGluZyBmZWxsb3dzIGluY2x1ZGluZyBhY2FkZW1pY3MsIHJlc2VhcmNoZXJzIGFuZCBncmFkdWF0ZSBzdHVkZW50cy5cclxuXHJcblRoZSBvdXRwdXQgb2YgdGhlIGdyb3VwIGluY2x1ZGVzIG5ld3NnYXRoZXJpbmcgdG9vbHMsIGRhdGEgc2NpZW5jZSBkcml2ZW4gc3RvcmllcyBhbmQgYXV0b21hdGlvbiBwcm9qZWN0cy4gU29tZSByZWNlbnQgZWZmb3J0cyBpbmNsdWRlIGEgbWFjaGluZSBsZWFybmluZyBwb3dlcmVkIGNvbnRlbnQgYW5hbHl0aWNzIHBsYXRmb3JtIHRoYXQgYW5hbHlzZXMgdGhlIEpvdXJuYWxcdTIwMTlzIGFyY2hpdmUgYW5kIGhlbHBzIGpvdXJuYWxpc3RzIGZpbmQgZWRpdG9yaWFsIGluc2lnaHRzOyBhbiBvbmxpbmUgdG9vbCB0aGF0IDxhIGhyZWY9XCJodHRwczovL3d3dy53c2ouY29tL2FydGljbGVzL2NvbXBhcmUtYW55LXR3by1jb2xsZWdlcy1mcm9tLXRoZS13c2otdGhlLWNvbGxlZ2UtcmFua2luZ3MtMTE1NTE4ODY4MjRcIj5hdXRvbWF0aWNhbGx5IHR1cm5zIGNvbGxlZ2UgcmFua2luZ3MgZGF0YSBpbnRvIHRleHQ8L2E+IGNvbnRlbnQgYW5kIGEgPGEgaHJlZj1cImh0dHBzOi8vd3d3Lndzai5jb20vYXJ0aWNsZXMveW91LWdpdmUtYXBwcy1zZW5zaXRpdmUtcGVyc29uYWwtaW5mb3JtYXRpb24tdGhlbi10aGV5LXRlbGwtZmFjZWJvb2stMTE1NTA4NTE2MzZcIj5zdG9yeSB1c2luZyBjb21wdXRhdGlvbmFsIGpvdXJuYWxpc20gdGVjaG5pcXVlczwvYT4gdG8gaW52ZXN0aWdhdGUgRmFjZWJvb2tcdTIwMTlzIGRhdGEgcHJpdmFjeSBzaGFyaW5nIHByYWN0aWNlcy5cclxuXHJcbldTSiBSJmFtcDtELCB3aGljaCBpcyBjb21wcmlzZWQgb2YgZGF0YSBzY2llbnRpc3RzLCBtYWNoaW5lLWxlYXJuaW5nIGVuZ2luZWVycywgcHJvamVjdCBtYW5hZ2VycyBhbmQgc3BlY2lhbGl6ZWQgZWRpdG9ycywgaXMgZm9jdXNlZCBvbiBkZXBsb3lpbmcgbmV3IHRlY2hub2xvZ3kgdG8gaGVscCB0cmFuc2Zvcm0gdGhlIG5ld3NnYXRoZXJpbmcuIEl0IGlzIGNlbnRyZWQgb24gdGhlIGZvbGxvd2luZyBrZXkgYWN0aXZpdGllczpcclxuPHVsPlxyXG4gXHQ8bGk+RGV2ZWxvcCBBSSB0b29scyB0byBzb3VyY2UgaW5mb3JtYXRpb24gYW5kIHN0b3J5IGlkZWFzIHRocm91Z2ggbmV3IHR5cGVzIG9mIGRhdGEgY29sbGVjdGlvbiBwcm9jZXNzZXMuPC9saT5cclxuIFx0PGxpPkhlbHAgam91cm5hbGlzdHMgZXhwbG9yZSBvcHBvcnR1bml0aWVzIHRvIGR5bmFtaWNhbGx5IHJlZGVmaW5lIGNvbnRlbnQgcGFja2FnZXMgYXQgc2NhbGUuPC9saT5cclxuIFx0PGxpPkNvbmR1Y3QgcmVzZWFyY2ggdG8gaWRlbnRpZnkgdGVjaG5vbG9naWNhbCB0cmVuZHMgdGhhdCB3aWxsIGltcGFjdCB0aGUgZnV0dXJlIG9mIGpvdXJuYWxpc20uPC9saT5cclxuPC91bD5cclxuXHUyMDFjV2UgYnVpbGQgbWFjaGluZXMgdGhhdCBoZWxwIGpvdXJuYWxpc3RzIGZpbmQgYW5kIHByb2R1Y2UgcG93ZXJmdWwgc3Rvcnl0ZWxsaW5nXHUyMDFkLCBzdW1tYXJpemVzIEZyYW5jZXNjbyBNYXJjb25pLCBXU0ogUiZhbXA7RCBDaGllZiBhbmQgd2hvIGlzIGFsc28gdGhlIGF1dGhvciBvZiB0aGUgdXBjb21pbmcgYm9vayA8YSBocmVmPVwiaHR0cHM6Ly9jdXAuY29sdW1iaWEuZWR1L2Jvb2svbmV3c21ha2Vycy85NzgwMjMxMTkxMzcxXCI+TmV3c21ha2VyczogQXJ0aWZpY2lhbCBJbnRlbGxpZ2VuY2UgYW5kIHRoZSBGdXR1cmUgb2YgSm91cm5hbGlzbTwvYT4uXHJcblxyXG5JbiBhZGRpdGlvbiwgdGhlIHRlYW0gZGV2ZWxvcHMgbmV3c3Jvb20gZ3VpZGVzIGZvciBqb3VybmFsaXN0cyBpbmNsdWRpbmcgXHUyMDFjPGEgaHJlZj1cImh0dHBzOi8vd3d3Lm5pZW1hbmxhYi5vcmcvMjAxOS8wMi9hY2luZy10aGUtYWxnb3JpdGhtaWMtYmVhdC1qb3VybmFsaXNtcy1uZXh0LWZyb250aWVyL1wiPmhvdyB0byBjb3ZlciB0aGUgYWxnb3JpdGhtaWMgYmVhdDwvYT5cdTIwMWQgYW5kIFx1MjAxYzxhIGhyZWY9XCJodHRwczovL3d3dy5uaWVtYW5sYWIub3JnLzIwMTgvMTEvaG93LXRoZS13YWxsLXN0cmVldC1qb3VybmFsLWlzLXByZXBhcmluZy1pdHMtam91cm5hbGlzdHMtdG8tZGV0ZWN0LWRlZXBmYWtlcy9cIj5ob3cgdG8gZGV0ZWN0IGRlZXBmYWtlczwvYT5cdTIwMWQuIFNvbWUgb2YgdGhpcyByZXNlYXJjaCBsZWFkcyB0byBicm9hZGVyIGluaXRpYXRpdmVzIHN1Y2ggYXMgdGhlIGxhdW5jaCBvZiB0aGUgPGEgaHJlZj1cImh0dHBzOi8vd3d3LnRlbGVncmFwaC5jby51ay90ZWNobm9sb2d5LzIwMTgvMTEvMTUvam91cm5hbGlzdHMtd2FsbC1zdHJlZXQtam91cm5hbC10YXVnaHQtaWRlbnRpZnktZGVlcGZha2VzL1wiPldTSiBNZWRpYSBGb3JlbnNpY3MgY29tbWl0dGVlPC9hPiAtLSBhIGpvaW50IGVmZm9ydCBiZXR3ZWVuIHRoZSBTdGFuZGFyZHMgJmFtcDsgRXRoaWNzIHRlYW0gYW5kIFImYW1wO0QgdG8gdHJhaW4gam91cm5hbGlzdHMgdG8gZGV0ZWN0IEFJLWZ1ZWxsZWQgbWlzaW5mb3JtYXRpb24uXHJcbjxoMz5BIHNoYXJlZCBwcm9jZXNzOiBpbmNyZWFzaW5nIGludGVybmFsIGVuZ2FnZW1lbnQ8L2gzPlxyXG5NYXJjb25pIHN1Z2dlc3RzIHRoYXQgb25lIG9mIHRoZSBzdHJlbmd0aHMgb2YgdGhlIFImYW1wO0QgdGVhbSBpcyBpdHMgY29sbGFib3JhdGl2ZSBhcHByb2FjaCBhbmQgdGhlIGZhY3Qgb2YgYmVpbmcgYSBzaGFyZWQgcmVzb3VyY2UuIFx1MjAxY1dlIGFyZSB0cnlpbmcgdG8gbWFrZSB0aGUgcHJvY2VzcyBhcyB0cmFuc3BhcmVudCBhbmQgY29sbGVjdGl2ZSBhcyBwb3NzaWJsZSB3aXRoaW4gV1NKLiBXZSBwcmlvcml0aXplIGVmZm9ydHMgdG8gd29yayBvbiBiYXNlZCBvbiB0aGUgc3RyYXRlZ2ljIHByaW9yaXRpZXMgZGVmaW5lZCBieSB0aGUgbmV3c3Jvb20gbGVhZGVyc2hpcC5cdTIwMWRcclxuXHJcblRoaXMgc2hhcmVkIGFwcHJvYWNoIGlzIGNvbm5lY3RlZCB3aXRoIGFuIGludGVybmFsIHBsYXRmb3JtIGZvciBjcm93ZHNvdXJjaW5nIGlkZWFzLCB3aGljaCB3YXMgaW1wbGVtZW50ZWQgaW4gdGhlIHZlcnkgYmVnaW5uaW5nIG9mIHRoZSB1bml0LlxyXG5cclxuXHUyMDFjV2Ugc2V0IHVwIGFuIGlkZWEgc3VibWlzc2lvbiBwbGF0Zm9ybSB0byBnaXZlIGV2ZXJ5b25lIGFuIG9wcG9ydHVuaXR5IHRvIHBhcnRpY2lwYXRlIGluIHRoZSBkaWdpdGFsIHRyYW5zZm9ybWF0aW9uIHByb2Nlc3MuIFRoZSB0b29sIGlzIG5vd2FkYXlzIGEgdmVyeSBpbXBvcnRhbnQgc291cmNlIG9mIGlubm92YXRpb24gZm9yIHRoZSBicm9hZGVyIG5ld3Nyb29tLCBzbyBtdWNoIHNvIHRoYXQgdGhlcmUgd2lsbCBiZSBhIHRlYW0gZGVkaWNhdGVkIHRvIG1hbmFnZSB0aGF0IHByb2Nlc3MuXHUyMDFjXHJcblxyXG5bZW1iZWRdaHR0cHM6Ly90d2l0dGVyLmNvbS9mcG1hcmNvbmkvc3RhdHVzLzEwOTA2MTA3OTEwNDMyNjg2MDlbL2VtYmVkXVxyXG5cclxuTWFyY29uaSBleHBsYWlucyB0aGF0IHRoZSBldGhvcyBvZiB0aGUgb3ZlcmFsbCBzdHJhdGVneSBkZXBhcnRtZW50LCB3aGljaCBpcyBsZWQgYnkgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmRvd2pvbmVzLmNvbS9wcmVzcy1yb29tL3dhbGwtc3RyZWV0LWpvdXJuYWwtYXBwb2ludHMtbG91aXNlLXN0b3J5LWVkaXRvci1uZXdzcm9vbS1zdHJhdGVneS9cIj5Mb3Vpc2UgU3Rvcnk8L2E+LCBpcyBjb2xsYWJvcmF0aXZlIGFuZCBpbmNsdXNpdmUuIEFueW9uZSBpbiB0aGUgbmV3c3Jvb20gY2FuIHN1Ym1pdCBhbiBpZGVhLCBhbmQgb24gYSBtb250aGx5IGJhc2lzIHRoZXJlXHUyMDE5cyBhIHJldmlldyBzZXNzaW9uIG9wZW4gdG8gYW55b25lIHdobyB3YW50cyB0byBwYXJ0aWNpcGF0ZS5cclxuXHJcbkJlc2lkZXMgdGhlIGNyb3dkc291cmNpbmcgcGxhdGZvcm0sIHRoZSBSJmFtcDtEIHRlYW0gc291cmNlcyBuZXcgb3Bwb3J0dW5pdGllcyBieSBob3N0aW5nIGRlc2lnbi10aGlua2luZyBib290IGNhbXBzIGZvciBqb3VybmFsaXN0cywgYW4gYWN0aXZpdHkgcnVuIGluIGNsb3NlIGNvbGxhYm9yYXRpb24gd2l0aCBXU0pcdTIwMTlzIFRyYWluaW5nICZhbXA7IE91dHJlYWNoIGFuZCBVSS9VWCB0ZWFtcy5cclxuXHJcbltjYXB0aW9uIGlkPVwiYXR0YWNobWVudF8xNTE3MFwiIGFsaWduPVwiYWxpZ25jZW50ZXJcIiB3aWR0aD1cIjEwMjRcIl08aW1nIGNsYXNzPVwid3AtaW1hZ2UtMTUxNzAgc2l6ZS1sYXJnZVwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE5LzA2L0ZpZ3VyZTItMTAyNHg3NjguanBnXCIgYWx0PVwiXCIgd2lkdGg9XCIxMDI0XCIgaGVpZ2h0PVwiNzY4XCIgLz4gSm91cm5hbGlzdHMgYXQgdGhlIFdhbGwgU3RyZWV0IEpvdXJuYWwgcGFydGljaXBhdGUgaW4gZGVzaWduIHRoaW5raW5nIGV4ZXJjaXNlcyB0byBpZGVudGlmeSBhbmQgc3lzdGVtYXRpemUgbmV3IG9wcG9ydHVuaXRpZXMgZm9yIHRoZSBuZXdzcm9vbS4gSW1hZ2UgY3JlZGl0OiBXU0pbL2NhcHRpb25dXHJcbjxoMz5Qcmlvcml0aXphdGlvbiBwcmluY2lwbGVzOiBpbm5vdmF0aW9uIGNvbm5lY3RlZCB3aXRoIE9LUnM8L2gzPlxyXG5SZWx5aW5nIG11Y2ggb24gcHJvY2Vzc2VzLCB0aGlzIGlzIGEgcmVzdWx0cy1vcmllbnRlZCB1bml0LiBFdmVyeSBwcm9qZWN0IGlzIGNvbm5lY3RlZCB3aXRoIGJyb2FkZXIgc3RyYXRlZ2ljIGdvYWxzLCB3aGljaCBpbmNsdWRlIGRpdmVyc2lmeWluZyBhbmQgZ3Jvd2luZyBuZXcgYXVkaWVuY2UsIGFzIHdlbGwgYXMgZGlmZmVyZW50aWF0aW5nIFdTSlx1MjAxOXMgam91cm5hbGlzbS5cclxuXHJcblx1MjAxY1dlIGFyZSBub3QgZG9pbmcgdGhpbmdzIGp1c3QgZm9yIHRoZSBzYWtlIG9mIGV4cGVyaW1lbnRhdGlvbi4gRXZlcnl0aGluZyB3ZSB3b3JrIG9uIG11c3QgYmUgdGllZCB0byBhIG1lYXN1cmFibGUgb3V0Y29tZSBhbmQsIG1vc3QgaW1wb3J0YW50bHksIGhhdmUgcmVhbCBuZXdzcm9vbSBpbXBhY3QuIEZvciBldmVyeSBwcm9qZWN0IHdlIGRlZmluZSBPS1JzIChvYmplY3RpdmVzIGFuZCBrZXkgcmVzdWx0cyksIGEgcHJvY2VzcyB0aGF0IDxhIGhyZWY9XCJodHRwczovL21lZGl1bS5jb20vZG93am9uZXMvaG93LXRoZS13c2otaW9zLXRlYW0tcHJvbW90ZXMtY3Jvc3MtdGVhbS1jb2xsYWJvcmF0aW9uLXRocm91Z2gtb2tyLWRyaXZlbi1mZWF0dXJlLXJlcXVlc3RzLWEzZjUzNGJjY2NiXCI+d2FzIGludHJvZHVjZWQgYnkgb3VyIGNvbGxlYWd1ZXMgaW4gdGhlIFBERTwvYT4gKHByb2R1Y3QsIGRlc2lnbiBhbmQgZW5naW5lZXJpbmcpIHRlYW1cdTIwMWQuXHJcblxyXG5XaGVuIGRlZmluaW5nIHRoZSBzY29wZSBvZiBuZXcgUiZhbXA7RCB1bmRlcnRha2luZ3MsIHRoZSB0ZWFtIGdvZXMgdGhyb3VnaCBhIHZldHRpbmcgYW5kIHBsYW5uaW5nIHByb2Nlc3MgdG8gZW5zdXJlIHByb2plY3RzIHNhdGlzZnkgdGhlIGZvbGxvd2luZyBndWlkaW5nIHByaW5jaXBsZXM6XHJcbjxvbD5cclxuIFx0PGxpPk5ld3Nyb29tIGltcGFjdDogbm8gdW5zdHJ1Y3R1cmVkIGV4cGVyaW1lbnRzLCBldmVyeSBwcm9qZWN0IG11c3QgaGF2ZSBhIHNwZWNpZmljIHVzZSBjYXNlIGFuZCBvdXRjb21lLjwvbGk+XHJcbiBcdDxsaT5Db2xsYWJvcmF0aW9uIGRlZ3JlZTogaXQgc2hvdWxkIHN1cHBvcnQgZWRpdG9ycyBhbmQgcmVwb3J0ZXJzIGFjcm9zcyBtdWx0aXBsZSBkZXBhcnRtZW50cy48L2xpPlxyXG4gXHQ8bGk+U2NhbGFiaWxpdHk6IHNtYXJ0IHJlc291cmNlIGFsbG9jYXRpb24sIGF2b2lkaW5nIG9uZS1vZmYgcHJvamVjdHMuPC9saT5cclxuIFx0PGxpPkltcGFjdCBvbiBuZXdzZ2F0aGVyaW5nIG9yIHByb2R1Y3Rpb246IHRoZSB0ZWFtXHUyMDE5cyBnb2FsIGlzIHRvIGhlbHAgZXN0YWJsaXNoIGVtZXJnaW5nIGpvdXJuYWxpc3RpYyBwcm9jZXNzZXMsIGFzIG9wcG9zZWQgdG8gbmV3IHByb2R1Y3QgZGV2ZWxvcG1lbnQgKGFuIGVmZm9ydCBsZWQgYnkgYSBkaWZmZXJlbnQgdGVhbSkuPC9saT5cclxuIFx0PGxpPkRlcGxveW1lbnQgb2YgQXJ0aWZpY2lhbCBpbnRlbGxpZ2VuY2UgKEFJKSBhbmQvb3IgbWFjaGluZSBsZWFybmluZyAoTUwpOiB0aG9zZSBhcmUgY29uc2lkZXJlZCB0aGUgdHJhbnNmb3JtYXRpb25hbCBjYXBhYmlsaXRpZXMgbmVjZXNzYXJ5IGZvciB0aGUgbW9kZXJuIG5ld3Nyb29tIGJ5IHRoZSBSJmFtcDtEIHVuaXQ8L2xpPlxyXG48L29sPlxyXG48aDM+UiZhbXA7RCBpbiByZWxhdGlvbiB0byB0aGUgV1NKPC9oMz5cclxuUiZhbXA7RCBpcyBkZXNpZ25lZCB0byBhbGlnbiB3aXRoIHRoZSBvdmVyYWxsIHN0cmF0ZWd5IG9mIHRoZSBuZXdzcm9vbSwgYW5kIGNvb3BlcmF0aW9uIHdpdGggb3RoZXIgdGVhbXMgd2l0aGluIHRoZSBvcmdhbml6YXRpb24gaXMgdGhlcmVmb3JlIGltcG9ydGFudCBhbmQgdmVyeSBtdWNoIGRlc2lyZWQuIE9uZSBleGFtcGxlIGlzIHRoZSBkYXRhIGluZnJhc3RydWN0dXJlIHByb3ZpZGVkIGJ5IERvdyBKb25lcyAoV1NKXHUyMDE5cyBwYXJlbnQgY29tcGFueSksIHdoaWNoIHRoZSBncm91cCByZWxpZXMgb24gaW4gb3JkZXIgdG8gc2NhbGUgaXRzIHByb2plY3RzLlxyXG5cclxuXHUyMDFjU29tZXRoaW5nIHVuaXF1ZSBhYm91dCBkZXZlbG9waW5nIEFJIGNhcGFiaWxpdGllcyBhdCB0aGUgV2FsbCBTdHJlZXQgSm91cm5hbCBpcyB0aGUgc3VwcG9ydCBhbmQgZ3VpZGFuY2Ugd2UgcmVjZWl2ZSBmcm9tIERvdyBKb25lcyB3aGljaCBoYXMgYSBmYW50YXN0aWMgdGVjaG5vbG9neSB0ZWFtLCBhcyB3ZWxsIGFzIHZhc3QgPGEgaHJlZj1cImh0dHBzOi8vbWVkaXVtLmNvbS9kb3dqb25lcy9ob3ctZG93LWpvbmVzLWRuYS1wb3dlcnMtZGF0YS1zY2llbnRpc3RzLXdpdGgtdGhlLXRvb2xzLXRoZXktbmVlZC10by1zdWNjZWVkLThiZjI3Yjg4NzY3MlwiPmRhdGEgc2NpZW5jZSBjYXBhYmlsaXRpZXM8L2E+IHdlIGNhbiBsZXZlcmFnZS5cdTIwMWRcclxuXHJcbkJlc2lkZXMgdGVhbWluZyB1cCB3aXRoIGludGVybmFsIHN0YWtlaG9sZGVycywgUiZhbXA7RCBhbHNvIGVuZ2FnZXMgd2l0aCB1bml2ZXJzaXRpZXMgYW5kIHRlY2hub2xvZ3kgY29tcGFuaWVzIGZvciBzZWxlY3QgcHJvamVjdHMuIEZvciBleGFtcGxlLCBpbiBjb2xsYWJvcmF0aW9uIHdpdGggdGhlIENyYWlnIE5ld21hcmsgR3JhZHVhdGUgU2Nob29sIG9mIEpvdXJuYWxpc20sIHRoZSB0ZWFtIHRlc3RlZCBhbiBlbWVyZ2luZyBuZXdzZ2F0aGVyaW5nIGFwcHJvYWNoLiBUaGV5IGxldmVyYWdlZCBhbiBBSS1wb3dlcmVkIHJlcG9ydGluZyBkZXZpY2UgZGV2ZWxvcGVkIGJ5IDxhIGhyZWY9XCJodHRwczovL3d3dy5jb3J0aWNvLmFpL1wiPkNvcnRpY288L2E+LCBhIFx1MjAxY2RpZ2l0YWwgaGVhcnRoXHUyMDFkIHRoYXQgZHluYW1pY2FsbHkgcmVjb3JkcyBhbmQgc3RydWN0dXJlcyBpbnRlcnZpZXdzIGFzIHRoZSBqb3VybmFsaXN0IGd1aWRlcyBzdWJqZWN0cyB0aHJvdWdoIHF1ZXN0aW9ucyBhYm91dCBsb2NhbGx5IHJlbGV2YW50IHRvcGljcy5cclxuXHJcbltjYXB0aW9uIGlkPVwiYXR0YWNobWVudF8xNTE3MVwiIGFsaWduPVwiYWxpZ25jZW50ZXJcIiB3aWR0aD1cIjEwMjRcIl08aW1nIGNsYXNzPVwid3AtaW1hZ2UtMTUxNzEgc2l6ZS1sYXJnZVwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE5LzA2L0ZpZ3VyZTMtMTAyNHg3NjguanBnXCIgYWx0PVwiXCIgd2lkdGg9XCIxMDI0XCIgaGVpZ2h0PVwiNzY4XCIgLz4gUGFydGljaXBhbnRzIGF0IFdTSiBldmVudCBlbmdhZ2Ugd2l0aCBhIFwiZGlnaXRhbCBoZWFydGhcIiBkZXZlbG9wZWQgYnkgQ29ydGljby4gVGhlIEFJLXBvd2VyZWQgZGV2aWNlIGluZ2VzdHMgYXVkaW8gcmVzcG9uc2VzIGFuZCBzdHJ1Y3R1cmVzIGNvbnRlbnQgdG8gaGVscCBqb3VybmFsaXN0cyBmaW5kIGVkaXRvcmlhbCBpbnNpZ2h0cy4gSW1hZ2UgY3JlZGl0OiBXU0pbL2NhcHRpb25dXHJcblxyXG5BcyBmb3IgZnV0dXJlIGdvYWxzLCBNYXJjb25pIGV4cGxhaW5zIHRoYXQgUiZhbXA7RFx1MjAxOXMgYW1iaXRpb24gaXMgdG8gaGVscCBkZW1vY3JhdGl6ZSBkYXRhIHNjaWVuY2UgYW5kIEFJIHByYWN0aWNlcyB0aHJvdWdob3V0IHRoZSBuZXdzcm9vbSB3aGlsZSBidWlsZGluZyBvbiBjb3JlIGpvdXJuYWxpc3RpYyBza2lsbHMgYW5kIHRhbGVudHMuXHJcblxyXG5cdTIwMWNUaGVzZSBzbWFydCB0b29scyBjYW4gYXVnbWVudCB0aGUgd29yayBvZiBvdXIgdGFsZW50ZWQgam91cm5hbGlzdHMsIGJ1dCB0aGV5IGNhblx1MjAxOXQgcmVwbGljYXRlIHRoZWlyIGpvdXJuYWxpc3RpYyBpbnN0aW5jdC4gQWx0aG91Z2ggdGVjaG5vbG9neSBpcyBpbmNyZWFzaW5nbHkgaW1wYWN0ZnVsIGluIHRoZSBtb2Rlcm4gbWVkaWEgbGFuZHNjYXBlLCB0aGUgZWRpdG9yaWFsIHByb2Nlc3Mgd2lsbCBhbHdheXMgYmUgZHJpdmVuIGJ5IGh1bWFucyxcdTIwMWQgTWFyY29uaSBzYWlkLlxyXG5cclxuQ09OVEFDVCBQT0lOVFxyXG5cclxuPGltZyBjbGFzcz1cImFsaWdubm9uZSBzaXplLW1lZGl1bSB3cC1pbWFnZS0xNTE2NFwiIHN0eWxlPVwiZm9udC1mYW1pbHk6IC1hcHBsZS1zeXN0ZW0sIEJsaW5rTWFjU3lzdGVtRm9udCwgJ1NlZ29lIFVJJywgUm9ib3RvLCBPeHlnZW4tU2FucywgVWJ1bnR1LCBDYW50YXJlbGwsICdIZWx2ZXRpY2EgTmV1ZScsIHNhbnMtc2VyaWY7XCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTkvMDYvRnJhbmNlc2NvLU1hcmNvbmktMzAweDE2OS5wbmdcIiBhbHQ9XCJcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjE2OVwiIC8+XHJcblxyXG5GcmFuY2VzY28gTWFyY29uaSwgV1NKIFImYW1wO0QgQ2hpZWZcclxuXHJcblR3aXR0ZXI6IDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2ZwbWFyY29uaT9sYW5nPWVuLVwiPkBmcG1hcmNvbmk8L2E+Wy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjIvM1wiXVt2Y19jb2x1bW5fdGV4dF1cclxuPGgzPkF1dGhvcjwvaDM+XHJcbltzaW1wbGUtYXV0aG9yLWJveF1bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd10iLCJwb3N0X3RpdGxlIjoiV1NKIFImIzAzODtEOiBicmluZ2luZyBkYXRhIHNjaWVuY2UgYW5kIEFJIGNhcGFiaWxpdGllcyB0byB0aGUgbmV3c3Jvb20iLCJwb3N0X2xpbmsiOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvd3NqLXJkLWJyaW5naW5nLWRhdGEtc2NpZW5jZS1hbmQtYWktY2FwYWJpbGl0aWVzLXRvLXRoZS1uZXdzcm9vbS8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJXU0ogUiYjMDM4O0Q6IGJyaW5naW5nIGRhdGEgc2NpZW5jZSBhbmQgQUkgY2FwYWJpbGl0aWVzIHRvIHRoZSBuZXdzcm9vbVwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTkvMDYvRmlndXJlLTEtMzAweDIwMC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj4iLCJwb3N0X2NhdGVnb3JpZXMiOiJNZWRpYSBsYWJzIiwicG9zdF90YWdzIjoiIiwiJV9lZGl0X2xvY2slIjoiMTU4MTQzOTY3MDo5MzEiLCIlX29lbWJlZF80M2I0NTBlMWQyYzAwZGIyYzA5ZjM4NGJjNDNmMmUwOSUiOiI8YmxvY2txdW90ZSBjbGFzcz1cInR3aXR0ZXItdHdlZXRcIiBkYXRhLXdpZHRoPVwiNTUwXCIgZGF0YS1kbnQ9XCJ0cnVlXCI+PHAgbGFuZz1cImVuXCIgZGlyPVwibHRyXCI+LjxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL1dTSj9yZWZfc3JjPXR3c3JjJTVFdGZ3XCI+QFdTSjwvYT4gaXMgZGVjZW50cmFsaXppbmcgaW5ub3ZhdGlvbiBieSBpbnZpdGluZyBvdXIgam91cm5hbGlzdHMgdG8gcGFydGljaXBhdGUgaW4gdGhlIHByb2Nlc3MhIFdlIGxhdW5jaGVkIGFuIGludGVybmFsIHBsYXRmb3JtIHdoZXJlIHN0YWZmIGNhbiBzdWJtaXQgbmV3IGlkZWFzIHdoaWNoIGFyZSB0aGVuIHJldmlld2VkIGJ5IGEgY3Jvc3MgZnVuY3Rpb25hbCBncm91cCBhbmQgbGF0ZXIgZXZhbHVhdGVkIGFjY29yZGluZyB0byBhIHNldCBvZiBzdHJhdGVnaWMgY3JpdGVyaWE/IDxhIGhyZWY9XCJodHRwczovL3QuY28vNWp4QTMyQzFIRlwiPnBpYy50d2l0dGVyLmNvbS81anhBMzJDMUhGPC9hPjwvcD4mbWRhc2g7IEZyYW5jZXNjbyBNYXJjb25pIChAZnBtYXJjb25pKSA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9mcG1hcmNvbmkvc3RhdHVzLzEwOTA2MTA3OTEwNDMyNjg2MDk/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkphbnVhcnkgMzAsIDIwMTk8L2E+PC9ibG9ja3F1b3RlPjxzY3JpcHQgYXN5bmMgc3JjPVwiaHR0cHM6Ly9wbGF0Zm9ybS50d2l0dGVyLmNvbS93aWRnZXRzLmpzXCIgY2hhcnNldD1cInV0Zi04XCI+PC9zY3JpcHQ+IiwiJV9vZW1iZWRfdGltZV80M2I0NTBlMWQyYzAwZGIyYzA5ZjM4NGJjNDNmMmUwOSUiOiIxNTYxNTUyNDM1IiwiJV9lZGl0X2xhc3QlIjoiOTMxIiwiJXNsaWRlX3RlbXBsYXRlJSI6ImRlZmF1bHQiLCIlX3dwYl92Y19qc19zdGF0dXMlIjoidHJ1ZSIsIiVfd3BnbXBfbG9jYXRpb25fYWRkcmVzcyUiOiJOZXcgWW9yaywgTlksIFVTQSIsIiVfd3BnbXBfbG9jYXRpb25fY2l0eSUiOiJOZXcgWW9yayIsIiVfd3BnbXBfbG9jYXRpb25fc3RhdGUlIjoiTmV3IFlvcmsiLCIlX3dwZ21wX2xvY2F0aW9uX2NvdW50cnklIjoiVW5pdGVkIFN0YXRlcyIsIiVfd3BnbXBfbWV0YWJveF9sYXRpdHVkZSUiOiI0MC43MTI3NzUzIiwiJV93cGdtcF9tZXRhYm94X2xvbmdpdHVkZSUiOiItNzQuMDA1OTcyOCIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiMlwiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6Ik47IiwiJV93cGdtcF9tZXRhYm94X3RheG9tb21pZXNfdGVybXMlIjoiTjsiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6Ik47IiwiJV9rbGVvX3RyYW5zcGFyZW50X21lbnVfY29sb3IlIjoid2hpdGUiLCIlX2tsZW9fdGl0bGVfY2hlY2tib3glIjoiMSIsIiVfa2xlb190aXRsZV9jb2xvciUiOiIjIiwiJV9rbGVvX3RpdGxlX2JnJSI6IiwgcmVwZWF0LCBpbmhlcml0LCBzY3JvbGwsIGxlZnQgdG9wIiwiJV9rbGVvX3RpdGxlX2JnX2NvbG9yJSI6IiMiLCIlX3lvYXN0X3dwc2VvX2NvbnRlbnRfc2NvcmUlIjoiMzAiLCIlX29lbWJlZF9kMDgwNmE4YTgwMWY0YjIzZWE4MTkzYTQyOWNmZWU0MyUiOiI8YmxvY2txdW90ZSBjbGFzcz1cInR3aXR0ZXItdHdlZXRcIiBkYXRhLXdpZHRoPVwiNTUwXCIgZGF0YS1kbnQ9XCJ0cnVlXCI+PHAgbGFuZz1cImVuXCIgZGlyPVwibHRyXCI+LjxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL1dTSj9yZWZfc3JjPXR3c3JjJTVFdGZ3XCI+QFdTSjwvYT4gaXMgZGVjZW50cmFsaXppbmcgaW5ub3ZhdGlvbiBieSBpbnZpdGluZyBvdXIgam91cm5hbGlzdHMgdG8gcGFydGljaXBhdGUgaW4gdGhlIHByb2Nlc3MhIFdlIGxhdW5jaGVkIGFuIGludGVybmFsIHBsYXRmb3JtIHdoZXJlIHN0YWZmIGNhbiBzdWJtaXQgbmV3IGlkZWFzIHdoaWNoIGFyZSB0aGVuIHJldmlld2VkIGJ5IGEgY3Jvc3MgZnVuY3Rpb25hbCBncm91cCBhbmQgbGF0ZXIgZXZhbHVhdGVkIGFjY29yZGluZyB0byBhIHNldCBvZiBzdHJhdGVnaWMgY3JpdGVyaWE/IDxhIGhyZWY9XCJodHRwczovL3QuY28vNWp4QTMyQzFIRlwiPnBpYy50d2l0dGVyLmNvbS81anhBMzJDMUhGPC9hPjwvcD4mbWRhc2g7IEZyYW5jZXNjbyBNYXJjb25pIChAZnBtYXJjb25pKSA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9mcG1hcmNvbmkvc3RhdHVzLzEwOTA2MTA3OTEwNDMyNjg2MDk/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkphbnVhcnkgMzAsIDIwMTk8L2E+PC9ibG9ja3F1b3RlPjxzY3JpcHQgYXN5bmMgc3JjPVwiaHR0cHM6Ly9wbGF0Zm9ybS50d2l0dGVyLmNvbS93aWRnZXRzLmpzXCIgY2hhcnNldD1cInV0Zi04XCI+PC9zY3JpcHQ+IiwiJV9vZW1iZWRfdGltZV9kMDgwNmE4YTgwMWY0YjIzZWE4MTkzYTQyOWNmZWU0MyUiOiIxNTc1MDMzNDM4IiwiJV95b2FzdF93cHNlb19wcmltYXJ5X2NhdGVnb3J5JSI6IjE0MiIsIiVfb2VtYmVkXzBhNzdiYTk3Y2M1MmIzYmJiMzliMjJhZjQwZDJlOTk5JSI6IjxibG9ja3F1b3RlIGNsYXNzPVwidHdpdHRlci10d2VldFwiIGRhdGEtd2lkdGg9XCI0NzdcIiBkYXRhLWRudD1cInRydWVcIj48cCBsYW5nPVwiZW5cIiBkaXI9XCJsdHJcIj4uPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vV1NKP3JlZl9zcmM9dHdzcmMlNUV0ZndcIj5AV1NKPC9hPiBpcyBkZWNlbnRyYWxpemluZyBpbm5vdmF0aW9uIGJ5IGludml0aW5nIG91ciBqb3VybmFsaXN0cyB0byBwYXJ0aWNpcGF0ZSBpbiB0aGUgcHJvY2VzcyEgV2UgbGF1bmNoZWQgYW4gaW50ZXJuYWwgcGxhdGZvcm0gd2hlcmUgc3RhZmYgY2FuIHN1Ym1pdCBuZXcgaWRlYXMgd2hpY2ggYXJlIHRoZW4gcmV2aWV3ZWQgYnkgYSBjcm9zcyBmdW5jdGlvbmFsIGdyb3VwIGFuZCBsYXRlciBldmFsdWF0ZWQgYWNjb3JkaW5nIHRvIGEgc2V0IG9mIHN0cmF0ZWdpYyBjcml0ZXJpYT8gPGEgaHJlZj1cImh0dHBzOi8vdC5jby81anhBMzJDMUhGXCI+cGljLnR3aXR0ZXIuY29tLzVqeEEzMkMxSEY8L2E+PC9wPiZtZGFzaDsgRnJhbmNlc2NvIE1hcmNvbmkgKEBmcG1hcmNvbmkpIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2ZwbWFyY29uaS9zdGF0dXMvMTA5MDYxMDc5MTA0MzI2ODYwOT9yZWZfc3JjPXR3c3JjJTVFdGZ3XCI+SmFudWFyeSAzMCwgMjAxOTwvYT48L2Jsb2NrcXVvdGU+PHNjcmlwdCBhc3luYyBzcmM9XCJodHRwczovL3BsYXRmb3JtLnR3aXR0ZXIuY29tL3dpZGdldHMuanNcIiBjaGFyc2V0PVwidXRmLThcIj48L3NjcmlwdD4iLCIlX29lbWJlZF90aW1lXzBhNzdiYTk3Y2M1MmIzYmJiMzliMjJhZjQwZDJlOTk5JSI6IjE1NjE1NTI0NzkiLCIlX3RodW1ibmFpbF9pZCUiOiIxNTE2OSIsIiVfb2VtYmVkXzgyODJjYTk2YjRmNjg1NmEyZjQzYzE3MWM0MTQxODljJSI6IjxibG9ja3F1b3RlIGNsYXNzPVwidHdpdHRlci10d2VldFwiIGRhdGEtd2lkdGg9XCI0ODJcIiBkYXRhLWRudD1cInRydWVcIj48cCBsYW5nPVwiZW5cIiBkaXI9XCJsdHJcIj4uPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vV1NKP3JlZl9zcmM9dHdzcmMlNUV0ZndcIj5AV1NKPC9hPiBpcyBkZWNlbnRyYWxpemluZyBpbm5vdmF0aW9uIGJ5IGludml0aW5nIG91ciBqb3VybmFsaXN0cyB0byBwYXJ0aWNpcGF0ZSBpbiB0aGUgcHJvY2VzcyEgV2UgbGF1bmNoZWQgYW4gaW50ZXJuYWwgcGxhdGZvcm0gd2hlcmUgc3RhZmYgY2FuIHN1Ym1pdCBuZXcgaWRlYXMgd2hpY2ggYXJlIHRoZW4gcmV2aWV3ZWQgYnkgYSBjcm9zcyBmdW5jdGlvbmFsIGdyb3VwIGFuZCBsYXRlciBldmFsdWF0ZWQgYWNjb3JkaW5nIHRvIGEgc2V0IG9mIHN0cmF0ZWdpYyBjcml0ZXJpYT8gPGEgaHJlZj1cImh0dHBzOi8vdC5jby81anhBMzJDMUhGXCI+cGljLnR3aXR0ZXIuY29tLzVqeEEzMkMxSEY8L2E+PC9wPiZtZGFzaDsgRnJhbmNlc2NvIE1hcmNvbmkgKEBmcG1hcmNvbmkpIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2ZwbWFyY29uaS9zdGF0dXMvMTA5MDYxMDc5MTA0MzI2ODYwOT9yZWZfc3JjPXR3c3JjJTVFdGZ3XCI+SmFudWFyeSAzMCwgMjAxOTwvYT48L2Jsb2NrcXVvdGU+PHNjcmlwdCBhc3luYyBzcmM9XCJodHRwczovL3BsYXRmb3JtLnR3aXR0ZXIuY29tL3dpZGdldHMuanNcIiBjaGFyc2V0PVwidXRmLThcIj48L3NjcmlwdD4iLCIlX29lbWJlZF90aW1lXzgyODJjYTk2YjRmNjg1NmEyZjQzYzE3MWM0MTQxODljJSI6IjE1NjE1NTI3NTMiLCIlX29lbWJlZF9hMWUzZGQ0YzRhY2I0YzJlNWZlM2Q3OGM1NzllZTI2NiUiOiI8YmxvY2txdW90ZSBjbGFzcz1cInR3aXR0ZXItdHdlZXRcIiBkYXRhLXdpZHRoPVwiNDcyXCIgZGF0YS1kbnQ9XCJ0cnVlXCI+PHAgbGFuZz1cImVuXCIgZGlyPVwibHRyXCI+LjxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL1dTSj9yZWZfc3JjPXR3c3JjJTVFdGZ3XCI+QFdTSjwvYT4gaXMgZGVjZW50cmFsaXppbmcgaW5ub3ZhdGlvbiBieSBpbnZpdGluZyBvdXIgam91cm5hbGlzdHMgdG8gcGFydGljaXBhdGUgaW4gdGhlIHByb2Nlc3MhIFdlIGxhdW5jaGVkIGFuIGludGVybmFsIHBsYXRmb3JtIHdoZXJlIHN0YWZmIGNhbiBzdWJtaXQgbmV3IGlkZWFzIHdoaWNoIGFyZSB0aGVuIHJldmlld2VkIGJ5IGEgY3Jvc3MgZnVuY3Rpb25hbCBncm91cCBhbmQgbGF0ZXIgZXZhbHVhdGVkIGFjY29yZGluZyB0byBhIHNldCBvZiBzdHJhdGVnaWMgY3JpdGVyaWE/IDxhIGhyZWY9XCJodHRwczovL3QuY28vNWp4QTMyQzFIRlwiPnBpYy50d2l0dGVyLmNvbS81anhBMzJDMUhGPC9hPjwvcD4mbWRhc2g7IEZyYW5jZXNjbyBNYXJjb25pIChAZnBtYXJjb25pKSA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9mcG1hcmNvbmkvc3RhdHVzLzEwOTA2MTA3OTEwNDMyNjg2MDk/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkphbnVhcnkgMzAsIDIwMTk8L2E+PC9ibG9ja3F1b3RlPjxzY3JpcHQgYXN5bmMgc3JjPVwiaHR0cHM6Ly9wbGF0Zm9ybS50d2l0dGVyLmNvbS93aWRnZXRzLmpzXCIgY2hhcnNldD1cInV0Zi04XCI+PC9zY3JpcHQ+IiwiJV9vZW1iZWRfdGltZV9hMWUzZGQ0YzRhY2I0YzJlNWZlM2Q3OGM1NzllZTI2NiUiOiIxNTYyMzE0ODA1IiwiJV9vZW1iZWRfZDU3MDZlNjMzNmRkMGI3Mjg5MDNkZDcwOGEzY2QxYTYlIjoiPGJsb2NrcXVvdGUgY2xhc3M9XCJ0d2l0dGVyLXR3ZWV0XCIgZGF0YS13aWR0aD1cIjQ3NVwiIGRhdGEtZG50PVwidHJ1ZVwiPjxwIGxhbmc9XCJlblwiIGRpcj1cImx0clwiPi48YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9XU0o/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkBXU0o8L2E+IGlzIGRlY2VudHJhbGl6aW5nIGlubm92YXRpb24gYnkgaW52aXRpbmcgb3VyIGpvdXJuYWxpc3RzIHRvIHBhcnRpY2lwYXRlIGluIHRoZSBwcm9jZXNzISBXZSBsYXVuY2hlZCBhbiBpbnRlcm5hbCBwbGF0Zm9ybSB3aGVyZSBzdGFmZiBjYW4gc3VibWl0IG5ldyBpZGVhcyB3aGljaCBhcmUgdGhlbiByZXZpZXdlZCBieSBhIGNyb3NzIGZ1bmN0aW9uYWwgZ3JvdXAgYW5kIGxhdGVyIGV2YWx1YXRlZCBhY2NvcmRpbmcgdG8gYSBzZXQgb2Ygc3RyYXRlZ2ljIGNyaXRlcmlhPyA8YSBocmVmPVwiaHR0cHM6Ly90LmNvLzVqeEEzMkMxSEZcIj5waWMudHdpdHRlci5jb20vNWp4QTMyQzFIRjwvYT48L3A+Jm1kYXNoOyBGcmFuY2VzY28gTWFyY29uaSAoQGZwbWFyY29uaSkgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vZnBtYXJjb25pL3N0YXR1cy8xMDkwNjEwNzkxMDQzMjY4NjA5P3JlZl9zcmM9dHdzcmMlNUV0ZndcIj5KYW51YXJ5IDMwLCAyMDE5PC9hPjwvYmxvY2txdW90ZT48c2NyaXB0IGFzeW5jIHNyYz1cImh0dHBzOi8vcGxhdGZvcm0udHdpdHRlci5jb20vd2lkZ2V0cy5qc1wiIGNoYXJzZXQ9XCJ1dGYtOFwiPjwvc2NyaXB0PiIsIiVfb2VtYmVkX3RpbWVfZDU3MDZlNjMzNmRkMGI3Mjg5MDNkZDcwOGEzY2QxYTYlIjoiMTU2MjMxNTA2MyIsIiVfb2VtYmVkX2EyMTFkZjU3YjJkMGU4ODA5NWI1ZGM1NzNhMDc5ZDRiJSI6IjxibG9ja3F1b3RlIGNsYXNzPVwidHdpdHRlci10d2VldFwiIGRhdGEtd2lkdGg9XCI0NzNcIiBkYXRhLWRudD1cInRydWVcIj48cCBsYW5nPVwiZW5cIiBkaXI9XCJsdHJcIj4uPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vV1NKP3JlZl9zcmM9dHdzcmMlNUV0ZndcIj5AV1NKPC9hPiBpcyBkZWNlbnRyYWxpemluZyBpbm5vdmF0aW9uIGJ5IGludml0aW5nIG91ciBqb3VybmFsaXN0cyB0byBwYXJ0aWNpcGF0ZSBpbiB0aGUgcHJvY2VzcyEgV2UgbGF1bmNoZWQgYW4gaW50ZXJuYWwgcGxhdGZvcm0gd2hlcmUgc3RhZmYgY2FuIHN1Ym1pdCBuZXcgaWRlYXMgd2hpY2ggYXJlIHRoZW4gcmV2aWV3ZWQgYnkgYSBjcm9zcyBmdW5jdGlvbmFsIGdyb3VwIGFuZCBsYXRlciBldmFsdWF0ZWQgYWNjb3JkaW5nIHRvIGEgc2V0IG9mIHN0cmF0ZWdpYyBjcml0ZXJpYT8gPGEgaHJlZj1cImh0dHBzOi8vdC5jby81anhBMzJDMUhGXCI+cGljLnR3aXR0ZXIuY29tLzVqeEEzMkMxSEY8L2E+PC9wPiZtZGFzaDsgRnJhbmNlc2NvIE1hcmNvbmkgKEBmcG1hcmNvbmkpIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2ZwbWFyY29uaS9zdGF0dXMvMTA5MDYxMDc5MTA0MzI2ODYwOT9yZWZfc3JjPXR3c3JjJTVFdGZ3XCI+SmFudWFyeSAzMCwgMjAxOTwvYT48L2Jsb2NrcXVvdGU+PHNjcmlwdCBhc3luYyBzcmM9XCJodHRwczovL3BsYXRmb3JtLnR3aXR0ZXIuY29tL3dpZGdldHMuanNcIiBjaGFyc2V0PVwidXRmLThcIj48L3NjcmlwdD4iLCIlX29lbWJlZF90aW1lX2EyMTFkZjU3YjJkMGU4ODA5NWI1ZGM1NzNhMDc5ZDRiJSI6IjE1NjIzMTUxMDMiLCIlc2JnX3NlbGVjdGVkX3NpZGViYXIlIjoiMCIsIiVzYmdfc2VsZWN0ZWRfc2lkZWJhcl9yZXBsYWNlbWVudCUiOiIwIiwiJV9vZW1iZWRfMTFmOGRiNTQ3YmM4Y2FlMDIxNjZkZDRmOGNhM2FhYjUlIjoiPGJsb2NrcXVvdGUgY2xhc3M9XCJ0d2l0dGVyLXR3ZWV0XCIgZGF0YS13aWR0aD1cIjU1MFwiIGRhdGEtZG50PVwidHJ1ZVwiPjxwIGxhbmc9XCJlblwiIGRpcj1cImx0clwiPi48YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9XU0o/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkBXU0o8L2E+IGlzIGRlY2VudHJhbGl6aW5nIGlubm92YXRpb24gYnkgaW52aXRpbmcgb3VyIGpvdXJuYWxpc3RzIHRvIHBhcnRpY2lwYXRlIGluIHRoZSBwcm9jZXNzISBXZSBsYXVuY2hlZCBhbiBpbnRlcm5hbCBwbGF0Zm9ybSB3aGVyZSBzdGFmZiBjYW4gc3VibWl0IG5ldyBpZGVhcyB3aGljaCBhcmUgdGhlbiByZXZpZXdlZCBieSBhIGNyb3NzIGZ1bmN0aW9uYWwgZ3JvdXAgYW5kIGxhdGVyIGV2YWx1YXRlZCBhY2NvcmRpbmcgdG8gYSBzZXQgb2Ygc3RyYXRlZ2ljIGNyaXRlcmlhPyA8YSBocmVmPVwiaHR0cHM6Ly90LmNvLzVqeEEzMkMxSEZcIj5waWMudHdpdHRlci5jb20vNWp4QTMyQzFIRjwvYT48L3A+Jm1kYXNoOyBGcmFuY2VzY28gTWFyY29uaSAoQGZwbWFyY29uaSkgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vZnBtYXJjb25pL3N0YXR1cy8xMDkwNjEwNzkxMDQzMjY4NjA5P3JlZl9zcmM9dHdzcmMlNUV0ZndcIj5KYW51YXJ5IDMwLCAyMDE5PC9hPjwvYmxvY2txdW90ZT48c2NyaXB0IGFzeW5jIHNyYz1cImh0dHBzOi8vcGxhdGZvcm0udHdpdHRlci5jb20vd2lkZ2V0cy5qc1wiIGNoYXJzZXQ9XCJ1dGYtOFwiPjwvc2NyaXB0PiIsIiVfb2VtYmVkX3RpbWVfMTFmOGRiNTQ3YmM4Y2FlMDIxNjZkZDRmOGNhM2FhYjUlIjoiMTU3NTAzMzQ0MSIsIiVfb2VtYmVkX2E1MGM2NWQ3Mjc4MWYzMTZkODkxY2U2ZjRiNmE1NDI1JSI6IjxibG9ja3F1b3RlIGNsYXNzPVwidHdpdHRlci10d2VldFwiIGRhdGEtd2lkdGg9XCI1MTJcIiBkYXRhLWRudD1cInRydWVcIj48cCBsYW5nPVwiZW5cIiBkaXI9XCJsdHJcIj4uPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vV1NKP3JlZl9zcmM9dHdzcmMlNUV0ZndcIj5AV1NKPC9hPiBpcyBkZWNlbnRyYWxpemluZyBpbm5vdmF0aW9uIGJ5IGludml0aW5nIG91ciBqb3VybmFsaXN0cyB0byBwYXJ0aWNpcGF0ZSBpbiB0aGUgcHJvY2VzcyEgV2UgbGF1bmNoZWQgYW4gaW50ZXJuYWwgcGxhdGZvcm0gd2hlcmUgc3RhZmYgY2FuIHN1Ym1pdCBuZXcgaWRlYXMgd2hpY2ggYXJlIHRoZW4gcmV2aWV3ZWQgYnkgYSBjcm9zcyBmdW5jdGlvbmFsIGdyb3VwIGFuZCBsYXRlciBldmFsdWF0ZWQgYWNjb3JkaW5nIHRvIGEgc2V0IG9mIHN0cmF0ZWdpYyBjcml0ZXJpYT8gPGEgaHJlZj1cImh0dHBzOi8vdC5jby81anhBMzJDMUhGXCI+cGljLnR3aXR0ZXIuY29tLzVqeEEzMkMxSEY8L2E+PC9wPiZtZGFzaDsgRnJhbmNlc2NvIE1hcmNvbmkgKEBmcG1hcmNvbmkpIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2ZwbWFyY29uaS9zdGF0dXMvMTA5MDYxMDc5MTA0MzI2ODYwOT9yZWZfc3JjPXR3c3JjJTVFdGZ3XCI+SmFudWFyeSAzMCwgMjAxOTwvYT48L2Jsb2NrcXVvdGU+PHNjcmlwdCBhc3luYyBzcmM9XCJodHRwczovL3BsYXRmb3JtLnR3aXR0ZXIuY29tL3dpZGdldHMuanNcIiBjaGFyc2V0PVwidXRmLThcIj48L3NjcmlwdD4iLCIlX29lbWJlZF90aW1lX2E1MGM2NWQ3Mjc4MWYzMTZkODkxY2U2ZjRiNmE1NDI1JSI6IjE1ODE0Mzk4MDciLCJ0YXhvbm9teT1jYXRlZ29yeSI6Ik1lZGlhIGxhYnMiLCJ0YXhvbm9teT1wb3N0X3RhZyI6IiJ9LCJpY29uIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTgvMDIvbWFya2VyLTEucG5nIn0sImlkIjoxNTE2NywiaW5mb3dpbmRvd19kaXNhYmxlIjpmYWxzZX0seyJzb3VyY2UiOiJwb3N0IiwidGl0bGUiOiJMYSBDb21wYWduaWUgUm90YXRpdmUsIGlubm92YXRpb24gdGhyb3VnaCBwcm94aW1pdHkiLCJpbmZvd2luZG93X2NvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIkxhIENvbXBhZ25pZSBSb3RhdGl2ZSwgaW5ub3ZhdGlvbiB0aHJvdWdoIHByb3hpbWl0eVwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMTU3XCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTkvMDQvb3Blbi1ncmFwaC0zMDB4MTU3LmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmdcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXBhZGRpbmctY29udGVudF8yMFwiPlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLW1ldGEgZmMtaXRlbS1zZWNvbmRhcnktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZSBmYy10ZXh0LWNlbnRlclwiPk1lZGlhIGxhYnM8L2Rpdj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS10aXRsZSBmYy1pdGVtLXByaW1hcnktdGV4dC1jb2xvciBmYy10ZXh0LWNlbnRlclwiPkxhIENvbXBhZ25pZSBSb3RhdGl2ZSwgaW5ub3ZhdGlvbiB0aHJvdWdoIHByb3hpbWl0eTwvZGl2PlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2VcIj5cclxuICAgICAgICAgICAgXHUyMDFjTGEgQ29tcGFnbmllIFJvdGF0aXZlIGlzIHRoZSBtZWRpYSBsYWIgb2YgcHJveGltaXRpZXMuXHUyMDFkIFRoaXMgcGhyYXNlIHN1bW1hcmlzZXMgd2VsbCB0aGUgcGhpbG9zb3BoeSBiZWhpbmQgdGhlIG1lZGlhIGxhYiBvZiB0aGUgZ3JvdXAgQ2VudHJlIEZyYW5jZS4gSXRzIGFwcHJvYWNoIHRvIGlubm92YXRpb24gaXMgYmFzZWQgb24gY2xvc2VuZXNzIGJldHdlZW4gcGVvcGxlLCBsb2NhbCBlY29ub21pYyBhY3RvcnMsIGFuZCBjaXRpemVucywgYXMgd2VsbCBhcyBzaGFyaW5nIGFuZCBjcmVhdGluZyBjb25uZWN0aW9ucy5cclxuICAgICAgICA8L2Rpdj5cclxuPGEgaHJlZj1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9sYS1jb21wYWduaWUtcm90YXRpdmUtaW5ub3ZhdGlvbi10aHJvdWdoLXByb3hpbWl0eS9cIj5SZWFkIG1vcmU8L2E+XHJcbiAgICA8L2Rpdj5cclxuICAgIDwvZGl2PlxyXG48L2Rpdj5cclxuXHJcbiIsImNvbnRlbnQiOiJcdTIwMWNMYSBDb21wYWduaWUgUm90YXRpdmUgaXMgdGhlIG1lZGlhIGxhYiBvZiBwcm94aW1pdGllcy5cdTIwMWQgVGhpcyBwaHJhc2Ugc3VtbWFyaXNlcyB3ZWxsIHRoZSBwaGlsb3NvcGh5IGJlaGluZCB0aGUgbWVkaWEgbGFiIG9mIHRoZSBncm91cCBDZW50cmUgRnJhbmNlLiBJdHMgYXBwcm9hY2ggdG8gaW5ub3ZhdGlvbiBpcyBiYXNlZCBvbiBjbG9zZW5lc3MgYmV0d2VlbiBwZW9wbGUsIGxvY2FsIGVjb25vbWljIGFjdG9ycywgYW5kIGNpdGl6ZW5zLCBhcyB3ZWxsIGFzIHNoYXJpbmcgYW5kIGNyZWF0aW5nIGNvbm5lY3Rpb25zLiIsImFkZHJlc3MiOiJDbGVybW9udC1GZXJyYW5kLCBGcmFuY2UiLCJsb2NhdGlvbiI6eyJsYXQiOiI0NS43NzcyMjE5OTk5OTk5OSIsImNpdHkiOiJDbGVybW9udC1GZXJyYW5kIiwic3RhdGUiOiJBdXZlcmduZS1SaFx1MDBmNG5lLUFscGVzIiwiY291bnRyeSI6IkZyYW5jZSIsImxuZyI6IjMuMDg3MDI1MDAwMDAwMDM5NyIsIm9uY2xpY2tfYWN0aW9uIjoibWFya2VyIiwicmVkaXJlY3RfcGVybWFsaW5rIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL2xhLWNvbXBhZ25pZS1yb3RhdGl2ZS1pbm5vdmF0aW9uLXRocm91Z2gtcHJveGltaXR5LyIsInpvb20iOjIsImV4dHJhX2ZpZWxkcyI6eyJwb3N0X2V4Y2VycHQiOiJcdTIwMWNMYSBDb21wYWduaWUgUm90YXRpdmUgaXMgdGhlIG1lZGlhIGxhYiBvZiBwcm94aW1pdGllcy5cdTIwMWQgVGhpcyBwaHJhc2Ugc3VtbWFyaXNlcyB3ZWxsIHRoZSBwaGlsb3NvcGh5IGJlaGluZCB0aGUgbWVkaWEgbGFiIG9mIHRoZSBncm91cCBDZW50cmUgRnJhbmNlLiBJdHMgYXBwcm9hY2ggdG8gaW5ub3ZhdGlvbiBpcyBiYXNlZCBvbiBjbG9zZW5lc3MgYmV0d2VlbiBwZW9wbGUsIGxvY2FsIGVjb25vbWljIGFjdG9ycywgYW5kIGNpdGl6ZW5zLCBhcyB3ZWxsIGFzIHNoYXJpbmcgYW5kIGNyZWF0aW5nIGNvbm5lY3Rpb25zLiIsInBvc3RfY29udGVudCI6Ilt2Y19yb3ddW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIyLzNcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxoMT5MYSBDb21wYWduaWUgUm90YXRpdmUsIGlubm92YXRpb24gdGhyb3VnaCBwcm94aW1pdHk8L2gxPlxyXG48ZW0+V2UgYXJlIHJlcHVibGlzaGluZyB0aGlzIGFydGljbGUsIG9yaWdpbmFsbHkgcHVibGlzaGVkIG9uIDxhIGhyZWY9XCJodHRwczovL3d3dy5tZXRhLW1lZGlhLmZyLzIwMTkvMDQvMTcvbGEtY29tcGFnbmllLXJvdGF0aXZlLWxpbm5vdmF0aW9uLXBhci1sYS1wcm94aW1pdGUuaHRtbFwiPk1cdTAwZTl0YS1NZWRpYTwvYT4sIGFzIHBhcnQgb2YgYW4gZWRpdG9yaWFsIHBhcnRuZXJzaGlwIGJldHdlZW4gTVx1MDBlOXRhLU1lZGlhIGFuZCBXQU4tSUZSQS4gVGhlIGFydGljbGUgd2FzIHdyaXR0ZW4gYnkgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vYWxleF9ib3VuaW9sXCI+QWxleGFuZHJlIEJvdW5pb2w8L2E+LCBGcmFuY2UgVFx1MDBlOWxcdTAwZTl2aXNpb25zLCBNZWRpYUxhYi48L2VtPlxyXG5cclxuXHUyMDFjTGEgQ29tcGFnbmllIFJvdGF0aXZlIGlzIHRoZSBtZWRpYSBsYWIgb2YgcHJveGltaXRpZXMuXHUyMDFkIFRoaXMgcGhyYXNlIHN1bW1hcmlzZXMgd2VsbCB0aGUgcGhpbG9zb3BoeSBiZWhpbmQgdGhlIG1lZGlhIGxhYiBvZiB0aGUgZ3JvdXAgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmNlbnRyZWZyYW5jZS5jb20vXCI+Q2VudHJlIEZyYW5jZTwvYT4uIEl0cyBhcHByb2FjaCB0byBpbm5vdmF0aW9uIGlzIGJhc2VkIG9uIGNsb3NlbmVzcyBiZXR3ZWVuIHBlb3BsZSwgbG9jYWwgZWNvbm9taWMgYWN0b3JzLCBhbmQgY2l0aXplbnMsIGFzIHdlbGwgYXMgc2hhcmluZyBhbmQgY3JlYXRpbmcgY29ubmVjdGlvbnMuIFJlYWQgb24gZm9yIGFuIGludGVydmlldyB3aXRoIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL3JhcG91P2xhbmc9ZnJcIj5SYXBoYVx1MDBlYmwgUG91Z2hvbjwvYT4sIGNvZm91bmRlciBvZiBsYSA8YSBocmVmPVwiaHR0cHM6Ly93d3cuY29tcGFnbmllLXJvdGF0aXZlLmZyL21lY2FuaXF1ZXMvXCI+Q29tcGFnbmllIFJvdGF0aXZlPC9hPi5cclxuPGgzPlBlb3BsZSBiZWZvcmUgbWFjaGluZXM8L2gzPlxyXG5DcmVhdGVkIGZpdmUgeWVhcnMgYWdvIGluIDIwMTQsIHRoZSBtZWRpYSBsYWIgb2YgQ2VudHJlIEZyYW5jZSBjaGFuZ2VkIGl0cyBuYW1lIGxhc3QgSmFudWFyeSB0byBiZWNvbWUgTGEgQ29tcGFnbmllIFJvdGF0aXZlLiBTaW5jZSBpdHMgY29uY2VwdGlvbiwgdGhlIHZpc2lvbiBmb3IgdGhpcyBuZXcgb3BlcmF0aW9uIGhhcyBiZWVuIGNsZWFyOiBwcm9tb3RpbmcgaW5ub3ZhdGlvbiB3aXRoaW4gdGhlIGdyb3VwLlxyXG5cclxuPHN0cm9uZz5JdCB3YXMgYWdyZWVkIGZyb20gdGhlIG91dHNldCB0aGF0IHRoZSBsYWIgc2hvdWxkIG5vdCBvbmx5IGZvY3VzIG9uIG5ldyB0ZWNobm9sb2dpZXMsIGJ1dCByYXRoZXIgYmUgYSBwYXJ0IG9mIGEgY29tcHJlaGVuc2l2ZSB0cmFuc2Zvcm1hdGlvbiBvZiB0aGUgZ3JvdXAgb3ZlcmFsbC48L3N0cm9uZz5cclxuPGJsb2NrcXVvdGU+XHUyMDFjRGlnaXRhbCB0cmFuc2Zvcm1hdGlvbiB3YXMgb25lIG9mIHRoZSBsZXZlcnMuIFdlIHdvcmtlZCBhIGxvdCBvbiBpbnRlcm5hbCBjb21tdW5pY2F0aW9ucywgd29ya2Zsb3dzLCBhbmQgc28gb24uIEdlbmVyYWxseSB0aGUgYXBwcm9hY2ggd2FzIG1vcmUgY3VsdHVyYWwgdGhhbiBkaWdpdGFsXHUyMDFkLCBleHBsYWlucyBSYXBoYVx1MDBlYmwgUG91Z2hvbi48L2Jsb2NrcXVvdGU+XHJcbmh0dHBzOi8veW91dHUuYmUvRDlGa01qeEYtb3NcclxuXHJcblNldmVyYWwgdG9vbHMgd2VyZSBkZXZlbG9wZWQgd2l0aGluIHRoZSBncm91cCBieSBSYXBoYVx1MDBlYmwgUG91Z2hvbiBhbmQgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vcXVlbnRpbmphdWRcIj5RdWVudGluIEphdWQ8L2E+LCB3aG8gbGVhZCBsYSBDb21wYWduaWUgUm90YXRpdmU6XHJcbjx1bD5cclxuIFx0PGxpPjxzdHJvbmc+U2V0dGluZyB1cCBhbiBpbnRlcm5hbCBzb2NpYWwgbmV0d29yay48L3N0cm9uZz4gQnVpbHQgdG9nZXRoZXIgd2l0aCB0aGUgZ3JvdXBcdTIwMTlzIGNvbGxhYm9yYXRvcnMsIHRoZSB0b29sIHNlcnZlcyBhcyB0aGUgY29ybmVyc3RvbmUgaW4gdGhlIGdyb3VwXHUyMDE5cyB0cmFuc2Zvcm1hdGlvbi4gVGhlIGd1aWRpbmcgaWRlYSBvZiBpdHMgZGV2ZWxvcG1lbnQgaXMgYmFzZWQgb24gPGVtPmRlc2lnbiB0aGlua2luZzwvZW0+OyBpbiBvdGhlciB3b3JkcywgdGhlIGdvYWwgaXMgdG8gZGVzaWduIGEgdG9vbCB0aGF0IGlzIG1vc3QgaW4gbGluZSB3aXRoIGl0cyB1c2Vyc1x1MjAxOSBuZWVkcyBhbmQgdGhhdCBhbGxvd3MgZm9yIGFnaWxlIGRldmVsb3BtZW50IG92ZXIgdGltZS4gUmFwaGFcdTAwZWJsIFBvdWdob24gZXZlbiBkZXNjcmliZXMgaXQgYXMgYSBcdTIwMWNUcm95YW4gaG9yc2Ugb2YgdHJhbnNmb3JtYXRpb25cdTIwMWQsIHNpbmNlIHRoZSB0b29sIGhhcyByZXN1bHRlZCBpbiBcdTIwMWNibG93aW5nIHVwIHRoZSBzaWxvcyBiZXR3ZWVuIGRlcGFydG1lbnRcdTIwMWQsIFx1MjAxY2hpZ2hsaWdodGluZyBjb21wZXRlbmNpZXNcdTIwMWQgb2YgdGhlIHN0YWZmLCBhbmQgXHUyMDFjZGlzY292ZXJpbmcgbmV3IG1hbmFnZW1lbnQgbWV0aG9kc1x1MjAxZC48L2xpPlxyXG4gXHQ8bGk+PHN0cm9uZz5PcmdhbmlzaW5nIGludGVybmFsIGV2ZW50czwvc3Ryb25nPiwgc3VjaCBhcyBcdTIwMWNNb3JuaW5nIExhYnNcdTIwMWQsIHdoaWNoIGJyaW5nIHRvZ2V0aGVyIHNldmVyYWwgY29sbGFib3JhdG9ycyBmcm9tIHZhcmlvdXMgZGVwYXJ0bWVudHMgdG8gZGlzY3VzcyB0aGUgbG9naWMgb2YgaW5ub3ZhdGlvbiBhcm91bmQgYnJlYWtmYXN0LiBBbHNvIG1lZXRpbmdzIHdpdGggbWFuYWdlcnMgYXJlIG9yZ2FuaXNlZCB0byBkaXNjdXNzIFx1MjAxY2RpZ2l0YWwgdHJlbmRzXHUyMDFkLCBhbmQgZXNwZWNpYWxseSB0byBzaGFyZSB0ZWNobm9sb2dpY2FsIHdhdGNoIGluc2lnaHRzLjwvbGk+XHJcbjwvdWw+XHJcbkFjY29yZGluZyB0byBSYXBoYVx1MDBlYmwgUG91Z2hvbiwgdGhlIHVzZXItY2VudGVyZWQgYXBwcm9hY2ggaXMgcGFydCBvZiB0aGUgYWltIHRvIFx1MjAxY2ludGVncmF0ZSB0aGUgY29sbGFib3JhdG9ycyBpbiB0aGlzIGR5bmFtaWMsIGFuZCBub3QgdG8gaW1wb3NlIHN0cmF0ZWdpZXMgdGhhdCBhcmUgY29uY2VpdmVkIGluIGEgdmVyeSB2ZXJ0aWNhbCBtYW5uZXJcdTIwMWQuXHJcbjxoMz5PcHBvcnR1bml0eSB0byBwcm9tb3RlIGlubm92YXRpb24gdGhyb3VnaCBwcm94aW1pdHk8L2gzPlxyXG5UaGUgaW5pdGlhbCBwdXJwb3NlIG9mIHRoZSBtZWRpYSBsYWIgd2FzIHRvIHJlc29sdXRlbHkgdHVybiB0b3dhcmRzIGludGVybmFsIHByb2JsZW1hdGljcy4gPHN0cm9uZz5CdXQgdmVyeSBzb29uLCBSYXBoYVx1MDBlYmwgUG91Z2hvbiBzYXcgdGhhdCBcdTIwMWN0byB3b3JrIG9uIHRyYW5zZm9ybWF0aW9uIGFuZCBpbm5vdmF0aW9uLCB3ZSBuZWVkZWQgdG8gb3BlbiB0byB0aGUgb3V0c2lkZVx1MjAxZC48L3N0cm9uZz5cclxuXHJcbkNvbnNlcXVlbnRseSwgdGhlIGxhYiBvZiBDZW50cmUgRnJhbmNlIGhhcyBzdGFydGVkIHRvIGNvbGxhYm9yYXRlIHdpdGggZXh0ZXJuYWwgYWN0b3JzIG1vcmUgYW5kIG1vcmUuIFx1MjAxY0luaXRpYWxseSB3aXRoIG90aGVyIG1lZGlhLCB0aGVuIHdpdGggb3RoZXIgaW5kdXN0cmllc1x1MjAxZC4gVGhhdCBpcyB0aGUgcmVhc29uIHdoeSB0aGUgbWVkaWEgbGFiIGNoYW5nZWQgaXRzIG5hbWUgdG8gbGEgQ29tcGFnbmllIFJvdGF0aXZlLiBXaGF0IGhhcyByZW1haW5lZCBpcyB0aGUgdmlzaW9uIG9mIFx1MjAxY2NyZWF0aW5nIGxpbmtzIGFuZCBicmluZ2luZyB0cnVzdCBsb2NhbGx5XHUyMDFkLlxyXG5cclxuVGhlc2UgbmV3IHR5cGVzIG9mIGNvbGxhYm9yYXRpb25zIHRha2UgdmFyaW91cyBmb3JtczpcclxuPHVsPlxyXG4gXHQ8bGk+PHN0cm9uZz5NZWV0aW5ncyB3aXRoIGNpdGl6ZW5zLjwvc3Ryb25nPiBUaGUgTGFiIG9yZ2FuaXNlcyBtZWV0aW5ncyBjYWxsZWQgXHUyMDFjUmVuZGV6LXZvdXMgZGUgbGEgTW9udGFnbmVcdTIwMWQgKGFmdGVyIG9uZSBvZiB0aGUgZ3JvdXBcdTIwMTlzIHRpdGxlcyksIHdoaWNoIGFyZSBhdGVsaWVycyB3aGVyZSBjaXRpemVucyBhbmQgam91cm5hbGlzdHMgbWVldCBcdTIwMWNhdCB0aGUgc2FtZSBsZXZlbFx1MjAxZCB0byByZWNyZWF0ZSBhIGNvbm5lY3Rpb24gYmV0d2VlbiB0aGVtLjwvbGk+XHJcbjwvdWw+XHJcbmh0dHBzOi8vdHdpdHRlci5jb20vTGFDaWVSb3RhdGl2ZS9zdGF0dXMvMTEwMzM4NDMxMDYwMDY4NzYxNlxyXG48dWw+XHJcbiBcdDxsaT48c3Ryb25nPkNvbGxhYm9yYXRpb24gd2l0aCBqb3VybmFsaXN0cyBmcm9tIG90aGVyIHB1Ymxpc2hlcnMuPC9zdHJvbmc+IEEgXHUyMDFjSm91cm5vIENhbXBcdTIwMWQgd2FzIG9yZ2FuaXNlZCBsYXN0IHllYXIgYnkgdGhlIG1lZGlhIGxhYiB0byBicmluZyB0b2dldGhlciBkYXRhIGpvdXJuYWxpc3RzIGZyb20gYWxsIG92ZXIgRnJhbmNlLiBJdCByZXN1bHRlZCBpbiB0aGUgYmlydGggb2YgdGhlIGNvbGxlY3RpdmUgXHUyMDFjPGEgaHJlZj1cImh0dHBzOi8vY29sbGVjdGlmLWRhdGFsb2NhbC5naXRodWIuaW8vXCI+ZGF0YStsb2NhbDwvYT5cdTIwMWQsIFx1MjAxY3doaWNoIGFsbG93cyBmb3IgZXhjaGFuZ2Ugb2YgYmVzdCBwcmFjdGljZXMsIGNhcGFjaXRpZXMsIHRvb2xzLCBtaXN0YWtlcyBhbmQgZGF0YWJhc2VzXHUyMDFkLCBhbmQgdG8gXHUyMDFjcHVzaCBmb3Igb3BlbiBkYXRhXHUyMDFkIGFtb25nIGRhdGFiYXNlIG93bmVycy48L2xpPlxyXG48L3VsPlxyXG48aW1nIGNsYXNzPVwid3AtaW1hZ2UtMTUxNDIgc2l6ZS1mdWxsIGFsaWduY2VudGVyXCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTkvMDQvQ2FwdHVyZS1kXHUyMDE5ZVx1MDMwMWNyYW4tMjAxOS0wNC0wOS1hXHUwMzAwLTEyLjUxLjA4LTYwMHg1NTAucG5nXCIgYWx0PVwiXCIgd2lkdGg9XCI2MDBcIiBoZWlnaHQ9XCI1NTBcIiAvPlxyXG48dWw+XHJcbiBcdDxsaT48c3Ryb25nPkNvbGxhYm9yYXRpb24gd2l0aCBsb2NhbCBidXNpbmVzc2VzIHRvIHByb21vdGUgb3BlbiBpbm5vdmF0aW9uLjwvc3Ryb25nPiBMYSBDb21wYWduaWUgUm90YXRpdmUgb3JnYW5pc2VzIHNldmVyYWwgZXZlbnRzLCBzdWNoIGFzIGEgaGFja2F0aG9uIGxhc3QgeWVhciBvbiB0aGUgdG9waWMgb2YgXHUyMDFjbmV3IHByb3hpbWl0aWVzXHUyMDFkLjwvbGk+XHJcbiBcdDxsaT48c3Ryb25nPlN0YXJ0dXAgaW5jdWJhdGlvbi48L3N0cm9uZz4gVGhpcyBwcm9ncmFtbWUgd2FzIGxhdW5jaGVkIGxhc3QgeWVhciB0byBwcm9tb3RlIHN0YXJ0dXBzIFx1MjAxY2luIHNlcnZpY2VzLCBsb2NhbGl0eSBhbmQgdXRpbGl0eVx1MjAxZCwgYW5kIHRvIFx1MjAxY2luY3JlYXNlIHRoZSBjb21wZXRlbmNpZXMgYW5kIHNraWxsc1x1MjAxZCBpbiBhbiBpbm5vdmF0aXZlIHNldHRpbmcuIFNpbmNlIDxzdHJvbmc+XHUyMDFjdGhlIGVudHJlcHJlbmV1cmlhbCBlY29zeXN0ZW0gaGFzIGEgd2F5IG9mIGRvaW5nIGFuZCBzZWVpbmcgdGhpbmdzIHRoYXQgd2UgZG9uXHUyMDE5dCwgYW5kIHRoYXQgZG9uXHUyMDE5dCBleGlzdCBpbiBvdXIgY3VsdHVyZSwgaXRcdTIwMTlzIGEgZ29vZCB3YXkgZm9yIHRoZXNlIHR3byB3b3JsZHMgdG8gZXhjaGFuZ2UgYW5kIGxlYXJuIGZyb20gZWFjaCBvdGhlci5cdTIwMWQ8L3N0cm9uZz4gRml2ZSBzdGFydHVwcyB3ZXJlIHNlbGVjdGVkIGF0IHRoZSBlbmQgb2YgdGhlIHByb2dyYW1tZS4gVGhlIGdvYWwgaXMgbm90IG5lY2Vzc2FyaWx5IHRvIGludGVncmF0ZSB0aGVzZSBzdGFydHVwcyBpbiB0aGUgZ3JvdXAsIGJ1dCB0byBhbGxvdyB0aGVtIHRvIGdyb3cgYW5kIGV4Y2hhbmdlIGtub3ctaG93IGFuZCBza2lsbHMuIEEgY29uY3JldGUgZXhhbXBsZSBpcyB0aGUgbWVudG9yc2hpcCBiZXR3ZWVuIHRoZSBjb21wYW5pZXMgYW5kICh2b2x1bnRhcnkpIG1lbnRvcnMgZnJvbSB0aGUgZ3JvdXAgQ2VudHJlLUZyYW5jZS4gVGhpcyBhbGxvd3MgdGhlIG1lbnRvcnMgdG8gcHV0IHRoZWlyIGNvbXBldGVuY2llcyB0byB3b3JrIGluIGEgbmV3IHNldHRpbmcsIHdoaWxlIHRoZSBjb21wYW5pZXMgaW4gdHVybiBiZW5lZml0IGZyb20gdGhlaXIgZXhwZXJ0aXNlLjwvbGk+XHJcbiBcdDxsaT48c3Ryb25nPlN0cnVjdHVyaW5nIGEgbmV0d29yayBvZiBsb2NhbCBzdGFydHVwcy48L3N0cm9uZz4gVGhlIENvbXBhZ25pZSBSb3RhdGl2ZSBoYXMgbGF1bmNoZWQgYSBjb2xsZWN0aXZlIFx1MjAxMyA8YSBocmVmPVwiaHR0cHM6Ly9zdGFydHVwLWZlc3RpdmFsLmNvbS9cIj5NYWdtYTwvYT4gXHUyMDEzIHRoYXQgZ2F0aGVycyB0b2dldGhlciBmb3VyIGluY3ViYXRvcnMuIFRoZSBmaXJzdCBldmVudCB0b29rIHBsYWNlIDEgQXByaWwgMjAxOSwgYnJpbmdpbmcgdG9nZXRoZXIgNDAgc3RhcnR1cHMuPC9saT5cclxuPC91bD5cclxuPGltZyBjbGFzcz1cIndwLWltYWdlLTE1MTQzIHNpemUtZnVsbCBhbGlnbmNlbnRlclwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE5LzA0L0NhcHR1cmUtZFx1MjAxOWVcdTAzMDFjcmFuLTIwMTktMDQtMDktYVx1MDMwMC0xMi41My4yNi02MDB4MjQ0LnBuZ1wiIGFsdD1cIlwiIHdpZHRoPVwiNjAwXCIgaGVpZ2h0PVwiMjQ0XCIgLz5cclxuXHJcbkNvbmNlcm5pbmcgdGhlIG5leHQgc3RlcHMsIFJhcGhhXHUwMGVibCBQb3VnaG9uIHBsYW5zIHRvIFx1MjAxY3Byb21vdGUgb3Blbm5lc3MgaW4gb3VyIGVjb3N5c3RlbSBhbmQgZXNwZWNpYWxseSB0aGUgYWJpbGl0eSB0byBtb2JpbGlzZSBldmVuIG1vcmUgdGhlIGNpdGl6ZW4gc2lkZSBvZiB0aGUgbWVkaWEgbGFiXHUyMDFkLCBhbmQgdG8gb3BlbiB1cCBtb3JlIHRvIFx1MjAxY3Jlc2VhcmNoZXJzIGFuZCBzY2hvb2xzXHUyMDFkIHRvIGNvbXBsaW1lbnQgdGhlaXIgcmVzZWFyY2guWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddIiwicG9zdF90aXRsZSI6IkxhIENvbXBhZ25pZSBSb3RhdGl2ZSwgaW5ub3ZhdGlvbiB0aHJvdWdoIHByb3hpbWl0eSIsInBvc3RfbGluayI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9sYS1jb21wYWduaWUtcm90YXRpdmUtaW5ub3ZhdGlvbi10aHJvdWdoLXByb3hpbWl0eS8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJMYSBDb21wYWduaWUgUm90YXRpdmUsIGlubm92YXRpb24gdGhyb3VnaCBwcm94aW1pdHlcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjE1N1wiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE5LzA0L29wZW4tZ3JhcGgtMzAweDE1Ny5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj4iLCJwb3N0X2NhdGVnb3JpZXMiOiJNZWRpYSBsYWJzIiwicG9zdF90YWdzIjoiIiwiJV9lZGl0X2xvY2slIjoiMTU2MTU1NjU4OTo5MzEiLCIlX2VkaXRfbGFzdCUiOiI5MzEiLCIlX29lbWJlZF9hM2YyNmE2MzVkZWFjZTFlNzgzNzZhNTcxNzMwYzY4YyUiOiI8aWZyYW1lIHdpZHRoPVwiNTkyXCIgaGVpZ2h0PVwiNDQ0XCIgc3JjPVwiaHR0cHM6Ly93d3cueW91dHViZS5jb20vZW1iZWQvRDlGa01qeEYtb3M/ZmVhdHVyZT1vZW1iZWQmYW1wO3dtb2RlPW9wYXF1ZSZhbXA7c2hvd2luZm89MFwiIHN0eWxlPVwiYm9yZGVyOiBub25lXCIgYWxsb3c9XCJhY2NlbGVyb21ldGVyOyBhdXRvcGxheTsgZW5jcnlwdGVkLW1lZGlhOyBneXJvc2NvcGU7IHBpY3R1cmUtaW4tcGljdHVyZVwiIGFsbG93ZnVsbHNjcmVlbj48L2lmcmFtZT4iLCIlX29lbWJlZF90aW1lX2EzZjI2YTYzNWRlYWNlMWU3ODM3NmE1NzE3MzBjNjhjJSI6IjE1NTYyMDk2NTAiLCIlX29lbWJlZF80Mjg4YzA3MzVmODU0MDdhNTIwM2U1YTFmZDY1Y2RhMCUiOiI8YmxvY2txdW90ZSBjbGFzcz1cInR3aXR0ZXItdHdlZXRcIiBkYXRhLXdpZHRoPVwiNTUwXCIgZGF0YS1kbnQ9XCJ0cnVlXCI+PHAgbGFuZz1cImZyXCIgZGlyPVwibHRyXCI+UmF2aXMgZFx1MjAxOWF2b2lyIGZhY2lsaXRcdTAwZTkgdW5lIGJlbGxlIHNvaXJcdTAwZTllIGRcdTIwMTlpbnRlbGxpZ2VuY2UgY29sbGVjdGl2ZSBzdXIgbGUgdGhcdTAwZThtZSBkZSBsYSBtb2JpbGl0XHUwMGU5IHByIGxlcyA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9oYXNodGFnL3JkdkxhTW9udGFnbmU/c3JjPWhhc2gmYW1wO3JlZl9zcmM9dHdzcmMlNUV0ZndcIj4jcmR2TGFNb250YWduZTwvYT4gYXZlYyBsZXMgY2xlcm1vbnRvaXMgISA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9oYXNodGFnL3Byb3hpbWl0JUMzJUE5P3NyYz1oYXNoJmFtcDtyZWZfc3JjPXR3c3JjJTVFdGZ3XCI+I3Byb3hpbWl0XHUwMGU5PC9hPiA8YSBocmVmPVwiaHR0cHM6Ly90LmNvL1ZEVGwzNzlDWjhcIj5waWMudHdpdHRlci5jb20vVkRUbDM3OUNaODwvYT48L3A+Jm1kYXNoOyBMYSBDb21wYWduaWUgUm90YXRpdmUgKEBMYUNpZVJvdGF0aXZlKSA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9MYUNpZVJvdGF0aXZlL3N0YXR1cy8xMTAzMzg0MzEwNjAwNjg3NjE2P3JlZl9zcmM9dHdzcmMlNUV0ZndcIj5NYXJjaCA2LCAyMDE5PC9hPjwvYmxvY2txdW90ZT48c2NyaXB0IGFzeW5jIHNyYz1cImh0dHBzOi8vcGxhdGZvcm0udHdpdHRlci5jb20vd2lkZ2V0cy5qc1wiIGNoYXJzZXQ9XCJ1dGYtOFwiPjwvc2NyaXB0PiIsIiVfb2VtYmVkX3RpbWVfNDI4OGMwNzM1Zjg1NDA3YTUyMDNlNWExZmQ2NWNkYTAlIjoiMTU1NjIwOTc5MSIsIiVfdGh1bWJuYWlsX2lkJSI6IjE1MTU2IiwiJXNsaWRlX3RlbXBsYXRlJSI6ImRlZmF1bHQiLCIlX3dwYl92Y19qc19zdGF0dXMlIjoidHJ1ZSIsIiVfd3BnbXBfbG9jYXRpb25fYWRkcmVzcyUiOiJDbGVybW9udC1GZXJyYW5kLCBGcmFuY2UiLCIlX3dwZ21wX2xvY2F0aW9uX2NpdHklIjoiQ2xlcm1vbnQtRmVycmFuZCIsIiVfd3BnbXBfbG9jYXRpb25fc3RhdGUlIjoiQXV2ZXJnbmUtUmhcdTAwZjRuZS1BbHBlcyIsIiVfd3BnbXBfbG9jYXRpb25fY291bnRyeSUiOiJGcmFuY2UiLCIlX3dwZ21wX21ldGFib3hfbGF0aXR1ZGUlIjoiNDUuNzc3MjIxOTk5OTk5OTkiLCIlX3dwZ21wX21ldGFib3hfbG9uZ2l0dWRlJSI6IjMuMDg3MDI1MDAwMDAwMDM5NyIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiMlwiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6Ik47IiwiJV93cGdtcF9tZXRhYm94X3RheG9tb21pZXNfdGVybXMlIjoiTjsiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6Ik47IiwiJV9rbGVvX3RyYW5zcGFyZW50X21lbnVfY29sb3IlIjoid2hpdGUiLCIlX2tsZW9fdGl0bGVfY29sb3IlIjoiIyIsIiVfa2xlb190aXRsZV9iZyUiOiIsIHJlcGVhdCwgaW5oZXJpdCwgc2Nyb2xsLCBsZWZ0IHRvcCIsIiVfa2xlb190aXRsZV9iZ19jb2xvciUiOiIjIiwiJV95b2FzdF93cHNlb19jb250ZW50X3Njb3JlJSI6IjMwIiwiJV9vZW1iZWRfYzVkZWNlZjUwYjczNzk2NThlNmE4NjY3NjBiZTdjM2ElIjoiPGlmcmFtZSB3aWR0aD1cIjEyMDBcIiBoZWlnaHQ9XCI5MDBcIiBzcmM9XCJodHRwczovL3d3dy55b3V0dWJlLmNvbS9lbWJlZC9EOUZrTWp4Ri1vcz9mZWF0dXJlPW9lbWJlZCZhbXA7d21vZGU9b3BhcXVlJmFtcDtzaG93aW5mbz0wXCIgc3R5bGU9XCJib3JkZXI6IG5vbmVcIiBhbGxvdz1cImFjY2VsZXJvbWV0ZXI7IGF1dG9wbGF5OyBlbmNyeXB0ZWQtbWVkaWE7IGd5cm9zY29wZTsgcGljdHVyZS1pbi1waWN0dXJlXCIgYWxsb3dmdWxsc2NyZWVuPjwvaWZyYW1lPiIsIiVfb2VtYmVkX3RpbWVfYzVkZWNlZjUwYjczNzk2NThlNmE4NjY3NjBiZTdjM2ElIjoiMTU1NjIxMDAwNSIsIiVfb2VtYmVkXzQ1N2E5OTMzOGEwMjQyOTBlYzFhZjNiNWJmZmMwMjczJSI6IjxibG9ja3F1b3RlIGNsYXNzPVwidHdpdHRlci10d2VldFwiIGRhdGEtd2lkdGg9XCI1NTBcIiBkYXRhLWRudD1cInRydWVcIj48cCBsYW5nPVwiZnJcIiBkaXI9XCJsdHJcIj5SYXZpcyBkXHUyMDE5YXZvaXIgZmFjaWxpdFx1MDBlOSB1bmUgYmVsbGUgc29pclx1MDBlOWUgZFx1MjAxOWludGVsbGlnZW5jZSBjb2xsZWN0aXZlIHN1ciBsZSB0aFx1MDBlOG1lIGRlIGxhIG1vYmlsaXRcdTAwZTkgcHIgbGVzIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2hhc2h0YWcvcmR2TGFNb250YWduZT9zcmM9aGFzaCZhbXA7cmVmX3NyYz10d3NyYyU1RXRmd1wiPiNyZHZMYU1vbnRhZ25lPC9hPiBhdmVjIGxlcyBjbGVybW9udG9pcyAhIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2hhc2h0YWcvcHJveGltaXQlQzMlQTk/c3JjPWhhc2gmYW1wO3JlZl9zcmM9dHdzcmMlNUV0ZndcIj4jcHJveGltaXRcdTAwZTk8L2E+IDxhIGhyZWY9XCJodHRwczovL3QuY28vVkRUbDM3OUNaOFwiPnBpYy50d2l0dGVyLmNvbS9WRFRsMzc5Q1o4PC9hPjwvcD4mbWRhc2g7IExhIENvbXBhZ25pZSBSb3RhdGl2ZSAoQExhQ2llUm90YXRpdmUpIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL0xhQ2llUm90YXRpdmUvc3RhdHVzLzExMDMzODQzMTA2MDA2ODc2MTY/cmVmX3NyYz10d3NyYyU1RXRmd1wiPk1hcmNoIDYsIDIwMTk8L2E+PC9ibG9ja3F1b3RlPjxzY3JpcHQgYXN5bmMgc3JjPVwiaHR0cHM6Ly9wbGF0Zm9ybS50d2l0dGVyLmNvbS93aWRnZXRzLmpzXCIgY2hhcnNldD1cInV0Zi04XCI+PC9zY3JpcHQ+IiwiJV9vZW1iZWRfdGltZV80NTdhOTkzMzhhMDI0MjkwZWMxYWYzYjViZmZjMDI3MyUiOiIxNTU2MjEwMDA1IiwiJV95b2FzdF93cHNlb19wcmltYXJ5X2NhdGVnb3J5JSI6IjE0MiIsIiVfb2VtYmVkX2EwNTIwNTViNzM5NzVkZTExMTQ3MWQ4Nzg3MjhhMmU1JSI6IjxibG9ja3F1b3RlIGNsYXNzPVwidHdpdHRlci10d2VldFwiIGRhdGEtd2lkdGg9XCI0NzVcIiBkYXRhLWRudD1cInRydWVcIj48cCBsYW5nPVwiZnJcIiBkaXI9XCJsdHJcIj5SYXZpcyBkXHUyMDE5YXZvaXIgZmFjaWxpdFx1MDBlOSB1bmUgYmVsbGUgc29pclx1MDBlOWUgZFx1MjAxOWludGVsbGlnZW5jZSBjb2xsZWN0aXZlIHN1ciBsZSB0aFx1MDBlOG1lIGRlIGxhIG1vYmlsaXRcdTAwZTkgcHIgbGVzIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2hhc2h0YWcvcmR2TGFNb250YWduZT9zcmM9aGFzaCZhbXA7cmVmX3NyYz10d3NyYyU1RXRmd1wiPiNyZHZMYU1vbnRhZ25lPC9hPiBhdmVjIGxlcyBjbGVybW9udG9pcyAhIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2hhc2h0YWcvcHJveGltaXQlQzMlQTk/c3JjPWhhc2gmYW1wO3JlZl9zcmM9dHdzcmMlNUV0ZndcIj4jcHJveGltaXRcdTAwZTk8L2E+IDxhIGhyZWY9XCJodHRwczovL3QuY28vVkRUbDM3OUNaOFwiPnBpYy50d2l0dGVyLmNvbS9WRFRsMzc5Q1o4PC9hPjwvcD4mbWRhc2g7IExhIENvbXBhZ25pZSBSb3RhdGl2ZSAoQExhQ2llUm90YXRpdmUpIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL0xhQ2llUm90YXRpdmUvc3RhdHVzLzExMDMzODQzMTA2MDA2ODc2MTY/cmVmX3NyYz10d3NyYyU1RXRmd1wiPk1hcmNoIDYsIDIwMTk8L2E+PC9ibG9ja3F1b3RlPjxzY3JpcHQgYXN5bmMgc3JjPVwiaHR0cHM6Ly9wbGF0Zm9ybS50d2l0dGVyLmNvbS93aWRnZXRzLmpzXCIgY2hhcnNldD1cInV0Zi04XCI+PC9zY3JpcHQ+IiwiJV9vZW1iZWRfdGltZV9hMDUyMDU1YjczOTc1ZGUxMTE0NzFkODc4NzI4YTJlNSUiOiIxNTU2MjEwMDE0IiwiJV9vZW1iZWRfYjFlYTkyZjdmNDI2Zjg4ODM3ODI5ZTg3Y2FjZmUxM2UlIjoiPGlmcmFtZSB3aWR0aD1cIjQ3NVwiIGhlaWdodD1cIjM1NlwiIHNyYz1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkL0Q5RmtNanhGLW9zP2ZlYXR1cmU9b2VtYmVkJmFtcDt3bW9kZT1vcGFxdWUmYW1wO3Nob3dpbmZvPTBcIiBzdHlsZT1cImJvcmRlcjogbm9uZVwiIGFsbG93PVwiYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGVuY3J5cHRlZC1tZWRpYTsgZ3lyb3Njb3BlOyBwaWN0dXJlLWluLXBpY3R1cmVcIiBhbGxvd2Z1bGxzY3JlZW4+PC9pZnJhbWU+IiwiJV9vZW1iZWRfdGltZV9iMWVhOTJmN2Y0MjZmODg4Mzc4MjllODdjYWNmZTEzZSUiOiIxNTU2MjEwMDE0IiwiJV9rbGVvX3RpdGxlX2NoZWNrYm94JSI6IjEiLCIlX3dwX29sZF9kYXRlJSI6IjIwMTktMDQtMjUiLCIlX29lbWJlZF9lN2ZhZTk1N2I0ZDBjZDNiMDA0MzIzMzRlOWMxNmFmMyUiOiI8YmxvY2txdW90ZSBjbGFzcz1cInR3aXR0ZXItdHdlZXRcIiBkYXRhLXdpZHRoPVwiNDc4XCIgZGF0YS1kbnQ9XCJ0cnVlXCI+PHAgbGFuZz1cImZyXCIgZGlyPVwibHRyXCI+UmF2aXMgZFx1MjAxOWF2b2lyIGZhY2lsaXRcdTAwZTkgdW5lIGJlbGxlIHNvaXJcdTAwZTllIGRcdTIwMTlpbnRlbGxpZ2VuY2UgY29sbGVjdGl2ZSBzdXIgbGUgdGhcdTAwZThtZSBkZSBsYSBtb2JpbGl0XHUwMGU5IHByIGxlcyA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9oYXNodGFnL3JkdkxhTW9udGFnbmU/c3JjPWhhc2gmYW1wO3JlZl9zcmM9dHdzcmMlNUV0ZndcIj4jcmR2TGFNb250YWduZTwvYT4gYXZlYyBsZXMgY2xlcm1vbnRvaXMgISA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9oYXNodGFnL3Byb3hpbWl0JUMzJUE5P3NyYz1oYXNoJmFtcDtyZWZfc3JjPXR3c3JjJTVFdGZ3XCI+I3Byb3hpbWl0XHUwMGU5PC9hPiA8YSBocmVmPVwiaHR0cHM6Ly90LmNvL1ZEVGwzNzlDWjhcIj5waWMudHdpdHRlci5jb20vVkRUbDM3OUNaODwvYT48L3A+Jm1kYXNoOyBMYSBDb21wYWduaWUgUm90YXRpdmUgKEBMYUNpZVJvdGF0aXZlKSA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9MYUNpZVJvdGF0aXZlL3N0YXR1cy8xMTAzMzg0MzEwNjAwNjg3NjE2P3JlZl9zcmM9dHdzcmMlNUV0ZndcIj5NYXJjaCA2LCAyMDE5PC9hPjwvYmxvY2txdW90ZT48c2NyaXB0IGFzeW5jIHNyYz1cImh0dHBzOi8vcGxhdGZvcm0udHdpdHRlci5jb20vd2lkZ2V0cy5qc1wiIGNoYXJzZXQ9XCJ1dGYtOFwiPjwvc2NyaXB0PiIsIiVfb2VtYmVkX3RpbWVfZTdmYWU5NTdiNGQwY2QzYjAwNDMyMzM0ZTljMTZhZjMlIjoiMTU1NjI2NjM4MCIsIiVfb2VtYmVkX2NkYjJhZmFmYjM1YWJjMTU5ZGUyYzMxZjlkM2M5ZjZmJSI6IjxpZnJhbWUgd2lkdGg9XCI0NzhcIiBoZWlnaHQ9XCIzNTlcIiBzcmM9XCJodHRwczovL3d3dy55b3V0dWJlLmNvbS9lbWJlZC9EOUZrTWp4Ri1vcz9mZWF0dXJlPW9lbWJlZCZhbXA7d21vZGU9b3BhcXVlJmFtcDtzaG93aW5mbz0wXCIgc3R5bGU9XCJib3JkZXI6IG5vbmVcIiBhbGxvdz1cImFjY2VsZXJvbWV0ZXI7IGF1dG9wbGF5OyBlbmNyeXB0ZWQtbWVkaWE7IGd5cm9zY29wZTsgcGljdHVyZS1pbi1waWN0dXJlXCIgYWxsb3dmdWxsc2NyZWVuPjwvaWZyYW1lPiIsIiVfb2VtYmVkX3RpbWVfY2RiMmFmYWZiMzVhYmMxNTlkZTJjMzFmOWQzYzlmNmYlIjoiMTU1NjI2NjM4MCIsIiVfb2VtYmVkXzQxZDY0ZTkxNjdlMjcxOTQ4OTIzZmZlYjQ3Y2NmOGZiJSI6IjxibG9ja3F1b3RlIGNsYXNzPVwidHdpdHRlci10d2VldFwiIGRhdGEtd2lkdGg9XCI0NzdcIiBkYXRhLWRudD1cInRydWVcIj48cCBsYW5nPVwiZnJcIiBkaXI9XCJsdHJcIj5SYXZpcyBkXHUyMDE5YXZvaXIgZmFjaWxpdFx1MDBlOSB1bmUgYmVsbGUgc29pclx1MDBlOWUgZFx1MjAxOWludGVsbGlnZW5jZSBjb2xsZWN0aXZlIHN1ciBsZSB0aFx1MDBlOG1lIGRlIGxhIG1vYmlsaXRcdTAwZTkgcHIgbGVzIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2hhc2h0YWcvcmR2TGFNb250YWduZT9zcmM9aGFzaCZhbXA7cmVmX3NyYz10d3NyYyU1RXRmd1wiPiNyZHZMYU1vbnRhZ25lPC9hPiBhdmVjIGxlcyBjbGVybW9udG9pcyAhIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2hhc2h0YWcvcHJveGltaXQlQzMlQTk/c3JjPWhhc2gmYW1wO3JlZl9zcmM9dHdzcmMlNUV0ZndcIj4jcHJveGltaXRcdTAwZTk8L2E+IDxhIGhyZWY9XCJodHRwczovL3QuY28vVkRUbDM3OUNaOFwiPnBpYy50d2l0dGVyLmNvbS9WRFRsMzc5Q1o4PC9hPjwvcD4mbWRhc2g7IExhIENvbXBhZ25pZSBSb3RhdGl2ZSAoQExhQ2llUm90YXRpdmUpIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL0xhQ2llUm90YXRpdmUvc3RhdHVzLzExMDMzODQzMTA2MDA2ODc2MTY/cmVmX3NyYz10d3NyYyU1RXRmd1wiPk1hcmNoIDYsIDIwMTk8L2E+PC9ibG9ja3F1b3RlPjxzY3JpcHQgYXN5bmMgc3JjPVwiaHR0cHM6Ly9wbGF0Zm9ybS50d2l0dGVyLmNvbS93aWRnZXRzLmpzXCIgY2hhcnNldD1cInV0Zi04XCI+PC9zY3JpcHQ+IiwiJV9vZW1iZWRfdGltZV80MWQ2NGU5MTY3ZTI3MTk0ODkyM2ZmZWI0N2NjZjhmYiUiOiIxNTU2MjY2NjMxIiwiJV9vZW1iZWRfODg1MGU2YWIwZjViZDMwNWI5NWNiY2Q1MGUyY2JkYWIlIjoiPGlmcmFtZSB3aWR0aD1cIjQ3N1wiIGhlaWdodD1cIjM1OFwiIHNyYz1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkL0Q5RmtNanhGLW9zP2ZlYXR1cmU9b2VtYmVkJmFtcDt3bW9kZT1vcGFxdWUmYW1wO3Nob3dpbmZvPTBcIiBzdHlsZT1cImJvcmRlcjogbm9uZVwiIGFsbG93PVwiYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGVuY3J5cHRlZC1tZWRpYTsgZ3lyb3Njb3BlOyBwaWN0dXJlLWluLXBpY3R1cmVcIiBhbGxvd2Z1bGxzY3JlZW4+PC9pZnJhbWU+IiwiJV9vZW1iZWRfdGltZV84ODUwZTZhYjBmNWJkMzA1Yjk1Y2JjZDUwZTJjYmRhYiUiOiIxNTU2MjY2NjMxIiwiJV9vZW1iZWRfZDMzNDg4Y2MzMTAxMGIzNzY5MzExNTQ2YjkwZmMwYzMlIjoiPGJsb2NrcXVvdGUgY2xhc3M9XCJ0d2l0dGVyLXR3ZWV0XCIgZGF0YS13aWR0aD1cIjQ4MVwiIGRhdGEtZG50PVwidHJ1ZVwiPjxwIGxhbmc9XCJmclwiIGRpcj1cImx0clwiPlJhdmlzIGRcdTIwMTlhdm9pciBmYWNpbGl0XHUwMGU5IHVuZSBiZWxsZSBzb2lyXHUwMGU5ZSBkXHUyMDE5aW50ZWxsaWdlbmNlIGNvbGxlY3RpdmUgc3VyIGxlIHRoXHUwMGU4bWUgZGUgbGEgbW9iaWxpdFx1MDBlOSBwciBsZXMgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vaGFzaHRhZy9yZHZMYU1vbnRhZ25lP3NyYz1oYXNoJmFtcDtyZWZfc3JjPXR3c3JjJTVFdGZ3XCI+I3JkdkxhTW9udGFnbmU8L2E+IGF2ZWMgbGVzIGNsZXJtb250b2lzICEgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vaGFzaHRhZy9wcm94aW1pdCVDMyVBOT9zcmM9aGFzaCZhbXA7cmVmX3NyYz10d3NyYyU1RXRmd1wiPiNwcm94aW1pdFx1MDBlOTwvYT4gPGEgaHJlZj1cImh0dHBzOi8vdC5jby9WRFRsMzc5Q1o4XCI+cGljLnR3aXR0ZXIuY29tL1ZEVGwzNzlDWjg8L2E+PC9wPiZtZGFzaDsgTGEgQ29tcGFnbmllIFJvdGF0aXZlIChATGFDaWVSb3RhdGl2ZSkgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vTGFDaWVSb3RhdGl2ZS9zdGF0dXMvMTEwMzM4NDMxMDYwMDY4NzYxNj9yZWZfc3JjPXR3c3JjJTVFdGZ3XCI+TWFyY2ggNiwgMjAxOTwvYT48L2Jsb2NrcXVvdGU+PHNjcmlwdCBhc3luYyBzcmM9XCJodHRwczovL3BsYXRmb3JtLnR3aXR0ZXIuY29tL3dpZGdldHMuanNcIiBjaGFyc2V0PVwidXRmLThcIj48L3NjcmlwdD4iLCIlX29lbWJlZF90aW1lX2QzMzQ4OGNjMzEwMTBiMzc2OTMxMTU0NmI5MGZjMGMzJSI6IjE1NTYyNjcwNTIiLCIlX29lbWJlZF8yYWNhM2UyOThkNDE3MzI4YjY2NjVjMGMzM2NmMTRkOCUiOiI8aWZyYW1lIHdpZHRoPVwiNDgxXCIgaGVpZ2h0PVwiMzYxXCIgc3JjPVwiaHR0cHM6Ly93d3cueW91dHViZS5jb20vZW1iZWQvRDlGa01qeEYtb3M/ZmVhdHVyZT1vZW1iZWQmYW1wO3dtb2RlPW9wYXF1ZSZhbXA7c2hvd2luZm89MFwiIHN0eWxlPVwiYm9yZGVyOiBub25lXCIgYWxsb3c9XCJhY2NlbGVyb21ldGVyOyBhdXRvcGxheTsgZW5jcnlwdGVkLW1lZGlhOyBneXJvc2NvcGU7IHBpY3R1cmUtaW4tcGljdHVyZVwiIGFsbG93ZnVsbHNjcmVlbj48L2lmcmFtZT4iLCIlX29lbWJlZF90aW1lXzJhY2EzZTI5OGQ0MTczMjhiNjY2NWMwYzMzY2YxNGQ4JSI6IjE1NTYyNjcwNTIiLCIlX29lbWJlZF9hN2FjZGExMjdiZDVlMzE2OWU0YzU2YzA2NTY3MzY2NSUiOiI8YmxvY2txdW90ZSBjbGFzcz1cInR3aXR0ZXItdHdlZXRcIiBkYXRhLXdpZHRoPVwiNDc5XCIgZGF0YS1kbnQ9XCJ0cnVlXCI+PHAgbGFuZz1cImZyXCIgZGlyPVwibHRyXCI+UmF2aXMgZFx1MjAxOWF2b2lyIGZhY2lsaXRcdTAwZTkgdW5lIGJlbGxlIHNvaXJcdTAwZTllIGRcdTIwMTlpbnRlbGxpZ2VuY2UgY29sbGVjdGl2ZSBzdXIgbGUgdGhcdTAwZThtZSBkZSBsYSBtb2JpbGl0XHUwMGU5IHByIGxlcyA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9oYXNodGFnL3JkdkxhTW9udGFnbmU/c3JjPWhhc2gmYW1wO3JlZl9zcmM9dHdzcmMlNUV0ZndcIj4jcmR2TGFNb250YWduZTwvYT4gYXZlYyBsZXMgY2xlcm1vbnRvaXMgISA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9oYXNodGFnL3Byb3hpbWl0JUMzJUE5P3NyYz1oYXNoJmFtcDtyZWZfc3JjPXR3c3JjJTVFdGZ3XCI+I3Byb3hpbWl0XHUwMGU5PC9hPiA8YSBocmVmPVwiaHR0cHM6Ly90LmNvL1ZEVGwzNzlDWjhcIj5waWMudHdpdHRlci5jb20vVkRUbDM3OUNaODwvYT48L3A+Jm1kYXNoOyBMYSBDb21wYWduaWUgUm90YXRpdmUgKEBMYUNpZVJvdGF0aXZlKSA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9MYUNpZVJvdGF0aXZlL3N0YXR1cy8xMTAzMzg0MzEwNjAwNjg3NjE2P3JlZl9zcmM9dHdzcmMlNUV0ZndcIj5NYXJjaCA2LCAyMDE5PC9hPjwvYmxvY2txdW90ZT48c2NyaXB0IGFzeW5jIHNyYz1cImh0dHBzOi8vcGxhdGZvcm0udHdpdHRlci5jb20vd2lkZ2V0cy5qc1wiIGNoYXJzZXQ9XCJ1dGYtOFwiPjwvc2NyaXB0PiIsIiVfb2VtYmVkX3RpbWVfYTdhY2RhMTI3YmQ1ZTMxNjllNGM1NmMwNjU2NzM2NjUlIjoiMTU1NjI2OTQyNiIsIiVfb2VtYmVkXzE3NjVkMjIwZGU2YzliOTM5ZjMwZjJhZTkwZmQwOGU2JSI6IjxpZnJhbWUgd2lkdGg9XCI0NzlcIiBoZWlnaHQ9XCIzNTlcIiBzcmM9XCJodHRwczovL3d3dy55b3V0dWJlLmNvbS9lbWJlZC9EOUZrTWp4Ri1vcz9mZWF0dXJlPW9lbWJlZCZhbXA7d21vZGU9b3BhcXVlJmFtcDtzaG93aW5mbz0wXCIgc3R5bGU9XCJib3JkZXI6IG5vbmVcIiBhbGxvdz1cImFjY2VsZXJvbWV0ZXI7IGF1dG9wbGF5OyBlbmNyeXB0ZWQtbWVkaWE7IGd5cm9zY29wZTsgcGljdHVyZS1pbi1waWN0dXJlXCIgYWxsb3dmdWxsc2NyZWVuPjwvaWZyYW1lPiIsIiVfb2VtYmVkX3RpbWVfMTc2NWQyMjBkZTZjOWI5MzlmMzBmMmFlOTBmZDA4ZTYlIjoiMTU1NjI2OTQyNiIsIiVfb2VtYmVkXzVmNTY5ODdjYzFkZWUzNDBmZWQ2M2ZiMjUzMjgxMjA2JSI6IjxibG9ja3F1b3RlIGNsYXNzPVwidHdpdHRlci10d2VldFwiIGRhdGEtd2lkdGg9XCI0ODJcIiBkYXRhLWRudD1cInRydWVcIj48cCBsYW5nPVwiZnJcIiBkaXI9XCJsdHJcIj5SYXZpcyBkXHUyMDE5YXZvaXIgZmFjaWxpdFx1MDBlOSB1bmUgYmVsbGUgc29pclx1MDBlOWUgZFx1MjAxOWludGVsbGlnZW5jZSBjb2xsZWN0aXZlIHN1ciBsZSB0aFx1MDBlOG1lIGRlIGxhIG1vYmlsaXRcdTAwZTkgcHIgbGVzIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2hhc2h0YWcvcmR2TGFNb250YWduZT9zcmM9aGFzaCZhbXA7cmVmX3NyYz10d3NyYyU1RXRmd1wiPiNyZHZMYU1vbnRhZ25lPC9hPiBhdmVjIGxlcyBjbGVybW9udG9pcyAhIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2hhc2h0YWcvcHJveGltaXQlQzMlQTk/c3JjPWhhc2gmYW1wO3JlZl9zcmM9dHdzcmMlNUV0ZndcIj4jcHJveGltaXRcdTAwZTk8L2E+IDxhIGhyZWY9XCJodHRwczovL3QuY28vVkRUbDM3OUNaOFwiPnBpYy50d2l0dGVyLmNvbS9WRFRsMzc5Q1o4PC9hPjwvcD4mbWRhc2g7IExhIENvbXBhZ25pZSBSb3RhdGl2ZSAoQExhQ2llUm90YXRpdmUpIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL0xhQ2llUm90YXRpdmUvc3RhdHVzLzExMDMzODQzMTA2MDA2ODc2MTY/cmVmX3NyYz10d3NyYyU1RXRmd1wiPk1hcmNoIDYsIDIwMTk8L2E+PC9ibG9ja3F1b3RlPjxzY3JpcHQgYXN5bmMgc3JjPVwiaHR0cHM6Ly9wbGF0Zm9ybS50d2l0dGVyLmNvbS93aWRnZXRzLmpzXCIgY2hhcnNldD1cInV0Zi04XCI+PC9zY3JpcHQ+IiwiJV9vZW1iZWRfdGltZV81ZjU2OTg3Y2MxZGVlMzQwZmVkNjNmYjI1MzI4MTIwNiUiOiIxNTU2Mjc2MDUyIiwiJV9vZW1iZWRfOTNjZGIzYzA3YmIyN2E4ODVmNTRjM2U4OWRiNWVlYTglIjoiPGlmcmFtZSB3aWR0aD1cIjQ4MlwiIGhlaWdodD1cIjM2MlwiIHNyYz1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkL0Q5RmtNanhGLW9zP2ZlYXR1cmU9b2VtYmVkJmFtcDt3bW9kZT1vcGFxdWUmYW1wO3Nob3dpbmZvPTBcIiBzdHlsZT1cImJvcmRlcjogbm9uZVwiIGFsbG93PVwiYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGVuY3J5cHRlZC1tZWRpYTsgZ3lyb3Njb3BlOyBwaWN0dXJlLWluLXBpY3R1cmVcIiBhbGxvd2Z1bGxzY3JlZW4+PC9pZnJhbWU+IiwiJV9vZW1iZWRfdGltZV85M2NkYjNjMDdiYjI3YTg4NWY1NGMzZTg5ZGI1ZWVhOCUiOiIxNTU2Mjc2MDUzIiwiJXNiZ19zZWxlY3RlZF9zaWRlYmFyJSI6IjAiLCIlc2JnX3NlbGVjdGVkX3NpZGViYXJfcmVwbGFjZW1lbnQlIjoiMCIsIiVfb2VtYmVkXzFmYWIyMTZhMmQ0N2Y0NzQwNmM0NTlhYzhjNDI2NzFhJSI6IjxpZnJhbWUgdGl0bGU9XCJRdSYjMDM5O2VzdC1jZSBxdWUgTGEgQ29tcGFnbmllIFJvdGF0aXZlID9cIiB3aWR0aD1cIjUwMFwiIGhlaWdodD1cIjM3NVwiIHNyYz1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkL0Q5RmtNanhGLW9zP2ZlYXR1cmU9b2VtYmVkJmFtcDt3bW9kZT1vcGFxdWUmYW1wO3Nob3dpbmZvPTBcIiBzdHlsZT1cImJvcmRlcjogbm9uZVwiIGFsbG93PVwiYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGNsaXBib2FyZC13cml0ZTsgZW5jcnlwdGVkLW1lZGlhOyBneXJvc2NvcGU7IHBpY3R1cmUtaW4tcGljdHVyZTsgd2ViLXNoYXJlXCIgYWxsb3dmdWxsc2NyZWVuPjwvaWZyYW1lPiIsIiVfb2VtYmVkX3RpbWVfMWZhYjIxNmEyZDQ3ZjQ3NDA2YzQ1OWFjOGM0MjY3MWElIjoiMTcwNzQyMTE0MyIsInRheG9ub215PWNhdGVnb3J5IjoiTWVkaWEgbGFicyIsInRheG9ub215PXBvc3RfdGFnIjoiIn0sImljb24iOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxOC8wMi9tYXJrZXItMS5wbmcifSwiaWQiOjE1MTQxLCJpbmZvd2luZG93X2Rpc2FibGUiOmZhbHNlfSx7InNvdXJjZSI6InBvc3QiLCJ0aXRsZSI6Ik1BUzogTmljZS1NYXRpblx1MjAxOXMgbmV3IGlubm92YXRpb24gc3BhY2UiLCJpbmZvd2luZG93X2NvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIk1BUzogTmljZS1NYXRpblx1MjAxOXMgbmV3IGlubm92YXRpb24gc3BhY2VcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjE2OVwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE5LzAzL3NlcmllLU1lZGlhTGFicy1uaWNlLW1hdGluLTYwMHgzMzgtMzAweDE2OS5qcGVnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZ1wiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tcGFkZGluZy1jb250ZW50XzIwXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tbWV0YSBmYy1pdGVtLXNlY29uZGFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlIGZjLXRleHQtY2VudGVyXCI+TWVkaWEgbGFiczwvZGl2PlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLXRleHQtY2VudGVyXCI+TUFTOiBOaWNlLU1hdGluXHUyMDE5cyBuZXcgaW5ub3ZhdGlvbiBzcGFjZTwvZGl2PlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2VcIj5cclxuICAgICAgICAgICAgSW4gMjAxNSwgTmljZS1NYXRpbiBlbWJhcmtlZCBvbiBhIHByb2ZvdW5kIGRpZ2l0YWwgdHJhbnNmb3JtYXRpb24uIEZhY2VkIHdpdGggbWFqb3IgZWNvbm9taWMgZGlmZmljdWx0aWVzLCB0aGUgZGFpbHkgbmV3c3BhcGVyIG9wdGVkIGZvciBhIDE4MC1kZWdyZWUgdHVybiB0byBlc3RhYmxpc2ggaXRzZWxmIGFzIGFuIGlubm92YXRpdmUgbWVkaWEgaW4gaXRzIG93biByaWdodC4gSXRzIGxhdGVzdCBpbml0aWF0aXZlOiBNQVMsIHRoZSBuZXdzcGFwZXJcdTIwMTlzIGlubm92YXRpb24gc3BhY2UsIGxhdW5jaGVkIGxhc3QgSmFudWFyeS5cclxuICAgICAgICA8L2Rpdj5cclxuPGEgaHJlZj1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9tYXMtbmljZS1tYXRpbnMtbmV3LWlubm92YXRpb24tc3BhY2UvXCI+UmVhZCBtb3JlPC9hPlxyXG4gICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuPC9kaXY+XHJcblxyXG4iLCJjb250ZW50IjoiSW4gMjAxNSwgTmljZS1NYXRpbiBlbWJhcmtlZCBvbiBhIHByb2ZvdW5kIGRpZ2l0YWwgdHJhbnNmb3JtYXRpb24uIEZhY2VkIHdpdGggbWFqb3IgZWNvbm9taWMgZGlmZmljdWx0aWVzLCB0aGUgZGFpbHkgbmV3c3BhcGVyIG9wdGVkIGZvciBhIDE4MC1kZWdyZWUgdHVybiB0byBlc3RhYmxpc2ggaXRzZWxmIGFzIGFuIGlubm92YXRpdmUgbWVkaWEgaW4gaXRzIG93biByaWdodC4gSXRzIGxhdGVzdCBpbml0aWF0aXZlOiBNQVMsIHRoZSBuZXdzcGFwZXJcdTIwMTlzIGlubm92YXRpb24gc3BhY2UsIGxhdW5jaGVkIGxhc3QgSmFudWFyeS4iLCJhZGRyZXNzIjoiTmljZSwgRnJhbmNlIiwibG9jYXRpb24iOnsibGF0IjoiNDMuNzEwMTcyOCIsImNpdHkiOiJOaWNlIiwic3RhdGUiOiJQcm92ZW5jZS1BbHBlcy1DXHUwMGY0dGUgZCdBenVyIiwiY291bnRyeSI6IkZyYW5jZSIsImxuZyI6IjcuMjYxOTUzMTk5OTk5OTk0Iiwib25jbGlja19hY3Rpb24iOiJtYXJrZXIiLCJyZWRpcmVjdF9wZXJtYWxpbmsiOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvbWFzLW5pY2UtbWF0aW5zLW5ldy1pbm5vdmF0aW9uLXNwYWNlLyIsInpvb20iOjIsImV4dHJhX2ZpZWxkcyI6eyJwb3N0X2V4Y2VycHQiOiJJbiAyMDE1LCBOaWNlLU1hdGluIGVtYmFya2VkIG9uIGEgcHJvZm91bmQgZGlnaXRhbCB0cmFuc2Zvcm1hdGlvbi4gRmFjZWQgd2l0aCBtYWpvciBlY29ub21pYyBkaWZmaWN1bHRpZXMsIHRoZSBkYWlseSBuZXdzcGFwZXIgb3B0ZWQgZm9yIGEgMTgwLWRlZ3JlZSB0dXJuIHRvIGVzdGFibGlzaCBpdHNlbGYgYXMgYW4gaW5ub3ZhdGl2ZSBtZWRpYSBpbiBpdHMgb3duIHJpZ2h0LiBJdHMgbGF0ZXN0IGluaXRpYXRpdmU6IE1BUywgdGhlIG5ld3NwYXBlclx1MjAxOXMgaW5ub3ZhdGlvbiBzcGFjZSwgbGF1bmNoZWQgbGFzdCBKYW51YXJ5LiIsInBvc3RfY29udGVudCI6Ilt2Y19yb3ddW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIyLzNcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxoMT5NQVM6IE5pY2UtTWF0aW5cdTIwMTlzIG5ldyBpbm5vdmF0aW9uIHNwYWNlPC9oMT5cclxuPGVtPlRoaXMgYXJ0aWNsZSB3YXMgb3JpZ2luYWxseSBwdWJsaXNoZWQgb24gPGEgaHJlZj1cImh0dHBzOi8vd3d3Lm1ldGEtbWVkaWEuZnIvMjAxOS8wMy8wNS9sZS1tYXMtbm91dmVhdS1icmFzLWFybWUtZGUtbGlubm92YXRpb24tZGUtbmljZS1tYXRpbi5odG1sXCI+TVx1MDBlOXRhLU1lZGlhPC9hPiwgYXMgcGFydCBvZiBhbiBlZGl0b3JpYWwgcGFydG5lcnNoaXAgYmV0d2VlbiBNXHUwMGU5dGEtTWVkaWEgYW5kIFdBTi1JRlJBLiBUaGUgYXJ0aWNsZSB3YXMgd3JpdHRlbiBieSA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9hbGV4X2JvdW5pb2xcIj5BbGV4YW5kcmUgQm91bmlvbDwvYT4sIEZyYW5jZSBUXHUwMGU5bFx1MDBlOXZpc2lvbnMsIE1lZGlhTGFiLjwvZW0+XHJcblxyXG5JbiAyMDE1LCBOaWNlLU1hdGluIGVtYmFya2VkIG9uIGEgcHJvZm91bmQgZGlnaXRhbCB0cmFuc2Zvcm1hdGlvbi4gRmFjZWQgd2l0aCBtYWpvciBlY29ub21pYyBkaWZmaWN1bHRpZXMsIHRoZSBkYWlseSBuZXdzcGFwZXIgb3B0ZWQgZm9yIGEgMTgwLWRlZ3JlZSB0dXJuIHRvIGVzdGFibGlzaCBpdHNlbGYgYXMgYW4gaW5ub3ZhdGl2ZSBtZWRpYSBpbiBpdHMgb3duIHJpZ2h0LiBJdHMgbGF0ZXN0IGluaXRpYXRpdmU6IE1BUywgdGhlIG5ld3NwYXBlclx1MjAxOXMgaW5ub3ZhdGlvbiBzcGFjZSwgbGF1bmNoZWQgbGFzdCBKYW51YXJ5LlxyXG5cclxuV2UgaGFkIHRoZSBvcHBvcnR1bml0eSB0byB0YWxrIHdpdGggRGFtaWVuIEFsbGVtYW5kLCBoZWFkIG9mIGRpZ2l0YWwgc2VydmljZXMgYXQgTmljZS1NYXRpbiBhbmQgdGhlIE1BUyBpbml0aWF0aXZlLCB3aG8gb3V0bGluZWQgdGhlIHN0cmF0ZWd5LCBnb2FscyBhbmQgcHJvamVjdHMgb2YgdGhpcyBicmFuZCBuZXcgcGxhY2UgZm9yIGlubm92YXRpb24uXHJcbjxoMz5Gb3VyIGRldmVsb3BtZW50IGFyZWFzPC9oMz5cclxuTGF1bmNoZWQgaW4gSmFudWFyeSAyMDE5LCBNQVMgaXMgaGVhZGVkIGJ5IHRoZSBwcm9qZWN0IG1hbmFnZXIgTWFyam9yaWUgUm91YmF1ZC1MdWJyYW5vLCB3aG8gaXMgYWNjb21wYW5pZWQgYnkgdHdvIGNvbnN1bHRhbnRzLiBCdXQgYWxsIG9mIE5pY2UtTWF0aW5cdTIwMTlzIGRlcGFydG1lbnRzIGFyZSBhbHNvIGludm9sdmVkIGluIGRpZmZlcmVudCBkZWdyZWVzLCBzYXlzIERhbWllbiBBbGxlbWFuZCwgd2hvIGVtcGhhc2lzZXMgdGhlIGltcG9ydGFuY2Ugb2YgZ29vZCBpbnRlcm5hbCBjb21tdW5pY2F0aW9uIFx1MjAxY3RvIG1ha2Ugc3VyZSBNQVMgaXMgbm90IHNlZW4gYXMgYSBjb21wZXRpbmcgc3BhY2UsIGFuZCB0byBmYW1pbGlhcmlzZSB0aGUgcmVzdCBvZiB0aGUgcGVyc29ubmVsIHdpdGggaXQgc28gdGhhdCB0aGV5IHZpc2l0IGFuZCBtYWtlIHVzZSBvZiB0aGUgcGxhY2UuIEl0XHUyMDE5cyBpbXBvcnRhbnQgdGhhdCB0aGUgcGxhY2UgaXMgb24gdGhlIHdheSBmb3IgcGVvcGxlIHdoZW4gdGhleSBnbyB0byB0aGUgb2ZmaWNlLCB0aGF0IGl0XHUyMDE5cyBub3QgYSBjbG9zZWQgc3BhY2UgW1x1MjAyNl0gYXMgd2VsbCBhcyBicmluZ2luZyBpbiBwZW9wbGUgZnJvbSBvdXRzaWRlLlx1MjAxZFxyXG5cclxuSXRcdTIwMTlzIGRldmVsb3BtZW50IGlzIGJhc2VkIG9uIGZvdXIgc3RyYXRlZ2ljIGFyZWFzOlxyXG48dWw+XHJcbiBcdDxsaT48c3Ryb25nPkluY3ViYXRpb24gb2Ygc3RhcnR1cHM8L3N0cm9uZz4gKFRoZSBNQVMgc3RhcnR1cCksIHdoaWNoIGFpbXMgdG8gYmUgXHUyMDFjYSBidXNpbmVzcyBhbmQgc3VjY2VzcyBhY2NlbGVyYXRvciBmb3IgbG9jYWwgZW50cmVwcmVuZXVycyBhbmQgYnVzaW5lc3Nlc1x1MjAxZCwgYXMgPGEgaHJlZj1cImh0dHA6Ly93d3cud2VidGltZW1lZGlhcy5jb20vYXJ0aWNsZS9hdmVjLWxlLW1hcy1uaWNlLW1hdGluLXZhLWxhbmNlci1zb24taW5jdWJhdGV1ci1hY2NlbGVyYXRldXItMjAxODEwMTEtNjMyMTFcIj5kZXNjcmliZWQ8L2E+IGJ5IHRoZSBDRU8gb2YgdGhlIGdyb3VwIEplYW4tTWFyYyBQYXN0b3Jpbm8uPC9saT5cclxuIFx0PGxpPjxzdHJvbmc+SW5jdWJhdGlvbiBvZiBlbWVyZ2luZyBtZWRpYXM8L3N0cm9uZz4gKFRoZSBNQVMgbWVkaWEpIHRvIDxhIGhyZWY9XCJodHRwczovL21lZGl1bS5jb20vbGUtbWFzLW5pY2UtbWF0aW4vcG91cnF1b2ktbGUtbWFzLW5pY2UtbWF0aW4tc2ludmVzdGl0LWF1cHIlQzMlQThzLWRlcy1qb3VybmFsaXN0ZXMtZW50cmVwcmVuZXVycy02Yjc0MjcxZmI0MzVcIj5cdTIwMWNpbnZlbnQgdGhlIGpvdXJuYWxpc3RzIG9mIHRvbW9ycm93XHUyMDFkPC9hPi48L2xpPlxyXG4gXHQ8bGk+PHN0cm9uZz5UaGUgTUFTIGV2ZW50czwvc3Ryb25nPiB0byBvcmdhbmlzZSBjb25mZXJlbmNlcyBvbiBpbm5vdmF0aW9uLjwvbGk+XHJcbiBcdDxsaT48c3Ryb25nPlRoZSBNQVMgdHJhaW5pbmc8L3N0cm9uZz4gdG8gdHJhaW4gbG9jYWwgYnVzaW5lc3NlcyBpbiBkaWdpdGFsIHRyYW5zZm9ybWF0aW9uIGFuZCBjb21tdW5pY2F0aW9uLiBUaGUgdHJhaW5pbmcgaXMgcHJvdmlkZWQgYnkgTmljZS1NYXRpblx1MjAxOXMgc3BlY2lhbGlzdHMgYW5kIGV4dGVybmFsIHNwZWFrZXJzLjwvbGk+XHJcbjwvdWw+XHJcbjxoMz5Eb3VibGUgaW5jdWJhdGlvbiwgbXV0dWFsIGJlbmVmaXRzPC9oMz5cclxuRHVyaW5nIHRoZSBmaXJzdCB5ZWFycyBvZiBNQVMsIE5pY2UtTWF0aW4gd2VsY29tZWQgc2l4IHN0YXJ0dXBzIHdpdGhpbiBpdHMgcHJlbWlzZXM6IDxhIGhyZWY9XCJodHRwczovL2RpYnN0ZXIuY28vXCI+RGlic3RlcjwvYT4sIDxhIGhyZWY9XCJodHRwczovL2JlZXNoYXJ5LmNvbS9cIj5CZWUgc2hhcnk8L2E+LCA8YSBocmVmPVwiaHR0cHM6Ly93d3cuZmFjZWJvb2suY29tL21pYXBwbGljYXRpb25tb2JpbGUvXCI+RGVzZXJ2ZSBNaTwvYT4sIDxhIGhyZWY9XCJodHRwczovL3d3dy50aW1lbmpveS5mci8jL2hvbWVcIj5UaW1lIE5cdTIwMTkgSm95PC9hPiwgPGEgaHJlZj1cImh0dHA6Ly9yZWFkeXBhcmsuZnIvXCI+UmVhZHkgUGFyazwvYT4gZXQgPGEgaHJlZj1cImh0dHBzOi8veW9tYWZhbWlseS5jb20vXCI+WVx1MDBmNm1hIEZhbWlseTwvYT4uIDxzdHJvbmc+VGhlc2Ugc3RhcnR1cHMgZG8gbm90IGRldmVsb3AgdGVjaG5pY2FsIGlubm92YXRpb25zLCBidXQgb2ZmZXIgdmFyaW91cyBzZXJ2aWNlcy48L3N0cm9uZz4gRm9yIERhbWllbiBBbGxlbWFuZCwgZXZlbiBpZiB0aGUgZmlybXMgZG8gbm90IGhhdmUgbWVkaWEgYWN0aXZpdGllcyBhcyBzdWNoLCBcdTIwMWN0aGUgc3RhcnR1cHMgYXJlIHBlcmZlY3RseSBjb2hlcmVudCB3aXRoIHRoZSBlZGl0b3JpYWwgbGluZSBvZiBvdXIgc3Vic2NyaXB0aW9ucyBvZmZlclx1MjAxZCwgd2l0aCBcdTIwMWN0aGUgcmVhZGVyIGF0IHRoZSBjZW50cmUgb2YgdGhlIHN1YnNjcmlwdGlvbiBvZmZlciwgb3Igb24gc29sdXRpb25zIGpvdXJuYWxpc20gdGhhdCBicmluZ3MgY29uY3JldGUgc29sdXRpb25zIHRvIHBlb3BsZVx1MjAxOXMgcHJvYmxlbXMuXHUyMDFkIEZvciBleGFtcGxlLCBEaWJzdGVyIG9mZmVycyBmb3IgcGVvcGxlIHdobyBoYXZlIGhhZCBhIGZsaWdodCBjYW5jZWxsZWQgb3IgZGVsYXllZCB0byBoYW5kbGUgYWRtaW5pc3RyYXRpdmUgcHJvY2VkdXJlcyB0byBvYnRhaW4gY29tcGVuc2F0aW9uLlxyXG5cclxuVGhlIG5ld3NwYXBlciBwcm92aWRlcyBmb3IgZnJlZSBpdHMgcHJlbWlzZXMgZm9yIHRoZSBjb21wYW5pZXMsIGFzIHdlbGwgYXMgdGhlIHBvc3NpYmlsaXR5IHRvIFx1MjAxY2JldGEgdGVzdFx1MjAxZCB0aGVpciBzZXJ2aWNlcyB3aXRoIHRoZSBjb21tdW5pdHkgb2YgcmVhZGVycyBhcyBzb29uIGFzIHRoZXkgYXJlIHZpYWJsZS4gVGhlIHN0YXJ0dXBzIHByb21vdGUgd29ya2luZyBtZXRob2RzIGJhc2VkIG9uIGhvcml6b250YWxpdHksIGFnaWxpdHkgYW5kIG11dHVhbCBzdXBwb3J0LCB3aGljaCBjYW4gb2ZmZXIgbmV3IHBlcnNwZWN0aXZlcyB0byBkYWlseSB3b3JrIHdpdGhpbiB0aGUgbmV3c3BhcGVyLlxyXG5cclxuaHR0cHM6Ly90d2l0dGVyLmNvbS9NYXJqTHVicmFuby9zdGF0dXMvMTEwMDY2ODY3MzM1MjU4MTEyMVxyXG5cclxuTmljZS1NYXRpbiBoYXMgYWxzbyBob3N0ZWQgdHdvIG1lZGlhIGluIGl0cyBpbmN1YmF0b3IgdGhpcyB5ZWFyOiA8YSBocmVmPVwiaHR0cHM6Ly93d3cuc3dpdGNob25wYXBlci5jb20vXCI+U3dpdGNoIE9uIFBhcGVyPC9hPiwgYSBzaXRlIHRoYXQgZXhwbGFpbnMgbmV3cyB0aHJvdWdoIHRoZSBwcmlzbSBvZiBjb250ZW1wb3JhcnkgYXJ0LCBhbmQgPGEgaHJlZj1cImh0dHA6Ly93d3cucmFkaW9uaXp6YS5pdC9cIj5SYWRpbyBOaXp6YTwvYT4sIHdoaWNoIHByb2R1Y2VzIGxvY2FsIG5ld3MgaW4gSXRhbGlhbiB0aHJvdWdoIGl0cyBibG9nIGFuZCBwb2RjYXN0LiBSYWRpbyBOaXp6YSwgZm9yIGV4YW1wbGUsIGxldHMgdGhlIG5ld3NwYXBlciBjb25uZWN0IHdpdGggYSBjb21tdW5pdHkgd2hvIGl0IHdvdWxkblx1MjAxOXQgb3RoZXJ3aXNlIHJlYWNoIChJdGFsaWFucyBpbiBOaWNlKSwgYW5kIGludmVzdCBpbiB0aGUgZmllbGQgb2YgcG9kY2FzdGluZywgd2hlcmUgTmljZS1NYXRpbiB3b3VsZCBsaWtlIHRvIGVuZ2FnZSBtb3JlIGluIHRoZSBmdXR1cmUuIERhbWllbiBBbGxlbWFuZCBzcGVha3MgZXZlbiBvZiBhIFx1MjAxY2tpbmQgb2YgTmljZS1NYXRpbiBpbiBJdGFsaWFuXHUyMDFkLCB1bmRlcmxpbmluZyBldmVuIG1vcmUgdGhlIGNvbXBsZW1lbnRhcnkgYW5kIG11dHVhbCBiZW5lZml0cyB0aGVzZSBtZWRpYSBjYW4gb2ZmZXIgdG8gZWFjaCBvdGhlci5cclxuPGgzPkFuIGVjb25vbWljIG1vZGVsIHRvIGRldmVsb3A8L2gzPlxyXG5JbiBvcmRlciB0byBmaW5hbmNlIHRoaXMgbmV3IGlubm92YXRpb24gc3BhY2UsIE5pY2UtTWF0aW4gcmVsaWVzIG9uIGV2ZW50cyBhbmQgdHJhaW5pbmcgc2VjdGlvbnMgb2YgTUFTIHRoYXQgZ2VuZXJhdGUgcmV2ZW51ZXMsIGJ1dCBhbHNvIG9uIGdyYW50cy4gU29tZSBvZiB0aGVzZSBhcmUgcHJpdmF0ZSwgdGhyb3VnaCBkaWZmZXJlbnQgZnVuZHMgc3VjaCBhcyB0aG9zZSBkZWRpY2F0ZWQgdG8gdGhlIHByZXNzZSBieSBHb29nbGUsIGFuZCBzb21lIHB1YmxpYywgZ3JhbnRlZCBieSB0aGUgRnJlbmNoIE1pbmlzdHJ5IG9mIEN1bHR1cmUuIFRoZXNlIGZ1bmRzIGFyZSBhYnNvbHV0ZWx5IG5lY2Vzc2FyeSBmb3IgaW5ub3ZhdGlvbiwgdW5kZXJsaW5lcyBEYW1pZW4gQWxsZW1hbmQ6IFx1MjAxY2lmIEkgZGlkblx1MjAxOXQgaGF2ZSBhbGwgdGhlc2UgZnVuZHMsIEkgd291bGQgbmV2ZXIgaGF2ZSBiZWVuIGFibGUgdG8gbGVhZCBhbGwgdGhlc2UgcHJvamVjdHNcdTIwMWQuIEl0IGFsc28gdGhlIDxhIGhyZWY9XCJodHRwOi8vd3d3LmN1bHR1cmUuZ291di5mci9UaGVtYXRpcXVlcy9QcmVzc2UvQWlkZXMtYS1sYS1wcmVzc2UvTGUtRm9uZHMtZGUtc291dGllbi1hLWwtZW1lcmdlbmNlLWV0LWEtbC1pbm5vdmF0aW9uLWRhbnMtbGEtcHJlc3NlXCI+c3VwcG9ydCBmdW5kIGZvciBlbWVyZ2VuY2UgYW5kIGlubm92YXRpb24gaW4gdGhlIHByZXNzPC9hPiB0aGF0IHBlcm1pdHRlZCB0aGUgbGF1bmNoaW5nIG9mIE1BUy5cclxuXHJcbk1BUyBpcyBhbHNvIGVjb25vbWljYWxseSBzaWduaWZpY2FudCBmb3IgdGhlIG5ld3NwYXBlci4gRm9yIERhbWllbiBBbGxlbWFuZCwgXHUyMDFjaXRcdTIwMTlzIGEgY2xlYXIgZGl2ZXJzaWZpY2F0aW9uXHUyMDFkIG9mIHRoZSBncm91cFx1MjAxOXMgYWN0aXZpdGllcy4gVGhpcyB3aWxsIHVsdGltYXRlbHkgYWxsb3cgdGhlIGRpc2NvdmVyeSBvZiBhIHZpYWJsZSBidXNpbmVzcyBtb2RlbDpcclxuPGJsb2NrcXVvdGU+XHUyMDFjSXRcdTIwMTlzIG5lY2Vzc2FyeSB0byBkaXZlcnNpZnkuIFNvIGZhciBubyBvbmUgaGFzIHVubG9ja2VkIHRoZSBidXNpbmVzcyBtb2RlbC4gVGhlIGtleSB3aWxsIGJlIGEgY29tYmluYXRpb24gb2Ygc29sdXRpb25zIHdoaWNoLCB3aGVuIHB1dCB0b2dldGhlciwgd2lsbCBzdXN0YWluIE5pY2UtTWF0aW4uIFRoZSBNQVMgaXMgcGFydCBvZiB0aGlzIGNvbWJpbmF0aW9uIG9mIHNvbHV0aW9ucyB0aGF0IHdpbGwgdHVybiBhcm91bmQgTmljZS1NYXRpbi5cdTIwMWQgLSBEYW1pZW4gQWxsZW1hbmQ8L2Jsb2NrcXVvdGU+XHJcbjxoMz5QZXJtYW5lbnQgaW5ub3ZhdGlvbjwvaDM+XHJcblRoZSBsYXVuY2ggb2YgdGhlIGlubm92YXRpb24gc3BhY2UgaXMgcGFydCBvZiBhIGJyb2FkZXIgZnJhbWV3b3JrIG9mIGlubm92YXRpb24gb2YgdGhlIGdyb3VwLiBTaW5jZSAyMDE1LCBOaWNlLU1hdGluIGhhcyBsYXVuY2hlZCBhIG11bHRpdHVkZSBvZiBkaXNydXB0aXZlIHByb2plY3RzOlxyXG48dWw+XHJcbiBcdDxsaT5BIHNlY3Rpb24gZGVkaWNhdGVkIHRvIHNvbHV0aW9ucyBqb3VybmFsaXNtIHdpdGggPGEgaHJlZj1cImh0dHBzOi8vd3d3Lm5pY2VtYXRpbi5jb20vc3VqZXQvc29sdXRpb25zXCI+I01vbkpvdXJuYWw8L2E+LCBhIHNlY3Rpb24gd2hlcmUgc3Vic2NyaWJlcnMgY2hvb3NlIHRoZSB0b3BpY3MgZm9yIHRoZSBuZXdzcm9vbSB0byB0YWNrbGUuPC9saT5cclxuIFx0PGxpPkEgY2hhdGJvdCBvbiBsb2NhbCBuZXdzIGluIDIwMTc8L2xpPlxyXG4gXHQ8bGk+PGEgaHJlZj1cImh0dHBzOi8va2lkc21hdGluLmNvbS9cIj5LaWRzLU1hdGluPC9hPiwgYSBuZXdzIG1lZGlhIGZvciB1bmRlciAxMyB5ZWFyIG9sZHM7IGEgY29tbXVuaXR5IGluY2x1ZGVkIHNpbmNlIHRoZSBiZWdpbm5pbmcgb2YgdGhlIHByb2plY3QgaW4gYSBjcm93ZGZ1bmRpbmcgY2FtcGFpZ24uPC9saT5cclxuPC91bD5cclxuW2VtYmVkXWh0dHBzOi8veW91dHUuYmUvNVExMkg1QV92ZndbL2VtYmVkXVxyXG5cclxuVGhlIG5ld3NwYXBlciBwbGFucyB0byBjb250aW51ZSBvbiB0aGlzIHBhdGgsIGFuZCBpcyBwbGFubmluZyBcdTIwMWNiYWNrZ3JvdW5kIHdvcmtzXHUyMDFkIGluIDIwMTksIHN0YXJ0aW5nIHdpdGggdGhlIHJlZGVzaWduIG9mIHRoZSB3ZWJzaXRlIGFuZCB0aGUgc3Vic2NyaWJlciBvZmZlci5cclxuPGJsb2NrcXVvdGU+XHUyMDFjV2UgYXJlIHRyeWluZyB0byBidWlsZCBhIE5ldGZsaXggZm9yIGxvY2FsIG5ld3NcdTIwMWQsIHJldmVhbHMgRGFtaWVuIEFsbGVtYW5kLjwvYmxvY2txdW90ZT5cclxuQW5vdGhlciBwcm9qZWN0IGxhdW5jaGVkIGluIHBhcmFsbGVsIHRoaXMgeWVhciBpcyB0aGUgYXJyaXZhbCBvZiBhIHJvYm90IGpvdXJuYWxpc3QgaW4gdGhlIGRhaWx5XHUyMDE5cyBvZmZpY2VzLCBtYWRlIHBvc3NpYmxlIGJ5IDxhIGhyZWY9XCJodHRwczovL25ld3Npbml0aWF0aXZlLndpdGhnb29nbGUuY29tL2RuaWZ1bmQvXCI+ZnVuZGluZyBmcm9tIEdvb2dsZTwvYT4uIEl0IHdpbGwgYmUgYSBjb3JuZXJzdG9uZSBvZiBjb250ZW50IGF1dG9tYXRpc2F0aW9uLCBub3RhYmx5IGZvciBjb250ZW50IHdpdGggbGl0dGxlIGFkZGVkIHZhbHVlIHN1Y2ggYXMgdGhlIHdlYXRoZXIsIGFsbG93aW5nIGpvdXJuYWxpc3RzIHRvIHNwZW5kIG1vcmUgdGltZSBvbiBvdGhlciB3b3JrLiBBbiBhZGRpdGlvbmFsIHRhc2sgZm9yIHRoZSByb2JvdCBpcyBkYXRhIHByb2Nlc3Npbmc7IGl0IHdpbGwgYmUgYWJsZSB0byBhbGVydCBqb3VybmFsaXN0cyBieSBoaWdobGlnaHRpbmcgcmVsZXZhbnQgaW5mb3JtYXRpb24uXHJcbjxibG9ja3F1b3RlPlx1MjAxY1RoZSBnb2FsIHdpbGwgYmUgdG8gbGliZXJhdGUgam91cm5hbGlzdHNcdTIwMTkgdGltZSBzbyB0aGV5IGNhbiBnbyBzZWVrIGhpZ2hlciBxdWFsaXR5IGluZm9ybWF0aW9uLlx1MjAxZCAtIERhbWllbiBBbGxlbWFuZDwvYmxvY2txdW90ZT5cclxuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddIiwicG9zdF90aXRsZSI6Ik1BUzogTmljZS1NYXRpblx1MjAxOXMgbmV3IGlubm92YXRpb24gc3BhY2UiLCJwb3N0X2xpbmsiOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvbWFzLW5pY2UtbWF0aW5zLW5ldy1pbm5vdmF0aW9uLXNwYWNlLyIsInBvc3RfZmVhdHVyZWRfaW1hZ2UiOiI8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIk1BUzogTmljZS1NYXRpblx1MjAxOXMgbmV3IGlubm92YXRpb24gc3BhY2VcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjE2OVwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE5LzAzL3NlcmllLU1lZGlhTGFicy1uaWNlLW1hdGluLTYwMHgzMzgtMzAweDE2OS5qcGVnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+IiwicG9zdF9jYXRlZ29yaWVzIjoiTWVkaWEgbGFicyIsInBvc3RfdGFncyI6ImJ1c2luZXNzIG1vZGVscywgY3VsdHVyZSBvZiBpbm5vdmF0aW9uLCBpbmN1YmF0b3IsIHN0YXJ0dXBzLCB0cmFpbmluZyBhbmQgZWR1Y2F0aW9uIiwiJV9lZGl0X2xvY2slIjoiMTU2NDU5Njc0MTo5MzEiLCIlX2VkaXRfbGFzdCUiOiI5MzEiLCIlX29lbWJlZF82YjI0MjQ2NzRjZTFmNTBkZjkzODliZjRjNTgxYTAxMCUiOiI8YmxvY2txdW90ZSBjbGFzcz1cInR3aXR0ZXItdHdlZXRcIiBkYXRhLXdpZHRoPVwiNTUwXCIgZGF0YS1kbnQ9XCJ0cnVlXCI+PHAgbGFuZz1cImZyXCIgZGlyPVwibHRyXCI+RW4gbW9kZSBoYXBweSwgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vaGFzaHRhZy9MZU1hcz9zcmM9aGFzaCZhbXA7cmVmX3NyYz10d3NyYyU1RXRmd1wiPiNMZU1hczwvYT4gPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vTmljZV9NYXRpbj9yZWZfc3JjPXR3c3JjJTVFdGZ3XCI+QE5pY2VfTWF0aW48L2E+IGVzdCBuXHUwMGU5LiBMZSBiXHUwMGU5Ylx1MDBlOSA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9oYXNodGFnL0lubm92YXRpb24/c3JjPWhhc2gmYW1wO3JlZl9zcmM9dHdzcmMlNUV0ZndcIj4jSW5ub3ZhdGlvbjwvYT4gc2UgcG9ydGUgYmllbi4gTm9zIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2hhc2h0YWcvU3RhcnR1cD9zcmM9aGFzaCZhbXA7cmVmX3NyYz10d3NyYyU1RXRmd1wiPiNTdGFydHVwPC9hPiBhcmUgaW4gZGEgcGxhY2UuIEJpZW52ZW51IFx1MDBlMCAgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vYm9uam91cl9kaWJzdGVyP3JlZl9zcmM9dHdzcmMlNUV0ZndcIj5AYm9uam91cl9kaWJzdGVyPC9hPiAsIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL0JlZVNoYXJ5P3JlZl9zcmM9dHdzcmMlNUV0ZndcIj5AQmVlU2hhcnk8L2E+LCA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9UaW1lTmpveT9yZWZfc3JjPXR3c3JjJTVFdGZ3XCI+QFRpbWVOam95PC9hPiwgWW9tYSBGYW1pbHksIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL3JlYWR5X3Bhcms/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkByZWFkeV9wYXJrPC9hPiwgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vZGVzZXJ2ZV9oZXI/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkBkZXNlcnZlX2hlcjwvYT4gPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vc3dpdGNob25wYXBlcj9yZWZfc3JjPXR3c3JjJTVFdGZ3XCI+QHN3aXRjaG9ucGFwZXI8L2E+IGV0IFJhZGlvIE5penphICEgPGEgaHJlZj1cImh0dHBzOi8vdC5jby9DdThCUkN5UjNzXCI+cGljLnR3aXR0ZXIuY29tL0N1OEJSQ3lSM3M8L2E+PC9wPiZtZGFzaDsgTWFyam9yaWUgTHVicmFuby1Sb3ViYXVkIChATWFyakx1YnJhbm8pIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL01hcmpMdWJyYW5vL3N0YXR1cy8xMTAwNjY4NjczMzUyNTgxMTIxP3JlZl9zcmM9dHdzcmMlNUV0ZndcIj5GZWJydWFyeSAyNywgMjAxOTwvYT48L2Jsb2NrcXVvdGU+PHNjcmlwdCBhc3luYyBzcmM9XCJodHRwczovL3BsYXRmb3JtLnR3aXR0ZXIuY29tL3dpZGdldHMuanNcIiBjaGFyc2V0PVwidXRmLThcIj48L3NjcmlwdD4iLCIlX29lbWJlZF90aW1lXzZiMjQyNDY3NGNlMWY1MGRmOTM4OWJmNGM1ODFhMDEwJSI6IjE1NTI1NzcyMzIiLCIlX29lbWJlZF9kZGU3NTE2YWQ0Y2Y1MzNmZjAxMTU2MWVkNjU4ODVjNiUiOiI8aWZyYW1lIHdpZHRoPVwiMTIwMFwiIGhlaWdodD1cIjY3NVwiIHNyYz1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkLzVRMTJINUFfdmZ3P2ZlYXR1cmU9b2VtYmVkJmFtcDt3bW9kZT1vcGFxdWUmYW1wO3Nob3dpbmZvPTBcIiBzdHlsZT1cImJvcmRlcjogbm9uZVwiIGFsbG93PVwiYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGVuY3J5cHRlZC1tZWRpYTsgZ3lyb3Njb3BlOyBwaWN0dXJlLWluLXBpY3R1cmVcIiBhbGxvd2Z1bGxzY3JlZW4+PC9pZnJhbWU+IiwiJV9vZW1iZWRfdGltZV9kZGU3NTE2YWQ0Y2Y1MzNmZjAxMTU2MWVkNjU4ODVjNiUiOiIxNTU2Mjc2MTY4IiwiJV9vZW1iZWRfM2I4MmUwZjI2Yjc0MDY3YWFkOGM5YzkxYjAzN2M1YTIlIjoiPGlmcmFtZSB3aWR0aD1cIjU2MlwiIGhlaWdodD1cIjMxNlwiIHNyYz1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkLzVRMTJINUFfdmZ3P2ZlYXR1cmU9b2VtYmVkJmFtcDt3bW9kZT1vcGFxdWUmYW1wO3Nob3dpbmZvPTBcIiBzdHlsZT1cImJvcmRlcjogbm9uZVwiIGFsbG93PVwiYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGVuY3J5cHRlZC1tZWRpYTsgZ3lyb3Njb3BlOyBwaWN0dXJlLWluLXBpY3R1cmVcIiBhbGxvd2Z1bGxzY3JlZW4+PC9pZnJhbWU+IiwiJV9vZW1iZWRfdGltZV8zYjgyZTBmMjZiNzQwNjdhYWQ4YzljOTFiMDM3YzVhMiUiOiIxNTUyNTc3NTgwIiwiJV90aHVtYm5haWxfaWQlIjoiMTUwNjMiLCIlc2xpZGVfdGVtcGxhdGUlIjoiZGVmYXVsdCIsIiVfd3BiX3ZjX2pzX3N0YXR1cyUiOiJ0cnVlIiwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6Ik5pY2UsIEZyYW5jZSIsIiVfd3BnbXBfbG9jYXRpb25fY2l0eSUiOiJOaWNlIiwiJV93cGdtcF9sb2NhdGlvbl9zdGF0ZSUiOiJQcm92ZW5jZS1BbHBlcy1DXHUwMGY0dGUgZCdBenVyIiwiJV93cGdtcF9sb2NhdGlvbl9jb3VudHJ5JSI6IkZyYW5jZSIsIiVfd3BnbXBfbWV0YWJveF9sYXRpdHVkZSUiOiI0My43MTAxNzI4IiwiJV93cGdtcF9tZXRhYm94X2xvbmdpdHVkZSUiOiI3LjI2MTk1MzE5OTk5OTk5NCIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiMlwiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6Ik47IiwiJV93cGdtcF9tZXRhYm94X3RheG9tb21pZXNfdGVybXMlIjoiTjsiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6Ik47IiwiJV9rbGVvX3RyYW5zcGFyZW50X21lbnVfY29sb3IlIjoid2hpdGUiLCIlX2tsZW9fdGl0bGVfY29sb3IlIjoiIyIsIiVfa2xlb190aXRsZV9iZyUiOiIsIHJlcGVhdCwgaW5oZXJpdCwgc2Nyb2xsLCBsZWZ0IHRvcCIsIiVfa2xlb190aXRsZV9iZ19jb2xvciUiOiIjIiwiJV95b2FzdF93cHNlb19jb250ZW50X3Njb3JlJSI6IjYwIiwiJV9vZW1iZWRfZDk4NGQ1NTA0ZDkzYTI2NDhiNDVkZDZkNGU5ZDE4YWMlIjoiPGJsb2NrcXVvdGUgY2xhc3M9XCJ0d2l0dGVyLXR3ZWV0XCIgZGF0YS13aWR0aD1cIjU1MFwiIGRhdGEtZG50PVwidHJ1ZVwiPjxwIGxhbmc9XCJmclwiIGRpcj1cImx0clwiPkVuIG1vZGUgaGFwcHksIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2hhc2h0YWcvTGVNYXM/c3JjPWhhc2gmYW1wO3JlZl9zcmM9dHdzcmMlNUV0ZndcIj4jTGVNYXM8L2E+IDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL05pY2VfTWF0aW4/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkBOaWNlX01hdGluPC9hPiBlc3Qgblx1MDBlOS4gTGUgYlx1MDBlOWJcdTAwZTkgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vaGFzaHRhZy9Jbm5vdmF0aW9uP3NyYz1oYXNoJmFtcDtyZWZfc3JjPXR3c3JjJTVFdGZ3XCI+I0lubm92YXRpb248L2E+IHNlIHBvcnRlIGJpZW4uIE5vcyA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9oYXNodGFnL1N0YXJ0dXA/c3JjPWhhc2gmYW1wO3JlZl9zcmM9dHdzcmMlNUV0ZndcIj4jU3RhcnR1cDwvYT4gYXJlIGluIGRhIHBsYWNlLiBCaWVudmVudSBcdTAwZTAgIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2JvbmpvdXJfZGlic3Rlcj9yZWZfc3JjPXR3c3JjJTVFdGZ3XCI+QGJvbmpvdXJfZGlic3RlcjwvYT4gLCA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9CZWVTaGFyeT9yZWZfc3JjPXR3c3JjJTVFdGZ3XCI+QEJlZVNoYXJ5PC9hPiwgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vVGltZU5qb3k/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkBUaW1lTmpveTwvYT4sIFlvbWEgRmFtaWx5LCA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9yZWFkeV9wYXJrP3JlZl9zcmM9dHdzcmMlNUV0ZndcIj5AcmVhZHlfcGFyazwvYT4sIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2Rlc2VydmVfaGVyP3JlZl9zcmM9dHdzcmMlNUV0ZndcIj5AZGVzZXJ2ZV9oZXI8L2E+IDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL3N3aXRjaG9ucGFwZXI/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkBzd2l0Y2hvbnBhcGVyPC9hPiBldCBSYWRpbyBOaXp6YSAhIDxhIGhyZWY9XCJodHRwczovL3QuY28vQ3U4QlJDeVIzc1wiPnBpYy50d2l0dGVyLmNvbS9DdThCUkN5UjNzPC9hPjwvcD4mbWRhc2g7IE1hcmpvcmllIEx1YnJhbm8tUm91YmF1ZCAoQExlTWFzTmljZU1hdGluKSA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9MZU1hc05pY2VNYXRpbi9zdGF0dXMvMTEwMDY2ODY3MzM1MjU4MTEyMT9yZWZfc3JjPXR3c3JjJTVFdGZ3XCI+RmVicnVhcnkgMjcsIDIwMTk8L2E+PC9ibG9ja3F1b3RlPjxzY3JpcHQgYXN5bmMgc3JjPVwiaHR0cHM6Ly9wbGF0Zm9ybS50d2l0dGVyLmNvbS93aWRnZXRzLmpzXCIgY2hhcnNldD1cInV0Zi04XCI+PC9zY3JpcHQ+IiwiJV9vZW1iZWRfdGltZV9kOTg0ZDU1MDRkOTNhMjY0OGI0NWRkNmQ0ZTlkMThhYyUiOiIxNTU2Mjc2MTY4IiwiJV95b2FzdF93cHNlb19wcmltYXJ5X2NhdGVnb3J5JSI6IjE0MiIsIiVfb2VtYmVkXzQwMjQwMDFjMWVlZGUwZjUwYmJkNmE0MGM2NWU5Mzc2JSI6IjxibG9ja3F1b3RlIGNsYXNzPVwidHdpdHRlci10d2VldFwiIGRhdGEtd2lkdGg9XCI0ODRcIiBkYXRhLWRudD1cInRydWVcIj48cCBsYW5nPVwiZnJcIiBkaXI9XCJsdHJcIj5FbiBtb2RlIGhhcHB5LCA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9oYXNodGFnL0xlTWFzP3NyYz1oYXNoJmFtcDtyZWZfc3JjPXR3c3JjJTVFdGZ3XCI+I0xlTWFzPC9hPiA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9OaWNlX01hdGluP3JlZl9zcmM9dHdzcmMlNUV0ZndcIj5ATmljZV9NYXRpbjwvYT4gZXN0IG5cdTAwZTkuIExlIGJcdTAwZTliXHUwMGU5IDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2hhc2h0YWcvSW5ub3ZhdGlvbj9zcmM9aGFzaCZhbXA7cmVmX3NyYz10d3NyYyU1RXRmd1wiPiNJbm5vdmF0aW9uPC9hPiBzZSBwb3J0ZSBiaWVuLiBOb3MgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vaGFzaHRhZy9TdGFydHVwP3NyYz1oYXNoJmFtcDtyZWZfc3JjPXR3c3JjJTVFdGZ3XCI+I1N0YXJ0dXA8L2E+IGFyZSBpbiBkYSBwbGFjZS4gQmllbnZlbnUgXHUwMGUwICA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9ib25qb3VyX2RpYnN0ZXI/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkBib25qb3VyX2RpYnN0ZXI8L2E+ICwgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vQmVlU2hhcnk/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkBCZWVTaGFyeTwvYT4sIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL1RpbWVOam95P3JlZl9zcmM9dHdzcmMlNUV0ZndcIj5AVGltZU5qb3k8L2E+LCBZb21hIEZhbWlseSwgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vcmVhZHlfcGFyaz9yZWZfc3JjPXR3c3JjJTVFdGZ3XCI+QHJlYWR5X3Bhcms8L2E+LCA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9kZXNlcnZlX2hlcj9yZWZfc3JjPXR3c3JjJTVFdGZ3XCI+QGRlc2VydmVfaGVyPC9hPiA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9zd2l0Y2hvbnBhcGVyP3JlZl9zcmM9dHdzcmMlNUV0ZndcIj5Ac3dpdGNob25wYXBlcjwvYT4gZXQgUmFkaW8gTml6emEgISA8YSBocmVmPVwiaHR0cHM6Ly90LmNvL0N1OEJSQ3lSM3NcIj5waWMudHdpdHRlci5jb20vQ3U4QlJDeVIzczwvYT48L3A+Jm1kYXNoOyBNYXJqb3JpZSBMdWJyYW5vLVJvdWJhdWQgKEBNYXJqTHVicmFubykgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vTWFyakx1YnJhbm8vc3RhdHVzLzExMDA2Njg2NzMzNTI1ODExMjE/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkZlYnJ1YXJ5IDI3LCAyMDE5PC9hPjwvYmxvY2txdW90ZT48c2NyaXB0IGFzeW5jIHNyYz1cImh0dHBzOi8vcGxhdGZvcm0udHdpdHRlci5jb20vd2lkZ2V0cy5qc1wiIGNoYXJzZXQ9XCJ1dGYtOFwiPjwvc2NyaXB0PiIsIiVfb2VtYmVkX3RpbWVfNDAyNDAwMWMxZWVkZTBmNTBiYmQ2YTQwYzY1ZTkzNzYlIjoiMTU1MjU3NzY5NyIsIiVfb2VtYmVkXzJmNDEzOWRkZThjOWU0MjY1NGM0ODgwZjNkZDZmNmZlJSI6IjxpZnJhbWUgd2lkdGg9XCI0ODRcIiBoZWlnaHQ9XCIyNzJcIiBzcmM9XCJodHRwczovL3d3dy55b3V0dWJlLmNvbS9lbWJlZC81UTEySDVBX3Zmdz9mZWF0dXJlPW9lbWJlZCZhbXA7d21vZGU9b3BhcXVlJmFtcDtzaG93aW5mbz0wXCIgc3R5bGU9XCJib3JkZXI6IG5vbmVcIiBhbGxvdz1cImFjY2VsZXJvbWV0ZXI7IGF1dG9wbGF5OyBlbmNyeXB0ZWQtbWVkaWE7IGd5cm9zY29wZTsgcGljdHVyZS1pbi1waWN0dXJlXCIgYWxsb3dmdWxsc2NyZWVuPjwvaWZyYW1lPiIsIiVfb2VtYmVkX3RpbWVfMmY0MTM5ZGRlOGM5ZTQyNjU0YzQ4ODBmM2RkNmY2ZmUlIjoiMTU1MjU3NzY5OCIsIiVfa2xlb190aXRsZV9jaGVja2JveCUiOiIxIiwiJV9vZW1iZWRfNmIxNTZiZjcxOTIxZGFiYjI2NTI2OTQxNmZjZDUzZTYlIjoiPGlmcmFtZSB3aWR0aD1cIjQ4M1wiIGhlaWdodD1cIjI3MlwiIHNyYz1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkLzVRMTJINUFfdmZ3P2ZlYXR1cmU9b2VtYmVkJmFtcDt3bW9kZT1vcGFxdWUmYW1wO3Nob3dpbmZvPTBcIiBzdHlsZT1cImJvcmRlcjogbm9uZVwiIGFsbG93PVwiYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGVuY3J5cHRlZC1tZWRpYTsgZ3lyb3Njb3BlOyBwaWN0dXJlLWluLXBpY3R1cmVcIiBhbGxvd2Z1bGxzY3JlZW4+PC9pZnJhbWU+IiwiJV9vZW1iZWRfdGltZV82YjE1NmJmNzE5MjFkYWJiMjY1MjY5NDE2ZmNkNTNlNiUiOiIxNTUyNTc3ODYzIiwiJV9vZW1iZWRfZjVjNTQwZWIxMGVmOGJiNDBmYzJhZjkyMjliZTVmZmYlIjoiPGJsb2NrcXVvdGUgY2xhc3M9XCJ0d2l0dGVyLXR3ZWV0XCIgZGF0YS13aWR0aD1cIjQ4M1wiIGRhdGEtZG50PVwidHJ1ZVwiPjxwIGxhbmc9XCJmclwiIGRpcj1cImx0clwiPkVuIG1vZGUgaGFwcHksIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2hhc2h0YWcvTGVNYXM/c3JjPWhhc2gmYW1wO3JlZl9zcmM9dHdzcmMlNUV0ZndcIj4jTGVNYXM8L2E+IDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL05pY2VfTWF0aW4/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkBOaWNlX01hdGluPC9hPiBlc3Qgblx1MDBlOS4gTGUgYlx1MDBlOWJcdTAwZTkgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vaGFzaHRhZy9Jbm5vdmF0aW9uP3NyYz1oYXNoJmFtcDtyZWZfc3JjPXR3c3JjJTVFdGZ3XCI+I0lubm92YXRpb248L2E+IHNlIHBvcnRlIGJpZW4uIE5vcyA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9oYXNodGFnL1N0YXJ0dXA/c3JjPWhhc2gmYW1wO3JlZl9zcmM9dHdzcmMlNUV0ZndcIj4jU3RhcnR1cDwvYT4gYXJlIGluIGRhIHBsYWNlLiBCaWVudmVudSBcdTAwZTAgIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2JvbmpvdXJfZGlic3Rlcj9yZWZfc3JjPXR3c3JjJTVFdGZ3XCI+QGJvbmpvdXJfZGlic3RlcjwvYT4gLCA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9CZWVTaGFyeT9yZWZfc3JjPXR3c3JjJTVFdGZ3XCI+QEJlZVNoYXJ5PC9hPiwgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vVGltZU5qb3k/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkBUaW1lTmpveTwvYT4sIFlvbWEgRmFtaWx5LCA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9yZWFkeV9wYXJrP3JlZl9zcmM9dHdzcmMlNUV0ZndcIj5AcmVhZHlfcGFyazwvYT4sIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2Rlc2VydmVfaGVyP3JlZl9zcmM9dHdzcmMlNUV0ZndcIj5AZGVzZXJ2ZV9oZXI8L2E+IDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL3N3aXRjaG9ucGFwZXI/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkBzd2l0Y2hvbnBhcGVyPC9hPiBldCBSYWRpbyBOaXp6YSAhIDxhIGhyZWY9XCJodHRwczovL3QuY28vQ3U4QlJDeVIzc1wiPnBpYy50d2l0dGVyLmNvbS9DdThCUkN5UjNzPC9hPjwvcD4mbWRhc2g7IE1hcmpvcmllIEx1YnJhbm8tUm91YmF1ZCAoQE1hcmpMdWJyYW5vKSA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9NYXJqTHVicmFuby9zdGF0dXMvMTEwMDY2ODY3MzM1MjU4MTEyMT9yZWZfc3JjPXR3c3JjJTVFdGZ3XCI+RmVicnVhcnkgMjcsIDIwMTk8L2E+PC9ibG9ja3F1b3RlPjxzY3JpcHQgYXN5bmMgc3JjPVwiaHR0cHM6Ly9wbGF0Zm9ybS50d2l0dGVyLmNvbS93aWRnZXRzLmpzXCIgY2hhcnNldD1cInV0Zi04XCI+PC9zY3JpcHQ+IiwiJV9vZW1iZWRfdGltZV9mNWM1NDBlYjEwZWY4YmI0MGZjMmFmOTIyOWJlNWZmZiUiOiIxNTUyNTc3ODY0IiwiJV9vZW1iZWRfZWQzMGZjMTYyZDZjMTY4Nzc2Njg2MzZlMGVhMWY2MGIlIjoiPGJsb2NrcXVvdGUgY2xhc3M9XCJ0d2l0dGVyLXR3ZWV0XCIgZGF0YS13aWR0aD1cIjQ4MlwiIGRhdGEtZG50PVwidHJ1ZVwiPjxwIGxhbmc9XCJmclwiIGRpcj1cImx0clwiPkVuIG1vZGUgaGFwcHksIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2hhc2h0YWcvTGVNYXM/c3JjPWhhc2gmYW1wO3JlZl9zcmM9dHdzcmMlNUV0ZndcIj4jTGVNYXM8L2E+IDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL05pY2VfTWF0aW4/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkBOaWNlX01hdGluPC9hPiBlc3Qgblx1MDBlOS4gTGUgYlx1MDBlOWJcdTAwZTkgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vaGFzaHRhZy9Jbm5vdmF0aW9uP3NyYz1oYXNoJmFtcDtyZWZfc3JjPXR3c3JjJTVFdGZ3XCI+I0lubm92YXRpb248L2E+IHNlIHBvcnRlIGJpZW4uIE5vcyA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9oYXNodGFnL1N0YXJ0dXA/c3JjPWhhc2gmYW1wO3JlZl9zcmM9dHdzcmMlNUV0ZndcIj4jU3RhcnR1cDwvYT4gYXJlIGluIGRhIHBsYWNlLiBCaWVudmVudSBcdTAwZTAgIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2JvbmpvdXJfZGlic3Rlcj9yZWZfc3JjPXR3c3JjJTVFdGZ3XCI+QGJvbmpvdXJfZGlic3RlcjwvYT4gLCA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9CZWVTaGFyeT9yZWZfc3JjPXR3c3JjJTVFdGZ3XCI+QEJlZVNoYXJ5PC9hPiwgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vVGltZU5qb3k/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkBUaW1lTmpveTwvYT4sIFlvbWEgRmFtaWx5LCA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9yZWFkeV9wYXJrP3JlZl9zcmM9dHdzcmMlNUV0ZndcIj5AcmVhZHlfcGFyazwvYT4sIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2Rlc2VydmVfaGVyP3JlZl9zcmM9dHdzcmMlNUV0ZndcIj5AZGVzZXJ2ZV9oZXI8L2E+IDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL3N3aXRjaG9ucGFwZXI/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkBzd2l0Y2hvbnBhcGVyPC9hPiBldCBSYWRpbyBOaXp6YSAhIDxhIGhyZWY9XCJodHRwczovL3QuY28vQ3U4QlJDeVIzc1wiPnBpYy50d2l0dGVyLmNvbS9DdThCUkN5UjNzPC9hPjwvcD4mbWRhc2g7IE1hcmpvcmllIEx1YnJhbm8tUm91YmF1ZCAoQE1hcmpMdWJyYW5vKSA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9NYXJqTHVicmFuby9zdGF0dXMvMTEwMDY2ODY3MzM1MjU4MTEyMT9yZWZfc3JjPXR3c3JjJTVFdGZ3XCI+RmVicnVhcnkgMjcsIDIwMTk8L2E+PC9ibG9ja3F1b3RlPjxzY3JpcHQgYXN5bmMgc3JjPVwiaHR0cHM6Ly9wbGF0Zm9ybS50d2l0dGVyLmNvbS93aWRnZXRzLmpzXCIgY2hhcnNldD1cInV0Zi04XCI+PC9zY3JpcHQ+IiwiJV9vZW1iZWRfdGltZV9lZDMwZmMxNjJkNmMxNjg3NzY2ODYzNmUwZWExZjYwYiUiOiIxNTUyNTc4MDczIiwiJV9vZW1iZWRfODA2OWI1YmFmOGY5NTU4OTQ4NTJjMTMxOTlmNWU0YWYlIjoiPGlmcmFtZSB3aWR0aD1cIjQ4MlwiIGhlaWdodD1cIjI3MVwiIHNyYz1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkLzVRMTJINUFfdmZ3P2ZlYXR1cmU9b2VtYmVkJmFtcDt3bW9kZT1vcGFxdWUmYW1wO3Nob3dpbmZvPTBcIiBzdHlsZT1cImJvcmRlcjogbm9uZVwiIGFsbG93PVwiYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGVuY3J5cHRlZC1tZWRpYTsgZ3lyb3Njb3BlOyBwaWN0dXJlLWluLXBpY3R1cmVcIiBhbGxvd2Z1bGxzY3JlZW4+PC9pZnJhbWU+IiwiJV9vZW1iZWRfdGltZV84MDY5YjViYWY4Zjk1NTg5NDg1MmMxMzE5OWY1ZTRhZiUiOiIxNTUyNTc4MDczIiwiJV9vZW1iZWRfNjIxMzdmOTgxOTExZDY3YWY4MGMzZDQ2YmU4YmZlMDIlIjoiPGJsb2NrcXVvdGUgY2xhc3M9XCJ0d2l0dGVyLXR3ZWV0XCIgZGF0YS13aWR0aD1cIjQ4OVwiIGRhdGEtZG50PVwidHJ1ZVwiPjxwIGxhbmc9XCJmclwiIGRpcj1cImx0clwiPkVuIG1vZGUgaGFwcHksIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2hhc2h0YWcvTGVNYXM/c3JjPWhhc2gmYW1wO3JlZl9zcmM9dHdzcmMlNUV0ZndcIj4jTGVNYXM8L2E+IDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL05pY2VfTWF0aW4/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkBOaWNlX01hdGluPC9hPiBlc3Qgblx1MDBlOS4gTGUgYlx1MDBlOWJcdTAwZTkgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vaGFzaHRhZy9Jbm5vdmF0aW9uP3NyYz1oYXNoJmFtcDtyZWZfc3JjPXR3c3JjJTVFdGZ3XCI+I0lubm92YXRpb248L2E+IHNlIHBvcnRlIGJpZW4uIE5vcyA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9oYXNodGFnL1N0YXJ0dXA/c3JjPWhhc2gmYW1wO3JlZl9zcmM9dHdzcmMlNUV0ZndcIj4jU3RhcnR1cDwvYT4gYXJlIGluIGRhIHBsYWNlLiBCaWVudmVudSBcdTAwZTAgIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2JvbmpvdXJfZGlic3Rlcj9yZWZfc3JjPXR3c3JjJTVFdGZ3XCI+QGJvbmpvdXJfZGlic3RlcjwvYT4gLCA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9CZWVTaGFyeT9yZWZfc3JjPXR3c3JjJTVFdGZ3XCI+QEJlZVNoYXJ5PC9hPiwgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vVGltZU5qb3k/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkBUaW1lTmpveTwvYT4sIFlvbWEgRmFtaWx5LCA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9yZWFkeV9wYXJrP3JlZl9zcmM9dHdzcmMlNUV0ZndcIj5AcmVhZHlfcGFyazwvYT4sIDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2Rlc2VydmVfaGVyP3JlZl9zcmM9dHdzcmMlNUV0ZndcIj5AZGVzZXJ2ZV9oZXI8L2E+IDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL3N3aXRjaG9ucGFwZXI/cmVmX3NyYz10d3NyYyU1RXRmd1wiPkBzd2l0Y2hvbnBhcGVyPC9hPiBldCBSYWRpbyBOaXp6YSAhIDxhIGhyZWY9XCJodHRwczovL3QuY28vQ3U4QlJDeVIzc1wiPnBpYy50d2l0dGVyLmNvbS9DdThCUkN5UjNzPC9hPjwvcD4mbWRhc2g7IE1hcmpvcmllIEx1YnJhbm8tUm91YmF1ZCAoQE1hcmpMdWJyYW5vKSA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9NYXJqTHVicmFuby9zdGF0dXMvMTEwMDY2ODY3MzM1MjU4MTEyMT9yZWZfc3JjPXR3c3JjJTVFdGZ3XCI+RmVicnVhcnkgMjcsIDIwMTk8L2E+PC9ibG9ja3F1b3RlPjxzY3JpcHQgYXN5bmMgc3JjPVwiaHR0cHM6Ly9wbGF0Zm9ybS50d2l0dGVyLmNvbS93aWRnZXRzLmpzXCIgY2hhcnNldD1cInV0Zi04XCI+PC9zY3JpcHQ+IiwiJV9vZW1iZWRfdGltZV82MjEzN2Y5ODE5MTFkNjdhZjgwYzNkNDZiZThiZmUwMiUiOiIxNTUyNjQ5OTkzIiwiJV9vZW1iZWRfYmUxZjJiMjc0ODA1OWU1ZDgyMWFhN2FjOTk5OTdiN2YlIjoiPGlmcmFtZSB3aWR0aD1cIjQ4OVwiIGhlaWdodD1cIjI3NVwiIHNyYz1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkLzVRMTJINUFfdmZ3P2ZlYXR1cmU9b2VtYmVkJmFtcDt3bW9kZT1vcGFxdWUmYW1wO3Nob3dpbmZvPTBcIiBzdHlsZT1cImJvcmRlcjogbm9uZVwiIGFsbG93PVwiYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGVuY3J5cHRlZC1tZWRpYTsgZ3lyb3Njb3BlOyBwaWN0dXJlLWluLXBpY3R1cmVcIiBhbGxvd2Z1bGxzY3JlZW4+PC9pZnJhbWU+IiwiJV9vZW1iZWRfdGltZV9iZTFmMmIyNzQ4MDU5ZTVkODIxYWE3YWM5OTk5N2I3ZiUiOiIxNTUyNjQ5OTkzIiwiJXNiZ19zZWxlY3RlZF9zaWRlYmFyJSI6IjAiLCIlc2JnX3NlbGVjdGVkX3NpZGViYXJfcmVwbGFjZW1lbnQlIjoiMCIsIiVfb2VtYmVkX2YyYjgzYjM1MDllOGYwOGM0ZGNhYWE3OTZmNDRlMGQ4JSI6IjxpZnJhbWUgdGl0bGU9XCJLaWRzLU1hdGluLCBjb21tZW50IFx1MDBlN2EgbWFyY2hlID9cIiB3aWR0aD1cIjUwMFwiIGhlaWdodD1cIjI4MVwiIHNyYz1cImh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL2VtYmVkLzVRMTJINUFfdmZ3P2ZlYXR1cmU9b2VtYmVkJmFtcDt3bW9kZT1vcGFxdWUmYW1wO3Nob3dpbmZvPTBcIiBzdHlsZT1cImJvcmRlcjogbm9uZVwiIGFsbG93PVwiYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGNsaXBib2FyZC13cml0ZTsgZW5jcnlwdGVkLW1lZGlhOyBneXJvc2NvcGU7IHBpY3R1cmUtaW4tcGljdHVyZTsgd2ViLXNoYXJlXCIgYWxsb3dmdWxsc2NyZWVuPjwvaWZyYW1lPiIsIiVfb2VtYmVkX3RpbWVfZjJiODNiMzUwOWU4ZjA4YzRkY2FhYTc5NmY0NGUwZDglIjoiMTcwNzQxOTM0NCIsInRheG9ub215PWNhdGVnb3J5IjoiTWVkaWEgbGFicyIsInRheG9ub215PXBvc3RfdGFnIjoiYnVzaW5lc3MgbW9kZWxzLCBjdWx0dXJlIG9mIGlubm92YXRpb24sIGluY3ViYXRvciwgc3RhcnR1cHMsIHRyYWluaW5nIGFuZCBlZHVjYXRpb24ifSwiaWNvbiI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE4LzAyL21hcmtlci0xLnBuZyJ9LCJpZCI6MTUwNjAsImluZm93aW5kb3dfZGlzYWJsZSI6ZmFsc2V9LHsic291cmNlIjoicG9zdCIsInRpdGxlIjoiVGhlIEFubmVuYmVyZyBJbm5vdmF0aW9uIExhYjogJiM4MjE2O1RoaW5rIGFuZCBEbyBUYW5rJiM4MjE3OyBhdCB0aGUgVW5pdmVyc2l0eSBvZiBTb3V0aGVybiBDYWxpZm9ybmlhIChVU0MpIiwiaW5mb3dpbmRvd19jb250ZW50IjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZ1wiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJUaGUgQW5uZW5iZXJnIElubm92YXRpb24gTGFiOiAmIzgyMTY7VGhpbmsgYW5kIERvIFRhbmsmIzgyMTc7IGF0IHRoZSBVbml2ZXJzaXR5IG9mIFNvdXRoZXJuIENhbGlmb3JuaWEgKFVTQylcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjE1MFwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE4LzA5L0FubkxhYl8zNjAtMzAweDE1MC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1wYWRkaW5nLWNvbnRlbnRfMjBcIj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1tZXRhIGZjLWl0ZW0tc2Vjb25kYXJ5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2UgZmMtdGV4dC1jZW50ZXJcIj5Jbm5vdmF0aW9uIENhc2UsIE1lZGlhIGxhYnM8L2Rpdj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS10aXRsZSBmYy1pdGVtLXByaW1hcnktdGV4dC1jb2xvciBmYy10ZXh0LWNlbnRlclwiPlRoZSBBbm5lbmJlcmcgSW5ub3ZhdGlvbiBMYWI6ICYjODIxNjtUaGluayBhbmQgRG8gVGFuayYjODIxNzsgYXQgdGhlIFVuaXZlcnNpdHkgb2YgU291dGhlcm4gQ2FsaWZvcm5pYSAoVVNDKTwvZGl2PlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2VcIj5cclxuICAgICAgICAgICAgSGVhZGVkIHVwIGJ5IENvbGluIE1hY2xheSwgdGhleSBjb21iaW5lIG5pbWJsZW5lc3MgYW5kIG5ldHdvcmsgdG8gYmUgaW5ub3ZhdGl2ZSBib3RoIGluIHRoZWlyIGxvY2FsIGNvbW11bml0eSBhbmQgb24gYSBuYXRpb25hbCBzY2FsZS5cclxuICAgICAgICA8L2Rpdj5cclxuPGEgaHJlZj1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi90aGUtYW5uZW5iZXJnLWlubm92YXRpb24tbGFiL1wiPlJlYWQgbW9yZTwvYT5cclxuICAgIDwvZGl2PlxyXG4gICAgPC9kaXY+XHJcbjwvZGl2PlxyXG5cclxuIiwiY29udGVudCI6IkhlYWRlZCB1cCBieSBDb2xpbiBNYWNsYXksIHRoZXkgY29tYmluZSBuaW1ibGVuZXNzIGFuZCBuZXR3b3JrIHRvIGJlIGlubm92YXRpdmUgYm90aCBpbiB0aGVpciBsb2NhbCBjb21tdW5pdHkgYW5kIG9uIGEgbmF0aW9uYWwgc2NhbGUuIiwiYWRkcmVzcyI6IlVuaXZlcnNpdHkgb2YgU291dGhlcm4gQ2FsaWZvcm5pYSwgTG9zIEFuZ2VsZXMsIENBLCBVU0EiLCJsb2NhdGlvbiI6eyJsYXQiOiIzNC4wMjIzNTE5IiwibG5nIjoiLTExOC4yODUxMTcwMDAwMDAwMSIsIm9uY2xpY2tfYWN0aW9uIjoibWFya2VyIiwicmVkaXJlY3RfcGVybWFsaW5rIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL3RoZS1hbm5lbmJlcmctaW5ub3ZhdGlvbi1sYWIvIiwiem9vbSI6MiwiZXh0cmFfZmllbGRzIjp7InBvc3RfZXhjZXJwdCI6IkhlYWRlZCB1cCBieSBDb2xpbiBNYWNsYXksIHRoZXkgY29tYmluZSBuaW1ibGVuZXNzIGFuZCBuZXR3b3JrIHRvIGJlIGlubm92YXRpdmUgYm90aCBpbiB0aGVpciBsb2NhbCBjb21tdW5pdHkgYW5kIG9uIGEgbmF0aW9uYWwgc2NhbGUuIiwicG9zdF9jb250ZW50IjoiW3ZjX3Jvd11bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjIvM1wiXVt2Y19jb2x1bW5fdGV4dF1cclxuPGgxPlRoZSBBbm5lbmJlcmcgSW5ub3ZhdGlvbiBMYWI6ICdUaGluayBhbmQgRG8gVGFuaycgYXQgdGhlIFVuaXZlcnNpdHkgb2YgU291dGhlcm4gQ2FsaWZvcm5pYSAoVVNDKTwvaDE+XHJcbjxzdHJvbmc+SGVhZGVkIHVwIGJ5IENvbGluIE1hY2xheSwgdGhleSBjb21iaW5lIG5pbWJsZW5lc3MgYW5kIG5ldHdvcmsgdG8gYmUgaW5ub3ZhdGl2ZSBib3RoIGluIHRoZWlyIGxvY2FsIGNvbW11bml0eSBhbmQgb24gYSBuYXRpb25hbCBzY2FsZS48L3N0cm9uZz5cclxuXHJcbk1hY2xheSBoYXMgYmVlbiBhdCB0aGUgTGFiIGZvciB0d28geWVhcnMsIGhhdmluZyBwcmV2aW91c2x5IHdvcmtlZCBhdCBIYXJ2YXJkIEJ1c2luZXNzIFNjaG9vbC4gVGhlIGZvcm1lciBoZWFkIG9mIHRoZSBsYWIgbWFkZSB0aGUgZGVjaXNpb24gdG8gd2luZCBkb3duIGFueSBwcm9qZWN0cyB0aGV5IGhhZCBydW5uaW5nIHByaW9yIHRvIE1hY2xheVx1MjAxOXMgc3RhcnQgaW4gdGhlIHJvbGUuIFRoaXMgbWVhbnQgaGUgaGFkIGEgZnJlc2ggc2xhdGUgYW5kIGEgY2hhbmNlIHRvIGFzc2VzcyB0aGVpciBwcmFjdGljZXM6XHJcbjxibG9ja3F1b3RlPlx1MjAxY0kgdGhpbmsgd2UgbmVlZGVkIGEgcmVmbGVjdGlvbiBwZXJpb2QuIEFzIHdpdGggYW55IG9yZ2FuaXNhdGlvbiwgYnV0IGVzcGVjaWFsbHkgd2l0aCBhIHNvLWNhbGxlZCBpbm5vdmF0aW9uIGxhYiwgd2UgbmVlZCB0byBiZSByZWZsZWN0aW5nIG9uIG91ciBwcmFjdGljZSBhbmQgd2hhdCB3ZSBmb2N1cyBvbiB3aXRoIHJlZ3VsYXJpdHksXCJcdTAwYTBNYWNsYXkgc2F5cy4gXCJUaGUgd29ybGQgaXMgY2hhbmdpbmcgcmFwaWRseSBhbmQgd2UgZG9uXHUyMDE5dCB3YW50IHRvIGJ1aWxkIGFuIGVuZ2luZSB0aGF0IHdvcmtlZCBmb3IgdGhlIGVudmlyb25tZW50IGZpdmUgeWVhcnMgYWdvLiBXZSB3YW50IHRvIGNvbnRpbnVlIHRvIGNoYWxsZW5nZSBvdXJzZWx2ZXMsIHRvIGFkYXB0LCBwaXZvdCBhbmQgZW5zdXJlIHRoYXQgd2VcdTIwMTlyZSBiZWluZyByZXNwb25zaXZlIHRvIHRoZSBjdXJyZW50IG1vbWVudC5cdTIwMWQ8L2Jsb2NrcXVvdGU+XHJcbk1hY2xheSBmZWx0IGhlIG5lZWRlZCB0byB1bmRlcnN0YW5kIGEgYml0IG1vcmUgYWJvdXQgd2hhdCB3YXMgZ29pbmcgb24gYXJvdW5kIExvcyBBbmdlbGVzIGFuZCBVU0MsIGhhdmluZyBjb21lIGZyb20gdGhlIEVhc3QgQ29hc3QgYW5kIEJvc3RvbjpcclxuPGJsb2NrcXVvdGU+XHUyMDFjSSByZWFsbHkgbmVlZGVkIHRvIGZpZ3VyZSBvdXQgd2hhdCB3YXMgaGFwcGVuaW5nLCB0byBnZXQgYSBzZW5zZSBvZiB3aGF0IHdhcyBvbiBvZmZlciBhbHJlYWR5LCB3aGVyZSB0aGUgZ2FwcyB3ZXJlLiBJdCB3YXMgcmVhbGx5IGFib3V0IGdldHRpbmcgYSBzZW5zZSBvZiB3aGF0IHRoZSByZXNvdXJjZXMgd2VyZSB0aGF0IHdlIGNvdWxkIGFjdGl2YXRlLiBPciB0aGUgcm9sZSB0aGF0IHdlIGNvdWxkIHBsYXkgYXMgYSBzbWFsbCBvcmdhbmlzYXRpb24uXHUyMDFkPC9ibG9ja3F1b3RlPlxyXG5JdCBkb2Vzblx1MjAxOXQganVzdCBlbmQgdGhlcmUgaG93ZXZlci4gTWFjbGF5IHN1Z2dlc3RzIHRoZXJlIG5lZWRlZCB0byBiZSBhIGdyZWF0ZXIgdW5kZXJzdGFuZGluZyBvZiB3aGF0IG90aGVyIHBlb3BsZSB3ZXJlIGRvaW5nLCB3aGF0IHRoZSBpbmR1c3RyeSB3ZXJlIGFscmVhZHkgY3JlYXRpbmcgdGhlbXNlbHZlczpcclxuPGJsb2NrcXVvdGU+XHUyMDFjWW91IGRvblx1MjAxOXQgd2FudCB0byBkdXBsaWNhdGUgd2hhdCBvdGhlciBmb2xrcyBhcmUgYWxyZWFkeSBkb2luZyBvciBjYW4gZG8gYmV0dGVyLiBXZSB3YW50IHRvIGxldmVyYWdlIG91ciBuaW1ibGVuZXNzLiBJdCBzdGFydGVkIHdpdGggdGhhdCBhbmQgdGhlbiBJIHJlYWNoZWQgb3V0IHRvIGNvbGxlYWd1ZXMgYW5kIHRoZSBmdW5kaW5nIHdvcmxkIHRvIHNlZSB3aGF0IGlzc3VlcyB0aGV5IHdlcmUgd29ya2luZyBvbiwgaW50ZXJlc3RlZCBpbiwgaW52ZXN0aW5nIGluIGFuZCBsb29rIGZvciBwbGFjZXMgd2hlcmUgSSBmZWx0IHRoYXQgb3ZlcmxhcHBlZCB3aXRoIG91ciBza2lsbHNldCBhcyBhIGxhYi5cdTIwMWQgTWFjbGF5IGFkZGVkLjwvYmxvY2txdW90ZT5cclxuPGgzPkJ1aWxkaW5nIHlvdXIgbXVzY2xlczwvaDM+XHJcbkFmdGVyIHVuZGVyc3RhbmRpbmcgd2hhdCB0aGUgbWVkaWEgbGFuZHNjYXBlIGxvb2tlZCBsaWtlLCB0aGUgbmF0dXJhbCBwcm9ncmVzc2lvbiB3YXMgdG8gZGVjaWRlIHdoZXJlIHRoZSBsYWIgd2FudHMgdG8gZm9jdXMgaXRzIHRpbWUuIFRoZSBsYWIgaGFzIGEgY29yZSB0ZWFtIG9mIGZvdXIgZGVkaWNhdGVkIHN0YWZmIGFzIHdlbGwgYXMgYSBtaXhlZCBncm91cCBvZiBmYWN1bHR5IGFuZCBzdHVkZW50cyB3aG8gZG8gd29yayBvbiB2YXJpb3VzIHByb2plY3RzLiBPdXRzaWRlIG9mIHRoYXQgdGhlcmUgaXMgYSB3aWRlIGNvbGxhYm9yYXRpdmUgbmV0d29yayB0aGF0IHRoZXkgYXJlIGVuZ2FnZWQgd2l0aCwgYnV0IGl0XHUyMDE5cyBpbXBvcnRhbnQgZm9yIHRoZSB0ZWFtIHRvIGJlIGNvbnN0YW50bHkgaW50ZXJhY3Rpbmcgd2l0aG91dCBvdXRzaWRlIGNvbGxhYm9yYXRvcnMgYXMgdGhleSBhcmUgYSBzbWFsbCBncm91cC5cclxuPGJsb2NrcXVvdGU+XHUyMDFjVGhlIG5ldyBpZGVhcyBhbmQgaW5zaWdodHMgY29tZSBmcm9tIHRoZSBlZGdlcy4gVGhleSBkb25cdTIwMTl0IGNvbWUgZnJvbSB0aGUgcGVvcGxlIHdobyBoYXZlIGJlZW4gd29ya2luZyBvbiB0aGF0IHRoaW5nIGZvcmV2ZXIuIFNvIGNyZWF0aW5nIGZsdWlkLCBkeW5hbWljIGFuZCBuZXR3b3JrZWQgY29tbXVuaXRpZXMgdG8gd29yayBvbiBkaWZmZXJlbnQgY2hhbGxlbmdlcyBhbmQgb3Bwb3J0dW5pdGllcyBpcyBrZXkuXHUyMDFkPC9ibG9ja3F1b3RlPlxyXG5BdCB0aGlzIHBvaW50IHRoZSBsYWIgaGFkIG5vIGFjdGl2ZSBwcm9qZWN0cywgbm8gaW5jb21lIG9yIHJldmVudWUuIFRoaXMgcGxheWVkIGEgcGFydCBpbiB0aGUgY2hvb3Npbmcgb2YgcHJvamVjdHMgYXQgdGhpcyBzdGFnZSBpbiB0aGUgbGlmZSBvZiB0aGUgbGFiLiBUaGV5IG5lZWQgdG8gYmUgc2VsZiBzdXN0YWluaW5nLCBNYWNsYXkgc3VnZ2VzdHM6XHJcbjxibG9ja3F1b3RlPlx1MjAxY1RoZSB1bml2ZXJzaXR5IGRvZXNuXHUyMDE5dCB3YW50IHRvIHBheSBmb3IgdXMsIHRoZXkgd2FudCB1cyB0byBiZSBzZWxmIHN1c3RhaW5pbmcgYW5kIHRoZXkgd2FudCB1cyB0byBjb250cmlidXRlIHRvIHRoZSBpbnRlbGxlY3R1YWwgY29tbXVuaXR5IGFuZCBsaWZlIG9mIHRoZSB1bml2ZXJzaXR5LCB0byBsb29rIGdvb2QgZm9yIHRoZW0uIE91ciBpbmNlbnRpdmVzIGFyZSBhbGlnbmVkLlx1MjAxZDwvYmxvY2txdW90ZT5cclxuU28gaG93IGRvIHRoZXkgYmVjb21lIHNlbGYgc3VzdGFpbmluZyBhbmQgZ2VuZXJhdGUgcmV2ZW51ZSB3aGlsc3QgYWxzbyBjb250cmlidXRpbmcgdG8gdGhlIGludGVsbGVjdHVhbCBjb21tdW5pdHk/XHJcbjxibG9ja3F1b3RlPlx1MjAxY1RoZXJlIHdlcmUgcHJvamVjdHMgdGhhdCBJIGZlbHQgd2VyZSBnYXMgaW4gdGhlIHRhbmsgaW4gdGVybXMgb2YgbW9uZXksIGNoYWxsZW5nZXMsIHRoaW5ncyB0byBjaGV3IG9uIHRvIGdldCB1cyBtb3ZpbmcuIElmIHlvdSB0aGluayBhYm91dCBhIGJvYXQ6IGlmIHlvdVx1MjAxOXJlIG5vdCBtb3ZpbmcgeW91IGNhblx1MjAxOXQgc3RlZXIsIHlvdVx1MjAxOXZlIGdvdCB0byBiZSBtb3ZpbmcgdG8gc3RlZXIuXHUyMDFkXHJcblxyXG5cdTIwMWNJIGlkZW50aWZpZWQgYSBmZXcgcHJvamVjdHMgdGhhdCB3ZXJlIGludGVyZXN0aW5nIGFuZCBtZWFuaW5nZnVsLiBQcm9qZWN0cyB0aGF0IHdvdWxkIGhlbHAgdXMgdG8gcmVidWlsZCBvciBidWlsZCBvdXIgcHJhY3RpY2VzLCBhIGNvbW11bml0eSwgb3VyIHByb2Nlc3NlcyBhbmQgb3VyIHRpZXMgd2l0aGluIHRoZSBjb21tdW5pdHkuIFRob3NlIGluaXRpYWwgcHJvamVjdHMgd2VyZSB0aGluZ3MgdGhhdCB3ZSBjb3VsZCBnZXQgbW9uZXkgZm9yIGFuZCB0aGF0IHdvdWxkIGhlbHAgdXMgdG8gYnVpbGQgb3VyIG11c2NsZXMsIHNvIHRoYXQgYXMgd2UgZ290IGEgYmV0dGVyIHNlbnNlIG9mIHRoZSBwbGFjZSB3aGVyZSB3ZSByZWFsbHkgd2FudGVkIHRvIGdvLCB3ZSBjb3VsZCBpbnZlc3QgYW5kIGVuZ2FnZSBpbiB0aG9zZSBhcmVhcy5cdTIwMWQ8L2Jsb2NrcXVvdGU+XHJcblRocm91Z2ggdGhpcyBhcHByb2FjaCBhbmQgY2FyZWZ1bCBkZXZlbG9wbWVudCwgaW4gdGhlIHBhc3QgdHdvIHllYXJzIE1hY2xheSBoYXMgYnVpbHQgYSBtYXR1cmluZyBwb3J0Zm9saW8gdGhhdCB3aWxsIGFsbG93IGhpcyBsYWIgdG8gZ3JvdywgYm90aCBpbiB0ZXJtcyBvZiByZXB1dGF0aW9uIGFuZCBsZWFybmluZy4gU29tZXRoaW5nIHRoYXQgd2lsbCBhbGxvdyBpdCB0byBcdTIwMThidWlsZCB0aGVpciBtdXNjbGVzXHUyMDE5IGFzIGFuIG9yZ2FuaXNhdGlvbiBhbmQgcGxhbiBmb3Igd2hlcmUgdGhleSB3YW50IHRvIGdvIGluIHRoZSBjb21pbmcgeWVhcnMuXHJcblxyXG5Tb21lIG9mIHRoZSBjdXJyZW50IHByb2plY3RzIGluY2x1ZGUgbW9uaXRvcmluZyBhaXIgcG9sbHV0aW9uIGluIGNpdGllcyBhbmQgbWFwcGluZyBhIGNsZWFuZXN0IHJvdXRlIHRvIHdvcmsgZm9yIGN5Y2xpc3RzLiBUaGlzIGludm9sdmVzIHRoZSB1c2Ugb2YgcG9sbHV0aW9uIG1vbml0b3JzIG9uIHRoZSBjb3JuZXIgb2Ygc2V2ZXJhbCBcdTIwMWNibG9ja3NcdTIwMWQgYWNyb3NzIHRoZSBjaXR5IHRvIG1ha2UgcHJvdmlkZSBoaWdobHkgYWNjdXJhdGUgcmVhZGluZ3MgZm9yIHBlb3BsZS5cclxuPGgzPjIxc3QgQ2VudHVyeSBDZW5zdXM8L2gzPlxyXG5QZXJoYXBzIHRoZSBtb3N0IGdyb3VuZGJyZWFraW5nIHByb2plY3QgdGhlIEFubmVuYmVyZyBJbm5vdmF0aW9uIExhYiBhcmUgd29ya2luZyBvbiBpcyB0aGUgZGlnaXRpc2F0aW9uIG9mIHRoZSBBbWVyaWNhbiBjZW5zdXMuIFRoZSBjZW5zdXMgYWltcyB0byBjb3VudCBldmVyeSBwZXJzb24gaW4gdGhlIFVTIGJyb2tlbiBkb3duIGJ5IHN0YXRlLCBjb3VudHkgYW5kIGNpdHksIHdpdGggdGhlIG5leHQgZGVjZW5uaWFsIGNlbnN1cyBkdWUgaW4gMjAyMC4gU2luY2UgdGhlIGxhc3QgVVMgY2Vuc3VzIGluIDIwMTAsIHRoZXJlIGhhcyBiZWVuIHNpZ25pZmljYW50IGFkdmFuY2VtZW50cyBpbiB0aGUgdGVjaG5vbG9neSBpbmR1c3RyeSwgbWFraW5nIHNvbWV0aGluZyBsaWtlIGEgZGlnaXRhbCB2ZXJzaW9uIHBvc3NpYmxlLiBNYWNsYXkgc2F5cyB0aGF0IENhbGlmb3JuaWEgc3RhdGUgaXMgbm90IG9ubHkgdGhlIGhhcmRlc3QgdG8gY291bnQgc3RhdGUsIGJ1dCBMb3MgQW5nZWxlcyBjb3VudHkgaXMgdGhlIGhhcmRlc3QgdG8gY291bnQgY291bnR5IGZvciB0aGUgY2Vuc3VzIGFzIHdlbGwuXHJcbjxibG9ja3F1b3RlPlx1MjAxY0l0IGhhcyBib3RoIGEgbG9jYWwgYW5kIGEgbmF0aW9uYWwgZWxlbWVudC4gSXQgY29ubmVjdHMgdG8gb3VyIGludGVyZXN0IGluIGNpdHkgYW5kIGNvbW11bml0eSwgYW5kIGl0IGlzIGFsc28gYXQgdGhlIGludGVyc2VjdGlvbiBvZiBtZWRpYSB0ZWNoIGFuZCBjdWx0dXJlLCB3aGljaCBpcyBpbXBvcnRhbnQgdG8gdXMuIFRoZSBjZW5zdXMgZGlyZWN0cyB0aGUgb3JkZXIgb2YgNyBvciA4MDAgYmlsbGlvbiBkb2xsYXJzIG9mIFVTIGZlZGVyYWwgc3BlbmRpbmcgbWFudWFsbHkgYXMgd2VsbCBhcyBkZXRlcm1pbmluZyBjb25ncmVzc2lvbmFsIGFwcG9ydGlvbm1lbnRzIGFuZCByZXByZXNlbnRhdGlvbiBmb3IgdGhlIHN0YXRlIGluIGNvbmdyZXNzLlx1MjAxZFxyXG5cclxuXHUyMDFjSXRcdTIwMTlzIGludGVyZXN0aW5nIGZyb20gYSByZXNlYXJjaCBwZXJzcGVjdGl2ZS4gV2VcdTIwMTl2ZSBnb3Qgc3R1ZGVudHMgaW52b2x2ZWQgYW5kIGl0XHUyMDE5cyBhIHBsYWNlIHdoZXJlIG90aGVyIG9yZ2FuaXNhdGlvbnMsIGZvciBwcm9maXQgb3Igbm90LCBhbHNvIGhhdmUgYSBzdGFrZS4gVGhlIHNjYWxlIGlzIGp1c3QgaW5zYW5lISBTb21lIDIwMCwwMDAgb3JnYW5pc2F0aW9ucyB3b3JrIG9uIHRoZSBjZW5zdXMsIHJhbmdpbmcgZnJvbSBjb21wYW5pZXMgdG8gcGhpbGFudGhyb3B5IHRvIHRoZSBidXJlYXUgdG8gc3RhdGUgbGV2ZWwgZ292ZXJubWVudC5cdTIwMWQ8L2Jsb2NrcXVvdGU+XHJcbk1hY2xheSBiZWxpZXZlcyBzdWNjZXNzIGZvciB0aGlzIHByb2plY3QgaXMgYWJvdXQgZmluZGluZyB0aGUgcmlnaHQgc2tpbGxzIGJhbGFuY2UuIFNvbWUgcGVvcGxlIGludm9sdmVkIGluIHRoZSBwcm9kdWN0aW9uIG9mIHRoZSBjZW5zdXMgYXJlIHNraWxsZWQgaW4gY2VydGFpbiB0aGluZ3MsIHNvIGl0XHUyMDE5cyBpbXBvcnRhbnQgdG8gdXRpbGlzZSBzcGVjaWFsaXN0cyBpbiB0aGVpciBvd24gYXJlYXMgdG8gZGV2ZWxvcCB0aGUgYmVzdCByZXN1bHQuXHJcblxyXG5UaGlzIHByb2plY3Qgd2lsbCByZWFsbHkgY29tZSBpbnRvIGl0cyBvd24gYmVmb3JlIHRoZSAyMDIwIGNlbnN1cyBhbmQgaXMgYW5vdGhlciBleGFtcGxlIG9mIGhvdyBNYWNsYXkgaGFzIGN1cmF0ZWQgaGlzIHBvcnRmb2xpbyBvZiBwcm9qZWN0cyB0byBlbmNvbXBhc3MgdGhlIGxvY2FsIGNvbW11bml0eSBhbmQgaGF2ZSBpbXBhY3Qgb24gcG90ZW50aWFsbHkgYSBuYXRpb25hbCBzY2FsZS5cclxuXHJcbkNPTlRBQ1QgUE9JTlRcclxuPGltZyBjbGFzcz1cImFsaWdubm9uZSB3cC1pbWFnZS0xMTc4NyBzaXplLWZ1bGxcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxOC8wOS9jb2xpbi1tYWNsYXktZTE1MzY4NDc0MzYxMzAuanBnXCIgYWx0PVwiXCIgd2lkdGg9XCIyMDBcIiBoZWlnaHQ9XCIyNTBcIiAvPlxyXG5Db2xpbiBNYWNsYXksIEV4ZWN1dGl2ZSBEaXJlY3RvciwgQW5uZW5iZXJnIExhYlxyXG5XZWI6IDxhIGhyZWY9XCJodHRwOi8vd3d3LmFubmVuYmVyZ2xhYi5jb21cIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPnd3dy5hbm5lbmJlcmdsYWIuY29tPC9hPlxyXG5Ud2l0dGVyOiA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9jbWFjXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5AY21hYzwvYT5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMi8zXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48aDM+QXV0aG9yPC9oMz5cclxuW3NpbXBsZS1hdXRob3ItYm94XVsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XSIsInBvc3RfdGl0bGUiOiJUaGUgQW5uZW5iZXJnIElubm92YXRpb24gTGFiOiAmIzgyMTY7VGhpbmsgYW5kIERvIFRhbmsmIzgyMTc7IGF0IHRoZSBVbml2ZXJzaXR5IG9mIFNvdXRoZXJuIENhbGlmb3JuaWEgKFVTQykiLCJwb3N0X2xpbmsiOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvdGhlLWFubmVuYmVyZy1pbm5vdmF0aW9uLWxhYi8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJUaGUgQW5uZW5iZXJnIElubm92YXRpb24gTGFiOiAmIzgyMTY7VGhpbmsgYW5kIERvIFRhbmsmIzgyMTc7IGF0IHRoZSBVbml2ZXJzaXR5IG9mIFNvdXRoZXJuIENhbGlmb3JuaWEgKFVTQylcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjE1MFwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE4LzA5L0FubkxhYl8zNjAtMzAweDE1MC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj4iLCJwb3N0X2NhdGVnb3JpZXMiOiJJbm5vdmF0aW9uIENhc2UsIE1lZGlhIGxhYnMiLCJwb3N0X3RhZ3MiOiJhY2FkZW1pYyBMYWIsIHVyYmFuIGlubm92YXRpb24sIFVTQSIsIiVfdmNfcG9zdF9zZXR0aW5ncyUiOnsidmNfZ3JpZF9pZCI6W119LCIlX2VkaXRfbG9jayUiOiIxNTYyMjI5MTMxOjkzMSIsIiVfZWRpdF9sYXN0JSI6IjEwMSIsIiVfdGh1bWJuYWlsX2lkJSI6IjExNzg1IiwiJXNsaWRlX3RlbXBsYXRlJSI6ImRlZmF1bHQiLCIlX3dwYl92Y19qc19zdGF0dXMlIjoidHJ1ZSIsIiVfd3BnbXBfbG9jYXRpb25fYWRkcmVzcyUiOiJVbml2ZXJzaXR5IG9mIFNvdXRoZXJuIENhbGlmb3JuaWEsIExvcyBBbmdlbGVzLCBDQSwgVVNBIiwiJV93cGdtcF9tZXRhYm94X2xhdGl0dWRlJSI6IjM0LjAyMjM1MTkiLCIlX3dwZ21wX21ldGFib3hfbG9uZ2l0dWRlJSI6Ii0xMTguMjg1MTE3MDAwMDAwMDEiLCIlX3dwZ21wX21ldGFib3hfbG9jYXRpb25fcmVkaXJlY3QlIjoibWFya2VyIiwiJV93cGdtcF9tZXRhYm94X2N1c3RvbV9saW5rJSI6IiIsIiVfd3BnbXBfbWFwX2lkJSI6ImE6MTp7aTowO3M6MTpcIjJcIjt9IiwiJV93cGdtcF9tZXRhYm94X21hcmtlcl9pZCUiOiJOOyIsIiVfd3BnbXBfbWV0YWJveF90YXhvbW9taWVzX3Rlcm1zJSI6Ik47IiwiJV93cGdtcF9leHRlbnNpb25zX2ZpZWxkcyUiOiJOOyIsIiVfa2xlb190cmFuc3BhcmVudF9tZW51X2NvbG9yJSI6IndoaXRlIiwiJV9rbGVvX3RpdGxlX2NoZWNrYm94JSI6IjEiLCIlX2tsZW9fdGl0bGVfY29sb3IlIjoiIyIsIiVfa2xlb190aXRsZV9iZyUiOiIsIHJlcGVhdCwgaW5oZXJpdCwgc2Nyb2xsLCBsZWZ0IHRvcCIsIiVfa2xlb190aXRsZV9iZ19jb2xvciUiOiIjIiwiJV95b2FzdF93cHNlb19jb250ZW50X3Njb3JlJSI6IjMwIiwiJV95b2FzdF93cHNlb19wcmltYXJ5X2NhdGVnb3J5JSI6IjY5IiwiJXNiZ19zZWxlY3RlZF9zaWRlYmFyJSI6IjAiLCIlc2JnX3NlbGVjdGVkX3NpZGViYXJfcmVwbGFjZW1lbnQlIjoiMCIsIiVfamV0cGFja19yZWxhdGVkX3Bvc3RzX2NhY2hlJSI6eyI2MjM5M2IyNDJjN2E1NjE3NzRmOGViZmY1YzFjMDU2NSI6eyJleHBpcmVzIjoxNTQ1NTI2Mzg4LCJwYXlsb2FkIjpbeyJpZCI6MTA5NDJ9LHsiaWQiOjEwNjgxfSx7ImlkIjoxMTc2NX1dfX0sInRheG9ub215PWNhdGVnb3J5IjoiSW5ub3ZhdGlvbiBDYXNlLCBNZWRpYSBsYWJzIiwidGF4b25vbXk9cG9zdF90YWciOiJhY2FkZW1pYyBMYWIsIHVyYmFuIGlubm92YXRpb24sIFVTQSJ9LCJpY29uIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTgvMDIvbWFya2VyLTEucG5nIn0sImlkIjoxMTc4NCwiaW5mb3dpbmRvd19kaXNhYmxlIjpmYWxzZX0seyJzb3VyY2UiOiJwb3N0IiwidGl0bGUiOiJNb25kYXkgSW5ub3ZhdGlvbiBMYWI6IElubm92YXRpbmcgc3RlcC1ieS1zdGVwLCB3aGlsZSBhaW1pbmcgZm9yIFV0b3BpYSIsImluZm93aW5kb3dfY29udGVudCI6IjxkaXYgY2xhc3M9XCJmYy1pdGVtLWJveCBmYy1pdGVtLW5vLXBhZGRpbmdcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiTW9uZGF5IElubm92YXRpb24gTGFiOiBJbm5vdmF0aW5nIHN0ZXAtYnktc3RlcCwgd2hpbGUgYWltaW5nIGZvciBVdG9waWFcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjE1N1wiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE4LzA5LzM2MDY0ODE4XzIwNTk5MDEyMzQyNzAyNTZfNDU2NDMwNTE5NzY0MzMzMzYzMl9vLTMwMHgxNTcuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZ1wiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tcGFkZGluZy1jb250ZW50XzIwXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tbWV0YSBmYy1pdGVtLXNlY29uZGFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlIGZjLXRleHQtY2VudGVyXCI+SW5ub3ZhdGlvbiBDYXNlLCBNZWRpYSBsYWJzPC9kaXY+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tdGl0bGUgZmMtaXRlbS1wcmltYXJ5LXRleHQtY29sb3IgZmMtdGV4dC1jZW50ZXJcIj5Nb25kYXkgSW5ub3ZhdGlvbiBMYWI6IElubm92YXRpbmcgc3RlcC1ieS1zdGVwLCB3aGlsZSBhaW1pbmcgZm9yIFV0b3BpYTwvZGl2PlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2VcIj5cclxuICAgICAgICAgICAgV2hlbiB5b3UgdGhpbmsgb2YgaW5ub3ZhdGlvbiBsYWJzLCB5b3UgcHJvYmFibHkgaW1hZ2luZSBhIHJvb20gb2YgcGVvcGxlIGZpZ3VyaW5nIG91dCB0aGUgbmV4dCBncm91bmRicmVha2luZyBhcHAgb3IgdG9vbC4gTW9uZGF5IElubm92YXRpb24gTGFiIGlzIHRha2luZyBpbm5vdmF0aW9uIGNpdHl3aWRlLlxyXG4gICAgICAgIDwvZGl2PlxyXG48YSBocmVmPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL21vbmRheS1pbm5vdmF0aW9uLWxhYi9cIj5SZWFkIG1vcmU8L2E+XHJcbiAgICA8L2Rpdj5cclxuICAgIDwvZGl2PlxyXG48L2Rpdj5cclxuXHJcbiIsImNvbnRlbnQiOiJXaGVuIHlvdSB0aGluayBvZiBpbm5vdmF0aW9uIGxhYnMsIHlvdSBwcm9iYWJseSBpbWFnaW5lIGEgcm9vbSBvZiBwZW9wbGUgZmlndXJpbmcgb3V0IHRoZSBuZXh0IGdyb3VuZGJyZWFraW5nIGFwcCBvciB0b29sLiBNb25kYXkgSW5ub3ZhdGlvbiBMYWIgaXMgdGFraW5nIGlubm92YXRpb24gY2l0eXdpZGUuIiwiYWRkcmVzcyI6IkJhcmNlbG9uYSwgU3BhaW4iLCJsb2NhdGlvbiI6eyJsYXQiOiI0MS4zODUwNjM4OTk5OTk5OSIsImxuZyI6IjIuMTczNDAzNDk5OTk5OTQ5NCIsIm9uY2xpY2tfYWN0aW9uIjoibWFya2VyIiwicmVkaXJlY3RfcGVybWFsaW5rIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL21vbmRheS1pbm5vdmF0aW9uLWxhYi8iLCJ6b29tIjoyLCJleHRyYV9maWVsZHMiOnsicG9zdF9leGNlcnB0IjoiV2hlbiB5b3UgdGhpbmsgb2YgaW5ub3ZhdGlvbiBsYWJzLCB5b3UgcHJvYmFibHkgaW1hZ2luZSBhIHJvb20gb2YgcGVvcGxlIGZpZ3VyaW5nIG91dCB0aGUgbmV4dCBncm91bmRicmVha2luZyBhcHAgb3IgdG9vbC4gTW9uZGF5IElubm92YXRpb24gTGFiIGlzIHRha2luZyBpbm5vdmF0aW9uIGNpdHl3aWRlLiIsInBvc3RfY29udGVudCI6Ilt2Y19yb3ddW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIyLzNcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxoMT5Nb25kYXkgSW5ub3ZhdGlvbiBMYWI6IElubm92YXRpbmcgc3RlcC1ieS1zdGVwLCB3aGlsZSBhaW1pbmcgZm9yIFV0b3BpYTwvaDE+XHJcbjxzdHJvbmc+V2hlbiB5b3UgdGhpbmsgb2YgaW5ub3ZhdGlvbiBsYWJzLCB5b3UgcHJvYmFibHkgaW1hZ2luZSBhIHJvb20gb2YgcGVvcGxlIGZpZ3VyaW5nIG91dCB0aGUgbmV4dCBncm91bmRicmVha2luZyBhcHAgb3IgdG9vbC4gTW9uZGF5IElubm92YXRpb24gTGFiIGlzIHRha2luZyBpbm5vdmF0aW9uIGNpdHl3aWRlLjwvc3Ryb25nPlxyXG5cclxuU2l0dWF0ZWQgaW4gQmFyY2Vsb25hLCB0aGUgTW9uZGF5IElubm92YXRpb24gTGFiIGhlbHBzIGNpdGllcyBpbiBDYXRhbG9uaWEsIHNtYWxsIG9yIGxhcmdlLCB0byBpbm5vdmF0ZSBhbmQgYWRhcHQgdG8gbmV3IGNoYWxsZW5nZXMuIEhhdmluZyBvbmx5IGJlZW4gYWN0aXZlIGZvciAxOCBtb250aHMsIHRoZSBMYWIgaXMgc3RpbGwgaW4gaXRzIGluZmFuY3ksIGJ1dCBpdCBhaW1zIHRvIGFkZHJlc3MgZm91ciBrZXkgdXJiYW4gaXNzdWVzIC0geW91dGggdW5lbXBsb3ltZW50LCB0aGUgZWxkZXJseSwgdGhlIGRpZ2l0YWwgZ2VuZGVyIGdhcCwgYW5kIGN1c3RvbSBwcm9qZWN0cyAtIGluIG5vdmVsIHdheXM6IFx1MjAxY0ZvciBtZSBpbm5vdmF0aW5nIGlzIGRvaW5nIHNvbWV0aGluZyBkaWZmZXJlbnQsXCIgc2F5cyBQYXRyaWNpYSBHb256YWxleiBHYXJjaWEsIGZvdW5kZXIgb2YgTW9uZGF5IElubm92YXRpb24gTGFiLiBcIldpdGggdGhlIGFpbSB0byBhY2hpZXZlIGRpZmZlcmVudCByZXN1bHRzLlx1MjAxZFxyXG5cclxuVGhpcyBiZWxpZWYgaXMgYXBwbGllZCB0byByaWdpZCBhbmQgc29tZXRpbWVzIGRpZmZpY3VsdCB0byBtYW5ldXZlciBsb2NhbCBnb3Zlcm5tZW50cy4gVGhlIHN0cnVjdHVyZSBvZiBCYXJjZWxvbmFcdTIwMTlzIENpdHkgSGFsbCBpcyBub3QgZm9yZWlnbiB0byBHb256YWxleiwgaGF2aW5nIHdvcmtlZCBpbnNpZGUgZm9yIGVpZ2h0IHllYXJzIGJlZm9yZSByZWFsaXNpbmcgaW5ub3ZhdGlvbiBhbmQgdGhlIHByb2Nlc3MsIG1ldGhvZG9sb2d5IGFuZCB0ZWNobm9sb2d5IG9mIGlubm92YXRpb24gaXMgbmVlZGVkIGV2ZXJ5d2hlcmUuXHJcblxyXG5Hb256YWxleiB3b3JrcyB3aXRoIGdvdmVybm1lbnRzIHRoYXQgYXJlIGtlZW4gdG8gY2hhbmdlLCBidXQgbWF5IG5vdCBxdWl0ZSBoYXZlIHRoZSByaWdodCB0b29scyBvciBza2lsbCBzZXQuIFRoZXkgbWF5IG5vdCBrbm93IGhvdyB0byBjb25uZWN0IGVmZmVjdGl2ZWx5IHdpdGggY2l0aXplbnMgb3IgaG93IHRvIHV0aWxpc2UgYSBuZXcgdGVjaG5vbG9neS4gVGhhdFx1MjAxOXMgd2hlcmUgc2hlIHN0ZXBzIGluOlxyXG48YmxvY2txdW90ZT5cIk15IG1pc3Npb24gaXMgdG8gaGVscCBsb2NhbCBnb3Zlcm5tZW50cyB0aGF0IHdhbnQgdG8gaW5ub3ZhdGU7IG5vdCBoZWxwIHRoZSBwZW9wbGUgdGhhdCBkb24ndCBrbm93IHRoYXQgdGhleSBoYXZlIHRvIGlubm92YXRlLlx1MjAxZDwvYmxvY2txdW90ZT5cclxuPGgzPkJlc3Bva2UgVGVhbSBCdWlsZGluZzwvaDM+XHJcblRoZSBsYWIgaXRzZWxmIGlzIGp1c3QgR29uemFsZXogLSBzaGUgZGV0ZWN0cyBvcHBvcnR1bml0aWVzLCBzdGFydHMgcHJvamVjdHMgYW5kIGxpYWlzZXMgd2l0aCB0aGUgY2l0eSBoYWxscyB0aGF0IHdhbnQgdG8gaW5ub3ZhdGUuIEhhdmluZyBob25lZCBoZXIgc2tpbGxzIGluIEJhcmNlbG9uYSBiZWZvcmUgdGFraW5nIHRoZW0gYWNyb3NzIHRoZSBBdGxhbnRpYyB0byB0aGUgVVMsIEdvbnphbGV6IGhhcyBidWlsdCB1cCBhIHdpZGUgbmV0d29yayBvZiBjb250cmlidXRvcnMgYW5kIHBvdGVudGlhbCBjb2xsYWJvcmF0b3JzLlxyXG5cclxuQWZ0ZXIgaWRlbnRpZnlpbmcgYSBwb3RlbnRpYWwgcHJvamVjdCB0aGVyZSBjb3VsZCBiZSBhbiBpZGVhdGlvbiBvciBjby1jcmVhdGlvbiBzZXNzaW9uIHRvIHRyeSBhbmQgZGVmaW5lIHRoZSBpc3N1ZSBhbmQgcGxhbiBhIGNvdXJzZSBvZiBhY3Rpb24uIE5leHQsIEdvbnphbGV6IGNyZWF0ZXMgYSB0ZWFtOlxyXG48YmxvY2txdW90ZT5cdTIwMWNJIGRvblx1MjAxOXQgaGF2ZSBhIHBlcm1hbmVudCB0ZWFtIGJlY2F1c2UgdGhpcyB3b3VsZCBtZWFuIEkgYWx3YXlzIGhhdmUgdG8gZ2l2ZSB0aGUgc2FtZSBzb2x1dGlvbiB0byBldmVyeWJvZHkuIEkgY29ubmVjdCB0byBkaWZmZXJlbnQgcGVvcGxlIHdpdGggZGlmZmVyZW50IHNraWxscyBhbmQgY3JlYXRlIHByb2plY3Qtc3BlY2lmaWMgdGVhbXMuIElcdTIwMTltIGxpa2UgYSBodWIhXHUyMDFkPC9ibG9ja3F1b3RlPlxyXG5CdXQgdGhpcyBsYWIgaXNuXHUyMDE5dCBqdXN0IGFib3V0IHF1aWNrIGZpeGVzIGFuZCBzaG9ydC10ZXJtIHNvbHV0aW9uczogXHUyMDFjV2UgY3JlYXRlIGEgdGVhbSB3aXRoIHRoZSBhaW0gdGhhdCB3aGVuIHdlIGZpbmlzaCB0aGUgcHJvamVjdCwgdGhlIHByb2plY3Qgd2lsbCBsYXN0Llx1MjAxZFxyXG48aDM+SW5ub3ZhdGluZyBmcm9tIGEgc2VudGVuY2U8L2gzPlxyXG5PbmUgc3VjaCBwcm9qZWN0IGJ1aWx0IHRvIGxhc3QgaXMgXHUyMDFjSVx1MjAxOW0gQmxvZ2dlclx1MjAxZCAtIGEgY2l0aXplbiBqb3VybmFsaXNtIGluaXRpYXRpdmUgZm9yIHRoZSBlbGRlcmx5IGFuZCByZXRpcmVlcywgYm9ybiBmcm9tIGFuIHVubGlrZWx5IGJlZ2lubmluZzpcclxuPGJsb2NrcXVvdGU+XHUyMDFjVGhlIGRlcHV0eSBtYXlvciBzYWlkIHRvIHRoZSBkaXJlY3RvciBvZiBlbGRlcmx5IHBlb3BsZSBhdCBCYXJjZWxvbmEgQ2l0eSBIYWxsIFx1MjAxOEkgd2FudCB0aGUgZWxkZXJseSB0byB3cml0ZSBvbiB0aGUgZmFjZWJvb2sgcGFnZSBvZiB0aGUgbXVuaWNpcGFsaXR5Llx1MjAxOSBUaGF0XHUyMDE5cyBhbGwsXHUyMDFkIHJlbWVtYmVycyBHb256YWxlei48L2Jsb2NrcXVvdGU+XHJcblNvIGhvdyBkbyB5b3UgaW5ub3ZhdGUgYW5kIGNyZWF0ZSBmcm9tIGp1c3QgMTMgd29yZHM/IEdvbnphbGV6IHVucGlja2VkIHRoaXMgc2luZ2xlIHNlbnRlbmNlIHRvIGRlY2lkZSB3aGF0IGNvdWxkIGJlIGRvbmUuIEFzIHNoZSByZWFsaXNlZCB0aGlzIGNvdWxkIGJlIHNjYWxlZCB1cCBhbmQgdGFrZW4gZnVydGhlciB0aGFuIHNpbXBsZSBpbnRlcmFjdGlvbiBvbiBGYWNlYm9vaywgYSBmZXcgd29yZHMgZnJvbSB0aGUgZGVwdXR5IG1ham9yIHR1cm5lZCBpbnRvIGEgZnVsbC1mbGVkZ2VkIHByb2plY3QgZm9yIGNpdGl6ZW4gam91cm5hbGlzbS5cclxuXHJcbkFmdGVyIGFuIGluaXRpYWwgcGlsb3Qgd2l0aCBuaW5lIHBhcnRpY2lwYW50cywgR29uemFsZXogZGVjaWRlZCB0aGV5IG5lZWRlZCBhIHBoeXNpY2FsIHNwYWNlIHdoZXJlIHRoZSBwYXJ0aWNpcGFudHMgY291bGQgaW50ZXJhY3QgYW5kIGVuZ2FnZSB3aXRoIGVhY2ggb3RoZXI6XHJcbjxibG9ja3F1b3RlPlx1MjAxY1dlIGFyZSBodW1hbiBhbmQgb2YgY291cnNlIHdlIGFyZSB1c2VkIHRvIHdvcmtpbmcgd2l0aCBjb21wdXRlcnMgYW5kIG91ciBtb2JpbGUgcGhvbmVzIGV2ZXJ5IGRheSwgYnV0IHdlIG5lZWQgdGhlIGh1bWFuIHRvdWNoLiBXZSBuZWVkIHRvIGdvIHRvIGEgYmFyIG9yIGEgY2FmZSB0byB0YWxrIHdpdGggcGVvcGxlLiBUaGlzIGlzIHdoZXJlIHlvdSByZWFsbHkgZXhjaGFuZ2UgaWRlYXMuIFBoeXNpY2FsIHNwYWNlcyBhcmUgbmVlZGVkIHNvbWV0aW1lcyBpbiB0aGUgZmlyc3Qgc3RhZ2UuIEEgcGxhY2Ugc29tZXdoZXJlIHRoYXQgaXMgb3BlbiBhbGwgZGF5LCBldmVyeSBkYXkgYW5kIHdoZXJlIHlvdSBjYW4gZ28gYW5kIGFzayBxdWVzdGlvbnMgb3IgYXNrIHNvbWVvbmUgaG93IHRvIGRvIHNvbWV0aGluZy4gVGhpcyBtaW5kc2V0IGlzIHByb21vdGVkIHdoZW4geW91IGhhdmUgYSBzcGVjaWZpYyBzcGFjZSBmb3IgdGhhdC5cdTIwMWQ8L2Jsb2NrcXVvdGU+XHJcblRoZSBwcm9qZWN0IGdyZXcgZnJvbSB0aGUgcGlsb3QgaW50byB3aGF0IGl0IGhhcyBiZWNvbWUgbm93LCBhIGNvbW11bmljYXRpb24gYW5kIHNvY2lhbCBuZXR3b3JrIGZvciB0aGUgZWxkZXJseSBpbiBCYXJjZWxvbmEuIEdvbnphbGV6IHBsYWNlcyBhIHN0cm9uZyBmb2N1cyBvbiBoYXZpbmcgdXNlcnMgaW52b2x2ZWQgYXQgYWxsIHN0YWdlcyBvZiBwcm9kdWN0IGRldmVsb3BtZW50LiBUaGlzIGFsbG93cyB0aGVtIHRvIGdyb3cgYW5kIGRldmVsb3AgaW4gbGluZSB3aXRoIHdoYXQgdGhlIHVzZXJzIHdhbnQgYW5kIG5lZWQgZnJvbSB0aGUgcHJvamVjdDpcclxuPGJsb2NrcXVvdGU+XHUyMDFjVGhleSBhcmUgYWx3YXlzIGdpdmluZyB1cyBmZWVkYmFjayBhbmQgd2UgYXJlIGRvaW5nIHNlc3Npb25zIHRvIHJlZmluZSB0aGUgcHJvdG90eXBlLiBXZSBhcmUgY2hhbmdpbmcgdGhlIHByb2dyYW1tZSBldmVyeSB0aW1lIHRvIGVuZ2FnZSBtb3JlIHBlb3BsZS4gVGhleSBsaWtlIGNyZWF0aW5nIHRoZSBwcm9ncmFtbWUgZm9yIG90aGVyIHBlb3BsZSB3aXRoIHVzIGFuZCB0byBlbmdhZ2Ugb3RoZXIgcGVvcGxlIGFuZCBzbyBvbiBhbmQgc28gb24uIEkgYW0gcmVhbGx5IHByb3VkIG9mIHRoaXMgcHJvamVjdC5cdTIwMWQ8L2Jsb2NrcXVvdGU+XHJcbjxoMz5BaW1pbmcgZm9yIFV0b3BpYTwvaDM+XHJcbldoZW4gaXQgY29tZXMgdG8gcHJvamVjdHMsIEdvbnphbGV6IGJlbGlldmVzIGl0XHUyMDE5cyBpbXBvcnRhbnQgdG8ga2VlcCBhIGJyb2FkZXIgdmlzaW9uIG9mIHdoYXQgeW91XHUyMDE5cmUgY3JlYXRpbmcgYW5kIGJlIGF3YXJlIG9mIGhvdyBpdCBjYW4gcmVhbGx5IGNoYW5nZSB0aGUgbGl2ZXMgb2YgY2l0aXplbnMuIFNoZSBob3BlcyB0byBwdXNoIHRoZSBwcm9qZWN0IGZ1cnRoZXIgYW5kIGNyZWF0ZSBhIHJlYWwgaW1wYWN0IGluIHRoZSBjaXR5OlxyXG48YmxvY2txdW90ZT5cdTIwMWNJIHdhbnQgdG8gc2VlIHRoZSBjb21tdW5pdHkgdGhhdCBoYXZlIGxlYXJuZWQgYWxsIHRoZXNlIHNraWxscywgZXhwZXJpZW5jZWQgdGhpcyBwcm9jZXNzIGFuZCB0aGVuIGJlIHJlYWxseSBwYXNzaW9uYXRlIGZvciB3cml0aW5nIGFib3V0IHRoZWlyIGNpdHkuIFRvIG1vdmUgYmV5b25kIHdoYXQgdGhlIGRlcHV0eSBtYXlvciBhc2tlZC4gSGUgZ2F2ZSB1cyBhIGRpcmVjdGlvbiwgYnV0IHdlIGNhbiBncm93IGEgY2l0aXplbiBtb3ZlbWVudCB0aGF0IGNhbiBnaXZlIHZhbHVlIHRvIHRoZSBjaXR5Llx1MjAxZDwvYmxvY2txdW90ZT5cclxuQW5kIGl0IGRvZXNuXHUyMDE5dCBlbmQgdGhlcmUuIEdvbnphbGV6IGFsd2F5cyBob2xkcyBhIHZpc2lvbiBmb3Igd2hlcmUgdGhlIHByb2plY3Qgc2hvdWxkIGdvOiBcdTIwMWNZb3UgYWx3YXlzIGhhdmUgdG8gaGF2ZSBhIFV0b3BpYSBiZWNhdXNlIHRoYXRcdTIwMTlzIHlvdXIgYWltLCB0aGF0IGlzIHlvdXIgTm9ydGggYW5kIHdoZXJlIHlvdSB3YW50IHRvIGdvLiBCdXQgeW91IGhhdmUgdG8gc3RhcnQgd2l0aCB0aGUgZmlyc3Qgc3RlcC5cdTIwMWRcclxuXHJcbkluIHRoaXMgY2FzZSB0aGUgZmlyc3Qgc3RlcCB3YXMgdGhlIHBpbG90LCBjb21pbmcgZnJvbSAxMyB3b3JkcyBhbmQgaGFzIGJlY29tZSBhIG5ldHdvcmsgb2YgY2l0aXplbiBqb3VybmFsaXN0cywgZW5yaWNoaW5nIGEgY2l0eSBhbmQgcHJvdmlkaW5nIGl0IGEgYmFzZSB1cG9uIHdoaWNoIHRoZSBlbGRlcmx5IGNhbiBjcmVhdGUgY29udGVudC5cclxuXHJcbkdvbnphbGV6IGhvcGVzIHRvIHRha2UgaGVyIHNraWxscyBhbmQgaW5zaWdodHMgdG8gb3RoZXIgY2l0aWVzIGluIHRoZSBmdXR1cmUsIHRoZXJlXHUyMDE5cyBjdXJyZW50bHkgYSBsb3Qgb2YgZ3Jvd3RoIGluIHRoZSBpbmR1c3RyeSB3aXRoaW4gQ2F0YWxvbmlhIGJ1dCB0aGUgYWltIGlzIGEgYml0IGZ1cnRoZXIgYWZpZWxkLiBHb256YWxleiBpcyBsb29raW5nIHRvIGJ1aWxkIGEgY29yZSB0ZWFtIGFyb3VuZCBoZXIsIHdpdGhvdXQgZGlsdXRpbmcgdGhlIHF1YWxpdHkgb2Ygd29yayBvciB0aGUgdmlzaW9uIHNoZSBob2xkcy4gV2hlbiB0aGF0IGJlY29tZXMgYSByZWFsaXR5LCBzaGUgaG9wZXMgcHJvamVjdHMgaW4gYm90aCB0aGUgVVMgYW5kIEV1cm9wZSB3aWxsIGJlY29tZSBtb3JlIGFjY2Vzc2libGUuXHJcblxyXG5DT05UQUNUIFBPSU5UXHJcbjxpbWcgY2xhc3M9XCJhbGlnbm5vbmUgd3AtaW1hZ2UtMTE3NzUgc2l6ZS1mdWxsXCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTgvMDkvUGF0LWUxNTM2MjI4MTU5NTk4LmpwZ1wiIGFsdD1cIlwiIHdpZHRoPVwiMjAwXCIgaGVpZ2h0PVwiMjUwXCIgLz5cclxuUGF0cmljaWEgR29uemFsZXogR2FyY2lhLCBGb3VuZGVyLCBNb25kYXkgSW5ub3ZhdGlvbiBMYWJcclxuV2ViOiA8YSBocmVmPVwiaHR0cDovL21vbmRheWJhcmNlbG9uYS5jb20vXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5odHRwOi8vbW9uZGF5YmFyY2Vsb25hLmNvbS88L2E+XHJcblR3aXR0ZXI6IDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL1BhdF9HR1wiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+QFBhdF9HRzwvYT5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMi8zXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48aDM+QXV0aG9yPC9oMz5cclxuW3NpbXBsZS1hdXRob3ItYm94XVsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XSIsInBvc3RfdGl0bGUiOiJNb25kYXkgSW5ub3ZhdGlvbiBMYWI6IElubm92YXRpbmcgc3RlcC1ieS1zdGVwLCB3aGlsZSBhaW1pbmcgZm9yIFV0b3BpYSIsInBvc3RfbGluayI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9tb25kYXktaW5ub3ZhdGlvbi1sYWIvIiwicG9zdF9mZWF0dXJlZF9pbWFnZSI6IjxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiTW9uZGF5IElubm92YXRpb24gTGFiOiBJbm5vdmF0aW5nIHN0ZXAtYnktc3RlcCwgd2hpbGUgYWltaW5nIGZvciBVdG9waWFcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjE1N1wiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE4LzA5LzM2MDY0ODE4XzIwNTk5MDEyMzQyNzAyNTZfNDU2NDMwNTE5NzY0MzMzMzYzMl9vLTMwMHgxNTcuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+IiwicG9zdF9jYXRlZ29yaWVzIjoiSW5ub3ZhdGlvbiBDYXNlLCBNZWRpYSBsYWJzIiwicG9zdF90YWdzIjoiY2l0aXplbiBqb3VybmFsaXNtLCBlbGRlcmx5LCBuZXR3b3JrLCBTcGFpbiwgdXJiYW4gaW5ub3ZhdGlvbiIsIiVfdmNfcG9zdF9zZXR0aW5ncyUiOnsidmNfZ3JpZF9pZCI6W119LCIlX2VkaXRfbG9jayUiOiIxNTYyMjY3NjEyOjEiLCIlX2VkaXRfbGFzdCUiOiIxMDEiLCIlc2xpZGVfdGVtcGxhdGUlIjoiZGVmYXVsdCIsIiVfd3BiX3ZjX2pzX3N0YXR1cyUiOiJ0cnVlIiwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6IkJhcmNlbG9uYSwgU3BhaW4iLCIlX3dwZ21wX21ldGFib3hfbGF0aXR1ZGUlIjoiNDEuMzg1MDYzODk5OTk5OTkiLCIlX3dwZ21wX21ldGFib3hfbG9uZ2l0dWRlJSI6IjIuMTczNDAzNDk5OTk5OTQ5NCIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiMlwiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6Ik47IiwiJV93cGdtcF9tZXRhYm94X3RheG9tb21pZXNfdGVybXMlIjoiTjsiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6Ik47IiwiJV9rbGVvX3RyYW5zcGFyZW50X21lbnVfY29sb3IlIjoid2hpdGUiLCIlX2tsZW9fdGl0bGVfY29sb3IlIjoiIyIsIiVfa2xlb190aXRsZV9iZyUiOiIsIHJlcGVhdCwgaW5oZXJpdCwgc2Nyb2xsLCBsZWZ0IHRvcCIsIiVfa2xlb190aXRsZV9iZ19jb2xvciUiOiIjIiwiJV95b2FzdF93cHNlb19jb250ZW50X3Njb3JlJSI6IjMwIiwiJV95b2FzdF93cHNlb19wcmltYXJ5X2NhdGVnb3J5JSI6IjY5IiwiJV90aHVtYm5haWxfaWQlIjoiMTE3NzgiLCIlX2pldHBhY2tfcmVsYXRlZF9wb3N0c19jYWNoZSUiOnsiNjIzOTNiMjQyYzdhNTYxNzc0ZjhlYmZmNWMxYzA1NjUiOnsiZXhwaXJlcyI6MTU0NTM5Mzk5MCwicGF5bG9hZCI6W3siaWQiOjExNDEyfSx7ImlkIjoxMTIzNX0seyJpZCI6MTEwMjR9XX19LCIlX2tsZW9fdGl0bGVfY2hlY2tib3glIjoiMSIsIiVzYmdfc2VsZWN0ZWRfc2lkZWJhciUiOiIwIiwiJXNiZ19zZWxlY3RlZF9zaWRlYmFyX3JlcGxhY2VtZW50JSI6IjAiLCJ0YXhvbm9teT1jYXRlZ29yeSI6Iklubm92YXRpb24gQ2FzZSwgTWVkaWEgbGFicyIsInRheG9ub215PXBvc3RfdGFnIjoiY2l0aXplbiBqb3VybmFsaXNtLCBlbGRlcmx5LCBuZXR3b3JrLCBTcGFpbiwgdXJiYW4gaW5ub3ZhdGlvbiJ9LCJpY29uIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTgvMDIvbWFya2VyLTEucG5nIn0sImlkIjoxMTc3MCwiaW5mb3dpbmRvd19kaXNhYmxlIjpmYWxzZX0seyJzb3VyY2UiOiJwb3N0IiwidGl0bGUiOiJTdGFuZm9yZCBDb21wdXRhdGlvbmFsIEpvdXJuYWxpc20gTGFiOiBMYXlpbmcgdGhlIGZvdW5kYXRpb25zIG9mIFVTIGRhdGEgam91cm5hbGlzbSIsImluZm93aW5kb3dfY29udGVudCI6IjxkaXYgY2xhc3M9XCJmYy1pdGVtLWJveCBmYy1pdGVtLW5vLXBhZGRpbmdcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiU3RhbmZvcmQgQ29tcHV0YXRpb25hbCBKb3VybmFsaXNtIExhYjogTGF5aW5nIHRoZSBmb3VuZGF0aW9ucyBvZiBVUyBkYXRhIGpvdXJuYWxpc21cIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjIwMFwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE4LzA4LzE1ODIzLWpvdXJuYWxpc21fbmV3cy0zMDB4MjAwLmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmdcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXBhZGRpbmctY29udGVudF8yMFwiPlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLW1ldGEgZmMtaXRlbS1zZWNvbmRhcnktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZSBmYy10ZXh0LWNlbnRlclwiPklubm92YXRpb24gQ2FzZSwgTWVkaWEgbGFiczwvZGl2PlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLXRleHQtY2VudGVyXCI+U3RhbmZvcmQgQ29tcHV0YXRpb25hbCBKb3VybmFsaXNtIExhYjogTGF5aW5nIHRoZSBmb3VuZGF0aW9ucyBvZiBVUyBkYXRhIGpvdXJuYWxpc208L2Rpdj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1jb250ZW50IGZjLWl0ZW0tYm9keS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+XHJcbiAgICAgICAgICAgIFdvcmtpbmcgZnJvbSB0aGUgZ3JvdW5kIHVwLCBTdGFuZm9yZCBVbml2ZXJzaXR5IGlzIHRha2luZyBhIG5ldyBhcHByb2FjaCB0byBpbm5vdmF0aW9uIHRvIHByb3ZpZGUgcGxhdGZvcm1zIGZvciBqb3VybmFsaXN0cyB0byB0ZWxsIHN0b3JpZXMgdGhhdCB3b3VsZCBvdGhlcndpc2UgZ28gdW50b2xkLiBcclxuICAgICAgICA8L2Rpdj5cclxuPGEgaHJlZj1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi8xMTc2NS9cIj5SZWFkIG1vcmU8L2E+XHJcbiAgICA8L2Rpdj5cclxuICAgIDwvZGl2PlxyXG48L2Rpdj5cclxuXHJcbiIsImNvbnRlbnQiOiJXb3JraW5nIGZyb20gdGhlIGdyb3VuZCB1cCwgU3RhbmZvcmQgVW5pdmVyc2l0eSBpcyB0YWtpbmcgYSBuZXcgYXBwcm9hY2ggdG8gaW5ub3ZhdGlvbiB0byBwcm92aWRlIHBsYXRmb3JtcyBmb3Igam91cm5hbGlzdHMgdG8gdGVsbCBzdG9yaWVzIHRoYXQgd291bGQgb3RoZXJ3aXNlIGdvIHVudG9sZC4gIiwiYWRkcmVzcyI6IlN0YW5mb3JkLCBDQSwgVVNBIiwibG9jYXRpb24iOnsibGF0IjoiMzcuNDI0MTA1OTk5OTk5OTkiLCJsbmciOiItMTIyLjE2NjA3NTYiLCJvbmNsaWNrX2FjdGlvbiI6Im1hcmtlciIsInJlZGlyZWN0X3Blcm1hbGluayI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi8xMTc2NS8iLCJ6b29tIjoyLCJleHRyYV9maWVsZHMiOnsicG9zdF9leGNlcnB0IjoiV29ya2luZyBmcm9tIHRoZSBncm91bmQgdXAsIFN0YW5mb3JkIFVuaXZlcnNpdHkgaXMgdGFraW5nIGEgbmV3IGFwcHJvYWNoIHRvIGlubm92YXRpb24gdG8gcHJvdmlkZSBwbGF0Zm9ybXMgZm9yIGpvdXJuYWxpc3RzIHRvIHRlbGwgc3RvcmllcyB0aGF0IHdvdWxkIG90aGVyd2lzZSBnbyB1bnRvbGQuICIsInBvc3RfY29udGVudCI6Ilt2Y19yb3ddW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIyLzNcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxoMT5TdGFuZm9yZCBDb21wdXRhdGlvbmFsIEpvdXJuYWxpc20gTGFiOiBMYXlpbmcgdGhlIGZvdW5kYXRpb25zIG9mIFVTIGRhdGEgam91cm5hbGlzbTwvaDE+XHJcbjxiPldvcmtpbmcgZnJvbSB0aGUgZ3JvdW5kIHVwLCBTdGFuZm9yZCBVbml2ZXJzaXR5IGlzIHRha2luZyBhIG5ldyBhcHByb2FjaCB0byBpbm5vdmF0aW9uIHRvIHByb3ZpZGUgcGxhdGZvcm1zIGZvciBqb3VybmFsaXN0cyB0byB0ZWxsIHN0b3JpZXMgdGhhdCB3b3VsZCBvdGhlcndpc2UgZ28gdW50b2xkLiA8L2I+XHJcblxyXG5Gcm9tIGNvdmVyaW5nIGhhY2thYmxlIHZvdGluZyBtYWNoaW5lcyB0byBhbmFseXNpbmcgcG9saWNlIHN0b3BzLCBTdGFuZm9yZCBhcmUgdXNpbmcgZGF0YSBqb3VybmFsaXNtIHRvIGNoYW5nZSBwdWJsaWMgcG9saWN5IGFuZCByYWlzZSBhd2FyZW5lc3MgZm9yIHRoZSBpc3N1ZXMgaW4gQW1lcmljYSB0b2RheS4gVGhleSBhaW0gdG8gY3JlYXRlIHJlYWwgd29ybGQgY2hhbmdlIHRocm91Z2ggdGhlaXIgZWZmb3J0cywgYW5kIGhhdmUgbm8gaW50ZW50aW9uIG9mIHN0b3BwaW5nLlxyXG5cclxuVGhlIGxhYiwgZm91bmRlZCBpbiAyMDE0LCBpcyBvbmUgYnJhbmNoIG9mIHRoZSBsYXJnZXIgU3RhbmZvcmQgSm91cm5hbGlzbSBuZXR3b3JrLCBjb25zaXN0aW5nIG9mIHRoZSA8YSBocmVmPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL2Jyb3duLWluc3RpdHV0ZS1tZWRpYS1pbm5vdmF0aW9uLWNyb3NzLXBvbGxpbmF0aW5nLWlubm92YXRpb24tbWFnaWMtYW1lcmljYXMtY29hc3RzL1wiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyIG5vcmVmZXJyZXJcIj5Ccm93biBJbnN0aXR1dGUgZm9yIE1lZGlhIElubm92YXRpb248L2E+IChhIGNvbGxhYm9yYXRpb24gYmV0d2VlbiBDb2x1bWJpYSBKb3VybmFsaXNtIFNjaG9vbCBhbmQgdGhlIFN0YW5mb3JkIFVuaXZlcnNpdHlcdTIwMTlzIFNjaG9vbCBvZiBFbmdpbmVlcmluZykgPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPmFuZCBUaGUgU3RhbmZvcmQgRGFpbHkgTmV3c3BhcGVyLiBIZXJlIHRoZXkgdGVhY2ggc3R1ZGVudHMgaG93IHRvIGV4dHJhY3QgYW5kIHVzZSBkYXRhIHRvIGVuaGFuY2Ugc3RvcmllcyBvciB1bmNvdmVyIG5ldyBzdG9yaWVzLiBJdCBpcyBoZWFkZWQgdXAgYnkgY28tZm91bmRlciBDaGVyeWwgUGhpbGxpcHMgYnV0IGl0IGlzIHZlcnkgbXVjaCBhIGZsdWlkIG5ldHdvcmsgb2YgcGVvcGxlIHdobyBjb250cmlidXRlLiBUaGUgbGFiJ3MgbWlzc2lvbiBpcyB0d29mb2xkOiBsb3dlciB0aGUgY29zdCBvZiBcdTIwMThhY2NvdW50YWJpbGl0eSBqb3VybmFsaXNtXHUyMDE5IGFuZCB1c2UgY29tcHV0YXRpb25hbCBtZXRob2RzIHRvIGhlbHAgdW5jb3ZlciBzdG9yaWVzIHRoYXQgd291bGQgb3RoZXJ3aXNlIGdvIHVudG9sZC48L3NwYW4+XHJcblxyXG5QaGlsbGlwcyBoYXMgYmVlbiB0ZWFjaGluZyBqb3VybmFsaXNtIGF0IFN0YW5mb3JkIFVuaXZlcnNpdHkgc2luY2UgMjAxNC4gSGF2aW5nIHByZXZpb3VzbHkgd29ya2VkIGF0IHRoZSBTZWF0dGxlIFRpbWVzIGZvciBtb3JlIHRoYW4gYSBkZWNhZGUsIHdpdGggaGVyIG1vc3QgcmVjZW50IHJvbGUgYmVpbmcgRGF0YSBJbm5vdmF0aW9uIEVkaXRvciwgUGhpbGxpcHMgaXMgbm8gc3RyYW5nZXIgdG8gdGhlIHdvcmxkIG9mIG1lZGlhIGlubm92YXRpb246XHJcbjxibG9ja3F1b3RlPlx1MjAxY1dlIHdhbnQgdG8gaGVscCBqb3VybmFsaXN0cyB0ZWxsIHN0b3JpZXMgaW4gYSBtb3JlIHBlcnNvbmFsaXNlZCBhbmQgZW5nYWdpbmcgd2F5LiBUaGF0IGNvdWxkIGJlIGhlbHBpbmcgdG8gYnVpbGQgdG9vbHMsIHRvIHByb2Nlc3MgZGF0YS4gV2UgdGFrZSBjYXJlIG9mIHRoZSBwbHVtYmluZyBzbyB0aGUgam91cm5hbGlzdHMgY2FuIGRvIHRoZSBzdG9yeS5cdTIwMWQ8L2Jsb2NrcXVvdGU+XHJcbjxoMz5CaWcgTG9jYWwgTmV3czwvaDM+XHJcblBoaWxsaXBzXHUyMDE5IG1haW4gZm9jdXMgY3VycmVudGx5IGxpZXMgd2l0aCB0aGUgQmlnIExvY2FsIE5ld3MgcHJvamVjdCB3aGVyZSB0aGUgZ29hbCBpcyB0byBkZXZlbG9wIHBhcnRuZXJzaGlwcyBhY3Jvc3MgbmV3c3Jvb21zIHRvIGNvbGxlY3QgZGF0YSwgcHJvY2VzcyBpdCBhbmQgbWFrZSBpdCBhdmFpbGFibGUgZm9yIGpvdXJuYWxpc3RzLiBSZXBvcnRlcnMgY2FuIGFsc28gc2F2ZSB0aGVpciBkYXRhIGluIHRoZSBTdGFuZm9yZCBEaWdpdGFsIExpYnJhcnkgUmVwb3NpdG9yeSBmb3IgYXMgbG9uZyBhcyBuZWVkZWQuIFRoaXMgbGlicmFyeSBpcyBhIGRpZ2l0YWwgc3BhY2UgZGVkaWNhdGVkIHRvIG1ha2luZyBjb250ZW50IGFjY2Vzc2libGUgZm9yIGZ1dHVyZSBnZW5lcmF0aW9ucy4gSW4gcmV0dXJuIGZvciBsb2NhbCBqb3VybmFsaXN0cyB1c2luZyB0aGlzIHNlcnZpY2UsIHRoZXkgZ2V0IGEgcGVyc2lzdGVudCBVUkwgdGhleSBjYW4gc2hhcmUgb3V0IGFuZCBkb25cdTIwMTl0IGhhdmUgdG8gd29ycnkgYWJvdXQgdGhlaXIgc2VydmVyIGNoYW5naW5nIG9yIHRoZWlyIHN5c3RlbSBnb2luZyBkb3duLlxyXG5cclxuQWRkaXRpb25hbGx5LCBKb25hdGhhbiBTdHJheSwgYSBqb3VybmFsaXN0IGFuZCBsZWN0dXJlciBmcm9tIENvbHVtYmlhIFVuaXZlcnNpdHksIGlzIHdvcmtpbmcgb24gYSBcdTIwMThjb21wdXRlciBqb3VybmFsaXNtIHdvcmtiZW5jaFx1MjAxOSAoY3VycmVudGx5IGluIGJldGEpLCB3aGljaCBpcyBwYXJ0IG9mIEJpZyBMb2NhbCBhbmQgaXQgd2lsbCBiZSBvbmUgb2YgdGhlIHRvb2xzIHVzZWQgYnkgam91cm5hbGlzdHMuXHJcbjxibG9ja3F1b3RlPlx1MjAxZFRoZSB3aG9sZSBpZGVhIHdpdGggdGhhdCBpcyB0byBhbmFseXNlIGRhdGEgd2l0aG91dCBoYXZpbmcgdG8gY29kZSwgc28gaXRcdTIwMTlzIGJ1aWx0IG9uIFB5dGhvbiAoYSBwcm9ncmFtbWluZyBsYW5ndWFnZSkgYnV0IGlmIHlvdVx1MjAxOXJlIGEgam91cm5hbGlzdCB3aG8gZG9lc25cdTIwMTl0IHJlYWxseSBrbm93IGhvdyB0byB1c2UgdGhhdCBzb2Z0d2FyZSB5b3UgY2FuIHVzZSB0aGVzZSBtb2R1bGVzIHRvIGZpZ3VyZSBvdXQgaG93IHRvIGFuYWx5c2UgaW5mb3JtYXRpb24sXHUyMDFkIHNheXMgUGhpbGxpcHMuPC9ibG9ja3F1b3RlPlxyXG5UaGlzIHdvcmsgaXMgdGhhdCBQaGlsbGlwcyByZWZlcnMgdG8gYXMgXHUyMDFjZG9pbmcgdGhlIHBsdW1iaW5nXHUyMDFkLCB0aGUga2luZCBvZiB3b3JrIHRoYXRcdTIwMTlzIHVuZGVyZ3JvdW5kLCBub3Qgc2VlbiBvciB0aG91Z2h0IGFib3V0IG1vc3Qgb2YgdGhlIHRpbWUsIGJ1dCB3b3JrIHdoaWNoIGlzIGFic29sdXRlbHkgZXNzZW50aWFsIHRvIGxvY2FsIG5ld3MgcHVibGlzaGVycyBhbmQgbG9jYWwgam91cm5hbGlzdHMgdGhhdCBhcmUgc3RyZXRjaGVkIGZvciBib3RoIHRpbWUgYW5kIG1vbmV5LlxyXG48aDM+U3RydWN0dXJpbmcgdGhlIElubm92YXRpb24gTmV0d29yazwvaDM+XHJcblRoZXJlIGFyZSBzZXZlcmFsIGRpZmZlcmVudCBicmFuY2hlcyB0byB0aGUgU3RhbmZvcmQgSm91cm5hbGlzbSBuZXR3b3JrIGluY2x1ZGluZyB0aGUgQnJvd24gSW5zdGl0dXRlIGFuZCBUaGUgU3RhbmZvcmQgRGFpbHksIHNvIHdoYXQgZG9lcyBpdCBsb29rIGxpa2U/IFBoaWxsaXBzIGRlc2NyaWJlcyBpdCBhcyBhIFx1MjAxY3ZlcnkgZmx1aWRcdTIwMWQgc3RydWN0dXJlLCB0aGVpciBzZW1pbmFycyBhbmQgd29ya3Nob3BzIGFyZSB0YXVnaHQgYnkgYSB2YXJpZXR5IG9mIGluZHVzdHJ5IHByb2Zlc3Npb25hbHMgcmFuZ2luZyBmcm9tIHRoZSBoZWFkIG9mIHRoZSBCcm93biBJbnN0aXR1dGUsIE1hbmVlc2ggQWdyYXdhbGEsIHRvIEtyaXNobmEgQmhhcmF0IHRoZSBmb3VuZGVyIG9mIEdvb2dsZSBOZXdzLiBUaGUgZGVwYXJ0bWVudCBpcyBmcmVlIHRvIGludmVzdGlnYXRlIGFuZCBmbGVzaCBvdXQgZGlmZmVyZW50IHByb2plY3RzIGFzIHRoZXkgc2VlIGZpdCwgdG8gY3JlYXRlIG1vcmUgY29udmVyc2F0aW9ucyBhcm91bmQgdG9waWNzLCB0byBmb3N0ZXIgY29sbGFib3JhdGlvbnMgYW5kIGJ1aWxkIHBhcnRuZXJzaGlwcyB0aHJvdWdob3V0IHRoZSBpbmR1c3RyeS5cclxuXHJcblRoaXMgbGljZW5jZSB0byBmb2xsb3cgdGhlaXIgam91cm5hbGlzdGljIGluc3RpbmN0IGhhcyBhbGxvd2VkIHRoZW0gbXVjaCBtb3JlIGZyZWVkb20gd2hlbiBpdCBjb21lcyB0byBzZWxlY3RpbmcgcHJvamVjdHMuIFBoaWxsaXBzIHN1Z2dlc3RzIHRoZXkgYXJlblx1MjAxOXQgbW90aXZhdGVkIGJ5IGEgbmVlZCB0byBnZW5lcmF0ZSByZXZlbnVlLCBidXQgcmF0aGVyIHRoZWlyIGZvY3VzIGlzIG9uIGltcGFjdCBpbiBzb21lIGZvcm06XHJcbjxibG9ja3F1b3RlPlx1MjAxY1doYXQgd2VcdTIwMTlyZSBnb2luZyBmb3IgaXMgc29tZSBraW5kIG9mIGltcGFjdCwgY2hhbmdpbmcgcG9saWN5IGlmIHBvc3NpYmxlLCBqdXN0IGxpa2Ugd2l0aCBhbnkga2luZCBvZiBpbnZlc3RpZ2F0aXZlIGpvdXJuYWxpc20uXHUyMDFkPC9ibG9ja3F1b3RlPlxyXG5CdXQgdGhhdCBpcyBub3QgdGhlIG9ubHkgZHJpdmVyLiBXaGVuIHNvbWVvbmUgY29tZXMgdG8gUGhpbGxpcHMgd2l0aCBhIHByb2plY3Qgb3IgYW4gaWRlYSBzaGUgYWx3YXlzIHRyaWVzIHRvIGludm9sdmUgYSBuZXdzcm9vbSBpZiB0aGVyZSBpcyBvbmUgaW50ZXJlc3RlZC4gVGhpcyBub3Qgb25seSBnaXZlcyB0aG9zZSBzdHVkZW50cyBhIGdsaW1wc2UgaW50byBhIHJlYWwgbmV3c3Jvb20gYnV0IGl0IGhlbHBzIHRoZW0gY3JlYXRlIGEgbmV0d29yayBhbmQgZ2FpbiBleHBlcmllbmNlIGFsb25nc2lkZSByZWFsIHByb2Zlc3Npb25hbHMuXHJcblxyXG5UaGVyZSBhIGZldyBvdGhlciBrZXkgdGhpbmdzIFBoaWxsaXBzIGxvb2sgZm9yIGluIGEgcHJvamVjdDogaXMgaXQgbmV3IGFuZCBkb2VzIGl0IGhhdmUgcG90ZW50aWFsIGZvciBjaGFuZ2Ugb3IgcmVmb3JtPyBXaGF0IGlzIHRoZSBtaW5pbXVtIHN0b3J5IHRoYXQgY2FuIGJlIHRvbGQ/IElmIGFsbCBlbHNlIGZhaWxzIGlzIHRoZXJlIHN0aWxsIGEgc3RvcnkgdG8gYmUgdG9sZD8gV2hhdCBjb3VsZCB0aGUgbWF4aW11bSBzdG9yeSBiZTsganVzdCBob3cgZmFyIGNhbiB0aGlzIHN0b3J5IGdvP1xyXG48aDM+TWFwcGluZyBIYWNrYWJsZSB2b3RpbmcgbWFjaGluZXM8L2gzPlxyXG5UaGlzIGFwcHJvYWNoIGxlZCB0byB0aGVpciB3b3JrIGFyb3VuZCBcdTIwMWNoYWNrYWJsZVx1MjAxZCB2b3RpbmcgbWFjaGluZXMgaW4gUGVubnN5bHZhbmlhLiBUaGUgZGF0YSBqb3VybmFsaXNtIHN0dWRlbnRzIGludmVzdGlnYXRlZCB2b3RpbmcgbWFjaGluZXMgdGhhdCB3ZXJlIGp1ZGdlZCB0byBiZSBsb3cgdGVjaCBhbmQgYXQgcmlzayBvZiBiZWluZyBoYWNrZWQgZm9yIGVhY2ggY291bnR5IGluIHRoZSBzdGF0ZS5cclxuXHJcbkluIHRlbiB3ZWVrcyB0aGV5IG1hcHBlZCBkYXRhIGZvciB3aG8gaGFkIHBsYW5zIHRvIHVwZ3JhZGUgdGhlaXIgbWFjaGluZXMgb3Igbm90IGJlZm9yZSB0aGUgbmV4dCB2b3RpbmcgY3ljbGUgYW5kIHB1Ymxpc2hlZCB0aGVpciBmaW5kaW5ncyBpbiBhbiBhcnRpY2xlIGZvciB0aGUgUGhpbGFkZWxwaGlhIElucXVpcmVyLiBUaGUgcmVzdWx0cyB3ZXJlIHRoYXQgdGhlIGNvdW50eSBjaGFuZ2VkIHRoZWlyIHBvbGljeSBvbiB2b3RpbmcgbWFjaGluZXMgc28gdGhhdCBhbGwgY291bnRpZXMsIG5vdCBqdXN0IHRoZSBmb3VyIHRoYXQgcGxhbm5lZCB0bywgdXBkYXRlZCB0aGVpciBtYWNoaW5lcy5cclxuXHJcblRoaXMgaXMgd2hhdCB0aGlzIGxhYiBpcyBhaW1pbmcgZm9yOyByZWFsIHdvcmxkIGNoYW5nZSBhcyBhIHJlc3VsdCBvZiBkb2luZyB0aGVzZSBzb3J0cyBvZiBzdG9yaWVzLCBidWlsZGluZyBwbGF0Zm9ybXMgc28gdGhleSBkb25cdTIwMTl0IGdvIHVudG9sZCBhbmQsIG1heWJlIG1vc3QgaW1wb3J0YW50bHksIHRvIGtlZXAgYWNjb3VudGFiaWxpdHkgam91cm5hbGlzbSBsb3cgY29zdCBhbmQgZWFzeSBmb3IgcmVwb3J0ZXJzLlxyXG48aDM+UHJvYmxlbSBzb2x2aW5nIHRocm91Z2ggSW5ub3ZhdGlvbjwvaDM+XHJcbk9uIHRoZSBicm9hZGVyIHRvcGljIG9mIGlubm92YXRpb24gUGhpbGxpcHMgc2F5cyBzaGUgbG9va3MgdG8gaWRlbnRpZnkgdW5tZXQgbmVlZHMgYW5kIHNlZSBob3cgdGhlIHN0cnVjdHVyZXMgb3IgY29sbGFib3JhdGlvbnMgdG8gZnVsZmlsbCB0aG9zZSBuZWVkcyBjb3VsZCBiZSBjaGFuZ2VkLiBUaGV5IGRvblx1MjAxOXQgaG93ZXZlciB0cnkgdG8gaW5ub3ZhdGUgZnJvbSBhIHN0YW5kaW5nIHN0YXJ0LCBzYXlzIFBoaWxsaXBzLlxyXG48YmxvY2txdW90ZT5cdTIwMWNJIHRoaW5rIGl0XHUyMDE5cyBpbm5vdmF0ZSBvZmYgdGhlIGJhY2sgb2YgW2FuIGlzc3VlXSBhbmQgc29sdmUgYSBwcm9ibGVtIHRoYXRcdTIwMTlzIGtpbmQgb2Ygd2hlcmUgb3VyIGZvY3VzIGlzLiBUaGVyZVx1MjAxOXMgc28gbWFueSBzdHJlc3NlcyBvbiBsb2NhbCBqb3VybmFsaXNtIGFuZCBhY2NvdW50YWJpbGl0eSBqb3VybmFsaXNtIHRoYXQgdGhlcmVcdTIwMTlzIG5vIHNob3J0YWdlIG9mIHByb2JsZW1zLiBTbyB3ZSBqdXN0IHRyeSB0byB0YWNrbGUgdGhvc2Ugd2hlcmUgd2UgY2FuIGFsdGhvdWdoIHNvbWV0aW1lcyBJIHRoaW5rIHRoZSBwcm9ibGVtcyBoYXZlIGFzIHlldCBiZWVuIHVuaWRlbnRpZmllZC5cdTIwMWQ8L2Jsb2NrcXVvdGU+XHJcbk9uZSBvZiB0aGVzZSBtYW55IHN0cmVzc2VzIG9uIGxvY2FsIGpvdXJuYWxpc20gbGVkIHRvIHRoZSBpbnRyb2R1Y3Rpb24gb2YgdGhlIEJpZyBMb2NhbCBwcm9qZWN0OlxyXG48YmxvY2txdW90ZT5cdTIwMWNUaGUgaWRlYSBpcyB0byBjb2xsZWN0IGxvY2FsIGRhdGEgc2V0cyB0aGF0IGxlbmQgdGhlbXNlbHZlcyB0byBpbnZlc3RpZ2F0aXZlIG9yIGFjY291bnRhYmlsaXR5IGpvdXJuYWxpc20sIHRoZW4gaGVscCBsb2NhbCBuZXdzcm9vbXMgd2l0aCB0aG9zZSBhbmQgYWxzbyBhZ2dyZWdhdGUgZGF0YSBzZXRzIGZvciBiaWdnZXIgaW1wYWN0IHN0b3JpZXMuIFBlb3BsZSBtYXkgaGF2ZSB0aG91Z2h0IGFib3V0IGRvaW5nIHNvbWV0aGluZyBsaWtlIHRoaXMgYmVmb3JlLCBidXQgdGhleSB3ZXJlblx1MjAxOXQgXHUyMDFjcnVubmluZyBhcm91bmQgc2F5aW5nIFx1MjAxOGhleSBzb21lYm9keSBoYXMgdG8gZG8gdGhpc1x1MjAxOVx1MjAxZCBQaGlsbGlwcyBhZGRlZC48L2Jsb2NrcXVvdGU+XHJcbjxoMz5UaGUgRnV0dXJlPC9oMz5cclxuVGhlIG1lZGlhIGxhbmRzY2FwZSBpcyBldmVyIGNoYW5naW5nLCBidXQgdGhlIExhYlx1MjAxOXMgYXBwcm9hY2ggdG8gaW5ub3ZhdGlvbiBtYXkgYmUgc29tZXRoaW5nIHRoYXQgaXMgcXVpdGUgY29uc2lzdGVudC4gR29pbmcgZm9yd2FyZCwgUGhpbGxpcHMgc3VnZ2VzdHMgdGhhdCBvdGhlciB1bml2ZXJzaXRpZXMgbG9va2luZyB0byBmb2xsb3cgaW4gdGhlaXIgZm9vdHN0ZXBzIHNob3VsZG5cdTIwMTl0IGJlIGFmcmFpZCB0byBtYWtlIG1pc3Rha2VzLCByYXRoZXIgdG8gbWFrZSB0aGVtLCBsZWFybiBhbmQgaW1wcm92ZS4gQXMgd2VsbCBhcyBcdTIwMWNqdXN0IHN0YXJ0IHRlYWNoaW5nIGRhdGEgam91cm5hbGlzbSB0byB5b3VyIHN0dWRlbnRzXHUyMDFkLlxyXG5cclxuQSBzdHVkeSBjb25kdWN0ZWQgYnkgUGhpbGxpcHMgYW5kIENoYXJsZXMgQmVycmV0LCBpbnRvIGpvdXJuYWxpc20gc2Nob29scyBpbiB0aGUgVVNBIGZvdW5kIHRoYXQgYSBsaXR0bGUgbW9yZSB0aGFuIGhhbGYgcmVndWxhcmx5IG9mZmVyZWQgb25lIG9yIG1vcmUgZGF0YSBqb3VybmFsaXNtIGNsYXNzLCBidXQgbW9zdCBvZiB0aG9zZSBjbGFzc2VzIHdlcmUgXHUyMDE4YmFzaWNcdTIwMTkuIFRoZSBjb3Vyc2VzIHRhdWdodCBleGNlbCBzcHJlYWRzaGVldHMgcmF0aGVyIHRoYW4gcHJvZ3JhbW1pbmcgc2tpbGxzIGFuZCBpbiA1NCBvdXQgb2YgMTEzIGNhc2VzLCBubyBkYXRhIGpvdXJuYWxpc20gY291cnNlIHdhcyB0YXVnaHQuXHJcblxyXG5UaGUgYXBwcm9hY2ggQ2hlcnlsIFBoaWxsaXBzIHRha2VzIHRvIHRoZSBmdXR1cmUgYW5kIHdoYXQgaW5ub3ZhdGlvbiBtYXkgYnJpbmcgaXMgc29tZXRoaW5nIHRoYXQgYW55b25lIGludm9sdmVkIGluIHRoZSBtZWRpYSBpbm5vdmF0aW9uIHdvcmxkIHNob3VsZCB0YWtlIG9uIGJvYXJkOlxyXG48YmxvY2txdW90ZT5cdTIwMWNJIHRoaW5rIG9uZSBvZiB0aGUgdGhpbmdzIGFib3V0IG5ld3NwYXBlcnMgaW4gaGlzdG9yeSwgdGhhdCB5b3Ugc29tZXRpbWVzIGRvblx1MjAxOXQgZ2V0IG9ubGluZSwgaXMgdGhhdCBzZW5zZSBvZiBzZXJlbmRpcGl0eSwgeW91IG1pZ2h0IGZpbmQgYSBzdG9yeSB5b3UgZGlkblx1MjAxOXQga25vdyB5b3VcdTIwMTlkIGJlIGludGVyZXN0ZWQgaW4gYW5kIHRoZW4geW91IHJlYWQgaXQuLi5hbmQgaXQgZXhwYW5kcyB5b3VyIGhvcml6b25zLiBXZWxsIHRoZSBzYW1lIHRoaW5nIGlzIHRydWUgb2YgaW5ub3ZhdGlvbi48L2Jsb2NrcXVvdGU+XHJcbjxibG9ja3F1b3RlPkkgZG9uXHUyMDE5dCBrbm93IHdoYXQgdGhleSBuZXh0IHRvb2wgbWlnaHQgYmUuIEkgaG9wZSBJXHUyMDE5bSBhIHBhcnQgb2YgaXQgYW5kIHRoZSB3YXkgSSBjYW4gbWFrZSBzdXJlIElcdTIwMTltIGdvaW5nIHRvIGJlIGEgcGFydCBvZiBpdCBpcyB0byBmb3N0ZXIgdGhlc2UgY29udmVyc2F0aW9ucy4gV2hldGhlciBpdFx1MjAxOXMgYSB0b29sIG9yIGFuIGVmZm9ydCBmaXZlIHllYXJzIGRvd24gdGhlIHJvYWQgSVx1MjAxOW0gbm90IHN1cmUgd2hhdCBpdFx1MjAxOXMgYWxsIGdvaW5nIHRvIGxvb2sgbGlrZS48L2Jsb2NrcXVvdGU+XHJcbjxibG9ja3F1b3RlPkkgaGF2ZSBubyBkb3VidCB0aGF0IHRoZSBuZXh0IHRpbWUgd2UgaGF2ZSB0aGUgY29tcHV0YXRpb25hbCBqb3VybmFsaXNtIHNlbWluYXIsIHNvbWVib2R5IHdpbGwgcHJvYmFibHkgaGF2ZSBhbiBpZGVhIHRoYXQgd29uXHUyMDE5dCBldmVuIGJlIHNvbWV0aGluZyBJXHUyMDE5dmUgdGhvdWdodCBvZiByaWdodCBhbmQgdGhhdFx1MjAxOXMgdGhhdCBzZXJlbmRpcGl0eS5DcmVhdGluZyBhIGdyb3VuZCBmb3Igc2VyZW5kaXBpdG91cyBtb21lbnRzIHRoYXQgd2lsbCBoZWxwIGpvdXJuYWxpc20uXHUyMDFkPC9ibG9ja3F1b3RlPlxyXG5DT05UQUNUIFBPSU5UXHJcbjxpbWcgY2xhc3M9XCJhbGlnbm5vbmUgd3AtaW1hZ2UtMTE3NDYgc2l6ZS1mdWxsXCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTgvMDgvY2VwaGlsbGlwczEtZTE1MzYyMjc1ODQ5MzIuanBnXCIgYWx0PVwiXCIgd2lkdGg9XCIyMDBcIiBoZWlnaHQ9XCIyNTBcIiAvPlxyXG5DaGVyeWwgUGhpbGxpcHMsIENvLUZvdW5kZXIsIFN0YW5mb3JkIENvbXB1dGF0aW9uYWwgSm91cm5hbGlzbSBMYWJcclxuV2ViOiA8YSBocmVmPVwiaHR0cDovL2NqbGFiLnN0YW5mb3JkLmVkdS9cIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lciBub3JlZmVycmVyXCI+aHR0cDovL2NqbGFiLnN0YW5mb3JkLmVkdS88L2E+XHJcblR3aXR0ZXI6IDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2NlcGhpbGxpcHNcIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lciBub3JlZmVycmVyXCI+QGNlcGhpbGxpcHM8L2E+Wy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjIvM1wiXVt2Y19jb2x1bW5fdGV4dF1cclxuPGgzPkF1dGhvcjwvaDM+XHJcbltzaW1wbGUtYXV0aG9yLWJveF1bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd10iLCJwb3N0X3RpdGxlIjoiU3RhbmZvcmQgQ29tcHV0YXRpb25hbCBKb3VybmFsaXNtIExhYjogTGF5aW5nIHRoZSBmb3VuZGF0aW9ucyBvZiBVUyBkYXRhIGpvdXJuYWxpc20iLCJwb3N0X2xpbmsiOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvMTE3NjUvIiwicG9zdF9mZWF0dXJlZF9pbWFnZSI6IjxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiU3RhbmZvcmQgQ29tcHV0YXRpb25hbCBKb3VybmFsaXNtIExhYjogTGF5aW5nIHRoZSBmb3VuZGF0aW9ucyBvZiBVUyBkYXRhIGpvdXJuYWxpc21cIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjIwMFwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE4LzA4LzE1ODIzLWpvdXJuYWxpc21fbmV3cy0zMDB4MjAwLmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6Iklubm92YXRpb24gQ2FzZSwgTWVkaWEgbGFicyIsInBvc3RfdGFncyI6ImFjYWRlbWljIExhYiwgZGF0YSBqb3VybmFsaXNtLCBVU0EiLCIlX2VkaXRfbG9jayUiOiIxNTYyMzE1NzE2OjkzMSIsIiVfZWRpdF9sYXN0JSI6IjkzMSIsIiVzbGlkZV90ZW1wbGF0ZSUiOiJkZWZhdWx0IiwiJV93cGJfdmNfanNfc3RhdHVzJSI6InRydWUiLCIlX3dwZ21wX2xvY2F0aW9uX2FkZHJlc3MlIjoiU3RhbmZvcmQsIENBLCBVU0EiLCIlX3dwZ21wX21ldGFib3hfbGF0aXR1ZGUlIjoiMzcuNDI0MTA1OTk5OTk5OTkiLCIlX3dwZ21wX21ldGFib3hfbG9uZ2l0dWRlJSI6Ii0xMjIuMTY2MDc1NiIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiMlwiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6Ik47IiwiJV93cGdtcF9tZXRhYm94X3RheG9tb21pZXNfdGVybXMlIjoiTjsiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6Ik47IiwiJV9rbGVvX3RyYW5zcGFyZW50X21lbnVfY29sb3IlIjoid2hpdGUiLCIlX2tsZW9fdGl0bGVfY29sb3IlIjoiIyIsIiVfa2xlb190aXRsZV9iZyUiOiIsIHJlcGVhdCwgaW5oZXJpdCwgc2Nyb2xsLCBsZWZ0IHRvcCIsIiVfa2xlb190aXRsZV9iZ19jb2xvciUiOiIjIiwiJV95b2FzdF93cHNlb19jb250ZW50X3Njb3JlJSI6IjMwIiwiJV95b2FzdF93cHNlb19wcmltYXJ5X2NhdGVnb3J5JSI6IjY5IiwiJV90aHVtYm5haWxfaWQlIjoiMTE3NDIiLCIlX2pldHBhY2tfcmVsYXRlZF9wb3N0c19jYWNoZSUiOnsiNjIzOTNiMjQyYzdhNTYxNzc0ZjhlYmZmNWMxYzA1NjUiOnsiZXhwaXJlcyI6MTU0NTQxMjc5NywicGF5bG9hZCI6W3siaWQiOjExMDMyfSx7ImlkIjoxMDY4MX0seyJpZCI6MTEwMjR9XX19LCIlX2tsZW9fdGl0bGVfY2hlY2tib3glIjoiMSIsIiVfd3BnbXBfbG9jYXRpb25fY2l0eSUiOiIiLCIlX3dwZ21wX2xvY2F0aW9uX3N0YXRlJSI6IiIsIiVfd3BnbXBfbG9jYXRpb25fY291bnRyeSUiOiIiLCIlc2JnX3NlbGVjdGVkX3NpZGViYXIlIjoiMCIsIiVzYmdfc2VsZWN0ZWRfc2lkZWJhcl9yZXBsYWNlbWVudCUiOiIwIiwidGF4b25vbXk9Y2F0ZWdvcnkiOiJJbm5vdmF0aW9uIENhc2UsIE1lZGlhIGxhYnMiLCJ0YXhvbm9teT1wb3N0X3RhZyI6ImFjYWRlbWljIExhYiwgZGF0YSBqb3VybmFsaXNtLCBVU0EifSwiaWNvbiI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE4LzAyL21hcmtlci0xLnBuZyJ9LCJpZCI6MTE3NjUsImluZm93aW5kb3dfZGlzYWJsZSI6ZmFsc2V9LHsic291cmNlIjoicG9zdCIsInRpdGxlIjoiTWVkaWF0aTogaW5jdWJhdGluZyBuZXcgbWVkaWEgc3RhcnR1cHMgdG8gc2hha2UgdXAgdGhlIGxlZ2FjeSBtZWRpYSBsYW5kc2NhcGUiLCJpbmZvd2luZG93X2NvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIk1lZGlhdGk6IGluY3ViYXRpbmcgbmV3IG1lZGlhIHN0YXJ0dXBzIHRvIHNoYWtlIHVwIHRoZSBsZWdhY3kgbWVkaWEgbGFuZHNjYXBlXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMjVcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxOC8wOC8yMTc0Mjk4Nl8xNjA3NzYxMzc5Mjk0NTUzXzI1ODA5NjEzMTg3MzczMTA1OTZfbi0zMDB4MjI1LmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmdcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXBhZGRpbmctY29udGVudF8yMFwiPlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLW1ldGEgZmMtaXRlbS1zZWNvbmRhcnktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZSBmYy10ZXh0LWNlbnRlclwiPklubm92YXRpb24gQ2FzZSwgTWVkaWEgbGFiczwvZGl2PlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLXRleHQtY2VudGVyXCI+TWVkaWF0aTogaW5jdWJhdGluZyBuZXcgbWVkaWEgc3RhcnR1cHMgdG8gc2hha2UgdXAgdGhlIGxlZ2FjeSBtZWRpYSBsYW5kc2NhcGU8L2Rpdj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1jb250ZW50IGZjLWl0ZW0tYm9keS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+XHJcbiAgICAgICAgICAgIFwiSWYgY29udGVudCBmcm9tIG9sZCBtZWRpYSBjYW5ub3QgY29tcGV0ZSB3aXRoIGEgMjIteWVhciBvbGQgWW91VHViZXIsIHRoYXRcdTIwMTlzIGEgcHJvYmxlbSxcdTIwMWQgc2F5cyBNZWRpYXRpJ3MgQ29udGVudCBTdHJhdGVnaXN0IFNpbW9uIFBhcmsuXHJcbiAgICAgICAgPC9kaXY+XHJcbjxhIGhyZWY9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvbWVkaWF0aS1pbmN1YmF0aW5nLW5ldy1tZWRpYS1zdGFydHVwcy10by1zaGFrZS11cC10aGUtbGVnYWN5LW1lZGlhLWxhbmRzY2FwZS9cIj5SZWFkIG1vcmU8L2E+XHJcbiAgICA8L2Rpdj5cclxuICAgIDwvZGl2PlxyXG48L2Rpdj5cclxuXHJcbiIsImNvbnRlbnQiOiJcIklmIGNvbnRlbnQgZnJvbSBvbGQgbWVkaWEgY2Fubm90IGNvbXBldGUgd2l0aCBhIDIyLXllYXIgb2xkIFlvdVR1YmVyLCB0aGF0XHUyMDE5cyBhIHByb2JsZW0sXHUyMDFkIHNheXMgTWVkaWF0aSdzIENvbnRlbnQgU3RyYXRlZ2lzdCBTaW1vbiBQYXJrLiIsImFkZHJlc3MiOiJTZW91bCwgU291dGggS29yZWEiLCJsb2NhdGlvbiI6eyJsYXQiOiIzNy41NjY1MzUiLCJsbmciOiIxMjYuOTc3OTY5MTk5OTk5OTYiLCJvbmNsaWNrX2FjdGlvbiI6Im1hcmtlciIsInJlZGlyZWN0X3Blcm1hbGluayI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9tZWRpYXRpLWluY3ViYXRpbmctbmV3LW1lZGlhLXN0YXJ0dXBzLXRvLXNoYWtlLXVwLXRoZS1sZWdhY3ktbWVkaWEtbGFuZHNjYXBlLyIsInpvb20iOjIsImV4dHJhX2ZpZWxkcyI6eyJwb3N0X2V4Y2VycHQiOiJcIklmIGNvbnRlbnQgZnJvbSBvbGQgbWVkaWEgY2Fubm90IGNvbXBldGUgd2l0aCBhIDIyLXllYXIgb2xkIFlvdVR1YmVyLCB0aGF0XHUyMDE5cyBhIHByb2JsZW0sXHUyMDFkIHNheXMgTWVkaWF0aSdzIENvbnRlbnQgU3RyYXRlZ2lzdCBTaW1vbiBQYXJrLiIsInBvc3RfY29udGVudCI6Ilt2Y19yb3ddW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIyLzNcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxoMT5NZWRpYXRpOiBpbmN1YmF0aW5nIG5ldyBtZWRpYSBzdGFydHVwcyB0byBzaGFrZSB1cCB0aGUgbGVnYWN5IG1lZGlhIGxhbmRzY2FwZTwvaDE+XHJcbjxzdHJvbmc+XCJJZiBjb250ZW50IGZyb20gb2xkIG1lZGlhIGNhbm5vdCBjb21wZXRlIHdpdGggYSAyMi15ZWFyIG9sZCBZb3VUdWJlciwgdGhhdFx1MjAxOXMgYSBwcm9ibGVtLFx1MjAxZCBzYXlzIE1lZGlhdGkncyBDb250ZW50IFN0cmF0ZWdpc3QgU2ltb24gUGFyay5cclxuPC9zdHJvbmc+XHJcblxyXG5DcmVhdGVkIGluIDIwMTYsIE1lZGlhdGkgYWltcyB0byBhZGRyZXNzIGlzc3VlcyB3aXRoIHRoZSBsZWdhY3kgbWVkaWEgaW4gU291dGggS29yZWEuIEFjY29yZGluZyB0byB0aGUgbGFiJ3MgQ29udGVudCBTdHJhdGVnaXN0IFNpbW9uIFBhcmssIHRoZXkgYXJlIG5vdCB0cmFuc3BhcmVudCBhYm91dCB0aGVpciByZWxhdGlvbnMgd2l0aCBhZHZlcnRpc2VycyBhbmQgdGhlaXIgY29udGVudCBpcyBvZnRlbiBvdXQtZGF0ZWQ6XHJcbjxibG9ja3F1b3RlPlx1MjAxY0JlY2F1c2Ugb2xkIG1lZGlhIGRpZG5cdTIwMTl0IGhhdmUgdG8gaW1wcm92ZSB1c2VyIGV4cGVyaWVuY2UsIHRoZWlyIHByb2R1Y3QgaXMgYWR2ZXJ0aXNlbWVudCwgYW5kIGl0XHUyMDE5cyBiYXNlZCBvbiB0aGUgbnVtYmVycywgbm90IHRoZSBhY3R1YWwgZXhwZXJpZW5jZSBvZiB0aGUgYXVkaWVuY2UuIFNvIGl0XHUyMDE5cyByZWFsbHkgb3V0LWRhdGVkIGNvbnRlbnQgdGhhdCBkb2Vzblx1MjAxOXQgd29yayBvbiBzb2NpYWwgbWVkaWEuIElcdTIwMTltIG5vdCBzYXlpbmcgc29jaWFsIG1lZGlhIG9yIGJpZyBwbGF0Zm9ybXMgYXJlIG91ciBmdXR1cmUsIGJ1dCBpZiBjb250ZW50IGZyb20gb2xkIG1lZGlhIGNhbm5vdCBjb21wZXRlIHdpdGggYSAyMi15ZWFyIG9sZCBZb3VUdWJlciwgdGhhdFx1MjAxOXMgYSBwcm9ibGVtLlx1MjAxZDwvYmxvY2txdW90ZT5cclxuVGhlIGlkZWEgd2FzIHRvIGx1cmUgeW91bmcgam91cm5hbGlzbSBncmFkdWF0ZXMgaW50byBzdGFydGluZyB0aGVpciBvd24gaW5ub3ZhdGl2ZSBjb21wYW5pZXMgYmVmb3JlIGxlZ2FjeSBtZWRpYSBvcmdhbmlzYXRpb25zIHN3b29wIHRoZW0gdXAuIFR3byB5ZWFycyBsYXRlciwgaXQgdHVybnMgb3V0IGhhcmRlciB0byBmaW5kIG1lZGlhIHN0YXJ0dXBzIHRoYW4gdGhlIE1lZGlhdGkgdGVhbSBoYWQgaG9wZWQuIEluc3RlYWQgb2YgdGhlIGV4cGVjdGVkIDIwLCB0aGV5IGp1c3QgZ290IHRoZWlyIDE0dGggdGVhbSBvbiBib2FyZDpcclxuPGJsb2NrcXVvdGU+XHUyMDFjT25lIHRoaW5nIHRoYXQgd2UgZm91bmQgb3ZlciB0aGUgcGFzdCB0d28geWVhcnMgaXMgdGhhdCBpdFx1MjAxOXMgbm90IGVhc3kgZm9yIHVzIHRvIGZpbmQgbmV3IG1lZGlhIHN0YXJ0dXBzIGluIHRoZSBLb3JlYW4gbWFya2V0LiBZb3VuZyBwZW9wbGUgZG9uJ3QgdGhpbmsgdGhleSBoYXZlIHRoZSBvcHBvcnR1bml0eSB0byBjcmVhdGUgYSBjb21wYW55IGFuZCB3b3VsZCByYXRoZXIgZ28gdG8gdGhlIGxlZ2FjeSBtZWRpYSB0byBzdGFydCB0aGVpciBjYXJlZXJzLlx1MjAxZDwvYmxvY2txdW90ZT5cclxuPGgzPlNlbGVjdGlvbiBvZiBzdGFydHVwczwvaDM+XHJcblRoZSBpbmN1YmF0b3IgaXMgb3BlbiB0byBhbnlvbmUgaW4gcHJpbmNpcGFsLiBUaGV5IGhhdmUgYW4gb3BlbiBtZW50b3JpbmcgcHJvZ3JhbTsgYSAxLDUgaG91ciBzZXNzaW9uIGVhY2ggbW9udGggdGhhdCBhbnlvbmUgY2FuIGFwcGx5IGZvcjpcclxuPGJsb2NrcXVvdGU+XHUyMDFjV2UgZG8gdGhpcyB0aGluZyBjYWxsZWQgUHJvZHVjdCBGaWVsZDogYSBHZXJtYW4gbWV0aG9kIG9mIHByb2R1Y3QgZGV2ZWxvcG1lbnQsIHRoYXQgd2UgY2hhbmdlZCB0byBmaXQgYSBtZWRpYSBtb2RlbC4gSXQgaGVscHMgeW91IGZpbmQgb3V0IGluIGxlc3MgdGhhbiBhbiBob3VyIHdobyB5b3VyIGF1ZGllbmNlIGlzLCB5b3VyIHByb2R1Y3QsIGFuZCBwb3NzaWJsZSBidXNpbmVzcyBtb2RlbHMuXHUyMDFkPC9ibG9ja3F1b3RlPlxyXG5NZWRpYXRpIHdvcmtzIHdpdGggR29vZ2xlIEtvcmVhLiBTb21lIG9mIHRoZSBtb3N0IHN1Y2Nlc3NmdWwgdGVhbXMgdGhhdCBNZWRpYXRpIGVuZHMgdXAgdHJhaW5pbmcgYW5kIGludmVzdGluZyBpbiBjb21lIGZyb20gdGhlaXIgR29vZ2xlIE5ld3MgTGFiLCB0aGF0IHRha2VzIHBsYWNlIGVhY2ggeWVhciBmcm9tIG1pZC1EZWNlbWJlciB0byB0aGUgZW5kIG9mIEZlYnJ1YXJ5LiBTaW5jZSBpdCdzIG1haW5seSBjb2xsZWdlIHN0dWRlbnRzIGFwcGx5aW5nIGZvciB0aGUgcHJvZ3JhbSwgaXQgbWFrZXMgc2Vuc2UgdG8gb3JnYW5pc2UgaXQgZHVyaW5nIHRoZWlyIHdpbnRlciBicmVhay5cclxuPGJsb2NrcXVvdGU+XHUyMDFjV2UgdGVhY2ggdGhlbSB0aGUgYmFzaWNzIG9mIGhvdyBuZXcgbWVkaWEgd29ya3MuIEFmdGVyIHR3byBtb250aHMgd2Ugc2VlIHdobyBhcmUgaW50ZXJlc3RlZCBpbiBzdGFydGluZyBhIG5ldyBtZWRpYSBhbmQgd2UgY2FuIGFjdHVhbGx5IHNlZSB3aG8gaXMgdGFsZW50ZWQgYWxyZWFkeSwgYW5kIHRoZXkgZ2V0IGEgYml0IG9mIGEgbGVnIHVwLiBUaGV5IGFyZSByZWFsbHkgdGFsZW50ZWQgcGVvcGxlLCBzbyB0aGUgY29tcGV0aXRpb24gZm9yIHRoZW0gaXMgcmVhbGx5IGhpZ2guXHUyMDFkPC9ibG9ja3F1b3RlPlxyXG48aDM+SGVscGluZyB5b3VuZyBwZW9wbGUgc3RhcnQgbWVkaWEgY29tcGFuaWVzPC9oMz5cclxuU2VsZWN0ZWQgc3RhcnR1cHMgZ28gaW50byBhIHNpeC1tb250aCBpbmN1YmF0aW9uIHByb2dyYW0sIHdoaWNoIHN0YXJ0cyB3aXRoIGF1ZGllbmNlIHJlc2VhcmNoLCBpbiB0aGUgZm9ybSBvZiBpbnRlcnZpZXdzOlxyXG48YmxvY2txdW90ZT5cIk9uZSBvZiB0aGUgc3RhcnR1cHMgYWN0dWFsbHkgZ2F2ZSB1cCB0aGVpciBwcm9kdWN0LiBJdCB3YXMgdGhlIGZpcnN0IHRpbWUgdGhleSBtZXQgdGhlaXIgYXVkaWVuY2UuIFRoZXkgZGlkIHRoZXNlIG9uZS1ob3VyIGludGVydmlld3Mgd2l0aCB0aGVtIGFuZCBmb3VuZCBvdXQgdGhhdCBubyBvbmUgd2FudHMgdGhlaXIgcHJvZHVjdC4gQnV0IGZpbmRpbmcgdGhhdCBvdXQgaW4gdHdvIHdlZWtzIGlzIGdyZWF0LiBBbmQgYXNraW5nIHRoZWlyIGF1ZGllbmNlcyB3aGF0IGluZm9ybWF0aW9uIHRoZXkgbmVlZCBidXQgY3VycmVudGx5IGxhY2sgaGVscGVkIHRoZW0gY29tZSB1cCB3aXRoIGEgZGlmZmVyZW50IHByb2R1Y3QuXHUyMDFkPC9ibG9ja3F1b3RlPlxyXG5OZXh0LCB0aGUgdGVhbXMgZGV2ZWxvcCB0aGVpciBwcm9kdWN0cywgYW5kIE1lZGlhdGkgcHJvdmlkZXMgbWVudG9yaW5nIGJ5IHNpbXBseSB0YWxraW5nIHRvIHRoZW0gYWJvdXQgdGhlaXIgcHJvZHVjdHMgYW5kIGFza2luZyBxdWVzdGlvbnMgdGhleSBoYWQgbm90IHRob3VnaHQgYWJvdXQgdGhlbXNlbHZlczogXHUyMDFjV2UganVzdCB0YWxrIHRvIHRoZW0gc28gdGhleSByZWFsaXNlIGJldHRlciB3aGF0IHRoZXkgYXJlIGRvaW5nLlx1MjAxZFxyXG5cclxuRmluYWxseSwgdGhleSBjb3ZlciB0aGUgYnVzaW5lc3MgZGV0YWlscywgcHJlcGFyaW5nIHRoZSB0ZWFtcyBmb3IgdGhlIG5leHQgaW52ZXN0bWVudCByb3VuZC4gTWVkaWF0aSBzcGVuZHMgYSBsb3Qgb2YgdGltZSB0ZWFjaGluZyBidXNpbmVzcyBza2lsbHMsIGJlY2F1c2UgZXZlbiB3aGVuIGpvdXJuYWxpc20gZ3JhZHVhdGVzIHB1cnN1ZSB0aGlzIHBhdGggb2YgY3JlYXRpbmcgdGhlaXIgb3duIGNvbXBhbnksIHRoZXkgbGFjayB0aGUgZW50cmVwcmVuZXVyaWFsIG1pbmRzZXQgbmVjZXNzYXJ5LiBUaGV5IHdlcmUgdGF1Z2h0IHRvIGxpc3RlbiB0byBsZWN0dXJlcyBhbmQgdGhlbiBjcmVhdGUgY29udGVudCwgZXhwbGFpbnMgU2ltb246XHJcbjxibG9ja3F1b3RlPlx1MjAxY1RoZXkgZ3JldyB1cCB0aGlua2luZyBhYm91dCBjcmVhdGluZyBjb250ZW50LCBub3QgYSBidXNpbmVzcy4gVGhlIGlkZWEgb2YgYSB3b3JraW5nIGJ1c2luZXNzIG1vZGVsIGNhbiBiZSBuZXcgdG8gdGhlbS4gU28gd2UgaGF2ZSB0byBzdGFydCBmcm9tIHRoZXJlLiBXaGF0IGlzIGEgYnVzaW5lc3M/IFdoYXQgaXMgdGhlIGRpZmZlcmVuY2UgYmV0d2VlbiBydW5uaW5nIGEgYnVzaW5lc3MgYW5kIGJlaW5nIGEgWW91VHViZXI/IE5vdCBtYW55IHBlb3BsZSBzZWUgdGhhdCBkaWZmZXJlbmNlLlx1MjAxYzwvYmxvY2txdW90ZT5cclxuPGgzPkxlYXJuaW5nIGFuZCBhZGFwdGluZyBmYXN0ZXI8L2gzPlxyXG5TaW1vbiBiZWxpZXZlcyB0aGF0IHRoZSBNZWRpYXRpIHN0YXJ0dXBzIHByb3ZpZGUgcmVhbCBhZGRlZCB2YWx1ZSB0byB0aGUgS29yZWFuIG1lZGlhIGxhbmRzY2FwZTpcclxuPGJsb2NrcXVvdGU+XHUyMDFjVGhleVx1MjAxOXJlIHNvIGRpZmZlcmVudCBhbmQgaW5ub3ZhdGl2ZSBiZWNhdXNlIHRoZXlcdTIwMTlyZSBsZWFybmluZyB0byBjcmVhdGUgdGhpbmdzLCBieSB0aGVtc2VsdmVzLCBieSB3YXRjaGluZyBZb3VUdWJlIHZpZGVvcywgaW5zdGVhZCBvZiBsZWFybmluZyBob3cgdGhleSBzaG91bGQgZG8gaXQgaW4gdGhlIGxlZ2FjeSBjb21wYW5pZXMuXHUyMDFkPC9ibG9ja3F1b3RlPlxyXG5JdFx1MjAxOXMgaW1wb3J0YW50IHRvIG5vdXJpc2ggdGhpcywgc2F5cyBTaW1vbiwgYXMgdGhlIHJpc2sgaXMgdGhhdCB5b3VuZyBwZW9wbGUgZ28gaW50byBsZWdhY3kgbWVkaWEgY29tcGFuaWVzIGFuZCBxdWlja2x5IGxlYXJuIGhvdyB0byB3b3JrIGxpa2UgdGhlIG90aGVycy4gSGUgZHJhd3MgYSBwYXJhbGxlbCB3aXRoIHRoZSBUZWFtcyB0aGF0IGFwcGx5IGZvciB0aGUgR29vZ2xlIEtvcmVhIGluY3ViYXRvcjpcclxuPGJsb2NrcXVvdGU+XHUyMDFjTW9zdCBvZiB0aGUgdmlkZW9ncmFwaGVycyBhbmQgZGVzaWduZXJzIHRoYXQgYXBwbHkgZm9yIHRoZSBwcm9ncmFtIGRpZCBub3QgbWFqb3IgaW4gdGhlc2Ugc3ViamVjdHMuIFRoZXkgYXJlIGF1dG8tZGlkYWN0cywgaGF2aW5nIGxlYXJuZWQgZnJvbSB3YXRjaGluZyBZb3VUdWJlIHZpZGVvcywgd2hpY2ggbWVhbnMgdGhleSBoYXZlIG1vcmUgdXAgdG8gZGF0ZSBza2lsbHMsIGFyZSBsZWFybmluZyBmYXN0ZXIsIGFuZCBhZG9wdGluZyBuZXcgd2F5cyBvZiB3b3JraW5nIG1vcmUgZWFzaWx5Llx1MjAxZDwvYmxvY2txdW90ZT5cclxuPGgzPkludmVzdG1lbnQgZm9yIEltcGFjdDwvaDM+XHJcblRoZSBpbmN1YmF0b3IgaXMgZnVuZGVkIGJ5IGFuIGludmVzdG9yLiBcdTIwMWNXZSBhcmUgdG90YWxseSBpbmRlcGVuZGVudCxcdTIwMWQgc2F5cyBTaW1vbiBQYXJrIGFib3V0IHRoZSByZWxhdGlvbnNoaXAgd2l0aCB0aGVpciBpbnZlc3Rvci4gXHUyMDFjQWxsIHRoYXQgaGUgYXNrcyBpcyB0aGF0IHdlXHUyMDE5cmUgbW9yZSBhZ2dyZXNzaXZlLlx1MjAxZFxyXG5cclxuSGF2aW5nIGFscmVhZHkgZGV2ZWxvcGVkIGEgbHVjcmF0aXZlIGJ1c2luZXNzIGFzIGFuIG9ubGluZSBlbnRyZXByZW5ldXIgXHUyMDEzIGJlaW5nIHRoZSBmb3VuZGVyIG9mIERhdW0sIG9uZSBvZiBLb3JlYVx1MjAxOXMgdG9wIHdlYiBwb3J0YWxzIC0gdGhlIGludmVzdG9yIGlzIG5vdCBleHBlY3RpbmcgYW55IHByb2ZpdCBmcm9tIHRoZSBzdGFydHVwcywgYW5kIHRoZSA0MCAwMDAgZG9sbGFycyBpbiBzZWVkIGZ1bmRpbmcgaGUgcHJvdmlkZWQgaXMgcGVhbnV0cyB0byBoaW0sIHNheXMgU2ltb24uIEZvcnR1bmF0ZWx5LCBiZWNhdXNlIHRoZSBtZWRpYSBmb3IgZXF1aXR5IE1lZGlhdGkgZ2V0cyBpcyBvbmx5IDEwIHBlciBjZW50IGFuZCB0aGUgc3RhcnR1cHMgYXJlIG5vdCBtYWtpbmcgYW55IG1vbmV5IHlldC4gQWNjb3JkaW5nIHRvIFNpbW9uLCBoaXMgbW90aXZhdGlvbnMgYXJlIG1vcmUgcmVsYXRlZCB0byBzb2NpYWwgaW1wYWN0IGFuZCBjaGFsbGVuZ2luZyB0aGUgY3VycmVudCBtZWRpYSBsYW5kc2NhcGU6XHJcbjxibG9ja3F1b3RlPlx1MjAxY0hlIGhhZCBzb21lIGNvbnRhY3Qgd2l0aCBvbGQgbWVkaWEgYW5kIGhlIGRpZG5cdTIwMTl0IGxpa2UgaXQsIGJlY2F1c2UgdGhlaXIgYnVzaW5lc3MgaXMgbm90IHJlYWxseSB0cmFuc3BhcmVudCBpbiB0ZXJtcyB3aXRoIHRoZWlyIHJlbGF0aW9uc2hpcHMgd2l0aCB0aGUgYWR2ZXJ0aXNlcnMsIHRoZWlyIGdvaW5nIGZvciB0aGUgbnVtYmVyIG9mIGNsaWNrcy4gSGUgZG9lc25cdTIwMTl0IGxpa2UgdGhlIHN0YXRlIG9mIEtvcmVhbiBtZWRpYSBhbmQgSSB0b3RhbGx5IGFncmVlIHdpdGggaGltLiBTbyBoaXMgZ29hbCBpcyBub3QgaGF2aW5nIGEgbmV3IG1lZGlhIHVuZGVyIGhpcyBiZWx0LiBCdXQgaWYgdGhlcmVcdTIwMTlzIGEgY291cGxlIG9mIG5ldyBtZWRpYSB0aGF0IGNhbiBzaGFrZSB1cCB0aGlzIG1lZGlhIHdvcmxkIGluIEtvcmVhLCBpdCB3aWxsIGJlIG1lYW5pbmdmdWwgZm9yIHVzLlx1MjAxZDwvYmxvY2txdW90ZT5cclxuPGgzPkFmdGVyIHRoZSBpbmN1YmF0b3I8L2gzPlxyXG5UaGUgY2hhbGxlbmdlIGlzIHRvIGZpbmQgZGVlcC1wb2NrZXRlZCBpbnZlc3RvcnMgdG8gY29udGludWUgYWZ0ZXIgdGhlIHNpeCBtb250aHMgaW4gdGhlIGluY3ViYXRvciBhcmUgb3Zlci4gQWx0aG91Z2ggaXRcdTIwMTlzIHRvbyBlYXJseSB0byBzYXkgYW55dGhpbmcgaW4gdGVybXMgb2YgYWN0dWFsIHJlc3VsdHMsIG9uZSBvZiB0aGUgc3RhcnR1cHMgZGlkIGZpbmQgYSBwYXJ0bmVyc2hpcCB3aXRoIGEgbW92aWUgc3R1ZGlvIGZvciBleGFtcGxlOiBcdTIwMWNJbiB0aGF0IHBhcnRpY3VsYXIgY2FzZSwgaXQgd2FzIG5vdCBhbiBpbnZlc3RtZW50LCBidXQgc3BvbnNvcmVkIGNvbnRlbnQgb3Bwb3J0dW5pdGllcywgd2hpY2ggaXMgYSBkZWNlbnQgbW9kZWwgZm9yIHRoZSBtZWRpYS5cdTIwMWRcclxuXHJcbkF0IHRoZSBzYW1lIHRpbWUsIGludmVzdG9ycyBsaWtlIHRvIHNlZSB0aGVzZSBraW5kcyBvZiBpbmR1c3RyeSByZWxhdGlvbnNoaXBzLCBhY2NvcmRpbmcgdG8gU2ltb24sIGFuZCB0aGVyZVx1MjAxOXMgYWxzbyBpbmNyZWFzaW5nbHkgaW50ZXJlc3QgZnJvbSBsZWdhY3kgbWVkaWEgY29tcGFuaWVzOlxyXG48YmxvY2txdW90ZT5cdTIwMWNJdCBkaWRuXHUyMDE5dCBoYXBwZW4geWV0LCBidXQgdGhleSBhcmUgc2hvd2luZyBzb21lIGludGVyZXN0IGluIGJ1eWluZyB0aGVtLiBGb3IgZXhhbXBsZSB0aGUgb3duZXIgb2YgYW4gYWxsLXByaW50IGludGVyaW9yIGRlc2lnbiBtYWdhemluZSwgb25lIG9mIHRoZSBsYXJnZXN0IGluIFNvdXRoIEtvcmVhLCB3YW50ZWQgdG8gZGlnaXRhbGl6ZSB0aGVpciBjb250ZW50LiBTaGUgdG9sZCB1cyBzaGUgZ2F2ZSB1cCBiZWNhdXNlIHRoZXJlIHdhcyBhIGh1Z2UgcmVzaXN0YW5jZSBmcm9tIGhlciBwYXBlci1iYXNlZCBlZGl0b3JzLiBTaGUgd2FzIGxvb2tpbmcgZm9yIG5ldyBtZWRpYSBlZGl0b3JzIHRvIHdvcmsgb24gdGhpcyBpbnN0ZWFkLiBUaGUgZGVhbCBkaWRuXHUyMDE5dCBnbyB0aHJvdWdoLCBidXQgaXQgc2hvd3MgYSBjaGFuZ2UgaW4gdGhpbmtpbmcuXHUyMDFkPC9ibG9ja3F1b3RlPlxyXG5UaGlzIGlzIGFuIGVuY291cmFnaW5nIHNpZ24gYXMgTWVkaWF0aSBob3BlcyB0byBzaGFrZSB1cCB0aGUgbGVnYWN5IG1lZGlhIGxhbmRzY2FwZSBpbiBTb3V0aCBLb3JlYS4gSG93ZXZlciwgc28gZmFyIHRoZSBjaGFuZ2Ugc2VlbXMgdG8gYmUgY29taW5nIHRvIGxlZ2FjeSBtZWRpYSB0aHJvdWdoIGdsb2JhbCBjb3Jwb3JhdGlvbnMsIGxpa2UgRGFpbHlNb3Rpb24gYW5kIFZJQ0UuIEFzIHRoZXkncmUgbG9va2luZyB0byBzZXQgdXAgS29yZWFuIG9mZmljZXMsIHRoZXkgcmVhY2ggb3V0IHRvIG5ldyBtZWRpYSBpbml0aWF0aXZlcyBsaWtlIE1lZGlhdGkuXHJcblxyXG5DT05UQUNUIFBPSU5UXHJcbjxpbWcgY2xhc3M9XCJhbGlnbm5vbmUgc2l6ZS1mdWxsIHdwLWltYWdlLTExNzM5XCIgc3JjPVwiaHR0cHM6Ly9nYW1pLndhbi1pZnJhLm9yZy93cC1jb250ZW50L3VwbG9hZHMvMjAxOC8wOC9TaW1vbi1QYXJrLmpwZWdcIiBhbHQ9XCJcIiB3aWR0aD1cIjIwMFwiIGhlaWdodD1cIjI1MFwiIC8+XHJcblNpbW9uIFBhcmssIENvbnRlbnQgTGFiIFN0cmF0ZWdpc3QsIE1lZGlhdGlcclxuV2ViOiA8YSBocmVmPVwiaHR0cDovL21lZGlhdGkua3IvXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5odHRwOi8vbWVkaWF0aS5rci88L2E+XHJcbkZhY2Vib29rOiA8YSBocmVmPVwiaHR0cHM6Ly93d3cuZmFjZWJvb2suY29tL21lZGlhdGkua3IvXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5AbWVkaWF0aS5rcjwvYT5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMi8zXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48aDM+QXV0aG9yPC9oMz5cclxuW3NpbXBsZS1hdXRob3ItYm94XVsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XSIsInBvc3RfdGl0bGUiOiJNZWRpYXRpOiBpbmN1YmF0aW5nIG5ldyBtZWRpYSBzdGFydHVwcyB0byBzaGFrZSB1cCB0aGUgbGVnYWN5IG1lZGlhIGxhbmRzY2FwZSIsInBvc3RfbGluayI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9tZWRpYXRpLWluY3ViYXRpbmctbmV3LW1lZGlhLXN0YXJ0dXBzLXRvLXNoYWtlLXVwLXRoZS1sZWdhY3ktbWVkaWEtbGFuZHNjYXBlLyIsInBvc3RfZmVhdHVyZWRfaW1hZ2UiOiI8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIk1lZGlhdGk6IGluY3ViYXRpbmcgbmV3IG1lZGlhIHN0YXJ0dXBzIHRvIHNoYWtlIHVwIHRoZSBsZWdhY3kgbWVkaWEgbGFuZHNjYXBlXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMjVcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxOC8wOC8yMTc0Mjk4Nl8xNjA3NzYxMzc5Mjk0NTUzXzI1ODA5NjEzMTg3MzczMTA1OTZfbi0zMDB4MjI1LmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6Iklubm92YXRpb24gQ2FzZSwgTWVkaWEgbGFicyIsInBvc3RfdGFncyI6ImJ1c2luZXNzIG1vZGVscywgY29udGVudCwgaW5jdWJhdG9yLCBQcm9kdWN0IEZpZWxkLCBTb3V0aCBLb3JlYSwgc3RhcnR1cHMiLCIlX3ZjX3Bvc3Rfc2V0dGluZ3MlIjp7InZjX2dyaWRfaWQiOltdfSwiJV9lZGl0X2xvY2slIjoiMTUzNTAxMTczNToxMDEiLCIlX2VkaXRfbGFzdCUiOiIxMDEiLCIlc2xpZGVfdGVtcGxhdGUlIjoiZGVmYXVsdCIsIiVfd3BiX3ZjX2pzX3N0YXR1cyUiOiJ0cnVlIiwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6IlNlb3VsLCBTb3V0aCBLb3JlYSIsIiVfd3BnbXBfbWV0YWJveF9sYXRpdHVkZSUiOiIzNy41NjY1MzUiLCIlX3dwZ21wX21ldGFib3hfbG9uZ2l0dWRlJSI6IjEyNi45Nzc5NjkxOTk5OTk5NiIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiMlwiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6Ik47IiwiJV93cGdtcF9tZXRhYm94X3RheG9tb21pZXNfdGVybXMlIjoiTjsiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6Ik47IiwiJV9rbGVvX3RyYW5zcGFyZW50X21lbnVfY29sb3IlIjoid2hpdGUiLCIlX2tsZW9fdGl0bGVfY2hlY2tib3glIjoiMSIsIiVfa2xlb190aXRsZV9jb2xvciUiOiIjIiwiJV9rbGVvX3RpdGxlX2JnJSI6IiwgcmVwZWF0LCBpbmhlcml0LCBzY3JvbGwsIGxlZnQgdG9wIiwiJV9rbGVvX3RpdGxlX2JnX2NvbG9yJSI6IiMiLCIlX3lvYXN0X3dwc2VvX2NvbnRlbnRfc2NvcmUlIjoiOTAiLCIlX3lvYXN0X3dwc2VvX3ByaW1hcnlfY2F0ZWdvcnklIjoiNjkiLCIlX3RodW1ibmFpbF9pZCUiOiIxMTczNSIsIiVfamV0cGFja19yZWxhdGVkX3Bvc3RzX2NhY2hlJSI6eyI2MjM5M2IyNDJjN2E1NjE3NzRmOGViZmY1YzFjMDU2NSI6eyJleHBpcmVzIjoxNTQ1NTA5NjAwLCJwYXlsb2FkIjpbeyJpZCI6MTE4MzN9LHsiaWQiOjEwNzgzfSx7ImlkIjoxMTU1M31dfX0sIiVzYmdfc2VsZWN0ZWRfc2lkZWJhciUiOiIwIiwiJXNiZ19zZWxlY3RlZF9zaWRlYmFyX3JlcGxhY2VtZW50JSI6IjAiLCJ0YXhvbm9teT1jYXRlZ29yeSI6Iklubm92YXRpb24gQ2FzZSwgTWVkaWEgbGFicyIsInRheG9ub215PXBvc3RfdGFnIjoiYnVzaW5lc3MgbW9kZWxzLCBjb250ZW50LCBpbmN1YmF0b3IsIFByb2R1Y3QgRmllbGQsIFNvdXRoIEtvcmVhLCBzdGFydHVwcyJ9LCJpY29uIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTgvMDIvbWFya2VyLTEucG5nIn0sImlkIjoxMTczMiwiaW5mb3dpbmRvd19kaXNhYmxlIjpmYWxzZX0seyJzb3VyY2UiOiJwb3N0IiwidGl0bGUiOiJPdWVzdCBNXHUwMGU5ZGlhbGFiOiBhIGNsdXN0ZXIgYW5kIGluZGVwZW5kZW50IG1lZGlhIGxhYiB0aGF0IHN1cHBvcnRzIHRoZSByZWdpb25hbCBkaWdpdGFsIHRyYW5zaXRpb24iLCJpbmZvd2luZG93X2NvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIk91ZXN0IE1cdTAwZTlkaWFsYWI6IGEgY2x1c3RlciBhbmQgaW5kZXBlbmRlbnQgbWVkaWEgbGFiIHRoYXQgc3VwcG9ydHMgdGhlIHJlZ2lvbmFsIGRpZ2l0YWwgdHJhbnNpdGlvblwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTgvMDgvMkh5YkxhYlJjaXRzSW50ZXJhY3RpZnNSZW5uZXMyMDE2LTYwMHg0MDAtMzAweDIwMC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1wYWRkaW5nLWNvbnRlbnRfMjBcIj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1tZXRhIGZjLWl0ZW0tc2Vjb25kYXJ5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2UgZmMtdGV4dC1jZW50ZXJcIj5Jbm5vdmF0aW9uIENhc2UsIE1lZGlhIGxhYnM8L2Rpdj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS10aXRsZSBmYy1pdGVtLXByaW1hcnktdGV4dC1jb2xvciBmYy10ZXh0LWNlbnRlclwiPk91ZXN0IE1cdTAwZTlkaWFsYWI6IGEgY2x1c3RlciBhbmQgaW5kZXBlbmRlbnQgbWVkaWEgbGFiIHRoYXQgc3VwcG9ydHMgdGhlIHJlZ2lvbmFsIGRpZ2l0YWwgdHJhbnNpdGlvbjwvZGl2PlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2VcIj5cclxuICAgICAgICAgICAgT3Vlc3QgTVx1MDBlOWRpYWxhYiBicmluZ3MgdG9nZXRoZXIgYSB2YXJpZXR5IG9mIGFjdG9ycyBhcm91bmQgZGlnaXRhbCBpbm5vdmF0aW9uIHByb2plY3RzIGluIHRoZSBGcmVuY2ggcmVnaW9ucyBQYXlzIGRlIGxhIExvaXJlIGFuZCBCcmV0YWduZS4gXHJcbiAgICAgICAgPC9kaXY+XHJcbjxhIGhyZWY9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvb3Vlc3QtbWVkaWFsYWItYS1jbHVzdGVyLWFuZC1pbmRlcGVuZGVudC1tZWRpYS1sYWItdGhhdC1zdXBwb3J0cy10aGUtcmVnaW9uYWwtZGlnaXRhbC10cmFuc2l0aW9uL1wiPlJlYWQgbW9yZTwvYT5cclxuICAgIDwvZGl2PlxyXG4gICAgPC9kaXY+XHJcbjwvZGl2PlxyXG5cclxuIiwiY29udGVudCI6Ik91ZXN0IE1cdTAwZTlkaWFsYWIgYnJpbmdzIHRvZ2V0aGVyIGEgdmFyaWV0eSBvZiBhY3RvcnMgYXJvdW5kIGRpZ2l0YWwgaW5ub3ZhdGlvbiBwcm9qZWN0cyBpbiB0aGUgRnJlbmNoIHJlZ2lvbnMgUGF5cyBkZSBsYSBMb2lyZSBhbmQgQnJldGFnbmUuICIsImFkZHJlc3MiOiJOYW50ZXMsIEZyYW5jZSIsImxvY2F0aW9uIjp7ImxhdCI6IjQ3LjIxODM3MSIsImxuZyI6Ii0xLjU1MzYyMTAwMDAwMDAyMSIsIm9uY2xpY2tfYWN0aW9uIjoibWFya2VyIiwicmVkaXJlY3RfcGVybWFsaW5rIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL291ZXN0LW1lZGlhbGFiLWEtY2x1c3Rlci1hbmQtaW5kZXBlbmRlbnQtbWVkaWEtbGFiLXRoYXQtc3VwcG9ydHMtdGhlLXJlZ2lvbmFsLWRpZ2l0YWwtdHJhbnNpdGlvbi8iLCJ6b29tIjoyLCJleHRyYV9maWVsZHMiOnsicG9zdF9leGNlcnB0IjoiT3Vlc3QgTVx1MDBlOWRpYWxhYiBicmluZ3MgdG9nZXRoZXIgYSB2YXJpZXR5IG9mIGFjdG9ycyBhcm91bmQgZGlnaXRhbCBpbm5vdmF0aW9uIHByb2plY3RzIGluIHRoZSBGcmVuY2ggcmVnaW9ucyBQYXlzIGRlIGxhIExvaXJlIGFuZCBCcmV0YWduZS4gIiwicG9zdF9jb250ZW50IjoiW3ZjX3Jvd11bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjIvM1wiXVt2Y19jb2x1bW5fdGV4dF1cclxuPGgxPk91ZXN0IE1cdTAwZTlkaWFsYWI6IGEgY2x1c3RlciBhbmQgaW5kZXBlbmRlbnQgbWVkaWEgbGFiIHRoYXQgc3VwcG9ydHMgdGhlIHJlZ2lvbmFsIGRpZ2l0YWwgdHJhbnNpdGlvbjwvaDE+XHJcbjxlbT5UaGlzIGFydGljbGUgd2FzIG9yaWdpbmFsbHkgcHVibGlzaGVkIG9uIDxhIGhyZWY9XCJodHRwczovL3d3dy5tZXRhLW1lZGlhLmZyLzIwMTgvMDcvMTkvb3Vlc3QtbWVkaWFsYWItdW4tY2x1c3Rlci1ldC1sYWJvcmF0b2lyZS1kZXMtbWVkaWFzLXF1aS1hY2NvbXBhZ25lLWxlcy1hY3RldXJzLXJlZ2lvbmF1eC1kYW5zLWxldXItdHJhbnNpdGlvbi1udW1lcmlxdWUuaHRtbFwiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+TVx1MDBlOXRhLU1lZGlhPC9hPiwgYXMgcGFydCBvZiBhbiBlZGl0b3JpYWwgcGFydG5lcnNoaXAgYmV0d2VlbiBNXHUwMGU5dGEtTWVkaWEgYW5kIFdBTi1JRlJBLiBUaGUgaW50ZXJ2aWV3IHdhcyBjb25kdWN0ZWQgYnkgRnJhblx1MDBlN29pcyBGbHVociwgRnJhbmNlIFRcdTAwZTlsXHUwMGU5dmlzaW9ucywgUHJvc3BlY3RpdmUgYW5kIE1lZGlhIExhYiBcdTAwYTkgWzIwMThdIEFsbCByaWdodHMgcmVzZXJ2ZWQuPC9lbT5cclxuXHJcbjxzdHJvbmc+V2l0aCBhIGdlb2dyYXBoaWNhbCBmb2N1cyBvbiBXZXN0IEZyYW5jZSwgT3Vlc3QgTVx1MDBlOWRpYWxhYiBicmluZ3MgdG9nZXRoZXIgYSB2YXJpZXR5IG9mIGFjdG9ycyBhcm91bmQgZGlnaXRhbCBpbm5vdmF0aW9uIHByb2plY3RzIGluIHRoZSByZWdpb25zIFBheXMgZGUgbGEgTG9pcmUgYW5kIEJyZXRhZ25lLjwvc3Ryb25nPlxyXG5cclxuQWZ0ZXIgaXQgd2FzIGNyZWF0ZWQgaW4gMjAxMiwgdGhlIGxhYiBuZWVkZWQgc29tZSB0aW1lIHRvIG1hdHVyZSwgYXNzZW1ibGUgYSBzdWZmaWNpZW50IG51bWJlciBvZiBwZW9wbGUsIGFuZCBwdXQgaW4gcGxhY2UgYSByb2FkIG1hcC4gSXQgc3RhcnRlZCBpdHMgYWN0aXZpdGVzIGluIDIwMTMsIGFyb3VuZCBmb3VyIHN0cmF0ZWdpYyBheGVzIHRoYXQgcmVtYWluIHRoZSBwaWxsYXJzIG9mIHRoZSBwcm9qZWN0IHRvZGF5OlxyXG48dWw+XHJcbiBcdDxsaT5UaGUgYW1iaXRpb24gdG8gZGV2ZWxvcCB0aGUgc2tpbGxzIG9mIHRoZSB0ZWFtcyBpbnZvbHZlZCBhbmQgdG8gY3JlYXRlIHN5bmVyZ2llcyBiZXR3ZWVuIGRpZmZlcmVudCBwcm9mZXNzaW9ucy4gVGhpcyBpcyBhIHNwZWNpZmljIGNoYWxsZW5nZSBpbiB0aGUgbWVkaWEgaW5kdXN0cnksIHdoZXJlIGl0IGhhcyBiZWNvbWUgZXNzZW50aWFsIHRvIGV4cGVyaW1lbnQgd2l0aCBkZXZlbG9wZXJzIGFuZCBkZXNpZ25lcnMgZm9yIGV4YW1wbGUuPC9saT5cclxuIFx0PGxpPlJlc2VhcmNoIGludG8gbmV3IGJ1c2luZXNzIG1vZGVscyBhbmQgc2hhcmluZyBiZXN0IHByYWN0aWNlcy4gVGhlIGdvYWwgaXMgdG8gc3VwcG9ydCBjb21wYW5pZXMgaW4gdGhlaXIgZGV2ZWxvcG1lbnQgb3IgY3JlYXRpb24uIFRoaXMgaGFzIGFsc28gbGVkIE91ZXN0IE1cdTAwZTlkaWFsYWIgdG8gbGF1bmNoIGl0cyBpbmN1YmF0b3IgTk1jdWJlIHRoaXMgeWVhci48L2xpPlxyXG4gXHQ8bGk+Q29tbXVuaWNhdGlvbiB0aGF0IHBsYWNlcyB0aGUgc3BvdGxpZ2h0IG9uIG5vdGV3b3J0aHkgaW5ub3ZhdGlvbiwgZXNwZWNpYWxseSBvbiBhIGxvY2FsIGxldmVsIC0gd2hldGhlciBpdFx1MjAxOXMgbWVkaWEsIHNjaG9vbHMsIHN0YXJ0LXVwcyBvciBldmVuIGNvbW11bml0aWVzLjwvbGk+XHJcbiBcdDxsaT5PcGVuIGlubm92YXRpb24gaW4gdGhlIGZvcm0gb2Ygc2hvcnQgYW5kIG1pZHRlcm0gcHJvamVjdHMgYWltZWQgYXQgYnJpbmdpbmcgYWN0b3JzIGNsb3NlciB0b2dldGhlciBhbmQgY3JlYXRpbmcgY29sbGFib3JhdGlvbnMgYXJvdW5kIGRpZ2l0YWwgdG9waWNzLiBUaGlzIGFsbG93cyB0aGUgbWVkaWEgbGFiIHRvIGhpZ2hsaWdodCBpdHMgdW5pcXVlIGNoYXJhY3RlcmlzdGljIGFzIGFuIG9wZW4gbGFiLCB3aGljaCBpcyBub3QgY29ubmVjdGVkIHRvIGFueSBvbmUgbWVkaWEgZ3JvdXAgaW4gcGFydGljdWxhci48L2xpPlxyXG48L3VsPlxyXG48aDM+QnVpbGRpbmcgYSBjb21tdW5pdHk8L2gzPlxyXG5JbiBhZGRpdGlvbiB0byBhIHNtYWxsIHRlYW0gb2YgZm91ciBlbXBsb3llZXMsIE91ZXN0IE1cdTAwZTlkaWFsYWIgYmVuZWZpdHMgZnJvbSB0aGUgdm9sdW50YXJ5IHN1cHBvcnQgb2YgaXRzIDEzMCBtZW1iZXJzOlxyXG48YmxvY2txdW90ZT5cdTIwMWNUaGUgdGltZSBvdXIgbWVtYmVycyBkZWRpY2F0ZSB0byB0aGUgYWN0aXZpdGllcyB3ZSBvcmdhbmlzZSByZXByZXNlbnRzIHRoZSBlcXVpdmFsZW50IG9mIGF0IGxlYXN0IHR3byBmdWxsLXRpbWVycyxcdTIwMWQgc2F5cyBPdWVzdCBNXHUwMGU5ZGlhbGFiIERpcmVjdG9yIEp1bGllbiBLb3N0clx1MDBlOGNoZS4gXHUyMDFjVGhlIGNsdXN0ZXIgYnJpbmdzIHRvZ2V0aGVyIG1vc3Qgb2YgdGhlIGxvY2FsIG1lZGlhIGluIHRoZSByZWdpb24gLSBpbmNsdWRpbmcgT3Vlc3QtRnJhbmNlLCBMZSBUXHUwMGU5bFx1MDBlOWdyYW1tZSwgRnJhbmNlIDMsIEZyYW5jZSBCbGV1LCBsb2NhbCB0ZWxldmlzaW9uIHN0YXRpb25zLCBjb21tdW5pdHkgcmFkaW8gXHUyMDEzIGJ1dCBhbHNvIHRoZSBjb21tdW5pdGllcywgY29udGVudCBhZ2VuY2llcywgc3RhcnR1cHMsIGpvdXJuYWxpc20gc2Nob29scywgY29tbXVuaWNhdGlvbiBwcm9ncmFtcywgZGVzaWduIGFuZCBjb21wdXRlciBzY2llbmNlIHNjaG9vbHMuXHUyMDFkPC9ibG9ja3F1b3RlPlxyXG5UbyBnZXQgdG8gdGhpcyBwb2ludCwgaXQgd2FzIG5lY2Vzc2FyeSB0byBmaW5kIGEgY29tbW9uIGdyb3VuZDogdGhlIGRpZ2l0YWwuIEFsdGhvdWdoIG5vdCBldmVyeWJvZHkgc3RhcnRzIGF0IHRoZSBzYW1lIGxldmVsLCBlbXBoYXNpc2VzIEp1bGllbjogXHUyMDFjV2hpbGUgc29tZSBvbmx5IGp1c3QgZ290IHN0YXJ0ZWQgd2l0aCB2aWRlbyBmb3IgZXhhbXBsZSwgb3RoZXJzIGFyZSBwYXJ0IG9mIGNvbXBhbmllcyB3aGVyZSB0aGlzIGhhcyBiZWVuIHRoZSBjb3JlIG9mIHRoZWlyIHByb2Zlc3Npb24gZm9yIGEgbG9uZyB0aW1lIGFscmVhZHkuXHUyMDFkXHJcblxyXG5UaGlzIGxlZCB0byB0aGUgY3JlYXRpb24gb2YgdGhlIE1cdTAwZTlkaWFsYWIgU3BlZWQgVHJhaW5pbmcgZXZlbnQsIGR1cmluZyB3aGljaCBwcm9mZXNzaW9uYWxzIHRoYXQgbWFzdGVyIGNlcnRhaW4gZGlnaXRhbCB0b29scyBzaGFyZSB0aGVpciBza2lsbHMgYW5kIGJlc3QgcHJhY3RpY2VzIHdpdGggdGhlaXIgcGVlcnMuIFRoZSBwb3dlciBvZiBzdWNoIGEgY29tbXVuaXR5IGlzIGFsc28gdGhhdCBpdCBvcGVucyB1cCBhY2Nlc3MgdG8gZmVlZGJhY2sgZnJvbSBtZW1iZXJzLiBBcyB0aGV5IHZvaWNlIHRoZWlyIG5lZWRzIGR1cmluZyB0aGUgZXhwZXJpbWVudGF0aW9ucywgdGhleSBhbGxvdyB0aGUgbWVkaWEgbGFiIHRvIHJldGhpbmsgYW5kIHJlZm9jdXMgaXRzIHN0cmF0ZWd5IGFjY29yZGluZ2x5LlxyXG48aDM+VHJ1c3Q8L2gzPlxyXG5JdFx1MjAxOXMgbm90IHNlbGYtZXZpZGVudCBob3dldmVyIGZvciBhY3RvcnMgdGhhdCBhcmUgYXQgdGltZXMgY29tcGV0aW5nIHRvIHNoYXJlIGxpa2UgdGhpcywgc2F5cyBKdWxpZW46XHJcbjxibG9ja3F1b3RlPlx1MjAxY1doZW4geW91IGNyZWF0ZSBhIGxhYiBsaWtlIHRoYXQsIHBlb3BsZSBuZWVkIHRpbWUgdG8gZ2V0IHRvIGtub3cgZWFjaCBvdGhlciwgc3RhcnQgdHJ1c3RpbmcgZWFjaCBvdGhlciwgYW5kIGFjY2VwdCB0byBzaGFyZSB0aGVpciBjaGFsbGVuZ2VzIHdpdGggZWFjaCBvdGhlci4gU29tZXRpbWVzIHlvdSBoYXZlIHRvIGFjY2VwdCB0byBsYXkgeW91cnNlbGYgYmFyZSBvbiBjZXJ0YWluIHF1ZXN0aW9ucy5cdTIwMWQ8L2Jsb2NrcXVvdGU+XHJcbkluIHJlc3BvbnNlIHRvIHRoaXMgY2hhbGxlbmdlLCB0aGUgTGFiIG9yZ2FuaXNlZCBudW1lcm91cyB3b3Jrc2hvcHMgdG8gYWxsb3cgZXZlcnlvbmUgdG8gZXhjaGFuZ2UsIHByb3Bvc2UgdGhlaXIgcHJvamVjdHMsIGFuZCBzaGFyZSB0aGVpciB3aXNoZXMsIGJ1dCBhbHNvIHRvIGdldCBmZWVkYmFjay4gQSBncmVhdCB3YXkgdG8gbWFrZSBldmVyeW9uZSBhd2FyZSBvZiB0aGUgaW1wb3J0YW5jZSBvZiB0aGlzIGNvbGxlY3RpdmUgZWZmb3J0OlxyXG48YmxvY2txdW90ZT5cdTIwMWNUb2RheSBwZW9wbGUgdGFsayB0byB1cyBtdWNoIG1vcmUgZWFzaWx5LiBUaGV5IHNoYXJlIHRoZWlyIGNvbmNlcm5zIHdpdGggdXMgYW5kIGVudHJ1c3QgdXMgd2hhdCB0aGV5IHdvdWxkIGxpa2UgdG8gZG8uIEl0XHUyMDE5cyB0aGVuIHVwIHRvIHVzIHRvIGdldCB0aGUgcmlnaHQgcGVvcGxlIGFyb3VuZCB0aGUgdGFibGUsIHNvIHRoZXkgYWxsIGdldCBleGNpdGVkIGFib3V0IHdvcmtpbmcgdG9nZXRoZXIuXHUyMDFkPC9ibG9ja3F1b3RlPlxyXG48aDM+RGV2ZWxvcGluZyBhIG1ldGhvZDwvaDM+XHJcbkl0IGFsbCBzdGFydHMgd2l0aCBhbiBpZGVhdGlvbiBwaGFzZSBkdXJpbmcgd2hpY2ggdGhlIGxhYiB1c2VzIGRlc2lnbi10aGlua2luZyBtZXRob2RzIGZvY3VzZWQgb24gdGhlIHVzZXIuIER1cmluZyB0aGlzIHBoYXNlLCBhbGwgb2YgdGhlIHByb2Zlc3Npb25zIGFyZSBwbGFjZWQgYXQgdGhlIHNhbWUgbGV2ZWw6XHJcbjxibG9ja3F1b3RlPlx1MjAxY1dlIGRvblx1MjAxOXQgZ28gaW50byBhIHNlZ21lbnRlZCBwcm9kdWN0aW9uIGxpbmUgcmlnaHQgYXdheS4gV2Ugc3RhcnQgdGhpbmtpbmcgYWJvdXQgdGhlIHByb2plY3QgZmlyc3QsIGFuZCBldmVyeW9uZSBpcyBhbGxvd2VkIHRvIGxlYXZlIGhpcyB1c3VhbCBmaWVsZC4gQSBjb21wdXRlciBzY2llbnRpc3QgY2FuIGV4cHJlc3MgaGltc2VsZiBvbiBhbiBlZGl0b3JpYWwgZGltZW5zaW9uOyBhIGpvdXJuYWxpc3Qgb24gdGhlIGludGVyZmFjZS4gVGhpcyBjcmVhdGVzIHVuaXF1ZSBjb252ZXJzYXRpb25zIGFuZCB0YWtlcyB0aGUgdGVhbXMgb3V0IG9mIHRoZWlyIGNvbWZvcnQgem9uZXMuXHUyMDFkPC9ibG9ja3F1b3RlPlxyXG5OZXh0LCB0aGUgdGVhbXMgY3JlYXRlIGEgbW9kZWwgYW5kIGEgcHJvdG90eXBlIHRoYXQgdGhleSB0ZXN0IGluIG9yZGVyIHRvIGNvbmZyb250IHRoZW1zZWx2ZXMgd2l0aCB0aGUgdXNlci4gVGhlbiBldmVyeWJvZHkgZ29lcyBiYWNrIHRvIGhpcyBvciBoZXIgZXhwZXJ0aXNlLiBUaGlzIGZpcnN0IHBoYXNlIGlzIHJlYWxseSBkaWZmaWN1bHQsIGFjY29yZGluZyB0byBKdWxpZW4sIGJlY2F1c2Ugbm90IGV2ZXJ5b25lIHNwZWFrcyB0aGUgc2FtZSBsYW5ndWFnZTpcclxuPGJsb2NrcXVvdGU+XHUyMDFjV2UgaGF2ZSB0byBhZGFwdCB0byB0aGUgdGhlbWVzIHRoYXQgd2VcdTIwMTlyZSB3b3JraW5nIG9uLiBEb2luZyBkYXRhIGpvdXJuYWxpc20gYW5kIGNyZWF0aW5nIGFuIGFwcGxpY2F0aW9uIGZvciB2YWxvcmlzaW5nIGFyY2hpdmVzIGRvIG5vdCBuZWNlc3NhcmlseSByZXF1aXJlIHRoZSBzYW1lIHNraWxscy5cdTIwMWQ8L2Jsb2NrcXVvdGU+XHJcbkFsdGhvdWdoIGl0XHUyMDE5cyBhIHRpbWUtY29uc3VtaW5nIG1ldGhvZCwgaXQgaGFzIHByb3ZlbiBpdHNlbGYgaW5kaXNwZW5zYWJsZS4gR29pbmcgdGhyb3VnaCB0aGVzZSBwaGFzZXMgdG9vIHF1aWNrbHkgd291bGQgbWVhbiByZXByb2R1Y2luZyB0aGUgc2FtZSBvbGQgd2F5cyBvZiBwcm9kdWNpbmcgY29udGVudCwgd2l0aCBhIGZyYWdtZW50ZWQgdHJhbnNtaXNzaW9uIG9mIGluZm9ybWF0aW9uLiBUaGlzIHdvdWxkIHJlc3VsdCBpbiBwcm9qZWN0cyB0aGF0IGFyZSBpbmNhcGFibGUgb2YgZ29pbmcgb2ZmIHRoZSBiZWF0aW5nIHRyYWNrLlxyXG48aDM+QWRhcHRpbmcgdG8gY29uc3RyYWludHM8L2gzPlxyXG5JbiBvcmRlciB0byB3b3JrIHdpdGggbWVkaWEgeW91IGhhdmUgdG8gYmUgYWJsZSB0byBpZGVudGlmeSBhbmQgZGVhbCB3aXRoIHNvbWUgb2YgdGhlIGVsZW1lbnRzIHRoYXQgYXJlIGxpa2VseSB0byBob2xkIHRoZW0gYmFjayBpbiB0aGVpciBpbm5vdmF0aW9uIGFtYml0aW9uczpcclxuPGJsb2NrcXVvdGU+XHUyMDFjV2Ugc3RhcnRlZCBvdXQgd2l0aCByZXNlYXJjaCBsYWJzIGluaXRpYWxseS4gSXQgd2FzIGhhcmQgdG8gZ2V0IG1lZGlhIG9uIGJvYXJkIHRoYXQgZG8gbm90IGFsd2F5cyBoYXZlIHRoZSB0aW1lLCB0aGUgbWVhbnMsIG9yIHRoaXMgUiZhbXA7RCBjdWx0dXJlLCBhbmQgd2hvIHdhbnQgdG8gZ2V0IHJlc3VsdHMgd2l0aGluIHNob3J0ZXIgdGltZWZyYW1lcy5cdTIwMWQ8L2Jsb2NrcXVvdGU+XHJcbkluIHJlc3BvbnNlIHRvIHRoaXMsIHRoZSBNZWRpYSBsYWIgdGVhbSBkcmV3IGluc3BpcmF0aW9uIGZyb20gaGFja2F0aG9ucyBhbmQgY3JlYXRlZCBIeWJsYWJzLiBUaGV5IGJyaW5nIHRvZ2V0aGVyIGEgaHVuZHJlZCBzdHVkZW50cyBmcm9tIHZhcmlvdXMgZGlzY2lwbGluZXMgKElULCBkZXNpZ24sIG1lZGlhKSBpbnRvIHdvcmtncm91cHMgdGhhdCB0YWNrbGUgcHJvamVjdHMgcHJvcG9zZWQgYnkgcHJpdmF0ZSBtZWRpYSwgY29tbXVuaXR5IG1lZGlhIGFuZCBjb21tdW5pY2F0aW9uIHByb2Zlc3Npb25hbHMuIFNvIGZhciwgMTYgSHlibGFicyBoYXZlIHRha2VuIHBsYWNlICgzIHRvIDQgYSB5ZWFyKSwgb24gdG9waWNzIHJhbmdpbmcgZnJvbSBkYXRhIGpvdXJuYWxpc20gYW5kIHZhbG9yaXNpbmcgYXJjaGl2ZXMgdG8gaW50ZXJhY3RpdmUgc3Rvcnl0ZWxsaW5nIGFuZCBsaXZlIGNvdmVyYWdlIG9mIGV2ZW50czpcclxuPGJsb2NrcXVvdGU+XHUyMDFjWW91IGhhdmUgdG8gdGhlIGZpbmQgcGVvcGxlIHdobyBhcmUgZXhjaXRlZCBhYm91dCB0aGVzZSB0aGluZ3MsIGJ1dCB5b3UgYWxzbyBoYXZlIHRvIHRyaWdnZXIgZW50aHVzaWFzbSB3aXRoaW4gb3JnYW5pc2F0aW9ucy4gSW4gdGhlIGJlZ2lubmluZywgcGVvcGxlIHdvdWxkIHRha2UgaG9saWRheXMgb3IgcGFydGljaXBhdGVkIHdoZW4gdGhleSBoYWQgYSBkYXkgb2ZmLiBXZSBzYWlkIHRvIG91cnNlbHZlcyAnd2UgaGF2ZSBhIHByb2JsZW0nLiBTbyB3ZSBraWNrZWQgaXQgdXAgYSBmZXcgbm90Y2hlcyB0byBjb252aW5jZSB0aGUgdXBwZXIgZmxvb3JzIHRoYXQgdGhleSBzaG91bGQgZnJlZSB0aGVpciB0ZWFtcyBmb3IgdGhpcy5cdTIwMWQ8L2Jsb2NrcXVvdGU+XHJcblVuZm9ydHVuYXRlbHksIHRoZSBtZWRpYSBlY29ub215IGRvZXNuXHUyMDE5dCBhbHdheXMgYWxsb3cgZm9yIHRoaXMuIEl0IHJlbWFpbnMgZGlmZmljdWx0IHRvIG1ha2UgcGVvcGxlIGFjY2VwdCB0aGUgZXhwZXJpbWVudGFsIG5hdHVyZSBvZiBhIHByb2plY3QgaW4gYSB0ZW5zZSBmaW5hbmNpYWwgZW52aXJvbm1lbnQgd2hlcmUgZXZlcnkgaW52ZXN0bWVudCBoYXMgdG8gbGVhZCB0byBjb25jcmV0ZSByZXN1bHRzIHF1aWNrbHk6XHJcbjxibG9ja3F1b3RlPlx1MjAxY0l0IGhhcHBlbnMgdGhhdCBtZWRpYSB0ZWxsIHVzIFx1MjAxOG9uZSBvZiBvdXIgam91cm5hbGlzdHMgd2lsbCBqb2luIGZvciAzIGRheXMsIGJ1dCB5b3UgaGF2ZSB0byBndWFyYW50ZWUgdXMgd2VcdTIwMTlsbCBnZXQgYSByZXN1bHQhXHUyMDE5IEJ1dCB3aGVuIHdlIGV4cGVyaW1lbnQsIHdlIGNhblx1MjAxOXQgYXBwbHkgdGhpcyBraW5kIG9mIHByZXNzdXJlIFx1MjAxMyBuZWl0aGVyIG9uIHRoZSB0ZWFtcyBub3Igb24gdGhlIHN0dWRlbnRzIHRoYXQgd29yayB0b2dldGhlci4gWW91IGhhdmUgdG8gdHJ5IHRvIGxldCBnbyBhbmQgYWNjZXB0IHRoZSBwb3NzaWJpbGl0eSBvZiBmYWlsdXJlLlx1MjAxZDwvYmxvY2txdW90ZT5cclxuPGgzPkEgbWF0dGVyIG9mIGdvb2QgdGltaW5nPC9oMz5cclxuVGhlIGRhdGEgam91cm5hbGlzbSBsYWJzIHdlcmUgb25lIG9mIHRoZSBtYWluIHN1Y2Nlc3NlcyBvZiB0aGUgTWVkaWEgTGFiLiBQYXJ0aWNpcGFudHMgbGVhcm5lZCB0byBjb2xsZWN0LCB0cmVhdCBhbmQgdmlzdWFsaXNlIGRhdGEgdG8gdGVsbCBzdG9yaWVzLiBUaGUgbWFqb3JpdHkgb2YgdGhlIHByb2plY3RzIHRoYXQgY2FtZSBvdXQgb2YgdGhlIGhhY2thdGhvbnMgaGF2ZSBiZWVuIHB1Ymxpc2hlZCBhbmQgd2VsbCByZWNlaXZlZCBieSB0aGUgYXVkaWVuY2UuIFNvbWUgd2VyZSBldmVuIGF3YXJkZWQgYW5kIGxlZCB0byB0aGUgY3JlYXRpb24gb2YgZGVkaWNhdGVkIGRhdGEgdGVhbXMsIGxpa2UgdGhvc2UgYXQgVFx1MDBlOWxcdTAwZTlncmFtbWUgYW5kIE91ZXN0LUZyYW5jZTpcclxuPGJsb2NrcXVvdGU+XHUyMDFjSW4gdGhlIGNhc2Ugb2YgVFx1MDBlOWxcdTAwZTlncmFtbWUsIHRoZSBqb3VybmFsaXN0IGNhbWUgd2l0aCBhbiBhbWJpdGlvbjogbWFwIHRoZSB0cmFuc2Zvcm1hdGlvbiBvZiB0aGUgY2l0eSBvZiBCcmVzdC4gSGUgY29sbGVjdHMgZGF0YSBmcm9tIHRoZSByZWxldmFudCBzZXJ2aWNlcywgZHJhd3Mgb24gd2hhdCB3YXMgZG9uZSBvbiB0aGUgY2l0eSBvZiBCZXJsaW4gYW5kIGNvbWVzIHRvIHRoZSBIeWJMYWIgd2hlcmUgaGUgbWVldHMgYSB0ZWFtIG9mIHN0dWRlbnRzIGZyb20gUG9seXRlY2ggKGNvbXB1dGVyKSwgQUdSICh3ZWIgZGVzaWduKSwgYW5kIEF1ZGVuY2lhIFNjaWVuY2VzQ29tIChtZWRpYSkuIEluIGZvdXIgbG9uZyBkYXlzLCB0aGV5IG1hbmFnZSB0byBwcm9kdWNlIGFuZCBwdWJsaXNoIHRoZSBjb250ZW50IG9ubGluZSwgYXNraW5nIGluaGFiaXRhbnRzIGZyb20gQnJlc3Qgd2hhdCB0aGV5IHRoaW5rIGFib3V0IHRoZSB0cmFuc2Zvcm1hdGlvbiBvZiB0aGUgY2l0eS4gSXRcdTIwMTlzIGEgaGl0IGFuZCB0aGUgcHJvamVjdCBjb25zb2xpZGF0ZXMgdGhlIGRlY2lzaW9uIG9mIHRoZSBwcmVzcyBncm91cCBtYW5hZ2VtZW50IHRvIGNyZWF0ZSBhIGRlZGljYXRlZCBkYXRhIGRlcGFydG1lbnQgd2l0aCBhIGZ1bGwtdGltZSBqb3VybmFsaXN0LlwiPC9ibG9ja3F1b3RlPlxyXG5Gb3IgSnVsaWVuIEtvc3RyXHUwMGU4Y2hlLCB0aGUgY3J1Y2lhbCBjaGFsbGVuZ2UgaXMgdG8gZmluZCB0aGUgcmlnaHQgc2NhbGUgYW5kIHRoZSByaWdodCB0aW1pbmc6XHJcbjxibG9ja3F1b3RlPlx1MjAxY0FueXRoaW5nIGFyb3VuZCBkYXRhIHdvcmtlZCBwcmV0dHkgd2VsbCwgYmVjYXVzZSBldmVyeW9uZSBnb3QgaW50byB0aGF0IGFyb3VuZCBtb3JlIG9yIGxlc3MgdGhlIHNhbWUgbW9tZW50LiBUaGVyZSB3YXMgYWxzbyBhIGdyZWF0IHRpbWluZyB3aXRoIHRoZSBvcGVuaW5nIHVwIG9mIHB1YmxpYyBkYXRhIChPcGVuIERhdGEpLCB3aGljaCBicm91Z2h0IHVzIGEgbG90IG9mIG1hdGVyaWFsIGFuZCBpdCB3YXMgYSBtb21lbnQgd2hlcmUgZXh0cmFvcmRpbmFyeSB0b29scyB3ZXJlIGxhdW5jaGVkIGFsbW9zdCBldmVyeSBtb250aCB0byB2aXN1YWxpc2UgdGhpcyBkYXRhLlx1MjAxZDwvYmxvY2txdW90ZT5cclxuT3Vlc3QgTWVkaWFsYWIgaGFzIHRvIGNvbnN0YW50bHkgc3RheSBcdTIwMWNvbiB0aGUgZWRnZVx1MjAxZCwgdG8gZmluZCBuZXcgcGxheWluZyBmaWVsZHMgdGhhdCBhcmUgaW4gbGluZSB3aXRoIGJvdGggdGhlIGNvbnN0cmFpbnRzIG9mIHRoZSBzZWN0b3IgYW5kIHRoZSBsb2NhbCBzY2FsZSwgYXMgd2VsbCBhcyB0aGUgbWF0dXJpdHkgb2YgdGVjaG5vbG9naWVzIGFuZCB0aGVpciBhcHBsaWNhdGlvbnMuXHJcblxyXG4mbmJzcDtcclxuXHJcbkNPTlRBQ1QgUE9JTlRcclxuPGltZyBjbGFzcz1cImFsaWdubm9uZSBzaXplLWZ1bGwgd3AtaW1hZ2UtMTE3MDNcIiBzcmM9XCJodHRwczovL2dhbWkud2FuLWlmcmEub3JnL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE4LzA3L2p1bGllbi1lMTUzMzA1MTU4OTI3MS5qcGdcIiBhbHQ9XCJcIiB3aWR0aD1cIjE3MVwiIGhlaWdodD1cIjIzMVwiIC8+XHJcbkp1bGllbiBLb3N0clx1MDBlOGNoZSwgQ28tZGlyZWN0ZXVyLCBPdWVzdCBGcmFuY2UgTGFiXHJcbldlYjogPGEgaHJlZj1cImh0dHBzOi8vd3d3Lm91ZXN0bWVkaWFsYWIuZnIvXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5odHRwczovL3d3dy5vdWVzdG1lZGlhbGFiLmZyLzwvYT5cclxuVHdpdHRlcjogPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vamtvc3RyZWNoZT9sYW5nPWVuXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5Aamtvc3RyZWNoZTwvYT5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd10iLCJwb3N0X3RpdGxlIjoiT3Vlc3QgTVx1MDBlOWRpYWxhYjogYSBjbHVzdGVyIGFuZCBpbmRlcGVuZGVudCBtZWRpYSBsYWIgdGhhdCBzdXBwb3J0cyB0aGUgcmVnaW9uYWwgZGlnaXRhbCB0cmFuc2l0aW9uIiwicG9zdF9saW5rIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL291ZXN0LW1lZGlhbGFiLWEtY2x1c3Rlci1hbmQtaW5kZXBlbmRlbnQtbWVkaWEtbGFiLXRoYXQtc3VwcG9ydHMtdGhlLXJlZ2lvbmFsLWRpZ2l0YWwtdHJhbnNpdGlvbi8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJPdWVzdCBNXHUwMGU5ZGlhbGFiOiBhIGNsdXN0ZXIgYW5kIGluZGVwZW5kZW50IG1lZGlhIGxhYiB0aGF0IHN1cHBvcnRzIHRoZSByZWdpb25hbCBkaWdpdGFsIHRyYW5zaXRpb25cIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjIwMFwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE4LzA4LzJIeWJMYWJSY2l0c0ludGVyYWN0aWZzUmVubmVzMjAxNi02MDB4NDAwLTMwMHgyMDAuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+IiwicG9zdF9jYXRlZ29yaWVzIjoiSW5ub3ZhdGlvbiBDYXNlLCBNZWRpYSBsYWJzIiwicG9zdF90YWdzIjoiY2x1c3RlciwgZXhwZXJpbWVudHMsIEZyYW5jZSwgSGFja2F0aG9uLCBtdWx0aWRpc2NpcGxpbmFyeSwgcmVnaW9uYWwgam91cm5hbGlzbSwgc3R1ZGVudHMiLCIlX3ZjX3Bvc3Rfc2V0dGluZ3MlIjp7InZjX2dyaWRfaWQiOltdfSwiJV9lZGl0X2xvY2slIjoiMTUzNDI2MDQwODoxMDEiLCIlX2VkaXRfbGFzdCUiOiIxMDEiLCIlc2xpZGVfdGVtcGxhdGUlIjoiZGVmYXVsdCIsIiVfd3BiX3ZjX2pzX3N0YXR1cyUiOiJ0cnVlIiwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6Ik5hbnRlcywgRnJhbmNlIiwiJV93cGdtcF9tZXRhYm94X2xhdGl0dWRlJSI6IjQ3LjIxODM3MSIsIiVfd3BnbXBfbWV0YWJveF9sb25naXR1ZGUlIjoiLTEuNTUzNjIxMDAwMDAwMDIxIiwiJV93cGdtcF9tZXRhYm94X2xvY2F0aW9uX3JlZGlyZWN0JSI6Im1hcmtlciIsIiVfd3BnbXBfbWV0YWJveF9jdXN0b21fbGluayUiOiIiLCIlX3dwZ21wX21hcF9pZCUiOiJhOjE6e2k6MDtzOjE6XCIyXCI7fSIsIiVfd3BnbXBfbWV0YWJveF9tYXJrZXJfaWQlIjoiTjsiLCIlX3dwZ21wX21ldGFib3hfdGF4b21vbWllc190ZXJtcyUiOiJOOyIsIiVfd3BnbXBfZXh0ZW5zaW9uc19maWVsZHMlIjoiTjsiLCIlX2tsZW9fdHJhbnNwYXJlbnRfbWVudV9jb2xvciUiOiJ3aGl0ZSIsIiVfa2xlb190aXRsZV9jb2xvciUiOiIjIiwiJV9rbGVvX3RpdGxlX2JnJSI6IiwgcmVwZWF0LCBpbmhlcml0LCBzY3JvbGwsIGxlZnQgdG9wIiwiJV9rbGVvX3RpdGxlX2JnX2NvbG9yJSI6IiMiLCIlX3lvYXN0X3dwc2VvX2NvbnRlbnRfc2NvcmUlIjoiMzAiLCIlX3lvYXN0X3dwc2VvX3ByaW1hcnlfY2F0ZWdvcnklIjoiNjkiLCIlX2tsZW9fdGl0bGVfY2hlY2tib3glIjoiMSIsIiVfdGh1bWJuYWlsX2lkJSI6IjExNzE3IiwiJV9qZXRwYWNrX3JlbGF0ZWRfcG9zdHNfY2FjaGUlIjp7IjYyMzkzYjI0MmM3YTU2MTc3NGY4ZWJmZjVjMWMwNTY1Ijp7ImV4cGlyZXMiOjE1NDUyOTIyODIsInBheWxvYWQiOlt7ImlkIjoxMDc2Nn0seyJpZCI6MTA3MDR9LHsiaWQiOjEwNjgxfV19fSwiJXNiZ19zZWxlY3RlZF9zaWRlYmFyJSI6IjAiLCIlc2JnX3NlbGVjdGVkX3NpZGViYXJfcmVwbGFjZW1lbnQlIjoiMCIsInRheG9ub215PWNhdGVnb3J5IjoiSW5ub3ZhdGlvbiBDYXNlLCBNZWRpYSBsYWJzIiwidGF4b25vbXk9cG9zdF90YWciOiJjbHVzdGVyLCBleHBlcmltZW50cywgRnJhbmNlLCBIYWNrYXRob24sIG11bHRpZGlzY2lwbGluYXJ5LCByZWdpb25hbCBqb3VybmFsaXNtLCBzdHVkZW50cyJ9LCJpY29uIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTgvMDIvbWFya2VyLTEucG5nIn0sImlkIjoxMTcxNCwiaW5mb3dpbmRvd19kaXNhYmxlIjpmYWxzZX0seyJzb3VyY2UiOiJwb3N0IiwidGl0bGUiOiJSRUQvQUNDSU9OOiBib3RoIGEgZm9ybWFsIGlubm92YXRpb24gbGFiIGFuZCBkYWlseSBleHBlcmltZW50YXRpb24gaW4gdGhlIG5ld3Nyb29tIiwiaW5mb3dpbmRvd19jb250ZW50IjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZ1wiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJSRUQvQUNDSU9OOiBib3RoIGEgZm9ybWFsIGlubm92YXRpb24gbGFiIGFuZCBkYWlseSBleHBlcmltZW50YXRpb24gaW4gdGhlIG5ld3Nyb29tXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMDBcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxOC8wNy9EU0NfOTc2Ni0zMDB4MjAwLmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmdcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXBhZGRpbmctY29udGVudF8yMFwiPlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLW1ldGEgZmMtaXRlbS1zZWNvbmRhcnktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZSBmYy10ZXh0LWNlbnRlclwiPklubm92YXRpb24gQ2FzZSwgTWVkaWEgbGFiczwvZGl2PlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLXRleHQtY2VudGVyXCI+UkVEL0FDQ0lPTjogYm90aCBhIGZvcm1hbCBpbm5vdmF0aW9uIGxhYiBhbmQgZGFpbHkgZXhwZXJpbWVudGF0aW9uIGluIHRoZSBuZXdzcm9vbTwvZGl2PlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2VcIj5cclxuICAgICAgICAgICAgSXQncyBpbXBvcnRhbnQgdG8gaGF2ZSB0aGUgc3BhY2UsIHRoZSByZXNvdXJjZXMgYW5kIHRoZSB0aW1lIHRvIGV4cGVyaW1lbnQgYW5kIGxlYXJuIG9uIGEgZGFpbHkgYmFzaXMgaW4gdGhlIG5ld3Nyb29tLiBcIldlIGRvblx1MjAxOXQgd2FudCB0aGUgTWFrZXIgTGFiIHRvIGJlIHRoZSBvbmx5IHBsYWNlIHdoZXJlIGV4cGVyaW1lbnRhdGlvbiBhbmQgbGVhcm5pbmcgdGFrZSBwbGFjZVwiLCBzYXlzIENoYW5pIEd1eW90LiBcclxuICAgICAgICA8L2Rpdj5cclxuPGEgaHJlZj1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9yZWQtYWNjaW9uLWJvdGgtYS1mb3JtYWwtaW5ub3ZhdGlvbi1sYWItYW5kLWRhaWx5LWV4cGVyaW1lbnRhdGlvbi1pbi10aGUtbmV3c3Jvb20vXCI+UmVhZCBtb3JlPC9hPlxyXG4gICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuPC9kaXY+XHJcblxyXG4iLCJjb250ZW50IjoiSXQncyBpbXBvcnRhbnQgdG8gaGF2ZSB0aGUgc3BhY2UsIHRoZSByZXNvdXJjZXMgYW5kIHRoZSB0aW1lIHRvIGV4cGVyaW1lbnQgYW5kIGxlYXJuIG9uIGEgZGFpbHkgYmFzaXMgaW4gdGhlIG5ld3Nyb29tLiBcIldlIGRvblx1MjAxOXQgd2FudCB0aGUgTWFrZXIgTGFiIHRvIGJlIHRoZSBvbmx5IHBsYWNlIHdoZXJlIGV4cGVyaW1lbnRhdGlvbiBhbmQgbGVhcm5pbmcgdGFrZSBwbGFjZVwiLCBzYXlzIENoYW5pIEd1eW90LiAiLCJhZGRyZXNzIjoiQnVlbm9zIEFpcmVzLCBBcmdlbnRpbmEiLCJsb2NhdGlvbiI6eyJsYXQiOiItMzQuNjAzNjg0NDAwMDAwMDEiLCJsbmciOiItNTguMzgxNTU5MTAwMDAwMDA0Iiwib25jbGlja19hY3Rpb24iOiJtYXJrZXIiLCJyZWRpcmVjdF9wZXJtYWxpbmsiOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvcmVkLWFjY2lvbi1ib3RoLWEtZm9ybWFsLWlubm92YXRpb24tbGFiLWFuZC1kYWlseS1leHBlcmltZW50YXRpb24taW4tdGhlLW5ld3Nyb29tLyIsInpvb20iOjIsImV4dHJhX2ZpZWxkcyI6eyJwb3N0X2V4Y2VycHQiOiJJdCdzIGltcG9ydGFudCB0byBoYXZlIHRoZSBzcGFjZSwgdGhlIHJlc291cmNlcyBhbmQgdGhlIHRpbWUgdG8gZXhwZXJpbWVudCBhbmQgbGVhcm4gb24gYSBkYWlseSBiYXNpcyBpbiB0aGUgbmV3c3Jvb20uIFwiV2UgZG9uXHUyMDE5dCB3YW50IHRoZSBNYWtlciBMYWIgdG8gYmUgdGhlIG9ubHkgcGxhY2Ugd2hlcmUgZXhwZXJpbWVudGF0aW9uIGFuZCBsZWFybmluZyB0YWtlIHBsYWNlXCIsIHNheXMgQ2hhbmkgR3V5b3QuICIsInBvc3RfY29udGVudCI6Ilt2Y19yb3ddW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIyLzNcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxoMT5SRUQvQUNDSU9OOiBib3RoIGEgZm9ybWFsIGlubm92YXRpb24gbGFiIGFuZCBkYWlseSBleHBlcmltZW50YXRpb24gaW4gdGhlIG5ld3Nyb29tPC9oMT5cclxuPHN0cm9uZz5JdCdzIGltcG9ydGFudCB0byBoYXZlIHRoZSBzcGFjZSwgdGhlIHJlc291cmNlcyBhbmQgdGhlIHRpbWUgdG8gZXhwZXJpbWVudCBhbmQgbGVhcm4gb24gYSBkYWlseSBiYXNpcyBpbiB0aGUgbmV3c3Jvb20uIFwiV2UgZG9uXHUyMDE5dCB3YW50IHRoZSBNYWtlciBMYWIgdG8gYmUgdGhlIG9ubHkgcGxhY2Ugd2hlcmUgZXhwZXJpbWVudGF0aW9uIGFuZCBsZWFybmluZyB0YWtlIHBsYWNlXCIsIHNheXMgQ2hhbmkgR3V5b3QuXHJcbjwvc3Ryb25nPlxyXG5cclxuSGF2aW5nIHNwZW50IDIwIHllYXJzIGFzIGEgam91cm5hbGlzdCBhbmQgZWRpdG9yLWluLWNoaWVmIGF0IExhIE5hY2lvbiwgQ2hhbmkgR3V5b3QgZGVjaWRlZCBoZSB3b3VsZCBsaWtlIHRvIGRvIHNvbWV0aGluZyBlbHNlIGluIHRoZSBuZXh0IDIwIHllYXJzIG9mIGhpcyBjYXJlZXIuIEluIEFwcmlsIDIwMTggaGUgbGF1bmNoZWQgUkVEL0FDQ0lPTiwgYWZ0ZXIgaGF2aW5nIGNvbGxlY3RlZCAxLDUgbWlsbGlvbiBkb2xsYXJzIGluIGluaXRpYWwgZnVuZGluZyBpbiBvbmx5IHR3byBtb250aHMuXHJcblxyXG5UaGUgZGlnaXRhbCBwdXJlIHBsYXllciBjb21iaW5lcyBhIDEyIHBlb3BsZSBuZXdzcm9vbSB0aGF0XHUyMDE5cyBleHBsb3JpbmcgZGlmZmVyZW50IHdheXMgdG8gcmVwb3J0IG1vYmlsZSBzdG9yaWVzIHdpdGggYSBmb3JtYWwgaW5ub3ZhdGlvbiBsYWI6XHJcbjxibG9ja3F1b3RlPlx1MjAxY1dlIGRvblx1MjAxOXQgd2FudCB0aGUgTWFrZXIgTGFiIHRvIGJlIHRoZSBvbmx5IHBsYWNlIHdoZXJlIGV4cGVyaW1lbnRhdGlvbiBhbmQgbGVhcm5pbmcgdGFrZSBwbGFjZS4gV2VcdTIwMTlyZSB2ZXJ5IHNlcmlvdXMgYWJvdXQgaGF2aW5nIHRoZSBzcGFjZSwgdGhlIHJlc291cmNlcyBhbmQgdGhlIHRpbWUgdG8gZXhwZXJpbWVudCBhbmQgbGVhcm4gb24gYSBkYWlseSBiYXNpcyBpbiBvdXIgbmV3c3Jvb20sIGV2ZW4gaWYgd2UgZG9uXHUyMDE5dCBwdXQgdGhlIG5hbWUgTGFiIG9uIGl0Llx1MjAxZDwvYmxvY2txdW90ZT5cclxuPGgzPk1ha2VyIExhYiB3aXRoIHN0dWRlbnRzPC9oMz5cclxuQ2hhbmkgdGVhbWVkIHVwIHdpdGggSnVhbiBNYXNjYXJkaSwgb25lIG9mIHRoZSBiZXN0IGpvdXJuYWxpc3RzIGFuZCB0ZWFjaGVycyBpbiBBcmdlbnRpbmEsIHRvIGRldmVsb3AgYSBtb2RlbCBvZiB0aGUgTWFrZXIgTGFiIHRoYXQgaXMgdmVyeSBmb2N1c2VkIG9uIHN0dWRlbnRzOlxyXG48YmxvY2txdW90ZT5cdTIwMWNCZWNhdXNlIHdlIHdhbnQgeW91bmcgbWVuIGFuZCB3b21lbiBpbiB0aGVpciBlYXJseSB0d2VudGllcyB0byBoYXZlIHRoZSB0b29scywgdGhlIHNwYWNlLCB0aGUgc3VwcG9ydCBhbmQgdGhlIHRyYWluaW5nIHRvIHJlYWxseSBleHBlcmltZW50Llx1MjAxZDwvYmxvY2txdW90ZT5cclxuVGhlaXIgZmlyc3QgcHJvamVjdCB3aWxsIGJlIGFyb3VuZCBJbmNsdXNpdmUgQ2l0aWVzLCBpbiBSb3NhcmlvLCB0aGUgdGhpcmQgY2l0eSBvZiBBcmdlbnRpbmEsIHdlbGwga25vd24gZm9yIGl0cyBlZHVjYXRpb24gYW5kIGN1bHR1cmFsIGxpZmUuIER1cmluZyBhIHRocmVlLW1vbnRoIHByb2dyYW0sIHN0dWRlbnRzIGdldCBoYW5kcy1vbiB0cmFpbmluZywgdG9vbHMsIGFuZCBlZGl0b3JpYWwgc3VwcG9ydCB0byByZXBvcnQgb24gdGhlIHRvcGljIG9mIFx1MjAxOGluY2x1c2l2ZSBjaXRpZXNcdTIwMTksIGFuZCBSRUQvQUNDSU9OIHB1Ymxpc2hlcyB0aGVpciBzdG9yaWVzOlxyXG48YmxvY2txdW90ZT5cdTIwMWNXZSBmb2N1cyBvbiBob3cgdG8gdGVsbCBsb2NhbCBzdG9yaWVzIHdpdGggeW91ciBwaG9uZSBhbmQgZm9yIHlvdXIgcGhvbmUuIFNvIHRoYXRcdTIwMTlzIHRoZSBzY29wZSBvZiB0aGUgbGFiLCBtYWlubHksIHdpdGggdGhlIHVzZSBvZiB2aWRlbywgZGF0YSwgYW5kIHRyYW5zbWVkaWEgd2l0aCBzb21lIHRvb2xzLiBJdFx1MjAxOXMgYSB2ZXJ5IHNtYWxsIHNjb3BlIGJlY2F1c2Ugd2Ugd2FudCB0byBtb3ZlIGZvcndhcmQgcXVpY2tseSBhbmQgdGhhdFx1MjAxOXMgdGhlIHdheSB0byBkbyB0aGF0Llx1MjAxZDwvYmxvY2txdW90ZT5cclxuQXMgdGhleSBvbmx5IGp1c3Qgc3RhcnRlZCBzZWxlY3Rpbmcgc3R1ZGVudHMgZnJvbSB0aGUgNCBqb3VybmFsaXNtIHNjaG9vbHMgaW4gUm9zYXJpbywgaXRcdTIwMTlzIHRvbyBzb29uIHRvIHNheSBhbnl0aGluZyBpbiB0ZXJtcyBvZiByZXN1bHRzLiBCdXQgYWZ0ZXIgdGhpcyBwaWxvdCBpbiBBcmdlbnRpbmFcdTIwMTlzIHRoaXJkIGxhcmdlc3QgY2l0eSwgdGhlIGlkZWEgaXMgdG8gcm9sbCBvdXQgdGhlIGZvcm1hdCB0byBvdGhlciBwbGFjZXMgaW4gdGhlIGNvdW50cnksIGFyb3VuZCB0aGUgdG9waWNzIHRoYXQgYXJlIHJlbGV2YW50IHRvIGVhY2ggY2l0eS5cclxuPGgzPk5ld3Nyb29tIGV4cGVyaW1lbnRzPC9oMz5cclxuVGhlIExhYiBpcyBwYXJ0IG9mIGEgZGlnaXRhbCBwdXJlIHBsYXllciB0aGF0IENoYW5pIGxhdW5jaGVkIG9ubHkgbGFzdCBBcHJpbC4gSGUgc3RyZXNzZXMgdGhhdCBleHBlcmltZW50YXRpb24gYW5kIGxlYXJuaW5nIHNob3VsZG4ndCBqdXN0IGhhcHBlbiBpbiB0aGUgbGFiLiBPbiBhIGRhaWx5IGJhc2lzLCB0aGUgbmV3c3Jvb20gaXMgZXhwZXJpbWVudGluZyB3aXRoIG5ldyBmb3JtYXRzIGFuZCBuZXcgd2F5cyBvZiB3b3JraW5nLCBlc3BlY2lhbGx5IGFyb3VuZCBjb252ZXJzYXRpb25hbCBwbGF0Zm9ybXM6XHJcbjxibG9ja3F1b3RlPlx1MjAxY1dlIHRoaW5rIHRoYXQgY29udmVyc2F0aW9uYWwgcGxhdGZvcm1zIGFyZSBhIGJpZyBkZWFsIGFuZCB3aWxsIGJlIGEgYmlnZ2VyIGRlYWwgaW4gdGhlIGZ1dHVyZS4gSW4gQXJnZW50aW5hIHdlIGhhdmUgMSwyIGNlbGwgcGhvbmVzIHBlciBwZXJzb24gYW5kIG9uZSBvZiB0aGUgaGlnaGVzdCByYXRlcyBvZiBhY3RpdmUgV2hhdHNhcHAgYWNjb3VudHMuIFNvIHRoZSBkYXkgV2hhdHNhcHAgb3BlbnMgaXRzIEFQSSB3ZSB3YW50IHRvIGJlIHJlYWR5Llx1MjAxZDwvYmxvY2txdW90ZT5cclxuQXMgcGFydCBvZiB0aGUgZXhwZXJpbWVudGF0aW9uIHdpdGggY29udmVyc2F0aW9uYWwgcGxhdGZvcm1zLCBSRUQvQUNDSU9OIHB1Ymxpc2hlZCBhIG51bWJlciBvZiBpbnRlcnZpZXdzIHRoYXQgd2VyZSBtYWRlIG9uIFdoYXRzYXBwIGFuZCBwdWJsaXNoZWQgYXMgYSBjb2xsZWN0aW9uIG9mIHNjcmVlbnNob3RzOlxyXG48YmxvY2txdW90ZT5cdTIwMWNXaGVuIHlvdSByZWFkIHRoYXQgb24geW91ciBwaG9uZSB5b3UgZmVlbCBsaWtlIHlvdVx1MjAxOXJlIHNuZWFraW5nIGludG8gYSBwcml2YXRlIGNvbnZlcnNhdGlvbi4gQmVjYXVzZSB0aGF0XHUyMDE5cyB0aGUgdXN1YWwgdXNhZ2Ugb2YgV2hhdHNhcHAsIGFuZCB0aGUgdG9uZSBhbmQgc3R5bGUgYXJlIHByZXNlcnZlZC5cdTIwMWQ8L2Jsb2NrcXVvdGU+XHJcbiZuYnNwO1xyXG5cclxuPGltZyBjbGFzcz1cImFsaWduY2VudGVyIHdwLWltYWdlLTExNzAzIHNpemUtbGFyZ2VcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxOC8wNy9TY3JlZW4tU2hvdC0yMDE4LTA3LTI0LWF0LTEwLjI4LjAyLTEwMjR4NTY2LnBuZ1wiIGFsdD1cIlwiIHdpZHRoPVwiMTAyNFwiIGhlaWdodD1cIjU2NlwiIC8+XHJcblxyXG5UbyB0YWtlIHRoaXMgYSBzdGVwIGZ1cnRoZXIsIHRoZXkgdHJpZWQgdG8gdXNlIEFsIEphemVlcmFcdTIwMTlzIG9wZW4gSW50ZXJ2aWV3IEFQSSBTSiwgYnV0IHRoZSB1c2VyIGV4cGVyaWVuY2Ugd2FzIGEgbGl0dGxlIGNsdW1zeS4gRm9yIGFub3RoZXIgc3RvcnkgYWJvdXQgYmVlcywgYSBiZWUgd291bGQgZGllIHdoZW4geW91IHRvdWNoZWQgaXQgb24geW91ciBzY3JlZW4uIFRoaXMgZWxlbWVudCB3YXMgZXZlbnR1YWxseSB0YWtlbiBvdXQsIGJlY2F1c2UgaXQgZGlkblx1MjAxOXQgc3VpdCB0aGUgc3Bpcml0IG9mIHRoZSBzdG9yeS4gQnV0IHRob3NlIFx1MjAxOG1pc3Rha2VzXHUyMDE5IGFyZSBwYXJ0IG9mIHRoZSBwcm9jZXNzLCBhY2NvcmRpbmcgdG8gQ2hhbmk6XHJcbjxibG9ja3F1b3RlPlx1MjAxY1RoZSBpbnRlcmVzdGluZyB0aGluZyBJIHRoaW5rIGlzIHRoYXQgd2UgcHVibGlzaGVkLCBzYXlpbmcgdG8gb3VyIHJlYWRlcnM6IHdlIGFyZSBleHBlcmltZW50aW5nIC0gd2Ugd2FudCB0byBsZWFybiBcdTIwMTMgd2hhdCBkbyB5b3UgdGhpbms/IEFuZCB3ZSBhcmUgcmVjZWl2aW5nIGEgbG90IG9mIGZlZWRiYWNrLlx1MjAxZDwvYmxvY2txdW90ZT5cclxuPGgzPlRyYWluaW5nIHlvdXIgbXVzY2xlczwvaDM+XHJcbjxibG9ja3F1b3RlPlx1MjAxY1RoZSBtb3N0IGludGVyZXN0aW5nIHRoaW5ncyB3ZSBsZWFybiBkb2luZyBJbnN0YWdyYW0gc3Rvcmllcy4gV2UgZG8gcXVpenplcywgYW5kIGFsbW9zdCBldmVyeWJvZHkgZmFpbHMuIFdlXHUyMDE5cmUgYnJlYWtpbmcgb3BlbiBjb21tb24gc2Vuc2UgYnkgc2hvd2luZyB0aGUgZGlmZmVyZW5jZSBiZXR3ZWVuIHdoYXQgeW91IHRoaW5rIHRoZSBzdG9yeSBpcyBhbmQgd2hhdCBpdCBhY3R1YWxseSBpcy5cdTIwMWQ8L2Jsb2NrcXVvdGU+XHJcblNvbWUgb2YgdGhlc2UgcHJvamVjdHMgZG9uXHUyMDE5dCBsZWFkIHRvIGFueSBkaXJlY3QgcmVzdWx0cyBcdTIwMTNldmVuIHRob3VnaCBtb3N0IG9mIHRoZW0gaW5jcmVhc2UgYXVkaWVuY2UgZW5nYWdlbWVudCB3aXRoIHRoZSBwcm9qZWN0XHUyMDEzLCB5b3UncmUgc3RpbGwgdHJhaW5pbmcgbXVzY2xlcyB0aGF0IHlvdSBjYW4gdGhlbiB1c2UgZm9yIHByb2plY3RzIHRoYXQgeW91IGRvbid0IGtub3cgbm93IG1pZ2h0IGNvbWUgYWxvbmcgaW4gNiBtb250aHMgb3Igc28sIHNheXMgQ2hhbmk6XHJcbjxibG9ja3F1b3RlPlx1MjAxY0xpa2Ugd2hlbiB5b3UncmUgZG9pbmcgc3BvcnRzIGFuZCBzdWRkZW5seSBkaXNjb3ZlciB5b3UgaHVydCBpbiBwbGFjZXMgeW91IGRpZG4ndCBldmVuIGtub3cgeW91IGhhZCBtdXNjbGVzLlx1MjAxZDwvYmxvY2txdW90ZT5cclxuPGgzPkZhc3QsIGZhc3RlciwgZmFzdDwvaDM+XHJcbkdvaW5nIGZyb20gYSBsYXJnZSBsZWdhY3kgbWVkaWEgY29tcGFueSB0byBzdGFydGluZyBhbiBvbmxpbmUgb3V0bGV0IGZyb20gc2NyYXRjaCwgQ2hhbmkgaGFzIGJlZW4gbW9zdGx5IHN1cnByaXNlZCBieSB0aGUgc3BlZWQgYXQgd2hpY2ggdGhpbmdzIGNhbiBtb3ZlIGZyb20gZGVjaXNpb24gdG8gZXhlY3V0aW9uLiBSZWNlbnRseSwgZm9yIGV4YW1wbGUsIHdoZW4gYSBmcmllbmQgY2FsbGVkIGhpbSBhYm91dCBwdWJsaXNoaW5nIGEgbmV3IHBvZGNhc3Qgc2VyaWVzOlxyXG48YmxvY2txdW90ZT5cdTIwMWNTaGUgY2FsbGVkIG1lIGluIHRoZSBtb3JuaW5nIHRvIGFzayBpZiB3ZSB3YW50ZWQgdG8gcGFydG5lciBvbiBpdC4gMjQgaG91cnMgbGF0ZXIgd2UgYXBwcm92ZWQgdGhlIGlkZWEsIGdvdCB0aGUgdGVjaG5pY2FsIHJlcXVpcmVtZW50cyBpbiBwbGFjZSBhbmQgcHVibGlzaGVkIHRoZSBmaXJzdCBzdG9yeS5cdTIwMWQ8L2Jsb2NrcXVvdGU+XHJcblRoZXJlXHUyMDE5cyBubyBxdWVzdGlvbiBmb3IgQ2hhbmkgdGhhdCBMYSBOYWNpb24gaXMgYW4gZXhxdWlzaXRlIGNvbXBhbnksIGJ1dCB0aGUgYmVhdXR5IG9mIGJlaW5nIHNtYWxsIGlzIHRoYXQgdGhlIHJld2FyZCBkb2Vzblx1MjAxOXQgaGF2ZSB0byBiZSBlbm9ybW91czpcclxuPGJsb2NrcXVvdGU+XHUyMDFjSSB3YXMgbGVhZGluZyBhIG5ld3Nyb29tIG9mIDMwMCBwZW9wbGUgYW5kIGV2ZW4gdGhvdWdoIHdlIGhhZCBtb3JlIG9yIGxlc3MgdW5saW1pdGVkIHJlc291cmNlcywgeW91IG5lZWQgdG8ga25vdyB0aGUgc2l6ZSBvZiB0aGUgaW1wYWN0IHdoZW4geW91IG1vdmUgZm9yd2FyZCB3aXRoIHRoZXNlIGtpbmRzIG9mIHByb2plY3RzLiBJbiBvdXIgY2FzZSwgYXMgd2UgYXJlIG5ldyBhbmQgc21hbGwsIHRoZSByaXNrIGlzIGxvd2VyLlx1MjAxZDwvYmxvY2txdW90ZT5cclxuPGgzPk51cnR1cmluZyBzbWFsbCBpZGVhczwvaDM+XHJcbkJlaW5nIHNtYWxsIGdpdmVzIHlvdSBhZHZhbnRhZ2VzIGluIHRlcm1zIG9mIGdvaW5nIGZhc3RlciBhbmQgZGVlcGVyLiBJbiBhIGJpZyBzdHJ1Y3R1cmUgc21hbGwgaWRlYXMgYXJlIHVzdWFsbHkgZHJvcHBlZCB0b28gZmFzdCB1bmxlc3MgdGhleSBwcm92ZSB0aGF0IHRoZXkgaGF2ZSB0aGUgcG90ZW50aWFsIG9mIGJlY29taW5nIGJpZyBpZGVhcy4gSXRcdTIwMTlzIGVhc2llciB0byBicmVlZCBzbWFsbCBpZGVhcyB0dXJuaW5nIGludG8gYmlnIGlkZWFzIGluIGEgc21hbGwgc3RydWN0dXJlIHRoYW4gaW4gYSBiaWcgb25lIHNheXMgQ2hhbmk6XHJcbjxibG9ja3F1b3RlPlx1MjAxY0kgbG92ZSB0aGlzIGlkZWEgdGhhdCBhIGJpZyBpZGVhLCBhIHZlcnkgYmlnIGlkZWEsIGl0XHUyMDE5cyByZWFsbHkganVzdCBhIHNtYWxsIGlkZWEgdGhhdCBmaW5kcyBzb21lb25lIGNvdXJhZ2VvdXMgdG8gcHJvdGVjdCBpdCB0aHJvdWdoIHRoZSBicmVlZGluZyBwaGFzZXMuIEFuZCBvZiBjb3Vyc2UsIG9uY2UgdGhleSBiZWNvbWUgYmlnIGlkZWFzLCB0aGV5IGFyZSBhZG9wdGVkIGJ5IGJpZyBtZWRpYS4gVGhhdFx1MjAxOXMgYmVhdXRpZnVsLlx1MjAxZFxyXG5cclxuJm5ic3A7PC9ibG9ja3F1b3RlPlxyXG5DT05UQUNUIFBPSU5UXHJcbjxpbWcgY2xhc3M9XCJhbGlnbm5vbmUgc2l6ZS1mdWxsIHdwLWltYWdlLTExNjk1XCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTgvMDcvY2hhbmkuanBnXCIgYWx0PVwiXCIgd2lkdGg9XCIyMDBcIiBoZWlnaHQ9XCIyNTBcIiAvPlxyXG5DaGFuaSBHdXlvdCwgZm91bmRlciwgUkVEL0FDQ0lPTlxyXG5XZWI6IDxhIGhyZWY9XCJodHRwczovL3JlZGFjY2lvbi5jb20uYXIvbGFiLWRlLXJlZGFjY2lvbi9cIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPmh0dHBzOi8vcmVkYWNjaW9uLmNvbS5hci9sYWItZGUtcmVkYWNjaW9uLzwvYT5cclxuVHdpdHRlcjogPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vY2FybG9zZ3V5b3RcIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPkBjYXJsb3NndXlvdDwvYT5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMi8zXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48aDM+QXV0aG9yPC9oMz5cclxuW3NpbXBsZS1hdXRob3ItYm94XVsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XSIsInBvc3RfdGl0bGUiOiJSRUQvQUNDSU9OOiBib3RoIGEgZm9ybWFsIGlubm92YXRpb24gbGFiIGFuZCBkYWlseSBleHBlcmltZW50YXRpb24gaW4gdGhlIG5ld3Nyb29tIiwicG9zdF9saW5rIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL3JlZC1hY2Npb24tYm90aC1hLWZvcm1hbC1pbm5vdmF0aW9uLWxhYi1hbmQtZGFpbHktZXhwZXJpbWVudGF0aW9uLWluLXRoZS1uZXdzcm9vbS8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJSRUQvQUNDSU9OOiBib3RoIGEgZm9ybWFsIGlubm92YXRpb24gbGFiIGFuZCBkYWlseSBleHBlcmltZW50YXRpb24gaW4gdGhlIG5ld3Nyb29tXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMDBcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxOC8wNy9EU0NfOTc2Ni0zMDB4MjAwLmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6Iklubm92YXRpb24gQ2FzZSwgTWVkaWEgbGFicyIsInBvc3RfdGFncyI6ImFwcGxpY2F0aW9ucywgQXJnZW50aW5hLCBkaWdpdGFsIG1lZGlhLCBtb2JpbGUgam91cm5hbGlzbSwgc3R1ZGVudHMiLCIlX3ZjX3Bvc3Rfc2V0dGluZ3MlIjp7InZjX2dyaWRfaWQiOltdfSwiJV9lZGl0X2xvY2slIjoiMTUzMzA1MDc5MDoxMDEiLCIlX2VkaXRfbGFzdCUiOiIxMDEiLCIlc2xpZGVfdGVtcGxhdGUlIjoiZGVmYXVsdCIsIiVfd3BiX3ZjX2pzX3N0YXR1cyUiOiJ0cnVlIiwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6IkJ1ZW5vcyBBaXJlcywgQXJnZW50aW5hIiwiJV93cGdtcF9tZXRhYm94X2xhdGl0dWRlJSI6Ii0zNC42MDM2ODQ0MDAwMDAwMSIsIiVfd3BnbXBfbWV0YWJveF9sb25naXR1ZGUlIjoiLTU4LjM4MTU1OTEwMDAwMDAwNCIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiMlwiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6Ik47IiwiJV93cGdtcF9tZXRhYm94X3RheG9tb21pZXNfdGVybXMlIjoiTjsiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6Ik47IiwiJV9rbGVvX3RyYW5zcGFyZW50X21lbnVfY29sb3IlIjoid2hpdGUiLCIlX2tsZW9fdGl0bGVfY29sb3IlIjoiIyIsIiVfa2xlb190aXRsZV9iZyUiOiIsIHJlcGVhdCwgaW5oZXJpdCwgc2Nyb2xsLCBsZWZ0IHRvcCIsIiVfa2xlb190aXRsZV9iZ19jb2xvciUiOiIjIiwiJV95b2FzdF93cHNlb19jb250ZW50X3Njb3JlJSI6IjYwIiwiJV95b2FzdF93cHNlb19wcmltYXJ5X2NhdGVnb3J5JSI6IjE0MiIsIiVfa2xlb190aXRsZV9jaGVja2JveCUiOiIxIiwiJV9qZXRwYWNrX3JlbGF0ZWRfcG9zdHNfY2FjaGUlIjp7IjYyMzkzYjI0MmM3YTU2MTc3NGY4ZWJmZjVjMWMwNTY1Ijp7ImV4cGlyZXMiOjE1NDU0MzczMjEsInBheWxvYWQiOlt7ImlkIjoxMTIzNX0seyJpZCI6MTAxNTV9LHsiaWQiOjExMjI1fV19fSwiJV90aHVtYm5haWxfaWQlIjoiMTE3MDciLCIlX3dwX29sZF9kYXRlJSI6IjIwMTgtMDctMTIiLCIlc2JnX3NlbGVjdGVkX3NpZGViYXIlIjoiMCIsIiVzYmdfc2VsZWN0ZWRfc2lkZWJhcl9yZXBsYWNlbWVudCUiOiIwIiwidGF4b25vbXk9Y2F0ZWdvcnkiOiJJbm5vdmF0aW9uIENhc2UsIE1lZGlhIGxhYnMiLCJ0YXhvbm9teT1wb3N0X3RhZyI6ImFwcGxpY2F0aW9ucywgQXJnZW50aW5hLCBkaWdpdGFsIG1lZGlhLCBtb2JpbGUgam91cm5hbGlzbSwgc3R1ZGVudHMifSwiaWNvbiI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE4LzAyL21hcmtlci0xLnBuZyJ9LCJpZCI6MTE2OTEsImluZm93aW5kb3dfZGlzYWJsZSI6ZmFsc2V9LHsic291cmNlIjoicG9zdCIsInRpdGxlIjoiJiM4MjIwO1N0aWNrIHRvIHRoZSBtZXRob2QgYW5kIGRvIGl0IGJ5IHRoZSBib29rLCBhdCBsZWFzdCBpbiB0aGUgYmVnaW5uaW5nJiM4MjIxOyIsImluZm93aW5kb3dfY29udGVudCI6IjxkaXYgY2xhc3M9XCJmYy1pdGVtLWJveCBmYy1pdGVtLW5vLXBhZGRpbmdcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiJiM4MjIwO1N0aWNrIHRvIHRoZSBtZXRob2QgYW5kIGRvIGl0IGJ5IHRoZSBib29rLCBhdCBsZWFzdCBpbiB0aGUgYmVnaW5uaW5nJiM4MjIxO1wiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMTgxXCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTgvMDQvU2NyZWVuLVNob3QtMjAxOC0wNC0xOC1hdC0xMC4xMC4zNy0zMDB4MTgxLnBuZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmdcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXBhZGRpbmctY29udGVudF8yMFwiPlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLW1ldGEgZmMtaXRlbS1zZWNvbmRhcnktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZSBmYy10ZXh0LWNlbnRlclwiPklubm92YXRpb24gQ2FzZSwgTWVkaWEgbGFiczwvZGl2PlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLXRleHQtY2VudGVyXCI+JiM4MjIwO1N0aWNrIHRvIHRoZSBtZXRob2QgYW5kIGRvIGl0IGJ5IHRoZSBib29rLCBhdCBsZWFzdCBpbiB0aGUgYmVnaW5uaW5nJiM4MjIxOzwvZGl2PlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2VcIj5cclxuICAgICAgICAgICAgRml2ZSBxdWVzdGlvbnMgdG8gQ2xlbWVucyBQcmVyb3Zza3kgKENETykgYWJvdXQgb25nb2luZyBwcm9qZWN0cywgbGVzc29ucyBsZWFybmVkIGFuZCBiZXN0IHByYWN0aWNlcyBhdCB0aGUgQVBBLW1lZGlhbGFiLlxyXG4gICAgICAgIDwvZGl2PlxyXG48YSBocmVmPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL3N0aWNrLW1ldGhvZC1ib29rLWxlYXN0LWJlZ2lubmluZy9cIj5SZWFkIG1vcmU8L2E+XHJcbiAgICA8L2Rpdj5cclxuICAgIDwvZGl2PlxyXG48L2Rpdj5cclxuXHJcbiIsImNvbnRlbnQiOiJGaXZlIHF1ZXN0aW9ucyB0byBDbGVtZW5zIFByZXJvdnNreSAoQ0RPKSBhYm91dCBvbmdvaW5nIHByb2plY3RzLCBsZXNzb25zIGxlYXJuZWQgYW5kIGJlc3QgcHJhY3RpY2VzIGF0IHRoZSBBUEEtbWVkaWFsYWIuIiwiYWRkcmVzcyI6IlZpZW5uYSwgQXVzdHJpYSIsImxvY2F0aW9uIjp7ImxhdCI6IjQ4LjIwODE3NDMiLCJsbmciOiIxNi4zNzM4MTg5MDAwMDAwNiIsIm9uY2xpY2tfYWN0aW9uIjoibWFya2VyIiwicmVkaXJlY3RfcGVybWFsaW5rIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL3N0aWNrLW1ldGhvZC1ib29rLWxlYXN0LWJlZ2lubmluZy8iLCJ6b29tIjoyLCJleHRyYV9maWVsZHMiOnsicG9zdF9leGNlcnB0IjoiRml2ZSBxdWVzdGlvbnMgdG8gQ2xlbWVucyBQcmVyb3Zza3kgKENETykgYWJvdXQgb25nb2luZyBwcm9qZWN0cywgbGVzc29ucyBsZWFybmVkIGFuZCBiZXN0IHByYWN0aWNlcyBhdCB0aGUgQVBBLW1lZGlhbGFiLiIsInBvc3RfY29udGVudCI6Ilt2Y19yb3ddW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIyLzNcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxoMT5cIlN0aWNrIHRvIHRoZSBtZXRob2QgYW5kIGRvIGl0IGJ5IHRoZSBib29rLCBhdCBsZWFzdCBpbiB0aGUgYmVnaW5uaW5nXCI8L2gxPlxyXG48c3Ryb25nPkZpdmUgcXVlc3Rpb25zIHRvIENsZW1lbnMgUHJlcm92c2t5IChDRE8pIGFib3V0IG9uZ29pbmcgcHJvamVjdHMsIGxlc3NvbnMgbGVhcm5lZCBhbmQgYmVzdCBwcmFjdGljZXMgYXQgdGhlIEFQQS1tZWRpYWxhYi48L3N0cm9uZz5cclxuXHJcbkluIEphbnVhcnkgMjAxNywgdGhlIEFQQS1tZWRpYWxhYiB3YXMgPGEgaHJlZj1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9hcGEtbWVkaWFsYWItaW5ub3ZhdGluZy1qb3VybmFsaXNtLXRocm91Z2gtcHJvdG90eXBlcy1hbmQtdHJlbmQtcmVzZWFyY2gvXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5jcmVhdGVkPC9hPiB0byBpbXByb3ZlIHRoZSB0aW1lIHRvIG1hcmtldCBvZiB0aGVpciBwcm9kdWN0cyBhbmQgdG8gYnJlYWsgZG93biBzaWxvcyB0aGF0IGV4aXN0ZWQgd2l0aGluIHRoZSBuZXdzIGFnZW5jeSBpbiB0ZXJtcyBvZiBhcHByb2FjaGluZyB0b3BpY3Mgb2YgaW5ub3ZhdGlvbi4gSW4gdGhlIG1lYW50aW1lLCB0aGUgSGVhZCBvZiB0aGUgbGFiIGxlZnQgdG8gc3RhcnQgYSBjb21wYW55IHdpdGggaGlzIGJyb3RoZXIsIGFuZCBDbGVtZW5zIFByZXJvdnNreSB0b29rIG92ZXIuXHJcbjxoMz4xLiBXaGF0IGFyZSB5b3Ugd29ya2luZyBvbiByaWdodCBub3c/PC9oMz5cclxuV2UgaGF2ZSBhIGxvdCBvZiBzdHVmZiBnb2luZyBvbiByaWdodCBub3cuIFRoZSB0aGluZyB3ZVx1MjAxOXJlIGN1cnJlbnRseSB3b3JraW5nIG9uIGlzIGEgcmVhbGx5IHBsYXlmdWwgb25lLiBXZSBvZnRlbiBoYXZlIHRvIHNob3cgc29tZXRoaW5nIGF0IGV2ZW50cyB0aGF0IHdlJ3JlIGF0dGVuZGluZy4gU28gd2VcdTIwMTlyZSB3b3JraW5nIG9uIGFuIGFwcGxpY2F0aW9uIHRoYXQgdXNlcyBmYWNlIGRldGVjdGlvbiBhbmQgaW50ZXJwcmV0cyB5b3VyIGVtb3Rpb25zIHVzaW5nIG9wZW4gc291cmNlIHNvZnR3YXJlLiBCYXNlZCBvbiB0aGF0IHdlIGF1dG9tYXRpY2FsbHkgZ2VuZXJhdGUgYSBzb2NpYWwgbWVkaWEgbWVzc2FnZSB0aGF0IHlvdSBjYW4gdGhlbiBwb3N0LlxyXG5cclxuU28geW91IGNhbiB3cml0ZSBhIHBvc3Qgd2l0aCB5b3VyIGZhY2UhXHJcblxyXG5CdXQgaXRcdTIwMTlzIG5vdCBvbmx5IGZ1bi4gSXQgYWxzbyBpbmNvcnBvcmF0ZXMgdGVjaG5vbG9naWVzIHRoYXQgd2UgbWlnaHQgdXNlIGluIHRoZSBmdXR1cmUsIGxpa2UgZW1vdGlvbiBkZXRlY3Rpb24sIGZhY2UgZGV0ZWN0aW9uLCBhdXRvbWF0ZWQgdGV4dCBnZW5lcmF0aW9uIGFuZCBBcnRpZmljYWwgSW50ZWxsaWdlbmNlLiBBbmQgdGhhdFx1MjAxOXMgd2hlcmUgd2VcdTIwMTlyZSBoZWFkZWQuXHJcblxyXG5JbiBNYXksIHdlIHdpbGwgaGF2ZSBvdXIgZmlyc3QgZnVsbC1mbGVkZ2VkIG1hY2hpbmUtbGVhcm5pbmcgcHJvamVjdCwgd2hpY2ggSVx1MjAxOW0gcmVhbGx5IGV4Y2l0ZWQgYWJvdXQuIFdlIHdpbGwgY2F0ZWdvcmlzZSB0ZXh0IGFuZCBuZXdzLCBzbyBjdXN0b21lcnMgY2FuIG9yZGVyIGFsbCB0aGUgbmV3cyBhcnRpY2xlcyB0aGF0IGFyZSBhYm91dCB0aGVtIHRvIGJlIHNlbnQgdG8gdGhlbSBldmVyeSBkYXkuIFJpZ2h0IG5vdywgc29tZWJvZHkgaXMgcmVhZGluZyB0aHJvdWdoIDMwMCBhcnRpY2xlcyBldmVyeSBtb3JuaW5nIGFuZCB3ZSBob3BlIHRvIGF1dG9tYXRlIHRoYXQgdG8gc29tZSBleHRlbnQuIElcdTIwMTltIGNvbmZpZGVudCB0aGF0IHdlIGNhbiBkbyB0aGF0IHdpdGggaGlnaCBwcmVjaXNpb24uIEFzIGEgbmV3cyBhZ2VuY3ksIHdlIGhhdmUgeWVhcnMgYW5kIHllYXJzIG9mIGRhdGEgdGhhdCB3ZSBjYW4gdXNlIHRvIHRyYWluIGEgTmV1cmFsIE5ldHdvcmsgdG8gZG8gdGhhdC5cclxuPGgzPjIuIFdoYXQgY2hhbmdlZCBzaW5jZSB0aGUgbGFiIHdhcyBjcmVhdGVkIGluIEphbnVhcnkgMjAxNz88L2gzPlxyXG5Tb21ldGhpbmcgd2lsbCBwcm9iYWJseSBjaGFuZ2UgdmVyeSBzb29uLCBuYW1lbHkgdGhlIHdheSB3ZSBzZXQgdXAgdGhlIHJvYWQgbWFwIGZvciB0aGUgbGFiLiBTbyBmYXIsIGV2ZXJ5Ym9keSBjb3VsZCBib29rIHRoZWlyIHRpbWUgd2l0aCB1cyBhbmQgd2UgdHJ5IHRvIGJhbGFuY2UgYWxsIHRoZSByZXF1ZXN0cyBhbmQgaWRlYXMgZnJvbSBhbGwgcGFydHMgb2YgdGhlIGNvbXBhbnk6IGZyb20gZGlmZmVyZW50IGRlcGFydG1lbnRzLCBmcm9tIHRoZSBDRU9zIGFuZCBzb21lIGZyb20gdGhlIGxhYiBpdHNlbGYuIFdlIGNvbGxlY3QgYWxsIG9mIHRob3NlIHJlcXVlc3RzIGFuZCB0dXJuIHRoZW0gaW50byBhIHJvYWQgbWFwLiBJdFx1MjAxOXMgYSByYXRoZXIgY29tcGxpY2F0ZWQgcHJvY2VzcyBhbmQgdGhlIHByb3Bvc2FscyBhcmUgdG9vIG9mdGVuIGZvY3VzZWQgb24gdGhlIG5vdy5cclxuXHJcbkkgd291bGQgbGlrZSB0byBjaGFuZ2UgdGhhdCBwcmV0dHkgZHJhc3RpY2FsbHksIHNvIHRoYXQgdGhlIGxhYiBwcm92aWRlcyBhbGwgb2YgdGhlIHRvcGljcyBmb3IgdGhlIGZ1dHVyZSByb2FkbWFwLiBTaW5jZSB3ZSBhbHNvIGhhdmUgYSByZXNlYXJjaCBmb2N1cyBhbmQgd2FudCB0byBsb29rIGF0IHRoZSB0cmVuZHMgdGhhdCB3aWxsIGltcGFjdCB1cyB1bnRpbCAyMDI1LiBBdCB0aGUgbW9tZW50LCB0aGlzIGlzIG1pc3NpbmcgYSBiaXQgZnJvbSBvdXIgcm9hZG1hcCwgZXhjZXB0IHRoZSBBSSBzdHVmZi4gQW5kIEkgd291bGQgbGlrZSB0byBmb2N1cyBtb3JlIG9uIHRoZSBmdXR1cmUuIERlY2lkZSB3aGVyZSB0aGUgY29tcGFueSB3YW50cyB0byBiZSBpbiBhIGZldyB5ZWFycyBhbmQgdGhlbiB3b3JrIHRvd2FyZHMgdGhhdC5cclxuPGgzPjMuIFdoYXQgaXMgeW91ciBtYWluIGxlc3NvbiBsZWFybmVkPzwvaDM+XHJcbk9uZSB0aGluZyB3ZVx1MjAxOXZlIGxlYXJuZWQgaXMgdGhhdCBwYXJ0aWNpcGF0aW5nIGluIGEgRGVzaWduIFNwcmludCBkdXJpbmcgb25lIHdlZWsgaXMgcGVyY2VpdmVkIGFzIGEgdmVyeSBoaWdoIGNvbW1pdG1lbnQuIFdoaWNoIGlzIHVuZGVyc3RhbmRhYmxlLCBiZWNhdXNlIHlvdVx1MjAxOXJlIHJlYWxseSB0YWtlbiBvZmYgdGhlIGpvYiBmb3Igb25lIHdlZWsuIEJ1dCBubyBvbmUgc2VlbXMgdG8gcmVhbGlzZSB0aGF0IGl0IHdvdWxkIGhhdmUgb3RoZXJ3aXNlIHRha2VuIGhhbGYgYSB5ZWFyIHRvIGRldmVsb3AgdGhlIHNhbWUgcHJvamVjdC5cclxuXHJcblRoZSBvdGhlciB0aGluZyBpcyB0aGF0IHRoZSBHb29nbGUgRGVzaWduIFNwcmludCBpcyBmb2N1c2VkIG9uIHRlc3Rpbmcgb24gRnJpZGF5LCBidXQgdGhhdFx1MjAxOXMgc3VwZXIgaGFyZCB0byBkbyBpbiBBdXN0cmlhLiBQZW9wbGUgdXN1YWxseSB0cnkgdG8gZ2V0IHRoZWlyIHN0dWZmIGRvbmUgb24gRnJpZGF5IG1vcm5pbmcsIHNvIHRoZXkgY2FuIGxlYXZlIGVhcmx5LiBXaGljaCBtZWFucyB0aGVyZSBpcyBubyByb29tIGZvciB0ZXN0aW5nIHdpdGggdXMuXHJcblxyXG5UaGF0XHUyMDE5cyB3aHkgd2UgY2hhbmdlZCB1cCB0aGUgc3ByaW50IGEgYml0LiBXZSBzcHJlYWQgaXQgb3V0LCBzbyB0aGUgZGV2ZWxvcGVycyBjYW4gY29udGludWUgY29kaW5nIG9uIEZyaWRheSBhbmQgd2UgZG8gdGhlIHVzZXIgdGVzdGluZyB0aGUgZm9sbG93aW5nIHdlZWsuIFRoaXMgd29ya3MgcmVhbGx5IHdlbGwgYWdhaW5zdCB0aGUgZmVhciBvZiBoaWdoIGNvbW1pdG1lbnQgYW5kIHRoZSBkZXZlbG9wZXJzIGhhdmUgbW9yZSB0aW1lIHRvIGRvIHRoZWlyIHdvcmsuXHJcblxyXG5XZSBhbHNvIHRyaWVkIGEgdmVyeSBzaG9ydCBzcHJpbnQgb25jZSwgd2hpY2ggbGFzdGVkIG9ubHkgMiw1IGRheXMuIFRoZSBvd25lciB3YXMgdmVyeSBoYXBweSB3aXRodCBoZSByZXN1bHRzLCBidXQgSSB3YXNuXHUyMDE5dC4gSSBmZWx0IHRoZSBpZGVhcyB3ZXJlIHRvbyBtdWNoIGFsaWduZWQgd2l0aCBlYWNoIG90aGVyLCBiZWNhdXNlIHdlIGxhY2tlZCB0aGlzIHBoYXNlIG9mIGNyZWF0aXZlIGlucHV0IGluIHRoZSBiZWdpbm5pbmcuIFRoYXQganVzdCB3YXNuXHUyMDE5dCBlbm91Z2guIFdlIGJhc2ljYWxseSBlbmRlZCB1cCB3aXRoIHNldmVuIHNrZXRjaGVzIG9mIHRoZSBzYW1lIHByb2R1Y3QuXHJcbjxoMz40LiBXaGF0IGhhcyBiZWVuIHlvdXIgXHUyMDE4YmVzdCBmYWlsdXJlXHUyMDE5PzwvaDM+XHJcbkEgZmV3IG1vbnRocyBhZ28sIHdlIGRpZCBhIHNwcmludCBvbiB2b2ljZS1lbmFibGVkIG1lZGlhIHdpdGggdGhlIGFpbSB0byB0aGluayBvZiBuZXcgd2F5cyB0byB1c2Ugdm9pY2UgaW4gbWVkaWEuIFRoZSBvbmx5IHRoaW5nIHlvdSBjYW4gcmVhbGx5IGRvIGF0IHRoZSBtb21lbnQgaXMgYXNrIEFsZXhhIGZvciBuZXdzIHVwZGF0ZXMuIFlvdSBnZXQgYSBuZXdzIHVwZGF0ZSB0aGF0IHNoZSByZWFkcyBvdXQsIGFuZCBpbiB0aGUgbW9ybmluZyBpdFx1MjAxOXMgdGhlIHNhbWUgYXMgaW4gdGhlIGV2ZW5pbmcuIFNvIHdlIHdhbnRlZCB0byB3b3JrIHRyeSBhbmQgY29tZSB1cCB3aXRoIG5ldyBpZGVhcyBmb3Igdm9pY2UtZW5hYmxlZCBtZWRpYS5cclxuXHJcbkV2ZXJ5dGhpbmcgd2FzIGdvaW5nIHJlYWxseSB3ZWxsOyB3ZSBhbGlnbmVkIHRoZSBzcHJpbnQgd2l0aCB0aGUgbGF1bmNoIG9mIEdvb2dsZSBob21lIGluIEdlcm1hbnksIHNvIHdlIGhhZCB0aGUgR29vZ2xlIGRldmljZSBhbmQgd2Ugd2VyZSBwcmVwYXJlZCByZWFsbHkgd2VsbC4gQnV0IHRoZW4gaXQgdHVybmVkIG91dCB0aGF0IGFsdGhvdWdoIEdvb2dsZSBob21lIHdvcmtzIGluIEdlcm1hbiwgaXQgZG9lc25cdTIwMTl0IGhhdmUgYSBHZXJtYW4gQVBJLiBTbyB3ZSBjb3VsZG5cdTIwMTl0IGRvIGFueXRoaW5nIHdpdGggdGhlIGRldmljZS4gSXQgd2FzIHRvdGFsbHkgcG9pbnRsZXNzLiBOb2JvZHkgY291bGQgZGV2ZWxvcCBhbiBhcHAgaW4gR2VybWFuLiBTbyB0aGF0IHdhcyBraW5kIG9mIGEgZmFpbHVyZS5cclxuXHJcbkFsdGVybmF0aXZlbHkgd2UgdXNlZCBBbGV4YSwgYnV0IEFsZXhhIGhhcyB0ZXJyaWJsZSB2b2ljZSBjYXBhYmlsaXRpZXMuIFdlIHdlcmUgbm90IGltcHJlc3NlZCB3aXRoIHRoYXQuIFNvIGluIHRoZSBlbmQgd2UgdXNlZCB0aGUgYnJvd3Nlclx1MjAxOXMgY2FwYWJpbGl0aWVzIGZvciB2b2ljZS1yZWNvZ25pdGlvbi4gV2hpY2ggYXJlIG5vdCBhcyBnb29kLCBidXQgdGhleSB3ZXJlIHRoZXJlIGFuZCB0aGV5IHdlcmUgZnJlZS5cclxuXHJcbkFuZCB3ZSBoYWQgc28gbXVjaCBmdW4hIEFsdGhvdWdoIEFsZXhhIGZhaWxlZCBhbGwgdGhlIHRpbWUsIHRoZSBjb29sIHRoaW5nIGlzIHRoYXQgdGhlIGRlc2lnbiBzcHJpbnQgbWV0aG9kIGFsbG93cyB5b3UgdG8gYWNjb21tb2RhdGUgdG8gdGhlIHNpdHVhdGlvbiwgZXZlbiB3aGVuIHRoaW5ncyBnbyByZWFsbHkgd3JvbmcuIFdlIHdlcmUgbm90IHN0dWNrIHRvIHRoZSBHb29nbGUgZGV2aWNlLiBXZSB3ZXJlIGFibGUgdG8gd29yayBhcm91bmQgaXQgYW5kIHN0aWxsIGRvIHRoZSBzcHJpbnQuXHJcbjxoMz41LiBXaGF0IGFkdmljZSB3b3VsZCB5b3UgZ2l2ZSB0byBzb21lb25lIGxvb2tpbmcgdG8gc3RhcnQgYSBtZWRpYSBpbm5vdmF0aW9uIGxhYj88L2gzPlxyXG5TdGljayB0byB0aGUgbWV0aG9kIGFuZCBkbyBpdCBieSB0aGUgYm9vaywgYXQgbGVhc3QgaW4gdGhlIGJlZ2lubmluZy4gVGhpbmdzIHN0YXJ0IHRvIGZhbGwgYXBhcnQgcXVpY2tseSBlbm91Z2gsIGJ1dCB3aGF0IEkgc2VlIGEgbG90IG9mIHRpbWVzIGlzIHRoYXQgcGVvcGxlIHN0YXJ0IGNoYW5naW5nIHVwIHRoZSBtZXRob2QgYmVmb3JlIHRoZXkgZXZlbiB0cmllZCB0byBkbyBpdCBjb3JyZWN0bHkgb25jZSBhbmQgc2VlIGhvdyBpdCB3b3Jrcy5cclxuXHJcblRoYXQgd2FzIG9uZSBvZiB0aGUgZmlyc3QgdGhpbmdzIEkgd2FudGVkIHRvIHRyeSB3aGVuIEkgYmVjYW1lIGhlYWQgb2YgdGhlIEFQQS1tZWRpYWxhYiwgdG8gcmVhbGx5IGRvIGl0IGJ5IHRoZSBib29rLiBXZSBkaWRuXHUyMDE5dCB1c2UgdGhlIG1hcCBmb3IgZXhhbXBsZSwgYmVjYXVzZSBwZW9wbGUgZGlkblx1MjAxOXQgbGlrZSBpdC4gQnV0IGl0IGFjdHVhbGx5IGJyb3VnaHQgc29tZSByZWFsbHkgbmljZSBpbnNpZ2h0cy5cclxuXHJcbkV2ZW4gdGhvdWdoIHdlIGNoYW5nZWQgdGhlIHRpbWUgZnJhbWVzLCBJIGRvblx1MjAxOXQgbGlrZSBjaGFuZ2luZyB1cCB0aG9zZSBtZXRob2RzIHRvbyBtdWNoLiBUaGUgYWdpbGUgbWV0aG9kcyBhcmUgc28gZm9jdXNlZCB0aGF0IHRha2luZyBzb21ldGhpbmcgb3V0IG1lYW5zIHlvdVx1MjAxOWxsIG1pc3MgYW4gaW1wb3J0YW50IHBhcnQgb2YgdGhlIHByb2Nlc3MuIEl0XHUyMDE5cyBsaWtlIGRyaXZpbmcgYSB0aHJlZS13aGVlbGVkIGNhci5cclxuXHJcbldoYXQgeW91IGNvdWxkIGRvIGlzIHRha2UgcGFydHMgb2YgdGhlIG1ldGhvZCBhbmQgdXNlIHRoZW0gaW4gZGlmZmVyZW50IGNvbnRleHRzLiBFdmVyeSBwaWVjZSBpcyB0aGVyZSB0byBzb2x2ZSBhIHNwZWNpZmljIHByb2JsZW0sIGluIGEgc3BlY2lmaWMgc3RhZ2Ugb2YgZ2VuZXJhdGluZyBpZGVhcy4gQW5kIG9mIGNvdXJzZSB5b3UgY2FuIHJldXNlIHRoZW0gaW4gb3RoZXIgc2l0dWF0aW9ucy5cclxuXHJcbi0tXHJcblxyXG48ZW0+QVBBIEVkaXRvci1pbi1DaGllZiBNaWNoYWVsIExhbmcgd2lsbCBiZSBhdCB0aGUgPGEgaHJlZj1cImh0dHBzOi8vZXZlbnRzLndhbi1pZnJhLm9yZy9ldmVudHMvNzB0aC13b3JsZC1uZXdzLW1lZGlhLWNvbmdyZXNzLTI1dGgtd29ybGQtZWRpdG9ycy1mb3J1bS9wcm9ncmFtbWVcIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPldvcmxkIE5ld3MgTWVkaWEgQ29uZ3Jlc3M8L2E+IHRvIHRhbGsgYWJvdXQgaGlzIGV4cGVyaWVuY2VzIHdvcmtpbmcgd2l0aCB0aGUgTGFiLiBKb2luIHVzIGZvciB0aGUgTGFiTHVuY2ggb24gRnJpZGF5IDggSnVuZS4gPC9lbT5cclxuXHJcbi0tXHJcblxyXG48ZW0+QWxzbyByZWFkIHRoZSBwcmV2aW91cyBhcnRpY2xlIG9uIHRoZSBBUEEtbWVkaWFsYWI6IDxhIGhyZWY9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvYXBhLW1lZGlhbGFiLWlubm92YXRpbmctam91cm5hbGlzbS10aHJvdWdoLXByb3RvdHlwZXMtYW5kLXRyZW5kLXJlc2VhcmNoL1wiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+SW5ub3ZhdGluZyBqb3VybmFsaXNtIHRocm91Z2ggcHJvdG90eXBlcyBhbmQgdHJlbmQgcmVzZWFyY2g8L2E+LjwvZW0+XHJcblxyXG4tLVxyXG5cclxuQ09OVEFDVCBQT0lOVFxyXG48aW1nIGNsYXNzPVwiYWxpZ25ub25lIHNpemUtZnVsbCB3cC1pbWFnZS0xMTU3N1wiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE4LzA0L1ByZXJvdnNreV9DbGVtZW5zX1BSX0NNWUsuanBnXCIgYWx0PVwiXCIgd2lkdGg9XCIyMDBcIiBoZWlnaHQ9XCIyNTBcIiAvPlxyXG5DbGVtZW5zIFByZXJvdnNreSwgQ0RPLCBBUEEtbWVkaWFsYWJcclxuV2ViOiA8YSBocmVmPVwiaHR0cHM6Ly9tZWRpYWxhYi5hcGEuYXQvXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5odHRwczovL21lZGlhbGFiLmFwYS5hdC88L2E+XHJcblR3aXR0ZXI6IDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2JsYWNrdGFybWFjXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5AYmxhY2t0YXJtYWMgXHUyMDBmPC9hPlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIyLzNcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxoMz5BdXRob3I8L2gzPlxyXG5bc2ltcGxlLWF1dGhvci1ib3hdWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddIiwicG9zdF90aXRsZSI6IiYjODIyMDtTdGljayB0byB0aGUgbWV0aG9kIGFuZCBkbyBpdCBieSB0aGUgYm9vaywgYXQgbGVhc3QgaW4gdGhlIGJlZ2lubmluZyYjODIyMTsiLCJwb3N0X2xpbmsiOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvc3RpY2stbWV0aG9kLWJvb2stbGVhc3QtYmVnaW5uaW5nLyIsInBvc3RfZmVhdHVyZWRfaW1hZ2UiOiI8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIiYjODIyMDtTdGljayB0byB0aGUgbWV0aG9kIGFuZCBkbyBpdCBieSB0aGUgYm9vaywgYXQgbGVhc3QgaW4gdGhlIGJlZ2lubmluZyYjODIyMTtcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjE4MVwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE4LzA0L1NjcmVlbi1TaG90LTIwMTgtMDQtMTgtYXQtMTAuMTAuMzctMzAweDE4MS5wbmdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj4iLCJwb3N0X2NhdGVnb3JpZXMiOiJJbm5vdmF0aW9uIENhc2UsIE1lZGlhIGxhYnMiLCJwb3N0X3RhZ3MiOiJBSSwgQXVzdHJpYSwgYXV0b21hdGlvbiwgZGVzaWduIHNwcmludCwgbWFjaGluZSBsZWFybmluZyIsIiVfdmNfcG9zdF9zZXR0aW5ncyUiOnsidmNfZ3JpZF9pZCI6W119LCIlX2VkaXRfbG9jayUiOiIxNTM1NTIzMzM4OjEwMSIsIiVfZWRpdF9sYXN0JSI6IjEwMSIsIiVzbGlkZV90ZW1wbGF0ZSUiOiJkZWZhdWx0IiwiJV93cGJfdmNfanNfc3RhdHVzJSI6InRydWUiLCIlX3dwZ21wX2xvY2F0aW9uX2FkZHJlc3MlIjoiVmllbm5hLCBBdXN0cmlhIiwiJV93cGdtcF9tZXRhYm94X2xhdGl0dWRlJSI6IjQ4LjIwODE3NDMiLCIlX3dwZ21wX21ldGFib3hfbG9uZ2l0dWRlJSI6IjE2LjM3MzgxODkwMDAwMDA2IiwiJV93cGdtcF9tZXRhYm94X2xvY2F0aW9uX3JlZGlyZWN0JSI6Im1hcmtlciIsIiVfd3BnbXBfbWV0YWJveF9jdXN0b21fbGluayUiOiIiLCIlX3dwZ21wX21hcF9pZCUiOiJhOjE6e2k6MDtzOjE6XCIyXCI7fSIsIiVfd3BnbXBfbWV0YWJveF9tYXJrZXJfaWQlIjoiTjsiLCIlX3dwZ21wX21ldGFib3hfdGF4b21vbWllc190ZXJtcyUiOiJOOyIsIiVfd3BnbXBfZXh0ZW5zaW9uc19maWVsZHMlIjoiTjsiLCIlX2tsZW9fdHJhbnNwYXJlbnRfbWVudV9jb2xvciUiOiJ3aGl0ZSIsIiVfa2xlb190aXRsZV9jaGVja2JveCUiOiIxIiwiJV9rbGVvX3RpdGxlX2NvbG9yJSI6IiMiLCIlX2tsZW9fdGl0bGVfYmclIjoiLCByZXBlYXQsIGluaGVyaXQsIHNjcm9sbCwgbGVmdCB0b3AiLCIlX2tsZW9fdGl0bGVfYmdfY29sb3IlIjoiIyIsIiVfeW9hc3Rfd3BzZW9fY29udGVudF9zY29yZSUiOiI5MCIsIiVfeW9hc3Rfd3BzZW9fcHJpbWFyeV9jYXRlZ29yeSUiOiIiLCIlX2pldHBhY2tfcmVsYXRlZF9wb3N0c19jYWNoZSUiOnsiNjIzOTNiMjQyYzdhNTYxNzc0ZjhlYmZmNWMxYzA1NjUiOnsiZXhwaXJlcyI6MTU0NTI5MTY0NywicGF5bG9hZCI6W3siaWQiOjExNzE0fSx7ImlkIjoxMDY1MX0seyJpZCI6MTA3MDR9XX19LCIlX3RodW1ibmFpbF9pZCUiOiIxMTU4MSIsIiVfeW9hc3Rfd3BzZW9fZm9jdXNrd190ZXh0X2lucHV0JSI6IkFQQS1tZWRpYWxhYiIsIiVfeW9hc3Rfd3BzZW9fZm9jdXNrdyUiOiJBUEEtbWVkaWFsYWIiLCIlX3lvYXN0X3dwc2VvX2xpbmtkZXglIjoiNjMiLCIlX3B1YmxpY2l6ZV9wZW5kaW5nJSI6IjEiLCIlX3dwX29sZF9kYXRlJSI6IjIwMTgtMDQtMTgiLCIlc2hhcmluZ19kaXNhYmxlZCUiOiIxIiwiJXN3aXRjaF9saWtlX3N0YXR1cyUiOiIwIiwiJV9zaG93X2F1dGhvcl9pbnRoaXNfcG9zdCUiOiJpbnRoaXNfcG9zdCIsIiVzYmdfc2VsZWN0ZWRfc2lkZWJhciUiOiIwIiwiJXNiZ19zZWxlY3RlZF9zaWRlYmFyX3JlcGxhY2VtZW50JSI6IjAiLCJ0YXhvbm9teT1jYXRlZ29yeSI6Iklubm92YXRpb24gQ2FzZSwgTWVkaWEgbGFicyIsInRheG9ub215PXBvc3RfdGFnIjoiQUksIEF1c3RyaWEsIGF1dG9tYXRpb24sIGRlc2lnbiBzcHJpbnQsIG1hY2hpbmUgbGVhcm5pbmcifSwiaWNvbiI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE4LzAyL21hcmtlci0xLnBuZyJ9LCJpZCI6MTE1NzQsImluZm93aW5kb3dfZGlzYWJsZSI6ZmFsc2V9LHsic291cmNlIjoicG9zdCIsInRpdGxlIjoiRnJhbmNlVFYgTGFiOiB0ZXN0aW5nIG5ldyB0b29scyBpbiB0aGUgbGFiIGZpcnN0IHRvIGZhY2lsaXRhdGUgYWRvcHRpb24gaW4gdGhlIG5ld3Nyb29tIiwiaW5mb3dpbmRvd19jb250ZW50IjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZ1wiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJGcmFuY2VUViBMYWI6IHRlc3RpbmcgbmV3IHRvb2xzIGluIHRoZSBsYWIgZmlyc3QgdG8gZmFjaWxpdGF0ZSBhZG9wdGlvbiBpbiB0aGUgbmV3c3Jvb21cIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjE2NVwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE4LzA0L1ZSLWFwcGxpY2F0aW9ucy0zMDB4MTY1LnBuZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmdcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXBhZGRpbmctY29udGVudF8yMFwiPlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLW1ldGEgZmMtaXRlbS1zZWNvbmRhcnktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZSBmYy10ZXh0LWNlbnRlclwiPklubm92YXRpb24gQ2FzZSwgTWVkaWEgbGFiczwvZGl2PlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLXRleHQtY2VudGVyXCI+RnJhbmNlVFYgTGFiOiB0ZXN0aW5nIG5ldyB0b29scyBpbiB0aGUgbGFiIGZpcnN0IHRvIGZhY2lsaXRhdGUgYWRvcHRpb24gaW4gdGhlIG5ld3Nyb29tPC9kaXY+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tY29udGVudCBmYy1pdGVtLWJvZHktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZVwiPlxyXG4gICAgICAgICAgICBJbiB0aGUgbGFiLCBGcmFuY2VUViB0ZXN0cyBuZXcgdG9vbHMgYW5kIGxlYXJucyBob3cgdG8gdXNlIHRoZW0gYmVmb3JlIGludHJvZHVjaW5nIHRoZW0gdG8gdGhlIG5ld3Nyb29tLiBBIHdheSB0byBzcHJlYWQgdGhlIGRpZ2l0YWwgY3VsdHVyZSBhbW9uZyBqb3VybmFsaXN0cywgd2hvIHRlbmQgdG8gYmUgY29uc2VydmF0aXZlIGFuZCBub3QgYWx3YXlzIG9wZW4gdG8gbmV3IHdheXMgb2Ygd29ya2luZy5cclxuICAgICAgICA8L2Rpdj5cclxuPGEgaHJlZj1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9mcmFuY2V0di1sYWItdGVzdGluZy1uZXctdG9vbHMtbGFiLWZpcnN0LWZhY2lsaXRhdGUtYWRvcHRpb24tbmV3c3Jvb20vXCI+UmVhZCBtb3JlPC9hPlxyXG4gICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuPC9kaXY+XHJcblxyXG4iLCJjb250ZW50IjoiSW4gdGhlIGxhYiwgRnJhbmNlVFYgdGVzdHMgbmV3IHRvb2xzIGFuZCBsZWFybnMgaG93IHRvIHVzZSB0aGVtIGJlZm9yZSBpbnRyb2R1Y2luZyB0aGVtIHRvIHRoZSBuZXdzcm9vbS4gQSB3YXkgdG8gc3ByZWFkIHRoZSBkaWdpdGFsIGN1bHR1cmUgYW1vbmcgam91cm5hbGlzdHMsIHdobyB0ZW5kIHRvIGJlIGNvbnNlcnZhdGl2ZSBhbmQgbm90IGFsd2F5cyBvcGVuIHRvIG5ldyB3YXlzIG9mIHdvcmtpbmcuIiwiYWRkcmVzcyI6IjcgRXNwbGFuYWRlIEhlbnJpIEZyYW5jZSwgNzUwMTUgUGFyaXMsIEZyYW5jZSIsImxvY2F0aW9uIjp7ImxhdCI6IjQ4LjgzOTM0ODgiLCJsbmciOiIyLjI3MTEyNTI5OTk5OTk5NDIiLCJvbmNsaWNrX2FjdGlvbiI6Im1hcmtlciIsInJlZGlyZWN0X3Blcm1hbGluayI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9mcmFuY2V0di1sYWItdGVzdGluZy1uZXctdG9vbHMtbGFiLWZpcnN0LWZhY2lsaXRhdGUtYWRvcHRpb24tbmV3c3Jvb20vIiwiem9vbSI6MiwiZXh0cmFfZmllbGRzIjp7InBvc3RfZXhjZXJwdCI6IkluIHRoZSBsYWIsIEZyYW5jZVRWIHRlc3RzIG5ldyB0b29scyBhbmQgbGVhcm5zIGhvdyB0byB1c2UgdGhlbSBiZWZvcmUgaW50cm9kdWNpbmcgdGhlbSB0byB0aGUgbmV3c3Jvb20uIEEgd2F5IHRvIHNwcmVhZCB0aGUgZGlnaXRhbCBjdWx0dXJlIGFtb25nIGpvdXJuYWxpc3RzLCB3aG8gdGVuZCB0byBiZSBjb25zZXJ2YXRpdmUgYW5kIG5vdCBhbHdheXMgb3BlbiB0byBuZXcgd2F5cyBvZiB3b3JraW5nLiIsInBvc3RfY29udGVudCI6Ilt2Y19yb3ddW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIyLzNcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxoMz5GcmFuY2VUViBMYWI6IHRlc3RpbmcgbmV3IHRvb2xzIGluIHRoZSBsYWIgZmlyc3QgdG8gZmFjaWxpdGF0ZSBhZG9wdGlvbiBpbiB0aGUgbmV3c3Jvb208L2gzPlxyXG48c3Ryb25nPkluIHRoZSBsYWIsIEZyYW5jZVRWIHRlc3RzIG5ldyB0b29scyBhbmQgbGVhcm5zIGhvdyB0byB1c2UgdGhlbSBiZWZvcmUgaW50cm9kdWNpbmcgdGhlbSB0byB0aGUgbmV3c3Jvb20uIEEgd2F5IHRvIHNwcmVhZCB0aGUgZGlnaXRhbCBjdWx0dXJlIGFtb25nIGpvdXJuYWxpc3RzLCB3aG8gdGVuZCB0byBiZSBjb25zZXJ2YXRpdmUgYW5kIG5vdCBhbHdheXMgb3BlbiB0byBuZXcgd2F5cyBvZiB3b3JraW5nLjwvc3Ryb25nPlxyXG5cclxuRnJhbmNlIFRcdTAwZTlsXHUwMGU5dmlzaW9ucyBpcyB0aGUgRnJlbmNoIHB1YmxpYyBicm9hZGNhc3Rpbmcgb3JnYW5pc2F0aW9uIGJhc2VkIGluIFBhcmlzLCB3aXRoIG92ZXIgMTAgMDAwIGVtcGxveWVlcy4gR3Jvd24gb3V0IG9mIGEgc21hbGwgaW5ub3ZhdGlvbiBkZXBhcnRtZW50IHRoYXQgZXhpc3RlZCB3aXRoaW4gRnJhbmNlIFRcdTAwZTlsXHUwMGU5dmlzaW9ucyBzaW5jZSAyMDEwLCB0aGUgbWVkaWEgbGFiIHdhcyBjcmVhdGVkIGluIDIwMTYgd2l0aCBhIHRyaXBsZSBtaXNzaW9uOlxyXG48dWw+XHJcblx0PGxpPlRlc3QgbmV3IHRvb2xzIHRoYXQgY291bGQgYmUgdXNlZnVsIGZvciB0aGUgbmV3c3Jvb20gYW5kIGZvciBkZXZlbG9waW5nIGF1ZGllbmNlczs8L2xpPlxyXG5cdDxsaT5Db25uZWN0IHRlbGV2aXNpb24gYW5kIG9ubGluZSBqb3VybmFsaXN0cywgZGV2ZWxvcGVycywgZGVzaWduZXJzLCBhbmQgc3RhcnQtdXBzOzwvbGk+XHJcblx0PGxpPkFuZCBoZWxwIHRoZSBuZXdzcm9vbSBiZWNvbWUgbW9yZSBhY2N1c3RvbWVkIHRvIGRpZ2l0YWwgY2hhbGxlbmdlcyB0aHJvdWdoIHRyYWluaW5nLCBrbm93bGVkZ2Ugc2hhcmluZyBhbmQgYmVzdCBwcmFjdGljZXMuPC9saT5cclxuPC91bD5cclxuQSBsYWIgbmVlZGVkIHRvIGJlIGNyZWF0ZWQgdG8gZ2V0IGNsb3NlciB0byB0aGUgbmV3c3Jvb20gYW5kIHRvIGhhdmUgYW4gYWN0dWFsIHRlYW06XHJcbjxibG9ja3F1b3RlPlx1MjAxY0lcdTIwMTltIG1vc3QgcHJvdWQgb2YgaG93IHRoZSBsYWIgaXMgd29ya2luZyB3aXRoIHRoZSBuZXdzcm9vbSBvbiB0aGUgb25lIGhhbmQgYW5kIHdpdGggZGV2ZWxvcGVycyBhbmQgZGVzaWduZXJzIG9uIHRoZSBvdGhlciBoYW5kLFwiIHNheXMgRXJpYyBTY2hlcmVyLFx1MDBhMERpcmVjdG9yIG9mIHRoZSBEaWdpdGFsIElubm92YXRpb24gZGVwYXJ0bWVudCBhbmQgSGVhZCBvZiBGcmFuY2VUViBMYWIuIFwiVGhlIGxhYiBpcyBwYXJ0IG9mIHRoZSBuZXdzcm9vbS4gSXRcdTIwMTlzIGEgcmVhbCBiZWdpbm5pbmcgb2YgY28td29ya2luZyBiZXR3ZWVuIGVuZ2luZWVycyBhbmQgZGVzaWduZXJzLCBhbmQgam91cm5hbGlzdHMgYW5kIHJlcG9ydGVycy5cdTIwMWQ8L2Jsb2NrcXVvdGU+XHJcbjxoMz5UZXN0aW5nIHRvb2xzPC9oMz5cclxuQXMgdGhlIGxhYiBkb2Vzblx1MjAxOXQgaGF2ZSBhbnkgZGV2ZWxvcGVycyBpdHNlbGYsIHRoZXkgd29yayBjbG9zZWx5IHRvZ2V0aGVyIHdpdGggdGhlIGlubm92YXRpb24gZGVwYXJ0bWVudCB0byBkZXZlbG9wIHRoZSB0b29scy4gVGhlIHRlYW0gb2YgdGhyZWUgam91cm5hbGlzdHMgYW5kIHRyYWluZWVzIHRlc3RzIHRvb2xzIGFuZCBsZWFybnMgaG93IHRvIHVzZSB0aGVtIGJlZm9yZSBkZWNpZGluZyB3aGV0aGVyIHRvIGludHJvZHVjZSB0aGVtIHRvIHRoZSBqb3VybmFsaXN0czpcclxuPGJsb2NrcXVvdGU+XHUyMDFjV2UgdHJ5IGFuZCB0ZXN0IHRvb2xzLiBJZiBpdFx1MjAxOXMgYSBnb29kIHRvb2wgd2Ugd2lsbCBwcmVzZW50IGl0IHRvIHRoZSBuZXdzcm9vbS4gSWYgdGhleVx1MjAxOXJlIGludGVyZXN0ZWQgdGhleSBidXkgaXQuIElmIG5vdCwgd2UgdGhyb3cgaXQgYXdheSxcdTIwMWQgZXhwbGFpbnMgRXJpYyBTY2hlcmVyLjwvYmxvY2txdW90ZT5cclxuRXZlbiB3aGVuIHRoZSB0b29scyBhcmUgbm90IGFkb3B0ZWQgYnkgdGhlIGpvdXJuYWxpc3RzLCB0aGUgbGFiXHUyMDE5cyB3b3JrIHJlbWFpbnMgdXNlZnVsLiBJdCBoZWxwcyBGcmFuY2UgVFx1MDBlOWxcdTAwZTl2aXNpb25zIHRvIHN0YXkgYXdhcmUgb2YgdGhlIGlubm92YXRpb25zIGluIHRoZSBhdWRpb3Zpc3VhbCBzZWN0b3IsIHN1c3RhaW4gYSBkaWFsb2d1ZSB3aXRoIHRoZSBzdGFydC11cCBlY29zeXN0ZW0gYW5kIGJlY29tZSBhY2N1bHR1cmVkIHRvIHRoZSBkaWdpdGFsIGNoYWxsZW5nZXMgdGhhdCB0aGUgbWVkaWEgbmVlZCB0byBmYWNlIHRvZGF5LlxyXG5cclxuSG93ZXZlciwgRXJpYyBkb2Vzblx1MjAxOXQgc2VlIHRoYXQgaXQgaGFzIGJlY29tZSBhbnkgZWFzaWVyIHRvIGludHJvZHVjZSBuZXcgdG9vbHMgdG8gdGhlIG5ld3Nyb29tIGNvbXBhcmVkIHRvIDIwMTYsIHdoZW4gdGhleSBmaXJzdCBzdGFydGVkIGRvaW5nIHRoaXM6IFx1MjAxY0l0XHUyMDE5cyBzdGlsbCB2ZXJ5IGRpZmZpY3VsdCwgYmVjYXVzZSBqb3VybmFsaXN0cyBhcmUgYWx3YXlzIGluIGEgcnVzaDsgdGhleSBoYXZlIG5vIHRpbWUgdG8gdHJ5IG5ldyB0aGluZ3MuXHUyMDFkXHJcblxyXG5BbHRob3VnaCBpdCBkZXBlbmRzIGEgbG90IG9uIHRoZSBpbmRpdmlkdWFsIGpvdXJuYWxpc3RzOlxyXG48YmxvY2txdW90ZT5cdTIwMWNJdCBkZXBlbmRzIG9uIHRoZSBkaWdpdGFsIGJhY2tncm91bmQgb2YgZXZlcnkgam91cm5hbGlzdCwgaWYgdGhleSBsaWtlIGl0LCBpZiB0aGV5XHUyMDE5cmUgeW91bmcuIEl0XHUyMDE5cyBub3QgY29ubmVjdGVkIHRvIHNwZWNpZmljIGRlcGFydG1lbnRzLiBXZSBqdXN0IGhhdmUgdG8ga25vdyB0aG9zZSBpbmRpdmlkdWFscyBhbmQgbGV0IHRoZW0gYmUgb3VyIGFtYmFzc2Fkb3JzIGluIHRoZSBuZXdzcm9vbS5cdTIwMWQ8L2Jsb2NrcXVvdGU+XHJcbjxoMz5OZXcgZm9ybWF0czwvaDM+XHJcblRyeWluZyB0byBjcmVhdGUgbmV3IGZvcm1hdHMgYW5kIHRvb2xzIHRvIHJlY29ubmVjdCB3aXRoIGF1ZGllbmNlczsgdGhhdFx1MjAxOXMgdGhlIGdvYWwuIEV4YW1wbGVzIG9mIHByb2plY3RzIGluY2x1ZGUgdGhlIHVzZSBvZiA8YSBocmVmPVwiaHR0cDovL3d3dy5mcmFuY2V0ZWxldmlzaW9ucy5mci9sYWIvcG93ZXItYmktbC1pbmZvcm1hdGlvbi1kZWNyeXB0ZWUtc291cy12b3MteWV1eFwiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+ZGF0YXZpc3VhbGlzYXRpb24gdGVjaG5vbG9naWVzPC9hPiBkdXJpbmcgdGhlIGVsZWN0b3JhbCBuaWdodHMgb24gdGhlIG5ld3MgY2hhbm5lbCBmcmFuY2VpbmZvLCBpbiBwYXJ0bmVyc2hpcCB3aXRoIE1pY3Jvc29mdCwgYW5kIGEgc2VyaW91cyBnYW1lIGFwcCBjYWxsZWQgPGEgaHJlZj1cImh0dHA6Ly93d3cuZnJhbmNldGVsZXZpc2lvbnMuZnIvbGFiL21hLWNhbXBhZ25lLWluZm9ybWF0aW9uLWdhbWlmaWVlXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5NYSBDYW1wYWduZTwvYT4sIGRldmVsb3BlZCB3aXRoIGpvdXJuYWxpc20gYW5kIGRlc2lnbiBzdHVkZW50cywgdGhhdCByZWFjaGVkIDM1LjAwMCBkb3dubG9hZHMuIEFzIHRoZSBsYWIgZG9lc25cdTIwMTl0IGhhdmUgYSBkZWRpY2F0ZWQgYnVkZ2V0LCBpdCB3b3JrcyB3aXRoIHBhcnRuZXJzIGluc2lkZSBhbmQgb3V0c2lkZSB0aGUgY29tcGFueSB0byBkZXZlbG9wIHRoZXNlIHByb2plY3RzLlxyXG48aDM+PGltZyBjbGFzcz1cImFsaWduY2VudGVyIHdwLWltYWdlLTExNjAyXCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTgvMDQvUG93ZXJCSS1wcm9qZWN0LTMwMHgxNjUuanBnXCIgYWx0PVwiXCIgd2lkdGg9XCI3NDBcIiBoZWlnaHQ9XCI0MDdcIiAvPjwvaDM+XHJcbkZvciBleGFtcGxlLCB3aXRoIHRoZSBQcmVzaWRlbnRpYWwgZWxlY3Rpb25zIGluIEZyYW5jZSBsYXN0IHllYXIsIHRoZSBsYWIgd29ya2VkIHRvZ2V0aGVyIGNsb3NlbHkgd2l0aCB0aGUgbmV3c3Jvb20gb24gYSBWaXJ0dWFsIFJlYWxpdHkgcHJvamVjdC4gSW4gdGhpcyA8YSBocmVmPVwiaHR0cDovL3d3dy5mcmFuY2V0ZWxldmlzaW9ucy5mci9sYWIvcHJlc2lkZW50aWVsbGUtMjAxNy12ci1sLWluZm9ybWF0aW9uLWltbWVyc2l2ZVwiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+VlIgYXBwbGljYXRpb248L2E+LCBhbGwgY2FuZGlkYXRlcyBoYWQgdGhlaXIgb3duIGF2YXRhcnMgdGhhdCBhbGxvd2VkIHZvdGVycyB0byBcdTIwMThtZWV0XHUyMDE5IHRoZSBjYW5kaWRhdGVzLCBkaXNjb3ZlciB0aGVpciBwcm9ncmFtbWVzIGFuZCBoYXZlIGFjY2VzcyB0byBhbGwgb2YgdGhlaXIgbWVkaWEgYXBwZWFyYW5jZXMuIFVzZXJzIG9mIHRoZSBhcHAgY291bGQgYWxzbyB0YWtlIGEgdmlydHVhbCB0b3VyIG9mIHRoZSBQYWxhaXMgZGUgbFx1MjAxOUVseXNcdTAwZTllOlxyXG48YmxvY2txdW90ZT5cdTIwMWNUaGUgaW1tZXJzaXZlIHRlY2hub2xvZ2llcyBjcmVhdGVkIGEgc2V0dGluZyBmb3IgYSByZWxhdGlvbnNoaXAgd2hlcmUgdGhlIHVzZXIgd2FzIGFuIGFjdG9yIGluIHRoZSBtZWV0aW5nIGFuZCBjb3VsZCBnZXQgdmVyeSBjbG9zZSB0byBnZW5lcmFsbHkgdW5hcHByb2FjaGFibGUgcG9saXRpY2lhbnMuXHUyMDFkPC9ibG9ja3F1b3RlPlxyXG48aDM+TGVhcm5pbmcgYW5kIHRyYWluaW5nPC9oMz5cclxuVW5mb3J0dW5hdGVseSwgbm90IGEgbG90IG9mIHBlb3BsZSBpbiBGcmFuY2Ugd2VyZSBhd2FyZSBvZiB0aGUgYXBwbGljYXRpb24sIHNvIGZldyBwZW9wbGUgYWN0dWFsbHkgdXNlZCBpdC4gT24gdGhlIGJyaWdodCBzaWRlLCB0aGUgRnJhbmNlVFYgTGFiIHRlYW0gbGVhcm5lZCBhIGxvdCBhYm91dCBWUiB0ZWNobm9sb2d5OlxyXG48YmxvY2txdW90ZT5cdTIwMWNUaGUgYXBwIHJlYWNoZWQgYSBxdWl0ZSByZXN0cmljdGVkIGF1ZGllbmNlIGNvbXBhcmVkIHRvIG91ciBvdGhlciBUViBhbmQgZGlnaXRhbCBjb250ZW50cyBvbiBwb2xpdGljcy4gQnV0IHdlIHN0aWxsIHJlYWNoZWQgb3VyIGdvYWwsIHdoaWNoIHdhcyB0byBzaG93IHRoYXQgRnJhbmNlIFRcdTAwZTlsXHUwMGU5dmlzaW9ucyBpcyBhYmxlIHRvIG9mZmVyIGlubm92YXRpdmUgbmV3cyBmb3JtYXRzLlx1MjAxZDwvYmxvY2txdW90ZT5cclxuRHJhd2luZyBvbiB0aGlzIGV4cGVyaWVuY2UsIHRoZSB0ZWFtIGtlZXBzIGV4cGxvcmluZyB0aGUgZWRpdG9yaWFsIGFwcGxpY2F0aW9ucyBvZiBuZXcgdGVjaG5vbG9naWVzIGFuZCBpcyBub3cgdHJhaW5pbmcgam91cm5hbGlzdHMgd2hvIHdhbnQgdG8gd29yayB3aXRoIDM2MFx1MDBiMCB2aWRlbzsgdGVhY2hpbmcgdGhlbSB0aGUgcnVsZXMgYW5kIGJlc3QgcHJhY3RpY2VzIG9mIHRoaXMgZm9ybWF0LlxyXG5cclxuVGhhdCBleHBlcnRpc2UgaXMgYWxzbyB1c2VmdWwgZm9yIG90aGVyIG1lZGlhIGNvbXBhbmllcy4gV2hlbiB0aGUgbGFiIGxlYXJuZWQgaG93IHRvIHVzZSBTbmFwY2hhdCB0byBwcm9kdWNlIG1lZGlhIGNvbnRlbnQgZm9yIGV4YW1wbGUsIHRoZXkgd2VyZSBub3Qgb25seSBhYmxlIHRvIHRyYWluIGpvdXJuYWxpc3RzIGF0IEZyYW5jZSBUXHUwMGU5bFx1MDBlOXZpc2lvbnMsIGJ1dCBhbHNvIGVsc2V3aGVyZSBpbiBQYXJpcyBhbmQgRnJhbmNlIG9uIGhvdyBiZXN0IHRvIHVzZSB0aGUgcGxhdGZvcm0uXHJcbjxoMz5CcmlkZ2VzIGluc2lkZSB0aGUgY29tcGFueTwvaDM+XHJcbkJlaW5nIHRoZSBoZWFkIG9mIGJvdGggdGhlIERpZ2l0YWwgSW5ub3ZhdGlvbiBkZXBhcnRtZW50IGFuZCB0aGUgbWVkaWEgbGFiIG1ha2VzIGl0IGVhc2llciB0byBidWlsZCBicmlkZ2VzIGJldHdlZW4gZGlmZmVyZW50IHBhcnRzIG9mIHRoZSBvcmdhbmlzYXRpb24sIHNheXMgRXJpYyBTY2hlcmVyOlxyXG48YmxvY2txdW90ZT5cdTIwMWNJdFx1MjAxOXMgZXhhY3RseSB0aGUgcmlnaHQgb3Bwb3J0dW5pdHkgdG8gYnVpbGQgYnJpZGdlcyBiZXR3ZWVuIHRoZSBkaWdpdGFsIGFuZCB0aGUgcmVzdCBvZiB0aGUgY29tcGFueSwgd2hpY2ggaXMgdmVyeSBkaWZmaWN1bHQuIERpZ2l0YWwgaXMgYWx3YXlzIHNlcGFyYXRlIGFuZCBpdFx1MjAxOXMgMSBrbSBhd2F5IGZyb20gdGhlIG9mZmljZS4gU28gdGhpcyBicmlkZ2UgaXMgYSBjb25jcmV0ZSBicmlkZ2UgYmV0d2VlbiB0aGUgZGlnaXRhbCBhbmQgb25lIG9mIHRoZSB0cmFkaXRpb25hbCBkZXBhcnRtZW50cywgd2hpY2ggaXMgdGhlIG5ld3Nyb29tLlx1MjAxZDwvYmxvY2txdW90ZT5cclxuSG93ZXZlciwgdGhlIGxhYlx1MjAxOXMgd29yayBzZWVtcyBtb3JlIHZpc2libGUgb3V0c2lkZSBvZiB0aGUgY29tcGFueSB0aGFuIGludGVybmFsbHkuIFdoaWxlIHRoZWlyIDxhIGhyZWY9XCJodHRwczovL3d3dy5tZXRhLW1lZGlhLmZyL1wiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+bWV0YS1tZWRpYSBibG9nPC9hPiBnZXRzIDUwLjAwMCB2aWV3cyBvbiBhdmVyYWdlIHBlciBtb250aCwgbW9zdCBGcmFuY2UgVFx1MDBlOWxcdTAwZTl2aXNpb25zIGpvdXJuYWxpc3RzIGRvIG5vdCByZWFsbHkgcmVhZCBpdDpcclxuPGJsb2NrcXVvdGU+XHUyMDFjSW4gRnJlbmNoIHdlIHNheSBcdTIwMThudWwgblx1MjAxOWVzdCBwcm9waFx1MDBlOHRlIGVuIHNvbiBwYXlzXHUyMDE5LiBXZVx1MjAxOWxsIHN0YXJ0IHNlbmRpbmcgb3V0IGEgbmV3c2xldHRlciBzb29uLCBhbmQgd2UgaGF2ZSB0byBvcmdhbmlzZSBtb3JlIHBoeXNpY2FsIG1lZXRpbmdzIGF0IGRpZmZlcmVudCBuZXdzIGRlcGFydG1lbnRzIHdpdGhpbiBvdXIgY29tcGFueS4gV2UgYXJlIG5vdCBkb2luZyBpdCBlbm91Z2guIEdvaW5nIGZvcndhcmQsIHdlIHdpbGwgYmUgbW9yZSBpbnNpZGUtbG9va2luZywgdG8gc2hhcmUgbW9yZSB3aXRoIHRoZSBuZXdzcm9vbS5cdTIwMWRcclxuXHJcbiZuYnNwOzwvYmxvY2txdW90ZT5cclxuQ09OVEFDVCBQT0lOVFxyXG48aW1nIGNsYXNzPVwiYWxpZ25ub25lIHNpemUtZnVsbCB3cC1pbWFnZS0xMTYwNVwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE4LzA0L2VyaWMtc2NoZXJlci5qcGdcIiBhbHQ9XCJcIiB3aWR0aD1cIjIwMFwiIGhlaWdodD1cIjI1MFwiIC8+XHJcbkVyaWMgU2NoZXJlciwgRGlyZWN0b3Igb2YgdGhlIERpZ2l0YWwgSW5ub3ZhdGlvbiBkZXBhcnRtZW50IGFuZCBIZWFkIG9mIEZyYW5jZVRWIExhYiwgRnJhbmNlIFRcdTAwZTlsXHUwMGU5dmlzaW9uc1xyXG5XZWI6IDxhIGhyZWY9XCJodHRwOi8vd3d3LmZyYW5jZXRlbGV2aXNpb25zLmZyL2xhYlwiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+aHR0cDovL3d3dy5mcmFuY2V0ZWxldmlzaW9ucy5mci9sYWI8L2E+XHJcblR3aXR0ZXI6IDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL0VyaWNTY2hlcmVyXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5ARXJpY1NjaGVyZXI8L2E+Wy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjIvM1wiXVt2Y19jb2x1bW5fdGV4dF1cclxuPGgzPkF1dGhvcjwvaDM+XHJcbltzaW1wbGUtYXV0aG9yLWJveF1bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd10iLCJwb3N0X3RpdGxlIjoiRnJhbmNlVFYgTGFiOiB0ZXN0aW5nIG5ldyB0b29scyBpbiB0aGUgbGFiIGZpcnN0IHRvIGZhY2lsaXRhdGUgYWRvcHRpb24gaW4gdGhlIG5ld3Nyb29tIiwicG9zdF9saW5rIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL2ZyYW5jZXR2LWxhYi10ZXN0aW5nLW5ldy10b29scy1sYWItZmlyc3QtZmFjaWxpdGF0ZS1hZG9wdGlvbi1uZXdzcm9vbS8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJGcmFuY2VUViBMYWI6IHRlc3RpbmcgbmV3IHRvb2xzIGluIHRoZSBsYWIgZmlyc3QgdG8gZmFjaWxpdGF0ZSBhZG9wdGlvbiBpbiB0aGUgbmV3c3Jvb21cIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjE2NVwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE4LzA0L1ZSLWFwcGxpY2F0aW9ucy0zMDB4MTY1LnBuZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6Iklubm92YXRpb24gQ2FzZSwgTWVkaWEgbGFicyIsInBvc3RfdGFncyI6IkZyYW5jZSwgSW1tZXJzaXZlLCBpbmR1c3RyeSBjb2xsYWJvcmF0aW9uLCB0b29scywgdHJhaW5pbmcgYW5kIGVkdWNhdGlvbiIsIiVfdmNfcG9zdF9zZXR0aW5ncyUiOnsidmNfZ3JpZF9pZCI6W119LCIlX2VkaXRfbG9jayUiOiIxNTcwMTE0Mzg1OjkzMSIsIiVfZWRpdF9sYXN0JSI6IjEwMSIsIiVzbGlkZV90ZW1wbGF0ZSUiOiJkZWZhdWx0IiwiJV93cGJfdmNfanNfc3RhdHVzJSI6InRydWUiLCIlX3dwZ21wX2xvY2F0aW9uX2FkZHJlc3MlIjoiNyBFc3BsYW5hZGUgSGVucmkgRnJhbmNlLCA3NTAxNSBQYXJpcywgRnJhbmNlIiwiJV93cGdtcF9tZXRhYm94X2xhdGl0dWRlJSI6IjQ4LjgzOTM0ODgiLCIlX3dwZ21wX21ldGFib3hfbG9uZ2l0dWRlJSI6IjIuMjcxMTI1Mjk5OTk5OTk0MiIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiMlwiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6Ik47IiwiJV93cGdtcF9tZXRhYm94X3RheG9tb21pZXNfdGVybXMlIjoiTjsiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6Ik47IiwiJV9rbGVvX3RyYW5zcGFyZW50X21lbnVfY29sb3IlIjoid2hpdGUiLCIlX2tsZW9fdGl0bGVfY29sb3IlIjoiIyIsIiVfa2xlb190aXRsZV9iZyUiOiIsIHJlcGVhdCwgaW5oZXJpdCwgc2Nyb2xsLCBsZWZ0IHRvcCIsIiVfa2xlb190aXRsZV9iZ19jb2xvciUiOiIjIiwiJV95b2FzdF93cHNlb19jb250ZW50X3Njb3JlJSI6IjMwIiwiJV95b2FzdF93cHNlb19wcmltYXJ5X2NhdGVnb3J5JSI6IjY5IiwiJV9rbGVvX3RpdGxlX2NoZWNrYm94JSI6IjEiLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza3dfdGV4dF9pbnB1dCUiOiJ0ZXN0aW5nIiwiJV95b2FzdF93cHNlb19mb2N1c2t3JSI6InRlc3RpbmciLCIlX3lvYXN0X3dwc2VvX2xpbmtkZXglIjoiNjgiLCIlX3RodW1ibmFpbF9pZCUiOiIxMTYwMyIsIiVfamV0cGFja19yZWxhdGVkX3Bvc3RzX2NhY2hlJSI6eyI2MjM5M2IyNDJjN2E1NjE3NzRmOGViZmY1YzFjMDU2NSI6eyJleHBpcmVzIjoxNTQ0NzU1MjA2LCJwYXlsb2FkIjpbeyJpZCI6MTEyMzV9LHsiaWQiOjExNjkxfSx7ImlkIjoxMDcwNH1dfX0sIiVfcHVibGljaXplX3BlbmRpbmclIjoiMSIsIiVzYmdfc2VsZWN0ZWRfc2lkZWJhciUiOiIwIiwiJXNiZ19zZWxlY3RlZF9zaWRlYmFyX3JlcGxhY2VtZW50JSI6IjAiLCJ0YXhvbm9teT1jYXRlZ29yeSI6Iklubm92YXRpb24gQ2FzZSwgTWVkaWEgbGFicyIsInRheG9ub215PXBvc3RfdGFnIjoiRnJhbmNlLCBJbW1lcnNpdmUsIGluZHVzdHJ5IGNvbGxhYm9yYXRpb24sIHRvb2xzLCB0cmFpbmluZyBhbmQgZWR1Y2F0aW9uIn0sImljb24iOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxOC8wMi9tYXJrZXItMS5wbmcifSwiaWQiOjExNTY4LCJpbmZvd2luZG93X2Rpc2FibGUiOmZhbHNlfSx7InNvdXJjZSI6InBvc3QiLCJ0aXRsZSI6Ik1lZGlhIGFuZCBEZW1vY3JhY3k6IHJlc2VhcmNoIGFuZCBpbm5vdmF0aW9uIHRvIHN0cmVuZ3RoZW4gam91cm5hbGlzbSwgcHVibGljIGRpc2NvdXJzZSBhbmQgZGVtb2NyYWN5IiwiaW5mb3dpbmRvd19jb250ZW50IjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZ1wiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJNZWRpYSBhbmQgRGVtb2NyYWN5OiByZXNlYXJjaCBhbmQgaW5ub3ZhdGlvbiB0byBzdHJlbmd0aGVuIGpvdXJuYWxpc20sIHB1YmxpYyBkaXNjb3Vyc2UgYW5kIGRlbW9jcmFjeVwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMTcwXCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTgvMDQvTWVkaWEtZGVtb2NyYWN5LW1lZGlhbGFiLTMwMHgxNzAuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZ1wiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tcGFkZGluZy1jb250ZW50XzIwXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tbWV0YSBmYy1pdGVtLXNlY29uZGFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlIGZjLXRleHQtY2VudGVyXCI+SW5ub3ZhdGlvbiBDYXNlLCBNZWRpYSBsYWJzPC9kaXY+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tdGl0bGUgZmMtaXRlbS1wcmltYXJ5LXRleHQtY29sb3IgZmMtdGV4dC1jZW50ZXJcIj5NZWRpYSBhbmQgRGVtb2NyYWN5OiByZXNlYXJjaCBhbmQgaW5ub3ZhdGlvbiB0byBzdHJlbmd0aGVuIGpvdXJuYWxpc20sIHB1YmxpYyBkaXNjb3Vyc2UgYW5kIGRlbW9jcmFjeTwvZGl2PlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2VcIj5cclxuICAgICAgICAgICAgTWVkaWEgb3JnYW5pc2F0aW9ucywgYWNhZGVtaWNzIGFuZCBwdWJsaWMgaW5zdGl0dXRpb25zIHdvcmsgdG9nZXRoZXIgb24gZXhwZXJpbWVudGFsIGlubm92YXRpb24gYW5kIHJlc2VhcmNoIGF0IExpbmRob2xtZW4gU2NpZW5jZSBQYXJrLlxyXG4gICAgICAgIDwvZGl2PlxyXG48YSBocmVmPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL21lZGlhLWFuZC1kZW1vY3JhY3ktbGluZGhvbG1lbi9cIj5SZWFkIG1vcmU8L2E+XHJcbiAgICA8L2Rpdj5cclxuICAgIDwvZGl2PlxyXG48L2Rpdj5cclxuXHJcbiIsImNvbnRlbnQiOiJNZWRpYSBvcmdhbmlzYXRpb25zLCBhY2FkZW1pY3MgYW5kIHB1YmxpYyBpbnN0aXR1dGlvbnMgd29yayB0b2dldGhlciBvbiBleHBlcmltZW50YWwgaW5ub3ZhdGlvbiBhbmQgcmVzZWFyY2ggYXQgTGluZGhvbG1lbiBTY2llbmNlIFBhcmsuIiwiYWRkcmVzcyI6IkxpbmRob2xtZW4sIEdvdGhlbmJ1cmcsIFN3ZWRlbiIsImxvY2F0aW9uIjp7ImxhdCI6IjU3LjcwNzc1OTkiLCJsbmciOiIxMS45MzgyODY1MDAwMDAwMDQiLCJvbmNsaWNrX2FjdGlvbiI6Im1hcmtlciIsInJlZGlyZWN0X3Blcm1hbGluayI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9tZWRpYS1hbmQtZGVtb2NyYWN5LWxpbmRob2xtZW4vIiwiem9vbSI6MiwiZXh0cmFfZmllbGRzIjp7InBvc3RfZXhjZXJwdCI6Ik1lZGlhIG9yZ2FuaXNhdGlvbnMsIGFjYWRlbWljcyBhbmQgcHVibGljIGluc3RpdHV0aW9ucyB3b3JrIHRvZ2V0aGVyIG9uIGV4cGVyaW1lbnRhbCBpbm5vdmF0aW9uIGFuZCByZXNlYXJjaCBhdCBMaW5kaG9sbWVuIFNjaWVuY2UgUGFyay4iLCJwb3N0X2NvbnRlbnQiOiJbdmNfcm93XVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMi8zXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48aDE+TWVkaWEgYW5kIERlbW9jcmFjeTogcmVzZWFyY2ggYW5kIGlubm92YXRpb24gdG8gc3RyZW5ndGhlbiBqb3VybmFsaXNtLCBwdWJsaWMgZGlzY291cnNlIGFuZCBkZW1vY3JhY3k8L2gxPlxyXG48c3Ryb25nPk1lZGlhIG9yZ2FuaXNhdGlvbnMsIGFjYWRlbWljcyBhbmQgcHVibGljIGluc3RpdHV0aW9ucyB3b3JrIHRvZ2V0aGVyIG9uIGV4cGVyaW1lbnRhbCBpbm5vdmF0aW9uIGFuZCByZXNlYXJjaCBhdCBMaW5kaG9sbWVuIFNjaWVuY2UgUGFyay48L3N0cm9uZz5cclxuXHJcbkluIHRoZSBzdW1tZXIgb2YgMjAxNywgdGhlIE1lZGlhIGFuZCBEZW1vY3JhY3kgcmVzZWFyY2ggYW5kIGlubm92YXRpb24gcHJvZ3JhbW1lIHdhcyBsYXVuY2hlZCB0byBmYWNpbGl0YXRlIGNvbGxhYm9yYXRpb24gb24gZXhwZXJpbWVudGFsIHByb2plY3RzIGJldHdlZW4gdW5pdmVyc2l0aWVzIGFuZCBtZWRpYSBjb21wYW5pZXMgaW4gU3dlZGVuLiBJdHMgY29yZSBtaXNzaW9uIGlzIHRvIGluaXRpYXRlLCBmaW5hbmNlIGFuZCBydW4gcmVzZWFyY2ggYW5kIGlubm92YXRpb24gcHJvamVjdHMgdGhhdCBwcm92aWRlIG5ldyBrbm93bGVkZ2UgYW5kIHRvb2xzIGZvciBqb3VybmFsaXNtIGFuZCBjaXZpbCBkaWFsb2cuXHJcblxyXG5IZWFkIG9mIHRoZSBwcm9ncmFtbWUgTWFydGluIEhvbG1iZXJnIGFuZCBoaXMgY29sbGVhZ3VlIEpvbmF0aGFuIEZhbGNrIGJyaW5nIHRvZ2V0aGVyIGRpZmZlcmVudCBhY3RvcnMgYW5kIHNoYXJlIG5ldyBpbnNpZ2h0cyBhYm91dCB0aGUgd2F5cyBpbiB3aGljaCBpbm5vdmF0aW9uIGluZmx1ZW5jZXMgbWVkaWEgYW5kIGRlbW9jcmFjeSB0aHJvdWdoIHJlcG9ydHMgYW5kIHNlbWluYXJzLiBCdWlsdCBvbiB0aGUgaWRlYWxzIG9mIG9wZW4gaW5ub3ZhdGlvbiwgY2l0aXplbnMgYXJlIHdlbGNvbWUgdG8gcGFydGljaXBhdGUgaW4gdGhlaXIgYWN0aXZpdGllcyBhcyB3ZWxsLlxyXG5cclxuV2hpbGUgbWVkaWEgY29tcGFuaWVzIGRvblx1MjAxOXQgY29sbGFib3JhdGUgYXMgbXVjaCBhcyB0aGV5IGNvdWxkIG9yIHNob3VsZCwgYWNhZGVtaWNzIGFyZSBpbmNyZWFzaW5nbHkgbG9va2luZyB0byBnZXQgYWNjZXNzIHRvIG5ld3Mgb3JnYW5pc2F0aW9ucyBmb3IgbWFraW5nIHRoZWlyIHJlc2VhcmNoIG1vcmUgcmVsZXZhbnQgdG8gcHJhY3RpY2UuIEFjY29yZGluZyB0byBNYXJ0aW4sIExpbmRob2xtZW4gU2NpZW5jZSBQYXJrIHByb3ZpZGVzIGEgbmV1dHJhbCBzcGFjZSB3aGVyZSB0aGV5IGNhbiBtZWV0IHBoeXNpY2FsbHkgYW5kIG1lbnRhbGx5IHRvIGRldmVsb3AgaW5ub3ZhdGl2ZSBpZGVhcyB0b2dldGhlcjpcclxuPGJsb2NrcXVvdGU+XHUyMDFjV2UgYXJlIGEgbm9uLXByb2ZpdCBjb21wYW55LiBPdXIgbWlzc2lvbiBpcyB0byBnZXQgYmVuZWZpdHMgdG8gc29jaWV0eSBhbmQgZ2V0IHRoZSBhY3RvcnMgdG8gc3VjY2VlZC4gTm8gb25lIGNhbiBiZSBhZnJhaWQgb2YgTGluZGhvbG1lbiwgYmVjYXVzZSB3ZSBoYXZlIHRoZSBtaXNzaW9uIGp1c3QgdG8gZG8gbmljZSB0aGluZ3MgZm9yIGFsbCB0aGUgcGVvcGxlIGluIG91ciBuZXR3b3JrLlwiPC9ibG9ja3F1b3RlPlxyXG48aDM+UmVpbmZvcmNpbmcgbG9jYWwgZGVtb2NyYWN5PC9oMz5cclxuU3dlZGlzaCBsb2NhbCBuZXdzcGFwZXIgQm9yXHUwMGU1cyBUaWRuaW5nLCBSSVNFIEludGVyYWN0aXZlIGFuZCBTXHUwMGY2ZGVydFx1MDBmNnJuIFVuaXZlcnNpdHkgYXJlIHBhcnQgb2Ygb25lIG9mIHRoZSBMYWJcdTIwMTlzIDxhIGhyZWY9XCJodHRwczovL21lZGllcm9jaGRlbW9rcmF0aS5saW5kaG9sbWVuLnNlL2VuL25ld3MvbWVkaWEtZGVtb2NyYWN5LWxhdW5jaGVzLXRlc3QtZWRpdG9yaWFsLXRlYW0tbmV3LWxvY2FsLWpvdXJuYWxpc21cIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPmZpcnN0IHByb2plY3RzPC9hPi4gSW4gYW4gYXR0ZW1wdCB0byBzdHJlbmd0aGVuIGpvdXJuYWxpc20gYXQgdGhlIGxvY2FsIGxldmVsLCB0aGUgcHJvamVjdCBydW5zIGFuIGV4cGVyaW1lbnQgd2l0aCB0b3BpY3MgYW5kIGZvcm1hdHMgaW50ZXJlc3RpbmcgZm9yIHlvdW5nZXIgYXVkaWVuY2VzOlxyXG48YmxvY2txdW90ZT5cdTIwMWNUaGUgcGFwZXIgaGFzIGVtcGxveWVkIGZvdXIgcGVvcGxlIGJldHdlZW4gMjUgYW5kIDM1IHllYXJzIG9sZCB0aGF0IHdvcmsgaW4gdGhlIG5ld3NwYXBlcjsgc29tZSBhcmUgam91cm5hbGlzdHMsIHNvbWUgYXJlIG5vdC4gVGhleSBkb25cdTIwMTl0IGhhdmUgdG8gbGlzdGVuIHRvIHRoZSBlZGl0b3JzIGxpa2UgdGhlIG90aGVyIGpvdXJuYWxpc3RzLCBzbyB3ZSBjYW4gY29tcGFyZSB0aGUgZGlmZmVyZW5jZS4gVGhhdFx1MjAxOXMgdGhlIHdheSB3ZSB0eXBpY2FsbHkgd2FudCB0byB3b3JrLCB0aHJvdWdoIGV4cGVyaW1lbnRhdGlvbi5cdTIwMWQ8L2Jsb2NrcXVvdGU+XHJcbjxpbWcgY2xhc3M9XCJhbGlnbmNlbnRlciB3cC1pbWFnZS0xMTU1OSBzaXplLWZ1bGxcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxOC8wNC9FeHBlcmltZW50YWwtbmV3c3Jvb20tYXQtQm9yYVx1MDMwYXMtVGlkbmluZy1lMTUyMzAxMTY5MTIxNS5qcGdcIiBhbHQ9XCJcIiB3aWR0aD1cIjkyN1wiIGhlaWdodD1cIjcwMFwiIC8+XHJcblxyXG5UaGlzIGtpbmQgb2YgcHJvamVjdCBpcyBvbmUgb2YgdGhlIHdheXMgaW4gd2hpY2ggTGluZGhvbG1lbiBpcyBhZGRyZXNzaW5nIHRoZSBjaGFsbGVuZ2Ugb2YgZGV2ZWxvcGluZyB0aGUgbG9jYWwgc29jaWV0eSBpbiBhIG5ldyBtZWRpYSBsYW5kc2NhcGUuIEV2ZW4gdGVuIHllYXJzIGFnbywgZGlzY3Vzc2lvbnMgc3RpbGwgaGFwcGVuZWQgcHJpbWFyaWx5IG9uIGxvY2FsIHBsYXRmb3Jtczsgbm93IHRoZXkgbW9zdGx5IHRha2UgcGxhY2Ugb24gc29jaWFsIG1lZGlhLiBUaGF0IHJhaXNlcyBpbXBvcnRhbnQgaXNzdWVzIGZvciBtZWRpYSBhbmQgZGVtb2NyYWN5LCBzYXlzIE1hcnRpbjpcclxuPGJsb2NrcXVvdGU+XHUyMDFjSG93IGNhbiB3ZSBtYWtlIHN1cmUgdGhhdCBpbiB0aGUgZnV0dXJlIHlvdSBjYW4gZGV2ZWxvcCB0aGUgcHVibGljIGRpc2N1c3Npb24gaW4gdGhlIGxvY2FsIHNvY2lldHksIGluIHRoZSBzZW5zZSB0aGF0IHBlb3BsZSBzaGFyZSBlbm91Z2ggaW1wb3J0YW50IGluZm9ybWF0aW9uIHRvIGJlIGFibGUgdG8gaGF2ZSBwcm9zcGVjdGl2ZSwgZGVtb2NyYXRpYyBkaXNjdXNzaW9ucyB0b2dldGhlcj8gT24gc29jaWFsIG1lZGlhIHlvdSBkb25cdTIwMTl0IHNoYXJlIHRoZSBzYW1lIGluZm9ybWF0aW9uLCBzbyBkZXZlbG9waW5nIHRoZSBsb2NhbCBzb2NpZXR5IGJlY29tZXMgYSBjaGFsbGVuZ2UuXHUyMDFkPC9ibG9ja3F1b3RlPlxyXG48aDM+TmV3IG1lZGlhIGJlaGF2aW91cjwvaDM+XHJcbkFzIHNvY2lldHkgY2hhbmdlcywgc28gZG8gdGhlIHdheXMgaW4gd2hpY2ggcGVvcGxlIGludGVyYWN0IHdpdGggbWVkaWE6XHJcbjxibG9ja3F1b3RlPlx1MjAxY0kgY2FuIHNlZSBteSB3aWZlIGFuZCBJIGZvciBleGFtcGxlIGxpdmUgdmVyeSBkaWZmZXJlbnRseSB0aGFuIG15IHBhcmVudHMuIEkgbGl2ZSBpbiBhIHNtYWxsIHRvd24gbm9ydGggb2YgR290aGVuYmVyZywgd2UgdGFrZSB0aGUgY29tbXV0aW5nIHRyYWluLCBzbyB3ZSBjYW5cdTIwMTl0IHNwZW5kIHRpbWUgb24gdGhlIHNhbWUgdGhpbmdzIG15IHBhcmVudHMgZGlkLlxyXG5cclxuTXkgcGFyZW50cyB3b3JrZWQgd2l0aGluIDEwIG1pbnV0ZXMgYnkgYmljeWNsZSBmcm9tIG91ciBob21lLiBUaGV5IHBpY2tlZCB1cCB0aGUgbmV3c3BhcGVyIGluIHRoZSBtb3JuaW5nIGFuZCBpbiB0aGUgZXZlbmluZy4gSSByZW1lbWJlciBteSBmYXRoZXIgc29tZXRpbWVzIGNhbWUgaG9tZSBmb3IgbHVuY2ggYW5kIHRoZW4gYmlrZWQgYmFjay5cclxuXHJcbkkgZG9uXHUyMDE5dCBrbm93IGFueSBwZW9wbGUgb2YgbXkgYWdlIHdobyBkbyB0aGlzLlx1MjAxZDwvYmxvY2txdW90ZT5cclxuV2l0aCBldmVyeSBwcm9qZWN0LCB0aGUgZ29hbCBpcyB0byBmaW5kIG91dCBob3cgcGVvcGxlIGFjdCwgd2hhdCBpcyBpbXBvcnRhbnQgZm9yIHRoZW0sIGFuZCBwb3NzaWJseSB0byBkZXZlbG9wIHNvbWUgdGVjaG5vbG9naWVzIHRvIHN1cHBvcnQgdGhhdC4gQnV0IHRlY2hub2xvZ3kgaXMgbm90IGluIHRoZSBtaWRkbGU7IHRoZSBzdGFydGluZyBwb2ludCBpcyB3aGF0IHBlb3BsZSBuZWVkLlxyXG48aDM+Qm90dG9tLXVwIHByb2JsZW0gZmluZGluZzwvaDM+XHJcbkluIHRoZSBzYW1lIHdheSwgTWVkaWEgYW5kIERlbW9jcmFjeSBkZWNpZGVzIHdoYXQgdG9waWNzIHRvIHRhY2tsZSBieSBhc2tpbmcgaXRzIG5ldHdvcmsgd2hhdCB0aGVpciBtYWluIGNoYWxsZW5nZXMgYXJlLiBGb3VyIHRpbWVzIGEgeWVhciwgdGhleSBpbnZpdGUgcGVvcGxlIHdpdGggZGlmZmVyZW50IHNraWxscyBhbmQgZXhwZXJpZW5jZXMgdG8gcm91bmQgdGFibGVzLCBpbmNsdWRpbmcgc2Nob2xhcnMsIG1lZGlhIGNvbXBhbmllcyBhbmQgY2l0aXplbnM6XHJcbjxibG9ja3F1b3RlPlx1MjAxY1dlIGRpc2N1c3Mgd2hhdCBraW5kcyBvZiBjaGFsbGVuZ2VzIHRoZXkgc2VlLCB3aGF0IHByb2plY3RzIHdvdWxkIGJlIHBlcmZlY3QgdG8gZmluZCBuZXcga25vd2xlZGdlIGFib3V0IHRoZXNlIGNoYWxsZW5nZXMsIHdoYXQgZXhwZXJpbWVudGFsIHdheXMgdGhlcmUgYXJlIHRvIGRldmVsb3AgbmV3IGtub3dsZWRnZSwgYW5kIHdobyBpbiB0aGUgcm9vbSB3b3VsZCB3YW50IHRvIHBhcnRpY2lwYXRlIGluIHN1Y2ggYSBwcm9qZWN0IG9yIGhhcyBpZGVhcyBhYm91dCB3aG8gd2Ugc2hvdWxkIHRhbGsgdG8uXHUyMDFkPC9ibG9ja3F1b3RlPlxyXG5JdFx1MjAxOXMgZXNwZWNpYWxseSByZW1hcmthYmxlIGhvdyBkaWZmZXJlbnQgYWN0b3JzIG9mdGVuIGhhdmUgdmVyeSBzaW1pbGFyIGlzc3VlcyBvbiB0aGVpciBtaW5kcywgc2F5cyBNYXJ0aW4uIFRoZSByb2xlIG9mIE1lZGlhIGFuZCBEZW1vY3JhY3kgaXMgdG8gY29sbGVjdCB0aGlzIGlucHV0IGFuZCB0dXJuIGl0IGludG8gY29uY3JldGUgcHJvamVjdHM6XHJcbjxibG9ja3F1b3RlPlx1MjAxY0FmdGVyIHRoZXNlIHJvdW5kIHRhYmxlcyB0aGV5IHJldHVybiB0byB0aGVpciBub3JtYWwgZGF5IHdvcmssIGJ1dCB3ZSBoYXZlIHRoZSB0aW1lIGFuZCBvcHBvcnR1bml0eSB0byB0aGluayBhYm91dCBob3cgd2UgY291bGQgZG8gdGhpcywgd2hhdCBwYXJ0bmVycyB3ZSBjb3VsZCBpbnZpdGUsIHdoZXJlIHdlIGNvdWxkIGZpbmQgZnVuZGluZy4gU28gd2UgZG8gYSBsb3Qgb2Ygd29yayBpbiB0aGUgYmFja2dyb3VuZCB0byBnZXQgdGhlc2UgcHJvamVjdHMgdXAgYW5kIHJ1bm5pbmcuXHUyMDFkPC9ibG9ja3F1b3RlPlxyXG5CYXNpYyBmdW5kaW5nIGZvciB0aGUgcHJvamVjdHMgY29tZXMgZnJvbSB0aGUgUmVnaW9uIFZcdTAwZTRzdHJhIEdcdTAwZjZ0YWxhbmQsIGJ1dCB0aGUgaW5pdGlhdGl2ZSBpcyBhbHNvIHN1cHBvcnRlZCBieSBjb21tZXJjaWFsIG1lZGlhLCBwdWJsaWMgYnJvYWRjYXN0aW5nIGNvbXBhbmllcyBhbmQga2V5IG1lZGlhIHBsYXllcnMgaW4gdGhlIFN3ZWRpc2ggYWNhZGVtaWMgY29tbXVuaXR5LlxyXG48aDM+QW4gaW5ub3ZhdGl2ZSBlbnZpcm9ubWVudDwvaDM+XHJcblRoZSBMaW5kaG9sbWVuIFNjaWVuY2UgUGFyayBlbWVyZ2VkIG9ubHkgcmVjZW50bHkgaW4gdGhlIG9sZCBoYXJib3Igb2YgR290aGVuYmVyZy4gV2hlbiB0aGUgc2hpcCBidWlsZGluZyBjb21wYW5pZXMgY2xvc2VkIHRoZWlyIGRvb3JzIGluIHRoZSAxOTcwcywgdGhlIFNjaWVuY2UgUGFyayBzdWNjZXNzaXZlbHkgdG9vayB0aGVpciBwbGFjZSBhbmQgYXR0cmFjdGVkIGNvbXBhbmllcyBpbiB0aGUgSVQsIGF1dG8gbW9iaWxpdHkgYW5kIG1lZGlhIHNlY3RvcnMuIFNjaWVuY2UgUGFya3MgaW4gU3dlZGVuIGFyZSBnZW5lcmFsbHkgYWltZWQgYXQgYnVzaW5lc3NlcywgYnV0IExpbmRob2xtZW4gaXMgY29ubmVjdGluZyB0ZWNobm9sb2d5IGFuZCBjcmVhdGl2aXR5LiBUaGV5IGFpbSB0byBicmluZyB0b2dldGhlciBkaWZmZXJlbnQgcGVyc3BlY3RpdmVzIGFuZCBkaWZmZXJlbnQgc2tpbGxzIHRvIGZpbmQgbmV3IHNvbHV0aW9uczpcclxuPGJsb2NrcXVvdGU+XHUyMDFjVGhlIGdhbWUgaW5jdWJhdG9yIGxhdW5jaGVzIGdhbWVzIHRoYXQgYXJlIGJlaW5nIGRvd25sb2FkZWQgYW5kIGdlbmVyYXRlIGJ1c2luZXNzLiBIYWxmIG9mIGFsbCBmaWxtcyBpbiBTd2VkZW4gYXJlIGluIHNvbWUgd2F5IGNvbm5lY3RlZCB0byB0aGUgZmlsbSBjbHVzdGVyIGF0IExpbmRob2xtZW4gU2NpZW5jZSBQYXJrLiBBbmQgc2V2ZXJhbCBjb21wYW5pZXMgYW5kIGNvbW11bml0aWVzIHVzZSB0aGUgdmlzdWFsaXNhdGlvbiB0ZWNobm9sb2d5IGFuZCBlbnZpcm9ubWVudCBoZXJlLCBpbmNsdWRpbmcgdG8gc3RyZW5ndGhlbiBkZW1vY3JhY3kuXHJcblxyXG5UaGVyZSBtaWdodCBiZSBwb3NzaWJpbGl0aWVzIHRvIGNvbWJpbmUgc29tZSBvZiB0aGUgZXhwZXJ0aXNlIGFuZCB0aGUgdGVjaG5vbG9naWVzIHByZXNlbnQgaW4gdGhlIGNsdXN0ZXIgZm9yIG1lZGlhIGlubm92YXRpb24uXHUyMDFkPC9ibG9ja3F1b3RlPlxyXG5BbHRob3VnaCB0aGUgTWVkaWEgYW5kIERlbW9jcmFjeSBwcm9ncmFtbWUgaXMgc3RpbGwgdmVyeSB5b3VuZywgTWFydGluIGhvcGVzIGl0cyBzdWNjZXNzIHdpbGwgYmUgc2ltaWxhciB0byB0aGF0IG9mIHRoZSBcdTIwMThvbGRlclx1MjAxOSBsYWJzIGF0IExpbmRob2xtZW4gU2NpZW5jZSBQYXJrLlxyXG5cclxuQ09OVEFDVCBQT0lOVFxyXG48aW1nIGNsYXNzPVwiYWxpZ25ub25lIHNpemUtZnVsbCB3cC1pbWFnZS0xMTU1NFwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE4LzA0L01hcnRpbkhvbWxiZXJnLTIwMTYtd2ViYi5qcGdcIiBhbHQ9XCJcIiB3aWR0aD1cIjIwMFwiIGhlaWdodD1cIjI1MFwiIC8+XHJcbk1hcnRpbiBIb2xtYmVyZywgSGVhZCBvZiBNZWRpYSAmYW1wOyBEZW1vY3JhY3ksIExpbmRob2xtZW4gU2NpZW5jZSBQYXJrXHJcbldlYjogPGEgaHJlZj1cImh0dHBzOi8vbWVkaWVyb2NoZGVtb2tyYXRpLmxpbmRob2xtZW4uc2UvZW5cIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPmh0dHBzOi8vbWVkaWVyb2NoZGVtb2tyYXRpLmxpbmRob2xtZW4uc2UvZW48L2E+XHJcblR3aXR0ZXI6IDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL0xpbmRob2xtZW5cIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPkBMaW5kaG9sbWVuPC9hPlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIyLzNcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxoMz5BdXRob3I8L2gzPlxyXG5bc2ltcGxlLWF1dGhvci1ib3hdWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddIiwicG9zdF90aXRsZSI6Ik1lZGlhIGFuZCBEZW1vY3JhY3k6IHJlc2VhcmNoIGFuZCBpbm5vdmF0aW9uIHRvIHN0cmVuZ3RoZW4gam91cm5hbGlzbSwgcHVibGljIGRpc2NvdXJzZSBhbmQgZGVtb2NyYWN5IiwicG9zdF9saW5rIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL21lZGlhLWFuZC1kZW1vY3JhY3ktbGluZGhvbG1lbi8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJNZWRpYSBhbmQgRGVtb2NyYWN5OiByZXNlYXJjaCBhbmQgaW5ub3ZhdGlvbiB0byBzdHJlbmd0aGVuIGpvdXJuYWxpc20sIHB1YmxpYyBkaXNjb3Vyc2UgYW5kIGRlbW9jcmFjeVwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMTcwXCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTgvMDQvTWVkaWEtZGVtb2NyYWN5LW1lZGlhbGFiLTMwMHgxNzAuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+IiwicG9zdF9jYXRlZ29yaWVzIjoiSW5ub3ZhdGlvbiBDYXNlLCBNZWRpYSBsYWJzIiwicG9zdF90YWdzIjoiYWNhZGVtaWMgY29sbGFib3JhdGlvbiwgZXhwZXJpbWVudHMsIGluZHVzdHJ5IGNvbGxhYm9yYXRpb24sIGxvY2FsIGpvdXJuYWxpc20sIFN3ZWRlbiwgeW91bmcgYXVkaWVuY2VzIiwiJV92Y19wb3N0X3NldHRpbmdzJSI6eyJ2Y19ncmlkX2lkIjpbXX0sIiVfZWRpdF9sb2NrJSI6IjE1MjY5OTk3Mzg6MTAxIiwiJV9lZGl0X2xhc3QlIjoiMTAxIiwiJXNsaWRlX3RlbXBsYXRlJSI6ImRlZmF1bHQiLCIlX3dwYl92Y19qc19zdGF0dXMlIjoidHJ1ZSIsIiVfd3BnbXBfbG9jYXRpb25fYWRkcmVzcyUiOiJMaW5kaG9sbWVuLCBHb3RoZW5idXJnLCBTd2VkZW4iLCIlX3dwZ21wX21ldGFib3hfbGF0aXR1ZGUlIjoiNTcuNzA3NzU5OSIsIiVfd3BnbXBfbWV0YWJveF9sb25naXR1ZGUlIjoiMTEuOTM4Mjg2NTAwMDAwMDA0IiwiJV93cGdtcF9tZXRhYm94X2xvY2F0aW9uX3JlZGlyZWN0JSI6Im1hcmtlciIsIiVfd3BnbXBfbWV0YWJveF9jdXN0b21fbGluayUiOiIiLCIlX3dwZ21wX21hcF9pZCUiOiJhOjE6e2k6MDtzOjE6XCIyXCI7fSIsIiVfd3BnbXBfbWV0YWJveF9tYXJrZXJfaWQlIjoiTjsiLCIlX3dwZ21wX21ldGFib3hfdGF4b21vbWllc190ZXJtcyUiOiJOOyIsIiVfd3BnbXBfZXh0ZW5zaW9uc19maWVsZHMlIjoiTjsiLCIlX2tsZW9fdHJhbnNwYXJlbnRfbWVudV9jb2xvciUiOiJ3aGl0ZSIsIiVfa2xlb190aXRsZV9jb2xvciUiOiIjIiwiJV9rbGVvX3RpdGxlX2JnJSI6IiwgcmVwZWF0LCBpbmhlcml0LCBzY3JvbGwsIGxlZnQgdG9wIiwiJV9rbGVvX3RpdGxlX2JnX2NvbG9yJSI6IiMiLCIlX3lvYXN0X3dwc2VvX2NvbnRlbnRfc2NvcmUlIjoiNjAiLCIlX3lvYXN0X3dwc2VvX3ByaW1hcnlfY2F0ZWdvcnklIjoiNjkiLCIlX3RodW1ibmFpbF9pZCUiOiIxMTU1NiIsIiVfa2xlb190aXRsZV9jaGVja2JveCUiOiIxIiwiJV95b2FzdF93cHNlb19mb2N1c2t3X3RleHRfaW5wdXQlIjoiZGVtb2NyYWN5IiwiJV95b2FzdF93cHNlb19mb2N1c2t3JSI6ImRlbW9jcmFjeSIsIiVfeW9hc3Rfd3BzZW9fbGlua2RleCUiOiI3MSIsIiVfamV0cGFja19yZWxhdGVkX3Bvc3RzX2NhY2hlJSI6eyI2MjM5M2IyNDJjN2E1NjE3NzRmOGViZmY1YzFjMDU2NSI6eyJleHBpcmVzIjoxNTQ0ODkyOTk0LCJwYXlsb2FkIjpbeyJpZCI6MTEzNjJ9LHsiaWQiOjEwNjQ1fSx7ImlkIjoxMDY3M31dfX0sIiVfcHVibGljaXplX3BlbmRpbmclIjoiMSIsIiVzYmdfc2VsZWN0ZWRfc2lkZWJhciUiOiIwIiwiJXNiZ19zZWxlY3RlZF9zaWRlYmFyX3JlcGxhY2VtZW50JSI6IjAiLCJ0YXhvbm9teT1jYXRlZ29yeSI6Iklubm92YXRpb24gQ2FzZSwgTWVkaWEgbGFicyIsInRheG9ub215PXBvc3RfdGFnIjoiYWNhZGVtaWMgY29sbGFib3JhdGlvbiwgZXhwZXJpbWVudHMsIGluZHVzdHJ5IGNvbGxhYm9yYXRpb24sIGxvY2FsIGpvdXJuYWxpc20sIFN3ZWRlbiwgeW91bmcgYXVkaWVuY2VzIn0sImljb24iOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxOC8wMi9tYXJrZXItMS5wbmcifSwiaWQiOjExNTUzLCJpbmZvd2luZG93X2Rpc2FibGUiOmZhbHNlfSx7InNvdXJjZSI6InBvc3QiLCJ0aXRsZSI6Ik5leHQgTWVkaWEgQWNjZWxlcmF0b3I6IHRoZSBHZXJtYW4gUHJlc3MgQWdlbmN5IGFjY2VsZXJhdGluZyBtZWRpYSBhbmQgbWFya2V0aW5nIHN0YXJ0LXVwcyBpbiBIYW1idXJnIiwiaW5mb3dpbmRvd19jb250ZW50IjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZ1wiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJOZXh0IE1lZGlhIEFjY2VsZXJhdG9yOiB0aGUgR2VybWFuIFByZXNzIEFnZW5jeSBhY2NlbGVyYXRpbmcgbWVkaWEgYW5kIG1hcmtldGluZyBzdGFydC11cHMgaW4gSGFtYnVyZ1wiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMTU3XCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTgvMDIvSGVhZGVyLTMwMHgxNTcuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZ1wiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tcGFkZGluZy1jb250ZW50XzIwXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tbWV0YSBmYy1pdGVtLXNlY29uZGFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlIGZjLXRleHQtY2VudGVyXCI+SW5ub3ZhdGlvbiBDYXNlLCBNZWRpYSBsYWJzPC9kaXY+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tdGl0bGUgZmMtaXRlbS1wcmltYXJ5LXRleHQtY29sb3IgZmMtdGV4dC1jZW50ZXJcIj5OZXh0IE1lZGlhIEFjY2VsZXJhdG9yOiB0aGUgR2VybWFuIFByZXNzIEFnZW5jeSBhY2NlbGVyYXRpbmcgbWVkaWEgYW5kIG1hcmtldGluZyBzdGFydC11cHMgaW4gSGFtYnVyZzwvZGl2PlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2VcIj5cclxuICAgICAgICAgICAgTk1BIGFpbXMgdG8gb2ZmZXIgbWVkaWEgYW5kIG1hcmtldGluZyBzdGFydC11cHMgYSBwbGFjZSB0byBzdWNjZWVkIGFuZCBwcm92aWRlIGl0cyAxOTAgc3Rha2Vob2xkZXJzIHdpdGggc3RyYXRlZ2llcyBmb3IgbWFuYWdpbmcgdGhlIGRpZ2l0YWwgdHJhbnNmb3JtYXRpb24gYXQgaGFuZC4gXHJcbiAgICAgICAgPC9kaXY+XHJcbjxhIGhyZWY9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvbmV4dC1tZWRpYS1hY2NlbGVyYXRvci1nZXJtYW4tcHJlc3MtYWdlbmN5LWFjY2VsZXJhdGluZy1tZWRpYS1tYXJrZXRpbmctc3RhcnQtdXBzLWhhbWJ1cmcvXCI+UmVhZCBtb3JlPC9hPlxyXG4gICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuPC9kaXY+XHJcblxyXG4iLCJjb250ZW50IjoiTk1BIGFpbXMgdG8gb2ZmZXIgbWVkaWEgYW5kIG1hcmtldGluZyBzdGFydC11cHMgYSBwbGFjZSB0byBzdWNjZWVkIGFuZCBwcm92aWRlIGl0cyAxOTAgc3Rha2Vob2xkZXJzIHdpdGggc3RyYXRlZ2llcyBmb3IgbWFuYWdpbmcgdGhlIGRpZ2l0YWwgdHJhbnNmb3JtYXRpb24gYXQgaGFuZC4gIiwiYWRkcmVzcyI6IkhhbWJ1cmcsIEdlcm1hbnkiLCJsb2NhdGlvbiI6eyJsYXQiOiI1My41NTEwODQ2IiwibG5nIjoiOS45OTM2ODE4OTk5OTk5NTYiLCJvbmNsaWNrX2FjdGlvbiI6Im1hcmtlciIsInJlZGlyZWN0X3Blcm1hbGluayI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9uZXh0LW1lZGlhLWFjY2VsZXJhdG9yLWdlcm1hbi1wcmVzcy1hZ2VuY3ktYWNjZWxlcmF0aW5nLW1lZGlhLW1hcmtldGluZy1zdGFydC11cHMtaGFtYnVyZy8iLCJ6b29tIjoyLCJleHRyYV9maWVsZHMiOnsicG9zdF9leGNlcnB0IjoiTk1BIGFpbXMgdG8gb2ZmZXIgbWVkaWEgYW5kIG1hcmtldGluZyBzdGFydC11cHMgYSBwbGFjZSB0byBzdWNjZWVkIGFuZCBwcm92aWRlIGl0cyAxOTAgc3Rha2Vob2xkZXJzIHdpdGggc3RyYXRlZ2llcyBmb3IgbWFuYWdpbmcgdGhlIGRpZ2l0YWwgdHJhbnNmb3JtYXRpb24gYXQgaGFuZC4gIiwicG9zdF9jb250ZW50IjoiW3ZjX3Jvd11bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjIvM1wiXVt2Y19jb2x1bW5fdGV4dF1cclxuPGgxPk5leHQgTWVkaWEgQWNjZWxlcmF0b3I6IHRoZSBHZXJtYW4gUHJlc3MgQWdlbmN5IGFjY2VsZXJhdGluZyBtZWRpYSBhbmQgbWFya2V0aW5nIHN0YXJ0LXVwcyBpbiBIYW1idXJnPC9oMT5cclxuPHN0cm9uZz5cdTIwMWNCdXQgd29ya2luZyB3aXRoIHN0YXJ0LXVwcyBjYW4gbmV2ZXIgcmVwbGFjZSBkb2luZyBpbm5vdmF0aW9uIHdpdGhpbiB5b3VyIG93biBjb21wYW55OyB5b3UgbmVlZCBib3RoLFx1MjAxZCBzYXlzIE1laW5vbGYgRWxsZXJzIChkcGEpLjwvc3Ryb25nPlxyXG5cclxuTmV4dCBNZWRpYSBBY2NlbGVyYXRvciBpcyBhbiBpbmRlcGVuZGVudCBpbmR1c3RyeSBhY2NlbGVyYXRvciBpbml0aWF0ZWQgYnkgdGhlIEdlcm1hbiBQcmVzcyBBZ2VuY3kgKGRwYSkuIEZvdW5kZWQgaW4gMjAxNSwgaXQgYWltcyB0byBvZmZlciBtZWRpYSBhbmQgbWFya2V0aW5nIHN0YXJ0LXVwcyBhIHBsYWNlIHRvIHN1Y2NlZWQgYW5kIHByb3ZpZGUgaXRzIDE5MCBzdGFrZWhvbGRlcnMgd2l0aCBzdHJhdGVnaWVzIGZvciBtYW5hZ2luZyB0aGUgZGlnaXRhbCB0cmFuc2Zvcm1hdGlvbiBhdCBoYW5kLlxyXG5cclxuQXMgZHBhIGlzIGEgbWVkaWEgY29tcGFueSBpdHNlbGYgYXMgd2VsbCwgdGhleSBhcmUgbm90IG9ubHkgdGhlIGluaXRpYXRvciBvZiB0aGUgTmV4dCBNZWRpYSBBY2NlbGVyYXRvciwgYnV0IGFsc28gd29yayB3aXRoIHRoZWlyIHN0YXJ0LXVwcyBhbmQgcGFydGljaXBhdGUgaW4gdGVzdC1ydW5zIHRvIGZpbmQgc29sdXRpb25zIHRoZW1zZWx2ZXM6XHJcbjxibG9ja3F1b3RlPlx1MjAxY05NQSBtYXkgYmUgdGhlIG1vc3QgcmFkaWNhbCBhbmQgZm9vbGlzaCBpbml0aWF0aXZlIHdlXHUyMDE5dmUgZXZlciB0YWtlbiBpbiB0ZXJtcyBvZiBkaWdpdGFsIHRyYW5zZm9ybWF0aW9uIGF0IGRwYSxcdTIwMWQgc2F5cyBNZWlub2xmIEVsbGVycywgbWFuYWdpbmcgcGFydG5lciBvZiB0aGUgTmV4dCBNZWRpYSBBY2NlbGVyYXRvciBhbmQgaW4gY2hhcmdlIG9mIGRpZ2l0YWwgb3BlcmF0aW9ucyBhdCBkcGEgZm9yIHRoZSBsYXN0IDIzIHllYXJzLiBcdTIwMWNCdXQgd29ya2luZyB3aXRoIHN0YXJ0LXVwcyBjYW4gbmV2ZXIgcmVwbGFjZSBkb2luZyBpbm5vdmF0aW9uIHdpdGhpbiB5b3VyIG93biBjb21wYW55OyB5b3UgbmVlZCBib3RoLlx1MjAxZDwvYmxvY2txdW90ZT5cclxuPGgzPlNjYWxhYmxlIHRlY2ggYW5kIGJ1c2luZXNzIG1vZGVsczwvaDM+XHJcblRoZSBpZGVhIGZvciB0aGUgTmV4dCBNZWRpYSBBY2NlbGVyYXRvciBjYW1lIGR1cmluZyBhIHRyaXAgdG8gdGhlIFVuaXRlZCBTdGF0ZXMgd2hlcmUgTWVpbm9sZiBtZXQgTWF0dGVyIFZDLCBhIG1lZGlhIHN0YXJ0LXVwIGFjY2VsZXJhdG9yIHdpdGggb2ZmaWNlcyBpbiBTYW4gRnJhbmNpc2NvIGFuZCBOZXcgWW9yayBDaXR5OlxyXG48YmxvY2txdW90ZT5cdTIwMWNUaGV5IHdlcmUgYSBsaXR0bGUgYml0IGEgYmx1ZXByaW50IGZvciB1cy4gV2hlbiB3ZSB2aXNpdGVkIFNpbGljb24gVmFsbGV5IGluIDIwMTMgYW5kIHdlIGNhbWUgYWNyb3NzIHRoaXMgaW5pdGlhdGl2ZSB3ZSB3b25kZXJlZCB3aHkgbm90aGluZyBsaWtlIHRoaXMgZXhpc3RlZCBpbiBFdXJvcGUuXHUyMDFkPC9ibG9ja3F1b3RlPlxyXG5NYXR0ZXIgVkMgc3VwcG9ydHMgaW5pdGlhdGl2ZXMgYXJvdW5kIHN0b3J5dGVsbGluZyBhbmQgdGhlIGZ1dHVyZSBvZiBqb3VybmFsaXNtLCBhbmQgaW5pdGlhbCBmdW5kaW5nIGNhbWUgZnJvbSB0aGUgS25pZ2h0IEZvdW5kYXRpb24uIFRoZSBOZXh0IE1lZGlhIEFjY2VsZXJhdG9yIHdvdWxkIHJhdGhlciBmb2N1cyBvbiBzY2FsYWJsZSB0ZWNoIGFuZCBidXNpbmVzcyBtb2RlbHM6XHJcbjxibG9ja3F1b3RlPlx1MjAxY1dlIGRvblx1MjAxOXQgbmVlZCBpbm5vdmF0aW9uIGluIHN0b3J5dGVsbGluZyBpbiBFdXJvcGUuIE9uIHRoZSBvdGhlciBoYW5kLCB0aGVyZSBpcyBhIGJpZyBuZWVkIGZvciBzY2FsYWJsZSB0ZWNobm9sb2d5IGFuZCBzdXN0YWluYWJsZSBidXNpbmVzcyBtb2RlbHMuXHUyMDFkPC9ibG9ja3F1b3RlPlxyXG48aDM+TWVkaWEgY29tcGFuaWVzIGFzIGludmVzdG9yczwvaDM+XHJcbkRpZmZlcmVudCBvYmplY3RpdmVzIGNhbGwgZm9yIGRpZmZlcmVudCBzb3VyY2VzIG9mIGZpbmFuY2luZy4gU28gaXQgbWFkZSBtb3JlIHNlbnNlIGZvciB0aGUgTmV4dCBNZWRpYSBBY2NlbGVyYXRvciB0byBzZXQgdXAgYSBsYXVuY2hpbmcgcHJvZ3JhbSB0aGFuIHRvIGFwcGx5IGZvciBmdW5kcy5cclxuXHJcblRlbiBpbnZlc3RvcnMgZnJvbSB0aGUgR2VybWFuIG1lZGlhIGluZHVzdHJ5IC0gaW5jbHVkaW5nIEF4ZWwgU3ByaW5nZXIsIERpZSBaZWl0IGFuZCBEZXIgU3BpZWdlbCAtIGVhY2ggcGFpZCAyMDBrLCBmaW5hbmNpbmcgdGhlIGZpcnN0IHR3byB5ZWFycyBvZiB0aGUgTk1BLiBJbiByZXR1cm4sIE5NQSBndWFyYW50ZWVkIHRoZW0gdG8gYnVpbGQgYSBwb3J0Zm9saW8gb2YgMjAgY29tcGFuaWVzIG9mZmVyaW5nIG1lZGlhIGFuZCBtYXJrZXRpbmcgc29sdXRpb25zLiBUaGV5IHN1Y2NlZWRlZCBhbmQgY2xvc2VkIHRoaXMgcm91bmQgbGFzdCBzdW1tZXI6XHJcbjxibG9ja3F1b3RlPlx1MjAxY1NpbmNlIHRoZSBmaXJzdCBvZiBKdWx5IDIwMTcgd2UgYXJlIGluIHRoZSBuZXh0IHJvdW5kLCBOTUEgMi4gV2UgaGF2ZSBleHRlbmRlZCB0aGUgZnVuZHJhaXNpbmcgcGVyaW9kIHVudGlsIHRoZSBlbmQgb2YgTWFyY2ggMjAxOC4gQ3VycmVudGx5IHdlIGFyZSAyNSBpbnZlc3RvcnMgYW5kIHdlIGhhdmUgcmFpc2VkIDcgTWlsbGlvbiBzbyBmYXIsIGJ1dCB3ZSBob3BlIHRvIGdldCBhIGxpdHRsZSBiaXQgY2xvc2VyIHRvIDggTWlsbGlvbi4gQW5kIHdlJ2xsIHVzZSB0aGlzIG1vbmV5IHRvIHJ1biB0aGUgcHJvZ3JhbSB1bnRpbCAyMDIyLCBzbyBmb3IgZml2ZSB5ZWFycyB0aGlzIHRpbWUgaW5zdGVhZCBvZiB0d28uXHUyMDFkPC9ibG9ja3F1b3RlPlxyXG5BbHRob3VnaCB0aGVyZSBhcmUgS1BJcyBmb3IgdGhlIHN0YXJ0LXVwcywgdGhlIGludmVzdG9ycyBzZWVtIG1vc3QgaW50ZXJlc3RlZCBpbiB0aGUgY29udHJpYnV0aW9uIHRoZSBwcm9ncmFtbWUgbWFrZXMgdG8gdGhlaXIgZGlnaXRhbCB0cmFuc2Zvcm1hdGlvbjpcclxuPGJsb2NrcXVvdGU+XHUyMDFjU29tZSBvZiBvdXIgaW52ZXN0b3JzLCBlc3BlY2lhbGx5IHRob3NlIHRoYXQgd2VyZSBhbHJlYWR5IG91ciBwYXJ0bmVycyBpbiB0aGUgZmlyc3Qgcm91bmQsIGRlY2lkZWQgdG8gam9pbiBOTUEyIGFuZCBldmVuIHdpdGggYSBoaWdoZXIgaW52ZXN0bWVudC4gTm90IGJlY2F1c2UgaXQncyBhbiBpbnZlc3RtZW50IHRoYXQgbWVhbnMgYSBsb3Qgb2YgcHJvZml0IGZvciB0aGVtIGluIHRoZSBsb25nIHJ1biwgYnV0IGJlY2F1c2UgaXQncyBhIHN0cm9uZyB0b29sIGZvciB0aGVpciB0cmFuc2Zvcm1hdGlvbiBzdHJhdGVneS4gSXQncyBsaWtlIGFuIG91dHNvdXJjZWQgUiZhbXA7RCB1bml0Llx1MjAxZDwvYmxvY2txdW90ZT5cclxuPGgzPlRoZSBmcmVlZG9tIHRvIHBpdm90PC9oMz5cclxuQnkgcG9zaXRpb25pbmcgaXRzZWxmIGFuIGluZGVwZW5kZW50IGluZHVzdHJ5IGFjY2VsZXJhdG9yLCB0aGUgTk1BIGFpbXMgdG8gZGlzdGluZ3Vpc2ggaXRzZWxmIGZyb20gY29ycG9yYXRlIGFjY2VsZXJhdG9yczpcclxuPGJsb2NrcXVvdGU+XHUyMDFjV2UgYmVsaWV2ZSB0aGF0IGNvcnBvcmF0ZSBhY2NlbGVyYXRvcnMgYXJlIGEgbW9kZWwgb2YgdGhlIHBhc3QsIGJlY2F1c2UgaW4gYSBjb3Jwb3JhdGUgYWNjZWxlcmF0b3IgeW91J3JlIGxpbWl0ZWQgdG8gdGhlIHZpZXdzIGFuZCB0aGUgc3RyYXRlZ2ljIGlucHV0IG9mIG9uZSBjb21wYW55LiBBbmQgdGhhdCBpcyBuZXZlciBoZWxwZnVsIGZvciBhIHN0YXJ0LXVwIHRoYXQgbmVlZHMgdG8gcGl2b3QuIFBpdm90aW5nIGNhbiBvZnRlbiBvbmx5IGJlIGVmZmVjdGl2ZSBpZiB5b3UgaGF2ZSBhY2Nlc3MgdG8gdmVyeSBkaWZmZXJlbnQgdmlld3Mgb24gd2hhdCB5b3UncmUgZG9pbmcuXHUyMDFkPC9ibG9ja3F1b3RlPlxyXG5Gb3IgdGhlIHNhbWUgcmVhc29uLCB0aGUgTmV4dCBNZWRpYSBBY2NlbGVyYXRvciBvbmx5IGFjY2VwdHMgYXBwbGljYXRpb25zIGZyb20gc3RhcnQtdXAgdGVhbXMgdGhhdCBoYXZlIHRoZSBzb2Z0d2FyZSBhcmNoaXRlY3QgYXMgb25lIG9mIHRoZWlyIGZvdW5kZXJzOlxyXG48YmxvY2txdW90ZT5cdTIwMWNJdCdzIGEga2lsbC1jcml0ZXJpYS4gSWYgeW91IGhhdmUgdG8gY29tcGxldGVseSBvdmVyaGF1bCB5b3VyIHRlY2huaWNhbCBzdHJ1Y3R1cmUsIHRoZSBzb2Z0d2FyZSBhcmNoaXRlY3QgbmVlZHMgdG8gYmUgYXQgdGhlIHRhYmxlIGZyb20gdGhlIGJlZ2lubmluZy4gQW5kIG5vdCBhcyBhbiBlbXBsb3llZSwgYnV0IGFzIGFuIGVudHJlcHJlbmV1ci5cdTIwMWQ8L2Jsb2NrcXVvdGU+XHJcbjxoMz5OZXcgb3Bwb3J0dW5pdGllcyBmb3IgY29udGVudCBkaXN0cmlidXRpb248L2gzPlxyXG5TbyBmYXIsIHR3byBlc3BlY2lhbGx5IHN1Y2Nlc3NmdWwgc29sdXRpb25zIGNhbWUgb3V0IG9mIHRoZSBhY2NlbGVyYXRvcjogQ29udGVudGZsb3cgYW5kIFNwZWt0cnVtLlxyXG48YmxvY2txdW90ZT5cdTIwMWNTcGVrdHJ1bSBpcyBhIGJpZyBzdWNjZXNzIHN0b3J5LFx1MjAxZCBNZWlub2xmIHByb3VkbHkgYW5ub3VuY2VzLiBcdTIwMWNUaGUgR2VybWFuIHRhYmxvaWQgQmlsZCB3YXMgdGhlIGZpcnN0IG9uZSB0byB1c2UgdGhlaXIgbWVzc2VuZ2VyIGFwcGxpY2F0aW9uIGZvciBhIHNlcnZpY2Ugb24gc29jY2VyIHRyYW5zZmVycy4gRHVyaW5nIHRoZSB3aW50ZXIgYnJlYWsgdmVyeSBvZnRlbiBwbGF5ZXJzIGFyZSBzb2xkIGFuZCBib3VnaHQgYW5kIHNvIHlvdSBjb3VsZCBhcHBseSBhbmQgcmVnaXN0ZXIgZm9yIHlvdXIgY2x1YiwgYW5kIHdoZW5ldmVyIHRoZXkgd2VyZSBpbnZvbHZlZCBpbiBhIHRyYW5zZmVyLCB5b3VcdTIwMTlkIGJlIG5vdGlmaWVkLlx1MjAxZDwvYmxvY2txdW90ZT5cclxuVGhlcmUgd2FzIG9ubHkgb25lIGJ1bXAgaW4gdGhlIHJvYWQuIEp1c3Qgd2hlbiB0aGlzIHNlcnZpY2UgYnkgQmlsZCB3ZW50IGxpdmUsIFdoYXRzYXBwIGhhZCBjaGFuZ2VkIGl0cyBydWxlcyBvdmVybmlnaHQuIFNvIG1hbnkgcGVvcGxlIHdobyBhcHBsaWVkIGZvciB0aGUgc2VydmljZSB3ZXJlIHJlamVjdGVkOlxyXG48YmxvY2txdW90ZT5cdTIwMWNCdXQgZHVlIHRvIG91ciBjb250YWN0cyB3ZSB3ZXJlIGFibGUgdG8gY29udmluY2UgRmFjZWJvb2sgdG8gYWxsb3cgU3Bla3RydW0gdG8gYmUgdGhlIGZpcnN0IGFuZCBleHBlcmltZW50YWwgcGFydG5lciB0byB1c2UgdGhlIEZhY2Vib29rIG1lc3NlbmdlciBBUEkgZm9yIGNvbnRlbnQgZGlzdHJpYnV0aW9uLlx1MjAxZDwvYmxvY2txdW90ZT5cclxuPGgzPlBhcnQgb2YgdGhlIGlubm92YXRpb24gZWNvc3lzdGVtPC9oMz5cclxuVGhpcyBjYXNlIGlsbHVzdHJhdGVzIHRoZSB2YWx1ZSBvZiBiZWluZyBwYXJ0IG9mIGFuIGlubm92YXRpb24gZWNvc3lzdGVtOlxyXG48YmxvY2txdW90ZT5cdTIwMWNUaGUgY29yZSBvZiB0aGUgTk1BIGlzIG1hdGNoaW5nIG1lZGlhLXJlbGF0ZWQgc3RhcnR1cHMgd2l0aCBtZWRpYSBhbmQgbWFya2V0aW5nIGNvcnBvcmF0ZXMgYW5kIGVuYWJsZSB0aGVtIGFuZCBtb2RlcmF0ZSBhIHByb2Nlc3Mgd2hlcmUgdGhleSBkbyBwcm90b3R5cGVzIGFuZCB0ZXN0LXJ1bnMgdG9nZXRoZXIuIEFuZCBJIGJlbGlldmUgdGhhdCB0aGlzIGlzIG1heWJlIHRoZSBzZWNyZXQgc2F1Y2Ugb2YgdGhlIE5NQSxcdTIwMWQgc2F5cyBNZWlub2xmLlxyXG5cclxuXHUyMDFjU2luY2Ugd2UgaGF2ZSB0aGlzIGh1Z2UgbmV0d29yayBvZiBtZWRpYSBhbmQgbWFya2V0aW5nIHBsYXllcnMgb2YgZGlmZmVyZW50IGNoYXJhY3RlciBhbmQgc3RhcnQtdXBzIGZyb20gYWxsIGRpZmZlcmVudCBkaXJlY3Rpb25zLCB3ZSBjYW4gb24gdGhlIG9uZSBoYW5kIHByb3ZpZGUgdGhlIHN0YXJ0LXVwcyB3aXRoIGRvemVucyBvZiBkaWZmZXJlbnQgb3Bwb3J0dW5pdGllcyB0byB0ZXN0IHRoZWlyIHByb2R1Y3QgYW5kIG9uIHRoZSBvdGhlciBoYW5kIHNlZSB3aGVyZSBleGFjdGx5IGl0IGZpdHMgaW50byB0aGUgbWFya2V0IGFuZCB3aGVyZSBpdCBzb2x2ZXMgcHJvYmxlbXMgb2YgdGhlIGluZHVzdHJ5XHUyMDFkPC9ibG9ja3F1b3RlPlxyXG5UaGlzIG5ldHdvcmsgaXMgaW50ZXJuYXRpb25hbC4gVGhlIE5NQSBoYXMgcGFydG5lcnNoaXBzIHdpdGggbWVkaWEgYWNjZWxlcmF0b3JzIGluIEJlbGdpdW0sIHRoZSBOZXRoZXJsYW5kcywgU2NhbmRpbmF2aWEgYW5kIHRoZSBCYWx0aWMgU3RhdGVzLiBUaGUgb2xkIEhhbnNlYXRpYyBMZWFndWUgbmV0d29yayBzdGlsbCBzZWVtcyB0byBzaGFyZSBhIHNpbWlsYXIgYnVzaW5lc3MgbWVudGFsaXR5LCB3aGljaCBtYWtlcyBpdCBwbGVhc2FudCB0byBkbyBidXNpbmVzcyB0b2dldGhlciwgYWNjb3JkaW5nIHRvIE1laW5vbGYuIEJ1dCB0aGUgaW5ub3ZhdGlvbiBlY29zeXN0ZW0gaXMgZ2xvYmFsIGFuZCBzbyB0aGV5IGFyZSBhbHNvIHdvcmtpbmcgd2l0aCBzdGFydC11cHMgaW4gSXNyYWVsIGFuZCBhcmUgcGxhbm5pbmcgdG8gc2V0IHVwIHNpbWlsYXIgaW5pdGlhdGl2ZXMgaW4gTmV3IFlvcmsuXHJcblxyXG5PbiBhIGxvY2FsIGxldmVsLCB0aGUgTk1BIGlzIHN1cHBvcnRpbmcgdHdvIFx1MjAxOHNpc3Rlclx1MjAxOS1hY2NlbGVyYXRvcnMgdGhhdCBoYXZlIGVtZXJnZWQgaW4gSGFtYnVyZyBzaW5jZSAyMDE1OiBhIE5leHQgQ29tbWVyY2UgQWNjZWxlcmF0b3IgYW5kIGEgTmV4dCBMb2dpc3RpY3MgQWNjZWxlcmF0b3IuXHJcbjxibG9ja3F1b3RlPlx1MjAxY0hhbWJ1cmcgaXMgYSBwb3J0LWNpdHksIGl0J3MgdGhlIGNlbnRyZSBpbiBHZXJtYW55IG9mIGxvZ2lzdGljcyBhbmQgdHJhZGUsIGFuZCBpdCdzIHRoZSBjZW50cmUgb2YgbWVkaWEgYW5kIGFkdmVydGlzaW5nLiBTbyB0aGlzIGlzIHRoZSBzdHJhdGVneSBmb3IgSGFtYnVyZyBub3c6IFRha2UgdGhlIGNvbmNlcHQgb2YgdGhlIGluZHVzdHJ5IGFjY2VsZXJhdG9ycyBhbmQgcHV0IHRoZW0gb24gdG9wIG9mIGFsbCB0aGUgaW5kdXN0cmllcyB3aGVyZSBIYW1idXJnIGhhcyBhIHZlcnkgc3Ryb25nIHBvc2l0aW9uIGluIHRoZSBtYXJrZXQuXHUyMDFkPC9ibG9ja3F1b3RlPlxyXG5DT05UQUNUIFBPSU5UXHJcbjxpbWcgY2xhc3M9XCJhbGlnbm5vbmUgd3AtaW1hZ2UtMTE0ODkgc2l6ZS1mdWxsXCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTgvMDIvTWVpbm9sZi1lbGxlcnMuanBnXCIgYWx0PVwiXCIgd2lkdGg9XCIyMDBcIiBoZWlnaHQ9XCIyNTBcIiAvPlxyXG5NZWlub2xmIEVsbGVycywgQ2hpZWYgRGlnaXRhbCBPZmZpY2VyLCBkcGEgKEdlcm1hbiBQcmVzcyBBZ2VuY3kpXHJcbldlYjogPGEgaHJlZj1cImh0dHBzOi8vd3d3Lm5tYS52Yy9cIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPmh0dHBzOi8vd3d3Lm5tYS52Yy88L2E+XHJcblR3aXR0ZXI6IDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL05NQV92Y1wiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+QE5NQV92YzwvYT5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMi8zXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48aDM+QXV0aG9yPC9oMz5cclxuW3NpbXBsZS1hdXRob3ItYm94XVsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XSIsInBvc3RfdGl0bGUiOiJOZXh0IE1lZGlhIEFjY2VsZXJhdG9yOiB0aGUgR2VybWFuIFByZXNzIEFnZW5jeSBhY2NlbGVyYXRpbmcgbWVkaWEgYW5kIG1hcmtldGluZyBzdGFydC11cHMgaW4gSGFtYnVyZyIsInBvc3RfbGluayI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9uZXh0LW1lZGlhLWFjY2VsZXJhdG9yLWdlcm1hbi1wcmVzcy1hZ2VuY3ktYWNjZWxlcmF0aW5nLW1lZGlhLW1hcmtldGluZy1zdGFydC11cHMtaGFtYnVyZy8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJOZXh0IE1lZGlhIEFjY2VsZXJhdG9yOiB0aGUgR2VybWFuIFByZXNzIEFnZW5jeSBhY2NlbGVyYXRpbmcgbWVkaWEgYW5kIG1hcmtldGluZyBzdGFydC11cHMgaW4gSGFtYnVyZ1wiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMTU3XCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTgvMDIvSGVhZGVyLTMwMHgxNTcuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+IiwicG9zdF9jYXRlZ29yaWVzIjoiSW5ub3ZhdGlvbiBDYXNlLCBNZWRpYSBsYWJzIiwicG9zdF90YWdzIjoiYWNjZWxlcmF0b3IsIGJ1c2luZXNzIG1vZGVscywgR2VybWFueSwgaW52ZXN0b3JzLCBuZXR3b3JrLCBuZXdzIGFnZW5jeSwgc2NhbGFibGUgdGVjaG5vbG9neSwgc3RhcnR1cHMiLCIlX3ZjX3Bvc3Rfc2V0dGluZ3MlIjp7InZjX2dyaWRfaWQiOltdfSwiJV9lZGl0X2xvY2slIjoiMTUyNjk5OTg0MjoxMDEiLCIlX2VkaXRfbGFzdCUiOiIxMDEiLCIlc2xpZGVfdGVtcGxhdGUlIjoiZGVmYXVsdCIsIiVfd3BiX3ZjX2pzX3N0YXR1cyUiOiJ0cnVlIiwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6IkhhbWJ1cmcsIEdlcm1hbnkiLCIlX3dwZ21wX21ldGFib3hfbGF0aXR1ZGUlIjoiNTMuNTUxMDg0NiIsIiVfd3BnbXBfbWV0YWJveF9sb25naXR1ZGUlIjoiOS45OTM2ODE4OTk5OTk5NTYiLCIlX3dwZ21wX21ldGFib3hfbG9jYXRpb25fcmVkaXJlY3QlIjoibWFya2VyIiwiJV93cGdtcF9tZXRhYm94X2N1c3RvbV9saW5rJSI6IiIsIiVfd3BnbXBfbWFwX2lkJSI6ImE6MTp7aTowO3M6MTpcIjJcIjt9IiwiJV93cGdtcF9tZXRhYm94X21hcmtlcl9pZCUiOiJOOyIsIiVfd3BnbXBfbWV0YWJveF90YXhvbW9taWVzX3Rlcm1zJSI6Ik47IiwiJV93cGdtcF9leHRlbnNpb25zX2ZpZWxkcyUiOiJOOyIsIiVfa2xlb190cmFuc3BhcmVudF9tZW51X2NvbG9yJSI6IndoaXRlIiwiJV9rbGVvX3RpdGxlX2NvbG9yJSI6IiMiLCIlX2tsZW9fdGl0bGVfYmclIjoiLCByZXBlYXQsIGluaGVyaXQsIHNjcm9sbCwgbGVmdCB0b3AiLCIlX2tsZW9fdGl0bGVfYmdfY29sb3IlIjoiIyIsIiVfeW9hc3Rfd3BzZW9fY29udGVudF9zY29yZSUiOiI2MCIsIiVfeW9hc3Rfd3BzZW9fcHJpbWFyeV9jYXRlZ29yeSUiOiI2OSIsIiVfa2xlb190aXRsZV9jaGVja2JveCUiOiIxIiwiJV90aHVtYm5haWxfaWQlIjoiMTE0ODgiLCIlX2pldHBhY2tfcmVsYXRlZF9wb3N0c19jYWNoZSUiOnsiNjIzOTNiMjQyYzdhNTYxNzc0ZjhlYmZmNWMxYzA1NjUiOnsiZXhwaXJlcyI6MTU0NTQxOTk3MSwicGF5bG9hZCI6W3siaWQiOjEwNzgzfSx7ImlkIjoxMTQ5NH0seyJpZCI6MTA5OTF9XX19LCIlX3B1YmxpY2l6ZV9wZW5kaW5nJSI6IjEiLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza3dfdGV4dF9pbnB1dCUiOiJIYW1idXJnIiwiJV95b2FzdF93cHNlb19mb2N1c2t3JSI6IkhhbWJ1cmciLCIlX3lvYXN0X3dwc2VvX2xpbmtkZXglIjoiNzIiLCIlc2JnX3NlbGVjdGVkX3NpZGViYXIlIjoiMCIsIiVzYmdfc2VsZWN0ZWRfc2lkZWJhcl9yZXBsYWNlbWVudCUiOiIwIiwidGF4b25vbXk9Y2F0ZWdvcnkiOiJJbm5vdmF0aW9uIENhc2UsIE1lZGlhIGxhYnMiLCJ0YXhvbm9teT1wb3N0X3RhZyI6ImFjY2VsZXJhdG9yLCBidXNpbmVzcyBtb2RlbHMsIEdlcm1hbnksIGludmVzdG9ycywgbmV0d29yaywgbmV3cyBhZ2VuY3ksIHNjYWxhYmxlIHRlY2hub2xvZ3ksIHN0YXJ0dXBzIn0sImljb24iOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxOC8wMi9tYXJrZXItMS5wbmcifSwiaWQiOjExNDg1LCJpbmZvd2luZG93X2Rpc2FibGUiOmZhbHNlfSx7InNvdXJjZSI6InBvc3QiLCJ0aXRsZSI6IkVQRkwrRUNBTCBMYWI6IGlubm92YXRpb25zIHNob3VsZCBmZWVsIG5hdHVyYWwgdG8gdXNlcnMgdG8gYmUgc3VzdGFpbmFibGUiLCJpbmZvd2luZG93X2NvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIkVQRkwrRUNBTCBMYWI6IGlubm92YXRpb25zIHNob3VsZCBmZWVsIG5hdHVyYWwgdG8gdXNlcnMgdG8gYmUgc3VzdGFpbmFibGVcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjE1MlwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE4LzAxL2hlYWRlci0xLTEtMzAweDE1Mi5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1wYWRkaW5nLWNvbnRlbnRfMjBcIj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1tZXRhIGZjLWl0ZW0tc2Vjb25kYXJ5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2UgZmMtdGV4dC1jZW50ZXJcIj5Jbm5vdmF0aW9uIENhc2UsIE1lZGlhIGxhYnM8L2Rpdj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS10aXRsZSBmYy1pdGVtLXByaW1hcnktdGV4dC1jb2xvciBmYy10ZXh0LWNlbnRlclwiPkVQRkwrRUNBTCBMYWI6IGlubm92YXRpb25zIHNob3VsZCBmZWVsIG5hdHVyYWwgdG8gdXNlcnMgdG8gYmUgc3VzdGFpbmFibGU8L2Rpdj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1jb250ZW50IGZjLWl0ZW0tYm9keS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+XHJcbiAgICAgICAgICAgIElubm92YXRpb24gaXMgbm90IGFib3V0IGltcHJlc3NpbmcgcGVvcGxlIHdpdGggdGhlIGxhdGVzdCB0ZWNobm9sb2dpZXMuIEZvciB0aGUgRVBGTCtFQ0FMIExhYiwgYW4gaW5ub3ZhdGlvbiBpcyBzdWNjZXNzZnVsIGlmIGEgdXNlciBmb3JnZXRzIGFib3V0IHRoZSB0ZWNobm9sb2d5IGFuZCBpbnN0ZWFkIGZvY3VzZXMgb24gdGhlIGNvbnRlbnQuXHJcbiAgICAgICAgPC9kaXY+XHJcbjxhIGhyZWY9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvZXBmbGVjYWwtbGFiLWlubm92YXRpb25zLWZlZWwtbmF0dXJhbC11c2Vycy1zdXN0YWluYWJsZS9cIj5SZWFkIG1vcmU8L2E+XHJcbiAgICA8L2Rpdj5cclxuICAgIDwvZGl2PlxyXG48L2Rpdj5cclxuXHJcbiIsImNvbnRlbnQiOiJJbm5vdmF0aW9uIGlzIG5vdCBhYm91dCBpbXByZXNzaW5nIHBlb3BsZSB3aXRoIHRoZSBsYXRlc3QgdGVjaG5vbG9naWVzLiBGb3IgdGhlIEVQRkwrRUNBTCBMYWIsIGFuIGlubm92YXRpb24gaXMgc3VjY2Vzc2Z1bCBpZiBhIHVzZXIgZm9yZ2V0cyBhYm91dCB0aGUgdGVjaG5vbG9neSBhbmQgaW5zdGVhZCBmb2N1c2VzIG9uIHRoZSBjb250ZW50LiIsImFkZHJlc3MiOiJMYXVzYW5uZSwgU3dpdHplcmxhbmQiLCJsb2NhdGlvbiI6eyJsYXQiOiI0Ni41MTk2NTM1IiwibG5nIjoiNi42MzIyNzM0MDAwMDAwMzEiLCJvbmNsaWNrX2FjdGlvbiI6InBvc3QiLCJyZWRpcmVjdF9wZXJtYWxpbmsiOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvZXBmbGVjYWwtbGFiLWlubm92YXRpb25zLWZlZWwtbmF0dXJhbC11c2Vycy1zdXN0YWluYWJsZS8iLCJ6b29tIjoyLCJleHRyYV9maWVsZHMiOnsicG9zdF9leGNlcnB0IjoiSW5ub3ZhdGlvbiBpcyBub3QgYWJvdXQgaW1wcmVzc2luZyBwZW9wbGUgd2l0aCB0aGUgbGF0ZXN0IHRlY2hub2xvZ2llcy4gRm9yIHRoZSBFUEZMK0VDQUwgTGFiLCBhbiBpbm5vdmF0aW9uIGlzIHN1Y2Nlc3NmdWwgaWYgYSB1c2VyIGZvcmdldHMgYWJvdXQgdGhlIHRlY2hub2xvZ3kgYW5kIGluc3RlYWQgZm9jdXNlcyBvbiB0aGUgY29udGVudC4iLCJwb3N0X2NvbnRlbnQiOiJbdmNfcm93XVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMi8zXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48aDE+RVBGTCtFQ0FMIExhYjogaW5ub3ZhdGlvbnMgc2hvdWxkIGZlZWwgbmF0dXJhbCB0byB1c2VycyB0byBiZSBzdXN0YWluYWJsZTwvaDE+XHJcbjxzdHJvbmc+SW5ub3ZhdGlvbiBpcyBub3QgYWJvdXQgaW1wcmVzc2luZyBwZW9wbGUgd2l0aCB0aGUgbGF0ZXN0IHRlY2hub2xvZ2llcy4gRm9yIHRoZSBFUEZMK0VDQUwgTGFiLCBhbiBpbm5vdmF0aW9uIGlzIHN1Y2Nlc3NmdWwgaWYgYSB1c2VyIGZvcmdldHMgYWJvdXQgdGhlIHRlY2hub2xvZ3kgYW5kIGluc3RlYWQgZm9jdXNlcyBvbiB0aGUgY29udGVudC48L3N0cm9uZz5cclxuXHJcbkNyZWF0ZWQgaW4gMjAwNywgdGhlIEVQRkwrRUNBTCBMYWIgaXMgYW4gaW5ub3ZhdGlvbiBsYWIgaW4gTGF1c2FubmUsIGxvY2F0ZWQgaW4gdGhlIEVDQUwgYnVpbGRpbmcgb2YgdGhlIFVuaXZlcnNpdHkgb2YgQXJ0IGFuZCBEZXNpZ24gTGF1c2FubmUsIGFuZCBiZWxvbmdpbmcgdG8gdGhlIEVjb2xlIFBvbHl0ZWNobmlxdWUgRlx1MDBlOWRcdTAwZTlyYWxlIGRlIExhdXNhbm5lIChFUEZMKS5cclxuXHJcbkl0IGFpbXMgdG8gZXhwbG9yZSB0aGUgcG90ZW50aWFsIG9mIGVtZXJnaW5nIHRlY2hub2xvZ2llcyB0aHJvdWdoIGRlc2lnbiByZXNlYXJjaDpcclxuPGJsb2NrcXVvdGU+XHUyMDFjVGhlIG1haW4gcXVlc3Rpb24gZm9yIG1lZGlhIGlubm92YXRpb24gaXMgaG93IHdlIGNhbiB0cmFuc2Zvcm0gdGhlc2UgbmV3IHRlY2hub2xvZ2llcyBpbnRvIGNvbnZpbmNpbmcgZXhwZXJpZW5jZXMgZm9yIHRoZSB1c2VyLFx1MjAxZCBzYXlzIE5pY29sYXMgSGVuY2hveiwgZGlyZWN0b3Igb2YgdGhlIEVQRkwtRUNBTCBMYWIuIFx1MjAxY1dlIHRlbmQgdG8gcmVkdWNlIGlubm92YXRpb24gdG8gdGVjaG5vbG9naWNhbCBwZXJmb3JtYW5jZSAtIGluY3JlYXNlZCBzcGVlZCBhbmQgaW5jcmVhc2VkIGZ1bmN0aW9uYWxpdHkgXHUyMDEzIGFuZCBmb3JnZXQgYWJvdXQgaG93IHRvIG1ha2Ugc2Vuc2Ugb2YgdGhlbS5cdTIwMWQ8L2Jsb2NrcXVvdGU+XHJcbkRlc2lnbmVycywgZW5naW5lZXJzIGFuZCBwc3ljaG9sb2dpc3RzIHdvcmsgdG9nZXRoZXIgaW4gdGhlIExhYi4gVGhleSBkZXZlbG9wIGZ1bmN0aW9uYWwgcHJvdG90eXBlcyBhbmQgZXZhbHVhdGUgdGhlIGN1bHR1cmFsIGFuZCBlbW90aW9uYWwgaW1wYWN0IG9mIHRoZXNlIHByb3RvdHlwZXMgb24gdGhlIGVuZCB1c2Vycy5cclxuPGgzPk9yaWdpbmFsIGZhaWx1cmU8L2gzPlxyXG5OaWNvbGFzIGFuZCBoaXMgdGVhbSBsb29rZWQgYXQgbWFueSBvdGhlciBpbml0aWF0aXZlcyBmb3IgaW5zcGlyYXRpb24gYW5kIHRyYW5zbGF0ZWQgdGhlaXIgb2JzZXJ2YXRpb25zIGludG8gYSBuZXcgYW5kIG9yaWdpbmFsIGFwcHJvYWNoOlxyXG48YmxvY2txdW90ZT5cdTIwMWNXZSBoYWQgdGhlIGNoYW5jZSB0byBvYnNlcnZlIHRoZSBnb29kIGFuZCB0aGUgYmFkIGFzcGVjdHMgb2YgYWxsIG9mIHRoZXNlIG1vZGVscyBhbmQgdGhlbiBzdGFydCBvdXIgb3duLiBJIGFsd2F5cyBzYWlkIFx1MjAxOHdlIHdpbGwgZmFpbCBzb29uZXIgb3IgbGF0ZXIsIGJ1dCBhdCBsZWFzdCBpdCBzaG91bGQgYmUgYW4gb3JpZ2luYWwgZmFpbHVyZVx1MjAxOS5cdTIwMWQ8L2Jsb2NrcXVvdGU+XHJcbkluc3BpcmF0aW9uIGZvciB0aGUgTGFiXHUyMDE5cyBhcHByb2FjaCBjb21lcyBpbiBsYXJnZSBwYXJ0IGZyb20gZGVzaWduZXJzIEphc3BlciBNb3JyaXNvbiBhbmQgTmFvdG8gRnVrYXNhd2EuIFRoZXkgY29pbmVkIHRoZSB0ZXJtIFx1MjAxOHN1cGVyIG5vcm1hbFx1MjAxOSB0byBoZWxwIGZpbmQgdGhlIGVzc2VuY2Ugb2Ygbm9ybWFsaXR5IGluIGRlc2lnbjpcclxuPGJsb2NrcXVvdGU+XHUyMDFjVGhpcyBhbGxvd3MgdXMgdG8gbWFrZSBzb21ldGhpbmcgdGhhdCBpcyBkaXNydXB0aXZlIHNlZW0gbm9ybWFsLCBhbG1vc3QgbGlrZSB5b3VcdTIwMTl2ZSBzZWVuIGl0IGJlZm9yZS4gV2hlbiB5b3UgcmVhY2ggdGhpcyBsZXZlbCwgeW91IGNhbiBjcmVhdGUgdGhpbmdzIHRoYXQgbGFzdCBmaXZlIHRvIHRlbiB5ZWFycy4gQW5kIHRoYXRcdTIwMTlzIHdoZW4geW91IGhhdmUgYSByZWFsIHJldHVybiBvbiBpbnZlc3RtZW50IGZvciB0aGUgdXNlciwgZm9yIHRoZSBjb21wYW55LCBmb3IgZXZlcnlib2R5Llx1MjAxZDwvYmxvY2txdW90ZT5cclxuPGgzPkNvbnRlbnQgb3ZlciB0ZWNobm9sb2d5PC9oMz5cclxuQWx0aG91Z2ggaXRcdTIwMTlzIGZhciBmcm9tIGVhc3ksIHRoZSBFUEZMLUVDQUwgTGFiIGhhcyBzaG93biB0aHJvdWdoIHNldmVyYWwgaW5zdGFsbGF0aW9ucyB0aGF0IGl0IGlzIHBvc3NpYmxlIHRvIG1ha2UgcGVvcGxlIGZvcmdldCBhYm91dCB0aGUgdGVjaG5vbG9neS5cclxuXHJcblRocm91Z2ggdGhlaXIgd29yayBvbiBpbW1lcnNpdmUgbWVkaWEsIHRoZXkgdGFja2xlZCB0aGUgY2hhbGxlbmdlIG9mIGdldHRpbmcgZnJvbSBhIGNvb2wgM0Qgd29ybGQgdGhhdCBpbXByZXNzZXMgcGVvcGxlIGZvciBhIGZldyBtaW51dGVzIHRvIGEgcG9pbnQgYXQgd2hpY2ggcGVvcGxlIHJlYWxseSBzdGFydCB0byBsb29rIGF0IHRoZSBjb250ZW50LiBBcyBzb29uIGFzIHBlb3BsZSBmb3JnZXQgYWJvdXQgdGhlIHRlY2hub2xvZ3ksIHlvdSBzdGFydCB0byBzZWUgaW4gd2hpY2ggY2FzZXMgYW4gaW1tZXJzaXZlIGVudmlyb25tZW50IGNhbiBiZSBhbiBhZGRlZCB2YWx1ZS5cclxuXHJcblRoZSBcdTIwMTg8YSBocmVmPVwiaHR0cDovL3d3dy5lcGZsLWVjYWwtbGFiLmNoL3dvcmsvY2hyb25vZ3JhbS9cIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPkhpc3Rvcnkgb2YgV2F0Y2ggTWFraW5nPC9hPlx1MjAxOSBwcm9qZWN0IHdlbnQgdGhyb3VnaCBzZXZlcmFsIHZlcnNpb25zOlxyXG48YmxvY2txdW90ZT5cdTIwMWNJbiB0aGUgZmlyc3QgdmVyc2lvbnMgcGVvcGxlIHdlcmUgbW9zdGx5IHNlZHVjZWQgYnkgdGhlIDNEIGVudmlyb25tZW50LFx1MjAxZCByZW1lbWJlcnMgTmljb2xhcywgXHUyMDFjYnV0IG9uIHRoZSBmaW5hbCBvbmUgcGVvcGxlIHdlcmUgcmVhbGx5IGxvb2tpbmcgYXQgdGhlIGNvbnRlbnQuIEZvciB0aGUgaW5ub3ZhdGlvbiB0byBsYXN0LCBpdCBpcyBpbXBvcnRhbnQgdGhhdCB0aGUgY29udGVudCBpcyBwZXJjZWl2ZWQgYXMgc29tZXRoaW5nIHRoYXQgZXhpc3RzIGFuZCBub3QganVzdCBhcyBzb21ldGhpbmcgZnVuLlx1MjAxZDwvYmxvY2txdW90ZT5cclxuPGgzPkVtb3Rpb25hbCBwZXJjZXB0aW9uczwvaDM+XHJcbk5pY29sYXMgYmVsaWV2ZXMgdGhhdCBtYW55IGlubm92YXRpdmUgcHJvamVjdHMgdHVybiBpbnRvIGEgZGlzYXN0ZXIgYmVjYXVzZSBtb3N0IG9mIHRoZSBtb25leSBpcyBpbnZlc3RlZCBpbnRvIGRldmVsb3BpbmcgdGhlIHRlY2hub2xvZ2llcywgd2hpbGUgYWxtb3N0IG5vdGhpbmcgZ29lcyB0byB0aGlua2luZyBhbmQgZXhwZXJpbWVudGluZyBhYm91dCB0aGUgd2F5cyBpbiB3aGljaCB1c2VycyBtYWtlIHNlbnNlIG9mIHRob3NlIHRlY2hub2xvZ2llcy5cclxuXHJcbklubm92YXRpb25zIHRoYXQgZmVlbCBuYXR1cmFsIGluY29ycG9yYXRlIHRoZSBpZGVhIHRoYXQgZXhwZXJpZW5jZXMgY29uc2lzdCBvZiBkaWZmZXJlbnQgZWxlbWVudHMuIE1lbW9yaWVzIG9mdGVuIGluY2x1ZGUgYW4gaW1hZ2UsIGEgc21lbGwsIHNvbWUgc291bmRzOyB0aGV5IGFyZSBhIGtpbmQgb2YgZ2xvYmFsIHNlbnNhdGlvbiwgYSBiaXQgbGlrZSBkcmVhbXMuXHJcblxyXG5BcyBhbiBhbHRlcm5hdGl2ZSwgdGhlIEVQRkwtRUNBTCBMYWIgYXBwcm9hY2ggZG9lc25cdTIwMTl0IGp1c3QgdGFrZSBpbnRvIGFjY291bnQgdGhlIHN0b3J5dGVsbGluZyBsZXZlbCwgYnV0IGFsc28gdGhlIGh1bWFuIHBlcmNlcHRpb24gdGhyb3VnaCB0aGUgc28tY2FsbGVkIFx1MjAxOGxhbmRzY2FwZSBvZiBzZW5zYXRpb25cdTIwMTk6XHJcbjxibG9ja3F1b3RlPlx1MjAxY1RoYXQgaXMgc29tZXRoaW5nIHZlcnkgZnV6enkgdGhhdCB5b3UgYWNxdWlyZSBpbiB0aGUgZmlyc3Qgd2Vla3Mgb2YgeW91ciBsaWZlLiBZb3Ugc3RpbGwgaGF2ZSBpdCBpbiB5b3VyIG1pbmQgYXMgYW4gYWR1bHQsIGJ1dCBhcyB3ZSBhbHdheXMgc3BlYWsgd2l0aCB3b3JkcyB3aGVuIHdlIHRyeSB0byBjb252aW5jZSB0aGUgb3RoZXIgd2l0aCB3b3JkcyBhbmQgc3Rvcmllcywgd2UgdGVuZCB0byBmb3JnZXQgdGhpcyBkaW1lbnNpb24uXHUyMDFkPC9ibG9ja3F1b3RlPlxyXG48aDM+SW5kdXN0cnkgcGFydG5lcnNoaXBzPC9oMz5cclxuQ2xpZW50c1x1MjAxOSBmdW5kIGFib3V0IGhhbGYgb2YgdGhlIHdvcmssIHRoZSBzY2hvb2wgdGhlIG90aGVyIGhhbGYuIFRoZXkgaGlyZSB0aGUgRVBGTC1FQ0FMIExhYiB0byBtYWtlIHNlbnNlIG9mIG5ldyB0ZWNobm9sb2dpZXMuIE5pY29sYXMgZXhwbGFpbnMgd2h5IHRoZXNlIGZpcm1zIGFyZSBpbnRlcmVzdGVkIGluIHdvcmtpbmcgd2l0aCB0aGUgTGFiLCBkZXNwaXRlIHRoZSBhbHRob3VnaCBpdCB0YWtlcyB0aGVtIG1vcmUgdGltZSBhbmQgaXMgdGhlcmVmb3JlIG1vcmUgY29zdGx5OlxyXG48YmxvY2txdW90ZT5cdTIwMWNXaGVuIHlvdSBoYXZlIG5ldyB0b3BpY3MsIG5ldyBkb21haW5zLCBuZXcgY2hhbGxlbmdlczsgbm9ib2R5IGtub3dzLiBXb3JraW5nIHdpdGggYSBjb25zdWx0YW5jeSBmaXJtIHRoYXQgZG9lc25cdTIwMTl0IGtub3cgaG93IHRvIGRlYWwgd2l0aCB0aGlzIGFuZCBsb29zaW5nIHlvdXIgbW9uZXkgYmVjYXVzZSB5b3UgZW5kIHVwIGluIGEgZGVhZCBlbmQgaXMgcHJvYmFibHkgbm90IHZlcnkgZWZmaWNpZW50LiBBbmQgd2UgaGF2ZSBhIHZlcnkgZ29vZCByZXR1cm4gb24gaW52ZXN0bWVudCBmb3IgdGhlIGNvbXBhbnkuIEl0XHUyMDE5cyB2ZXJ5IGltcG9ydGFudCB0byBiZSBjbGVhciBhYm91dCB3aGF0IHdlIGNhbiBiZSBnb29kIGF0IGFuZCB3aGF0IHdlIGNhbiBwcm92aWRlIGFzIGFuIGFkdmFudGFnZS5cdTIwMWQ8L2Jsb2NrcXVvdGU+XHJcblRoZSBMYWIgYWNjZXB0cyBwcm9qZWN0cyBpZiB0aGV5IGFyZSBjb252aW5jZWQgYnkgaXQgYW5kIGlmIGl0IGJyaW5ncyBuZXcga25vd2xlZGdlOlxyXG48YmxvY2txdW90ZT5cdTIwMWNPdXIgbGFiIGlzIGJhc2VkIG9uIGJlaW5nIGhhbmRzLW9uLCBiZWNhdXNlIGRlc2lnbiBpbnNwaXJhdGlvbiBjb21lcyBieSBkb2luZywgbm90IG9ubHkgYnkgdGhpbmtpbmcsIHNvIGl0IG11c3QgYmUgd2l0aCByZWFsIHBlb3BsZSBpbiBhIHJlYWwgY2FzZSwgYnV0IGl0IG11c3QgYWxzbyB0YWNrbGUgYSByZWFsIGNoYWxsZW5nZSBmb3Igc29jaWV0eS5cdTIwMWQ8L2Jsb2NrcXVvdGU+XHJcbkFzIGEgTGFiLCB0aGV5IGRlbGl2ZXIgZnVuY3Rpb25hbCBwcm90b3R5cGVzLCBidXQgbm8gZmluYWwgcHJvZHVjdHMuIEFsdGhvdWdoIHRoZSBwcm90b3R5cGVzIGFyZSBtYWRlIGluIHN1Y2ggYSB3YXkgdGhhdCBpdCBpcyBwb3NzaWJsZSBmb3IgdGhlIGNvbXBhbnkgdG8gZGV2ZWxvcCB0aGUgcHJvZHVjdCBmdXJ0aGVyIGlmIHRoZXkgd2lzaCB0byBkbyBzbzogXHUyMDFjVGhhdFx1MjAxOXMgYWxzbyB0aGUgb25seSB3YXkgdG8gYmVuZWZpdCBzb2NpZXR5LiBPdGhlcndpc2UgdGhleSBoYXZlIHNvbWV0aGluZyB0aGF0IGlzIHJlYWxseSBjb29sLCBidXQgaWYgdGhlcmUgaXMgbm8gaW5jb21lLCBubyBmdW5kaW5nLCBpdCB3aWxsIG5vdCBsYXN0Llx1MjAxZFxyXG5cclxuQ09OVEFDVCBQT0lOVFxyXG5cclxuPGltZyBjbGFzcz1cImFsaWdubm9uZSB3cC1pbWFnZS0xMTQxNCBzaXplLWZ1bGxcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxOC8wMS9uaWNvbGFzLWUxNTE3MjMzNDA3NjM2LmpwZ1wiIGFsdD1cIlwiIHdpZHRoPVwiMjAwXCIgaGVpZ2h0PVwiMjUwXCIgLz5cclxuXHJcbk5pY29sYXMgSGVuY2hveiwgRGlyZWN0b3IsIEVQRkwrRUNBTCBMYWJcclxuV2ViOiA8YSBocmVmPVwiaHR0cDovL3d3dy5lcGZsLWVjYWwtbGFiLmNoL1wiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+aHR0cDovL3d3dy5lcGZsLWVjYWwtbGFiLmNoLzwvYT5cclxuVHdpdHRlcjogPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vZXBmbGVjYWxsYWJcIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPkBlcGZsZWNhbGxhYjwvYT5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMi8zXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48aDM+QXV0aG9yPC9oMz5cclxuW3NpbXBsZS1hdXRob3ItYm94XVsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XSIsInBvc3RfdGl0bGUiOiJFUEZMK0VDQUwgTGFiOiBpbm5vdmF0aW9ucyBzaG91bGQgZmVlbCBuYXR1cmFsIHRvIHVzZXJzIHRvIGJlIHN1c3RhaW5hYmxlIiwicG9zdF9saW5rIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL2VwZmxlY2FsLWxhYi1pbm5vdmF0aW9ucy1mZWVsLW5hdHVyYWwtdXNlcnMtc3VzdGFpbmFibGUvIiwicG9zdF9mZWF0dXJlZF9pbWFnZSI6IjxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiRVBGTCtFQ0FMIExhYjogaW5ub3ZhdGlvbnMgc2hvdWxkIGZlZWwgbmF0dXJhbCB0byB1c2VycyB0byBiZSBzdXN0YWluYWJsZVwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMTUyXCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTgvMDEvaGVhZGVyLTEtMS0zMDB4MTUyLmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6Iklubm92YXRpb24gQ2FzZSwgTWVkaWEgbGFicyIsInBvc3RfdGFncyI6ImFjYWRlbWljIExhYiwgZGVzaWduIHJlc2VhcmNoLCBJbW1lcnNpdmUsIGluZHVzdHJ5IGNvbGxhYm9yYXRpb24sIHByb3RvdHlwZXMsIFN3aXR6ZXJsYW5kIiwiJV92Y19wb3N0X3NldHRpbmdzJSI6eyJ2Y19ncmlkX2lkIjpbXX0sIiVfZWRpdF9sb2NrJSI6IjE1MjY5OTk4ODI6MTAxIiwiJV9lZGl0X2xhc3QlIjoiMTAxIiwiJXNsaWRlX3RlbXBsYXRlJSI6ImRlZmF1bHQiLCIlX3dwYl92Y19qc19zdGF0dXMlIjoidHJ1ZSIsIiVfa2xlb190cmFuc3BhcmVudF9tZW51X2NvbG9yJSI6IndoaXRlIiwiJV9rbGVvX3RpdGxlX2NoZWNrYm94JSI6IjEiLCIlX2tsZW9fdGl0bGVfY29sb3IlIjoiIyIsIiVfa2xlb190aXRsZV9iZyUiOiIsIHJlcGVhdCwgaW5oZXJpdCwgc2Nyb2xsLCBsZWZ0IHRvcCIsIiVfa2xlb190aXRsZV9iZ19jb2xvciUiOiIjIiwiJV95b2FzdF93cHNlb19jb250ZW50X3Njb3JlJSI6IjMwIiwiJV95b2FzdF93cHNlb19wcmltYXJ5X2NhdGVnb3J5JSI6IjY5IiwiJV9wdWJsaWNpemVfcGVuZGluZyUiOiIxIiwiJV90aHVtYm5haWxfaWQlIjoiMTE0MjIiLCIlX3dwZ21wX2xvY2F0aW9uX2FkZHJlc3MlIjoiTGF1c2FubmUsIFN3aXR6ZXJsYW5kIiwiJV93cGdtcF9tZXRhYm94X2xhdGl0dWRlJSI6IjQ2LjUxOTY1MzUiLCIlX3dwZ21wX21ldGFib3hfbG9uZ2l0dWRlJSI6IjYuNjMyMjczNDAwMDAwMDMxIiwiJV93cGdtcF9tZXRhYm94X2xvY2F0aW9uX3JlZGlyZWN0JSI6InBvc3QiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiMlwiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6Ik47IiwiJV93cGdtcF9tZXRhYm94X3RheG9tb21pZXNfdGVybXMlIjoiTjsiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6Ik47IiwiJV9qZXRwYWNrX3JlbGF0ZWRfcG9zdHNfY2FjaGUlIjp7IjYyMzkzYjI0MmM3YTU2MTc3NGY4ZWJmZjVjMWMwNTY1Ijp7ImV4cGlyZXMiOjE1NDUzNjU4NjksInBheWxvYWQiOlt7ImlkIjoxMTQ5NH0seyJpZCI6MTAxNDR9LHsiaWQiOjEwNjg2fV19fSwiJXNiZ19zZWxlY3RlZF9zaWRlYmFyJSI6IjAiLCIlc2JnX3NlbGVjdGVkX3NpZGViYXJfcmVwbGFjZW1lbnQlIjoiMCIsInRheG9ub215PWNhdGVnb3J5IjoiSW5ub3ZhdGlvbiBDYXNlLCBNZWRpYSBsYWJzIiwidGF4b25vbXk9cG9zdF90YWciOiJhY2FkZW1pYyBMYWIsIGRlc2lnbiByZXNlYXJjaCwgSW1tZXJzaXZlLCBpbmR1c3RyeSBjb2xsYWJvcmF0aW9uLCBwcm90b3R5cGVzLCBTd2l0emVybGFuZCJ9LCJpY29uIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTgvMDIvbWFya2VyLTEucG5nIn0sImlkIjoxMTQxMiwiaW5mb3dpbmRvd19kaXNhYmxlIjpmYWxzZX0seyJzb3VyY2UiOiJwb3N0IiwidGl0bGUiOiJpTk9WQSBNZWRpYSBMYWI6IHJlc2VhcmNoLCBwcm9qZWN0IGRldmVsb3BtZW50IGFuZCBuZXR3b3JraW5nIHdpdGggbWVkaWEiLCJpbmZvd2luZG93X2NvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cImlOT1ZBIE1lZGlhIExhYjogcmVzZWFyY2gsIHByb2plY3QgZGV2ZWxvcG1lbnQgYW5kIG5ldHdvcmtpbmcgd2l0aCBtZWRpYVwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMTI5XCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTgvMDEvaU5PVkEtMjktMTQ4Mng2MzUtMzAweDEyOS5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1wYWRkaW5nLWNvbnRlbnRfMjBcIj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1tZXRhIGZjLWl0ZW0tc2Vjb25kYXJ5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2UgZmMtdGV4dC1jZW50ZXJcIj5Jbm5vdmF0aW9uIENhc2UsIE1lZGlhIGxhYnM8L2Rpdj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS10aXRsZSBmYy1pdGVtLXByaW1hcnktdGV4dC1jb2xvciBmYy10ZXh0LWNlbnRlclwiPmlOT1ZBIE1lZGlhIExhYjogcmVzZWFyY2gsIHByb2plY3QgZGV2ZWxvcG1lbnQgYW5kIG5ldHdvcmtpbmcgd2l0aCBtZWRpYTwvZGl2PlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2VcIj5cclxuICAgICAgICAgICAgSm9pbmluZyB0aGUgd29ybGRzIG9mIHNvY2lhbCBzY2llbmNlcyBhbmQgZW1lcmdpbmcgdGVjaG5vbG9naWVzLCBieSBhcHBseWluZyB0aGVpciByZXNlYXJjaCB0byBtZWRpYSBpbmR1c3RyeSBwcmFjdGljZXMuXHJcbiAgICAgICAgPC9kaXY+XHJcbjxhIGhyZWY9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvaW5vdmEtbWVkaWEtbGFiL1wiPlJlYWQgbW9yZTwvYT5cclxuICAgIDwvZGl2PlxyXG4gICAgPC9kaXY+XHJcbjwvZGl2PlxyXG5cclxuIiwiY29udGVudCI6IkpvaW5pbmcgdGhlIHdvcmxkcyBvZiBzb2NpYWwgc2NpZW5jZXMgYW5kIGVtZXJnaW5nIHRlY2hub2xvZ2llcywgYnkgYXBwbHlpbmcgdGhlaXIgcmVzZWFyY2ggdG8gbWVkaWEgaW5kdXN0cnkgcHJhY3RpY2VzLiIsImFkZHJlc3MiOiJMaXNib24sIFBvcnR1Z2FsIiwibG9jYXRpb24iOnsibGF0IjoiMzguNzIyMjUyNCIsImxuZyI6Ii05LjEzOTMzNjU5OTk5OTk3OSIsIm9uY2xpY2tfYWN0aW9uIjoicG9zdCIsInJlZGlyZWN0X3Blcm1hbGluayI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9pbm92YS1tZWRpYS1sYWIvIiwiem9vbSI6MiwiZXh0cmFfZmllbGRzIjp7InBvc3RfZXhjZXJwdCI6IkpvaW5pbmcgdGhlIHdvcmxkcyBvZiBzb2NpYWwgc2NpZW5jZXMgYW5kIGVtZXJnaW5nIHRlY2hub2xvZ2llcywgYnkgYXBwbHlpbmcgdGhlaXIgcmVzZWFyY2ggdG8gbWVkaWEgaW5kdXN0cnkgcHJhY3RpY2VzLiIsInBvc3RfY29udGVudCI6Ilt2Y19yb3ddW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIyLzNcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxoMT5pTk9WQSBNZWRpYSBMYWIgXHUyMDEzIHJlc2VhcmNoLCBwcm9qZWN0IGRldmVsb3BtZW50IGFuZCBuZXR3b3JraW5nIHdpdGggbWVkaWE8L2gxPlxyXG48c3Ryb25nPkpvaW5pbmcgdGhlIHdvcmxkcyBvZiBzb2NpYWwgc2NpZW5jZXMgYW5kIGVtZXJnaW5nIHRlY2hub2xvZ2llcywgYnkgYXBwbHlpbmcgdGhlaXIgcmVzZWFyY2ggdG8gbWVkaWEgaW5kdXN0cnkgcHJhY3RpY2VzLjwvc3Ryb25nPlxyXG5cclxuTG9jYXRlZCBpbiBMaXNib24sIFBvcnR1Z2FsLCBpTk9WQSBicmluZ3MgYSBkaWZmZXJlbnQgYXBwcm9hY2ggdG8gbWVkaWEgaW5ub3ZhdGlvbi4gSXQgYWltcyB0byBpbmNvcnBvcmF0ZSBuZXcgZGlnaXRhbCB0ZWNobm9sb2dpZXMgd2l0aGluIHRoZSB0cmFkaXRpb25hbCBtZWRpYSBpbmR1c3RyaWVzLCBhcyB3ZWxsIGFzIHJlc2VhcmNoIG5ldyBtZXRob2RzIGFuZCBwcm9kdWN0cyB0byBpbXByb3ZlIHRoZSBxdWFsaXR5IG9mIHJlcG9ydGluZyBhbmQgc29sdmUgaXNzdWVzIHdpdGhpbiB0aGUgbWVkaWEgZW52aXJvbm1lbnQ6XHJcbjxibG9ja3F1b3RlPlx1MjAxY0kgdGhpbmsgbWVkaWEgaW5ub3ZhdGlvbiBpcyBub3QganVzdCBsaW5rZWQgdG8gYWRkcmVzc2luZyB0aGUgY2hhbGxlbmdlcyBvZiB0aGUgaW5kdXN0cnksIGJ1dCBhbHNvIHRvIHNlZWluZyB3aGF0XHUyMDE5cyBub3QgYWxyZWFkeSB0aGVyZS4gSXRcdTIwMTlzIGFib3V0IGRldmVsb3BpbmcgbmV3IG1vZGVzIG9mIGludGVybWVkaWF0aW9uIHdpdGggY29udGVudC4gSW4gYSB3YXkgaXRcdTIwMTlzIGFkZHJlc3NpbmcgaW5kdXN0cnkgcHJvYmxlbXMsIGJ1dCBpdFx1MjAxOXMgYWxzbyBhYm91dCBjb25jZWl2aW5nIGFuZCBkZXZlbG9waW5nIGFwcGxpZWQgYW5zd2VycyBmb3IgdGhlIGZ1dHVyZSxcdTIwMWQgc2F5cyBQYXVsbyBOdW5vIFZpY2VudGUsIGNvb3JkaW5hdG9yIG9mIHRoZSBpTk9WQSBNZWRpYSBMYWIuPC9ibG9ja3F1b3RlPlxyXG48aDM+TWVkaWEgcmVzZWFyY2ggYXBwbGllZCB0byBqb3VybmFsaXNtIHByYWN0aWNlczwvaDM+XHJcblRoZSBsYWIgc3RhcnRlZCBpbiBGZWJydWFyeSAyMDE2IHVuZGVyIHRoZSB2aXNpb24gYW5kIGNvb3JkaW5hdGlvbiBvZiBQYXVsbyBOdW5vIFZpY2VudGUgd2hvIGxvb2tlZCB0byBjcmVhdGUgYSBuZXcgdmVudHVyZSBmb3IgbWVkaWEgaW5ub3ZhdGlvbiBpbnNwaXJlZCBieSByZXNlYXJjaCBsYWJzIGZyb20gb3RoZXIgYXJlYXMuXHJcblxyXG5pTk9WQSBNZWRpYSBMYWIgZm9jdXNlcyBpdHMgcmVzb3VyY2VzIG9uIHRocmVlIG1haW4gYXJlYXM6XHJcbjx1bD5cclxuXHQ8bGk+Q29uZHVjdGluZyBhcHBsaWVkIHJlc2VhcmNoIGluIHZhcmlvdXMgZGlnaXRhbCBtZWRpYSBpbm5vdmF0aW9uIHN0cmF0ZWdpZXMsIHN1Y2ggYXMgaW1tZXJzaXZlIGFuZCBpbnRlcmFjdGl2ZSBzdG9yeXRlbGxpbmcsIGRpZ2l0YWwgam91cm5hbGlzbSwgc2NpZW5jZSBjb21tdW5pY2F0aW9uLCBkaWdpdGFsIG1ldGhvZHMgYW5kIHdlYiBwbGF0Zm9ybXMsIGluZm9ybWF0aW9uIHZpc3VhbGl6YXRpb24gYW5kIHRoZSBmdXR1cmUgb2YgZWR1Y2F0aW9uOzwvbGk+XHJcblx0PGxpPkNyZWF0aW5nIHdvcmtzaG9wcyBhbmQgdHJhaW5pbmcgY291cnNlcyBmb3IgYm90aCBzdHVkZW50cywgcmVzZWFyY2hlcnMsIHByb2Zlc3NvcnMgYW5kIG1lZGlhIHByb2Zlc3Npb25hbHM8L2xpPlxyXG5cdDxsaT5PZmZlcmluZyBmaW5pc2hlZCBwcm9kdWN0cyBhbmQgc2VydmljZXMgcGVyIHJlcXVlc3QsIGluY2x1ZGluZyBhdWRpbyBhbmQgdmlkZW8gcHJvZHVjdGlvbiB1c2luZyAzNjAgZGVncmVlcyBmb3JtYXRzLCBpbW1lcnNpdmUgdGVjaG5vbG9naWVzIGFuZCBvdGhlciBkaWdpdGFsIGRldmljZXMgYW5kIG1ldGhvZHMuPC9saT5cclxuPC91bD5cclxuPGgzPjwvaDM+XHJcbjxoMz5QQU5PUFRJUyBwcm9qZWN0PC9oMz5cclxuaU5PVkEgTWVkaWEgTGFiXHUyMDE5cyBwcmltYXJ5IGludGVyZXN0IGF0IHRoZSBtb21lbnQgaXMgdGhlIGRldmVsb3BtZW50IG9mIHRoZSBQQU5PUFRJUyBwcm9qZWN0LCBhbiBpbnRlcmRpc2NpcGxpbmFyeSBwcm9qZWN0IGFyb3VuZCBjbGltYXRlIGNoYW5nZSBmb2N1c2VkIG9uIHJlZGVmaW5pbmcgcmVwb3J0aW5nIHRocm91Z2ggaW1tZXJzaXZlIHRlY2hub2xvZ3kuXHJcblxyXG5UaGUgb25lLXllYXIgbG9uZyBwcm9qZWN0IGlzIGRlc2lnbmVkIHRvIHRha2UgYSBjcmVhdGl2ZSBhbmQgY3V0dGluZy1lZGdlIGFwcHJvYWNoIHRvIHJlcG9ydGluZyBvbiB0aGUgaHVtYW4gY29udHJpYnV0aW9uIHRvIGNsaW1hdGUgY2hhbmdlIGJ5IGRldmVsb3BpbmcgdHdvIHByb3RvdHlwZXMgb2YgaW1tZXJzaXZlIGRvY3VtZW50YXJpZXMgaW4gdHdvIGRpZmZlcmVudCBhcmVhczogR3VpbmVhLUJpc3NhdSBhbmQgTWFkZWlyYSBJc2xhbmQuXHJcblxyXG5BY2NvcmRpbmcgdG8gUGF1bG8gTnVubyBWaWNlbnRlLCB3aG8gaXMgYWxzbyB0aGUgcHJpbmNpcGFsIGludmVzdGlnYXRvciBmb3IgdGhlIFBBTk9QVElTIHByb2plY3QsIHRoZSBvYmplY3RpdmUgaXMgbm90IG9ubHkgdG8gcmFpc2UgYXdhcmVuZXNzIG9mIHRoZSBpc3N1ZXMgc3Vycm91bmRpbmcgY2xpbWF0ZSBjaGFuZ2UsIGJ1dCBhbHNvIGVucmljaGluZyB0aGUgbWVkaWFcdTIwMTlzIHZpZXcgb24gcmVwb3J0aW5nIGJ5IGluY29ycG9yYXRpbmcgZGlnaXRhbCB0ZWNobm9sb2dpZXMgaW50byB0cmFkaXRpb25hbCBqb3VybmFsaXNtLlxyXG48YmxvY2txdW90ZT5cdTIwMWNJbiBhIHdheSwgd2hhdCB3ZSB3YW50IHRvIGRvIGlzIGFkZHJlc3MgY29udGVtcG9yYXJ5IGlzc3VlcyBhbmQgZGV2ZWxvcCB0aGUgcG90ZW50aWFsIGNvbWluZyBmcm9tIHRoZSBsYW5ndWFnZSBvZiBuZXcgbWVkaWEuIFNvIG9uIHRvcCBvZiBkb2luZyB0aGUgdHJhZGl0aW9uYWwgZG9jdW1lbnRhcnkgdXNpbmcgbmV3IG1lZGlhLCBhbHNvIHN0dWR5aW5nIGFuZCB0ZXN0aW5nIGhvdyB0byB1c2UgaW1tZXJzaXZlIG1lZGlhIGFuZCBkYXRhIHZpc3VhbGlzYXRpb24uIFlvdSBuZWVkIHRvIGNoYWxsZW5nZSB0aGUgc3RhdHVzIHF1by5cdTIwMWQ8L2Jsb2NrcXVvdGU+XHJcblRoZSBwcm9qZWN0IGJyaW5ncyB0b2dldGhlciBhIGNvbnNvcnRpdW0gb2YgcGFydG5lcnMgYWNyb3NzIFBvcnR1Z2FsLCB0aGUgbWFpbiBvbmVzIGJlaW5nIHRoZSBQb3J0dWd1ZXNlIEluc3RpdHV0ZSBmb3IgT2NlYW4gU3R1ZGllcyBhbmQgTk9WQSBMYWJvcmF0b3J5IGZvciBDb21wdXRlciBTY2llbmNlIGFuZCBJbmZvcm1hdGljcyAoTk9WQSBMSU5DUyksIGFuZCBhbHNvIGZyb20gdGhlIFVuaXRlZCBTdGF0ZXMsIGluIGNvbGxhYm9yYXRpb24gd2l0aCBVbml2ZXJzaXR5IG9mIFRleGFzIGF0IEF1c3Rpbi5cclxuPGgzPkluZHVzdHJ5IHBhcnRuZXJzaGlwczwvaDM+XHJcbkFsdGhvdWdoIGZhaXJseSBuZXcsIGlOT1ZBIE1lZGlhIExhYidzIHdvcmsgcG9ydGZvbGlvIGluY2x1ZGVzIGEgdmFyaWV0eSBvZiBwcm9qZWN0cyBkb25lIGluIGNvbGxhYm9yYXRpb24gd2l0aCBleHRlcm5hbCBtZWRpYSBvcmdhbmlzYXRpb25zIGFuZCB1bml2ZXJzaXR5IHN0dWRlbnRzLlxyXG5cclxuU3VjaCBwcm9qZWN0cyBpbmNsdWRlIHRoZSBcIjkwIFNlY29uZHMgb2YgU2NpZW5jZVwiIHJhZGlvIHByb2dyYW1tZSwgYnJvYWRjYXN0ZWQgZGFpbHkgYnkgQW50ZW5hIDEsIG9uZSBvZiBQb3J0dWdhbCdzIG5hdGlvbmFsIHB1YmxpYyByYWRpbyBzdGF0aW9ucy4gVGhlIHByb2dyYW1tZSBpcyBkZWRpY2F0ZWQgdG8gcHJlc2VudGluZyBuZXcgYW5kIGRpZmZlcmVudCByZXNlYXJjaCBtZXRob2RzIGFuZCBwcm9qZWN0cyBkb25lIGFsbCBhY3Jvc3MgUG9ydHVnYWwuXHJcblxyXG5UaGFua3MgdG8gdGhlIHN1Y2Nlc3Mgb2YgdGhlIHJhZGlvIHNob3csIGlOT1ZBIE1lZGlhIExhYiBpcyBjdXJyZW50bHkgd29ya2luZyBvbiBkZXZlbG9waW5nIGEgcGlsb3QgZXBpc29kZSBmb3IgYSBzcGluLW9mZiBjYWxsZWQgXCI1IE1pbnV0ZXMgb2YgU2NpZW5jZVwiLCB3aGljaCB3aWxsIGJlIGF2YWlsYWJsZSBvbiBUViBhbmQgb25saW5lLlxyXG5cclxuaU5PVkEgTWVkaWEgTGFiIGFsc28gb2ZmZXJzIGEgdmFyaWV0eSBvZiB3b3Jrc2hvcHMgYW5kIHRyYWluaW5nIGNvdXJzZXMgc3Vycm91bmRpbmcgaW1tZXJzaXZlIG1lZGlhLCBlbnRyZXByZW5ldXJpYWwgam91cm5hbGlzbSBhbmQgc3Rvcnl0ZWxsaW5nIHVzaW5nIGRpZ2l0YWwgbWVkaWEgdGVjaG5vbG9naWVzLiBUaGVzZSBhcmUgcGFydCBvZiB0aGVpciBEaWdpdGFsIE1lZGlhIFN1bW1lciBJbnN0aXR1dGUsIGNyZWF0ZWQgaW4gcGFydG5lcnNoaXAgd2l0aCBUaGUgVW5pdmVyc2l0eSBvZiBUZXhhcyBhdCBBdXN0aW4uXHJcblxyXG5JbiBKYW51YXJ5LCB0aGUgbGFiIG9yZ2FuaXNlZCBhIERpZ2l0YWwgTWVkaWEgV2ludGVyIEluc3RpdHV0ZSwgZGVkaWNhdGVkIHRvIGFkdmFuY2luZyB0aGUgc3R1ZHkgb2YgbmV3IG1lZGlhLCBzb2NpYWwgbWVkaWEgbWV0aG9kcywgYW5kIGRhdGEgdmlzdWFsaXNhdGlvbi4gVGhlIGV2ZW50IHByb21vdGVkIGludGVyZGlzY2lwbGluYXJ5IHJlc2VhcmNoIHRocm91Z2ggdGhlIGRhdGEtc3ByaW50IGFwcHJvYWNoIGFuZCBvdGhlciBpbnRlbnNpdmUgaGFuZHMtb24gd29yayBjb3Vyc2VzLlxyXG48aDM+RnV0dXJlIHByb2plY3RzIGFuZCBjb2xsYWJvcmF0aW9uczwvaDM+XHJcbmlOT1ZBIE1lZGlhIExhYiB3aWxsIGVudGVyIGEgbmV3IHBoYXNlIGluIEphbnVhcnkgMjAxOCwgd2hpY2ggd2lsbCBhbGxvdyBpdCB0byBkZXZlbG9wIGRpZmZlcmVudCBleHBsb3JhdG9yeSBzdHVkaWVzIGFuZCBwcm90b3R5cGVzIGNvbm5lY3RlZCB0byBkaWdpdGFsIG1lZGlhIGlubm92YXRpb24gYW5kIGFwcGxpZWQgcmVzZWFyY2guIEFzIHBhcnQgb2YgdGhlIG5ldyBwaGFzZSwgdGhlIGxhYiBleHBlY3RzIHRvIGdyb3cgaXRzIHRlYW0gYnkgaGlyaW5nIG5ldyBzdGFmZiwgYnJpbmdpbmcgdGhlIHRvdGFsIG51bWJlciBvZiBjb2xsYWJvcmF0b3JzIGFuZCBlbXBsb3llZXMgdG8gMTMuXHJcbjxibG9ja3F1b3RlPlx1MjAxY0kgZG8gaGF2ZSB2ZXJ5IGNsZWFyIG1ldHJpY3MgdGhhdCBoZWxwIHRoZSBkZXZlbG9wbWVudCBvZiB0aGUgbGFib3JhdG9yeSBpdHNlbGYsIGFuZCBwYXJ0IG9mIHRoYXQgaXMgdGhlIGFiaWxpdHkgdG8gYXR0cmFjdCBwZW9wbGUsIHNvIFBoRCByZXNlYXJjaGVycyBhbmQgbWFzdGVyIHN0dWRlbnRzOyBjb21taXR0ZWQsIGVuZ2FnZWQgYW5kIG1vdGl2YXRlZCBwZW9wbGUsXHUyMDFkIHNheXMgUGF1bG8gTnVubyBWaWNlbnRlLjwvYmxvY2txdW90ZT5cclxuTW9yZW92ZXIsIHRoZSB0ZWFtIGlzIGxvb2tpbmcgdG8gc3RhcnQgYSBuZXcsIDQteWVhciByZXNlYXJjaCBwcm9qZWN0IG5hbWVkIFwiSW5ub3YtYWN0aW9uXCIsIGZvY3VzZWQgb24gYW5hbHlzaW5nIGlubm92YXRpdmUgcHJvY2Vzc2VzIGFuZCBtZXRob2RvbG9naWVzIGFjcm9zcyB0aGUgY291bnRyeS4gVGhlIHByb2plY3QgY29uc2lzdHMgb2YgXCJtYXBwaW5nXCIgY3JlYXRpdmUgYW5kIG5ldyBkZXZlbG9wbWVudCBtZXRob2RzIHdpdGhpbiBjdWx0dXJhbCBpbmR1c3RyaWVzIGluIFBvcnR1Z2FsIGFuZCBwcm9kdWNpbmcgcmVzZWFyY2ggcmVwb3J0cyBvbiB0aGVpciBtZXRob2RzLlxyXG5cclxuRmluYWxseSwgaU5PVkEgTWVkaWEgTGFiIGlzIGxvb2tpbmcgdG8gaW5jcmVhc2UgaXRzIG5ldHdvcmsgYnkgbGlhaXNpbmcgd2l0aCBvdGhlciBtZWRpYSBsYWJzIG5hdGlvbmFsbHkgYW5kIGludGVybmF0aW9uYWxseSwgYXMgd2VsbCBhcyBtYWludGFpbmluZyBhbmQgZGV2ZWxvcGluZyBuZXcgcmVsYXRpb25zIHdpdGggbWVkaWEgaW5kdXN0cmllcy5cclxuXHJcbkNPTlRBQ1QgUE9JTlRcclxuPGltZyBjbGFzcz1cImFsaWdubm9uZSB3cC1pbWFnZS0xMTM2NiBzaXplLWZ1bGxcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxOC8wMS9QYXVsby1OdW5vLVZpY2VudGVfZnVsbC0xLnBuZ1wiIGFsdD1cIlwiIHdpZHRoPVwiMjAwXCIgaGVpZ2h0PVwiMjUwXCIgLz5cclxuUGF1bG8gTnVubyBWaWNlbnRlLCBjb29yZGluYXRvciwgaU5PVkEgTWVkaWEgTGFiXHJcblR3aXR0ZXI6IDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL2lub3ZhbWVkaWFsYWJcIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPkBpTk9WQW1lZGlhbGFiPC9hPlxyXG5XZWI6IDxhIGhyZWY9XCJodHRwOi8vaW5vdmFtZWRpYWxhYi5vcmcvcGF1bG8tbnVuby12aWNlbnRlL1wiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+aW5vdmFtZWRpYWxhYi5vcmc8L2E+Wy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjIvM1wiXVt2Y19jb2x1bW5fdGV4dF1cclxuPGgzPkF1dGhvcjwvaDM+XHJcbltzaW1wbGUtYXV0aG9yLWJveF1bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd10iLCJwb3N0X3RpdGxlIjoiaU5PVkEgTWVkaWEgTGFiOiByZXNlYXJjaCwgcHJvamVjdCBkZXZlbG9wbWVudCBhbmQgbmV0d29ya2luZyB3aXRoIG1lZGlhIiwicG9zdF9saW5rIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL2lub3ZhLW1lZGlhLWxhYi8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJpTk9WQSBNZWRpYSBMYWI6IHJlc2VhcmNoLCBwcm9qZWN0IGRldmVsb3BtZW50IGFuZCBuZXR3b3JraW5nIHdpdGggbWVkaWFcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjEyOVwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE4LzAxL2lOT1ZBLTI5LTE0ODJ4NjM1LTMwMHgxMjkuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+IiwicG9zdF9jYXRlZ29yaWVzIjoiSW5ub3ZhdGlvbiBDYXNlLCBNZWRpYSBsYWJzIiwicG9zdF90YWdzIjoiYWNhZGVtaWMgTGFiLCBkZXNpZ24gc3ByaW50LCBJbW1lcnNpdmUsIGluZHVzdHJ5IGNvbGxhYm9yYXRpb24sIFBvcnR1Z2FsLCB0cmFpbmluZyBhbmQgZWR1Y2F0aW9uIiwiJV92Y19wb3N0X3NldHRpbmdzJSI6eyJ2Y19ncmlkX2lkIjpbXX0sIiVfZWRpdF9sb2NrJSI6IjE1MjY5OTk5NTE6MTAxIiwiJV9lZGl0X2xhc3QlIjoiMTAxIiwiJXNsaWRlX3RlbXBsYXRlJSI6ImRlZmF1bHQiLCIlX3dwYl92Y19qc19zdGF0dXMlIjoidHJ1ZSIsIiVfa2xlb190cmFuc3BhcmVudF9tZW51X2NvbG9yJSI6IndoaXRlIiwiJV9rbGVvX3RpdGxlX2NvbG9yJSI6IiMiLCIlX2tsZW9fdGl0bGVfYmclIjoiLCByZXBlYXQsIGluaGVyaXQsIHNjcm9sbCwgbGVmdCB0b3AiLCIlX2tsZW9fdGl0bGVfYmdfY29sb3IlIjoiIyIsIiVfeW9hc3Rfd3BzZW9fY29udGVudF9zY29yZSUiOiI2MCIsIiVfeW9hc3Rfd3BzZW9fcHJpbWFyeV9jYXRlZ29yeSUiOiI2OSIsIiVfa2xlb190aXRsZV9jaGVja2JveCUiOiIxIiwiJV95b2FzdF93cHNlb19mb2N1c2t3X3RleHRfaW5wdXQlIjoiaU5PVkEiLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza3clIjoiaU5PVkEiLCIlX3lvYXN0X3dwc2VvX2xpbmtkZXglIjoiNzQiLCIlX3RodW1ibmFpbF9pZCUiOiIxMTM2OCIsIiVfeW9hc3Rfd3BzZW9fbWV0YWRlc2MlIjoiSm9pbmluZyB0aGUgd29ybGRzIG9mIHNvY2lhbCBzY2llbmNlcyBhbmQgZW1lcmdpbmcgdGVjaG5vbG9naWVzLCBieSBhcHBseWluZyB0aGVpciByZXNlYXJjaCB0byBtZWRpYSBpbmR1c3RyeSBwcmFjdGljZXMuIiwiJV9wdWJsaWNpemVfcGVuZGluZyUiOiIxIiwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6Ikxpc2JvbiwgUG9ydHVnYWwiLCIlX3dwZ21wX21ldGFib3hfbGF0aXR1ZGUlIjoiMzguNzIyMjUyNCIsIiVfd3BnbXBfbWV0YWJveF9sb25naXR1ZGUlIjoiLTkuMTM5MzM2NTk5OTk5OTc5IiwiJV93cGdtcF9tZXRhYm94X2xvY2F0aW9uX3JlZGlyZWN0JSI6InBvc3QiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiMlwiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6Ik47IiwiJV93cGdtcF9tZXRhYm94X3RheG9tb21pZXNfdGVybXMlIjoiTjsiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6Ik47IiwiJV9qZXRwYWNrX3JlbGF0ZWRfcG9zdHNfY2FjaGUlIjp7IjYyMzkzYjI0MmM3YTU2MTc3NGY4ZWJmZjVjMWMwNTY1Ijp7ImV4cGlyZXMiOjE1NDUyNzQ3MzAsInBheWxvYWQiOlt7ImlkIjoxMDE0NH0seyJpZCI6MTEzNTJ9LHsiaWQiOjEwNjgxfV19fSwiJXNiZ19zZWxlY3RlZF9zaWRlYmFyJSI6IjAiLCIlc2JnX3NlbGVjdGVkX3NpZGViYXJfcmVwbGFjZW1lbnQlIjoiMCIsInRheG9ub215PWNhdGVnb3J5IjoiSW5ub3ZhdGlvbiBDYXNlLCBNZWRpYSBsYWJzIiwidGF4b25vbXk9cG9zdF90YWciOiJhY2FkZW1pYyBMYWIsIGRlc2lnbiBzcHJpbnQsIEltbWVyc2l2ZSwgaW5kdXN0cnkgY29sbGFib3JhdGlvbiwgUG9ydHVnYWwsIHRyYWluaW5nIGFuZCBlZHVjYXRpb24ifSwiaWNvbiI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE4LzAyL21hcmtlci0xLnBuZyJ9LCJpZCI6MTEzNjIsImluZm93aW5kb3dfZGlzYWJsZSI6ZmFsc2V9LHsic291cmNlIjoicG9zdCIsInRpdGxlIjoiRGlnaXRhbCBXb3JsZCBSZXNlYXJjaCBDZW50cmU6IGV4cGxvcmluZyB0aGUgaW50ZXJwbGF5IGJldHdlZW4gbWVkaWEgY29udGVudCwgcGxhdGZvcm0gYW5kIGV4cGVyaWVuY2UiLCJpbmZvd2luZG93X2NvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIkRpZ2l0YWwgV29ybGQgUmVzZWFyY2ggQ2VudHJlOiBleHBsb3JpbmcgdGhlIGludGVycGxheSBiZXR3ZWVuIG1lZGlhIGNvbnRlbnQsIHBsYXRmb3JtIGFuZCBleHBlcmllbmNlXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMjVcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxNy8xMi91bm5hbWVkLTMwMHgyMjUuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZ1wiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tcGFkZGluZy1jb250ZW50XzIwXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tbWV0YSBmYy1pdGVtLXNlY29uZGFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlIGZjLXRleHQtY2VudGVyXCI+SW5ub3ZhdGlvbiBDYXNlLCBNZWRpYSBsYWJzPC9kaXY+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tdGl0bGUgZmMtaXRlbS1wcmltYXJ5LXRleHQtY29sb3IgZmMtdGV4dC1jZW50ZXJcIj5EaWdpdGFsIFdvcmxkIFJlc2VhcmNoIENlbnRyZTogZXhwbG9yaW5nIHRoZSBpbnRlcnBsYXkgYmV0d2VlbiBtZWRpYSBjb250ZW50LCBwbGF0Zm9ybSBhbmQgZXhwZXJpZW5jZTwvZGl2PlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2VcIj5cclxuICAgICAgICAgICAgRFdSQyBicmluZ3MgdG9nZXRoZXIgZW5naW5lZXJpbmcsIGNvbW11bmljYXRpb24sIHNvY2lhbCBzY2llbmNlLCBidXNpbmVzcywgZGVzaWduIGFuZCBhcnRzIHRvIHdvcmsgb24gbWVkaWEgaW5ub3ZhdGlvbiBwcm9qZWN0cyB0aGF0IGhhdmUgYSBjb25jcmV0ZSBpbXBhY3Qgb24gc29jaWV0eSBhbmQgY3VsdHVyZS4gXHJcbiAgICAgICAgPC9kaXY+XHJcbjxhIGhyZWY9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvZGlnaXRhbC13b3JsZC1yZXNlYXJjaC1jZW50cmUvXCI+UmVhZCBtb3JlPC9hPlxyXG4gICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuPC9kaXY+XHJcblxyXG4iLCJjb250ZW50IjoiRFdSQyBicmluZ3MgdG9nZXRoZXIgZW5naW5lZXJpbmcsIGNvbW11bmljYXRpb24sIHNvY2lhbCBzY2llbmNlLCBidXNpbmVzcywgZGVzaWduIGFuZCBhcnRzIHRvIHdvcmsgb24gbWVkaWEgaW5ub3ZhdGlvbiBwcm9qZWN0cyB0aGF0IGhhdmUgYSBjb25jcmV0ZSBpbXBhY3Qgb24gc29jaWV0eSBhbmQgY3VsdHVyZS4gIiwiYWRkcmVzcyI6IjM4OCBTdGFnIEhpbGwsIEd1aWxkZm9yZCBHVTIgN1hILCBVbml0ZWQgS2luZ2RvbSIsImxvY2F0aW9uIjp7ImxhdCI6IjUxLjI0MjU3MTg5OTk5OTk5IiwibG5nIjoiLTAuNTg3OTQ1OTAwMDAwMDIyNCIsIm9uY2xpY2tfYWN0aW9uIjoicG9zdCIsInJlZGlyZWN0X3Blcm1hbGluayI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9kaWdpdGFsLXdvcmxkLXJlc2VhcmNoLWNlbnRyZS8iLCJ6b29tIjoyLCJleHRyYV9maWVsZHMiOnsicG9zdF9leGNlcnB0IjoiRFdSQyBicmluZ3MgdG9nZXRoZXIgZW5naW5lZXJpbmcsIGNvbW11bmljYXRpb24sIHNvY2lhbCBzY2llbmNlLCBidXNpbmVzcywgZGVzaWduIGFuZCBhcnRzIHRvIHdvcmsgb24gbWVkaWEgaW5ub3ZhdGlvbiBwcm9qZWN0cyB0aGF0IGhhdmUgYSBjb25jcmV0ZSBpbXBhY3Qgb24gc29jaWV0eSBhbmQgY3VsdHVyZS4gIiwicG9zdF9jb250ZW50IjoiW3ZjX3Jvd11bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjIvM1wiXVt2Y19jb2x1bW5fdGV4dF1cclxuPGgxPkRpZ2l0YWwgV29ybGQgUmVzZWFyY2ggQ2VudHJlOiBleHBsb3JpbmcgdGhlIGludGVycGxheSBiZXR3ZWVuIG1lZGlhIGNvbnRlbnQsIHBsYXRmb3JtIGFuZCBleHBlcmllbmNlPC9oMT5cclxuPHN0cm9uZz5EV1JDIGJyaW5ncyB0b2dldGhlciBlbmdpbmVlcmluZywgY29tbXVuaWNhdGlvbiwgc29jaWFsIHNjaWVuY2UsIGJ1c2luZXNzLCBkZXNpZ24gYW5kIGFydHMgdG8gd29yayBvbiBtZWRpYSBpbm5vdmF0aW9uIHByb2plY3RzIHRoYXQgaGF2ZSBhIGNvbmNyZXRlIGltcGFjdCBvbiBzb2NpZXR5IGFuZCBjdWx0dXJlLiA8L3N0cm9uZz5cclxuXHJcblRoZSBEaWdpdGFsIFdvcmxkIFJlc2VhcmNoIENlbnRyZSAoRFdSQykgaXMgYSByZXNlYXJjaCBuZXR3b3JrIHdpdGhpbiB0aGUgVW5pdmVyc2l0eSBvZiBTdXJyZXksIGNhcnJ5aW5nIG91dCBuZXcgbWVkaWEgaW5ub3ZhdGlvbiBwcm9qZWN0cyB3aXRoIHNvY2lhbCBhbmQgY3VsdHVyYWwgYmVuZWZpdC4gVGhleSBjb25kdWN0IGludGVyZGlzY2lwbGluYXJ5IHJlc2VhcmNoIGludG8gbmV3IG1lZGlhIHBsYXRmb3JtcywgY29udGVudCBhbmQgZXhwZXJpZW5jZXMsIGFuZCBzdHJpdmUgdG8gY29tbWVyY2lhbGlzZSBhbmQgYXBwbHkgdGhlIGZpbmRpbmdzIG9mIHJlc2VhcmNoIGluIHNvY2lldHkuXHJcblxyXG5UaGVpciB3b3JrIGlzIGZvY3VzZWQgb24gdW5kZXJzdGFuZGluZyBuZXcgZm9ybXMgb2YgZGlnaXRhbCBtZWRpYSBwcm9kdWN0aW9uIGFuZCBjb25zdW1wdGlvbiwgYW5kIGRldmVsb3Bpbmcgd2F5cyBvZiBzdXBwb3J0aW5nIHRoZW0gd2l0aCBub3ZlbCBtZWRpYSBnZW5yZXMsIGZvcm1hdHMsIGRldmljZXMgYW5kIHNlcnZpY2VzLlxyXG5cclxuQ3JlYXRlZCBpbiAxOTk4IGFzIGEgbXVsdGktZGlzY2lwbGluYXJ5IHJlc2VhcmNoIGNlbnRyZSwgdGhlIERXUkMgYWltcyB0byBicmluZyB0b2dldGhlciBhIGRpdmVyc2l0eSBvZiBpbnRlcm5hbCBhbmQgZXh0ZXJuYWwgcGFydG5lcnMgZm9yIHRoZWlyIGlubm92YXRpb24gcHJvamVjdHM6XHJcbjxibG9ja3F1b3RlPlx1MjAxY0FsdGhvdWdoIEkgYmVsb25nIHRvIHRoZSBEZXBhcnRtZW50IG9mIE11c2ljIGFuZCBNZWRpYSBvcmdhbmlzYXRpb25hbGx5LCBJIHNpdCBwaHlzaWNhbGx5IGluIFRoZSBEZXBhcnRtZW50IG9mIEVsZWN0cmljYWwgYW5kIEVsZWN0cm9uaWMgRW5naW5lZXJpbmcsXCIgc2F5cyBEaXJlY3RvciBvZiB0aGUgRFdSQyBEYXZpZCBGcm9obGljaC4gXCJGdXJ0aGVybW9yZSwgdGhlIHBlb3BsZSBJIHdvcmsgd2l0aCBjb21lIGZyb20gYWxsIHRocmVlIEZhY3VsdGllcyBhdCBTdXJyZXksIGluY2x1ZGluZyBIZWFsdGggYW5kIE1lZGljYWwgc2NpZW5jZXMsIEVuZ2luZWVyaW5nIGFuZCBQaHlzaWNhbCBTY2llbmNlcywgYW5kIEFydHMgYW5kIFNvY2lhbCBTY2llbmNlcy5cIjwvYmxvY2txdW90ZT5cclxuPGgzPkRlc2lnbiBSZXNlYXJjaDwvaDM+XHJcbldoZW4gRGF2aWQgam9pbmVkIHRoZSBDZW50cmUgaW4gMjAwNSwgaGUgaW50cm9kdWNlZCBpbm5vdmF0aW9uIHRvIHRoZSBncm91cCBhcyB3ZWxsIGFzIGEgbmV3IHdheSBvZiB3b3JraW5nIGludm9sdmluZyBkZXNpZ24gcmVzZWFyY2g6XHJcbjxibG9ja3F1b3RlPlx1MjAxY0kgaGFkIGJlZW4gd29ya2luZyB3aXRoIEhQIExhYnMgYXMgYSB1c2VyIHJlc2VhcmNoZXIsIGJ1dCBJIGdvdCBpbmNyZWFzaW5nbHkgaW52b2x2ZWQgd2l0aCBkZXNpZ24gLSBlc3BlY2lhbGx5IGRlc2lnbiBvZiBuZXcgdGVjaG5vbG9neSBwcm90b3R5cGVzLiBTbyBJIHN0YXJ0ZWQgb3V0IGRvaW5nIHN0dWRpZXMgb2YgdGVjaG5vbG9neSB1c2UsIGJ1dCB0aGVzZSBuYXR1cmFsbHkgbGVkIG9udG8gZGVzaWduaW5nLCBidWlsZGluZyBhbmQgdGVzdGluZyBwcm90b3R5cGVzIGluIHRoZSB3aWxkLlx1MjAxZDwvYmxvY2txdW90ZT5cclxuRGVzaWduIHJlc2VhcmNoIGxpa2UgdGhpcyBjYW4gYmUgYWJvdXQgcmVzZWFyY2gtZm9yLWRlc2lnbiBvciByZXNlYXJjaC10aHJvdWdoLWRlc2lnbi4gRFdSQyBkb2VzIGJvdGgsIGRlcGVuZGluZyBvbiB0aGUgdHlwZSBvZiBwcm9qZWN0LlxyXG5cclxuT24gdGhlIDxhIGhyZWY9XCJodHRwczovL3d3dy5zdXJyZXkuYWMudWsvZGlnaXRhbC13b3JsZC1yZXNlYXJjaC1jZW50cmUvZnVuZGVkLXByb2plY3RzL2NvbW11bml0eS1nZW5lcmF0ZWQtbWVkaWEtbmV4dC1iaWxsaW9uXCI+PGVtPkNvbW11bml0eS1nZW5lcmF0ZWQgbWVkaWEgZm9yIHRoZSBuZXh0IGJpbGxpb248L2VtPjwvYT4gcHJvamVjdCBmb3IgZXhhbXBsZSwgcmVzZWFyY2gtZm9yLWRlc2lnbiBhbGxvd2VkIHRoZW0gdG8gaW52ZXN0aWdhdGUgdGhlIGNyZWF0aXZlIHVzZSBvZiBjYW1lcmEgcGhvbmVzIGluIHJ1cmFsIFNvdXRoIEFmcmljYS4gVGhlIGFpbSB3YXMgdG8gZGVzaWduIGEgbW9iaWxlIGRpZ2l0YWwgc3Rvcnl0ZWxsaW5nIHN5c3RlbSAodGhlIDxlbT5Db20tTWU8L2VtPiB0b29sa2l0KSBmb3Igbm9uLXRleHR1YWwgY29tbXVuaWNhdGlvbi5cclxuXHJcbldoaWxlIG9uIHRoZSA8YSBocmVmPVwiaHR0cHM6Ly93d3cuc3VycmV5LmFjLnVrL2RpZ2l0YWwtd29ybGQtcmVzZWFyY2gtY2VudHJlL2Z1bmRlZC1wcm9qZWN0cy9pbnRlcmFjdGl2ZS1uZXdzcHJpbnRcIj48ZW0+SW50ZXJhY3RpdmUgTmV3c3ByaW50PC9lbT48L2E+IHByb2plY3QsIHRoZXkgZGlkIHJlc2VhcmNoLXRocm91Z2gtZGVzaWduIGJ5IGNvLWRlc2lnbmluZyBhbmQgY3JlYXRpbmcgYSBzZXJpZXMgb2YgaW50ZXJhY3RpbmcgcHJpbnQgcHJvdG90eXBlcyB3aXRoIGEgbG9jYWwgY29tbXVuaXR5LiBIZXJlIHRoZSB0ZWFtIGV4cGxvcmVkIHRoZSBhZmZvcmRhbmNlcyBvZiBcdTIwMThhdWRpbyBwYXBlcicgZm9yIHByaW50ZWQgY29tbXVuaXR5IG5ld3MuXHJcbjxoMz5QbGF0Zm9ybXMsIGNvbnRlbnQgYW5kIGV4cGVyaWVuY2VzPC9oMz5cclxuRm9yIERhdmlkLCBtZWRpYSBpbm5vdmF0aW9uIFx1MjAxY2hhcyBhbHdheXMgYmVlbiBhYm91dCB0cnlpbmcgdG8gaW52ZW50IGEgbmV3IG1lZGlhIGZvcm0sIGEgbmV3IG1lZGl1bSBpZiB5b3UgbGlrZSwgZm9yIGNvbW11bmljYXRpb25cdTIwMWQuIERXUkMgaXMgd29ya2luZyBvbiBwbGF0Zm9ybXMsIGNvbnRlbnQgYW5kIGV4cGVyaWVuY2VzIGF0IHRoZSBzYW1lIHRpbWUsIHdoaWxlIG1vc3QgY2VudHJlcyBhcmUgd29ya2luZyBvbiBvbmx5IG9uZSBvZiB0aGVzZS4gSW5ub3ZhdGlvbiBzaG91bGQgaW52b2x2ZSB0aG9zZSB0aHJlZSwgYXMgd29ya2luZyBvbiBvbmx5IG9uZSBhdCB0aGUgdGltZSBvdmVybG9va3MgdGhlIGludGVyYWN0aW9uIGJldHdlZW4gdGhlc2UgZnVuZGFtZW50YWwgcHJvcGVydGllcyBvZiBtZWRpYSBzeXN0ZW1zLlxyXG5cclxuVGhpcyBpbnRlcmFjdGlvbiBjYW4gYmUgc2VlbiBhdCB0aGUgYmVnaW5uaW5nIG9mIGVhY2ggbmV3IG1lZGlhIGZvcm0sIGFjY29yZGluZyB0byBEYXZpZC4gSW4gdGhlIGNhc2Ugb2YgY2luZW1hIGZvciBleGFtcGxlLCBpdCB3YXMgbm90IG9ubHkgYSBwbGF0Zm9ybSBpbnZlbnRpb24gZm9yIHJlY29yZGluZyBhbmQgcGxheWluZyBtb3ZpbmcgaW1hZ2VzIHdpdGggc291bmQ6XHJcbjxibG9ja3F1b3RlPlwiQ2luZW1hIGFsc28gcmVxdWlyZWQgbmV3IGtpbmRzIG9mIFx1MjAxOGNpbmVtYXRvZ3JhcGh5XHUyMDE5IGluIHRoZSBtYWtpbmcgb2YgZmlsbWljIGNvbnRlbnQgYXMgb3Bwb3NlZCB0byBqdXN0IHJlY29yZGluZyBwbGF5cy4gQ29udGVudCBjaGFuZ2VkIGZyb20gc2lsZW50IG1vdmllcyB0byBcdTIwMTh0YWxraWVzXHUyMDE5IGFzIHNvdW5kIHdhcyBhZGRlZCB0byB0aGUgcGxhdGZvcm0uIFRoZSBleHBlcmllbmNlIG9mIG1ha2luZyBhbmQgd2F0Y2hpbmcgZmlsbXMgZGVwZW5kcyBvbiB0aGVzZSBpbnRlcmFjdGlvbnMsIGFuZCBjb3VsZCBpbiB0dXJuIGJlIHVzZWQgdG8gZHJpdmUgY2hhbmdlcyBpbiBlaXRoZXIgcGxhdGZvcm0gb3IgY29udGVudC5cIjwvYmxvY2txdW90ZT5cclxuRGF2aWQgYW5kIGhpcyB0ZWFtIGFyZSBjdXJyZW50bHkgYXBwbHlpbmcgdGhpcyBwcmluY2lwbGUgaW4gYSBuZXcgcHJvamVjdCB0byBkZWZpbmUgPGEgaHJlZj1cImh0dHBzOi8vd3d3LnN1cnJleS5hYy51ay9kaWdpdGFsLXdvcmxkLXJlc2VhcmNoLWNlbnRyZS9mdW5kZWQtcHJvamVjdHMvbmV4dC1nZW5lcmF0aW9uLXBhcGVyLWNvbm5lY3RpbmctcGFwZXItd2ViXCI+PGVtPk5leHQgR2VuZXJhdGlvbiBQYXBlcjwvZW0+PC9hPi4gVGhleSBhcmUgY29uZHVjdGluZyBzdHVkaWVzIG9mIG9wdGljYWwgYW5kIHByaW50ZWQgZWxlY3Ryb25pYyB0ZWNobm9sb2d5IGZvciBhdWdtZW50aW5nIGJvb2tzIGFsb25nc2lkZSB0aGUgbWFraW5nIG9mIG5ldyBhdWdtZW50ZWQgYm9vayBjb250ZW50IGZvciB0cmF2ZWwgYW5kIHRvdXJpc20uXHJcbjxoMz5SZXNlYXJjaCB3aXRoIGNvbmNyZXRlIHJlc3VsdHM8L2gzPlxyXG5UaGUgcHJvamVjdHMgYXJlIHVzdWFsbHkgcmVzZWFyY2ggcmF0aGVyIHRoYW4gZGV2ZWxvcG1lbnQgcHJvamVjdHMsIHdoaWNoIHJlc3VsdHMgaW4gdGVjaG5vbG9naWNhbCBpbnRlcnZlbnRpb25zIHRoYXQgcmV2ZWFsIG5ldyBpbnNpZ2h0cyBhYm91dCBob3cgcGVvcGxlIGRvIHRoaW5ncyB3aXRoIG1lZGlhIC0gc3VjaCBhcyBjb21tdW5pY2F0ZSwga2VlcCBpbiB0b3VjaCwgc2hhcmUsIHJlbWVtYmVyLCB1bmRlcnN0YW5kLlxyXG5cclxuSG93ZXZlciwgRGlnaXRhbCBXb3JsZCBpcyBhbHNvIGludGVyZXN0ZWQgaW4gdGhlIGJ1c2luZXNzIHNpZGUgb2YgbWVkaWEgYXMgd2VsbCwgYmVjYXVzZSBidXNpbmVzcyBmYWN0b3JzIHNoYXBlIGlubm92YXRpb24ganVzdCBhcyBtdWNoIG9yIG1heWJlIGV2ZW4gbW9yZSB0aGFuIHRlY2hub2xvZ3kgZG9lczpcclxuPGJsb2NrcXVvdGU+XHUyMDFjTm90IGhhdmluZyBhIGJ1c2luZXNzIG1vZGVsIHRoYXQgd29ya3MgaXMgb2Z0ZW4gYSBiYXJyaWVyIHRvIHRoZSBhcHBsaWNhdGlvbiBvZiBuZXcgbWVkaWEgaW5ub3ZhdGlvbnMgaW4gdGhlIHJlYWwgd29ybGQuIFJlc2VhcmNoIHByb2plY3RzIGNhbiBjb21lIHVwIHdpdGggYSBncmVhdCBwcm90b3R5cGUgd2hpY2ggbWVldHMgYW4gdW5tZXQgdXNlciBuZWVkLCBidXQgdGhpcyB3aWxsIGp1c3QgZGllIHVubGVzcyBhIGNvbXBhbnkgaXMgYWJsZSB0byBkZXZlbG9wIGFuZCBzZWxsIGl0IGF0IGEgcHJvZml0Llx1MjAxZDwvYmxvY2txdW90ZT5cclxuU3BlY2lmaWNhbGx5LCBpbiB0aGUgTmV4dCBHZW5lcmF0aW9uIFBhcGVyIHByb2plY3QsIHRoZSBidXNpbmVzcyBzY2hvb2wgaXMgYWxzbyBpbnZvbHZlZDpcclxuPGJsb2NrcXVvdGU+XHUyMDFjSVx1MjAxOW0gdmVyeSBwbGVhc2VkIGFib3V0IHRoYXQsIGJlY2F1c2UgaXQgbWVhbnMgd2Ugd2lsbCBiZSBhYmxlIHRvIHVuZGVyc3RhbmQgdGhlIG1hcmtldHMgZm9yIHRoaXMgdGVjaG5vbG9neSBhbmQgdXNlIHRoYXQgdW5kZXJzdGFuZGluZyB0byBzaGFwZSB0aGUgdGVjaG5vbG9neSBpdHNlbGYuXHUyMDFkPC9ibG9ja3F1b3RlPlxyXG48aDM+QnVzaW5lc3Mgc2hhcGluZyBpbm5vdmF0aW9uPC9oMz5cclxuSGUgYmVsaWV2ZXMgdGhlIGJlc3QgcHJvamVjdHMgYXJlIHRob3NlIHRoYXQgZW5hYmxlIG5ldyBtZWRpYSBiZWhhdmlvdXIgdGhhdCBwZW9wbGUgZW5qb3kgYW5kIGJlbmVmaXQgZnJvbSBpbiBzb21lIHdheS4gQW5kIHRoYXQgY29tcGFuaWVzIGxhdGVyIGluY29ycG9yYXRlIGludG8gdGhlaXIgcHJvZHVjdHMgYW5kIHNlcnZpY2VzOlxyXG48YmxvY2txdW90ZT5cdTIwMWNXZSB0aGVyZWZvcmUgdGVuZCB0byBjb25jZWl2ZSBhbmQgY29uZHVjdCBwcm9qZWN0cyBub3dhZGF5cyB3aXRoIGluZHVzdHJpYWwgYW5kIHRoaXJkIHNlY3RvciBwYXJ0bmVycyB3aG8gY2FuIG1ha2UgdXNlIG9mIHRoZSBpbnNpZ2h0cyBvZiByZXNlYXJjaCBpbiB0aGVpciBidXNpbmVzcyBhY3Rpdml0aWVzLlx1MjAxZDwvYmxvY2txdW90ZT5cclxuVGhlIERXUkMgaGFzIHJlY2VpdmVkIGluZHVzdHJpYWwgZnVuZGluZyBmcm9tIGNvbXBhbmllcyBzdWNoIGFzIFZvZGFmb25lLCBNaWNyb3NvZnQsIEtvZGFrLCBCcml0aXNoIFRlbGVjb20sIE9yYW5nZSwgSGV3bGV0dCBQYWNrYXJkIGFuZCBGdWppdHN1LCBhcyB3ZWxsIGFzIGZyb20gc21hbGxlciBjcmVhdGl2ZSBpbmR1c3RyeSBhbmQgdGhpcmQgc2VjdG9yIG9yZ2FuaXNhdGlvbnMuXHJcblxyXG5DT05UQUNUIFBPSU5UXHJcbjxpbWcgY2xhc3M9XCJhbGlnbm5vbmUgc2l6ZS1mdWxsIHdwLWltYWdlLTExMzU3XCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTcvMTIvZGF2aWRfZnJvaGxpY2guY29udGFjdF8wLmpwZ1wiIGFsdD1cIlwiIHdpZHRoPVwiMTUwXCIgaGVpZ2h0PVwiMjAwXCIgLz5cclxuRGF2aWQgRnJvaGxpY2gsIERpcmVjdG9yLCBEaWdpdGFsIFdvcmxkIFJlc2VhcmNoIENlbnRyZVxyXG5XZWI6IDxhIGhyZWY9XCJodHRwczovL3d3dy5zdXJyZXkuYWMudWsvZGlnaXRhbC13b3JsZC1yZXNlYXJjaC1jZW50cmUvcGVvcGxlXCI+aHR0cHM6Ly93d3cuc3VycmV5LmFjLnVrLzwvYT5cclxuVHdpdHRlcjogPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vZGF2aWRmcm9obGljaD9sYW5nPWVuXCI+QGRhdmlkZnJvaGxpY2g8L2E+Wy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjIvM1wiXVt2Y19jb2x1bW5fdGV4dF1cclxuPGgzPkF1dGhvcjwvaDM+XHJcbltzaW1wbGUtYXV0aG9yLWJveF1bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd10iLCJwb3N0X3RpdGxlIjoiRGlnaXRhbCBXb3JsZCBSZXNlYXJjaCBDZW50cmU6IGV4cGxvcmluZyB0aGUgaW50ZXJwbGF5IGJldHdlZW4gbWVkaWEgY29udGVudCwgcGxhdGZvcm0gYW5kIGV4cGVyaWVuY2UiLCJwb3N0X2xpbmsiOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvZGlnaXRhbC13b3JsZC1yZXNlYXJjaC1jZW50cmUvIiwicG9zdF9mZWF0dXJlZF9pbWFnZSI6IjxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiRGlnaXRhbCBXb3JsZCBSZXNlYXJjaCBDZW50cmU6IGV4cGxvcmluZyB0aGUgaW50ZXJwbGF5IGJldHdlZW4gbWVkaWEgY29udGVudCwgcGxhdGZvcm0gYW5kIGV4cGVyaWVuY2VcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjIyNVwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE3LzEyL3VubmFtZWQtMzAweDIyNS5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj4iLCJwb3N0X2NhdGVnb3JpZXMiOiJJbm5vdmF0aW9uIENhc2UsIE1lZGlhIGxhYnMiLCJwb3N0X3RhZ3MiOiJhY2FkZW1pYyBMYWIsIGRlc2lnbiByZXNlYXJjaCwgbXVsdGlkaXNjaXBsaW5hcnksIFVLIiwiJV92Y19wb3N0X3NldHRpbmdzJSI6eyJ2Y19ncmlkX2lkIjpbXX0sIiVfZWRpdF9sb2NrJSI6IjE1MjY5OTk5OTQ6MTAxIiwiJV9lZGl0X2xhc3QlIjoiMTAxIiwiJXNsaWRlX3RlbXBsYXRlJSI6ImRlZmF1bHQiLCIlX3dwYl92Y19qc19zdGF0dXMlIjoidHJ1ZSIsIiVfa2xlb190cmFuc3BhcmVudF9tZW51X2NvbG9yJSI6IndoaXRlIiwiJV9rbGVvX3RpdGxlX2NvbG9yJSI6IiMiLCIlX2tsZW9fdGl0bGVfYmclIjoiLCByZXBlYXQsIGluaGVyaXQsIHNjcm9sbCwgbGVmdCB0b3AiLCIlX2tsZW9fdGl0bGVfYmdfY29sb3IlIjoiIyIsIiVfeW9hc3Rfd3BzZW9fY29udGVudF9zY29yZSUiOiIzMCIsIiVfeW9hc3Rfd3BzZW9fcHJpbWFyeV9jYXRlZ29yeSUiOiIxNDIiLCIlX3RodW1ibmFpbF9pZCUiOiIxMTM1NCIsIiVfa2xlb190aXRsZV9jaGVja2JveCUiOiIxIiwiJV95b2FzdF93cHNlb19mb2N1c2t3X3RleHRfaW5wdXQlIjoiRFdSQyIsIiVfeW9hc3Rfd3BzZW9fZm9jdXNrdyUiOiJEV1JDIiwiJV95b2FzdF93cHNlb19tZXRhZGVzYyUiOiJEV1JDIGJyaW5ncyB0b2dldGhlciBlbmdpbmVlcmluZywgY29tbXVuaWNhdGlvbiwgc29jaWFsIHNjaWVuY2UsIGJ1c2luZXNzLCBkZXNpZ24gYW5kIGFydHMgdG8gd29yayBvbiBtZWRpYSBpbm5vdmF0aW9uIHByb2plY3RzIHRoYXQgaGF2ZSBhIGNvbmNyZXRlIGltcGFjdCBvbiBzb2NpZXR5IGFuZCBjdWx0dXJlLiIsIiVfeW9hc3Rfd3BzZW9fbGlua2RleCUiOiI3MyIsIiVfd3BnbXBfbG9jYXRpb25fYWRkcmVzcyUiOiIzODggU3RhZyBIaWxsLCBHdWlsZGZvcmQgR1UyIDdYSCwgVW5pdGVkIEtpbmdkb20iLCIlX3dwZ21wX21ldGFib3hfbGF0aXR1ZGUlIjoiNTEuMjQyNTcxODk5OTk5OTkiLCIlX3dwZ21wX21ldGFib3hfbG9uZ2l0dWRlJSI6Ii0wLjU4Nzk0NTkwMDAwMDAyMjQiLCIlX3dwZ21wX21ldGFib3hfbG9jYXRpb25fcmVkaXJlY3QlIjoicG9zdCIsIiVfd3BnbXBfbWV0YWJveF9jdXN0b21fbGluayUiOiIiLCIlX3dwZ21wX21hcF9pZCUiOiJhOjE6e2k6MDtzOjE6XCIyXCI7fSIsIiVfd3BnbXBfbWV0YWJveF9tYXJrZXJfaWQlIjoiTjsiLCIlX3dwZ21wX21ldGFib3hfdGF4b21vbWllc190ZXJtcyUiOiJOOyIsIiVfd3BnbXBfZXh0ZW5zaW9uc19maWVsZHMlIjoiTjsiLCIlX2pldHBhY2tfcmVsYXRlZF9wb3N0c19jYWNoZSUiOnsiNjIzOTNiMjQyYzdhNTYxNzc0ZjhlYmZmNWMxYzA1NjUiOnsiZXhwaXJlcyI6MTU0NDk2NjkxNiwicGF5bG9hZCI6W3siaWQiOjEwNzc2fSx7ImlkIjoxMDEzMH0seyJpZCI6MTEzNjJ9XX19LCIlc2JnX3NlbGVjdGVkX3NpZGViYXIlIjoiMCIsIiVzYmdfc2VsZWN0ZWRfc2lkZWJhcl9yZXBsYWNlbWVudCUiOiIwIiwidGF4b25vbXk9Y2F0ZWdvcnkiOiJJbm5vdmF0aW9uIENhc2UsIE1lZGlhIGxhYnMiLCJ0YXhvbm9teT1wb3N0X3RhZyI6ImFjYWRlbWljIExhYiwgZGVzaWduIHJlc2VhcmNoLCBtdWx0aWRpc2NpcGxpbmFyeSwgVUsifSwiaWNvbiI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE4LzAyL21hcmtlci0xLnBuZyJ9LCJpZCI6MTEzNTIsImluZm93aW5kb3dfZGlzYWJsZSI6ZmFsc2V9LHsic291cmNlIjoicG9zdCIsInRpdGxlIjoiTGFiIDM1MTogaW5ub3ZhdGlvbi1pbi1hLWJveCBhcHByb2FjaCBhbGxvd3MgYW55b25lIGluIHRoZSBjb21wYW55IHRvIGRldmVsb3AgdGhlaXIgaWRlYXMgYW5kIGVudHJlcHJlbmV1cmlhbCBza2lsbHMiLCJpbmZvd2luZG93X2NvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIkxhYiAzNTE6IGlubm92YXRpb24taW4tYS1ib3ggYXBwcm9hY2ggYWxsb3dzIGFueW9uZSBpbiB0aGUgY29tcGFueSB0byBkZXZlbG9wIHRoZWlyIGlkZWFzIGFuZCBlbnRyZXByZW5ldXJpYWwgc2tpbGxzXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIxNjVcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxNy8xMC9pbWFnZTAwMS1lMTUwOTAwODU5Njg4Ni0zMDB4MTY1LnBuZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmdcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXBhZGRpbmctY29udGVudF8yMFwiPlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLW1ldGEgZmMtaXRlbS1zZWNvbmRhcnktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZSBmYy10ZXh0LWNlbnRlclwiPklubm92YXRpb24gQ2FzZSwgTWVkaWEgbGFiczwvZGl2PlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLXRleHQtY2VudGVyXCI+TGFiIDM1MTogaW5ub3ZhdGlvbi1pbi1hLWJveCBhcHByb2FjaCBhbGxvd3MgYW55b25lIGluIHRoZSBjb21wYW55IHRvIGRldmVsb3AgdGhlaXIgaWRlYXMgYW5kIGVudHJlcHJlbmV1cmlhbCBza2lsbHM8L2Rpdj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1jb250ZW50IGZjLWl0ZW0tYm9keS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+XHJcbiAgICAgICAgICAgIFRoZSBHbG9iZSBhbmQgTWFpbCBlbmNvdXJhZ2VzIGFsbCBlbXBsb3llZXMgaW4gdGhlIGNvbXBhbnkgdG8gcGl0Y2ggYXMgbWFueSBpbm5vdmF0aXZlIGlkZWFzIGFzIHRoZXkgY2FuIGV2ZW4gaWYgdGhleSBhcmUgYXQgdGhlIGJhY2sgb2YgbmFwa2luIHN0YWdlLlxyXG4gICAgICAgIDwvZGl2PlxyXG48YSBocmVmPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL2xhYi0zNTEtaW5ub3ZhdGlvbi1ib3gtYXBwcm9hY2gtYWxsb3dzLWFueW9uZS1jb21wYW55LWRldmVsb3AtaWRlYXMtZW50cmVwcmVuZXVyaWFsLXNraWxscy9cIj5SZWFkIG1vcmU8L2E+XHJcbiAgICA8L2Rpdj5cclxuICAgIDwvZGl2PlxyXG48L2Rpdj5cclxuXHJcbiIsImNvbnRlbnQiOiJUaGUgR2xvYmUgYW5kIE1haWwgZW5jb3VyYWdlcyBhbGwgZW1wbG95ZWVzIGluIHRoZSBjb21wYW55IHRvIHBpdGNoIGFzIG1hbnkgaW5ub3ZhdGl2ZSBpZGVhcyBhcyB0aGV5IGNhbiBldmVuIGlmIHRoZXkgYXJlIGF0IHRoZSBiYWNrIG9mIG5hcGtpbiBzdGFnZS4iLCJhZGRyZXNzIjoiVG9yb250bywgT04sIENhbmFkYSIsImxvY2F0aW9uIjp7ImxhdCI6IjQzLjY1MzIyNiIsImxuZyI6Ii03OS4zODMxODQyOTk5OTk5OCIsIm9uY2xpY2tfYWN0aW9uIjoicG9zdCIsInJlZGlyZWN0X3Blcm1hbGluayI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9sYWItMzUxLWlubm92YXRpb24tYm94LWFwcHJvYWNoLWFsbG93cy1hbnlvbmUtY29tcGFueS1kZXZlbG9wLWlkZWFzLWVudHJlcHJlbmV1cmlhbC1za2lsbHMvIiwiem9vbSI6MiwiZXh0cmFfZmllbGRzIjp7InBvc3RfZXhjZXJwdCI6IlRoZSBHbG9iZSBhbmQgTWFpbCBlbmNvdXJhZ2VzIGFsbCBlbXBsb3llZXMgaW4gdGhlIGNvbXBhbnkgdG8gcGl0Y2ggYXMgbWFueSBpbm5vdmF0aXZlIGlkZWFzIGFzIHRoZXkgY2FuIGV2ZW4gaWYgdGhleSBhcmUgYXQgdGhlIGJhY2sgb2YgbmFwa2luIHN0YWdlLiIsInBvc3RfY29udGVudCI6Ilt2Y19yb3ddW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIyLzNcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxoMT5MYWIgMzUxOiBpbm5vdmF0aW9uLWluLWEtYm94IGFwcHJvYWNoIGFsbG93cyBhbnlvbmUgaW4gdGhlIGNvbXBhbnkgdG8gZGV2ZWxvcCB0aGVpciBpZGVhcyBhbmQgZW50cmVwcmVuZXVyaWFsIHNraWxsczwvaDE+XHJcbjxzdHJvbmc+VGhlIEdsb2JlIGFuZCBNYWlsIGVuY291cmFnZXMgYWxsIGVtcGxveWVlcyBpbiB0aGUgY29tcGFueSB0byBwaXRjaCBhcyBtYW55IGlubm92YXRpdmUgaWRlYXMgYXMgdGhleSBjYW4gZXZlbiBpZiB0aGV5IGFyZSBhdCB0aGUgYmFjayBvZiBuYXBraW4gc3RhZ2UuPC9zdHJvbmc+XHJcblxyXG5TZWxlY3RlZCBpbmRpdmlkdWFscyB0aGVuIGdldCAyIGRheXMgb2YgYWNjZWxlcmF0ZWQgaW5ub3ZhdGlvbiB0cmFpbmluZyBhbmQgJDEwMDAgdG8gdmFsaWRhdGUgc29tZSBvZiB0aGVpciBpZGVhcywgd2l0aG91dCBrbm93aW5nIHdoaWNoIGlkZWEgZ290IHRoZW0gZ290IHRoZW0gaW50byB0aGUgbGFiLiBGcm9tIHRoZXJlLCB0aGUgTGFiIGxvb2tzIHRvIGJ1aWxkIHRlYW1zIG9uIHRvcCBvZiB0aG9zZSBmaW5kaW5ncywgZnJlZWluZyB1cCBzbWFsbCBncm91cHMgZnJvbSB0aGVpciBkYWlseSB3b3JrIGFuZCBmdW5kaW5nIHRoZW0gZm9yIHVwIHRvIDkwIGRheXMgc28gdGhhdCB0aGV5IGNhbiBzaG93IHRoZSBjb21wYW55IHdoYXQgbmVlZHMgdG8gYmUgZG9uZS5cclxuXHJcblRoZSBHbG9iZSBhbmQgTWFpbCBpbiBDYW5hZGEgaGFzIGJlZW4gaW4gcHJpbnQgZm9yIDE3MiB5ZWFycy4gQXMgdGhlIGJpZ2dlc3QgbmV3c3BhcGVyIGluIHRoZSBjb3VudHJ5LCBpdCBhdHRyYWN0cyBhIHNpeC1kYXkgcmVhZGVyc2hpcCB0b3RhbCBvZiBvdmVyIDMuNSBtaWxsaW9uLCBtYWtpbmcgaXQgdGhlIGJlc3QtcmVhZCBuZXdzcGFwZXIgYWNyb3NzIENhbmFkYS5cclxuXHJcbkxhYjM1MSBpcyBwYXJ0IG9mIEdsb2JlIExhYnMsIHRoZSBHbG9iZSBhbmQgTWFpbFx1MjAxOXMgaW5ub3ZhdGlvbiBodWIgd2hlcmUgZGF0YSBzY2llbmNlLCBVWCwgcHJvdG90eXBpbmcsIHVzZXIgdGVzdGluZyBhbmQgaWRlYXRpb24gaGFwcGVuLiBMYWIzNTEgaXMgbm90IHN0YWZmZWQgYnkgYSBkZWRpY2F0ZWQgdGVhbS4gSW5zdGVhZCwgR29yZG9uIEVkYWxsIChEaXJlY3RvciBHbG9iZSBMYWJzKSB0cmllcyB0byBlbmNvdXJhZ2UgYWxsIGVtcGxveWVlcyB0byBwaXRjaCB0aGVpciBpZGVhcy4gVGhlcmVcdTIwMTlzIGFuIGluZGl2aWR1YWwgdHJhY2sgYW5kIGEgdHJhY2sgZm9yIHNtYWxsIHRlYW1zIHRvIHRhcCBpbnRvIHRoZSByZXNvdXJjZXMgdGhleSBuZWVkIHRvIGRldmVsb3AgdGhlaXIgaWRlYXMgYW5kIHR1cm4gdGhlbSBpbnRvIHByb2plY3RzIHRoYXQgbWFrZSBhIGRpZmZlcmVuY2UuIExhdW5jaGVkIGluIEp1bmUgMjAxNSwgdGhlIGxhYiB3YXMgaW5zcGlyZWQgYnkgdGhlIENvbW11bml0ZWNoIGxhYiBhdCB0aGUgVW5pdmVyc2l0eSBvZiBXYXRlcmxvby5cclxuXHJcblRoZSBHbG9iZSBhbmQgTWFpbCByZWNlbnRseSBtb3ZlZCBpbnRvIGEgbmV3IGJ1aWxkaW5nIHdoZXJlIHRoZSBsYWIgaGFzIGEgZGVkaWNhdGVkIHNwYWNlLiBBbHRob3VnaCB0aGUgaW5pdGlhbCBpZGVhIHdhcyB0byBleHRlbmQgdGhlIGxhYiB0byBleHRlcm5hbCBpbm5vdmF0aW9uIGluIHRoZSBmb3JtIG9mIHN0YXJ0LXVwIGFjY2VsZXJhdGlvbiwgdGhleSBoYXZlIGRlY2lkZWQgdG8gc3RpY2sgd2l0aCBpbnRlcm5hbCBpbm5vdmF0aW9uIGZvciB0aGUgbW9tZW50OlxyXG48YmxvY2txdW90ZT5cdTIwMWNXZSBoYXZlblx1MjAxOXQgZWxpbWluYXRlZCBpdCBhcyBhbiBpZGVhIHRoYXQgaXMgd29ydGggY29uc2lkZXJpbmcgb24gYSByZWd1bGFyIGJhc2lzIGFuZCBJIGhhdmUgY29udmVyc2F0aW9ucyBhYm91dCB3aGF0IHRoYXQgd291bGQgc3RpbGwgbG9vayBsaWtlLFwiIHNheXMgR29yZG9uIEVkYWxsLCBcImJ1dCBleHRlcm5hbCBpbm5vdmF0aW9uIHdvdWxkIGhhdmUgYmVlbiBhIG11Y2ggYmlnZ2VyIGludmVzdG1lbnQgYW5kIGl0IHdvdWxkIGhhdmUgYmVlbiBhIG11Y2ggbW9yZSByaXNreSBlbmRlYXZvdXIuXHUyMDFkPC9ibG9ja3F1b3RlPlxyXG48aDM+RXhjaXRlbWVudCBhY3Jvc3MgdGhlIGNvbXBhbnk8L2gzPlxyXG5HbG9iZSBsYWJzIGhvd2V2ZXIgaGFzIGV2b2x2ZWQgaXRzIGFwcHJvYWNoIHRvIGludGVybmFsIGlubm92YXRpb24uIEJlZm9yZSwgdGhlcmUgd2FzIGEgdGVhbS1vbmx5IGFwcHJvYWNoIGFuZCB0aGUgc2l6ZSBvZiB0aGUgdGVhbXMgd2FzIHRvbyBzbWFsbCB0byByZWFsbHkgbWFrZSBhIGRpZmZlcmVuY2UgaW4gdGVybXMgb2YgY29ycG9yYXRlIGN1bHR1cmUgYW5kIHRoZSBiYXIgdG8gZ2V0IGludG8gb25lIG9mIHRoZSB0ZWFtcyB3YXMgdmVyeSBoaWdoLiBBcyBvbmUgb2YgdGhlIGdvYWxzIGlzIHRvIGhlbHAgY2hhbmdlIHRoZSBjdWx0dXJlIGluIHRoZSBvcmdhbmlzYXRpb24sIHRoZXkgc3VwcGxlbWVudGVkIHRoaXMgdGVhbS1iYXNlZCBhcHByb2FjaCB3aXRoIGEgdHJhaW5pbmcgcHJvZ3JhbW1lIHRvIGVuY291cmFnZSBpbmRpdmlkdWFscyB3aXRoaW4gdGhlIGNvbXBhbnkgdG8gZ2VuZXJhdGUgaWRlYXMuXHJcblxyXG5BbiBhZHZpc29yeSBjb21taXR0ZWUgc2VsZWN0cyB0aGUgaW5pdGlhbCBpZGVhcyB0byBmaW5kIHRoZSBwZW9wbGUgZm9yIHRoZSBpbnRlbnNpdmUgaW5kaXZpZHVhbCB0cmFpbmluZy4gVXNpbmcgbGVzc29ucyBhbmQgbWV0aG9kb2xvZ2llcyBmcm9tIHRoZSBvcGVuLXNvdXJjZSBBZG9iZSBLaWNrYm94IGlubm92YXRpb24gcHJvZ3JhbSwgc2VsZWN0ZWQgaW5kaXZpZHVhbHMgZ2V0IGEgYm94IHdpdGggYSBzZXQgb2YgaW5ub3ZhdGlvbiBndWlkZWxpbmVzIGFsb25nIHdpdGggc29tZSBoYW5kcy1vbiB0cmFpbmluZyBhbmQgYSBwcmUtcGFpZCBjcmVkaXQgY2FyZCBsb2FkZWQgd2l0aCAkMTAwMCB0byBiZSBzcGVudCBhcyB0aGV5IHNlZSBmaXQgdG8gdmFsaWRhdGUgdGhlaXIgaWRlYTpcclxuPGJsb2NrcXVvdGU+XHUyMDFjWW91IGRvblx1MjAxOXQgZXZlciBoYXZlIHRvIGdlbmVyYXRlIGFueSBpbnZvaWNlcy4gWW91IGRvblx1MjAxOXQgZXZlciBoYXZlIHRvIGp1c3RpZnkgd2hhdCB5b3Ugc3BlbmQgdGhhdCBtb25leSBvbi4gVGhlIG1vbmV5IGlzIHRoZXJlIGZvciB5b3UgYW5kIGlzIGdpdmVuIHRvIHlvdSBpbiBnb29kIGZhaXRoIHNvIHRoYXQgeW91IGNhbiBzaG93IHVzIHdoYXQgeW91IHRoaW5rIG5lZWRzIGRvbmVcdTIwMWQsIGV4cGxhaW5zIEdvcmRvbiBFZGFsbC4gXHUyMDFjSWYgd2UgZ2l2ZSB5b3UgYSB2ZXJ5IHNtYWxsIGFtb3VudCBvZiBtb25leSBhbmQgdGVhY2ggeW91IGhvdyB0byB1c2UgaXQsIHRvIHNob3cgdXMgaG93IHRvIGRvIHNvbWV0aGluZyBpbnRlcmVzdGluZyBhbmQgbmV3LCB3ZSBiZWxpZXZlIHlvdSB3aWxsIGRvIHRoYXQsIG9uIHlvdXIgb3duLlx1MjAxZDwvYmxvY2txdW90ZT5cclxuVGhlIGV4Y2l0ZW1lbnQgdGhpcyBnZW5lcmF0ZXMgaW4gcGVvcGxlIGlzIGluZmVjdGlvdXMgYW5kIHNwcmVhZHMgdG8gb3RoZXJzIGluIHRoZSBjb21wYW55LCBzYXlzIEVkYWxsLiBBcyBpbmRpdmlkdWFscyBubyBsb25nZXIgZGlzYXBwZWFyIGZvciA5MCBkYXlzIHRoZSB3YXkgdGhleSBkaWQgd2hlbiBMYWIzNTEgd2FzIGZpcnN0IGNyZWF0ZWQsIHRoZXkgY2FuIHNoYXJlIHRoaXMgZXhjaXRlbWVudCB3aXRoIHRoZWlyIGNvbGxlYWd1ZXMgd2hpbGUgaXQgaXMgc3RpbGwgZnJlc2ggaW4gdGhlaXIgbWluZC5cclxuPGgzPkNhcHBlZCByaXNrPC9oMz5cclxuRm9yIGlkZWFzIGFuZCB2ZW50dXJlcyB0aGF0IHJlcXVpcmUgbW9yZSB0aW1lIGFuZCBtb25leSBidXQgc3RpbGwgcmVwcmVzZW50IGFuIGV4cGVyaW1lbnRhbCBpZGVhLCBUaGUgR2xvYmUgYW5kIE1haWwgY29udGludWVzIHRvIHJ1biBhIGNvbXBldGl0aXZlIHRlYW0tYmFzZWQgcHJvZ3JhbS4gV2lubmluZyB0ZWFtcyBnZXQgOTAgZGF5cywgd2l0aCB0ZWFtIG1lbWJlcnMgZnJlZWQgZnJvbSB0aGUgZGlzdHJhY3Rpb25zIG9mIHRoZWlyIGRheSBqb2JzLCB0byBidWlsZCBhIHByb3RvdHlwZSBvciBjcmVhdGUgYSBidXNpbmVzcyBvcHBvcnR1bml0eS5cclxuXHJcbkZ1bmRpbmcgZm9yIGVhY2ggdGVhbSBpcyBwcm92aWRlZCB1cCB0byBhICQxMDAsMDAwIHRocmVzaG9sZCBhbmQgdGhlIHRpbWUgcmVzdHJpY3Rpb25zIGFyZSB2ZXJ5IHJlYWwgXHUyMDEzIGVhY2ggdGVhbSB1bmRlcnN0YW5kcyB0aGF0IExhYjM1MSBpcyBhbiBleGVyY2lzZSBpbiBjb25zdHJhaW50IGJhc2VkIGlubm92YXRpb24gYW5kIHRoaXMgYWxsb3dzIHRoZSBsYWIgdG8gY2FwIHRoZSByaXNrIGFyb3VuZCB0aGUgaW5ub3ZhdGlvbiBwcm9jZXNzLlxyXG5cclxuQXQgdGhlIGVuZCBvZiB0aGUgOTAtZGF5IHBlcmlvZCwgdGhlIHRlYW1zIGtub3cgdGhleSB3aWxsIGZhY2UgYW5vdGhlciB0ZXN0OiBcdTIwMWNPbmNlIHRob3NlIDkwIGRheXMgYXJlIHVwLCB5b3UgbmVlZCB5b3VyIFx1MjAxOHN0YXJ0LXVwXHUyMDE5IHRvIGJlIGJvdWdodCBieSBhbiBleGlzdGluZyBsaW5lIG9mIGJ1c2luZXNzIGhlcmUgb3IgZmluZCBhZGRpdGlvbmFsIGZ1bmRpbmcgb3V0c2lkZSB0aGUgbGFiLFx1MjAxZCBzYXlzIEVkYWxsLlxyXG48aDM+UmVjb2duaXNpbmcgYSBnb29kIGlkZWE8L2gzPlxyXG5Bbnlib2R5IGluIHRoZSBjb21wYW55LCBhY3Jvc3MgYW55IGRlcGFydG1lbnQsIGNhbiBwaXRjaCBhbiBpZGVhLiBJZGVhcyB0byBkYXRlIGhhdmUgcmFuZ2VkIGZyb20gbmV3IGRhdGEgc2NpZW5jZSBjYXBhYmlsaXRpZXMgdG8gVlIgYW5kIG90aGVyIGVkaXRvcmlhbCBwcm9qZWN0cy4gQW4gaW1wb3J0YW50IHBhcnQgb2YgdGhlIHByb2Nlc3MgaXMgdG8gbGVhcm4gaG93IHRvIHJlY29nbmlzZSBhIGdvb2QgaWRlYTpcclxuPGJsb2NrcXVvdGU+XHUyMDFjT25lIG9mIHRoZSB0aGluZ3MgcGVvcGxlIHJlYWxseSBzdHJ1Z2dsZSB3aXRoIGluIHRoZSBsYWIgaXMgdGhhdCB3ZSBkb25cdTIwMTl0IHRlbGwgdGhlbSB3aGljaCBpZGVhIGdvdCB0aGVtIHNlbGVjdGVkLiBXaGVuIHlvdVx1MjAxOXJlIHBpdGNoaW5nIHRvIHRoZSBsYWIsIGFueW9uZSBjYW4gcGl0Y2ggYW5kIHlvdSBjYW4gcGl0Y2ggYXMgbWFueSBpZGVhcyBhcyB5b3Ugd2FudC4gV2UgZXZhbHVhdGUgYWxsIG9mIHRoZSBpZGVhcyBhbm9ueW1vdXNseSBhbmQgd2UganVzdCBwaWNrIGlkZWFzIGFuZCB3ZSBwaWNrIGlkZWFzIHVudGlsIHdlIGhhdmUgZW5vdWdoIHBlb3BsZSBmb3IgdGhlIGNsYXNzLiBXaGVuIHlvdSBnZXQgaW50byB0aGUgdHJhaW5pbmcgdGhvdWdoIHdlIHJlZnVzZSB0byB0ZWxsIHlvdSB3aGF0IHRoZSBpZGVhIHdhcyB0aGF0IGdvdCB5b3Ugc2VsZWN0ZWQgYmVjYXVzZSB0aGUgdHJhaW5pbmcgaXMgcmVhbGx5IGFib3V0IGJlaW5nIGFibGUgdG8gdGVsbCB0aGUgZGlmZmVyZW5jZSBiZXR3ZWVuIGEgZ29vZCBpZGVhIGFuZCBhIGJhZCBpZGVhLlx1MjAxZDwvYmxvY2txdW90ZT5cclxuSG93ZXZlciwgdGhlIGJpZ2dlc3QgZGl2aWRlbmQgc28gZmFyIGlzIG5vdCBidXNpbmVzcyBwcm9jZXNzIGltcHJvdmVtZW50IG9yIHNtYXJ0ZXIgc3Rvcnl0ZWxsaW5nLCBidXQgYSBzaGlmdCBpbiB0aGUgbWluZC1zZXQgb2Ygc3RhZmY6IFx1MjAxY0l0XHUyMDE5cyBhYm91dCBoYXZpbmcgYmV0dGVyIGNvbnZlcnNhdGlvbnMgYWJvdXQgd2hldGhlciBvciBub3Qgd2Ugc2hvdWxkIGRvIHRoaW5ncyxcdTIwMWQgc2F5cyBFZGFsbC4gQW5vdGhlciBhdHRyYWN0aXZlIGNoYXJhY3RlcmlzdGljIG9mIHRoZSBBZG9iZSBLaWNrYm94IG1ldGhvZCBpcyB0aGF0IGl0IGdpdmVzIHBhcnRpY2lwYW50cyBhIHNoYXJlZCB2b2NhYnVsYXJ5IHRvIGFjdHVhbGx5IHRhbGsgYWJvdXQgaW5ub3ZhdGlvbiBpbiBhIG1vcmUgY29uc2lzdGVudCB3YXk6XHJcbjxibG9ja3F1b3RlPlx1MjAxY0ludHJvZHVjaW5nIHBlb3BsZSB0byBjb25jZXB0cyBsaWtlIHJhcGlkIHByb3RvdHlwaW5nIGFuZCBsb3cgZmlkZWxpdHkgdGVzdGluZyBcdTIwMTMgd2hhdCB3ZSBmaW5kIGlzIHRoYXQgd2hlbiB3ZSBwdXQgYSBmZXcgcGVvcGxlIHRocm91Z2ggdGhlIHRyYWluaW5nLCB0aGUgY29udmVyc2F0aW9ucyB0aGF0IHRoZXkgaGF2ZSBiZXR3ZWVuIHRoZW1zZWx2ZXMgYWJvdXQgYW4gaWRlYSBvciBhIHByb2plY3QgYXJlIGdlbmVyYWxseSBtdWNoIGJldHRlciB0aGFuIHRoZXkgd2VyZSBiZWZvcmUuXHUyMDFkPC9ibG9ja3F1b3RlPlxyXG48aDM+TG9va2luZyBmdXJ0aGVyIGFoZWFkPC9oMz5cclxuPGJsb2NrcXVvdGU+XHUyMDFjV2VcdTIwMTlyZSBzdGlsbCB0cnlpbmcgdG8gZmlndXJlIG91dCBob3cgZmFyIG91dCBvdXIgaG9yaXpvbiBjYW4gYmUuIFJpZ2h0IG5vdyB3ZVx1MjAxOXJlIHN0aWxsIHdvcmtpbmcgb24gY3JlYXRpbmcgdGhpbmdzIHRpZWQgdG8gbmVhcmVyIHRlcm0gaG9yaXpvbnMgYW5kIEkgaG9wZSBvdmVyIHRpbWUgd2VcdTIwMTlyZSBtYWtpbmcgbW9yZSBiZXRzIHRoYXQgY3Jvc3MgZGlmZmVyZW50IGFuZCB3aWRlciB0aW1lIGRpbWVuc2lvbnMuIEkgd2FudCB1cyB0byBiZSB3ZVx1MjAxOXJlIGxvb2tpbmcgYXQgbW9yZSB0aGluZ3MgdGhhdCBhcmUgMyB0byA1IHllYXJzIG91dCBhbmQgZmV3ZXIgdGhpbmdzIHRoYXQgYXJlIHNvcnQgb2YgcXVpY2sgd2lucy5cdTIwMWQ8L2Jsb2NrcXVvdGU+XHJcbkEgZ29vZCBleGFtcGxlIG9mIHRoZSB0eXBlcyBvZiBwcm9qZWN0cyBHb3Jkb24gRWRhbGwgaXMgYWltaW5nIGZvciBhcmUgU29waGkgYW5kIERlbHBoaS5cclxuXHJcblRoZSBHbG9iZSBhbmQgTWFpbCBoYXMgcmVjZW50bHkgcmVwbGFjZWQgaXRzIGVudGlyZSBhbmFseXRpY2FsIGluZnJhc3RydWN0dXJlIHdpdGggYSBzZXQgb2YgaG9tZS1idWlsdCB0b29scyBjYWxsZWQgU29waGkuIEl0XHUyMDE5cyBhIGRlY2lzaW9uIHN1cHBvcnQgYW5kIGJ1c2luZXNzIGludGVsbGlnZW5jZSB0b29sIHRoZSBuZXdzcm9vbSB1c2VzIGJvdGggZm9yIHRhY3RpY2FsIHB1cnBvc2VzLCBsaWtlIG1hbmFnaW5nIHRoZSB3ZWJzaXRlIGluIHJlYWwgdGltZSwgYW5kIHN0cmF0ZWdpYyBwdXJwb3NlcywgbGlrZSByZS1hbGxvY2F0aW5nIHJlc291cmNlcyB0byBhZGRyZXNzIHVubWV0IG5lZWRzIHRoYXQgdGhlIGFkdmFuY2VkIGFuYWx5dGljcyByZXZlYWwuXHJcblxyXG5EZWxwaGkgbWVhbndoaWxlIGlzIGEgcHJlZGljdGl2ZSBhbmFseXRpY2FsIHN0YWNrIHRoZXkgaGF2ZSBidWlsdCBvbiB0b3Agb2YgU29waGkgdGhhdCwgYW1vbmcgb3RoZXIgdGhpbmdzLCBwcmVkaWN0cyB0aGUgdmFsdWUgb2YgYSBzdG9yeSBiZWZvcmUgaXQgaXMgcHVibGlzaGVkLiBEb2luZyB0aGlzIGtpbmQgb2YgYW5hbHlzaXMgcHJpb3IgdG8gcHVibGljYXRpb24gY2FuIGhlbHAgZWRpdG9ycyBtYWtlIGJldHRlciBkZWNpc2lvbnMgYWJvdXQgd2hlcmUgdG8gcGxhY2UgYSBzdG9yeSBvciBtYWtlIGRlY2lzaW9ucyBhYm91dCBmdXR1cmUgc3RvcmllczpcclxuPGJsb2NrcXVvdGU+XHUyMDFjV2VcdTIwMTl2ZSBzaG93biBpdCB0byBhIGZldyBwZW9wbGUgaW4gdGhlIGluZHVzdHJ5IG5vdyBhbmQgdGhlIGZlZWRiYWNrIGhhcyBiZWVuIHByZXR0eSBkcmFtYXRpY2FsbHkgZ3JlYXQuIFBlb3BsZSBoYXZlIHJlYWxseSBsb3ZlZCB3aGF0IHdlXHUyMDE5cmUgYWJsZSB0byBkbyBhbmQgdGhlIGRlZ3JlZSB0byB3aGljaCB3ZVx1MjAxOXJlIHNvbHZpbmcgcmVhbCBwcm9ibGVtcyBpbiB0aGUgbmV3c3Jvb20gaW4gcmVhbCB0aW1lIG9uIGEgdGFjdGljYWwgYmFzaXMgYW5kIG9uIGEgaGlzdG9yaWNhbCBiYXNpcyBzb2x2aW5nIHNvbWUgcHJldHR5IGRpZmZpY3VsdCBpc3N1ZXMgYXJvdW5kIHdoZXJlIHRvIGZvY3VzIHlvdXIgZWZmb3J0IGFzIGEgbmV3c3Jvb20uXHUyMDFkPC9ibG9ja3F1b3RlPlxyXG5BIG1pZC10ZXJtIHByb2plY3Qgb2YgdGhlIGtpbmQgdGhlIExhYjM1MSBhc3BpcmVzIHRvIGRvIG1vcmUgb2YgaXMgY3JlYXRpbmcgZ2VuZXJpYyB2ZXJzaW9ucyBvZiBTb3BoaSBhbmQgRGVscGhpIGFuZCBvcGVuaW5nIGl0IHVwIHRvIG90aGVyIGNvbXBhbmllcywgYm90aCBpbnNpZGUgdGhlIG1lZGlhIGluZHVzdHJ5IG9yIGluIG90aGVyIG1hcmtldHMuXHJcblxyXG5DT05UQUNUIFBPSU5UXHJcblxyXG48aW1nIGNsYXNzPVwiYWxpZ25ub25lIHdwLWltYWdlLTExNTQzIHNpemUtbWVkaXVtXCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTgvMDMvR29yZG9uRWRhbGwxMi0yMzJ4MzAwLmpwZWdcIiBhbHQ9XCJcIiB3aWR0aD1cIjIzMlwiIGhlaWdodD1cIjMwMFwiIC8+XHJcblxyXG5Hb3Jkb24gRWRhbGwsIERpcmVjdG9yIEdsb2JlIExhYnMsIFRoZSBHbG9iZSBhbmQgTWFpbFxyXG5XZWI6IDxhIGhyZWY9XCJodHRwczovL3d3dy50aGVnbG9iZWFuZG1haWwuY29tXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5odHRwczovL3d3dy50aGVnbG9iZWFuZG1haWwuY29tPC9hPlxyXG5Ud2l0dGVyOiA8YSBocmVmPVwiaHR0cHM6Ly90d2l0dGVyLmNvbS9nb3Jkb25lZGFsbFwiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+QGdvcmRvbmVkYWxsPC9hPlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIyLzNcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxoMz5BdXRob3I8L2gzPlxyXG5bc2ltcGxlLWF1dGhvci1ib3hdWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddIiwicG9zdF90aXRsZSI6IkxhYiAzNTE6IGlubm92YXRpb24taW4tYS1ib3ggYXBwcm9hY2ggYWxsb3dzIGFueW9uZSBpbiB0aGUgY29tcGFueSB0byBkZXZlbG9wIHRoZWlyIGlkZWFzIGFuZCBlbnRyZXByZW5ldXJpYWwgc2tpbGxzIiwicG9zdF9saW5rIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL2xhYi0zNTEtaW5ub3ZhdGlvbi1ib3gtYXBwcm9hY2gtYWxsb3dzLWFueW9uZS1jb21wYW55LWRldmVsb3AtaWRlYXMtZW50cmVwcmVuZXVyaWFsLXNraWxscy8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJMYWIgMzUxOiBpbm5vdmF0aW9uLWluLWEtYm94IGFwcHJvYWNoIGFsbG93cyBhbnlvbmUgaW4gdGhlIGNvbXBhbnkgdG8gZGV2ZWxvcCB0aGVpciBpZGVhcyBhbmQgZW50cmVwcmVuZXVyaWFsIHNraWxsc1wiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMTY1XCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTcvMTAvaW1hZ2UwMDEtZTE1MDkwMDg1OTY4ODYtMzAweDE2NS5wbmdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj4iLCJwb3N0X2NhdGVnb3JpZXMiOiJJbm5vdmF0aW9uIENhc2UsIE1lZGlhIGxhYnMiLCJwb3N0X3RhZ3MiOiJBZG9iZSBraWNrYm94LCBhbmFseXRpY3MsIENhbmFkYSwgY3VsdHVyZSBvZiBpbm5vdmF0aW9uLCBkYXRhIHNjaWVuY2UsIGludGVybmFsIGlubm92YXRpb24sIG5ld3NwYXBlciwgcHJvdG90eXBlcywgc3RhZmYgZGV2ZWxvcG1lbnQsIHRyYWluaW5nIGFuZCBlZHVjYXRpb24sIFVYLCB2aXJ0dWFsIHJlYWxpdHkiLCIlX3ZjX3Bvc3Rfc2V0dGluZ3MlIjp7InZjX2dyaWRfaWQiOltdfSwiJV9lZGl0X2xvY2slIjoiMTUyODcyODA0NDoxMDEiLCIlX2VkaXRfbGFzdCUiOiIxMDEiLCIlc2xpZGVfdGVtcGxhdGUlIjoiZGVmYXVsdCIsIiVfd3BiX3ZjX2pzX3N0YXR1cyUiOiJ0cnVlIiwiJV9rbGVvX3RyYW5zcGFyZW50X21lbnVfY29sb3IlIjoid2hpdGUiLCIlX2tsZW9fdGl0bGVfY2hlY2tib3glIjoiMSIsIiVfa2xlb190aXRsZV9jb2xvciUiOiIjIiwiJV9rbGVvX3RpdGxlX2JnJSI6IiwgcmVwZWF0LCBpbmhlcml0LCBzY3JvbGwsIGxlZnQgdG9wIiwiJV9rbGVvX3RpdGxlX2JnX2NvbG9yJSI6IiMiLCIlX3lvYXN0X3dwc2VvX2NvbnRlbnRfc2NvcmUlIjoiMzAiLCIlX3lvYXN0X3dwc2VvX3ByaW1hcnlfY2F0ZWdvcnklIjoiMTQyIiwiJV90aHVtYm5haWxfaWQlIjoiMTEyNjEiLCIlX3dwZ21wX2xvY2F0aW9uX2FkZHJlc3MlIjoiVG9yb250bywgT04sIENhbmFkYSIsIiVfd3BnbXBfbWV0YWJveF9sYXRpdHVkZSUiOiI0My42NTMyMjYiLCIlX3dwZ21wX21ldGFib3hfbG9uZ2l0dWRlJSI6Ii03OS4zODMxODQyOTk5OTk5OCIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJwb3N0IiwiJV93cGdtcF9tZXRhYm94X2N1c3RvbV9saW5rJSI6IiIsIiVfd3BnbXBfbWFwX2lkJSI6ImE6MTp7aTowO3M6MTpcIjJcIjt9IiwiJV93cGdtcF9tZXRhYm94X21hcmtlcl9pZCUiOiJOOyIsIiVfd3BnbXBfbWV0YWJveF90YXhvbW9taWVzX3Rlcm1zJSI6Ik47IiwiJV93cGdtcF9leHRlbnNpb25zX2ZpZWxkcyUiOiJOOyIsIiVfamV0cGFja19yZWxhdGVkX3Bvc3RzX2NhY2hlJSI6eyI2MjM5M2IyNDJjN2E1NjE3NzRmOGViZmY1YzFjMDU2NSI6eyJleHBpcmVzIjoxNTQ1NTM3MDY1LCJwYXlsb2FkIjpbeyJpZCI6MTA3NjZ9LHsiaWQiOjExNDk0fSx7ImlkIjoxMDkzNX1dfX0sIiVzYmdfc2VsZWN0ZWRfc2lkZWJhciUiOiIwIiwiJXNiZ19zZWxlY3RlZF9zaWRlYmFyX3JlcGxhY2VtZW50JSI6IjAiLCJ0YXhvbm9teT1jYXRlZ29yeSI6Iklubm92YXRpb24gQ2FzZSwgTWVkaWEgbGFicyIsInRheG9ub215PXBvc3RfdGFnIjoiQWRvYmUga2lja2JveCwgYW5hbHl0aWNzLCBDYW5hZGEsIGN1bHR1cmUgb2YgaW5ub3ZhdGlvbiwgZGF0YSBzY2llbmNlLCBpbnRlcm5hbCBpbm5vdmF0aW9uLCBuZXdzcGFwZXIsIHByb3RvdHlwZXMsIHN0YWZmIGRldmVsb3BtZW50LCB0cmFpbmluZyBhbmQgZWR1Y2F0aW9uLCBVWCwgdmlydHVhbCByZWFsaXR5In0sImljb24iOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxOC8wMi9tYXJrZXItMS5wbmcifSwiaWQiOjExMjM1LCJpbmZvd2luZG93X2Rpc2FibGUiOmZhbHNlfSx7InNvdXJjZSI6InBvc3QiLCJ0aXRsZSI6IkFQIExhYjogaW5jbHVkaW5nIGV2ZXJ5b25lIGluIHRoZSBvcmdhbmlzYXRpb24gaW4gdGhlIGlubm92YXRpb24gcHJvY2VzcyIsImluZm93aW5kb3dfY29udGVudCI6IjxkaXYgY2xhc3M9XCJmYy1pdGVtLWJveCBmYy1pdGVtLW5vLXBhZGRpbmdcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiQVAgTGFiOiBpbmNsdWRpbmcgZXZlcnlvbmUgaW4gdGhlIG9yZ2FuaXNhdGlvbiBpbiB0aGUgaW5ub3ZhdGlvbiBwcm9jZXNzXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIxNjNcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxNy8xMC9Bc3NvY2lhdGVkLVByZXNzLU5ZQy0yMDE3LTg3LWUxNTA4MzE2ODQ3NTU5LTMwMHgxNjMuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZ1wiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tcGFkZGluZy1jb250ZW50XzIwXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tbWV0YSBmYy1pdGVtLXNlY29uZGFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlIGZjLXRleHQtY2VudGVyXCI+SW5ub3ZhdGlvbiBDYXNlLCBNZWRpYSBsYWJzPC9kaXY+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tdGl0bGUgZmMtaXRlbS1wcmltYXJ5LXRleHQtY29sb3IgZmMtdGV4dC1jZW50ZXJcIj5BUCBMYWI6IGluY2x1ZGluZyBldmVyeW9uZSBpbiB0aGUgb3JnYW5pc2F0aW9uIGluIHRoZSBpbm5vdmF0aW9uIHByb2Nlc3M8L2Rpdj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1jb250ZW50IGZjLWl0ZW0tYm9keS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+XHJcbiAgICAgICAgICAgIFRoZSBBc3NvY2lhdGVkIFByZXNzIGlzIGRldmVsb3BpbmcgYSB3b3JsZHdpZGUgaHViIHRocm91Z2ggaW50ZXJuYWwgYW5kIGV4dGVybmFsIGlubm92YXRpb24gZWZmb3J0cyB0byBlbmNvdXJhZ2UgYSBjdWx0dXJlIG9mIGV4cGVyaW1lbnRhdGlvbiBhbmQgY29sbGFib3JhdGlvbiB3aXRoaW4gdGhlIG9yZ2FuaXNhdGlvbi5cclxuICAgICAgICA8L2Rpdj5cclxuPGEgaHJlZj1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9hcC1sYWItaW5jbHVkaW5nLWV2ZXJ5b25lLW9yZ2FuaXNhdGlvbi1pbm5vdmF0aW9uLXByb2Nlc3MvXCI+UmVhZCBtb3JlPC9hPlxyXG4gICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuPC9kaXY+XHJcblxyXG4iLCJjb250ZW50IjoiVGhlIEFzc29jaWF0ZWQgUHJlc3MgaXMgZGV2ZWxvcGluZyBhIHdvcmxkd2lkZSBodWIgdGhyb3VnaCBpbnRlcm5hbCBhbmQgZXh0ZXJuYWwgaW5ub3ZhdGlvbiBlZmZvcnRzIHRvIGVuY291cmFnZSBhIGN1bHR1cmUgb2YgZXhwZXJpbWVudGF0aW9uIGFuZCBjb2xsYWJvcmF0aW9uIHdpdGhpbiB0aGUgb3JnYW5pc2F0aW9uLiIsImFkZHJlc3MiOiJOZXcgWW9yaywgTlksIFVuaXRlZCBTdGF0ZXMiLCJsb2NhdGlvbiI6eyJsYXQiOiIzMi45MjE2ODk2IiwibG5nIjoiLTgwLjA5ODgyMzkwMDAwMDAxIiwib25jbGlja19hY3Rpb24iOiJwb3N0IiwicmVkaXJlY3RfcGVybWFsaW5rIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL2FwLWxhYi1pbmNsdWRpbmctZXZlcnlvbmUtb3JnYW5pc2F0aW9uLWlubm92YXRpb24tcHJvY2Vzcy8iLCJ6b29tIjoyLCJleHRyYV9maWVsZHMiOnsicG9zdF9leGNlcnB0IjoiVGhlIEFzc29jaWF0ZWQgUHJlc3MgaXMgZGV2ZWxvcGluZyBhIHdvcmxkd2lkZSBodWIgdGhyb3VnaCBpbnRlcm5hbCBhbmQgZXh0ZXJuYWwgaW5ub3ZhdGlvbiBlZmZvcnRzIHRvIGVuY291cmFnZSBhIGN1bHR1cmUgb2YgZXhwZXJpbWVudGF0aW9uIGFuZCBjb2xsYWJvcmF0aW9uIHdpdGhpbiB0aGUgb3JnYW5pc2F0aW9uLiIsInBvc3RfY29udGVudCI6Ilt2Y19yb3ddW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIyLzNcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxoMT5BUCBJbm5vdmF0aW9uOiBpbmNsdWRpbmcgZXZlcnlvbmUgaW4gdGhlIG9yZ2FuaXNhdGlvbiBpbiB0aGUgaW5ub3ZhdGlvbiBwcm9jZXNzPC9oMT5cclxuPHN0cm9uZz5UaGUgQXNzb2NpYXRlZCBQcmVzcyBpcyBkZXZlbG9waW5nIGEgd29ybGR3aWRlIGh1YiB0aHJvdWdoIGludGVybmFsIGFuZCBleHRlcm5hbCBpbm5vdmF0aW9uIGVmZm9ydHMgdG8gZW5jb3VyYWdlIGEgY3VsdHVyZSBvZiBleHBlcmltZW50YXRpb24gYW5kIGNvbGxhYm9yYXRpb24gd2l0aGluIHRoZSBvcmdhbmlzYXRpb24uPC9zdHJvbmc+XHJcblxyXG5UaGUgQXNzb2NpYXRlZCBQcmVzcyAoQVApIGlzIGEgbGFyZ2UgY29vcGVyYXRpb24gb2YgYnJvYWRjYXN0IGFuZCBuZXdzcGFwZXIgb3JnYW5pc2F0aW9ucy4gV2l0aCB0ZWFtcyBpbiBvdmVyIDEwMCBjb3VudHJpZXMsIHRoZXkgY292ZXIgY3VycmVudCBldmVudHMgZnJvbSBicmVha2luZyBuZXdzIHRvIGludmVzdGlnYXRpdmUgcmVwb3J0aW5nIGluIGFsbCBraW5kcyBvZiBmb3JtYXRzLCBpbmNsdWRpbmcgcGhvdG8sIHZpZGVvIGFuZCB0ZXh0LlxyXG5cclxuVGhlIGlubm92YXRpb24gZWZmb3J0cyBvZiBBUCB3ZXJlIGluaXRpYXRlZCB0aHJlZSB5ZWFycyBhZ28sIGFmdGVyIGEgc3RyYXRlZ2ljIHBsYW5uaW5nIHByb2Nlc3MgdGhhdCByZXN1bHRlZCBpbiB0aGUgZGVmaW5pdGlvbiBvZiB0aHJlZSBzdHJhdGVnaWMgcGlsbGFyczogZXhwYW5kaW5nIGNvbnRlbnQsIGhhcm5lc3NpbmcgbWFjaGluZSBpbnRlbGxpZ2VuY2UsIGFuZCBleHBsb3JpbmcgYnVzaW5lc3MgbW9kZWxzIGJleW9uZCB0aGUgY29yZSBhY3Rpdml0aWVzIG9mIEFQLiBBIGN1bHR1cmUgb2YgaW5ub3ZhdGlvbiB3YXMgbmVjZXNzYXJ5IHRvIHRpZSB0aGVzZSBzdHJhdGVnaWMgcGlsbGFycyB0b2dldGhlci5cclxuXHJcbkl0IHdhcyBhIGNvbnNjaW91cyBkZWNpc2lvbiBub3QgdG8gaGF2ZSBhIHBoeXNpY2FsIGxhYiBpbiB3aGljaCBvbmx5IGEgZmV3IHBlb3BsZSBjb3VsZCBjb2xsYWJvcmF0ZSwgYXMgYSBjdWx0dXJlIG9mIGlubm92YXRpb24gaXMgcmF0aGVyIG9yZ2FuaWM6XHJcbjxibG9ja3F1b3RlPlx1MjAxY0JlaW5nIHN1Y2ggYSBsYXJnZSBvcmdhbmlzYXRpb247IGhhdmluZyBidXJlYXVzIGFyb3VuZCB0aGUgd29ybGQgYW5kIHBlb3BsZSB3b3JraW5nIGZyb20gZGlmZmVyZW50IGNvdW50cmllcywgd2UgZmVsdCBmb3Igb3VyIHNwZWNpZmljIGNhc2UgdGhhdCBpdCB3YXMgYmV0dGVyIHRvIGZvY3VzIG9uIHNwcmVhZGluZyB0aGlzIGN1bHR1cmUgb2YgaW5ub3ZhdGlvbixcdTIwMWQgc2F5cyBGcmFuY2VzY28gTWFyY29uaSwgTWFuYWdlciBvZiBDb3Jwb3JhdGUgU3RyYXRlZ3kuIFx1MjAxY1NvIGV2ZXJ5b25lIGNvdWxkIGJlIHBhcnQgb2YgdGhhdCBwcm9jZXNzLlx1MjAxZDwvYmxvY2txdW90ZT5cclxuPGgzPkNvbW11bmljYXRpb24gaXMga2V5PC9oMz5cclxuQVAgaXMgZGV2ZWxvcGluZyB0aGlzIGN1bHR1cmUgb2YgaW5ub3ZhdGlvbiB0aHJvdWdoIHRocmVlIG1ham9yIGVmZm9ydHMuIE9uZSBpcyBBUCBJbnNpZ2h0cyBvbiB0aGUgQVAgd2Vic2l0ZSwgd2hlcmUgYmVzdCBwcmFjdGljZXMgZnJvbSB0aGUgaW5kdXN0cnkgaW4gdGVybXMgb2YgbmV3cyBpbm5vdmF0aW9uLCB0aG91Z2h0IGxlYWRlcnNoaXAgYW5kIHJlcG9ydHMgYXJlIGdhdGhlcmVkLiBJdCBhbHNvIGhpZ2hsaWdodHMgdGhlIHRoaW5ncyB0aGUgQXNzb2NpYXRlZCBQcmVzcyBhbmQgc3RhZmZlcnMgYXJlIGRvaW5nIGFyb3VuZCBpbm5vdmF0aW9uLCB3aGV0aGVyIHRoaXMgaXMgdGVjaG5vbG9naWNhbCBpbm5vdmF0aW9uLCBpbm5vdmF0aW9uIGluIGhvdyB0byBkbyBidXNpbmVzcywgb3Igd2F5cyB0byBjb2xsYWJvcmF0ZSB3aXRoIHVuaXZlcnNpdGllcy4gXHUyMDFjQXMgYSByZXN1bHQgYSBsb3Qgb2YgcGVvcGxlIGJlY2FtZSBpbnRlcmVzdGVkIGluIHRoZSBlZmZvcnQsXHUyMDFkIHNheXMgRnJhbmNlc2NvIE1hcmNvbmkuXHJcblxyXG5MYXN0IHllYXIsIHRoZXkgY3JlYXRlZCBhbmFydGlmaWNpYWwgaW50ZWxsaWdlbmNlIGNvbW1pdHRlZSBmb2N1c2VkIG9uIGRlcGxveWluZyBhcnRpZmljaWFsIGludGVsbGlnZW5jZSBhY3Jvc3MgdGhlIG9yZ2FuaXNhdGlvbi4gRnJhbmNlc2NvIE1hcmNvbmkgYmVsaWV2ZXMgaW5ub3ZhdGl2ZSBpbXBsZW1lbnRhdGlvbiBvZiBBSSBjYW4gZnJlZSBuZXdzcm9vbSByZXNvdXJjZXMgdG8gZm9jdXMgb24gdGhlIHZpdGFsIGpvdXJuYWxpc3RpYyB0YXNrcyAtIGxpa2UgcmVwb3J0aW5nLCBkZXZlbG9waW5nIG5ldyBzb3VyY2VzIGFuZCBkb2luZyBkZWVwIGludmVzdGlnYXRpb25zIC0gdGhhdCBodW1hbnMgZG8gYmVzdC4gV2hlbiB1c2VkIHRoZSByaWdodCB3YXksIGFydGlmaWNpYWwgaW50ZWxsaWdlbmNlIGNhbiBoZWxwIG1heGltaXplIG91dHB1dCBpbiBuZXdzcm9vbXMgLSBlc3BlY2lhbGx5IGFzIGVkaXRvcmlhbCB0ZWFtcyBhcmUgY2hhbGxlbmdlZCB3aXRoIGxlc3MgcmVzb3VyY2VzIGFuZCBzbWFsbGVyIGJ1ZGdldHMuIEFJIGlzIGhlbHBpbmcgdGhlbSBjb3ZlciBzdG9yaWVzIHRoZXkgZGlkblx1MjAxOXQgbWFuYWdlIHRvIGNvdmVyIGJlZm9yZS5cclxuXHJcblRoZSB0aGlyZCBhbmQgcGVyaGFwcyBtb3N0IHRyYW5zZm9ybWF0aXZlIGVmZm9ydCBpbiB0ZXJtcyBvZiBjaGFuZ2luZyB0aGUgbWluZC1zZXQgd2l0aGluIHRoZSBvcmdhbmlzYXRpb246IEluc2lkZSBBUC4gQXMgYSBzb3J0IG9mIEZhY2Vib29rIGZvciBBUCBzdGFmZiwgSW5zaWRlIEFQIGFsbG93cyBBUFx1MjAxOWVycyB0byBmb2xsb3cgd2hhdFx1MjAxOXMgaGFwcGVuaW5nIHdpdGhpbiBBUCBpbiB0ZXJtcyBvZiBpbm5vdmF0aW9uLiBSYW5naW5nIGZyb20gZXZlbnRzIHRvIHVwZGF0ZXMgb24gZGVhbHMgc3RydWNrIHdpdGggYW5vdGhlciBpbm5vdmF0aXZlIGNvbXBhbnkuXHJcbjxoMz5IdWIgcmF0aGVyIHRoYW4gYSBsYWI8L2gzPlxyXG5BbGwgdGhlc2UgZWZmb3J0cyB0b2dldGhlciBmb3JtIEFQXHUyMDE5cyBpbm5vdmF0aW9uIGh1YiwgYnVpbHQgYXJvdW5kIHRoZSBpZGVhIHRoYXQgY29tbXVuaWNhdGluZyB3aGF0IHlvdSBhcmUgZG9pbmcgaGVscHMgY3JlYXRlIHN1cHBvcnQgZnJvbSBlbXBsb3llZXMsIG9yIGFzIE1hcmNvbmkgc2F5cyBcdTIwMWNvdXIgYXBwcm9hY2ggdG8gaW5ub3ZhdGlvbiBpcyBiYXNlZCBvbiB3aGF0IHdlIGRvIGJlc3QsIHdoaWNoIGlzIGNyZWF0aW5nIGNvbnRlbnQgYW5kIHN0b3J5dGVsbGluZ1x1MjAxZC4gQWNjb3JkaW5nIHRvIGhpbSwgb3RoZXIgdGhpbmdzIG5hdHVyYWxseSBlbWVyZ2VkIGZyb20gdGhhdDpcclxuPGJsb2NrcXVvdGU+XHUyMDFjd2Ugc3RhcnRlZCBkb2luZyB3ZWJpbmFycyBhbmQgYm9vdGNhbXBzIGZvciBvdXIgc3RhZmZlcnMsIHdoZXJlIHdlIHRyYWluIHRoZW0gaW4gZGVzaWduIHRoaW5raW5nLCBsZXZlcmFnaW5nIG5ldyB0ZWNobm9sb2dpZXMgc3VjaCBhcyB2aXJ0dWFsIHJlYWxpdHkgYW5kIGFydGlmaWNpYWwgaW50ZWxsaWdlbmNlLiBBbmQgaW4gdGhlIGxvbmcgcnVuIHdlIGFsc28gbWFrZSB0aGUgZWZmb3J0IG9mIHNoYXJpbmcgdGhlc2UgaW5zaWdodHMgd2l0aCB0aGUgaW5kdXN0cnkuXHUyMDFkPC9ibG9ja3F1b3RlPlxyXG5UaGlzIGNvbWJpbmF0aW9uIG9mIGxlYXJuaW5nIGFuZCBzaGFyaW5nIGZvcm1zIHRoZSBiYXNpcyBvZiBhIHNvcnQgb2YgQVAgaW5ub3ZhdGlvbiBodWIsIHdoaWNoIGZpdHMgd2VsbCB0aGUgbmV0d29ya2VkIHN0cnVjdHVyZSBvZiBBUCB3aXRoIG9mZmljZXMgYW5kIGpvdXJuYWxpc3RzIHdvcmtpbmcgYWxsIGFyb3VuZCB0aGUgd29ybGQuIEZvciB0aGUgY3VsdHVyZSBvZiBpbm5vdmF0aW9uIHRvIGRldmVsb3AsIGl0XHUyMDE5cyBpbXBvcnRhbnQgdG8gaW5jbHVkZSBhbGwgc3RhZmZlcnMgaW4gdGhlIHByb2Nlc3M6XHJcbjxibG9ja3F1b3RlPlx1MjAxY1dlIG1hZGUgbGl0dGxlIHBvc3RlcnMgd2l0aCB0aGUgc3RyYXRlZ2ljIGdvYWxzIG9mIHRoZSBjb21wYW55LCBiZWF1dGlmdWxseSBkZXNpZ25lZCwgYW5kIHdlIGRpc3RyaWJ1dGVkIHRoZW0gd2l0aGluIHRoZSBjb21wYW55LCBvbiBkZXNrcyBvciBvbiB0aGUgd2FsbC4gQWdhaW4sIGl0XHUyMDE5cyBqdXN0IG1ha2luZyBzdXJlIHRoYXQgcGVvcGxlIGFyZSBhd2FyZSwgdGhhdCBldmVyeW9uZSBjYW4gY29udHJpYnV0ZSwgZXZlcnlvbmVcdTIwMTlzIG9waW5pb24sIGV2ZXJ5b25lXHUyMDE5cyBpZGVhcyBhcmUgdmFsdWFibGUgYW5kIGl0XHUyMDE5cyBhIG5ldHdvcmsgb2Yga25vd2xlZGdlIHRoYXQgZW5hYmxlcyB0aGUgY29tcGFueSB0byBtb3ZlIGZvcndhcmQgYW5kIHNoYXJlIHRoZWlyIGV4cGVydGlzZSBhbG9uZyB0aGUgd2F5Llx1MjAxZDwvYmxvY2txdW90ZT5cclxuPGgzPkludmVzdGluZyBpbiBzdGFydC11cHM8L2gzPlxyXG5BbG1vc3QgYWN0aW5nIGxpa2UgYSBmb3JtYWxpc2VkIG91dHNvdXJjZWQgaW5ub3ZhdGlvbiBsYWIgQVAgYWxzbyBoYXMgYSBwYXJ0bmVyc2hpcCB3aXRoIE1hdHRlclZlbnR1cmVzLiBUaGlzIFNhbiBGcmFuY2lzY28gYW5kIE5ldyBZb3JrIGJhc2VkIG1lZGlhIGluY3ViYXRvciBpcyBmdW5kZWQgYnkgbWVkaWEgb3JnYW5pc2F0aW9ucywgaW5jbHVkaW5nIEFQLCB0aGUgTmV3IFlvcmsgVGltZXMgYW5kIE1jQ2xhdGNoeSBUaGUgc3RhcnQtdXBzIGdvIHRocm91Z2ggYSBwcm9ncmFtIHRoYXRcdTIwMTlzIGFsc28gb3BlbiBmb3IgdGVhbXMgZnJvbSB0aGUgcGFydG5lciBtZWRpYSBjb21wYW5pZXMgdG8gcGFydGljaXBhdGUgaW4uXHJcblxyXG5SaWdodCBub3csIGFuIEFQIHRlYW0gaXMgd29ya2luZyBvbiBhbiBpZGVhIGZvciBzcG9ydHMgaW5ub3ZhdGlvbiB3aXRoaW4gdGhhdCBzdGFydC11cCBwcm9ncmFtLiBMYXN0IHllYXIsIEZyYW5jZXNjbyB3YXMgcGFydCBvZiBhIHByb2plY3Qgb24gQXJ0aWZpY2lhbCBJbnRlbGxpZ2VuY2UsIHdoaWNoIGxlZCB0byB0aGUgY3JlYXRpb24gb2YgdGhlIEFydGlmaWNpYWwgSW50ZWxsaWdlbmNlIGNvbW1pdHRlZSB3aXRoaW4gQVAuXHJcbjxoMz5Jbm5vdmF0aW9uIHdpdGggYSBzdHJhdGVnaWMgZ29hbDwvaDM+XHJcbklubm92YXRpb24gaXMgYSBwcm9jZXNzIHRoYXRcdTIwMTlzIGRyaXZlbiBieSBhIHdpbGxpbmduZXNzIHRvIGxlYXJuIGFuZCBzaGFyZSBpbnNpZ2h0cywgYnV0IGl0IHN0YXJ0cyB3aXRoIHRoZSBidXNpbmVzc1x1MjAxOSBuZWVkczogXHUyMDFjQWxsIHRoZSBtb25leSBBUCBtYWtlcyBpcyByZWludmVzdGVkIGJhY2sgaW4gbmV3cywgaW4gam91cm5hbGlzbSwgc28gYWx0aG91Z2ggd2VcdTIwMTlyZSBhIG5vdC1mb3ItcHJvZml0IGNvbXBhbnksIGl0XHUyMDE5cyBpbXBvcnRhbnQgdG8gYnVpbGQgYSBoZWFsdGh5IGJ1c2luZXNzLlx1MjAxZFxyXG5UaGF0IGlzIHdoYXQgYSBtZWRpYSBvcmdhbmlzYXRpb24gY2FuIGFkZC4gSXRcdTIwMTlzIG5vdCBqdXN0IGFib3V0IGFkb3B0aW5nIGEgc3RhcnQtdXAgbWVudGFsaXR5OyBpdFx1MjAxOXMgYWJvdXQgY29tYmluaW5nIHRoZSBhc3NldHMgb2YgYSBmbGV4aWJsZSBzdGFydC11cCBtZW50YWxpdHkgd2l0aCB0aGUgc3RydWN0dXJlIG9mIGEgMTcwLXllYXItb2xkIGNvbXBhbnkuXHJcbjxibG9ja3F1b3RlPlx1MjAxY1NvIGl0XHUyMDE5cyBub3QgZG9pbmcgdGhpbmdzIG9yIHRlc3RpbmcgdGVjaG5vbG9neSBqdXN0IGZvciB0aGUgc2FrZSBvZiBleHBlcmltZW50YXRpb24uIFdlIHRyeSB0byBhdm9pZCB0aGF0IGF0IGFsbCBjb3N0LiBXZSBpbnN0ZWFkIGxpa2UgdG8gZm9jdXMgb24gdmVyeSBzcGVjaWZpYyBwcm9qZWN0cyB0aGF0IGhhdmUgc3BlY2lmaWMgb3V0Y29tZXMgdGhhdCB3ZSBjYW4gbWVhc3VyZSBhbmQgdGhhdCBkb2Vzblx1MjAxOXQgaGF2ZSB0byBiZSBhbnl0aGluZyByaXNreSxcdTIwMWQgZXhwbGFpbnMgRnJhbnNjZXNjbyBNYXJjb25pLjwvYmxvY2txdW90ZT5cclxuQ09OVEFDVCBQT0lOVFxyXG5cclxuPGltZyBjbGFzcz1cImFsaWdubm9uZSB3cC1pbWFnZS0xMTIzMSBzaXplLWZ1bGxcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxNy8xMC9GcmFuY2VzY28tZTE1MDc2NTEwMTU3MDkuanBnXCIgYWx0PVwiXCIgd2lkdGg9XCIyMDBcIiBoZWlnaHQ9XCIyNTBcIiAvPlxyXG5cclxuRnJhbmNlc2NvIE1hcmNvbmksIE1hbmFnZXIgb2YgQ29ycG9yYXRlIFN0cmF0ZWd5LCBBUCBMYWIvQVAgSW5zaWdodHNcclxuVHdpdHRlcjogPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vZnBtYXJjb25pXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5AZnBtYXJjb25pPC9hPlxyXG5XZWJzaXRlOiA8YSBocmVmPVwiaHR0cHM6Ly9pbnNpZ2h0cy5hcC5vcmcvXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5odHRwczovL2luc2lnaHRzLmFwLm9yZy88L2E+XHJcblxyXG4tLVxyXG5cclxuPGVtPkhlYWRlciBJPC9lbT48ZW0+bWFnZTogXHUyMDFjUGhvdG8gY291cnRlc3kgb2YgVFBHIEFyY2hpdGVjdHVyZVx1MjAxZDwvZW0+Wy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjIvM1wiXVt2Y19jb2x1bW5fdGV4dF1cclxuPGgzPkF1dGhvcjwvaDM+XHJcbltzaW1wbGUtYXV0aG9yLWJveF1bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd10iLCJwb3N0X3RpdGxlIjoiQVAgTGFiOiBpbmNsdWRpbmcgZXZlcnlvbmUgaW4gdGhlIG9yZ2FuaXNhdGlvbiBpbiB0aGUgaW5ub3ZhdGlvbiBwcm9jZXNzIiwicG9zdF9saW5rIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL2FwLWxhYi1pbmNsdWRpbmctZXZlcnlvbmUtb3JnYW5pc2F0aW9uLWlubm92YXRpb24tcHJvY2Vzcy8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJBUCBMYWI6IGluY2x1ZGluZyBldmVyeW9uZSBpbiB0aGUgb3JnYW5pc2F0aW9uIGluIHRoZSBpbm5vdmF0aW9uIHByb2Nlc3NcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjE2M1wiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE3LzEwL0Fzc29jaWF0ZWQtUHJlc3MtTllDLTIwMTctODctZTE1MDgzMTY4NDc1NTktMzAweDE2My5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj4iLCJwb3N0X2NhdGVnb3JpZXMiOiJJbm5vdmF0aW9uIENhc2UsIE1lZGlhIGxhYnMiLCJwb3N0X3RhZ3MiOiJBSSwgY29tbXVuaWNhdGlvbiwgY3VsdHVyZSBvZiBpbm5vdmF0aW9uLCBleHRlcm5hbCBpbm5vdmF0aW9uLCBpbnRlcm5hbCBpbm5vdmF0aW9uLCBuZXR3b3JrLCBuZXdzIGFnZW5jeSwgdHJhaW5pbmcgYW5kIGVkdWNhdGlvbiwgVVNBIiwiJV92Y19wb3N0X3NldHRpbmdzJSI6eyJ2Y19ncmlkX2lkIjpbXX0sIiVfZWRpdF9sb2NrJSI6IjE1MjcwMDAwODY6MTAxIiwiJV9lZGl0X2xhc3QlIjoiMTAxIiwiJXNsaWRlX3RlbXBsYXRlJSI6ImRlZmF1bHQiLCIlX3dwYl92Y19qc19zdGF0dXMlIjoidHJ1ZSIsIiVfa2xlb190cmFuc3BhcmVudF9tZW51X2NvbG9yJSI6IndoaXRlIiwiJV9rbGVvX3RpdGxlX2NvbG9yJSI6IiMiLCIlX2tsZW9fdGl0bGVfYmclIjoiLCByZXBlYXQsIGluaGVyaXQsIHNjcm9sbCwgbGVmdCB0b3AiLCIlX2tsZW9fdGl0bGVfYmdfY29sb3IlIjoiIyIsIiVfeW9hc3Rfd3BzZW9fY29udGVudF9zY29yZSUiOiI2MCIsIiVfeW9hc3Rfd3BzZW9fcHJpbWFyeV9jYXRlZ29yeSUiOiI2OSIsIiVfa2xlb190aXRsZV9jaGVja2JveCUiOiIxIiwiJV90aHVtYm5haWxfaWQlIjoiMTEyNDgiLCIlX3dwZ21wX2xvY2F0aW9uX2FkZHJlc3MlIjoiTmV3IFlvcmssIE5ZLCBVbml0ZWQgU3RhdGVzIiwiJV93cGdtcF9tZXRhYm94X2xhdGl0dWRlJSI6IjMyLjkyMTY4OTYiLCIlX3dwZ21wX21ldGFib3hfbG9uZ2l0dWRlJSI6Ii04MC4wOTg4MjM5MDAwMDAwMSIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJwb3N0IiwiJV93cGdtcF9tZXRhYm94X2N1c3RvbV9saW5rJSI6IiIsIiVfd3BnbXBfbWFwX2lkJSI6ImE6MTp7aTowO3M6MTpcIjJcIjt9IiwiJV93cGdtcF9tZXRhYm94X21hcmtlcl9pZCUiOiJOOyIsIiVfd3BnbXBfbWV0YWJveF90YXhvbW9taWVzX3Rlcm1zJSI6Ik47IiwiJV93cGdtcF9leHRlbnNpb25zX2ZpZWxkcyUiOiJOOyIsIiVfamV0cGFja19yZWxhdGVkX3Bvc3RzX2NhY2hlJSI6eyI2MjM5M2IyNDJjN2E1NjE3NzRmOGViZmY1YzFjMDU2NSI6eyJleHBpcmVzIjoxNTQ1NDQ2MjM2LCJwYXlsb2FkIjpbeyJpZCI6MTEyMzV9LHsiaWQiOjExNDk0fSx7ImlkIjoxMTcxNH1dfX0sIiVzYmdfc2VsZWN0ZWRfc2lkZWJhciUiOiIwIiwiJXNiZ19zZWxlY3RlZF9zaWRlYmFyX3JlcGxhY2VtZW50JSI6IjAiLCJ0YXhvbm9teT1jYXRlZ29yeSI6Iklubm92YXRpb24gQ2FzZSwgTWVkaWEgbGFicyIsInRheG9ub215PXBvc3RfdGFnIjoiQUksIGNvbW11bmljYXRpb24sIGN1bHR1cmUgb2YgaW5ub3ZhdGlvbiwgZXh0ZXJuYWwgaW5ub3ZhdGlvbiwgaW50ZXJuYWwgaW5ub3ZhdGlvbiwgbmV0d29yaywgbmV3cyBhZ2VuY3ksIHRyYWluaW5nIGFuZCBlZHVjYXRpb24sIFVTQSJ9LCJpY29uIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTgvMDIvbWFya2VyLTEucG5nIn0sImlkIjoxMTIyNSwiaW5mb3dpbmRvd19kaXNhYmxlIjpmYWxzZX0seyJzb3VyY2UiOiJwb3N0IiwidGl0bGUiOiJIYWNrYXN0b3J5OiB0ZWFjaGluZyBjb2RlcnMgYW5kIGpvdXJuYWxpc3RzIGhvdyB0byBjb2xsYWJvcmF0ZSIsImluZm93aW5kb3dfY29udGVudCI6IjxkaXYgY2xhc3M9XCJmYy1pdGVtLWJveCBmYy1pdGVtLW5vLXBhZGRpbmdcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiSGFja2FzdG9yeTogdGVhY2hpbmcgY29kZXJzIGFuZCBqb3VybmFsaXN0cyBob3cgdG8gY29sbGFib3JhdGVcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjE2NVwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE3LzA5L0hhY2thc3Rvcnktd29ya3Nob3AtYXQtVGhlLU5leHQtV2ViLUNvbmZlcmVuY2UtZTE1MDU4MzMyMTE5NzktMzAweDE2NS5wbmdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1wYWRkaW5nLWNvbnRlbnRfMjBcIj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1tZXRhIGZjLWl0ZW0tc2Vjb25kYXJ5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2UgZmMtdGV4dC1jZW50ZXJcIj5Jbm5vdmF0aW9uIENhc2UsIE1lZGlhIGxhYnM8L2Rpdj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS10aXRsZSBmYy1pdGVtLXByaW1hcnktdGV4dC1jb2xvciBmYy10ZXh0LWNlbnRlclwiPkhhY2thc3Rvcnk6IHRlYWNoaW5nIGNvZGVycyBhbmQgam91cm5hbGlzdHMgaG93IHRvIGNvbGxhYm9yYXRlPC9kaXY+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tY29udGVudCBmYy1pdGVtLWJvZHktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZVwiPlxyXG4gICAgICAgICAgICBCdWlsZGluZyB0aGUgZnV0dXJlIG9mIGpvdXJuYWxpc20gYnkgb3JnYW5pc2luZyBqb3VybmFsaXNtIEhhY2thdGhvbnMgd2hlcmUgbXVsdGlkaXNjaXBsaW5hcnkgdGVhbXMgb2YgZGVzaWduZXJzLCBjb2RlcnMgYW5kIGpvdXJuYWxpc3RzIHdvcmsgdG9nZXRoZXIuXHJcbiAgICAgICAgPC9kaXY+XHJcbjxhIGhyZWY9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvaGFja2FzdG9yeS10ZWFjaGluZy1jb2RlcnMtam91cm5hbGlzdHMtY29sbGFib3JhdGUvXCI+UmVhZCBtb3JlPC9hPlxyXG4gICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuPC9kaXY+XHJcblxyXG4iLCJjb250ZW50IjoiQnVpbGRpbmcgdGhlIGZ1dHVyZSBvZiBqb3VybmFsaXNtIGJ5IG9yZ2FuaXNpbmcgam91cm5hbGlzbSBIYWNrYXRob25zIHdoZXJlIG11bHRpZGlzY2lwbGluYXJ5IHRlYW1zIG9mIGRlc2lnbmVycywgY29kZXJzIGFuZCBqb3VybmFsaXN0cyB3b3JrIHRvZ2V0aGVyLiIsImFkZHJlc3MiOiJOZXRoZXJsYW5kcyIsImxvY2F0aW9uIjp7ImxhdCI6IjUyLjEzMjYzMzAwMDAwMDAxIiwibG5nIjoiNS4yOTEyNjU5OTk5OTk5NTA1Iiwib25jbGlja19hY3Rpb24iOiJwb3N0IiwicmVkaXJlY3RfcGVybWFsaW5rIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL2hhY2thc3RvcnktdGVhY2hpbmctY29kZXJzLWpvdXJuYWxpc3RzLWNvbGxhYm9yYXRlLyIsInpvb20iOjIsImV4dHJhX2ZpZWxkcyI6eyJwb3N0X2V4Y2VycHQiOiJCdWlsZGluZyB0aGUgZnV0dXJlIG9mIGpvdXJuYWxpc20gYnkgb3JnYW5pc2luZyBqb3VybmFsaXNtIEhhY2thdGhvbnMgd2hlcmUgbXVsdGlkaXNjaXBsaW5hcnkgdGVhbXMgb2YgZGVzaWduZXJzLCBjb2RlcnMgYW5kIGpvdXJuYWxpc3RzIHdvcmsgdG9nZXRoZXIuIiwicG9zdF9jb250ZW50IjoiW3ZjX3Jvd11bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjIvM1wiXVt2Y19jb2x1bW5fdGV4dF1cclxuPGgxPkhhY2thc3Rvcnk6IHRlYWNoaW5nIGNvZGVycyBhbmQgam91cm5hbGlzdHMgaG93IHRvIGNvbGxhYm9yYXRlPC9oMT5cclxuPHN0cm9uZz5CdWlsZGluZyB0aGUgZnV0dXJlIG9mIGpvdXJuYWxpc20gYnkgb3JnYW5pc2luZyBqb3VybmFsaXNtIEhhY2thdGhvbnMgd2hlcmUgbXVsdGlkaXNjaXBsaW5hcnkgdGVhbXMgb2YgZGVzaWduZXJzLCBjb2RlcnMgYW5kIGpvdXJuYWxpc3RzIHdvcmsgdG9nZXRoZXIuPC9zdHJvbmc+XHJcblxyXG5IYWNrYXN0b3J5IGZvdW5kZXIgQWxiZXJ0aW5lIFBpZWxzIHdhcyB3b3JraW5nIGFzIGEgam91cm5hbGlzdCBmb3IgMTUgeWVhcnMgd2hlbiBzaGUgcmVhbGlzZWQgc2hlIGhhZCBub3Qgb25jZSBpbiB0aG9zZSB5ZWFycyB3b3JrZWQgd2l0aCBhIG5ld3Nyb29tIGRldmVsb3Blci4gVGhpcyBzdHJ1Y2sgaGVyIGFzIHN0cmFuZ2UsIGVzcGVjaWFsbHkgc2luY2UgY29sbGFib3JhdGlvbiB3aXRoIGNhbWVyYW1lbiwgcHJvZHVjZXJzIGFuZCBlZGl0b3JzIGlzIHZlcnkgY29tbW9uIHdpdGhpbiB0aGUgRHV0Y2ggYnJvYWRjYXN0aW5nIG9yZ2FuaXNhdGlvbiBzaGUgd2FzIHdvcmtpbmcgZm9yIGF0IHRoZSB0aW1lLlxyXG5cclxuV29uZGVyaW5nIHdoZXRoZXIgdGhpcyBzdXJwcmlzZWQgbW9yZSBwcm9mZXNzaW9uYWxzIGluIHRoZSBqb3VybmFsaXNtIGZpZWxkLCBzaGUgY3JlYXRlZCBhIHNpbXBsZSB3b3JkcHJlc3MgcGFnZSB3aGVyZSBzaGUgYXNrZWQgcGVvcGxlIHRvIHJlYWNoIG91dCBpZiB0aGV5IHdlcmUgaW50ZXJlc3RlZCBpbiBjb2xsYWJvcmF0aW5nLiBXaXRoaW4gYW4gaG91ciwgMTUgcGVvcGxlIGhhZCBzaWduZWQgdXA6XHJcbjxibG9ja3F1b3RlPlx1MjAxY1RoZSBmaXJzdCBIYWNrYXRob24gY2FtZSBvdXQgb2YgdGhpcy4gSXQgd2FzIGFuIGluY3JlZGlibHkgYmFzaWMgc2V0dXAuIFdlIGp1c3Qgd2VsY29tZWQgYWxsIHRoZSBwYXJ0aWNpcGFudHMgYW5kIHRoZW4gdGhleSBhbGwgc3RhcnRlZCB0YXBwaW5nIG9uIHRoZWlyIGNvbXB1dGVycy4gQW5kIGFsbW9zdCBhbGwgdGVhbXMgcmFuIGludG8gYmlnIGNoYWxsZW5nZXMuXHUyMDFkPC9ibG9ja3F1b3RlPlxyXG48aDM+VHdlYWtpbmcgdGhlIG1ldGhvZDwvaDM+XHJcbkFmdGVyIHRoZSBmaXJzdCBIYWNrYXRob24sIEFsYmVydGluZSBhbmQgaGVyIHRlYW0gcmVhbGlzZWQgdGhleSBuZWVkZWQgYSBiZXR0ZXIgd2F5IHRvIGNvbm5lY3QgdGhlIGJyYWlucyBvZiB0aGUgcGFydGljaXBhbnRzIGR1cmluZyBhIGxvbmdlciBwZXJpb2Qgb2YgdGltZS4gVGhleSBkZXZlbG9wZWQgYSBwcm9jZXNzIHRvIGZpbmQgY3JlYXRpdmUgc29sdXRpb25zIGZvciBjaGFsbGVuZ2VzIGluIGpvdXJuYWxpc20uIFVzaW5nIG1ldGhvZCBjYXJkcyBhbmQgY2FudmFzIHRoZXkgYWltIHRvIGd1aWRlIGpvdXJuYWxpc3RzLCBjb2RlcnMgYW5kIGRlc2lnbmVycyB0byBidWlsZCBuZXcgcHJvZHVjdHMgaW4gMiw1IGRheXMuIEhhY2thc3RvcnkgdXNlcyBwcmluY2lwbGVzIGZyb20gZGVzaWduIHRoaW5raW5nIGFuZCBhZ2lsZSBwcm9qZWN0IGRldmVsb3BtZW50IGFuZCBhcHBsaWVzIHRoZW0gdG8gam91cm5hbGlzbTpcclxuPGJsb2NrcXVvdGU+XHUyMDFjRHVyaW5nIHRoZSBoYWNrYXRob25zIGFuZCB3b3Jrc2hvcHMgd2Ugb2JzZXJ2ZSBvdXIgcGFydGljaXBhbnRzLiBBZnRlcndhcmRzIHdlIGludGVydmlldyBhIGNvdXBsZSBvZiB0aGVtIHRvIGxlYXJuIGZyb20gdGhlaXIgZXhwZXJpZW5jZXMuIEFuZCB3ZSBkbyBpdCBhZ2FpbiBhZnRlciBhIGZldyBtb250aHMgdG8gdHJhY2sgb3VyIGltcGFjdC4gV2UgdHJ1bHkgYmVsaWV2ZSB5b3UgaGF2ZSB0byBmb2N1cyBvbiB0aGUgdXNlci4gSXQgaXMgd2hhdCB3ZSBwcmVhY2ggd2hpbGUgZGV2ZWxvcGluZyBuZXcgZGlnaXRhbCBwcm9qZWN0cyB3aXRoIG91ciBjbGllbnRzOiBhdWRpZW5jZSBmaXJzdC5cdTIwMWQ8L2Jsb2NrcXVvdGU+XHJcbkNvb3BlcmF0aW9uIGJldHdlZW4gam91cm5hbGlzdHMgYW5kIGNvZGVycyBpcyBub3QgYWx3YXlzIGVhc3kgdG8gYWNoaWV2ZSwgYnV0IHRoZSBiYXNpY3MgYXJlIHNpbXBsZSwgYWNjb3JkaW5nIHRvIEFsYmVydGluZTogXHUyMDFjYmUgY3VyaW91cyBhbmQgaGF2ZSBmdW4uIFR3byB0aGluZ3MgLSBpZiB5b3UgYXNrIG1lIC0gam91cm5hbGlzdHMgYXJlIGdvb2QgYXQuXHUyMDFkXHJcbjxoMz5FbmNvdXJhZ2luZyB0ZWNobm9sb2d5IHVzZTwvaDM+XHJcbkJ1dCBIYWNrYXN0b3J5IGlzIG5vdCBvbmx5IGFib3V0IG9yZ2FuaXNpbmcgSGFja2F0aG9ucy4gVGhleSBhbHNvIGNyZWF0ZWQgPGEgaHJlZj1cImh0dHBzOi8vZGlnaXRhbHN0b3J5LnRvb2xzL1wiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyIG5vcmVmZXJyZXJcIj5EaWdpdGFsU3RvcnkuVG9vbHM8L2E+LCB3aGVyZSB0aGV5IGNvbGxlY3QgdGhlIHRvb2xzIEFsYmVydGluZSBhbmQgaGVyIHRlYW0gbGlrZSB0byB3b3JrIHdpdGggdGhlbXNlbHZlcy4gSW4gdGhlIGZpcnN0IDEwIHdlZWtzIGFmdGVyIGxhdW5jaCB0aGV5IGhhZCAyNS4wMDAgdmlld3MgZnJvbSBkb3plbnMgb2YgY291bnRyaWVzIGFuZCBhZnRlciA5IG1vbnRocyB0aGV5IHJlYWNoZWQgMTAwLjAwMCB2aWV3cyBmcm9tIDE1MCBjb3VudHJpZXMgYXJvdW5kIHRoZSB3b3JsZC4gQWxiZXJ0aW5lIGV4cGxhaW5zIHdoeSB0aGlzIGlzIHN1Y2ggYW4gaW1wb3J0YW50IHNpZ25hbDpcclxuPGJsb2NrcXVvdGU+XHUyMDFjVGhlIGludGVybmV0IGlzIGEgcG93ZXJmdWwgdG9vbCBpbiB0aGUgaGFuZHMgb2Ygam91cm5hbGlzdHMuIFdlYiB0ZWNobm9sb2d5IGFuZCB0aGUgcG9zc2liaWxpdGllcyBvZiBvbmxpbmUgc3Rvcnl0ZWxsaW5nIGFyZSBtb3JlIGltcG9ydGFudCB0aGFuIGV2ZXIgYmVmb3JlIHRvIGJlIGVtYnJhY2VkIGJ5IG5ld3MgbWVkaWEuIEl0XHUyMDE5cyBjcnVjaWFsIGZvciBqb3VybmFsaXN0cyB0byBzdGF5IGluZmx1ZW50aWFsIGluIHRoaXMgZGlnaXRhbCBlcmEuIEFuZCAtIHdlXHUyMDE5cmUgcmVhbGlzdGljIC0gdGhlIG1ham9yaXR5IG9mIG1lZGlhIGNvbXBhbmllcyBkb25cdTIwMTl0IGhhdmUgYSBuZXdzcm9vbSBkZXZlbG9wZXIuIEx1Y2tpbHksIGpvdXJuYWxpc3RzIGNhbiBhY2NvbXBsaXNoIGEgbG90IHdpdGggdG9vbHMuXHUyMDFkPC9ibG9ja3F1b3RlPlxyXG48aDM+Sm91cm5hbGlzdHMgYW5kIGlubm92YXRpb248L2gzPlxyXG48YmxvY2txdW90ZT5cdTIwMWNKb3VybmFsaXN0cyByZXNwb25kIHJlYWxseSBxdWlja2x5IHRvIGJyZWFraW5nIG5ld3MuIElmIHNvbWV0aGluZyBoYXBwZW5zIG9uIERhbSBTcXVhcmUgaGVyZSBpbiBBbXN0ZXJkYW0sIHdlXHUyMDE5bGwgYmUgbGl2ZSByZXBvcnRpbmcgb24gdGhhdCB3aXRoaW4gdGhlIGhvdXIuIEhvd2V2ZXIsIHdlIGRvblx1MjAxOXQgcmVzcG9uZCBhcyBhZGVxdWF0ZWx5IHRvIGlubm92YXRpb24uXHUyMDFkPC9ibG9ja3F1b3RlPlxyXG5BbGJlcnRpbmUgZmVlbHMgdGhpcyBpcyBwYXJ0aWFsbHkgZHVlIHRvIGpvdXJuYWxpc3RzXHUyMDE5IGNyaXRpY2FsIGF0dGl0dWRlLiBUaGV5IG5lZWQgdGhpcyB0byBnZXQgdG8gdGhlIGJvdHRvbSBvZiBhIHN0b3J5LCB0byByZXBvcnQgbW9yZSBwcm9mb3VuZGx5IG9uIGV2ZW50cyB0aGFuIHNpbXBseSBjb3B5aW5nIGEgcHJlc3MgcmVsZWFzZS4gSG93ZXZlciwgc2hlIGFsc28gc2VlcyB0aGlzIGNyaXRpY2FsIGF0dGl0dWRlIGR1cmluZyB0aGVpciBIYWNrYXRob25zLCB3aGVyZSBpdCBpcyBkb2luZyBtb3JlIGhhcm0gdGhhbiBnb29kOlxyXG48YmxvY2txdW90ZT5cdTIwMWNKb3VybmFsaXN0cyBhcmUgdmVyeSBrbm93bGVkZ2VhYmxlIGFuZCB0aGV5IGJyaW5nIHRoaXMga25vd2xlZGdlIGludG8gdGhlIGJyYWluc3Rvcm0gc2Vzc2lvbnMuIFRoZXkgYXJlIGV4dHJlbWVseSBjcml0aWNhbC4gVGhpcyBsZWFkcyB0aGVtIHRvIHNvbWV0aW1lcyBjcnVzaCBhIHNlZWQgYmVmb3JlIGl0IGhhcyBldmVuIGhhZCBhIGNoYW5jZSB0byBiZSBwbGFudGVkLlx1MjAxZDwvYmxvY2txdW90ZT5cclxuPGgzPkxlYXJuaW5nIHRvIGRhbmNlIHRvZ2V0aGVyPC9oMz5cclxuS2V5IHRvIGlubm92YXRpb24gaXMgZGl2ZXJzaXR5LiBBbmQgd2hpbGUgdGhlcmVcdTIwMTlzIGluY3JlYXNpbmcgYXR0ZW50aW9uIGZvciBkaXZlcnNpdHkgaW4gbmV3c3Jvb21zIGluIHRlcm1zIG9mIGV0aG5pYywgY3VsdHVyYWwgYW5kIHJlbGlnaW91cyBiYWNrZ3JvdW5kcywgdGhlIG5lZWQgZm9yIGRpdmVyc2l0eSBpbiBwcm9mZXNzaW9uYWwgYmFja2dyb3VuZHMgcmVtYWlucyB1bmRlci1leHBvc2VkOlxyXG48YmxvY2txdW90ZT5cdTIwMWNBcm91bmQgdGhlIHdvcmxkLCBqb3VybmFsaXN0cyBhcmUgc3RpbGwgYSByZWxhdGl2ZWx5IGhvbW9nZW5vdXMgZ3JvdXAuIFRoaXMgbGVhdmVzIG1hbnkgcG9zc2liaWxpdGllcyB1bnRhcHBlZC4gVGhlIGxhY2sgb2YgY29sbGFib3JhdGlvbiBiZXR3ZWVuIGpvdXJuYWxpc3RzIGFuZCBkZXZlbG9wZXJzIGlzIGxpa2UgZGFuY2luZyBhbG9uZSxcdTIwMWQgc2F5cyBBbGJlcnRpbmUuPC9ibG9ja3F1b3RlPlxyXG5JbiB0aGVpciBIYWNrYXRob25zLCBIYWNrYXN0b3J5IGFpbXMgZm9yIGdyb3VwcyB0aGF0IGFyZSA1MCUgam91cm5hbGlzdHMgYW5kIDUwJSBkZXZlbG9wZXJzLiBUaGUgY3J1eCBzZWVtcyB0byBiZSBpbiBnaXZpbmcgam91cm5hbGlzdHMgdGhlIGNvbmZpZGVuY2UgdGhhdCB0aGV5IGhhdmUgc29tZXRoaW5nIHZhbHVhYmxlIHRvIGNvbnRyaWJ1dGUgdG8gdGhlIGlubm92YXRpb24gcHJvY2VzcyBhcyB3ZWxsOlxyXG48YmxvY2txdW90ZT5cdTIwMWNBIGpvdXJuYWxpc3QgcGFydGljaXBhbnQgcmVjZW50bHkgdG9sZCBtZSBzaGUgaGFkIGJlbGlldmVkIHVudGlsIHRoYXQgbW9tZW50IHRoYXQgZGV2ZWxvcGVycyB3ZXJlIHBhcnQgb2Ygc29tZSBwYXJhbGxlbCB1bml2ZXJzZSB3aXRoIGEgdmVyeSBzcGVjaWFsIGtpbmQgb2YgZXhwZXJ0aXNlLiBEdXJpbmcgdGhlIEhhY2thdGhvbiBzaGUgZGlzY292ZXJlZCB0aGF0IGRldmVsb3BlcnMgZG8gbm90IGtub3cgZXZlcnl0aGluZyBlaXRoZXIuIEFuZCBzaGUsIGFzIGEgam91cm5hbGlzdCwgYWN0dWFsbHkgaGFkIHNvbWV0aGluZyB0byBjb250cmlidXRlIHRvIHRoZSBjb252ZXJzYXRpb24gb3RoZXIgdGhhbiBnZXR0aW5nIGNvZmZlZSB3aGlsZSB0aGUgdGVjaG5pY2lhbnMgd2VyZSBkb2luZyB0aGUgd29yay5cdTIwMWQ8L2Jsb2NrcXVvdGU+XHJcbjxoMz5QdXR0aW5nIHRoaW5ncyBpbnRvIHBlcnNwZWN0aXZlPC9oMz5cclxuSXQgaGFzIGJlZW4gYSB5ZWFyIHNpbmNlIEFsYmVydGluZSBzdG9wcGVkIHdvcmtpbmcgZnVsbHRpbWUgYXMgYSBqb3VybmFsaXN0LCBidXQgc2hlIGZlZWxzIGdyZWF0IGFib3V0IGhhdmluZyBtb3JlIHRpbWUgdG8gdGhpbmsgYWJvdXQgdGhlIGZ1dHVyZSBvZiBqb3VybmFsaXNtIHRocm91Z2ggSGFja2FzdG9yeTpcclxuPGJsb2NrcXVvdGU+XHUyMDFjSSByZWFsbHkgbWlzc2VkIHRoaXMgd2hpbGUgd29ya2luZyBpbiB0aGUgbmV3c3Jvb20uIEpvdXJuYWxpc3RzIGFyZSBleHRyZW1lbHkgYnVzeSBhbmQgYXJlIHdvcmtpbmcgaW5jcmVkaWJseSBoYXJkIGZvciB2ZXJ5IGxpdHRsZSBtb25leS4gVGhlcmVcdTIwMTlzIG5vIHRpbWUgdG8gdGhpbmsgYWJvdXQgd2hldGhlciB3ZVx1MjAxOXJlIGFjdHVhbGx5IHJ1bm5pbmcgdGhpcyBoYXJkIGluIHRoZSByaWdodCBkaXJlY3Rpb24uXHUyMDFkPC9ibG9ja3F1b3RlPlxyXG5BdCBldmVudHMgc2hlIG9mdGVuIGhlYXJzIGhvdyBmYW1pbGlhciB0aGlzIGlzIGZvciBqb3VybmFsaXN0cywgYnV0IGl0IHdvdWxkIGJlbmVmaXQgZnJvbSBiZWluZyBzaGFyZWQgbW9yZSBvZnRlbi4gTm9uZXRoZWxlc3MsIGl0IG9ubHkgdG9vayBUaGUgR3VhcmRpYW4gYSBmZXcgd2Vla3MgdG8gcmVhY2ggb3V0IHRvIGhlciBhZnRlciB0aGUgZmlyc3QgSGFja2F0aG9uIHdpdGggYSByZXF1ZXN0IHRvIG9yZ2FuaXNlIHNvbWV0aGluZyBzaW1pbGFyIGZvciB0aGVtLiBIYWNrYXN0b3J5IGhhcyBvcmdhbmlzZWQgMTEgSGFja2F0aG9ucyBzbyBmYXIgZm9yIGRpZmZlcmVudCBsZWdhY3kgbWVkaWEgd29ybGR3aWRlIGFuZCB1bml2ZXJzaXRpZXMuXHJcblxyXG5DT05UQUNUIFBPSU5UXHJcblxyXG48aW1nIGNsYXNzPVwiYWxpZ25ub25lIHdwLWltYWdlLTExMjAwIHNpemUtZnVsbFwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE3LzA5LzNiNjhkNzAtZTE1MDU4MzM3NTY0NTIuanBnXCIgYWx0PVwiXCIgd2lkdGg9XCIxNTBcIiBoZWlnaHQ9XCIxOTlcIiAvPlxyXG5cclxuQWxiZXJ0aW5lIFBpZWxzLCBGb3VuZGVyLCBIYWNrYXN0b3J5XHJcbldlYjpcdTAwYTA8YSBocmVmPVwiaHR0cHM6Ly9oYWNrYXN0b3J5LmNvbS9cIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lciBub3JlZmVycmVyXCI+aHR0cHM6Ly9oYWNrYXN0b3J5LmNvbS88L2E+XHJcblR3aXR0ZXI6IDxhIGhyZWY9XCJodHRwczovL3R3aXR0ZXIuY29tL0FsYmVydGluZVBpZWxzXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXIgbm9yZWZlcnJlclwiPkBBbGJlcnRpbmVQaWVsczwvYT5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMi8zXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48aDM+QXV0aG9yPC9oMz5cclxuW3NpbXBsZS1hdXRob3ItYm94XVsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XSIsInBvc3RfdGl0bGUiOiJIYWNrYXN0b3J5OiB0ZWFjaGluZyBjb2RlcnMgYW5kIGpvdXJuYWxpc3RzIGhvdyB0byBjb2xsYWJvcmF0ZSIsInBvc3RfbGluayI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9oYWNrYXN0b3J5LXRlYWNoaW5nLWNvZGVycy1qb3VybmFsaXN0cy1jb2xsYWJvcmF0ZS8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJIYWNrYXN0b3J5OiB0ZWFjaGluZyBjb2RlcnMgYW5kIGpvdXJuYWxpc3RzIGhvdyB0byBjb2xsYWJvcmF0ZVwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMTY1XCIgc3JjPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTcvMDkvSGFja2FzdG9yeS13b3Jrc2hvcC1hdC1UaGUtTmV4dC1XZWItQ29uZmVyZW5jZS1lMTUwNTgzMzIxMTk3OS0zMDB4MTY1LnBuZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6Iklubm92YXRpb24gQ2FzZSwgTWVkaWEgbGFicyIsInBvc3RfdGFncyI6ImNvZGluZywgZGVzaWduIHRoaW5raW5nLCBleHRlcm5hbCBsYWIsIEhhY2thdGhvbiwgTmV0aGVybGFuZHMiLCIlX3ZjX3Bvc3Rfc2V0dGluZ3MlIjp7InZjX2dyaWRfaWQiOltdfSwiJV9lZGl0X2xvY2slIjoiMTUyNzAwMTgwODoxMDEiLCIlX2VkaXRfbGFzdCUiOiIxMDEiLCIlc2xpZGVfdGVtcGxhdGUlIjoiZGVmYXVsdCIsIiVfd3BiX3ZjX2pzX3N0YXR1cyUiOiJ0cnVlIiwiJV9rbGVvX3RyYW5zcGFyZW50X21lbnVfY29sb3IlIjoid2hpdGUiLCIlX2tsZW9fdGl0bGVfY29sb3IlIjoiIyIsIiVfa2xlb190aXRsZV9iZyUiOiIsIHJlcGVhdCwgaW5oZXJpdCwgc2Nyb2xsLCBsZWZ0IHRvcCIsIiVfa2xlb190aXRsZV9iZ19jb2xvciUiOiIjIiwiJV95b2FzdF93cHNlb19jb250ZW50X3Njb3JlJSI6IjkwIiwiJV95b2FzdF93cHNlb19wcmltYXJ5X2NhdGVnb3J5JSI6IjE0MiIsIiVfa2xlb190aXRsZV9jaGVja2JveCUiOiIxIiwiJV90aHVtYm5haWxfaWQlIjoiMTExOTkiLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza3dfdGV4dF9pbnB1dCUiOiJIYWNrYXN0b3J5IiwiJV95b2FzdF93cHNlb19mb2N1c2t3JSI6IkhhY2thc3RvcnkiLCIlX3lvYXN0X3dwc2VvX2xpbmtkZXglIjoiNjgiLCIlX3dwZ21wX2xvY2F0aW9uX2FkZHJlc3MlIjoiTmV0aGVybGFuZHMiLCIlX3dwZ21wX21ldGFib3hfbGF0aXR1ZGUlIjoiNTIuMTMyNjMzMDAwMDAwMDEiLCIlX3dwZ21wX21ldGFib3hfbG9uZ2l0dWRlJSI6IjUuMjkxMjY1OTk5OTk5OTUwNSIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJwb3N0IiwiJV93cGdtcF9tZXRhYm94X2N1c3RvbV9saW5rJSI6IiIsIiVfd3BnbXBfbWFwX2lkJSI6ImE6MTp7aTowO3M6MTpcIjJcIjt9IiwiJV93cGdtcF9tZXRhYm94X21hcmtlcl9pZCUiOiJOOyIsIiVfd3BnbXBfbWV0YWJveF90YXhvbW9taWVzX3Rlcm1zJSI6Ik47IiwiJV93cGdtcF9leHRlbnNpb25zX2ZpZWxkcyUiOiJOOyIsIiVfamV0cGFja19yZWxhdGVkX3Bvc3RzX2NhY2hlJSI6eyI2MjM5M2IyNDJjN2E1NjE3NzRmOGViZmY1YzFjMDU2NSI6eyJleHBpcmVzIjoxNTQ1Mjg1NTc3LCJwYXlsb2FkIjpbeyJpZCI6MTE3NjV9LHsiaWQiOjEwNzY2fSx7ImlkIjoxMTAzMn1dfX0sIiVzYmdfc2VsZWN0ZWRfc2lkZWJhciUiOiIwIiwiJXNiZ19zZWxlY3RlZF9zaWRlYmFyX3JlcGxhY2VtZW50JSI6IjAiLCJ0YXhvbm9teT1jYXRlZ29yeSI6Iklubm92YXRpb24gQ2FzZSwgTWVkaWEgbGFicyIsInRheG9ub215PXBvc3RfdGFnIjoiY29kaW5nLCBkZXNpZ24gdGhpbmtpbmcsIGV4dGVybmFsIGxhYiwgSGFja2F0aG9uLCBOZXRoZXJsYW5kcyJ9LCJpY29uIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3Mvd3AtY29udGVudC91cGxvYWRzLzIwMTgvMDIvbWFya2VyLTEucG5nIn0sImlkIjoxMTE5NSwiaW5mb3dpbmRvd19kaXNhYmxlIjpmYWxzZX0seyJzb3VyY2UiOiJwb3N0IiwidGl0bGUiOiJJblZJRCA6IHZpZGVvIHZlcmlmaWNhdGlvbiBwcm9qZWN0IGludm9sdmluZyBkZXZlbG9wZXJzLCBhY2FkZW1pY3MgYW5kIGpvdXJuYWxpc3RzIiwiaW5mb3dpbmRvd19jb250ZW50IjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZ1wiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJJblZJRCA6IHZpZGVvIHZlcmlmaWNhdGlvbiBwcm9qZWN0IGludm9sdmluZyBkZXZlbG9wZXJzLCBhY2FkZW1pY3MgYW5kIGpvdXJuYWxpc3RzXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIxNDJcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxNy8wOS9wb3N0NDEtMzAweDE0Mi5wbmdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1wYWRkaW5nLWNvbnRlbnRfMjBcIj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1tZXRhIGZjLWl0ZW0tc2Vjb25kYXJ5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2UgZmMtdGV4dC1jZW50ZXJcIj5Jbm5vdmF0aW9uIENhc2UsIE1lZGlhIGxhYnM8L2Rpdj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS10aXRsZSBmYy1pdGVtLXByaW1hcnktdGV4dC1jb2xvciBmYy10ZXh0LWNlbnRlclwiPkluVklEIDogdmlkZW8gdmVyaWZpY2F0aW9uIHByb2plY3QgaW52b2x2aW5nIGRldmVsb3BlcnMsIGFjYWRlbWljcyBhbmQgam91cm5hbGlzdHM8L2Rpdj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1jb250ZW50IGZjLWl0ZW0tYm9keS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+XHJcbiAgICAgICAgICAgIFNob3J0IGZvciBcdTIwMThJbiB2aWRlbyB2ZXJpdGFzXHUyMDE5IChpbiB2aWRlbywgdGhlcmUgaXMgdHJ1dGgpLCBJblZJRCBpcyBjcmVhdGluZyBhIHBsYXRmb3JtIHRoYXQgYWxsb3dzIGpvdXJuYWxpc3RzIHRvIHZlcmlmeSB2aWRlbyBjb250ZW50IGZyb20gc29jaWFsIG5ldHdvcmtzIG1vcmUgZWFzaWx5LlxyXG4gICAgICAgIDwvZGl2PlxyXG48YSBocmVmPVwiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL2ludmlkLXZpZGVvLXZlcmlmaWNhdGlvbi1wcm9qZWN0LWludm9sdmluZy1kZXZlbG9wZXJzLWFjYWRlbWljcy1qb3VybmFsaXN0cy9cIj5SZWFkIG1vcmU8L2E+XHJcbiAgICA8L2Rpdj5cclxuICAgIDwvZGl2PlxyXG48L2Rpdj5cclxuXHJcbiIsImNvbnRlbnQiOiJTaG9ydCBmb3IgXHUyMDE4SW4gdmlkZW8gdmVyaXRhc1x1MjAxOSAoaW4gdmlkZW8sIHRoZXJlIGlzIHRydXRoKSwgSW5WSUQgaXMgY3JlYXRpbmcgYSBwbGF0Zm9ybSB0aGF0IGFsbG93cyBqb3VybmFsaXN0cyB0byB2ZXJpZnkgdmlkZW8gY29udGVudCBmcm9tIHNvY2lhbCBuZXR3b3JrcyBtb3JlIGVhc2lseS4iLCJhZGRyZXNzIjoiVGhlcm1pLCA1NzAgMDEsIFRoZXNzYWxvbmlraSwgR3JlZWNlIiwibG9jYXRpb24iOnsibGF0IjoiNDAuNTQ4NTIwMSIsImxuZyI6IjIzLjAxOTY0NTk5OTk5OTk2NiIsIm9uY2xpY2tfYWN0aW9uIjoicG9zdCIsInJlZGlyZWN0X3Blcm1hbGluayI6Imh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9pbnZpZC12aWRlby12ZXJpZmljYXRpb24tcHJvamVjdC1pbnZvbHZpbmctZGV2ZWxvcGVycy1hY2FkZW1pY3Mtam91cm5hbGlzdHMvIiwiem9vbSI6MiwiZXh0cmFfZmllbGRzIjp7InBvc3RfZXhjZXJwdCI6IlNob3J0IGZvciBcdTIwMThJbiB2aWRlbyB2ZXJpdGFzXHUyMDE5IChpbiB2aWRlbywgdGhlcmUgaXMgdHJ1dGgpLCBJblZJRCBpcyBjcmVhdGluZyBhIHBsYXRmb3JtIHRoYXQgYWxsb3dzIGpvdXJuYWxpc3RzIHRvIHZlcmlmeSB2aWRlbyBjb250ZW50IGZyb20gc29jaWFsIG5ldHdvcmtzIG1vcmUgZWFzaWx5LiIsInBvc3RfY29udGVudCI6Ilt2Y19yb3ddW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIyLzNcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxoMT5JblZJRCA6IHZpZGVvIHZlcmlmaWNhdGlvbiBwcm9qZWN0IGludm9sdmluZyBkZXZlbG9wZXJzLCBhY2FkZW1pY3MgYW5kIGpvdXJuYWxpc3RzPC9oMT5cclxuPHN0cm9uZz5TaG9ydCBmb3IgXHUyMDE4SW4gdmlkZW8gdmVyaXRhc1x1MjAxOSAoaW4gdmlkZW8sIHRoZXJlIGlzIHRydXRoKSwgSW5WSUQgaXMgY3JlYXRpbmcgYSBwbGF0Zm9ybSB0aGF0IGFsbG93cyBqb3VybmFsaXN0cyB0byB2ZXJpZnkgdmlkZW8gY29udGVudCBmcm9tIHNvY2lhbCBuZXR3b3JrcyBtb3JlIGVhc2lseS48L3N0cm9uZz5cclxuXHJcblRoZSBFVSBIb3Jpem9uMjAyMCBmdW5kZWQgSW5WSUQgcHJvamVjdCBlbWJhcmtlZCBvbiBhIG1pc3Npb24gdG8gY3JlYXRlIGEgcGxhdGZvcm0gdG8gZGV0ZWN0LCBhdXRoZW50aWNhdGUgYW5kIGNoZWNrIHRoZSByZWxpYWJpbGl0eSBhbmQgYWNjdXJhY3kgb2YgbmV3c3dvcnRoeSB2aWRlbyBmaWxlcyBhbmQgdmlkZW8gY29udGVudCBzcHJlYWQgdmlhIHNvY2lhbCBtZWRpYS4gQWx0aG91Z2ggbWFueSBpbml0aWF0aXZlcyBoYXZlIHNpbmNlIGJlZW4gZGV2ZWxvcGVkIHRvIGZpZ2h0IGZha2UgbmV3cywgZmV3IG9mIHRoZW0gaGF2ZSBvZmZlcmVkIHNvbHV0aW9ucyBmb3IgdmlkZW8gc3BlY2lmaWNhbGx5OlxyXG48YmxvY2txdW90ZT5cdTIwMWNPbmUgb2YgdGhlIG1vc3QgaW50ZXJlc3RpbmcgdGhpbmdzIHRoYXQgaGFzIGhhcHBlbmVkIGluIGluZm9ybWF0aW9uIGFuZCBjb21tdW5pY2F0aW9uIGluIHRoZSBsYXN0IDE1IHllYXJzIGlzIHRoZSByaXNlIG9mIHVzZXIgZ2VuZXJhdGVkIGNvbnRlbnQgKHBob3RvcywgdmlkZW9zIGV0Yy4pLFx1MjAxZCBzYXlzIERlbmlzIFRleXNzb3UsIEluVklEXHUyMDE5cyBpbm5vdmF0aW9uIG1hbmFnZXIgYW5kIGhlYWQgb2YgPGEgaHJlZj1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9hZnAtbWVkaWFsYWIvXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXIgbm9yZWZlcnJlclwiPkFGUCBNZWRpYWxhYjwvYT4sIHdob1x1MjAxOXMgb25lIG9mIHRoZSBjb25zb3J0aXVtIHBhcnRuZXJzLiBcdTIwMWNUaGlzIGFsc28gY29tZXMgd2l0aCB0aGUgZGlmZmljdWx0eSBvZiB2ZXJpZnlpbmcgdGhpcyBjb250ZW50IGNyZWF0ZWQgYnkgdGhlIGF1ZGllbmNlLlx1MjAxZDwvYmxvY2txdW90ZT5cclxuSW4gYW4gYXR0ZW1wdCB0byBzb2x2ZSB0aGlzIGNoYWxsZW5nZSwgdGhlIEluVklEIHBsYXRmb3JtIGZvY3VzZXMgb24gZGlnaXRhbCBmaWxlcyBhcyB3ZWxsIGFzIGNvbnRleHR1YWwgYW5kIHVzZXIgcmlnaHRzIHZlcmlmaWNhdGlvbnMgb2YgdXNlci1nZW5lcmF0ZWQgdmlkZW8gb24gc29jaWFsIG5ldHdvcmtzLiBJblZJRCBzdGFydGVkIGluIEphbnVhcnkgMjAxNiB3aXRoIGpvdXJuYWxpc20gcGFydG5lcnMgaW5jbHVkaW5nIERldXRzY2hlIFdlbGxlIGFuZCBBRlAuIEFGUCwgRGV1dHNjaGUgV2VsbGUgYW5kIHRoZSBDZW50ZXIgZm9yIFJlc2VhcmNoIGFuZCBUZWNobm9sb2d5IEhlbGxhcyBoYWQgYmVlbiBwYXJ0bmVycyBpbiBwcmV2aW91cyBFdXJvcGVhbiBwcm9qZWN0cyBhbmQgSW5WSUQgc3RhcnRlZCBmcm9tIHRoYXQ6XHJcbjxibG9ja3F1b3RlPlx1MjAxY1dlIGRpc2N1c3NlZCBhIG5ldyBjb2xsYWJvcmF0aW9uIGFyb3VuZCB2aWRlbyBhbmQgd2UgY2FtZSB1cCB3aXRoIHRoZSBpZGVhIG9mIHZlcmlmaWNhdGlvbiwgd2hpY2ggd2FzIGEgdmVyeSBpbnRlcmVzdGluZyBmaWVsZCBmb3IgcmVzZWFyY2ggYW5kIGRldmVsb3BtZW50LFx1MjAxZCBhZGRzIFRleXNzb3UuPC9ibG9ja3F1b3RlPlxyXG5UaGUgcHJvamVjdCBpcyBjb29yZGluYXRlZCBieSB0aGUgQ2VudGVyIGZvciBSZXNlYXJjaCBhbmQgVGVjaG5vbG9neSBIZWxsYXMuXHJcbjxoMz5UaGUgdmFsdWUgb2YgcGFydG5lcnNoaXBzPC9oMz5cclxuSW5WSUQgaXMgYWxzbyBhIHBhcnRuZXIgaW4gdGhlIEZpcnN0IERyYWZ0IE5ld3MgbmV0d29yaywgd2hpY2ggYWltcyB0byByYWlzZSBhd2FyZW5lc3MgYW5kIGFkZHJlc3MgY2hhbGxlbmdlcyByZWxhdGluZyB0byB0cnVzdCBhbmQgdHJ1dGggaW4gdGhlIGRpZ2l0YWwgYWdlLiBUb2dldGhlciB3aXRoIGl0cyBwYXJ0bmVycywgRmlyc3QgRHJhZnQgTmV3cyBpcyB0YWNrbGluZyBjb21tb24gaXNzdWVzLCBpbmNsdWRpbmcgd2F5cyB0byBzdHJlYW1saW5lIHRoZSB2ZXJpZmljYXRpb24gcHJvY2VzcywgaW1wcm92ZSB0aGUgZXhwZXJpZW5jZSBvZiBleWV3aXRuZXNzZXMgYW5kIGluY3JlYXNlIG5ld3MgbGl0ZXJhY3kuXHJcblxyXG5UaHJvdWdoIHRoaXMgcGFydG5lcnNoaXAsIEluVklEIEZyZW5jaCBwYXJ0bmVyIEFGUCBoYXMgYmVlbiBpbnZvbHZlZCBpbiBDcm9zc0NoZWNrLCBhIGNvbGxlY3RpdmUgZWZmb3J0IG9mIEV1cm9wZWFuIG5ld3Nyb29tcyB0byBmYWN0LWNoZWNrIG5ld3MgaW4gbGlnaHQgb2YgRnJlbmNoIHByZXNpZGVudGlhbCBlbGVjdGlvbiBpbiB0aGUgc3ByaW5nIG9mIDIwMTcuIEJlaW5nIGEgY29yZSBwYXJ0bmVyIG9mIEZpcnN0IERyYWZ0IE5ld3MgbmV0d29yayB3YXMgYSBrZXkgYXNzZXQgZm9yIEluVklEIGJlY2F1c2UgaXQgYWxsb3dlZCB1cyB0byBsZWFybiBmcm9tIHRoZSBcdTIwMWN2ZXJpZmljYXRpb24gY29tbXVuaXR5XHUyMDFkIGFuZCB0byByZWFjaCB0aGUgY29tbXVuaXR5IG1lbWJlcnMgdG8gc3ByZWFkIHRoZSB0b29scyB3ZSBhcmUgZGV2ZWxvcGluZy5cclxuXHJcblVzaW5nIGEgZGVzaWduIHRoaW5raW5nIG1ldGhvZG9sb2d5LCB3ZSBwYXJ0aWNpcGF0ZWQgYW5kIG9ic2VydmVkIHRoZSBDcm9zc0NoZWNrIGluaXRpYXRpdmUgYW5kIGNvbmNlaXZlZCB0aGUgSW5WSUQgcGx1Z2luIGR1cmluZyB0aGF0IHByb2Nlc3MsIGFzIGEga2luZCBvZiBcdTIwMWNTd2lzcyBhcm15IGtuaWZlXHUyMDFkIG9mZmVyaW5nIGpvdXJuYWxpc3RzIHNldmVyYWwgdG9vbHMgdG8gZWFzZSBhbmQgc3BlZWQgdXAgdGhlaXIgdmVyaWZpY2F0aW9uIHByb2Nlc3Nlcy5cclxuPGgzPkNoYWxsZW5nZXM8L2gzPlxyXG5UaGVyZSB3ZXJlIHNvbWUgY2hhbGxlbmdlcyB0aGUgSW5WSUQgdGVhbSBpcyBmYWNpbmcsIGFjY29yZGluZyB0byBUZXlzc291LiBGaXJzdCwgZmFrZSBuZXdzIHNwcmVhZHMgcXVpY2tseSBmcm9tIHBsYXRmb3JtIHRvIHBsYXRmb3JtLiBBbmQgd2hpbGUgc29tZSBwbGF0Zm9ybXMgaGF2ZSBvcGVuIEFQSXMgYW5kIGFsbG93IGFkdmFuY2VkIHNlYXJjaCwgb3RoZXJzIGFyZSBjbG9zZWQsIHdoaWNoIG1ha2VzIHZlcmlmaWNhdGlvbiBtb3JlIGRpZmZpY3VsdC4gRmluYWxseSwgbW9zdCBzb2NpYWwgbmV0d29ya3MgZXJhc2UgdGhlIG9yaWdpbmFsIG1ldGFkYXRhIG9mIG11bHRpbWVkaWEgY29udGVudC5cclxuXHJcbkluIGFkZGl0aW9uLCBtYW5hZ2luZyBhIG11bHRpZGlzY2lwbGluYXJ5IHByb2plY3QgYmV0d2VlbiBkaWZmZXJlbnQgY3VsdHVyZXMgY2FuIGJlIGNvbXBsaWNhdGVkIGF0IHRpbWVzLCBhbHRob3VnaCBUZXlzc291IGVtcGhhc2lzZXMgdGhlIGJlbmVmaXRzIG9mIHN1Y2ggY29sbGFib3JhdGlvbi4gVGhlc2UgaW5jbHVkZSByZWFjaGluZyBhbiBpbnRlcm5hdGlvbmFsIG1hcmtldCBvciBjb21tdW5pdHksIGV4cGFuZGVkIGFjY2VzcyB0byBrbm93bGVkZ2UgZnJvbSB0aGUgc2NpZW50aWZpYyBjb21tdW5pdHksIGFuZCBzdGVwcGluZyBvdXQgb2YgeW91ciBjb21mb3J0IHpvbmUgZW5jb3VyYWdlcyB5b3UgdG8gc3RhcnQgdGhpbmtpbmcgb3V0IG9mIHRoZSBib3guXHJcbjxibG9ja3F1b3RlPlwiQmFzaWNhbGx5LCBzY2llbnRpc3RzIGRvIHNjaWVuY2UsIGVuZ2luZWVycyB3b3JrIG9uIGludGVncmF0aW9uIGFuZCBBUElzLCBhbmQgam91cm5hbGlzdHMgd29yayBvbiB1c2VyIHJlcXVpcmVtZW50cywgdGVzdHMsIGV2YWx1YXRpb24sIGFuZCBkaXNzZW1pbmF0aW9uLFwiIFRleXNzb3UgZXhwbGFpbnMuIFwiQW5kIHJlZ3VsYXIgdGVsZWNvbmZlcmVuY2VzLCB2aWRlb2NvbmZlcmVuY2VzLCB3b3JraW5nIG9ubGluZSBhbmQgc2hhcmluZyBkb2N1bWVudHMsIGFuZCBBcHBsaWNhdGlvbiBQcm9ncmFtbWluZyBJbnRlcmZhY2VzIChBUElzKSBoZWxwZWQgYnJpZGdlIHRoZSBnZW9ncmFwaGljYWwgZ2FwIGJldHdlZW4gdGhlIHBhcnRuZXJzIGFuZCBlbmFibGVkIGNvbGxhYm9yYXRpb24gYWNyb3NzIHRoZXNlIHZhcmlvdXMgcHJvZmVzc2lvbmFsIGJhY2tncm91bmRzLlwiPC9ibG9ja3F1b3RlPlxyXG48aDM+T3BlbiBzb3VyY2UgYXBwbGljYXRpb248L2gzPlxyXG5JbiByZXNwb25zZSB0byB0aGUgZ3Jvd2luZyBhdHRlbnRpb24gZm9yIHRoZSBmYWtlIG5ld3MgcHJvYmxlbSwgSW5WSUQgcmVsZWFzZWQgYSBmcmVlIGJyb3dzZXIgcGx1Zy1pbiBpbiBKdWx5IHRvIGhlbHAgam91cm5hbGlzdHMgdmVyaWZ5IGltYWdlcyBhbmQgdmlkZW9zIGFuZCB0byBkZWJ1bmsgZmFrZSB2aWRlbyBuZXdzLiBBIGNvdXBsZSBvZiBtb250aHMgbGF0ZXIsIGl0IGhhZCBiZWVuIGRvd25sb2FkZWQgbW9yZSB0aGFuIDUwMCB0aW1lcyBhbmQgcmVjZWl2ZWQgPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vaS9tb21lbnRzLzg4ODQ5NTkxNTYxMDI3NTg0MFwiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyIG5vcmVmZXJyZXJcIj5nb29kIGZlZWRiYWNrPC9hPiBvbiBzb2NpYWwgbmV0d29ya3MuXHJcblxyXG5UaGUgcGx1Z2luIGlzIDxhIGhyZWY9XCJodHRwOi8vd3d3LmludmlkLXByb2plY3QuZXUvdG9vbHMtYW5kLXNlcnZpY2VzL2ludmlkLXZlcmlmaWNhdGlvbi1wbHVnaW4vXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXIgbm9yZWZlcnJlclwiPmF2YWlsYWJsZTwvYT4gZm9yIENocm9tZSBhbmQgRmlyZWZveCBhbmQgd2lsbCBiZSBtYWludGFpbmVkLCByZWZpbmVkIGFuZCBlbmhhbmNlZCB1bnRpbCB0aGUgZW5kIG9mIHRoZSBwcm9qZWN0IGluIGxhdGUgMjAxOC4gVGhlIHBsdWdpbiBjb2RlIGhhcyBiZWVuIHByb3ZpZGVkIGluIG9wZW4gc291cmNlIHVuZGVyIGEgTUlUIGxpY2Vuc2UuIE1ha2luZyB0aGUgdG9vbCBhcyB3aWRlbHkgYXZhaWxhYmxlIGFzIHBvc3NpYmxlIGFsbG93cyB0aGVtIHRvIGdldCBmZWVkYmFjayBmcm9tIHVzZXJzLCBzbyB0aGV5IGNhbiBjb250aW51ZSB0byBpbXByb3ZlIGl0OlxyXG48YmxvY2txdW90ZT5cdTIwMWNTbyBmYXIgd2UgZ290IHNvbWUgbmljZSBhbmQgZW5jb3VyYWdpbmcgY29tbWVudHMgZnJvbSB2ZXJpZmljYXRpb24gZXhwZXJ0cyBvbiBzb2NpYWwgbmV0d29ya3MsIGFuZCB3ZSBob3BlIHRvIGdldCB2YWx1YWJsZSBmZWVkYmFjayBmcm9tIHRoZSBjb21tdW5pdHkgdG8gZGV2ZWxvcCBtb3JlIHRvb2xzIGFuZCBpbXByb3ZlIHRoZSBleGlzdGluZyBvbmVzLFx1MjAxZCBzYXlzIFRleXNzb3UuPC9ibG9ja3F1b3RlPlxyXG5CeSBwYXN0aW5nIGEgVVJMIHRvIGEgWW91VHViZSBvciBGYWNlYm9vayB2aWRlbyBpbnRvIHRoZSB0b29sLCB0aGUgdXNlciBjYW4gYW5hbHlzZSBpdHMgb3JpZ2lucywgaW5jbHVkaW5nIHdoZW4gaXQgd2FzIHVwbG9hZGVkLCB0aGUgbG9jYXRpb25zIGZlYXR1cmVkIGFuZCB0aHVtYm5haWxzIHJldHJpZXZlZCBmcm9tIGRpZmZlcmVudCBzZWFyY2ggZW5naW5lcy4gVmFyaW91cyBvcHRpb25zIG1ha2UgY2xvc2VyIGluc3BlY3Rpb24gb2YgdGhlIHZpZGVvIHBvc3NpYmxlLCBzdWNoIGFzIGEgbWFnbmlmaWVyIGFuZCBhIHJldmVyc2UgaW1hZ2Ugc2VhcmNoIG9uIHNldmVyYWwgc2VhcmNoIGVuZ2luZXMuXHJcblxyXG5UaGUgSW5WSUQgdGVhbSBpcyBjdXJyZW50bHkgYWxzbyB3b3JraW5nIG9uIGEgcGxhdGZvcm0gd2hpY2ggaGVscHMgdXNlcnMgZGlzY292ZXIgbmV3c3dvcnRoeSB2aWRlb3MsIGFuZCBhIHdlYiBhcHBsaWNhdGlvbiB0aGF0IGhlbHBzIHZlcmlmeSB0aG9zZSB2aWRlb3MuXHJcbjxkaXYgc3R5bGU9XCJ0ZXh0LWFsaWduOiBjZW50ZXI7XCI+PGlmcmFtZSBzcmM9XCJodHRwczovL3d3dy55b3V0dWJlLmNvbS9lbWJlZC9ubWdiRk9EUGlCWVwiIHdpZHRoPVwiNTYwXCIgaGVpZ2h0PVwiMzE1XCIgZnJhbWVib3JkZXI9XCIwXCIgYWxsb3dmdWxsc2NyZWVuPVwiYWxsb3dmdWxsc2NyZWVuXCI+PC9pZnJhbWU+PC9kaXY+XHJcbkNPTlRBQ1QgUE9JTlRcclxuPGltZyBjbGFzcz1cImFsaWdubm9uZSB3cC1pbWFnZS0xMTE2NSBzaXplLWZ1bGxcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxNy8wOS9tZXphci0yNjU1NDQ2LXNtYWxsLWUxNTA0NjE4NTczMTkyLmdpZlwiIGFsdD1cIlwiIHdpZHRoPVwiMTUwXCIgaGVpZ2h0PVwiMjAwXCIgLz5cclxuRHIuIFZhc2lsZWlvcyBNZXphcmlzLCBJbmZvcm1hdGlvbiBUZWNobm9sb2dpZXMgSW5zdGl0dXRlIChJVEkpLCBQcm9qZWN0IENvb3JkaW5hdG9yIEluVklEXHJcbldlYjogPGEgaHJlZj1cImh0dHA6Ly93d3cuaW52aWQtcHJvamVjdC5ldS9cIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lciBub3JlZmVycmVyXCI+aHR0cDovL3d3dy5pbnZpZC1wcm9qZWN0LmV1LzwvYT5cclxuVHdpdHRlcjogPGEgaHJlZj1cImh0dHBzOi8vdHdpdHRlci5jb20vSW5WSURfRVVcIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lciBub3JlZmVycmVyXCI+QEluVklEX0VVPC9hPlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIyLzNcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxoMz5BdXRob3I8L2gzPlxyXG5bc2ltcGxlLWF1dGhvci1ib3hdWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddIiwicG9zdF90aXRsZSI6IkluVklEIDogdmlkZW8gdmVyaWZpY2F0aW9uIHByb2plY3QgaW52b2x2aW5nIGRldmVsb3BlcnMsIGFjYWRlbWljcyBhbmQgam91cm5hbGlzdHMiLCJwb3N0X2xpbmsiOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy9tZWRpYS1sYWIvaW52aWQtdmlkZW8tdmVyaWZpY2F0aW9uLXByb2plY3QtaW52b2x2aW5nLWRldmVsb3BlcnMtYWNhZGVtaWNzLWpvdXJuYWxpc3RzLyIsInBvc3RfZmVhdHVyZWRfaW1hZ2UiOiI8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIkluVklEIDogdmlkZW8gdmVyaWZpY2F0aW9uIHByb2plY3QgaW52b2x2aW5nIGRldmVsb3BlcnMsIGFjYWRlbWljcyBhbmQgam91cm5hbGlzdHNcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjE0MlwiIHNyYz1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDE3LzA5L3Bvc3Q0MS0zMDB4MTQyLnBuZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6Iklubm92YXRpb24gQ2FzZSwgTWVkaWEgbGFicyIsInBvc3RfdGFncyI6IkV1cm9wZSwgZmFjdC1jaGVja2luZywgaG9yaXpvbiAyMDIwLCBtdWx0aWRpc2NpcGxpbmFyeSwgdmVyaWZpY2F0aW9uLCB2aWRlbyIsIiVfdmNfcG9zdF9zZXR0aW5ncyUiOnsidmNfZ3JpZF9pZCI6W119LCIlX2VkaXRfbG9jayUiOiIxNTI3MDAxODYwOjEwMSIsIiVfZWRpdF9sYXN0JSI6IjEwMSIsIiVzbGlkZV90ZW1wbGF0ZSUiOiJkZWZhdWx0IiwiJV93cGJfdmNfanNfc3RhdHVzJSI6InRydWUiLCIlX2tsZW9fdHJhbnNwYXJlbnRfbWVudV9jb2xvciUiOiJ3aGl0ZSIsIiVfa2xlb190aXRsZV9jb2xvciUiOiIjIiwiJV9rbGVvX3RpdGxlX2JnJSI6IiwgcmVwZWF0LCBpbmhlcml0LCBzY3JvbGwsIGxlZnQgdG9wIiwiJV9rbGVvX3RpdGxlX2JnX2NvbG9yJSI6IiMiLCIlX3lvYXN0X3dwc2VvX2NvbnRlbnRfc2NvcmUlIjoiMzAiLCIlX3lvYXN0X3dwc2VvX3ByaW1hcnlfY2F0ZWdvcnklIjoiNjkiLCIlX2tsZW9fdGl0bGVfY2hlY2tib3glIjoiMSIsIiVfdGh1bWJuYWlsX2lkJSI6IjExMTY0IiwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6IlRoZXJtaSwgNTcwIDAxLCBUaGVzc2Fsb25pa2ksIEdyZWVjZSIsIiVfd3BnbXBfbWV0YWJveF9sYXRpdHVkZSUiOiI0MC41NDg1MjAxIiwiJV93cGdtcF9tZXRhYm94X2xvbmdpdHVkZSUiOiIyMy4wMTk2NDU5OTk5OTk5NjYiLCIlX3dwZ21wX21ldGFib3hfbG9jYXRpb25fcmVkaXJlY3QlIjoicG9zdCIsIiVfd3BnbXBfbWV0YWJveF9jdXN0b21fbGluayUiOiIiLCIlX3dwZ21wX21hcF9pZCUiOiJhOjE6e2k6MDtzOjE6XCIyXCI7fSIsIiVfd3BnbXBfbWV0YWJveF9tYXJrZXJfaWQlIjoiTjsiLCIlX3dwZ21wX21ldGFib3hfdGF4b21vbWllc190ZXJtcyUiOiJOOyIsIiVfd3BnbXBfZXh0ZW5zaW9uc19maWVsZHMlIjoiTjsiLCIlX2pldHBhY2tfcmVsYXRlZF9wb3N0c19jYWNoZSUiOnsiNjIzOTNiMjQyYzdhNTYxNzc0ZjhlYmZmNWMxYzA1NjUiOnsiZXhwaXJlcyI6MTU0NTUyMDE1MCwicGF5bG9hZCI6W3siaWQiOjEwNzA0fSx7ImlkIjo5OTQ1fSx7ImlkIjoxMDk0Mn1dfX0sIiVzYmdfc2VsZWN0ZWRfc2lkZWJhciUiOiIwIiwiJXNiZ19zZWxlY3RlZF9zaWRlYmFyX3JlcGxhY2VtZW50JSI6IjAiLCJ0YXhvbm9teT1jYXRlZ29yeSI6Iklubm92YXRpb24gQ2FzZSwgTWVkaWEgbGFicyIsInRheG9ub215PXBvc3RfdGFnIjoiRXVyb3BlLCBmYWN0LWNoZWNraW5nLCBob3Jpem9uIDIwMjAsIG11bHRpZGlzY2lwbGluYXJ5LCB2ZXJpZmljYXRpb24sIHZpZGVvIn0sImljb24iOiJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxOC8wMi9tYXJrZXItMS5wbmcifSwiaWQiOjExMTU0LCJpbmZvd2luZG93X2Rpc2FibGUiOmZhbHNlfSx7InNvdXJjZSI6InBvc3QiLCJ0aXRsZSI6IlRoZSBCcm93biBJbnN0aXR1dGUgZm9yIE1lZGlhIElubm92YXRpb246IGNyb3NzLXBvbGxpbmF0aW5nIGlubm92YXRpb24gYW5kIFx1MjAxY01hZ2ljXHUyMDFkIG9uIEFtZXJpY2FcdTIwMTlzIGNvYXN0cyIsImluZm93aW5kb3dfY29udGVudCI6IjxkaXYgY2xhc3M9XCJmYy1pdGVtLWJveCBmYy1pdGVtLW5vLXBhZGRpbmdcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiVGhlIEJyb3duIEluc3RpdHV0ZSBmb3IgTWVkaWEgSW5ub3ZhdGlvbjogY3Jvc3MtcG9sbGluYXRpbmcgaW5ub3ZhdGlvbiBhbmQgXHUyMDFjTWFnaWNcdTIwMWQgb24gQW1lcmljYVx1MjAxOXMgY29hc3RzXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMDBcIiBzcmM9XCJodHRwczovL21lZGlhLWlubm92YXRpb24ubmV3cy93cC1jb250ZW50L3VwbG9hZHMvMjAxNy8wOC9Ccm93bi1JbnN0aXR1dGUtMzAweDIwMC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1wYWRkaW5nLWNvbnRlbnRfMjBcIj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1tZXRhIGZjLWl0ZW0tc2Vjb25kYXJ5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2UgZmMtdGV4dC1jZW50ZXJcIj5Jbm5vdmF0aW9uIENhc2UsIE1lZGlhIGxhYnM8L2Rpdj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS10aXRsZSBmYy1pdGVtLXByaW1hcnktdGV4dC1jb2xvciBmYy10ZXh0LWNlbnRlclwiPlRoZSBCcm93biBJbnN0aXR1dGUgZm9yIE1lZGlhIElubm92YXRpb246IGNyb3NzLXBvbGxpbmF0aW5nIGlubm92YXRpb24gYW5kIFx1MjAxY01hZ2ljXHUyMDFkIG9uIEFtZXJpY2FcdTIwMTlzIGNvYXN0czwvZGl2PlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2VcIj5cclxuICAgICAgICAgICAgRXhwbG9yaW5nIG5ldyBmb3JtcyBvZiBzdG9yeXRlbGxpbmcsIHdpdGggdGhlIGludGVudCBvZiBmdXJ0aGVyaW5nIGJvdGggZW5naW5lZXJpbmcgcmVzZWFyY2ggYW5kIGpvdXJuYWxpc3RpYyBwcmFjdGljZS5cclxuICAgICAgICA8L2Rpdj5cclxuPGEgaHJlZj1cImh0dHBzOi8vbWVkaWEtaW5ub3ZhdGlvbi5uZXdzL21lZGlhLWxhYi9icm93bi1pbnN0aXR1dGUtbWVkaWEtaW5ub3ZhdGlvbi1jcm9zcy1wb2xsaW5hdGluZy1pbm5vdmF0aW9uLW1hZ2ljLWFtZXJpY2FzLWNvYXN0cy9cIj5SZWFkIG1vcmU8L2E+XHJcbiAgICA8L2Rpdj5cclxuICAgIDwvZGl2PlxyXG48L2Rpdj5cclxuXHJcbiIsImNvbnRlbnQiOiJFeHBsb3JpbmcgbmV3IGZvcm1zIG9mIHN0b3J5dGVsbGluZywgd2l0aCB0aGUgaW50ZW50IG9mIGZ1cnRoZXJpbmcgYm90aCBlbmdpbmVlcmluZyByZXNlYXJjaCBhbmQgam91cm5hbGlzdGljIHByYWN0aWNlLiIsImFkZHJlc3MiOiJCcm93biBJbnN0aXR1dGUgZm9yIE1lZGlhIElubm92YXRpb24sIEJyb2Fkd2F5LCBOZXcgWW9yaywgTlksIFVuaXRlZCBTdGF0ZXMiLCJsb2NhdGlvbiI6eyJsYXQiOiI0MC44MDc0ODU5IiwibG5nIjoiLTczLjk2MzIyMzcwMDAwMDAxIiwib25jbGlja19hY3Rpb24iOiJwb3N0IiwicmVkaXJlY3RfcGVybWFsaW5rIjoiaHR0cHM6Ly9tZWRpYS1pbm5vdmF0aW9uLm5ld3MvbWVkaWEtbGFiL2Jyb3duLWluc3RpdHV0ZS1tZWRpYS1pbm5vdmF0aW9uLWNyb3NzLXBvbGxpbmF0aW5nLWlubm92YXRpb24tbWFnaWMtYW1lcmljYXMtY29hc3RzLyIsInpvb20iOjIsImV4dHJhX2ZpZWxkcyI6eyJwb3N0X2V4Y2VycHQiOiJFeHBsb3JpbmcgbmV3IGZvcm1zIG9mIHN0b3J5dGVsbGluZywgd2l0aCB0aGUgaW50ZW50IG9mIGZ1cnRoZXJpbmcgYm90aCBlbmdpbmVlcmluZyByZXNlYXJjaCBhbmQgam91cm5hbGlzdGljIHByYWN0aWNlLiIsInBvc3RfY29udGVudCI6Ilt2Y19yb3ddW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIyLzNcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxoMT5UaGUgQnJvd24gSW5zdGl0dXRlIGZvciBNZWRpYSBJbm5vdmF0aW9uOiBjcm9zcy1wb2xsaW5hdGluZyBpbm5vdmF0aW9uIGFuZCBcdTIwMWNNYWdpY1x1MjAxZCBvbiBBbWVyaWNhXHUyMDE5cyBjb2FzdHM8L2gxPlxyXG48c3Ryb25nPlRoZSBCcm93biBJbnN0aXR1dGVcdTIwMTlzIG1pc3Npb24gaXMgdG8gZXhwbG9yZSBuZXcgZm9ybXMgb2Ygc3Rvcnl0ZWxsaW5nLCB3aXRoIHRoZSBpbnRlbnQgb2YgZnVydGhlcmluZyBib3RoIGVuZ2luZWVyaW5nIHJlc2VhcmNoIGFuZCBqb3VybmFsaXN0aWMgcHJhY3RpY2UuPC9zdHJvbmc+XHJcblxyXG5UbyB0aGlzIGVuZCwgdGhlIGluc3RpdHV0ZSBoYXMgZm9yZ2VkIGEgbnVtYmVyIG9mIHNpZ25pZmljYW50IHBhcnRuZXJzaGlwcyB3aXRoIGluZGl2aWR1YWxzIGFuZCBvcmdhbmlzYXRpb25zIGluIHRoZSByZXNlYXJjaCwgam91cm5hbGlzbSBhbmQgY3JlYXRpdmUgY29tbXVuaXRpZXMgaW4gTmV3IFlvcmsgYW5kIHRoZSBCYXkgQXJlYS5cdTAwYTBUaGUgRGF2aWQgYW5kIEhlbGVuIEd1cmxleSBCcm93biBJbnN0aXR1dGUgZm9yIE1lZGlhIElubm92YXRpb24gaXMgc3BsaXQgYmV0d2VlbiBDb2x1bWJpYSBVbml2ZXJzaXR5XHUyMDE5cyBKb3VybmFsaXNtIFNjaG9vbCAoRWFzdCBDb2FzdCwgTmV3IFlvcmspIGFuZCBTdGFuZm9yZFx1MjAxOXMgU2Nob29sIG9mIEVuZ2luZWVyaW5nIChXZXN0IENvYXN0LCBDYWxpZm9ybmlhKS4gSXQgcHJvdmlkZXMgcm91Z2hseSAkMW0gYW5udWFsbHkgdG8gc3BhcmsgaW5ub3ZhdGlvbiB0aHJvdWdoIGl0cyBcdTIwMThNYWdpYyBHcmFudFx1MjAxOSBhbmQgZmVsbG93c2hpcCBwcm9ncmFtbWVzLiBJdCBoYXMgYWxzbyB0YWtlbiBvbiBhIHBlZGFnb2dpY2FsIGZ1bmN0aW9uIHdpdGhpbiB0aGUgc2Nob29scywgbGV2ZXJhZ2luZyBpdHMgcGFydG5lcnNoaXBzIGFuZCBuZXR3b3JrcyBvZiBwYXN0IGdyYW50ZWVzIGFuZCBmZWxsb3dzLCB0byBicmluZyBuZXcgaWRlYXMsIG5ldyBxdWVzdGlvbnMsIHRvIHRoZSBmYWN1bHR5LCBzdHVkZW50cyBhbmQgYWx1bW5pIG9mIGVhY2ggc2Nob29sLlxyXG48aDM+PGI+T3JpZ2lucyAmYW1wOyBNaXNzaW9uPC9iPjwvaDM+XHJcblRoZSBCcm93biBJbnN0aXR1dGVcdTIwMTlzIG1pc3Npb24gaXMgc2ltcGxlLCBcdTIwMWN0byBsb29rIGF0IG5ldyB3YXlzIHRvIGZpbmQgYW5kIHRlbGwgc3RvcmllcyxcdTIwMWQgYWNjb3JkaW5nIHRvIEJyb3duIEluc3RpdHV0ZSBEaXJlY3RvciBhbmQgUHJvZmVzc29yIG9mIEpvdXJuYWxpc20gYXQgQ29sdW1iaWEgVW5pdmVyc2l0eSwgTWFyayBIYW5zZW4uXHJcblxyXG5Fc3RhYmxpc2hlZCBpbiAyMDEyIHdpdGggYSAkMzBtIGdpZnQgZnJvbSBIZWxlbiBHdXJsZXkgQnJvd24sIHRoZSBmb3JtZXIgZWRpdG9yLWluLWNoaWVmIGF0IENvc21vcG9saXRhbiBtYWdhemluZSBmb3Igb3ZlciB0aHJlZSBkZWNhZGVzLCB0aGUgSW5zdGl0dXRlIHdhcyBjcmVhdGVkIHRvIHByb3ZpZGUgYSBwbGF0Zm9ybSBhbmQgdG8gaW5zcGlyZSB5b3VuZyBwZW9wbGUgaW4gdGhlaXIgcHVyc3VpdCBvZiBhZHZhbmNpbmcgdGhlIG1lZGlhIGluZHVzdHJ5LiBUaGUgZW5kb3dtZW50IHdhcyBjcmVhdGVkIGluIG1lbW9yeSBvZiBoZXIgbGF0ZSBodXNiYW5kIERhdmlkIEJyb3duLiBBIGdyYWR1YXRlIG9mIGJvdGggU3RhbmZvcmQgYW5kIENvbHVtYmlhLCBCcm93biBpcyBtb3N0IHdlbGwga25vd24gZm9yIHByb2R1Y2luZyBoaXQgZmlsbXMgbGlrZSA8ZW0+SmF3czwvZW0+LCA8ZW0+QSBGZXcgR29vZCBNZW48L2VtPiBhbmQgPGVtPkRyaXZpbmcgTWlzcyBEYWlzeTwvZW0+LlxyXG48YmxvY2txdW90ZT5cdTIwMWNEYXZpZCBhbmQgSSBoYXZlIGxvbmcgc3VwcG9ydGVkIGFuZCBlbmNvdXJhZ2VkIGJyaWdodCB5b3VuZyBwZW9wbGUgdG8gZm9sbG93IHRoZWlyIHBhc3Npb25zIGFuZCB0byBjcmVhdGUgb3JpZ2luYWwgY29udGVudC4gR3JlYXQgY29udGVudCBuZWVkcyB1c2VhYmxlIHRlY2hub2xvZ3kuIFNoYXJpbmcgYSBsYW5ndWFnZSBpcyB3aGVyZSB0aGUgbWFnaWMgaGFwcGVucy4gSXQncyB0aW1lIGZvciB0d28gZ3JlYXQgQW1lcmljYW4gaW5zdGl0dXRpb25zIG9uIHRoZSBFYXN0IGFuZCBXZXN0IGNvYXN0cyB0byBidWlsZCBhIGJyaWRnZS5cdTIwMWQ8L2Jsb2NrcXVvdGU+XHJcbjxoMz48Yj5NZXRob2RzPC9iPjwvaDM+XHJcblRoZSBCcm93biBJbnN0aXR1dGUgc2V0cyBhIGxhdGUtTWFyY2ggZGVhZGxpbmUgZm9yIGFwcGxpY2F0aW9ucyB0byBpdHMgYW5udWFsIE1hZ2ljIEdyYW50IGNvbXBldGl0aW9uLiBUaGUgcHJvY2VzcyBpdHNlbGYgaXMgZGVzaWduZWQgdG8gYmUgc2ltcGxlIGFuZCBzdHJhaWdodGZvcndhcmQsIGNvbnNpc3Rpbmcgb2Ygb25seSBhIHR3by1wYWdlIHByb3Bvc2FsLCBhIGJ1ZGdldCBhbmQgQ1ZzL3Jlc3VtZXMuIEFmdGVyIGFuIGluaXRpYWwgc2NyZWVuaW5nLCBhIHNob3J0bGlzdCBvZiBwb3RlbnRpYWwgcHJvamVjdHMgaXMgaWRlbnRpZmllZCwgd2l0aCBzcGVjaWFsIGVtcGhhc2lzIGdpdmVuIHRvIFx1MjAxY2JpLWNvYXN0YWxcdTIwMWQgcHJvamVjdHMsIHRob3NlIHdpdGggdGVhbXMgbWFkZSB1cCBvZiBtZW1iZXJzIGZyb20gYm90aCB0aGUgQ29sdW1iaWEgYW5kIFN0YW5mb3JkIGNvbW11bml0aWVzLiBUd28gY29tbWl0dGVlcyAtIG9uZSBhdCBlYWNoIGluc3RpdHV0aW9uIC0gYXJlIHRoZW4gYXNzZW1ibGVkIHRvIGhlYXIgb3JhbCBwcmVzZW50YXRpb25zIGZyb20gdGhlIGZpbmFsaXN0cy4gVGhlIGNvbW1pdHRlZXMgcmFuayB0aGUgcHJvcG9zYWxzIGFuZCB0aGUgaW5zdGl0dXRlIGRpcmVjdG9ycyBhbmQgc3RhZmYgYWxsb2NhdGUgZnVuZGluZyBmb3IgYXMgbWFueSBwcm9qZWN0cyBhcyB0aGV5IGNhbiwgZm9sbG93aW5nIHRoZSBwcmlvcml0aWVzIHNldCBieSB0aGUgY29tbWl0dGVlcy4gTWFnaWMgR3JhbnRzIGNhbiBiZSB1cCB0byAkMTUwayBmb3IgYSB5ZWFyLCB3aXRoIHRoYXQgYW1vdW50IGluY3JlYXNpbmcgdG8gJDMwMGsgaWYgYSBwcm9qZWN0IGlzIGJpLWNvYXN0YWwuXHJcblxyXG5IYW5zZW4gc2VlcyBkZWZpbml0ZSBhZHZhbnRhZ2VzIHRvIGpvdXJuYWxpc20gdGhyb3VnaCBzdWNoIGJpLWNvYXN0YWwgY29sbGFib3JhdGlvbnMuIEhpc3RvcmljYWxseSwgam91cm5hbGlzbSBoYXMgdGVuZGVkIHRvIHJlbHkgb24gdG9vbHMgYW5kIHBsYXRmb3JtcyB0aGF0IHdlcmUgYnVpbHQgYnkgdGVjaG5vbG9naXN0cyBvdXRzaWRlIG9yIGluZGVwZW5kZW50IG9mIHRoZSBwcm9mZXNzaW9uLCBoZSBub3Rlcy4gVGhyb3VnaCBpdHMgdHJhaW5pbmcgcHJvZ3JhbW1lcyBhbmQgTWFnaWMgR3JhbnRzLCB0aGUgaW5zdGl0dXRlIHNlZWtzIHRvIHByZXBhcmUgam91cm5hbGlzdHMsIG9yIHN0b3J5dGVsbGVycyBtb3JlIGJyb2FkbHksIHRvIHRha2UgYW4gYWN0aXZlIHJvbGUgaW4gdGVjaG5pY2FsIGRldmVsb3BtZW50LCBcdTIwMWN0cmFpbmluZyB0aGVtIHRvIGJlIHRvb2wgYnVpbGRlcnMgYW5kIG5vdCBqdXN0IHRvb2wgdXNlcnNcdTIwMWQuXHJcblxyXG5PdmVyIGl0cyBmaXZlIHllYXJzLCB0aGUgQnJvd24gSW5zdGl0dXRlIHN0YWZmIGhhcyBsZWFybmVkIGEgZ3JlYXQgZGVhbCBhYm91d