Natuur

Glen Canyon National Recreation Area

eyJtYXBfb3B0aW9ucyI6eyJjZW50ZXJfbGF0IjoiMzkuNzI5OTM1NDExMzYzMDY2IiwiY2VudGVyX2xuZyI6Ii0xMDEuNzAzMjk2MjEwMjM4OTkiLCJ6b29tIjoxMiwibWFwX3R5cGVfaWQiOiJIWUJSSUQiLCJjZW50ZXJfYnlfbmVhcmVzdCI6ZmFsc2UsImZpdF9ib3VuZHMiOmZhbHNlLCJjZW50ZXJfY2lyY2xlX2ZpbGxjb2xvciI6IiM4Q0FFRjIiLCJjZW50ZXJfY2lyY2xlX3N0cm9rZWNvbG9yIjoiIzhDQUVGMiIsInNob3dfY2VudGVyX2NpcmNsZSI6ZmFsc2UsInNob3dfY2VudGVyX21hcmtlciI6ZmFsc2UsImNlbnRlcl9tYXJrZXJfaWNvbiI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjEvMDEvNC5wbmciLCJkcmFnZ2FibGUiOnRydWUsInNjcm9sbF93aGVlbCI6InRydWUiLCJnZXN0dXJlIjoiYXV0byIsIm1hcmtlcl9kZWZhdWx0X2ljb24iOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIxLzA2L3N0YW5kYWFyZC1sb2NhdGllLnBuZyIsImluZm93aW5kb3dfc2V0dGluZyI6IjxkaXYgY2xhc3M9XCJmYy1pdGVtLWJveCBmYy1pdGVtLW5vLXBhZGRpbmdcIj5cbjxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XG48ZGl2IGNsYXNzPVwiZmMtaXRlbS1wYWRkaW5nLWNvbnRlbnRfMjBcIj5cbjxkaXYgY2xhc3M9XCJmYy1pdGVtLW1ldGEgZmMtaXRlbS1zZWNvbmRhcnktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZSBmYy10ZXh0LWNlbnRlclwiPnttYXJrZXJfY2F0ZWdvcnl9PC9kaXY+XG48ZGl2IGNsYXNzPVwiZmMtaXRlbS10aXRsZSBmYy1pdGVtLXByaW1hcnktdGV4dC1jb2xvciBmYy10ZXh0LWNlbnRlclwiPnttYXJrZXJfdGl0bGV9PC9kaXY+XG48ZGl2IGNsYXNzPVwiZmMtaXRlbS1jb250ZW50IGZjLWl0ZW0tYm9keS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+XG48ZGl2IGNsYXNzPVwiZmMtYnV0dG9uXCI+PGEgaHJlZj1cIntidXR0b259XCI+PHN0cm9uZz5MRUVTIE1FRVI6PC9zdHJvbmc+PC9hPjwvZGl2PlxuPC9wPjwvZGl2PlxuPC9wPjwvZGl2PlxuPC9wPjwvZGl2PlxuPC9kaXY+XG4iLCJpbmZvd2luZG93X2dlb3RhZ3Nfc2V0dGluZyI6IjxkaXYgY2xhc3M9XCJmYy1pdGVtLWJveCBmYy1pdGVtLW5vLXBhZGRpbmcgXCI+XHJcbiAgICB7cG9zdF9mZWF0dXJlZF9pbWFnZX1cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmcgZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+e3Bvc3RfdGl0bGV9PC9kaXY+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3JcIj57bWFya2VyX2FkZHJlc3N9PC9kaXY+XHJcbiAgICAgICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1jbGVhclwiPjwvZGl2PlxyXG48L2Rpdj4iLCJpbmZvd2luZG93X3NraW4iOnsibmFtZSI6InVkaW5lIiwidHlwZSI6ImluZm93aW5kb3ciLCJzb3VyY2Vjb2RlIjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZ1wiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmdcIj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1wYWRkaW5nLWNvbnRlbnRfMjBcIj5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tbWV0YSBmYy1pdGVtLXNlY29uZGFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlIGZjLXRleHQtY2VudGVyXCI+e21hcmtlcl9jYXRlZ29yeX08L2Rpdj5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tdGl0bGUgZmMtaXRlbS1wcmltYXJ5LXRleHQtY29sb3IgZmMtdGV4dC1jZW50ZXJcIj57bWFya2VyX3RpdGxlfTwvZGl2PlxyXG4gICAgICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1jb250ZW50IGZjLWl0ZW0tYm9keS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+XHJcbiA8ZGl2IGNsYXNzPVwiZmMtYnV0dG9uXCI+PGEgaHJlZj1cIntidXR0b259XCI+PHN0cm9uZz5MRUVTIE1FRVI6PC9zdHJvbmc+PC9hPjwvZGl2PlxyXG4gICAgICAgICAgICA8L2Rpdj5cclxuXHJcbiAgICAgICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuPC9kaXY+In0sImluZm93aW5kb3dfcG9zdF9za2luIjp7Im5hbWUiOiJhYXJlIiwidHlwZSI6InBvc3QiLCJzb3VyY2Vjb2RlIjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZyBcIj5cclxuICAgIHtwb3N0X2ZlYXR1cmVkX2ltYWdlfVxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmdcIj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZyBmYy1pdGVtLW5vLXBhZGRpbmdcIj5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tdGl0bGUgZmMtaXRlbS1wcmltYXJ5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2VcIj57cG9zdF90aXRsZX08L2Rpdj5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tY29udGVudCBmYy1pdGVtLWJvZHktdGV4dC1jb2xvclwiPnttYXJrZXJfYWRkcmVzc308L2Rpdj5cclxuICAgICAgICA8L2Rpdj5cclxuICAgIDwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWNsZWFyXCI+PC9kaXY+XHJcbjwvZGl2PiJ9LCJpbmZvd2luZG93X2Ryb3BfYW5pbWF0aW9uIjpmYWxzZSwiY2xvc2VfaW5mb3dpbmRvd19vbl9tYXBfY2xpY2siOmZhbHNlLCJkZWZhdWx0X2luZm93aW5kb3dfb3BlbiI6ZmFsc2UsImluZm93aW5kb3dfb3Blbl9ldmVudCI6ImNsaWNrIiwibGlzdGluZ19pbmZvd2luZG93X29wZW5fZXZlbnQiOiJjbGljayIsImlzX21vYmlsZSI6ZmFsc2UsImluZm93aW5kb3dfZmlsdGVyX29ubHkiOmZhbHNlLCJpbmZvd2luZG93X2NsaWNrX2NoYW5nZV96b29tIjowLCJpbmZvd2luZG93X2NsaWNrX2NoYW5nZV9jZW50ZXIiOmZhbHNlLCJmdWxsX3NjcmVlbl9jb250cm9sIjp0cnVlLCJzZWFyY2hfY29udHJvbCI6dHJ1ZSwiem9vbV9jb250cm9sIjp0cnVlLCJtYXBfdHlwZV9jb250cm9sIjp0cnVlLCJzdHJlZXRfdmlld19jb250cm9sIjp0cnVlLCJsb2NhdGVtZV9jb250cm9sIjpmYWxzZSwibW9iaWxlX3NwZWNpZmljIjpmYWxzZSwiem9vbV9tb2JpbGUiOjUsImRyYWdnYWJsZV9tb2JpbGUiOnRydWUsInNjcm9sbF93aGVlbF9tb2JpbGUiOnRydWUsImZ1bGxfc2NyZWVuX2NvbnRyb2xfcG9zaXRpb24iOiJUT1BfUklHSFQiLCJzZWFyY2hfY29udHJvbF9wb3NpdGlvbiI6IlRPUF9MRUZUIiwibG9jYXRlbWVfY29udHJvbF9wb3NpdGlvbiI6IlRPUF9MRUZUIiwiem9vbV9jb250cm9sX3Bvc2l0aW9uIjoiVE9QX0xFRlQiLCJtYXBfdHlwZV9jb250cm9sX3Bvc2l0aW9uIjoiVE9QX1JJR0hUIiwibWFwX3R5cGVfY29udHJvbF9zdHlsZSI6IkhPUklaT05UQUxfQkFSIiwic3RyZWV0X3ZpZXdfY29udHJvbF9wb3NpdGlvbiI6IlRPUF9MRUZUIiwibWFwX2NvbnRyb2wiOmZhbHNlLCJzY3JlZW5zIjp7InNtYXJ0cGhvbmVzIjp7Im1hcF96b29tX2xldmVsX21vYmlsZSI6IjUifSwiaXBhZHMiOnsibWFwX3pvb21fbGV2ZWxfbW9iaWxlIjoiNSJ9LCJsYXJnZS1zY3JlZW5zIjp7Im1hcF96b29tX2xldmVsX21vYmlsZSI6IjUifX0sIm1hcF9pbmZvd2luZG93X2N1c3RvbWlzYXRpb25zIjp0cnVlLCJpbmZvd2luZG93X3dpZHRoIjoiMTAwJSIsImluZm93aW5kb3dfYm9yZGVyX2NvbG9yIjoicmdiYSgwLCAwLCAwLCAwLjA5ODAzOTIpIiwiaW5mb3dpbmRvd19iZ19jb2xvciI6IiNmZmYiLCJzaG93X2luZm93aW5kb3dfaGVhZGVyIjpmYWxzZSwibWluX3pvb20iOiIwIiwibWF4X3pvb20iOiIxOSIsInpvb21fbGV2ZWxfYWZ0ZXJfc2VhcmNoIjoiMTAiLCJ1cmxfZmlsdGVycyI6ZmFsc2UsImRvdWJsZWNsaWNrem9vbSI6ZmFsc2UsImN1cnJlbnRfcG9zdF9vbmx5Ijp0cnVlLCJib3VuZF9tYXBfYWZ0ZXJfZmlsdGVyIjpmYWxzZSwiZGlzcGxheV9yZXNldF9idXR0b24iOmZhbHNlLCJtYXBfcmVzZXRfYnV0dG9uX3RleHQiOiJSZXNldCIsIndpZHRoIjoiMTAwJSIsImhlaWdodCI6IjU1MCJ9LCJwbGFjZXMiOlt7InNvdXJjZSI6InBvc3QiLCJ0aXRsZSI6Ik1lZ2Fyb29mIHZhbiBtaWxqb2VuZW4gZG9sbGFycyBpbiBMb3MgQW5nZWxlcyIsImluZm93aW5kb3dfY29udGVudCI6IjxkaXYgY2xhc3M9XCJmYy1pdGVtLWJveCBmYy1pdGVtLW5vLXBhZGRpbmcgXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIk1lZ2Fyb29mIHZhbiB0aWVudGFsbGVuIG1pbGpvZW5lbiBpbiBMb3MgQW5nZWxlc1wiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjE4XCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyNC8wNC9iYW5ra2x1aXMtMzAweDIxOC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmcgZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+TWVnYXJvb2YgdmFuIG1pbGpvZW5lbiBkb2xsYXJzIGluIExvcyBBbmdlbGVzPC9kaXY+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3JcIj57bWFya2VyX2FkZHJlc3N9PC9kaXY+XHJcbiAgICAgICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1jbGVhclwiPjwvZGl2PlxyXG48L2Rpdj4iLCJjb250ZW50IjoiIiwiYWRkcmVzcyI6IlN5bG1hciwgTG9zIEFuZ2VsZXMsIENhbGlmb3JuaVx1MDBlYiwgVmVyZW5pZ2RlIFN0YXRlbiIsImxvY2F0aW9uIjp7ImxhdCI6IjM0LjI5OTQ4NzQiLCJjaXR5IjoiTG9zIEFuZ2VsZXMiLCJzdGF0ZSI6IkNhbGlmb3JuaVx1MDBlYiIsImNvdW50cnkiOiJWZXJlbmlnZGUgU3RhdGVuIiwibG5nIjoiLTExOC40NTg4MjkyIiwicmVkaXJlY3RfY3VzdG9tX2xpbmsiOiIiLCJvbmNsaWNrX2FjdGlvbiI6Im1hcmtlciIsInJlZGlyZWN0X3Blcm1hbGluayI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvbWVnYXJvb2YtdmFuLW1pbGpvZW5lbi1kb2xsYXJzLWluLWxvcy1hbmdlbGVzLyIsInpvb20iOjEyLCJleHRyYV9maWVsZHMiOnsicG9zdF9leGNlcnB0IjoiIiwicG9zdF9jb250ZW50IjoiW3ZjX3Jvd11bdmNfY29sdW1uXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiTmV0IGFscyBpbiBkZSBmaWxtIChvZiB0dikgZWVuIG1lZ2Fyb29mIHZhbiB0aWVudGFsbGVuIG1pbGpvZW5lbiBpbiBMQVwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTozMHx0ZXh0X2FsaWduOmNlbnRlcnxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1cclxuPHAgc3R5bGU9XCJ0ZXh0LWFsaWduOiBjZW50ZXI7XCI+PHN0cm9uZz5KZSB6b3UgYmlqbmEgZGVua2VuIGRhdCBlciBuaWV1d2Ugb3BuYW1lcyBwbGFhdHMgaGViYmVuIGdldm9uZGVuIHZhbiAnTGEgQ2FzYSBkZSBQYXBlbCcgb2YgJ01vbmV5IEhlaXN0JyBpbiBoZXQgRW5nZWxzLiBNYWFyIG5pZXRzIGlzIG1pbmRlciB3YWFyLFx1MDBhMGluYnJla2VycyBoZWJiZW4gMzAgbWlsam9lbiBkb2xsYXIgKHJ1aW0gMjcgbWlsam9lbiBldXJvKSBnZXN0b2xlbiB1aXQgZWVuIGdlbGRvcHNsYWcgaW4gTG9zIEFuZ2VsZXMuIEhldCB6b3UgZ2FhbiBvbSBcdTAwZTlcdTAwZTluIHZhbiBkZSBncm9vdHN0ZSBkaWVmc3RhbGxlbiB2YW4gY29udGFudCBnZWxkIGluIGRlIEFtZXJpa2FhbnNlIHN0YWQgb29pdC48L3N0cm9uZz48L3A+XHJcblsvdmNfY29sdW1uX3RleHRdW3ZjX2NvbHVtbl90ZXh0XURlIHBvbGl0aWUgdmFuIExvcyBBbmdlbGVzIGVuIGRlIEZCSSBvbmRlcnpvZWtlbiBkZSBkaWVmc3RhbCB2YW4gdGllbnRhbGxlbiBtaWxqb2VuZW4gZG9sbGFycyB1aXQgZWVuIGdlbGRvcHNsYWdwbGFhdHMgaW4gZGUgU2FuIEZlcm5hbmRvIFZhbGxleSwgaW4gZGUgd2lqayBTeWxtYXIgZGljaHRiaWogQnVyYmFuay5cclxuPGgzPkRpZXZlbiBibGV2ZW4gb25vcGdlbWVya3Q6IGhldCBhbGFybSBnaW5nIG5pZXQgYWYhPC9oMz5cclxuRGUgZGlldmVuIGJyYWtlbiBvbm9wZ2VtZXJrdCBoZXQgcGFuZCBiaW5uZW4gLSB6b25kZXIgaGV0IGFsYXJtIHRlIGxhdGVuIGFmZ2FhbiAtIHZpYSBoZXQgZGFrLiBIaWVybWVlIHdpc3RlbiB6ZSBvcCBlZW4gb2YgYW5kZXJlIG1hbmllciBkZSBnZWxkb3BzbGFncnVpbXRlIGJpbm5lbiB0ZSBkcmluZ2VuLiBCb3ZlbmRpZW4gdG9vbnQgZGUga2x1aXMgdmFuIGJ1aXRlbmFmIGdlZW4gc3BvcmVuIHZhbiBpbmJyYWFrLiBIZXQgYmVkcmlqZiBkYXQgZWlnZW5hYXIgaXMgdmFuIGhldCBnZWJvdXcgb250ZGVrdGUgZGUgbWFzc2FsZSBkaWVmc3RhbCBwYXMgZGUgb2NodGVuZCBsYXRlci4gSG9lIGhldCBkZSBkaWV2ZW4gaXMgZ2VsdWt0IG9tIHpvdmVlbCBnZWxkIGJ1aXQgdGUgbWFrZW4sIGlzIGVlbiBteXN0ZXJpZS5cclxuPGgzPkxBUEQgd2Vya3Qgc2FtZW4gbWV0IGRlIEZCSSBhYW4gaGV0IG9uZGVyem9lazwvaDM+XHJcbkxBUEQgKExvcyBBbmdlbGVzIFBvbGljZSBEZXBhcnRtZW50KSB6ZWd0IGRhdCBkZSBkaWVuc3Qgc2FtZW53ZXJrdCBtZXQgZGUgRkJJIGFhbiBkZXplIHphYWsuIEhldCBpcyBvbmR1aWRlbGlqayBob2V2ZWVsIGVyIHByZWNpZXMgaXMgZ2VzdG9sZW4sIG1hYXIgZXIgd29yZHQgYWFuZ2Vub21lbiBkYXQgaGV0IGVlbiB2YW4gZGUgZ3Jvb3RzdGUgb3ZlcnZhbGxlbiBpbiBkZSBnZXNjaGllZGVuaXMgdmFuIExBIGlzLlxyXG5cclxuRGUgdmVyZmlqbmRlIGFhbnBhayB2YW4gZGUgb3ZlcnZhbCBkb2V0IGRlIGF1dG9yaXRlaXRlbiBnZWxvdmVuIGRhdCBlZW4gcHJvZmVzc2lvbmVsZSBlbiBlcnZhcmVuIGluYnJla2VycyB2ZXJhbnR3b29yZGVsaWprIHppam4gdm9vciBkZSBicnV0YWxlIGluYnJhYWsuIEhldCBpcyBub2cgb25kdWlkZWxpamsgb20gd2llIGhldCBnYWF0LlxyXG5cclxuW2NhcHRpb24gaWQ9XCJhdHRhY2htZW50XzE5NTk1XCIgYWxpZ249XCJhbGlnbmxlZnRcIiB3aWR0aD1cIjEwMjRcIl08aW1nIGNsYXNzPVwic2l6ZS1sYXJnZSB3cC1pbWFnZS0xOTU5NVwiIHNyYz1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjQvMDQvYnJpbmtzLW1vbmV5LXRydWNrLTEwMjR4NzQ1LmpwZ1wiIGFsdD1cIkVlbiBCcmlua3Mgd2FhcmRldHJhbnNwb3J0IHRydWNrIGluIFBhc2FkZW5hXCIgd2lkdGg9XCIxMDI0XCIgaGVpZ2h0PVwiNzQ1XCIgLz4gRWVuIEJyaW5rcyB3YWFyZGV0cmFuc3BvcnQgdHJ1Y2sgaW4gUGFzYWRlbmFbL2NhcHRpb25dXHJcbjxoMz5Ud2VlIGphYXIgbmEgYW5kZXJlIGdyb3RlIHJvb2YgaW4gTG9zIEFuZ2VsZXM8L2gzPlxyXG5EZSBkaWVmc3RhbCBrb210IGJpam5hIHR3ZWUgamFhciBuYWRhdCBtYWFyIGxpZWZzdCAkMTAwIG1pbGpvZW4gYWFuIGp1d2VsZW4gZW4gYW5kZXJlIHdhYXJkZXZvbGxlIHNwdWxsZW4gd2VyZCBnZXN0b2xlbiB1aXQgZWVuIHdhYXJkZXRyYW5zcG9ydHdhZ2VuIHZhbiBCcmluaydzIGJpaiBlZW4gdnJhY2h0d2FnZW5zdG9wcGxhYXRzIGluIFp1aWQtQ2FsaWZvcm5pXHUwMGViLiBPb2sgZGV6ZSBkaWV2ZW4gemlqbiBub29pdCBnZXBha3QuWy92Y19jb2x1bW5fdGV4dF1bdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW5dW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjk1JVwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIk1lZXIgI1RyZW5kaW5nIEFtZXJpa2EgbmlldXdzXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiI2IzNGE0Y1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDo0NXB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMjVweFwiXVt0aGJfcG9zdGdyaWQgY29sdW1ucz1cIjVcIiBwYWdpbmF0aW9uPVwic3R5bGUyXCIgc291cmNlPVwic2l6ZToxMHxwb3N0X3R5cGU6cG9zdHxjYXRlZ29yaWVzOjE5OCwxOTksMjAwLDIwNSwyMDFcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd10iLCJwb3N0X3RpdGxlIjoiTWVnYXJvb2YgdmFuIG1pbGpvZW5lbiBkb2xsYXJzIGluIExvcyBBbmdlbGVzIiwicG9zdF9saW5rIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9tZWdhcm9vZi12YW4tbWlsam9lbmVuLWRvbGxhcnMtaW4tbG9zLWFuZ2VsZXMvIiwicG9zdF9mZWF0dXJlZF9pbWFnZSI6IjxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiTWVnYXJvb2YgdmFuIHRpZW50YWxsZW4gbWlsam9lbmVuIGluIExvcyBBbmdlbGVzXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMThcIiBzcmM9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDI0LzA0L2JhbmtrbHVpcy0zMDB4MjE4LmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6IlRyZW5kaW5nIExvcyBBbmdlbGVzIiwicG9zdF90YWdzIjoiIiwiJV9sYXN0X2VkaXRvcl91c2VkX2pldHBhY2slIjoiY2xhc3NpYy1lZGl0b3IiLCIlX2VkaXRfbG9jayUiOiIxNzEyMjM3NDcwOjEiLCIlX2VkaXRfbGFzdCUiOiIxIiwiJV90aHVtYm5haWxfaWQlIjoiMTk1OTMiLCIlX3lvYXN0X2luZGV4bm93X2xhc3RfcGluZyUiOiIxNzEyMjM3NDY2IiwiJV9oaWRlX2ZlYXR1cmVkJSI6bnVsbCwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6IlN5bG1hciwgTG9zIEFuZ2VsZXMsIENhbGlmb3JuaVx1MDBlYiwgVmVyZW5pZ2RlIFN0YXRlbiIsIiVfd3BnbXBfbG9jYXRpb25fY2l0eSUiOiJMb3MgQW5nZWxlcyIsIiVfd3BnbXBfbG9jYXRpb25fc3RhdGUlIjoiQ2FsaWZvcm5pXHUwMGViIiwiJV93cGdtcF9sb2NhdGlvbl9jb3VudHJ5JSI6IlZlcmVuaWdkZSBTdGF0ZW4iLCIlX3dwZ21wX21ldGFib3hfbGF0aXR1ZGUlIjoiMzQuMjk5NDg3NCIsIiVfd3BnbXBfbWV0YWJveF9sb25naXR1ZGUlIjoiLTExOC40NTg4MjkyIiwiJV93cGdtcF9tZXRhYm94X2xvY2F0aW9uX3JlZGlyZWN0JSI6Im1hcmtlciIsIiVfd3BnbXBfbWV0YWJveF9jdXN0b21fbGluayUiOiIiLCIlX3dwZ21wX21hcF9pZCUiOiJhOjE6e2k6MDtzOjE6XCI3XCI7fSIsIiVfd3BnbXBfbWV0YWJveF9tYXJrZXJfaWQlIjoiYToxOntpOjA7czoxOlwiMVwiO30iLCIlX3dwZ21wX21ldGFib3hfdGF4b21vbWllc190ZXJtcyUiOiIiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6IiIsIiVfd3dzX3N1cHBvcnRfY29udGFjdF9udW1iZXIlIjoiIiwiJV93d3NfYWJvdXRfc3VwcG9ydF90ZXh0JSI6IiIsIiVfd3dzX3RyaWdnZXJfYnV0dG9uX3RleHQlIjoiIiwiJV93d3NfcHJlZGVmaW5lZF90ZXh0JSI6IiIsIiVfd3BiX3ZjX2pzX3N0YXR1cyUiOiJ0cnVlIiwiJV95b2FzdF93cHNlb19tZXRhZGVzYyUiOiJIZXQgbGlqa3Qgb3AgZWVuIGFmbGV2ZXJpbmcgdmFuIExhIENhc2EgZGUgUGFwZWwsIG1hYXIgaW5icmVrZXJzIGluIExBIHdpc3RlbiBvbm9wZ2VtZXJrdCB0aWVudGFsbGVuIG1pbGpvZW5lbiB0ZSBzdGVsZW4gdGlqZGVucyBlZW4gaW5icmFhay4iLCIlX3lvYXN0X3dwc2VvX2NvbnRlbnRfc2NvcmUlIjoiOTAiLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza2V5d29yZHMlIjoiW10iLCIlX3lvYXN0X3dwc2VvX2tleXdvcmRzeW5vbnltcyUiOiJbXCJ6b25zdmVyZHVpc3RlcmluZyB2YW4gMjAyNCBpbiAxMyBzdGF0ZW5cIl0iLCIlX3lvYXN0X3dwc2VvX2VzdGltYXRlZC1yZWFkaW5nLXRpbWUtbWludXRlcyUiOiIzIiwiJV95b2FzdF93cHNlb193b3JkcHJvb2ZfdGltZXN0YW1wJSI6IiIsIiVwb3N0LXByaW1hcnktY2F0ZWdvcnklIjoiYXV0byIsIiVmZWF0dXJlZF9pbWFnZV9vdmVycmlkZSUiOiJvZmYiLCIlc3RhbmRhcmQtZmVhdHVyZWQtY3JlZGl0JSI6IiIsIiVwb3N0X3NvdXJjZSUiOiIiLCIlYXJ0aWNsZV9zdHlsZV9vdmVycmlkZSUiOiJvbiIsIiVwb3N0X3N0eWxlJSI6InN0eWxlOCIsIiVwb3N0X2dhbGxlcnlfc3R5bGUlIjoibGlnaHRib3giLCIlcG9zdF9yZXZpZXclIjoib2ZmIiwiJXBvc3RfcmV2aWV3X3N0eWxlJSI6InN0eWxlMSIsIiVwb3N0X3Jldmlld19hdmVyYWdlJSI6IjUwIiwiJWlubGluZV9mZWF0dXJlZF9pbWFnZSUiOiIwIiwiJV95b2FzdF93cHNlb19wcmltYXJ5X2NhdGVnb3J5JSI6IjIwNSIsIiVfeW9hc3Rfd3BzZW9fZm9jdXNrdyUiOiJNZWdhcm9vZiB2YW4gdGllbnRhbGxlbiBtaWxqb2VuZW4gaW4gTG9zIEFuZ2VsZXMiLCIlX3lvYXN0X3dwc2VvX2xpbmtkZXglIjoiNjYiLCIlX3lvYXN0X3dwc2VvX3RpdGxlJSI6Ik1lZ2Fyb29mIHZhbiB0aWVudGFsbGVuIG1pbGpvZW5lbiBpbiBMb3MgQW5nZWxlcyIsIiVwb3N0X3ZpYSUiOiIiLCIlYWN0aXZlZXJfc3VibWVudSUiOiIwIiwiJV9hY3RpdmVlcl9zdWJtZW51JSI6ImZpZWxkXzY1OTNmNTIxZTk3YzIiLCJ0YXhvbm9teT1jYXRlZ29yeSI6IlRyZW5kaW5nIExvcyBBbmdlbGVzIiwidGF4b25vbXk9cG9zdF90YWciOiIiLCJ0YXhvbm9teT1wb3N0X2Zvcm1hdCI6IiIsInRheG9ub215PXRoYi1yZWFjdGlvbnMiOiIiLCJ0YXhvbm9teT10aGItc3BvbnNvcnMiOiIifSwiaWNvbiI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjEvMDQvYnV1cnQtMS5wbmcifSwiaWQiOjE5NTkyLCJjdXN0b21fZmlsdGVycyI6W10sImluZm93aW5kb3dfZGlzYWJsZSI6ZmFsc2UsImNhdGVnb3JpZXMiOlt7Imljb24iOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIxLzA0L2J1dXJ0LTEucG5nIiwibmFtZSI6IkJ1dXJ0ZW4iLCJpZCI6IjEiLCJ0eXBlIjoiY2F0ZWdvcnkiLCJleHRlbnNpb25fZmllbGRzIjp7ImNhdF9vcmRlciI6IiJ9fV19LHsic291cmNlIjoicG9zdCIsInRpdGxlIjoiRGUgbWVlc3QgbHV4dWV1emUgcmVzb3J0cyBpbiBMYXMgVmVnYXMiLCJpbmZvd2luZG93X2NvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nIFwiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJMdXh1ZXV6ZSByZXNvcnRzIGluIExhcyBWZWdhc1wiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyNC8wMy9sdXhlLWhvdGVscy1pbi1sYXMtdmVnYXMtMzAweDIwMC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmcgZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+RGUgbWVlc3QgbHV4dWV1emUgcmVzb3J0cyBpbiBMYXMgVmVnYXM8L2Rpdj5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tY29udGVudCBmYy1pdGVtLWJvZHktdGV4dC1jb2xvclwiPnttYXJrZXJfYWRkcmVzc308L2Rpdj5cclxuICAgICAgICA8L2Rpdj5cclxuICAgIDwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWNsZWFyXCI+PC9kaXY+XHJcbjwvZGl2PiIsImNvbnRlbnQiOiJBbGxlZW4gYWwgdm9vciBoZXQgdWl0emljaHQgdmFudWl0IGRlIERlbGZ0cyBibGF1d2Uga2FtZXJzLCB3aWwgamUgaGllciBsb2dlcmVuLiBIZXQgTm9NbyBpbiBkZSB3aWprIFNvSG8gaXMgI3dvdy4gIiwiYWRkcmVzcyI6IjkgQ3Jvc2J5IFN0LCBOZXcgWW9yaywgTlkgMTAwMTMsIFZlcmVuaWdkZSBTdGF0ZW4iLCJsb2NhdGlvbiI6eyJsYXQiOiI0MC43MTk4MzUzNjI5NTQ5MjUiLCJjaXR5IjoiTmV3IFlvcmsiLCJzdGF0ZSI6Ik5ldyBZb3JrIiwiY291bnRyeSI6IlZlcmVuaWdkZSBTdGF0ZW4iLCJsbmciOiItNzQuMDAwMDg0OTg2NTA4MTciLCJvbmNsaWNrX2FjdGlvbiI6Im1hcmtlciIsInJlZGlyZWN0X3Blcm1hbGluayI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvbHV4dWV1emUtaG90ZWxzLWxhcy12ZWdhcy8iLCJ6b29tIjoxMiwiZXh0cmFfZmllbGRzIjp7InBvc3RfZXhjZXJwdCI6IkFsbGVlbiBhbCB2b29yIGhldCB1aXR6aWNodCB2YW51aXQgZGUgRGVsZnRzIGJsYXV3ZSBrYW1lcnMsIHdpbCBqZSBoaWVyIGxvZ2VyZW4uIEhldCBOb01vIGluIGRlIHdpamsgU29IbyBpcyAjd293LiAiLCJwb3N0X2NvbnRlbnQiOiJbdmNfcm93XVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMi8zXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIkdlbmlldGVuIHZhbiBlZW4gbHV4ZSBob3RlbD9cIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6NDVweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjUwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIkRpdCB6aWpuIGRlIGJlc3RlIHJlc29ydHMgaW4gTGFzIFZlZ2FzXCIgaGVhZGluZ190YWc9XCJkaXZcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpPc3dhbGR8Zm9udF9jYWxsOk9zd2FsZFwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjMwcHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozNXB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdR2VuaWV0ZW4gdmFuIHVsdGllbWUgbHV4ZSBlbiBldmVuIG9udHNwYW5uZW4gbmEgYWxsZSBoZWN0aWVrIG9wIGRlIFN0cmlwPyBEYW4gemlqbiBkZXplIGhvdGVscyBkZSBiZXN0ZSBvcHRpZXMgb20gdGUgb3Zlcm5hY2h0ZW4gaW4gTGFzIFZlZ2FzLiBMdXhlIHJlc29ydHMgd2FhciBqZSBhbGxlIGZhY2lsaXRlaXRlbiBrdW50IHZpbmRlbiBkaWUgamUgbWFhciB3ZW5zdC4gVmVyc2NoaWxsZW5kZSB6d2VtYmFkZW4sIGZpdG5lc3MgZW4gc3BhIHJ1aW10ZXMsIHBpZWtmaWpuZSByZXN0YXVyYW50cyBlbiBrYW1lcnMgd2FhciBqZSBuaWV0IG1lZXIgYWYgd2lsdCwgZGl0IHppam4gZGUgYmVzdGUgaG90ZWxzIHZhbiBMYXMgVmVnYXMgd2lsIGplIGVjaHQgdWx0aWVtIGdlbmlldGVuIHZhbiBsdXhlLlsvdmNfY29sdW1uX3RleHRdW3ZjX2NvbHVtbl90ZXh0XVxyXG48cCBzdHlsZT1cInRleHQtYWxpZ246IGNlbnRlcjtcIj5cdTJiNTBcdWZlMGZcdTJiNTBcdWZlMGZcdTJiNTBcdWZlMGZcdTJiNTBcdWZlMGZcdTJiNTBcdWZlMGY8L3A+XHJcblsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiQ3JvY2tmb3JkcyBQYWxhY2UgU3VpdGUgKFJlc29ydHMgV29ybGQpXCIgYWxpZ25tZW50PVwibGVmdFwiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6MzBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XUVyIHppam4gZ2Vub2VnIGhvdGVscyBvcCBkZSA8YSBocmVmPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9sYXMtdmVnYXMvdGhlLXN0cmlwLWxhcy12ZWdhcy9cIj5TdHJpcDwvYT4gd2FhciBqZSBrdW50IHZlcmJsaWp2ZW4gYWxzIGplIExhcyBWZWdhcyBiZXpvZWt0LiBUaGUgUmVzb3J0IFdvcmxkIGNvbWJpbmVlcnQgaGV0IGJlc3RlIHZhbiBhbGxlcy4gUmVzaWRlbnRpZXMgdmFuIGJlcm9lbWRoZWRlbiwgZ29lZGUgcmVzdGF1cmFudHMsIHp3ZW1iYWRlbiwgZWVuIGdhbWVzY2VuZSwgd2lua2VscyBlbiBlZW4gZmFudGFzdGlzY2hlIHNwYSwgamUgaG9lZnQgaGV0IGhvdGVsIG5pZXQgbWVlciB1aXQuIEhldCByZXNvcnQgaGVlZnQgZ2VlbiBzcGVjaWZpZWsgdGhlbWEsIG1hYXIgamUgdmluZHQgZXIgdm9vcmFsIGVlbiByZXNpZGVudGlcdTAwZWJsZSBzZmVlci4gVmFuYWYgZGUga2FtZXJzIGhlYiBqZSB1aXR6aWNodCBvcCBMYXMgVmVnYXMgVmFsbGV5IGVuIGRlIGJlcmdlbiBpbiBoZXQgd2VzdGVuLiBFciB6aWpuIGRyaWUgdmVyc2NoaWxsZW5kZSBob3RlbGluZ2FuZ2VuOyBoZXQgSGlsdG9uIGJpZWR0IGRlIGdvZWRrb29wc3RlIGthbWVycywgYmlqIGhldCBDb25yYWQga3JpamcgamUgaWV0cyBtZWVyIGx1eGUgZW4gaW4gaGV0IENyb2NrZm9yZHMgdmluZCBqZSBwZW50aG91c2VzLCB2aWxsYSdzIGVuIHN1aXRlcy4gRWV0bW9nZWxpamtoZWRlbiBnZW5vZWcgd2Fhcm9uZGVyIEZhbW91cyBGb29kcyBTdHJlZXQgRWF0cywgZWVuIHZlcnphbWVsaW5nIHZhbiBtZWVyIGRhbiAxNSBmb29kY291cnRzIG1ldCBadWlkb29zdC0gQXppYXRpc2NoIGV0ZW4uIEZhdm9yaWV0ZW4gemlqbiBvbmRlciBhbmRlcmUgRmFtb3VzIFBobywgSGFyYWp1a3UgUmFtZW4gZW4gQnVyZ2VyIEJhcm4uIERlIHNwYSBpcyBtaXNzY2hpZW4gbm9nIHdlbCBkZSBtZWVzdCB1bmlla2UgdmFuIGFsbGUgc3BhJ3MgaW4gTGFzIFZlZ2FzLiBOaWV0IGFsbGVlbiBoZWIgamUgZGUgbW9nZWxpamtoZWlkIHRvdCBlZW4gdWl0Z2VicmVpZGUgYmVoYW5kZWxpbmcsIG9vayB2b29yIGVlbiBzbmVsbGUgdm9ldC1zcGFiZWhhbmRlbGluZyBrdW4gamUgaGllciB0ZXJlY2h0LlsvdmNfY29sdW1uX3RleHRdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiUG9wdWxhaXJlIGZhY2lsaXRlaXRlblwiIGhlYWRpbmdfdGFnPVwiaDNcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozMHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdGhiX2ljb25saXN0IGljb249XCJmYXMgZmEtbWFwLW1hcmtlci1hbHRcIiBsaXN0X2NvbnRlbnQ9XCIzMDAwIExhcyBWZWdhcyBCb3VsZXZhcmQgU1wiXVt0aGJfaWNvbmxpc3QgaWNvbj1cImZhcyBmYS13aWZpXCIgbGlzdF9jb250ZW50PVwiR3JhdGlzIFdpRmlcIl1bdGhiX2ljb25saXN0IGljb249XCJmYXMgZmEtc3dpbW1lclwiIGxpc3RfY29udGVudD1cIlp3ZW1iYWRcIl1bdGhiX2ljb25saXN0IGljb249XCJmYXMgZmEtYmVkXCIgbGlzdF9jb250ZW50PVwiQ29tZm9ydGFiZWxlIGJlZGRlblwiXVt0aGJfaWNvbmxpc3QgaWNvbj1cImZhcyBmYS1ydW5uaW5nXCIgbGlzdF9jb250ZW50PVwiR3ltXCJdW3RoYl9pY29ubGlzdCBpY29uPVwiZmFzIGZhLXNwYVwiIGxpc3RfY29udGVudD1cIldlbG5lc3NjZW50cnVtXCJdW3RoYl9pY29ubGlzdCBpY29uPVwiZmFzIGZhLXV0ZW5zaWxzXCIgbGlzdF9jb250ZW50PVwiUmVzdGF1cmFudFwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIyNXB4XCJdW3VsdF9idXR0b25zIGJ0bl90aXRsZT1cIkJvZWsgZWVuIGthbWVyIGJpaiBDb25yYWRcIiBidG5fbGluaz1cInVybDpodHRwcyUzQSUyRiUyRnd3dy5ib29raW5nLmNvbSUyRmhvdGVsJTJGdXMlMkZjb25yYWQtbGFzLXZlZ2FzLWF0LXJlc29ydHMtd29ybGQuZW4uaHRtbCUzRmFpZCUzRDc5NTg0OTglMjZub19yb29tcyUzRDElMjZncm91cF9hZHVsdHMlM0QyJTI2bGFiZWwlM0RsdXhlaG90ZWxzbGFzdmVnYXNjb25yYWR8dGl0bGU6Qm9layUyMGVlbiUyMGthbWVyfHRhcmdldDpfYmxhbmtcIiBidG5fdGl0bGVfY29sb3I9XCIjZmZmZmZmXCIgYnRuX2JnX2NvbG9yPVwiI2IzNGE0Y1wiIGJ0bl9ob3Zlcj1cInVidG4tYm90dG9tLWJnXCIgYnRuX2JnX2NvbG9yX2hvdmVyPVwiIzUzMWEyM1wiIGljb25fc2l6ZT1cIjMyXCIgYnRuX2ljb25fcG9zPVwidWJ0bi1zZXAtaWNvbi1hdC1sZWZ0XCIgYnRuX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIGJ0bl9mb250X3NpemU9XCJkZXNrdG9wOjIwcHg7XCIgYnRuX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDoyNXB4O1wiXVt1bHRfYnV0dG9ucyBidG5fdGl0bGU9XCJCb2VrIGVlbiBrYW1lciBiaWogQ3JvY2tmb3Jkc1wiIGJ0bl9saW5rPVwidXJsOmh0dHBzJTNBJTJGJTJGd3d3LmJvb2tpbmcuY29tJTJGaG90ZWwlMkZ1cyUyRmNyb2NrZm9yZHMtbGFzLXZlZ2FzLWx4ci1ob3RlbHMtcmVzb3J0cy5lbi5odG1sJTNGYWlkJTNENzk1ODQ5OCUyNm5vX3Jvb21zJTNEMSUyNmdyb3VwX2FkdWx0cyUzRDIlMjZsYWJlbCUzRGx1eGVob3RlbHNsYXN2ZWdhc2Nyb2NrZm9yZHN8dGl0bGU6Qm9layUyMGVlbiUyMGthbWVyfHRhcmdldDpfYmxhbmtcIiBidG5fdGl0bGVfY29sb3I9XCIjZmZmZmZmXCIgYnRuX2JnX2NvbG9yPVwiI2IzNGE0Y1wiIGJ0bl9ob3Zlcj1cInVidG4tYm90dG9tLWJnXCIgYnRuX2JnX2NvbG9yX2hvdmVyPVwiIzUzMWEyM1wiIGljb25fc2l6ZT1cIjMyXCIgYnRuX2ljb25fcG9zPVwidWJ0bi1zZXAtaWNvbi1hdC1sZWZ0XCIgYnRuX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIGJ0bl9mb250X3NpemU9XCJkZXNrdG9wOjIwcHg7XCIgYnRuX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDoyNXB4O1wiXVt1bHRfYnV0dG9ucyBidG5fdGl0bGU9XCJCb2VrIGVlbiBrYW1lciBiaWogSGlsdG9uXCIgYnRuX2xpbms9XCJ1cmw6aHR0cHMlM0ElMkYlMkZ3d3cuYm9va2luZy5jb20lMkZob3RlbCUyRnVzJTJGbGFzLXZlZ2FzLWhpbHRvbi1hdC1yZXNvcnRzLXdvcmxkLmVuLmh0bWwlM0ZhaWQlM0Q3OTU4NDk4JTI2bm9fcm9vbXMlM0QxJTI2Z3JvdXBfYWR1bHRzJTNEMiUyNmxhYmVsJTNEbHV4ZWhvdGVsc2xhc3ZlZ2FzaGlsdG9ufHRpdGxlOkJvZWslMjBlZW4lMjBrYW1lcnx0YXJnZXQ6X2JsYW5rXCIgYnRuX3RpdGxlX2NvbG9yPVwiI2ZmZmZmZlwiIGJ0bl9iZ19jb2xvcj1cIiNiMzRhNGNcIiBidG5faG92ZXI9XCJ1YnRuLWJvdHRvbS1iZ1wiIGJ0bl9iZ19jb2xvcl9ob3Zlcj1cIiM1MzFhMjNcIiBpY29uX3NpemU9XCIzMlwiIGJ0bl9pY29uX3Bvcz1cInVidG4tc2VwLWljb24tYXQtbGVmdFwiIGJ0bl9mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBidG5fZm9udF9zaXplPVwiZGVza3RvcDoyMHB4O1wiIGJ0bl9saW5lX2hlaWdodD1cImRlc2t0b3A6MjVweDtcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMi8zXCJdW3RoYl9pbWFnZV9zbGlkZXIgbGlnaHRib3g9XCJtZnAtZ2FsbGVyeVwiIHRoYl9lcXVhbF9oZWlnaHQ9XCJ0cnVlXCIgYXV0b3BsYXk9XCJ0cnVlXCIgaW1hZ2VzPVwiMTk1MzQsMTk1MzUsMTk1MzYsMTk1MzdcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW5dW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIkZvbnRhaW5lYmxlYXVcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozMHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdRm9udGFpbmVibGVhdSBpbiBMYXMgVmVnYXMgaXMgZWVuIHZhbiBkZSBuaWV1d3N0ZSBob3RlbHMgb3AgZGUgU3RyaXAuIEplIHZpbmR0IGVyIGVlbiBmaWpuZSBtaXggYWFuIGVudGVydGFpbm1lbnQsIG1hYXIga3VudCBvb2sgb250c25hcHBlbiBhYW4gaGV0IG5hY2h0bGV2ZW4gd2FhciBkZSBzdGFkIG9tIGJla2VuZCBzdGFhdC4gSGV0IGhvdGVsIGJlc2NoaWt0IG92ZXIgbWVlciBkYW4gMzUwMCBrYW1lcnMgZGllIHVpdHppY2h0IGhlYmJlbiBvcCBkZSBTdHJpcC4gT250c3Bhbm5pbmcga2FuIG5pZXQgb250YnJla2VuIG1ldCA3IHp3ZW1iYWRlbiwgZWVuIDE1MC4wMDAgdmllcmthbnRlIG1ldGVyIGNhc2lubyBlbiB2ZWVsIGFhbmJvZCBpbiByZXN0YXVyYW50cy4gRGUgbHV4ZSBzdWl0ZXMgaGViYmVuIHphY2h0ZSBsb3VuZ2VzdG9lbGVuIGVuIGdldmVuIGplIGRlIG1vZ2VsaWpraGVpZCBvbSBlZW4gcG90amUgcG9vbCB0ZSBzcGVsZW4uIFZvb3JhbCBkZSBMYXBpcyBTcGEgaXMgZWVuIGFhbnJhZGVyIG9tIGJpanZvb3JiZWVsZCBlZW4gbWFzc2FnZSBvZiBlZW4gZ2V6aWNodHNiZWhhbmRlbGluZyB0ZSBrcmlqZ2VuLiBPb2sgaHlkcm90aGVyYXBpZSBtZXQgdml0YWxpdGVpdHNiYWRlbiwga291ZGUgZHVpa3Nlc3NpZXMgZW4gYXJvbWF0aGVyYXBpZSBiZWhvcmVuIHRvdCBkZSBtb2dlbGlqa2hlZGVuLiBPcCBlZW4gYWN0aWV2ZSBtYW5pZXIgb250c3Bhbm5lbj8gRGF0IGthbiBpbiBoZXQgZml0bmVzc2NlbnRydW0gd2FhciBncmF0aXMgZ3JvZXBzbGVzc2VuIHdvcmRlbiBnZWdldmVuLlsvdmNfY29sdW1uX3RleHRdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiUG9wdWxhaXJlIGZhY2lsaXRlaXRlblwiIGhlYWRpbmdfdGFnPVwiaDNcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozMHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdGhiX2ljb25saXN0IGljb249XCJmYXMgZmEtbWFwLW1hcmtlci1hbHRcIiBsaXN0X2NvbnRlbnQ9XCIyNzc3IFMgTGFzIFZlZ2FzIEJvdWxldmFyZFwiXVt0aGJfaWNvbmxpc3QgaWNvbj1cImZhcyBmYS13aWZpXCIgbGlzdF9jb250ZW50PVwiV2lGaVwiXVt0aGJfaWNvbmxpc3QgaWNvbj1cImZhcyBmYS1zd2ltbWVyXCIgbGlzdF9jb250ZW50PVwiWndlbWJhZFwiXVt0aGJfaWNvbmxpc3QgaWNvbj1cImZhcyBmYS1iZWRcIiBsaXN0X2NvbnRlbnQ9XCJDb21mb3J0YWJlbGUgYmVkZGVuXCJdW3RoYl9pY29ubGlzdCBpY29uPVwiZmFzIGZhLXJ1bm5pbmdcIiBsaXN0X2NvbnRlbnQ9XCJHeW1cIl1bdGhiX2ljb25saXN0IGljb249XCJmYXMgZmEtc3BhXCIgbGlzdF9jb250ZW50PVwiV2VsbmVzc2NlbnRydW1cIl1bdGhiX2ljb25saXN0IGljb249XCJmYXMgZmEtdXRlbnNpbHNcIiBsaXN0X2NvbnRlbnQ9XCJSZXN0YXVyYW50XCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjI1cHhcIl1bdWx0X2J1dHRvbnMgYnRuX3RpdGxlPVwiQm9layBlZW4ga2FtZXJcIiBidG5fbGluaz1cInVybDpodHRwcyUzQSUyRiUyRnd3dy5ib29raW5nLmNvbSUyRmhvdGVsJTJGdXMlMkZmb250YWluZWJsZWF1LWxhcy12ZWdhcy1sYXMtdmVnYXM5OC5lbi5odG1sJTNGYWlkJTNENzk1ODQ5OCUyNm5vX3Jvb21zJTNEMSUyNmdyb3VwX2FkdWx0cyUzRDIlMjZsYWJlbCUzRGx1eGVob3RlbHNsYXN2ZWdhc2ZvbnRhaW5lYmxlYXV8dGl0bGU6Qm9layUyMGVlbiUyMGthbWVyfHRhcmdldDpfYmxhbmtcIiBidG5fdGl0bGVfY29sb3I9XCIjZmZmZmZmXCIgYnRuX2JnX2NvbG9yPVwiI2IzNGE0Y1wiIGJ0bl9ob3Zlcj1cInVidG4tYm90dG9tLWJnXCIgYnRuX2JnX2NvbG9yX2hvdmVyPVwiIzUzMWEyM1wiIGljb25fc2l6ZT1cIjMyXCIgYnRuX2ljb25fcG9zPVwidWJ0bi1zZXAtaWNvbi1hdC1sZWZ0XCIgYnRuX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIGJ0bl9mb250X3NpemU9XCJkZXNrdG9wOjIwcHg7XCIgYnRuX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDoyNXB4O1wiXVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIyLzNcIl1bdGhiX2ltYWdlX3NsaWRlciBsaWdodGJveD1cIm1mcC1nYWxsZXJ5XCIgdGhiX2VxdWFsX2hlaWdodD1cInRydWVcIiBhdXRvcGxheT1cInRydWVcIiBpbWFnZXM9XCIxOTUyOSwxOTUyOCwxOTUyNywxOTUyNlwiXVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiTm9idSBIb3RlbFwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjMwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF1IZXQgTm9idSBIb3RlbCBpbiBMYXMgVmVnYXMgYnJlbmd0IGplIGluIEphcGFuc2Ugc2ZlcmVuLiBPbnRkZWsgamUgemVuIHRpamRlbnMgZGUgbHV4ZSBvdmVybmFjaHRpbmcgaW4gaGV0IE5vYnUgSG90ZWwgaW4gTGFzIFZlZ2FzLiBLb20gdG90IHJ1c3QgZW4gZXJ2YWFyIGRlIHNwZWNpYWxlIGFhbmRhY2h0IHpvYWxzIGplIGRhdCBpbiBlZW4gYm9ldGlla2hvdGVsIG1hZyB2ZXJ3YWNodGVuLiBTZXJ2aWNlcyBhbHMgZWVuIGJ1dGxlciwgbGltb3VzaW5lIHZlcnZvZXIsIGVlbiB0dWluIGVuIGJ1YmJlbGJhZCBlbiBlZW4gVklQIGJlaGFuZGVsaW5nIGluIGhldCByZXN0YXVyYW50IHpvcmdlbiBlcnZvb3IgZGF0IGplIGdyYWFnIGluIGhldCBob3RlbCB3aWx0IGJsaWp2ZW4uIEplIGt1bnQgemVsZnMgZ2VuaWV0ZW4gdmFuIGVlbiBkaW5lciBvcCBqZSBrYW1lciBnZW1hYWt0IGRvb3IgZGUgTm9idSBjaGVmcy4gRW4gZGUgSmFwYW5zZSBIb2t1c2V0c3UgYnJvdXdlcmlqIGxhYXQgamUga2VubmlzbWFrZW4gbWV0IHplbGZnZWJyb3V3ZW4gYmllcnRqZXMuWy92Y19jb2x1bW5fdGV4dF1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJQb3B1bGFpcmUgZmFjaWxpdGVpdGVuXCIgaGVhZGluZ190YWc9XCJoM1wiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjMwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt0aGJfaWNvbmxpc3QgaWNvbj1cImZhcyBmYS1tYXAtbWFya2VyLWFsdFwiIGxpc3RfY29udGVudD1cIjQ0NTUgUGFyYWRpc2UgUm9hZFwiXVt0aGJfaWNvbmxpc3QgaWNvbj1cImZhcyBmYS13aWZpXCIgbGlzdF9jb250ZW50PVwiV2lGaVwiXVt0aGJfaWNvbmxpc3QgaWNvbj1cImZhcyBmYS1zd2ltbWVyXCIgbGlzdF9jb250ZW50PVwiWndlbWJhZFwiXVt0aGJfaWNvbmxpc3QgaWNvbj1cImZhcyBmYS1iaW5vY3VsYXJzXCIgbGlzdF9jb250ZW50PVwiUm9vZnRvcFwiXVt0aGJfaWNvbmxpc3QgaWNvbj1cImZhcyBmYS1iZWRcIiBsaXN0X2NvbnRlbnQ9XCJDb21mb3J0YWJlbGUgYmVkZGVuXCJdW3RoYl9pY29ubGlzdCBpY29uPVwiZmFzIGZhLXJ1bm5pbmdcIiBsaXN0X2NvbnRlbnQ9XCJHeW1cIl1bdGhiX2ljb25saXN0IGljb249XCJmYXMgZmEtc3BhXCIgbGlzdF9jb250ZW50PVwiV2VsbmVzc2NlbnRydW1cIl1bdGhiX2ljb25saXN0IGljb249XCJmYXMgZmEtdXRlbnNpbHNcIiBsaXN0X2NvbnRlbnQ9XCJSZXN0YXVyYW50XCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjI1cHhcIl1bdWx0X2J1dHRvbnMgYnRuX3RpdGxlPVwiQm9layBlZW4ga2FtZXJcIiBidG5fbGluaz1cInVybDpodHRwcyUzQSUyRiUyRnd3dy5ib29raW5nLmNvbSUyRmhvdGVsJTJGdXMlMkZub2J1LWF0LWNhZXNhcnMtcGFsYWNlLmVuLmh0bWwlM0ZhaWQlM0Q3OTU4NDk4JTI2bm9fcm9vbXMlM0QxJTI2Z3JvdXBfYWR1bHRzJTNEMiUyNmxhYmVsJTNEbHV4ZWhvdGVsc2xhc3ZlZ2Fzbm9idXx0aXRsZTpCb2VrJTIwZWVuJTIwa2FtZXJ8dGFyZ2V0Ol9ibGFua1wiIGJ0bl90aXRsZV9jb2xvcj1cIiNmZmZmZmZcIiBidG5fYmdfY29sb3I9XCIjYjM0YTRjXCIgYnRuX2hvdmVyPVwidWJ0bi1ib3R0b20tYmdcIiBidG5fYmdfY29sb3JfaG92ZXI9XCIjNTMxYTIzXCIgaWNvbl9zaXplPVwiMzJcIiBidG5faWNvbl9wb3M9XCJ1YnRuLXNlcC1pY29uLWF0LWxlZnRcIiBidG5fZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgYnRuX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjBweDtcIiBidG5fbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjI1cHg7XCJdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjIvM1wiXVt0aGJfaW1hZ2Vfc2xpZGVyIGxpZ2h0Ym94PVwibWZwLWdhbGxlcnlcIiB0aGJfZXF1YWxfaGVpZ2h0PVwidHJ1ZVwiIGF1dG9wbGF5PVwidHJ1ZVwiIGltYWdlcz1cIjE5NTMwLDE5NTMxLDE5NTMyLDE5NTMzXCJdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJUaGUgVmVuZXRpYW5cIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozMHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdVmVuZXRpXHUwMGViIGluIExhcyBWZWdhcy4gRXIgemlqbiB2ZWxlIHRoZW1hIGhvdGVscyBpbiBkZSBzdGFkIHRlIHZpbmRlbi4gRWVuIHZhbiBkZSBtZWVzdCBsdXhlIHRoZW1hIGhvdGVscyBpcyBUaGUgVmVuZXRpYW4sIGVlbiBlZXJiZXRvb24gYWFuIGRlIHN0YWQgVmVuZXRpXHUwMGViLiBNZXQgbWVlciBkYW4gNzAwMCBrYW1lcnMgaXMgaGV0IG9wIFx1MDBlOVx1MDBlOW4gbmEgZ3Jvb3RzdGUgaG90ZWwgdGVyIHdlcmVsZC4gUmVwbGljYSdzIGFscyBoZXQgU2FuIE1hcmNvcGxlaW4sIGthbmFsZW4gbWV0IGdvbmRlbGllcnMgZW4gZGUgQ2FuYWwgR3JhbmRlIGt1bm5lbiBuaWV0IG9udGJyZWtlbi4gVGhlIFZlbmV0aWFuIGlzIG5pZXQgYWxsZWVuIGx1eGUgb3Zlcm5hY2h0ZW4sIGhldCByZXNvcnQgaGVlZnQgb29rIHdpbmtlbHMsIGVlbiBmb29kY291cnQsIGVlbiB2YW4gZGUgYmVzdGUgQ2hpbmVzZSByZXN0YXVyYW50cyB2YW4gQW1lcmlrYSBlbiB6ZWxmcyBub2cgdmVyYm9yZ2VuIHBsZWtrZW4gem9hbHMgVGhvbWFzIEtlbGxlcidzIEJvdWNob24gb3AgZGUgMTBlIHZlcmRpZXBpbmcgdmFuIGRlIHRvcmVuLiBOYXR1dXJsaWprIGt1bm5lbiB2b29yemllbmluZ2VuIHpvYWxzIGVlbiBzcGEsIGZpdG5lc3MsIGVlbiBrbGltbXV1ciwgYWN1cHVuY3R1dXIgZW4gZ3JvdGUgaG90ZWxrYW1lcnMgbmlldCBvbnRicmVrZW4gaW4gZWVuIGhvdGVsIGFscyBkaXQuWy92Y19jb2x1bW5fdGV4dF1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJQb3B1bGFpcmUgZmFjaWxpdGVpdGVuXCIgaGVhZGluZ190YWc9XCJoM1wiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjMwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt0aGJfaWNvbmxpc3QgaWNvbj1cImZhcyBmYS1tYXAtbWFya2VyLWFsdFwiIGxpc3RfY29udGVudD1cIjM2MDAgUyBMYXMgVmVnYXMgQm91bGV2YXJkXCJdW3RoYl9pY29ubGlzdCBpY29uPVwiZmFzIGZhLXdpZmlcIiBsaXN0X2NvbnRlbnQ9XCJHcmF0aXMgV2lGaVwiXVt0aGJfaWNvbmxpc3QgaWNvbj1cImZhcyBmYS1zd2ltbWVyXCIgbGlzdF9jb250ZW50PVwiWndlbWJhZFwiXVt0aGJfaWNvbmxpc3QgaWNvbj1cImZhcyBmYS1iaW5vY3VsYXJzXCIgbGlzdF9jb250ZW50PVwiUm9vZnRvcFwiXVt0aGJfaWNvbmxpc3QgaWNvbj1cImZhcyBmYS1iZWRcIiBsaXN0X2NvbnRlbnQ9XCJDb21mb3J0YWJlbGUgYmVkZGVuXCJdW3RoYl9pY29ubGlzdCBpY29uPVwiZmFzIGZhLXJ1bm5pbmdcIiBsaXN0X2NvbnRlbnQ9XCJHeW1cIl1bdGhiX2ljb25saXN0IGljb249XCJmYXMgZmEtc3BhXCIgbGlzdF9jb250ZW50PVwiV2VsbmVzc2NlbnRydW1cIl1bdGhiX2ljb25saXN0IGljb249XCJmYXMgZmEtdXRlbnNpbHNcIiBsaXN0X2NvbnRlbnQ9XCJSZXN0YXVyYW50XCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjI1cHhcIl1bdWx0X2J1dHRvbnMgYnRuX3RpdGxlPVwiQm9layBlZW4ga2FtZXJcIiBidG5fbGluaz1cInVybDpodHRwcyUzQSUyRiUyRnd3dy5ib29raW5nLmNvbSUyRmhvdGVsJTJGdXMlMkZ0aGUtdmVuZXRpYW4tcmVzb3J0LWNhc2luby5lbi5odG1sJTNGYWlkJTNENzk1ODQ5OCUyNm5vX3Jvb21zJTNEMSUyNmdyb3VwX2FkdWx0cyUzRDIlMjZsYWJlbCUzRGx1eGVob3RlbHNsYXN2ZWdhc3ZlbmV0aWFufHRpdGxlOkJvZWslMjBlZW4lMjBrYW1lcnx0YXJnZXQ6X2JsYW5rXCIgYnRuX3RpdGxlX2NvbG9yPVwiI2ZmZmZmZlwiIGJ0bl9iZ19jb2xvcj1cIiNiMzRhNGNcIiBidG5faG92ZXI9XCJ1YnRuLWJvdHRvbS1iZ1wiIGJ0bl9iZ19jb2xvcl9ob3Zlcj1cIiM1MzFhMjNcIiBpY29uX3NpemU9XCIzMlwiIGJ0bl9pY29uX3Bvcz1cInVidG4tc2VwLWljb24tYXQtbGVmdFwiIGJ0bl9mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBidG5fZm9udF9zaXplPVwiZGVza3RvcDoyMHB4O1wiIGJ0bl9saW5lX2hlaWdodD1cImRlc2t0b3A6MjVweDtcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMi8zXCJdW3RoYl9pbWFnZV9zbGlkZXIgbGlnaHRib3g9XCJtZnAtZ2FsbGVyeVwiIHRoYl9lcXVhbF9oZWlnaHQ9XCJ0cnVlXCIgYXV0b3BsYXk9XCJ0cnVlXCIgaW1hZ2VzPVwiMTk1MjIsMTk1MjMsMTk1MjQsMTk1MjVcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW5dW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIld5bm4gVmlsbGFcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozMHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdVmFuIGNhc2lubyBob3RlbCBuYWFyIHJlc29ydC4gRGF0IHdlcmQgaGV0IFd5bm4gaG90ZWwgaW4gMjAwNSB0b2VuIGVyIGVlbiBnb2xmYmFhbiBhY2h0ZXIgaGV0IGhvdGVsIHdlcmQgZ2VvcGVuZC4gVGVnZWxpamtlcnRpamQgd2VyZGVuIG9vayBwcml2XHUwMGU5bWVyZW4gZW4gd2F0ZXJ2YWxsZW4gZ2VjcmVcdTAwZWJlcmQgYmlqIGhldCBob3RlbC4gV3lubiBpcyBvcCBlbiB0b3AgZ2xhbW91ciwgamUgZ2FhdCBuaWV0IG5hYXIgTGFzIFZlZ2FzLCBtYWFyIGplIGdhYXQgbmFhciBXeW5uLiBJbiBkZSBrYW1lcnMgdmluZCBqZSBvcCBtYWF0IG9udHdvcnBlbiBtZXViaWxhaXIsIHdhcm1lIGhvdXRlbiBhY2NlbnRlbiBlbiB2ZXJzY2hpbGxlbmRlIGt1bnN0d2Vya2VuLiBWZXJnZWV0IG5pZXQgZGF0IFd5bm4gb29rIG5vZyBlZW5zIG92ZXIgZXhjZWxsZW50ZSByZXN0YXVyYW50cyBiZXNjaGlrdC4gRGVsaWxhaCBkb2V0IGRlbmtlbiBhYW4gaGV0IGdvdWRlbiB0aWpkcGVyayB2YW4gZGUgc3RhZCBoYWx2ZXJ3ZWdlIGRlIGVldXcuIE5hdHV1cmxpamsga3VubmVuIHNwZWNpYWxlIGNvY2t0YWlsYmFycyBuaWV0IG9udGJyZWtlbi4gRGVuayBhYW4gQWZ0IENvY2t0YWlsIERlY2sgZGF0IGdlXHUwMGVmbnNwaXJlZXJkIGlzIG9wIGhldCBqYWNodGxldmVuLiBPZiBraWprIHVpdCBvdmVyIExha2Ugb2YgRHJlYW0gbWV0IGVlbiBjb2NrdGFpbCBpbiBqZSBoYW5kLlsvdmNfY29sdW1uX3RleHRdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiUG9wdWxhaXJlIGZhY2lsaXRlaXRlblwiIGhlYWRpbmdfdGFnPVwiaDNcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozMHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdGhiX2ljb25saXN0IGljb249XCJmYXMgZmEtbWFwLW1hcmtlci1hbHRcIiBsaXN0X2NvbnRlbnQ9XCIzMTMyIExhcyBWZWdhcyBCb3VsZXZhcmRcIl1bdGhiX2ljb25saXN0IGljb249XCJmYXMgZmEtd2lmaVwiIGxpc3RfY29udGVudD1cIldpRmlcIl1bdGhiX2ljb25saXN0IGljb249XCJmYXMgZmEtc3dpbW1lclwiIGxpc3RfY29udGVudD1cIlp3ZW1iYWRcIl1bdGhiX2ljb25saXN0IGljb249XCJmYXMgZmEtYmlub2N1bGFyc1wiIGxpc3RfY29udGVudD1cIlJvb2Z0b3BcIl1bdGhiX2ljb25saXN0IGljb249XCJmYXMgZmEtYmVkXCIgbGlzdF9jb250ZW50PVwiQ29tZm9ydGFiZWxlIGJlZGRlblwiXVt0aGJfaWNvbmxpc3QgaWNvbj1cImZhcyBmYS1ydW5uaW5nXCIgbGlzdF9jb250ZW50PVwiR3ltXCJdW3RoYl9pY29ubGlzdCBpY29uPVwiZmFzIGZhLXV0ZW5zaWxzXCIgbGlzdF9jb250ZW50PVwiUmVzdGF1cmFudFwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIyNXB4XCJdW3VsdF9idXR0b25zIGJ0bl90aXRsZT1cIkJvZWsgZWVuIGthbWVyXCIgYnRuX2xpbms9XCJ1cmw6aHR0cHMlM0ElMkYlMkZ3d3cuYm9va2luZy5jb20lMkZob3RlbCUyRnVzJTJGd3lubi1sYXMtdmVnYXMtYm91bGV2YXJkLmVuLmh0bWwlM0ZhaWQlM0Q3OTU4NDk4JTI2bm9fcm9vbXMlM0QxJTI2Z3JvdXBfYWR1bHRzJTNEMiUyNmxhYmVsJTNEbHV4ZWhvdGVsc2xhc3ZlZ2Fzd3lubnx0aXRsZTpCb2VrJTIwZWVuJTIwa2FtZXJ8dGFyZ2V0Ol9ibGFua1wiIGJ0bl90aXRsZV9jb2xvcj1cIiNmZmZmZmZcIiBidG5fYmdfY29sb3I9XCIjYjM0YTRjXCIgYnRuX2hvdmVyPVwidWJ0bi1ib3R0b20tYmdcIiBidG5fYmdfY29sb3JfaG92ZXI9XCIjNTMxYTIzXCIgaWNvbl9zaXplPVwiMzJcIiBidG5faWNvbl9wb3M9XCJ1YnRuLXNlcC1pY29uLWF0LWxlZnRcIiBidG5fZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgYnRuX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjBweDtcIiBidG5fbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjI1cHg7XCJdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjIvM1wiXVt0aGJfaW1hZ2Vfc2xpZGVyIGxpZ2h0Ym94PVwibWZwLWdhbGxlcnlcIiB0aGJfZXF1YWxfaGVpZ2h0PVwidHJ1ZVwiIGF1dG9wbGF5PVwidHJ1ZVwiIGltYWdlcz1cIjE5NTE3LDE5NTE4LDE5NTE5LDE5NTIwXCJdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNzVweFwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIkxhcyBWZWdhcyB0aXBzXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiI2IzNGE0Y1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDo0NXB4O1wiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NTBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjI1cHhcIl1bdGhiX3Bvc3RncmlkIHN0eWxlPVwic3R5bGU0XCIgY29sdW1ucz1cIjRcIiBzb3VyY2U9XCJzaXplOjh8cG9zdF90eXBlOnBvc3R8YnlfaWQ6MTk0NzgsMTc5MzAsMTQ2NjAsNDM0OFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XSIsInBvc3RfdGl0bGUiOiJEZSBtZWVzdCBsdXh1ZXV6ZSByZXNvcnRzIGluIExhcyBWZWdhcyIsInBvc3RfbGluayI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvbHV4dWV1emUtaG90ZWxzLWxhcy12ZWdhcy8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJMdXh1ZXV6ZSByZXNvcnRzIGluIExhcyBWZWdhc1wiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyNC8wMy9sdXhlLWhvdGVscy1pbi1sYXMtdmVnYXMtMzAweDIwMC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj4iLCJwb3N0X2NhdGVnb3JpZXMiOiJMYXMgVmVnYXMiLCJwb3N0X3RhZ3MiOiIiLCIlaW5saW5lX2ZlYXR1cmVkX2ltYWdlJSI6IjAiLCIlX2VkaXRfbG9jayUiOiIxNzExNTM5Njg5OjIiLCIlX2VkaXRfbGFzdCUiOiIyIiwiJV95b2FzdF93cHNlb19wcmltYXJ5X2NhdGVnb3J5JSI6IjUzIiwiJV90aHVtYm5haWxfaWQlIjoiMTk1NDAiLCIlX2hpZGVfZmVhdHVyZWQlIjpudWxsLCIlX3dwZ21wX2xvY2F0aW9uX2FkZHJlc3MlIjoiOSBDcm9zYnkgU3QsIE5ldyBZb3JrLCBOWSAxMDAxMywgVmVyZW5pZ2RlIFN0YXRlbiIsIiVfd3BnbXBfbG9jYXRpb25fY2l0eSUiOiJOZXcgWW9yayIsIiVfd3BnbXBfbG9jYXRpb25fc3RhdGUlIjoiTmV3IFlvcmsiLCIlX3dwZ21wX2xvY2F0aW9uX2NvdW50cnklIjoiVmVyZW5pZ2RlIFN0YXRlbiIsIiVfd3BnbXBfbWV0YWJveF9sYXRpdHVkZSUiOiI0MC43MTk4MzUzNjI5NTQ5MjUiLCIlX3dwZ21wX21ldGFib3hfbG9uZ2l0dWRlJSI6Ii03NC4wMDAwODQ5ODY1MDgxNyIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiN1wiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6ImE6MTp7aTowO3M6MjpcIjEzXCI7fSIsIiVfd3BnbXBfbWV0YWJveF90YXhvbW9taWVzX3Rlcm1zJSI6IiIsIiVfd3BnbXBfZXh0ZW5zaW9uc19maWVsZHMlIjoiIiwiJV93cGJfdmNfanNfc3RhdHVzJSI6InRydWUiLCIlX3lvYXN0X3dwc2VvX2NvbnRlbnRfc2NvcmUlIjoiMzAiLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza2V5d29yZHMlIjoiW10iLCIlX3lvYXN0X3dwc2VvX2tleXdvcmRzeW5vbnltcyUiOiJbXCJsdXhlIGhvdGVscyBsYXMgdmVnYXNcIl0iLCIlX3lvYXN0X3dwc2VvX2VzdGltYXRlZC1yZWFkaW5nLXRpbWUtbWludXRlcyUiOiI2IiwiJXBvc3QtcHJpbWFyeS1jYXRlZ29yeSUiOiJhdXRvIiwiJWZlYXR1cmVkX2ltYWdlX292ZXJyaWRlJSI6Im9mZiIsIiVzdGFuZGFyZC1mZWF0dXJlZC1jcmVkaXQlIjoiIiwiJWFydGljbGVfc3R5bGVfb3ZlcnJpZGUlIjoib24iLCIlcG9zdF9zdHlsZSUiOiJzdHlsZTUiLCIlcG9zdF9nYWxsZXJ5X3N0eWxlJSI6ImxpZ2h0Ym94IiwiJXBvc3RfcmV2aWV3JSI6Im9mZiIsIiVwb3N0X3Jldmlld19zdHlsZSUiOiJzdHlsZTEiLCIlcG9zdF9yZXZpZXdfYXZlcmFnZSUiOiI1MCIsIiVfeW9hc3Rfd3BzZW9fZm9jdXNrdyUiOiJEZSBtZWVzdCBsdXh1ZXV6ZSByZXNvcnRzIGluIExhcyBWZWdhcyIsIiVfeW9hc3Rfd3BzZW9fbWV0YWRlc2MlIjoiRGUgbWVlc3QgbHV4dWV1emUgcmVzb3J0cyBpbiBMYXMgVmVnYXMsIGRpdCB6aWpuIGRlIGJlc3RlIHBsZWtrZW4gb20gdGUgb3Zlcm5hY2h0ZW4gaW4gbHV4ZSBpbiBMYXMgVmVnYXMuIiwiJV95b2FzdF93cHNlb19saW5rZGV4JSI6Ijc2IiwiJXBvc3Rfc291cmNlJSI6IiIsIiVfeW9hc3RfaW5kZXhub3dfbGFzdF9waW5nJSI6IjE3MTE1Mzk2NjEiLCIlX3d3c19zdXBwb3J0X2NvbnRhY3RfbnVtYmVyJSI6IiIsIiVfd3dzX2Fib3V0X3N1cHBvcnRfdGV4dCUiOiIiLCIlX3d3c190cmlnZ2VyX2J1dHRvbl90ZXh0JSI6IiIsIiVfd3dzX3ByZWRlZmluZWRfdGV4dCUiOiIiLCIlX3lvYXN0X3dwc2VvX3dvcmRwcm9vZl90aW1lc3RhbXAlIjoiIiwiJWV4ZWN1dGl2ZV9zdW1tYXJ5JSI6IkRlbGZ0cyBibGF1dyBwYXN0IGJpaiBqb3UhIiwiJV9sYXN0X2VkaXRvcl91c2VkX2pldHBhY2slIjoiY2xhc3NpYy1lZGl0b3IiLCIlYWN0aXZlZXJfc3VibWVudSUiOiIwIiwiJV9hY3RpdmVlcl9zdWJtZW51JSI6ImZpZWxkXzY1OTNmNTIxZTk3YzIiLCIlcG9zdF92aWElIjpbeyJ0aXRsZSI6IlJlc29ydHMgV29ybGQiLCJwb3N0X3NvdXJjZV91cmwiOiJodHRwczovL3d3dy5yd2xhc3ZlZ2FzLmNvbS8ifSx7InRpdGxlIjoiRm9udGFpbmVibGVhdSIsInBvc3Rfc291cmNlX3VybCI6Imh0dHBzOi8vd3d3LmZvbnRhaW5lYmxlYXVsYXN2ZWdhcy5jb20vIn0seyJ0aXRsZSI6Ik5vYnUiLCJwb3N0X3NvdXJjZV91cmwiOiJodHRwczovL3d3dy5jYWVzYXJzLmNvbS9ub2J1LWNhZXNhcnMtcGFsYWNlIn0seyJ0aXRsZSI6IlRoZSBWZW5ldGlhbiIsInBvc3Rfc291cmNlX3VybCI6Imh0dHBzOi8vd3d3LnZlbmV0aWFubGFzdmVnYXMuY29tLyJ9LHsidGl0bGUiOiJUaGUgV3lubiIsInBvc3Rfc291cmNlX3VybCI6IiJ9XSwidGF4b25vbXk9Y2F0ZWdvcnkiOiJMYXMgVmVnYXMiLCJ0YXhvbm9teT1wb3N0X3RhZyI6IiIsInRheG9ub215PXBvc3RfZm9ybWF0IjoiIiwidGF4b25vbXk9dGhiLXJlYWN0aW9ucyI6IiIsInRheG9ub215PXRoYi1zcG9uc29ycyI6IiJ9LCJpY29uIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMS8wNC9ob3RlbC5wbmcifSwiaWQiOjE5NTE0LCJpbmZvd2luZG93X2Rpc2FibGUiOmZhbHNlLCJjYXRlZ29yaWVzIjpbeyJpY29uIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMS8wNC9ob3RlbC5wbmciLCJuYW1lIjoiSG90ZWxzIiwiaWQiOiIxMyIsInR5cGUiOiJjYXRlZ29yeSIsImV4dGVuc2lvbl9maWVsZHMiOnsiY2F0X29yZGVyIjoiIn19XX0seyJzb3VyY2UiOiJwb3N0IiwidGl0bGUiOiJWYWxsZXkgb2YgdGhlIEdvZHMiLCJpbmZvd2luZG93X2NvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nIFwiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJWYWxsZXkgb2YgdGhlIEdvZHNcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjIwMFwiIHNyYz1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjQvMDMvdmFsbGV5LW9mLXRoZS1nb2RzLTMwMHgyMDAuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZ1wiPlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nIGZjLWl0ZW0tbm8tcGFkZGluZ1wiPlxyXG4gICAgICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS10aXRsZSBmYy1pdGVtLXByaW1hcnktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZVwiPlZhbGxleSBvZiB0aGUgR29kczwvZGl2PlxyXG4gICAgICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1jb250ZW50IGZjLWl0ZW0tYm9keS10ZXh0LWNvbG9yXCI+e21hcmtlcl9hZGRyZXNzfTwvZGl2PlxyXG4gICAgICAgIDwvZGl2PlxyXG4gICAgPC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtY2xlYXJcIj48L2Rpdj5cclxuPC9kaXY+IiwiYWRkcmVzcyI6IlZhbGxleSBvZiB0aGUgR29kcywgVXRhaCA4NDUzMSwgVmVyZW5pZ2RlIFN0YXRlbiIsImxvY2F0aW9uIjp7ImxhdCI6IjM3LjI2NjY2NzkwMDAwMDAxIiwic3RhdGUiOiJVdGFoIiwiY291bnRyeSI6IlZlcmVuaWdkZSBTdGF0ZW4iLCJsbmciOiItMTA5LjgzNDAxMzYiLCJvbmNsaWNrX2FjdGlvbiI6Im1hcmtlciIsInJlZGlyZWN0X3Blcm1hbGluayI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvdmFsbGV5LW9mLXRoZS1nb2RzLyIsInpvb20iOjEyLCJleHRyYV9maWVsZHMiOnsicG9zdF9leGNlcnB0IjoiIiwicG9zdF9jb250ZW50IjoiW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIl1bdmNfY29sdW1uIHdpZHRoPVwiMS8yXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjEwMCVcIl1bdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS8yXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJWYWxsZXkgb2YgdGhlIEdvZHMgaW4gVXRhaFwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTozNXx0ZXh0X2FsaWduOmxlZnR8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdUmlqZCBqZSB0dXNzZW4gPGEgaHJlZj1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd2F0LXRlLWRvZW4taW4tbW9hYi9cIj5Nb2FiPC9hPiBlbiBNb251bWVudCBWYWxsZXk/IERhbiBpcyBkZSByb3V0ZSBkb29yIFZhbGxleSBvZiB0aGUgR29kcyBlZW4gYWFucmFkZXIgb20gdGUgbmVtZW4uIEhldCBpcyBlZW4ga2xlaW5lIG9td2VnLCBtYWFyIGVlbiBkaWUgemVrZXIgZGUgbW9laXRlIHdhYXJkIGlzLiBWYWxsZXkgb2YgdGhlIEdvZHMgaXMgZWVuIGtsZWluZXJlIHZlcnNpZSB2YW4gTW9udW1lbnQgVmFsbGV5LCBlZW4gc3R1ayBtaW5kZXIgYmVrZW5kIGVuIGRhYXJkb29yIGlzIGhldCBlciBtaW5kZXIgZHJ1ay4gT3ZlcmFsIHdhYXIgamUga2lqa3QgemllIGplIHJvZGUgcm90c2Zvcm1hdGllcywgYnV0dGVzLCBtZXNhJ3MgZW4gdG9yZW5zcGl0c2VuLiBFZW4gaW5kcnVrd2Vra2VuZCBsYW5kc2NoYXAgZGF0IGplIHBlciBhdXRvIGt1bnQgdmVya2VubmVuLlsvdmNfY29sdW1uX3RleHRdW3VsdGltYXRlX2ljb25fbGlzdCBpY29uX3NpemU9XCIyMFwiXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtYXV0b21vYmlsZSBjYXJcIl03MDAga2lsb21ldGVyIHZhbmFmIExhcyBWZWdhc1svdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy1jbG9jay1vXCJdMzY1IGRhZ2VuIHBlciBqYWFyWy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLWRvbGxhciB1c2RcIl1HcmF0aXNbL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtdGh1bWJzLXVwXCJdQmVzdGUgcGVyaW9kZTogbGVudGUgZW4gaGVyZnN0Wy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLXRyZWVcIl08c3BhbiBjbGFzcz1cIkxyelhyIGtuby1mdlwiPjM5MCBrbTI8L3NwYW4+Wy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bL3VsdGltYXRlX2ljb25fbGlzdF1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIGNzcz1cIi52Y19jdXN0b21fMTYwODY2NjUxOTQ5MntiYWNrZ3JvdW5kLWNvbG9yOiAjZWFlYWVhICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMi8zXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIk1pZGRsZSBvZiBOb3doZXJlIGdldm9lbFwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTozNXx0ZXh0X2FsaWduOmNlbnRlcnxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1FZW4gYmV6b2VrIGFhbiBWYWxsZXkgb2YgdGhlIEdvZHMgdm9lbHQgdm9vcmFsIGFsc29mIGplIGluIHRoZSBtaWRkbGUgb2Ygbm93aGVyZSBzdGFhdC4gSG9ld2VsIGhldCBnZWJpZWQgZ3JvdGVuZGVlbHMgbGlqa3Qgb3AgaGV0IHBvcHVsYWlyZSA8YSBocmVmPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9tb251bWVudC12YWxsZXkvXCI+TW9udW1lbnQgVmFsbGV5PC9hPiwgaXMgaGV0IGVyIHJ1c3RpZ2VyLiBFciBsb29wdCBlZW4gb252ZXJoYXJkZSB3ZWcgZG9vciBoZXQgZ2ViaWVkLCBoZXQgaXMgZ2VlbiBkb29yZ2FhbmRlIHdlZywgbWVuc2VuIG1vZXRlbiBlciBlZW4gc3R1a2plIHZvb3Igb21yaWpkZW4uIERlIHRvdGFsZSBsZW5ndGUgaXMgMjcga2lsb21ldGVyIGVuIHJlZGVsaWprIGJlZ2FhbmJhYXIgbWV0IGdvZWQgd2Vlci4gSmUga3VudCBlciBpbiBwcmluY2lwZSBvdmVyaGVlbiBtZXQgZWVuIGdld29uZSBodXVyYXV0bywgaGlnaCBjbGVhcmFuY2Ugd29yZHQgd2VsIGFhbmdlcmFkZW4uIEhldCBtb29pc3RlIGdlZGVlbHRlIHZpbmQgamUgcm9uZG9tIENhc3RsZSBCdXR0ZSB3YWFyIGplICdtZXNhIHdhbGxzJyBlbiByb3RzZm9ybWF0aWVzIGt1bnQgdmluZGVuLiBEZSBiZXJvZW1kc3RlIHJvdHNmb3JtYXRpZSBpcyBNZXhpY2FuIEhhdHQgZGllIGplIHppZXQgdmFuYWYgVVMtMTYzLlsvdmNfY29sdW1uX3RleHRdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI3NXB4XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIiBmdWxsX3dpZHRoPVwic3RyZXRjaF9yb3dcIiBjb250ZW50X3RleHRfYWxpZ21lbnQ9XCJjZW50ZXJcIiBjc3M9XCIudmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9XCIgcGFyYWxsYXhfYmFja2dyb3VuZF9pbWFnZT1cIjM4MzZcIl1bdmNfY29sdW1uIHRoYl9jb2xvcj1cInRoYi1saWdodC1jb2x1bW5cIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJTY2VuaWMgRHJpdmVcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6NzV8dGV4dF9hbGlnbjpjZW50ZXJ8Y29sb3I6JTIzZmZmZmZmfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW2hleXVzYV9oZWFkaW5nIHRhZz1cImRpdlwiIHRleHRfYWxpZ249XCJjZW50ZXJcIiBoZWFkaW5nPVwiSW4gVmFsbGV5IG9mIHRoZSBHb2RzXCIgZm9udF9zaXplPVwiNTBcIiBsaW5lX2hlaWdodD1cIjUwXCIgZm9udF9jb2xvcj1cIiNmZmZmZmZcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bcGFyYWxsYXhfcm93IGVuYWJsZV9tb2JpbGU9XCJwYXJhbGxheC1lbmFibGUtbW9iaWxlXCIgaW1hZ2U9XCIxOTQ2MVwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCJdW3ZjX2NvbHVtbl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvM1wiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiSG9lIGtvbSBqZSBiaWogVmFsbGV5IG9mIHRoZSBHb2RzP1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZToyNXx0ZXh0X2FsaWduOmxlZnRcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XUplIHZpbmR0IFZhbGxleSBvZiB0aGUgR29kcyBvcCBkZSB3ZWcgdHVzc2VuIE1vYWIgZW4gTW9udW1lbnQgVmFsbGV5LiBXYW5uZWVyIGplIEhpZ2h3YXkgMTYzIG5lZW10LCBrb20gamUgbmEgZW5rZWxlIGtpbG9tZXRlcnMgaGV0IHBsYWF0c2plIEJsdWZmIHRlZ2VuLCBoaWVybmEgbmVlbSBqZSByZWNodHNhZiBkZSBTY2VuaWMgRHJpdmUuIE92ZXIgZGV6ZSB3ZWcgZG9lIGplIG9uZ2V2ZWVyIGVlbiB1dXJ0amUsIGhvZXdlbCBzdG9wcGVuIG9tIGZvdG8ncyB0ZSBtYWtlbiBuYXR1dXJsaWprIG1vZ2VsaWprIGlzLiBOYSBkZSBTY2VuaWMgRHJpdmUga29tIGplIHVpdCBvcCBIaWdod2F5IDI2MSB2YW53YWFyIGplIGRvb3Iga3VudCBuYWFyIE1vbnVtZW50IFZhbGxleS4gT21kYXQgZXIgaW4gaGV0IGdlYmllZCBnZWVuIGZhY2lsaXRlaXRlbiB6aWpuIGlzIGhldCBoYW5kaWcgb20gd2F0IGV4dHJhIHZvb3JyYWRlbiBtZWUgdGUgbmVtZW4uWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8zXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJPdmVybmFjaHRlbiBpbiBkZSBidXVydFwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZToyNXx0ZXh0X2FsaWduOmxlZnRcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XVZhbGxleSBvZiB0aGUgR29kcyBpcyBlaWdlbmxpamsgYWxsZWVuIGdlc2NoaWt0IG9tIGRvb3JoZWVuIHRlIHJpamRlbiwgb3Zlcm5hY2h0ZW4gaW4gaGV0IG5hdHV1cmdlYmllZCBrYW4gaGVsYWFzIG5pZXQuIERhYXJ2b29yIGJlbiBqZSBhYW5nZXdlemVuIG9wIHBsYWF0c2VuIGFscyBCbHVmZiB3YWFyIGplIGJpanZvb3JiZWVsZCBoZXQgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmJvb2tpbmcuY29tL2hvdGVsL3VzL2JsdWZmLWR3ZWxsaW5ncy1yZXNvcnQtYmx1ZmYuZW4uaHRtbD9haWQ9Nzk1ODQ5OCZhbXA7bm9fcm9vbXM9MSZhbXA7Z3JvdXBfYWR1bHRzPTJ2YWxsZXlvZnRoZWdvZHNibHVmZlwiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+Qmx1ZmYgRHdlbGxpbmdzIFJlc29ydDwvYT4gb2YgaGV0IDxhIGhyZWY9XCJodHRwczovL3d3dy5ib29raW5nLmNvbS9ob3RlbC91cy9kZXNlcnQtcm9zZS1pbm4tY2FiaW5zLmVuLmh0bWw/YWlkPTc5NTg0OTgmYW1wO25vX3Jvb21zPTEmYW1wO2dyb3VwX2FkdWx0cz0yZGVzZXJ0cm9zZXJlc29ydFwiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+RGVzZXJ0IFJvc2UgUmVzb3J0PC9hPiB2aW5kdCBvbSB0ZSBvdmVybmFjaHRlbi4gUmlqZCBqZSByaWNodGluZyBNb251bWVudCBWYWxsZXk/IERhbiBrdW4gamUgb3Zlcm5hY2h0ZW4gYmlqIDxhIGhyZWY9XCJodHRwczovL3d3dy5ib29raW5nLmNvbS9ob3RlbC91cy9nb3VsZGluZy1zLWxvZGdlLmVuLmh0bWw/YWlkPTc5NTg0OTgmYW1wO25vX3Jvb21zPTEmYW1wO2dyb3VwX2FkdWx0cz0yZ291bGRpbmdcIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPkdvdWxkaW5nJ3MgTG9kZ2U8L2E+LlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvM1wiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiQmVzdGUgcmVpc3BlcmlvZGUgb20gVmFsbGV5IG9mIHRoZSBHb2RzIHRlIGJlem9la2VuXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjI1fHRleHRfYWxpZ246bGVmdFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdVmFsbGV5IG9mIHRoZSBHb2RzIGlzIGhldCBoZWxlIGphYXIgZ2VvcGVuZC4gRGUgYmVzdGUgcGVyaW9kZSBvbSBWYWxsZXkgb2YgdGhlIEdvZHMgdGUgYmV6b2VrZW4gaXMgaW4gZGUgbGVudGUgb2YgZGUgaGVyZnN0LiBJbiBkZSB6b21lcm1hYW5kZW4gaXMgaGV0IGVyZyB3YXJtIGluIGhldCBnZWJpZWQgZW4gZXIgemlqbiBnZWVuIGZhY2lsaXRlaXRlbiBhYW53ZXppZy4gRGFhcm5hYXN0IGlzIGhldCBvb2sgaGV0IHNlaXpvZW4gdmFuIGRlIG1vZXNzb24uIEhldCBtb29pc3RlIG1vbWVudCB2YW4gZGUgZGFnIGlzIGVlbiB6b25zb3Brb21zdCBvZiB6b25zb25kZXJnYW5nLiBIZXQgaXMgZ29lZCBvbSByZWtlbmluZyB0ZSBob3VkZW4gbmF0IHdlZXIsIGRlIHdlZ2VuIHppam4gZGFuIG1pbmRlciBnb2VkIGJlZ2FhbmJhYXIuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiIGZ1bGxfd2lkdGg9XCJzdHJldGNoX3Jvd1wiIGNvbnRlbnRfdGV4dF9hbGlnbWVudD1cImNlbnRlclwiIGNzcz1cIi52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O31cIiBwYXJhbGxheF9iYWNrZ3JvdW5kX2ltYWdlPVwiMzgzNlwiXVt2Y19jb2x1bW4gdGhiX2NvbG9yPVwidGhiLWxpZ2h0LWNvbHVtblwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkRlIHByYWNodGlnZSByb2RlIHJvdHNmb3JtYXRpZXNcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6NzV8dGV4dF9hbGlnbjpjZW50ZXJ8Y29sb3I6JTIzZmZmZmZmfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW2hleXVzYV9oZWFkaW5nIHRhZz1cImRpdlwiIHRleHRfYWxpZ249XCJjZW50ZXJcIiBoZWFkaW5nPVwiTmV0IHpvIGluZHJ1a3dla2tlbmQgYWxzIE1vbnVtZW50IFZhbGxleT9cIiBmb250X3NpemU9XCI1MFwiIGxpbmVfaGVpZ2h0PVwiNTBcIiBmb250X2NvbG9yPVwiI2ZmZmZmZlwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVtwYXJhbGxheF9yb3cgZW5hYmxlX21vYmlsZT1cInBhcmFsbGF4LWVuYWJsZS1tb2JpbGVcIiBpbWFnZT1cIjE5NDYwXCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI3NXB4XCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIyLzNcIl1baGV5dXNhX2hlYWRpbmcgdGFnPVwiZGl2XCIgdGV4dF9hbGlnbj1cImNlbnRlclwiIGhlYWRpbmc9XCJPbnRkZWsgbWVlciBuYXR1dXIgaW4gZGUgYnV1cnRcIiBmb250X3NpemU9XCI0MFwiIGxpbmVfaGVpZ2h0PVwiNDBcIiBmb250X2NvbG9yPVwiIzI4MjgyOFwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIk5vZyBtZWVyIFV0YWhcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMjgyODI4XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6NDBweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDo0NXB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjI1cHhcIl1bdGhiX3Bvc3RiYWNrZ3JvdW5kIHN0eWxlPVwic3R5bGUyXCIgc291cmNlPVwiYnlfaWQ6LTE2MTkyLC0xNjIwNCwtMTYxNzQsLTE2MTI2LC0xNTY0NCwtMTU2MTQsLTE1NTgwLC0xMjYyLC0yMjY3LC01NzIsLTU0NSwxODkxNiw0MTk1LDEyNzMsNDgxN1wiXVsvdmNfY29sdW1uXVsvdmNfcm93XSIsInBvc3RfdGl0bGUiOiJWYWxsZXkgb2YgdGhlIEdvZHMiLCJwb3N0X2xpbmsiOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3ZhbGxleS1vZi10aGUtZ29kcy8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJWYWxsZXkgb2YgdGhlIEdvZHNcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjIwMFwiIHNyYz1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjQvMDMvdmFsbGV5LW9mLXRoZS1nb2RzLTMwMHgyMDAuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+IiwicG9zdF9jYXRlZ29yaWVzIjoiTmF0dXVyZ2ViaWVkZW4iLCJwb3N0X3RhZ3MiOiJVdGFoIiwiJV93cGJfc2hvcnRjb2Rlc19jdXN0b21fY3NzJSI6Ii52Y19jdXN0b21fMTYwODY2NjUxOTQ5MntiYWNrZ3JvdW5kLWNvbG9yOiAjZWFlYWVhICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9IiwiJWlubGluZV9mZWF0dXJlZF9pbWFnZSUiOiIwIiwiJV9lZGl0X2xvY2slIjoiMTcxMTAxMzcyMToyIiwiJV9lZGl0X2xhc3QlIjoiMiIsIiVfaGlkZV9mZWF0dXJlZCUiOm51bGwsIiVfd3BiX3ZjX2pzX3N0YXR1cyUiOiJ0cnVlIiwiJXBvc3QtcHJpbWFyeS1jYXRlZ29yeSUiOiJhdXRvIiwiJWZlYXR1cmVkX2ltYWdlX292ZXJyaWRlJSI6Im9mZiIsIiVhcnRpY2xlX3N0eWxlX292ZXJyaWRlJSI6Im9uIiwiJXBvc3Rfc3R5bGUlIjoic3R5bGUxMSIsIiVwb3N0X2dhbGxlcnlfc3R5bGUlIjoibGlnaHRib3giLCIlcG9zdF9yZXZpZXclIjoib2ZmIiwiJXBvc3RfcmV2aWV3X3N0eWxlJSI6InN0eWxlMSIsIiVwb3N0X3Jldmlld19hdmVyYWdlJSI6IjUwIiwiJV95b2FzdF93cHNlb19jb250ZW50X3Njb3JlJSI6IjkwIiwiJV95b2FzdF93cHNlb19mb2N1c2tleXdvcmRzJSI6IltdIiwiJV95b2FzdF93cHNlb19rZXl3b3Jkc3lub255bXMlIjoiW1wiQm9ubmV2aWxsZSBTYWx0IEZsYXRzIFV0YWhcIl0iLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza3clIjoiVmFsbGV5IG9mIHRoZSBHb2RzIiwiJV95b2FzdF93cHNlb19tZXRhZGVzYyUiOiJPbnRkZWsgVmFsbGV5IG9mIHRoZSBHb2RzIGluIGRlIHN0YWF0IFV0YWguIEJlbmlldXdkIHdhdCBqZSBlciBrdW50IGRvZW4/IFRpcHMgdm9vciBlZW4gYmV6b2VrIGFhbiBkZSBWYWxsZXkgb2YgdGhlIEdvZHMuIiwiJV95b2FzdF93cHNlb19saW5rZGV4JSI6IjgyIiwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6IlZhbGxleSBvZiB0aGUgR29kcywgVXRhaCA4NDUzMSwgVmVyZW5pZ2RlIFN0YXRlbiIsIiVfd3BnbXBfbG9jYXRpb25fY2l0eSUiOiIiLCIlX3dwZ21wX2xvY2F0aW9uX3N0YXRlJSI6IlV0YWgiLCIlX3dwZ21wX2xvY2F0aW9uX2NvdW50cnklIjoiVmVyZW5pZ2RlIFN0YXRlbiIsIiVfd3BnbXBfbWV0YWJveF9sYXRpdHVkZSUiOiIzNy4yNjY2Njc5MDAwMDAwMSIsIiVfd3BnbXBfbWV0YWJveF9sb25naXR1ZGUlIjoiLTEwOS44MzQwMTM2IiwiJV93cGdtcF9tZXRhYm94X2xvY2F0aW9uX3JlZGlyZWN0JSI6Im1hcmtlciIsIiVfd3BnbXBfbWV0YWJveF9jdXN0b21fbGluayUiOiIiLCIlX3dwZ21wX21hcF9pZCUiOiJhOjE6e2k6MDtzOjE6XCI3XCI7fSIsIiVfd3BnbXBfbWV0YWJveF9tYXJrZXJfaWQlIjoiIiwiJV93cGdtcF9tZXRhYm94X3RheG9tb21pZXNfdGVybXMlIjoiIiwiJV93cGdtcF9leHRlbnNpb25zX2ZpZWxkcyUiOiIiLCIlX3lvYXN0X3dwc2VvX2VzdGltYXRlZC1yZWFkaW5nLXRpbWUtbWludXRlcyUiOiI0IiwiJV95b2FzdF93cHNlb19wcmltYXJ5X2NhdGVnb3J5JSI6IjIyNyIsIiVfeW9hc3Rfd3BzZW9fdGl0bGUlIjoiVmFsbGV5IG9mIHRoZSBHb2RzICUlcGFnZSUlICUlc2VwJSUgJSVzaXRlbmFtZSUlIiwiJV93d3Nfc3VwcG9ydF9jb250YWN0X251bWJlciUiOiIiLCIlX3d3c19hYm91dF9zdXBwb3J0X3RleHQlIjoiIiwiJV93d3NfdHJpZ2dlcl9idXR0b25fdGV4dCUiOiIiLCIlX3d3c19wcmVkZWZpbmVkX3RleHQlIjoiIiwiJV95b2FzdF93cHNlb193b3JkcHJvb2ZfdGltZXN0YW1wJSI6IiIsIiVfeW9hc3RfaW5kZXhub3dfbGFzdF9waW5nJSI6IjE3MTEwMTMwODQiLCIlX2xhc3RfZWRpdG9yX3VzZWRfamV0cGFjayUiOiJjbGFzc2ljLWVkaXRvciIsIiVzdGFuZGFyZC1mZWF0dXJlZC1jcmVkaXQlIjoiIiwiJV90aHVtYm5haWxfaWQlIjoiMTk0NjIiLCIlYWN0aXZlZXJfc3VibWVudSUiOiIwIiwiJV9hY3RpdmVlcl9zdWJtZW51JSI6ImZpZWxkXzY1OTNmNTIxZTk3YzIiLCIlX3dwX29sZF9kYXRlJSI6IjIwMjQtMDItMDYiLCIlX3lvYXN0X3dwc2VvX29wZW5ncmFwaC1kZXNjcmlwdGlvbiUiOiJPbnRkZWsgVmFsbGV5IG9mIHRoZSBHb2RzIGluIGRlIHN0YWF0IFV0YWguIEJlbmlldXdkIHdhdCBqZSBlciBrdW50IGRvZW4/IFRpcHMgdm9vciBlZW4gYmV6b2VrIGFhbiBkZSBWYWxsZXkgb2YgdGhlIEdvZHMuIiwidGF4b25vbXk9Y2F0ZWdvcnkiOiJOYXR1dXJnZWJpZWRlbiIsInRheG9ub215PXBvc3RfdGFnIjoiVXRhaCIsInRheG9ub215PXBvc3RfZm9ybWF0IjoiIiwidGF4b25vbXk9dGhiLXJlYWN0aW9ucyI6IiIsInRheG9ub215PXRoYi1zcG9uc29ycyI6IiJ9fSwiaWQiOjE5NDU4LCJpbmZvd2luZG93X2Rpc2FibGUiOmZhbHNlfSx7InNvdXJjZSI6InBvc3QiLCJ0aXRsZSI6IlJlZCBSb2NrIENhbnlvbiBTdGF0ZSBQYXJrIiwiaW5mb3dpbmRvd19jb250ZW50IjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZyBcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiUmVkIFJvY2sgQ2FueW9uIFN0YXRlIHBhcmtcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjIwMFwiIHNyYz1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjQvMDMvcmVkLXJvY2stY2FueW9uLXJvdHNmb3JtYXRpZS0zMDB4MjAwLmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmdcIj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZyBmYy1pdGVtLW5vLXBhZGRpbmdcIj5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tdGl0bGUgZmMtaXRlbS1wcmltYXJ5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2VcIj5SZWQgUm9jayBDYW55b24gU3RhdGUgUGFyazwvZGl2PlxyXG4gICAgICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1jb250ZW50IGZjLWl0ZW0tYm9keS10ZXh0LWNvbG9yXCI+e21hcmtlcl9hZGRyZXNzfTwvZGl2PlxyXG4gICAgICAgIDwvZGl2PlxyXG4gICAgPC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtY2xlYXJcIj48L2Rpdj5cclxuPC9kaXY+IiwiYWRkcmVzcyI6IjM3NzQ5IEFiYm90dCBEciwgQ2FudGlsLCBDQSA5MzUxOSwgVmVyZW5pZ2RlIFN0YXRlbiIsImxvY2F0aW9uIjp7ImxhdCI6IjM1LjM4NDM3MTgiLCJjaXR5IjoiQ2FudGlsIiwic3RhdGUiOiJDYWxpZm9ybmlhIiwiY291bnRyeSI6IlZlcmVuaWdkZSBTdGF0ZW4iLCJsbmciOiItMTE3Ljk2MjMxOTUiLCJvbmNsaWNrX2FjdGlvbiI6Im1hcmtlciIsInJlZGlyZWN0X3Blcm1hbGluayI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvcmVkLXJvY2stY2FueW9uLXN0YXRlLXBhcmsvIiwiem9vbSI6MTIsImV4dHJhX2ZpZWxkcyI6eyJwb3N0X2V4Y2VycHQiOiIiLCJwb3N0X2NvbnRlbnQiOiJbdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiMTAwJVwiXVt2Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIlJlZCBSb2NrIENhbnlvbiBTdGF0ZSBQYXJrIGluIENhbGlmb3JuaVx1MDBlYlwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTozNXx0ZXh0X2FsaWduOmxlZnR8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdT3Agem9layBuYWFyIGVlbiBvbmJla2VuZCBuYXR1dXJnZWJpZWQgaW4gQ2FsaWZvcm5pXHUwMGViPyBCZXpvZWsgZGFuIGhldCBSZWQgUm9jayBDYW55b24gU3RhdGUgUGFyayBpbiBDYWxpZm9ybmlcdTAwZWIuIEplIHZpbmR0IGluIGRpdCBwYXJrIGVlbiBjb21iaW5hdGllIHR1c3NlbiA8YSBocmVmPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9qb3NodWEtdHJlZS1uYXRpb25hbC1wYXJrL1wiPkpvc2h1YSBUcmVlPC9hPiBlbiA8YSBocmVmPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9icnljZS1jYW55b24tbmF0aW9uYWwtcGFyay9cIj5CcnljZSBDYW55b24gTmF0aW9uYWwgUGFyazwvYT4uIEVyIHppam4gZW5rZWxlIG1vZ2VsaWpraGVkZW4gdG90IHdhbmRlbGVuIGVuIGhldCBpcyBlZW4gZ29lZGUgcGxlayBvbSBzdGVycmVuIHRlIGtpamtlbi4gT250ZGVrIGRlIHdvZXN0aWpua2xpZmZlbiwgcm90c2Zvcm1hdGllcywgdmVyZHdhYWxkZSBjYWN0dXNzZW4gZW4gaG9vZG9vcyB2YW4gaGV0IFJlZCBSb2NrIENhbnlvbiBTdGF0ZSBQYXJrIGluIENhbGlmb3JuaVx1MDBlYi5bL3ZjX2NvbHVtbl90ZXh0XVt1bHRpbWF0ZV9pY29uX2xpc3QgaWNvbl9zaXplPVwiMjBcIl1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLWF1dG9tb2JpbGUgY2FyXCJdMTkxIGtpbG9tZXRlciB2YW5hZiBMb3MgQW5nZWxlc1svdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy10cmVlXCJdPHNwYW4gY2xhc3M9XCJMcnpYciBrbm8tZnZcIj4xMTAga21cdTAwYjIgb3BwZXJ2bGFrdGU8L3NwYW4+Wy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLXBhd1wiXTM4IHZlcnNjaGlsbGVuZGUgc29vcnRlbiB6b29nZGllcmVuWy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bL3VsdGltYXRlX2ljb25fbGlzdF1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIGNzcz1cIi52Y19jdXN0b21fMTYwODY2NjUxOTQ5MntiYWNrZ3JvdW5kLWNvbG9yOiAjZWFlYWVhICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMi8zXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkVlbiBzdHVramUgYWNodGVyZ3JvbmQgdmFuIGhldCBSZWQgUm9jayBDYW55b24gU3RhdGUgUGFya1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTozNXx0ZXh0X2FsaWduOmNlbnRlcnxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1cclxuPHAgc3R5bGU9XCJ0ZXh0LWFsaWduOiBjZW50ZXI7XCI+SmUgdmluZHQgUmVkIFJvY2sgQ2FueW9uIFN0YXRlIFBhcmsgaW4gQ2FsaWZvcm5pXHUwMGViIGluIGhldCB1aXRlcnN0ZSB6dWlkZW4gdmFuIGRlIDxhIGhyZWY9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3NpZXJyYS1uZXZhZGEtY2FsaWZvcm5pZS9cIj5TaWVycmEgTmV2YWRhPC9hPi4gSGV0IGdlYmllZCB3YXMgb29pdCBkZSB0aHVpc2Jhc2lzIHZhbiBkZSBLYXdhaWlzdSBiZXZvbGtpbmcuIEVyIHppam4gcm90c3Rla2VuaW5nZW4gZW4gcGljdG9ncmFtbWVuIGdldm9uZGVuIGluIGhldCBFbCBQYXNvIGdlYmVyZ3RlLiBEZXplIHZlcnRlZ2Vud29vcmRpZ2VuIHJpdHVlbGUgbG9jYXRpZXMgdmFuIGRlIHZvb3JvdWRlcnMgdmFuIGhldCBDb3NvIHZvbGssIGRlIHZyb2VnZSBpbmhlZW1zZSBiZXdvbmVycy4gRGV6ZSBwZXRyb2dsaWVmZW4gemlqbiBub2cgc3RlZWRzIHRlIHppZW4gaW4gaGV0IHBhcmsuIEluIGRlIHZyb2VnZSBqYXJlbiAnNzAgZGllbmRlbiBkZSByb2RlIHJvdHNmb3JtYXRpZXMgYWxzIGhlcmtlbm5pbmdzcHVudCB2b29yIGRlIGhhbmRlbHNyb3V0ZXMgZGllIGRvb3IgaGV0IGdlYmllZCBsaWVwZW4uIFNpbmRzIGRlIGphcmVuICczMCB3b3JkdCBoZXQgcGFyayBnZWJydWlrdCBhbHMgZmlsbWxvY2F0aWUgdm9vciA8YSBocmVmPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9sb3MtYW5nZWxlcy9ob2xseXdvb2QvXCI+SG9sbHl3b29kPC9hPiBwcm9kdWN0aWVzLiBEZW5rIGFhbiBmaWxtcyBhbHMgSnVyYXNzaWMgUGFyaywgVGhlIE11bW15IGVuIEJlbmVhdGggdGhlIFBsYW5ldCBvZiB0aGUgQXBlcyBkaWUgaGllciBvcGdlbm9tZW4gd2VyZGVuLjwvcD5cclxuWy92Y19jb2x1bW5fdGV4dF1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiIGZ1bGxfd2lkdGg9XCJzdHJldGNoX3Jvd1wiIGNvbnRlbnRfdGV4dF9hbGlnbWVudD1cImNlbnRlclwiIGNzcz1cIi52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O31cIiBwYXJhbGxheF9iYWNrZ3JvdW5kX2ltYWdlPVwiMzgzNlwiXVt2Y19jb2x1bW4gdGhiX2NvbG9yPVwidGhiLWxpZ2h0LWNvbHVtblwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIlJlZCBSb2NrIENhbnlvbiBTdGF0ZSBQYXJrXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjc1fHRleHRfYWxpZ246Y2VudGVyfGNvbG9yOiUyM2ZmZmZmZnxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVtoZXl1c2FfaGVhZGluZyB0YWc9XCJoNFwiIHRleHRfYWxpZ249XCJjZW50ZXJcIiBoZWFkaW5nPVwiSW5kcnVrd2Vra2VuZGUgcm9kZSByb3RzZm9ybWF0aWVzXCIgZm9udF9zaXplPVwiNTBcIiBsaW5lX2hlaWdodD1cIjFcIiBmb250X2NvbG9yPVwiI2ZmZmZmZlwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVtwYXJhbGxheF9yb3cgZW5hYmxlX21vYmlsZT1cInBhcmFsbGF4LWVuYWJsZS1tb2JpbGVcIiBpbWFnZT1cIjE5NDE5XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIl1bdmNfY29sdW1uXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJIb2Uga29tIGplIGJpaiBSZWQgUm9jayBDYW55b24gU3RhdGUgUGFyaz9cIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MjV8dGV4dF9hbGlnbjpsZWZ0XCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1KZSB2aW5kdCBSZWQgUm9jayBDYW55b24gU3RhdGUgUGFyayBpbiBDYW50aWwsIENhbGlmb3JuaVx1MDBlYiAobmlldCB0ZSB2ZXJ3YXJyZW4gbWV0IFJlZCBSb2NrIENhbnlvbiBOYXRpb25hbCBDb25zZXJ2YXRpb24gQXJlYSBuYWJpaiBMYXMgVmVnYXMpLiBEZSBkaWNodHN0YmlqemlqbmRlIGdyb3RlcmUgc3RhZCBpcyBCYWtlcnNmaWVsZCBvcCBpZXRzIG1lZXIgZGFuIGVlbiB1dXIgcmlqZGVuLiA8YSBocmVmPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9sb3MtYW5nZWxlcy9cIj5Mb3MgQW5nZWxlczwvYT4gbGlndCBvcCAyIHV1ciByaWpkZW4gaW4genVpZHdlc3RlbGlqa2UgcmljaHRpbmcuIEhpZXJkb29yIGt1biBqZSBoZXQgcGFyayBiZXpvZWtlbiBhbHMgZWVuIDxhIGhyZWY9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL2RhZ3RyaXBzLWxvcy1hbmdlbGVzL1wiPmRhZ3RyaXAgdmFudWl0IExvcyBBbmdlbGVzPC9hPi5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIldhdCB0ZSBkb2VuIGluIGhldCBSZWQgUm9jayBDYW55b24gU3RhdGUgUGFya1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZToyNXx0ZXh0X2FsaWduOmxlZnRcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XUluIGhldCBSZWQgUm9jayBDYW55b24gU3RhdGUgUGFyayBrdW4gamUga2VubmlzbWFrZW4gbWV0IHJvZGUgcm90c2Zvcm1hdGllcyBkaWUgamUgdm9vcmFsIGtlbnQgdmFuIGRlIG5hdHV1cmdlYmllZGVuIGluIFV0YWguIEplIHZpbmR0IGVyIHJvdHN0ZWtlbmluZ2VuIGRpZSBhY2h0ZXJnZWxhdGVuIHppam4gZG9vciBkZSBLYXdhaWlzdSBpbmRpYW5lbiBlbiBlZW4gdmVybGF0ZW4gb3VkZSBtaWpuIGJpaiBPcGFsIFJvYWQgQ2FueW9uLiBPbSBoZXQgcGFyayB0ZSB2ZXJrZW5uZW4gbWV0IGRlIGF1dG8sIGlzIGVlbiA0V0Qgbm9kaWcuIEhpZXJtZWUga3VuIGplIGJlemllbnN3YWFyZGlnaGVkZW4gem9hbHMgUmVkIFJvb3N0ZXIsIFJlZCBDbGlmZnMsIFNjZW5pYyBDbGlmZnMgZW4gSGFnZW4gQ2FueW9uIGJlem9la2VuLiBFciB6aWpuIG1vZ2VsaWpraGVkZW4gb20gaGV0IHBhcmsgd2FuZGVsZW5kIHRlIHZlcmtlbm5lbi4gRGFhcm5hYXN0IGlzIGhldCBnZWJpZWQgdnJpaiB2YW4gbGljaHR2ZXJ2dWlsaW5nICdzIG5hY2h0cywgZWVuIHBlcmZlY3RlIHBsZWsgdm9vciBzdGVycmVua2lqa2VuLlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJPdmVybmFjaHRlbiBpbiBoZXQgUmVkIFJvY2sgQ2FueW9uIFN0YXRlIFBhcmtcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MjV8dGV4dF9hbGlnbjpsZWZ0XCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1JbiBkZSBidXVydCB2YW4gaGV0IHBhcmsgemlqbiBhbGxlZW4gNTAgcHJpbWl0aWV2ZSBrYW1wZWVycGxla2tlbiBvcCBSaWNhcmRvIENhbXBncm91bmQsIHplIGhlYmJlbiBvdmVyaWdlbnMgd2VsIGZhbnRhc3Rpc2NoIHVpdHppY2h0IG9wIGRlIHJvdHNmb3JtYXRpZXMuIEVyIHppam4gdG9pbGV0dGVuLCB3YXRlciwgcGxla2tlbiB2b29yIHZ1dXIgZW4gdGFmZWxzIGJlc2NoaWtiYWFyLiBIZXQgd2Vya3Qgdm9sZ2VucyBoZXQgcHJpbmNpcGUgZmlyc3QtY29tZS1maXJzdC1zZXJ2ZWQuIFdpbCBqZSBvdmVybmFjaHRlbiBpbiBlZW4gaG90ZWwgb2YgYW5kZXJlIGFjY29tbW9kYXRpZT8gRGFuIHppam4gPGEgaHJlZj1cImh0dHBzOi8vd3d3LmJvb2tpbmcuY29tL3NlYXJjaHJlc3VsdHMuZW4uaHRtbD9jaXR5PTIwMDExNDYwJmFtcDthaWQ9Nzk1ODQ5OCZhbXA7bm9fcm9vbXM9MSZhbXA7Z3JvdXBfYWR1bHRzPTImYW1wO2xhYmVsPXJlZHJvY2tjYW55b25zdGF0ZXBhcmtiYWtlcnNmaWVsZFwiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+QmFrZXJzZmllbGQ8L2E+LCA8YSBocmVmPVwiaHR0cHM6Ly93d3cuYm9va2luZy5jb20vc2VhcmNocmVzdWx0cy5lbi5odG1sP2NpdHk9MjAwMTU1MzkmYW1wO2FpZD03OTU4NDk4JmFtcDtub19yb29tcz0xJmFtcDtncm91cF9hZHVsdHM9MiZhbXA7bGFiZWw9cmVkcm9ja2NhbnlvbnN0YXRlcGFya3JpZGdlY3Jlc3RcIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPlJpZGdlY3Jlc3Q8L2E+IGVuIDxhIGhyZWY9XCJodHRwczovL3d3dy5ib29raW5nLmNvbS9zZWFyY2hyZXN1bHRzLmVuLmh0bWw/Y2l0eT0yMDAxNDE4MSZhbXA7YWlkPTc5NTg0OTgmYW1wO25vX3Jvb21zPTEmYW1wO2dyb3VwX2FkdWx0cz0yJmFtcDtsYWJlbD1yZWRyb2NrY2FueW9uc3RhdGVwYXJrbGFcIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPkxvcyBBbmdlbGVzPC9hPiBvcHRpZXMuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJCZXN0ZSBwZXJpb2RlIHZvb3IgZWVuIGJlem9layBhYW4gaGV0IFJlZCBSb2NrIENhbnlvbiBTdGF0ZSBQYXJrXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjI1fHRleHRfYWxpZ246bGVmdFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdRGUgYmVzdGUgcGVyaW9kZSBvbSBoZXQgcGFyayB0ZSBiZXpvZWtlbiBpcyBkZSBsYXRlIGhlcmZzdCwgd2ludGVyIGVuIHZyb2VnZSBsZW50ZS4gSW4gZGUgem9tZXJtYWFuZGVuIGlzIGhldCBlY2h0IHRlIHdhcm0gb20gaGV0IHBhcmsgdGUgdmVya2VubmVuLCBkZSB0ZW1wZXJhdHVyZW4gbGlnZ2VuIHR1c3NlbiBkZSAzNS00MCBncmFkZW4uIEluIGRlIHdpbnRlciBoZWIgamUga2FucyBvcCB0ZW1wZXJhdHVyZW4gcm9uZCBkZSAxNSBncmFkZW4sIGRlIGxlbnRlIGVuIGhlcmZzdCB0dXNzZW4gZGUgMjAtMjUgZ3JhZGVuLlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIiBmdWxsX3dpZHRoPVwic3RyZXRjaF9yb3dcIiBjb250ZW50X3RleHRfYWxpZ21lbnQ9XCJjZW50ZXJcIiBjc3M9XCIudmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9XCIgcGFyYWxsYXhfYmFja2dyb3VuZF9pbWFnZT1cIjM4MzZcIl1bdmNfY29sdW1uIHRoYl9jb2xvcj1cInRoYi1saWdodC1jb2x1bW5cIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiV2lsZGxpZmUgaW4gUmVkIFJvY2sgQ2FueW9uIFN0YXRlIFBhcmtcIiBoZWFkaW5nX3RhZz1cInBcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjZmZmZmZmXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6NDVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDo1NXB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMTBweFwiXVtoZXl1c2FfaGVhZGluZyB0YWc9XCJoNFwiIHRleHRfYWxpZ249XCJjZW50ZXJcIiBoZWFkaW5nPVwiU3BvdCBkZSBoYWdlZGlzXCIgZm9udF9zaXplPVwiNTBcIiBsaW5lX2hlaWdodD1cIjFcIiBmb250X2NvbG9yPVwiI2ZmZmZmZlwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVtwYXJhbGxheF9yb3cgZW5hYmxlX21vYmlsZT1cInBhcmFsbGF4LWVuYWJsZS1tb2JpbGVcIiBpbWFnZT1cIjE5NDIzXCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjc3M9XCIudmNfY3VzdG9tXzE2MDg2NjY4ODU0OTd7YmFja2dyb3VuZC1pbWFnZTogdXJsKGh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjAvMDgvYmFja2dyb3VuZC1oZXl1c2EtbmF0dXVyLTEuZ2lmP2lkPTMwODgpICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW5dW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiV2FuZGVsZW4gaW4gaGV0IFJlZCBSb2NrIENhbnlvbiBTdGF0ZSBQYXJrXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzAwMDAwMFwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjU1cHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF1IZXQgaXMgbW9nZWxpamsgb20gZWVuIGFhbnRhbCB3YW5kZWxpbmdlbiB0ZSBtYWtlbiBpbiBoZXQgcGFyay4gRXIgemlqbiBnZW1ha2tlbGlqa2Ugd2FuZGVsaW5nZW4gZW4gd2FuZGVsaW5nZW4gbWV0IGlldHMgbWVlciB1aXRkYWdpbmcuIEFscyBqZSBnYWF0IHdhbmRlbGVuLCBnYSBkYW4gem8gdnJvZWcgbW9nZWxpamsgb3AgcGFkLCBkYW4gYmVuIGplIG9wIGhldCBoZWV0c3QgdmFuIGRlIGRhZyB3ZWVyIHRlcnVnLiBEZSByb3V0ZXMgaW4gaGV0IHBhcms6XHJcbjx1bD5cclxuIFx0PGxpPlJlZCBDbGlmZnMgVHJhaWwgfCAxLDYga2lsb21ldGVyIHwgbWFra2VsaWprPC9saT5cclxuIFx0PGxpPkhhZ2VuIENhbnlvbiB8IDIga2lsb21ldGVyIHwgbWFra2VsaWprPC9saT5cclxuIFx0PGxpPlJpY2FyZG8gQ2FtcGdyb3VuZCBUcmFpbCB8IDIsMiBraWxvbWV0ZXIgfCBtYWtrZWxpams8L2xpPlxyXG4gXHQ8bGk+TmlnaHRtYXJlIEd1bGNoIExvb3AgfCAxMyw4IGtpbG9tZXRlciB8IGdlbWlkZGVsZDwvbGk+XHJcbiBcdDxsaT5CdXJybyBTY2htaWR0J3MgVHVubmVsIHwgMTYsNCBraWxvbWV0ZXIgfCBnZW1pZGRlbGQ8L2xpPlxyXG48L3VsPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJIYW5kaWdlIGluZm8gdm9vciBqZSBiZXpvZWtcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMDAwMDAwXCIgYWxpZ25tZW50PVwibGVmdFwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6Um9ib3RvIFNsYWJ8Zm9udF9jYWxsOlJvYm90bytTbGFifHZhcmlhbnQ6ODAwXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDo1NXB4O1wiIG1haW5faGVhZGluZ19zdHlsZT1cImZvbnQtd2VpZ2h0OjgwMDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3VsdGltYXRlX2ljb25fbGlzdCBpY29uX3NpemU9XCIyNVwiXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtY2xvY2stb1wiIGNvbnRlbnRfZm9udF9zaXplPVwiZGVza3RvcDoxNnB4O1wiXTM2NSBkYWdlbiBnZW9wZW5kLCAyNC83Wy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLXRodW1icy11cFwiIGNvbnRlbnRfZm9udF9zaXplPVwiZGVza3RvcDoxNnB4O1wiXUJlc3RlIHBlcmlvZGU6IGxlbnRlIGVuIGhlcmZzdFsvdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy1kb2xsYXIgdXNkXCIgY29udGVudF9mb250X3NpemU9XCJkZXNrdG9wOjE2cHg7XCJdJDZbL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVsvdWx0aW1hdGVfaWNvbl9saXN0XVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIiBmdWxsX3dpZHRoPVwic3RyZXRjaF9yb3dcIiBjb250ZW50X3RleHRfYWxpZ21lbnQ9XCJjZW50ZXJcIiBjc3M9XCIudmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9XCIgcGFyYWxsYXhfYmFja2dyb3VuZF9pbWFnZT1cIjM4MzZcIl1bdmNfY29sdW1uIHRoYl9jb2xvcj1cInRoYi1saWdodC1jb2x1bW5cIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiUm9kZSByb3RzZm9ybWF0aWVzXCIgaGVhZGluZ190YWc9XCJwXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiI2ZmZmZmZlwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjQ1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NTVweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjEwcHhcIl1baGV5dXNhX2hlYWRpbmcgdGFnPVwiaDRcIiB0ZXh0X2FsaWduPVwiY2VudGVyXCIgaGVhZGluZz1cIlpvdmVyIGplIGt1bnQga2lqa2VuXCIgZm9udF9zaXplPVwiNTBcIiBsaW5lX2hlaWdodD1cIjFcIiBmb250X2NvbG9yPVwiI2ZmZmZmZlwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVtwYXJhbGxheF9yb3cgZW5hYmxlX21vYmlsZT1cInBhcmFsbGF4LWVuYWJsZS1tb2JpbGVcIiBpbWFnZT1cIjE5NDI0XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIl1bdmNfY29sdW1uXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJNZWVyIENhbGlmb3JuaVx1MDBlYjpcIiBmb250X2NvbnRhaW5lcj1cInRhZzpkaXZ8Zm9udF9zaXplOjQwfHRleHRfYWxpZ246Y2VudGVyXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt0aGJfcG9zdGdyaWQgc3R5bGU9XCJzdHlsZTExXCIgY29sdW1ucz1cIjRcIiBzb3VyY2U9XCJwb3N0X3R5cGU6cG9zdHxieV9pZDotMTg5NTYsLTE4OTM5LC0xODkzMiwtMTczMTgsLTE1MDYyLC0xNDkwNywtMTQyNTAsLTEzNTg3LC0xMjUwNCwtMTE5OTcsLTk5ODAsLTg3NDIsLTQ3OTIsLTQ3MzgsLTQ3MTQsLTQ2ODksLTQ1NzQsLTMyMDgsLTMwMTQsLTE5NzEsNDU1NiwxODgwOSw0NzAwLDE4MzgxXCJdWy92Y19jb2x1bW5dWy92Y19yb3ddIiwicG9zdF90aXRsZSI6IlJlZCBSb2NrIENhbnlvbiBTdGF0ZSBQYXJrIiwicG9zdF9saW5rIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9yZWQtcm9jay1jYW55b24tc3RhdGUtcGFyay8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJSZWQgUm9jayBDYW55b24gU3RhdGUgcGFya1wiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyNC8wMy9yZWQtcm9jay1jYW55b24tcm90c2Zvcm1hdGllLTMwMHgyMDAuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+IiwicG9zdF9jYXRlZ29yaWVzIjoiU3RhdGUgUGFya3MiLCJwb3N0X3RhZ3MiOiJDYWxpZm9ybmlcdTAwZWIiLCIlX3dwYl9zaG9ydGNvZGVzX2N1c3RvbV9jc3MlIjoiLnZjX2N1c3RvbV8xNjA4NjY2NTE5NDkye2JhY2tncm91bmQtY29sb3I6ICNlYWVhZWEgIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE2MDg2NjY4ODU0OTd7YmFja2dyb3VuZC1pbWFnZTogdXJsKGh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjAvMDgvYmFja2dyb3VuZC1oZXl1c2EtbmF0dXVyLTEuZ2lmP2lkPTMwODgpICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O30iLCIlaW5saW5lX2ZlYXR1cmVkX2ltYWdlJSI6IjAiLCIlX2VkaXRfbG9jayUiOiIxNzEwODYxMTk3OjIiLCIlX2VkaXRfbGFzdCUiOiIyIiwiJV90aHVtYm5haWxfaWQlIjoiMTk0MjAiLCIlX2hpZGVfZmVhdHVyZWQlIjpudWxsLCIlX3dwYl92Y19qc19zdGF0dXMlIjoidHJ1ZSIsIiVwb3N0LXByaW1hcnktY2F0ZWdvcnklIjoiYXV0byIsIiVmZWF0dXJlZF9pbWFnZV9vdmVycmlkZSUiOiJvZmYiLCIlYXJ0aWNsZV9zdHlsZV9vdmVycmlkZSUiOiJvbiIsIiVwb3N0X3N0eWxlJSI6InN0eWxlMTEiLCIlcG9zdF9nYWxsZXJ5X3N0eWxlJSI6ImxpZ2h0Ym94IiwiJXBvc3RfcmV2aWV3JSI6Im9mZiIsIiVwb3N0X3Jldmlld19zdHlsZSUiOiJzdHlsZTEiLCIlcG9zdF9yZXZpZXdfYXZlcmFnZSUiOiI1MCIsIiVfeW9hc3Rfd3BzZW9fY29udGVudF9zY29yZSUiOiI2MCIsIiVfeW9hc3Rfd3BzZW9fZm9jdXNrZXl3b3JkcyUiOiJbXSIsIiVfeW9hc3Rfd3BzZW9fa2V5d29yZHN5bm9ueW1zJSI6IltcIlwiXSIsIiVfeW9hc3Rfd3BzZW9fZm9jdXNrdyUiOiJSZWQgUm9jayBDYW55b24gU3RhdGUgUGFyayIsIiVfeW9hc3Rfd3BzZW9fbWV0YWRlc2MlIjoiSW4gQ2FsaWZvcm5pXHUwMGViIHZpbmQgamUgaGV0IFJlZCBSb2NrIENhbnlvbiBTdGF0ZSBQYXJrLCBoZXQgcGFyayB2YW4gZGUgcm9kZSByb3RzZm9ybWF0aWVzLiBUaXBzIHZvb3IgUmVkIFJvY2sgQ2FueW9uIFN0YXRlIFBhcmsiLCIlX3lvYXN0X3dwc2VvX2xpbmtkZXglIjoiNzciLCIlX3dwZ21wX2xvY2F0aW9uX2FkZHJlc3MlIjoiMzc3NDkgQWJib3R0IERyLCBDYW50aWwsIENBIDkzNTE5LCBWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9sb2NhdGlvbl9jaXR5JSI6IkNhbnRpbCIsIiVfd3BnbXBfbG9jYXRpb25fc3RhdGUlIjoiQ2FsaWZvcm5pYSIsIiVfd3BnbXBfbG9jYXRpb25fY291bnRyeSUiOiJWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9tZXRhYm94X2xhdGl0dWRlJSI6IjM1LjM4NDM3MTgiLCIlX3dwZ21wX21ldGFib3hfbG9uZ2l0dWRlJSI6Ii0xMTcuOTYyMzE5NSIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiN1wiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6IiIsIiVfd3BnbXBfbWV0YWJveF90YXhvbW9taWVzX3Rlcm1zJSI6IiIsIiVfd3BnbXBfZXh0ZW5zaW9uc19maWVsZHMlIjoiIiwiJV95b2FzdF93cHNlb19lc3RpbWF0ZWQtcmVhZGluZy10aW1lLW1pbnV0ZXMlIjoiNSIsIiVfeW9hc3Rfd3BzZW9fcHJpbWFyeV9jYXRlZ29yeSUiOiIxNzAiLCIlX3d3c19zdXBwb3J0X2NvbnRhY3RfbnVtYmVyJSI6IiIsIiVfd3dzX2Fib3V0X3N1cHBvcnRfdGV4dCUiOiIiLCIlX3d3c190cmlnZ2VyX2J1dHRvbl90ZXh0JSI6IiIsIiVfd3dzX3ByZWRlZmluZWRfdGV4dCUiOiIiLCIlX3lvYXN0X3dwc2VvX3dvcmRwcm9vZl90aW1lc3RhbXAlIjoiIiwiJV95b2FzdF9pbmRleG5vd19sYXN0X3BpbmclIjoiMTcxMDg2MTI5OCIsIiVfbGFzdF9lZGl0b3JfdXNlZF9qZXRwYWNrJSI6ImNsYXNzaWMtZWRpdG9yIiwiJV93cF9vbGRfZGF0ZSUiOiIyMDIzLTA5LTIyIiwiJV93cF9vbGRfc2x1ZyUiOiJzYWd1YXJvLW5hdGlvbmFsLXBhcmsiLCIlYWN0aXZlZXJfc3VibWVudSUiOiIwIiwiJV9hY3RpdmVlcl9zdWJtZW51JSI6ImZpZWxkXzY1OTNmNTIxZTk3YzIiLCJ0YXhvbm9teT1jYXRlZ29yeSI6IlN0YXRlIFBhcmtzIiwidGF4b25vbXk9cG9zdF90YWciOiJDYWxpZm9ybmlcdTAwZWIiLCJ0YXhvbm9teT1wb3N0X2Zvcm1hdCI6IiIsInRheG9ub215PXRoYi1yZWFjdGlvbnMiOiIiLCJ0YXhvbm9teT10aGItc3BvbnNvcnMiOiIifX0sImlkIjoxOTQxMywiaW5mb3dpbmRvd19kaXNhYmxlIjpmYWxzZX0seyJzb3VyY2UiOiJwb3N0IiwidGl0bGUiOiJCZXpvZWsgZGUgZmlsbXN0dWRpbyYjODIxNztzIGluIExvcyBBbmdlbGVzIiwiaW5mb3dpbmRvd19jb250ZW50IjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZyBcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiQmV6b2VrIGRlIGZpbG1zdHVkaW9zIGluIGxvcyBhbmdlbGVzXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMDBcIiBzcmM9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDI0LzAzL2ZpbG1zdHVkaW9zLWluLWxvcy1hbmdlbGVzLTMwMHgyMDAuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZ1wiPlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nIGZjLWl0ZW0tbm8tcGFkZGluZ1wiPlxyXG4gICAgICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS10aXRsZSBmYy1pdGVtLXByaW1hcnktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZVwiPkJlem9layBkZSBmaWxtc3R1ZGlvJiM4MjE3O3MgaW4gTG9zIEFuZ2VsZXM8L2Rpdj5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tY29udGVudCBmYy1pdGVtLWJvZHktdGV4dC1jb2xvclwiPnttYXJrZXJfYWRkcmVzc308L2Rpdj5cclxuICAgICAgICA8L2Rpdj5cclxuICAgIDwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWNsZWFyXCI+PC9kaXY+XHJcbjwvZGl2PiIsImFkZHJlc3MiOiJOaWFnYXJhIEZhbGxzLCBOZXcgWW9yaywgVmVyZW5pZ2RlIFN0YXRlbiIsImxvY2F0aW9uIjp7ImxhdCI6IjQzLjA5NjIxNDMiLCJjaXR5IjoiTmlhZ2FyYSBGYWxscyIsInN0YXRlIjoiTmV3IFlvcmsiLCJjb3VudHJ5IjoiVmVyZW5pZ2RlIFN0YXRlbiIsImxuZyI6Ii03OS4wMzc3Mzg4Iiwib25jbGlja19hY3Rpb24iOiJtYXJrZXIiLCJyZWRpcmVjdF9wZXJtYWxpbmsiOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL2ZpbG1zdHVkaW9zLWxvcy1hbmdlbGVzLyIsInpvb20iOjEyLCJleHRyYV9maWVsZHMiOnsicG9zdF9leGNlcnB0IjoiIiwicG9zdF9jb250ZW50IjoiW3ZjX3JvdyB0aGJfY29sdW1uX3BhZGRpbmc9XCJ0cnVlXCJdW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIyLzNcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiMTAwJVwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIkRlIGZpbG1zdHVkaW8ncyBpbiBMb3MgQW5nZWxlc1wiIG1haW5faGVhZGluZ19jb2xvcj1cIiNiMzRhNGNcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6NTBweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjUwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVtoZXl1c2FfaGVhZGluZyB0YWc9XCJoNFwiIHRleHRfYWxpZ249XCJjZW50ZXJcIiBoZWFkaW5nPVwiRWVuIGxldWtlIGNvbWJpIHR1c3NlbiBmaWxtIGVuIGF0dHJhY3RpZXNcIiBmb250X3NpemU9XCI1MFwiIGxpbmVfaGVpZ2h0PVwiMVwiIGZvbnRfY29sb3I9XCIjMDAwMDAwXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48cCBzdHlsZT1cInRleHQtYWxpZ246IGNlbnRlcjtcIj5Mb3MgQW5nZWxlcyBlbiBmaWxtcyB6aWpuIG9uYWZoYW5rZWxpamsgbWV0IGVsa2FhciB2ZXJib25kZW4uIEhvbGx5d29vZCBzdGFhdCBkYW4gb29rIHN5bm9uaWVtIHZvb3IgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvbG9zLWFuZ2VsZXMvXCI+TG9zIEFuZ2VsZXM8L2E+LiBEZSBtZWVzdCBiZWtlbmRlIGZpbG1zIGFmZ2Vsb3BlbiBqYXJlbiB6aWpuIG9wZ2Vub21lbiBpbiBkZSB2ZXJzY2hpbGxlbmRlIGZpbG1zdHVkaW8ncyB2YW4gTG9zIEFuZ2VsZXMuIERyaWUgYmVrZW5kZSBmaWxtc3R1ZGlvJ3MgaW4gTG9zIEFuZ2VsZXMgemlqbiBVbml2ZXJzYWwsIFdhcm5lciBCcm9zLiBlbiBQYXJhbW91bnQgUGljdHVyZXMsIHN0dWRpbydzIGRpZSBqZSBhbGxlbWFhbCBrdW50IGJlem9la2VuLiBFZW4gYWFudGFsIHRpcHMgdm9vciBlZW4gYmV6b2VrIGFhbiBkZSBmaWxtc3R1ZGlvJ3MgaW4gTG9zIEFuZ2VsZXMuPC9wPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW5dW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IGRpc2FibGVfZWxlbWVudD1cInllc1wiXVt2Y19jb2x1bW5dW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjgwJVwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIiBmdWxsX3dpZHRoPVwic3RyZXRjaF9yb3dcIiBjb250ZW50X3RleHRfYWxpZ21lbnQ9XCJjZW50ZXJcIiBjc3M9XCIudmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9XCIgcGFyYWxsYXhfYmFja2dyb3VuZF9pbWFnZT1cIjM4MzZcIl1bdmNfY29sdW1uIHRoYl9jb2xvcj1cInRoYi1saWdodC1jb2x1bW5cIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJWZXJzY2hpbGxlbmRlIHRoZW1hcGFya2VuIGluIGRlIGZpbG1zdHVkaW8nc1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTo0NXx0ZXh0X2FsaWduOmNlbnRlcnxjb2xvcjolMjNmZmZmZmZ8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1baGV5dXNhX2hlYWRpbmcgdGFnPVwiaDRcIiB0ZXh0X2FsaWduPVwiY2VudGVyXCIgaGVhZGluZz1cIk9udGRlayBkZSBsZXVrZSBjb21iaW5hdGllIHR1c3NlbiBmaWxtdGhlbWEncyBlbiBhdHRyYWN0aWVzXCIgZm9udF9zaXplPVwiNTBcIiBsaW5lX2hlaWdodD1cIjFcIiBmb250X2NvbG9yPVwiI2ZmZmZmZlwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVtwYXJhbGxheF9yb3cgZW5hYmxlX21vYmlsZT1cInBhcmFsbGF4LWVuYWJsZS1tb2JpbGVcIiBpbWFnZT1cIjE5MzQyXCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIl1bdmNfY29sdW1uXVt2Y19lbXB0eV9zcGFjZV1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMi8zXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiQmV6b2VrIGRlIHZlcnNjaGlsbGVuZGUgZmlsbXN0dWRpbydzIGluIExvcyBBbmdlbGVzXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiI2IzNGE0Y1wiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjM1cHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDo0MHB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XVxyXG48cCBzdHlsZT1cInRleHQtYWxpZ246IGNlbnRlcjtcIj5JbiBMb3MgQW5nZWxlcyBoZWIgamUgZGUgbW9nZWxpamtoZWlkIG9tIHZlcnNjaGlsbGVuZGUgZmlsbXN0dWRpbydzIG9tIHRlIGJlem9la2VuLiBXZSBnZXZlbiBqZSBlZW4gYWFudGFsIHRpcHMgdm9vciBlZW4gYmV6b2VrIGFhbiBkZSBmaWxtc3R1ZGlvJ3MgdmFuIFVuaXZlcnNhbCwgV2FybmVyIEJyb3MuIGVuIFBhcmFtb3VudCBQaWN0dXJlcyBpbiBMb3MgQW5nZWxlcy48L3A+XHJcblsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvM1wiXVt2Y19zaW5nbGVfaW1hZ2UgaW1hZ2U9XCIxMjg3MVwiIGltZ19zaXplPVwibGFyZ2VcIiBhZGRfY2FwdGlvbj1cInllc1wiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIlVuaXZlcnNhbCBTdHVkaW8nc1wiIG1haW5faGVhZGluZ19jb2xvcj1cIiNiMzRhNGNcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjMwcHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiXVsvdWx0aW1hdGVfaGVhZGluZ11bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJWYW5hZiBcdTIwYWM5OVwiIG1haW5faGVhZGluZ19jb2xvcj1cIiNjNTljNGRcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjBweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19tYXJnaW49XCJtYXJnaW4tdG9wOjVweDttYXJnaW4tYm90dG9tOjVweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiT3ZlciBVbml2ZXJzYWwgU3R1ZGlvJ3NcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMDAwMDAwXCIgYWxpZ25tZW50PVwibGVmdFwiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDo0NXB4O1wiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NTBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XVVuaXZlcnNhbCBTdHVkaW8ncyBIb2xseXdvb2QgaXMgZWVuIHZhbiBkZSBvdWRzdGUgZW4gYmVyb2VtZHN0ZSBmaWxtc3R1ZGlvJ3MgaW4gSG9sbHl3b29kIGRpZSBub2cgc3RlZWRzIGluIGdlYnJ1aWsgaXMuIERlIHN0dWRpbyBpcyBnZW1hYWt0IG9tIG1lbnNlbiBrZW5uaXMgdGUgbGF0ZW4gbWFrZW4gbWV0IGVjaHRlIEhvbGx5d29vZCBmaWxtc2V0cyBkb29yIG1pZGRlbCB2YW4gcm9uZGxlaWRpbmdlbi4gSGV0IGlzIGVlbiB2YW4gZGUgZWVyc3RlIFVuaXZlcnNhbCBTdHVkaW8ncyB0aGVtYXBhcmtlbiBpbiBkZSB3ZXJlbGQuIERlIGZpbG1zdHVkaW8ncyB6aWpuIG9uZGVyZGVlbCB2YW4gVW5pdmVyc2FsIENpdHkgd2FhciB3aW5rZWxzLCBob3RlbHMgZW4gb25kZXIgYW5kZXJlIGJpb3Njb3Blbi4gVW5pdmVyc2FsIFN0dWRpbydzIHdlcmQgaW4gMTkxNSBnZW9wZW5kIGRvb3IgRHVpdHMtQW1lcmlrYWFuc2UgaW1taWdyYW50IENhcmxlIExhZW1tbGUgZGUgVGF5bG9yIFJhbmNoLiBJbiBlZXJzdGUgaW5zdGFudGllIHZvZWxkZSBoZXQgbWVlciBhbHMgZWVuIGJvZXJkZXJpaiBkYW4gZWVuIGZpbG1zdHVkaW8uIFBhcyBpbiBkZSBqYXJlbiAnNjAga3dhbWVuIGRlIGVlcnN0ZSB0aGVtYXBhcmtlbiBpbiBVbml2ZXJzYWwgZW4gYmVnb24gaGV0IHRlIGxpamtlbiBvcCBkZSBVbml2ZXJzYWwgem9hbHMgd2UgZGllIG51IGtlbm5lbi5bL3ZjX2NvbHVtbl90ZXh0XVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIk9udGRlayBVbml2ZXJzYWwgTG9zIEFuZ2VsZXNcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMDAwMDAwXCIgYWxpZ25tZW50PVwibGVmdFwiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDo0NXB4O1wiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NTBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XU1ldCBlZW4gdGlja2V0IHZvb3IgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvdW5pdmVyc2FsLXN0dWRpb3MtaG9sbHl3b29kLWxvcy1hbmdlbGVzL1wiPlVuaXZlcnNhbDwvYT4ga3VuIGplIGdlbmlldGVuIHZhbiBlbnRlcnRhaW5tZW50LiBFciB6aWpuIHRoZW1hcGFya2VuIGRpZSBqZSBrdW50IGJlem9la2VuIGRpZSBhbGxlbWFhbCB2ZXJzY2hpbGxlbmRlIGF0dHJhY3RpZXMgaGViYmVuLiBEZW5rIGhpZXJiaWogYWFuIEhhcnJ5IFBvdHRlciBXb3JsZCwgSnVyYXNzaWMgV29ybGQsIFNwcmluZ2ZpZWxkLCBUcmFuc2Zvcm1lcnMgb2YgTWluaW9uIExhbmQuIEplIGt1bnQgb29rIG1lZSBtZXQgZGUgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmdldHlvdXJndWlkZS5ubC9sb3MtYW5nZWxlcy1sMTc5L2RhZ3RpY2tldC12b29yLXVuaXZlcnNhbC1zdHVkaW9zLWhvbGx5d29vZC1tZXQtb3B0aWVzLXQ0NTQ1My8/cGFydG5lcl9pZD1ETUQyVkw0JmFtcDt1dG1fbWVkaXVtPW9ubGluZV9wdWJsaXNoZXImYW1wO2NtcD1maWxtc3R1ZGlvc2xhdW5pdmVyc2FsaW50ZWtzdFwiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+V29ybGQgRmFtb3VzIFN0dWRpbyBUb3VyPC9hPiB3YWFyYmlqIGplIG1lZXIgbGVlcnQgb3ZlciBIb2xseXdvb2Rwcm9kdWN0aWVzLCBmaWxtc2V0cyB0ZSB6aWVuIGtyaWpndCBlbiBtZWVyIHRlIGhvcmVuIGtyaWpndCBvdmVyIGRlIGdlc2NoaWVkZW5pcyB2YW4gSG9sbHl3b29kLlsvdmNfY29sdW1uX3RleHRdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiUHJha3Rpc2NoZSBpbmZvcm1hdGllXCIgaGVhZGluZ190YWc9XCJkaXZcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMjgyODI4XCIgYWxpZ25tZW50PVwibGVmdFwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjIwcHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OlJvYm90byBTbGFifGZvbnRfY2FsbDpSb2JvdG8rU2xhYnx2YXJpYW50OjMwMFwiIG1haW5faGVhZGluZ19zdHlsZT1cImZvbnQtd2VpZ2h0OjMwMDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XTxiPkR1dXI6PC9iPlx1MDBhMCBIZWxlIGRhZ1xyXG48Yj5QYXJrZXJlbjwvYj46IDEwMCBVbml2ZXJzYWwgQ2l0eSBQbGF6YSwgVW5pdmVyc2FsIENpdHlcclxuPGI+VGlja2V0cyB2YW4gZGUgdGUgdm9yZW4gcmVzZXJ2ZXJlbjpcdTAwYTA8L2I+TmlldCBwZXIgc2Ugbm9kaWcsIGplIGt1bnQgZWVuIHRpY2tldCB2b29yIGVlbiBiZXBhYWxkZSBkYWcgdmFuIHRlIHZvcmVuIGtvcGVuXHJcbjxzdHJvbmc+TGV0IG9wOlx1MDBhMDwvc3Ryb25nPiBOZWVtIGplIHBhc3Bvb3J0IG1lZSB0aWpkZW5zIGVlbiBiZXpvZWssIGRlIHRpY2tldHMgemlqbiBwZXJzb29uc2dlYm9uZGVuWy92Y19jb2x1bW5fdGV4dF1bdWx0X2J1dHRvbnMgYnRuX3RpdGxlPVwiQm9layBkZXplIHRvdXJcIiBidG5fbGluaz1cInVybDpodHRwcyUzQSUyRiUyRnd3dy5nZXR5b3VyZ3VpZGUubmwlMkZsb3MtYW5nZWxlcy1sMTc5JTJGZGFndGlja2V0LXZvb3ItdW5pdmVyc2FsLXN0dWRpb3MtaG9sbHl3b29kLW1ldC1vcHRpZXMtdDQ1NDUzJTJGJTNGcGFydG5lcl9pZCUzRERNRDJWTDQlMjZ1dG1fbWVkaXVtJTNEb25saW5lX3B1Ymxpc2hlciUyNmNtcCUzRGZpbG1zdHVkaW9zbGF1bml2ZXJzYWx8dGl0bGU6Qm9layUyMGRlemUlMjByb25kbGVpZGluZ3x0YXJnZXQ6X2JsYW5rXCIgYnRuX3RpdGxlX2NvbG9yPVwiI2ZmZmZmZlwiIGJ0bl9iZ19jb2xvcj1cIiNiMzRhNGNcIiBidG5faG92ZXI9XCJ1YnRuLWxlZnQtYmdcIiBidG5fYmdfY29sb3JfaG92ZXI9XCIjNTMxYTIzXCIgaWNvbl9zaXplPVwiMzJcIiBidG5faWNvbl9wb3M9XCJ1YnRuLXNlcC1pY29uLWF0LWxlZnRcIiBidG5fZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgYnRuX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MThweDtcIiBidG5fbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjIwcHg7XCJdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvM1wiXVt2Y19zaW5nbGVfaW1hZ2UgaW1hZ2U9XCIxOTM0NFwiIGltZ19zaXplPVwibGFyZ2VcIiBhZGRfY2FwdGlvbj1cInllc1wiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIldhcm5lciBCcm9zLiBTdHVkaW8nc1wiIG1haW5faGVhZGluZ19jb2xvcj1cIiNiMzRhNGNcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjMwcHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiXVsvdWx0aW1hdGVfaGVhZGluZ11bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJWYW5hZiBcdTIwYWM2M1wiIG1haW5faGVhZGluZ19jb2xvcj1cIiNjNTljNGRcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjBweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19tYXJnaW49XCJtYXJnaW4tdG9wOjVweDttYXJnaW4tYm90dG9tOjVweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiT3ZlciBXYXJuZXIgQnJvcy5cIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMDAwMDAwXCIgYWxpZ25tZW50PVwibGVmdFwiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDo0NXB4O1wiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NTBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XVdhcm5lciBCcm9zLiBkYXQgdm9vcmhlZW4gYmVrZW5kIHN0b25kIGFscyBGaXJzdCBOYXRpb25hbCBTdHVkaW8sIHdlcmQgaW4gMTkyMyBvcGdlcmljaHQgZG9vciBkZSA0IGJyb2VycyBXYXJuZXIuIEhldCBzdHVkaW8gY29tcGxleCB3b3JkdCBhbCBzaW5kcyAxOTI2IGdlYnJ1aWt0IHZvb3IgaGV0IHByb2R1Y2VyZW4gdmFuIGZpbG0gZW4gdGVsZXZpc2llLiBFZW4gdmFuIGRlIGJla2VuZHN0ZSB0ZWxldmlzaWVwcm9kdWN0aWVzIHZhbiBkZSBhZmdlbG9wZW4gamFyZW4gaXMgZGUgc2VyaWUgRnJpZW5kcyBkYXQgbWFhciBsaWVmc3QgMTAgamFhciBsYW5nIGdlZmlsbWQgd2VyZCBpbiBkZSBzdHVkaW9zIHZhbiBXYXJuZXIgQnJvcy4gT29rIGhldCBwb3B1bGFpcmUgRnVsbCBIb3VzZSB3ZXJkIG9wZ2Vub21lbiBpbiBkZSBmaWxtc3R1ZGlvJ3MuIEJla2VuZGUgZmlsbXMgdmFuIGRlIGhhbmQgdmFuIFdhcm5lciBCcm9zLiB6aWpuIEFubmllLCBUaGUgRGFyayBLbmlnaHQsIFNwaWRlci1NYW4gZW4gTGEgTGEgTGFuZC4gRXIgemlqbiBtZWVyIGRhbiAzMCB2ZXJzY2hpbGxlbmRlIGJpbm5lbnN0dWRpbydzIG1hYXIgb29rIHZlcnNjaGlsbGVuZGUgYnVpdGVuIHN0dWRpbydzLiBTdGFnZSAxNSBlbiAxNiB6aWpuIHZlcnJld2VnIGhldCBtZWVzdCBnZWJydWlrdCB2b29yIHBvcHVsYWlyZSBmaWxtcy5bL3ZjX2NvbHVtbl90ZXh0XVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIldhcm5lciBCcm9zLiBTdHVkaW8gVG91clwiIG1haW5faGVhZGluZ19jb2xvcj1cIiMwMDAwMDBcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjQ1cHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDo1MHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdQmVuaWV1d2QgaG9lIGhldCBlciBvcCBlZW4gSG9sbHl3b29kIHNldCBhYW4gdG9lIGdhYXQ/IEtvb3AgZGFuIGVlbiB0aWNrZXQgdm9vciBkZSA8YSBocmVmPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93YXJuZXItYnJvcy1sb3MtYW5nZWxlcy9cIj5XYXJuZXIgQnJvcy4gU3R1ZGlvIFRvdXIgSG9sbHl3b29kPC9hPi4gQmVraWprIG1lZXIgZGFuIDEwMCBoZWN0YXJlIGFhbiBidWl0ZW5zZXRzIGRpZSBnZWJydWlrdCB3ZXJkZW4gdm9vciBmaWxtcyBhbHMgQXJnbyBlbiBCYXRtYW4uIE9vayBkZSB0b3Zlcm5hYXJzd2VyZWxkIHZhbiBIYXJyeSBQb3R0ZXIga29tdCB2b29yYmlqLiBFbiBuYXR1dXJsaWprIGthbiBlZW4gYmV6b2VrIGFhbiBkZSBzZXQgdmFuIGRlIHNlcmllIEZyaWVuZHMgbmlldCBvbnRicmVrZW4uIE5hYXN0IGhldCBiZXpvZWtlbiB2YW4gdmVyc2NoaWxsZW5kZSBmaWxtLSBlbiB0diBzZXRzLCBrb20gamUgb29rIG1lZXIgdGUgd2V0ZW4gb3ZlciBkZSB2ZXJzY2hpbGxlbmRlIGZhc2VzIGluIGhldCBwcm9kdWN0aWVwcm9jZXMuIE5hIGRlIHRvdXIga3VuIGplIGRpbmVyZW4gaW4gaGV0IENlbnRyYWwgUGVyayBDYWZcdTAwZTkgb2YgbWVyY2hhbmRpc2Uga29wZW4gdmFuIGplIGZhdm9yaWV0ZSBzZXJpZSBvZiBmaWxtLlsvdmNfY29sdW1uX3RleHRdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiUHJha3Rpc2NoZSBpbmZvcm1hdGllXCIgaGVhZGluZ190YWc9XCJkaXZcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMjgyODI4XCIgYWxpZ25tZW50PVwibGVmdFwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjIwcHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OlJvYm90byBTbGFifGZvbnRfY2FsbDpSb2JvdG8rU2xhYnx2YXJpYW50OjMwMFwiIG1haW5faGVhZGluZ19zdHlsZT1cImZvbnQtd2VpZ2h0OjMwMDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XTxiPkR1dXI6PC9iPlx1MDBhMCBUb3VyIDEgdXVyIGVuIHplbGZzdGFuZGlnIG5vZyAyIHV1clxyXG48Yj5QYXJrZXJlbjwvYj46IFdhcm5lciBCbHZkLCBQYXJraW5nIExvdCBvcCBkZSA1ZSB2ZXJkaWVwaW5nXHJcbjxiPlRpY2tldHMgdmFuIGRlIHRlIHZvcmVuIHJlc2VydmVyZW46XHUwMGEwPC9iPkphIVxyXG48c3Ryb25nPlRvdXJzOlx1MDBhMDwvc3Ryb25nPkRhZ2VsaWprc1xyXG48c3Ryb25nPkxldCBvcDo8L3N0cm9uZz4gTmVlbSBlZW4gcGFzcG9vcnQgbWVlIGVuIGVyIHppam4gYmVwZXJrdGUgbW9nZWxpamtoZWRlbiB0b3QgZm90b2dyYWZpZSBlbiBmaWxtZW5bL3ZjX2NvbHVtbl90ZXh0XVt1bHRfYnV0dG9ucyBidG5fdGl0bGU9XCJCb2VrIGRlemUgdG91clwiIGJ0bl9saW5rPVwidXJsOmh0dHBzJTNBJTJGJTJGd3d3LmdldHlvdXJndWlkZS5ubCUyRndhcm5lci1icm9zLXN0dWRpb3MtaG9sbHl3b29kLWwyMTA1MCUyRmxvcy1hbmdlbGVzLWhvbGx5d29vZC1yb25kbGVpZGluZy1kb29yLXdhcm5lci1icm9zLXN0dWRpby1zLXQ1NTg2NCUyRiUzRnBhcnRuZXJfaWQlM0RETUQyVkw0JTI2dXRtX21lZGl1bSUzRG9ubGluZV9wdWJsaXNoZXIlMjZjbXAlM0RmaWxtc3R1ZGlvc2xhd2FybmVyfHRpdGxlOkJvZWslMjBqZSUyMHRpY2tldHN8dGFyZ2V0Ol9ibGFua1wiIGJ0bl90aXRsZV9jb2xvcj1cIiNmZmZmZmZcIiBidG5fYmdfY29sb3I9XCIjYjM0YTRjXCIgYnRuX2hvdmVyPVwidWJ0bi1sZWZ0LWJnXCIgYnRuX2JnX2NvbG9yX2hvdmVyPVwiIzUzMWEyM1wiIGljb25fc2l6ZT1cIjMyXCIgYnRuX2ljb25fcG9zPVwidWJ0bi1zZXAtaWNvbi1hdC1sZWZ0XCIgYnRuX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIGJ0bl9mb250X3NpemU9XCJkZXNrdG9wOjE4cHg7XCIgYnRuX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDoyMHB4O1wiXVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzNcIl1bdmNfc2luZ2xlX2ltYWdlIGltYWdlPVwiMTkzNDNcIiBpbWdfc2l6ZT1cImxhcmdlXCIgYWRkX2NhcHRpb249XCJ5ZXNcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJQYXJhbW91bnQgUGljdHVyZXMgU3R1ZGlvJ3NcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjYjM0YTRjXCIgYWxpZ25tZW50PVwibGVmdFwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozMHB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIl1bL3VsdGltYXRlX2hlYWRpbmddW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiVmFuYWYgXHUyMGFjNjVcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjYzU5YzRkXCIgYWxpZ25tZW50PVwibGVmdFwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjIwcHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbWFyZ2luPVwibWFyZ2luLXRvcDo1cHg7bWFyZ2luLWJvdHRvbTo1cHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIk92ZXIgUGFyYW1vdW50IFBpY3R1cmVzXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzAwMDAwMFwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6NDVweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjUwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF1QYXJhbW91bnQgUGljdHVyZXMgaGVlZnQgZWVuIHZhbiBkZSBncm9vdHN0ZSBmaWxtc3R1ZGlvJ3MgdGVyIHdlcmVsZC4gT29pdCBnZXN0YXJ0IGluIDE5MTIsIGlzIFBhcmFtb3VudCBvb2sgZWVuIHZhbiBkZSBvdWRzdGUgZmlsbW1hYXRzY2hhcHBpamVuIHRlciB3ZXJlbGQuIEZpbG1zIGFscyBUaGUgR29kZmF0aGVyLCBGb3JyZXN0IEd1bXAsIFRyYW5zZm9ybWVycyBlbiBkZSBUaXRhbmljIHppam4gZW5vcm1lIHN1Y2Nlc3NlbiB2YW4gZGUgc3R1ZGlvJ3MgdmFuIFBhcmFtb3VudC4gVm9vcmFsIFRyYW5zZm9ybWVycyBlbiBkZSBUaXRhbmljIGJyYWNodGVuIGVub3JtIHZlZWwgZ2VsZCBpbiBoZXQgbGFhdGplIHZvb3IgUGFyYW1vdW50LiBEZSBmaWxtLSBlbiB0ZWxldmlzaWVwcm9kdWN0aWUgbWFhdHNjaGFwcGlqIGlzIGRlIGVuaWdlIHZhbiBkZSBCaWcgRml2ZSBmaWxtc3R1ZGlvJ3MgKFdhbHQgRGlzbmV5LCBVbml2ZXJzYWwsIFdhcm5lciBCcm9zLiBlbiBTb255KSBkaWUgemljaCBiaW5uZW4gZGUgc3RhZHNncmVuemVuIHZhbiBMb3MgQW5nZWxlcyBiZXZpbmR0LlsvdmNfY29sdW1uX3RleHRdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiUGFyYW1vdW50IFN0dWRpbyBUb3VyXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzAwMDAwMFwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6NDVweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjUwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF1OZWVtIGVlbiBraWpramUgYWNodGVyIGRlIHNjaGVybWVuIGJpaiBQYXJhbW91bnQgU3R1ZGlvJ3MgbWV0IGRlemUgc3R1ZGlvdG91ci4gVGlqZGVucyBlZW4gMiB1dXIgZHVyZW5kZSB0b3VyIG9udGRlayBqZSBkZSBlZXJzdGUgZ3JvdGUgZmlsbXN0dWRpbyB2YW4gSG9sbHl3b29kIGVuIGJlem9la3QgaWNvbmlzY2hlIGxvY2F0aWVzLiBNZXQgbWVlciBkYW4gMTEwIGphYXIgYWFuIHN0dWRpby1lcnZhcmluZywgdmFsdCBlciBnZW5vZWcgdGUgemllbiBlbiB0ZSBsZXJlbiBiaWogZWVuIHN0dWRpb3RvdXIuIE1hYWsga2VubmlzIG1ldCBIb2xseXdvb2QgdGlqZGVucyBkZXplIHN0dWRpb3RvdXIuWy92Y19jb2x1bW5fdGV4dF1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJQcmFrdGlzY2hlIGluZm9ybWF0aWVcIiBoZWFkaW5nX3RhZz1cImRpdlwiIG1haW5faGVhZGluZ19jb2xvcj1cIiMyODI4MjhcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjBweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6Um9ib3RvIFNsYWJ8Zm9udF9jYWxsOlJvYm90bytTbGFifHZhcmlhbnQ6MzAwXCIgbWFpbl9oZWFkaW5nX3N0eWxlPVwiZm9udC13ZWlnaHQ6MzAwO1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdPGI+RHV1cjo8L2I+XHUwMGEwIEluIHRvdGFhbCAyIHV1clxyXG48Yj5QYXJrZXJlbjwvYj46IFZpc2l0b3IgUGFya2luZyBMb3QgQTogNjQzIE4gV2luZHNvciBCbHZkLCBIb2xseXdvb2RcclxuPGI+VGlja2V0cyB2YW4gZGUgdGUgdm9yZW4gcmVzZXJ2ZXJlbjpcdTAwYTA8L2I+SmEhXHJcbjxzdHJvbmc+VG91cnM6XHUwMGEwPC9zdHJvbmc+RGFnZWxpamtzWy92Y19jb2x1bW5fdGV4dF1bdWx0X2J1dHRvbnMgYnRuX3RpdGxlPVwiQm9layBkZXplIHRvdXJcIiBidG5fbGluaz1cInVybDpodHRwcyUzQSUyRiUyRnBhcmFtb3VudHN0dWRpb3RvdXIudmVudHJhdGEuY29tJTJGZW4lMkZzdHVkaW8tdG91cnx0aXRsZTpCb2VrJTIwZGV6ZSUyMHRvdXJ8dGFyZ2V0Ol9ibGFua1wiIGJ0bl90aXRsZV9jb2xvcj1cIiNmZmZmZmZcIiBidG5fYmdfY29sb3I9XCIjYjM0YTRjXCIgYnRuX2hvdmVyPVwidWJ0bi1sZWZ0LWJnXCIgYnRuX2JnX2NvbG9yX2hvdmVyPVwiIzUzMWEyM1wiIGljb25fc2l6ZT1cIjMyXCIgYnRuX2ljb25fcG9zPVwidWJ0bi1zZXAtaWNvbi1hdC1sZWZ0XCIgYnRuX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIGJ0bl9mb250X3NpemU9XCJkZXNrdG9wOjE4cHg7XCIgYnRuX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDoyMHB4O1wiXVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5NSVcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW5dW3ZjX2VtcHR5X3NwYWNlXVtmdWxsd2lkdGhfcm93XVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiQW5kZXJlIGludGVyZXNzYW50ZSBhcnRpa2VsZW5cIiBmb250X2NvbnRhaW5lcj1cInRhZzpkaXZ8Zm9udF9zaXplOjY1fHRleHRfYWxpZ246Y2VudGVyfGNvbG9yOiUyMzAwMDAwMFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdGhiX3Bvc3RncmlkIHN0eWxlPVwic3R5bGUyMFwiIGNvbHVtbnM9XCI0XCIgc291cmNlPVwic2l6ZTo0fG9yZGVyX2J5OmRhdGV8b3JkZXI6REVTQ3xwb3N0X3R5cGU6cG9zdHxjYXRlZ29yaWVzOi02MywtNjJ8YnlfaWQ6MTY5MjgsMTI4NjUsMTQxODYsNTAwM1wiXVsvdmNfY29sdW1uXVsvdmNfcm93XSIsInBvc3RfdGl0bGUiOiJCZXpvZWsgZGUgZmlsbXN0dWRpbyYjODIxNztzIGluIExvcyBBbmdlbGVzIiwicG9zdF9saW5rIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9maWxtc3R1ZGlvcy1sb3MtYW5nZWxlcy8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJCZXpvZWsgZGUgZmlsbXN0dWRpb3MgaW4gbG9zIGFuZ2VsZXNcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjIwMFwiIHNyYz1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjQvMDMvZmlsbXN0dWRpb3MtaW4tbG9zLWFuZ2VsZXMtMzAweDIwMC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj4iLCJwb3N0X2NhdGVnb3JpZXMiOiJCZXppZW5zd2FhcmRpZ2hlZGVuIExvcyBBbmdlbGVzIiwicG9zdF90YWdzIjoiIiwiJV93cGJfc2hvcnRjb2Rlc19jdXN0b21fY3NzJSI6Ii52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O30iLCIlaW5saW5lX2ZlYXR1cmVkX2ltYWdlJSI6IjAiLCIlX2VkaXRfbGFzdCUiOiIyIiwiJV9lZGl0X2xvY2slIjoiMTcxMDkzMTY4NToyIiwiJV93cGJfdmNfanNfc3RhdHVzJSI6InRydWUiLCIlcG9zdC1wcmltYXJ5LWNhdGVnb3J5JSI6IjE1IiwiJWZlYXR1cmVkX2ltYWdlX292ZXJyaWRlJSI6Im9mZiIsIiVhcnRpY2xlX3N0eWxlX292ZXJyaWRlJSI6Im9uIiwiJXBvc3Rfc3R5bGUlIjoic3R5bGU1IiwiJXBvc3RfZ2FsbGVyeV9zdHlsZSUiOiJsaWdodGJveCIsIiVwb3N0X3JldmlldyUiOiJvZmYiLCIlcG9zdF9yZXZpZXdfc3R5bGUlIjoic3R5bGUxIiwiJXBvc3RfcmV2aWV3X2F2ZXJhZ2UlIjoiNTAiLCIlc3RhbmRhcmQtZmVhdHVyZWQtY3JlZGl0JSI6IiIsIiVfaGlkZV9mZWF0dXJlZCUiOm51bGwsIiVwb3N0X3NvdXJjZSUiOiIiLCIlX3RodW1ibmFpbF9pZCUiOiIxOTM0NiIsIiVfd3BnbXBfbG9jYXRpb25fYWRkcmVzcyUiOiJOaWFnYXJhIEZhbGxzLCBOZXcgWW9yaywgVmVyZW5pZ2RlIFN0YXRlbiIsIiVfd3BnbXBfbG9jYXRpb25fY2l0eSUiOiJOaWFnYXJhIEZhbGxzIiwiJV93cGdtcF9sb2NhdGlvbl9zdGF0ZSUiOiJOZXcgWW9yayIsIiVfd3BnbXBfbG9jYXRpb25fY291bnRyeSUiOiJWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9tZXRhYm94X2xhdGl0dWRlJSI6IjQzLjA5NjIxNDMiLCIlX3dwZ21wX21ldGFib3hfbG9uZ2l0dWRlJSI6Ii03OS4wMzc3Mzg4IiwiJV93cGdtcF9tZXRhYm94X2xvY2F0aW9uX3JlZGlyZWN0JSI6Im1hcmtlciIsIiVfd3BnbXBfbWV0YWJveF9jdXN0b21fbGluayUiOiIiLCIlX3dwZ21wX21hcF9pZCUiOiJhOjE6e2k6MDtzOjE6XCI3XCI7fSIsIiVfd3BnbXBfbWV0YWJveF9tYXJrZXJfaWQlIjoiIiwiJV93cGdtcF9tZXRhYm94X3RheG9tb21pZXNfdGVybXMlIjoiIiwiJV93cGdtcF9leHRlbnNpb25zX2ZpZWxkcyUiOiIiLCIlX3lvYXN0X3dwc2VvX2NvbnRlbnRfc2NvcmUlIjoiMzAiLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza2V5d29yZHMlIjoiW10iLCIlX3lvYXN0X3dwc2VvX2tleXdvcmRzeW5vbnltcyUiOiJbXCJmaWxtc3R1ZGlvcyBsb3MgYW5nZWxlc1wiXSIsIiVfeW9hc3Rfd3BzZW9fZm9jdXNrdyUiOiJCZXpvZWsgZGUgZmlsbXN0dWRpbydzIGluIExvcyBBbmdlbGVzIiwiJV95b2FzdF93cHNlb19tZXRhZGVzYyUiOiJCZXpvZWsgZGUgZmlsbXN0dWRpbydzIGluIExvcyBBbmdlbGVzLiBCZXpvZWsgZGUgZmlsbXN0dWRpbydzIHZhblVuaXZlcnNhbCwgV2FybmVyIEJyb3RoZXJzLCBQYXJhbW91bnQgUGljdHVyZXMgaW4gTG9zIEFuZ2VsZXMiLCIlX3lvYXN0X3dwc2VvX2xpbmtkZXglIjoiNzIiLCIlX3lvYXN0X3dwc2VvX3ByaW1hcnlfY2F0ZWdvcnklIjoiNTIiLCIlX3lvYXN0X3dwc2VvX3RpdGxlJSI6IkJlem9layBkZSBmaWxtc3R1ZGlvJ3MgaW4gTG9zIEFuZ2VsZXMiLCIlX3lvYXN0X3dwc2VvX2VzdGltYXRlZC1yZWFkaW5nLXRpbWUtbWludXRlcyUiOiI2IiwiJV93d3Nfc3VwcG9ydF9jb250YWN0X251bWJlciUiOiIiLCIlX3d3c19hYm91dF9zdXBwb3J0X3RleHQlIjoiIiwiJV93d3NfdHJpZ2dlcl9idXR0b25fdGV4dCUiOiIiLCIlX3d3c19wcmVkZWZpbmVkX3RleHQlIjoiIiwiJV95b2FzdF93cHNlb193b3JkcHJvb2ZfdGltZXN0YW1wJSI6IiIsIiVfeW9hc3RfaW5kZXhub3dfbGFzdF9waW5nJSI6IjE3MTA0MjIzMjMiLCIlX2xhc3RfZWRpdG9yX3VzZWRfamV0cGFjayUiOiJjbGFzc2ljLWVkaXRvciIsIiVhY3RpdmVlcl9zdWJtZW51JSI6IjAiLCIlX2FjdGl2ZWVyX3N1Ym1lbnUlIjoiZmllbGRfNjU5M2Y1MjFlOTdjMiIsInRheG9ub215PWNhdGVnb3J5IjoiQmV6aWVuc3dhYXJkaWdoZWRlbiBMb3MgQW5nZWxlcyIsInRheG9ub215PXBvc3RfdGFnIjoiIiwidGF4b25vbXk9cG9zdF9mb3JtYXQiOiIiLCJ0YXhvbm9teT10aGItcmVhY3Rpb25zIjoiIiwidGF4b25vbXk9dGhiLXNwb25zb3JzIjoiIn19LCJpZCI6MTkzNDAsImluZm93aW5kb3dfZGlzYWJsZSI6ZmFsc2V9LHsic291cmNlIjoicG9zdCIsInRpdGxlIjoiR29ibGluIFZhbGxleSBTdGF0ZSBQYXJrIiwiaW5mb3dpbmRvd19jb250ZW50IjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZyBcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiR29ibGluIFZhbGxleSBTdGF0ZSBQYXJrXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMDBcIiBzcmM9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDI0LzAzL3RocmVlLXNpc3RlcnMtR29ibGluLVZhbGxleS1TdGF0ZS1QYXJrLTMwMHgyMDAuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZ1wiPlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nIGZjLWl0ZW0tbm8tcGFkZGluZ1wiPlxyXG4gICAgICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS10aXRsZSBmYy1pdGVtLXByaW1hcnktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZVwiPkdvYmxpbiBWYWxsZXkgU3RhdGUgUGFyazwvZGl2PlxyXG4gICAgICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1jb250ZW50IGZjLWl0ZW0tYm9keS10ZXh0LWNvbG9yXCI+e21hcmtlcl9hZGRyZXNzfTwvZGl2PlxyXG4gICAgICAgIDwvZGl2PlxyXG4gICAgPC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtY2xlYXJcIj48L2Rpdj5cclxuPC9kaXY+IiwiYWRkcmVzcyI6IjE4NjMwR29ibGluLCBWYWxsZXkgUm9hZCwgR3JlZW4gUml2ZXIsIFVUIDg0NTI1LCBWZXJlbmlnZGUgU3RhdGVuIiwibG9jYXRpb24iOnsibGF0IjoiMzguNTczNjk3IiwiY2l0eSI6IkdyZWVuIFJpdmVyIiwic3RhdGUiOiJVdGFoIiwiY291bnRyeSI6IlZlcmVuaWdkZSBTdGF0ZW4iLCJsbmciOiItMTEwLjcwNzEwOSIsIm9uY2xpY2tfYWN0aW9uIjoibWFya2VyIiwicmVkaXJlY3RfcGVybWFsaW5rIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9nb2JsaW4tdmFsbGV5LXN0YXRlLXBhcmsvIiwiem9vbSI6MTIsImV4dHJhX2ZpZWxkcyI6eyJwb3N0X2V4Y2VycHQiOiIiLCJwb3N0X2NvbnRlbnQiOiJbdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiMTAwJVwiXVt2Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkdvYmxpbiBWYWxsZXkgU3RhdGUgUGFya1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTozNXx0ZXh0X2FsaWduOmxlZnR8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdRWVuIGtsZWluLCBhZmdlbGVnZW4gZW4gdW5pZWsgc3RhYXRzcGFyaywgZGF0IGlzIEdvYmxpbiBWYWxsZXkgU3RhdGUgUGFyay4gRHVpemVuZGVuIHJvdHNmb3JtYXRpZXMgZGllIGVyIHVpdCB6aWVuIGFscyBwYW5uZW5rb2VrZW4gb2YgY2hhbXBpZ25vbnMsIG9vayB3ZWwgZ29ibGlucyBnZW5vZW1kLCBtYWtlbiB2YW4gaGV0IHBhcmsgZWVuIGJlemllbnN3YWFyZGlnaGVpZCBkYXQgZGUgbW9laXRlIHdhYXJkIGlzLiBIZXQgcGFyayBpcyBlZW4gZ29lZGUgdHVzc2Vuc3RvcCB3YW5uZWVyIGplIGVlbiByb2FkdHJpcCBtYWFrdCBpbiBVdGFoLiBWZXJrZW4gaGV0IHBhcmsgdmlhIGRlIHZlcnNjaGlsbGVuZGUgd2FuZGVscm91dGVzIGVuIG9udGRlayBkZSBtb29pc3RlIGVuIHVuaWVrZSBnb2JsaW5zLiBUaXBzIHZvb3IgZWVuIGJlem9layBhYW4gR29ibGlucyBWYWxsZXkgU3RhdGUgUGFyay5bL3ZjX2NvbHVtbl90ZXh0XVt1bHRpbWF0ZV9pY29uX2xpc3QgaWNvbl9zaXplPVwiMjBcIl1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLWF1dG9tb2JpbGUgY2FyXCJdMzQ3IGtpbG9tZXRlciB2YW5hZiBTYWx0IExha2UgQ2l0eVsvdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy10cmVlXCJdPHNwYW4gY2xhc3M9XCJMcnpYciBrbm8tZnZcIj40MCBrbVx1MDBiMiBvcHBlcnZsYWt0ZTwvc3Bhbj5bL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtcGF3XCJdNyB2ZXJzY2hpbGxlbmRlIHNvb3J0ZW4gZGllcmVuWy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bL3VsdGltYXRlX2ljb25fbGlzdF1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIGNzcz1cIi52Y19jdXN0b21fMTYwODY2NjUxOTQ5MntiYWNrZ3JvdW5kLWNvbG9yOiAjZWFlYWVhICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMi8zXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkRlIGdlc2NoaWVkZW5pcyB2YW4gR29ibGluIFZhbGxleSBTdGF0ZSBQYXJrXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjM1fHRleHRfYWxpZ246Y2VudGVyfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48cCBzdHlsZT1cInRleHQtYWxpZ246IGNlbnRlcjtcIj5Hb2JsaW4gVmFsbGV5IFN0YXRlIFBhcmsgbGlndCBpbiBkZSBTYW4gUmFmYWVsIHdvZXN0aWpuLiBJbiBoZXQgZ2ViaWVkIGlzIGJld2lqcyBnZXZvbmRlbiB2YW4gSW5kaWFhbnNlIGN1bHR1cmVuLCB6b2FscyBkZSBGcmVtb250LCBQYWl1dGUgZW4gVXRlLiBFciB6aWpuIHZlcnNjaGlsbGVuZGUgcm90c3Rla2VuaW5nZW4gZ2V2b25kZW4gZGllIGRpdCBiZXZlc3RpZ2VuLiBEYWFybmEgdm9sZ2RlbiBkZSBjb3dib3lzIGRpZSBpbiBoZXQgZ2ViaWVkIG9wIHpvZWsgd2FyZW4gbmFhciB2ZWUuIEhldCBnZWJpZWQgd2VyZCBpbiBrYWFydCBnZWJyYWNodCBkb29yIEFydGh1ciBDaGFmZmluLCBoaWogem9jaHQgcm9uZCAxOTIwIHNhbWVuIG1ldCB0d2VlIG1ldGdlemVsbGVuIGVlbiByb3V0ZSBkb29yIGhldCBnZWJpZWQsIHRvZW4gemUgaGV0IHVpdGtpamtwdW50IGJlcmVpa3RlbiB3YXJlbiB6ZSBlbm9ybSBvbmRlciBkZSBpbmRydWsuIFplIHphZ2VuIDUgYnV0dGVzIGVuIGVlbiB2YWxlaSBtZXQgYWxsZW1hYWwgcGFubmVua29layByb3RzZm9ybWF0aWVzLiBJbiAxOTQ5IGtlZXJkZSBDaGFmZmluIHRlcnVnIG5hYXIgaGV0IGdlYmllZCBkYXQgaGlqIGlubWlkZGVscyBvbWdlZG9vcHQgaGFkIHRvdCBkZSBWYWxsZWkgdmFuIGRlIFBhZGRlc3RvZWxlbi4gSGlqIGJyYWNodCBkYWdlbiBkb29yIG1ldCBoZXQgZm90b2dyYWZlcmVuIHZhbiBkZSByb2RlIHJvdHNlbi4gT25kYW5rcyBkZSBhZmdlbGVnZW4gbGlnZ2luZyB3ZXJkIGFsIHNuZWwgZWVuIHBvZ2luZyBnZWRhYW4gb20gaGV0IGdlYmllZCB0ZSBiZXNjaGVybWVuIHRlZ2VuIHZhbmRhbGlzbWUsIGluIDE5NjQgd2VyZCBoZXQgb2ZmaWNpZWVsIGVlbiBzdGFhdHNwYXJrLjwvcD5cclxuWy92Y19jb2x1bW5fdGV4dF1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiIGZ1bGxfd2lkdGg9XCJzdHJldGNoX3Jvd1wiIGNvbnRlbnRfdGV4dF9hbGlnbWVudD1cImNlbnRlclwiIGNzcz1cIi52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O31cIiBwYXJhbGxheF9iYWNrZ3JvdW5kX2ltYWdlPVwiMzgzNlwiXVt2Y19jb2x1bW4gdGhiX2NvbG9yPVwidGhiLWxpZ2h0LWNvbHVtblwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkdvYmxpbiBWYWxsZXkgU3RhdGUgUGFya1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTo3NXx0ZXh0X2FsaWduOmNlbnRlcnxjb2xvcjolMjNmZmZmZmZ8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1baGV5dXNhX2hlYWRpbmcgdGFnPVwiaDRcIiB0ZXh0X2FsaWduPVwiY2VudGVyXCIgaGVhZGluZz1cImBgVmFsbGVpIHZhbiBkZSBwYWRkZW5zdG9lbGVuYGBcIiBmb250X3NpemU9XCI1MFwiIGxpbmVfaGVpZ2h0PVwiMVwiIGZvbnRfY29sb3I9XCIjZmZmZmZmXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3BhcmFsbGF4X3JvdyBlbmFibGVfbW9iaWxlPVwicGFyYWxsYXgtZW5hYmxlLW1vYmlsZVwiIGltYWdlPVwiMTkyNDVcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiXVt2Y19jb2x1bW5dW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkhvZSBrb20gamUgYmlqIEdvYmxpbiBWYWxsZXkgU3RhdGUgUGFyaz9cIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MjV8dGV4dF9hbGlnbjpsZWZ0XCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1IZXQgc3RhdGUgcGFyayBsaWd0IG9wIG1lZXIgZGFuIDMwMCBraWxvbWV0ZXIgdmFuIDxhIGhyZWY9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dhdC10ZS1kb2VuLWluLXNhbHQtbGFrZS1jaXR5L1wiPlNhbHQgTGFrZSBDaXR5PC9hPi4gRXIgbGlnZ2VuIG5pZXQgZWNodCBhbmRlcmUgZ3JvdGUgcGxla2tlbiBpbiBkZSBidXVydCwgaGV0IHdvcmR0IHZvb3JhbCBvbXJpbmdkIGRvb3IgbmF0aW9uYWxlIHBhcmtlbiBlbiBhbmRlcmUgbmF0dXVyZ2ViaWVkZW4uIDxhIGhyZWY9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL2FyY2hlcy1uYXRpb25hbC1wYXJrL1wiPkFyY2hlcyBOYXRpb25hbCBQYXJrPC9hPiwgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvY2FueW9ubGFuZHMtbmF0aW9uYWwtcGFyay9cIj5DYW55b25sYW5kcyBOYXRpb25hbCBQYXJrPC9hPiBlbiA8YSBocmVmPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9jYXBpdG9sLXJlZWYtbmF0aW9uYWwtcGFyay9cIj5DYXBpdG9sIFJlZWYgTmF0aW9uYWwgUGFyazwvYT4gbGlnZ2VuIGFsbGUgMyBpbiBkZSBidXVydC4gSmUga3VudCBoZXQgc3RhdGUgcGFyayBiZXJlaWtlbiBvcCBkZSB2b2xnZW5kZSBtYW5pZXIsIHZhbmFmIGRlIEktNzAgc2xhIGplIGFmIG9wIEhpZ2h3YXkgMjQgZW4gcmlqZCB6dWlkd2FhcnRzIGVlbiBrbGVpbmUgNDAga2lsb21ldGVyIG5hYXIgZGUgYWFuZ2VnZXZlbiBhZnNsYWcgbmFhciBoZXQgcGFyay4gVmFuYWYgZGFhciB2b2xnIGplIG5vZyAxOSBraWxvbWV0ZXIgZGUgdmVyaGFyZGUgd2VnIG5hYXIgaGV0IHBhcmsuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJXYXQgdGUgZG9lbiBpbiBoZXQgR29ibGluIFZhbGxleSBTdGF0ZSBQYXJrXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjI1fHRleHRfYWxpZ246bGVmdFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdRGUgYmVsYW5ncmlqa3N0ZSBiZXppZW5zd2FhcmRpZ2hlaWQgd2Fhcm9tIG1lbnNlbiBuYWFyIEdvYmxpbiBWYWxsZXkgU3RhdGUgUGFyayBhZnJlaXplbiBpcyBoZXQgemllbiB2YW4gbWVlciBkYW4gZHVpemVuZGVuIGdvYmxpbnMuIEplIGt1bnQgaGV0IGdlYmllZCBoZXQgYmVzdGUgd2FuZGVsZW5kIHZlcmtlbm5lbi4gRm90b2dyYWZlbiBrdW5uZW4gaHVuIGhhcnQgb3BoYWxlbiwgd2FudCBoZXQgcGFyayBpcyBlbm9ybSBmb3RvZ2VuaWVrLiBSb25kb20gaGV0IHN0YXRlIHBhcmsgemlqbiBtb2dlbGlqa2hlZGVuIG9tIHRlIG1vdW50YWluYmlrZW4gb2YgZWVuIEFUViB0ZSBwYWtrZW4uIEVyIHppam4gdmVyc2NoaWxsZW5kZSBjYW55b25zIGluIGRlIGJ1dXJ0IHpvYWxzIExpdHRsZSBXaWxkIEhvcnNlIENhbnlvbi5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiT3Zlcm5hY2h0ZW4gaW4gaGV0IEdvYmxpbiBWYWxsZXkgU3RhdGUgUGFya1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZToyNXx0ZXh0X2FsaWduOmxlZnRcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XUluIGRlIGJ1dXJ0IHZhbiBoZXQgcGFyayBiZXZpbmR0IHppY2ggZWVuIGNhbXBpbmcgd2FhciBqZSBrdW50IG92ZXJuYWNodGVuLiBSZXNlcnZlcmVuIHZvb3IgZGUgY2FtcGluZyBpcyBub29kemFrZWxpamssIHplIGt1bm5lbiB2b29yIGVlbiBwZXJpb2RlIHZhbiB2aWVyIG1hYW5kZW4gd29yZGVuIGdlcmVzZXJ2ZWVyZC4gS2FtcGVyZW4ga2FuIHZhbmFmICQ0NS4gR2VkdXJlbmRlIGhldCBqYWFyIGt1biBqZSBvb2sgb3Zlcm5hY2h0ZW4gaW4gXHUwMGU5XHUwMGU5biB2YW4gZGUgMiB5dXJ0cy4gWmUgemlqbiB0b2VnYW5rZWxpamsgcGVyIGF1dG8gZW4gaGViYmVuIHN0YXBlbGJlZGRlbi4gRXIga3VubmVuIGluIHRvdGFhbCA1IGdhc3RlbiBpbiBlZW4geXVydC4gS3Vzc2VucywgZGVrZW5zIGVuIGtldWtlbnNwdWxsZW4gZGllbiBqZSB6ZWxmIG1lZSB0ZSBuZW1lbi4gRGUgZGljaHRzdGJpanppam5kZSBzdGFkIGlzIEhhbmtzdmlsbGUgb3AgaWV0cyBtZWVyIGRhbiA1MCBraWxvbWV0ZXIuIEJla2lqayBoaWVyIGRlIDxhIGhyZWY9XCJodHRwczovL3d3dy5ib29raW5nLmNvbS9zZWFyY2hyZXN1bHRzLmVuLmh0bWw/Y2l0eT0yMDEzMzIyMiZhbXA7YWlkPTc5NTg0OTgmYW1wO25vX3Jvb21zPTEmYW1wO2dyb3VwX2FkdWx0cz0yJmFtcDtsYWJlbD1nb2JsaW52YWxsZXloYW5rc3ZpbGxlXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5tb2dlbGlqa2hlZGVuIG9tIGluIEh1bnRzdmlsbGUgdGUgb3Zlcm5hY2h0ZW48L2E+Llx1MDBhMCBJZXRzIHZlcmRlciB3ZWcsIG1hYXIgbWV0IGlldHMgbWVlciBvcHRpZXMsIGlzIGRlIDxhIGhyZWY9XCJodHRwczovL3d3dy5ib29raW5nLmNvbS9zZWFyY2hyZXN1bHRzLmVuLmh0bWw/Y2l0eT0yMDEzMzE5NCZhbXA7YWlkPTc5NTg0OTgmYW1wO25vX3Jvb21zPTEmYW1wO2dyb3VwX2FkdWx0cz0yJmFtcDtsYWJlbD1nb2JsaW52YWxsZXlncmVlbnJpdmVyXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5wbGVrIEdyZWVuIFJpdmVyPC9hPi5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkJlc3RlIHBlcmlvZGUgdm9vciBlZW4gYmV6b2VrIGFhbiBoZXQgR29ibGluIFZhbGxleSBTdGF0ZSBQYXJrXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjI1fHRleHRfYWxpZ246bGVmdFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdRGUgYmVzdGUgcGVyaW9kZSBvbSBoZXQgcGFyayB0ZSBiZXpvZWtlbiBpcyBpbiBsZW50ZSBlbiBoZXJmc3QuIEluIGRlemUgcGVyaW9kZSB6aWpuIGRlIHRlbXBlcmF0dXJlbiBoZXQgYmVzdGUuIEluIGRlIHdpbnRlciBrYW4gaGV0IG5vZyAtOC8tOSB3b3JkZW4gZW4gaW4gZGUgem9tZXJtYWFuZGVuIHR1c3NlbiBkZSAzNSBlbiA0MCBncmFkZW4uIFBsYWF0c2VsaWprZSBvdmVyc3Ryb21pbmdlbiwgYmxpa3NlbSBlbiBhbmRlcmUgZ2V2YWFybGlqa2Ugd2VlcnNvbXN0YW5kaWdoZWRlbiB6aWpuIG1vZ2VsaWprLiBCZWtpamsgZGFhcm9tIGFsdGlqZCBkZSB3ZWVyc3Zvb3JzcGVsbGluZ2VuIHZvb3IgamUgYmV6b2VrLiBHYSBqZSBpbiBkZSB6b21lciBvZiBvcCBlZW4gd2FybWUgZGFnPyBIZXQgZ2ViaWVkIGlzIHJ1aWcgbWV0IHdlaW5pZyBmYWNpbGl0ZWl0ZW4sIHpvcmcgZGF0IGplIGFsdGlqZCB2b2xkb2VuZGUgZXRlbiBlbiBkcmlua2VuIGJpaiBqZSBoZWJ0LiBIZXQgbW9vaXN0ZSBtb21lbnQgdm9vciBlZW4gYmV6b2VrIGFhbiBoZXQgcGFyayBpcyBvdmVyaWdlbnMgaW4gZGUgb2NodGVuZCBvZiBsYWF0IGluIGRlIG1pZGRhZywgZGUgbGljaHRpbnZhbCBpcyBkYW4gaGV0IG1vb2lzdC5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIGNvbnRlbnRfcGxhY2VtZW50PVwibWlkZGxlXCIgZnVsbF93aWR0aD1cInN0cmV0Y2hfcm93XCIgY29udGVudF90ZXh0X2FsaWdtZW50PVwiY2VudGVyXCIgY3NzPVwiLnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fVwiIHBhcmFsbGF4X2JhY2tncm91bmRfaW1hZ2U9XCIzODM2XCJdW3ZjX2NvbHVtbiB0aGJfY29sb3I9XCJ0aGItbGlnaHQtY29sdW1uXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIldhbmRlbGVuIGluIEdvYmxpbiBWYWxsZXkgU3RhdGUgUGFya1wiIGhlYWRpbmdfdGFnPVwicFwiIG1haW5faGVhZGluZ19jb2xvcj1cIiNmZmZmZmZcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDo0NXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjU1cHg7XCIgbWFyZ2luX2Rlc2lnbl90YWJfdGV4dD1cIlwiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMTBweFwiXVtoZXl1c2FfaGVhZGluZyB0YWc9XCJoNFwiIHRleHRfYWxpZ249XCJjZW50ZXJcIiBoZWFkaW5nPVwiT250ZGVrIGhldCBwYXJrIHRlIHZvZXRcIiBmb250X3NpemU9XCI1MFwiIGxpbmVfaGVpZ2h0PVwiMVwiIGZvbnRfY29sb3I9XCIjZmZmZmZmXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3BhcmFsbGF4X3JvdyBlbmFibGVfbW9iaWxlPVwicGFyYWxsYXgtZW5hYmxlLW1vYmlsZVwiIGltYWdlPVwiMTkyNDZcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIGNzcz1cIi52Y19jdXN0b21fMTYwODY2Njg4NTQ5N3tiYWNrZ3JvdW5kLWltYWdlOiB1cmwoaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMC8wOC9iYWNrZ3JvdW5kLWhleXVzYS1uYXR1dXItMS5naWY/aWQ9MzA4OCkgIWltcG9ydGFudDt9XCJdW3ZjX2NvbHVtbl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJXYW5kZWxlbiBpbiBoZXQgR29ibGluIFZhbGxleSBTdGF0ZSBQYXJrXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzAwMDAwMFwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjU1cHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF1IZXQgR29ibGluIFZhbGxleSBTdGF0ZSBQYXJrIGlzIGVlbiByZWxhdGllZiBrbGVpbiBzdGF0ZSBwYXJrLiBFciB6aWpuIGVlbiBkcmlldGFsIHRyYWlscyB1aXRnZXpldCBkaWUgamUga3VudCBsb3BlbiBpbiBoZXQgcGFyay4gRGFhcm5hYXN0IG1hZyBqZSBvb2sgdmFuIGRlIHBhZGVuIGFmIG9tIHRlIHdhbmRlbGVuIHR1c3NlbiBkZSBHb2JsaW5zLiBMb29wIHZvb3JhbCBkb29yIG5hYXIgaGV0IGVpbmRlIHZhbiBoZXQgcGFyaywgaGllciB2aW5kIGplIG5hbWVsaWprIGRlIG1vb2lzdGUgZ29ibGlucy4gRGUgcm91dGVzIGluIGhldCBwYXJrOlxyXG48dWw+XHJcbiBcdDxsaT5DdXJ0aXMgQmVuY2ggVHJhaWwgfCAzLDMga2lsb21ldGVyPC9saT5cclxuIFx0PGxpPkNhcm1lbCBDYW55b24gVHJhaWwgfCAyLDQga2lsb21ldGVyPC9saT5cclxuIFx0PGxpPkVudHJhZGEgVHJhaWwgfCAyIGtpbG9tZXRlcjwvbGk+XHJcbjwvdWw+XHJcblsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIkhhbmRpZ2UgaW5mbyB2b29yIGplIGJlem9la1wiIG1haW5faGVhZGluZ19jb2xvcj1cIiMwMDAwMDBcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpSb2JvdG8gU2xhYnxmb250X2NhbGw6Um9ib3RvK1NsYWJ8dmFyaWFudDo4MDBcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjU1cHg7XCIgbWFpbl9oZWFkaW5nX3N0eWxlPVwiZm9udC13ZWlnaHQ6ODAwO1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdWx0aW1hdGVfaWNvbl9saXN0IGljb25fc2l6ZT1cIjI1XCJdW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy1jbG9jay1vXCIgY29udGVudF9mb250X3NpemU9XCJkZXNrdG9wOjE2cHg7XCJdMzY1IGRhZ2VuIGdlb3BlbmRcclxuMDYuMDAtMjIuMDAgdXVyIGdlb3BlbmRbL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtdGh1bWJzLXVwXCIgY29udGVudF9mb250X3NpemU9XCJkZXNrdG9wOjE2cHg7XCJdQmVzdGUgcGVyaW9kZTogbGVudGUgZW4gaGVyZnN0Wy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLWRvbGxhciB1c2RcIiBjb250ZW50X2ZvbnRfc2l6ZT1cImRlc2t0b3A6MTZweDtcIl0kMjAgdm9vciBhdXRvJ3NcclxuJDUgdm9vciB2b2V0Z2FuZ2Vyc1svdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dWy91bHRpbWF0ZV9pY29uX2xpc3RdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiIGZ1bGxfd2lkdGg9XCJzdHJldGNoX3Jvd1wiIGNvbnRlbnRfdGV4dF9hbGlnbWVudD1cImNlbnRlclwiIGNzcz1cIi52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O31cIiBwYXJhbGxheF9iYWNrZ3JvdW5kX2ltYWdlPVwiMzgzNlwiXVt2Y19jb2x1bW4gdGhiX2NvbG9yPVwidGhiLWxpZ2h0LWNvbHVtblwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJHb2JsaW5zIGluIGhldCBHb2JsaW4gVmFsbGV5IFN0YXRlIFBhcmtcIiBoZWFkaW5nX3RhZz1cInBcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjZmZmZmZmXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6NDVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDo1NXB4O1wiIG1hcmdpbl9kZXNpZ25fdGFiX3RleHQ9XCJcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjEwcHhcIl1baGV5dXNhX2hlYWRpbmcgdGFnPVwiaDRcIiB0ZXh0X2FsaWduPVwiY2VudGVyXCIgaGVhZGluZz1cIlppam4gaGV0IHBhbm5lbmtvZWtlbiBvZiB0b2NoIGNoYW1waWdub25zP1wiIGZvbnRfc2l6ZT1cIjUwXCIgbGluZV9oZWlnaHQ9XCIxXCIgZm9udF9jb2xvcj1cIiNmZmZmZmZcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bcGFyYWxsYXhfcm93IGVuYWJsZV9tb2JpbGU9XCJwYXJhbGxheC1lbmFibGUtbW9iaWxlXCIgaW1hZ2U9XCIxOTI1M1wiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCJdW3ZjX2NvbHVtbl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiTWVlciBVdGFoOlwiIGZvbnRfY29udGFpbmVyPVwidGFnOmRpdnxmb250X3NpemU6NDB8dGV4dF9hbGlnbjpjZW50ZXJcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3RoYl9wb3N0Z3JpZCBzdHlsZT1cInN0eWxlMTFcIiBjb2x1bW5zPVwiNFwiIHNvdXJjZT1cInBvc3RfdHlwZTpwb3N0fGJ5X2lkOi0xNzMxOCwtMTUwNjIsLTE0OTA3LC0xNDI1MCwtMTI1MDQsLTExOTk3LC05OTgwLC04NzQyLC00NzkyLC00NzM4LC00NzE0LC00Njg5LC00NTc0LC0zMjA4LC0zMDE0LC0xOTcxLDE4OTM5LDE4OTU2LDE4OTMyLDEzNTg3XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddIiwicG9zdF90aXRsZSI6IkdvYmxpbiBWYWxsZXkgU3RhdGUgUGFyayIsInBvc3RfbGluayI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvZ29ibGluLXZhbGxleS1zdGF0ZS1wYXJrLyIsInBvc3RfZmVhdHVyZWRfaW1hZ2UiOiI8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIkdvYmxpbiBWYWxsZXkgU3RhdGUgUGFya1wiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyNC8wMy90aHJlZS1zaXN0ZXJzLUdvYmxpbi1WYWxsZXktU3RhdGUtUGFyay0zMDB4MjAwLmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6IlN0YXRlIFBhcmtzIiwicG9zdF90YWdzIjoiQ2FsaWZvcm5pXHUwMGViIiwiJV93cGJfc2hvcnRjb2Rlc19jdXN0b21fY3NzJSI6Ii52Y19jdXN0b21fMTYwODY2NjUxOTQ5MntiYWNrZ3JvdW5kLWNvbG9yOiAjZWFlYWVhICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNjA4NjY2ODg1NDk3e2JhY2tncm91bmQtaW1hZ2U6IHVybChodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIwLzA4L2JhY2tncm91bmQtaGV5dXNhLW5hdHV1ci0xLmdpZj9pZD0zMDg4KSAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9IiwiJWlubGluZV9mZWF0dXJlZF9pbWFnZSUiOiIwIiwiJV9lZGl0X2xvY2slIjoiMTcwOTcyODkxMDoyIiwiJV9lZGl0X2xhc3QlIjoiMiIsIiVfdGh1bWJuYWlsX2lkJSI6IjE5MjQ0IiwiJV9oaWRlX2ZlYXR1cmVkJSI6bnVsbCwiJV93cGJfdmNfanNfc3RhdHVzJSI6InRydWUiLCIlcG9zdC1wcmltYXJ5LWNhdGVnb3J5JSI6ImF1dG8iLCIlZmVhdHVyZWRfaW1hZ2Vfb3ZlcnJpZGUlIjoib2ZmIiwiJWFydGljbGVfc3R5bGVfb3ZlcnJpZGUlIjoib24iLCIlcG9zdF9zdHlsZSUiOiJzdHlsZTExIiwiJXBvc3RfZ2FsbGVyeV9zdHlsZSUiOiJsaWdodGJveCIsIiVwb3N0X3JldmlldyUiOiJvZmYiLCIlcG9zdF9yZXZpZXdfc3R5bGUlIjoic3R5bGUxIiwiJXBvc3RfcmV2aWV3X2F2ZXJhZ2UlIjoiNTAiLCIlX3lvYXN0X3dwc2VvX2NvbnRlbnRfc2NvcmUlIjoiNjAiLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza2V5d29yZHMlIjoiW10iLCIlX3lvYXN0X3dwc2VvX2tleXdvcmRzeW5vbnltcyUiOiJbXCJcIl0iLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza3clIjoiR29ibGluIFZhbGxleSBTdGF0ZSBQYXJrIiwiJV95b2FzdF93cHNlb19tZXRhZGVzYyUiOiJJbiBVdGFoIHZpbmQgamUgaGV0IEdvYmxpbiBWYWxsZXkgU3RhdGUgUGFyaywgaGV0IHBhcmsgdmFuIGRlICdtdXNocm9vbXMuIFRpcHMgdm9vciBHb2JsaW4gVmFsbGV5IFN0YXRlIFBhcmsuIiwiJV95b2FzdF93cHNlb19saW5rZGV4JSI6Ijc4IiwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6IjE4NjMwR29ibGluLCBWYWxsZXkgUm9hZCwgR3JlZW4gUml2ZXIsIFVUIDg0NTI1LCBWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9sb2NhdGlvbl9jaXR5JSI6IkdyZWVuIFJpdmVyIiwiJV93cGdtcF9sb2NhdGlvbl9zdGF0ZSUiOiJVdGFoIiwiJV93cGdtcF9sb2NhdGlvbl9jb3VudHJ5JSI6IlZlcmVuaWdkZSBTdGF0ZW4iLCIlX3dwZ21wX21ldGFib3hfbGF0aXR1ZGUlIjoiMzguNTczNjk3IiwiJV93cGdtcF9tZXRhYm94X2xvbmdpdHVkZSUiOiItMTEwLjcwNzEwOSIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiN1wiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6IiIsIiVfd3BnbXBfbWV0YWJveF90YXhvbW9taWVzX3Rlcm1zJSI6IiIsIiVfd3BnbXBfZXh0ZW5zaW9uc19maWVsZHMlIjoiIiwiJV95b2FzdF93cHNlb19lc3RpbWF0ZWQtcmVhZGluZy10aW1lLW1pbnV0ZXMlIjoiNSIsIiVfeW9hc3Rfd3BzZW9fcHJpbWFyeV9jYXRlZ29yeSUiOiIxNzAiLCIlX3d3c19zdXBwb3J0X2NvbnRhY3RfbnVtYmVyJSI6IiIsIiVfd3dzX2Fib3V0X3N1cHBvcnRfdGV4dCUiOiIiLCIlX3d3c190cmlnZ2VyX2J1dHRvbl90ZXh0JSI6IiIsIiVfd3dzX3ByZWRlZmluZWRfdGV4dCUiOiIiLCIlX3lvYXN0X3dwc2VvX3dvcmRwcm9vZl90aW1lc3RhbXAlIjoiIiwiJV95b2FzdF9pbmRleG5vd19sYXN0X3BpbmclIjoiMTcwOTcyODY3MCIsIiVfbGFzdF9lZGl0b3JfdXNlZF9qZXRwYWNrJSI6ImNsYXNzaWMtZWRpdG9yIiwiJV93cF9vbGRfZGF0ZSUiOiIyMDIzLTA5LTIyIiwiJV93cF9vbGRfc2x1ZyUiOiJzYWd1YXJvLW5hdGlvbmFsLXBhcmsiLCIlYWN0aXZlZXJfc3VibWVudSUiOiIwIiwiJV9hY3RpdmVlcl9zdWJtZW51JSI6ImZpZWxkXzY1OTNmNTIxZTk3YzIiLCJ0YXhvbm9teT1jYXRlZ29yeSI6IlN0YXRlIFBhcmtzIiwidGF4b25vbXk9cG9zdF90YWciOiJDYWxpZm9ybmlcdTAwZWIiLCJ0YXhvbm9teT1wb3N0X2Zvcm1hdCI6IiIsInRheG9ub215PXRoYi1yZWFjdGlvbnMiOiIiLCJ0YXhvbm9teT10aGItc3BvbnNvcnMiOiIifX0sImlkIjoxOTI0MywiaW5mb3dpbmRvd19kaXNhYmxlIjpmYWxzZX0seyJzb3VyY2UiOiJwb3N0IiwidGl0bGUiOiJEZWFkIEhvcnNlIFBvaW50IFN0YXRlIFBhcmsiLCJpbmZvd2luZG93X2NvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nIFwiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJEZWFkIEhvcnNlIFBvaW50IFN0YXRlIHBhcmsgVXRhaFwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMi8xMS9kZWFkLWhvcnNlLXBvaW50LXN0YXRlLXBhcmstMzAweDIwMC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmcgZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+RGVhZCBIb3JzZSBQb2ludCBTdGF0ZSBQYXJrPC9kaXY+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3JcIj57bWFya2VyX2FkZHJlc3N9PC9kaXY+XHJcbiAgICAgICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1jbGVhclwiPjwvZGl2PlxyXG48L2Rpdj4iLCJhZGRyZXNzIjoiVVQtMzEzLCBNb2FiLCBVVCA4NDUzMiwgVmVyZW5pZ2RlIFN0YXRlbiIsImxvY2F0aW9uIjp7ImxhdCI6IjM4LjUwNTQyNjY5OTk5OTk5IiwiY2l0eSI6Ik1vYWIiLCJzdGF0ZSI6IlV0YWgiLCJjb3VudHJ5IjoiVmVyZW5pZ2RlIFN0YXRlbiIsImxuZyI6Ii0xMDkuNzI5NDI0MSIsIm9uY2xpY2tfYWN0aW9uIjoibWFya2VyIiwicmVkaXJlY3RfcGVybWFsaW5rIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9kZWFkLWhvcnNlLXBvaW50LXN0YXRlLXBhcmsvIiwiem9vbSI6MTIsImV4dHJhX2ZpZWxkcyI6eyJwb3N0X2V4Y2VycHQiOiIiLCJwb3N0X2NvbnRlbnQiOiJbdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiMTAwJVwiXVt2Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkRlYWQgSG9yc2UgUG9pbnQgU3RhdGUgUGFya1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTozNXx0ZXh0X2FsaWduOmxlZnR8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdRGVhZCBIb3JzZSBQb2ludCBTdGF0ZSBQYXJrLCB2b29yYWwgYmVrZW5kIHZhbndlZ2UgZWVuICdib2NodCcgZGllIGRvb3IgaGV0IGxhbmRzY2hhcCBrcm9ua2VsdC4gSG9ld2VsIDxhIGhyZWY9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL2hvcnNlc2hvZS1iZW5kL1wiPkhvcnNlc2hvZSBCZW5kPC9hPiBpbiBBbWVyaWthIGVlbiB2YW4gZGUgcG9wdWxhaXJzdGUgJ2JvY2h0ZW4nIHdlcmVsZHdpamQgaXMsIGJsaWprdCBlciBkdXMgbm9nIGVlbiBwcmFjaHRpZ2UgYm9jaHQgdGUgemlqbi4gT3ZlcmlnZW5zIGVlbiB0ZXJtIGRhdCBpbm1pZGRlbHMgd2VyZWxkd2lqZCBnZWJydWlrdCB3b3JkdCwgdmVsZSBwbGVra2VuIGRpZSBlZW4gemVsZmRlIHNvb3J0IGJvY2h0IGhlYmJlbiwgd29yZGVuIGRlIEhvcnNlc2hvZSBCZW5kIHZhbiBlZW4gbGFuZCBvZiBwbGVrIGdlbm9lbWQuIEluIFV0YWggdmluZCBqZSBkdXMgZWVuIHR3ZWVkZSBIb3JzZXNob2UgQmVuZC4gRWVuIHN0dWsgbWluZGVyIGJla2VuZCBlbiBkYWFyZG9vciBlZW4gc3R1a2plIHJ1c3RpZ2VyLiBKZSBibGlqa3QgZXIgZWVuIHByYWNodGlnIHVpdHppY2h0IHRlIGhlYmJlbiBvdmVyIGRlIENvbG9yYWRvIFJpdmVyIGRpZSA2MDAgbWV0ZXIgbGFnZXIgZG9vciBoZXQgbGFuZHNjaGFwIGtyb25rZWx0LiBUaXBzIHZvb3IgZWVuIGJlem9layBhYW4gaGV0IERlYWQgSG9yc2UgUG9pbnQgU3RhdGUgUGFyay5bL3ZjX2NvbHVtbl90ZXh0XVt1bHRpbWF0ZV9pY29uX2xpc3QgaWNvbl9zaXplPVwiMjBcIl1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLWF1dG9tb2JpbGUgY2FyXCJdNTEga2lsb21ldGVyIHZhbiBNb2FiWy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLXRyZWVcIl08c3BhbiBjbGFzcz1cIkxyelhyIGtuby1mdlwiPjIxIGttMjwvc3Bhbj5bL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVsvdWx0aW1hdGVfaWNvbl9saXN0XVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY3NzPVwiLnZjX2N1c3RvbV8xNjA4NjY2NTE5NDkye2JhY2tncm91bmQtY29sb3I6ICNlYWVhZWEgIWltcG9ydGFudDt9XCJdW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIyLzNcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNzVweFwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiRGUgbGVnZW5kZSB2YW4gRGVhZCBIb3JzZSBQb2ludCBTdGF0ZSBQYXJrXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjM1fHRleHRfYWxpZ246Y2VudGVyfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XURlIG5hYW0gRGVhZCBIb3JzZSBrbGlua3QgbmF0dXVybGlqayByZWRlbGlqayBsdWd1YmVyLiBFciBnYWF0IGVlbiBsZWdlbmRlIGRhdCBkZSBuYWFtIGtvbXQgdWl0IGVpbmQgMTllIGVldXcuIEhldCBwdW50IHdlcmQgZ2VicnVpa3QgYWxzIHZhbmduZXQgdm9vciB3aWxkZSBtdXN0YW5ncy4gQ293Ym95cyBkcmV2ZW4gemUgbmFhciBkZSBzbWFsbGUgbGFuZHRvbmcgd2FhcmRvb3IgemUgJ29wZ2VzbG90ZW4nIGt3YW1lbiB0ZSB6aXR0ZW4gem9uZGVyIHdhdGVyLCBkYXQgemljaCBvdmVyaWdlbnMgem8nbiA2MDAgbWV0ZXIgbGFnZXIgYmV2b25kLiBEZSBwYWFyZGVuIHZvbmRlbiBoZWxhYXMgZGUgZG9vZCBkb29yZGF0IHplIHVpdGdlZHJvb2dkIHJhYWt0ZW4uWy92Y19jb2x1bW5fdGV4dF1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiIGZ1bGxfd2lkdGg9XCJzdHJldGNoX3Jvd1wiIGNvbnRlbnRfdGV4dF9hbGlnbWVudD1cImNlbnRlclwiIGNzcz1cIi52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O31cIiBwYXJhbGxheF9iYWNrZ3JvdW5kX2ltYWdlPVwiMzgzNlwiXVt2Y19jb2x1bW4gdGhiX2NvbG9yPVwidGhiLWxpZ2h0LWNvbHVtblwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIlpvbnNvcGdhbmcgZW4gem9uc29uZGVyZ2FuZ1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTo3NXx0ZXh0X2FsaWduOmNlbnRlcnxjb2xvcjolMjNmZmZmZmZ8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1baGV5dXNhX2hlYWRpbmcgdGFnPVwiZGl2XCIgdGV4dF9hbGlnbj1cImNlbnRlclwiIGhlYWRpbmc9XCJEZSBiZXN0ZSB0aWpkIG9tIGhldCBwYXJrIHRlIGJlem9la2VuXCIgZm9udF9zaXplPVwiNTBcIiBsaW5lX2hlaWdodD1cIjUwXCIgZm9udF9jb2xvcj1cIiNmZmZmZmZcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bcGFyYWxsYXhfcm93IGVuYWJsZV9tb2JpbGU9XCJwYXJhbGxheC1lbmFibGUtbW9iaWxlXCIgaW1hZ2U9XCIxOTIzOFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCJdW3ZjX2NvbHVtbl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiSG9lIGtvbSBqZSBiaWogaGV0IERlYWQgSG9yc2UgUG9pbnQgU3RhdGUgUGFyaz9cIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MjV8dGV4dF9hbGlnbjpsZWZ0XCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1KZSBrdW50IGhldCBwYXJrIG1ha2tlbGlqayBiZXJlaWtlbiB2YW51aXQgTW9hYi4gUmlqZCBvbmdldmVlciAxNSBraWxvbWV0ZXIgbm9vcmR3ZXN0IHZhbmFmIE1vYWIgb3AgVVMgMTkxLiBkYWFybmEgb25nZXZlZXIgMzcga2lsb21ldGVyIHp1aWR3ZXN0IG9wIFV0YWggMzEzLiBEZSBhZnN0YW5kIHRvdCBoZXQgdmlzaXRvciBjZW50ZXIgdmFudWl0IE1vYWIgaXMgb25nZXZlZXIgNDUgbWludXRlbi4gRGFhcm5hYXN0IGlzIGdvZWQgdGUgY29tYmluZXJlbiBtZXQgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvY2FueW9ubGFuZHMtbmF0aW9uYWwtcGFyay9cIj5DYW55b25sYW5kcyBOYXRpb25hbCBQYXJrPC9hPi5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIk92ZXJuYWNodGVuIGluIGRlIGJ1dXJ0XCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjI1fHRleHRfYWxpZ246bGVmdFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdRXIgemlqbiAyIG1vZ2VsaWpraGVkZW4gb20gdGUga2FtcGVyZW4gYmlqIERlYWQgSG9yc2UgUG9pbnQgU3RhdGUgUGFyay4gSmUgaGVidCBkZSBLYXllbnRhIENhbXBncm91bmQgZW4gc2luZHMgMjAxOCBvb2sgZGUgV2luZ2F0ZSBDYW1wZ3JvdW5kLiBEZSBwbGVra2VuIGhlYmJlbiBtb2dlbGlqa2hlZGVuIHZvb3IgZWxla3RyaWNpdGVpdCwgcGlja25pY2twbGVra2VuLCB0b2lsZXR0ZW4gZW4gZG91Y2hlcy4gRWVuIGFuZGVyZSBtb2dlbGlqa2hlaWQgb20gdGUgb3Zlcm5hY2h0ZW4gaXMgaW4gMSB2YW4gZGUgOSB5dXJ0cyBiaWogaGV0IHBhcmsuIERcdTAwZTkgbG9jYXRpZSB2b29yIGVlbiB6b25zb3Brb21zdCBlbiB6b25zb25kZXJnYW5nLiBKZSBrdW50IG1ldCA2IHBlcnNvbmVuIHNsYXBlbiBpbiBkZXplIHl1cnRzLiA8YSBocmVmPVwiaHR0cHM6Ly91dGFoc3RhdGVwYXJrcy5yZXNlcnZlYW1lcmljYS5jb20vY2FtcGluZy9kZWFkLWhvcnNlLXBvaW50LXN0YXRlLXBhcmsvci9jYW1wZ3JvdW5kRGV0YWlscy5kbz9jb250cmFjdENvZGU9VVQmYW1wO3BhcmtJZD0zNDQxNjFcIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPkJla2lqayBoaWVyIGRlIHl1cnRzPC9hPi4gT20gaWV0cyBsdXhlciB0ZSBvdmVybmFjaHRlbiBpcyBNb2FiIGRlIGJlc3RlIHVpdHZhbHNiYXNpcy4gSGllciB2aW5kIGplIDxhIGhyZWY9XCJodHRwczovL3d3dy5ib29raW5nLmNvbS9zZWFyY2hyZXN1bHRzLmVuLmh0bWw/Y2l0eT0yMDEzMzYwMyZhbXA7YWlkPTc5NTg0OTgmYW1wO25vX3Jvb21zPTEmYW1wO2dyb3VwX2FkdWx0cz0yJmFtcDtsYWJlbD1kZWFkaG9yc2Vwb2ludFwiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+dmVsZSBob3RlbHM8L2E+IG9tIHRlIG92ZXJuYWNodGVuLlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJXYXQgdGUgZG9lbiBiaWogaGV0IERlYWQgSG9yc2UgUG9pbnQgU3RhdGUgUGFya1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZToyNXx0ZXh0X2FsaWduOmxlZnRcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XURlYWQgSG9yc2UgUG9pbnQgU3RhdGUgUGFyayBpcyBlZW4gcmVsYXRpZWYga2xlaW4gcGFyay4gSG9ld2VsIGhldCB1aXR6aWNodCBvdmVyIGRlemUgJ0hvcnNlc2hvZSBCZW5kJyB2ZWVsIGdvZWQgbWFha3QsIHppam4gZXIgd2VpbmlnIGFuZGVyZSBkaW5nZW4gb20gdGUgZG9lbiBpbiBoZXQgcGFyay4gRXIgemlqbiBlZW4gYWFudGFsIGtvcnRlIGhpa2luZyBlbiBmaWV0cyB0cmFpbHMsIHZlcnNjaGlsbGVuZGUgYW5kZXJlIHVpdGtpamtwdW50ZW4gb20gdGUgYmV3b25kZXJlbiBlbiBqZSBrdW50IGVyIGdvZWQgcGlja25pY2tlbi4gRGFhcm5hYXN0IGlzIGhldCBwYXJrIGVlbiBnZWNlcnRpZmljZWVyZCBEYXJrIFNreSBQYXJrLCBlZW4gcGVyZmVjdGUgcGxlayBvbSBzdGVycmVuIHRlIGtpamtlbi5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkJlc3RlIHBlcmlvZGUgb20gaGV0IERlYWQgSG9yc2UgUG9pbnQgU3RhdGUgUGFyayB0ZSBiZXpvZWtlblwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZToyNXx0ZXh0X2FsaWduOmxlZnRcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XUplIGt1bnQgRGVhZCBIb3JzZSBQb2ludCBTdGF0ZSBQYXJrIGhldCBoZWxlIGphYXIgZG9vciBiZXpvZWtlbi4gRWNodGVyIGthbiBoZXQgaW4gZGUgem9tZXJtYWFuZGVuIHdhcm0gd29yZGVuIGluIGhldCBwYXJrLiBEZSBiZXN0ZSBqYWFyZ2V0aWpkZSBpcyBkYWFyb20gZGUgbGVudGUgb2YgaGVyZnN0LiBJbiBkZSB3aW50ZXJtYWFuZGVuIGhlYiBqZSBrYW5zIG9wIHRlbXBlcmF0dXJlbiByb25kIGhldCB2cmllc3B1bnQgZW4ga2FuIGhldCBhZiBlbiB0b2Ugc25lZXV3ZW4uIEhldCBwb3B1bGFpcnN0ZSBtb21lbnQgb3AgZGUgZGFnIG9tIGhldCBwYXJrIHRlIGJlem9la2VuIGlzIHRpamRlbnMgem9uc29wa29tc3QgZW4gem9uc29uZGVyZ2FuZy5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIGNvbnRlbnRfcGxhY2VtZW50PVwibWlkZGxlXCIgZnVsbF93aWR0aD1cInN0cmV0Y2hfcm93XCIgY29udGVudF90ZXh0X2FsaWdtZW50PVwiY2VudGVyXCIgY3NzPVwiLnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fVwiIHBhcmFsbGF4X2JhY2tncm91bmRfaW1hZ2U9XCIzODM2XCJdW3ZjX2NvbHVtbiB0aGJfY29sb3I9XCJ0aGItbGlnaHQtY29sdW1uXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiRGVhZCBIb3JzZSBQb2ludCBTdGF0ZSBQYXJrXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjc1fHRleHRfYWxpZ246Y2VudGVyfGNvbG9yOiUyM2ZmZmZmZnxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVtoZXl1c2FfaGVhZGluZyB0YWc9XCJkaXZcIiB0ZXh0X2FsaWduPVwiY2VudGVyXCIgaGVhZGluZz1cIlRyYWlscyBpbiBoZXQgcGFya1wiIGZvbnRfc2l6ZT1cIjUwXCIgbGluZV9oZWlnaHQ9XCI1MFwiIGZvbnRfY29sb3I9XCIjZmZmZmZmXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3BhcmFsbGF4X3JvdyBlbmFibGVfbW9iaWxlPVwicGFyYWxsYXgtZW5hYmxlLW1vYmlsZVwiIGltYWdlPVwiMTkyMzdcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIGNzcz1cIi52Y19jdXN0b21fMTYwODY2Njg4NTQ5N3tiYWNrZ3JvdW5kLWltYWdlOiB1cmwoaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMC8wOC9iYWNrZ3JvdW5kLWhleXVzYS1uYXR1dXItMS5naWY/aWQ9MzA4OCkgIWltcG9ydGFudDt9XCJdW3ZjX2NvbHVtbl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfc2luZ2xlX2ltYWdlIGltYWdlPVwiMTkyMzZcIiBpbWdfc2l6ZT1cImxhcmdlXCIgYWRkX2NhcHRpb249XCJ5ZXNcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiSGFuZGlnZSBpbmZvIHZvb3IgamUgYmV6b2VrXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzAwMDAwMFwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OlJvYm90byBTbGFifGZvbnRfY2FsbDpSb2JvdG8rU2xhYnx2YXJpYW50OjgwMFwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NTVweDtcIiBtYWluX2hlYWRpbmdfc3R5bGU9XCJmb250LXdlaWdodDo4MDA7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt1bHRpbWF0ZV9pY29uX2xpc3QgaWNvbl9zaXplPVwiMjVcIl1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLWNsb2NrLW9cIiBjb250ZW50X2ZvbnRfc2l6ZT1cImRlc2t0b3A6MTZweDtcIl0zNjUgZGFnZW4gcGVyIGphYXIgLSB2YW5hZiAwNi4wMC0yMi4wMCB1dXJbL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtZG9sbGFyIHVzZFwiIGNvbnRlbnRfZm9udF9zaXplPVwiZGVza3RvcDoxNnB4O1wiXSQyMCB2b29yIGVlbiBhdXRvXHJcbiQxMCB2b29yIHZvZXRnYW5nZXJzWy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLXRodW1icy11cFwiIGNvbnRlbnRfZm9udF9zaXplPVwiZGVza3RvcDoxNnB4O1wiXUJlc3RlIHBlcmlvZGU6IGxlbnRlIGVuIGhlcmZzdFsvdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dWy91bHRpbWF0ZV9pY29uX2xpc3RdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI3NXB4XCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIyLzNcIl1baGV5dXNhX2hlYWRpbmcgdGFnPVwiZGl2XCIgdGV4dF9hbGlnbj1cImNlbnRlclwiIGhlYWRpbmc9XCJPbnRkZWsgbWVlciBuYXR1dXIgaW4gZGUgYnV1cnRcIiBmb250X3NpemU9XCI0MFwiIGxpbmVfaGVpZ2h0PVwiNDBcIiBmb250X2NvbG9yPVwiIzI4MjgyOFwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIk5vZyBtZWVyIFV0YWhcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMjgyODI4XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6NDBweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDo0NXB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjI1cHhcIl1bdGhiX3Bvc3RiYWNrZ3JvdW5kIHN0eWxlPVwic3R5bGUyXCIgc291cmNlPVwiYnlfaWQ6LTE2MTkyLC0xNjIwNCwtMTYxNzQsLTE2MTI2LC0xNTY0NCwtMTU2MTQsLTE1NTgwLC0xMjYyLC0yMjY3LC01NzIsLTU0NSwxODkxNiw0MTk1LDEyNzMsNDgxN1wiXVsvdmNfY29sdW1uXVsvdmNfcm93XSIsInBvc3RfdGl0bGUiOiJEZWFkIEhvcnNlIFBvaW50IFN0YXRlIFBhcmsiLCJwb3N0X2xpbmsiOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL2RlYWQtaG9yc2UtcG9pbnQtc3RhdGUtcGFyay8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJEZWFkIEhvcnNlIFBvaW50IFN0YXRlIHBhcmsgVXRhaFwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMi8xMS9kZWFkLWhvcnNlLXBvaW50LXN0YXRlLXBhcmstMzAweDIwMC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj4iLCJwb3N0X2NhdGVnb3JpZXMiOiJTdGF0ZSBQYXJrcyIsInBvc3RfdGFncyI6IlV0YWgiLCIlX3dwYl9zaG9ydGNvZGVzX2N1c3RvbV9jc3MlIjoiLnZjX2N1c3RvbV8xNjA4NjY2NTE5NDkye2JhY2tncm91bmQtY29sb3I6ICNlYWVhZWEgIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE2MDg2NjY4ODU0OTd7YmFja2dyb3VuZC1pbWFnZTogdXJsKGh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjAvMDgvYmFja2dyb3VuZC1oZXl1c2EtbmF0dXVyLTEuZ2lmP2lkPTMwODgpICFpbXBvcnRhbnQ7fSIsIiVpbmxpbmVfZmVhdHVyZWRfaW1hZ2UlIjoiMCIsIiVfZWRpdF9sb2NrJSI6IjE3MDk3MTE1NDk6MiIsIiVfZWRpdF9sYXN0JSI6IjIiLCIlX2hpZGVfZmVhdHVyZWQlIjpudWxsLCIlX3dwYl92Y19qc19zdGF0dXMlIjoidHJ1ZSIsIiVwb3N0LXByaW1hcnktY2F0ZWdvcnklIjoiYXV0byIsIiVmZWF0dXJlZF9pbWFnZV9vdmVycmlkZSUiOiJvZmYiLCIlYXJ0aWNsZV9zdHlsZV9vdmVycmlkZSUiOiJvbiIsIiVwb3N0X3N0eWxlJSI6InN0eWxlMTEiLCIlcG9zdF9nYWxsZXJ5X3N0eWxlJSI6ImxpZ2h0Ym94IiwiJXBvc3RfcmV2aWV3JSI6Im9mZiIsIiVwb3N0X3Jldmlld19zdHlsZSUiOiJzdHlsZTEiLCIlcG9zdF9yZXZpZXdfYXZlcmFnZSUiOiI1MCIsIiVfeW9hc3Rfd3BzZW9fY29udGVudF9zY29yZSUiOiI5MCIsIiVfeW9hc3Rfd3BzZW9fZm9jdXNrZXl3b3JkcyUiOiJbXSIsIiVfeW9hc3Rfd3BzZW9fa2V5d29yZHN5bm9ueW1zJSI6IltcIkRlYWQgSG9yc2UgUG9pbnRcIl0iLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza3clIjoiRGVhZCBIb3JzZSBQb2ludCBTdGF0ZSBQYXJrIiwiJV95b2FzdF93cHNlb19tZXRhZGVzYyUiOiJPbnRkZWsgRGVhZCBIb3JzZSBQb2ludCBTdGF0ZSBQYXJrIGluIGRlIHN0YWF0IFV0YWguIEJlbmlldXdkIHdhdCBqZSBlciBrdW50IGRvZW4/IFRpcHMgdm9vciBlZW4gYmV6b2VrIGFhbiBkZSBEZWFkIEhvcnNlIFBvaW50IFN0YXRlIFBhcmsuIiwiJV95b2FzdF93cHNlb19saW5rZGV4JSI6IjY4IiwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6IlVULTMxMywgTW9hYiwgVVQgODQ1MzIsIFZlcmVuaWdkZSBTdGF0ZW4iLCIlX3dwZ21wX2xvY2F0aW9uX2NpdHklIjoiTW9hYiIsIiVfd3BnbXBfbG9jYXRpb25fc3RhdGUlIjoiVXRhaCIsIiVfd3BnbXBfbG9jYXRpb25fY291bnRyeSUiOiJWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9tZXRhYm94X2xhdGl0dWRlJSI6IjM4LjUwNTQyNjY5OTk5OTk5IiwiJV93cGdtcF9tZXRhYm94X2xvbmdpdHVkZSUiOiItMTA5LjcyOTQyNDEiLCIlX3dwZ21wX21ldGFib3hfbG9jYXRpb25fcmVkaXJlY3QlIjoibWFya2VyIiwiJV93cGdtcF9tZXRhYm94X2N1c3RvbV9saW5rJSI6IiIsIiVfd3BnbXBfbWFwX2lkJSI6ImE6MTp7aTowO3M6MTpcIjdcIjt9IiwiJV93cGdtcF9tZXRhYm94X21hcmtlcl9pZCUiOiIiLCIlX3dwZ21wX21ldGFib3hfdGF4b21vbWllc190ZXJtcyUiOiIiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6IiIsIiVfeW9hc3Rfd3BzZW9fZXN0aW1hdGVkLXJlYWRpbmctdGltZS1taW51dGVzJSI6IjQiLCIlX3lvYXN0X3dwc2VvX3ByaW1hcnlfY2F0ZWdvcnklIjoiMTcwIiwiJV95b2FzdF93cHNlb190aXRsZSUiOiJEZWFkIEhvcnNlIFBvaW50IFN0YXRlIFBhcmsgJSVwYWdlJSUgJSVzZXAlJSAlJXNpdGVuYW1lJSUiLCIlX3d3c19zdXBwb3J0X2NvbnRhY3RfbnVtYmVyJSI6IiIsIiVfd3dzX2Fib3V0X3N1cHBvcnRfdGV4dCUiOiIiLCIlX3d3c190cmlnZ2VyX2J1dHRvbl90ZXh0JSI6IiIsIiVfd3dzX3ByZWRlZmluZWRfdGV4dCUiOiIiLCIlX3lvYXN0X3dwc2VvX3dvcmRwcm9vZl90aW1lc3RhbXAlIjoiIiwiJV95b2FzdF9pbmRleG5vd19sYXN0X3BpbmclIjoiMTcwOTcxMTI0MSIsIiVfbGFzdF9lZGl0b3JfdXNlZF9qZXRwYWNrJSI6ImNsYXNzaWMtZWRpdG9yIiwiJXN0YW5kYXJkLWZlYXR1cmVkLWNyZWRpdCUiOiIiLCIlX3RodW1ibmFpbF9pZCUiOiIxMzU5NiIsIiVhY3RpdmVlcl9zdWJtZW51JSI6IjAiLCIlX2FjdGl2ZWVyX3N1Ym1lbnUlIjoiZmllbGRfNjU5M2Y1MjFlOTdjMiIsIiVfd3Bfb2xkX2RhdGUlIjoiMjAyNC0wMi0wNiIsInRheG9ub215PWNhdGVnb3J5IjoiU3RhdGUgUGFya3MiLCJ0YXhvbm9teT1wb3N0X3RhZyI6IlV0YWgiLCJ0YXhvbm9teT1wb3N0X2Zvcm1hdCI6IiIsInRheG9ub215PXRoYi1yZWFjdGlvbnMiOiIiLCJ0YXhvbm9teT10aGItc3BvbnNvcnMiOiIifX0sImlkIjoxOTIzMywiaW5mb3dpbmRvd19kaXNhYmxlIjpmYWxzZX0seyJzb3VyY2UiOiJwb3N0IiwidGl0bGUiOiJBbnRlbG9wZSBJc2xhbmQgU3RhdGUgUGFyayIsImluZm93aW5kb3dfY29udGVudCI6IjxkaXYgY2xhc3M9XCJmYy1pdGVtLWJveCBmYy1pdGVtLW5vLXBhZGRpbmcgXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIkFudGVsb3BlIElzbGFuZCBTdGF0ZSBQYXJrIGluIFV0YWhcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjIwMFwiIHNyYz1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjQvMDIvYW50ZWxvcGUtaXNsYW5kLTMwMHgyMDAuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZ1wiPlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nIGZjLWl0ZW0tbm8tcGFkZGluZ1wiPlxyXG4gICAgICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS10aXRsZSBmYy1pdGVtLXByaW1hcnktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZVwiPkFudGVsb3BlIElzbGFuZCBTdGF0ZSBQYXJrPC9kaXY+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3JcIj57bWFya2VyX2FkZHJlc3N9PC9kaXY+XHJcbiAgICAgICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1jbGVhclwiPjwvZGl2PlxyXG48L2Rpdj4iLCJhZGRyZXNzIjoiQW50ZWxvcGUgSXNsYW5kIFN0YXRlIFBhcmssIFV0YWgsIFZlcmVuaWdkZSBTdGF0ZW4iLCJsb2NhdGlvbiI6eyJsYXQiOiI0MS4wMDUxNzYzIiwic3RhdGUiOiJVdGFoIiwiY291bnRyeSI6IlZlcmVuaWdkZSBTdGF0ZW4iLCJsbmciOiItMTEyLjI1NDUxNTMiLCJvbmNsaWNrX2FjdGlvbiI6Im1hcmtlciIsInJlZGlyZWN0X3Blcm1hbGluayI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvYW50ZWxvcGUtaXNsYW5kLXN0YXRlLXBhcmsvIiwiem9vbSI6MTIsImV4dHJhX2ZpZWxkcyI6eyJwb3N0X2V4Y2VycHQiOiIiLCJwb3N0X2NvbnRlbnQiOiJbdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiMTAwJVwiXVt2Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkFudGVsb3BlIElzbGFuZCBTdGF0ZSBQYXJrXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjM1fHRleHRfYWxpZ246bGVmdHxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1VdGFoIGtlbnQgdGFsIHZhbiBzdGF0ZSBwYXJrcy4gVmVlbCBzdGFhbiBiZWtlbmQgb20gZGUgcm9kZSByb3RzZm9ybWF0aWVzLiBFZW4gc3RhdGUgcGFyayBkaWUgZGF0IG5pZXQgaGVlZnQgaW4gVXRhaCwgaXMgQW50ZWxvcGUgSXNsYW5kIFN0YXRlIFBhcmsuIEplIHZpbmR0IGhldCBwYXJrIGluIGRlIGJ1dXJ0IHZhbiA8YSBocmVmPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93YXQtdGUtZG9lbi1pbi1zYWx0LWxha2UtY2l0eS9cIj5TYWx0IExha2UgQ2l0eTwvYT4gd2FhcmRvb3IgaGV0IGVlbiBsZXVrZSBkYWd0cmlwIGlzIHZhbnVpdCBkZSBzdGFkLiBIZXQgcGFyayBtYWFrdCBvbmRlcmRlZWwgdWl0IHZhbiBkZSBHcmVhdCBTYWx0IExha2UgZW4gaGVlZnQgZWVuIGNvbWJpbmF0aWUgdmFuIG5hdHV1ciBlbiB3aWxkbGlmZS4gRWVuIGFhbnRhbCB0aXBzIHZvb3IgZWVuIGJlem9layBhYW4gQW50ZWxvcGUgSXNsYW5kIFN0YXRlIFBhcmsgaW4gPGEgaHJlZj1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvdXRhaC9cIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPlV0YWguPC9hPlsvdmNfY29sdW1uX3RleHRdW3VsdGltYXRlX2ljb25fbGlzdCBpY29uX3NpemU9XCIyMFwiXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtYXV0b21vYmlsZSBjYXJcIl00MCBraWxvbWV0ZXIgdmFuYWYgU2FsdCBMYWtlIENpdHlbL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtdHJlZVwiXTxzcGFuIGNsYXNzPVwiTHJ6WHIga25vLWZ2XCI+MTkwIGttXHUwMGIyIG9wcGVydmxha3RlPC9zcGFuPlsvdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy1wYXdcIl0xMiB2ZXJzY2hpbGxlbmRlIHNvb3J0ZW4gZGllcmVuLCB3YWFydmFuIHR1c3NlbiA1MDAtNzAwIGJpem9uc1svdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dWy91bHRpbWF0ZV9pY29uX2xpc3RdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjc3M9XCIudmNfY3VzdG9tXzE2MDg2NjY1MTk0OTJ7YmFja2dyb3VuZC1jb2xvcjogI2VhZWFlYSAhaW1wb3J0YW50O31cIl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjIvM1wiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI3NXB4XCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJIZXQgZ3Jvb3RzdGUgZWlsYW5kIHZhbiBHcmVhdCBTYWx0IExha2VcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MzV8dGV4dF9hbGlnbjpjZW50ZXJ8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxwIHN0eWxlPVwidGV4dC1hbGlnbjogY2VudGVyO1wiPk1ldCBlZW4gb3BwZXJ2bGFrdGUgdmFuIDEwOSBrbTMgaXMgQW50ZWxvcGUgSXNsYW5kIFN0YXRlIFBhcmsgZGUgZ3Jvb3RzdGUgdmFuIGRlIDEwIGVpbGFuZGVuIGRpZSBpbiBHcmVhdCBTYWx0IExha2UgbGlnZ2VuLiBCaWogZWVuIGxhZ2Ugd2F0ZXJzdGFuZCB3b3JkdCBBbnRlbG9wZSBJc2xhbmQgZWVuIHNjaGllcmVpbGFuZC4gSGV0IGdlYmllZCB3YXMgbGFuZ2UgdGlqZCBwYXJ0aWN1bGllciBiZXppdCBkb29yIGRlIE1vcm1vbWVuIGRpZSB6aWNoIHJvbmQgMTg0OCBpbiBkZXplIHJlZ2lvIHZlc3RpZ2Rlbi4gRGUgZ3JvbmQgd2VyZCBnZWJydWlrdCB2b29yIGVlbiByYW5jaC4gSW4gMTk2OSBrb2NodCBkZSBzdGFhdCBoZXQgbm9vcmRlbGlqa2UgZGVlbCwgaW4gMTk4MSB3ZXJkIGRlIHJlc3Qgb3BnZWtvY2h0LiBEZSBuYWFtIGtvbXQgb3ZlcmlnZW5zIDxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj52YW4gZGUgZWVyc3RlIG9udGRla2tlcnMgZGllIGluIDE4NDMgYW50aWxvcGVuIHphZ2VuIGxvcGVuIG9wIGhldCBlaWxhbmQuPC9zcGFuPjwvcD5cclxuWy92Y19jb2x1bW5fdGV4dF1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiIGZ1bGxfd2lkdGg9XCJzdHJldGNoX3Jvd1wiIGNvbnRlbnRfdGV4dF9hbGlnbWVudD1cImNlbnRlclwiIGNzcz1cIi52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O31cIiBwYXJhbGxheF9iYWNrZ3JvdW5kX2ltYWdlPVwiMzgzNlwiXVt2Y19jb2x1bW4gdGhiX2NvbG9yPVwidGhiLWxpZ2h0LWNvbHVtblwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkJpem9uIGluIEFudGVsb3BlIElzbGFuZCBTdGF0ZSBQYXJrIGluIFV0YWhcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6NzV8dGV4dF9hbGlnbjpjZW50ZXJ8Y29sb3I6JTIzZmZmZmZmfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW2hleXVzYV9oZWFkaW5nIHRhZz1cImg0XCIgdGV4dF9hbGlnbj1cImNlbnRlclwiIGhlYWRpbmc9XCJWZWVsIHdpbGRsaWZlIGluIGhldCBzdGF0ZSBwYXJrXCIgZm9udF9zaXplPVwiNTBcIiBsaW5lX2hlaWdodD1cIjFcIiBmb250X2NvbG9yPVwiI2ZmZmZmZlwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVtwYXJhbGxheF9yb3cgZW5hYmxlX21vYmlsZT1cInBhcmFsbGF4LWVuYWJsZS1tb2JpbGVcIiBpbWFnZT1cIjE5MTI1XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIl1bdmNfY29sdW1uXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJIb2Uga29tIGplIGJpaiBBbnRlbG9wZSBJc2xhbmQgU3RhdGUgUGFyaz9cIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MjV8dGV4dF9hbGlnbjpsZWZ0XCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1KZSBrdW50IEFudGVsb3BlIElzbGFuZCBTdGF0ZSBQYXJrIGJlcmVpa2VuIHZpYSBJbnRlcnN0YXRlIDE1LiBOZWVtIGV4aXQgMzMyLCByaWpkIGRhYXJuYSBuYWFyIGhldCB3ZXN0ZW4gb3AgQW50ZWxvcGUgRHJpdmUgdm9vciBvbmdldmVlciAxMSBraWxvbWV0ZXIgbmFhciBkZSBlbnRyZWUuIERhYXJuYSByaWpkIGplIG92ZXIgZGUgZGlqayBuYWFyIGhldCBlaWxhbmQuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJXYXQgdGUgZG9lbiBpbiBBbnRlbG9wZSBJc2xhbmQgU3RhdGUgUGFya1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZToyNXx0ZXh0X2FsaWduOmxlZnRcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XUhvZXdlbCBBbnRlbG9wZSBJc2xhbmQgU3RhdGUgUGFyayBuaWV0IGhlZWwgZ3Jvb3QgaXMsIHppam4gZXIgZWVuIGFhbnRhbCBkaW5nZW4gZGllIGplIGVyIGt1bnQgZG9lbi4gRXIgemlqbiBuaWV0IGFsbGVlbiBlZW4gYWFudGFsIGhpa2luZyB0cmFpbHMsIGplIGt1bnQgZXIgb29rIG1vdW50YWluYmlrZW4uIERhYXJuYWFzdCB6aWpuIGVyIG1vZ2VsaWpraGVkZW4gb20gZGUga2FqYWtrZW4gZW4gcGFkZGxlYm9hcmRlbiBvcCBoZXQgd2F0ZXIuIEhldCBnZWJpZWQgaXMgZWVuIGRhcmsgc2t5IHBhcmssIHdhYXJkb29yIHN0ZXJyZW5raWprZW4gb29rIGVlbiBnb2VkZSBhY3Rpdml0ZWl0IGlzLiBFbiBuYXR1dXJsaWprIGlzIGhldCBnZWJpZWQgZWVuIGdvZWRlIHBsZWsgb20gd2lsZGxpZmUgdGUgc3BvdHRlbi4gQW50aWxvcGVzIGVuIGJpem9ucyBsb3BlbiB2cmlqIGluIGhldCBnZWJpZWQsIG1hYXIgb29rIGRpa2hvb3Juc2NoYXBlbiwgY295b3Rlcywgc3Rla2VsdmFya2VucywgZGFzc2VuIGVuIGx5bnhlbiBsZXZlbiBpbiBoZXQgZ2ViaWVkLlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJPdmVybmFjaHRlbiBpbiBBbnRlbG9wZSBJc2xhbmQgU3RhdGUgUGFya1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZToyNXx0ZXh0X2FsaWduOmxlZnRcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XUluIGhldCBBbnRlbG9wZSBJc2xhbmQgU3RhdGUgUGFyayB6aWpuIGFsbGVlbiBtb2dlbGlqa2hlZGVuIG9tIHRlIGthbXBlcmVuLiBFciB6aWpuIHBsZWtrZW4gdm9vciBmYW1pbGllcywga2xlaW5lIGdyb2VwZW4gZW4gZ3JvdGUgZ3JvZXBlbi4gRXIgemlqbiBmYWNpbGl0ZWl0ZW4gb3AgZGUgY2FtcGluZ3MsIGJpanZvb3JiZWVsZCB0b2lsZXR0ZW4gZW4gZG91Y2hlcyB6aWpuIGVyIG9wIEJyaWRnZXIgQmF5IENhbXBncm91bmQuIEVyIHdvcmR0IGFhbmdlcmFkZW4gb20gdGUgPGEgaHJlZj1cImh0dHBzOi8vdXRhaHN0YXRlcGFya3MucmVzZXJ2ZWFtZXJpY2EuY29tL2NhbXBpbmcvYW50ZWxvcGUtaXNsYW5kLXN0YXRlLXBhcmsvci9jYW1wZ3JvdW5kRGV0YWlscy5kbz9jb250cmFjdENvZGU9VVQmYW1wO3BhcmtJZD0zNDMwMzFcIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPnJlc2VydmVyZW48L2E+IHZvb3JhZmdhYW5kIGFhbiBqZSBiZXpvZWsuIFdpbCBqZSBpbiBlZW4gaG90ZWwgb3Zlcm5hY2h0ZW4/IERhYXJ2b29yIGt1biBqZSBoZXQgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmJvb2tpbmcuY29tL3NlYXJjaHJlc3VsdHMuZW4uaHRtbD9jaXR5PTIwMTMzOTU2JmFtcDthaWQ9Nzk1ODQ5OCZhbXA7bm9fcm9vbXM9MSZhbXA7Z3JvdXBfYWR1bHRzPTImYW1wO2xhYmVsPWFudGVsb3BlaXNsYW5kc3RhdGVwYXJrc2FsdGxha2VcIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPmJlc3RlIGVlbiBhY2NvbW1vZGF0aWUgaW4gU2FsdCBMYWtlIENpdHkga2llemVuPC9hPi5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkJlc3RlIHJlaXNwZXJpb2RlIEFudGVsb3BlIElzbGFuZCBTdGF0ZSBQYXJrXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjI1fHRleHRfYWxpZ246bGVmdFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdQW50ZWxvcGUgSXNsYW5kIFN0YXRlIFBhcmsgaXMgaGV0IGhlbGUgamFhciBkb29yIHRlIGJlem9la2VuLCBtYWFyIGRvb3IgZGUgaG9nZSBjb25jZW50cmF0aWUgem91dCB6aWpuIGVyIG9wIGJlcGFhbGRlIHBlcmlvZGVzIHZlZWwgdmxpZWdlbiB0ZSB2aW5kZW4uIFpla2VyIGluIGRlIHdhcm1lIHpvbWVybWFhbmRlbiBrdW4gamUgbGFzdCBoZWJiZW4gdmFuIHZsaWVnZW4uIEJlem9layBkYWFyb20gaGV0IHBhcmsgaW4gZGUgdnJvZWdlIGxlbnRlIG9mIGluIGRlIGhlcmZzdC5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIGNvbnRlbnRfcGxhY2VtZW50PVwibWlkZGxlXCIgZnVsbF93aWR0aD1cInN0cmV0Y2hfcm93XCIgY29udGVudF90ZXh0X2FsaWdtZW50PVwiY2VudGVyXCIgY3NzPVwiLnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fVwiIHBhcmFsbGF4X2JhY2tncm91bmRfaW1hZ2U9XCIzODM2XCJdW3ZjX2NvbHVtbiB0aGJfY29sb3I9XCJ0aGItbGlnaHQtY29sdW1uXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIldhbmRlbGVuIGluIEFudGVsb3BlIElzbGFuZCBTdGF0ZSBQYXJrXCIgaGVhZGluZ190YWc9XCJwXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiI2ZmZmZmZlwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjQ1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NTVweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjEwcHhcIl1baGV5dXNhX2hlYWRpbmcgdGFnPVwiaDRcIiB0ZXh0X2FsaWduPVwiY2VudGVyXCIgaGVhZGluZz1cIk9udGRlayBoZXQgcGFyayB0ZSB2b2V0XCIgZm9udF9zaXplPVwiNTBcIiBsaW5lX2hlaWdodD1cIjFcIiBmb250X2NvbG9yPVwiI2ZmZmZmZlwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVtwYXJhbGxheF9yb3cgZW5hYmxlX21vYmlsZT1cInBhcmFsbGF4LWVuYWJsZS1tb2JpbGVcIiBpbWFnZT1cIjE5MTI4XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjc3M9XCIudmNfY3VzdG9tXzE2MDg2NjY4ODU0OTd7YmFja2dyb3VuZC1pbWFnZTogdXJsKGh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjAvMDgvYmFja2dyb3VuZC1oZXl1c2EtbmF0dXVyLTEuZ2lmP2lkPTMwODgpICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW5dW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiV2FuZGVsZW4gaW4gaGV0IEFudGVsb3BlIElzbGFuZCBTdGF0ZSBQYXJrXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzAwMDAwMFwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjU1cHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF1FciBpcyAzNiBraWxvbWV0ZXIgYWFuIGhpa2luZyBlbiBtb3VudGFpbmJpa2UgdHJhaWxzIG9wIEFudGVsb3BlIElzbGFuZC4gRGUgRnJhcnkgUGVhayBUcmFpbCBpcyBkZSBiZWtlbmRzdGUgdHJhaWwgb3AgaGV0IGVpbGFuZC5cclxuPHVsPlxyXG4gXHQ8bGk+QnVmZmFsbyBQb2ludCBUcmFpbCB8IDEsNiBrbTwvbGk+XHJcbiBcdDxsaT5GcmFyeSBQZWFrIFRyYWlsIHwgMTEsMSBrbTwvbGk+XHJcbiBcdDxsaT5Eb29seSBLbm93IFRyYWlsIHwgMyw5IGttPC9saT5cclxuIFx0PGxpPkxha2UgU2lkZSBMb29wIFRyYWlsIHwgOCwyIGttPC9saT5cclxuIFx0PGxpPkxhZHkgRmluZ2VyIFRyYWlsIHwgMCw2IGttPC9saT5cclxuPC91bD5cclxuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiSGFuZGlnZSBpbmZvIHZvb3IgamUgYmV6b2VrXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzAwMDAwMFwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OlJvYm90byBTbGFifGZvbnRfY2FsbDpSb2JvdG8rU2xhYnx2YXJpYW50OjgwMFwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NTVweDtcIiBtYWluX2hlYWRpbmdfc3R5bGU9XCJmb250LXdlaWdodDo4MDA7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt1bHRpbWF0ZV9pY29uX2xpc3QgaWNvbl9zaXplPVwiMjVcIl1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLWNsb2NrLW9cIiBjb250ZW50X2ZvbnRfc2l6ZT1cImRlc2t0b3A6MTZweDtcIl0zNjUgZGFnZW4gZ2VvcGVuZFxyXG5tYWFydCAtIG9rdG9iZXIgMDYuMDAtMjIuMDAgdXVyXHJcbm5vdmVtYmVyIC0gZmVicnVhcmkgMDYuMDAtMTkuMDAgdXVyWy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLXRodW1icy11cFwiIGNvbnRlbnRfZm9udF9zaXplPVwiZGVza3RvcDoxNnB4O1wiXUJlc3RlIHBlcmlvZGU6IGxlbnRlIGVuIGhlcmZzdFsvdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy1kb2xsYXIgdXNkXCIgY29udGVudF9mb250X3NpemU9XCJkZXNrdG9wOjE2cHg7XCJdJDE1IHZvb3IgYXV0bydzXHJcbiQzIHZvb3Igdm9ldGdhbmdlcnNbL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVsvdWx0aW1hdGVfaWNvbl9saXN0XVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIiBmdWxsX3dpZHRoPVwic3RyZXRjaF9yb3dcIiBjb250ZW50X3RleHRfYWxpZ21lbnQ9XCJjZW50ZXJcIiBjc3M9XCIudmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9XCIgcGFyYWxsYXhfYmFja2dyb3VuZF9pbWFnZT1cIjM4MzZcIl1bdmNfY29sdW1uIHRoYl9jb2xvcj1cInRoYi1saWdodC1jb2x1bW5cIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiRGUgZGlqayBuYWFyIEFudGVsb3BlIElzbGFuZCBTdGF0ZSBQYXJrXCIgaGVhZGluZ190YWc9XCJwXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiI2ZmZmZmZlwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjQ1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NTVweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjEwcHhcIl1baGV5dXNhX2hlYWRpbmcgdGFnPVwiaDRcIiB0ZXh0X2FsaWduPVwiY2VudGVyXCIgaGVhZGluZz1cIk9udGRlayBBbnRlbG9wZSBJc2xhbmRcIiBmb250X3NpemU9XCI1MFwiIGxpbmVfaGVpZ2h0PVwiMVwiIGZvbnRfY29sb3I9XCIjZmZmZmZmXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3BhcmFsbGF4X3JvdyBlbmFibGVfbW9iaWxlPVwicGFyYWxsYXgtZW5hYmxlLW1vYmlsZVwiIGltYWdlPVwiMTkxMjZcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiXVt2Y19jb2x1bW5dW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIk1lZXIgVXRhaDpcIiBmb250X2NvbnRhaW5lcj1cInRhZzpkaXZ8Zm9udF9zaXplOjQwfHRleHRfYWxpZ246Y2VudGVyXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt0aGJfcG9zdGdyaWQgc3R5bGU9XCJzdHlsZTExXCIgY29sdW1ucz1cIjRcIiBzb3VyY2U9XCJwb3N0X3R5cGU6cG9zdHxieV9pZDotMTczMTgsLTE1MDYyLC0xNDkwNywtMTQyNTAsLTEyNTA0LC0xMTk5NywtOTk4MCwtODc0MiwtNDc5MiwtNDczOCwtNDcxNCwtNDY4OSwtNDU3NCwtMzIwOCwtMzAxNCwtMTk3MSwxODkzOSwxODk1NiwxODkzMiwxMzU4N1wiXVsvdmNfY29sdW1uXVsvdmNfcm93XSIsInBvc3RfdGl0bGUiOiJBbnRlbG9wZSBJc2xhbmQgU3RhdGUgUGFyayIsInBvc3RfbGluayI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvYW50ZWxvcGUtaXNsYW5kLXN0YXRlLXBhcmsvIiwicG9zdF9mZWF0dXJlZF9pbWFnZSI6IjxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiQW50ZWxvcGUgSXNsYW5kIFN0YXRlIFBhcmsgaW4gVXRhaFwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyNC8wMi9hbnRlbG9wZS1pc2xhbmQtMzAweDIwMC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj4iLCJwb3N0X2NhdGVnb3JpZXMiOiJTdGF0ZSBQYXJrcyIsInBvc3RfdGFncyI6IkNhbGlmb3JuaVx1MDBlYiIsIiVfd3BiX3Nob3J0Y29kZXNfY3VzdG9tX2NzcyUiOiIudmNfY3VzdG9tXzE2MDg2NjY1MTk0OTJ7YmFja2dyb3VuZC1jb2xvcjogI2VhZWFlYSAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTYwODY2Njg4NTQ5N3tiYWNrZ3JvdW5kLWltYWdlOiB1cmwoaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMC8wOC9iYWNrZ3JvdW5kLWhleXVzYS1uYXR1dXItMS5naWY/aWQ9MzA4OCkgIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fSIsIiVpbmxpbmVfZmVhdHVyZWRfaW1hZ2UlIjoiMCIsIiVfZWRpdF9sb2NrJSI6IjE3MDk1NTg3Mjk6MiIsIiVfZWRpdF9sYXN0JSI6IjIiLCIlX3RodW1ibmFpbF9pZCUiOiIxOTEyNCIsIiVfaGlkZV9mZWF0dXJlZCUiOm51bGwsIiVfd3BiX3ZjX2pzX3N0YXR1cyUiOiJ0cnVlIiwiJXBvc3QtcHJpbWFyeS1jYXRlZ29yeSUiOiJhdXRvIiwiJWZlYXR1cmVkX2ltYWdlX292ZXJyaWRlJSI6Im9mZiIsIiVhcnRpY2xlX3N0eWxlX292ZXJyaWRlJSI6Im9uIiwiJXBvc3Rfc3R5bGUlIjoic3R5bGUxMSIsIiVwb3N0X2dhbGxlcnlfc3R5bGUlIjoibGlnaHRib3giLCIlcG9zdF9yZXZpZXclIjoib2ZmIiwiJXBvc3RfcmV2aWV3X3N0eWxlJSI6InN0eWxlMSIsIiVwb3N0X3Jldmlld19hdmVyYWdlJSI6IjUwIiwiJV95b2FzdF93cHNlb19jb250ZW50X3Njb3JlJSI6IjYwIiwiJV95b2FzdF93cHNlb19mb2N1c2tleXdvcmRzJSI6IltdIiwiJV95b2FzdF93cHNlb19rZXl3b3Jkc3lub255bXMlIjoiW1wiXCJdIiwiJV95b2FzdF93cHNlb19mb2N1c2t3JSI6IkFudGVsb3BlIElzbGFuZCBTdGF0ZSBQYXJrIiwiJV95b2FzdF93cHNlb19tZXRhZGVzYyUiOiJJbiBVdGFoIHZpbmQgamUgaGV0IEFudGVsb3BlIElzbGFuZCBTdGF0ZSBQYXJrLCBnZWxlZ2VuIGluIGhldCBHcmVhdCBTYWx0IExha2UgZW4gZGljaHQgYmlqIFNhbHQgTGFrZSBDaXR5LiBUaXBzIHZvb3IgQW50ZWxvcGUgSXNsYW5kIFN0YXRlIFBhcmsuIiwiJV95b2FzdF93cHNlb19saW5rZGV4JSI6IjY2IiwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6IkFudGVsb3BlIElzbGFuZCBTdGF0ZSBQYXJrLCBVdGFoLCBWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9sb2NhdGlvbl9jaXR5JSI6IiIsIiVfd3BnbXBfbG9jYXRpb25fc3RhdGUlIjoiVXRhaCIsIiVfd3BnbXBfbG9jYXRpb25fY291bnRyeSUiOiJWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9tZXRhYm94X2xhdGl0dWRlJSI6IjQxLjAwNTE3NjMiLCIlX3dwZ21wX21ldGFib3hfbG9uZ2l0dWRlJSI6Ii0xMTIuMjU0NTE1MyIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiN1wiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6IiIsIiVfd3BnbXBfbWV0YWJveF90YXhvbW9taWVzX3Rlcm1zJSI6IiIsIiVfd3BnbXBfZXh0ZW5zaW9uc19maWVsZHMlIjoiIiwiJV95b2FzdF93cHNlb19lc3RpbWF0ZWQtcmVhZGluZy10aW1lLW1pbnV0ZXMlIjoiNCIsIiVfeW9hc3Rfd3BzZW9fcHJpbWFyeV9jYXRlZ29yeSUiOiIxNzAiLCIlX3d3c19zdXBwb3J0X2NvbnRhY3RfbnVtYmVyJSI6IiIsIiVfd3dzX2Fib3V0X3N1cHBvcnRfdGV4dCUiOiIiLCIlX3d3c190cmlnZ2VyX2J1dHRvbl90ZXh0JSI6IiIsIiVfd3dzX3ByZWRlZmluZWRfdGV4dCUiOiIiLCIlX3lvYXN0X3dwc2VvX3dvcmRwcm9vZl90aW1lc3RhbXAlIjoiIiwiJV95b2FzdF9pbmRleG5vd19sYXN0X3BpbmclIjoiMTcwOTEwNjEyOSIsIiVfbGFzdF9lZGl0b3JfdXNlZF9qZXRwYWNrJSI6ImNsYXNzaWMtZWRpdG9yIiwiJV93cF9vbGRfZGF0ZSUiOiIyMDIzLTA5LTIyIiwiJV93cF9vbGRfc2x1ZyUiOiJzYWd1YXJvLW5hdGlvbmFsLXBhcmsiLCIlYWN0aXZlZXJfc3VibWVudSUiOiIwIiwiJV9hY3RpdmVlcl9zdWJtZW51JSI6ImZpZWxkXzY1OTNmNTIxZTk3YzIiLCJ0YXhvbm9teT1jYXRlZ29yeSI6IlN0YXRlIFBhcmtzIiwidGF4b25vbXk9cG9zdF90YWciOiJDYWxpZm9ybmlcdTAwZWIiLCJ0YXhvbm9teT1wb3N0X2Zvcm1hdCI6IiIsInRheG9ub215PXRoYi1yZWFjdGlvbnMiOiIiLCJ0YXhvbm9teT10aGItc3BvbnNvcnMiOiIifX0sImlkIjoxOTEyMywiaW5mb3dpbmRvd19kaXNhYmxlIjpmYWxzZX0seyJzb3VyY2UiOiJwb3N0IiwidGl0bGUiOiJDb3JhbCBQaW5rIFNhbmQgRHVuZXMgU3RhdGUgUGFyayIsImluZm93aW5kb3dfY29udGVudCI6IjxkaXYgY2xhc3M9XCJmYy1pdGVtLWJveCBmYy1pdGVtLW5vLXBhZGRpbmcgXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIlZlZ2V0YXRpZSBDb3JhbCBQaW5rIFNhbmQgRHVuZXMgU3RhdGUgUGFya1wiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyNC8wMi9Db3JhbC1QaW5rLVNhbmQtRHVuZXMtU3RhdGUtUGFyay12ZWdldGF0aWUtMzAweDIwMC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmcgZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+Q29yYWwgUGluayBTYW5kIER1bmVzIFN0YXRlIFBhcms8L2Rpdj5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tY29udGVudCBmYy1pdGVtLWJvZHktdGV4dC1jb2xvclwiPnttYXJrZXJfYWRkcmVzc308L2Rpdj5cclxuICAgICAgICA8L2Rpdj5cclxuICAgIDwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWNsZWFyXCI+PC9kaXY+XHJcbjwvZGl2PiIsImFkZHJlc3MiOiJLYW5hYiwgVXRhaCA4NDc0MSwgVmVyZW5pZ2RlIFN0YXRlbiIsImxvY2F0aW9uIjp7ImxhdCI6IjM3LjAzNzczODM5OTk5OTk5IiwiY2l0eSI6IkthbmFiIiwic3RhdGUiOiJVdGFoIiwiY291bnRyeSI6IlZlcmVuaWdkZSBTdGF0ZW4iLCJsbmciOiItMTEyLjcxNDQzMzQiLCJvbmNsaWNrX2FjdGlvbiI6Im1hcmtlciIsInJlZGlyZWN0X3Blcm1hbGluayI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvY29yYWwtcGluay1zYW5kLWR1bmVzLXN0YXRlLXBhcmsvIiwiem9vbSI6MTIsImV4dHJhX2ZpZWxkcyI6eyJwb3N0X2V4Y2VycHQiOiIiLCJwb3N0X2NvbnRlbnQiOiJbdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiMTAwJVwiXVt2Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkNvcmFsIFBpbmsgU2FuZCBEdW5lcyBTdGF0ZSBQYXJrIGluIFV0YWhcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MzV8dGV4dF9hbGlnbjpsZWZ0fGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XUFscyBlciBlZW4gc3RhYXQgaXMgbWV0IHByYWNodGlnZSBzdGF0ZSBwYXJrcywgZGFuIGlzIGhldCBVdGFoIHdlbC4gRWVuIGRhYXJ2YW4gaXMgaGV0IENvcmFsIFBpbmsgU2FuZCBEdW5lcyBTdGF0ZSBQYXJrIGluIGhldCB1aXRlcnN0ZSB6dWlkZW4gdmFuIGRlIHN0YWF0LiBFZW4gcGFyayBkYXQgZG9ldCBkZW5rZW4gYWFuIGRlIFNhaGFyYSBkb29yIGRlIHZlbGUgemFuZGR1aW5lbi4gRGUgemFuZGR1aW5lbiB2YW4gaGV0IHBhcmsgaGViYmVuIGVlbiBrb3JhYWxyb3plIGtsZXVyIGRhbmt6aWogZGUgZXJvZGVyZW5kZSBOYXZham8gemFuZHN0ZWVuLiBIZXQgcGFyayBpcyBwb3B1bGFpciBvbmRlciBxdWFkIHJpamRlcnMsIG1hYXIgZXIgemlqbiBvb2sgbW9nZWxpamtoZWRlbiBvbSBoZXQgdGUgdm9ldCB0ZSB2ZXJrZW5uZW4uIEVlbiBiZXpvZWsgYnJlbmdlbiBhYW4gZWVuIGxhbmRzY2hhcCB2b2wgemFuZGR1aW5lbiBpbiBVdGFoPyBEYW4gYmVuIGplIGhpZXIgb3AgZGUganVpc3RlIHBsZWsuWy92Y19jb2x1bW5fdGV4dF1bdWx0aW1hdGVfaWNvbl9saXN0IGljb25fc2l6ZT1cIjIwXCJdW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy1hdXRvbW9iaWxlIGNhclwiXTI4OSBraWxvbWV0ZXIgdmFuIExhcyBWZWdhc1svdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy10cmVlXCJdPHNwYW4gY2xhc3M9XCJMcnpYciBrbm8tZnZcIj4xNCBrbTI8L3NwYW4+Wy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bL3VsdGltYXRlX2ljb25fbGlzdF1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIGNzcz1cIi52Y19jdXN0b21fMTYwODY2NjUxOTQ5MntiYWNrZ3JvdW5kLWNvbG9yOiAjZWFlYWVhICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMi8zXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIk9udHN0YWFuIENvcmFsIFBpbmsgU2FuZCBEdW5lc1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTozNXx0ZXh0X2FsaWduOmNlbnRlcnxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1FZW4gZ3Jvb3Qgd29lc3Rpam5sYW5kc2NoYXAgdm9sIHphbmRkdWluZW4sIHpvIGt1biBqZSBDb3JhbCBQaW5rIFNhbmQgRHVuZXMgU3RhdGUgUGFyayBoZXQgYmVzdGUgb21zY2hyaWp2ZW4uIFR1c3NlbiBkZSBiZXJnZW4gdmFuIE1vcXVpdGggTW91bnRhaW5zIGVuIE1vY2Nhc2luIE1vdW50YWlucyBpcyBlZW4gdHVubmVsIGdldm9ybWQuIERlIHphbmRrb3JyZWxzIHZvcm1kZW4gZWVuIHdlZyBkb29yIGRlemUgc21hbGxlIGJlcmdlbi4gSGV0IHR1bm5lbGVmZmVjdCB6b3JndCBlcnZvb3IgZGF0IGRlIHNuZWxoZWlkIHZhbiBkZSB3aW5kIHZlcnN0ZXJrdCB3ZXJkIGVuIGRlIGtvcnJlbHMgb21ob29nIGdlem9nZW4gZW4gbWVlZ2V2b2VyZCB3ZXJkZW4sIG9vayB3ZWwgaGV0IFZlbnR1cmkgRWZmZWN0IGdlbm9lbWQuIE5hIGRlIHR1bm5lbCBpcyBlZW4gb3BlbiB2YWxsZWkgdGUgdmluZGVuIHdhYXJkb29yIGRlIGtyYWNodCB2YW4gZGUgd2luZCB3ZWVyIGFmbmVlbXQuIFpvJ24gMTAuMDAwLTE1LjAwMCBqYWFyIGdlbGVkZW4gd2VyZCBvcCBkZXplIG1hbmllciBoZXQgc3RhdGUgcGFyayBnZXZvcm1kLiBTaW5kcyAxOTYzIGlzIGhldCBnZWJpZWQgb2ZmaWNpZWVsIGVlbiBzdGF0ZSBwYXJrLlsvdmNfY29sdW1uX3RleHRdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI3NXB4XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIiBmdWxsX3dpZHRoPVwic3RyZXRjaF9yb3dcIiBjb250ZW50X3RleHRfYWxpZ21lbnQ9XCJjZW50ZXJcIiBjc3M9XCIudmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9XCIgcGFyYWxsYXhfYmFja2dyb3VuZF9pbWFnZT1cIjM4MzZcIl1bdmNfY29sdW1uIHRoYl9jb2xvcj1cInRoYi1saWdodC1jb2x1bW5cIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJNZXQgZWVuIGJ1Z2d5IG9wIGRlIGR1aW5lblwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTo3NXx0ZXh0X2FsaWduOmNlbnRlcnxjb2xvcjolMjNmZmZmZmZ8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1baGV5dXNhX2hlYWRpbmcgdGFnPVwiZGl2XCIgdGV4dF9hbGlnbj1cImNlbnRlclwiIGhlYWRpbmc9XCJVbmlla2UgZXJ2YXJpbmcgaW4gaGV0IENvcmFsIFBpbmsgU2FuZCBEdW5lcyBTdGF0ZSBQYXJrXCIgZm9udF9zaXplPVwiNTBcIiBsaW5lX2hlaWdodD1cIjUwXCIgZm9udF9jb2xvcj1cIiNmZmZmZmZcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bcGFyYWxsYXhfcm93IGVuYWJsZV9tb2JpbGU9XCJwYXJhbGxheC1lbmFibGUtbW9iaWxlXCIgaW1hZ2U9XCIxOTExM1wiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCJdW3ZjX2NvbHVtbl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiSG9lIGtvbSBqZSBiaWogaGV0IENvcmFsIFBpbmsgU2FuZCBEdW5lcyBTdGF0ZSBQYXJrP1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZToyNXx0ZXh0X2FsaWduOmxlZnRcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XUplIHZpbmR0IGhldCBDb3JhbCBQaW5rIFNhbmQgRHVuZXMgU3RhdGUgUGFyayBpbiBoZXQgdWl0ZXJzdGUgenVpZGVuIHZhbiBkZSBzdGFhdCBVdGFoLiBEZSBkaWNodHN0YmlqemlqbmRlIHBsZWsgaXMgS2FuYWIuIFZhbnVpdCBLYW5hYiByaWpkIGplIHZpYSBTdGF0ZSBSb3V0ZSA4OSBuYWFyIGhldCBub29yZGVuLiBOYSBvbmdldmVlciAxMiBraWxvbWV0ZXIgZ2EgamUgbGlua3NhZiB2aWEgSGFuY29jayBSb2FkIHdhYXJuYSBqZSBuYSAxNCBraWxvbWV0ZXIgZWVuIHQtc3BsaXRzaW5nIHRlZ2Vua29tdC4gSGV0IHBhcmsgbGlndCBlZW4ga2xlaW5lIDQga2lsb21ldGVyIHZlcmRlci5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIk92ZXJuYWNodGVuIGluIGRlIGJ1dXJ0XCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjI1fHRleHRfYWxpZ246bGVmdFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdV2lsIGplIGluIGRlIGJ1dXJ0IHZhbiBoZXQgQ29yYWwgUGluayBTYW5kIER1bmVzIFN0YXRlIFBhcmsgb3Zlcm5hY2h0ZW4/IERhdCBrYW4gYWxsZWVuIGFscyBqZSBhYW4gaGV0IGthbXBlcmVuIGJlbnQuIEVyIHppam4gdHdlZSBwbGVra2VuIG9tIHRlIGthbXBlcmVuLiBUb2NoIGxpZXZlciBpbiBlZW4gaG90ZWw/IERhbiBpcyBLYW5hYiBlZW4gZ29lZGUgdWl0dmFsc2Jhc2lzIG1ldCA8YSBocmVmPVwiaHR0cHM6Ly93d3cuYm9va2luZy5jb20vc2VhcmNocmVzdWx0cy5lbi5odG1sP2NpdHk9MjAxMzMzNjkmYW1wO2FpZD03OTU4NDk4JmFtcDtub19yb29tcz0xJmFtcDtncm91cF9hZHVsdHM9MiZhbXA7bGFiZWw9Y29yYWxwaW5rc2FuZGR1bmVza2FuYWJcIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPnZvbGRvZW5kZSBhY2NvbW1vZGF0aWVzPC9hPi5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiV2F0IHRlIGRvZW4gb3AgaW4gaGV0IENvcmFsIFBpbmsgU2FuZCBEdW5lcyBTdGF0ZSBQYXJrXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjI1fHRleHRfYWxpZ246bGVmdFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdSGV0IENvcmFsIFBpbmsgU2FuZCBEdW5lcyBTdGF0ZSBQYXJrIGlzIGVlbiBncm90ZSB6YW5kdmxha3RlLiBUb2NoIHppam4gZXIgZWVuIGFhbnRhbCBkaW5nZW4gb20gdGUgZG9lbiBpbiBoZXQgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvc3RhdGUtcGFya3MtdXRhaC9cIj5zdGF0ZSBwYXJrIGluIFV0YWg8L2E+LiBabyBrdW4gamUgc2FuZGJvYXJkZW4sIG1ldCBlZW4gc2xlZSBuYWFyIGJlbmVkZW4gZW4gaXMgZWVuIGdyb290IGRlZWwgdmFuIGhldCBnZWJpZWQgb3BlbiB2b29yIG9mZi1oaWdod2F5IHZvZXJ0dWlnZW4uIERlIFNvdXRoIEJvdW5kYXJ5IFRyYWlsIGlzIHBlcmZlY3Qgb20gbWV0IGVlbiBvZmYgcm9hZCB2b2VydHVpZyB0ZSByaWpkZW4uIE1vY2h0IGplIGRpZSBuaWV0IGhlYmJlbiwgZGFuIGt1biBqZSBlZW4gPGEgaHJlZj1cImh0dHBzOi8vd3d3LnJvYW0tb3V0ZG9vci5jb20vXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5ndWlkZWQgdG91ciBib2VrZW48L2E+IGRvb3IgaGV0IGdlYmllZC5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkJlc3RlIHJlaXNwZXJpb2RlIG9tIGhldCBDb3JhbCBQaW5rIFNhbmQgRHVuZXMgU3RhdGUgUGFyayB0ZSBiZXpvZWtlblwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZToyNXx0ZXh0X2FsaWduOmxlZnRcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XUhldCBDb3JhbCBQaW5rIFNhbmQgRHVuZXMgU3RhdGUgUGFyayBpcyBoZXQgZ2VoZWxlIGphYXIgZG9vciB0ZSBiZXpvZWtlbi4gVmVyYmFhcyBqZSBuaWV0LCBtYWFyIGVyIHZhbHQgdmVlbCBuZWVyc2xhZyBpbiBoZXQgZ2ViaWVkLiBIaWVyZG9vciBncm9laWVuIGVyIHJlZGVsaWprIHdhdCBwbGFudGVuIGluIGhldCB3b2VzdGlqbmxhbmRzY2hhcC4gWmUgc3RhYW4gdmFhayBpbiBkZSBtYWFuZCBqdW5pIGluIGJsb2VpLiBIZXQgcGFyayBpcyBvdmVyaWdlbnMgd2VsIGFsbGVlbiB0ZSBiZXpvZWtlbiBnZWR1cmVuZGUgZGFnbGljaHQsIGdlbHVra2lnIGt1biBqZSBlZW4gem9uc29wa29tc3Qgb2Ygem9uc29uZGVyZ2FuZyBub2cgd2VsIG1lZSBwYWtrZW4uIERpdCB6aWpuIG5hbWVsaWprIGRlIG1vb2lzdGUgbW9tZW50ZW4gb20gaGV0IHBhcmsgdGUgYmV6b2VrZW4uWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiIGZ1bGxfd2lkdGg9XCJzdHJldGNoX3Jvd1wiIGNvbnRlbnRfdGV4dF9hbGlnbWVudD1cImNlbnRlclwiIGNzcz1cIi52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O31cIiBwYXJhbGxheF9iYWNrZ3JvdW5kX2ltYWdlPVwiMzgzNlwiXVt2Y19jb2x1bW4gdGhiX2NvbG9yPVwidGhiLWxpZ2h0LWNvbHVtblwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIlBsYW50ZW4gaW4gaGV0IHphbmRsYW5kc2NoYXBcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6NzV8dGV4dF9hbGlnbjpjZW50ZXJ8Y29sb3I6JTIzZmZmZmZmfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW2hleXVzYV9oZWFkaW5nIHRhZz1cImRpdlwiIHRleHRfYWxpZ249XCJjZW50ZXJcIiBoZWFkaW5nPVwiRG9vciBkZSBuZWVyc2xhZyBncm9laXQgZXIgdmFuIGFsbGVzIGluIENvcmFsIFBpbmsgU2FuZCBEdW5lcyBTdGF0ZSBQYXJrXCIgZm9udF9zaXplPVwiNTBcIiBsaW5lX2hlaWdodD1cIjUwXCIgZm9udF9jb2xvcj1cIiNmZmZmZmZcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bcGFyYWxsYXhfcm93IGVuYWJsZV9tb2JpbGU9XCJwYXJhbGxheC1lbmFibGUtbW9iaWxlXCIgaW1hZ2U9XCIxOTExNlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY3NzPVwiLnZjX2N1c3RvbV8xNjA4NjY2ODg1NDk3e2JhY2tncm91bmQtaW1hZ2U6IHVybChodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIwLzA4L2JhY2tncm91bmQtaGV5dXNhLW5hdHV1ci0xLmdpZj9pZD0zMDg4KSAhaW1wb3J0YW50O31cIl1bdmNfY29sdW1uXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt2Y19zaW5nbGVfaW1hZ2UgaW1hZ2U9XCIxOTExNVwiIGltZ19zaXplPVwibGFyZ2VcIiBhZGRfY2FwdGlvbj1cInllc1wiXVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJIYW5kaWdlIGluZm8gdm9vciBqZSBiZXpvZWtcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMDAwMDAwXCIgYWxpZ25tZW50PVwibGVmdFwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6Um9ib3RvIFNsYWJ8Zm9udF9jYWxsOlJvYm90bytTbGFifHZhcmlhbnQ6ODAwXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDo1NXB4O1wiIG1haW5faGVhZGluZ19zdHlsZT1cImZvbnQtd2VpZ2h0OjgwMDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3VsdGltYXRlX2ljb25fbGlzdCBpY29uX3NpemU9XCIyNVwiXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtY2xvY2stb1wiIGNvbnRlbnRfZm9udF9zaXplPVwiZGVza3RvcDoxNnB4O1wiXTM2NSBkYWdlbiBwZXIgamFhciAtIHZhbiB6b25zb3Brb21zdCB0b3Qgem9uc29uZGVyZ2FuZ1svdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy1kb2xsYXIgdXNkXCIgY29udGVudF9mb250X3NpemU9XCJkZXNrdG9wOjE2cHg7XCJdJDEwWy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLXRodW1icy11cFwiIGNvbnRlbnRfZm9udF9zaXplPVwiZGVza3RvcDoxNnB4O1wiXUJlc3RlIHBlcmlvZGU6IHZvb3JqYWFyLCB2cm9lZ2Ugem9tZXIgZW4gbmFqYWFyWy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bL3VsdGltYXRlX2ljb25fbGlzdF1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW5dW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjIvM1wiXVtoZXl1c2FfaGVhZGluZyB0YWc9XCJkaXZcIiB0ZXh0X2FsaWduPVwiY2VudGVyXCIgaGVhZGluZz1cIk9udGRlayBtZWVyIG5hdHV1ciBpbiBkZSBidXVydFwiIGZvbnRfc2l6ZT1cIjQwXCIgbGluZV9oZWlnaHQ9XCI0MFwiIGZvbnRfY29sb3I9XCIjMjgyODI4XCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiTm9nIG1lZXIgVXRhaFwiIG1haW5faGVhZGluZ19jb2xvcj1cIiMyODI4MjhcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDo0MHB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjQ1cHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMjVweFwiXVt0aGJfcG9zdGJhY2tncm91bmQgc3R5bGU9XCJzdHlsZTJcIiBzb3VyY2U9XCJieV9pZDotMTYxOTIsLTE2MjA0LC0xNjE3NCwtMTYxMjYsLTE1NjQ0LC0xNTYxNCwtMTU1ODAsLTEyNjIsLTIyNjcsLTU3MiwtNTQ1LDE4OTE2LDQxOTUsMTI3Myw0ODE3XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddIiwicG9zdF90aXRsZSI6IkNvcmFsIFBpbmsgU2FuZCBEdW5lcyBTdGF0ZSBQYXJrIiwicG9zdF9saW5rIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9jb3JhbC1waW5rLXNhbmQtZHVuZXMtc3RhdGUtcGFyay8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJWZWdldGF0aWUgQ29yYWwgUGluayBTYW5kIER1bmVzIFN0YXRlIFBhcmtcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjIwMFwiIHNyYz1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjQvMDIvQ29yYWwtUGluay1TYW5kLUR1bmVzLVN0YXRlLVBhcmstdmVnZXRhdGllLTMwMHgyMDAuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+IiwicG9zdF9jYXRlZ29yaWVzIjoiU3RhdGUgUGFya3MiLCJwb3N0X3RhZ3MiOiJVdGFoIiwiJV93cGJfc2hvcnRjb2Rlc19jdXN0b21fY3NzJSI6Ii52Y19jdXN0b21fMTYwODY2NjUxOTQ5MntiYWNrZ3JvdW5kLWNvbG9yOiAjZWFlYWVhICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNjA4NjY2ODg1NDk3e2JhY2tncm91bmQtaW1hZ2U6IHVybChodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIwLzA4L2JhY2tncm91bmQtaGV5dXNhLW5hdHV1ci0xLmdpZj9pZD0zMDg4KSAhaW1wb3J0YW50O30iLCIlaW5saW5lX2ZlYXR1cmVkX2ltYWdlJSI6IjAiLCIlX2VkaXRfbG9jayUiOiIxNzA4NTE3Mjk1OjIiLCIlX2VkaXRfbGFzdCUiOiIyIiwiJV9oaWRlX2ZlYXR1cmVkJSI6bnVsbCwiJV93cGJfdmNfanNfc3RhdHVzJSI6InRydWUiLCIlcG9zdC1wcmltYXJ5LWNhdGVnb3J5JSI6ImF1dG8iLCIlZmVhdHVyZWRfaW1hZ2Vfb3ZlcnJpZGUlIjoib2ZmIiwiJWFydGljbGVfc3R5bGVfb3ZlcnJpZGUlIjoib24iLCIlcG9zdF9zdHlsZSUiOiJzdHlsZTExIiwiJXBvc3RfZ2FsbGVyeV9zdHlsZSUiOiJsaWdodGJveCIsIiVwb3N0X3JldmlldyUiOiJvZmYiLCIlcG9zdF9yZXZpZXdfc3R5bGUlIjoic3R5bGUxIiwiJXBvc3RfcmV2aWV3X2F2ZXJhZ2UlIjoiNTAiLCIlX3lvYXN0X3dwc2VvX2NvbnRlbnRfc2NvcmUlIjoiOTAiLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza2V5d29yZHMlIjoiW10iLCIlX3lvYXN0X3dwc2VvX2tleXdvcmRzeW5vbnltcyUiOiJbXCJTdGF0ZSBwYXJrIFV0YWhcIl0iLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza3clIjoiQ29yYWwgUGluayBTYW5kIER1bmVzIFN0YXRlIFBhcmsiLCIlX3lvYXN0X3dwc2VvX21ldGFkZXNjJSI6Ik9udGRlayBDb3JhbCBQaW5rIFNhbmQgRHVuZXMgU3RhdGUgUGFyayBpbiBkZSBzdGFhdCBVdGFoLiBCZW5pZXV3ZCB3YXQgamUgZXIga3VudCBkb2VuPyBUaXBzIHZvb3IgQ29yYWwgUGluayBTYW5kIER1bmVzIFN0YXRlIFBhcmsuIiwiJV95b2FzdF93cHNlb19saW5rZGV4JSI6IjcxIiwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6IkthbmFiLCBVdGFoIDg0NzQxLCBWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9sb2NhdGlvbl9jaXR5JSI6IkthbmFiIiwiJV93cGdtcF9sb2NhdGlvbl9zdGF0ZSUiOiJVdGFoIiwiJV93cGdtcF9sb2NhdGlvbl9jb3VudHJ5JSI6IlZlcmVuaWdkZSBTdGF0ZW4iLCIlX3dwZ21wX21ldGFib3hfbGF0aXR1ZGUlIjoiMzcuMDM3NzM4Mzk5OTk5OTkiLCIlX3dwZ21wX21ldGFib3hfbG9uZ2l0dWRlJSI6Ii0xMTIuNzE0NDMzNCIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiN1wiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6IiIsIiVfd3BnbXBfbWV0YWJveF90YXhvbW9taWVzX3Rlcm1zJSI6IiIsIiVfd3BnbXBfZXh0ZW5zaW9uc19maWVsZHMlIjoiIiwiJV95b2FzdF93cHNlb19lc3RpbWF0ZWQtcmVhZGluZy10aW1lLW1pbnV0ZXMlIjoiNCIsIiVfeW9hc3Rfd3BzZW9fcHJpbWFyeV9jYXRlZ29yeSUiOiIyMjciLCIlX3lvYXN0X3dwc2VvX3RpdGxlJSI6IkNvcmFsIFBpbmsgU2FuZCBEdW5lcyBTdGF0ZSBQYXJrICUlcGFnZSUlICUlc2VwJSUgJSVzaXRlbmFtZSUlIiwiJV93d3Nfc3VwcG9ydF9jb250YWN0X251bWJlciUiOiIiLCIlX3d3c19hYm91dF9zdXBwb3J0X3RleHQlIjoiIiwiJV93d3NfdHJpZ2dlcl9idXR0b25fdGV4dCUiOiIiLCIlX3d3c19wcmVkZWZpbmVkX3RleHQlIjoiIiwiJV95b2FzdF93cHNlb193b3JkcHJvb2ZfdGltZXN0YW1wJSI6IiIsIiVfeW9hc3RfaW5kZXhub3dfbGFzdF9waW5nJSI6IjE3MDg1MTcyOTIiLCIlX2xhc3RfZWRpdG9yX3VzZWRfamV0cGFjayUiOiJjbGFzc2ljLWVkaXRvciIsIiVzdGFuZGFyZC1mZWF0dXJlZC1jcmVkaXQlIjoiIiwiJV90aHVtYm5haWxfaWQlIjoiMTkxMTQiLCIlYWN0aXZlZXJfc3VibWVudSUiOiIwIiwiJV9hY3RpdmVlcl9zdWJtZW51JSI6ImZpZWxkXzY1OTNmNTIxZTk3YzIiLCIlX3dwX29sZF9kYXRlJSI6IjIwMjQtMDItMDYiLCJ0YXhvbm9teT1jYXRlZ29yeSI6IlN0YXRlIFBhcmtzIiwidGF4b25vbXk9cG9zdF90YWciOiJVdGFoIiwidGF4b25vbXk9cG9zdF9mb3JtYXQiOiIiLCJ0YXhvbm9teT10aGItcmVhY3Rpb25zIjoiIiwidGF4b25vbXk9dGhiLXNwb25zb3JzIjoiIn19LCJpZCI6MTkxMTEsImluZm93aW5kb3dfZGlzYWJsZSI6ZmFsc2V9LHsic291cmNlIjoicG9zdCIsInRpdGxlIjoiQm9ubmV2aWxsZSBTYWx0IEZsYXRzIiwiaW5mb3dpbmRvd19jb250ZW50IjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZyBcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiQm9ubmV2aWxsZSBTYWx0IEZsYXRzIGluIFV0YWhcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjIwMFwiIHNyYz1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjQvMDIvYm9ubmV2aWxsZS1zYWx0LWZsYXRzLTMwMHgyMDAuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZ1wiPlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nIGZjLWl0ZW0tbm8tcGFkZGluZ1wiPlxyXG4gICAgICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS10aXRsZSBmYy1pdGVtLXByaW1hcnktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZVwiPkJvbm5ldmlsbGUgU2FsdCBGbGF0czwvZGl2PlxyXG4gICAgICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1jb250ZW50IGZjLWl0ZW0tYm9keS10ZXh0LWNvbG9yXCI+e21hcmtlcl9hZGRyZXNzfTwvZGl2PlxyXG4gICAgICAgIDwvZGl2PlxyXG4gICAgPC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtY2xlYXJcIj48L2Rpdj5cclxuPC9kaXY+IiwiYWRkcmVzcyI6IkJvbm5ldmlsbGUtem91dHZsYWt0ZSwgVXRhaCA4NDA4MywgVmVyZW5pZ2RlIFN0YXRlbiIsImxvY2F0aW9uIjp7ImxhdCI6IjQwLjc3ODc0NTQiLCJzdGF0ZSI6IlV0YWgiLCJjb3VudHJ5IjoiVmVyZW5pZ2RlIFN0YXRlbiIsImxuZyI6Ii0xMTMuODM1MjA0MyIsIm9uY2xpY2tfYWN0aW9uIjoibWFya2VyIiwicmVkaXJlY3RfcGVybWFsaW5rIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9ib25uZXZpbGxlLXNhbHQtZmxhdHMvIiwiem9vbSI6MTIsImV4dHJhX2ZpZWxkcyI6eyJwb3N0X2V4Y2VycHQiOiIiLCJwb3N0X2NvbnRlbnQiOiJbdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiMTAwJVwiXVt2Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkJvbm5ldmlsbGUgU2FsdCBGbGF0c1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTozNXx0ZXh0X2FsaWduOmxlZnR8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdRGUgQm9ubmV2aWxsZSBTYWx0IEZsYXRzIGlzIGVlbiB1bmllayBzdHVramUgbmF0dXVyIG9wIG9uZ2V2ZWVyIDE3MCBraWxvbWV0ZXIgYnVpdGVuIFNhbHQgTGFrZSBDaXR5IGluIFV0YWguIEhldCBuYXR1dXJnZWJpZWQgc3RhYXQgYmVrZW50IG9tIGRlIGdyb3RlIGhvZXZlZWxoZWRlbiB6b3V0LCBncm90ZSB2bGFrdGVuIG1ldCBhbGxlZW4gbWFhciB6b3V0LiBIZXQgbGlqa3QgYWxzb2YgamUgbmFhciBlZW4gYmVzbmVldXdkZSBvbmRlcmdyb25kIGtpamt0LCBtYWFyIGhldCBpcyBlY2h0IGFsbGVlbiBtYWFyIHpvdXQuIEhldCBsZXVrZSBhYW4gZGUgQm9ubmV2aWxsZSBTYWx0IEZsYXRzLCBpcyBkYXQgamUgZXIgb3ZlcmhlZW4ga3VudCBsb3BlbiBlbiB6ZWxmcyBtZXQgZGUgYXV0byBrdW4gamUgZXIgb3ZlcmhlZW4gcmlqZGVuLiBIZXQgZ2ViaWVkIHN0YWF0IGJla2VuZCBvbSBkZSB2ZWxlIHNuZWxoZWlkc3JlY29yZHMgZGllIGVyIHZlcnNjaGlsbGVuZGUgdm9lcnR1aWdlbiBnZW1hYWt0IHdvcmRlbi4gQmV6b2VrIGRlIEJvbm5ldmlsbGUgU2FsdCBGbGF0cyBpbiBVdGFoIHZvb3IgZWVuIHVuaWVrZSBiZWxldmVuaXMuWy92Y19jb2x1bW5fdGV4dF1bdWx0aW1hdGVfaWNvbl9saXN0IGljb25fc2l6ZT1cIjIwXCJdW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy1hdXRvbW9iaWxlIGNhclwiXTE3MCBraWxvbWV0ZXIgdmFuIFNhbHQgTGFrZSBDaXR5Wy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLXRyZWVcIl08c3BhbiBjbGFzcz1cIkxyelhyIGtuby1mdlwiPjEwMCBoZWN0YXJlPC9zcGFuPlsvdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dWy91bHRpbWF0ZV9pY29uX2xpc3RdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjc3M9XCIudmNfY3VzdG9tXzE2MDg2NjY1MTk0OTJ7YmFja2dyb3VuZC1jb2xvcjogI2VhZWFlYSAhaW1wb3J0YW50O31cIl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjIvM1wiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI3NXB4XCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJSYWNlcmVjb3JkcyBvcCBkZSBCb25uZXZpbGxlIFNhbHQgRmxhdHNcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MzV8dGV4dF9hbGlnbjpjZW50ZXJ8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdRGUgQm9ubmV2aWxsZSBTYWx0IEZsYXRzIHppam4gb25nZXZlZXIgMTkga2lsb21ldGVyIGxhbmcgZW4gOCBraWxvbWV0ZXIgYnJlZWQuIE9wIHNvbW1pZ2UgcGxla2tlbiBpcyBkZSBrb3JzdCAxLDUgdG90IDIgbWV0ZXIgZGlrLiBIZXQgaGVsZSBnZWJpZWQgYmVzdGFhdCB1aXQgMTcwIG1pbGpvZW4gdG9uIHpvdXQsIGhpZXJ2YW4gaXMgOTAlIGdld29vbiBrZXVrZW56b3V0LiBPcCBkZSB2bGFrdGVuIHZhbiBkZSBCb25uZXZpbGxlIFNhbHQgRmxhdHMgd29yZGVuIHJlZ2VsbWF0aWcgc25lbGhlaWRzcmVjb3JkcyBnZWJyb2tlbi4gRG9vcmRhdCBkZSB2bGFrdGVuIHpvIHZsYWsgemlqbiwgamUgemlldCB6ZWxmcyBkZSBjdXJ2ZXMgdmFuIGRlIGFhcmRlLCBrdW5uZW4gYXV0bydzIGxhbmdlIHN0dWtrZW4gcmlqZGVuIHpvbmRlciBvYnN0YWtlbHMuIERlIGtvcnN0IHZhbiBkZSBCb25uZXZpbGxlIFNhbHQgRmxhdHMgaG91ZHQgZGUgYmFuZGVuIGtvZWwgYmlqIGhvZ2Ugc25lbGhlZGVuLiBFciB6aWpuIHNuZWxoZWRlbiBnZW1ldGVuIHZhbiAxMDAwIGtpbG9tZXRlciBwZXIgdXVyLiBIZXQgc25lbGhlaWRzcmVjb3JkIG9wIGRlIHJhY2VmaWV0cyBzdGFhdCBvcCBuYWFtIHZhbiBlZW4gTmVkZXJsYW5kLiBGcmVkIFJvbXBlbGJlcmcgcmVlZCBtZXQgZWVuIHNuZWxoZWlkIHZhbiAyNjgsODMxIG9wIGRlIHZsYWt0ZW4gaW4gMTk5NS4gT29rIGJpaiBkZSBkYW1lcyBzdGFhdCBoZXQgKG9uKW9mZmljaVx1MDBlYmxlIHJlY29yZCBvcCBuYWFtIHZhbiBlZW4gTmVkZXJsYW5kc2Ugc2luZHMgMjAxNi5bL3ZjX2NvbHVtbl90ZXh0XVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNzVweFwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIGNvbnRlbnRfcGxhY2VtZW50PVwibWlkZGxlXCIgZnVsbF93aWR0aD1cInN0cmV0Y2hfcm93XCIgY29udGVudF90ZXh0X2FsaWdtZW50PVwiY2VudGVyXCIgY3NzPVwiLnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fVwiIHBhcmFsbGF4X2JhY2tncm91bmRfaW1hZ2U9XCIzODM2XCJdW3ZjX2NvbHVtbiB0aGJfY29sb3I9XCJ0aGItbGlnaHQtY29sdW1uXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiUmFjZW4gb3AgZGUgQm9ubmV2aWxsZSBTYWx0IEZsYXRzXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjc1fHRleHRfYWxpZ246Y2VudGVyfGNvbG9yOiUyM2ZmZmZmZnxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVtoZXl1c2FfaGVhZGluZyB0YWc9XCJkaXZcIiB0ZXh0X2FsaWduPVwiY2VudGVyXCIgaGVhZGluZz1cIlZlbGUgc25lbGhlaWRzcmVjb3JkcyB3b3JkZW4gaGllciBnZXZlc3RpZ2RcIiBmb250X3NpemU9XCI1MFwiIGxpbmVfaGVpZ2h0PVwiNTBcIiBmb250X2NvbG9yPVwiI2ZmZmZmZlwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVtwYXJhbGxheF9yb3cgZW5hYmxlX21vYmlsZT1cInBhcmFsbGF4LWVuYWJsZS1tb2JpbGVcIiBpbWFnZT1cIjE4OTQ4XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIl1bdmNfY29sdW1uXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJIb2Uga29tIGplIGJpaiBCb25uZXZpbGxlIFNhbHQgRmxhdHM/XCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjI1fHRleHRfYWxpZ246bGVmdFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdSmUga3VudCBkZSBCb25uZXZpbGxlIFNhbHQgRmxhdHMgYmVyZWlrZW4gdmFuYWYgRXhpdCA0IG9wIGRlIEludGVyc3RhdGUgODAuIEplIHJpamR0IGRhbiBub29yZHdhYXJ0cywgdm9sZ3QgZGUgU3BlZWR3YXkgYm9yZGVuIGVuIGRlIExlcHB5IFBhc3MgUm9hZC4gV2FubmVlciBlciB3YXRlciBvcCBkZSB2bGFrdGVuIGxpZ3QsIGt1biBqZSBlciBiZXRlciBuaWV0IG9wIHJpamRlbi4gRXIgaXMga2FucyBkYXQgamUgdmFzdCBrb210IHRlIHppdHRlbiwgaWV0cyBkYXQgamUgbGlldmVyIG5pZXQgd2lsdCBtZXQgZWVuIDxhIGhyZWY9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL2F1dG8taHVyZW4taW4tYW1lcmlrYS9cIj5odXVyYXV0byBpbiBBbWVyaWthPC9hPi4gUGFya2VyZW4ga2FuIG9wIGVlbiB2YW4gZGUgcmVzdGFyZWEncyB3YWFyIGplIGVlbiB3aXQgZ2Vib3V3IHppZXQgbWV0IHRvaWxldHRlbi5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIk92ZXJuYWNodGVuIGluIGRlIGJ1dXJ0XCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjI1fHRleHRfYWxpZ246bGVmdFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdRGUgQm9ubmV2aWxsZSBTYWx0IEZsYXRzIGxpZ2dlbiBvcCBpZXRzIG1lZXIgZGFuIDE3MCBraWxvbWV0ZXIgdmFuYWYgU2FsdCBMYWtlIENpdHkuIEVlbiBkYWd0cmlwIHZhbnVpdCBkZSBzdGFkIGlzIG1vZ2VsaWprLCBtYWFyIGplIGhvdWQgd2VpbmlnIHRpamQgb3ZlciBvbSBoZXQgbmF0dXVyZ2ViaWVkIHRlIGJla2lqa2VuLiBKZSBrdW50IGR1cyBvdmVybmFjaHRlbiBpbiA8YSBocmVmPVwiaHR0cHM6Ly93d3cuYm9va2luZy5jb20vc2VhcmNocmVzdWx0cy5lbi5odG1sP2NpdHk9MjAxMzM5NTYmYW1wO2FpZD03OTU4NDk4JmFtcDtub19yb29tcz0xJmFtcDtncm91cF9hZHVsdHM9MiZhbXA7bGFiZWw9Qm9ubmV2aWxsZXNhbHRmbGF0c3NhbHRsYWtlXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5TYWx0IExha2UgQ2l0eTwvYT4sIG1hYXIgd2lsIGplIGRpY2h0ZXJiaWogb3Zlcm5hY2h0ZW4/IERhbiBpcyBXZW5kb3ZlciBlZW4gb3B0aWUuIEplIHZpbmR0IGhpZXIgbmlldCBwZXIgc2Ugc3BlY2lhbGUgaG90ZWxzLCBtYWFyIHZlZWxhbCBkZSA8YSBocmVmPVwiaHR0cHM6Ly93d3cuYm9va2luZy5jb20vc2VhcmNocmVzdWx0cy5lbi5odG1sP2NpdHk9MjAxMzQzNjEmYW1wO2FpZD03OTU4NDk4JmFtcDtub19yb29tcz0xJmFtcDtncm91cF9hZHVsdHM9MiZhbXA7bGFiZWw9Qm9ubmV2aWxsZXNhbHRmbGF0c3dlbmRvdmVyXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5zdGFuZGFhcmQgaG90ZWxrZXRlbnM8L2E+LlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJXYXQgdGUgZG9lbiBvcCBkZSBCb25uZXZpbGxlIFNhbHQgRmxhdHNcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MjV8dGV4dF9hbGlnbjpsZWZ0XCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1XYW5uZWVyIGplIGRlIEJvbm5ldmlsbGUgU2FsdCBGbGF0cyBiZXpvZWt0IGhlYiBqZSBzb3dpZXNvIGFsIGVlbiB1bmlla2UgZXJ2YXJpbmcsIHN0YWFuIG9wIGVlbiBncm9uZG9wcGVydmxhayBkYXQgb29pdCBlZW4gbWVlciB3YXMgZW4gbnUgYmVzdGFhdCB1aXQgem91dC4gTWV0IGRlIGF1dG8ga3VuIGplIG92ZXIgZGUgem91dHZsYWt0ZXMgcmlqZGVuIGVuIHNuZWxoZWRlbiBoYWxlbi4gSmUga3VudCBvcCBkZSB6b3V0dmxha3RlbiBwcmFjaHRpZ2UgZm90bydzIG1ha2VuLiBaZWtlciB3YW5uZWVyIGVyIHBsYXNzZW4gbGlnZ2VuLCBpcyBkZSByZWZsZWN0aWUgZW5vcm0gbW9vaS4gRGFhcm5hYXN0IHppam4gZGUgem91dHZsYWt0ZW4gZWVuIGdvZWRlIHBsZWsgdm9vciBoZXQga2lqa2VuIHZhbiBzdGVycmVuLiBFbiBuaWV0IHRlIHZlcmdldGVuLCB3aWwgamUgZWNodGUgc25lbGhlZGVuIHppZW4/IEJlem9layBkYW4gaGV0IGdlYmllZCB0aWpkZW5zIGVlbiB2YW4gZGUgcmFjZS1ldmVudHMgZGllIGVyIGdlaG91ZGVuIHdvcmRlbi5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkJlc3RlIHJlaXNwZXJpb2RlIG9tIGRlIEJvbm5ldmlsbGUgU2FsdCBGbGF0cyB0ZSBiZXpvZWtlblwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZToyNXx0ZXh0X2FsaWduOmxlZnRcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XUplIGt1bnQgZGUgQm9ubmV2aWxsZSBTYWx0IEZsYXRzIGhldCBnZWhlbGUgamFhciBiZXpvZWtlbi4gSG91ZCBlciB3ZWwgcmVrZW5pbmcgbWVlIGRhdCBlciBpbiBkZSB6b21lciBlbiBoZXJmc3QgdmFhayA8YSBocmVmPVwiaHR0cHM6Ly93d3cuYmxtLmdvdi92aXNpdC9ib25uZXZpbGxlLXNhbHQtZmxhdHNcIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPnJhY2UgZXZlbnRzPC9hPiB3b3JkZW4gZ2Vob3VkZW4uIFZhbiBqdW5pIHRvdCBlbiBtZXQgYXVndXN0dXMgaXMgaGV0IGhldCBkcm9vZ3RlIHNlaXpvZW4gZW4gaGViIGplIGdyb3RlIGthbnMgb20gbWV0IGRlIGF1dG8gdGUgcmlqZGVuIG9wIGRlIHpvdXR2bGFrdGVuLiBXYW5uZWVyIGVyIHdhdGVyIG9wIGxpZ3QsIGhlYiBqZSBrYW5zIG9tIHZhc3QgdGUgeml0dGVuLiBUdXNzZW4gc2VwdGVtYmVyIGVuIG5vdmVtYmVyIHZhbHQgZGUgbWVlc3RlIHJlZ2VuLiBJbiBkZXplIHBlcmlvZGUgaGViIGplIHdlbCB3ZWVyIGRlIGthbnMgbW9vaWUgZm90bydzIHRlIG1ha2VuIG1ldCByZWZsZWN0aWUgdmFuIGhldCB3YXRlci4gSW4gZGUgem9tZXJtYWFuZGVuIGthbiBoZXQgd2FybSB3b3JkZW4sIGVyIGlzIGdlZW4gc2NoYWR1dyBlbiBkZSB6b24gaXMgZmVsIGRvb3IgZGUgcmVmbGVjdGllLlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIiBmdWxsX3dpZHRoPVwic3RyZXRjaF9yb3dcIiBjb250ZW50X3RleHRfYWxpZ21lbnQ9XCJjZW50ZXJcIiBjc3M9XCIudmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9XCIgcGFyYWxsYXhfYmFja2dyb3VuZF9pbWFnZT1cIjM4MzZcIl1bdmNfY29sdW1uIHRoYl9jb2xvcj1cInRoYi1saWdodC1jb2x1bW5cIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJXYXRlciBvcCBkZSB6b3V0dmxha3RlblwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTo3NXx0ZXh0X2FsaWduOmNlbnRlcnxjb2xvcjolMjNmZmZmZmZ8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1baGV5dXNhX2hlYWRpbmcgdGFnPVwiZGl2XCIgdGV4dF9hbGlnbj1cImNlbnRlclwiIGhlYWRpbmc9XCJMYWF0IGRlIGF1dG8gc3RhYW4gb20gZGUgbW9vaXN0ZSBmb3RvJ3MgdGUgbWFrZW5cIiBmb250X3NpemU9XCI1MFwiIGxpbmVfaGVpZ2h0PVwiNTBcIiBmb250X2NvbG9yPVwiI2ZmZmZmZlwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVtwYXJhbGxheF9yb3cgZW5hYmxlX21vYmlsZT1cInBhcmFsbGF4LWVuYWJsZS1tb2JpbGVcIiBpbWFnZT1cIjE4OTQ1XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjc3M9XCIudmNfY3VzdG9tXzE2MDg2NjY4ODU0OTd7YmFja2dyb3VuZC1pbWFnZTogdXJsKGh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjAvMDgvYmFja2dyb3VuZC1oZXl1c2EtbmF0dXVyLTEuZ2lmP2lkPTMwODgpICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW5dW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3ZjX3NpbmdsZV9pbWFnZSBpbWFnZT1cIjE4OTQ3XCIgaW1nX3NpemU9XCJsYXJnZVwiIGFkZF9jYXB0aW9uPVwieWVzXCJdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIkhhbmRpZ2UgaW5mbyB2b29yIGplIGJlem9la1wiIG1haW5faGVhZGluZ19jb2xvcj1cIiMwMDAwMDBcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpSb2JvdG8gU2xhYnxmb250X2NhbGw6Um9ib3RvK1NsYWJ8dmFyaWFudDo4MDBcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjU1cHg7XCIgbWFpbl9oZWFkaW5nX3N0eWxlPVwiZm9udC13ZWlnaHQ6ODAwO1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdWx0aW1hdGVfaWNvbl9saXN0IGljb25fc2l6ZT1cIjI1XCJdW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy1jbG9jay1vXCIgY29udGVudF9mb250X3NpemU9XCJkZXNrdG9wOjE2cHg7XCJdMzY1IGRhZ2VuIHBlciBqYWFyIC0gdmFuYWYgOC4wMCB1dXIgdG90IHpvbnNvbmRlcmdhbmdbL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtZG9sbGFyIHVzZFwiIGNvbnRlbnRfZm9udF9zaXplPVwiZGVza3RvcDoxNnB4O1wiXUdyYXRpc1svdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy10aHVtYnMtdXBcIiBjb250ZW50X2ZvbnRfc2l6ZT1cImRlc2t0b3A6MTZweDtcIl1CZXN0ZSBwZXJpb2RlOiBqdW5pIC0gYXVndXN0dXNbL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVsvdWx0aW1hdGVfaWNvbl9saXN0XVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNzVweFwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMi8zXCJdW2hleXVzYV9oZWFkaW5nIHRhZz1cImRpdlwiIHRleHRfYWxpZ249XCJjZW50ZXJcIiBoZWFkaW5nPVwiT250ZGVrIG1lZXIgbmF0dXVyIGluIGRlIGJ1dXJ0XCIgZm9udF9zaXplPVwiNDBcIiBsaW5lX2hlaWdodD1cIjQwXCIgZm9udF9jb2xvcj1cIiMyODI4MjhcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJOb2cgbWVlciBVdGFoXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzI4MjgyOFwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjQwcHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NDVweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIyNXB4XCJdW3RoYl9wb3N0YmFja2dyb3VuZCBzdHlsZT1cInN0eWxlMlwiIHNvdXJjZT1cImJ5X2lkOi0xNjE5MiwtMTYyMDQsLTE2MTc0LC0xNjEyNiwtMTU2NDQsLTE1NjE0LC0xNTU4MCwtMTI2MiwtMjI2NywtNTcyLC01NDUsMTg5MTYsNDE5NSwxMjczLDQ4MTdcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd10iLCJwb3N0X3RpdGxlIjoiQm9ubmV2aWxsZSBTYWx0IEZsYXRzIiwicG9zdF9saW5rIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9ib25uZXZpbGxlLXNhbHQtZmxhdHMvIiwicG9zdF9mZWF0dXJlZF9pbWFnZSI6IjxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiQm9ubmV2aWxsZSBTYWx0IEZsYXRzIGluIFV0YWhcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjIwMFwiIHNyYz1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjQvMDIvYm9ubmV2aWxsZS1zYWx0LWZsYXRzLTMwMHgyMDAuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+IiwicG9zdF9jYXRlZ29yaWVzIjoiTmF0dXVyZ2ViaWVkZW4iLCJwb3N0X3RhZ3MiOiJVdGFoIiwiJV93cGJfc2hvcnRjb2Rlc19jdXN0b21fY3NzJSI6Ii52Y19jdXN0b21fMTYwODY2NjUxOTQ5MntiYWNrZ3JvdW5kLWNvbG9yOiAjZWFlYWVhICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNjA4NjY2ODg1NDk3e2JhY2tncm91bmQtaW1hZ2U6IHVybChodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIwLzA4L2JhY2tncm91bmQtaGV5dXNhLW5hdHV1ci0xLmdpZj9pZD0zMDg4KSAhaW1wb3J0YW50O30iLCIlaW5saW5lX2ZlYXR1cmVkX2ltYWdlJSI6IjAiLCIlX2VkaXRfbG9jayUiOiIxNzA4MDA4MTU3OjIiLCIlX2VkaXRfbGFzdCUiOiIyIiwiJV9oaWRlX2ZlYXR1cmVkJSI6bnVsbCwiJV93cGJfdmNfanNfc3RhdHVzJSI6InRydWUiLCIlcG9zdC1wcmltYXJ5LWNhdGVnb3J5JSI6ImF1dG8iLCIlZmVhdHVyZWRfaW1hZ2Vfb3ZlcnJpZGUlIjoib2ZmIiwiJWFydGljbGVfc3R5bGVfb3ZlcnJpZGUlIjoib24iLCIlcG9zdF9zdHlsZSUiOiJzdHlsZTExIiwiJXBvc3RfZ2FsbGVyeV9zdHlsZSUiOiJsaWdodGJveCIsIiVwb3N0X3JldmlldyUiOiJvZmYiLCIlcG9zdF9yZXZpZXdfc3R5bGUlIjoic3R5bGUxIiwiJXBvc3RfcmV2aWV3X2F2ZXJhZ2UlIjoiNTAiLCIlX3lvYXN0X3dwc2VvX2NvbnRlbnRfc2NvcmUlIjoiOTAiLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza2V5d29yZHMlIjoiW10iLCIlX3lvYXN0X3dwc2VvX2tleXdvcmRzeW5vbnltcyUiOiJbXCJCb25uZXZpbGxlIFNhbHQgRmxhdHMgVXRhaFwiXSIsIiVfeW9hc3Rfd3BzZW9fZm9jdXNrdyUiOiJCb25uZXZpbGxlIFNhbHQgRmxhdHMiLCIlX3lvYXN0X3dwc2VvX21ldGFkZXNjJSI6Ik9udGRlayBCb25uZXZpbGxlIFNhbHQgRmxhdHMgaW4gZGUgc3RhYXQgVXRhaC4gQmVuaWV1d2Qgd2F0IGplIGVyIGt1bnQgZG9lbj8gVGlwcyB2b29yIGVlbiBiZXpvZWsgYWFuIGRlIEJvbm5ldmlsbGUgU2FsdCBGbGF0cy4iLCIlX3lvYXN0X3dwc2VvX2xpbmtkZXglIjoiODIiLCIlX3dwZ21wX2xvY2F0aW9uX2FkZHJlc3MlIjoiQm9ubmV2aWxsZS16b3V0dmxha3RlLCBVdGFoIDg0MDgzLCBWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9sb2NhdGlvbl9jaXR5JSI6IiIsIiVfd3BnbXBfbG9jYXRpb25fc3RhdGUlIjoiVXRhaCIsIiVfd3BnbXBfbG9jYXRpb25fY291bnRyeSUiOiJWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9tZXRhYm94X2xhdGl0dWRlJSI6IjQwLjc3ODc0NTQiLCIlX3dwZ21wX21ldGFib3hfbG9uZ2l0dWRlJSI6Ii0xMTMuODM1MjA0MyIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiN1wiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6IiIsIiVfd3BnbXBfbWV0YWJveF90YXhvbW9taWVzX3Rlcm1zJSI6IiIsIiVfd3BnbXBfZXh0ZW5zaW9uc19maWVsZHMlIjoiIiwiJV95b2FzdF93cHNlb19lc3RpbWF0ZWQtcmVhZGluZy10aW1lLW1pbnV0ZXMlIjoiNCIsIiVfeW9hc3Rfd3BzZW9fcHJpbWFyeV9jYXRlZ29yeSUiOiIyMjciLCIlX3lvYXN0X3dwc2VvX3RpdGxlJSI6IkJvbm5ldmlsbGUgU2FsdCBGbGF0cyAlJXBhZ2UlJSAlJXNlcCUlICUlc2l0ZW5hbWUlJSIsIiVfd3dzX3N1cHBvcnRfY29udGFjdF9udW1iZXIlIjoiIiwiJV93d3NfYWJvdXRfc3VwcG9ydF90ZXh0JSI6IiIsIiVfd3dzX3RyaWdnZXJfYnV0dG9uX3RleHQlIjoiIiwiJV93d3NfcHJlZGVmaW5lZF90ZXh0JSI6IiIsIiVfeW9hc3Rfd3BzZW9fd29yZHByb29mX3RpbWVzdGFtcCUiOiIiLCIlX3lvYXN0X2luZGV4bm93X2xhc3RfcGluZyUiOiIxNzA3Mjk1MjYyIiwiJV9sYXN0X2VkaXRvcl91c2VkX2pldHBhY2slIjoiY2xhc3NpYy1lZGl0b3IiLCIlc3RhbmRhcmQtZmVhdHVyZWQtY3JlZGl0JSI6IiIsIiVfdGh1bWJuYWlsX2lkJSI6IjE4OTQ2IiwiJWFjdGl2ZWVyX3N1Ym1lbnUlIjoiMCIsIiVfYWN0aXZlZXJfc3VibWVudSUiOiJmaWVsZF82NTkzZjUyMWU5N2MyIiwiJV93cF9vbGRfZGF0ZSUiOiIyMDI0LTAyLTA2IiwidGF4b25vbXk9Y2F0ZWdvcnkiOiJOYXR1dXJnZWJpZWRlbiIsInRheG9ub215PXBvc3RfdGFnIjoiVXRhaCIsInRheG9ub215PXBvc3RfZm9ybWF0IjoiIiwidGF4b25vbXk9dGhiLXJlYWN0aW9ucyI6IiIsInRheG9ub215PXRoYi1zcG9uc29ycyI6IiJ9fSwiaWQiOjE4OTM5LCJpbmZvd2luZG93X2Rpc2FibGUiOmZhbHNlfSx7InNvdXJjZSI6InBvc3QiLCJ0aXRsZSI6IkNhbnlvbmxhbmRzIE5hdGlvbmFsIFBhcmsiLCJpbmZvd2luZG93X2NvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nIFwiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJDYW55b25sYW5kcyBOYXRpb25hbCBQYXJrXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIxODhcIiBzcmM9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDI0LzAyL2NhbnlvbmxhbmRzLW5hdGlvbmFsLXBhcmstMzAweDE4OC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmcgZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+Q2FueW9ubGFuZHMgTmF0aW9uYWwgUGFyazwvZGl2PlxyXG4gICAgICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1jb250ZW50IGZjLWl0ZW0tYm9keS10ZXh0LWNvbG9yXCI+e21hcmtlcl9hZGRyZXNzfTwvZGl2PlxyXG4gICAgICAgIDwvZGl2PlxyXG4gICAgPC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtY2xlYXJcIj48L2Rpdj5cclxuPC9kaXY+IiwiYWRkcmVzcyI6IlV0YWgsIFZlcmVuaWdkZSBTdGF0ZW4iLCJsb2NhdGlvbiI6eyJsYXQiOiIzOC4yMTM1NzMzIiwic3RhdGUiOiJVdGFoIiwiY291bnRyeSI6IlZlcmVuaWdkZSBTdGF0ZW4iLCJsbmciOiItMTA5LjkwMjUzNDUiLCJvbmNsaWNrX2FjdGlvbiI6Im1hcmtlciIsInJlZGlyZWN0X3Blcm1hbGluayI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvY2FueW9ubGFuZHMtbmF0aW9uYWwtcGFyay8iLCJ6b29tIjoxMiwiZXh0cmFfZmllbGRzIjp7InBvc3RfZXhjZXJwdCI6IiIsInBvc3RfY29udGVudCI6Ilt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCJdW3ZjX2NvbHVtbiB3aWR0aD1cIjEvMlwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCIxMDAlXCJdW3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvMlwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiQ2FueW9ubGFuZHMgTmF0aW9uYWwgUGFya1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTozNXx0ZXh0X2FsaWduOmxlZnR8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdSGV0IGdyb290c3RlIG5hdGlvbmFsZSBwYXJrIHZhbiBVdGFoIGVuIHRlZ2VsaWprZXJ0aWpkIG9vayBoZXQgbWluc3QgYmV6b2NodGUgcGFyaywgZGF0IGlzIENhbnlvbmxhbmRzIE5hdGlvbmFsIFBhcmsuIEhldCBwYXJrIGlzIG9uZGVyZGVlbCB2YW4gZGUgJ21pZ2h0eSBmaXZlJyBpbiBVdGFoLCA1IHZhbiBkZSAnYmVzdGUnIG5hdGlvbmFsZSBwYXJrZW4gaW4gQW1lcmlrYS4gWm9hbHMgZGUgbmFhbSBkb2V0IHZlcm1vZWRlbiwgZWVuIHBhcmsgbWV0IHZlZWwgY2FueW9ucyBlbiByb3RzZm9ybWF0aWVzLiBFciBsb3BlbiB0d2VlIHZlcmhhcmRlIHdlZ2VuIGRvb3IgaGV0IGdlYmllZCwgZGUgSGlnaHdheSAzMTMgbmFhciBJc2xhbmQgaW4gZGUgU2t5IGVuIEhpZ2h3YXkgMjExIG5hYXIgVGhlIE5lZWRsZXMuIERlIHJlc3QgdmFuIGhldCBnZWJpZWQgaXMgYWxsZWVuIHRvZWdhbmtlbGlqayB2aWEgb2ZmLXJvYWQgd2VnZW4gd2FhciBqZSBlZW4gNHg0IHZvb3Igbm9kaWcgaGVidC4gQmVuaWV1d2QgbmFhciBDYW55b25sYW5kcyBOYXRpb25hbCBQYXJrP1svdmNfY29sdW1uX3RleHRdW3VsdGltYXRlX2ljb25fbGlzdCBpY29uX3NpemU9XCIyMFwiXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtYXV0b21vYmlsZSBjYXJcIl0zODkga2lsb21ldGVyIHZhbmFmIFNhbHQgTGFrZSBDaXR5Wy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLXRyZWVcIl08c3BhbiBjbGFzcz1cIkxyelhyIGtuby1mdlwiPjEzMDAga21cdTAwYjIgb3BwZXJ2bGFrdGU8L3NwYW4+Wy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLXBhd1wiXTI3MyB2ZXJzY2hpbGxlbmRlIHNvb3J0ZW4gZGllcmVuWy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bL3VsdGltYXRlX2ljb25fbGlzdF1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIGNzcz1cIi52Y19jdXN0b21fMTYwODY2NjUxOTQ5MntiYWNrZ3JvdW5kLWNvbG9yOiAjZWFlYWVhICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMi8zXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkRlIGRyaWUgZGVsZW4gdmFuIENhbnlvbmxhbmRzIE5hdGlvbmFsIFBhcmtcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MzV8dGV4dF9hbGlnbjpjZW50ZXJ8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxwIHN0eWxlPVwidGV4dC1hbGlnbjogY2VudGVyO1wiPkNhbnlvbmxhbmRzIE5hdGlvbmFsIFBhcmsgd29yZHQgZ2V2b3JtZCBkb29yIHZlcnNjaGlsbGVuZGUgcml2aWVyZW4uIERlIEdyZWVuIFJpdmVyLCBkZSBDb2xvcmFkbyBSaXZlciBlbiBkZSB6aWpyaXZpZXJlbiBoaWVydmFuIHN0cm9tZW4gZG9vciBoZXQgZ2ViaWVkLiBIaWVyZG9vciBpcyBDYW55b25sYW5kcyBvcGdlZGVlbGQgaW4gZHJpZSBkZWxlbjogVGhlIE1hemUsIFRoZSBJc2xhbmQgaW4gZGUgU2t5IGVuIFRoZSBOZWVkbGVzLiBIb2V3ZWwgZGUgZ2ViaWVkZW4gZ3JvdGVuZGVlbHMgcnVpZyB6aWpuLCBoZWJiZW4gemUgYWxsZWRyaWUgZWVuIGVpZ2VuIGthcmFrdGVyLiBabyBpcyBUaGUgTWF6ZSBoZXQgbWVlc3QgcnVpZ2UgZ2VkZWVsdGUgbWV0IHZlZWwgb2ZmLXJvYWQgd2VnZW4sIHN0YWF0IElzbGFuZCBpbiB0aGUgU2t5IGJla2VuZCBvbSBkZSB1aXR6aWNodGVuIGVuIHdvcmR0IFRoZSBOZWVkbGVzIGdla2VubWVya3QgZG9vciBrbGV1cnJpamtlIHJvdHNmb3JtYXRpZXMuIE92ZXJpZ2VucyB3b3JkZW4gZGUgcml2aWVyZW4gc29tcyBnZXppZW4gYWxzIGhldCB2aWVyZGUgZGVlbCB2YW4gaGV0IHBhcmsuPC9wPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNzVweFwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIGNvbnRlbnRfcGxhY2VtZW50PVwibWlkZGxlXCIgZnVsbF93aWR0aD1cInN0cmV0Y2hfcm93XCIgY29udGVudF90ZXh0X2FsaWdtZW50PVwiY2VudGVyXCIgY3NzPVwiLnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fVwiIHBhcmFsbGF4X2JhY2tncm91bmRfaW1hZ2U9XCIzODM2XCJdW3ZjX2NvbHVtbiB0aGJfY29sb3I9XCJ0aGItbGlnaHQtY29sdW1uXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiTWVzYSBBcmNoXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjc1fHRleHRfYWxpZ246Y2VudGVyfGNvbG9yOiUyM2ZmZmZmZnxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVtoZXl1c2FfaGVhZGluZyB0YWc9XCJoNFwiIHRleHRfYWxpZ249XCJjZW50ZXJcIiBoZWFkaW5nPVwiRGUgcG9wdWxhaXJzdGUgcGxlayB2YW4gQ2FueW9ubGFuZHMgTmF0aW9uYWwgUGFya1wiIGZvbnRfc2l6ZT1cIjUwXCIgbGluZV9oZWlnaHQ9XCIxXCIgZm9udF9jb2xvcj1cIiNmZmZmZmZcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bcGFyYWxsYXhfcm93IGVuYWJsZV9tb2JpbGU9XCJwYXJhbGxheC1lbmFibGUtbW9iaWxlXCIgaW1hZ2U9XCIxODkyMlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCJdW3ZjX2NvbHVtbl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvM1wiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiSGFuZGlnIG9tIHRlIHdldGVuXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjI1fHRleHRfYWxpZ246bGVmdFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdSW4gQ2FueW9ubGFuZHMgTmF0aW9uYWwgUGFyayBsb3BlbiB2ZWVsIG9udmVyaGFyZGUgd2VnZW4gd2FhciBqZSBhbGxlZW4gbWV0IGVlbiA0eDQgb3AgbWFnIHJpamRlbi4gWm8gdmluZCBqZSBpbiBoZXQgSXNsYW5kIGluIHRoZSBTa3kgRGlzdHJpY3QgZGUgMTYwIGtpbG9tZXRlciBsYW5nZSBXaGl0ZSBSaW0gUm9hZCBkaWUgYWxsZWVuIHRvZWdhbmtlbGlqayBpcyB2b29yIGVlbiA0eDQuIE92ZXJpZ2VucyBoZWIgamUgb29rIHRvZXN0ZW1taW5nIG5vZGlnIG9tIGluIGRpdCBkZWVsIHRlIG92ZXJuYWNodGVuLCBkZSByaXQgZHV1cnQgbmFtZWxpamsgMiBkYWdlbi4gRWVuIGFuZGVyZSByb3V0ZSBkaWUgcG9wdWxhaXIgaXMsIGlzIGRlIFNoYWZlciBUcmFpbC4gRWVuIHJvdXRlIGRpZSBub2cgdm9vciBoZXQgdmlzaXRvciBjZW50ZXIgYmVnaW50IGVuIGRpZSBkaXJlY3Qgc21hbGxlIGVuIHN0ZWlsZSBib2NodGVuIGhlZWZ0LiBKZSBrdW50IG9vayB2YW4gYmVpZGUgcm91dGVzIGVlbiBzdHVramUgcmlqZGVuLiBEZSBtZWVzdGUgb2ZmLXJvYWQgcm91dGVzIHppam4gdGUgdmluZGVuIGluIGhldCBNYXplIERpc3RyaWN0LiBFciByaWpkdCBnZWVuIHNodXR0bGUgb2YgT1YgaW4gQ2FueW9ubGFuZHMuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8zXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJCZXN0ZSByZWlzcGVyaW9kZSBDYW55b25sYW5kcyBOYXRpb25hbCBQYXJrXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjI1fHRleHRfYWxpZ246bGVmdFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdRGUgYmVzdGUgcGVyaW9kZSB2b29yIGVlbiBiZXpvZWsgYWFuIENhbnlvbmxhbmRzIE5hdGlvbmFsIFBhcmsgaXMgZGUgbGVudGUgb2YgaGVyZnN0LiBEZSB0ZW1wZXJhdHVyZW4ga3VubmVuIG5vZ2FsIHZlcnNjaGlsbGVuIGluIGhldCBuYXRpb25hbGUgcGFyay4gWm8gbGlnZ2VuIGRlIHRlbXBlcmF0dXJlbiBpbiBkZSB6b21lciBvdmVyZGFnIHR1c3NlbiBkZSAzMC00MCBncmFkZW4sIGRlIG5hY2h0ZW4gdHVzc2VuIDEwLTIwLiBUZXJ3aWpsIGluIGRlIHdpbnRlciBkZSB0ZW1wZXJhdHVyZW4gb3ZlcmRhZyB0dXNzZW4gMC0xMCBncmFkZW4gbGlnZ2VuIGVuICdzIG5hY2h0cyBrdW5uZW4gb3Bsb3BlbiB0b3QgdHVzc2VuIC0xMCBlbiAtMjAuIERhYXJvbSB6aWpuIGRlIGxlbnRlIGVuIGhlcmZzdCBpZGVhYWwgdm9vciBlZW4gYmV6b2VrLCB6ZWtlciBhbHMgamUgb29rIHdpbHQgd2FuZGVsZW4uIEluIGRlIGhlcmZzdCBoZWIgamUga2FucyBvcCBvbndlZXJzYnVpZW4gaW4gZGUgbWlkZGFnLlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvM1wiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiT3Zlcm5hY2h0ZW4gaW4gQ2FueW9ubGFuZHMgTmF0aW9uYWwgUGFya1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZToyNXx0ZXh0X2FsaWduOmxlZnRcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XUVyIHppam4gbW9nZWxpamtoZWRlbiBvbSB0ZSBrYW1wZXJlbiBpbiBDYW55b25sYW5kcyBOYXRpb25hbCBQYXJrLCBtYWFyIHZlcndhY2h0IG5pZXQgdGUgdmVlbCB2YW4gZGUgdm9vcnppZW5pbmdlbiBvcCBkZSBjYW1wZ3JvdW5kcy4gRGUgZWVyc3RlIHBsZWsgb20gdGUga2FtcGVyZW4gaXMgV2lsbG93IEZsYXQgaW4gSXNsYW5kIGluIHRoZSBTa3kuIEhpZXIgemlqbiAxMiBwbGVra2VuIGVuIGdlbGR0IGhldCBwcmluY2lwZSBmaXJzdCBjb21lLCBmaXJzdCBzZXJ2ZWQuIEVyIGlzIGdlZW4gd2F0ZXIsIGRhYXJ2b29yIG1vZXQgamUgbmFhciBoZXQgdmlzaXRvciBjZW50ZXIuIERlIGFuZGVyZSBpcyBUaGUgTmVlZGxlcyBDYW1wZ3JvdW5kLCBoaWVyIHppam4gMjYgcGxla2tlbiBkaWUgPGEgaHJlZj1cImh0dHA6Ly9SZWNyZWF0aW9uLmdvdlwiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+Z2VyZXNlcnZlZXJkPC9hPiBrdW5uZW4gd29yZGVuIHZhbiBsZW50ZSB0b3QgaGVyZnN0LiBPdmVyaWdlbnMga3VuIGplIGhpZXIgb29rIG1ldCBlZW4gY2FtcGVyIHN0YWFuLiBXaWwgamUgaW4gZWVuIGhvdGVsIG92ZXJuYWNodGVuPyBEYW4gaXMgTW9hYiBkZSBiZXN0ZSBrZXV6ZS4gQmVraWprIGhpZXIgZGUgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmJvb2tpbmcuY29tL3NlYXJjaHJlc3VsdHMuZW4uaHRtbD9jaXR5PTIwMTMzNjAzJmFtcDthaWQ9Nzk1ODQ5OCZhbXA7bm9fcm9vbXM9MSZhbXA7Z3JvdXBfYWR1bHRzPTImYW1wO2xhYmVsPWNhbnlvbmxhbmRzbW9hYlwiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+bW9nZWxpamtoZWRlbiBvbSB0ZSBvdmVybmFjaHRlbiBpbiBNb2FiPC9hPi5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIGNvbnRlbnRfcGxhY2VtZW50PVwibWlkZGxlXCIgZnVsbF93aWR0aD1cInN0cmV0Y2hfcm93XCIgY29udGVudF90ZXh0X2FsaWdtZW50PVwiY2VudGVyXCIgY3NzPVwiLnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fVwiIHBhcmFsbGF4X2JhY2tncm91bmRfaW1hZ2U9XCIzODM2XCJdW3ZjX2NvbHVtbiB0aGJfY29sb3I9XCJ0aGItbGlnaHQtY29sdW1uXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIlVpdHppY2h0ZW4gaW4gQ2FueW9ubGFuZHMgTmF0aW9uYWwgUGFya1wiIGhlYWRpbmdfdGFnPVwicFwiIG1haW5faGVhZGluZ19jb2xvcj1cIiNmZmZmZmZcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDo0NXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjU1cHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIxMHB4XCJdW2hleXVzYV9oZWFkaW5nIHRhZz1cImg0XCIgdGV4dF9hbGlnbj1cImNlbnRlclwiIGhlYWRpbmc9XCJFbmpveSB0aGUgdmlldyFcIiBmb250X3NpemU9XCI1MFwiIGxpbmVfaGVpZ2h0PVwiMVwiIGZvbnRfY29sb3I9XCIjZmZmZmZmXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3BhcmFsbGF4X3JvdyBlbmFibGVfbW9iaWxlPVwicGFyYWxsYXgtZW5hYmxlLW1vYmlsZVwiIGltYWdlPVwiMTg5MjZcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiXVt2Y19jb2x1bW5dW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIldhdCB0ZSBkb2VuIGluIENhbnlvbmxhbmRzIE5hdGlvbmFsIFBhcmtcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MzV8dGV4dF9hbGlnbjpjZW50ZXJ8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzNcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCIxLlwiIGhlYWRpbmdfdGFnPVwiZGl2XCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiI2IzNGE0Y1wiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjk1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6MTAwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19zaW5nbGVfaW1hZ2UgaW1hZ2U9XCIxODkxOVwiIGltZ19zaXplPVwibGFyZ2VcIiBhZGRfY2FwdGlvbj1cInllc1wiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiSXNsYW5kIGluIHRoZSBza3lcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MjV8dGV4dF9hbGlnbjpsZWZ0XCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1Jc2xhbmQgaW4gdGhlIFNreSBpcyBoZXQgbWVlc3QgcG9wdWxhaXJlIGRpc3RyaWN0IGVuIGhldCBtYWtrZWxpamtzdCB0ZSBiZXpvZWtlbi4gSmUga3VudCBkaXQgZGVlbCBub2cgYmV6b2VrZW4gdmlhIGVlbiB2ZXJoYXJkZSB3ZWcgZW4gamUgdmluZHQgZXIgZWVuIGFhbnRhbCBwcmFjaHRpZ2UgYmV6aWVuc3dhYXJkaWdoZWRlbjpcclxuPHVsPlxyXG4gXHQ8bGk+TWVzYSBBcmNoPC9saT5cclxuIFx0PGxpPlNoYWZlciBDYW55b24gT3Zlcmxvb2s8L2xpPlxyXG4gXHQ8bGk+V2hhbGUgUm9jazwvbGk+XHJcbiBcdDxsaT5HcmVlbiBSaXZlciBPdmVybG9vazwvbGk+XHJcbiBcdDxsaT5HcmFuZCBWaWV3IE92ZXJsb29rPC9saT5cclxuPC91bD5cclxuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8zXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiMi5cIiBoZWFkaW5nX3RhZz1cImRpdlwiIG1haW5faGVhZGluZ19jb2xvcj1cIiNiMzRhNGNcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDo5NXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjEwMHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfc2luZ2xlX2ltYWdlIGltYWdlPVwiMTg5MjFcIiBpbWdfc2l6ZT1cImxhcmdlXCIgYWRkX2NhcHRpb249XCJ5ZXNcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIk5lZWRsZXNcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MjV8dGV4dF9hbGlnbjpsZWZ0XCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1IZXQgTmVlZGxlcyBEaXN0cmljdCBzdGFhdCB2b29yYWwgYmVrZW5kIG9tIGRlIGtsZXVycmlqa2Ugcm90c2Zvcm1hdGllcy4gRGl0IGRlZWwgd29yZHQgdm9vcmFsIGJlem9jaHQgZG9vciB3YW5kZWxhYXJzIGVuIGJhY2twYWNrZXJzIGRpZSBtZWVyZGVyZSBkYWdlbiB3aWxsZW4gd2FuZGVsZW4uIEhldCBnZWJpZWQgaXMgZGVlbHMgYmVyZWlrYmFhciBtZXQgZGUgZ2V3b25lIGF1dG8sIG1hYXIgb29rIGRlbGVuIHppam4gYWxsZWVuIHRvZWdhbmtlbGlqayB2b29yIGVlbiA0eDQuIE9vayBpbiBUaGUgTmVlZGxlcyB2aW5kIGplIHZlcnNjaGlsbGVuZGUgYmV6aWVuc3dhYXJkaWdoZWRlbjpcclxuPHVsPlxyXG4gXHQ8bGk+Q2F2ZSBTcHJpbmc8L2xpPlxyXG4gXHQ8bGk+Um9hZHNpZGUgUnVpbjwvbGk+XHJcbiBcdDxsaT5CaWcgU3ByaW5nIENhbnlvbiBPdmVybG9vazwvbGk+XHJcbiBcdDxsaT5DaGVzbGVyIFBhcms8L2xpPlxyXG48L3VsPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzNcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCIzLlwiIGhlYWRpbmdfdGFnPVwiZGl2XCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiI2IzNGE0Y1wiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjk1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6MTAwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19zaW5nbGVfaW1hZ2UgaW1hZ2U9XCIxODkyMFwiIGltZ19zaXplPVwibGFyZ2VcIiBhZGRfY2FwdGlvbj1cInllc1wiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiTWF6ZVwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZToyNXx0ZXh0X2FsaWduOmxlZnRcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XUhldCBydWlnc3RlIGRlZWwgdmFuIENhbnlvbmxhbmRzIE5hdGlvbmFsIFBhcmsgaXMgVGhlIE1hemUsIGRlIG5hYW0gemVndCBoZXQgYWwsIGVlbiBkb29saG9mLiBKZSBrdW50IG1ha2tlbGlqayB2ZXJkd2FsZW4gaW4gaGV0IGdlYmllZCwgaGV0IGlzIGVlbiB2YW4gZGUgbWVlc3Qgb25oZXJiZXJnemFtZSBkZWxlbiB2YW4gQW1lcmlrYS4gVGhlIE1hemUgd29yZHQgdm9vcmFsIGJlem9jaHQgZG9vciBlcnZhcmVuIGJhY2twYWNrZXJzLCBlZW4gNHg0IGlzIG5vb2R6YWtlbGlqaywgZXIgemlqbiBnZWVuIHZvb3J6aWVuaW5nZW4gZW4gamUgYmVudCBlY2h0IG9wIGplemVsZiBhYW5nZXdlemVuLiBFciB6aWpuIHpla2VyIGhvb2d0ZXB1bnRlbiBpbiBUaGUgTWF6ZSBvbSB0ZSBiZXpvZWtlbiwgbWFhciBoZWxhYXMga2FuIGRpdCBkdXMgbmlldCBkb29yIGllZGVyZWVuOlxyXG48dWw+XHJcbiBcdDxsaT5DaG9jb2xhdGUgRHJvcHM8L2xpPlxyXG4gXHQ8bGk+SG9yc2VzaG9lIENhbnlvbjwvbGk+XHJcbjwvdWw+XHJcblsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY3NzPVwiLnZjX2N1c3RvbV8xNjA4NjY2ODg1NDk3e2JhY2tncm91bmQtaW1hZ2U6IHVybChodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIwLzA4L2JhY2tncm91bmQtaGV5dXNhLW5hdHV1ci0xLmdpZj9pZD0zMDg4KSAhaW1wb3J0YW50O31cIl1bdmNfY29sdW1uXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIldhbmRlbGVuIGluIGhldCBDYW55b25sYW5kcyBOYXRpb25hbCBQYXJrXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzAwMDAwMFwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjU1cHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF1XYW5kZWxlbiBpbiBDYW55b25sYW5kcyBOYXRpb25hbCBQYXJrIGlzIHpla2VyIG1vZ2VsaWprLCBtaXRzIGplIGdvZWQgdm9vcmJlcmVpZCBvcCBwYWQgZ2FhdC4gRWVuIGFhbnRhbCB0cmFpbHMgZGllIGplIGt1bnQgbG9wZW46XHJcbjx1bD5cclxuIFx0PGxpPk1lc2EgQXJjaCB8IElzbGFuZCBpbiB0aGUgU2t5IHwgMSBrbSB8IG1ha2tlbGlqazwvbGk+XHJcbiBcdDxsaT5XaGl0ZSBSaW0gT3Zlcmxvb2sgfCBJc2xhbmQgaW4gdGhlIFNreSB8IDIsOSBrbSB8IG1ha2tlbGlqazwvbGk+XHJcbiBcdDxsaT5HcmFuZCBWaWV3IFBvaW50IHwgSXNsYW5kIGluIHRoZSBTa3kgfCAyLDkga20gfCBtYWtrZWxpams8L2xpPlxyXG4gXHQ8bGk+QXp0ZWMgQnV0dGUgfCBJc2xhbmQgaW4gdGhlIFNreSB8IDIsMyBrbSB8IG1vZGVyYXRlPC9saT5cclxuIFx0PGxpPlJvYWRzaWRlIFJ1aW4gfCBOZWVkbGVzIHwgMCw1IGttIHwgbWFra2VsaWprL21vZGVyYXRlPC9saT5cclxuIFx0PGxpPkNhdmUgU3ByaW5nIHwgTmVlZGxlcyB8IDEga20gfCBtYWtrZWxpamsvbW9kZXJhdGU8L2xpPlxyXG48L3VsPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJIYW5kaWdlIGluZm8gdm9vciBqZSBiZXpvZWtcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMDAwMDAwXCIgYWxpZ25tZW50PVwibGVmdFwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6Um9ib3RvIFNsYWJ8Zm9udF9jYWxsOlJvYm90bytTbGFifHZhcmlhbnQ6ODAwXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDo1NXB4O1wiIG1haW5faGVhZGluZ19zdHlsZT1cImZvbnQtd2VpZ2h0OjgwMDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3VsdGltYXRlX2ljb25fbGlzdCBpY29uX3NpemU9XCIyNVwiXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtY2xvY2stb1wiIGNvbnRlbnRfZm9udF9zaXplPVwiZGVza3RvcDoxNnB4O1wiXTI0LzcgZW4gMzY1IGRhZ2VuIGdlb3BlbmRbL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtdGh1bWJzLXVwXCIgY29udGVudF9mb250X3NpemU9XCJkZXNrdG9wOjE2cHg7XCJdQmVzdGUgcGVyaW9kZTogbGVudGUgZW4gaGVyZnN0Wy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLWRvbGxhciB1c2RcIiBjb250ZW50X2ZvbnRfc2l6ZT1cImRlc2t0b3A6MTZweDtcIl0kMzAgdm9vciBlZW4gYXV0byB8ICQxNSB2b29yIGVlbiBwZXJzb29uWy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bL3VsdGltYXRlX2ljb25fbGlzdF1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIGNvbnRlbnRfcGxhY2VtZW50PVwibWlkZGxlXCIgZnVsbF93aWR0aD1cInN0cmV0Y2hfcm93XCIgY29udGVudF90ZXh0X2FsaWdtZW50PVwiY2VudGVyXCIgY3NzPVwiLnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fVwiIHBhcmFsbGF4X2JhY2tncm91bmRfaW1hZ2U9XCIzODM2XCJdW3ZjX2NvbHVtbiB0aGJfY29sb3I9XCJ0aGItbGlnaHQtY29sdW1uXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIk9mZiByb2FkIGluIENhbnlvbmxhbmRzIE5hdGlvbmFsIFBhcmtcIiBoZWFkaW5nX3RhZz1cInBcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjZmZmZmZmXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6NDVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDo1NXB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMTBweFwiXVtoZXl1c2FfaGVhZGluZyB0YWc9XCJoNFwiIHRleHRfYWxpZ249XCJjZW50ZXJcIiBoZWFkaW5nPVwiU29tbWlnZSBkZWxlbiB6aWpuIGFsbGVlbiB0b2VnYW5rZWxpamsgbWV0IGVlbiA0eDRcIiBmb250X3NpemU9XCI1MFwiIGxpbmVfaGVpZ2h0PVwiMVwiIGZvbnRfY29sb3I9XCIjZmZmZmZmXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3BhcmFsbGF4X3JvdyBlbmFibGVfbW9iaWxlPVwicGFyYWxsYXgtZW5hYmxlLW1vYmlsZVwiIGltYWdlPVwiMTg5MjVcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiXVt2Y19jb2x1bW5dW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIk1lZXIgVXRhaFwiIGZvbnRfY29udGFpbmVyPVwidGFnOmRpdnxmb250X3NpemU6NDB8dGV4dF9hbGlnbjpjZW50ZXJcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3RoYl9wb3N0Z3JpZCBzdHlsZT1cInN0eWxlMTFcIiBjb2x1bW5zPVwiNFwiIHNvdXJjZT1cInBvc3RfdHlwZTpwb3N0fGJ5X2lkOi0xNzMxOCwtMTUwNjIsLTE0OTA3LC0xNDI1MCwtMTI1MDQsLTExOTk3LC05OTgwLC04NzQyLC00NzkyLC00NzM4LC00NzE0LC00Njg5LC00NTc0LC0zMjA4LC0zMDE0LC0xOTcxLDQxOTUsMTAwMzMsMTI3Myw0ODE3XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddIiwicG9zdF90aXRsZSI6IkNhbnlvbmxhbmRzIE5hdGlvbmFsIFBhcmsiLCJwb3N0X2xpbmsiOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL2NhbnlvbmxhbmRzLW5hdGlvbmFsLXBhcmsvIiwicG9zdF9mZWF0dXJlZF9pbWFnZSI6IjxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiQ2FueW9ubGFuZHMgTmF0aW9uYWwgUGFya1wiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMTg4XCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyNC8wMi9jYW55b25sYW5kcy1uYXRpb25hbC1wYXJrLTMwMHgxODguanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+IiwicG9zdF9jYXRlZ29yaWVzIjoiQ2FueW9ubGFuZHMgTmF0aW9uYWwgUGFyayIsInBvc3RfdGFncyI6IiIsIiVfd3BiX3Nob3J0Y29kZXNfY3VzdG9tX2NzcyUiOiIudmNfY3VzdG9tXzE2MDg2NjY1MTk0OTJ7YmFja2dyb3VuZC1jb2xvcjogI2VhZWFlYSAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTYwODY2Njg4NTQ5N3tiYWNrZ3JvdW5kLWltYWdlOiB1cmwoaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMC8wOC9iYWNrZ3JvdW5kLWhleXVzYS1uYXR1dXItMS5naWY/aWQ9MzA4OCkgIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fSIsIiVpbmxpbmVfZmVhdHVyZWRfaW1hZ2UlIjoiMCIsIiVfZWRpdF9sb2NrJSI6IjE3MDcyMTI2MTE6MiIsIiVfZWRpdF9sYXN0JSI6IjIiLCIlX3RodW1ibmFpbF9pZCUiOiIxODkyNCIsIiVfaGlkZV9mZWF0dXJlZCUiOm51bGwsIiVfd3BiX3ZjX2pzX3N0YXR1cyUiOiJ0cnVlIiwiJXBvc3QtcHJpbWFyeS1jYXRlZ29yeSUiOiJhdXRvIiwiJWZlYXR1cmVkX2ltYWdlX292ZXJyaWRlJSI6Im9mZiIsIiVhcnRpY2xlX3N0eWxlX292ZXJyaWRlJSI6Im9uIiwiJXBvc3Rfc3R5bGUlIjoic3R5bGUxMSIsIiVwb3N0X2dhbGxlcnlfc3R5bGUlIjoibGlnaHRib3giLCIlcG9zdF9yZXZpZXclIjoib2ZmIiwiJXBvc3RfcmV2aWV3X3N0eWxlJSI6InN0eWxlMSIsIiVwb3N0X3Jldmlld19hdmVyYWdlJSI6IjUwIiwiJV95b2FzdF93cHNlb19jb250ZW50X3Njb3JlJSI6IjYwIiwiJV95b2FzdF93cHNlb19mb2N1c2tleXdvcmRzJSI6IltdIiwiJV95b2FzdF93cHNlb19rZXl3b3Jkc3lub255bXMlIjoiW1wiXCJdIiwiJV95b2FzdF93cHNlb19mb2N1c2t3JSI6IkNhbnlvbmxhbmRzIE5hdGlvbmFsIFBhcmsiLCIlX3lvYXN0X3dwc2VvX21ldGFkZXNjJSI6IkluIFV0YWggdmluZCBqZSBoZXQgQ2FueW9ubGFuZHMgTmF0aW9uYWwgUGFyaywgYmVrZW5kIHZhbndlZ2UgZGUgY2FueW9ucyBlbiByb3RzZm9ybWF0aWVzIGVuIE1lc2EgQXJjaC4gVGlwcyB2b29yIGVlbiBiZXpvZWsgYWFuIENhbnlvbmxhbmRzIE5hdGlvbmFsIFBhcmsuIiwiJV95b2FzdF93cHNlb19saW5rZGV4JSI6Ijc3IiwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6IlV0YWgsIFZlcmVuaWdkZSBTdGF0ZW4iLCIlX3dwZ21wX2xvY2F0aW9uX2NpdHklIjoiIiwiJV93cGdtcF9sb2NhdGlvbl9zdGF0ZSUiOiJVdGFoIiwiJV93cGdtcF9sb2NhdGlvbl9jb3VudHJ5JSI6IlZlcmVuaWdkZSBTdGF0ZW4iLCIlX3dwZ21wX21ldGFib3hfbGF0aXR1ZGUlIjoiMzguMjEzNTczMyIsIiVfd3BnbXBfbWV0YWJveF9sb25naXR1ZGUlIjoiLTEwOS45MDI1MzQ1IiwiJV93cGdtcF9tZXRhYm94X2xvY2F0aW9uX3JlZGlyZWN0JSI6Im1hcmtlciIsIiVfd3BnbXBfbWV0YWJveF9jdXN0b21fbGluayUiOiIiLCIlX3dwZ21wX21hcF9pZCUiOiJhOjE6e2k6MDtzOjE6XCI3XCI7fSIsIiVfd3BnbXBfbWV0YWJveF9tYXJrZXJfaWQlIjoiIiwiJV93cGdtcF9tZXRhYm94X3RheG9tb21pZXNfdGVybXMlIjoiIiwiJV93cGdtcF9leHRlbnNpb25zX2ZpZWxkcyUiOiIiLCIlX3lvYXN0X3dwc2VvX2VzdGltYXRlZC1yZWFkaW5nLXRpbWUtbWludXRlcyUiOiI2IiwiJV95b2FzdF93cHNlb19wcmltYXJ5X2NhdGVnb3J5JSI6IjI0MSIsIiVfd3dzX3N1cHBvcnRfY29udGFjdF9udW1iZXIlIjoiIiwiJV93d3NfYWJvdXRfc3VwcG9ydF90ZXh0JSI6IiIsIiVfd3dzX3RyaWdnZXJfYnV0dG9uX3RleHQlIjoiIiwiJV93d3NfcHJlZGVmaW5lZF90ZXh0JSI6IiIsIiVfeW9hc3Rfd3BzZW9fd29yZHByb29mX3RpbWVzdGFtcCUiOiIiLCIlX3lvYXN0X2luZGV4bm93X2xhc3RfcGluZyUiOiIxNzA2OTYwODQ5IiwiJV9sYXN0X2VkaXRvcl91c2VkX2pldHBhY2slIjoiY2xhc3NpYy1lZGl0b3IiLCIlX3dwX29sZF9kYXRlJSI6IjIwMjMtMDktMjIiLCIlX3dwX29sZF9zbHVnJSI6InNhZ3Vhcm8tbmF0aW9uYWwtcGFyayIsIiVhY3RpdmVlcl9zdWJtZW51JSI6IjAiLCIlX2FjdGl2ZWVyX3N1Ym1lbnUlIjoiZmllbGRfNjU5M2Y1MjFlOTdjMiIsInRheG9ub215PWNhdGVnb3J5IjoiQ2FueW9ubGFuZHMgTmF0aW9uYWwgUGFyayIsInRheG9ub215PXBvc3RfdGFnIjoiIiwidGF4b25vbXk9cG9zdF9mb3JtYXQiOiIiLCJ0YXhvbm9teT10aGItcmVhY3Rpb25zIjoiIiwidGF4b25vbXk9dGhiLXNwb25zb3JzIjoiIn19LCJpZCI6MTg5MTYsImluZm93aW5kb3dfZGlzYWJsZSI6ZmFsc2V9LHsic291cmNlIjoicG9zdCIsInRpdGxlIjoiU1BZU0NBUEUgc3Bpb25hZ2VtdXNldW0gTmV3IFlvcmsiLCJpbmZvd2luZG93X2NvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nIFwiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJTcHlzY2FwZSBzcGlvbmFnZW11c2V1bSBOZXcgWW9ya1wiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMTY4XCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyNC8wMS9zcHlzY2FwZS1tdXNldW0tMzAweDE2OC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmcgZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+U1BZU0NBUEUgc3Bpb25hZ2VtdXNldW0gTmV3IFlvcms8L2Rpdj5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tY29udGVudCBmYy1pdGVtLWJvZHktdGV4dC1jb2xvclwiPnttYXJrZXJfYWRkcmVzc308L2Rpdj5cclxuICAgICAgICA8L2Rpdj5cclxuICAgIDwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWNsZWFyXCI+PC9kaXY+XHJcbjwvZGl2PiIsImFkZHJlc3MiOiI5MjggOHRoIEF2ZSwgTmV3IFlvcmssIE5ZIDEwMDE5LCBWZXJlbmlnZGUgU3RhdGVuIiwibG9jYXRpb24iOnsibGF0IjoiNDAuNzY1MjY5NyIsImNpdHkiOiJOZXcgWW9yayIsInN0YXRlIjoiTmV3IFlvcmsiLCJjb3VudHJ5IjoiVmVyZW5pZ2RlIFN0YXRlbiIsImxuZyI6Ii03My45ODM3MjY5Iiwib25jbGlja19hY3Rpb24iOiJtYXJrZXIiLCJyZWRpcmVjdF9wZXJtYWxpbmsiOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3NweXNjYXBlLXNwaW9uYWdlbXVzZXVtLW5ldy15b3JrLyIsInpvb20iOjEyLCJleHRyYV9maWVsZHMiOnsicG9zdF9leGNlcnB0IjoiIiwicG9zdF9jb250ZW50IjoiW3ZjX3Jvd11bdmNfY29sdW1uXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfY29sdW1uX3RleHRdXHJcblxyXG5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfY29sdW1uX3RleHRdPHN0cm9uZz5OZXcgWW9yayBrZW50IHRhbCB2YW4gbGV1a2UgbXVzZWEgb20gdGUgYmV6b2VrZW4uIEVlbiBkYWFydmFuIGlzIGhldCBpbnRlcmFjdGlldmUgU1BZU0NBUEUgc3Bpb25hZ2VtdXNldW0uIE9udGRlayB3ZWxrZSBzcGlvbmFnZXJvbCBiaWogamUgcGFzdCB0aWpkZW5zIHZlcnNjaGlsbGVuZGUgc3Bpb25hZ2UgdWl0ZGFnaW5nZW4gaW4gZGUgU3B5IEhRLiBPZiB0ZXN0IGluIFNweWdhbWVzIGplIGZ5c2lla2UgZW4gbWVudGFsZSBiZWhlbmRpZ2hlaWQuIFRpcHMgdm9vciBlZW4gYmV6b2VrIGFhbiBoZXQgU1BZU0NBUEUgc3Bpb25hZ2VtdXNldW0gaW4gTmV3IFlvcmsuPC9zdHJvbmc+Wy92Y19jb2x1bW5fdGV4dF1bdGhiX2ljb25saXN0IGljb249XCJmYXMgZmEtbWFwLW1hcmtlci1hbHRcIiB0aGJfaWNvbl9jb2xvcj1cIiMwMDAwMDBcIiB0aGJfdGV4dF9jb2xvcj1cIiMwMDAwMDBcIiBsaXN0X2NvbnRlbnQ9XCI5MjYgOHRoIEF2ZW51ZVwiXVt0aGJfaWNvbmxpc3QgaWNvbj1cImZhcyBmYS1zdWJ3YXlcIiB0aGJfaWNvbl9jb2xvcj1cIiMwMDAwMDBcIiB0aGJfdGV4dF9jb2xvcj1cIiMwMDAwMDBcIiBsaXN0X2NvbnRlbnQ9XCI1NyBTdHJlZXQgLSA3IEF2ZW51ZSB8IE4gfCBRIHwgUiB8IFdcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMjVweFwiXVt1bHRfYnV0dG9ucyBidG5fdGl0bGU9XCJCZXN0ZWwgamUgdGlja2V0c1wiIGJ0bl9saW5rPVwidXJsOmh0dHBzJTNBJTJGJTJGd3d3LmdldHlvdXJndWlkZS5ubCUyRnNweXNjYXBlLWw4OTQ1MyUyRm5ldy15b3JrLXNweXNjYXBlLXNwaW9ubmVubXVzZXVtLWVuLWF2b250dXVyLXQyMzM2NDIlMkYlM0ZwYXJ0bmVyX2lkJTNERE1EMlZMNCUyNnV0bV9tZWRpdW0lM0RvbmxpbmVfcHVibGlzaGVyJTI2Y21wJTNEc3B5c2NhcGVtdXNldW18dGl0bGU6QmVzdGVsJTIwamUlMjB0aWNrZXRzfHRhcmdldDpfYmxhbmtcIiBidG5fc2l6ZT1cInVidG4tbGFyZ2VcIiBidG5fdGl0bGVfY29sb3I9XCIjZmZmZmZmXCIgYnRuX2JnX2NvbG9yPVwiI2IzNGE0Y1wiIGJ0bl9ob3Zlcj1cInVidG4tbGVmdC1iZ1wiIGJ0bl9iZ19jb2xvcl9ob3Zlcj1cIiM1MzFhMjNcIiBidG5fdGl0bGVfY29sb3JfaG92ZXI9XCIjZmZmZmZmXCIgaWNvbl9zaXplPVwiMzJcIiBidG5faWNvbl9wb3M9XCJ1YnRuLXNlcC1pY29uLWF0LWxlZnRcIiBidG5fZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgYnRuX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MTVweDtcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIlRpcDpcIiBmb250X2NvbnRhaW5lcj1cInRhZzpkaXZ8Zm9udF9zaXplOjE1fHRleHRfYWxpZ246bGVmdHxjb2xvcjolMjNiMzRhNGN8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkhldCBtdXNldW0gaXMgbmlldCBnZXNjaGlrdCB2b29yIGhlbGUgam9uZ2Uga2luZGVyZW4gb21kYXQgZGUgdm9lcnRhYWwgRW5nZWxzIGlzLlwiIGZvbnRfY29udGFpbmVyPVwidGFnOmRpdnxmb250X3NpemU6MjB8dGV4dF9hbGlnbjpsZWZ0fGNvbG9yOiUyMzI4MjgyOFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OlJvYm90byUyMFNsYWIlM0ExMDAlMkMzMDAlMkNyZWd1bGFyJTJDNzAwfGZvbnRfc3R5bGU6MTAwJTIwbGlnaHQlMjByZWd1bGFyJTNBMTAwJTNBbm9ybWFsXCJdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiIGNzcz1cIi52Y19jdXN0b21fMTU4MjkwNjI0MTk0MHtwYWRkaW5nLXRvcDogNTBweCAhaW1wb3J0YW50O3BhZGRpbmctYm90dG9tOiA1MHB4ICFpbXBvcnRhbnQ7YmFja2dyb3VuZC1jb2xvcjogI2UyZTJlMiAhaW1wb3J0YW50O31cIl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjIvM1wiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIk9udGRlayBkZSBzcGlvbiBpbiBqZSFcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMjgyODI4XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjM1cHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDo0MHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdXHJcbjxwIHN0eWxlPVwidGV4dC1hbGlnbjogY2VudGVyO1wiPkhldCBTUFlTQ0FQRSBzcGlvbmFnZW11c2V1bSBpbiBOZXcgWW9yayBpcyBlZW4gaW50ZXJhY3RpZWYgbXVzZXVtIGRhdCBqZSBkaXJlY3QgYmlqIGJpbm5lbmtvbXN0IGFsIG1lcmt0LiBWaWEgZWVuIGluc3RydWN0aWVmaWxtIGtyaWpnIGplIHRlIGhvcmVuIHdhdCBlciB2YW4gamUgdmVyd2FjaHQgd29yZHQgaW4gaGV0IG11c2V1bS4gSGV0IG11c2V1bSBpcyB2ZXJkZWVsZCBpbiA3IHZlcnNjaGlsbGVuZGUgcnVpbXRlcyBkaWUgYWxsZW1hYWwgZWVuIGVpZ2VuIHRoZW1hIGhlYmJlbi4gRGVuayBhYW4gaW5saWNodGluZ2VuZGllbnN0ZW4gb2YgY3liZXJvb3Jsb2dlbi4gTmF0dXVybGlqayB3b3JkdCBvb2sgZ2VrZWtlbiBob2UgZ29lZCBqZSBzY29vcnQgYWxzIHNwaW9uIG9wIGFsbGUgb25kZXJkZWxlbi4gVmlhIGVlbiBwb2xzYmFuZGplIHdvcmRlbiBqZSB2YWFyZGlnaGVkZW4gYmlqZ2Vob3VkZW4uIE5hIGFsbGUgdGVzdGVuIHdvcmRlbiBkZSByZXN1bHRhdGVuIGdlYW5hbHlzZWVyZCBlbiBrb20gamUgdGUgd2V0ZW4gd2F0IHZvb3IgdHlwZSBzcGlvbiBqZSBiZW50LjwvcD5cclxuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiIGZ1bGxfd2lkdGg9XCJzdHJldGNoX3Jvd1wiIGNvbnRlbnRfdGV4dF9hbGlnbWVudD1cImNlbnRlclwiIGNzcz1cIi52Y19jdXN0b21fMTU4NzY1OTI5OTA3MXtwYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O2JhY2tncm91bmQtY29sb3I6ICMwMDAwMDAgIWltcG9ydGFudDt9XCIgcGFyYWxsYXhfYmFja2dyb3VuZF9pbWFnZT1cIjM4MzZcIl1bdmNfY29sdW1uIHRoYl9jb2xvcj1cInRoYi1saWdodC1jb2x1bW5cIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiU3Bpb25hZ2VcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjZmZmZmZmXCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjU1cHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDo2MHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11baGV5dXNhX2hlYWRpbmcgdGFnPVwiaDRcIiB0ZXh0X2FsaWduPVwiY2VudGVyXCIgaGVhZGluZz1cIktvbSBtZWVyIHRlIHdldGVuIG92ZXIgZGUgdmVyc2NoaWxsZW5kZSBhc3BlY3RlbiB2YW4gc3Bpb25hZ2VcIiBmb250X3NpemU9XCI1MFwiIGxpbmVfaGVpZ2h0PVwiMVwiIGZvbnRfY29sb3I9XCIjZmZmZmZmXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3BhcmFsbGF4X3JvdyBvcGFjaXR5PVwiODVcIiBlbmFibGVfbW9iaWxlPVwicGFyYWxsYXgtZW5hYmxlLW1vYmlsZVwiIGltYWdlPVwiMTg4OTFcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IGNzcz1cIi52Y19jdXN0b21fMTQ3MjMwNzUwMjI5MHtwYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O3BhZGRpbmctYm90dG9tOiAyNXB4ICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW5dW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI3NXB4XCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiV2F0IGplIG5pZXQgbWFnIG1pc3NlblwiIGhlYWRpbmdfdGFnPVwicFwiIG1haW5faGVhZGluZ19jb2xvcj1cIiNiMzRhNGNcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDo1NXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjYwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIlNQWVNDQVBFIHNwaW9uYWdlbXVzZXVtXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzI4MjgyOFwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjQ1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6Um9ib3RvIFNsYWJ8Zm9udF9jYWxsOlJvYm90bytTbGFifHZhcmlhbnQ6MzAwXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDo1MHB4O1wiIG1haW5faGVhZGluZ19zdHlsZT1cImZvbnQtd2VpZ2h0OjMwMDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bdmNfcm93X2lubmVyIGNzcz1cIi52Y19jdXN0b21fMTU4Mjk3MDcwNDkwM3twYWRkaW5nLXRvcDogMTBweCAhaW1wb3J0YW50O3BhZGRpbmctcmlnaHQ6IDEwcHggIWltcG9ydGFudDtwYWRkaW5nLWJvdHRvbTogMTBweCAhaW1wb3J0YW50O3BhZGRpbmctbGVmdDogMTBweCAhaW1wb3J0YW50O31cIl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiU3B5IEhRXCIgaGVhZGluZ190YWc9XCJoM1wiIG1haW5faGVhZGluZ19jb2xvcj1cIiMyODI4MjhcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjMwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF1cclxuPHAgc3R5bGU9XCJ0ZXh0LWFsaWduOiBjZW50ZXI7XCI+U1BZU0NBUEUgSFEgaGVlZnQgNyB2ZXJzY2hpbGxlbmRlIHJ1aW10ZXM6IEVuY3J5cHRpZSwgRGVjZXB0aW9uLCBTdXJ2ZWlsbGFuY2UsIEhhY2tlbiwgQ3liZXJ3YXJmYXJlLCBTcGVjaWFscyBPcHMgZW4gSW50ZWxsaWdlbmNlLiBBbGxlbWFhbCB2ZXJzY2hpbGxlbmRlIG9uZGVyd2VycGVuIGRpZSB0ZSBtYWtlbiBoZWJiZW4gbWV0IHNwaW9uYWdlIHdvcmRlbiB1aXRnZWxpY2h0IGluIGRlemUgcnVpbXRlcy4gT25kZXJ0dXNzZW4ga3VuIGplIGFscyBiZXpvZWtlciBqZSB2YWFyZGlnaGVkZW4gdGVzdGVuIGRvb3IgdmVyc2NoaWxsZW5kZSB1aXRkYWdpbmdlbiBhYW4gdGUgZ2Fhbi4gSW4gZGUgcnVpbXRlIERlYnJpZWYga3JpamcgamUgdGUgaG9yZW4gaG9lIGplIGhldCBnZWRhYW4gaGVidCBlbiB3ZWxrZSBzcGlvbmFnZXJvbCBoZXQgYmVzdGUgcGFzdCBiaWogamUuPC9wPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJTcHlnYW1lc1wiIGhlYWRpbmdfdGFnPVwiaDNcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMjgyODI4XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozMHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdXHJcbjxwIHN0eWxlPVwidGV4dC1hbGlnbjogY2VudGVyO1wiPlNweWdhbWVzIGlzIGVlbiBzcGFubmVuZGUgZXJ2YXJpbmcgZGF0IG9udHdpa2tlbGQgaXMgbWV0IGV4cGVydHMgdmFuIGRlIENJQSBlbiBTcGVjaWFsIE9wcyBvbSBqZSBmeXNpZWtlIGVuIG1lbnRhbGUgYmVoZW5kaWdoZWlkIHRlIHRlc3Rlbi4gU2FtZW4gbWV0IGplIHJlaXNnZW5vdGVuIG1vZXQgamUgc3ByaW5nZW4sIG9udHdpamtlbiwgZ29vaWVuLCBrbGltbWVuIGJpaiBhbGxlcmxlaSB2ZXJzY2hpbGxlbmRlIHVpdGRhZ2luZ2VuLiBOaWV0IGFsbGVlbiBsZXVrIG9tIHRlIGRvZW4sIGplIHZlcmdyb290IG9uZGVydHVzc2VuIG9vayBqZSBwZXJzb29ubGlqa2UgdmFhcmRpZ2hlZGVuIGVuIGNvbmRpdGllLjwvcD5cclxuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIiBmdWxsX3dpZHRoPVwic3RyZXRjaF9yb3dcIiBjb250ZW50X3RleHRfYWxpZ21lbnQ9XCJjZW50ZXJcIiBjc3M9XCIudmNfY3VzdG9tXzE1ODc2NTkyOTkwNzF7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDtiYWNrZ3JvdW5kLWNvbG9yOiAjMDAwMDAwICFpbXBvcnRhbnQ7fVwiIHBhcmFsbGF4X2JhY2tncm91bmRfaW1hZ2U9XCIzODM2XCJdW3ZjX2NvbHVtbiB0aGJfY29sb3I9XCJ0aGItbGlnaHQtY29sdW1uXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIlNweWdhbWVzXCIgaGVhZGluZ190YWc9XCJwXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiI2ZmZmZmZlwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjY1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NzBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW2hleXVzYV9oZWFkaW5nIHRhZz1cImg0XCIgdGV4dF9hbGlnbj1cImNlbnRlclwiIGhlYWRpbmc9XCJPbnRkZWsgZGUgc3Bpb24gaW4gamVcIiBmb250X3NpemU9XCI1MFwiIGxpbmVfaGVpZ2h0PVwiMVwiIGZvbnRfY29sb3I9XCIjZmZmZmZmXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjIwcHhcIl1bdWx0X2J1dHRvbnMgYnRuX3RpdGxlPVwiQmVzdGVsIGplIHRpY2tldHNcIiBidG5fbGluaz1cInVybDpodHRwcyUzQSUyRiUyRnd3dy5nZXR5b3VyZ3VpZGUubmwlMkZzcHlzY2FwZS1sODk0NTMlMkZuZXcteW9yay1zcHlzY2FwZS1zcGlvbm5lbm11c2V1bS1lbi1hdm9udHV1ci10MjMzNjQyJTJGJTNGcGFydG5lcl9pZCUzRERNRDJWTDQlMjZ1dG1fbWVkaXVtJTNEb25saW5lX3B1Ymxpc2hlciUyNmNtcCUzRHNweXNjYXBlbXVzZXVtYmFubmVyb25kZXJ8dGl0bGU6QmVzdGVsJTIwdGlja2V0cyUyMHZvb3IlMjBTUFlTQ0FQRXx0YXJnZXQ6X2JsYW5rXCIgYnRuX2FsaWduPVwidWJ0bi1jZW50ZXJcIiBidG5fc2l6ZT1cInVidG4tbGFyZ2VcIiBidG5fdGl0bGVfY29sb3I9XCIjZmZmZmZmXCIgYnRuX2JnX2NvbG9yPVwiI2IzNGE0Y1wiIGJ0bl9ob3Zlcj1cInVidG4tbGVmdC1iZ1wiIGJ0bl9iZ19jb2xvcl9ob3Zlcj1cIiM1MzFhMjNcIiBidG5fdGl0bGVfY29sb3JfaG92ZXI9XCIjZmZmZmZmXCIgaWNvbl9zaXplPVwiMzJcIiBidG5faWNvbl9wb3M9XCJ1YnRuLXNlcC1pY29uLWF0LWxlZnRcIiBidG5fZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgYnRuX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MTVweDtcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bcGFyYWxsYXhfcm93IG9wYWNpdHk9XCI4NVwiIGVuYWJsZV9tb2JpbGU9XCJwYXJhbGxheC1lbmFibGUtbW9iaWxlXCIgaW1hZ2U9XCIxODg4OVwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIk9vayBsZXVrIGluIE5ldyBZb3JrIENpdHk6XCIgaGVhZGluZ190YWc9XCJwXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzI4MjgyOFwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjQ1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NTBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bZnVsbHdpZHRoX3Jvd11bdGhiX3Bvc3RncmlkIGNvbHVtbnM9XCI0XCIgc291cmNlPVwicG9zdF90eXBlOnBvc3R8YnlfaWQ6MTU5NCwxMzEyLDQwOCwxNTU5XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddIiwicG9zdF90aXRsZSI6IlNQWVNDQVBFIHNwaW9uYWdlbXVzZXVtIE5ldyBZb3JrIiwicG9zdF9saW5rIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9zcHlzY2FwZS1zcGlvbmFnZW11c2V1bS1uZXcteW9yay8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJTcHlzY2FwZSBzcGlvbmFnZW11c2V1bSBOZXcgWW9ya1wiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMTY4XCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyNC8wMS9zcHlzY2FwZS1tdXNldW0tMzAweDE2OC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj4iLCJwb3N0X2NhdGVnb3JpZXMiOiJNdXNlYSBOZXcgWW9yayIsInBvc3RfdGFncyI6Ik5ldyBZb3JrIiwiJV93cGJfc2hvcnRjb2Rlc19jdXN0b21fY3NzJSI6Ii52Y19jdXN0b21fMTU4MjkwNjI0MTk0MHtwYWRkaW5nLXRvcDogNTBweCAhaW1wb3J0YW50O3BhZGRpbmctYm90dG9tOiA1MHB4ICFpbXBvcnRhbnQ7YmFja2dyb3VuZC1jb2xvcjogI2UyZTJlMiAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE1ODc2NTkyOTkwNzF7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDtiYWNrZ3JvdW5kLWNvbG9yOiAjMDAwMDAwICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTQ3MjMwNzUwMjI5MHtwYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O3BhZGRpbmctYm90dG9tOiAyNXB4ICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTU4NzY1OTI5OTA3MXtwYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O2JhY2tncm91bmQtY29sb3I6ICMwMDAwMDAgIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNTgyOTcwNzA0OTAze3BhZGRpbmctdG9wOiAxMHB4ICFpbXBvcnRhbnQ7cGFkZGluZy1yaWdodDogMTBweCAhaW1wb3J0YW50O3BhZGRpbmctYm90dG9tOiAxMHB4ICFpbXBvcnRhbnQ7cGFkZGluZy1sZWZ0OiAxMHB4ICFpbXBvcnRhbnQ7fSIsIiVfZWRpdF9sb2NrJSI6IjE3MDcxNDY3ODU6MSIsIiVfZWRpdF9sYXN0JSI6IjEiLCIlX3dwYl92Y19qc19zdGF0dXMlIjoidHJ1ZSIsIiVwb3N0LXByaW1hcnktY2F0ZWdvcnklIjoiMTYiLCIlZmVhdHVyZWRfaW1hZ2Vfb3ZlcnJpZGUlIjoib2ZmIiwiJWFydGljbGVfc3R5bGVfb3ZlcnJpZGUlIjoib24iLCIlcG9zdF9zdHlsZSUiOiJzdHlsZTUiLCIlcG9zdF9nYWxsZXJ5X3N0eWxlJSI6ImxpZ2h0Ym94IiwiJXBvc3RfcmV2aWV3JSI6Im9mZiIsIiVwb3N0X3Jldmlld19zdHlsZSUiOiJzdHlsZTEiLCIlcG9zdF9yZXZpZXdfYXZlcmFnZSUiOiI1MCIsIiV0aGJfYWxsX2NvdW50cyUiOiIwIiwiJWV4ZWN1dGl2ZV9zdW1tYXJ5JSI6IiIsIiV0aGItcmVhY3Rpb25zLXZvdGVzJSI6IjEiLCIlX2hpZGVfZmVhdHVyZWQlIjpudWxsLCIlX3dwX29sZF9kYXRlJSI6IjIwMjAtMDgtMzEiLCIlaW5saW5lX2ZlYXR1cmVkX2ltYWdlJSI6IjAiLCIlX3lvYXN0X3dwc2VvX2NvbnRlbnRfc2NvcmUlIjoiMzAiLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza2V5d29yZHMlIjoiW10iLCIlX3lvYXN0X3dwc2VvX2tleXdvcmRzeW5vbnltcyUiOiJbXCJTcHlzY2FwZVwiXSIsIiVfeW9hc3Rfd3BzZW9fZm9jdXNrdyUiOiJTcHlzY2FwZSBzcGlvbmFnZW11c2V1bSBOZXcgWW9yayIsIiVfeW9hc3Rfd3BzZW9fbWV0YWRlc2MlIjoiRWVuIGxldWsgZW4gaW50ZXJhY3RpZWYgbXVzZXVtIGluIE5ldyBZb3JrIGlzIGhldCBTcHlzY2FwZSBzcGlvbmFnZW11c2V1bS4gT250ZGVrIGRlIHNwaW9uIGluIGplemVsZiBkb29yIGFsbGVybGVpIG9wZHJhY2h0ZW4gdWl0IHRlIHZvZXJlbiIsIiVfeW9hc3Rfd3BzZW9fbGlua2RleCUiOiI3MiIsIiVfd3BnbXBfbG9jYXRpb25fYWRkcmVzcyUiOiI5MjggOHRoIEF2ZSwgTmV3IFlvcmssIE5ZIDEwMDE5LCBWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9sb2NhdGlvbl9jaXR5JSI6Ik5ldyBZb3JrIiwiJV93cGdtcF9sb2NhdGlvbl9zdGF0ZSUiOiJOZXcgWW9yayIsIiVfd3BnbXBfbG9jYXRpb25fY291bnRyeSUiOiJWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9tZXRhYm94X2xhdGl0dWRlJSI6IjQwLjc2NTI2OTciLCIlX3dwZ21wX21ldGFib3hfbG9uZ2l0dWRlJSI6Ii03My45ODM3MjY5IiwiJV93cGdtcF9tZXRhYm94X2xvY2F0aW9uX3JlZGlyZWN0JSI6Im1hcmtlciIsIiVfd3BnbXBfbWV0YWJveF9jdXN0b21fbGluayUiOiIiLCIlX3dwZ21wX21hcF9pZCUiOiJhOjE6e2k6MDtzOjE6XCI3XCI7fSIsIiVfd3BnbXBfbWV0YWJveF9tYXJrZXJfaWQlIjoiYToxOntpOjA7czoxOlwiMlwiO30iLCIlX3dwZ21wX21ldGFib3hfdGF4b21vbWllc190ZXJtcyUiOiIiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6IiIsIiVfeW9hc3Rfd3BzZW9fZXN0aW1hdGVkLXJlYWRpbmctdGltZS1taW51dGVzJSI6IjMiLCIlX3d3c19zdXBwb3J0X2NvbnRhY3RfbnVtYmVyJSI6IiIsIiVfd3dzX2Fib3V0X3N1cHBvcnRfdGV4dCUiOiIiLCIlX3d3c190cmlnZ2VyX2J1dHRvbl90ZXh0JSI6IiIsIiVfd3dzX3ByZWRlZmluZWRfdGV4dCUiOiIiLCIlX3RodW1ibmFpbF9pZCUiOiIxODg5MCIsIiVwb3N0X3ZpYSUiOiIiLCIlX3lvYXN0X2luZGV4bm93X2xhc3RfcGluZyUiOiIxNzA2Mjc1OTI0IiwiJV95b2FzdF93cHNlb193b3JkcHJvb2ZfdGltZXN0YW1wJSI6IiIsIiVfbGFzdF9lZGl0b3JfdXNlZF9qZXRwYWNrJSI6ImNsYXNzaWMtZWRpdG9yIiwiJWFjdGl2ZWVyX3N1Ym1lbnUlIjoiMSIsIiVfYWN0aXZlZXJfc3VibWVudSUiOiJmaWVsZF82NTkzZjUyMWU5N2MyIiwiJWxvY2F0aWVfc3VibWVudSUiOiJTZWxlY3RlZXIgZWVuIHBhZ2luYSIsIiVfbG9jYXRpZV9zdWJtZW51JSI6ImZpZWxkXzY1OTNmNTMxZTk3YzMiLCIlc2VsZWN0ZWVyX3BhZ2luYSUiOiIxODQ1MyIsIiVfc2VsZWN0ZWVyX3BhZ2luYSUiOiJmaWVsZF82NTkzZjhiZTAxOWRhIiwiJV95b2FzdF93cHNlb19wcmltYXJ5X2NhdGVnb3J5JSI6IiIsInRheG9ub215PWNhdGVnb3J5IjoiTXVzZWEgTmV3IFlvcmsiLCJ0YXhvbm9teT1wb3N0X3RhZyI6Ik5ldyBZb3JrIiwidGF4b25vbXk9cG9zdF9mb3JtYXQiOiIiLCJ0YXhvbm9teT10aGItcmVhY3Rpb25zIjoiIiwidGF4b25vbXk9dGhiLXNwb25zb3JzIjoiIn0sImljb24iOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDI0LzAzL211c2VhLWljb24ucG5nIn0sImlkIjoxODg4OCwiaW5mb3dpbmRvd19kaXNhYmxlIjpmYWxzZSwiY2F0ZWdvcmllcyI6W3siaWNvbiI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjQvMDMvbXVzZWEtaWNvbi5wbmciLCJuYW1lIjoiTXVzZWEiLCJpZCI6IjIiLCJ0eXBlIjoiY2F0ZWdvcnkiLCJleHRlbnNpb25fZmllbGRzIjp7ImNhdF9vcmRlciI6IiJ9fV19LHsic291cmNlIjoicG9zdCIsInRpdGxlIjoiU2llcnJhIE5ldmFkYSBpbiBDYWxpZm9ybmlcdTAwZWIiLCJpbmZvd2luZG93X2NvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nIFwiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJTaWVycmEgTmV2YWRhIGluIENhbGlmb3JuaVx1MDBlYlwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMy8xMi9zaWVycmEtbmV2YWRhLTMwMHgyMDAuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZ1wiPlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nIGZjLWl0ZW0tbm8tcGFkZGluZ1wiPlxyXG4gICAgICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS10aXRsZSBmYy1pdGVtLXByaW1hcnktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZVwiPlNpZXJyYSBOZXZhZGEgaW4gQ2FsaWZvcm5pXHUwMGViPC9kaXY+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3JcIj57bWFya2VyX2FkZHJlc3N9PC9kaXY+XHJcbiAgICAgICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1jbGVhclwiPjwvZGl2PlxyXG48L2Rpdj4iLCJhZGRyZXNzIjoiTGFrZSBQbGFjaWQsIE5ldyBZb3JrIDEyOTQ2LCBWZXJlbmlnZGUgU3RhdGVuIiwibG9jYXRpb24iOnsibGF0IjoiNDQuMjc5NDkxMSIsImNpdHkiOiJOb3J0aCBFbGJhIiwic3RhdGUiOiJOZXcgWW9yayIsImNvdW50cnkiOiJWZXJlbmlnZGUgU3RhdGVuIiwibG5nIjoiLTczLjk3OTg3MTMiLCJvbmNsaWNrX2FjdGlvbiI6Im1hcmtlciIsInJlZGlyZWN0X3Blcm1hbGluayI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvc2llcnJhLW5ldmFkYS1jYWxpZm9ybmllLyIsInpvb20iOjEyLCJleHRyYV9maWVsZHMiOnsicG9zdF9leGNlcnB0IjoiIiwicG9zdF9jb250ZW50IjoiW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiODUlXCJdW3ZjX3NpbmdsZV9pbWFnZSBpbWFnZT1cIjE4NDIwXCIgaW1nX3NpemU9XCJsYXJnZVwiIGFkZF9jYXB0aW9uPVwieWVzXCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvMlwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW2hleXVzYV9oZWFkaW5nIHRhZz1cImRpdlwiIGhlYWRpbmc9XCJEcmllIE5hdGlvbmFsZSBQYXJrZW4gaW5cIiBmb250X3NpemU9XCI0NVwiIGxpbmVfaGVpZ2h0PVwiNTBcIiBmb250X2NvbG9yPVwiI2IzNGE0Y1wiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiU2llcnJhIE5ldmFkYSBpbiBDYWxpZm9ybmlcdTAwZWJcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MzV8dGV4dF9hbGlnbjpsZWZ0fGNvbG9yOiUyMzAwMDAwMFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdRGUgU2llcnJhIE5ldmFkYSwgb29rIHdlbCBTcGFhbnMgdm9vciBiZXNuZWV1d2RlIGJlcmdrZXRlbiwgaW4gQ2FsaWZvcm5pXHUwMGViIG9tdmF0IGVlbiBncm9vdCBkZWVsIHZhbiBkZSBzdGFhdC4gTWVlciBkYW4gMjUlIHZhbiBoZXQgZ3JvbmRnZWJpZWQgdmFuIENhbGlmb3JuaVx1MDBlYiBiZWhvb3J0IHRvdCBkZSBTaWVycmEgTmV2YWRhLCBlZW4ga2xlaW4gZGVlbCB2YW4gaGV0IG5hdHV1cmdlYmllZCBsaWd0IGluIGRlIHN0YWF0IE5ldmFkYS4gSGV0IGdlYmllZCBiZXZhdCAzIG5hdGlvbmFsZSBwYXJrZW4sIDI2IHdpbGRlcm5pcyBnZWJpZWRlbiwgMTAgbmF0aW9uYWwgZm9yZXN0cyBlbiAyIG5hdGlvbmFsZSBtb251bWVudGVuLiBKZSB2aW5kdCBkZSBTaWVycmEgTmV2YWRhIHR1c3NlbiBDZW50cmFsIFZhbGxleSBlbiBCYXNpbiBhbmQgUmFuZ2UgUHJvdmluY2UuIE1ldCBpbiB0b3RhYWwgNjQwIGtpbG9tZXRlciBsYW5nIGVuIDExMCBraWxvbWV0ZXIgYnJlZWQsIGlzIGRlIFNpZXJyYSBOZXZhZGEgaW4gQ2FsaWZvcm5pXHUwMGViIGVlbiBwcmFjaHRpZyBuYXR1dXJnZWJpZWQgb20gdGUgb250ZGVra2VuIGVuIHdpbGRsaWZlIHRlIHppZW4uWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIGNvbnRlbnRfcGxhY2VtZW50PVwibWlkZGxlXCIgZnVsbF93aWR0aD1cInN0cmV0Y2hfcm93XCIgY29udGVudF90ZXh0X2FsaWdtZW50PVwiY2VudGVyXCIgY3NzPVwiLnZjX2N1c3RvbV8xNzAzNjc0ODA3MDA3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fVwiIHBhcmFsbGF4X2JhY2tncm91bmRfaW1hZ2U9XCIzODM2XCJdW3ZjX2NvbHVtbiB0aGJfY29sb3I9XCJ0aGItbGlnaHQtY29sdW1uXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiTGFrZSBBbG9oYSBpbiBkZSBTaWVycmEgTmV2YWRhXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjU1fHRleHRfYWxpZ246Y2VudGVyfGNvbG9yOiUyM2ZmZmZmZnxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVtoZXl1c2FfaGVhZGluZyB0YWc9XCJkaXZcIiB0ZXh0X2FsaWduPVwiY2VudGVyXCIgaGVhZGluZz1cIldpc3NlbGVuZGUgbGFuZHNjaGFwcGVuIGluIGRlIFNpZXJyYSBOZXZhZGFcIiBmb250X3NpemU9XCI1NVwiIGxpbmVfaGVpZ2h0PVwiNjBcIiBmb250X2NvbG9yPVwiI2ZmZmZmZlwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVtwYXJhbGxheF9yb3cgZW5hYmxlX21vYmlsZT1cInBhcmFsbGF4LWVuYWJsZS1tb2JpbGVcIiBpbWFnZT1cIjE4Mzk1XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIl1bdmNfY29sdW1uXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8zXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJPbnRzdGFhbiB2YW4gZGUgU2llcnJhIE5ldmFkYVwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZToyNXx0ZXh0X2FsaWduOmxlZnRcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XU1lZXIgZGFuIDEwMCBtaWxqb2VuIGphYXIgZ2VsZWRlbiB2b3JtZGUgZ3JhbmlldCBkZSBkaWVwZSBvbmRlcmdyb25kIHZhbiBkaXQgZ2ViaWVkLiBWaWVyIG1pbGpvZW4gamFhciBnZWxlZGVuIHdlcmQgZGUgYmVyZ2tldGVuIG9taG9vZyBnZWR1d2QgZW4gZG9vciBlZW4gZ2xldHNqZXIga3dhbSBoZXQgZ3JhbmlldCBibG9vdCB0ZSBsaWdnZW4uIEhpZXJkb29yIG9udHN0b25kZW4gZGUgdW5pZWtlIGJlcmd0b3BwZW4gdmFuIGRlIFNpZXJyYSBOZXZhZGEuIEhldCBsYW5kc2NoYXAgdmFuIGRlIFNpZXJyYSBOZXZhZGEgaXMgZ2V2YXJpZWVyZCBtZXQgdmVyc2NoaWxsZW5kZSBob29ndGVzLCBtYWFyIG9vayBtZXQgYm9zc2VuLCBtZXJlbiwgd2F0ZXJ2YWxsZW4gZW4gZW5vcm1lIGJvbWVuLlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvM1wiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiT3Zlcm5hY2h0ZW4gaW4gZGUgU2llcnJhIE5ldmFkYVwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZToyNXx0ZXh0X2FsaWduOmxlZnRcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XUFhbmdlemllbiBoZXQgZ2ViaWVkIGVub3JtIGRhdCB0b3QgZGUgU2llcnJhIE5ldmFkYSBiZWhvb3J0IGVub3JtIGdyb290IGlzLCBpcyBlciBlZW4gdmVyc2NoZWlkZW5oZWlkIGFhbiBsb2NhdGllcyB3YWFyIGplIGt1bnQgb3Zlcm5hY2h0ZW4uIERlbmsgYWFuIG92ZXJuYWNodGVuIGluIGRlIGJ1dXJ0IHZhbiA8YSBocmVmPVwiaHR0cHM6Ly93d3cuYm9va2luZy5jb20vc2VhcmNocmVzdWx0cy5lbi5odG1sP2NpdHk9MjAwMTYwODcmYW1wO2FpZD03OTU4NDk4JmFtcDtub19yb29tcz0xJmFtcDtncm91cF9hZHVsdHM9MiZhbXA7bGFiZWw9c2llcnJhbmV2YWRhdGFob2VcIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPkxha2UgVGFob2U8L2E+LCA8YSBocmVmPVwiaHR0cHM6Ly93d3cuYm9va2luZy5jb20vc2VhcmNocmVzdWx0cy5lbi5odG1sP2NpdHk9MjAwMTY5NzEmYW1wO2FpZD03OTU4NDk4JmFtcDtub19yb29tcz0xJmFtcDtncm91cF9hZHVsdHM9MiZhbXA7bGFiZWw9c2llcnJhbmV2YWRheW9zZW1pdGVcIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPllvc2VtaXRlIE5hdGlvbmFsIFBhcms8L2E+IG9mIGhldCA8YSBocmVmPVwiaHR0cHM6Ly93d3cuYm9va2luZy5jb20vc2VhcmNocmVzdWx0cy5lbi5odG1sP2NpdHk9MjAwMTQxNTQmYW1wO2FpZD03OTU4NDk4JmFtcDtub19yb29tcz0xJmFtcDtncm91cF9hZHVsdHM9MiZhbXA7bGFiZWw9c2llcnJhbmV2YWRhbG9uZXBpbmVcIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPktpbmdzIENhbnlvbiBOYXRpb25hbCBQYXJrLjwvYT5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzNcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkJlc3RlIHJlaXNwZXJpb2RlIFNpZXJyYSBOZXZhZGFcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MjV8dGV4dF9hbGlnbjpsZWZ0XCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1EZSB6b21lciBpcyBkZSBtZWVzdCBwb3B1bGFpcmUgcGVyaW9kZSBvbSBkZSBTaWVycmEgTmV2YWRhIHRlIGJlem9la2VuLiBJbiBkZSB3aW50ZXIgZW4gaW4gZGUgdnJvZWdlIGxlbnRlIGlzIGVyIGthbnMgb3Agc25lZXV3dmFsLCB6ZWtlciBpbiBkZSBob2dlciBnZWxlZ2VuIGRlbGVuLCB3YWFyZG9vciB3ZWdlbiBhZmdlc2xvdGVuIHppam4uIFplbGZzIGVpbmQgbWVpIGhlYiBqZSBub2cga2FucyBvcCBzbmVldXcuIERhYXJvbSB6aWpuIGRlIG1hYW5kZW4ganVuaSwganVsaSwgYXVndXN0dXMgZW4gYmVnaW4gc2VwdGVtYmVyIGRlIGJlc3RlIHBlcmlvZGUgb20gZGUgU2llcnJhIE5ldmFkYSB0ZSBiZXpvZWtlbi4gVG9jaCB6aWpuIGRlbGVuIHZhbiBkZSBTaWVycmEgTmV2YWRhIHByaW1hIGluIGRlIHdpbnRlciB0ZSBiZXpvZWtlbiwgZGVuayBhYW4gc2tpIG1vZ2VsaWpraGVkZW4gcm9uZG9tIExha2UgVGFob2UgYmlqdm9vcmJlZWxkLlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIiBmdWxsX3dpZHRoPVwic3RyZXRjaF9yb3dcIiBjb250ZW50X3RleHRfYWxpZ21lbnQ9XCJjZW50ZXJcIiBjc3M9XCIudmNfY3VzdG9tXzE3MDM3NTI1Mzk5OTV7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDtiYWNrZ3JvdW5kLWNvbG9yOiAjMDAwMDAwICFpbXBvcnRhbnQ7fVwiIHBhcmFsbGF4X2JhY2tncm91bmRfaW1hZ2U9XCIzODM2XCJdW3ZjX2NvbHVtbiB0aGJfY29sb3I9XCJ0aGItbGlnaHQtY29sdW1uXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiU2llcnJhIE5ldmFkYSBpbiBDYWxpZm9ybmlcdTAwZWJcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6NTV8dGV4dF9hbGlnbjpjZW50ZXJ8Y29sb3I6JTIzZmZmZmZmfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW2hleXVzYV9oZWFkaW5nIHRhZz1cImRpdlwiIHRleHRfYWxpZ249XCJjZW50ZXJcIiBoZWFkaW5nPVwiRGUgcGVyZmVjdGUgcGxlayB2b29yIGVlbiByb2FkdHJpcFwiIGZvbnRfc2l6ZT1cIjU1XCIgbGluZV9oZWlnaHQ9XCI2MFwiIGZvbnRfY29sb3I9XCIjZmZmZmZmXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3BhcmFsbGF4X3JvdyBvcGFjaXR5PVwiOTBcIiBlbmFibGVfbW9iaWxlPVwicGFyYWxsYXgtZW5hYmxlLW1vYmlsZVwiIGltYWdlPVwiMTgzODdcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW5dW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW2hleXVzYV9oZWFkaW5nIHRhZz1cImRpdlwiIHRleHRfYWxpZ249XCJjZW50ZXJcIiBoZWFkaW5nPVwiT250ZGVrIGRlIFNpZXJyYSBOZXZhZGFcIiBmb250X3NpemU9XCI1MFwiIGxpbmVfaGVpZ2h0PVwiNTVcIiBmb250X2NvbG9yPVwiI2IzNGE0Y1wiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiT3B2YWxsZW5kZSBrZW5tZXJrZW4gU2llcnJhIE5ldmFkYVwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTo0NXx0ZXh0X2FsaWduOmNlbnRlcnxjb2xvcjolMjMwMDAwMDBcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjI1cHhcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzRcIl1bdmNfc2luZ2xlX2ltYWdlIGltYWdlPVwiMTgzODRcIiBpbWdfc2l6ZT1cImxhcmdlXCIgYWxpZ25tZW50PVwiY2VudGVyXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJHZW5lcmFsIFNoZXJtYW5cIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MjB8dGV4dF9hbGlnbjpsZWZ0fGNvbG9yOiUyMzAwMDAwMHxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1EZSBHZW5lcmFsIFNoZXJtYW4gVHJlZSBpcyBlZW4gdmFuICdzIHdlcmVsZHMgYmVrZW5kc3RlIGJvbWVuLiBEZSBzZXF1b2lhIGlzIGJlcm9lbWQgdmFud2VnZSB6aWpuIHZvbHVtZSwgaGV0IGlzIG5hbWVsaWprIHF1YSB2b2x1bWUgZGUgZ3Jvb3RzdGUgYm9vbSB0ZXIgd2VyZWxkLiBIaWogaXMgODMgbWV0ZXIgaG9vZywgaGVlZnQgZWVuIGRpYW1ldGVyIHZhbiAxMSBtZXRlciBlbiBlZW4gc3RhbXZvbHVtZSB2YW4gMTQ4NyBrdWJpZWtlIG1ldGVyLiBXYWFyc2NoaWpubGlqayBpcyBoaWogem8nbiAyMzAwLTI3MDAgamFhciBvdWQuIERlIEdlbmVyYWwgU2hlcm1hbiBUcmVlIHN0YWF0IGluIGhldCBHaWFudCBGb3Jlc3QsIGhpZXIgc3RhYW4gdmlqZiB2YW4gZGUgdGllbiBncm9vdHN0ZSBib21lbiB0ZXIgd2VyZWxkLlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvNFwiXVt2Y19zaW5nbGVfaW1hZ2UgaW1hZ2U9XCI0ODY4XCIgaW1nX3NpemU9XCJsYXJnZVwiIGFsaWdubWVudD1cImNlbnRlclwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiTGFrZSBUYWhvZVwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZToyMHx0ZXh0X2FsaWduOmxlZnR8Y29sb3I6JTIzMDAwMDAwfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XUxha2UgVGFob2UgaXMgaGV0IGdyb290c3RlIGJlcmdtZWVyIGluIE5vb3JkIEFtZXJpa2EuIEhldCB6b2V0d2F0ZXJtZWVyIGlzIGRhYXJuYWFzdCBvb2sgbm9nIGVlbnMgaGV0IG9wIGVlbiBuYSBkaWVwc3RlIG1lZXIgdmFuIGRlIFZlcmVuaWdkZSBTdGF0ZW4uIEhldCBpcyBlZW4gdmFuIGRlIG1lZXN0IHBvcHVsYWlyZSBiZXN0ZW1taW5nZW4gaW4gZGUgcmVnaW8sIHpvd2VsIGluIGRlIHpvbWVyLSBhbHMgaW4gZGUgd2ludGVybWFhbmRlbi4gSW4gZGUgem9tZXIgc3RhYW4gd2FuZGVsZW4sIHZhcmVuIGVuIHp3ZW1tZW4gY2VudHJhYWwsIGluIGRlIHdpbnRlciBrdW4gamUgcm9uZG9tIDxhIGhyZWY9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL2xha2UtdGFob2UvXCI+TGFrZSBUYWhvZTwvYT4gZGUgcGlzdGUgb3AuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS80XCJdW3ZjX3NpbmdsZV9pbWFnZSBpbWFnZT1cIjE4MzgzXCIgaW1nX3NpemU9XCJsYXJnZVwiIGFsaWdubWVudD1cImNlbnRlclwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiTW91bnQgV2hpdG5leVwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZToyMHx0ZXh0X2FsaWduOmxlZnR8Y29sb3I6JTIzMDAwMDAwfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XURlIGhvb2dzdGUgYmVyZyB2YW4gZGUgNDggYWFuZWVuZ2VzbG90ZW4gc3RhdGVuIHZpbmQgamUgaW4gZGUgU2llcnJhIE5ldmFkYS4gTW91bnQgV2hpdG5leSBpcyBtZXQgNDQyMSBtZXRlciBoZXQgaG9vZ3N0ZSBwdW50LiBEZSB3ZXN0ZWxpamtlIGhlbGxpbmcgdmFuIE1vdW50IFdoaXRuZXkgbGlndCBpbiBoZXQgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvc2VxdW9pYS1raW5ncy1jYW55b24tbmF0aW9uYWwtcGFyay9cIj5TZXF1b2lhIE5hdGlvbmFsIFBhcms8L2E+IGVuIGRlIHRvcCBiZWhvb3J0IHRvdCBkZSBKb2huIE11aXIgVHJhaWwgZGllIG5hYXIgWW9zZW1pdGUgVmFsbGV5IGxvb3B0LiBPdmVyaWdlbnMgbWFmIG9tIHRlIHdldGVuIGlzIGRhdCBNb3VudCBXaGl0bmV5IG9wIHNsZWNodHMgMTIyIGtpbG9tZXRlciB2YW4gaGV0IGxhYWdzdGUgcHVudCB2YW4gTm9vcmQgQW1lcmlrYSBsaWd0LCBCYWR3YXRlciBpbiA8YSBocmVmPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9kZWF0aC12YWxsZXktbmF0aW9uYWwtcGFyay9cIj5EZWF0aCBWYWxsZXk8L2E+LlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvNFwiXVt2Y19zaW5nbGVfaW1hZ2UgaW1hZ2U9XCIzMTk3XCIgaW1nX3NpemU9XCJsYXJnZVwiIGFsaWdubWVudD1cImNlbnRlclwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiWW9zZW1pdGUgVmFsbGV5XCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjIwfHRleHRfYWxpZ246bGVmdHxjb2xvcjolMjMwMDAwMDB8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdSW4gPGEgaHJlZj1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwveW9zZW1pdGUtbmF0aW9uYWwtcGFyay1jYWxpZm9ybmllL1wiPllvc2VtaXRlIE5hdGlvbmFsIFBhcms8L2E+IGlzIGRlIGdsYWNpZXIgdmFsbGV5IFlvc2VtaXRlIFZhbGxleSBlZW4gdmFuIGRlIGtlbm1lcmtlbiB2YW4gZGUgU2llcnJhIE5ldmFkYS4gSGllciBrd2FtIDEwMCBtaWxqb2VuIGphYXIgb3VkZSBncmFuaWV0IG5hYXIgYm92ZW4gZG9vciBlZW4gdmVyZHdlbmVuIGdsZXRzamVyLiBEZSBNZXJjZWQgUml2ZXIgaGVlZnQgZGUgcGxhYXRzIGluZ2Vub21lbiB2YW4gZGUgZ2xldHNqZXIgYWxzIHdhdGVyYWZ2b2VyLiBZb3NlbWl0ZSBWYWxsZXkgaXMgMTMga2lsb21ldGVyIGxhbmcgZW4gMTYwMCBtZXRlciBkaWVwLiBEYWFyb20gaGVlbiB6aWpuIGdyYW5pZXRlbiBiZXJndG9wcGVuIHRlIHZpbmRlbiB6b2FscyBIYWxmIERvbWUgZW4gRWwgQ2FwaXRhbi5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI3NXB4XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiB0aGJfcm93X3BhZGRpbmc9XCJ0cnVlXCIgdGhiX2NvbHVtbl9wYWRkaW5nPVwidHJ1ZVwiIGNvbnRlbnRfcGxhY2VtZW50PVwibWlkZGxlXCJdW3ZjX2NvbHVtbiB3aWR0aD1cIjEvMlwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCIxMDAlXCJdW3RoYl9pbWFnZSByZXRpbmE9XCJyZXRpbmFfc2l6ZVwiIGZ1bGxfd2lkdGg9XCJ0cnVlXCIgaW1hZ2U9XCI0ODQxXCJdWy90aGJfaW1hZ2VdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvMlwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjUvNlwiXVtoZXl1c2FfaGVhZGluZyB0YWc9XCJkaXZcIiBoZWFkaW5nPVwiT250ZGVrIGRlIEdpYW50c1wiIGZvbnRfc2l6ZT1cIjQwXCIgbGluZV9oZWlnaHQ9XCI0MFwiIGZvbnRfY29sb3I9XCIjMjgyODI4XCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJLaW5ncyBDYW55b24gJmFtcDsgU2VxdW9pYSBOYXRpb25hbCBQYXJrXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDN8Zm9udF9zaXplOjMwfHRleHRfYWxpZ246bGVmdHxjb2xvcjolMjMyODI4Mjh8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdSGV0IHR3ZWVkZSBuYXRpb25hbGUgcGFyayB2YW4gQW1lcmlrYSBpcyA8YSBocmVmPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9zZXF1b2lhLWtpbmdzLWNhbnlvbi1uYXRpb25hbC1wYXJrL1wiPlNlcXVvaWEgTmF0aW9uYWwgUGFyazwvYT4uIEhldCBwYXJrIGxpZ3QgaW4gaGV0IHp1aWRlbGlqa2UgZGVlbCB2YW4gZGUgU2llcnJhIE5ldmFkYSBlbiBzdGFhdCBiZWtlbmQgb20gZGUgc2VxdW9pYSBib21lbiwgb29rIHdlbCByZXV6ZW5ib21lbi4gU2VxdW9pYSBOYXRpb25hbCBQYXJrIGVuIEtpbmdzIENhbnlvbiBOYXRpb25hbCBQYXJrIHdvcmRlbiBkb29yIGRlIG5hdGlvbmFsZSBwYXJrIHNlcnZpY2UgYWxzIFx1MDBlOVx1MDBlOW4gcGFyayBnZXppZW4uIFNhbWVuIHppam4gemUgZWVuIHZhbiBkZSBtZWVzdCBvbmdlcmVwdGUgcGFya2VuIHZhbiBBbWVyaWthLiBIZXQgZ3Jvb3RzdGUgZGVlbCB2YW4gaGV0IHBhcmsgaXMgYWxsZWVuIHRlIHZvZXQgdGUgdmVya2VubmVuLlsvdmNfY29sdW1uX3RleHRdW3VsdF9idXR0b25zIGJ0bl90aXRsZT1cIkxFRVMgTUVFUlwiIGJ0bl9saW5rPVwidXJsOmh0dHBzJTNBJTJGJTJGd3d3LmhleXVzYS5jb20lMkZubCUyRnNlcXVvaWEta2luZ3MtY2FueW9uLW5hdGlvbmFsLXBhcmslMkZ8dGl0bGU6S2luZ3MlMjBDYW55b25cIiBidG5fc2l6ZT1cInVidG4tc21hbGxcIiBidG5fdGl0bGVfY29sb3I9XCIjZmZmZmZmXCIgYnRuX2JnX2NvbG9yPVwiI2IzNGE0Y1wiIGJ0bl9iZ19jb2xvcl9ob3Zlcj1cIiM1MzFhMjNcIiBpY29uX3NpemU9XCIzMlwiIGJ0bl9pY29uX3Bvcz1cInVidG4tc2VwLWljb24tYXQtbGVmdFwiIGJ0bl9mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBidG5fZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIGJ0bl9saW5lX2hlaWdodD1cImRlc2t0b3A6MzBweDtcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiIGZ1bGxfd2lkdGg9XCJzdHJldGNoX3Jvd1wiIGNvbnRlbnRfdGV4dF9hbGlnbWVudD1cImNlbnRlclwiIGNzcz1cIi52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O31cIiBwYXJhbGxheF9iYWNrZ3JvdW5kX2ltYWdlPVwiMzgzNlwiXVt2Y19jb2x1bW4gdGhiX2NvbG9yPVwidGhiLWxpZ2h0LWNvbHVtblwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt0aGJfcG9zdGJhY2tncm91bmQgc291cmNlPVwic2l6ZToxfHBvc3RfdHlwZTpwb3N0fGJ5X2lkOi0xNDgzMCwtMTYxOSwtNjY3LDMwMTRcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY3NzPVwiLnZjX2N1c3RvbV8xNjA2MTY4ODc1MDM4e2JhY2tncm91bmQtY29sb3I6ICNlYWVhZWEgIWltcG9ydGFudDt9XCJdW3ZjX2NvbHVtbl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiMTAwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3ZjX3NpbmdsZV9pbWFnZSBpbWFnZT1cIjMxNzhcIiBpbWdfc2l6ZT1cImxhcmdlXCIgYWxpZ25tZW50PVwiY2VudGVyXCIgc3R5bGU9XCJ2Y19ib3hfc2hhZG93XzNkXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiTGVudGUgJmFtcDsgem9tZXJcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMDAwMDAwXCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19zdHlsZT1cImZvbnQtd2VpZ2h0OjcwMDtcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDozNXB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdXHJcbjxwIHN0eWxlPVwidGV4dC1hbGlnbjogY2VudGVyO1wiPkRlIHpvbWVybWFhbmRlbiB6aWpuIGRlIHBvcHVsYWlyc3RlIG1hYW5kZW4gb20gZGUgU2llcnJhIE5ldmFkYSB0ZSBiZXpvZWtlbi4gRGUgd2VnZW4gemlqbiAodmFhaykgc25lZXV3dnJpaiwgd2FhcmRvb3IgYWxsZSBuYXR1dXJsaWprZSBiZXppZW5zd2FhcmRpZ2hlZGVuIHRlIGJlem9la2VuIHppam4uIEhldCBnZWJpZWQgc3RhYXQgaW4gYmxvZWksIGRlIHdhdGVydmFsbGVuIHppam4gaGV0IG1vb2lzdCBlbiBkZSBoaWtpbmcgdHJhaWxzIHppam4gZ29lZCBiZWdhYW5iYWFyLiBOaWV0IGFsbGVlbiBkZSBiZXN0ZSBwZXJpb2RlIG9tIGRlIFNpZXJyYSBOZXZhZGEgdGUgdmVya2VubmVuLCBvb2sgemlqbiBlciBkZSBtZWVzdGUgbWVuc2VuIGluIGhldCBnZWJpZWQuPC9wPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfc2luZ2xlX2ltYWdlIGltYWdlPVwiMTcyMTVcIiBpbWdfc2l6ZT1cImxhcmdlXCIgYWxpZ25tZW50PVwiY2VudGVyXCIgc3R5bGU9XCJ2Y19ib3hfc2hhZG93XzNkXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiV2ludGVyICZhbXA7IGhlcmZzdFwiIG1haW5faGVhZGluZ19jb2xvcj1cIiMwMDAwMDBcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX3N0eWxlPVwiZm9udC13ZWlnaHQ6NzAwO1wiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjM1cHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF1cclxuPHAgc3R5bGU9XCJ0ZXh0LWFsaWduOiBjZW50ZXI7XCI+V2FhciBoZXQgZ3Jvb3RzdGUgZGVlbCB2YW4gZGUgU2llcnJhIE5ldmFkYSBvbmJlZ2FhbmJhYXIgaXMgaW4gZGUgd2ludGVybWFhbmRlbiwgaXMgTGFrZSBUYWhvZSBqdWlzdCBlZW4gcG9wdWxhaXJlIGJlc3RlbW1pbmcgb20gdGUgYmV6b2VrZW4uIEhldCBpcyBcdTAwZTlcdTAwZTluIHZhbiBkZSBiZXN0ZSA8YSBocmVmPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9za2llbi1pbi1hbWVyaWthL1wiPndpbnRlcnNwb3J0YmVzdGVtbWluZ2VuIGluIEFtZXJpa2E8L2E+LiBEZSBtZWVzdGUgc2tpZ2ViaWVkZW4gbGlnZ2VuIGFhbiBkZSBub29yZGthbnQgdmFuIGhldCBnZWJpZWQgYmlqIFRydWNrZWUgZW4gUmVuby4gSW4gaGV0IHp1aWRlbiBpcyBIZWF2ZW5seSBNb3VudGFpbiBSZXNvcnQgZWVuIGdyb290IHNraWdlYmllZC48L3A+XHJcblsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIGNvbnRlbnRfcGxhY2VtZW50PVwibWlkZGxlXCIgZnVsbF93aWR0aD1cInN0cmV0Y2hfcm93XCIgY29udGVudF90ZXh0X2FsaWdtZW50PVwiY2VudGVyXCIgY3NzPVwiLnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fVwiIHBhcmFsbGF4X2JhY2tncm91bmRfaW1hZ2U9XCIzODM2XCJdW3ZjX2NvbHVtbiB0aGJfY29sb3I9XCJ0aGItbGlnaHQtY29sdW1uXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiS2luZ3MgQ2FueW9uIE5hdGlvbmFsIFBhcmtcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6NTV8dGV4dF9hbGlnbjpjZW50ZXJ8Y29sb3I6JTIzZmZmZmZmfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW2hleXVzYV9oZWFkaW5nIHRhZz1cImRpdlwiIHRleHRfYWxpZ249XCJjZW50ZXJcIiBoZWFkaW5nPVwiRVx1MDBlOW4gdmFuIGRlIDMgbmF0aW9uYWxlIHBhcmtlblwiIGZvbnRfc2l6ZT1cIjU1XCIgbGluZV9oZWlnaHQ9XCI2MFwiIGZvbnRfY29sb3I9XCIjZmZmZmZmXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3BhcmFsbGF4X3JvdyBlbmFibGVfbW9iaWxlPVwicGFyYWxsYXgtZW5hYmxlLW1vYmlsZVwiIGltYWdlPVwiMTgzOTZcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIGNzcz1cIi52Y19jdXN0b21fMTYwODY2Njg4NTQ5N3tiYWNrZ3JvdW5kLWltYWdlOiB1cmwoaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMC8wOC9iYWNrZ3JvdW5kLWhleXVzYS1uYXR1dXItMS5naWY/aWQ9MzA4OCkgIWltcG9ydGFudDt9XCJdW3ZjX2NvbHVtbl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJXYW5kZWxlbiBpbiBkZSBTaWVycmEgTmV2YWRhXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzAwMDAwMFwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjU1cHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF1NZXQgZWVuIG5hdHV1cmdlYmllZCB2YW4gNjQwIGtpbG9tZXRlciBsYW5nIGVuIDExMCBraWxvbWV0ZXIgemlqbiBlciBnZW5vZWcgbW9nZWxpamtoZWRlbiB0b3Qgd2FuZGVsZW4uIFpla2VyIGFscyBqZSBiZWRlbmt0IGRhdCBlciAzIG5hdGlvbmFsZSBwYXJrZW4gZW4gMjYgd2lsZGVybmlzIGdlYmllZGVuIGluIGRlIFNpZXJyYSBOZXZhZGEgbGlnZ2VuLiBVaXRkYWdlbmRlIGVuIGljb25pc2NoZSB3YW5kZWxpbmdlbiB2YW4gbWVlciBkYW4gMTAwIGtpbG9tZXRlcnMsIG1hYXIgb29rIHdhbmRlbGluZ2VuIGRpZSB2b29yIGllZGVyZWVuIGdlc2NoaWt0IHppam4uIE9udGRlayB2b29yYWwgWW9zZW1pdGUgTmF0aW9uYWwgUGFyaywgU2VxdW9pYSBlbiBLaW5ncyBOYXRpb25hbCBQYXJrIHdhbmRlbGVuZCBvbSBkZSBtb29pc3RlIG5hdHV1ciB0ZSB6aWVuLlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIkFhbnJhZGVycyBvbSB0ZSB3YW5kZWxlblwiIG1haW5faGVhZGluZ19jb2xvcj1cIiMwMDAwMDBcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpSb2JvdG8gU2xhYnxmb250X2NhbGw6Um9ib3RvK1NsYWJ8dmFyaWFudDo4MDBcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjU1cHg7XCIgbWFpbl9oZWFkaW5nX3N0eWxlPVwiZm9udC13ZWlnaHQ6ODAwO1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdXHJcbjx1bD5cclxuIFx0PGxpPkpvaG4gTXVpciBUcmFpbCB8IDMzOCBraWxvbWV0ZXI8L2xpPlxyXG4gXHQ8bGk+UGFjaWZpYyBDcmVzdCBUcmFpbCB8IDQyODYga2lsb21ldGVyPC9saT5cclxuIFx0PGxpPllvc2VtaXRlIEZhbGxzIFRyYWlsIHwgMTIga2lsb21ldGVyPC9saT5cclxuIFx0PGxpPk1vdW50IFdoaXRuZXkgVHJhaWwgfCAzMyBraWxvbWV0ZXI8L2xpPlxyXG4gXHQ8bGk+UGFub3JhbWEgVHJhaWwgfCAxMyw1IGtpbG9tZXRlcjwvbGk+XHJcbiBcdDxsaT5Ub2tvcGFoIEZhbGxzIFRyYWlsIHwgNiw1IGtpbG9tZXRlcjwvbGk+XHJcbiBcdDxsaT5CdWVuYSBWaXN0YSBQZWFrIHwgMyBraWxvbWV0ZXI8L2xpPlxyXG48L3VsPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIiBmdWxsX3dpZHRoPVwic3RyZXRjaF9yb3dcIiBjb250ZW50X3RleHRfYWxpZ21lbnQ9XCJjZW50ZXJcIiBjc3M9XCIudmNfY3VzdG9tXzE3MDM3NTI3OTcyNDh7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDtiYWNrZ3JvdW5kLWNvbG9yOiAjMDAwMDAwICFpbXBvcnRhbnQ7fVwiIHBhcmFsbGF4X2JhY2tncm91bmRfaW1hZ2U9XCIzODM2XCJdW3ZjX2NvbHVtbiB0aGJfY29sb3I9XCJ0aGItbGlnaHQtY29sdW1uXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiV2F0ZXJ2YWwgaW4gWW9zZW1pdGUgTmF0aW9uYWwgUGFya1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTo1NXx0ZXh0X2FsaWduOmNlbnRlcnxjb2xvcjolMjNmZmZmZmZ8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1baGV5dXNhX2hlYWRpbmcgdGFnPVwiZGl2XCIgdGV4dF9hbGlnbj1cImNlbnRlclwiIGhlYWRpbmc9XCJPbnRkZWsgZGUgd2F0ZXJ2YWxsZW4gaW4gZGUgU2llcnJhIE5ldmFkYVwiIGZvbnRfc2l6ZT1cIjU1XCIgbGluZV9oZWlnaHQ9XCI2MFwiIGZvbnRfY29sb3I9XCIjZmZmZmZmXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3BhcmFsbGF4X3JvdyBvcGFjaXR5PVwiOTBcIiBlbmFibGVfbW9iaWxlPVwicGFyYWxsYXgtZW5hYmxlLW1vYmlsZVwiIGltYWdlPVwiMTgzOTdcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIGNzcz1cIi52Y19jdXN0b21fMTYwODY2Njg4NTQ5N3tiYWNrZ3JvdW5kLWltYWdlOiB1cmwoaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMC8wOC9iYWNrZ3JvdW5kLWhleXVzYS1uYXR1dXItMS5naWY/aWQ9MzA4OCkgIWltcG9ydGFudDt9XCJdW3ZjX2NvbHVtbl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJSb2FkdHJpcHBlbiBpbiBkZSBTaWVycmEgTmV2YWRhXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzAwMDAwMFwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjU1cHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF1OYWFzdCB3YW5kZWxtb2dlbGlqa2hlZGVuLCB6aWpuIGVyIG9vayBnZW5vZWcgbW9vaWUgcm91dGVzIG9tIG1ldCBkZSBhdXRvIG9mIGNhbXBlciB0ZSByaWpkZW4gaW4gZGUgU2llcnJhIE5ldmFkYS4gRGUgYmVyZ2VuIHZhbiBkZSBTaWVycmEgTmV2YWRhIGhlYmJlbiBhbCBsYW5nIGFhbnRyZWtraW5nc2tyYWNodCBvcCBtZW5zZW4gdmFuIG92ZXIgZGUgaGVsZSB3ZXJlbGQuIFRlbCBkYWFyYmlqIG9wIGRlIHByYWNodGlnZSBibGF1d2UgbWVyZW4sIGRlIGVub3JtZSB3YXRlcnZhbGxlbiBlbiB2ZXJnZXppY2h0ZW4gb20gYmlqIHdlZyB0ZSBkcm9tZW4sIGRpdCBpcyB3YWFyb20gZGl0IGRlZWwgdmFuIENhbGlmb3JuaVx1MDBlYiBwb3B1bGFpciBpcyBvbSB0ZSBiZXpvZWtlbi5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJEZSBtb29pc3RlIHJvdXRlcyBpbiBkZSBTaWVycmEgTmV2YWRhXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzAwMDAwMFwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjU1cHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF1cclxuPHVsPlxyXG4gXHQ8bGk+SGlnaHdheSAzOTU8L2xpPlxyXG4gXHQ8bGk+U2llcnJhIFZpc3RhIFNjZW5pYyBCeXdheTwvbGk+XHJcbiBcdDxsaT5UaW9nYSBSb2FkPC9saT5cclxuIFx0PGxpPkdvbGQgQ291bnRyeSBSb3V0ZTwvbGk+XHJcbiBcdDxsaT5FYmJldHQncyBQYXNzPC9saT5cclxuIFx0PGxpPk1vbml0b3IgUGFzczwvbGk+XHJcbiBcdDxsaT5FY2hvIFN1bW1pdDwvbGk+XHJcbiBcdDxsaT5DYXJzb24gUGFzczwvbGk+XHJcbjwvdWw+XHJcblsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdGhiX3Bvc3RiYWNrZ3JvdW5kIHNvdXJjZT1cInBvc3RfdHlwZTpwb3N0fGJ5X2lkOjcyNTRcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW5dW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd10iLCJwb3N0X3RpdGxlIjoiU2llcnJhIE5ldmFkYSBpbiBDYWxpZm9ybmlcdTAwZWIiLCJwb3N0X2xpbmsiOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3NpZXJyYS1uZXZhZGEtY2FsaWZvcm5pZS8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJTaWVycmEgTmV2YWRhIGluIENhbGlmb3JuaVx1MDBlYlwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMy8xMi9zaWVycmEtbmV2YWRhLTMwMHgyMDAuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+IiwicG9zdF9jYXRlZ29yaWVzIjoiTmF0dXVyZ2ViaWVkZW4iLCJwb3N0X3RhZ3MiOiJDYWxpZm9ybmlcdTAwZWIiLCIlX3dwYl9zaG9ydGNvZGVzX2N1c3RvbV9jc3MlIjoiLnZjX2N1c3RvbV8xNzAzNjc0ODA3MDA3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTcwMzc1MjUzOTk5NXtwYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O2JhY2tncm91bmQtY29sb3I6ICMwMDAwMDAgIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTYwNjE2ODg3NTAzOHtiYWNrZ3JvdW5kLWNvbG9yOiAjZWFlYWVhICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE2MDg2NjY4ODU0OTd7YmFja2dyb3VuZC1pbWFnZTogdXJsKGh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjAvMDgvYmFja2dyb3VuZC1oZXl1c2EtbmF0dXVyLTEuZ2lmP2lkPTMwODgpICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTcwMzc1Mjc5NzI0OHtwYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O2JhY2tncm91bmQtY29sb3I6ICMwMDAwMDAgIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNjA4NjY2ODg1NDk3e2JhY2tncm91bmQtaW1hZ2U6IHVybChodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIwLzA4L2JhY2tncm91bmQtaGV5dXNhLW5hdHV1ci0xLmdpZj9pZD0zMDg4KSAhaW1wb3J0YW50O30iLCIlaW5saW5lX2ZlYXR1cmVkX2ltYWdlJSI6IjAiLCIlX2VkaXRfbGFzdCUiOiIxIiwiJV9lZGl0X2xvY2slIjoiMTcwNzIyOTEyNDoxIiwiJV93cGJfdmNfanNfc3RhdHVzJSI6InRydWUiLCIlcG9zdC1wcmltYXJ5LWNhdGVnb3J5JSI6IjIyNyIsIiVmZWF0dXJlZF9pbWFnZV9vdmVycmlkZSUiOiJvZmYiLCIlYXJ0aWNsZV9zdHlsZV9vdmVycmlkZSUiOiJvbiIsIiVwb3N0X3N0eWxlJSI6InN0eWxlNSIsIiVwb3N0X2dhbGxlcnlfc3R5bGUlIjoibGlnaHRib3giLCIlcG9zdF9yZXZpZXclIjoib2ZmIiwiJXBvc3RfcmV2aWV3X3N0eWxlJSI6InN0eWxlMSIsIiVwb3N0X3Jldmlld19hdmVyYWdlJSI6IjUwIiwiJXN0YW5kYXJkLWZlYXR1cmVkLWNyZWRpdCUiOiIiLCIlX2hpZGVfZmVhdHVyZWQlIjpudWxsLCIlcG9zdF9zb3VyY2UlIjoiIiwiJV90aHVtYm5haWxfaWQlIjoiMTgzODgiLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza3clIjoiU2llcnJhIE5ldmFkYSBDYWxpZm9ybmlcdTAwZWIiLCIlX3lvYXN0X3dwc2VvX21ldGFkZXNjJSI6IkRlIFNpZXJyYSBOZXZhZGEgaXMgZWVuIGVub3JtIG5hdHV1cmdlYmllZCBpbiBkZSBzdGFhdCBDYWxpZm9ybmlcdTAwZWIuIEJlbmlldXdkIHdhdCBqZSBrdW50IGRvZW4gaW4gZGUgU2llcnJhIE5ldmFkYSBpbiBDYWxpZm9ybmlcdTAwZWI/IiwiJV95b2FzdF93cHNlb19saW5rZGV4JSI6IjgwIiwiJV95b2FzdF93cHNlb19jb250ZW50X3Njb3JlJSI6IjYwIiwiJV95b2FzdF93cHNlb19mb2N1c2tleXdvcmRzJSI6IltdIiwiJV95b2FzdF93cHNlb19rZXl3b3Jkc3lub255bXMlIjoiW1wiU2llcnJhIE5ldmFkYVwiXSIsIiVfd3BnbXBfbG9jYXRpb25fYWRkcmVzcyUiOiJMYWtlIFBsYWNpZCwgTmV3IFlvcmsgMTI5NDYsIFZlcmVuaWdkZSBTdGF0ZW4iLCIlX3dwZ21wX2xvY2F0aW9uX2NpdHklIjoiTm9ydGggRWxiYSIsIiVfd3BnbXBfbG9jYXRpb25fc3RhdGUlIjoiTmV3IFlvcmsiLCIlX3dwZ21wX2xvY2F0aW9uX2NvdW50cnklIjoiVmVyZW5pZ2RlIFN0YXRlbiIsIiVfd3BnbXBfbWV0YWJveF9sYXRpdHVkZSUiOiI0NC4yNzk0OTExIiwiJV93cGdtcF9tZXRhYm94X2xvbmdpdHVkZSUiOiItNzMuOTc5ODcxMyIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiN1wiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6ImE6MTp7aTowO3M6MTpcIjdcIjt9IiwiJV93cGdtcF9tZXRhYm94X3RheG9tb21pZXNfdGVybXMlIjoiIiwiJV93cGdtcF9leHRlbnNpb25zX2ZpZWxkcyUiOiIiLCIlX3lvYXN0X3dwc2VvX2VzdGltYXRlZC1yZWFkaW5nLXRpbWUtbWludXRlcyUiOiI3IiwiJV95b2FzdF93cHNlb19wcmltYXJ5X2NhdGVnb3J5JSI6IjIyNyIsIiVfd3dzX3N1cHBvcnRfY29udGFjdF9udW1iZXIlIjoiIiwiJV93d3NfYWJvdXRfc3VwcG9ydF90ZXh0JSI6IiIsIiVfd3dzX3RyaWdnZXJfYnV0dG9uX3RleHQlIjoiIiwiJV93d3NfcHJlZGVmaW5lZF90ZXh0JSI6IiIsIiVfeW9hc3RfaW5kZXhub3dfbGFzdF9waW5nJSI6IjE3MDcyMjI5MjkiLCIlX3lvYXN0X3dwc2VvX3dvcmRwcm9vZl90aW1lc3RhbXAlIjoiIiwiJV9sYXN0X2VkaXRvcl91c2VkX2pldHBhY2slIjoiY2xhc3NpYy1lZGl0b3IiLCIlX3dwX29sZF9kYXRlJSI6IjIwMjMtMTItMjciLCIlX3lvYXN0X3dwc2VvX29wZW5ncmFwaC1kZXNjcmlwdGlvbiUiOiJEZSBTaWVycmEgTmV2YWRhIGlzIGVlbiBlbm9ybSBuYXR1dXJnZWJpZWQgaW4gZGUgc3RhYXQgQ2FsaWZvcm5pXHUwMGViLiBCZW5pZXV3ZCB3YXQgamUga3VudCBkb2VuIGluIGRlIFNpZXJyYSBOZXZhZGEgaW4gQ2FsaWZvcm5pXHUwMGViPyIsIiVhY3RpdmVlcl9zdWJtZW51JSI6IjAiLCIlX2FjdGl2ZWVyX3N1Ym1lbnUlIjoiZmllbGRfNjU5M2Y1MjFlOTdjMiIsInRheG9ub215PWNhdGVnb3J5IjoiTmF0dXVyZ2ViaWVkZW4iLCJ0YXhvbm9teT1wb3N0X3RhZyI6IkNhbGlmb3JuaVx1MDBlYiIsInRheG9ub215PXBvc3RfZm9ybWF0IjoiIiwidGF4b25vbXk9dGhiLXJlYWN0aW9ucyI6IiIsInRheG9ub215PXRoYi1zcG9uc29ycyI6IiJ9LCJpY29uIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMS8wNC9wYXJrZW4ucG5nIn0sImlkIjoxODM4MSwiaW5mb3dpbmRvd19kaXNhYmxlIjpmYWxzZSwiY2F0ZWdvcmllcyI6W3siaWNvbiI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjEvMDQvcGFya2VuLnBuZyIsIm5hbWUiOiJOYXRpb25hbGUgUGFya2VuIiwiaWQiOiI3IiwidHlwZSI6ImNhdGVnb3J5IiwiZXh0ZW5zaW9uX2ZpZWxkcyI6eyJjYXRfb3JkZXIiOiIifX1dfSx7InNvdXJjZSI6InBvc3QiLCJ0aXRsZSI6IldhbHZpc3NlbiBraWprZW4gaW4gQ2FsaWZvcm5pXHUwMGViIiwiaW5mb3dpbmRvd19jb250ZW50IjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZyBcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiV2Fsdmlzc2VuIGtpamtlbiBpbiBDYWxpZm9ybmlcdTAwZWJcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjIwMFwiIHNyYz1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjMvMTIvd2FsdmlzLWNhbGlmb3JuaWUtMzAweDIwMC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmcgZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+V2Fsdmlzc2VuIGtpamtlbiBpbiBDYWxpZm9ybmlcdTAwZWI8L2Rpdj5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tY29udGVudCBmYy1pdGVtLWJvZHktdGV4dC1jb2xvclwiPnttYXJrZXJfYWRkcmVzc308L2Rpdj5cclxuICAgICAgICA8L2Rpdj5cclxuICAgIDwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWNsZWFyXCI+PC9kaXY+XHJcbjwvZGl2PiIsImFkZHJlc3MiOiJTYW5pYmVsIElzbGFuZCwgRmxvcmlkYSwgVmVyZW5pZ2RlIFN0YXRlbiIsImxvY2F0aW9uIjp7ImxhdCI6IjI2LjQ0MzM5NzIiLCJzdGF0ZSI6IkZsb3JpZGEiLCJjb3VudHJ5IjoiVmVyZW5pZ2RlIFN0YXRlbiIsImxuZyI6Ii04Mi4xMTE1MTE5Iiwib25jbGlja19hY3Rpb24iOiJtYXJrZXIiLCJyZWRpcmVjdF9wZXJtYWxpbmsiOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dhbHZpc3Nlbi1jYWxpZm9ybmllLyIsInpvb20iOjEyLCJleHRyYV9maWVsZHMiOnsicG9zdF9leGNlcnB0IjoiIiwicG9zdF9jb250ZW50IjoiW3ZjX3Jvd11bdmNfY29sdW1uXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjE1cHhcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJXYWx2aXNzZW4ga2lqa2VuIGluIENhbGlmb3JuaVx1MDBlYlwiIG1haW5faGVhZGluZ19jb2xvcj1cIiMyODI4MjhcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6NDVweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjMwcHg7XCIgbWFyZ2luX2Rlc2lnbl90YWJfdGV4dD1cIlwiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMTVweFwiXVt2Y19jb2x1bW5fdGV4dF1cclxuPHAgc3R5bGU9XCJ0ZXh0LWFsaWduOiBjZW50ZXI7XCI+PHN0cm9uZz5FZW4gdmFuIGRlIGhvb2d0ZXB1bnRlbiB2YW4gZGUgc3RhYXQgQ2FsaWZvcm5pXHUwMGViIGlzIGhldCBiZWtpamtlbiB2YW4gd2Fsdmlzc2VuIGRpZSBpbiBncm90ZSBhYW50YWxsZW4gdm9vciBkZSBrdXN0IHZhbiBkZSBzdGFhdCB2b29ya29tZW4uIE1lZXIgZGFuIDIwLjAwMCBncmlqemUgd2Fsdmlzc2VuIHp3ZW1tZW4gaW4gZGUgd2F0ZXJlbiB2YW4gQ2FsaWZvcm5pXHUwMGViLiBTb21zIGhlYiBqZSBnZWx1ayBlbiBrdW4gamUgemUgdmFuYWYgZGUga3VzdCBhbCB6aWVuLCBzb21zIGhldCBpcyBoYW5kaWdlciBvbSBlZW4gZXhjdXJzaWUgdGUgYm9la2VuLiBFZW4gdmFuIGRlIGRlIGdyb3RlIHZvb3JkZWxlbiB2YW4gd2Fsdmlzc2VuIHNwb3R0ZW4gaW4gQ2FsaWZvcm5pXHUwMGViLCBpcyBkYXQgamUgaGV0IGhlbGUgamFhciBkb29yIGRlIGthbnMgaGVidCBvbSB6ZSB0ZSB6aWVuLlxyXG48L3N0cm9uZz48L3A+XHJcblsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyBjc3M9XCIudmNfY3VzdG9tXzE0NzIzMDc1MDIyOTB7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDtwYWRkaW5nLWJvdHRvbTogMjVweCAhaW1wb3J0YW50O31cIl1bdmNfY29sdW1uXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMjVweFwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIyNXB4XCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiRGUgYmVzdGUgbG9jYXRpZXMgb20gd2Fsdmlzc2VuIHRlIGtpamtlbiBpbiBDYWxpZm9ybmlcdTAwZWJcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjYjM0YTRjXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6NTVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDo2MHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMjVweFwiXVt2Y19jb2x1bW5fdGV4dF1cclxuPHAgc3R5bGU9XCJ0ZXh0LWFsaWduOiBjZW50ZXI7XCI+RGUgbWlncmF0aWUgdmFuIGRlIGdyaWp6ZSB3YWx2aXNzZW4gdmFuIEFsYXNrYSBuYWFyIEJhamEgQ2FsaWZvcm5pXHUwMGViIHpvcmd0IGVydm9vciBkYXQgZGUgc3RhYXQgZWVuIGdld2lsZGUgcGxlayBpcyBvbSB3YWx2aXNzZW4gdGUgemllbi4gT3AgdmVyc2NoaWxsZW5kZSBwbGVra2VuIGluIGRlIHN0YWF0IGlzIGhldCBtb2dlbGlqayBvbSB6ZWVkaWVyZW4gdGUgc3BvdHRlbi4gSW4gaGV0IG5vb3JkZW4gaXMgTW9udGVyZXkgZWVuIGdvZWRlIGxvY2F0aWUsIGRlIG92ZXJpZ2UgcGxla2tlbiBiZXZpbmRlbiB6aWNoIG1lZXIgaW4gaGV0IHp1aWRlbiB2YW4gQ2FsaWZvcm5pXHUwMGViLiBPbnplIHRpcHMgdm9vciBkZSBiZXN0ZSBsb2NhdGllcyBvbSB3YWx2aXNzZW4gdGUgemllbiBpbiBDYWxpZm9ybmlcdTAwZWIuPC9wPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIyNXB4XCJdW3ZjX3Jvd19pbm5lciBjc3M9XCIudmNfY3VzdG9tXzE1ODI5NzA3MDQ5MDN7cGFkZGluZy10b3A6IDEwcHggIWltcG9ydGFudDtwYWRkaW5nLXJpZ2h0OiAxMHB4ICFpbXBvcnRhbnQ7cGFkZGluZy1ib3R0b206IDEwcHggIWltcG9ydGFudDtwYWRkaW5nLWxlZnQ6IDEwcHggIWltcG9ydGFudDt9XCJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvNVwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIk1vbnRlcmV5IEJheVwiIGhlYWRpbmdfdGFnPVwiaDNcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMjgyODI4XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozMHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdXHJcbjxwIHN0eWxlPVwidGV4dC1hbGlnbjogY2VudGVyO1wiPkVlbiB2YW4gZGUgYmVzdGUgcGxla2tlbiBpbiBDYWxpZm9ybmlcdTAwZWIgb20gd2Fsdmlzc2VuIHRlIGtpamtlbiBpcyBNb250ZXJleSBCYXkuIEplIHZpbmR0IGhpZXIgdm9vciBkZSBrdXN0IGVlbiBhbmRlcmhhbGYga2lsb21ldGVyIGRpZXBlIG9uZGVyemVlc2Uga2xvb2Ygd2FhcmRvb3Igd2Fsdmlzc2VuIGVuIHplZXpvb2dkaWVyZW4gZ3JhYWcgaGllciBrb21lbi4gSmUga3VudCB6ZWxmcyBtZXQgZWVuIGJlZXRqZSBnZWx1ayBkZSB3YWx2aXNzZW4gbGFuZ3MgZGUga3VzdCB2YW4gZGUgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvYmlnLXN1ci9cIj5CaWcgU3VyPC9hPiBhbCB6aWVuLiBNb2NodCBqZSBkaWNodGVyYmlqIHdpbGxlbiBrb21lbiwgZGFuIHppam4gZXIgdmVyc2NoaWxsZW5kZSBtb2dlbGlqa2hlZGVuIHZvb3IgZXhjdXJzaWVzIG9wIGhldCB3YXRlci4gQm9layBlZW4gPGEgaHJlZj1cImh0dHBzOi8vd3d3LmdldHlvdXJndWlkZS5ubC9tb250ZXJleS1sNTQ4L21vbnRlcmV5LWJheS1leGN1cnNpZS13YWx2aXMtc3BvdHRlbi10MjQ2NTA3Lz9wYXJ0bmVyX2lkPURNRDJWTDQmYW1wO3V0bV9tZWRpdW09b25saW5lX3B1Ymxpc2hlciZhbXA7Y21wPXdhbHZpc3Nlbm1vbnRlcmV5XCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj52aWVyIHV1ciBkdXJlbmRlIGV4Y3Vyc2llPC9hPiBvbSBkZXplIG1hY2h0aWdlIGJlZXN0ZW4gdmFuIGRpY2h0YmlqIHRlIHppZW4uPC9wPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzVcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJOZXdwb3J0IEJlYWNoXCIgaGVhZGluZ190YWc9XCJoM1wiIG1haW5faGVhZGluZ19jb2xvcj1cIiMyODI4MjhcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjMwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF1cclxuPHAgc3R5bGU9XCJ0ZXh0LWFsaWduOiBjZW50ZXI7XCI+SW4gZGUgYnV1cnQgdmFuIExvcyBBbmdlbGVzIGlzIE5ld3BvcnQgQmVhY2ggZGUgYmVzdGUgcGxlayBvbSB3YWx2aXNzZW4gdGUga2lqa2VuLiBJbiBkZSB6b21lciBlbiBoZXJmc3QgaGViIGplIGthbnMgb3AgYmxhdXdlIHZpbnZpc3NlbiBlbiBpbiBkZSB3aW50ZXIgb3AgZ3JpanplIHdhbHZpc3Nlbi4gQW5kZXJlIHNvb3J0ZW4gZGllIGplIG5vZyB0ZWdlbiBrdW50IGtvbWVuIHppam4gZHdlcmd2aW52aXNzZW4sIGJ1bHRydWdnZW4sIHZlbGUgc29vcnRlbiBkb2xmaWpuZW4gZW4gemVlaG9uZGVuLiBIb2V3ZWwgZGUgd2Fsdmlzc2VuIHNvbXMgb3AgZW5rZWxlIGhvbmRlcmRlbiBtZXRlcnMgdmFuIGRlIGt1c3Qga29tZW4sIGt1biBqZSBkZSB3YWx2aXNzZW4gaGV0IGJlc3RlIHppZW4gPGEgaHJlZj1cImh0dHBzOi8vd3d3LmdldHlvdXJndWlkZS5ubC9uZXdwb3J0LWJlYWNoLWw5NTM2Ni9uZXdwb3J0LWJlYWNoLWNydWlzZS1vbS13YWx2aXNzZW4tZW4tZG9sZmlqbmVuLXRlLXNwb3R0ZW4tdDI5MTYxLz9wYXJ0bmVyX2lkPURNRDJWTDQmYW1wO3V0bV9tZWRpdW09b25saW5lX3B1Ymxpc2hlciZhbXA7Y21wPXdhbHZpc3Nlbm5ld3BvcnRcIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPnRpamRlbnMgZWVuIHRvdXI8L2E+LjwvcD5cclxuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS81XCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiU2FuIERpZWdvXCIgaGVhZGluZ190YWc9XCJoM1wiIG1haW5faGVhZGluZ19jb2xvcj1cIiMyODI4MjhcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjMwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF1cclxuPHAgc3R5bGU9XCJ0ZXh0LWFsaWduOiBjZW50ZXI7XCI+U2FuIERpZWdvIGlzIGRlIHBsZWsgd2FhciBqZSBoZXQgaGVsZSBqYWFyIGRvb3Igd2Fsdmlzc2VuIGt1bnQgemllbi4gTmV0IGFscyBpbiBOZXdwb3J0IHppam4gZGUgem9tZXIgZW4gaGVyZnN0IHZvb3IgZGUgYmxhdXdlIHZpbnZpc3NlbiwgZGUgd2ludGVyIGVuIGxlbnRlIHZvb3IgZGUgZ3JpanplIHdhbHZpc3NlbiBkZSBiZXN0ZSBwZXJpb2RlLiBEZSBncmlqemUgd2Fsdmlzc2VuIG1pZ3JlcmVuIGluIGRlIHdpbnRlciBlbiBsZW50ZSB2YW4gQWxhc2thIG5hYXIgZGUgbGFndW5lcyB2YW4gQ2FsaWZvcm5pXHUwMGViIG9tIHRlIGthbHZlbi4gTmFhc3Qgd2Fsdmlzc2VuIHppam4gZXIgb29rIHZlcnNjaGlsbGVuZGUgZG9sZmlqbmVuc29vcnRlbiBkaWUgemljaCBpbiBkZSB3YXRlcmVuIHJvbmRvbSBTYW4gRGllZ28gb3Bob3VkZW4uIE1ldCA8YSBocmVmPVwiaHR0cHM6Ly93d3cuZ2V0eW91cmd1aWRlLm5sL3Nhbi1kaWVnby1sMjYzL3Nhbi1kaWVnby13YWx2aXNzZW4tZW4tZG9sZmlqbmVuLXNwb3R0ZW4tdDY2MzUvP3BhcnRuZXJfaWQ9RE1EMlZMNCZhbXA7dXRtX21lZGl1bT1vbmxpbmVfcHVibGlzaGVyJmFtcDtjbXA9d2Fsdmlzc2Vuc2FuZGllZ29cIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPmVlbiBleGN1cnNpZTwvYT4gaGViIGplIG5pZXQgYWxsZWVuIGRlIGJlc3RlIGthbnMgb20gZGUgd2Fsdmlzc2VuIGVuIGRvbGZpam5lbiB0ZSBzcG90dGVuLCBtYWFyIGtvbSBqZSBvbmRlcnR1c3NlbiBvb2sgbWVlciB0ZSB3ZXRlbiBvdmVyIGRlIHplZWRpZXJlbiBlbiBoZXQgbWlsaWV1YmVsZWlkLjwvcD5cclxuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS81XCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiU2FudGEgQmFyYmFyYVwiIGhlYWRpbmdfdGFnPVwiaDNcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMjgyODI4XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozMHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdXHJcbjxwIHN0eWxlPVwidGV4dC1hbGlnbjogY2VudGVyO1wiPlN0YXAgaW4gU2FudGEgQmFyYmFyYSA8YSBocmVmPVwiaHR0cHM6Ly93d3cuZ2V0eW91cmd1aWRlLm5sL3NhbnRhLWJhcmJhcmEtbDM5My9zYW50YS1iYXJiYXJhLWNhdGFtYXJhbmNydWlzZS13YWx2aXNzZW4tc3BvdHRlbi1tZXQtYmFyLXQ0MTI2NjYvP3BhcnRuZXJfaWQ9RE1EMlZMNCZhbXA7dXRtX21lZGl1bT1vbmxpbmVfcHVibGlzaGVyJmFtcDtjbXA9d2Fsdmlzc2Vuc2FudGFiYXJiYXJhXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5hYW4gYm9vcmQgdmFuIGVlbiBjYXRhbWFyYW48L2E+IG9tIG9wIGVlbiBpbnRpZW1lIG1hbmllciBlZW4gd2FsdmlzIHNwb3QgZXJ2YXJpbmcgdGUgaGViYmVuLiBJbiBkZSB3aW50ZXIgemlqbiBkZSB3YXRlcmVuIHZhbiBTYW50YSBCYXJiYXJhIGRlIHRodWlzYmFzaXMgdmFuIG1lZXIgZGFuIDMwIHNvb3J0ZW4gd2Fsdmlzc2VuIGVuIGRvbGZpam5lbi4gVmVlbCB2b29ya29tZW5kIHppam4gUGFjaWZpc2NoZSBncmlqemUgd2Fsdmlzc2VuLCBnZXdvbmUgZG9sZmlqbmVuLCBDYWxpZm9ybmlzY2hlIHplZWxlZXV3ZW4gZW4gZ2V3b25lIHplZWhvbmRlbi4gTW9jaHQgamUgZ2VsdWsgaGViYmVuLCBkYW4ga3VuIGplIG9vayBub2cgb3JrYSdzLCBibGF1d2Ugdmludmlzc2VuLCBidWx0cnVnZ2VuIGVuIGdyaWVuZGVuIHppZW4gendlbW1lbi48L3A+XHJcblsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvNVwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIkRhbmEgUG9pbnRcIiBoZWFkaW5nX3RhZz1cImgzXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzI4MjgyOFwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6MzBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XVxyXG48cCBzdHlsZT1cInRleHQtYWxpZ246IGNlbnRlcjtcIj5EYW5hIFBvaW50IGlzIGhldCAnd2hhbGUgd2F0Y2hpbmcnIG1la2thIHZhbiBkZSB3ZXJlbGQuIEplIHZpbmR0IGhpZXIgbWVlciBkb2xmaWpuZW4gcGVyIHZpZXJrYW50ZSBtZXRlciBkYW4gd2FhciBkYW4gb29rIGluIGRlIHdlcmVsZCBlbiBqZSBrdW50IGVyIGhldCBoZWxlIGphYXIgZG9vciBibGF1d2Ugdmludmlzc2VuLCBnZXdvbmUgdmludmlzc2VuLCBncmlqemUgd2Fsdmlzc2VuLCBidWx0cnVnZ2VuIGVuIGR3ZXJndmludmlzc2VuIHZpbmRlbi4gRGFhcm5hYXN0IGhlYiBqZSBrYW5zIG9tIGFmIGVuIHRvZSBkZSB6ZWxkemFtZSBvcmthJ3MsIGdyaWVuZGVuLCBwb3R2aXNzZW4gZW4gYnJ1aW52aXNzZW4gdGUgemllbi4gQmlqIERhbmEgUG9pbnQgaGViIGplIGRlIGthbnMgb20gaGV0IGdyb290c3RlIGRpZXIgdGUgYmVraWprZW4gZGF0IG9vaXQgb3AgYWFyZGUgaGVlZnQgZ2VsZWVmZDogZGUgYmxhdXdlIHZpbnZpcy4gV2Fsdmlzc2VuIGtpamtlbiBiaWogRGFuYSBQb2ludCBrYW4gaGV0IGhlbGUgamFhciBkb29yLiBHYSBtZWUgbWV0IGVlbjxhIGhyZWY9XCJodHRwczovL3d3dy5nZXR5b3VyZ3VpZGUubmwvc2FudGEtYmFyYmFyYS1sMzkzL3NhbnRhLWJhcmJhcmEtY2F0YW1hcmFuY3J1aXNlLXdhbHZpc3Nlbi1zcG90dGVuLW1ldC1iYXItdDQxMjY2Ni8/cGFydG5lcl9pZD1ETUQyVkw0JmFtcDt1dG1fbWVkaXVtPW9ubGluZV9wdWJsaXNoZXImYW1wO2NtcD13YWx2aXNzZW5kYW5hXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj4gZXhjdXJzaWUgb3AgZWVuIGNhdGFtYXJhbmJvb3QgbWV0IGVlbiBvbmRlcndhdGVycG9kPC9hPiwgd2FhcmRvb3IgamUgZGUgZG9sZmlqbmVuIGVuIHdhbHZpc3NlbiBrdW50IHppZW4gendlbW1lbiBvbmRlciB3YXRlci48L3A+XHJcblsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjI1cHhcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIGNvbnRlbnRfcGxhY2VtZW50PVwibWlkZGxlXCIgZnVsbF93aWR0aD1cInN0cmV0Y2hfcm93XCIgY29udGVudF90ZXh0X2FsaWdtZW50PVwiY2VudGVyXCIgY3NzPVwiLnZjX2N1c3RvbV8xNTg3NjU5Mjk5MDcxe3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7YmFja2dyb3VuZC1jb2xvcjogIzAwMDAwMCAhaW1wb3J0YW50O31cIiBwYXJhbGxheF9iYWNrZ3JvdW5kX2ltYWdlPVwiMzgzNlwiXVt2Y19jb2x1bW4gdGhiX2NvbG9yPVwidGhiLWxpZ2h0LWNvbHVtblwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJXYWx2aXNzZW4ga2lqa2VuIGluIENhbGlmb3JuaVx1MDBlYlwiIGhlYWRpbmdfdGFnPVwicFwiIG1haW5faGVhZGluZ19jb2xvcj1cIiNmZmZmZmZcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDo2NXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjcwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVtoZXl1c2FfaGVhZGluZyB0YWc9XCJkaXZcIiB0ZXh0X2FsaWduPVwiY2VudGVyXCIgaGVhZGluZz1cIkhvZXZlZWwgc29vcnRlbiBrdW4gamlqIGFmc3RyZXBlbj9cIiBmb250X3NpemU9XCI1MFwiIGxpbmVfaGVpZ2h0PVwiNTBcIiBmb250X2NvbG9yPVwiI2ZmZmZmZlwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVtwYXJhbGxheF9yb3cgb3BhY2l0eT1cIjg1XCIgZW5hYmxlX21vYmlsZT1cInBhcmFsbGF4LWVuYWJsZS1tb2JpbGVcIiBpbWFnZT1cIjE4MzE4XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiTWVlciBDYWxpZm9ybmlcdTAwZWJcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMjgyODI4XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6NDVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDo1MHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVtmdWxsd2lkdGhfcm93XVt0aGJfcG9zdGdyaWQgY29sdW1ucz1cIjRcIiBzb3VyY2U9XCJwb3N0X3R5cGU6cG9zdHxieV9pZDotMTY1MDcsLTE2NDAwLC0xNjM0MiwtMTYxNzQsLTE1MzU1LC0xNTE2MywtNDcyNSwtMTU1OSw5OTQyLDE4MTQ4LDk5NjEsMTgyNzhcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd10iLCJwb3N0X3RpdGxlIjoiV2Fsdmlzc2VuIGtpamtlbiBpbiBDYWxpZm9ybmlcdTAwZWIiLCJwb3N0X2xpbmsiOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dhbHZpc3Nlbi1jYWxpZm9ybmllLyIsInBvc3RfZmVhdHVyZWRfaW1hZ2UiOiI8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIldhbHZpc3NlbiBraWprZW4gaW4gQ2FsaWZvcm5pXHUwMGViXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMDBcIiBzcmM9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIzLzEyL3dhbHZpcy1jYWxpZm9ybmllLTMwMHgyMDAuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+IiwicG9zdF9jYXRlZ29yaWVzIjoiQXZvbnR1dXIiLCJwb3N0X3RhZ3MiOiJDYWxpZm9ybmlcdTAwZWIiLCIlX3dwYl9zaG9ydGNvZGVzX2N1c3RvbV9jc3MlIjoiLnZjX2N1c3RvbV8xNDcyMzA3NTAyMjkwe3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7cGFkZGluZy1ib3R0b206IDI1cHggIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNTg3NjU5Mjk5MDcxe3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7YmFja2dyb3VuZC1jb2xvcjogIzAwMDAwMCAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE1ODI5NzA3MDQ5MDN7cGFkZGluZy10b3A6IDEwcHggIWltcG9ydGFudDtwYWRkaW5nLXJpZ2h0OiAxMHB4ICFpbXBvcnRhbnQ7cGFkZGluZy1ib3R0b206IDEwcHggIWltcG9ydGFudDtwYWRkaW5nLWxlZnQ6IDEwcHggIWltcG9ydGFudDt9IiwiJV9lZGl0X2xvY2slIjoiMTcwMjY0MzU5NzoyIiwiJV9lZGl0X2xhc3QlIjoiMiIsIiVfd3BiX3ZjX2pzX3N0YXR1cyUiOiJ0cnVlIiwiJXBvc3QtcHJpbWFyeS1jYXRlZ29yeSUiOiI2NyIsIiVmZWF0dXJlZF9pbWFnZV9vdmVycmlkZSUiOiJvZmYiLCIlYXJ0aWNsZV9zdHlsZV9vdmVycmlkZSUiOiJvbiIsIiVwb3N0X3N0eWxlJSI6InN0eWxlNSIsIiVwb3N0X2dhbGxlcnlfc3R5bGUlIjoibGlnaHRib3giLCIlcG9zdF9yZXZpZXclIjoib2ZmIiwiJXBvc3RfcmV2aWV3X3N0eWxlJSI6InN0eWxlMSIsIiVwb3N0X3Jldmlld19hdmVyYWdlJSI6IjUwIiwiJXRoYl9hbGxfY291bnRzJSI6IjAiLCIlZXhlY3V0aXZlX3N1bW1hcnklIjoiIiwiJXRoYi1yZWFjdGlvbnMtdm90ZXMlIjoiMSIsIiVfaGlkZV9mZWF0dXJlZCUiOm51bGwsIiVfd3Bfb2xkX2RhdGUlIjoiMjAyMC0wNi0xNyIsIiVpbmxpbmVfZmVhdHVyZWRfaW1hZ2UlIjoiMCIsIiVfeW9hc3Rfd3BzZW9fZm9jdXNrdyUiOiJXYWx2aXNzZW4ga2lqa2VuIGluIENhbGlmb3JuaVx1MDBlYiIsIiVfeW9hc3Rfd3BzZW9fdGl0bGUlIjoiV2Fsdmlzc2VuIGtpamtlbiBpbiBDYWxpZm9ybmlcdTAwZWIlJXNlcCUlICUlc2l0ZW5hbWUlJSIsIiVfeW9hc3Rfd3BzZW9fbWV0YWRlc2MlIjoiRWVuIHZhbiBkZSBiZXN0ZSBwbGVra2VuIG9tIHdhbHZpc3NlbiB0ZSB6aWVuIGluIEFtZXJpa2EgaXMgQ2FsaWZvcm5pXHUwMGViLiBXYXQgemlqbiBkZSBiZXN0ZSBwbGVra2VuIG9tIHdhbHZpc3NlbiB0ZSBraWprZW4gaW4gQ2FsaWZvcm5pXHUwMGViIiwiJV95b2FzdF93cHNlb19saW5rZGV4JSI6Ijc1IiwiJV95b2FzdF93cHNlb19jb250ZW50X3Njb3JlJSI6IjYwIiwiJV95b2FzdF93cHNlb19mb2N1c2tleXdvcmRzJSI6IltdIiwiJV95b2FzdF93cHNlb19rZXl3b3Jkc3lub255bXMlIjoiW1wiXCJdIiwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6IlNhbmliZWwgSXNsYW5kLCBGbG9yaWRhLCBWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9sb2NhdGlvbl9jaXR5JSI6IiIsIiVfd3BnbXBfbG9jYXRpb25fc3RhdGUlIjoiRmxvcmlkYSIsIiVfd3BnbXBfbG9jYXRpb25fY291bnRyeSUiOiJWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9tZXRhYm94X2xhdGl0dWRlJSI6IjI2LjQ0MzM5NzIiLCIlX3dwZ21wX21ldGFib3hfbG9uZ2l0dWRlJSI6Ii04Mi4xMTE1MTE5IiwiJV93cGdtcF9tZXRhYm94X2xvY2F0aW9uX3JlZGlyZWN0JSI6Im1hcmtlciIsIiVfd3BnbXBfbWV0YWJveF9jdXN0b21fbGluayUiOiIiLCIlX3dwZ21wX21hcF9pZCUiOiJhOjE6e2k6MDtzOjE6XCI3XCI7fSIsIiVfd3BnbXBfbWV0YWJveF9tYXJrZXJfaWQlIjoiYToxOntpOjA7czoxOlwiMlwiO30iLCIlX3dwZ21wX21ldGFib3hfdGF4b21vbWllc190ZXJtcyUiOiIiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6IiIsIiVfeW9hc3Rfd3BzZW9fZXN0aW1hdGVkLXJlYWRpbmctdGltZS1taW51dGVzJSI6IjQiLCIlX3d3c19zdXBwb3J0X2NvbnRhY3RfbnVtYmVyJSI6IiIsIiVfd3dzX2Fib3V0X3N1cHBvcnRfdGV4dCUiOiIiLCIlX3d3c190cmlnZ2VyX2J1dHRvbl90ZXh0JSI6IiIsIiVfd3dzX3ByZWRlZmluZWRfdGV4dCUiOiIiLCIlX3lvYXN0X2luZGV4bm93X2xhc3RfcGluZyUiOiIxNzAyNjQzNTA4IiwiJV95b2FzdF93cHNlb193b3JkcHJvb2ZfdGltZXN0YW1wJSI6IiIsIiVfbGFzdF9lZGl0b3JfdXNlZF9qZXRwYWNrJSI6ImNsYXNzaWMtZWRpdG9yIiwiJV95b2FzdF93cHNlb19wcmltYXJ5X2NhdGVnb3J5JSI6IjY3IiwiJXBvc3RfdmlhJSI6IiIsIiVfdGh1bWJuYWlsX2lkJSI6IjE4MzE1IiwiJXN0YW5kYXJkLWZlYXR1cmVkLWNyZWRpdCUiOiJcdTAwYTkgTlBJIFByb2R1Y3Rpb25zIiwidGF4b25vbXk9Y2F0ZWdvcnkiOiJBdm9udHV1ciIsInRheG9ub215PXBvc3RfdGFnIjoiQ2FsaWZvcm5pXHUwMGViIiwidGF4b25vbXk9cG9zdF9mb3JtYXQiOiIiLCJ0YXhvbm9teT10aGItcmVhY3Rpb25zIjoiIiwidGF4b25vbXk9dGhiLXNwb25zb3JzIjoiIn0sImljb24iOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDI0LzAzL211c2VhLWljb24ucG5nIn0sImlkIjoxODMwNSwiaW5mb3dpbmRvd19kaXNhYmxlIjpmYWxzZSwiY2F0ZWdvcmllcyI6W3siaWNvbiI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjQvMDMvbXVzZWEtaWNvbi5wbmciLCJuYW1lIjoiTXVzZWEiLCJpZCI6IjIiLCJ0eXBlIjoiY2F0ZWdvcnkiLCJleHRlbnNpb25fZmllbGRzIjp7ImNhdF9vcmRlciI6IiJ9fV19LHsic291cmNlIjoicG9zdCIsInRpdGxlIjoiMTctIE1pbGUgRHJpdmUgaW4gQ2FsaWZvcm5pXHUwMGViIiwiaW5mb3dpbmRvd19jb250ZW50IjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZyBcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiMTcgTWlsZSBEcml2ZVwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMy8xMi8xNy1taWxlLWRyaXZlLTMwMHgyMDAuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZ1wiPlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nIGZjLWl0ZW0tbm8tcGFkZGluZ1wiPlxyXG4gICAgICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS10aXRsZSBmYy1pdGVtLXByaW1hcnktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZVwiPjE3LSBNaWxlIERyaXZlIGluIENhbGlmb3JuaVx1MDBlYjwvZGl2PlxyXG4gICAgICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1jb250ZW50IGZjLWl0ZW0tYm9keS10ZXh0LWNvbG9yXCI+e21hcmtlcl9hZGRyZXNzfTwvZGl2PlxyXG4gICAgICAgIDwvZGl2PlxyXG4gICAgPC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtY2xlYXJcIj48L2Rpdj5cclxuPC9kaXY+IiwiYWRkcmVzcyI6IjE3IE1pbGUgRHIsIERlbCBNb250ZSBGb3Jlc3QsIENBLCBWZXJlbmlnZGUgU3RhdGVuIiwibG9jYXRpb24iOnsibGF0IjoiMzYuNTcyNzU3NyIsImNpdHkiOiJEZWwgTW9udGUgRm9yZXN0Iiwic3RhdGUiOiJDYWxpZm9ybmlhIiwiY291bnRyeSI6IlZlcmVuaWdkZSBTdGF0ZW4iLCJsbmciOiItMTIxLjk0ODcxNyIsIm9uY2xpY2tfYWN0aW9uIjoibWFya2VyIiwicmVkaXJlY3RfcGVybWFsaW5rIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC8xNy1taWxlLWRyaXZlLyIsInpvb20iOjEyLCJleHRyYV9maWVsZHMiOnsicG9zdF9leGNlcnB0IjoiIiwicG9zdF9jb250ZW50IjoiW3ZjX3Jvd11bdmNfY29sdW1uXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5fdGV4dF1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNzVweFwiXVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMjVweFwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIyNXB4XCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiMTctTWlsZSBEcml2ZVwiIG1haW5faGVhZGluZ19jb2xvcj1cIiMyODI4MjhcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozMHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdPHN0cm9uZz5FXHUwMGU5biB2YW4gZGUgbW9vaXN0ZSBhdXRvcm91dGVzIGluIEFtZXJpa2EgaXMgZGUgMTctTWlsZSBEcml2ZSBvcCBoZXQgc2NoaWVyZWlsYW5kIE1vbnRlcmV5LiBEZSAxNyBtaWpsLCBvb2sgd2VsIDI3IGtpbG9tZXRlciwgbGFuZ2Ugd2VnLCBicmVuZ3QgamUgbmFhciB2ZXJzY2hpbGxlbmRlIHVpdGtpamtwdW50ZW4gYWFuIGRlIFN0aWxsZSBPY2VhYW4uIERlIDE3LSBNaWxlIERyaXZlIGxpZ3QgdHVzc2VuIENhcm1lbC1ieS10aGUtU2VhIGVuIE1vbnRlcmV5LiBKZSBrb210IGhpZXJtZWUgZG9vciBlZW4gdmFuIGRlIG1lZXN0IGV4Y2x1c2lldmUgY29tbXVuaXRpZXMgdmFuIEFtZXJpa2E6IFBlYmJsZSBCZWFjaC4gRGUgYmVzdGUgcGVyaW9kZSB0cm91d2VucyBvbSBkZSAxNy1NaWxlIERyaXZlIHRlIHJpamRlbiwgaXMgaW4gZGUgbGVudGUgZW4gZGUgaGVyZnN0LCBpbiBkZSB6b21lciBpcyBlciB2YWFrIG1pc3QgZW4gaW4gZGUgd2ludGVyIGthbiBlciByZWRlbGlqayB3YXQgbmVlcnNsYWcgdmFsbGVuLlxyXG48L3N0cm9uZz5bL3ZjX2NvbHVtbl90ZXh0XVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI3NXB4XCJdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiIGZ1bGxfd2lkdGg9XCJzdHJldGNoX3Jvd1wiIGNvbnRlbnRfdGV4dF9hbGlnbWVudD1cImNlbnRlclwiIGNzcz1cIi52Y19jdXN0b21fMTU4NzY1OTI5OTA3MXtwYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O2JhY2tncm91bmQtY29sb3I6ICMwMDAwMDAgIWltcG9ydGFudDt9XCIgcGFyYWxsYXhfYmFja2dyb3VuZF9pbWFnZT1cIjM4MzZcIl1bdmNfY29sdW1uIHRoYl9jb2xvcj1cInRoYi1saWdodC1jb2x1bW5cIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiUGViYmxlIEJlYWNoXCIgaGVhZGluZ190YWc9XCJwXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiI2ZmZmZmZlwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjY1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NzBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW2hleXVzYV9oZWFkaW5nIHRhZz1cImRpdlwiIHRleHRfYWxpZ249XCJjZW50ZXJcIiBoZWFkaW5nPVwiVWl0emljaHQgb3AgZGUgcm90c2Zvcm1hdGllc1wiIGZvbnRfc2l6ZT1cIjUwXCIgbGluZV9oZWlnaHQ9XCI1MFwiIGZvbnRfY29sb3I9XCIjZmZmZmZmXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3BhcmFsbGF4X3JvdyBvcGFjaXR5PVwiODVcIiBlbmFibGVfbW9iaWxlPVwicGFyYWxsYXgtZW5hYmxlLW1vYmlsZVwiIGltYWdlPVwiMTgxNjFcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIHRoYl9yb3dfcGFkZGluZz1cInRydWVcIiB0aGJfY29sdW1uX3BhZGRpbmc9XCJ0cnVlXCIgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIl1bdmNfY29sdW1uIHdpZHRoPVwiMS8yXCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiNS82XCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCIxNy1NaWxlIERyaXZlXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjMwfHRleHRfYWxpZ246bGVmdHxjb2xvcjolMjMyODI4Mjh8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1baGV5dXNhX2hlYWRpbmcgdGFnPVwiZGl2XCIgaGVhZGluZz1cIkhvZSBrb20gamUgb3AgZGUgMTctTWlsZSBEcml2ZVwiIGZvbnRfc2l6ZT1cIjQwXCIgbGluZV9oZWlnaHQ9XCI0MFwiIGZvbnRfY29sb3I9XCIjMjgyODI4XCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48cCBzdHlsZT1cInRleHQtYWxpZ246IGxlZnQ7XCI+QXV0bydzIGhlYmJlbiB0b2VnYW5nIHRvdCBkZSAxNy1NaWxlIERyaXZlIHZpYSBcdTAwZTlcdTAwZTluIHZhbiBkZSB2aWpmIHBvb3J0ZW4gd2FhciBqZSBlZW4gdG9lZ2FuZ3NwcmlqcyBkaWVudCB0ZSBiZXRhbGVuLCBvbmdldmVlciAkMTIuIEplIGtyaWpndCBoaWVydm9vciBlZW4ga2FhcnQgbWV0IGJlemllbnN3YWFyZGlnaGVkZW4gbGFuZ3MgZGUgcm91dGUuIEtvbSBqZSB2YW51aXQgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvYmV6aWVuc3dhYXJkaWdoZWRlbi1tb250ZXJleS9cIj5Nb250ZXJleTwvYT4/IERhbiBpcyBkZSBpbmdhbmcgYmlqIDxhIGhyZWY9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL2hpZ2h3YXktMS9cIj5IaWdod2F5IDE8L2E+IGVuIEhpZ2h3YXkgNjggaGV0IGhhbmRpZ3N0IG9tIHRlIG5lbWVuLiBLb20gamUgdmFudWl0IDxhIGhyZWY9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dhdC10ZS1kb2VuLWNhcm1lbC1ieS10aGUtc2VhL1wiPkNhcm1lbC1ieS10aGUtU2VhPC9hPj8gRGFuIGlzIGRlIHRvZWdhbmdzcG9vcnQgdmFuIENhcm1lbCBnYXRlIGRlIG1ha2tlbGlqa3N0ZS4gRGUgb3ZlcmlnZSBpbmdhbmdlbiB6aWpuOiBQYWNpZmljIEdyb3ZlIEdhdGUsIENvdW50cnkgQ2x1YiBHYXRlIGVuIFMuRi5CLiBNb3JzZSBHYXRlLiBPdmVyaWdlbnMgemlqbiBtb3RvcmVuIG5pZXQgdG9lZ2VzdGFhbiBvcCBkZSAxNy1NaWxlIERyaXZlLiBNZXQgZWVuIGZpZXRzIG9mIGxvcGVuZCBob2VmIGplIGdlZW4gZW50cmVlIHRlIGJldGFsZW4uPC9wPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS8yXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiMTAwJVwiXVt0aGJfaW1hZ2UgcmV0aW5hPVwicmV0aW5hX3NpemVcIiBmdWxsX3dpZHRoPVwidHJ1ZVwiIGltYWdlPVwiMTgxNjJcIl1bL3RoYl9pbWFnZV1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IGNzcz1cIi52Y19jdXN0b21fMTQ3MjMwNzUwMjI5MHtwYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O3BhZGRpbmctYm90dG9tOiAyNXB4ICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW5dW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI3NXB4XCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiV2F0IGplIG5pZXQgbWFnIG1pc3NlbiBvcCBkZSAxNy1NaWxlIERyaXZlXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiI2IzNGE0Y1wiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjU1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NjBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XVxyXG48cCBzdHlsZT1cInRleHQtYWxpZ246IGNlbnRlcjtcIj5EZSAxNy1NaWxlIERyaXZlIHdvcmR0IG5pZXQgdm9vciBuaWV0cyBlZW4gdmFuIGRlIG1vb2lzdGUgYXV0b3JvdXRlcyBnZW5vZW1kLiBSaWpkIGplIGluIDEga2VlciBkb29yPyBEYW4gYmVuIGplIG9uZ2V2ZWVyIDIwIG1pbnV0ZW4gb25kZXJ3ZWcuIE1hYXIgZWlnZW5saWprIGlzIGRhdCBlbm9ybSB6b25kZS4gT25kZXJ3ZWcgemlqbiAxNyB1aXR6aWNodHB1bnRlbiBhYW4gZGUgb2NlYWFuIGRpZSBkZSBtb2VpdGUgd2FhcmQgemlqbiBvbSB0ZSBzdG9wcGVuLiBXZSBzZWxlY3RlZXJkZW4gNCBwbGVra2VuIG9tIGluIGllZGVyIGdldmFsIHRlIHN0b3BwZW4sIG1hYXIgZXIgemlqbiBub2cgdmVlbCBtZWVyITwvcD5cclxuWy92Y19jb2x1bW5fdGV4dF1bdmNfcm93X2lubmVyIGNzcz1cIi52Y19jdXN0b21fMTU4Mjk3MDcwNDkwM3twYWRkaW5nLXRvcDogMTBweCAhaW1wb3J0YW50O3BhZGRpbmctcmlnaHQ6IDEwcHggIWltcG9ydGFudDtwYWRkaW5nLWJvdHRvbTogMTBweCAhaW1wb3J0YW50O3BhZGRpbmctbGVmdDogMTBweCAhaW1wb3J0YW50O31cIl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS80XCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiQmlyZCBSb2NrXCIgaGVhZGluZ190YWc9XCJoM1wiIG1haW5faGVhZGluZ19jb2xvcj1cIiMyODI4MjhcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjMwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19zaW5nbGVfaW1hZ2UgaW1hZ2U9XCIxODE1NVwiIGltZ19zaXplPVwibGFyZ2VcIiBhZGRfY2FwdGlvbj1cInllc1wiXVt2Y19jb2x1bW5fdGV4dF1cclxuPHAgc3R5bGU9XCJ0ZXh0LWFsaWduOiBjZW50ZXI7XCI+Vm9vciBoZXQgemllbiB2YW4gd2lsZGxpZmUgaXMgQmlyZCBSb2NrIGVlbiBnb2VkZSBwbGVrIG9tIHRlIHN0b3BwZW4uIFRvdCAxOTMwIHdhcyBkZSByb3RzIG5vZyBiZWRla3QgbWV0IGd1YW5vIHZhbiBkZSBwZWxpa2FhbiBlbiBkZSBhYWxzY2hvbHZlciBkYXQgYWxzIG1lc3Qgd2VyZCBnZWJydWlrdC4gWmVlbGVldXdlbiBwcm9maXRlZXJkZW4gdmFuIGRlIHNjaG9vbmdlbWFha3RlIHJvdHNlbiBlbiBzaW5kc2RpZW4gbGlnZ2VuIGVyIHZhYWsgemVlbGVldXdlbiBvcCBkZSByb3RzZW4uIFR1c3NlbiBub3ZlbWJlciBlbiBtYWFydCBrdW4gamUgaGllciBncmlqemUgd2Fsdmlzc2VuIHZvb3JiaWogemllbiB6d2VtbWVuLjwvcD5cclxuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS80XCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiTG9uZSBDeXByZXNzXCIgaGVhZGluZ190YWc9XCJoM1wiIG1haW5faGVhZGluZ19jb2xvcj1cIiMyODI4MjhcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjMwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19zaW5nbGVfaW1hZ2UgaW1hZ2U9XCIxODE1NlwiIGltZ19zaXplPVwibGFyZ2VcIiBhZGRfY2FwdGlvbj1cInllc1wiXVt2Y19jb2x1bW5fdGV4dF1cclxuPHAgc3R5bGU9XCJ0ZXh0LWFsaWduOiBjZW50ZXI7XCI+RGUgbWVlc3QgYmVrZW5kZSBib29tIGluIGRlIHJlZ2lvOiBEZSBMb25lIEN5cHJlc3MuIEFsIG1lZXIgZGFuIDI1MCBqYWFyIHN0YWF0IGRlemUgYm9vbSBvcCBlZW4gcm90c2FjaHRpZyB2b2V0c3R1ayBtZXQgdWl0emljaHQgb3ZlciBkZSBTdGlsbGUgT2NlYWFuLiBEZSBib29tIHN0YWF0IGhlbGVtYWFsIGFsbGVlbiBvcCBkZSByb3RzIHdhYXJkb29yIGhldCBlZW4gcHJhY2h0aWcgZ2V6aWNodCBpcy48L3A+XHJcblsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvNFwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIlBlc2NhZGVybyBQb2ludFwiIGhlYWRpbmdfdGFnPVwiaDNcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMjgyODI4XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozMHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfc2luZ2xlX2ltYWdlIGltYWdlPVwiMTgxNTdcIiBpbWdfc2l6ZT1cImxhcmdlXCIgYWRkX2NhcHRpb249XCJ5ZXNcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxwIHN0eWxlPVwidGV4dC1hbGlnbjogY2VudGVyO1wiPkJpaiBQZXNjYWRlcm8gUG9pbnQgemllIGplIGVlbiBhYW50YWwgZ3JpZXplbGlnZSBjaXByZXNzZW4gc3RhYW4uIERhYXJuYWFzdCBpcyBkZSBwbGVrIGVlbiBsZWdlbmRhcmlzY2hlIHN1cmZzcG90LiBNZXQgZGUganVpc3RlIG9tc3RhbmRpZ2hlZGVuIHppam4gZXIgZ29sdmVuIHZhbiAxNSBtZXRlciBvcCBkZXplIHBsZWsuPC9wPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzRcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJTcGFuaXNoIEJheVwiIGhlYWRpbmdfdGFnPVwiaDNcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMjgyODI4XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozMHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfc2luZ2xlX2ltYWdlIGltYWdlPVwiMTgxNThcIiBpbWdfc2l6ZT1cImxhcmdlXCIgYWRkX2NhcHRpb249XCJ5ZXNcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxwIHN0eWxlPVwidGV4dC1hbGlnbjogY2VudGVyO1wiPkRlIHN0b3AgU3BhbmlzaCBCYXkgbGlndCBkaXJlY3QgYWFuIGhldCB3YXRlci4gSW4gMTc2OSBrYW1wZWVyZGVuIGhpZXIgU3BhYW5zZSBvbnRkZWtraW5nc3JlaXppZ2VycyBkaWUgTW9udGVyZXkgQmF5IHByb2JlZXJkZW4gdGUgdmluZGVuLiBIZXQga29zdHRlIGhlbiBlZW4gamFhciBvbSBNb250ZXJleSBCYXkgdGUgdmluZGVuLCBkaXQgcHJhY2h0aWdlIHN0cmFuZCBhYW4gZGUgMTctTWlsZSBEcml2ZSBpcyBuYWFyIGh1biB2ZXJub2VtZC48L3A+XHJcblsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIGNvbnRlbnRfcGxhY2VtZW50PVwibWlkZGxlXCIgZnVsbF93aWR0aD1cInN0cmV0Y2hfcm93XCIgY29udGVudF90ZXh0X2FsaWdtZW50PVwiY2VudGVyXCIgY3NzPVwiLnZjX2N1c3RvbV8xNTg3NjU5Mjk5MDcxe3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7YmFja2dyb3VuZC1jb2xvcjogIzAwMDAwMCAhaW1wb3J0YW50O31cIiBwYXJhbGxheF9iYWNrZ3JvdW5kX2ltYWdlPVwiMzgzNlwiXVt2Y19jb2x1bW4gdGhiX2NvbG9yPVwidGhiLWxpZ2h0LWNvbHVtblwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJHb2xmYmFhbiBQZWJibGUgQmVhY2hcIiBoZWFkaW5nX3RhZz1cInBcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjZmZmZmZmXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6NjVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDo3MHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11baGV5dXNhX2hlYWRpbmcgdGFnPVwiZGl2XCIgdGV4dF9hbGlnbj1cImNlbnRlclwiIGhlYWRpbmc9XCJFZW4gdmFuIGRlIHZlbGUgcGxla2tlbiBpbiBkZSBidXVydCB2YW4gZGUgMTctTWlsZSBEcml2ZSBvbSBlZW4gYmFsbGV0amUgdGUgc2xhYW5cIiBmb250X3NpemU9XCI1MFwiIGxpbmVfaGVpZ2h0PVwiNTBcIiBmb250X2NvbG9yPVwiI2ZmZmZmZlwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVtwYXJhbGxheF9yb3cgb3BhY2l0eT1cIjg1XCIgZW5hYmxlX21vYmlsZT1cInBhcmFsbGF4LWVuYWJsZS1tb2JpbGVcIiBpbWFnZT1cIjE3ODY4XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiB0aGJfcm93X3BhZGRpbmc9XCJ0cnVlXCIgdGhiX2NvbHVtbl9wYWRkaW5nPVwidHJ1ZVwiIGNvbnRlbnRfcGxhY2VtZW50PVwibWlkZGxlXCJdW3ZjX2NvbHVtbiB3aWR0aD1cIjEvMlwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI3NXB4XCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjEwMCVcIl1bdGhiX2ltYWdlIHJldGluYT1cInJldGluYV9zaXplXCIgZnVsbF93aWR0aD1cInRydWVcIiBpbWFnZT1cIjE4MTYyXCJdWy90aGJfaW1hZ2VdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS8yXCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiNS82XCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJSZXN0YXVyYW50IHRpcHMgMTctTWlsZSBEcml2ZVwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgzfGZvbnRfc2l6ZTozMHx0ZXh0X2FsaWduOmxlZnR8Y29sb3I6JTIzMjgyODI4fGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW2hleXVzYV9oZWFkaW5nIHRhZz1cImRpdlwiIGhlYWRpbmc9XCJPbnRkZWsgZGUga2V1a2VuIGFhbiBkZSAxNy1NaWxlIERyaXZlXCIgZm9udF9zaXplPVwiNDBcIiBsaW5lX2hlaWdodD1cIjQwXCIgZm9udF9jb2xvcj1cIiMyODI4MjhcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxwIHN0eWxlPVwidGV4dC1hbGlnbjogbGVmdDtcIj5EZSBvbWdldmluZyB2YW4gZGUgMTctTWlsZSBEcml2ZSBzdGFhdCBiZWtlbmQgYWxzIHJlZGVsaWprIGNoaXF1ZS4gT3AgemljaCBob2VmdCBoZXQgbmlldCBwZXIgc2UgZHV1ciB0ZSB6aWpuIHdhbm5lZXIgamUgaGllciB3YXQgd2lsdCBldGVuLiBLb29wIHdhdCBldGVuIGluIGVlbiBzdXBlcm1hcmt0IG9mIGhhYWwgZWVuIGJyb29kamUgb25kZXJ3ZWcgZW4gZ2Egeml0dGVuIGFhbiBlZW4gdmFuIGRlIHZlbGUgcGlja25pY2t0YWZlbHMgdHVzc2VuIFBvaW50IEpvZSBlbiBTZWFsIFJvY2suIFdpbCBqZSB3ZWwgZ3JhYWcgdWl0IGV0ZW4gZW4gbWFha3QgaGV0IGJ1ZGdldCBuaWV0IHVpdD8gR2EgZGFuIHVpdCBldGVuIGJpaiBkZSBMb2RnZSBhdCBQZWJibGUgQmVhY2gsIFJveSdzIGF0IFBlYmJsZSBCZWFjaCBvZiBTdGlsbHdhdGVyIEJhciAmYW1wOyBHcmlsbC4gSWV0cyBnb2Vka29wZXJlIG9wdGllcyB6aWpuIFN0aWNrcyBlbiBSZWQgSG91c2UgQ2FmXHUwMGU5LjwvcD5cclxuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiIGNzcz1cIi52Y19jdXN0b21fMTY4OTk1NjI4MDczMXtwYWRkaW5nLXRvcDogNTBweCAhaW1wb3J0YW50O3BhZGRpbmctYm90dG9tOiA1MHB4ICFpbXBvcnRhbnQ7YmFja2dyb3VuZC1pbWFnZTogdXJsKGh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjEvMDgvYWxsLWRheS11c2EtYmFja2dyb3VuZC5naWY/aWQ9ODQwOCkgIWltcG9ydGFudDt9XCJdW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIyLzNcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1baGV5dXNhX2hlYWRpbmcgdGFnPVwiZGl2XCIgaGVhZGluZz1cIkhhbmRpZ2UgaW5mbyB2YW4gZGUgcmVkYWN0aWVcIiBmb250X3NpemU9XCI0M1wiIGxpbmVfaGVpZ2h0PVwiNDVcIiBmb250X2NvbG9yPVwiI2IzNGE0Y1wiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiT3Zlcm5hY2h0ZW4gaW4gZGUgYnV1cnQgdmFuIGRlIDE3LU1pbGUgRHJpdmVcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoM3xmb250X3NpemU6MjV8dGV4dF9hbGlnbjpsZWZ0fGNvbG9yOiUyMzI4MjgyOHxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6Um9ib3RvJTIwU2xhYiUzQTEwMCUyQzMwMCUyQ3JlZ3VsYXIlMkM3MDB8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX3Jvd19pbm5lciBib3hfc2hhZG93PVwibGFyZ2Utc2hhZG93XCIgY3NzPVwiLnZjX2N1c3RvbV8xNjg5OTU1NDg2MDg3e2JhY2tncm91bmQtY29sb3I6ICNmZmZmZmYgIWltcG9ydGFudDtib3JkZXItcmFkaXVzOiAxMHB4ICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW5faW5uZXJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjI1cHhcIl1bdWx0aW1hdGVfaWNvbl9saXN0IGljb25fc2l6ZT1cIjY1XCIgaWNvbl9tYXJnaW49XCIxMFwiXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uX3R5cGU9XCJjdXN0b21cIiBpY29uX2ltZz1cImlkXjE2NzU4fHVybF5odHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIzLzA3L2hleXVzYS1leHBlcnQtdGlwLnBuZ3xjYXB0aW9uXkhleSFVU0EgRXhwZXJ0IFRpcCBvdmVyIHJlaXplbiBuYWFyIEFtZXJpa2F8YWx0XkhleSFVU0EgRXhwZXJ0IFRpcCBvdmVyIHJlaXplbiBuYWFyIEFtZXJpa2F8dGl0bGVeSGV5IVVTQSBFeHBlcnQgVGlwIG92ZXIgcmVpemVuIG5hYXIgQW1lcmlrYXxkZXNjcmlwdGlvbl5IZXkhVVNBIEV4cGVydCBUaXAgb3ZlciByZWl6ZW4gbmFhciBBbWVyaWthXCIgY29udGVudF9mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBjb250ZW50X2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBjb250ZW50X2ZvbnRfY29sb3I9XCIjMjgyODI4XCJdSGV5IVVTQVxyXG5wZXJzb29ubGlqa2UgdGlwczpbL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVsvdWx0aW1hdGVfaWNvbl9saXN0XVt2Y19jb2x1bW5fdGV4dF1Ib2V3ZWwgamUgZGUgMTctTWlsZSBEcml2ZSBpbiAyMCBtaW51dGVuIGt1bnQgcmlqZGVuLCBpcyBoZXQgYWFuIHRlIHJhZGVuIG9tIGRlIHRpamQgdGUgbmVtZW4gdm9vciBkZSBiZXppZW5zd2FhcmRpZ2hlZGVuIGluIGRpdCBkZWVsIHZhbiBDYWxpZm9ybmlcdTAwZWIuIEVlbiBhYW50YWwgaG90ZWwgdGlwcyBpbiBkZSBidXVydCB2YW4gZGUgMTctTWlsZSBEcml2ZTpcclxuPHVsPlxyXG4gXHQ8bGk+VGhlIEhpZGVhd2F5IC0gb3Agc2xlY2h0cyBlZW4ga2lsb21ldGVyIHZhbiBoZXQgc3RyYW5kPC9saT5cclxuIFx0PGxpPklubiBhdCBTcGFuaXNoIEJheSAtIGlkZWFhbCB2b29yIGFscyBqZSBvb2sgZWVuIGJhbGxldGplIHdpbCBzbGFhbiwgbWFhciBvb2sgZWVuIGtudXMgaG90ZWwgZGF0IHVpdGtpamt0IG92ZXIgU3BhbmlzaCBCYXk8L2xpPlxyXG4gXHQ8bGk+Q2FzYSBQYWxlcm1vIC0gZGljaHQgYmlqIFBlYmJsZSBCZWFjaDwvbGk+XHJcbiBcdDxsaT5Mb2RnZSBhdCBQZWJibGUgQmVhY2ggLSBuaWV0IGFsbGVlbiB2ZWVsIHNob3BzIGVuIHJlc3RhdXJhbnRzLCBqZSBrdW50IG9vayBvdmVybmFjaHRlbiBpbiBkaXQgNSBzdGVycmVuIGhvdGVsPC9saT5cclxuIFx0PGxpPjxhIGhyZWY9XCJodHRwczovL3d3dy5ib29raW5nLmNvbS9ob3RlbC91cy9jb3JhbC1vYXNpcy1wZWJibGUtYmVhY2guZW4uaHRtbD9haWQ9Nzk1ODQ5OCZhbXA7bm9fcm9vbXM9MSZhbXA7Z3JvdXBfYWR1bHRzPTIxN21pbGVvYXNpc1wiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+Q29yYWwgT2FzaXM8L2E+IC0gdmFrYW50aWVodWlzIG9wIDEsNSBraWxvbWV0ZXIgdmFuIGhldCBzdHJhbmQ8L2xpPlxyXG4gXHQ8bGk+PGEgaHJlZj1cImh0dHBzOi8vd3d3LmJvb2tpbmcuY29tL2hvdGVsL3VzL2xhLXBsYXlhLWNhcm1lbC5lbi5odG1sP2FpZD03OTU4NDk4JmFtcDtub19yb29tcz0xJmFtcDtncm91cF9hZHVsdHM9MjE3bWlsZWRyaXZlcGxheWFcIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPlBsYXlhIEhvdGVsIGluIENhcm1lbDwvYT4gLSBvcCA1IG1pbnV0ZW4gdmFuIGhldCBzdHJhbmQgbWV0IGVpZ2VuIGJ1aXRlbnp3ZW1iYWQ8L2xpPlxyXG48L3VsPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW5dW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJPbnRkZWsgbWVlciBDYWxpZm9ybmlcdTAwZWJcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMjgyODI4XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6NDVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDo1MHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVtmdWxsd2lkdGhfcm93XVt0aGJfcG9zdGdyaWQgY29sdW1ucz1cIjRcIiBzb3VyY2U9XCJwb3N0X3R5cGU6cG9zdHxieV9pZDotMTY1MDcsLTE2NDAwLC0xNjM0MiwtMTYxNzQsLTE1MzU1LC0xNTE2MywtNDcyNSwtMTU1OSwxNzg2MywxNzY5OSw5OTQyLDEzNTEzXCJdWy92Y19jb2x1bW5dWy92Y19yb3ddIiwicG9zdF90aXRsZSI6IjE3LSBNaWxlIERyaXZlIGluIENhbGlmb3JuaVx1MDBlYiIsInBvc3RfbGluayI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvMTctbWlsZS1kcml2ZS8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCIxNyBNaWxlIERyaXZlXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMDBcIiBzcmM9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIzLzEyLzE3LW1pbGUtZHJpdmUtMzAweDIwMC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj4iLCJwb3N0X2NhdGVnb3JpZXMiOiJCZXppZW5zd2FhcmRpZ2hlZGVuIiwicG9zdF90YWdzIjoiRmxvcmlkYSIsIiVfd3BiX3Nob3J0Y29kZXNfY3VzdG9tX2NzcyUiOiIudmNfY3VzdG9tXzE1ODc2NTkyOTkwNzF7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDtiYWNrZ3JvdW5kLWNvbG9yOiAjMDAwMDAwICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTQ3MjMwNzUwMjI5MHtwYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O3BhZGRpbmctYm90dG9tOiAyNXB4ICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTU4NzY1OTI5OTA3MXtwYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O2JhY2tncm91bmQtY29sb3I6ICMwMDAwMDAgIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNjg5OTU2MjgwNzMxe3BhZGRpbmctdG9wOiA1MHB4ICFpbXBvcnRhbnQ7cGFkZGluZy1ib3R0b206IDUwcHggIWltcG9ydGFudDtiYWNrZ3JvdW5kLWltYWdlOiB1cmwoaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMS8wOC9hbGwtZGF5LXVzYS1iYWNrZ3JvdW5kLmdpZj9pZD04NDA4KSAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE1ODI5NzA3MDQ5MDN7cGFkZGluZy10b3A6IDEwcHggIWltcG9ydGFudDtwYWRkaW5nLXJpZ2h0OiAxMHB4ICFpbXBvcnRhbnQ7cGFkZGluZy1ib3R0b206IDEwcHggIWltcG9ydGFudDtwYWRkaW5nLWxlZnQ6IDEwcHggIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNjg5OTU1NDg2MDg3e2JhY2tncm91bmQtY29sb3I6ICNmZmZmZmYgIWltcG9ydGFudDtib3JkZXItcmFkaXVzOiAxMHB4ICFpbXBvcnRhbnQ7fSIsIiVfZWRpdF9sb2NrJSI6IjE3MDMzMjA1ODg6MiIsIiVfZWRpdF9sYXN0JSI6IjIiLCIlX3dwYl92Y19qc19zdGF0dXMlIjoidHJ1ZSIsIiVwb3N0LXByaW1hcnktY2F0ZWdvcnklIjoiMTYiLCIlZmVhdHVyZWRfaW1hZ2Vfb3ZlcnJpZGUlIjoib2ZmIiwiJWFydGljbGVfc3R5bGVfb3ZlcnJpZGUlIjoib24iLCIlcG9zdF9zdHlsZSUiOiJzdHlsZTUiLCIlcG9zdF9nYWxsZXJ5X3N0eWxlJSI6ImxpZ2h0Ym94IiwiJXBvc3RfcmV2aWV3JSI6Im9mZiIsIiVwb3N0X3Jldmlld19zdHlsZSUiOiJzdHlsZTEiLCIlcG9zdF9yZXZpZXdfYXZlcmFnZSUiOiI1MCIsIiV0aGJfYWxsX2NvdW50cyUiOiIwIiwiJWV4ZWN1dGl2ZV9zdW1tYXJ5JSI6IiIsIiV0aGItcmVhY3Rpb25zLXZvdGVzJSI6IjEiLCIlX2hpZGVfZmVhdHVyZWQlIjpudWxsLCIlX3dwX29sZF9kYXRlJSI6IjIwMjAtMDYtMTciLCIlaW5saW5lX2ZlYXR1cmVkX2ltYWdlJSI6IjAiLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza3clIjoiMTctTWlsZSBEcml2ZSIsIiVfeW9hc3Rfd3BzZW9fdGl0bGUlIjoiMTctTWlsZSBEcml2ZSUlc2VwJSUgJSVzaXRlbmFtZSUlIiwiJV95b2FzdF93cHNlb19tZXRhZGVzYyUiOiJPcCBoZXQgc2NoaWVyZWlsYW5kIE1vbnRlcmV5IGxpZ3QgZWVuIHZhbiBkZSBtb29pc3RlIGF1dG9yb3V0ZXMgbGFuZyB2ZXJzY2hpbGxlbmRlIGRlIGJlemllbnN3YWFyZGlnaGVkZW46IGRlIDE3LU1pbGUgRHJpdmUuIFRpcHMgdm9vciBkZSAxNy1NaWxlIERyaXZlLiIsIiVfeW9hc3Rfd3BzZW9fbGlua2RleCUiOiI3NyIsIiVfeW9hc3Rfd3BzZW9fY29udGVudF9zY29yZSUiOiI2MCIsIiVfeW9hc3Rfd3BzZW9fZm9jdXNrZXl3b3JkcyUiOiJbXSIsIiVfeW9hc3Rfd3BzZW9fa2V5d29yZHN5bm9ueW1zJSI6IltcIjE3LU1pbGUgRHJpdmUgQ2FsaWZvcm5pXHUwMGViXCJdIiwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6IjE3IE1pbGUgRHIsIERlbCBNb250ZSBGb3Jlc3QsIENBLCBWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9sb2NhdGlvbl9jaXR5JSI6IkRlbCBNb250ZSBGb3Jlc3QiLCIlX3dwZ21wX2xvY2F0aW9uX3N0YXRlJSI6IkNhbGlmb3JuaWEiLCIlX3dwZ21wX2xvY2F0aW9uX2NvdW50cnklIjoiVmVyZW5pZ2RlIFN0YXRlbiIsIiVfd3BnbXBfbWV0YWJveF9sYXRpdHVkZSUiOiIzNi41NzI3NTc3IiwiJV93cGdtcF9tZXRhYm94X2xvbmdpdHVkZSUiOiItMTIxLjk0ODcxNyIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiN1wiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6ImE6MTp7aTowO3M6MTpcIjJcIjt9IiwiJV93cGdtcF9tZXRhYm94X3RheG9tb21pZXNfdGVybXMlIjoiIiwiJV93cGdtcF9leHRlbnNpb25zX2ZpZWxkcyUiOiIiLCIlX3lvYXN0X3dwc2VvX2VzdGltYXRlZC1yZWFkaW5nLXRpbWUtbWludXRlcyUiOiI1IiwiJV93d3Nfc3VwcG9ydF9jb250YWN0X251bWJlciUiOiIiLCIlX3d3c19hYm91dF9zdXBwb3J0X3RleHQlIjoiIiwiJV93d3NfdHJpZ2dlcl9idXR0b25fdGV4dCUiOiIiLCIlX3d3c19wcmVkZWZpbmVkX3RleHQlIjoiIiwiJV95b2FzdF9pbmRleG5vd19sYXN0X3BpbmclIjoiMTcwMTY5MDc2MSIsIiVfeW9hc3Rfd3BzZW9fd29yZHByb29mX3RpbWVzdGFtcCUiOiIiLCIlX2xhc3RfZWRpdG9yX3VzZWRfamV0cGFjayUiOiJjbGFzc2ljLWVkaXRvciIsIiVfeW9hc3Rfd3BzZW9fcHJpbWFyeV9jYXRlZ29yeSUiOiI2NSIsIiVwb3N0X3ZpYSUiOiIiLCIlX3RodW1ibmFpbF9pZCUiOiIxODE2MCIsIiVzdGFuZGFyZC1mZWF0dXJlZC1jcmVkaXQlIjoiIiwidGF4b25vbXk9Y2F0ZWdvcnkiOiJCZXppZW5zd2FhcmRpZ2hlZGVuIiwidGF4b25vbXk9cG9zdF90YWciOiJGbG9yaWRhIiwidGF4b25vbXk9cG9zdF9mb3JtYXQiOiIiLCJ0YXhvbm9teT10aGItcmVhY3Rpb25zIjoiIiwidGF4b25vbXk9dGhiLXNwb25zb3JzIjoiIn0sImljb24iOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDI0LzAzL211c2VhLWljb24ucG5nIn0sImlkIjoxODE0OCwiaW5mb3dpbmRvd19kaXNhYmxlIjpmYWxzZSwiY2F0ZWdvcmllcyI6W3siaWNvbiI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjQvMDMvbXVzZWEtaWNvbi5wbmciLCJuYW1lIjoiTXVzZWEiLCJpZCI6IjIiLCJ0eXBlIjoiY2F0ZWdvcnkiLCJleHRlbnNpb25fZmllbGRzIjp7ImNhdF9vcmRlciI6IiJ9fV19LHsic291cmNlIjoicG9zdCIsInRpdGxlIjoiRXNzZXggSG91c2UgTWlhbWkgQmVhY2giLCJpbmZvd2luZG93X2NvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nIFwiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJFZW4ga2FtZXIgaW4gaGV0IGljb25pc2NoZSBhcnQtZGVjbyBFc3NleCBIb3VzZSBob3RlbCBpbiBNaWFtaSBCZWFjaFwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMy8xMi9lc3NleC1ob3VzZS1taWFtaS1iZWFjaC0zMDB4MjAwLmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmdcIj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZyBmYy1pdGVtLW5vLXBhZGRpbmdcIj5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tdGl0bGUgZmMtaXRlbS1wcmltYXJ5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2VcIj5Fc3NleCBIb3VzZSBNaWFtaSBCZWFjaDwvZGl2PlxyXG4gICAgICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1jb250ZW50IGZjLWl0ZW0tYm9keS10ZXh0LWNvbG9yXCI+e21hcmtlcl9hZGRyZXNzfTwvZGl2PlxyXG4gICAgICAgIDwvZGl2PlxyXG4gICAgPC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtY2xlYXJcIj48L2Rpdj5cclxuPC9kaXY+IiwiYWRkcmVzcyI6IjEwMDEgQ29sbGlucyBBdmUsIE1pYW1pIEJlYWNoLCBGTCAzMzEzOSwgVmVyZW5pZ2RlIFN0YXRlbiIsImxvY2F0aW9uIjp7ImxhdCI6IjI1Ljc4MDc0MTUiLCJjaXR5IjoiTWlhbWkgQmVhY2giLCJzdGF0ZSI6IkZsb3JpZGEiLCJjb3VudHJ5IjoiVmVyZW5pZ2RlIFN0YXRlbiIsImxuZyI6Ii04MC4xMzE0Nzg1Iiwib25jbGlja19hY3Rpb24iOiJtYXJrZXIiLCJyZWRpcmVjdF9wZXJtYWxpbmsiOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL292ZXJuYWNodGVuLW1pYW1pL2Vzc2V4LWhvdXNlLW1pYW1pLWJlYWNoLyIsInpvb20iOjEyLCJleHRyYV9maWVsZHMiOnsicG9zdF9leGNlcnB0IjoiIiwicG9zdF9jb250ZW50IjoiW3ZjX3Jvd11bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjIvM1wiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJJY29uaXNjaCBhcnQtZGVjbyBob3RlbFwiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDo0NXB4O1wiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NTBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiMTAwMSBDb2xsaW5zIEF2ZW51ZSwgTWlhbWkgQmVhY2hcIiBoZWFkaW5nX3RhZz1cImRpdlwiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5Ok9zd2FsZHxmb250X2NhbGw6T3N3YWxkXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MzBweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjM1cHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF1cclxuPHAgc3R5bGU9XCJ0ZXh0LWFsaWduOiBjZW50ZXI7XCI+XHUyYjUwXHVmZTBmXHUyYjUwXHVmZTBmXHUyYjUwXHVmZTBmXHUyYjUwXHVmZTBmPC9wPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW5dW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIkVzc2V4IEhvdXNlIE1pYW1pIEJlYWNoXCIgYWxpZ25tZW50PVwibGVmdFwiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6MzBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiJCQkXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiI2M1OWM0ZFwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjMwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF1IZXQgaWNvbmlzY2hlIGFydC1kZWNvLWhvdGVsIEVzc2V4IEhvdXNlIGluIE1pYW1pIEJlYWNoIGlzIGVlbiB6dXN0ZXJ2ZXJibGlqZiB2YW4gaGV0IENsZXZlbGFuZGVyIEhvdGVsLCBkYXQgYWFuIE9jZWFuIERyaXZlIGdlbGVnZW4gaXMuIEVzc2V4IEhvdXNlIHdlcmQgaW4gMTkzOCBnZWJvdXdkIGVuIG9udHdvcnBlbiBkb29yIEhlbnJ5IEhvaGF1c2VyLCBoZXQgaXMgXHUwMGU5XHUwMGU5biB2YW4gZGUgbWVlc3QgaWNvbmlzY2hlIGFydC1kZWNvIGhvdGVscyBpbiBoZXQgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvYXJ0LWRlY28tZGlzdHJpY3QtbWlhbWkvXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5hcnQtZGVjbyBkaXN0cmljdDwvYT4gdmFuIE1pYW1pIEJlYWNoLiBBbGxlZW4gYWwgZGFhcm9tIGlzIGhldCBlZW4gbW9vaWUgcGxlayBvbSB0ZSB2ZXJibGlqdmVuLiBXYWFyIGhldCBDbGV2ZWxhbmRlciBlZW4gXHUwMGU5Y2h0IHBhcnR5aG90ZWwgaXMgbWV0IHp3ZW1iYWRmZWVzdGplcywgbHVpZGUgbXV6aWVrIGVuIHZlZWwgYW1iaWFuY2UsIGt1biBqZSBpbiBoZXQgRXNzZXggSG91c2UgamUgdGVydWd0cmVra2VuIHZvb3IgcnVzdC4gRGUga2FtZXJzIHppam4gbW9kZXJuIGluZ2VyaWNodCwgZXIgaGFuZ3Qga25hbGxlbmRlIGt1bnN0IGFhbiBkZSBtdXVyIGVuIGluIGRlIGJhZGthbWVyIHZpbmQgamUgYmFkcHJvZHVjdGVuIHZhbiBSaXR1YWxzLlsvdmNfY29sdW1uX3RleHRdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiR2VzZWxlY3RlZXJkIGRvb3IgSGV5IVVTQVwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpSb2JvdG8gU2xhYnxmb250X2NhbGw6Um9ib3RvK1NsYWJ8dmFyaWFudDo4MDBcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyMHB4O1wiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfc3R5bGU9XCJmb250LXdlaWdodDo4MDA7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF1Fc3NleCBIb3VzZSBpbiBNaWFtaSBCZWFjaCBpcyBlZW4gYmV0YWFsYmFhciBob3RlbCBpbiBlZW4gc3BlY3RhY3VsYWlyZSBhcnQtZGVjbyBvbWdldmluZy4gRGUga2xhc3NpZWtlIGFydC1kZWNvIGVsZW1lbnRlbiB2YW4gaGV0IGhvdGVsIHppam4gZ29lZCBiZXdhYXJkIGdlYmxldmVuIGVuIG1vb2kgZ2Vjb21iaW5lZXJkIG1ldCBtb2Rlcm5lIGVuIGdsYW1vdXJldXplIGFhbmtsZWRpbmcuIEhldCBob3RlbCB6ZWxmIGhlZWZ0IHdlaW5pZyBmYWNpbGl0ZWl0ZW4sIG1hYXIgZGFhcnZvb3Iga3VuIGplIGJpaiBuYWFzdGdlbGVnZW4gQ2xldmVsYW5kZXIgdGVyZWNodC4gS29ydG9tLCBlZW4gYXJ0LWRlY28ga2xhc3NpZWtlciB3YWFyIGplIGt1bnQgdmVyYmxpanZlbiB6b25kZXIgZmFpbGxpZXQgdGUgZ2FhbiFbL3ZjX2NvbHVtbl90ZXh0XVt1bHRfYnV0dG9ucyBidG5fdGl0bGU9XCJCb2VrIGVlbiBrYW1lclwiIGJ0bl9saW5rPVwidXJsOmh0dHBzJTNBJTJGJTJGd3d3LmJvb2tpbmcuY29tJTJGaG90ZWwlMkZ1cyUyRmVzc2V4LWhvdXNlLm5sLmh0bWwlM0ZhaWQlM0Q3OTU4NDk4JTI2bm9fcm9vbXMlM0QxJTI2Z3JvdXBfYWR1bHRzJTNEMiUyNmxhYmVsJTNEZXNzZXhob3VzZS1ob3RlbC1wYWdlfHRpdGxlOkJvZWslMjBlZW4lMjBrYW1lcnx0YXJnZXQ6X2JsYW5rXCIgYnRuX3RpdGxlX2NvbG9yPVwiI2ZmZmZmZlwiIGJ0bl9iZ19jb2xvcj1cIiNiMzRhNGNcIiBidG5faG92ZXI9XCJ1YnRuLWJvdHRvbS1iZ1wiIGJ0bl9iZ19jb2xvcl9ob3Zlcj1cIiM1MzFhMjNcIiBpY29uX3NpemU9XCIzMlwiIGJ0bl9pY29uX3Bvcz1cInVidG4tc2VwLWljb24tYXQtbGVmdFwiIGJ0bl9mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBidG5fZm9udF9zaXplPVwiZGVza3RvcDoyMHB4O1wiIGJ0bl9saW5lX2hlaWdodD1cImRlc2t0b3A6MjVweDtcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMi8zXCJdW3RoYl9pbWFnZV9zbGlkZXIgbGlnaHRib3g9XCJtZnAtZ2FsbGVyeVwiIHRoYl9lcXVhbF9oZWlnaHQ9XCJ0cnVlXCIgYXV0b3BsYXk9XCJ0cnVlXCIgaW1hZ2VzPVwiMTgxMzcsMTgxMzgsMTgxMzksMTgxNDAsMTgxNDEsMTgxNDIsMTgxNDMsMTgxNDQsMTgxNDUsMTgxNDZcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW5dW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt2Y19zaW5nbGVfaW1hZ2UgaW1hZ2U9XCIxODE0M1wiIGltZ19zaXplPVwibGFyZ2VcIiBhZGRfY2FwdGlvbj1cInllc1wiIHN0eWxlPVwidmNfYm94X3NoYWRvd18zZFwiXVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJQb3B1bGFpcmUgZmFjaWxpdGVpdGVuXCIgaGVhZGluZ190YWc9XCJoM1wiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjMwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF1KZSBoZXJrZW50IGhldCBFc3NleCBIb3VzZSBhYW4geiduIGljb25pc2NoZSBhcnQtZGVjbyB2ZXJsaWNodGluZyBvcCBoZXQgZGFrLCBkYXQgZXIgYWwgc2luZHMgMTkzOCBzdGFhdC4gRGUgYm9ldGllayBrYW1lcnMgemlqbiB2ZWVsYWwgcnVpbSwgaW4gendhcnQtd2l0IG1ldCBnb3VkZW4gYWNjZW50ZW4gaW5nZXJpY2h0IGVuIHZvb3J6aWVuIHZhbiBhbGxlcyB3YXQgamUgbm9kaWcgaGVidC4gWm9hbHMgZWVuIGtvZmZpZW1hY2hpbmUsIGtvZWxrYXN0amUgZW4gYWlyY28uIERlIHNmZWVyIGlzIHJldHJvLWNvb2wgZG9vciBoZXQgYmVob3VkIHZhbiBkZSBwcmFjaHRpZ2UgYXJ0LWRlY28gZWxlbWVudGVuIGdlY29tYmluZWVyZCBtZXQgbW9kZXJuIGRlc2lnbi4gRXNzZXggSG91c2UgaGVlZnQgc2xlY2h0cyA3MSBrYW1lcnMsIGdlZW4gYmFyLCB6d2VtYmFkIGVuIHJlc3RhdXJhbnQsIHdhYXJkb29yIGplIGhpZXIgaGVlcmxpamsgcnVzdGlnIGt1bnQgb3Zlcm5hY2h0ZW4uWy92Y19jb2x1bW5fdGV4dF1bdGhiX2ljb25saXN0IGljb249XCJmYXMgZmEtbWFwLW1hcmtlci1hbHRcIiBsaXN0X2NvbnRlbnQ9XCJcdTAwYzlcdTAwZTluIHN0cmFhdCB2YW5hZiBPY2VhbiBEcml2ZVwiXVt0aGJfaWNvbmxpc3QgaWNvbj1cImZhcyBmYS13aWZpXCIgbGlzdF9jb250ZW50PVwiR3JhdGlzIFdpRmlcIl1bdGhiX2ljb25saXN0IGljb249XCJmYXMgZmEtZG9sbGFyLXNpZ25cIiBsaXN0X2NvbnRlbnQ9XCJCZXRhYWxiYWFyXCJdW3RoYl9pY29ubGlzdCBpY29uPVwiZmFzIGZhLWJlZFwiIGxpc3RfY29udGVudD1cIkNvbWZvcnRhYmxlIGthbWVycyBtZXQgUml0dWFscyBiYWRwcm9kdWN0ZW5cIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMjVweFwiXVt1bHRfYnV0dG9ucyBidG5fdGl0bGU9XCJCb2VrIGVlbiBrYW1lclwiIGJ0bl9saW5rPVwidXJsOmh0dHBzJTNBJTJGJTJGd3d3LmJvb2tpbmcuY29tJTJGaG90ZWwlMkZ1cyUyRmVzc2V4LWhvdXNlLm5sLmh0bWwlM0ZhaWQlM0Q3OTU4NDk4JTI2bm9fcm9vbXMlM0QxJTI2Z3JvdXBfYWR1bHRzJTNEMiUyNmxhYmVsJTNEZXNzZXhob3VzZS1ob3RlbC1wYWdlfHRpdGxlOkJvZWslMjBlZW4lMjBrYW1lcnx0YXJnZXQ6X2JsYW5rXCIgYnRuX3RpdGxlX2NvbG9yPVwiI2ZmZmZmZlwiIGJ0bl9iZ19jb2xvcj1cIiNiMzRhNGNcIiBidG5faG92ZXI9XCJ1YnRuLWJvdHRvbS1iZ1wiIGJ0bl9iZ19jb2xvcl9ob3Zlcj1cIiM1MzFhMjNcIiBpY29uX3NpemU9XCIzMlwiIGJ0bl9pY29uX3Bvcz1cInVidG4tc2VwLWljb24tYXQtbGVmdFwiIGJ0bl9mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBidG5fZm9udF9zaXplPVwiZGVza3RvcDoyMHB4O1wiIGJ0bl9saW5lX2hlaWdodD1cImRlc2t0b3A6MjVweDtcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW5dWy92Y19jb2x1bW5dWy92Y19yb3ddIiwicG9zdF90aXRsZSI6IkVzc2V4IEhvdXNlIE1pYW1pIEJlYWNoIiwicG9zdF9saW5rIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9vdmVybmFjaHRlbi1taWFtaS9lc3NleC1ob3VzZS1taWFtaS1iZWFjaC8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJFZW4ga2FtZXIgaW4gaGV0IGljb25pc2NoZSBhcnQtZGVjbyBFc3NleCBIb3VzZSBob3RlbCBpbiBNaWFtaSBCZWFjaFwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMy8xMi9lc3NleC1ob3VzZS1taWFtaS1iZWFjaC0zMDB4MjAwLmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6Ik92ZXJuYWNodGVuIGluIE1pYW1pIiwicG9zdF90YWdzIjoiIiwiJWlubGluZV9mZWF0dXJlZF9pbWFnZSUiOiIwIiwiJV9lZGl0X2xvY2slIjoiMTcwMjAyMzUyOToxIiwiJV9lZGl0X2xhc3QlIjoiMSIsIiVfeW9hc3Rfd3BzZW9fcHJpbWFyeV9jYXRlZ29yeSUiOiIyMzQiLCIlX3RodW1ibmFpbF9pZCUiOiIxODEzNCIsIiVfaGlkZV9mZWF0dXJlZCUiOm51bGwsIiVfd3BnbXBfbG9jYXRpb25fYWRkcmVzcyUiOiIxMDAxIENvbGxpbnMgQXZlLCBNaWFtaSBCZWFjaCwgRkwgMzMxMzksIFZlcmVuaWdkZSBTdGF0ZW4iLCIlX3dwZ21wX2xvY2F0aW9uX2NpdHklIjoiTWlhbWkgQmVhY2giLCIlX3dwZ21wX2xvY2F0aW9uX3N0YXRlJSI6IkZsb3JpZGEiLCIlX3dwZ21wX2xvY2F0aW9uX2NvdW50cnklIjoiVmVyZW5pZ2RlIFN0YXRlbiIsIiVfd3BnbXBfbWV0YWJveF9sYXRpdHVkZSUiOiIyNS43ODA3NDE1IiwiJV93cGdtcF9tZXRhYm94X2xvbmdpdHVkZSUiOiItODAuMTMxNDc4NSIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiN1wiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6ImE6MTp7aTowO3M6MjpcIjEzXCI7fSIsIiVfd3BnbXBfbWV0YWJveF90YXhvbW9taWVzX3Rlcm1zJSI6IiIsIiVfd3BnbXBfZXh0ZW5zaW9uc19maWVsZHMlIjoiIiwiJV93cGJfdmNfanNfc3RhdHVzJSI6InRydWUiLCIlX3lvYXN0X3dwc2VvX2NvbnRlbnRfc2NvcmUlIjoiNjAiLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza2V5d29yZHMlIjoiW10iLCIlX3lvYXN0X3dwc2VvX2tleXdvcmRzeW5vbnltcyUiOiJbXCJcIl0iLCIlX3lvYXN0X3dwc2VvX2VzdGltYXRlZC1yZWFkaW5nLXRpbWUtbWludXRlcyUiOiIyIiwiJXBvc3QtcHJpbWFyeS1jYXRlZ29yeSUiOiJhdXRvIiwiJWZlYXR1cmVkX2ltYWdlX292ZXJyaWRlJSI6Im9mZiIsIiVzdGFuZGFyZC1mZWF0dXJlZC1jcmVkaXQlIjoiRXNzZXggSG91c2UgTWlhbWkgQmVhY2giLCIlYXJ0aWNsZV9zdHlsZV9vdmVycmlkZSUiOiJvbiIsIiVwb3N0X3N0eWxlJSI6InN0eWxlNSIsIiVwb3N0X2dhbGxlcnlfc3R5bGUlIjoibGlnaHRib3giLCIlcG9zdF9yZXZpZXclIjoib2ZmIiwiJXBvc3RfcmV2aWV3X3N0eWxlJSI6InN0eWxlMSIsIiVwb3N0X3Jldmlld19hdmVyYWdlJSI6IjUwIiwiJV95b2FzdF93cHNlb19mb2N1c2t3JSI6IkVzc2V4IEhvdXNlIE1pYW1pIEJlYWNoIiwiJV95b2FzdF93cHNlb19tZXRhZGVzYyUiOiJHbGl0dGVyLCBnbGFtb3VyIFx1MDBlOW4gY2VsZWJyaXRpZXMgc3BvdHRlbiBpbiBkaXQgbGVnZW5kYXJpc2NoZSBNaWFtaSBCZWFjaCByZXNvcnQuIFZvb3JhbCBkZSB6d2VtYmFkZmVlc3RqZXMgemlqbiBwb3B1bGFpciBpbiBoZXQgRm9udGFpbmVibGVhdSEiLCIlX3lvYXN0X3dwc2VvX2xpbmtkZXglIjoiNjgiLCIlcG9zdF9zb3VyY2UlIjpbeyJ0aXRsZSI6IkZvdG9ncmFmaWU6IEVzc2V4IEhvdXNlIE1pYW1pIEJlYWNoIiwicG9zdF9zb3VyY2VfdXJsIjoiaHR0cHM6Ly93d3cuZXNzZXhob3RlbC5jb20ifV0sIiVfeW9hc3RfaW5kZXhub3dfbGFzdF9waW5nJSI6IjE3MDE2MTYzMzAiLCIlX3d3c19zdXBwb3J0X2NvbnRhY3RfbnVtYmVyJSI6IiIsIiVfd3dzX2Fib3V0X3N1cHBvcnRfdGV4dCUiOiIiLCIlX3d3c190cmlnZ2VyX2J1dHRvbl90ZXh0JSI6IiIsIiVfd3dzX3ByZWRlZmluZWRfdGV4dCUiOiIiLCIlX3lvYXN0X3dwc2VvX3dvcmRwcm9vZl90aW1lc3RhbXAlIjoiIiwiJV9sYXN0X2VkaXRvcl91c2VkX2pldHBhY2slIjoiY2xhc3NpYy1lZGl0b3IiLCJ0YXhvbm9teT1jYXRlZ29yeSI6Ik92ZXJuYWNodGVuIGluIE1pYW1pIiwidGF4b25vbXk9cG9zdF90YWciOiIiLCJ0YXhvbm9teT1wb3N0X2Zvcm1hdCI6IiIsInRheG9ub215PXRoYi1yZWFjdGlvbnMiOiIiLCJ0YXhvbm9teT10aGItc3BvbnNvcnMiOiIifSwiaWNvbiI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjEvMDQvaG90ZWwucG5nIn0sImlkIjoxODEzMywiaW5mb3dpbmRvd19kaXNhYmxlIjpmYWxzZSwiY2F0ZWdvcmllcyI6W3siaWNvbiI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjEvMDQvaG90ZWwucG5nIiwibmFtZSI6IkhvdGVscyIsImlkIjoiMTMiLCJ0eXBlIjoiY2F0ZWdvcnkiLCJleHRlbnNpb25fZmllbGRzIjp7ImNhdF9vcmRlciI6IiJ9fV19LHsic291cmNlIjoicG9zdCIsInRpdGxlIjoiRm9udGFpbmVibGVhdSBNaWFtaSIsImluZm93aW5kb3dfY29udGVudCI6IjxkaXYgY2xhc3M9XCJmYy1pdGVtLWJveCBmYy1pdGVtLW5vLXBhZGRpbmcgXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIkVlbiBrYW1lciBtZXQgemVlemljaHQgaW4gaGV0IGJlcm9lbWRlIEZvbnRhaW5lYmxlYXUgcmVzb3J0IGluIE1pYW1pIEJlYWNoXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMDBcIiBzcmM9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIzLzEyL2ZvbnRhaW5lYmxlYXUtbWlhbWktYmVhY2gtMzAweDIwMC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmcgZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+Rm9udGFpbmVibGVhdSBNaWFtaTwvZGl2PlxyXG4gICAgICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1jb250ZW50IGZjLWl0ZW0tYm9keS10ZXh0LWNvbG9yXCI+e21hcmtlcl9hZGRyZXNzfTwvZGl2PlxyXG4gICAgICAgIDwvZGl2PlxyXG4gICAgPC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtY2xlYXJcIj48L2Rpdj5cclxuPC9kaXY+IiwiYWRkcmVzcyI6IjQ0NDEgQ29sbGlucyBBdmUsIE1pYW1pIEJlYWNoLCBGTCAzMzE0MCwgVmVyZW5pZ2RlIFN0YXRlbiIsImxvY2F0aW9uIjp7ImxhdCI6IjI1LjgxNzc2NzciLCJjaXR5IjoiTWlhbWkgQmVhY2giLCJzdGF0ZSI6IkZsb3JpZGEiLCJjb3VudHJ5IjoiVmVyZW5pZ2RlIFN0YXRlbiIsImxuZyI6Ii04MC4xMjI0NTgyOTk5OTk5OSIsIm9uY2xpY2tfYWN0aW9uIjoibWFya2VyIiwicmVkaXJlY3RfcGVybWFsaW5rIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9vdmVybmFjaHRlbi1taWFtaS9mb250YWluZWJsZWF1LW1pYW1pLyIsInpvb20iOjEyLCJleHRyYV9maWVsZHMiOnsicG9zdF9leGNlcnB0IjoiIiwicG9zdF9jb250ZW50IjoiW3ZjX3Jvd11bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjIvM1wiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJDZWxlYnJpdHkgcmVzb3J0IGluIE1pYW1pXCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjQ1cHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDo1MHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCI0NDQxIENvbGxpbnMgQXZlbnVlLCBNaWFtaSBCZWFjaFwiIGhlYWRpbmdfdGFnPVwiZGl2XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6T3N3YWxkfGZvbnRfY2FsbDpPc3dhbGRcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDozMHB4O1wiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6MzVweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XVxyXG48cCBzdHlsZT1cInRleHQtYWxpZ246IGNlbnRlcjtcIj5cdTJiNTBcdWZlMGZcdTJiNTBcdWZlMGZcdTJiNTBcdWZlMGZcdTJiNTBcdWZlMGZcdTJiNTBcdWZlMGY8L3A+XHJcblsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiRm9udGFpbmVibGVhdSBNaWFtaSBCZWFjaFwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjMwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIiQkJCRcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjYzU5YzRkXCIgYWxpZ25tZW50PVwibGVmdFwiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6MzBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XUhldCBGb250YWluZWJsZWF1IGluIE1pYW1pIEJlYWNoIGlzIGVlbiBsZWdlbmRhcmlzY2ggY2VsZWJyaXR5IHJlc29ydCB3YWFyIHdlcmVsZGJlcm9lbWRlIGNlbGVicml0aWVzIGFscyBMYWR5IEdhZ2EsIEtpbSBLYXJkYXNoaWFuIGVuIHplbGZzIEVsdmlzIFByZXNsZXkgdmVyYmxldmVuLiBEaXQgbGV2ZW5kaWdlLCBpY29uaXNjaGUgaG90ZWwgaW4gTWlkIEJlYWNoIHdlcmQgaW4gZGUgamFyZW4gJzUwIG9udHdvcnBlbiBkb29yIGFyY2hpdGVjdCBNb3JyaXMgTGFwaWR1cyBlbiBiZXN0YWF0IHVpdCBtZWVyZGVyZSBnZWJvdXdlbiBlbiB0b3JlbnMuIFZvb3JhbCBoZXQgendlbWJhZCBpcyBsZWdlbmRhcmlzY2ggdmFud2VnZSBkZSB2ZWxlIGZlZXN0amVzIGVuIHBvbXBlbmRlIGJlYXRzLiBIZXQgcmVzb3J0IGRpZW5kZSBhbHMgbG9jYXRpZSB2b29yIHRhbGxvemUgaWNvbmlzY2hlIGZpbG1zIGVuIHR2LXNob3dzLCB3YWFyb25kZXIgVGhlIEJvZHlndWFyZCBtZXQgV2hpdG5leSBIb3VzdG9uIGVuIEtldmluIENvc3RuZXIuIEhldCBoZWVmdCBib3ZlbmRpZW4gZWVuIHJlcHV0YXRpZSBvcGdlYm91d2QgYWxzIGhvdHNwb3Qgdm9vciBiZXJvZW1kaGVkZW4uIERlIHdlcmVsZGJlcm9lbWRlIHBvb2xwYXJ0eSdzIGVuIG5hY2h0Y2x1YnMgdmFuIGhldCByZXNvcnQgdHJla2tlbiByZWdlbG1hdGlnIGJlcm9lbWRoZWRlbiBhYW4sIHdhYXJkb29yIGhldCBGb250YWluZWJsZWF1IFJlc29ydCBkXHUwMGU5IHBsZWsgaXMgb20gamUgZmF2b3JpZXRlIHN0ZXJyZW4gdGVnZW4gdGUga29tZW4uWy92Y19jb2x1bW5fdGV4dF1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJHZXNlbGVjdGVlcmQgZG9vciBIZXkhVVNBXCIgYWxpZ25tZW50PVwibGVmdFwiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OlJvYm90byBTbGFifGZvbnRfY2FsbDpSb2JvdG8rU2xhYnx2YXJpYW50OjgwMFwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjIwcHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19zdHlsZT1cImZvbnQtd2VpZ2h0OjgwMDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XUhldCBGb250YWluZWJsZWF1IGlzIGFic29sdXV0IGVlbiBrbGFzc2lla2VyIGluIE1pYW1pIEJlYWNoLiBIZXQgcmVzb3J0IGlzIGdpZ2FudGlzY2gsIGhlZWZ0IG1lZXJkZXJlIHJlc3RhdXJhbnRzLCB6d2VtYmFkZW4sIG5hY2h0Y2x1YnMgZW4gZWVuIHZpbnRhZ2UtY2hpcXVlIHN0aWpsIG1ldCB2ZWVsIHdpdC4gSGV0IGhvdGVsIGxpZ3QgZGlyZWN0IGFhbiBoZXQgc3RyYW5kLCB3YWFyZG9vciBqZSBkZSBiZWF0cyB2YW4gaGV0IGJlcm9lbWRlIHp3ZW1iYWQgYWwgdmFuIHZlciBrdW50IGhvcmVuIGFscyBqZSBlZW4gd2FuZGVsaW5nIG1hYWt0IG92ZXIgZGUgTWlhbWkgQmVhY2ggQm9hcmR3YWxrLiBaZWtlciB2b29yIGpvbmdlcmVuIGlzIGRpdCBkXHUwMGU5ICdwbGFjZSB0byBiZScuWy92Y19jb2x1bW5fdGV4dF1bdWx0X2J1dHRvbnMgYnRuX3RpdGxlPVwiQm9layBlZW4ga2FtZXJcIiBidG5fbGluaz1cInVybDpodHRwcyUzQSUyRiUyRnd3dy5ib29raW5nLmNvbSUyRmhvdGVsJTJGdXMlMkZmb250YWluZWJsZWF1LXJlc29ydC5ubC5odG1sJTNGYWlkJTNENzk1ODQ5OCUyNm5vX3Jvb21zJTNEMSUyNmdyb3VwX2FkdWx0cyUzRDIlMjZsYWJlbCUzRGZvbnRhaW5lYmxlYXUtaG90ZWwtcGFnZXx0aXRsZTpCb2VrJTIwZWVuJTIwa2FtZXJ8dGFyZ2V0Ol9ibGFua1wiIGJ0bl90aXRsZV9jb2xvcj1cIiNmZmZmZmZcIiBidG5fYmdfY29sb3I9XCIjYjM0YTRjXCIgYnRuX2hvdmVyPVwidWJ0bi1ib3R0b20tYmdcIiBidG5fYmdfY29sb3JfaG92ZXI9XCIjNTMxYTIzXCIgaWNvbl9zaXplPVwiMzJcIiBidG5faWNvbl9wb3M9XCJ1YnRuLXNlcC1pY29uLWF0LWxlZnRcIiBidG5fZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgYnRuX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjBweDtcIiBidG5fbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjI1cHg7XCJdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt2Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjIvM1wiXVt0aGJfaW1hZ2Vfc2xpZGVyIGxpZ2h0Ym94PVwibWZwLWdhbGxlcnlcIiB0aGJfZXF1YWxfaGVpZ2h0PVwidHJ1ZVwiIGF1dG9wbGF5PVwidHJ1ZVwiIGltYWdlcz1cIjE4MTI0LDE4MTI1LDE4MTI2LDE4MTI3LDE4MTI4LDE4MTI5LDE4MTMwLDE4MTMxLDE4MTIwXCJdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfc2luZ2xlX2ltYWdlIGltYWdlPVwiMTgxMjlcIiBpbWdfc2l6ZT1cImxhcmdlXCIgYWRkX2NhcHRpb249XCJ5ZXNcIiBzdHlsZT1cInZjX2JveF9zaGFkb3dfM2RcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiUG9wdWxhaXJlIGZhY2lsaXRlaXRlblwiIGhlYWRpbmdfdGFnPVwiaDNcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozMHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdSGV0IEZvbnRhaW5lYmxlYXUgaW4gTWlhbWkgQmVhY2ggaXMgdm9vcmFsIGhlcmtlbmJhYXIgYWFuIGhldCBob3RlbCBpbiBkZSBoYWx2ZSBib29nLCB1aXRraWprZW5kIG9wIGhldCBncm90ZSB6d2VtYmFkLiBJbiBkZSBUclx1MDBlOXNvciB0b3JlbiBlbiBkZSBTb3JyZW50byB0b3JlbiBiZXZpbmRlbiB6aWNoIHZvb3JuYW1lbGlqayBzdWl0ZXMgZW4gYXBwYXJ0ZW1lbnRlbi4gSGV0IHJlc29ydCBpcyBtb2Rlcm4sIGx1eHVldXMgZW4gaGVlZnQgbWVlcmRlcmUgcmVzdGF1cmFudHMsIHdhYXJvbmRlciBlZW4gZmlsaWFhbCB2YW4gaGV0IGJlcm9lbWRlIEhha2thc2FuLiBEZSBuYWNodGNsdWJzIHppam4gcG9wdWxhaXIgYmlqIGRlIGxvY2FscyBcdTAwZTluIGNlbGVicml0aWVzIGluIGluIEJsZWF1TGl2ZSB0cmVkZW4gcmVnZWxtYXRpZyBncm90ZSBzdGVycmVuIG9wLCB6b2FscyBKZW5uaWZlciBMb3Blei4gTGlnIGplIGxpZXZlciBhYW4gaGV0IHN0cmFuZD8gRm9udGFpbmVibGVhdSBsaWd0IGxldHRlcmxpamsgYWFuIE1pYW1pIEJlYWNoIG1ldCBlZW4gcHJpdlx1MDBlOSBnZWRlZWx0ZSB2b29yIGhvdGVsZ2FzdGVuLlsvdmNfY29sdW1uX3RleHRdW3RoYl9pY29ubGlzdCBpY29uPVwiZmFzIGZhLW1hcC1tYXJrZXItYWx0XCIgbGlzdF9jb250ZW50PVwiTGVnZW5kYXJpc2NoIGhvdGVsIGluIE1pZCBCZWFjaCBNaWFtaVwiXVt0aGJfaWNvbmxpc3QgaWNvbj1cImZhcyBmYS13aWZpXCIgbGlzdF9jb250ZW50PVwiR3JhdGlzIFdpRmlcIl1bdGhiX2ljb25saXN0IGljb249XCJmYXMgZmEtdXRlbnNpbHNcIiBsaXN0X2NvbnRlbnQ9XCJNZWVyZGVyZSByZXN0YXVyYW50c1wiXVt0aGJfaWNvbmxpc3QgaWNvbj1cImZhcyBmYS1nbGFzcy1jaGVlcnNcIiBsaXN0X2NvbnRlbnQ9XCJNZWVyZGVyZSBiYXJzIGVuIG5hY2h0Y2x1YnNcIl1bdGhiX2ljb25saXN0IGljb249XCJmYXMgZmEtZG9sbGFyLXNpZ25cIiBsaXN0X2NvbnRlbnQ9XCJUb3BzZWdtZW50IGhvdGVsXCJdW3RoYl9pY29ubGlzdCBpY29uPVwiZmFzIGZhLWJlZFwiIGxpc3RfY29udGVudD1cIlByYWNodGlnZSBrYW1lcnMgbWV0IHplZXppY2h0XCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjI1cHhcIl1bdWx0X2J1dHRvbnMgYnRuX3RpdGxlPVwiQm9layBlZW4ga2FtZXJcIiBidG5fbGluaz1cInVybDpodHRwcyUzQSUyRiUyRnd3dy5ib29raW5nLmNvbSUyRmhvdGVsJTJGdXMlMkZmb250YWluZWJsZWF1LXJlc29ydC5ubC5odG1sJTNGYWlkJTNENzk1ODQ5OCUyNm5vX3Jvb21zJTNEMSUyNmdyb3VwX2FkdWx0cyUzRDIlMjZsYWJlbCUzRGZvbnRhaW5lYmxlYXUtaG90ZWwtcGFnZXx0aXRsZTpCb2VrJTIwZWVuJTIwa2FtZXJ8dGFyZ2V0Ol9ibGFua1wiIGJ0bl90aXRsZV9jb2xvcj1cIiNmZmZmZmZcIiBidG5fYmdfY29sb3I9XCIjYjM0YTRjXCIgYnRuX2hvdmVyPVwidWJ0bi1ib3R0b20tYmdcIiBidG5fYmdfY29sb3JfaG92ZXI9XCIjNTMxYTIzXCIgaWNvbl9zaXplPVwiMzJcIiBidG5faWNvbl9wb3M9XCJ1YnRuLXNlcC1pY29uLWF0LWxlZnRcIiBidG5fZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgYnRuX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjBweDtcIiBidG5fbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjI1cHg7XCJdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uXVsvdmNfY29sdW1uXVsvdmNfcm93XSIsInBvc3RfdGl0bGUiOiJGb250YWluZWJsZWF1IE1pYW1pIiwicG9zdF9saW5rIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9vdmVybmFjaHRlbi1taWFtaS9mb250YWluZWJsZWF1LW1pYW1pLyIsInBvc3RfZmVhdHVyZWRfaW1hZ2UiOiI8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIkVlbiBrYW1lciBtZXQgemVlemljaHQgaW4gaGV0IGJlcm9lbWRlIEZvbnRhaW5lYmxlYXUgcmVzb3J0IGluIE1pYW1pIEJlYWNoXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMDBcIiBzcmM9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIzLzEyL2ZvbnRhaW5lYmxlYXUtbWlhbWktYmVhY2gtMzAweDIwMC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj4iLCJwb3N0X2NhdGVnb3JpZXMiOiJPdmVybmFjaHRlbiBpbiBNaWFtaSIsInBvc3RfdGFncyI6IiIsIiVpbmxpbmVfZmVhdHVyZWRfaW1hZ2UlIjoiMCIsIiVfZWRpdF9sb2NrJSI6IjE3MDE2MTM2Njk6MSIsIiVfZWRpdF9sYXN0JSI6IjEiLCIlX3lvYXN0X3dwc2VvX3ByaW1hcnlfY2F0ZWdvcnklIjoiMjM0IiwiJV90aHVtYm5haWxfaWQlIjoiMTgxMjAiLCIlX2hpZGVfZmVhdHVyZWQlIjpudWxsLCIlX3dwZ21wX2xvY2F0aW9uX2FkZHJlc3MlIjoiNDQ0MSBDb2xsaW5zIEF2ZSwgTWlhbWkgQmVhY2gsIEZMIDMzMTQwLCBWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9sb2NhdGlvbl9jaXR5JSI6Ik1pYW1pIEJlYWNoIiwiJV93cGdtcF9sb2NhdGlvbl9zdGF0ZSUiOiJGbG9yaWRhIiwiJV93cGdtcF9sb2NhdGlvbl9jb3VudHJ5JSI6IlZlcmVuaWdkZSBTdGF0ZW4iLCIlX3dwZ21wX21ldGFib3hfbGF0aXR1ZGUlIjoiMjUuODE3NzY3NyIsIiVfd3BnbXBfbWV0YWJveF9sb25naXR1ZGUlIjoiLTgwLjEyMjQ1ODI5OTk5OTk5IiwiJV93cGdtcF9tZXRhYm94X2xvY2F0aW9uX3JlZGlyZWN0JSI6Im1hcmtlciIsIiVfd3BnbXBfbWV0YWJveF9jdXN0b21fbGluayUiOiIiLCIlX3dwZ21wX21hcF9pZCUiOiJhOjE6e2k6MDtzOjE6XCI3XCI7fSIsIiVfd3BnbXBfbWV0YWJveF9tYXJrZXJfaWQlIjoiYToxOntpOjA7czoyOlwiMTNcIjt9IiwiJV93cGdtcF9tZXRhYm94X3RheG9tb21pZXNfdGVybXMlIjoiIiwiJV93cGdtcF9leHRlbnNpb25zX2ZpZWxkcyUiOiIiLCIlX3dwYl92Y19qc19zdGF0dXMlIjoidHJ1ZSIsIiVfeW9hc3Rfd3BzZW9fY29udGVudF9zY29yZSUiOiI2MCIsIiVfeW9hc3Rfd3BzZW9fZm9jdXNrZXl3b3JkcyUiOiJbXSIsIiVfeW9hc3Rfd3BzZW9fa2V5d29yZHN5bm9ueW1zJSI6IltcIlwiXSIsIiVfeW9hc3Rfd3BzZW9fZXN0aW1hdGVkLXJlYWRpbmctdGltZS1taW51dGVzJSI6IjMiLCIlcG9zdC1wcmltYXJ5LWNhdGVnb3J5JSI6ImF1dG8iLCIlZmVhdHVyZWRfaW1hZ2Vfb3ZlcnJpZGUlIjoib2ZmIiwiJXN0YW5kYXJkLWZlYXR1cmVkLWNyZWRpdCUiOiJGb250YWluZWJsZWF1IE1pYW1pIEJlYWNoIiwiJWFydGljbGVfc3R5bGVfb3ZlcnJpZGUlIjoib24iLCIlcG9zdF9zdHlsZSUiOiJzdHlsZTUiLCIlcG9zdF9nYWxsZXJ5X3N0eWxlJSI6ImxpZ2h0Ym94IiwiJXBvc3RfcmV2aWV3JSI6Im9mZiIsIiVwb3N0X3Jldmlld19zdHlsZSUiOiJzdHlsZTEiLCIlcG9zdF9yZXZpZXdfYXZlcmFnZSUiOiI1MCIsIiVfeW9hc3Rfd3BzZW9fZm9jdXNrdyUiOiJGb250YWluZWJsZWF1IE1pYW1pIEJlYWNoIiwiJV95b2FzdF93cHNlb19tZXRhZGVzYyUiOiJHbGl0dGVyLCBnbGFtb3VyIFx1MDBlOW4gY2VsZWJyaXRpZXMgc3BvdHRlbiBpbiBkaXQgbGVnZW5kYXJpc2NoZSBNaWFtaSBCZWFjaCByZXNvcnQuIFZvb3JhbCBkZSB6d2VtYmFkZmVlc3RqZXMgemlqbiBwb3B1bGFpciBpbiBoZXQgRm9udGFpbmVibGVhdSEiLCIlX3lvYXN0X3dwc2VvX2xpbmtkZXglIjoiNjMiLCIlcG9zdF9zb3VyY2UlIjpbeyJ0aXRsZSI6IkZvdG9ncmFmaWU6IEZvbnRhaW5lYmxlYXUgTWlhbWkgQmVhY2giLCJwb3N0X3NvdXJjZV91cmwiOiJodHRwczovL3d3dy5mb250YWluZWJsZWF1LmNvbSJ9XSwiJV95b2FzdF9pbmRleG5vd19sYXN0X3BpbmclIjoiMTcwMTYxMzY1NCIsIiVfd3dzX3N1cHBvcnRfY29udGFjdF9udW1iZXIlIjoiIiwiJV93d3NfYWJvdXRfc3VwcG9ydF90ZXh0JSI6IiIsIiVfd3dzX3RyaWdnZXJfYnV0dG9uX3RleHQlIjoiIiwiJV93d3NfcHJlZGVmaW5lZF90ZXh0JSI6IiIsIiVfeW9hc3Rfd3BzZW9fd29yZHByb29mX3RpbWVzdGFtcCUiOiIiLCIlX2xhc3RfZWRpdG9yX3VzZWRfamV0cGFjayUiOiJjbGFzc2ljLWVkaXRvciIsInRheG9ub215PWNhdGVnb3J5IjoiT3Zlcm5hY2h0ZW4gaW4gTWlhbWkiLCJ0YXhvbm9teT1wb3N0X3RhZyI6IiIsInRheG9ub215PXBvc3RfZm9ybWF0IjoiIiwidGF4b25vbXk9dGhiLXJlYWN0aW9ucyI6IiIsInRheG9ub215PXRoYi1zcG9uc29ycyI6IiJ9LCJpY29uIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMS8wNC9ob3RlbC5wbmcifSwiaWQiOjE4MTE5LCJpbmZvd2luZG93X2Rpc2FibGUiOmZhbHNlLCJjYXRlZ29yaWVzIjpbeyJpY29uIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMS8wNC9ob3RlbC5wbmciLCJuYW1lIjoiSG90ZWxzIiwiaWQiOiIxMyIsInR5cGUiOiJjYXRlZ29yeSIsImV4dGVuc2lvbl9maWVsZHMiOnsiY2F0X29yZGVyIjoiIn19XX0seyJzb3VyY2UiOiJwb3N0IiwidGl0bGUiOiJMaWZlIEhvdXNlIExpdHRsZSBIYXZhbmEiLCJpbmZvd2luZG93X2NvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nIFwiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJMaWZlIEhvdXNlIGhvdGVsIGluIGRlIHdpamsgTGl0dGxlIEhhdmFuYSBpbiBNaWFtaVwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMy8xMi9saWZlLWhvdXNlLWhvdGVsLWxpdHRsZS1oYXZhbmEtbWlhbWktMzAweDIwMC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmcgZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+TGlmZSBIb3VzZSBMaXR0bGUgSGF2YW5hPC9kaXY+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3JcIj57bWFya2VyX2FkZHJlc3N9PC9kaXY+XHJcbiAgICAgICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1jbGVhclwiPjwvZGl2PlxyXG48L2Rpdj4iLCJhZGRyZXNzIjoiNTI4IFNXIDl0aCBBdmUsIE1pYW1pLCBGTCAzMzEzMCwgVmVyZW5pZ2RlIFN0YXRlbiIsImxvY2F0aW9uIjp7ImxhdCI6IjI1Ljc2ODI4NyIsImNpdHkiOiJNaWFtaSIsInN0YXRlIjoiRmxvcmlkYSIsImNvdW50cnkiOiJWZXJlbmlnZGUgU3RhdGVuIiwibG5nIjoiLTgwLjIwOTM1NDMiLCJvbmNsaWNrX2FjdGlvbiI6Im1hcmtlciIsInJlZGlyZWN0X3Blcm1hbGluayI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvb3Zlcm5hY2h0ZW4tbWlhbWkvbGlmZS1ob3VzZS1saXR0bGUtaGF2YW5hLyIsInpvb20iOjEyLCJleHRyYV9maWVsZHMiOnsicG9zdF9leGNlcnB0IjoiIiwicG9zdF9jb250ZW50IjoiW3ZjX3Jvd11bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjIvM1wiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJMaWZlIEhvdXNlIEhvdGVsXCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjQ1cHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDo1MHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCI1MjggU1cgOXRoIEF2ZW51ZSwgTGl0dGxlIEhhdmFuYSBNaWFtaVwiIGhlYWRpbmdfdGFnPVwiZGl2XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6T3N3YWxkfGZvbnRfY2FsbDpPc3dhbGRcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDozMHB4O1wiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6MzVweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XVxyXG48cCBzdHlsZT1cInRleHQtYWxpZ246IGNlbnRlcjtcIj5cdTJiNTBcdWZlMGZcdTJiNTBcdWZlMGZcdTJiNTBcdWZlMGZcdTJiNTBcdWZlMGZcdTJiNTBcdWZlMGY8L3A+XHJcblsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiTGlmZSBIb3VzZSBIb3llbCBpbiBMaXR0bGUgSGF2YW5hLCBNaWFtaVwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjMwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIiQkJCRcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjYzU5YzRkXCIgYWxpZ25tZW50PVwibGVmdFwiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6MzBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XU9wIHNsZWNodHMgdHdlZSBzdHJhdGVuIHZhbiBoZXQgZ2V6ZWxsaWdlIENhbGxlIE9jaG8gKDh0aCBTdHJlZXQpIGtvbSBqZSBkZXplIHBhcmVsIHRlZ2VuLiBWZXJibGlqdmVuIGluIExpZmUgSG91c2UgTGl0dGxlIEhhdmFuYSBpbiBNaWFtaSBpcyBhbHNvZiBqZSBvcCByZWlzIGJlbnQgaW4gQ3ViYS4gTGl0dGxlIEhhdmFuYSBpcyBoZXQga2xldXJyaWprZSBjZW50cnVtIHZhbiBkZSBTcGFhbnMgQ3ViYWFuc2UgY3VsdHV1ciBpbiBNaWFtaS4gSGV0IGdlYmllZCBpcyBiZXphYWlkIG1ldCBMYXRpam5zLWdlXHUwMGVmbnNwaXJlZXJkZSBjYWZcdTAwZTlzLCByZXN0YXVyYW50cyBlbiBDdWJhYW5zZSBzaWdhcmVud2lua2Vscy4gTGlmZSBIb3VzZSB6aWV0IGVyIHplbGYgZGFuIG9vayB1aXQgYWxzb2YgamUgaW4gZWVuIEN1YmFhbnNlIHZpbGxhIHZlcmJsaWpmdC4gVGVycmFjb3R0YSwgZG9ua2VyZ3JvZW4gZW4gdmVlbCBob3V0IGdldmVuIGhldCBob3RlbCBlZW4gdmludGFnZSBDdWJhYW5zZSBzZmVlci4gRGUgd2VlbGRlcmlnZSAnY291cnR5YXJkJyBtZXQgcGxhbnRlbiBlbiB0YXBpanRlbiBlbiByaWV0ZW4gc3RvZWxlbiBkb2VuIGplIGdlbG92ZW4gZGF0IGplIG5pZXQgaW4gTWlhbWkgYmVudC5bL3ZjX2NvbHVtbl90ZXh0XVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIkdlc2VsZWN0ZWVyZCBkb29yIEhleSFVU0FcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6Um9ib3RvIFNsYWJ8Zm9udF9jYWxsOlJvYm90bytTbGFifHZhcmlhbnQ6ODAwXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjBweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX3N0eWxlPVwiZm9udC13ZWlnaHQ6ODAwO1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdRGl0IGJpanpvbmRlcmUgaG90ZWwgaXMgbmlldCBlbmtlbCBlZW4gYWFucmFkZXIgdmFud2VnZSBkZSBsb2NhdGllIGluIExpdHRsZSBIYXZhbmEsIGhldCBob3RlbCB6ZWxmIGlzIHByYWNodGlnIGVuIHRvdCBpbiBkZSBrbGVpbnN0ZSBkZXRhaWxzIG9udHdvcnBlbiBpbiBlZW4gcmV0cm8gQ3ViYWFuc2Ugc3RpamwuIERlIHNmZWVyIGluIGRlIGthbWVycyBpcyB3YXJtLCBtZXQgZG9ua2VyIGhvdXQsIGJlZGxpbm5lbiB2YW4gJ1Jldml2YWwgTmV3IFlvcmsnIGVuIHByb2R1Y3RlbiB2YW4gJ0xlIExhYm8nLiBCaWp6b25kZXIgaXMgZGUgJ01vZGVybiBEb3VibGUnIGthbWVyIHdhYXIgamUgbWV0IGVlbiB2cmllbmQgb2YgdnJpZW5kaW4ga3VudCBsb2dlcmVuIGluIGVlbiB2aWRlLXN0YXBlbGJlZCBtZXQgdmFzdGUgdHJhcC4gQWxsZSBrYW1lcnMgaGViYmVuIHByYWNodGlnZSBob3V0ZW4gdmxvZXJlbiwgZWVuIG1vb2llIGJhZGthbWVyIG1ldCBtb3phXHUwMGVmZWsgdGVnZWxzIGVuIGdvdWRlbiBrcmFuZW4uIEtvcnRvbTogZGl0IGlzIFx1MDBlOWNodCBlZW4gI3dvdyBob3RlbCBpbiBlZW4gYmlqem9uZGVyZSB3aWprLiBJZGVhYWwgdm9vciBhbHMgamUgJ29mZiB0aGUgYmVhdGVuIHBhdGgnIHdpbHQgaW4gTWlhbWkuWy92Y19jb2x1bW5fdGV4dF1bdWx0X2J1dHRvbnMgYnRuX3RpdGxlPVwiQm9layBlZW4ga2FtZXJcIiBidG5fbGluaz1cInVybDpodHRwcyUzQSUyRiUyRnd3dy5ib29raW5nLmNvbSUyRmhvdGVsJTJGdXMlMkZsaWZlLWhvdXNlLWxpdHRsZS1oYXZhbmEubmwuaHRtbCUzRmFpZCUzRDc5NTg0OTglMjZub19yb29tcyUzRDElMjZncm91cF9hZHVsdHMlM0QyJTI2bGFiZWwlM0RsaWZlLWhvdXNlLWhvdGVsLXBhZ2V8dGl0bGU6Qm9layUyMGVlbiUyMGthbWVyfHRhcmdldDpfYmxhbmtcIiBidG5fdGl0bGVfY29sb3I9XCIjZmZmZmZmXCIgYnRuX2JnX2NvbG9yPVwiI2IzNGE0Y1wiIGJ0bl9ob3Zlcj1cInVidG4tYm90dG9tLWJnXCIgYnRuX2JnX2NvbG9yX2hvdmVyPVwiIzUzMWEyM1wiIGljb25fc2l6ZT1cIjMyXCIgYnRuX2ljb25fcG9zPVwidWJ0bi1zZXAtaWNvbi1hdC1sZWZ0XCIgYnRuX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIGJ0bl9mb250X3NpemU9XCJkZXNrdG9wOjIwcHg7XCIgYnRuX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDoyNXB4O1wiXVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIyLzNcIl1bdGhiX2ltYWdlX3NsaWRlciBsaWdodGJveD1cIm1mcC1nYWxsZXJ5XCIgdGhiX2VxdWFsX2hlaWdodD1cInRydWVcIiBhdXRvcGxheT1cInRydWVcIiBpbWFnZXM9XCIxODEwNiwxODEwNywxODEwOCwxODEwOSwxODExMCwxODExMSwxODExMiwxODExMywxODExNCwxODExNSwxODEwMFwiXVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3ZjX3NpbmdsZV9pbWFnZSBpbWFnZT1cIjE4MTExXCIgaW1nX3NpemU9XCJsYXJnZVwiIGFkZF9jYXB0aW9uPVwieWVzXCIgc3R5bGU9XCJ2Y19ib3hfc2hhZG93XzNkXCJdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIlBvcHVsYWlyZSBmYWNpbGl0ZWl0ZW5cIiBoZWFkaW5nX3RhZz1cImgzXCIgYWxpZ25tZW50PVwibGVmdFwiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6MzBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XUxpZmUgSG91c2UgYmV2aW5kdCB6aWNoIGluIGRlIGtsZXVycmlqa2Ugd2lqayBMaXR0bGUgSGF2YW5hIGluIE1pYW1pLiBEZXplIHdpamsgc3RhYXQgYmVrZW5kIG9tIHppam4gQ3ViYWFuc2UgaW52bG9lZCBtZXQgdGFsbG96ZSBDdWJhYW5zZSByZXN0YXVyYW50cywgd2lua2Vscywgc2lnYXJlbndpbmtlbHMgZW4gTGF0aW5vIHZpYmVzLiBIZXQgaG90ZWwgaGVlZnQgdmVyc2NoaWxsZW5kZSBob3RlbGthbWVycyB1aXRlZW5sb3BlbmQgdmFuIEtpbmdzaXplIHRvdCBTdWl0ZSBlbiBrYW1lcnMgbWV0IHZpZGUtc3RhcGVsYmVkZGVuLiBFciBpcyBnZWVuIHp3ZW1iYWQgYWFud2V6aWcsIG1hYXIgem9ubmVuIGthbiB3ZWwgb3AgZGUgcm9vZnRvcC4gRGUgcm9vZnRvcGJhciAnVGVycmFzJyBpcyBlZW4gcG9wdWxhaXJlIHBsZWsgdm9vciBlZW4gaGFwamUgZW4gZWVuIE1vaml0byBtZXQgc3BlY3RhY3VsYWlyIHVpdHppY2h0IG9wIGRlIHNreWxpbmUgdmFuIE1pYW1pLlsvdmNfY29sdW1uX3RleHRdW3RoYl9pY29ubGlzdCBpY29uPVwiZmFzIGZhLW1hcC1tYXJrZXItYWx0XCIgbGlzdF9jb250ZW50PVwiQmlqem9uZGVyZSBsb2NhdGllIGluIExpdHRsZSBIYXZhbmFcIl1bdGhiX2ljb25saXN0IGljb249XCJmYXMgZmEtd2lmaVwiIGxpc3RfY29udGVudD1cIkdyYXRpcyBXaUZpXCJdW3RoYl9pY29ubGlzdCBpY29uPVwiZmFzIGZhLXV0ZW5zaWxzXCIgbGlzdF9jb250ZW50PVwiUm9vZnRvcCAnVGVycmFzJyBtZXQgcmVzdGF1cmFudCBlbiBiYXJcIl1bdGhiX2ljb25saXN0IGljb249XCJmYXMgZmEtZG9sbGFyLXNpZ25cIiBsaXN0X2NvbnRlbnQ9XCJOaWV0IGdvZWRrb29wIG1hYXIgdW5pZWtcIl1bdGhiX2ljb25saXN0IGljb249XCJmYXMgZmEtYmVkXCIgbGlzdF9jb250ZW50PVwiQ29tZm9ydGFiZWxlIGJlZGRlblwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIyNXB4XCJdW3VsdF9idXR0b25zIGJ0bl90aXRsZT1cIkJvZWsgZWVuIGthbWVyXCIgYnRuX2xpbms9XCJ1cmw6aHR0cHMlM0ElMkYlMkZ3d3cuYm9va2luZy5jb20lMkZob3RlbCUyRnVzJTJGbGlmZS1ob3VzZS1saXR0bGUtaGF2YW5hLm5sLmh0bWwlM0ZhaWQlM0Q3OTU4NDk4JTI2bm9fcm9vbXMlM0QxJTI2Z3JvdXBfYWR1bHRzJTNEMiUyNmxhYmVsJTNEbGlmZS1ob3VzZS1ob3RlbC1wYWdlfHRpdGxlOkJvZWslMjBlZW4lMjBrYW1lcnx0YXJnZXQ6X2JsYW5rXCIgYnRuX3RpdGxlX2NvbG9yPVwiI2ZmZmZmZlwiIGJ0bl9iZ19jb2xvcj1cIiNiMzRhNGNcIiBidG5faG92ZXI9XCJ1YnRuLWJvdHRvbS1iZ1wiIGJ0bl9iZ19jb2xvcl9ob3Zlcj1cIiM1MzFhMjNcIiBpY29uX3NpemU9XCIzMlwiIGJ0bl9pY29uX3Bvcz1cInVidG4tc2VwLWljb24tYXQtbGVmdFwiIGJ0bl9mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBidG5fZm9udF9zaXplPVwiZGVza3RvcDoyMHB4O1wiIGJ0bl9saW5lX2hlaWdodD1cImRlc2t0b3A6MjVweDtcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW5dWy92Y19jb2x1bW5dWy92Y19yb3ddIiwicG9zdF90aXRsZSI6IkxpZmUgSG91c2UgTGl0dGxlIEhhdmFuYSIsInBvc3RfbGluayI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvb3Zlcm5hY2h0ZW4tbWlhbWkvbGlmZS1ob3VzZS1saXR0bGUtaGF2YW5hLyIsInBvc3RfZmVhdHVyZWRfaW1hZ2UiOiI8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIkxpZmUgSG91c2UgaG90ZWwgaW4gZGUgd2lqayBMaXR0bGUgSGF2YW5hIGluIE1pYW1pXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMDBcIiBzcmM9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIzLzEyL2xpZmUtaG91c2UtaG90ZWwtbGl0dGxlLWhhdmFuYS1taWFtaS0zMDB4MjAwLmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6Ik92ZXJuYWNodGVuIGluIE1pYW1pIiwicG9zdF90YWdzIjoiIiwiJWlubGluZV9mZWF0dXJlZF9pbWFnZSUiOiIwIiwiJV9lZGl0X2xvY2slIjoiMTcwMTYxMzU5NjoxIiwiJV9lZGl0X2xhc3QlIjoiMSIsIiVfeW9hc3Rfd3BzZW9fcHJpbWFyeV9jYXRlZ29yeSUiOiIyMzQiLCIlX3RodW1ibmFpbF9pZCUiOiIxODEwMCIsIiVfaGlkZV9mZWF0dXJlZCUiOm51bGwsIiVfd3BnbXBfbG9jYXRpb25fYWRkcmVzcyUiOiI1MjggU1cgOXRoIEF2ZSwgTWlhbWksIEZMIDMzMTMwLCBWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9sb2NhdGlvbl9jaXR5JSI6Ik1pYW1pIiwiJV93cGdtcF9sb2NhdGlvbl9zdGF0ZSUiOiJGbG9yaWRhIiwiJV93cGdtcF9sb2NhdGlvbl9jb3VudHJ5JSI6IlZlcmVuaWdkZSBTdGF0ZW4iLCIlX3dwZ21wX21ldGFib3hfbGF0aXR1ZGUlIjoiMjUuNzY4Mjg3IiwiJV93cGdtcF9tZXRhYm94X2xvbmdpdHVkZSUiOiItODAuMjA5MzU0MyIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiN1wiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6ImE6MTp7aTowO3M6MjpcIjEzXCI7fSIsIiVfd3BnbXBfbWV0YWJveF90YXhvbW9taWVzX3Rlcm1zJSI6IiIsIiVfd3BnbXBfZXh0ZW5zaW9uc19maWVsZHMlIjoiIiwiJV93cGJfdmNfanNfc3RhdHVzJSI6InRydWUiLCIlX3lvYXN0X3dwc2VvX2NvbnRlbnRfc2NvcmUlIjoiMzAiLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza2V5d29yZHMlIjoiW10iLCIlX3lvYXN0X3dwc2VvX2tleXdvcmRzeW5vbnltcyUiOiJbXCJcIl0iLCIlX3lvYXN0X3dwc2VvX2VzdGltYXRlZC1yZWFkaW5nLXRpbWUtbWludXRlcyUiOiIzIiwiJXBvc3QtcHJpbWFyeS1jYXRlZ29yeSUiOiJhdXRvIiwiJWZlYXR1cmVkX2ltYWdlX292ZXJyaWRlJSI6Im9mZiIsIiVzdGFuZGFyZC1mZWF0dXJlZC1jcmVkaXQlIjoiTGlmZSBIb3VzZSBMaXR0bGUgSGF2YW5hIiwiJWFydGljbGVfc3R5bGVfb3ZlcnJpZGUlIjoib24iLCIlcG9zdF9zdHlsZSUiOiJzdHlsZTUiLCIlcG9zdF9nYWxsZXJ5X3N0eWxlJSI6ImxpZ2h0Ym94IiwiJXBvc3RfcmV2aWV3JSI6Im9mZiIsIiVwb3N0X3Jldmlld19zdHlsZSUiOiJzdHlsZTEiLCIlcG9zdF9yZXZpZXdfYXZlcmFnZSUiOiI1MCIsIiVfeW9hc3Rfd3BzZW9fZm9jdXNrdyUiOiJMaWZlIEhvdXNlIExpdHRsZSBIYXZhbmEiLCIlX3lvYXN0X3dwc2VvX21ldGFkZXNjJSI6IkxpZmUgSG91c2UgSG90ZWwgbGlndCBpbiBkZSBrbGV1cnJpamtlIEN1YmFhbnNlIHdpamsgTGl0dGxlIEhhdmFuYSBpbiBNaWFtaS4gRGl0IHByYWNodGlnZSBib2V0aWVrIGhvdGVsIGhlZWZ0IEN1YmFhbnNlIHNmZXJlbiBcdTAwZTluIGVlbiByb29mdG9wISIsIiVfeW9hc3Rfd3BzZW9fbGlua2RleCUiOiI3NCIsIiVwb3N0X3NvdXJjZSUiOlt7InRpdGxlIjoiRm90b2dyYWZpZTogTGlmZSBIb3VzZSBMaXR0bGUgSGF2YW5hIiwicG9zdF9zb3VyY2VfdXJsIjoiaHR0cHM6Ly93d3cubGlmZWhvdXNlaG90ZWxzLmNvbS9ob3RlbHMvbWlhbWkvbGl0dGxlLWhhdmFuYSJ9XSwiJV95b2FzdF9pbmRleG5vd19sYXN0X3BpbmclIjoiMTcwMTYxMzY5MSIsIiVfd3dzX3N1cHBvcnRfY29udGFjdF9udW1iZXIlIjoiIiwiJV93d3NfYWJvdXRfc3VwcG9ydF90ZXh0JSI6IiIsIiVfd3dzX3RyaWdnZXJfYnV0dG9uX3RleHQlIjoiIiwiJV93d3NfcHJlZGVmaW5lZF90ZXh0JSI6IiIsIiVfeW9hc3Rfd3BzZW9fd29yZHByb29mX3RpbWVzdGFtcCUiOiIiLCIlX2xhc3RfZWRpdG9yX3VzZWRfamV0cGFjayUiOiJjbGFzc2ljLWVkaXRvciIsInRheG9ub215PWNhdGVnb3J5IjoiT3Zlcm5hY2h0ZW4gaW4gTWlhbWkiLCJ0YXhvbm9teT1wb3N0X3RhZyI6IiIsInRheG9ub215PXBvc3RfZm9ybWF0IjoiIiwidGF4b25vbXk9dGhiLXJlYWN0aW9ucyI6IiIsInRheG9ub215PXRoYi1zcG9uc29ycyI6IiJ9LCJpY29uIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMS8wNC9ob3RlbC5wbmcifSwiaWQiOjE4MDk5LCJpbmZvd2luZG93X2Rpc2FibGUiOmZhbHNlLCJjYXRlZ29yaWVzIjpbeyJpY29uIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMS8wNC9ob3RlbC5wbmciLCJuYW1lIjoiSG90ZWxzIiwiaWQiOiIxMyIsInR5cGUiOiJjYXRlZ29yeSIsImV4dGVuc2lvbl9maWVsZHMiOnsiY2F0X29yZGVyIjoiIn19XX0seyJzb3VyY2UiOiJwb3N0IiwidGl0bGUiOiJLaW1wdG9uIEVwaWMgTWlhbWkiLCJpbmZvd2luZG93X2NvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nIFwiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJIZXQgS2ltcHRvbiBFcGljIEhvdGVsIGluIERvd250b3duIE1pYW1pXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMDBcIiBzcmM9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIzLzEyL2tpbXB0b24tZXBpYy1ob3RlbC1taWFtaS0zMDB4MjAwLmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmdcIj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZyBmYy1pdGVtLW5vLXBhZGRpbmdcIj5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tdGl0bGUgZmMtaXRlbS1wcmltYXJ5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2VcIj5LaW1wdG9uIEVwaWMgTWlhbWk8L2Rpdj5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tY29udGVudCBmYy1pdGVtLWJvZHktdGV4dC1jb2xvclwiPnttYXJrZXJfYWRkcmVzc308L2Rpdj5cclxuICAgICAgICA8L2Rpdj5cclxuICAgIDwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWNsZWFyXCI+PC9kaXY+XHJcbjwvZGl2PiIsImFkZHJlc3MiOiIyNzAgQmlzY2F5bmUgQmx2ZCBXYXksIE1pYW1pLCBGTCAzMzEzMSwgVmVyZW5pZ2RlIFN0YXRlbiIsImxvY2F0aW9uIjp7ImxhdCI6IjI1Ljc3MDcyMDQiLCJjaXR5IjoiTWlhbWkiLCJzdGF0ZSI6IkZsb3JpZGEiLCJjb3VudHJ5IjoiVmVyZW5pZ2RlIFN0YXRlbiIsImxuZyI6Ii04MC4xODkxODQ4Iiwib25jbGlja19hY3Rpb24iOiJtYXJrZXIiLCJyZWRpcmVjdF9wZXJtYWxpbmsiOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL292ZXJuYWNodGVuLW1pYW1pL2tpbXB0b24tZXBpYy1taWFtaS8iLCJ6b29tIjoxMiwiZXh0cmFfZmllbGRzIjp7InBvc3RfZXhjZXJwdCI6IiIsInBvc3RfY29udGVudCI6Ilt2Y19yb3ddW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIyLzNcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiTWlhbWkgR2xhbW91ciBIb3RlbFwiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDo0NXB4O1wiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NTBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiMjcwIEJpc2NheW5lIEJvdWxldmFyZCBXYXksIERvd250b3duIE1pYW1pXCIgaGVhZGluZ190YWc9XCJkaXZcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpPc3dhbGR8Zm9udF9jYWxsOk9zd2FsZFwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjMwcHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozNXB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdXHJcbjxwIHN0eWxlPVwidGV4dC1hbGlnbjogY2VudGVyO1wiPlx1MmI1MFx1ZmUwZlx1MmI1MFx1ZmUwZlx1MmI1MFx1ZmUwZlx1MmI1MFx1ZmUwZlx1MmI1MFx1ZmUwZjwvcD5cclxuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJLaW1wdG9uIEVwaWMgSG90ZWwgRG93bnRvd24gTWlhbWlcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozMHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCIkJCQkXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiI2M1OWM0ZFwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjMwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF1IZXQgS2ltcHRvbiBFcGljIEhvdGVsIGluIERvd250b3duIE1pYW1pIGlzIGVlbiBcdTAwZTljaHQgZ2xhbW91ciBob3RlbCBpbiBlZW4gMTgzIG1ldGVyIGhvZ2UgdG9yZW4uIERlIDU0IGV0YWdlcyBraWprZW4gdWl0IG92ZXIgZGUgYmFhaSB2YW4gQmlzY2F5bmUgZW4gaW4gZGUgdmVydGUga3VuIGplIHplbGZzIGRlIGhhdmVuIHZhbiBNaWFtaSBlbiBNaWFtaSBCZWFjaCB6aWVuIGxpZ2dlbi4gSGV0IEtpbXB0b24gRXBpYyBoZWVmdCA0MDAga2FtZXJzIHdhYXJ2YW4gZGUgbWVlc3RlIGVlbiBwcml2XHUwMGU5LWJhbGtvbiBoZWJiZW4gd2FhciBqZSB2YW4gaGV0IGFkZW1iZW5lbWVuZGUgdWl0emljaHQga3VudCBnZW5pZXRlbi4gSmUga3VudCBuaWV0IGluIFx1MDBlOVx1MDBlOW4gbWFhciB0d2VlIHp3ZW1iYWRlbiB2ZXJrb2VsZW4gb3AgZGUgMTZlIHZlcmRpZXBpbmcgXHUwMGYzZiBlZW4gY29ja3RhaWwgZHJpbmtlbiBpbiBBcmVhIDMxLCBkZSByb29mdG9wIHZhbiBoZXQgS2ltcHRvbiBFcGljIEhvdGVsLlsvdmNfY29sdW1uX3RleHRdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiR2VzZWxlY3RlZXJkIGRvb3IgSGV5IVVTQVwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpSb2JvdG8gU2xhYnxmb250X2NhbGw6Um9ib3RvK1NsYWJ8dmFyaWFudDo4MDBcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyMHB4O1wiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfc3R5bGU9XCJmb250LXdlaWdodDo4MDA7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF1WZXJibGlqdmVuIGluIERvd250b3duIE1pYW1pIGlzIGVlbiBoZWxlIGFuZGVyZSBiZWxldmluZyBkYW4gaW4gTWlhbWkgQmVhY2guIERlIHN0YWQgTWlhbWkgaGVlZnQgdmVyc2NoaWxsZW5kZSB3b2xrZW5rcmFiYmVycyBlbiBoZXQgS2ltcHRvbiBFcGljIEhvdGVsIGlzIGRhYXIgXHUwMGU5XHUwMGU5biB2YW4uIE9uZGFua3MgaGV0IGZvcm1hYXQgdmFuIGhldCBob3RlbCwgdm9lbHQgaGV0IG5pZXQgYWxzb2YgamUgaW4gZWVuIG1hc3NhaG90ZWwgdmVyYmxpamZ0LiBFZW4gZ3JvdGUgcGx1c3B1bnQgemlqbiBkZSBrYW1lcnMgbWV0IHByaXZcdTAwZTkgYmFsa29uIHdhYXIgamUgbmlldCB1aXRnZWtla2VuIHJhYWt0IHZhbiBoZXQgcHJhY2h0aWdlIHVpdHppY2h0LiBLb3J0b20sIGVlbiBwZXJmZWN0IGdsYW1vdXItaG90ZWwgdm9vciBlZW4gcGFhciBicnVpc2VuZGUgZGFnZW4gaW4gRG93bnRvd24gTWlhbWkuWy92Y19jb2x1bW5fdGV4dF1bdWx0X2J1dHRvbnMgYnRuX3RpdGxlPVwiQm9layBlZW4ga2FtZXJcIiBidG5fbGluaz1cInVybDpodHRwcyUzQSUyRiUyRnd3dy5ib29raW5nLmNvbSUyRmhvdGVsJTJGdXMlMkZlcGljLm5sLmh0bWwlM0ZhaWQlM0Q3OTU4NDk4JTI2bm9fcm9vbXMlM0QxJTI2Z3JvdXBfYWR1bHRzJTNEMiUyNmxhYmVsJTNEa2ltcHRvbi1lcGljLWhvdGVsLXBhZ2V8dGl0bGU6Qm9layUyMGVlbiUyMGthbWVyfHRhcmdldDpfYmxhbmtcIiBidG5fdGl0bGVfY29sb3I9XCIjZmZmZmZmXCIgYnRuX2JnX2NvbG9yPVwiI2IzNGE0Y1wiIGJ0bl9ob3Zlcj1cInVidG4tYm90dG9tLWJnXCIgYnRuX2JnX2NvbG9yX2hvdmVyPVwiIzUzMWEyM1wiIGljb25fc2l6ZT1cIjMyXCIgYnRuX2ljb25fcG9zPVwidWJ0bi1zZXAtaWNvbi1hdC1sZWZ0XCIgYnRuX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIGJ0bl9mb250X3NpemU9XCJkZXNrdG9wOjIwcHg7XCIgYnRuX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDoyNXB4O1wiXVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIyLzNcIl1bdGhiX2ltYWdlX3NsaWRlciBsaWdodGJveD1cIm1mcC1nYWxsZXJ5XCIgdGhiX2VxdWFsX2hlaWdodD1cInRydWVcIiBhdXRvcGxheT1cInRydWVcIiBpbWFnZXM9XCIxODA4MiwxODA4MywxODA4NCwxODA4NSwxODA4NiwxODA4NywxODA4OCwxODA4OSwxODA3NlwiXVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3ZjX3NpbmdsZV9pbWFnZSBpbWFnZT1cIjE4MDg3XCIgaW1nX3NpemU9XCJsYXJnZVwiIGFkZF9jYXB0aW9uPVwieWVzXCIgc3R5bGU9XCJ2Y19ib3hfc2hhZG93XzNkXCJdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIlBvcHVsYWlyZSBmYWNpbGl0ZWl0ZW5cIiBoZWFkaW5nX3RhZz1cImgzXCIgYWxpZ25tZW50PVwibGVmdFwiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6MzBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XVR3ZWUgendlbWJhZGVuIG9wIGRlIDE2ZSB2ZXJkaWVwaW5nIG1ldCBzcGVjdGFjdWxhaXIgdWl0emljaHQgaXMgYWwgYmlqbmEgZWVuIHJlZGVuIG9tIGluIGhldCBLaW1wdG9uIEVwaWMgSG90ZWwgdGUgdmVyYmxpanZlbi4gUHJhY2h0aWcgdWl0emljaHQgaXMgc293aWVzbyBcdTAwZTlcdTAwZTluIHZhbiBkZSBwbHVzcHVudGVuIHZhbiBkaXQgMTgzIG1ldGVyIGhvZ2UgaG90ZWwuIFJvb2Z0b3BiYXIgQXJlYSAzMSBpcyBwb3B1bGFpciBiaWogZGUgbG9jYWxzLCBkZSBNYWlzb24gRi5QLiBKb3VybmUgc2lnYWFybG91bmdlIGhlZWZ0IHNsZWNodHMgcGxlayB2b29yIDEwIHBlcnNvbmVuIGRpZSB2YW4gZWVuIHN0ZXJrIGRyYW5ramUgaG91ZGVuLiBEaW5lcmVuIGthbiBiaWogQXJlYSAzMSBlbiBoZXQgSmFwYW5zZSByZXN0YXVyYW50IFp1bWEuIE9udHdha2VuIGRvZSBqZSBcdTAwZjNcdTAwZjNrIG1ldCBlZW4gdmlldyBvcCBkZSAxNmUgdmVyZGllcGluZy5bL3ZjX2NvbHVtbl90ZXh0XVt0aGJfaWNvbmxpc3QgaWNvbj1cImZhcyBmYS1tYXAtbWFya2VyLWFsdFwiIGxpc3RfY29udGVudD1cIkJpanpvbmRlcmUgbG9jYXRpZSBhYW4gRXNwYVx1MDBmMW9sYSBXYXlcIl1bdGhiX2ljb25saXN0IGljb249XCJmYXMgZmEtd2lmaVwiIGxpc3RfY29udGVudD1cIkdyYXRpcyBXaUZpXCJdW3RoYl9pY29ubGlzdCBpY29uPVwiZmFzIGZhLXV0ZW5zaWxzXCIgbGlzdF9jb250ZW50PVwiUmVzdGF1cmFudCBlbiByb29mdG9wIGJhclwiXVt0aGJfaWNvbmxpc3QgaWNvbj1cImZhcyBmYS1nbGFzcy1jaGVlcnNcIiBsaXN0X2NvbnRlbnQ9XCJBcmVhIDMxIFJvb2Z0b3BcIl1bdGhiX2ljb25saXN0IGljb249XCJmYXMgZmEtZG9sbGFyLXNpZ25cIiBsaXN0X2NvbnRlbnQ9XCJOaWV0IGdvZWRrb29wIG1hYXIgbHV4dWV1c1wiXVt0aGJfaWNvbmxpc3QgaWNvbj1cImZhcyBmYS1iZWRcIiBsaXN0X2NvbnRlbnQ9XCJDb21mb3J0YWJlbGUgYmVkZGVuXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjI1cHhcIl1bdWx0X2J1dHRvbnMgYnRuX3RpdGxlPVwiQm9layBlZW4ga2FtZXJcIiBidG5fbGluaz1cInVybDpodHRwcyUzQSUyRiUyRnd3dy5ib29raW5nLmNvbSUyRmhvdGVsJTJGdXMlMkZlcGljLm5sLmh0bWwlM0ZhaWQlM0Q3OTU4NDk4JTI2bm9fcm9vbXMlM0QxJTI2Z3JvdXBfYWR1bHRzJTNEMiUyNmxhYmVsJTNEa2ltcHRvbi1lcGljLWhvdGVsLXBhZ2V8dGl0bGU6Qm9layUyMGVlbiUyMGthbWVyfHRhcmdldDpfYmxhbmtcIiBidG5fdGl0bGVfY29sb3I9XCIjZmZmZmZmXCIgYnRuX2JnX2NvbG9yPVwiI2IzNGE0Y1wiIGJ0bl9ob3Zlcj1cInVidG4tYm90dG9tLWJnXCIgYnRuX2JnX2NvbG9yX2hvdmVyPVwiIzUzMWEyM1wiIGljb25fc2l6ZT1cIjMyXCIgYnRuX2ljb25fcG9zPVwidWJ0bi1zZXAtaWNvbi1hdC1sZWZ0XCIgYnRuX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIGJ0bl9mb250X3NpemU9XCJkZXNrdG9wOjIwcHg7XCIgYnRuX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDoyNXB4O1wiXVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd10iLCJwb3N0X3RpdGxlIjoiS2ltcHRvbiBFcGljIE1pYW1pIiwicG9zdF9saW5rIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9vdmVybmFjaHRlbi1taWFtaS9raW1wdG9uLWVwaWMtbWlhbWkvIiwicG9zdF9mZWF0dXJlZF9pbWFnZSI6IjxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiSGV0IEtpbXB0b24gRXBpYyBIb3RlbCBpbiBEb3dudG93biBNaWFtaVwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMy8xMi9raW1wdG9uLWVwaWMtaG90ZWwtbWlhbWktMzAweDIwMC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj4iLCJwb3N0X2NhdGVnb3JpZXMiOiJPdmVybmFjaHRlbiBpbiBNaWFtaSIsInBvc3RfdGFncyI6IiIsIiVpbmxpbmVfZmVhdHVyZWRfaW1hZ2UlIjoiMCIsIiVfZWRpdF9sb2NrJSI6IjE3MDE1MTYxMzA6MSIsIiVfZWRpdF9sYXN0JSI6IjEiLCIlX3lvYXN0X3dwc2VvX3ByaW1hcnlfY2F0ZWdvcnklIjoiMjM0IiwiJV90aHVtYm5haWxfaWQlIjoiMTgwNzYiLCIlX2hpZGVfZmVhdHVyZWQlIjpudWxsLCIlX3dwZ21wX2xvY2F0aW9uX2FkZHJlc3MlIjoiMjcwIEJpc2NheW5lIEJsdmQgV2F5LCBNaWFtaSwgRkwgMzMxMzEsIFZlcmVuaWdkZSBTdGF0ZW4iLCIlX3dwZ21wX2xvY2F0aW9uX2NpdHklIjoiTWlhbWkiLCIlX3dwZ21wX2xvY2F0aW9uX3N0YXRlJSI6IkZsb3JpZGEiLCIlX3dwZ21wX2xvY2F0aW9uX2NvdW50cnklIjoiVmVyZW5pZ2RlIFN0YXRlbiIsIiVfd3BnbXBfbWV0YWJveF9sYXRpdHVkZSUiOiIyNS43NzA3MjA0IiwiJV93cGdtcF9tZXRhYm94X2xvbmdpdHVkZSUiOiItODAuMTg5MTg0OCIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiN1wiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6ImE6MTp7aTowO3M6MjpcIjEzXCI7fSIsIiVfd3BnbXBfbWV0YWJveF90YXhvbW9taWVzX3Rlcm1zJSI6IiIsIiVfd3BnbXBfZXh0ZW5zaW9uc19maWVsZHMlIjoiIiwiJV93cGJfdmNfanNfc3RhdHVzJSI6InRydWUiLCIlX3lvYXN0X3dwc2VvX2NvbnRlbnRfc2NvcmUlIjoiNjAiLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza2V5d29yZHMlIjoiW10iLCIlX3lvYXN0X3dwc2VvX2tleXdvcmRzeW5vbnltcyUiOiJbXCJcIl0iLCIlX3lvYXN0X3dwc2VvX2VzdGltYXRlZC1yZWFkaW5nLXRpbWUtbWludXRlcyUiOiIyIiwiJXBvc3QtcHJpbWFyeS1jYXRlZ29yeSUiOiJhdXRvIiwiJWZlYXR1cmVkX2ltYWdlX292ZXJyaWRlJSI6Im9mZiIsIiVzdGFuZGFyZC1mZWF0dXJlZC1jcmVkaXQlIjoiS2ltcHRvbiBFcGljIEhvdGVsIiwiJWFydGljbGVfc3R5bGVfb3ZlcnJpZGUlIjoib24iLCIlcG9zdF9zdHlsZSUiOiJzdHlsZTUiLCIlcG9zdF9nYWxsZXJ5X3N0eWxlJSI6ImxpZ2h0Ym94IiwiJXBvc3RfcmV2aWV3JSI6Im9mZiIsIiVwb3N0X3Jldmlld19zdHlsZSUiOiJzdHlsZTEiLCIlcG9zdF9yZXZpZXdfYXZlcmFnZSUiOiI1MCIsIiVfeW9hc3Rfd3BzZW9fZm9jdXNrdyUiOiJFc21cdTAwZTkgTWlhbWkgQmVhY2giLCIlX3lvYXN0X3dwc2VvX21ldGFkZXNjJSI6IkdsaXR0ZXIsIGdsYW1vdXIgXHUwMGU5biBnZXdlbGRpZ2UgdWl0emljaHRlbiBpbiBkaXQgMTgzIG1ldGVyIGhvZ2UgaG90ZWwuIEhldCBLaW1wdG9uIEVwaWMgaGVlZnQgZWVuIHBvcHVsYWlyZSByb29mdG9wYmFyIFx1MDBlOW4gdHdlZSB6d2VtYmFkZW4hIiwiJV95b2FzdF93cHNlb19saW5rZGV4JSI6IjUxIiwiJXBvc3Rfc291cmNlJSI6W3sidGl0bGUiOiJGb3RvZ3JhZmllOiBLaW1wdG9uIEVwaWMgSG90ZWwiLCJwb3N0X3NvdXJjZV91cmwiOiJodHRwczovL3d3dy5lcGljaG90ZWwuY29tIn1dLCIlX3lvYXN0X2luZGV4bm93X2xhc3RfcGluZyUiOiIxNzAxNDY3MDE3IiwiJV93d3Nfc3VwcG9ydF9jb250YWN0X251bWJlciUiOiIiLCIlX3d3c19hYm91dF9zdXBwb3J0X3RleHQlIjoiIiwiJV93d3NfdHJpZ2dlcl9idXR0b25fdGV4dCUiOiIiLCIlX3d3c19wcmVkZWZpbmVkX3RleHQlIjoiIiwiJV95b2FzdF93cHNlb193b3JkcHJvb2ZfdGltZXN0YW1wJSI6IiIsIiVfbGFzdF9lZGl0b3JfdXNlZF9qZXRwYWNrJSI6ImNsYXNzaWMtZWRpdG9yIiwidGF4b25vbXk9Y2F0ZWdvcnkiOiJPdmVybmFjaHRlbiBpbiBNaWFtaSIsInRheG9ub215PXBvc3RfdGFnIjoiIiwidGF4b25vbXk9cG9zdF9mb3JtYXQiOiIiLCJ0YXhvbm9teT10aGItcmVhY3Rpb25zIjoiIiwidGF4b25vbXk9dGhiLXNwb25zb3JzIjoiIn0sImljb24iOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIxLzA0L2hvdGVsLnBuZyJ9LCJpZCI6MTgwNzUsImluZm93aW5kb3dfZGlzYWJsZSI6ZmFsc2UsImNhdGVnb3JpZXMiOlt7Imljb24iOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIxLzA0L2hvdGVsLnBuZyIsIm5hbWUiOiJIb3RlbHMiLCJpZCI6IjEzIiwidHlwZSI6ImNhdGVnb3J5IiwiZXh0ZW5zaW9uX2ZpZWxkcyI6eyJjYXRfb3JkZXIiOiIifX1dfSx7InNvdXJjZSI6InBvc3QiLCJ0aXRsZSI6IkVzbVx1MDBlOSBNaWFtaSBCZWFjaCIsImluZm93aW5kb3dfY29udGVudCI6IjxkaXYgY2xhc3M9XCJmYy1pdGVtLWJveCBmYy1pdGVtLW5vLXBhZGRpbmcgXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIkhldCBiaWp6b25kZXJlIGJvZXRpZWsgaG90ZWwgRXNtXHUwMGU5IGluIE1pYW1pIEJlYWNoXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMDBcIiBzcmM9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIzLzEyL2VzbWUtaG90ZWwtbWlhbWktYmVhY2gtMzAweDIwMC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmcgZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+RXNtXHUwMGU5IE1pYW1pIEJlYWNoPC9kaXY+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3JcIj57bWFya2VyX2FkZHJlc3N9PC9kaXY+XHJcbiAgICAgICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1jbGVhclwiPjwvZGl2PlxyXG48L2Rpdj4iLCJhZGRyZXNzIjoiMTQzOCBXYXNoaW5ndG9uIEF2ZSwgTWlhbWkgQmVhY2gsIEZMIDMzMTM5LCBWZXJlbmlnZGUgU3RhdGVuIiwibG9jYXRpb24iOnsibGF0IjoiMjUuNzg2NzkxNTk5OTk5OTkiLCJjaXR5IjoiTWlhbWkgQmVhY2giLCJzdGF0ZSI6IkZsb3JpZGEiLCJjb3VudHJ5IjoiVmVyZW5pZ2RlIFN0YXRlbiIsImxuZyI6Ii04MC4xMzE5NzcxIiwib25jbGlja19hY3Rpb24iOiJtYXJrZXIiLCJyZWRpcmVjdF9wZXJtYWxpbmsiOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL292ZXJuYWNodGVuLW1pYW1pL2VzbWUtYm9ldGllay1ob3RlbC1taWFtaS1iZWFjaC8iLCJ6b29tIjoxMiwiZXh0cmFfZmllbGRzIjp7InBvc3RfZXhjZXJwdCI6IiIsInBvc3RfY29udGVudCI6Ilt2Y19yb3ddW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIyLzNcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiTWVkaXRlcnJhYW5zIEJvZXRpZWsgSG90ZWwgaW4gTWlhbWkgQmVhY2hcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6NDVweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjUwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIjE0MzggV2FzaGluZ3RvbiBBdmVudWUsIE1pYW1pIEJlYWNoXCIgaGVhZGluZ190YWc9XCJkaXZcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpPc3dhbGR8Zm9udF9jYWxsOk9zd2FsZFwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjMwcHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozNXB4O1wiIG1hcmdpbl9kZXNpZ25fdGFiX3RleHQ9XCJcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XVxyXG48cCBzdHlsZT1cInRleHQtYWxpZ246IGNlbnRlcjtcIj5cdTJiNTBcdWZlMGZcdTJiNTBcdWZlMGZcdTJiNTBcdWZlMGZcdTJiNTBcdWZlMGZcdTJiNTBcdWZlMGY8L3A+XHJcblsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiRXNtXHUwMGU5IGluIE1pYW1pIEJlYWNoXCIgYWxpZ25tZW50PVwibGVmdFwiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6MzBweDtcIiBtYXJnaW5fZGVzaWduX3RhYl90ZXh0PVwiXCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIiQkJCRcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjYzU5YzRkXCIgYWxpZ25tZW50PVwibGVmdFwiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6MzBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XUFsc29mIGplIG9wIGVlbiBvdWRlIHNldCBiZWxhbmQgYmVudCB2YW4gZWVuIEphbWVzIEJvbmQtZmlsbSBtZXQgUm9nZXIgTW9vcmUsIHpvIGt1biBqZSBoZXQgYmVzdCBoZXQgYm9ldGllayBob3RlbCBFc21cdTAwZTkgb21zY2hyaWp2ZW4uIERpdCBob3RlbCBhYW4gPGVtPkVzcGFcdTAwZjFvbGEgV2F5PC9lbT48ZW0+XHUwMGEwPC9lbT5pcyB0b3QgaW4gZGUgZGV0YWlscyBpbiBlZW4gTWVkaXRlcnJhYW5zZSBzZmVlciB1aXRnZXZvZXJkLiBWYW4gbW96YVx1MDBlZmVrIHRvdCB2ZWx2ZXQsIG9saWpmZ3JvZW4gZW4gZG9ua2VyIGhvdXQsIGVsa2Uga2FtZXIgaGVlZnQgeiduIGVpZ2VuIHVuaWVrZSBzdGlqbCBlbiBzZmVlci4gTWV0IGVlbiBiZWV0amUgZmFudGFzaWUgemllIGplIEphbWVzIEJvbmQgaW4gZGUgYmFyIDxlbT5FbCBTYWxcdTAwZjNuPC9lbT4gZWVuIE1hcnRpbmkgYmVzdGVsbGVuLiBXZWdkcm9tZW4gZG9lIGplICdzIG5hY2h0cyBvbmRlciBsaW5uZW4gdmFuICdCZWxsaW5vJyB1aXQgSXRhbGlcdTAwZWIgZW4gb3ZlcmRhZyBqZXRzZXQgamUgaW4gaGV0IHp3ZW1iYWQgb3AgZGUgcm9vZnRvcCB2YW4gaGV0IGhvdGVsLiBMZWtrZXIgZXRlbj8gRGFhcnZvb3IgbW9ldCBqZSBuaWV0IHZlciB3ZWcgdGUgZ2FhbiwgaW4gRXNwYVx1MDBmMW9sYSBXYXkga3VuIGplIHRlcmVjaHQgdm9vciBwYXN0YSdzLCBwaXp6YSwgcGFlbGxhIGVuIGFsIGhldCBsZWtrZXJzIGRhdCBqZSByb25kIGRlIE1lZGl0ZXJyYWFuc2UgemVlIGt1bnQgZXRlbi5bL3ZjX2NvbHVtbl90ZXh0XVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIkdlc2VsZWN0ZWVyZCBkb29yIEhleSFVU0FcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6Um9ib3RvIFNsYWJ8Zm9udF9jYWxsOlJvYm90bytTbGFifHZhcmlhbnQ6ODAwXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjBweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX3N0eWxlPVwiZm9udC13ZWlnaHQ6ODAwO1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdRXNtXHUwMGU5IGluIE1pYW1pIEJlYWNoIGlzIFx1MDBlOWNodCB6byduIHR5cGlzY2ggSGV5IVVTQS1ob3RlbC4gQm9tdm9sIGthcmFrdGVyLCBzZmVlciwgdW5pZWtlIGRldGFpbHMgZW4gb29nIHZvb3IgZGVzaWduLiBIZXQgaXMgZWVuICNidWNrZXRsaXN0IGhvdGVsIGFscyBqZSBncmFhZyB2ZXJibGlqZnQgaW4gdW5pZWtlIGhvdGVscyBlbiBhYnNvbHV1dCBcdTAwZTlcdTAwZTluIHZhbiBkZSBtb29pc3RlIGJvZXRpZWsgaG90ZWxzIGluIE1pYW1pIEJlYWNoLiBJbiB0ZWdlbnN0ZWxsaW5nIHRvdCBkZSBtZWVzdGUgaG90ZWxzIGluIE1pYW1pIEJlYWNoLCBkaWUgYWFuIE9jZWFuIERyaXZlIGxpZ2dlbiwgbW9ldCBqZSB2b29yIGhldCBzdHJhbmQgaWV0cyB2ZXJkZXIgd2FuZGVsZW4sIG1hYXIgZGF0IGlzIHNsZWNodHMgdmlqZiBtaW51dXRqZXMuIFdha2tlciB3b3JkZW4ga2FuIGhpZXIgbm9nIHRyYWRpdGlvbmVlbCBtZXQgZWVuIGVpZ2VuIGtyYW50LCBkaWUgZWxrZSBvY2h0ZW5kIHZvb3IgamUgZGV1ciBsaWd0IGVuIHZlcnNlIGtvZmZpZS4gVm9vciBqZSBnYWF0IHNsYXBlbiBrb21lbiB6ZSBqZSBrYW1lciBrbGFhcm1ha2VuIHZvb3IgZGUgbmFjaHQsIGRlemUgJ1R1cm5kb3duIHNlcnZpY2UnIHppZSBqZSBuaWV0IG1lZXIgdmVlbCwgbWFhciBnZWVmdCBuZXQgZGF0IGJlZXRqZSBleHRyYS5bL3ZjX2NvbHVtbl90ZXh0XVt1bHRfYnV0dG9ucyBidG5fdGl0bGU9XCJCb2VrIGVlbiBrYW1lclwiIGJ0bl9saW5rPVwidXJsOmh0dHBzJTNBJTJGJTJGd3d3LmJvb2tpbmcuY29tJTJGaG90ZWwlMkZ1cyUyRmVzbWUubmwuaHRtbCUzRmFpZCUzRDc5NTg0OTglMjZub19yb29tcyUzRDElMjZncm91cF9hZHVsdHMlM0QyJTI2bGFiZWwlM0Rlc21lLWhvdGVsLXBhZ2V8dGl0bGU6Qm9layUyMGVlbiUyMGthbWVyfHRhcmdldDpfYmxhbmtcIiBidG5fdGl0bGVfY29sb3I9XCIjZmZmZmZmXCIgYnRuX2JnX2NvbG9yPVwiI2IzNGE0Y1wiIGJ0bl9ob3Zlcj1cInVidG4tYm90dG9tLWJnXCIgYnRuX2JnX2NvbG9yX2hvdmVyPVwiIzUzMWEyM1wiIGljb25fc2l6ZT1cIjMyXCIgYnRuX2ljb25fcG9zPVwidWJ0bi1zZXAtaWNvbi1hdC1sZWZ0XCIgYnRuX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIGJ0bl9mb250X3NpemU9XCJkZXNrdG9wOjIwcHg7XCIgYnRuX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDoyNXB4O1wiXVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIyLzNcIl1bdGhiX2ltYWdlX3NsaWRlciBsaWdodGJveD1cIm1mcC1nYWxsZXJ5XCIgdGhiX2VxdWFsX2hlaWdodD1cInRydWVcIiBhdXRvcGxheT1cInRydWVcIiBpbWFnZXM9XCIxODA2MSwxODA3MiwxODA2MiwxODA2MywxODA2NCwxODA2NSwxODA3MywxODA2NiwxODA2NywxODA2OCwxODA2OSwxODA3MCwxODA3MVwiXVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3ZjX3NpbmdsZV9pbWFnZSBpbWFnZT1cIjE4MDY2XCIgaW1nX3NpemU9XCJsYXJnZVwiIGFkZF9jYXB0aW9uPVwieWVzXCIgc3R5bGU9XCJ2Y19ib3hfc2hhZG93XzNkXCJdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIlBvcHVsYWlyZSBmYWNpbGl0ZWl0ZW5cIiBoZWFkaW5nX3RhZz1cImgzXCIgYWxpZ25tZW50PVwibGVmdFwiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6MzBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XVZvb3JhbCBkZSByb29mdG9wIG1ldCBoZXQgendlbWJhZCBpcyBlZW4gcGx1cyB2YW4gZGl0IGhvdGVsLiBCaWp6b25kZXIgaXMgb29rIGhldCBrbGVpbmUgc3RlZWdqZSBhY2h0ZXIgaGV0IEVzbVx1MDBlOSBob3RlbCwgYWxzb2YgamUgaW4gZWVuIFNwYWFuc2UgZmlsbSB6aXQuIEplIGt1bnQgdmVyYmxpanZlbiBpbiBkZSAndmlsbGEnIG1hYXIgZXIgaXMgb29rIG5vZyBkZSBiaWp6b25kZXJlICdDYXNhIE1hdGFuemEnIHdhYXIgamUga3VudCBsb2dlcmVuIGluIGVlbiBzdWl0ZSBtZXQgZGUgdHlwaXNjaGUgJ0NhcG9uZSctbmFhbS4gRGF0IHplZ3QgYWwgZ2Vub2VnIG92ZXIgZGUgc3RpamwgZGllIGplIGhpZXIga3VudCB2ZXJ3YWNodGVuOiB2aW50YWdlIEFsIENhcG9uZXMuWy92Y19jb2x1bW5fdGV4dF1bdGhiX2ljb25saXN0IGljb249XCJmYXMgZmEtbWFwLW1hcmtlci1hbHRcIiBsaXN0X2NvbnRlbnQ9XCJCaWp6b25kZXJlIGxvY2F0aWUgYWFuIEVzcGFcdTAwZjFvbGEgV2F5XCJdW3RoYl9pY29ubGlzdCBpY29uPVwiZmFzIGZhLXdpZmlcIiBsaXN0X2NvbnRlbnQ9XCJHcmF0aXMgV2lGaVwiXVt0aGJfaWNvbmxpc3QgaWNvbj1cImZhcyBmYS11dGVuc2lsc1wiIGxpc3RfY29udGVudD1cIlJlc3RhdXJhbnQgZW4gZ2V6ZWxsaWdlIGJhclwiXVt0aGJfaWNvbmxpc3QgaWNvbj1cImZhcyBmYS1nbGFzcy1jaGVlcnNcIiBsaXN0X2NvbnRlbnQ9XCJSb29mdG9wIG1ldCBiYXIgZW4gendlbWJhZFwiXVt0aGJfaWNvbmxpc3QgaWNvbj1cImZhcyBmYS1kb2xsYXItc2lnblwiIGxpc3RfY29udGVudD1cIk5pZXQgZ29lZGtvb3AgbWFhciBlZW4gdW5pZWsgaG90ZWwhXCJdW3RoYl9pY29ubGlzdCBpY29uPVwiZmFzIGZhLWJlZFwiIGxpc3RfY29udGVudD1cIkNvbWZvcnRhYmVsZSBiZWRkZW5cIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMjVweFwiXVt1bHRfYnV0dG9ucyBidG5fdGl0bGU9XCJCb2VrIGVlbiBrYW1lclwiIGJ0bl9saW5rPVwidXJsOmh0dHBzJTNBJTJGJTJGd3d3LmJvb2tpbmcuY29tJTJGaG90ZWwlMkZ1cyUyRmVzbWUubmwuaHRtbCUzRmFpZCUzRDc5NTg0OTglMjZub19yb29tcyUzRDElMjZncm91cF9hZHVsdHMlM0QyJTI2bGFiZWwlM0Rlc21lLWhvdGVsLXBhZ2V8dGl0bGU6Qm9layUyMGVlbiUyMGthbWVyfHRhcmdldDpfYmxhbmtcIiBidG5fdGl0bGVfY29sb3I9XCIjZmZmZmZmXCIgYnRuX2JnX2NvbG9yPVwiI2IzNGE0Y1wiIGJ0bl9ob3Zlcj1cInVidG4tYm90dG9tLWJnXCIgYnRuX2JnX2NvbG9yX2hvdmVyPVwiIzUzMWEyM1wiIGljb25fc2l6ZT1cIjMyXCIgYnRuX2ljb25fcG9zPVwidWJ0bi1zZXAtaWNvbi1hdC1sZWZ0XCIgYnRuX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIGJ0bl9mb250X3NpemU9XCJkZXNrdG9wOjIwcHg7XCIgYnRuX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDoyNXB4O1wiXVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd10iLCJwb3N0X3RpdGxlIjoiRXNtXHUwMGU5IE1pYW1pIEJlYWNoIiwicG9zdF9saW5rIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9vdmVybmFjaHRlbi1taWFtaS9lc21lLWJvZXRpZWstaG90ZWwtbWlhbWktYmVhY2gvIiwicG9zdF9mZWF0dXJlZF9pbWFnZSI6IjxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiSGV0IGJpanpvbmRlcmUgYm9ldGllayBob3RlbCBFc21cdTAwZTkgaW4gTWlhbWkgQmVhY2hcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjIwMFwiIHNyYz1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjMvMTIvZXNtZS1ob3RlbC1taWFtaS1iZWFjaC0zMDB4MjAwLmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6Ik92ZXJuYWNodGVuIGluIE1pYW1pIiwicG9zdF90YWdzIjoiIiwiJWlubGluZV9mZWF0dXJlZF9pbWFnZSUiOiIwIiwiJV9lZGl0X2xvY2slIjoiMTcwMTQ2NTg4ODoxIiwiJV9lZGl0X2xhc3QlIjoiMSIsIiVfeW9hc3Rfd3BzZW9fcHJpbWFyeV9jYXRlZ29yeSUiOiIyMzQiLCIlX3RodW1ibmFpbF9pZCUiOiIxODA1NyIsIiVfaGlkZV9mZWF0dXJlZCUiOm51bGwsIiVfd3BnbXBfbG9jYXRpb25fYWRkcmVzcyUiOiIxNDM4IFdhc2hpbmd0b24gQXZlLCBNaWFtaSBCZWFjaCwgRkwgMzMxMzksIFZlcmVuaWdkZSBTdGF0ZW4iLCIlX3dwZ21wX2xvY2F0aW9uX2NpdHklIjoiTWlhbWkgQmVhY2giLCIlX3dwZ21wX2xvY2F0aW9uX3N0YXRlJSI6IkZsb3JpZGEiLCIlX3dwZ21wX2xvY2F0aW9uX2NvdW50cnklIjoiVmVyZW5pZ2RlIFN0YXRlbiIsIiVfd3BnbXBfbWV0YWJveF9sYXRpdHVkZSUiOiIyNS43ODY3OTE1OTk5OTk5OSIsIiVfd3BnbXBfbWV0YWJveF9sb25naXR1ZGUlIjoiLTgwLjEzMTk3NzEiLCIlX3dwZ21wX21ldGFib3hfbG9jYXRpb25fcmVkaXJlY3QlIjoibWFya2VyIiwiJV93cGdtcF9tZXRhYm94X2N1c3RvbV9saW5rJSI6IiIsIiVfd3BnbXBfbWFwX2lkJSI6ImE6MTp7aTowO3M6MTpcIjdcIjt9IiwiJV93cGdtcF9tZXRhYm94X21hcmtlcl9pZCUiOiJhOjE6e2k6MDtzOjI6XCIxM1wiO30iLCIlX3dwZ21wX21ldGFib3hfdGF4b21vbWllc190ZXJtcyUiOiIiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6IiIsIiVfd3BiX3ZjX2pzX3N0YXR1cyUiOiJ0cnVlIiwiJV95b2FzdF93cHNlb19jb250ZW50X3Njb3JlJSI6IjMwIiwiJV95b2FzdF93cHNlb19mb2N1c2tleXdvcmRzJSI6IltdIiwiJV95b2FzdF93cHNlb19rZXl3b3Jkc3lub255bXMlIjoiW1wiXCJdIiwiJV95b2FzdF93cHNlb19lc3RpbWF0ZWQtcmVhZGluZy10aW1lLW1pbnV0ZXMlIjoiMyIsIiVwb3N0LXByaW1hcnktY2F0ZWdvcnklIjoiYXV0byIsIiVmZWF0dXJlZF9pbWFnZV9vdmVycmlkZSUiOiJvZmYiLCIlc3RhbmRhcmQtZmVhdHVyZWQtY3JlZGl0JSI6IkVzbVx1MDBlOSBIb3RlbCBNaWFtaSBCZWFjaCIsIiVhcnRpY2xlX3N0eWxlX292ZXJyaWRlJSI6Im9uIiwiJXBvc3Rfc3R5bGUlIjoic3R5bGU1IiwiJXBvc3RfZ2FsbGVyeV9zdHlsZSUiOiJsaWdodGJveCIsIiVwb3N0X3JldmlldyUiOiJvZmYiLCIlcG9zdF9yZXZpZXdfc3R5bGUlIjoic3R5bGUxIiwiJXBvc3RfcmV2aWV3X2F2ZXJhZ2UlIjoiNTAiLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza3clIjoiRXNtXHUwMGU5IE1pYW1pIEJlYWNoIiwiJV95b2FzdF93cHNlb19tZXRhZGVzYyUiOiJLYXJha3RlcnZvbCBib2V0aWVrIGhvdGVsIGFhbiBoZXQgTWVkaXRlcnJhYW5zZSBFc3BhXHUwMGYxb2xhIFdheS4gRWVuIHVuaWVrIGhvdGVsIG1ldCBlZW4gb3VkZSBKYW1lcyBCb25kLWZpbG0gc2ZlZXIsIG92ZXJuYWNodGVuIGFscyBpbiBlZW4gZmlsbS4iLCIlX3lvYXN0X3dwc2VvX2xpbmtkZXglIjoiNjAiLCIlcG9zdF9zb3VyY2UlIjpbeyJ0aXRsZSI6IkZvdG9ncmFmaWU6IEVzbVx1MDBlOSIsInBvc3Rfc291cmNlX3VybCI6Imh0dHBzOi8vd3d3LmVzbWVob3RlbC5jb20ifV0sIiVfeW9hc3RfaW5kZXhub3dfbGFzdF9waW5nJSI6IjE3MDE0NjU5NDIiLCIlX3d3c19zdXBwb3J0X2NvbnRhY3RfbnVtYmVyJSI6IiIsIiVfd3dzX2Fib3V0X3N1cHBvcnRfdGV4dCUiOiIiLCIlX3d3c190cmlnZ2VyX2J1dHRvbl90ZXh0JSI6IiIsIiVfd3dzX3ByZWRlZmluZWRfdGV4dCUiOiIiLCIlX3lvYXN0X3dwc2VvX3dvcmRwcm9vZl90aW1lc3RhbXAlIjoiIiwiJV9sYXN0X2VkaXRvcl91c2VkX2pldHBhY2slIjoiY2xhc3NpYy1lZGl0b3IiLCJ0YXhvbm9teT1jYXRlZ29yeSI6Ik92ZXJuYWNodGVuIGluIE1pYW1pIiwidGF4b25vbXk9cG9zdF90YWciOiIiLCJ0YXhvbm9teT1wb3N0X2Zvcm1hdCI6IiIsInRheG9ub215PXRoYi1yZWFjdGlvbnMiOiIiLCJ0YXhvbm9teT10aGItc3BvbnNvcnMiOiIifSwiaWNvbiI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjEvMDQvaG90ZWwucG5nIn0sImlkIjoxODA1MiwiaW5mb3dpbmRvd19kaXNhYmxlIjpmYWxzZSwiY2F0ZWdvcmllcyI6W3siaWNvbiI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjEvMDQvaG90ZWwucG5nIiwibmFtZSI6IkhvdGVscyIsImlkIjoiMTMiLCJ0eXBlIjoiY2F0ZWdvcnkiLCJleHRlbnNpb25fZmllbGRzIjp7ImNhdF9vcmRlciI6IiJ9fV19LHsic291cmNlIjoicG9zdCIsInRpdGxlIjoiVGhlIEJldHN5IE1pYW1pIEJlYWNoIiwiaW5mb3dpbmRvd19jb250ZW50IjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZyBcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiSGV0IGJvdXRpcXVlIGhvdGVsIFRoZSBCZXRzeSBpbiBNaWFtaSBCZWFjaFwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMTk2XCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMy8xMi9UaGUtQmV0c3ktcm9vbS1taWFtaS1iZWFjaC0zMDB4MTk2LmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmdcIj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZyBmYy1pdGVtLW5vLXBhZGRpbmdcIj5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tdGl0bGUgZmMtaXRlbS1wcmltYXJ5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2VcIj5UaGUgQmV0c3kgTWlhbWkgQmVhY2g8L2Rpdj5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tY29udGVudCBmYy1pdGVtLWJvZHktdGV4dC1jb2xvclwiPnttYXJrZXJfYWRkcmVzc308L2Rpdj5cclxuICAgICAgICA8L2Rpdj5cclxuICAgIDwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWNsZWFyXCI+PC9kaXY+XHJcbjwvZGl2PiIsImFkZHJlc3MiOiIxNDQwIE9jZWFuIERyLCBNaWFtaSBCZWFjaCwgRkwgMzMxMzksIFZlcmVuaWdkZSBTdGF0ZW4iLCJsb2NhdGlvbiI6eyJsYXQiOiIyNS43ODY0NzcyIiwiY2l0eSI6Ik1pYW1pIEJlYWNoIiwic3RhdGUiOiJGbG9yaWRhIiwiY291bnRyeSI6IlZlcmVuaWdkZSBTdGF0ZW4iLCJsbmciOiItODAuMTI5ODQwNSIsIm9uY2xpY2tfYWN0aW9uIjoibWFya2VyIiwicmVkaXJlY3RfcGVybWFsaW5rIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9vdmVybmFjaHRlbi1taWFtaS90aGUtYmV0c3ktbWlhbWktYmVhY2gvIiwiem9vbSI6MTIsImV4dHJhX2ZpZWxkcyI6eyJwb3N0X2V4Y2VycHQiOiIiLCJwb3N0X2NvbnRlbnQiOiJbdmNfcm93XVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMi8zXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIlByYWNodGlnIGJvZXRpZWtob3RlbCBpbiBNaWFtaSBCZWFjaFwiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDo0NXB4O1wiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NTBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiMTQ0MCBPY2VhbiBEcml2ZSwgTWlhbWkgQmVhY2hcIiBoZWFkaW5nX3RhZz1cImRpdlwiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5Ok9zd2FsZHxmb250X2NhbGw6T3N3YWxkXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MzBweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjM1cHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF1cclxuPHAgc3R5bGU9XCJ0ZXh0LWFsaWduOiBjZW50ZXI7XCI+XHUyYjUwXHVmZTBmXHUyYjUwXHVmZTBmXHUyYjUwXHVmZTBmXHUyYjUwXHVmZTBmXHUyYjUwXHVmZTBmPC9wPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW5dW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIlRoZSBCZXRzeSBpbiBNaWFtaSBCZWFjaFwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjMwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIiQkJCRcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjYzU5YzRkXCIgYWxpZ25tZW50PVwibGVmdFwiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6MzBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XVRoZSBCZXRzeSBpbiBNaWFtaSBCZWFjaCBpcyBcdTAwZTljaHQgem8nbiB0eXBpc2NoICNidWNrZXRsaXN0IGhvdGVsIHdhYXIgamUgd2lsdCBvdmVybmFjaHRlbi4gR2VsZWdlbiBhYW4gZGUgYmVyb2VtZGUgT2NlYW4gRHJpdmUgZW4gaW4gcHJhY2h0aWdlIGFydC1kZWNvIHN0aWpsLiBIZXQgYm9ldGllayBob3RlbCBpcyB0b3QgaW4gZGUgcHVudGplcyBnZXN0eWxlZCB3YXQgamUgaGV0IGJlc3Qga3VudCBiZW5vZW1lbiBhbHMgdmludGFnZSBtZWV0cyBiZWFjaC4gRGUgdmVyc2NoaWxsZW5kZSBrYW1lcnMgaGViYmVuIGJvdmVuZGllbiBlbGsgZWVuIGVpZ2VuIHN0aWpsLiBIaWVyIGt1biBqZSB6b25kZXIgbW9laXRlIHJvbmRsb3BlbiBtZXQgZWVuIGdyb3RlIHpvbm5lYnJpbCwgZWVuIHN0cmFuZGhvZWQgZW4gZWVuIGthZmthanVyayBhbHMgbmlldXdlcndldHNlIGpldHNldHRlci4gSGV0IGhvdGVsIGhlZWZ0IHR3ZWUgendlbWJhZGVuLCBlZW50amUgb3AgZGUgcm9vZnRvcCBlbiBlZW4gendlbWJhZCBpbiBlZW4ga251c3NlIGJpbm5lbnBsYWF0cy4gRXIgaXMgZWVuIGdlemVsbGlnZSBiYXIgZW4gQmV0c3ksIGRlIEdvbGRlbiBSZXRyaWV2ZXIsIHZlcndlbGtvbXQgamUgbWV0IHZlZWwgbGllZmRlIGVuIGVudGhvdXNpYXNtZSFbL3ZjX2NvbHVtbl90ZXh0XVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIkdlc2VsZWN0ZWVyZCBkb29yIEhleSFVU0FcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6Um9ib3RvIFNsYWJ8Zm9udF9jYWxsOlJvYm90bytTbGFifHZhcmlhbnQ6ODAwXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjBweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX3N0eWxlPVwiZm9udC13ZWlnaHQ6ODAwO1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdV2lqIGhvdWRlbiB2YW4gZGl0IHNvb3J0IGhvdGVscy4gVGhlIEJldHN5IGluIE1pYW1pIEJlYWNoIGlzIGVlbiBob3RlbCBtZXQga2FyYWt0ZXIsIHNmZWVyIGVuIG9vZyB2b29yIGRldGFpbHMuIEhldCBpcyBhbHNvZiBqZSBsb2dlZXJ0IGJpaiBlZW4gcmlqa2UgQW1lcmlrYWFuc2UgbWV0IHZlZWwgc21hYWsgaW4gcGxhYXRzIHZhbiBlZW4gdHlwaXNjaCBob3RlbC4gVGhlIEJldHN5IGxpZ3QgYmlqbmEgYWFuIGhldCBlaW5kZSB2YW4gZGUgYmVyb2VtZGUgT2NlYW4gRHJpdmUgZW4gaGV0IHN0cmFuZCB2YW4gU291dGggQmVhY2ggaXMgc2xlY2h0cyBvcCBlbmtlbGUgbWV0ZXJzIHZhbiBoZXQgaG90ZWwgdmVyd2lqZGVyZC4gRGUgZ2V6ZWxsaWdlIHdpbmtlbHN0cmFhdCBMaW5jb2xuIFJvYWQgZW4gaGV0IE1lZGl0ZXJyYWFuc2UgRXNwYVx1MDBmMW9sYSBXYXkgbGlnZ2VuIFx1MDBmM1x1MDBmM2sgaW4gZGUgYnV1cnQgdmFuIGRpdCBoZWVybGlqa2UgaG90ZWwuWy92Y19jb2x1bW5fdGV4dF1bdWx0X2J1dHRvbnMgYnRuX3RpdGxlPVwiQm9layBlZW4ga2FtZXJcIiBidG5fbGluaz1cInVybDpodHRwcyUzQSUyRiUyRnd3dy5ib29raW5nLmNvbSUyRmhvdGVsJTJGdXMlMkZ0aGUtYmV0c3kubmwuaHRtbCUzRmFpZCUzRDc5NTg0OTglMjZub19yb29tcyUzRDElMjZncm91cF9hZHVsdHMlM0QyJTI2bGFiZWwlM0R0aGUtYmV0c3ktaG90ZWwtcGFnZXx0aXRsZTpCb2VrJTIwZWVuJTIwa2FtZXJ8dGFyZ2V0Ol9ibGFua1wiIGJ0bl90aXRsZV9jb2xvcj1cIiNmZmZmZmZcIiBidG5fYmdfY29sb3I9XCIjYjM0YTRjXCIgYnRuX2hvdmVyPVwidWJ0bi1ib3R0b20tYmdcIiBidG5fYmdfY29sb3JfaG92ZXI9XCIjNTMxYTIzXCIgaWNvbl9zaXplPVwiMzJcIiBidG5faWNvbl9wb3M9XCJ1YnRuLXNlcC1pY29uLWF0LWxlZnRcIiBidG5fZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgYnRuX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjBweDtcIiBidG5fbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjI1cHg7XCJdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt2Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjIvM1wiXVt0aGJfaW1hZ2Vfc2xpZGVyIGxpZ2h0Ym94PVwibWZwLWdhbGxlcnlcIiB0aGJfZXF1YWxfaGVpZ2h0PVwidHJ1ZVwiIGF1dG9wbGF5PVwidHJ1ZVwiIGltYWdlcz1cIjE4MDQyLDE4MDQzLDE4MDQ0LDE4MDQ1LDE4MDQ2LDE4MDQ3LDE4MDQ4LDE4MDQ5XCJdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfc2luZ2xlX2ltYWdlIGltYWdlPVwiMTgwNDNcIiBpbWdfc2l6ZT1cImxhcmdlXCIgYWRkX2NhcHRpb249XCJ5ZXNcIiBzdHlsZT1cInZjX2JveF9zaGFkb3dfM2RcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiUG9wdWxhaXJlIGZhY2lsaXRlaXRlblwiIGhlYWRpbmdfdGFnPVwiaDNcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozMHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdVGhlIEJldHN5IGluIE1pYW1pIEJlYWNoIGlzIG5pZXQgJ3pvbWFhcicgZWVuIGhvdGVsLiBOYXR1dXJsaWprIG1hZyBqZSBoaWVyIGFsbGUgdmVyd2VubmVyaWogdmVyd2FjaHRlbiB2YW4gZWVuIGx1eHVldXMgYm9ldGllayBob3RlbCwgbWFhciBoZXQgbGV1a3N0IGlzIGRlIHZlcmJpbnRlbmlzIG1ldCBkZSBidXVydC4gTG9jYWxzIGtvbWVuIGhpZXIga29mZmllIGRyaW5rZW4sIHBsYWF0c2VsaWprZSBrdW5zdGVuYWFycyBtb2dlbiBpbiBoZXQgaG90ZWwgZXhwb3NlcmVuIGVuIGRlIGxvYmJ5IGlzIGFsdGlqZCBnZXplbGxpZyBkcnVrLiBUaGUgQmV0c3kgaGVlZnQgdHdlZSB6d2VtYmFkZW4sICdyb29mIGRlY2tzJyB3YWFyIGplIGt1bnQgem9ubmVuIG1ldCBwcmFjaHRpZyB6aWNodCBvcCBkZSB6ZWUsIGVlbiBmaXRuZXNzLCBzcGEgZW4gZWVuIHVpdGdlYnJlaWRlIGJpYmxpb3RoZWVrLiBFciBpcyByZWdlbG1hdGlnIGxpdmUgbXV6aWVrIGluIGRlIGJhciBlbiBoZXQgcmVzdGF1cmFudC4gS29ydG9tLCBUaGUgQmV0c3kgaXMgXHUwMGU5Y2h0IGV2ZW4gZ2VuaWV0ZW4uWy92Y19jb2x1bW5fdGV4dF1bdGhiX2ljb25saXN0IGljb249XCJmYXMgZmEtbWFwLW1hcmtlci1hbHRcIiBsaXN0X2NvbnRlbnQ9XCJUb3Bsb2NhdGllXCJdW3RoYl9pY29ubGlzdCBpY29uPVwiZmFzIGZhLXdpZmlcIiBsaXN0X2NvbnRlbnQ9XCJHcmF0aXMgV2lGaVwiXVt0aGJfaWNvbmxpc3QgaWNvbj1cImZhcyBmYS11dGVuc2lsc1wiIGxpc3RfY29udGVudD1cIlJlc3RhdXJhbnQgZW4gZ2V6ZWxsaWdlIGJhclwiXVt0aGJfaWNvbmxpc3QgaWNvbj1cImZhcyBmYS1nbGFzcy1jaGVlcnNcIiBsaXN0X2NvbnRlbnQ9XCJSb29mdG9wIG1ldCBiYXIgZW4gendlbWJhZFwiXVt0aGJfaWNvbmxpc3QgaWNvbj1cImZhcyBmYS1kb2xsYXItc2lnblwiIGxpc3RfY29udGVudD1cIk5pZXQgZ29lZGtvb3AgbWFhciBhYnNvbHV1dCBkZSBtb2VpdGUhXCJdW3RoYl9pY29ubGlzdCBpY29uPVwiZmFzIGZhLWJlZFwiIGxpc3RfY29udGVudD1cIkNvbWZvcnRhYmVsZSBiZWRkZW5cIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMjVweFwiXVt1bHRfYnV0dG9ucyBidG5fdGl0bGU9XCJCb2VrIGVlbiBrYW1lclwiIGJ0bl9saW5rPVwidXJsOmh0dHBzJTNBJTJGJTJGd3d3LmJvb2tpbmcuY29tJTJGaG90ZWwlMkZ1cyUyRnRoZS1iZXRzeS5ubC5odG1sJTNGYWlkJTNENzk1ODQ5OCUyNm5vX3Jvb21zJTNEMSUyNmdyb3VwX2FkdWx0cyUzRDIlMjZsYWJlbCUzRHRoZS1iZXRzeS1ob3RlbC1wYWdlfHRpdGxlOkJvZWslMjBlZW4lMjBrYW1lcnx0YXJnZXQ6X2JsYW5rXCIgYnRuX3RpdGxlX2NvbG9yPVwiI2ZmZmZmZlwiIGJ0bl9iZ19jb2xvcj1cIiNiMzRhNGNcIiBidG5faG92ZXI9XCJ1YnRuLWJvdHRvbS1iZ1wiIGJ0bl9iZ19jb2xvcl9ob3Zlcj1cIiM1MzFhMjNcIiBpY29uX3NpemU9XCIzMlwiIGJ0bl9pY29uX3Bvcz1cInVidG4tc2VwLWljb24tYXQtbGVmdFwiIGJ0bl9mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBidG5fZm9udF9zaXplPVwiZGVza3RvcDoyMHB4O1wiIGJ0bl9saW5lX2hlaWdodD1cImRlc2t0b3A6MjVweDtcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW5dWy92Y19jb2x1bW5dWy92Y19yb3ddIiwicG9zdF90aXRsZSI6IlRoZSBCZXRzeSBNaWFtaSBCZWFjaCIsInBvc3RfbGluayI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvb3Zlcm5hY2h0ZW4tbWlhbWkvdGhlLWJldHN5LW1pYW1pLWJlYWNoLyIsInBvc3RfZmVhdHVyZWRfaW1hZ2UiOiI8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIkhldCBib3V0aXF1ZSBob3RlbCBUaGUgQmV0c3kgaW4gTWlhbWkgQmVhY2hcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjE5NlwiIHNyYz1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjMvMTIvVGhlLUJldHN5LXJvb20tbWlhbWktYmVhY2gtMzAweDE5Ni5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj4iLCJwb3N0X2NhdGVnb3JpZXMiOiJPdmVybmFjaHRlbiBpbiBNaWFtaSIsInBvc3RfdGFncyI6IiIsIiVpbmxpbmVfZmVhdHVyZWRfaW1hZ2UlIjoiMCIsIiVfZWRpdF9sb2NrJSI6IjE3MDE0NjEzMDI6MSIsIiVfZWRpdF9sYXN0JSI6IjEiLCIlX3lvYXN0X3dwc2VvX3ByaW1hcnlfY2F0ZWdvcnklIjoiMjM0IiwiJV90aHVtYm5haWxfaWQlIjoiMTgwMzUiLCIlX2hpZGVfZmVhdHVyZWQlIjpudWxsLCIlX3dwZ21wX2xvY2F0aW9uX2FkZHJlc3MlIjoiMTQ0MCBPY2VhbiBEciwgTWlhbWkgQmVhY2gsIEZMIDMzMTM5LCBWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9sb2NhdGlvbl9jaXR5JSI6Ik1pYW1pIEJlYWNoIiwiJV93cGdtcF9sb2NhdGlvbl9zdGF0ZSUiOiJGbG9yaWRhIiwiJV93cGdtcF9sb2NhdGlvbl9jb3VudHJ5JSI6IlZlcmVuaWdkZSBTdGF0ZW4iLCIlX3dwZ21wX21ldGFib3hfbGF0aXR1ZGUlIjoiMjUuNzg2NDc3MiIsIiVfd3BnbXBfbWV0YWJveF9sb25naXR1ZGUlIjoiLTgwLjEyOTg0MDUiLCIlX3dwZ21wX21ldGFib3hfbG9jYXRpb25fcmVkaXJlY3QlIjoibWFya2VyIiwiJV93cGdtcF9tZXRhYm94X2N1c3RvbV9saW5rJSI6IiIsIiVfd3BnbXBfbWFwX2lkJSI6ImE6MTp7aTowO3M6MTpcIjdcIjt9IiwiJV93cGdtcF9tZXRhYm94X21hcmtlcl9pZCUiOiJhOjE6e2k6MDtzOjI6XCIxM1wiO30iLCIlX3dwZ21wX21ldGFib3hfdGF4b21vbWllc190ZXJtcyUiOiIiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6IiIsIiVfd3BiX3ZjX2pzX3N0YXR1cyUiOiJ0cnVlIiwiJV95b2FzdF93cHNlb19jb250ZW50X3Njb3JlJSI6IjYwIiwiJV95b2FzdF93cHNlb19mb2N1c2tleXdvcmRzJSI6IltdIiwiJV95b2FzdF93cHNlb19rZXl3b3Jkc3lub255bXMlIjoiW1wiXCJdIiwiJV95b2FzdF93cHNlb19lc3RpbWF0ZWQtcmVhZGluZy10aW1lLW1pbnV0ZXMlIjoiMyIsIiVwb3N0LXByaW1hcnktY2F0ZWdvcnklIjoiYXV0byIsIiVmZWF0dXJlZF9pbWFnZV9vdmVycmlkZSUiOiJvZmYiLCIlc3RhbmRhcmQtZmVhdHVyZWQtY3JlZGl0JSI6IlRoZSBCZXRzeSBNaWFtaSBCZWFjaCIsIiVhcnRpY2xlX3N0eWxlX292ZXJyaWRlJSI6Im9uIiwiJXBvc3Rfc3R5bGUlIjoic3R5bGU1IiwiJXBvc3RfZ2FsbGVyeV9zdHlsZSUiOiJsaWdodGJveCIsIiVwb3N0X3JldmlldyUiOiJvZmYiLCIlcG9zdF9yZXZpZXdfc3R5bGUlIjoic3R5bGUxIiwiJXBvc3RfcmV2aWV3X2F2ZXJhZ2UlIjoiNTAiLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza3clIjoiVGhlIEJldHN5IE1pYW1pIEJlYWNoIiwiJV95b2FzdF93cHNlb19tZXRhZGVzYyUiOiJFZW4gcHJhY2h0aWcgYXJ0LWRlY28gYm91dGlxdWUgaG90ZWwgYWFuIGRlIGJlcm9lbWRlIE9jZWFuIERyaXZlIGluIE1pYW1pIEJlYWNoLiBFZW4gaG90ZWwgbWV0IEImQi1mZWVsaW5nIHdhYXIgaG9uZGVuIHdlbGtvbSB6aWpuISIsIiVfeW9hc3Rfd3BzZW9fbGlua2RleCUiOiI2NyIsIiVwb3N0X3NvdXJjZSUiOlt7InRpdGxlIjoiRm90b2dyYWZpZTogVGhlIEJldHN5IiwicG9zdF9zb3VyY2VfdXJsIjoiaHR0cHM6Ly93d3cudGhlYmV0c3lob3RlbC5jb20ifV0sIiVfeW9hc3RfaW5kZXhub3dfbGFzdF9waW5nJSI6IjE3MDE0NjA4NTMiLCIlX3d3c19zdXBwb3J0X2NvbnRhY3RfbnVtYmVyJSI6IiIsIiVfd3dzX2Fib3V0X3N1cHBvcnRfdGV4dCUiOiIiLCIlX3d3c190cmlnZ2VyX2J1dHRvbl90ZXh0JSI6IiIsIiVfd3dzX3ByZWRlZmluZWRfdGV4dCUiOiIiLCIlX3lvYXN0X3dwc2VvX3dvcmRwcm9vZl90aW1lc3RhbXAlIjoiIiwiJV9sYXN0X2VkaXRvcl91c2VkX2pldHBhY2slIjoiY2xhc3NpYy1lZGl0b3IiLCJ0YXhvbm9teT1jYXRlZ29yeSI6Ik92ZXJuYWNodGVuIGluIE1pYW1pIiwidGF4b25vbXk9cG9zdF90YWciOiIiLCJ0YXhvbm9teT1wb3N0X2Zvcm1hdCI6IiIsInRheG9ub215PXRoYi1yZWFjdGlvbnMiOiIiLCJ0YXhvbm9teT10aGItc3BvbnNvcnMiOiIifSwiaWNvbiI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjEvMDQvaG90ZWwucG5nIn0sImlkIjoxODAzNCwiaW5mb3dpbmRvd19kaXNhYmxlIjpmYWxzZSwiY2F0ZWdvcmllcyI6W3siaWNvbiI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjEvMDQvaG90ZWwucG5nIiwibmFtZSI6IkhvdGVscyIsImlkIjoiMTMiLCJ0eXBlIjoiY2F0ZWdvcnkiLCJleHRlbnNpb25fZmllbGRzIjp7ImNhdF9vcmRlciI6IiJ9fV19LHsic291cmNlIjoicG9zdCIsInRpdGxlIjoiWW90ZWwgV2FzaGluZ3RvbiBEQyIsImluZm93aW5kb3dfY29udGVudCI6IjxkaXYgY2xhc3M9XCJmYy1pdGVtLWJveCBmYy1pdGVtLW5vLXBhZGRpbmcgXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIkVlbiBZb3RlbCBob3RlbGthbWVyIGluIFdhc2hpbmd0b24gRENcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjIwMFwiIHNyYz1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjMvMTIvWW90ZWxfUHJlbWl1bV9LaW5nX1dhc2hpbmd0b25EQy0zMDB4MjAwLndlYnBcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmcgZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+WW90ZWwgV2FzaGluZ3RvbiBEQzwvZGl2PlxyXG4gICAgICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1jb250ZW50IGZjLWl0ZW0tYm9keS10ZXh0LWNvbG9yXCI+e21hcmtlcl9hZGRyZXNzfTwvZGl2PlxyXG4gICAgICAgIDwvZGl2PlxyXG4gICAgPC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtY2xlYXJcIj48L2Rpdj5cclxuPC9kaXY+IiwiYWRkcmVzcyI6IjQxNSBOZXcgSmVyc2V5IEF2ZSBOVywgV2FzaGluZ3RvbiwgREMgMjAwMDEsIFZlcmVuaWdkZSBTdGF0ZW4iLCJsb2NhdGlvbiI6eyJsYXQiOiIzOC44OTU0NjEzOTk5OTk5OSIsImNpdHkiOiJXYXNoaW5ndG9uIiwic3RhdGUiOiJEaXN0cmljdCBvZiBDb2x1bWJpYSIsImNvdW50cnkiOiJWZXJlbmlnZGUgU3RhdGVuIiwibG5nIjoiLTc3LjAxMDg4MDMiLCJvbmNsaWNrX2FjdGlvbiI6Im1hcmtlciIsInJlZGlyZWN0X3Blcm1hbGluayI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvb3Zlcm5hY2h0ZW4taW4td2FzaGluZ3Rvbi1kYy95b3RlbC13YXNoaW5ndG9uLWRjLyIsInpvb20iOjEyLCJleHRyYV9maWVsZHMiOnsicG9zdF9leGNlcnB0IjoiIiwicG9zdF9jb250ZW50IjoiW3ZjX3Jvd11bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjIvM1wiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJCZXRhYWxiYWFyIGhvdGVsIGluIFdhc2hpbmd0b24gRENcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6NDVweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjUwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIjQxNSBOZXcgSmVyc2V5IEF2ZW51ZSwgV2FzaGluZ3RvbiBEQ1wiIGhlYWRpbmdfdGFnPVwiZGl2XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6T3N3YWxkfGZvbnRfY2FsbDpPc3dhbGRcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDozMHB4O1wiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6MzVweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XVxyXG48cCBzdHlsZT1cInRleHQtYWxpZ246IGNlbnRlcjtcIj5cdTJiNTBcdWZlMGZcdTJiNTBcdWZlMGZcdTJiNTBcdWZlMGZcdTJiNTBcdWZlMGY8L3A+XHJcblsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiWW90ZWwgSG90ZWwgaW4gV2FzaGluZ3RvbiBEQ1wiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjMwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIiQkJFwiIG1haW5faGVhZGluZ19jb2xvcj1cIiNjNTljNGRcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozMHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdQmlqIDxhIGhyZWY9XCJodHRwczovL3d3dy5ib29raW5nLmNvbS9ob3RlbC91cy90aGUtbGlhc29uLWNhcGl0b2wtaGlsbC5ubC5odG1sP2FpZD03OTU4NDk4JmFtcDtub19yb29tcz0xJmFtcDtncm91cF9hZHVsdHM9MiZhbXA7bGFiZWw9eW90ZWwtaG90ZWwtcGFnZVwiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+WW90ZWwgaW4gV2FzaGluZ3RvbiBEQzwvYT4gZHJhYWl0IGFsbGVzIG9tIGxvY2F0aWUsIGxvY2F0aWUsIGxvY2F0aWUuIEhldCBob3RlbCBsaWd0IGRhbiBvb2sgb3Agd2FuZGVsYWZzdGFuZCB2YW4gZGUgTmF0aW9uYWwgTWFsbC4gQWxzIGplIG1ldCBkZSB0cmVpbiBuYWFyIFdhc2hpbmd0b24gREMgcmVpc3QgaXMgWW90ZWwgXHUwMGYzXHUwMGYzayBoZWVsIGhhbmRpZywgaGV0IGxpZ3QgbmFtZWxpamsgYmlqbmEgdGVnZW5vdmVyIDxhIGhyZWY9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dhc2hpbmd0b24tZGMvdW5pb24tc3RhdGlvbi9cIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPlVuaW9uIFN0YXRpb248L2E+LiBOaWV0IGVua2VsIGhhbmRpZyB2YW53ZWdlIGRlIHRyZWluLCBvb2sgZGUgbWV0cm8gc3RvcHQgaGllci4gTGFuZ2UgcmlqZW4gYmlqIGhldCBpbmNoZWNrZW4gaGViIGplIGhpZXIgYm92ZW5kaWVuIG5pZXQsIGplIGt1bnQgbmFtZWxpamsgemVsZiBpbmNoZWNrZW4gdmlhIGVlbiB0YWJsZXQuIFlvdGVsIGluIFdhc2hpbmd0b24gREMgaXMgYm92ZW5kaWVuIGVlbiBidWRnZXQgZnJpZW5kbHkgaG90ZWwuWy92Y19jb2x1bW5fdGV4dF1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJHZXNlbGVjdGVlcmQgZG9vciBIZXkhVVNBXCIgYWxpZ25tZW50PVwibGVmdFwiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OlJvYm90byBTbGFifGZvbnRfY2FsbDpSb2JvdG8rU2xhYnx2YXJpYW50OjgwMFwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjIwcHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19zdHlsZT1cImZvbnQtd2VpZ2h0OjgwMDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XVlvdGVsIGluIFdhc2hpbmd0b24gREMgaXMgZG9vciBIZXkhVVNBIGdlc2VsZWN0ZWVyZCBvbWRhdCBkaXQgaG90ZWwgZGljaHRiaWogZ3JvdGUgYmV6aWVuc3dhYXJkaWdoZWRlbiBsaWd0LCB6b2FscyBkZSBOYXRpb25hbCBNYWxsIG1ldCBkZSB2ZWxlIGdyYXRpcyBtdXNlYSwgaGV0IENhcGl0b29sIGVuIFVuaW9uIFN0YXRpb24uIFlvdGVsIGlzIGVlbiBidWRnZXR2cmllbmRlbGlqayBhbHRlcm5hdGllZiBtXHUwMGU5dCB2aWpmIHN0ZXJyZW4gZmFjaWxpdGVpdGVuLiBab2FscyBlZW4gcm9vZnRvcCBsb3VuZ2UgbWV0IHp3ZW1iYWRlbiBiYXIuIEVyIGlzIGdyYXRpcyBXaUZpLCBrb2ZmaWUgZW4gaW4gaGV0IHJlc3RhdXJhbnQgJ0FydCBhbmQgU291bCcgd29yZHQgb250YmlqdCBnZXNlcnZlZXJkLiBLb3J0b20sIGVlbiBpZGVhYWwgaG90ZWwsIHBlcmZlY3RlIGxvY2F0aWUsIGxldWsgdm9vciBqZSBwb3J0ZW1vbm5lZSBlbiBhYnNvbHV1dCBlZW4gYWFucmFkZXIuWy92Y19jb2x1bW5fdGV4dF1bdWx0X2J1dHRvbnMgYnRuX3RpdGxlPVwiQm9layBlZW4ga2FtZXJcIiBidG5fbGluaz1cInVybDpodHRwcyUzQSUyRiUyRnd3dy5ib29raW5nLmNvbSUyRmhvdGVsJTJGdXMlMkZ0aGUtbGlhc29uLWNhcGl0b2wtaGlsbC5ubC5odG1sJTNGYWlkJTNENzk1ODQ5OCUyNm5vX3Jvb21zJTNEMSUyNmdyb3VwX2FkdWx0cyUzRDIlMjZsYWJlbCUzRHlvdGVsLWhvdGVsLXBhZ2V8dGl0bGU6Qm9layUyMGVlbiUyMGthbWVyfHRhcmdldDpfYmxhbmtcIiBidG5fdGl0bGVfY29sb3I9XCIjZmZmZmZmXCIgYnRuX2JnX2NvbG9yPVwiI2IzNGE0Y1wiIGJ0bl9ob3Zlcj1cInVidG4tYm90dG9tLWJnXCIgYnRuX2JnX2NvbG9yX2hvdmVyPVwiIzUzMWEyM1wiIGljb25fc2l6ZT1cIjMyXCIgYnRuX2ljb25fcG9zPVwidWJ0bi1zZXAtaWNvbi1hdC1sZWZ0XCIgYnRuX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIGJ0bl9mb250X3NpemU9XCJkZXNrdG9wOjIwcHg7XCIgYnRuX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDoyNXB4O1wiXVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIyLzNcIl1bdGhiX2ltYWdlX3NsaWRlciBsaWdodGJveD1cIm1mcC1nYWxsZXJ5XCIgdGhiX2VxdWFsX2hlaWdodD1cInRydWVcIiBhdXRvcGxheT1cInRydWVcIiBpbWFnZXM9XCIxODAyNiwxODAyNywxODAyOCwxODAyOSwxODAzMCwxODAzMVwiXVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3ZjX3NpbmdsZV9pbWFnZSBpbWFnZT1cIjE4MDMwXCIgaW1nX3NpemU9XCJsYXJnZVwiIGFkZF9jYXB0aW9uPVwieWVzXCIgc3R5bGU9XCJ2Y19ib3hfc2hhZG93XzNkXCJdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIlBvcHVsYWlyZSBmYWNpbGl0ZWl0ZW5cIiBoZWFkaW5nX3RhZz1cImgzXCIgYWxpZ25tZW50PVwibGVmdFwiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6MzBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XVlvdGVsIGluIFdhc2hpbmd0b24gREMgbGlndCBvcCBzbGVjaHRzIGVua2VsZSBtaW51dGVuIHZhbiBkZSBOYXRpb25hbCBNYWxsLCBkZSB2ZWxlIGdyYXRpcyBtdXNlYSwgaGV0IENhcGl0b29sIGVuIFVuaW9uIFN0YXRpb24uIEJldGFhbGJhYXIgZXRlbiBrdW4gamUgaW4gQ2hpbmF0b3duLCBkYXQgc2xlY2h0cyAxMCBtaW51dGVuIHZlciB3YW5kZWxlbiBpcy5bL3ZjX2NvbHVtbl90ZXh0XVt0aGJfaWNvbmxpc3QgaWNvbj1cImZhcyBmYS1tYXAtbWFya2VyLWFsdFwiIGxpc3RfY29udGVudD1cIlRvcGxvY2F0aWVcIl1bdGhiX2ljb25saXN0IGljb249XCJmYXMgZmEtd2lmaVwiIGxpc3RfY29udGVudD1cIkdyYXRpcyBXaUZpXCJdW3RoYl9pY29ubGlzdCBpY29uPVwiZmFzIGZhLXV0ZW5zaWxzXCIgbGlzdF9jb250ZW50PVwiUmVzdGF1cmFudFwiXVt0aGJfaWNvbmxpc3QgaWNvbj1cImZhcyBmYS1nbGFzcy1jaGVlcnNcIiBsaXN0X2NvbnRlbnQ9XCJSb29mdG9wIGxvdW5nZSBtZXQgendlbWJhZFwiXVt0aGJfaWNvbmxpc3QgaWNvbj1cImZhcyBmYS1kb2xsYXItc2lnblwiIGxpc3RfY29udGVudD1cIkJ1ZGdldHZyaWVuZGVsaWprXCJdW3RoYl9pY29ubGlzdCBpY29uPVwiZmFzIGZhLWJlZFwiIGxpc3RfY29udGVudD1cIkNvbWZvcnRhYmVsZSBiZWRkZW5cIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMjVweFwiXVt1bHRfYnV0dG9ucyBidG5fdGl0bGU9XCJCb2VrIGVlbiBrYW1lclwiIGJ0bl9saW5rPVwidXJsOmh0dHBzJTNBJTJGJTJGd3d3LmJvb2tpbmcuY29tJTJGaG90ZWwlMkZ1cyUyRnRoZS1saWFzb24tY2FwaXRvbC1oaWxsLm5sLmh0bWwlM0ZhaWQlM0Q3OTU4NDk4JTI2bm9fcm9vbXMlM0QxJTI2Z3JvdXBfYWR1bHRzJTNEMiUyNmxhYmVsJTNEeW90ZWwtaG90ZWwtcGFnZXx0aXRsZTpCb2VrJTIwZWVuJTIwa2FtZXJ8dGFyZ2V0Ol9ibGFua1wiIGJ0bl90aXRsZV9jb2xvcj1cIiNmZmZmZmZcIiBidG5fYmdfY29sb3I9XCIjYjM0YTRjXCIgYnRuX2hvdmVyPVwidWJ0bi1ib3R0b20tYmdcIiBidG5fYmdfY29sb3JfaG92ZXI9XCIjNTMxYTIzXCIgaWNvbl9zaXplPVwiMzJcIiBidG5faWNvbl9wb3M9XCJ1YnRuLXNlcC1pY29uLWF0LWxlZnRcIiBidG5fZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgYnRuX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjBweDtcIiBidG5fbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjI1cHg7XCJdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uXVsvdmNfY29sdW1uXVsvdmNfcm93XSIsInBvc3RfdGl0bGUiOiJZb3RlbCBXYXNoaW5ndG9uIERDIiwicG9zdF9saW5rIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9vdmVybmFjaHRlbi1pbi13YXNoaW5ndG9uLWRjL3lvdGVsLXdhc2hpbmd0b24tZGMvIiwicG9zdF9mZWF0dXJlZF9pbWFnZSI6IjxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiRWVuIFlvdGVsIGhvdGVsa2FtZXIgaW4gV2FzaGluZ3RvbiBEQ1wiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMy8xMi9Zb3RlbF9QcmVtaXVtX0tpbmdfV2FzaGluZ3RvbkRDLTMwMHgyMDAud2VicFwiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6Ik92ZXJuYWNodGVuIGluIFdhc2hpbmd0b24gREMiLCJwb3N0X3RhZ3MiOiIiLCIlaW5saW5lX2ZlYXR1cmVkX2ltYWdlJSI6IjAiLCIlX2VkaXRfbG9jayUiOiIxNzAxNDU1MTc5OjEiLCIlX2VkaXRfbGFzdCUiOiIxIiwiJV95b2FzdF93cHNlb19wcmltYXJ5X2NhdGVnb3J5JSI6IjExMCIsIiVfdGh1bWJuYWlsX2lkJSI6IjE4MDIyIiwiJV9oaWRlX2ZlYXR1cmVkJSI6bnVsbCwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6IjQxNSBOZXcgSmVyc2V5IEF2ZSBOVywgV2FzaGluZ3RvbiwgREMgMjAwMDEsIFZlcmVuaWdkZSBTdGF0ZW4iLCIlX3dwZ21wX2xvY2F0aW9uX2NpdHklIjoiV2FzaGluZ3RvbiIsIiVfd3BnbXBfbG9jYXRpb25fc3RhdGUlIjoiRGlzdHJpY3Qgb2YgQ29sdW1iaWEiLCIlX3dwZ21wX2xvY2F0aW9uX2NvdW50cnklIjoiVmVyZW5pZ2RlIFN0YXRlbiIsIiVfd3BnbXBfbWV0YWJveF9sYXRpdHVkZSUiOiIzOC44OTU0NjEzOTk5OTk5OSIsIiVfd3BnbXBfbWV0YWJveF9sb25naXR1ZGUlIjoiLTc3LjAxMDg4MDMiLCIlX3dwZ21wX21ldGFib3hfbG9jYXRpb25fcmVkaXJlY3QlIjoibWFya2VyIiwiJV93cGdtcF9tZXRhYm94X2N1c3RvbV9saW5rJSI6IiIsIiVfd3BnbXBfbWFwX2lkJSI6ImE6MTp7aTowO3M6MTpcIjdcIjt9IiwiJV93cGdtcF9tZXRhYm94X21hcmtlcl9pZCUiOiJhOjE6e2k6MDtzOjI6XCIxM1wiO30iLCIlX3dwZ21wX21ldGFib3hfdGF4b21vbWllc190ZXJtcyUiOiIiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6IiIsIiVfd3BiX3ZjX2pzX3N0YXR1cyUiOiJ0cnVlIiwiJV95b2FzdF93cHNlb19jb250ZW50X3Njb3JlJSI6IjYwIiwiJV95b2FzdF93cHNlb19mb2N1c2tleXdvcmRzJSI6IltdIiwiJV95b2FzdF93cHNlb19rZXl3b3Jkc3lub255bXMlIjoiW1wiXCJdIiwiJV95b2FzdF93cHNlb19lc3RpbWF0ZWQtcmVhZGluZy10aW1lLW1pbnV0ZXMlIjoiMiIsIiVwb3N0LXByaW1hcnktY2F0ZWdvcnklIjoiYXV0byIsIiVmZWF0dXJlZF9pbWFnZV9vdmVycmlkZSUiOiJvZmYiLCIlc3RhbmRhcmQtZmVhdHVyZWQtY3JlZGl0JSI6IllvdGVsIFdhc2hpbmd0b24gREMiLCIlYXJ0aWNsZV9zdHlsZV9vdmVycmlkZSUiOiJvbiIsIiVwb3N0X3N0eWxlJSI6InN0eWxlNSIsIiVwb3N0X2dhbGxlcnlfc3R5bGUlIjoibGlnaHRib3giLCIlcG9zdF9yZXZpZXclIjoib2ZmIiwiJXBvc3RfcmV2aWV3X3N0eWxlJSI6InN0eWxlMSIsIiVwb3N0X3Jldmlld19hdmVyYWdlJSI6IjUwIiwiJV95b2FzdF93cHNlb19mb2N1c2t3JSI6IllvdGVsIFdhc2hpbmd0b24gREMiLCIlX3lvYXN0X3dwc2VvX21ldGFkZXNjJSI6IkhldCBZb3RlbCBpbiBXYXNoaW5ndG9uIERDIGlzIGVlbiBidWRnZXR2cmllbmRlbGlqayBob3RlbCwgZGljaHRiaWogVW5pb24gU3RhdGlvbiwgZGUgTWFsbCwgZGUgdmVsZSBtdXNlYSBlbiBoZXQgQ2FwaXRvb2wuIiwiJV95b2FzdF93cHNlb19saW5rZGV4JSI6IjcyIiwiJXBvc3Rfc291cmNlJSI6W3sidGl0bGUiOiJGb3RvZ3JhZmllOiBZb3RlbCIsInBvc3Rfc291cmNlX3VybCI6Imh0dHBzOi8vd3d3LnlvdGVsLmNvbSJ9XSwiJV95b2FzdF9pbmRleG5vd19sYXN0X3BpbmclIjoiMTcwMTQ0NzEyMSIsIiVfd3dzX3N1cHBvcnRfY29udGFjdF9udW1iZXIlIjoiIiwiJV93d3NfYWJvdXRfc3VwcG9ydF90ZXh0JSI6IiIsIiVfd3dzX3RyaWdnZXJfYnV0dG9uX3RleHQlIjoiIiwiJV93d3NfcHJlZGVmaW5lZF90ZXh0JSI6IiIsIiVfeW9hc3Rfd3BzZW9fd29yZHByb29mX3RpbWVzdGFtcCUiOiIiLCIlX2xhc3RfZWRpdG9yX3VzZWRfamV0cGFjayUiOiJjbGFzc2ljLWVkaXRvciIsInRheG9ub215PWNhdGVnb3J5IjoiT3Zlcm5hY2h0ZW4gaW4gV2FzaGluZ3RvbiBEQyIsInRheG9ub215PXBvc3RfdGFnIjoiIiwidGF4b25vbXk9cG9zdF9mb3JtYXQiOiIiLCJ0YXhvbm9teT10aGItcmVhY3Rpb25zIjoiIiwidGF4b25vbXk9dGhiLXNwb25zb3JzIjoiIn0sImljb24iOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIxLzA0L2hvdGVsLnBuZyJ9LCJpZCI6MTgwMjEsImluZm93aW5kb3dfZGlzYWJsZSI6ZmFsc2UsImNhdGVnb3JpZXMiOlt7Imljb24iOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIxLzA0L2hvdGVsLnBuZyIsIm5hbWUiOiJIb3RlbHMiLCJpZCI6IjEzIiwidHlwZSI6ImNhdGVnb3J5IiwiZXh0ZW5zaW9uX2ZpZWxkcyI6eyJjYXRfb3JkZXIiOiIifX1dfSx7InNvdXJjZSI6InBvc3QiLCJ0aXRsZSI6IlJlZHdvb2QgTmF0aW9uYWwgUGFyayIsImluZm93aW5kb3dfY29udGVudCI6IjxkaXYgY2xhc3M9XCJmYy1pdGVtLWJveCBmYy1pdGVtLW5vLXBhZGRpbmcgXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIlJlZHdvb2QgTmF0aW9uYWwgUGFya1wiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjI1XCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMy8xMC9yZWR3b29kcy0zMDB4MjI1LmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmdcIj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZyBmYy1pdGVtLW5vLXBhZGRpbmdcIj5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tdGl0bGUgZmMtaXRlbS1wcmltYXJ5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2VcIj5SZWR3b29kIE5hdGlvbmFsIFBhcms8L2Rpdj5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tY29udGVudCBmYy1pdGVtLWJvZHktdGV4dC1jb2xvclwiPnttYXJrZXJfYWRkcmVzc308L2Rpdj5cclxuICAgICAgICA8L2Rpdj5cclxuICAgIDwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWNsZWFyXCI+PC9kaXY+XHJcbjwvZGl2PiIsImFkZHJlc3MiOiJDYWxpZm9ybmlcdTAwZWIsIFZlcmVuaWdkZSBTdGF0ZW4iLCJsb2NhdGlvbiI6eyJsYXQiOiI0MS40MDE3MTU2Iiwic3RhdGUiOiJDYWxpZm9ybmlcdTAwZWIiLCJjb3VudHJ5IjoiVmVyZW5pZ2RlIFN0YXRlbiIsImxuZyI6Ii0xMjQuMDQxNzExIiwib25jbGlja19hY3Rpb24iOiJtYXJrZXIiLCJyZWRpcmVjdF9wZXJtYWxpbmsiOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3JlZHdvb2QtbmF0aW9uYWwtcGFyay8iLCJ6b29tIjoxMiwiZXh0cmFfZmllbGRzIjp7InBvc3RfZXhjZXJwdCI6IiIsInBvc3RfY29udGVudCI6Ilt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCJdW3ZjX2NvbHVtbiB3aWR0aD1cIjEvMlwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCIxMDAlXCJdW3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvMlwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiUmVkd29vZCBOYXRpb25hbCBQYXJrXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjM1fHRleHRfYWxpZ246bGVmdHxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1FXHUwMGU5biB2YW4gZGUgOSBuYXRpb25hbGUgcGFya2VuIGluIENhbGlmb3JuaVx1MDBlYiBpcyBoZXQgUmVkd29vZCBOYXRpb25hbCBQYXJrLiBJbiBoZXQgcGFyaywgZGF0IGluIGhldCBub29yZGVuIHZhbiBkZSBzdGFhdCBsaWd0LCBncm9laWVuIGRlIGVub3JtZSBrdXN0bWFtbW9ldGJvbWVuLiBEZSBjb2FzdGFsIHJlZHdvb2RzIHppam4gZGUgZ3Jvb3RzdGUgcHVibGlla3N0cmVra2VyIHZhbiBoZXQgZ2ViaWVkLiBNZXQgbWVlciBkYW4gMTAwIG1ldGVyIGhvb2d0ZSB6aWpuIHplIGluZHJ1a3dla2tlbmQgb20gdGUgemllbi4gWmUgZ3JvZWllbiBsYW5ncyBkZSBncmlsbGlnZSBrdXN0bGlqbiB3YWFyZG9vciBoZXQgdm9lbHQgYWxzb2YgamUgbm9nIGluIGVlbiBzdHVramUgb25nZXJlcHQgbmF0dXVyIGxvb3B0LiBUaXBzIHZvb3IgZWVuIGJlem9layBhYW4gaGV0IFJlZHdvb2QgTmF0aW9uYWwgUGFyay5bL3ZjX2NvbHVtbl90ZXh0XVt1bHRpbWF0ZV9pY29uX2xpc3QgaWNvbl9zaXplPVwiMjBcIl1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLWF1dG9tb2JpbGUgY2FyXCJdNTAwIGtpbG9tZXRlciB2YW5hZiBTYW4gRnJhbmNpc2NvWy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLXRyZWVcIl08c3BhbiBjbGFzcz1cIkxyelhyIGtuby1mdlwiPjU0MCBrbVx1MDBiMiBvcHBlcnZsYWt0ZTwvc3Bhbj5bL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtcGF3XCJdMjAwIHZlcnNjaGlsbGVuZGUgc29vcnRlbiBkaWVyZW5bL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVsvdWx0aW1hdGVfaWNvbl9saXN0XVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY3NzPVwiLnZjX2N1c3RvbV8xNjA4NjY2NTE5NDkye2JhY2tncm91bmQtY29sb3I6ICNlYWVhZWEgIWltcG9ydGFudDt9XCJdW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIyLzNcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNzVweFwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiUmVkd29vZHNcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MzV8dGV4dF9hbGlnbjpjZW50ZXJ8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxwIHN0eWxlPVwidGV4dC1hbGlnbjogY2VudGVyO1wiPkVub3JtZSBib21lbiwgbmlldCBhbGxlZW4gaW4gZGUgbGVuZ3RlLCBtYWFyIG9vayBxdWEgZGlrdGUuIE9mZmljaWVlbCB3b3JkZW4gemUgUmVkd29vZHMgZ2Vub2VtZC4gWmUgemlqbiB0ZSBvbmRlcnNjaGVpZGVuIGluIHR3ZWUgc29vcnRlbiwgZGUgc2VxdW9pYSdzIGVuIGNvYXN0YWwgcmVkd29vZHMuIERlIHNlcXVvaWEncyB2aW5kIGplIGluIGhldCA8YSBocmVmPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9zZXF1b2lhLWtpbmdzLWNhbnlvbi1uYXRpb25hbC1wYXJrL1wiPlNlcXVvaWEgTmF0aW9uYWwgUGFyazwvYT4sIGlldHMgbWVlciBsYW5kaW53YWFydHMgaW4gQ2FsaWZvcm5pXHUwMGViLiBEZSBjb2FzdGFsIHJlZHdvb2RzLCBvb2sgd2VsIGRlIGt1c3RtYW1tb2V0Ym9tZW4gZ2Vub2VtZCwgZ3JvZWllbiBpbiBoZXQgUmVkd29vZCBOYXRpb25hbCBQYXJrIHRvdCBvbmdldmVlciA4MCBtZXRlciB2YW4gZGUga3VzdC4gSGllciB6aWpuIGRlIHRlbXBlcmF0dXJlbiBwcmVjaWVzIGdvZWQgZG9vciBoZXQgemVla2xpbWFhdC4gSGV0IHZlcnNjaGlsIHR1c3NlbiBiZWlkZSBib21lbj8gRGUgc2VxdW9pYSdzIHppam4gZWVuIHN0dWsgZGlra2VyIGVuIG1pbmRlciBob29nIGRhbiBkZSByZWR3b29kczwvcD5cclxuWy92Y19jb2x1bW5fdGV4dF1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiIGZ1bGxfd2lkdGg9XCJzdHJldGNoX3Jvd1wiIGNvbnRlbnRfdGV4dF9hbGlnbWVudD1cImNlbnRlclwiIGNzcz1cIi52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O31cIiBwYXJhbGxheF9iYWNrZ3JvdW5kX2ltYWdlPVwiMzgzNlwiXVt2Y19jb2x1bW4gdGhiX2NvbG9yPVwidGhiLWxpZ2h0LWNvbHVtblwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkVub3JtZSBjb2FzdGFsIHJlZHdvb2RzXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjc1fHRleHRfYWxpZ246Y2VudGVyfGNvbG9yOiUyM2ZmZmZmZnxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVtoZXl1c2FfaGVhZGluZyB0YWc9XCJoNFwiIHRleHRfYWxpZ249XCJjZW50ZXJcIiBoZWFkaW5nPVwiRGUgaG9vZ3N0ZSB6aWpuIG1lZXIgZGFuIDEwMCBtZXRlciBob29nXCIgZm9udF9zaXplPVwiNTBcIiBsaW5lX2hlaWdodD1cIjFcIiBmb250X2NvbG9yPVwiI2ZmZmZmZlwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVtwYXJhbGxheF9yb3cgZW5hYmxlX21vYmlsZT1cInBhcmFsbGF4LWVuYWJsZS1tb2JpbGVcIiBpbWFnZT1cIjE3NzIzXCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIl1bdmNfY29sdW1uXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJGYWN0cyBSZWR3b29kIE5hdGlvbmFsIFBhcmtcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MjV8dGV4dF9hbGlnbjpsZWZ0XCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1IZXQgUmVkd29vZCBOYXRpb25hbCBQYXJrIHdlcmQgaW4gMTk2OCBvZmZpY2llZWwgb3BnZXJpY2h0LiBIZXQgcGFyayB2b3JtdCBcdTAwZTlcdTAwZTluIGdlaGVlbCBtZXQgZHJpZSBzdGFhdHNwYXJrZW46IERlbCBOb3J0ZSBDb2FzdCBSZWR3b29kcyBTdGF0ZSBQYXJrLCBKZWRlZGlhaCBTbWl0aCBSZWR3b29kcyBTdGF0ZSBQYXJrIGVuIFByYWlyaWUgQ3JlZWsgUmVkd29vZHMgU3RhdGUgUGFyay4gU2FtZW4gd29yZGVuIHplIG9vayB3ZWwgUmVkd29vZCBOYXRpb25hbCBlbiBTdGF0ZSBQYXJrcyBnZW5vZW1kLiBEZSB0b3RhbGUgb3BwZXJ2bGFrdGUgYmVzbGFhdCA1NDAga20yIGVuIGhpZXJpbiB2aW5kIGplIG9uZ2V2ZWVyIDQ1JSB2YW4gaGV0IG5vZyBiZXN0YWFuZGUgYm9zIG1ldCBjb2FzdCByZWR3b29kcy4gRGUgcmVkd29vZHMgaW4gZGl0IGRlZWwgd29yZGVuIHR1c3NlbiBkZSA1MDAtNzAwIGphYXIgb3VkIGVuIGt1bm5lbiBlZW4gaG9vZ3RlIGtyaWpnZW4gdmFuIG1lZXIgZGUgMTAwIG1ldGVyLiBEZSBob29nc3RlIHJlZHdvb2QgaXMgZGUgSHlwZXJpb24gbWV0IG1lZXIgZGFuIDExNSBtZXRlci5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIldhdCB0ZSBkb2VuIGluIFJlZHdvb2QgTmF0aW9uYWwgUGFya1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZToyNXx0ZXh0X2FsaWduOmxlZnRcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XUhldCBSZWR3b29kIE5hdGlvbmFsIFBhcmsgaXMgZWVuIGdlYmllZCBhYW4gZGUga3VzdCBtZXQgc3RlaWxlIGtsaWZmZW4sIGxhZ3VuZXMsIHdpbGRsaWZlIGVuIGVua2VsZSB3ZWdlbiBkaWUgaGV0IHBhcmsgZG9vcmtydWl6ZW4uIFpvIGxvb3B0IGRlIGJlcm9lbWRlIDxhIGhyZWY9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL2hpZ2h3YXktMS9cIj5IaWdod2F5IDE8L2E+IGR3YXJzIGRvb3IgaGV0IHBhcmsuIERlIG1vb2lzdGUgd2VnIGVjaHRlciBpcyBkZSBOZXd0b24gRHJ1cnkgU2NlbmljIFBhcmt3YXkuIFZhbmFmIGhpZXIgc3RhcnRlbiBvb2sgdmVyc2NoaWxsZW5kZSB3YW5kZWxpbmdlbi4gVm9sZyB2YW5hZiBoaWVyIGJpanZvb3JiZWVsZCBkZSBCaWcgVHJlZSBXYXlzaWRlIGRpZSBqZSBuYWFyIGRlIGdyb290c3RlIGJvbWVuIGJyZW5ndC4gT2YgYnJlbmcgZWVuIGJlem9layBhYW4gZGUgU2hyaW5lIERyaXZlIFRocnUgVHJlZSwgZWVuIGRvb3IgZGUgYmxpa3NlbSBnZXRyb2ZmZW4gYm9vbSB3YWFyIGplIGRvb3JoZWVuIGt1bnQgcmlqZGVuIG9mIGxvcGVuLlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJPdmVybmFjaHRlbiBpbiBSZWR3b29kIE5hdGlvbmFsIFBhcmtcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MjV8dGV4dF9hbGlnbjpsZWZ0XCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1IZXQgUmVkd29vZCBOYXRpb25hbCBQYXJrIGJpZWR0IG5pZXQgdmVlbCBtb2dlbGlqa2hlZGVuIG9tIHRlIG92ZXJuYWNodGVuLiBFciB6aWpuIDggYmFzaWMgY2FtcGdyb3VuZHMgdGUgdmluZGVuIGRpZSBqZSBvbmdldmVlciBlZW4gbWFhbmQgdmFuIHRlIHZvcmVuIGRpZW50IHRlIHJlc2VydmVyZW4uIFdpbCBqZSBpbiBlZW4gaG90ZWwgb3Zlcm5hY2h0ZW4/IEJla2lqayBkYW4gZGUgbW9nZWxpamtoZWRlbiBpbiA8YSBocmVmPVwiaHR0cHM6Ly93d3cuYm9va2luZy5jb20vc2VhcmNocmVzdWx0cy5lbi5odG1sP2NpdHk9MjAwMTIzOTAmYW1wO2FpZD03OTU4NDk4JmFtcDtub19yb29tcz0xJmFtcDtncm91cF9hZHVsdHM9MiZhbXA7bGFiZWw9cmVkd29vZHNucGNyZXNjZW50XCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5DcmVzY2VudCBDaXR5PC9hPiwgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmJvb2tpbmcuY29tL3NlYXJjaHJlc3VsdHMuZW4uaHRtbD9jaXR5PTIwMDEzODQ0JmFtcDthaWQ9Nzk1ODQ5OCZhbXA7bm9fcm9vbXM9MSZhbXA7Z3JvdXBfYWR1bHRzPTImYW1wO2xhYmVsPXJlZHdvb2RzbnBrbGFtYXRoXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5LbGFtYXRoPC9hPiBvZiA8YSBocmVmPVwiaHR0cHM6Ly93d3cuYm9va2luZy5jb20vc2VhcmNocmVzdWx0cy5lbi5odG1sP2NpdHk9MjAwMTQ5OTAmYW1wO2FpZD03OTU4NDk4JmFtcDtub19yb29tcz0xJmFtcDtncm91cF9hZHVsdHM9MiZhbXA7bGFiZWw9cmVkd29vZHNucG9yaWNrXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5PcmljazwvYT4uIEhpZXIgaGViIGplIGVlbiBhYW50YWwgb3B0aWVzIG9tIHRlIG92ZXJuYWNodGVuIGVuIHppdCBqZSBkaWNodCBiaWogaGV0IFJlZHdvb2RzIE5hdGlvbmFsIFBhcmsuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJCZXN0ZSByZWlzcGVyaW9kZSBSZWR3b29kIE5hdGlvbmFsIFBhcmtcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MjV8dGV4dF9hbGlnbjpsZWZ0XCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1IZXQgcGFyayBpcyBpbiBwcmluY2lwZSBoZXQgaGVsZSBqYWFyIHRlIGJlem9la2VuLiBEZSBiZXN0ZSByZWlzcGVyaW9kZSB2b29yIGhldCBSZWR3b29kIE5hdGlvbmFsIFBhcmsgaXMgZGUgbGVudGUuIERlIGJvc3NlbiB6aWpuIGdyb2VuLCBoZXQgaXMgZXIgbmlldCB0ZSBkcnVrIGVuIGRhYXJiaWogaGViIGplIGthbnMgb20gZGUgcm9kb2RlbmRyb24gaW4gYmxvZWkgdGUgemllbi4gRGUgem9tZXIgaXMgZGUgbWVlc3QgYmV6b2NodCBwZXJpb2RlIGVuIGlzIGhldCBlZW4gc3R1ayBkcnVra2VyIGluIGhldCBwYXJrLiBIZXQgbmFqYWFyIGlzIG9vayBlZW4gZ29lZGUgcGVyaW9kZSBvbSBoZXQgcGFyayB0ZSBiZXpvZWtlbi4gRGUgYm9tZW4ga3JpamdlbiBlZW4ga2xlaW4gYmVldGplIGVlbiBoZXJmc3RrbGV1ciBlbiBkZSBlZXJzdGUgcmVnZW4ga29tdCB2YWFrIHBhcyBtaWRkZW4gb2t0b2Jlci5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIGNvbnRlbnRfcGxhY2VtZW50PVwibWlkZGxlXCIgZnVsbF93aWR0aD1cInN0cmV0Y2hfcm93XCIgY29udGVudF90ZXh0X2FsaWdtZW50PVwiY2VudGVyXCIgY3NzPVwiLnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fVwiIHBhcmFsbGF4X2JhY2tncm91bmRfaW1hZ2U9XCIzODM2XCJdW3ZjX2NvbHVtbiB0aGJfY29sb3I9XCJ0aGItbGlnaHQtY29sdW1uXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIlNocmluZSBEcml2ZSBUaHJ1IFRyZWUgaW4gaGV0IFJlZHdvb2QgTmF0aW9uYWwgUGFya1wiIGhlYWRpbmdfdGFnPVwicFwiIG1haW5faGVhZGluZ19jb2xvcj1cIiNmZmZmZmZcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDo0NXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjU1cHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIxMHB4XCJdW2hleXVzYV9oZWFkaW5nIHRhZz1cImg0XCIgdGV4dF9hbGlnbj1cImNlbnRlclwiIGhlYWRpbmc9XCJXYW5kZWwgb25kZXIgZG9vciBkZSBib29tIGRvb3JcIiBmb250X3NpemU9XCI1MFwiIGxpbmVfaGVpZ2h0PVwiMVwiIGZvbnRfY29sb3I9XCIjZmZmZmZmXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3BhcmFsbGF4X3JvdyBlbmFibGVfbW9iaWxlPVwicGFyYWxsYXgtZW5hYmxlLW1vYmlsZVwiIGltYWdlPVwiMTc3MjFcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIGNzcz1cIi52Y19jdXN0b21fMTYwODY2Njg4NTQ5N3tiYWNrZ3JvdW5kLWltYWdlOiB1cmwoaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMC8wOC9iYWNrZ3JvdW5kLWhleXVzYS1uYXR1dXItMS5naWY/aWQ9MzA4OCkgIWltcG9ydGFudDt9XCJdW3ZjX2NvbHVtbl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJXYW5kZWxlbiBpbiBoZXQgUmVkd29vZCBOYXRpb25hbCBQYXJrXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzAwMDAwMFwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjU1cHg7XCIgbWFyZ2luX2Rlc2lnbl90YWJfdGV4dD1cIlwiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdQWFuZ2V6aWVuIGhldCBSZWR3b29kIE5hdGlvbmFsIFBhcmsgMyBzdGF0ZSBwYXJrcyBiZXZhdCwgemlqbiBlciB3YW5kZWxpbmdlbiB0ZSB2aW5kZW4gaW4gdmVyc2NoaWxsZW5kZSBkZWxlbiB2YW4gaGV0IHBhcmsuIEVlbiBhYW50YWwgdGlwcyB2b29yIHdhbmRlbGluZ2VuIGluIGhldCBSZWR3b29kIE5hdGlvbmFsIFBhcms6XHJcbjx1bD5cclxuIFx0PGxpPkNhdGhlZHJhbCBUcmFpbCB8IGVhc3kgfCAzLDUga2lsb21ldGVyIHwgUHJhaXJpZSBDcmVlayBSZWR3b29kcyBTdGF0ZSBQYXJrPC9saT5cclxuIFx0PGxpPkJveSBTY291dCBUcmVlIFRyYWlsIHwgZWFzeSB8IDgsNSBraWxvbWV0ZXIgfCBKZWRlZGlhaCBTbWl0aCBSZWR3b29kcyBTdGF0ZSBQYXJrPC9saT5cclxuIFx0PGxpPkxhZHkgQmlyZCBKb2huc29uIEdyb3ZlIFRyYWlsIHwgZWFzeSB8IDIga2lsb21ldGVyIHwgUmVkd29vZCBOYXRpb25hbCBQYXJrPC9saT5cclxuIFx0PGxpPll1cm9rIExvb3AgVHJhaWwgfCBlYXN5LCB3ZWwgaG9vZ3RldmVyc2NoaWxsZW4gfCAxLDYga2lsb21ldGVyIHwgRGVsIE5vcnRlIENvYXN0IFJlZHdvb2RzIFN0YXRlIFBhcms8L2xpPlxyXG4gXHQ8bGk+RmVybiBDYW55b24gfCBlYXN5IHwgMSw2IGtpbG9tZXRlciB8IFByYWlyaWUgQ3JlZWsgUmVkd29vZHMgU3RhdGUgUGFyazwvbGk+XHJcbiBcdDxsaT5TdG91dCBNZW1vcmlhbCBUcmFpbCB8IGVhc3kgfCAxLDEga2lsb21ldGVyIHwgSmVkZWRpYWggU21pdGggUmVkd29vZHMgU3RhdGUgUGFyazwvbGk+XHJcbiBcdDxsaT5QcmFpcmllIENyZWVrIGFuZCBGb290aGlsbCBMb29wIHwgZWFzeSB8IDQsMSBraWxvbWV0ZXIgfCBQcmFpcmllIENyZWVrIFJlZHdvb2RzIFN0YXRlIFBhcms8L2xpPlxyXG48L3VsPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJIYW5kaWdlIGluZm8gdm9vciBqZSBiZXpvZWtcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMDAwMDAwXCIgYWxpZ25tZW50PVwibGVmdFwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6Um9ib3RvIFNsYWJ8Zm9udF9jYWxsOlJvYm90bytTbGFifHZhcmlhbnQ6ODAwXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDo1NXB4O1wiIG1haW5faGVhZGluZ19zdHlsZT1cImZvbnQtd2VpZ2h0OjgwMDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3VsdGltYXRlX2ljb25fbGlzdCBpY29uX3NpemU9XCIyNVwiXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtY2xvY2stb1wiIGNvbnRlbnRfZm9udF9zaXplPVwiZGVza3RvcDoxNnB4O1wiXTI0LzcgZW4gMzY1IGRhZ2VuIGdlb3BlbmRbL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtdGh1bWJzLXVwXCIgY29udGVudF9mb250X3NpemU9XCJkZXNrdG9wOjE2cHg7XCJdQmVzdGUgcGVyaW9kZTogbGVudGVbL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtZG9sbGFyIHVzZFwiIGNvbnRlbnRfZm9udF9zaXplPVwiZGVza3RvcDoxNnB4O1wiXVJlZHdvb2QgTmF0aW9uYWwgUGFyayBpcyBncmF0aXMsIHZvb3IgZGUgJ2RheSB1c2UnIHZhbiBoZXQgUHJhaXJpZSBDcmVlayBSZWR3b29kcywgRGVsIE5vcnRlIFJlZHdvb2RzIGVuIEplZGVkaWFoIFJlZHdvb2RzIFN0YXRlIFBhcmsgemlqbiBlciBkYWdwYXNzZW4uWy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bL3VsdGltYXRlX2ljb25fbGlzdF1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIGNvbnRlbnRfcGxhY2VtZW50PVwibWlkZGxlXCIgZnVsbF93aWR0aD1cInN0cmV0Y2hfcm93XCIgY29udGVudF90ZXh0X2FsaWdtZW50PVwiY2VudGVyXCIgY3NzPVwiLnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fVwiIHBhcmFsbGF4X2JhY2tncm91bmRfaW1hZ2U9XCIzODM2XCJdW3ZjX2NvbHVtbiB0aGJfY29sb3I9XCJ0aGItbGlnaHQtY29sdW1uXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIk5ld3RvbiBEcnVyeSBTY2VuaWMgUGFya3dheVwiIGhlYWRpbmdfdGFnPVwicFwiIG1haW5faGVhZGluZ19jb2xvcj1cIiNmZmZmZmZcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDo0NXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjU1cHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIxMHB4XCJdW2hleXVzYV9oZWFkaW5nIHRhZz1cImg0XCIgdGV4dF9hbGlnbj1cImNlbnRlclwiIGhlYWRpbmc9XCJSaWpkIGRlIHNjZW5pYyBkcml2ZSBhZiB2b29yIGRlIG1vb2lzdGUgc3RvcHNcIiBmb250X3NpemU9XCI1MFwiIGxpbmVfaGVpZ2h0PVwiMVwiIGZvbnRfY29sb3I9XCIjZmZmZmZmXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3BhcmFsbGF4X3JvdyBlbmFibGVfbW9iaWxlPVwicGFyYWxsYXgtZW5hYmxlLW1vYmlsZVwiIGltYWdlPVwiMTc3MjJcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiXVt2Y19jb2x1bW5dW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIk1lZXIgQ2FsaWZvcm5pXHUwMGViXCIgZm9udF9jb250YWluZXI9XCJ0YWc6ZGl2fGZvbnRfc2l6ZTo0MHx0ZXh0X2FsaWduOmNlbnRlclwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdGhiX3Bvc3RncmlkIHN0eWxlPVwic3R5bGUxMVwiIGNvbHVtbnM9XCI0XCIgc291cmNlPVwicG9zdF90eXBlOnBvc3R8YnlfaWQ6LTE3MzE4LC0xNTA2MiwtMTQ5MDcsLTE0MjUwLC04NzQyLC00NzkyLC00NzM4LC00NzE0LC00Njg5LC00NTc0LC0zMjA4LC0xOTcxLDMwMTQsMTE5OTcsMTI1MDQsOTk4MFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XSIsInBvc3RfdGl0bGUiOiJSZWR3b29kIE5hdGlvbmFsIFBhcmsiLCJwb3N0X2xpbmsiOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3JlZHdvb2QtbmF0aW9uYWwtcGFyay8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJSZWR3b29kIE5hdGlvbmFsIFBhcmtcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjIyNVwiIHNyYz1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjMvMTAvcmVkd29vZHMtMzAweDIyNS5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj4iLCJwb3N0X2NhdGVnb3JpZXMiOiJSZWR3b29kIE5hdGlvbmFsIFBhcmsiLCJwb3N0X3RhZ3MiOiJDYWxpZm9ybmlcdTAwZWIiLCIlX3dwYl9zaG9ydGNvZGVzX2N1c3RvbV9jc3MlIjoiLnZjX2N1c3RvbV8xNjA4NjY2NTE5NDkye2JhY2tncm91bmQtY29sb3I6ICNlYWVhZWEgIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE2MDg2NjY4ODU0OTd7YmFja2dyb3VuZC1pbWFnZTogdXJsKGh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjAvMDgvYmFja2dyb3VuZC1oZXl1c2EtbmF0dXVyLTEuZ2lmP2lkPTMwODgpICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O30iLCIlaW5saW5lX2ZlYXR1cmVkX2ltYWdlJSI6IjAiLCIlX2VkaXRfbG9jayUiOiIxNjk4Mjk5MjY1OjIiLCIlX2VkaXRfbGFzdCUiOiIyIiwiJV90aHVtYm5haWxfaWQlIjoiMTc3MjQiLCIlX2hpZGVfZmVhdHVyZWQlIjpudWxsLCIlX3dwYl92Y19qc19zdGF0dXMlIjoidHJ1ZSIsIiVwb3N0LXByaW1hcnktY2F0ZWdvcnklIjoiYXV0byIsIiVmZWF0dXJlZF9pbWFnZV9vdmVycmlkZSUiOiJvZmYiLCIlYXJ0aWNsZV9zdHlsZV9vdmVycmlkZSUiOiJvbiIsIiVwb3N0X3N0eWxlJSI6InN0eWxlMTEiLCIlcG9zdF9nYWxsZXJ5X3N0eWxlJSI6ImxpZ2h0Ym94IiwiJXBvc3RfcmV2aWV3JSI6Im9mZiIsIiVwb3N0X3Jldmlld19zdHlsZSUiOiJzdHlsZTEiLCIlcG9zdF9yZXZpZXdfYXZlcmFnZSUiOiI1MCIsIiVfeW9hc3Rfd3BzZW9fY29udGVudF9zY29yZSUiOiI2MCIsIiVfeW9hc3Rfd3BzZW9fZm9jdXNrZXl3b3JkcyUiOiJbXSIsIiVfeW9hc3Rfd3BzZW9fa2V5d29yZHN5bm9ueW1zJSI6IltcIlwiXSIsIiVfeW9hc3Rfd3BzZW9fZm9jdXNrdyUiOiJSZWR3b29kIE5hdGlvbmFsIFBhcmsiLCIlX3lvYXN0X3dwc2VvX21ldGFkZXNjJSI6IkluIENhbGlmb3JuaVx1MDBlYiB2aW5kIGplIGhldCBSZWR3b29kIE5hdGlvbmFsIFBhcmssIGJla2VuZCB2YW53ZWdlIGRlIGVub3JtZSBrdXN0bWFtbW9ldGJvbWVuLiBUaXBzIHZvb3IgZWVuIGJlem9layBhYW4gaGV0IFJlZHdvb2QgTmF0aW9uYWwgUGFyay4iLCIlX3lvYXN0X3dwc2VvX2xpbmtkZXglIjoiODIiLCIlX3dwZ21wX2xvY2F0aW9uX2FkZHJlc3MlIjoiQ2FsaWZvcm5pXHUwMGViLCBWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9sb2NhdGlvbl9jaXR5JSI6IiIsIiVfd3BnbXBfbG9jYXRpb25fc3RhdGUlIjoiQ2FsaWZvcm5pXHUwMGViIiwiJV93cGdtcF9sb2NhdGlvbl9jb3VudHJ5JSI6IlZlcmVuaWdkZSBTdGF0ZW4iLCIlX3dwZ21wX21ldGFib3hfbGF0aXR1ZGUlIjoiNDEuNDAxNzE1NiIsIiVfd3BnbXBfbWV0YWJveF9sb25naXR1ZGUlIjoiLTEyNC4wNDE3MTEiLCIlX3dwZ21wX21ldGFib3hfbG9jYXRpb25fcmVkaXJlY3QlIjoibWFya2VyIiwiJV93cGdtcF9tZXRhYm94X2N1c3RvbV9saW5rJSI6IiIsIiVfd3BnbXBfbWFwX2lkJSI6ImE6MTp7aTowO3M6MTpcIjdcIjt9IiwiJV93cGdtcF9tZXRhYm94X21hcmtlcl9pZCUiOiIiLCIlX3dwZ21wX21ldGFib3hfdGF4b21vbWllc190ZXJtcyUiOiIiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6IiIsIiVfeW9hc3Rfd3BzZW9fZXN0aW1hdGVkLXJlYWRpbmctdGltZS1taW51dGVzJSI6IjUiLCIlX3lvYXN0X3dwc2VvX3ByaW1hcnlfY2F0ZWdvcnklIjoiMjM3IiwiJV93d3Nfc3VwcG9ydF9jb250YWN0X251bWJlciUiOiIiLCIlX3d3c19hYm91dF9zdXBwb3J0X3RleHQlIjoiIiwiJV93d3NfdHJpZ2dlcl9idXR0b25fdGV4dCUiOiIiLCIlX3d3c19wcmVkZWZpbmVkX3RleHQlIjoiIiwiJV95b2FzdF93cHNlb193b3JkcHJvb2ZfdGltZXN0YW1wJSI6IiIsIiVfeW9hc3RfaW5kZXhub3dfbGFzdF9waW5nJSI6IjE2OTgyOTkyODEiLCIlX2xhc3RfZWRpdG9yX3VzZWRfamV0cGFjayUiOiJjbGFzc2ljLWVkaXRvciIsIiVfd3Bfb2xkX2RhdGUlIjoiMjAyMy0wOS0yMiIsIiVfd3Bfb2xkX3NsdWclIjoic2FndWFyby1uYXRpb25hbC1wYXJrIiwidGF4b25vbXk9Y2F0ZWdvcnkiOiJSZWR3b29kIE5hdGlvbmFsIFBhcmsiLCJ0YXhvbm9teT1wb3N0X3RhZyI6IkNhbGlmb3JuaVx1MDBlYiIsInRheG9ub215PXBvc3RfZm9ybWF0IjoiIiwidGF4b25vbXk9dGhiLXJlYWN0aW9ucyI6IiIsInRheG9ub215PXRoYi1zcG9uc29ycyI6IiJ9fSwiaWQiOjE3NzE3LCJpbmZvd2luZG93X2Rpc2FibGUiOmZhbHNlfSx7InNvdXJjZSI6InBvc3QiLCJ0aXRsZSI6IkNhbnlvbiBkZSBDaGVsbHkgTmF0aW9uYWwgTW9udW1lbnQiLCJpbmZvd2luZG93X2NvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nIFwiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJDYW55b24gZGUgQ2hlbGx5IE5hdGlvbmFsIE1vbnVtZW50XCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMTZcIiBzcmM9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIzLzEwL0Nhbnlvbi1kZS1DaGVsbHktc3BpZGVyLXJvY2stMzAweDIxNi5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmcgZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+Q2FueW9uIGRlIENoZWxseSBOYXRpb25hbCBNb251bWVudDwvZGl2PlxyXG4gICAgICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1jb250ZW50IGZjLWl0ZW0tYm9keS10ZXh0LWNvbG9yXCI+e21hcmtlcl9hZGRyZXNzfTwvZGl2PlxyXG4gICAgICAgIDwvZGl2PlxyXG4gICAgPC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtY2xlYXJcIj48L2Rpdj5cclxuPC9kaXY+IiwiYWRkcmVzcyI6IkNoaW5sZSwgQXJpem9uYSwgVmVyZW5pZ2RlIFN0YXRlbiIsImxvY2F0aW9uIjp7ImxhdCI6IjM2LjExOTA3MzQiLCJjaXR5IjoiQ2hpbmxlIiwic3RhdGUiOiJBcml6b25hIiwiY291bnRyeSI6IlZlcmVuaWdkZSBTdGF0ZW4iLCJsbmciOiItMTA5LjMxOTcwNTIiLCJvbmNsaWNrX2FjdGlvbiI6Im1hcmtlciIsInJlZGlyZWN0X3Blcm1hbGluayI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvY2FueW9uLWRlLWNoZWxseS1uYXRpb25hbC1tb251bWVudC8iLCJ6b29tIjoxMiwiZXh0cmFfZmllbGRzIjp7InBvc3RfZXhjZXJwdCI6IiIsInBvc3RfY29udGVudCI6Ilt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCJdW3ZjX2NvbHVtbiB3aWR0aD1cIjEvMlwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCIxMDAlXCJdW3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvMlwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiQ2FueW9uIGRlIENoZWxseSBOYXRpb25hbCBNb251bWVudFwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTozNXx0ZXh0X2FsaWduOmxlZnR8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdQ2FueW9uIGRlIENoZWxseSBpcyBlZW4gbmF0aW9uYWFsIG1vbnVtZW50IGluIGhldCBub29yZG9vc3RlbiB2YW4gQXJpem9uYS4gRGUgY2FueW9uIHdvcmR0IGRvb3IgZGUgTmF0aW9uYWwgUGFyayBTZXJ2aWNlIGJlaGVlcmQgc2FtZW4gbWV0IGRlIE5hdmFqbyB0cmliZXMgZGllIGluIGhldCBnZWJpZWQgbGV2ZW4uIEVyIHppam4gZHJpZSBiZWxhbmdyaWprZSBjYW55b25zIHRlIHZpbmRlbiBpbiBoZXQgZ2ViaWVkOiBkZSBDaGVsbHksIGRlbCBNdWVydG8gZW4gTW9udW1lbnQgQ2FueW9uLiBJbiBoZXQgQ2FueW9uIGRlIENoZWxseSBOYXRpb25hbCBNb251bWVudCB2aW5kIGplIG5vZyB2ZXJzY2hpbGxlbmRlIG92ZXJibGlqZnNlbGVuIHZhbiBkZSB2cm9lZ2UgaW5oZWVtc2Ugc3RhbW1lbiBkaWUgaW4gaGV0IGdlYmllZCBsZWVmZGVuLiBOb2cgc3RlZWRzIGJlaG9vcnQgaGV0IGdlYmllZCB0b3QgaGV0IE5hdmFqb3ZvbGsuIE1lZXIgd2V0ZW4gb3ZlciBDYW55b24gZGUgQ2hlbGx5IGVuIHdhdCBqZSBlciBrdW50IGJlem9la2VuPyBPbnplIHRpcHMgdm9vciBDYW55b24gZGUgQ2hlbGx5IE5hdGlvbmFsIE1vbnVtZW50LlsvdmNfY29sdW1uX3RleHRdW3VsdGltYXRlX2ljb25fbGlzdCBpY29uX3NpemU9XCIyMFwiXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtdHJlZVwiXTxzcGFuIGNsYXNzPVwiTHJ6WHIga25vLWZ2XCI+MzM5IGttXHUwMGIyIG9wcGVydmxha3RlPC9zcGFuPlsvdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dWy91bHRpbWF0ZV9pY29uX2xpc3RdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjc3M9XCIudmNfY3VzdG9tXzE2MDg2NjY1MTk0OTJ7YmFja2dyb3VuZC1jb2xvcjogI2VhZWFlYSAhaW1wb3J0YW50O31cIl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjIvM1wiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI3NXB4XCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJOYXZham8gdHJpYmVcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MzV8dGV4dF9hbGlnbjpjZW50ZXJ8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxwIHN0eWxlPVwidGV4dC1hbGlnbjogY2VudGVyO1wiPkNhbnlvbiBkZSBDaGVsbHkgYmVob29ydCBub2cgc3RlZWRzIHRvdCBoZXQgTmF2YWpvIHZvbGssIHppaiBiZWhlcmVuIGhldCBnZWJpZWQgc2FtZW4gbWV0IGRlIE5hdGlvbmFsIFBhcmsgU2VydmljZS4gRGl0IGhvdWR0IGluIGRhdCBiZXBhYWxkZSBkZWxlbiB2YW4gZGUga2xvb2YgYmVwZXJrdCB0ZSBiZXpvZWtlbiB6aWpuIGVuIGFsbGVlbiBvbmRlciBiZWdlbGVpZGluZyBkb29yIGVlbiBwYXJrcmFuZ2VyIG9mIGVlbiBvZmZpY2lcdTAwZWJsZSBOYXZham9naWRzLiBEZSBnZW9sb2dpc2NoZSBmb3JtYXRpZSBTcGlkZXIgUm9jayBkaWUgamUgaW4gaGV0IGdlYmllZCB2aW5kdCwgdmVydGVsZCBoZXQgTmF2YWpvdm9sayBvdmVyIGRlIGt1bnN0IHZhbiBoZXQgd2V2ZW4uIFZvb3IgTmF2YWpva2luZGVyZW4gaXMgU3BpZGVyIFdvbWFuLCB3YWFyb3AgZGUgcm90cyBzdGFhdCwgZWVuIGxlcy4gRGUga2luZGVyZW4gd29yZHQgdmVydGVsZCBkYXQgYWxzIHplIHppY2ggbmlldCBnZWRyYWdlbiwgU3BpZGVyIFdvbWFuIHplIG9wIHphbCBldGVuLiBUZWdlbndvb3JkaWcgd29uZW4gZXIgbm9nIHN0ZWVkcyBvbmdldmVlciA0MCBOYXZham9mYW1pbGllcyBiaW5uZW4gZGUgZ3JlbnplbiB2YW4gaGV0IG1vbnVtZW50LjwvcD5cclxuWy92Y19jb2x1bW5fdGV4dF1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiIGZ1bGxfd2lkdGg9XCJzdHJldGNoX3Jvd1wiIGNvbnRlbnRfdGV4dF9hbGlnbWVudD1cImNlbnRlclwiIGNzcz1cIi52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O31cIiBwYXJhbGxheF9iYWNrZ3JvdW5kX2ltYWdlPVwiMzgzNlwiXVt2Y19jb2x1bW4gdGhiX2NvbG9yPVwidGhiLWxpZ2h0LWNvbHVtblwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIldlaWRzZSB1aXR6aWNodGVuIG9wIENhbnlvbiBkZSBDaGVsbHlcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6NzV8dGV4dF9hbGlnbjpjZW50ZXJ8Y29sb3I6JTIzZmZmZmZmfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJCZXpvZWsgXHUwMGU5XHUwMGU5biB2YW4gZGUgdWl0a2lqa3B1bnRlblwiIGZvbnRfY29udGFpbmVyPVwidGFnOmRpdnxmb250X3NpemU6NDV8dGV4dF9hbGlnbjpjZW50ZXJ8Y29sb3I6JTIzZmZmZmZmfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpEYW5jaW5nJTIwU2NyaXB0JTNBcmVndWxhciUyQzcwMHxmb250X3N0eWxlOjcwMCUyMGJvbGQlMjByZWd1bGFyJTNBNzAwJTNBbm9ybWFsXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3BhcmFsbGF4X3JvdyBlbmFibGVfbW9iaWxlPVwicGFyYWxsYXgtZW5hYmxlLW1vYmlsZVwiIGltYWdlPVwiMTc2MzFcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiXVt2Y19jb2x1bW5dW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkJlc3RlIHJlaXNwZXJpb2RlIENhbnlvbiBkZSBDaGVsbHkgXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjI1fHRleHRfYWxpZ246bGVmdFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdQ2FueW9uIGRlIENoZWxseSBiZXZpbmR0IHppY2ggbWlkZGVuIGluIGRlIHdvZXN0aWpuLiBIaWVyZG9vciBoZWIgamUgem93ZWwgaW4gZGUgem9tZXIgYWxzIGluIGRlIHdpbnRlciBleHRyZW1lIHRlbXBlcmF0dXJlbi4gSGV0IHBhcmsgaXMgaGV0IGhlbGUgamFhciBvcGVuIHdhYXJkb29yIGplIGRlIG1vZ2VsaWpraGVpZCBoZWJ0IG9tIGluIGhldCB2b29yamFhciBvZiBpbiBkZSBoZXJmc3QgdGUgZ2Fhbi4gSmUgaGVidCBkYW4gbm9nIHN0ZWVkcyB3YXJtZSBkYWdlbiwgbWFhciBuaWV0IHRlIHdhcm0uIEhpZXJkb29yIGt1biBqZSBDYW55b24gZGUgQ2hlbGx5IG9vayB3YW5kZWxlbmQga3VudCB2ZXJrZW5uZW4uIEplIGhlYnQgb25nZXZlZXIgMSBkYWcgbm9kaWcgb20gQ2FueW9uIHRlIENoZWxseSB0ZSB6aWVuLlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiT3Zlcm5hY2h0ZW4gYmlqIENhbnlvbiBkZSBDaGVsbHkgXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjI1fHRleHRfYWxpZ246bGVmdFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdRGUgYmVzdGUgdWl0dmFsc2Jhc2lzIHZvb3IgQ2FueW9uIGRlIENoZWxseSBpcyBoZXQgZG9ycGplIENoaW5sZS4gSGllciB2aW5kIGplIGVlbiBwYWFyIGhvdGVscyB3YWFyIGplIGt1bnQgb3Zlcm5hY2h0ZW4uIEVlbiBhYW50YWwgb3B0aWVzOlxyXG48dWw+XHJcbiBcdDxsaT48YSBocmVmPVwiaHR0cHM6Ly93d3cuYm9va2luZy5jb20vaG90ZWwvdXMvaG9saWRheS1pbm4tY2FueW9uLWRlLWNoZWxseS1jaGlubGUuZW4uaHRtbD9haWQ9Nzk1ODQ5OCZhbXA7bm9fcm9vbXM9MSZhbXA7Z3JvdXBfYWR1bHRzPTImYW1wO2xhYmVsPWNoaW5sZWhvbGlkYXlpbm5cIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPkhvbGlkYXkgSW5uIENhbnlvbiBkZSBDaGVsbHktIENoaW5sZTwvYT48L2xpPlxyXG4gXHQ8bGk+PGEgaHJlZj1cImh0dHBzOi8vd3d3LmJvb2tpbmcuY29tL2hvdGVsL3VzL2Jlc3Qtd2VzdGVybi1jYW55b24tZGUtY2hlbGx5LWlubi5lbi5odG1sP2FpZD03OTU4NDk4JmFtcDtub19yb29tcz0xJmFtcDtncm91cF9hZHVsdHM9MiZhbXA7bGFiZWw9Y2hpbmxlYmVzdHdlc3Rlcm5cIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPkJlc3QgV2VzdGVybiBDYW55b24gZGUgQ2hlbGx5IElubjwvYT48L2xpPlxyXG4gXHQ8bGk+PGEgaHJlZj1cImh0dHBzOi8vd3d3LmJvb2tpbmcuY29tL2hvdGVsL3VzL3RodW5kZXJiaXJkLWxvZGdlLS5lbi5odG1sP2FpZD03OTU4NDk4JmFtcDtub19yb29tcz0xJmFtcDtncm91cF9hZHVsdHM9MiZhbXA7bGFiZWw9Y2hpbmxldGh1bmRlcmJpcmRcIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPlRodW5kZXJiaXJkIExvZGdlPC9hPjwvbGk+XHJcbjwvdWw+XHJcblsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIiBmdWxsX3dpZHRoPVwic3RyZXRjaF9yb3dcIiBjb250ZW50X3RleHRfYWxpZ21lbnQ9XCJjZW50ZXJcIiBjc3M9XCIudmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9XCIgcGFyYWxsYXhfYmFja2dyb3VuZF9pbWFnZT1cIjM4MzZcIl1bdmNfY29sdW1uIHRoYl9jb2xvcj1cInRoYi1saWdodC1jb2x1bW5cIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiUnVcdTAwZWZuZXMgaW4gQ2FueW9uIGRlIENoZWxseVwiIGhlYWRpbmdfdGFnPVwicFwiIG1haW5faGVhZGluZ19jb2xvcj1cIiNmZmZmZmZcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDo0NXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjU1cHg7XCIgbWFyZ2luX2Rlc2lnbl90YWJfdGV4dD1cIlwiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMTBweFwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiUmVzdGFudGVuIHZhbiB3b25pbmdlbiB2YW4gaW5oZWVtc2Ugc3RhbW1lblwiIGZvbnRfY29udGFpbmVyPVwidGFnOmRpdnxmb250X3NpemU6NDV8dGV4dF9hbGlnbjpjZW50ZXJ8Y29sb3I6JTIzZmZmZmZmfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpEYW5jaW5nJTIwU2NyaXB0JTNBcmVndWxhciUyQzcwMHxmb250X3N0eWxlOjcwMCUyMGJvbGQlMjByZWd1bGFyJTNBNzAwJTNBbm9ybWFsXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3BhcmFsbGF4X3JvdyBlbmFibGVfbW9iaWxlPVwicGFyYWxsYXgtZW5hYmxlLW1vYmlsZVwiIGltYWdlPVwiMTc2MzBcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiXVt2Y19jb2x1bW5dW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJXYXQgdGUgZG9lbiBpbiBDYW55b24gZGUgQ2hlbGx5IE5hdGlvbmFsIE1vbnVtZW50XCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjM1fHRleHRfYWxpZ246Y2VudGVyfGNvbG9yOiUyM2IzNGE0Y1wiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxwIHN0eWxlPVwidGV4dC1hbGlnbjogY2VudGVyO1wiPkNhbnlvbiBkZSBDaGVsbHkgTmF0aW9uYWwgTW9udW1lbnQgaXMgZWVuIHVuaWVrZSBwbGVrIGluIEFtZXJpa2EuIE9udGRlayBkZSBTb3V0aCBSaW0gZW4gZGUgTm9ydGggUmltIG1ldCBkZSBhdXRvIGVuIHN0b3Agb25kZXJ3ZWcgYmlqIHZlcnNjaGlsbGVuZGUgdWl0emljaHRwdW50ZW4uPC9wPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW5dW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjI1cHhcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW4gd2lkdGg9XCIxLzNcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiNzAlXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJTb3V0aCBSaW1cIiBmb250X2NvbnRhaW5lcj1cInRhZzpoM3xmb250X3NpemU6MzB8dGV4dF9hbGlnbjpsZWZ0XCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19zaW5nbGVfaW1hZ2UgaW1hZ2U9XCIxNzYyNlwiIGltZ19zaXplPVwibGFyZ2VcIl1bdmNfY29sdW1uX3RleHRdRGUgU291dGggUmltIGlzIGVlbiAzMCBraWxvbWV0ZXIgbGFuZ2Ugd2VnIGRpZSBqZSBoZXQgYmVzdGUgYWFuIGhldCBlaW5kIHZhbiBkZSBtaWRkYWcga3VudCByaWpkZW4uIE9uZGVyd2VnIHZpbmQgamUgZWVuIHpldmVudGFsIHVpdGtpamtwdW50ZW4gd2FhciBqZSBrdW50IHN0b3BwZW46XHJcbjxvbD5cclxuIFx0PGxpPlR1bm5lbCBPdmVybG9vazwvbGk+XHJcbiBcdDxsaT5Uc2V5aSBPdmVybG9vayAtIHBsZWsgb20gZGUgY2FueW9uIGluIHRlIGtpamtlbiwgamUgemlldCBkZSBDaGlubGUgV2FzaCBzdHJvbWVuPC9saT5cclxuIFx0PGxpPkp1bmN0aW9uIE92ZXJsb29rIC0gdWl0emljaHQgb3AgZGUgcGxlayB3YWFyIENhbnlvbiBkZSBDaGVsbHkgZW4gQ2FueW9uIGRlbCBNdWVydG8gc3BsaXRzZW4uIEp1bmN0aW9uIFJ1aW4gaXMgb29rIHRlIHppZW4sIGVlbiB3b25pbmcgdmFuIDEwIGthbWVyczwvbGk+XHJcbiBcdDxsaT5XaGl0ZSBIb3VzZSBPdmVybG9vayAtIHN0YXJ0cHVudCB2b29yIFdoaXRlIEhvdXNlIFJ1aW4gVHJhaWw8L2xpPlxyXG4gXHQ8bGk+U2xpZGluZyBIb3VzZSBPdmVybG9vayAtIHZhbmFmIGhpZXIgemllIGplIHJ1XHUwMGVmbmVzIGRpZSBnZWJvdXdkIHppam4gaW4gZGUgY2FueW9uIHdhYXIgdnJvZWdlciBtZW5zZW4gd29vbmRlbjwvbGk+XHJcbiBcdDxsaT5GYWNlIFJvY2sgT3Zlcmxvb2s8L2xpPlxyXG4gXHQ8bGk+U3BpZGVyIFJvY2sgT3Zlcmxvb2sgLSBtZWVzdCBzcGVjdGFjdWxhaXJlIHBsZWssIHZhbmFmIGhpZXIgemllIGplIFNwaWRlciBSb2NrIGhldCBiZXN0ZTwvbGk+XHJcbjwvb2w+XHJcblsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvM1wiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiTm9ydGggUmltXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDN8Zm9udF9zaXplOjMwfHRleHRfYWxpZ246bGVmdFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfc2luZ2xlX2ltYWdlIGltYWdlPVwiMTc2MjRcIiBpbWdfc2l6ZT1cImxhcmdlXCJdW3ZjX2NvbHVtbl90ZXh0XU9vayBkZSBOb3J0aCBSaW0gaXMgb25nZXZlZXIgMzAga2lsb21ldGVyIGxhbmcgZW4gYmVnaW50IGJpaiBoZXQgYmV6b2VrZXJzY2VudHJ1bS4gT25kZXJ3ZWcgaGViIGplIGlldHMgbWluZGVyIHVpdHppY2h0cHVudGVuIGRhbiBvcCBkZSBTb3V0aCBSaW0uIFBsYW4gZGUgTm9ydGggUmltIGluIGRlIG9jaHRlbmQsIGRhbiBoZWIgamUgaGV0IG1vb2lzdGUgbGljaHQgb20gdGUgZm90b2dyYWZlcmVuLlxyXG48b2w+XHJcbiBcdDxsaT5MZWRnZSBSdWluIE92ZXJsb29rIC0gdWl0emljaHQgb3AgZGUgTGVkZ2UgUnVpbiB3YWFyIG9uZ2V2ZWVyIDEwMDAgamFhciBnZWxlZGVuIFB1ZWJsbyB3b29uZGVuPC9saT5cclxuIFx0PGxpPkFudGVsb3BlIEhvdXNlIE92ZXJsb29rIC0gbmEgZWVuIGtsZWluZSB3YW5kZWxpbmcga29tIGplIGJpaiBydVx1MDBlZm5lcyBlbiB3YW5kc2NoaWxkZXJpbmdlbjwvbGk+XHJcbiBcdDxsaT5NdW1teSBDYXZlIE92ZXJsb29rIC0gdmVybm9lbWQgbmFhciBkZSAyIG11bW1pZXMgZGllIG9uZGVyIGRlIHJ1XHUwMGVmbmVzIGdldm9uZGVuIHdlcmRlbjwvbGk+XHJcbiBcdDxsaT5NYXNzYWNyZSBDYXZlIE92ZXJsb29rIC0gb3AgZGV6ZSBwbGVrIHdlcmRlbiBpbiAxODA1IHRpamRlbnMgZWVuIFNwYWFuc2UgZXhwZWRpdGllIDExNSBOYXZham8ncyBvbSBoZXQgbGV2ZW4gZ2VicmFjaHQ8L2xpPlxyXG48L29sPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzNcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiNzAlXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJXaGl0ZSBIb3VzZSBUcmFpbFwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgzfGZvbnRfc2l6ZTozMHx0ZXh0X2FsaWduOmxlZnRcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX3NpbmdsZV9pbWFnZSBpbWFnZT1cIjE3NjI3XCIgaW1nX3NpemU9XCJsYXJnZVwiXVt2Y19jb2x1bW5fdGV4dF1DYW55b24gZGUgQ2hlbGx5IHZlcmtlbm5lbiBtb2V0IGdyb3RlbmRlZWxzIG9uZGVyIGJlZ2VsZWlkaW5nIHZhbiBlZW4gTmF2YWpvIGdpZHMgb2YgUGFya3Jhbmdlci4gRGUgTm9ydGggZW4gU291dGggUmltIGt1biBqZSB6ZWxmc3RhbmRpZyBhZnJpamRlbiBlbiBkZSBlbmlnZSB3YW5kZWxpbmcgZGllIGplIHplbGYga3VudCBtYWtlbiBpcyBkZSBXaGl0ZSBIb3VzZSBSdWluIFRyYWlsLiBEZXplIHN0YXJ0IGJpaiBoZXQgV2hpdGUgSG91c2UgT3Zlcmxvb2sgdWl0emljaHRwdW50IGFhbiBkZSBTb3V0aCBSaW0uIFdoaXRlIEhvdXNlIGlzIGVlbiBrbGVpbiBkb3JwamUgdGVnZW4gZGUgY2FueW9uIHdhbmQgd2FhciBtZWVyIGRhbiAxMDAwIGphYXIgZ2VsZWRlbiBtZW5zZW4gd29vbmRlbi4gSGV0IHdhbmRlbHBhZCBuYWFyIFdoaXRlIEhvdXNlIGlzIG9uZ2V2ZWVyIDIga2lsb21ldGVyLCBqZSBkYWFsdCAxODAgbWV0ZXIuIE5lZW0gdm9vciBkZXplIHdhbmRlbGluZyAyIHV1ciBkZSB0aWpkLlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIl1bdmNfY29sdW1uXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJJbiBkZSBidXVydFwiIGZvbnRfY29udGFpbmVyPVwidGFnOmRpdnxmb250X3NpemU6NDB8dGV4dF9hbGlnbjpjZW50ZXJcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3RoYl9wb3N0Z3JpZCBzdHlsZT1cInN0eWxlMTFcIiBjb2x1bW5zPVwiNFwiIHNvdXJjZT1cInBvc3RfdHlwZTpwb3N0fGJ5X2lkOi00NzkyLC00NzM4LC00NzE0LC00Njg5LDk5OTYsNjIwOSw5ODI2LDI2NjFcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd10iLCJwb3N0X3RpdGxlIjoiQ2FueW9uIGRlIENoZWxseSBOYXRpb25hbCBNb251bWVudCIsInBvc3RfbGluayI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvY2FueW9uLWRlLWNoZWxseS1uYXRpb25hbC1tb251bWVudC8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJDYW55b24gZGUgQ2hlbGx5IE5hdGlvbmFsIE1vbnVtZW50XCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMTZcIiBzcmM9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIzLzEwL0Nhbnlvbi1kZS1DaGVsbHktc3BpZGVyLXJvY2stMzAweDIxNi5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj4iLCJwb3N0X2NhdGVnb3JpZXMiOiJUcmliYWwgUGFya2VuIiwicG9zdF90YWdzIjoiQXJpem9uYSIsIiVfd3BiX3Nob3J0Y29kZXNfY3VzdG9tX2NzcyUiOiIudmNfY3VzdG9tXzE2MDg2NjY1MTk0OTJ7YmFja2dyb3VuZC1jb2xvcjogI2VhZWFlYSAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fSIsIiVpbmxpbmVfZmVhdHVyZWRfaW1hZ2UlIjoiMCIsIiVfZWRpdF9sb2NrJSI6IjE3MDM3NTQ2NzY6MSIsIiVfZWRpdF9sYXN0JSI6IjEiLCIlX3RodW1ibmFpbF9pZCUiOiIxNzYyNSIsIiVfaGlkZV9mZWF0dXJlZCUiOm51bGwsIiVfd3BiX3ZjX2pzX3N0YXR1cyUiOiJ0cnVlIiwiJXBvc3QtcHJpbWFyeS1jYXRlZ29yeSUiOiJhdXRvIiwiJWZlYXR1cmVkX2ltYWdlX292ZXJyaWRlJSI6Im9mZiIsIiVhcnRpY2xlX3N0eWxlX292ZXJyaWRlJSI6Im9uIiwiJXBvc3Rfc3R5bGUlIjoic3R5bGUxMSIsIiVwb3N0X2dhbGxlcnlfc3R5bGUlIjoibGlnaHRib3giLCIlcG9zdF9yZXZpZXclIjoib2ZmIiwiJXBvc3RfcmV2aWV3X3N0eWxlJSI6InN0eWxlMSIsIiVwb3N0X3Jldmlld19hdmVyYWdlJSI6IjUwIiwiJV95b2FzdF93cHNlb19jb250ZW50X3Njb3JlJSI6IjkwIiwiJV95b2FzdF93cHNlb19mb2N1c2tleXdvcmRzJSI6IltdIiwiJV95b2FzdF93cHNlb19rZXl3b3Jkc3lub255bXMlIjoiW1wiXCJdIiwiJV95b2FzdF93cHNlb19mb2N1c2t3JSI6IkNhbnlvbiBkZSBDaGVsbHkgTmF0aW9uYWwgTW9udW1lbnQiLCIlX3lvYXN0X3dwc2VvX21ldGFkZXNjJSI6IkluIEFyaXpvbmEgdmluZCBqZSBoZXQgMmUgZ3Jvb3RzZSBkb29yIG1lbnNlbiBhYW5nZWxlZ2RlIG1lZXIgTGFrZSBQb3dlbGwuIEJlbmlldXdkIHdhdCBqZSBoaWVyIGt1bnQgZG9lbj8gVGlwcyB2b29yIExha2UgUG93ZWxsIGluIEFyaXpvbmEiLCIlX3lvYXN0X3dwc2VvX2xpbmtkZXglIjoiNzIiLCIlX3dwZ21wX2xvY2F0aW9uX2FkZHJlc3MlIjoiQ2hpbmxlLCBBcml6b25hLCBWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9sb2NhdGlvbl9jaXR5JSI6IkNoaW5sZSIsIiVfd3BnbXBfbG9jYXRpb25fc3RhdGUlIjoiQXJpem9uYSIsIiVfd3BnbXBfbG9jYXRpb25fY291bnRyeSUiOiJWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9tZXRhYm94X2xhdGl0dWRlJSI6IjM2LjExOTA3MzQiLCIlX3dwZ21wX21ldGFib3hfbG9uZ2l0dWRlJSI6Ii0xMDkuMzE5NzA1MiIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiN1wiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6IiIsIiVfd3BnbXBfbWV0YWJveF90YXhvbW9taWVzX3Rlcm1zJSI6IiIsIiVfd3BnbXBfZXh0ZW5zaW9uc19maWVsZHMlIjoiIiwiJV95b2FzdF93cHNlb19lc3RpbWF0ZWQtcmVhZGluZy10aW1lLW1pbnV0ZXMlIjoiNSIsIiVfeW9hc3Rfd3BzZW9fcHJpbWFyeV9jYXRlZ29yeSUiOiIzOSIsIiVfd3dzX3N1cHBvcnRfY29udGFjdF9udW1iZXIlIjoiIiwiJV93d3NfYWJvdXRfc3VwcG9ydF90ZXh0JSI6IiIsIiVfd3dzX3RyaWdnZXJfYnV0dG9uX3RleHQlIjoiIiwiJV93d3NfcHJlZGVmaW5lZF90ZXh0JSI6IiIsIiVfeW9hc3Rfd3BzZW9fd29yZHByb29mX3RpbWVzdGFtcCUiOiIiLCIlX3lvYXN0X2luZGV4bm93X2xhc3RfcGluZyUiOiIxNzAzNzU0NjIwIiwiJV9sYXN0X2VkaXRvcl91c2VkX2pldHBhY2slIjoiY2xhc3NpYy1lZGl0b3IiLCIlX3lvYXN0X3dwc2VvX3RpdGxlJSI6IiUldGl0bGUlJSBBcml6b25hICUlcGFnZSUlICUlc2VwJSUgJSVzaXRlbmFtZSUlIiwidGF4b25vbXk9Y2F0ZWdvcnkiOiJUcmliYWwgUGFya2VuIiwidGF4b25vbXk9cG9zdF90YWciOiJBcml6b25hIiwidGF4b25vbXk9cG9zdF9mb3JtYXQiOiIiLCJ0YXhvbm9teT10aGItcmVhY3Rpb25zIjoiIiwidGF4b25vbXk9dGhiLXNwb25zb3JzIjoiIn19LCJpZCI6MTc2MTksImluZm93aW5kb3dfZGlzYWJsZSI6ZmFsc2V9LHsic291cmNlIjoicG9zdCIsInRpdGxlIjoiTGFrZSBQb3dlbGwiLCJpbmZvd2luZG93X2NvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nIFwiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJMYWtlIFBvd2VsbCBpbiBBcml6b25hXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMDBcIiBzcmM9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIzLzEwL2xha2UtcG93ZWxsLTMwMHgyMDAuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZ1wiPlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nIGZjLWl0ZW0tbm8tcGFkZGluZ1wiPlxyXG4gICAgICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS10aXRsZSBmYy1pdGVtLXByaW1hcnktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZVwiPkxha2UgUG93ZWxsPC9kaXY+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3JcIj57bWFya2VyX2FkZHJlc3N9PC9kaXY+XHJcbiAgICAgICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1jbGVhclwiPjwvZGl2PlxyXG48L2Rpdj4iLCJhZGRyZXNzIjoiTGFrZSBQb3dlbGwsIEFaIDg2MDQwLCBWZXJlbmlnZGUgU3RhdGVuIiwibG9jYXRpb24iOnsibGF0IjoiMzYuOTM4ODQ2NCIsImNpdHkiOiJMYWtlIFBvd2VsbCIsInN0YXRlIjoiQXJpem9uYSIsImNvdW50cnkiOiJWZXJlbmlnZGUgU3RhdGVuIiwibG5nIjoiLTExMS40ODQ3MTY3Iiwib25jbGlja19hY3Rpb24iOiJtYXJrZXIiLCJyZWRpcmVjdF9wZXJtYWxpbmsiOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL2xha2UtcG93ZWxsLyIsInpvb20iOjEyLCJleHRyYV9maWVsZHMiOnsicG9zdF9leGNlcnB0IjoiIiwicG9zdF9jb250ZW50IjoiW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIl1bdmNfY29sdW1uIHdpZHRoPVwiMS8yXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjEwMCVcIl1bdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS8yXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJMYWtlIFBvd2VsbFwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTozNXx0ZXh0X2FsaWduOmxlZnR8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdQW1lcmlrYSBrZW50IGVlbiBhYW50YWwgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvbW9vaXN0ZS1tZXJlbi1hbWVyaWthL1wiPnByYWNodGlnZSBtZXJlbjwvYT4uIFNvbW1pZ2VuIHppam4gbmF0dXVybGlqaywgYW5kZXJlbiBkb29yIG1lbnNlbiBhYW5nZWxlZ2QuIExha2UgUG93ZWxsIGlzIGVlbiBtZWVyIGRhdCBkb29yIG1lbnNlbiBnZW1hYWt0IGlzLiBIZXQgdHdlZWRlIGdyb290c3RlIGRvb3IgbWVuc2VuIGdlbWFha3RlIG1lZXIgaXMgb250c3RhYW4gZG9vciBkZSBib3V3IHZhbiBkZSBHbGVuIENhbnlvbiBEYW0uIExha2UgUG93ZWxsIGhlZWZ0IGVlbiBpbmRydWt3ZWtrZW5kZSBrdXN0bGlqbiwgbWV0IDMwNTAga2lsb21ldGVyIGlzIGhldCBsYW5nZXIgZGFuIGRlIGdlaGVsZSBBbWVyaWthYW5zZSB3ZXN0a3VzdC4gTGFrZSBQb3dlbGwgZW4gZGUgR2xlbiBDYW55b24gRGFtIHppam4gb25kZXJkZWVsIHZhbiBoZXQgTmF2YWpvIHJlc2VydmFhdC5bL3ZjX2NvbHVtbl90ZXh0XVt1bHRpbWF0ZV9pY29uX2xpc3QgaWNvbl9zaXplPVwiMjBcIl1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLXRyZWVcIl08c3BhbiBjbGFzcz1cIkxyelhyIGtuby1mdlwiPjY1OCBrbVx1MDBiMiBvcHBlcnZsYWt0ZTwvc3Bhbj5bL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVsvdWx0aW1hdGVfaWNvbl9saXN0XVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY3NzPVwiLnZjX2N1c3RvbV8xNjA4NjY2NTE5NDkye2JhY2tncm91bmQtY29sb3I6ICNlYWVhZWEgIWltcG9ydGFudDt9XCJdW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIyLzNcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNzVweFwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiT250c3RhYW4gTGFrZSBQb3dlbGxcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MzV8dGV4dF9hbGlnbjpjZW50ZXJ8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxwIHN0eWxlPVwidGV4dC1hbGlnbjogY2VudGVyO1wiPkxha2UgUG93ZWxsIGlzIG9udHN0YWFuIGRvb3IgZGUgb3ZlcnN0cm9taW5nIHZhbiBHbGVuIENhbnlvbiB3YWFyZG9vciBiZXNsb3RlbiB3ZXJkIHRvdCBkZSBib3V3IHZhbiBlZW4gZGFtLiBIaWVyZG9vciBvbnRzdG9uZCBoZXQgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvZ2xlbi1jYW55b24tcmVjcmVhdGlvbi1hcmVhL1wiPkdsZW4gQ2FueW9uIE5hdGlvbmFsIFJlY3JlYXRpb24gQXJlYTwvYT4uIEhldCBzdHV3bWVlciwgTGFrZSBQb3dlbGwsIGlzIHZlcm5vZW1kIG5hYXIgSm9obiBXZXNsZXkgUG93ZWxsLCBlZW4gdmV0ZXJhYW4gdWl0IGRlIGJ1cmdlcm9vcmxvZyBkaWUgaW4gMTg2OSBkZSByaXZpZXIgbWV0IDMgaG91dGVuIGJvdGVuIHZlcmtlbmRlLiBIZXQgbWVlciBiaWVkdCBtb2dlbGlqa2hlZGVuIHZvb3IgaGV0IG9wc2xhYW4gdmFuIHdhdGVyIHZvb3IgZGUgVXBwZXIgQmFzaW4gc3RhdGVuIHZhbiBkZSBDb2xvcmFkbyByaXZpZXIgKENvbG9yYWRvLCBVdGFoLCBXeW9taW5nIGVuIE5ldyBNZXhpY28pLiBEYWFybmFhc3Qgem9yZ3QgaGV0IHZvb3Igc3Ryb29tIGluIGRlIExvd2VyIEJhc2luIHN0YXRlbiAoQXJpem9uYSwgTmV2YWRhIGVuIENhbGlmb3JuaVx1MDBlYikuPC9wPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNzVweFwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIGNvbnRlbnRfcGxhY2VtZW50PVwibWlkZGxlXCIgZnVsbF93aWR0aD1cInN0cmV0Y2hfcm93XCIgY29udGVudF90ZXh0X2FsaWdtZW50PVwiY2VudGVyXCIgY3NzPVwiLnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fVwiIHBhcmFsbGF4X2JhY2tncm91bmRfaW1hZ2U9XCIzODM2XCJdW3ZjX2NvbHVtbiB0aGJfY29sb3I9XCJ0aGItbGlnaHQtY29sdW1uXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiTWV0IGVlbiBib290IG9wIExha2UgUG93ZWxsXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjc1fHRleHRfYWxpZ246Y2VudGVyfGNvbG9yOiUyM2ZmZmZmZnxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiRGUgYmVzdGUgbWFuaWVyIG9tIExha2UgUG93ZWxsIHRlIHZlcmtlbm5lblwiIGZvbnRfY29udGFpbmVyPVwidGFnOmRpdnxmb250X3NpemU6NDV8dGV4dF9hbGlnbjpjZW50ZXJ8Y29sb3I6JTIzZmZmZmZmfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpEYW5jaW5nJTIwU2NyaXB0JTNBcmVndWxhciUyQzcwMHxmb250X3N0eWxlOjcwMCUyMGJvbGQlMjByZWd1bGFyJTNBNzAwJTNBbm9ybWFsXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3BhcmFsbGF4X3JvdyBlbmFibGVfbW9iaWxlPVwicGFyYWxsYXgtZW5hYmxlLW1vYmlsZVwiIGltYWdlPVwiMTc2MTJcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiXVt2Y19jb2x1bW5dW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzNcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkZhY3RzIExha2UgUG93ZWxsXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjI1fHRleHRfYWxpZ246bGVmdFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdU2luZHMgMjAwMCBpcyBlciBzcHJha2UgdmFuIGVlbiBtZWdhIGRyb29ndGUgaW4gaGV0IHp1aWR3ZXN0ZW4gdmFuIE5vb3JkIEFtZXJpa2EuIE9vayBMYWtlIFBvd2VsbCBoZWVmdCBoaWVyb25kZXIgdGUgbGVpZGVuLiAyMDA1IHdhcyBoZXQgamFhciB3YWFyaW4gaGV0IGxhYWdzdGUgbml2ZWF1IHZhbiBkZSB3YXRlcnN0YW5kIHdlcmQgYmVyZWlrdC4gR2VsdWtraWcgaXMgaGV0IGRlIGFmZ2Vsb3BlbiBqYXJlbiBpZXRzIGhlcnN0ZWxkLCBtYWFyIGhldCBuaXZlYXUgaXMgbm9nIG5pZXQgb3AgaGV0IG91ZGUgcGVpbC4gRGUgY2FwYWNpdGVpdCB2YW4gTGFrZSBQb3dlbGwgaXMgc2luZHMgMTk2MyBtZXQgNyUgYWZnZW5vbWVuIGFscyBnZXZvbGcgdmFuIGRlIGluc3Ryb29tIHZhbiBzZWRpbWVudGVuIHVpdCBkZSBDb2xvcmFkbyByaXZpZXIgZW4gZGUgU2FuIEp1YW4gcml2aWVyLlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvM1wiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiQmVzdGUgcmVpc3BlcmlvZGUgTGFrZSBQb3dlbGxcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MjV8dGV4dF9hbGlnbjpsZWZ0XCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1UdXNzZW4ganVuaSBlbiBva3RvYmVyIGt1biBqZSBMYWtlIFBvd2VsbCBoZXQgYmVzdGUgYmV6b2VrZW4uIERlIG1hYW5kZW4ganVuaSwganVsaSBlbiBhdWd1c3R1cyB6aWpuIGRlIGRydWtzdGUgbWFhbmRlbiBtZXQgd2FybWUgZGFnZW4oMzUtMzcgZ3JhZGVuKSBlbiBnb2VkZSB3YXRlcnRlbXBlcmF0dXJlbi4gV2lsIGplIGVlbiBpZXRzIHJ1c3RpZ2VyZSBwZXJpb2RlPyBHYSBkYW4gaW4gc2VwdGVtYmVyIGVuIG9rdG9iZXIgbmFhciBMYWtlIFBvd2VsbC4gRGUgd2F0ZXJ0ZW1wZXJhdHVyZW4gemlqbiBub2cgc3RlZWRzIGdvZWQsIG1hYXIgZGUgdGVtcGVyYXR1cmVuIGlldHMgbGFnZXIgKHR1c3NlbiAyMy0zMCBncmFkZW4pLlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvM1wiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiT3Zlcm5hY2h0ZW4gYmlqIExha2UgUG93ZWxsXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjI1fHRleHRfYWxpZ246bGVmdFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdRGUgYmVzdGUgdWl0dmFsc2Jhc2lzIHZvb3IgTGFrZSBQb3dlbGwgaXMgUGFnZS4gSGllciB2aW5kIGplIHZlcnNjaGlsbGVuZGUgaG90ZWxzIHdhYXIgamUga3VudCBvdmVybmFjaHRlbi4gRWVuIGFhbnRhbCBvcHRpZXM6XHJcbjx1bD5cclxuIFx0PGxpPjxhIGhyZWY9XCJodHRwczovL3d3dy5ib29raW5nLmNvbS9ob3RlbC91cy9jb3VydHlhcmQtcGFnZS1hdC1sYWtlLXBvd2VsbC5lbi5odG1sP2FpZD03OTU4NDk4JmFtcDtub19yb29tcz0xJmFtcDtncm91cF9hZHVsdHM9MiZhbXA7bGFiZWw9bGFrZXBvd2VsbGNvdXJ0eWFyZFwiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+Q291cnR5YXJkIFBhZ2UgYXQgTGFrZSBQb3dlbGw8L2E+PC9saT5cclxuIFx0PGxpPjxhIGhyZWY9XCJodHRwczovL3d3dy5ib29raW5nLmNvbS9ob3RlbC91cy9iZXN0LXdlc3Rlcm4tYXQtbGFrZS1wb3dlbGwuZW4uaHRtbD9haWQ9Nzk1ODQ5OCZhbXA7bm9fcm9vbXM9MSZhbXA7Z3JvdXBfYWR1bHRzPTImYW1wO2xhYmVsPWxha2Vwb3dlbGxiZXN0d2VzdGVyblwiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+QmVzdCBXZXN0ZXJuIFBsdXMgYXQgTGFrZSBQb3dlbGw8L2E+PC9saT5cclxuIFx0PGxpPjxhIGhyZWY9XCJodHRwczovL3d3dy5ib29raW5nLmNvbS9ob3RlbC91cy9oeWF0dC1wbGFjZS1wYWdlLWxha2UtcG93ZWxsLmVuLmh0bWw/YWlkPTc5NTg0OTgmYW1wO25vX3Jvb21zPTEmYW1wO2dyb3VwX2FkdWx0cz0yJmFtcDtsYWJlbD1sYWtlcG93ZWxsaHlhdHRcIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPkh5YXR0IFBsYWNlIFBhZ2UgTGFrZSBQb3dlbGw8L2E+PC9saT5cclxuPC91bD5cclxuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiIGZ1bGxfd2lkdGg9XCJzdHJldGNoX3Jvd1wiIGNvbnRlbnRfdGV4dF9hbGlnbWVudD1cImNlbnRlclwiIGNzcz1cIi52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O31cIiBwYXJhbGxheF9iYWNrZ3JvdW5kX2ltYWdlPVwiMzgzNlwiXVt2Y19jb2x1bW4gdGhiX2NvbG9yPVwidGhiLWxpZ2h0LWNvbHVtblwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJSYWluYm93IEJyaWRnZVwiIGhlYWRpbmdfdGFnPVwicFwiIG1haW5faGVhZGluZ19jb2xvcj1cIiNmZmZmZmZcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDo0NXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjU1cHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIxMHB4XCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJFXHUwMGU5biB2YW4gZGUgbmF0dXVybGlqa2UgaGlnaGxpZ2h0c1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmRpdnxmb250X3NpemU6NDV8dGV4dF9hbGlnbjpjZW50ZXJ8Y29sb3I6JTIzZmZmZmZmfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpEYW5jaW5nJTIwU2NyaXB0JTNBcmVndWxhciUyQzcwMHxmb250X3N0eWxlOjcwMCUyMGJvbGQlMjByZWd1bGFyJTNBNzAwJTNBbm9ybWFsXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3BhcmFsbGF4X3JvdyBlbmFibGVfbW9iaWxlPVwicGFyYWxsYXgtZW5hYmxlLW1vYmlsZVwiIGltYWdlPVwiOTk5OVwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCJdW3ZjX2NvbHVtbl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lcl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIldhdCB0ZSBkb2VuIGJpaiBMYWtlIFBvd2VsbFwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTozNXx0ZXh0X2FsaWduOmNlbnRlcnxjb2xvcjolMjNiMzRhNGNcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48cCBzdHlsZT1cInRleHQtYWxpZ246IGNlbnRlcjtcIj5PcCBlbiByb25kb20gTGFrZSBQb3dlbGwgaXMgZ2Vub2VnIHRlIGRvZW4uIERlbmsgYWFuIHdhdGVyc3BvcnRlbiwgd2FuZGVsZW4gZW4gcHJhY2h0aWdlIG5hdHV1cmZlbm9tZW5lbiBvbSB0ZSBiZXpvZWtlbi4gQ29tYmluZWVyIGplIExha2UgUG93ZWxsIG1ldCA8YSBocmVmPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9iZXppZW5zd2FhcmRpZ2hlZGVuLXBhZ2UtYXJpem9uYS9cIj5QYWdlPC9hPiBpbiBBcml6b25hPyBEYW4ga3VuIGplIGhpZXIgemVsZnMgZWVuIHBhYXIgZGFnZW4gdmVyYmxpanZlbi4gT256ZSB0aXBzIHZvb3IgTGFrZSBQb3dlbGwuPC9wPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW5dW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjI1cHhcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiNzAlXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJCb290amUgdmFyZW4gb3AgTGFrZSBQb3dlbGxcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoM3xmb250X3NpemU6MzB8dGV4dF9hbGlnbjpsZWZ0XCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19zaW5nbGVfaW1hZ2UgaW1hZ2U9XCIxNzYxMlwiIGltZ19zaXplPVwibGFyZ2VcIl1bdmNfY29sdW1uX3RleHRdTGFrZSBQb3dlbGwga3VuIGplIG5hdHV1cmxpamsgaGV0IGJlc3RlIHZlcmtlbm5lbiB2YW5hZiBoZXQgd2F0ZXIuIEVyIHppam4gdmVyc2NoaWxsZW5kZSB3YXRlcnNwb3J0LWFjdGl2aXRlaXRlbiBtb2dlbGlqay4gTWV0IGVlbiByb25kdmFhcnQgb3ZlciBMYWtlIFBvd2VsbCBrcmlqZyBqZSBlZW4gZ29lZGUgaW5kcnVrIHZhbiBoZXQgbWVlci4gSmUga3VudCBvcCB0d2VlIHBsZWtrZW4gZWVuIHJvbmR2YWFydCBib2VrZW46IHZhbmFmIFdhaHdlYXAgTWFyaW5hIGVuIEFudGVsb3BlIFBvaW50IE1hcmluYS4gSmUga3VudCBkZSByb25kdmFhcnQgaGV0IGJlc3RlIG9ubGluZSBib2VrZW4sIHZhbmFmIEFudGVsb3BlIFBvaW50IE1hcmluYSB6aWpuIHplIHZhYWsgbmV0IGlldHMgZ29lZGtvcGVyLiBBbmRlcmUgd2F0ZXJzcG9ydC1hY3Rpdml0ZWl0ZW4gemlqbiB3YXRlcnNraVx1MDBlYm4sIGthbm9cdTAwZWJuLCB3YWtlYm9hcmRlbiBlbiBzdXBwZW4uWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS8yXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJSYWluYm93IEJyaWRnZSBNb251bWVudFwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgzfGZvbnRfc2l6ZTozMHx0ZXh0X2FsaWduOmxlZnRcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX3NpbmdsZV9pbWFnZSBpbWFnZT1cIjk5OTlcIiBpbWdfc2l6ZT1cImxhcmdlXCJdW3ZjX2NvbHVtbl90ZXh0XUVcdTAwZTluIHZhbiBkZSBtb29pc3RlIG5hdHV1cmxpamtlIGJlemllbnN3YWFyZGlnaGVkZW4gaW4gVXRhaCBpcyBkZSBSYWluYm93IEJyaWRnZS4gRWVuIG5hdHV1cmxpamtlIGJvb2cgbWV0IGVlbiBvdmVyc3Bhbm5pbmcgdmFuIDg0IG1ldGVyIGVuIGVlbiBob29ndGUgdmFuIDg4IG1ldGVyLiBEZSBicnVnIGlzIHZhbiBjdWx0dXJlZWwgYmVsYW5nIHZvb3IgZWVuIGFhbnRhbCA8YSBocmVmPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9uYXRpdmUtYW1lcmljYW5zL1wiPmluaGVlbXNlIEFtZXJpa2FhbnNlIHN0YW1tZW48L2E+IGVuIGlzIGFhbmdld2V6ZW4gYWxzIHRyYWRpdGlvbmVlbCBjdWx0dXJlZWwgYmV6aXQuIERlIG1ha2tlbGlqa3N0ZSBtYW5pZXIgb20gUmFpbmJvdyBCcmlkZ2UgdGUgYmV6b2VrZW4gaXMgbWV0IGVlbiB0d2VlIHV1ciBkdXJlbmRlIGJvb3R0b2NodCBvdmVyIExha2UgUG93ZWxsLiBXYW5kZWxlbiB2YW5hZiBOYXZham8gTW91bnRhaW4gaXMgb29rIG1vZ2VsaWprLCBtYWFyIGRhYXJ2b29yIGlzIGVlbiBnb2VkZSB2b29yYmVyZWlkaW5nIG5vb2R6YWtlbGlqay4gSmUgaGVidCBlZW4gdmVyZ3VubmluZyBub2RpZyBkaWUgamUgYWFuIGt1bnQgdnJhZ2VuIGJpaiBoZXQgTmF2YWpvIGhvb2Zka3dhcnRpZXIgaW4gV2luZG93IFJvY2suIEhvdWQgZXIgcmVrZW5pbmcgbWVlIGRhdCBoZXQgcmVzcGVjdGxvb3MgaXMgb20gb3ZlciBvZiBvbmRlciBkZSBicnVnIGRvb3IgdGUgbG9wZW4sIFJhaW5ib3cgQnJpZGdlIGlzIGVlbiByZWxpZ2lldXplIHBsZWsgdm9vciBkZSBOYXZham8gaW5kaWFuZW4uWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW5dW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiNzAlXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJHbGVuIENhbnlvbiBEYW1cIiBmb250X2NvbnRhaW5lcj1cInRhZzpoM3xmb250X3NpemU6MzB8dGV4dF9hbGlnbjpsZWZ0XCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19zaW5nbGVfaW1hZ2UgaW1hZ2U9XCIxNzYxNlwiIGltZ19zaXplPVwibGFyZ2VcIl1bdmNfY29sdW1uX3RleHRdRGUgR2xlbiBDYW55b24gRGFtIGlzIGVlbiBpbmRydWt3ZWtrZW5kZSBiZXppZW5zd2FhcmRpZ2hlaWQgaW4gZGUgYnV1cnQgdmFuIExha2UgUG93ZWxsIGVuIFBhZ2UuIEplIGt1bnQgZGUgR2xlbiBDYW55b24gRGFtIGVuaWdzemlucyB2ZXJnZWxpamtlbiBtZXQgZGUgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvaG9vdmVyLWRhbS1uZXZhZGEvXCI+SG9vdmVyIERhbTwvYT4uIERlIGRhbSBoZWVmdCBlZW4gaG9vZ3RlIHZhbiA0NTcgbWV0ZXIuIEJpaiBoZXQgQ2FybCBIYXlkZW4gVmlzaXRvciBDZW50ZXIgYWFuIGRlIHdlc3RrYW50IHZhbiBkZSBkYW0ga3VuIGplIG1lZXIgaW5mb3JtYXRpZSBrcmlqZ2VuIG92ZXIgZGUgR2xlbiBDYW55b24gRGFtLiBFciB6aWpuIHRlbnRvb25zdGVsbGluZ2VuIGVuIGplIGt1bnQgbWVlIG1ldCBlZW4gcm9uZGxlaWRpbmcgb20gaGV0IGluZHJ1a3dla2tlbmRlIGJvdXd3ZXJrIHRlIGJla2lqa2VuLlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvMlwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiV2FuZGVsZW4gcm9uZG9tIExha2UgUG93ZWxsXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDN8Zm9udF9zaXplOjMwfHRleHRfYWxpZ246bGVmdFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfc2luZ2xlX2ltYWdlIGltYWdlPVwiNjIxNVwiIGltZ19zaXplPVwibGFyZ2VcIl1bdmNfY29sdW1uX3RleHRdRGUgYmVzdGUgcGxlayBvbSB0ZSB3YW5kZWxlbiByb25kb20gTGFrZSBQb3dlbGwgaXMgaW4gZGUgYnV1cnQgdmFuIFdhaHdlYXAgTWFyaW5hLiBKZSB2aW5kdCBoaWVyIHRyYWlscyB2b29yIGllZGVyIG5pdmVhdS4gSmUga3VudCBkZSBHbGVuIENhbnlvbiBEYW0gT3Zlcmxvb2tcdTAwYTAgb2YgZGUgSG9yc2VzaG9lIEJlbmQgVHJhaWwgd2FuZGVsZW4uIEVyIHppam4gZWVuIGFhbnRhbCB0cmFpbHMgd2FhcnZvb3IgamUgZWVyc3QgbWV0IGRlIGJvb3QgZGllbnQgdGUgZ2Fhbi4gWm8gaXMgZGUgTmF2YWpvIENhbnlvbiBlZW4gbWFra2VsaWprZSB3YW5kZWxpbmcgd2FhcnZvb3IgamUgZWVyc3QgZWVuIGJvb3Qgb2Yga2FqYWsgbm9kaWcgaGVidC4gT29rIHZvb3IgZWVuIGJlem9layBhYW4gUmFpbmJvdyBCcmlkZ2UgZGllbiBqZSBlZXJzdCBlZW4gc3R1ayB2aWEgaGV0IHdhdGVyIGFmIHRlIGxlZ2dlbi5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCJdW3ZjX2NvbHVtbl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiSW4gZGUgYnV1cnRcIiBmb250X2NvbnRhaW5lcj1cInRhZzpkaXZ8Zm9udF9zaXplOjQwfHRleHRfYWxpZ246Y2VudGVyXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt0aGJfcG9zdGdyaWQgc3R5bGU9XCJzdHlsZTExXCIgY29sdW1ucz1cIjRcIiBzb3VyY2U9XCJwb3N0X3R5cGU6cG9zdHxieV9pZDotNDc5MiwtNDczOCwtNDcxNCwtNDY4OSw5OTk2LDYyMDksOTgyNiwyNjYxXCJdWy92Y19jb2x1bW5dWy92Y19yb3ddIiwicG9zdF90aXRsZSI6Ikxha2UgUG93ZWxsIiwicG9zdF9saW5rIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9sYWtlLXBvd2VsbC8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJMYWtlIFBvd2VsbCBpbiBBcml6b25hXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMDBcIiBzcmM9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIzLzEwL2xha2UtcG93ZWxsLTMwMHgyMDAuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+IiwicG9zdF9jYXRlZ29yaWVzIjoiTmF0dXVyZ2ViaWVkZW4iLCJwb3N0X3RhZ3MiOiJBcml6b25hIiwiJV93cGJfc2hvcnRjb2Rlc19jdXN0b21fY3NzJSI6Ii52Y19jdXN0b21fMTYwODY2NjUxOTQ5MntiYWNrZ3JvdW5kLWNvbG9yOiAjZWFlYWVhICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9IiwiJWlubGluZV9mZWF0dXJlZF9pbWFnZSUiOiIwIiwiJV9lZGl0X2xvY2slIjoiMTY5Njg0MTg5MToyIiwiJV9lZGl0X2xhc3QlIjoiMiIsIiVfdGh1bWJuYWlsX2lkJSI6IjE3NjExIiwiJV9oaWRlX2ZlYXR1cmVkJSI6bnVsbCwiJV93cGJfdmNfanNfc3RhdHVzJSI6InRydWUiLCIlcG9zdC1wcmltYXJ5LWNhdGVnb3J5JSI6ImF1dG8iLCIlZmVhdHVyZWRfaW1hZ2Vfb3ZlcnJpZGUlIjoib2ZmIiwiJWFydGljbGVfc3R5bGVfb3ZlcnJpZGUlIjoib24iLCIlcG9zdF9zdHlsZSUiOiJzdHlsZTExIiwiJXBvc3RfZ2FsbGVyeV9zdHlsZSUiOiJsaWdodGJveCIsIiVwb3N0X3JldmlldyUiOiJvZmYiLCIlcG9zdF9yZXZpZXdfc3R5bGUlIjoic3R5bGUxIiwiJXBvc3RfcmV2aWV3X2F2ZXJhZ2UlIjoiNTAiLCIlX3lvYXN0X3dwc2VvX2NvbnRlbnRfc2NvcmUlIjoiMzAiLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza2V5d29yZHMlIjoiW10iLCIlX3lvYXN0X3dwc2VvX2tleXdvcmRzeW5vbnltcyUiOiJbXCJcIl0iLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza3clIjoiTGFrZSBQb3dlbGwiLCIlX3lvYXN0X3dwc2VvX21ldGFkZXNjJSI6IkluIEFyaXpvbmEgdmluZCBqZSBoZXQgMmUgZ3Jvb3RzZSBkb29yIG1lbnNlbiBhYW5nZWxlZ2RlIG1lZXIgTGFrZSBQb3dlbGwuIEJlbmlldXdkIHdhdCBqZSBoaWVyIGt1bnQgZG9lbj8gVGlwcyB2b29yIExha2UgUG93ZWxsIGluIEFyaXpvbmEiLCIlX3lvYXN0X3dwc2VvX2xpbmtkZXglIjoiNzMiLCIlX3dwZ21wX2xvY2F0aW9uX2FkZHJlc3MlIjoiTGFrZSBQb3dlbGwsIEFaIDg2MDQwLCBWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9sb2NhdGlvbl9jaXR5JSI6Ikxha2UgUG93ZWxsIiwiJV93cGdtcF9sb2NhdGlvbl9zdGF0ZSUiOiJBcml6b25hIiwiJV93cGdtcF9sb2NhdGlvbl9jb3VudHJ5JSI6IlZlcmVuaWdkZSBTdGF0ZW4iLCIlX3dwZ21wX21ldGFib3hfbGF0aXR1ZGUlIjoiMzYuOTM4ODQ2NCIsIiVfd3BnbXBfbWV0YWJveF9sb25naXR1ZGUlIjoiLTExMS40ODQ3MTY3IiwiJV93cGdtcF9tZXRhYm94X2xvY2F0aW9uX3JlZGlyZWN0JSI6Im1hcmtlciIsIiVfd3BnbXBfbWV0YWJveF9jdXN0b21fbGluayUiOiIiLCIlX3dwZ21wX21hcF9pZCUiOiJhOjE6e2k6MDtzOjE6XCI3XCI7fSIsIiVfd3BnbXBfbWV0YWJveF9tYXJrZXJfaWQlIjoiIiwiJV93cGdtcF9tZXRhYm94X3RheG9tb21pZXNfdGVybXMlIjoiIiwiJV93cGdtcF9leHRlbnNpb25zX2ZpZWxkcyUiOiIiLCIlX3lvYXN0X3dwc2VvX2VzdGltYXRlZC1yZWFkaW5nLXRpbWUtbWludXRlcyUiOiI1IiwiJV95b2FzdF93cHNlb19wcmltYXJ5X2NhdGVnb3J5JSI6IjIyNyIsIiVfd3dzX3N1cHBvcnRfY29udGFjdF9udW1iZXIlIjoiIiwiJV93d3NfYWJvdXRfc3VwcG9ydF90ZXh0JSI6IiIsIiVfd3dzX3RyaWdnZXJfYnV0dG9uX3RleHQlIjoiIiwiJV93d3NfcHJlZGVmaW5lZF90ZXh0JSI6IiIsIiVfeW9hc3Rfd3BzZW9fd29yZHByb29mX3RpbWVzdGFtcCUiOiIiLCIlX3lvYXN0X2luZGV4bm93X2xhc3RfcGluZyUiOiIxNjk2ODQyMDA0IiwiJV9sYXN0X2VkaXRvcl91c2VkX2pldHBhY2slIjoiY2xhc3NpYy1lZGl0b3IiLCIlX3lvYXN0X3dwc2VvX3RpdGxlJSI6IiUldGl0bGUlJSBBcml6b25hICUlcGFnZSUlICUlc2VwJSUgJSVzaXRlbmFtZSUlIiwidGF4b25vbXk9Y2F0ZWdvcnkiOiJOYXR1dXJnZWJpZWRlbiIsInRheG9ub215PXBvc3RfdGFnIjoiQXJpem9uYSIsInRheG9ub215PXBvc3RfZm9ybWF0IjoiIiwidGF4b25vbXk9dGhiLXJlYWN0aW9ucyI6IiIsInRheG9ub215PXRoYi1zcG9uc29ycyI6IiJ9fSwiaWQiOjE3NjA4LCJpbmZvd2luZG93X2Rpc2FibGUiOmZhbHNlfSx7InNvdXJjZSI6InBvc3QiLCJ0aXRsZSI6IlNhZ3Vhcm8gTmF0aW9uYWwgUGFyayIsImluZm93aW5kb3dfY29udGVudCI6IjxkaXYgY2xhc3M9XCJmYy1pdGVtLWJveCBmYy1pdGVtLW5vLXBhZGRpbmcgXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIlNhZ3Vhcm8gTmF0aW9uYWwgUGFya1wiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMy8wOS9TYWd1YXJvLU5hdGlvbmFsLVBhcmsta29waWVyZW4tMzAweDIwMC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmcgZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+U2FndWFybyBOYXRpb25hbCBQYXJrPC9kaXY+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3JcIj57bWFya2VyX2FkZHJlc3N9PC9kaXY+XHJcbiAgICAgICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1jbGVhclwiPjwvZGl2PlxyXG48L2Rpdj4iLCJhZGRyZXNzIjoiQXJpem9uYSwgVmVyZW5pZ2RlIFN0YXRlbiIsImxvY2F0aW9uIjp7ImxhdCI6IjMyLjI5NjczNTkwMDAwMDAxIiwic3RhdGUiOiJBcml6b25hIiwiY291bnRyeSI6IlZlcmVuaWdkZSBTdGF0ZW4iLCJsbmciOiItMTExLjE2NjYxNSIsIm9uY2xpY2tfYWN0aW9uIjoibWFya2VyIiwicmVkaXJlY3RfcGVybWFsaW5rIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9zYWd1YXJvLW5hdGlvbmFsLXBhcmsvIiwiem9vbSI6MTIsImV4dHJhX2ZpZWxkcyI6eyJwb3N0X2V4Y2VycHQiOiIiLCJwb3N0X2NvbnRlbnQiOiJbdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiMTAwJVwiXVt2Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIlNhZ3Vhcm8gTmF0aW9uYWwgUGFya1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTozNXx0ZXh0X2FsaWduOmxlZnR8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdRGUgc3RhYXQgQXJpem9uYSBrZW50IDMgbmF0aW9uYWxlIHBhcmtlbiB3YWFydmFuIGhldCBHcmFuZCBDYW55b24gTmF0aW9uYWwgUGFyayB2ZXJyZXdlZyBkZSBiZWtlbmRzdGUgaXMuIERlIGFuZGVyZSB0d2VlIG5hdGlvbmFsZSBwYXJrZW4gemlqbiBlZW4gc3R1ayBtaW5kZXIgYmVrZW5kLCBtYWFyIG5ldCB6byB1bmllayBpbiBodW4gc29vcnQuIEhldCBQZXRyaWZpZWQgRm9yZXN0IE5hdGlvbmFsIFBhcmsgZW4gaGV0IFNhZ3Vhcm8gTmF0aW9uYWwgUGFyayBsYXRlbiB6aWVuIGhvZSBkaXZlcnMgZGUgc3RhYXQgQXJpem9uYSBpcyBxdWEgbmF0dXVyLiBIZXQgU2FndWFybyBOYXRpb25hbCBQYXJrIGlzIFx1MDBlOVx1MDBlOW4gdmFuIGRlIGRyb29nc3RlIHBsZWtrZW4gaW4gQW1lcmlrYSBlbiBoZWVmdCB6aWpuIG5hYW0gdGUgZGFua2VuIGFhbiBkZSBTYWd1YXJvIGNhY3R1cy4gQmVuaWV1d2QgbmFhciBoZXQgU2FndWFybyBOYXRpb25hbCBQYXJrPyBMZWVzIGRhbiBvbnplIHRpcHMgdm9vciBkaXQgbmF0aW9uYWxlIHBhcmsgaW4gQXJpem9uYS5bL3ZjX2NvbHVtbl90ZXh0XVt1bHRpbWF0ZV9pY29uX2xpc3QgaWNvbl9zaXplPVwiMjBcIl1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLWF1dG9tb2JpbGUgY2FyXCJdMzJcdTAwYTAgJmFtcDsgMjQga2lsb21ldGVyIHZhbmFmIFR1Y3NvblsvdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy10cmVlXCJdPHNwYW4gY2xhc3M9XCJMcnpYciBrbm8tZnZcIj4zNTQsMiBrbVx1MDBiMiBvcHBlcnZsYWt0ZTwvc3Bhbj5bL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtcGF3XCJdMjAwIHZlcnNjaGlsbGVuZGUgdm9nZWxzWy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bL3VsdGltYXRlX2ljb25fbGlzdF1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIGNzcz1cIi52Y19jdXN0b21fMTYwODY2NjUxOTQ5MntiYWNrZ3JvdW5kLWNvbG9yOiAjZWFlYWVhICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMi8zXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIlNhZ3Vhcm8gQ2FjdHVzXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjM1fHRleHRfYWxpZ246Y2VudGVyfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48cCBzdHlsZT1cInRleHQtYWxpZ246IGNlbnRlcjtcIj5EZSByZXV6ZW5jYWN0dXMgU2FndWFybyBpcyBkZSBiZWtlbmRzdGUgYXR0cmFjdGllIHZhbiBoZXQgU2FndWFybyBOYXRpb25hbCBQYXJrLiBEZSB1bmlla2UgY2FjdHVzIGthbiB0b3QgMTUgbWV0ZXIgaG9vZyB3b3JkZW4gZW4gaXMgZGFhcm1lZSBkZSBncm9vdHN0ZSBjYWN0dXMgZGllIGVyIGlzLiBIaWogaXMgb29rIGRlIGxhbmd6YWFtc3QgZ3JvZWllbmRlIGNhY3R1cy4gUGFzIG5hIDUwIGphYXIgYmVyZWlrdCBoaWogZWVuIGxlbmd0ZSB2YW4gMiBtZXRlciwgbWV0IDc1IGphYXIgYmVnaW5uZW4gZGUgdmVydGFra2luZ2VuIGVuIG1ldCAxNTAgamFhciBpcyBoaWogcGFzIHZvbGxlZGlnIHZvbGdyb2VpZC4gRGUgU2FndWFybyBpcyBoZXQgc3ltYm9vbCB2YW4gQXJpem9uYSBlbiBzdGFhdCBpbiBibG9laSB0dXNzZW4gYXByaWwgZW4ganVuaS4gJ3MgTmFjaHRzIGVuIGluIGRlIHZyb2VnZSBvY2h0ZW5kLCB3YW5uZWVyIGRlIHRlbXBlcmF0dXJlbiBub2cgbGFhZyB6aWpuLCBpcyBoaWogaGV0IG1vb2lzdC48L3A+XHJcblsvdmNfY29sdW1uX3RleHRdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI3NXB4XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIiBmdWxsX3dpZHRoPVwic3RyZXRjaF9yb3dcIiBjb250ZW50X3RleHRfYWxpZ21lbnQ9XCJjZW50ZXJcIiBjc3M9XCIudmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9XCIgcGFyYWxsYXhfYmFja2dyb3VuZF9pbWFnZT1cIjM4MzZcIl1bdmNfY29sdW1uIHRoYl9jb2xvcj1cInRoYi1saWdodC1jb2x1bW5cIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJTYWd1YXJvIGNhY3R1cyBpbiBibG9laVwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTo3NXx0ZXh0X2FsaWduOmNlbnRlcnxjb2xvcjolMjNmZmZmZmZ8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1baGV5dXNhX2hlYWRpbmcgdGFnPVwiaDRcIiB0ZXh0X2FsaWduPVwiY2VudGVyXCIgaGVhZGluZz1cIktvbSB0dXNzZW4gYXByaWwgZW4ganVuaSBuYWFyIGhldCBwYXJrXCIgZm9udF9zaXplPVwiNTBcIiBsaW5lX2hlaWdodD1cIjFcIiBmb250X2NvbG9yPVwiI2ZmZmZmZlwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVtwYXJhbGxheF9yb3cgZW5hYmxlX21vYmlsZT1cInBhcmFsbGF4LWVuYWJsZS1tb2JpbGVcIiBpbWFnZT1cIjE3NDk1XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIl1bdmNfY29sdW1uXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJGYWN0cyBTYWd1YXJvIE5hdGlvbmFsIFBhcmtcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MjV8dGV4dF9hbGlnbjpsZWZ0XCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1IZXQgU2FndWFybyBOYXRpb25hbCBQYXJrIGJlc3RhYXQgaW4gdGVnZW5zdGVsbGluZyB0b3QgZGUgYW5kZXJlIG5hdGlvbmFsZSBwYXJrZW4gdWl0IDIgZGVsZW4uIEVcdTAwZTluIGRlZWwgbGlndCBvcCAzMiBraWxvbWV0ZXIgdGVuIG9vc3RlbiB2YW4gZGUgc3RhZCBUdWNzb24sIGRlIGFuZGVyZSBvcCAyNCBraWxvbWV0ZXIgdGVuIHdlc3RlbiB2YW4gVHVjc29uLiBKZSBrdW50IHplZ2dlbiBkYXQgZGUgc3RhZCBUdWNzb24gaGV0IHBhcmsgc2NoZWlkdC4gSmUgdmluZHQgaW4gaGV0IFNhZ3Vhcm8gTmF0aW9uYWwgUGFyayBlZW4gd29lc3Rpam5rbGltYWF0LCBkZSB6b21lcnMgemlqbiB3YXJtIGVuIGVyIHZhbHQgaW4gaGV0IGphYXIgbWFhciB6byduIDMwIGNtIHJlZ2VuLiBEZSBmbG9yYSBlbiBmYXVuYSB6aWpuIGluZ2VzcGVlbGQgb3AgZGl0IHdlZXIuIFdhbnQgaG9ld2VsIGplIGhldCBtaXNzY2hpZW4gbmlldCB2ZXJ3YWNodCwgemlqbiBlciBpbiBoZXQgcGFyayB2ZWxlIHNvb3J0ZW4gYm9tZW4sIHBsYW50ZW4gZW4gZGllcmVuIHRlIHZpbmRlbi4gSW4gdG90YWFsIHppam4gZXIgbWVlciBkYW4gMTAwMCBpbmhlZW1zZSBwbGFudGVuLCAyMDAgdm9nZWxzIGVuIGtvbWVuIGRpZXJlbiBhbHMgY295b3RlcywgaGFsc2JhbmRwZWthcmkncyB2YWFrIHZvb3IuIE9vayBsZXZlbiBlciB6d2FydGUgYmVyZW4gZW4gcG9lbWEncyBpbiBoZXQgU2FndWFybyBOYXRpb25hbGUgUGFyay5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIldhdCB0ZSBkb2VuIGluIFNhZ3Vhcm8gTmF0aW9uYWwgUGFya1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZToyNXx0ZXh0X2FsaWduOmxlZnRcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XURvb3JkYXQgaGV0IFNhZ3Vhcm8gTmF0aW9uYWwgUGFyayB1aXQgMiBkZWxlbiBiZXN0YWF0LCB6aWpuIGVyIHZlcnNjaGlsbGVuZGUgYmV6aWVuc3dhYXJkaWdoZWRlbiBwZXIgZGVlbCB0ZSBiZXpvZWtlbi4gSGV0IG9vc3RlbGlqa2UgZGVlbCB2YW4gZGUgU2FndWFybyBpcyBtZWVyIGdlcmljaHQgb3AgZ2VzY2hpZWRlbmlzIGVuIGdlb2xvZ2llLiBIaWVyIHZpbmQgamUgb29rIGRlIG91ZHN0ZSBTYWd1YXJvIGNhY3R1c3Nlbi4gSmUga3VudCBoaWVyIGRlIDEzIGtpbG9tZXRlciBsYW5nZSBDYWN0dXMgRm9yZXN0IERyaXZlIHJpamRlbiBvbSBoZXQgcGFyayB0ZSBiZWtpamtlbi4gQWFuIGRlemUgd2VnIHN0YXJ0ZW4gdmVyc2NoaWxsZW5kZSB3YW5kZWxyb3V0ZXMuIERlIHdlZ2VuIHppam4gaW4gZGl0IGRlZWwgdmVyaGFyZC4gSGV0IHdlc3RlbGlqa2UgZGVlbCBiZXZhdCBtZWVyIG9uZ2VyZXB0ZSBuYXR1dXIuIERlIHdlZ2VuIHppam4gaGllciBncm90ZW5kZWVscyBvbnZlcmhhcmQgbWV0IHVpdHpvbmRlcmluZyB2YW4gZGUgd2VnIG5hYXIgaGV0IHZpc2l0b3IgY2VudGVyIGVuIGRlIERlc2VydCBEaXNjb3ZlcnkgVHJhaWwuIEJlem9layBpbiBoZXQgd2VzdGVsaWprZSBkZWVsIGRlIFNpZ25hbCBIaWxsIFBpY25pYyBBcmVhLCB3YWFyIGplIGVldXdlbm91ZGUgcm90c3Rla2VuaW5nZW4ga3VudCB6aWVuLlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJPdmVybmFjaHRlbiBpbiBTYWd1YXJvIE5hdGlvbmFsIFBhcmtcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MjV8dGV4dF9hbGlnbjpsZWZ0XCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1FciB6aWpuIGdlZW4gaG90ZWxzIG9mIGNhYmlucyB0ZSBodXVyIGluIGhldCBTYWd1YXJvIE5hdGlvbmFsIFBhcmsuIEVua2VsZSBrbGVpbmUgY2FtcHNpdGVzIG1ldCBlZW4gcGFhciBwbGVra2VuIHppam4gZXIgaW4gaGV0IHBhcmsgZGllIGplIGFsbGVlbiB3YW5kZWxlbmQga3VudCBiZXJlaWtlbi4gV2lsIGplIGluIGVlbiBob3RlbCBvdmVybmFjaHRlbj8gS2lqayBkYW4gdm9vciA8YSBocmVmPVwiaHR0cHM6Ly93d3cuYm9va2luZy5jb20vc2VhcmNocmVzdWx0cy5lbi5odG1sP2NpdHk9MjAwMDc0MTcmYW1wO2FpZD03OTU4NDk4JmFtcDtub19yb29tcz0xJmFtcDtncm91cF9hZHVsdHM9MiZhbXA7bGFiZWw9U2FndWFyb3R1Y3NvblwiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+bW9nZWxpamtoZWRlbiBpbiBUdWNzb248L2E+LiBBYW5nZXppZW4gZGUgc3RhZCBtaWRkZW4gdHVzc2VuIGRlIHR3ZWUgZGVsZW4gbGlndCwgZGUgYmVzdGUgdWl0dmFsc2Jhc2lzIG9tIGhldCBwYXJrIHRlIHZlcmtlbm5lbi5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkJlc3RlIHJlaXNwZXJpb2RlIFNhZ3Vhcm8gTmF0aW9uYWwgUGFya1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZToyNXx0ZXh0X2FsaWduOmxlZnRcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XUhldCBTYWd1YXJvIE5hdGlvbmFsIFBhcmsga3VuIGplIGhldCBiZXN0ZSBiZXpvZWtlbiB2YW4gb2t0b2JlciB0b3QgZW4gbWV0IGFwcmlsLiBJbiBkZXplIHBlcmlvZGUgbGlnZ2VuIGRlIHRlbXBlcmF0dXJlbiBvdmVyZGFnIHJvbmQgZGUgMjAgZ3JhZGVuIGVuIGtvZWx0IGhldCAncyBuYWNodHMgYWYgbmFhciBoZXQgdnJpZXNwdW50LiBCZW4gamUgaW4gYXByaWw/IERhbiBoZWIgamUga2FucyBvbSBkZSBTYWd1YXJvIHRlIHppZW4gYmxvZWllbi4gRGUgd2FybXN0ZSBtYWFuZGVuIHppam4gbWVpIHRvdCBlbiBtZXQgc2VwdGVtYmVyLiBEZSB0ZW1wZXJhdHVyZW4gbGlnZ2VuIGRhbiByb25kIGRlIDQwIGdyYWRlbiBvdmVyZGFnLiBUdXNzZW4gamFudWFyaSBlbiBtYWFydCBrdW5uZW4gZW5rZWxlIChoZWxlKSBsaWNodGUgcmVnZW5idWllbiB2b29ya29tZW4uWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiIGZ1bGxfd2lkdGg9XCJzdHJldGNoX3Jvd1wiIGNvbnRlbnRfdGV4dF9hbGlnbWVudD1cImNlbnRlclwiIGNzcz1cIi52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O31cIiBwYXJhbGxheF9iYWNrZ3JvdW5kX2ltYWdlPVwiMzgzNlwiXVt2Y19jb2x1bW4gdGhiX2NvbG9yPVwidGhiLWxpZ2h0LWNvbHVtblwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJUcmFpbHMgaW4gaGV0IFNhZ3Vhcm8gTmF0aW9uYWwgUGFya1wiIGhlYWRpbmdfdGFnPVwicFwiIG1haW5faGVhZGluZ19jb2xvcj1cIiNmZmZmZmZcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDo0NXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjU1cHg7XCIgbWFyZ2luX2Rlc2lnbl90YWJfdGV4dD1cIlwiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMTBweFwiXVtoZXl1c2FfaGVhZGluZyB0YWc9XCJoNFwiIHRleHRfYWxpZ249XCJjZW50ZXJcIiBoZWFkaW5nPVwiT250ZGVrIGhldCBwYXJrIG9wIFx1MDBlOVx1MDBlOW4gdmFuIGRlIHdhbmRlbHBhZGVuXCIgZm9udF9zaXplPVwiNTBcIiBsaW5lX2hlaWdodD1cIjFcIiBmb250X2NvbG9yPVwiI2ZmZmZmZlwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVtwYXJhbGxheF9yb3cgZW5hYmxlX21vYmlsZT1cInBhcmFsbGF4LWVuYWJsZS1tb2JpbGVcIiBpbWFnZT1cIjE3NDkzXCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjc3M9XCIudmNfY3VzdG9tXzE2MDg2NjY4ODU0OTd7YmFja2dyb3VuZC1pbWFnZTogdXJsKGh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjAvMDgvYmFja2dyb3VuZC1oZXl1c2EtbmF0dXVyLTEuZ2lmP2lkPTMwODgpICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW5dW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiV2FuZGVsZW4gaW4gU2FndWFybyBOYXRpb25hbCBQYXJrXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzAwMDAwMFwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjU1cHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF1JbiBoZXQgU2FndWFybyBOYXRpb25hbCBQYXJrIHppam4gZXIgdmVyc2NoaWxsZW5kZSBtb2dlbGlqa2hlZGVuIG9tIHRlIHdhbmRlbGVuLiBFZW4gYWFudGFsIHdhbmRlbGluZ2VuIGRpZSBkZSBtb2VpdGUgd2FhcmQgemlqbiBpbiBoZXQgb29zdGVuOlxyXG48dWw+XHJcbiBcdDxsaT5GcmVlbWFuIEhvbWVzdGFkIFRyYWlsICgyIGtpbG9tZXRlcik8L2xpPlxyXG4gXHQ8bGk+TG9tYSBWZXJkZSBMb29wICg2IGtpbG9tZXRlcik8L2xpPlxyXG4gXHQ8bGk+SG9wZSBDYW1wIGFuZCBSaWRnZXZpZXcgVHJhaWwgKDMsMiBraWxvbWV0ZXIpPC9saT5cclxuIFx0PGxpPkdhcndvb2QgRGFtIGFuZCBXaWxkaG9yc2UgVGFuayAoMTAga2lsb21ldGVyKTwvbGk+XHJcbjwvdWw+XHJcbkluIGhldCB3ZXN0ZW4ga3VuIGplIGRlIHZvbGdlbmRlIHdhbmRlbGluZ2VuIGRvZW46XHJcbjx1bD5cclxuIFx0PGxpPldpbGQgRG9nIFRyYWlsICgyLDgga2lsb21ldGVyKTwvbGk+XHJcbiBcdDxsaT5LaW5nIENhbnlvbiAvIEdvdWxkIE1pbmUgTG9vcCAoMyw4IGtpbG9tZXRlcik8L2xpPlxyXG4gXHQ8bGk+U2VuZGVybyBFc3BlcmFuemEgVHJhaWwgKDUsNiBraWxvbWV0ZXIpPC9saT5cclxuPC91bD5cclxuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiSGFuZGlnZSBpbmZvIHZvb3IgamUgYmV6b2VrXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzAwMDAwMFwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OlJvYm90byBTbGFifGZvbnRfY2FsbDpSb2JvdG8rU2xhYnx2YXJpYW50OjgwMFwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NTVweDtcIiBtYWluX2hlYWRpbmdfc3R5bGU9XCJmb250LXdlaWdodDo4MDA7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt1bHRpbWF0ZV9pY29uX2xpc3QgaWNvbl9zaXplPVwiMjVcIl1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLWNsb2NrLW9cIiBjb250ZW50X2ZvbnRfc2l6ZT1cImRlc2t0b3A6MTZweDtcIl0yNC83IGVuIDM2NSBkYWdlbiBnZW9wZW5kWy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLXRodW1icy11cFwiIGNvbnRlbnRfZm9udF9zaXplPVwiZGVza3RvcDoxNnB4O1wiXUJlc3RlIHBlcmlvZGU6IG9rdG9iZXIgdC9tIGFwcmlsWy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLWRvbGxhciB1c2RcIiBjb250ZW50X2ZvbnRfc2l6ZT1cImRlc2t0b3A6MTZweDtcIl0kMjUgYXV0b1xyXG4kMTUgcGVyc29vblsvdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dWy91bHRpbWF0ZV9pY29uX2xpc3RdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiIGZ1bGxfd2lkdGg9XCJzdHJldGNoX3Jvd1wiIGNvbnRlbnRfdGV4dF9hbGlnbWVudD1cImNlbnRlclwiIGNzcz1cIi52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O31cIiBwYXJhbGxheF9iYWNrZ3JvdW5kX2ltYWdlPVwiMzgzNlwiXVt2Y19jb2x1bW4gdGhiX2NvbG9yPVwidGhiLWxpZ2h0LWNvbHVtblwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJTdW5zZXQgaW4gaGV0IFNhZ3Vhcm8gTmF0aW9uYWwgUGFyayBcIiBoZWFkaW5nX3RhZz1cInBcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjZmZmZmZmXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6NDVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDo1NXB4O1wiIG1hcmdpbl9kZXNpZ25fdGFiX3RleHQ9XCJcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjEwcHhcIl1baGV5dXNhX2hlYWRpbmcgdGFnPVwiaDRcIiB0ZXh0X2FsaWduPVwiY2VudGVyXCIgaGVhZGluZz1cIkJla2lqayBkZSBpbmRydWt3ZWtrZW5kZSB6b25zb25kZXJnYW5nIGluIGhldCBwYXJrXCIgZm9udF9zaXplPVwiNTBcIiBsaW5lX2hlaWdodD1cIjFcIiBmb250X2NvbG9yPVwiI2ZmZmZmZlwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVtwYXJhbGxheF9yb3cgZW5hYmxlX21vYmlsZT1cInBhcmFsbGF4LWVuYWJsZS1tb2JpbGVcIiBpbWFnZT1cIjE3NDk2XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIl1bdmNfY29sdW1uXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJNZWVyIEFyaXpvbmFcIiBmb250X2NvbnRhaW5lcj1cInRhZzpkaXZ8Zm9udF9zaXplOjQwfHRleHRfYWxpZ246Y2VudGVyXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt0aGJfcG9zdGdyaWQgc3R5bGU9XCJzdHlsZTExXCIgY29sdW1ucz1cIjRcIiBzb3VyY2U9XCJwb3N0X3R5cGU6cG9zdHxieV9pZDotMTczMTgsLTE1MDYyLC0xNDkwNywtMTQyNTAsLTQ3OTIsLTQ3MzgsLTQ3MTQsLTQ2ODksMzIwOCw0NTc0LDE5NzEsODc0MlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XSIsInBvc3RfdGl0bGUiOiJTYWd1YXJvIE5hdGlvbmFsIFBhcmsiLCJwb3N0X2xpbmsiOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3NhZ3Vhcm8tbmF0aW9uYWwtcGFyay8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJTYWd1YXJvIE5hdGlvbmFsIFBhcmtcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjIwMFwiIHNyYz1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjMvMDkvU2FndWFyby1OYXRpb25hbC1QYXJrLWtvcGllcmVuLTMwMHgyMDAuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+IiwicG9zdF9jYXRlZ29yaWVzIjoiU2FndWFybyBOYXRpb25hbCBQYXJrIiwicG9zdF90YWdzIjoiQXJpem9uYSIsIiVfd3BiX3Nob3J0Y29kZXNfY3VzdG9tX2NzcyUiOiIudmNfY3VzdG9tXzE2MDg2NjY1MTk0OTJ7YmFja2dyb3VuZC1jb2xvcjogI2VhZWFlYSAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTYwODY2Njg4NTQ5N3tiYWNrZ3JvdW5kLWltYWdlOiB1cmwoaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMC8wOC9iYWNrZ3JvdW5kLWhleXVzYS1uYXR1dXItMS5naWY/aWQ9MzA4OCkgIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fSIsIiVpbmxpbmVfZmVhdHVyZWRfaW1hZ2UlIjoiMCIsIiVfZWRpdF9sb2NrJSI6IjE2OTU2MjYyMTI6MiIsIiVfZWRpdF9sYXN0JSI6IjIiLCIlX3RodW1ibmFpbF9pZCUiOiIxNzQ5NCIsIiVfaGlkZV9mZWF0dXJlZCUiOm51bGwsIiVfd3BiX3ZjX2pzX3N0YXR1cyUiOiJ0cnVlIiwiJXBvc3QtcHJpbWFyeS1jYXRlZ29yeSUiOiJhdXRvIiwiJWZlYXR1cmVkX2ltYWdlX292ZXJyaWRlJSI6Im9mZiIsIiVhcnRpY2xlX3N0eWxlX292ZXJyaWRlJSI6Im9uIiwiJXBvc3Rfc3R5bGUlIjoic3R5bGUxMSIsIiVwb3N0X2dhbGxlcnlfc3R5bGUlIjoibGlnaHRib3giLCIlcG9zdF9yZXZpZXclIjoib2ZmIiwiJXBvc3RfcmV2aWV3X3N0eWxlJSI6InN0eWxlMSIsIiVwb3N0X3Jldmlld19hdmVyYWdlJSI6IjUwIiwiJV95b2FzdF93cHNlb19jb250ZW50X3Njb3JlJSI6IjYwIiwiJV95b2FzdF93cHNlb19mb2N1c2tleXdvcmRzJSI6IltdIiwiJV95b2FzdF93cHNlb19rZXl3b3Jkc3lub255bXMlIjoiW1wiXCJdIiwiJV95b2FzdF93cHNlb19mb2N1c2t3JSI6IlNhZ3Vhcm8gTmF0aW9uYWwgUGFyayIsIiVfeW9hc3Rfd3BzZW9fbWV0YWRlc2MlIjoiSW4gQXJpem9uYSB2aW5kIGplIGhldCBTYWd1YXJvIE5hdGlvbmFsIFBhcmssIGJla2VuZCB2YW4gZGUgU2FndWFybyBjYWN0dXMuIFRpcHMgdm9vciBlZW4gYmV6b2VrIGFhbiBoZXQgU2FndWFybyBOYXRpb25hbCBQYXJrLiIsIiVfeW9hc3Rfd3BzZW9fbGlua2RleCUiOiI3OSIsIiVfd3BnbXBfbG9jYXRpb25fYWRkcmVzcyUiOiJBcml6b25hLCBWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9sb2NhdGlvbl9jaXR5JSI6IiIsIiVfd3BnbXBfbG9jYXRpb25fc3RhdGUlIjoiQXJpem9uYSIsIiVfd3BnbXBfbG9jYXRpb25fY291bnRyeSUiOiJWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9tZXRhYm94X2xhdGl0dWRlJSI6IjMyLjI5NjczNTkwMDAwMDAxIiwiJV93cGdtcF9tZXRhYm94X2xvbmdpdHVkZSUiOiItMTExLjE2NjYxNSIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiN1wiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6IiIsIiVfd3BnbXBfbWV0YWJveF90YXhvbW9taWVzX3Rlcm1zJSI6IiIsIiVfd3BnbXBfZXh0ZW5zaW9uc19maWVsZHMlIjoiIiwiJV95b2FzdF93cHNlb19lc3RpbWF0ZWQtcmVhZGluZy10aW1lLW1pbnV0ZXMlIjoiNSIsIiVfeW9hc3Rfd3BzZW9fcHJpbWFyeV9jYXRlZ29yeSUiOiIyMDQiLCIlX3d3c19zdXBwb3J0X2NvbnRhY3RfbnVtYmVyJSI6IiIsIiVfd3dzX2Fib3V0X3N1cHBvcnRfdGV4dCUiOiIiLCIlX3d3c190cmlnZ2VyX2J1dHRvbl90ZXh0JSI6IiIsIiVfd3dzX3ByZWRlZmluZWRfdGV4dCUiOiIiLCIlX3lvYXN0X3dwc2VvX3dvcmRwcm9vZl90aW1lc3RhbXAlIjoiIiwiJV95b2FzdF9pbmRleG5vd19sYXN0X3BpbmclIjoiMTY5NTYyNjI4MCIsIiVfbGFzdF9lZGl0b3JfdXNlZF9qZXRwYWNrJSI6ImNsYXNzaWMtZWRpdG9yIiwiJV93cF9vbGRfZGF0ZSUiOiIyMDIzLTA4LTE4IiwiJV93cF9vbGRfc2x1ZyUiOiJzYWd1YXJvLW5hdGlvbmFsLXBhcmsiLCJ0YXhvbm9teT1jYXRlZ29yeSI6IlNhZ3Vhcm8gTmF0aW9uYWwgUGFyayIsInRheG9ub215PXBvc3RfdGFnIjoiQXJpem9uYSIsInRheG9ub215PXBvc3RfZm9ybWF0IjoiIiwidGF4b25vbXk9dGhiLXJlYWN0aW9ucyI6IiIsInRheG9ub215PXRoYi1zcG9uc29ycyI6IiJ9fSwiaWQiOjE3NDc3LCJpbmZvd2luZG93X2Rpc2FibGUiOmZhbHNlfSx7InNvdXJjZSI6InBvc3QiLCJ0aXRsZSI6IkhhbGVha2FsYSBOYXRpb25hbCBQYXJrIiwiaW5mb3dpbmRvd19jb250ZW50IjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZyBcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiSGVsZWFrYWxhIE5hdGlvbmFsIFBhcmsgb3AgTWF1aVwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMy8wOS9oYWxlYWthbGEtbnAtMzAweDIwMC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmcgZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+SGFsZWFrYWxhIE5hdGlvbmFsIFBhcms8L2Rpdj5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tY29udGVudCBmYy1pdGVtLWJvZHktdGV4dC1jb2xvclwiPnttYXJrZXJfYWRkcmVzc308L2Rpdj5cclxuICAgICAgICA8L2Rpdj5cclxuICAgIDwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWNsZWFyXCI+PC9kaXY+XHJcbjwvZGl2PiIsImFkZHJlc3MiOiJIYXdhXHUwMGVmLCBWZXJlbmlnZGUgU3RhdGVuIiwibG9jYXRpb24iOnsibGF0IjoiMjAuNzIwMzgyNiIsInN0YXRlIjoiSGF3YVx1MDBlZiIsImNvdW50cnkiOiJWZXJlbmlnZGUgU3RhdGVuIiwibG5nIjoiLTE1Ni4xNTUxNTI0Iiwib25jbGlja19hY3Rpb24iOiJtYXJrZXIiLCJyZWRpcmVjdF9wZXJtYWxpbmsiOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL2hhbGVha2FsYS1uYXRpb25hbC1wYXJrLyIsInpvb20iOjEyLCJleHRyYV9maWVsZHMiOnsicG9zdF9leGNlcnB0IjoiIiwicG9zdF9jb250ZW50IjoiW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIl1bdmNfY29sdW1uIHdpZHRoPVwiMS8yXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjEwMCVcIl1bdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS8yXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJIZWxlYWthbGEgTmF0aW9uYWwgUGFya1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTozNXx0ZXh0X2FsaWduOmxlZnR8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdSGF3YWlpIGtlbmRlIGxhbmdlIHRpamQgbWFhciBcdTAwZTlcdTAwZTluIG5hdGlvbmFsIHBhcmsuIFZhbmFmIDE5NjEgd2VyZGVuIGhldCBIYWxlYWthbGEgTmF0aW9uYWwgUGFyayBlbiBoZXQgSGF3YWlpIFZvbGNhbm9lcyBOYXRpb25hbCBQYXJrIGdlc3BsaXRzdC4gT3AgemljaCBsb2dpc2NoLCB3YW50IGJlaWRlIHBhcmtlbiBsaWdnZW4gb3AgZWVuIGFuZGVyIGVpbGFuZC4gSGV0IEhhbGVha2FsYSBOYXRpb25hbCBQYXJrIGlzIHZlcm5vZW1kIG5hYXIgZGUgSGFsZWFrYWxhIHZ1bGthYW4gb3AgaGV0IGVpbGFuZCBNYXVpIGVuIGJlc2xhYXQgaGV0IGdyb290c3RlIGRlZWwgdmFuIGhldCBlaWxhbmQuIEVlbiBpbmRydWt3ZWtrZW5kIHZ1bGthbmlzY2ggbGFuZHNjaGFwIHdhYXIgamUgemVrZXIgbWV0IHpvbnNvcGtvbXN0IGVuIHpvbnNvbmRlcmdhbmcgZWVuIGtlZXIgbmFhciB0b2UgbW9ldC4gQWxsZSB0aXBzIHZvb3IgZWVuIGJlem9layBhYW4gaGV0IEhhbGVha2FsYSBOYXRpb25hbCBQYXJrLlsvdmNfY29sdW1uX3RleHRdW3VsdGltYXRlX2ljb25fbGlzdCBpY29uX3NpemU9XCIyMFwiXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtYXV0b21vYmlsZSBjYXJcIl00NSBraWxvbWV0ZXIgdmFuYWYgS2FodWx1aVsvdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy10cmVlXCJdPHNwYW4gY2xhc3M9XCJMcnpYciBrbm8tZnZcIj4xMzQsNiBrbVx1MDBiMiBvcHBlcnZsYWt0ZTwvc3Bhbj5bL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtcGF3XCJdR2VlbiBkaWVyZW4sIGFsbGVlbiB2ZXJzY2hpbGxlbmRlIHNvb3J0ZW4gdm9nZWxzWy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bL3VsdGltYXRlX2ljb25fbGlzdF1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIGNzcz1cIi52Y19jdXN0b21fMTYwODY2NjUxOTQ5MntiYWNrZ3JvdW5kLWNvbG9yOiAjZWFlYWVhICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMi8zXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIlZ1bGthYW4gSGFsZWFrYWxhXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjM1fHRleHRfYWxpZ246Y2VudGVyfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48cCBzdHlsZT1cInRleHQtYWxpZ246IGNlbnRlcjtcIj5EZSBuYWFtIEhhbGVha2FsYSB3ZXJkIHZyb2VnZXIgZG9vciBkZSBIYXdhaWlhbmVuIHRvZWdlcGFzdCBvcCBkZSBhbGdlbWVuZSBiZXJnIGVuIGJldGVrZW50IGh1aXMgdmFuIGRlIHpvbi4gSW4gZGUgSGF3YWlpYWFuc2UgZm9sa2xvcmUgd2FzIGRlIHRvcCB2YW4gZGUga3JhdGVyIGRlIHRodWlzYmFzaXMgdmFuIGRlIGdyb290bW9lZGVyIHZhbiBoYWxmZ29kIE1hdWkuIERlIGxlZ2VuZGUgdmVydGVsdCBkYXQgTWF1aSdzIGdyb290bW9lZGVyIGhlbSBoaWVscCBkZSB6b24gdGUgdmFuZ2VuIGVuIGhhYXIgdGUgZHdpbmdlbiBoYWFyIHJlaXMgZG9vciBkZSBsdWNodCB0ZSB2ZXJ0cmFnZW4gb20gZGUgZGFnIHRlIHZlcmxlbmdlbi48L3A+XHJcblsvdmNfY29sdW1uX3RleHRdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI3NXB4XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIiBmdWxsX3dpZHRoPVwic3RyZXRjaF9yb3dcIiBjb250ZW50X3RleHRfYWxpZ21lbnQ9XCJjZW50ZXJcIiBjc3M9XCIudmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9XCIgcGFyYWxsYXhfYmFja2dyb3VuZF9pbWFnZT1cIjM4MzZcIl1bdmNfY29sdW1uIHRoYl9jb2xvcj1cInRoYi1saWdodC1jb2x1bW5cIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJTbGlkaW5nIFNhbmRzIFRyYWlsIGluIEhhbGVha2FsYSBOYXRpb25hbCBQYXJrXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjc1fHRleHRfYWxpZ246Y2VudGVyfGNvbG9yOiUyM2ZmZmZmZnxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVtoZXl1c2FfaGVhZGluZyB0YWc9XCJoNFwiIHRleHRfYWxpZ249XCJjZW50ZXJcIiBoZWFkaW5nPVwiSW5kcnVrd2Vra2VuZGUgdHJhaWxcIiBmb250X3NpemU9XCI1MFwiIGxpbmVfaGVpZ2h0PVwiMVwiIGZvbnRfY29sb3I9XCIjZmZmZmZmXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3BhcmFsbGF4X3JvdyBlbmFibGVfbW9iaWxlPVwicGFyYWxsYXgtZW5hYmxlLW1vYmlsZVwiIGltYWdlPVwiMTczMjhcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiXVt2Y19jb2x1bW5dW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkZhY3RzIEhhbGVha2FsYSBOYXRpb25hbCBQYXJrXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjI1fHRleHRfYWxpZ246bGVmdFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdSGV0IEhhbGVha2FsYSBOYXRpb25hbCBQYXJrIGlzIHZlcm5vZW1kIG5hYXIgZGUgZ2VsaWprbmFtaWdlIHZ1bGthYW4gb3AgaGV0IGVpbGFuZCA8YSBocmVmPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93YXQtdGUtZG9lbi1vcC1tYXVpLWhhd2FpaS9cIj5NYXVpPC9hPiBpbiBIYXdhaWkuIERlIHNjaGlsZHZ1bGthYW4gYmVkZWt0IG1lZXIgZGFuIDc1JSB2YW4gaGV0IGhlbGUgZWlsYW5kIGVuIGhlZWZ0IGVlbiBob29ndGUgdmFuIDMwNTUgbWV0ZXIuIEhldCBpcyBpbm1pZGRlbHMgamFyZW4gZ2VsZWRlbiBkYXQgaGlqIGlzIHVpdGdlYmFyc3RlbiwgbmFhciBhbGxlIHdhYXJzY2hpam5saWpraGVpZCB3YXMgZGUgbGFhdHN0ZSB1aXRiYXJzdGluZyB0dXNzZW4gMTQ4MCBlbiAxNjAwLiBEYWFydm9vciB3YXMgZGUgdnVsa2FhbiBqYXJlbmxhbmcgYWN0aWVmIGVuIGtlbmRlIHRhbGxvemUgdWl0YmFyc3Rpbmdlbi4gRGUgdG9wIHZhbiBkZSB2dWxrYWFuIGlzIGVlbiBiZXppZW5zd2FhcmRpZ2hlaWQgb3AgemljaC4gVmFuYWYgaGllciBrdW4gamUgZGUga3JhdGVyIGluIHdhbmRlbGVuIGVuIGVyIHN0YWFuIGVlbiBhYW50YWwgdGVsZXNjb3BlbiB2YW53YWFyIGhldCBBbWVyaWthYW5zZSBtaW5pc3RlcmllIHZhbiBkZWZlbnNpZSBuYWFyIHNhdGVsbGlldGVuIGVuIHJha2V0dGVuIGtpamt0LiBEZSB0b3Aga3VuIGplIG1ldCBkZSBhdXRvIGJlcmVpa2VuLlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiV2F0IHRlIGRvZW4gaW4gSGFsZWFrYWxhIE5hdGlvbmFsIFBhcmtcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MjV8dGV4dF9hbGlnbjpsZWZ0XCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1IZXQgSGFsZWFrYWxhIE5hdGlvbmFsIFBhcmsga3VuIGplIHNwbGl0c2VuIGluIHR3ZWUgZ2VkZWVsdGVuOiBIZXQgU3VtbWl0IERpc3RyaWN0IGVuIGhldCBLaXBhaHVsdSBEaXN0cmljdC4gT25kZXIgaGV0IGVlcnN0ZSBkZWVsIHZhbGxlbiBkZSBrcmF0ZXJzIHZhbiBkZSB2dWxrYW5lbiwgaGV0IEtpcGFodWx1IGRpc3RyaWN0IGxpZ3QgbWVlciBpbiBoZXQgenVpZG9vc3RlbiB2YW4gTWF1aSBlbiBpcyBvbmRlcmRlZWwgdmFuIGRlIFJvYWQgdG8gSGFuYS4gRXIgaXMgZ2Vub2VnIHRlIGRvZW4gaW4gaGV0IEhhbGVha2FsYSBOYXRpb25hbCBQYXJrLiBFZW4gYWFudGFsIGFhbnJhZGVycyB6aWpuIEhvc21lcnMncyBHcm92ZSAoZWVuIHVuaWVrIGJvcyksIHN0ZXJyZW4ga2lqa2VuLCB6b25zb3Brb21zdCBlbiB6b25zb25kZXJnYW5nIG9wIGRlIEhhbGVha2FsYSBDcmF0ZXIsIE9oZSdPIEd1bGNoLCBXYWltb2t1IEZhbGxzLCBSZWQgSGlsbCAoaG9vZ3N0ZSBwdW50IE1hdWkpLCBLYWxhaGFrdSBvdmVybG9vayBlbiBkZSBMZWxlaXdpIG92ZXJsb29rLiBFciBsb3BlbiB2ZXJzY2hpbGxlbmRlIG1vb2llIHdhbmRlbGluZ2VuIGluIGhldCBnZWJpZWQsIGVlbiBnb2VkZSBtYW5pZXIgb20ga2VubmlzIHRlIG1ha2VuIG1ldCBoZXQgdnVsa2FuaXNjaCBsYW5kc2NoYXAgdmFuIGhldCBIYWxlYWthbGEgTmF0aW9uYWwgUGFyay5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiT3Zlcm5hY2h0ZW4gaW4gSGFsZWFrYWxhIE5hdGlvbmFsIFBhcmtcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MjV8dGV4dF9hbGlnbjpsZWZ0XCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1PdmVybmFjaHRlbiBpbiBoZXQgSGFsZWFrYWxhIE5hdGlvbmFsIFBhcmsgaXMgbmlldCBtb2dlbGlqay4gSmUgaGVidCByb25kb20gaGV0IHBhcmsgdmVyc2NoaWxsZW5kZSBvcHRpZXMgdm9vciBhY2NvbW1vZGF0aWVzLiBBYW4gZGUgenVpZGthbnQga3VubmVuIGRlIHBsZWtrZW4gPGEgaHJlZj1cImh0dHBzOi8vd3d3LmJvb2tpbmcuY29tL3NlYXJjaHJlc3VsdHMuZW4uaHRtbD9jaXR5PTIwMDMxMDQwJmFtcDthaWQ9Nzk1ODQ5OCZhbXA7bm9fcm9vbXM9MSZhbXA7Z3JvdXBfYWR1bHRzPTImYW1wO2xhYmVsPWhhbGVha2FsYW5hdGlvbmFscGFya2tpaGVpXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5LaWhlaTwvYT4gZW4gPGEgaHJlZj1cImh0dHBzOi8vd3d3LmJvb2tpbmcuY29tL3NlYXJjaHJlc3VsdHMuZW4uaHRtbD9jaXR5PTkwMDA0MDc5NCZhbXA7YWlkPTc5NTg0OTgmYW1wO25vX3Jvb21zPTEmYW1wO2dyb3VwX2FkdWx0cz0yJmFtcDtsYWJlbD1oYWxlYWthbGFuYXRpb25hbHBhcmt3YWlsZWFcIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPldhaWxlYTwvYT4gZ29lZGUgdWl0dmFsc2Jhc2lzc2VuIHppam4uIEVlbiBhbmRlcmUgbW9nZWxpamtoZWlkIGlzIGRlIHdlc3RrYW50IHZhbiBoZXQgSGFsZWFrYWxhIE5hdGlvbmFsIFBhcmssIGhpZXIgemlqbiA8YSBocmVmPVwiaHR0cHM6Ly93d3cuYm9va2luZy5jb20vc2VhcmNocmVzdWx0cy5lbi5odG1sP2NpdHk9MjAwMzEwNzMmYW1wO2FpZD03OTU4NDk4JmFtcDtub19yb29tcz0xJmFtcDtncm91cF9hZHVsdHM9MiZhbXA7bGFiZWw9aGFsZWFrYWxhbmF0aW9uYWxwYXJrbGFoYWluYVwiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+TGFoYWluYTwvYT4sIDxhIGhyZWY9XCJodHRwczovL3d3dy5ib29raW5nLmNvbS9zZWFyY2hyZXN1bHRzLmVuLmh0bWw/Y2l0eT0yMDAzMDkzNSZhbXA7YWlkPTc5NTg0OTgmYW1wO25vX3Jvb21zPTEmYW1wO2dyb3VwX2FkdWx0cz0yJmFtcDtsYWJlbD1oYWxlYWthbGFuYXRpb25hbHBhcmtrYWFuYXBhbGlcIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPkthYW5hcGFsaTwvYT4gZW4gPGEgaHJlZj1cImh0dHBzOi8vd3d3LmJvb2tpbmcuY29tL3NlYXJjaHJlc3VsdHMuZW4uaHRtbD9jaXR5PTIwMDMwOTg5JmFtcDthaWQ9Nzk1ODQ5OCZhbXA7bm9fcm9vbXM9MSZhbXA7Z3JvdXBfYWR1bHRzPTImYW1wO2xhYmVsPWhhbGVha2FsYW5hdGlvbmFscGFya2thcGFsdWFcIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPkthcGFsdWE8L2E+IG9wdGllcyBvbSB0ZSB2ZXJibGlqdmVuLlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiQmVzdGUgcmVpc3BlcmlvZGUgSGFsZWFrYWxhIE5hdGlvbmFsIFBhcmtcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MjV8dGV4dF9hbGlnbjpsZWZ0XCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1IZXQgSGFsZWFrYWxhIE5hdGlvbmFsIFBhcmsga3VuIGplIGhldCBoZWxlIGphYXIgYmV6b2VrZW4uIFR1c3NlbiBub3ZlbWJlciBlbiBhcHJpbCBpcyBoZXQgcmVnZW5zZWl6b2VuIGVuIGhlYiBqZSBtZWVyIGthbnMgb3AgYnVpZW4uIFZhbmFmIG1laSB0b3Qgb2t0b2JlciBpcyBoZXQgZHJvZ2VyLCBtYWFyIGlzIGhldCBkaXJlY3Qgb29rIGRydWtrZXIgaW4gaGV0IHBhcmsuIERlIGJlc3RlIHBlcmlvZGUgb20gaGV0IEhhbGVha2FsYSBOYXRpb25hbCBQYXJrIHRlIGJlem9la2VuIGlzIGluIGRlIG1hYW5kZW4gbWVpLCBzZXB0ZW1iZXIgZW4gb2t0b2Jlci5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIGNvbnRlbnRfcGxhY2VtZW50PVwibWlkZGxlXCIgZnVsbF93aWR0aD1cInN0cmV0Y2hfcm93XCIgY29udGVudF90ZXh0X2FsaWdtZW50PVwiY2VudGVyXCIgY3NzPVwiLnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fVwiIHBhcmFsbGF4X2JhY2tncm91bmRfaW1hZ2U9XCIzODM2XCJdW3ZjX2NvbHVtbiB0aGJfY29sb3I9XCJ0aGItbGlnaHQtY29sdW1uXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIlRyYWlscyBpbiBoZXQgSGFsZWFrYWxhIE5hdGlvbmFsIFBhcmtcIiBoZWFkaW5nX3RhZz1cInBcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjZmZmZmZmXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6NDVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDo1NXB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMTBweFwiXVtoZXl1c2FfaGVhZGluZyB0YWc9XCJoNFwiIHRleHRfYWxpZ249XCJjZW50ZXJcIiBoZWFkaW5nPVwiT250ZGVrIGhldCBwYXJrIG9wIFx1MDBlOVx1MDBlOW4gdmFuIGRlIHdhbmRlbHBhZGVuXCIgZm9udF9zaXplPVwiNTBcIiBsaW5lX2hlaWdodD1cIjFcIiBmb250X2NvbG9yPVwiI2ZmZmZmZlwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVtwYXJhbGxheF9yb3cgZW5hYmxlX21vYmlsZT1cInBhcmFsbGF4LWVuYWJsZS1tb2JpbGVcIiBpbWFnZT1cIjE3MzI3XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjc3M9XCIudmNfY3VzdG9tXzE2MDg2NjY4ODU0OTd7YmFja2dyb3VuZC1pbWFnZTogdXJsKGh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjAvMDgvYmFja2dyb3VuZC1oZXl1c2EtbmF0dXVyLTEuZ2lmP2lkPTMwODgpICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW5dW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiV2FuZGVsZW4gaW4gSGFsZWFrYWxhIE5hdGlvbmFsIFBhcmtcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMDAwMDAwXCIgYWxpZ25tZW50PVwibGVmdFwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NTVweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XUluIGhldCBIYWxlYWthbGEgTmF0aW9uYWwgUGFyayB6aWpuIGVyIHZlcnNjaGlsbGVuZGUgbW9nZWxpamtoZWRlbiBvbSB0ZSB3YW5kZWxlbi4gSW4gaGV0IFN1bW1pdCBEaXN0cmljdCB2aW5kIGplIDQ4IGtpbG9tZXRlciBhYW4gaGlraW5nIHRyYWlscywgdmFuIG1ha2tlbGlqa2Ugd2FuZGVsaW5nZW4gdG90IG1lZXJkYWFnc2Ugd2FuZGVsaW5nZW4uIERvb3JkYXQgamUgcmVkZWxpamsgb3AgaG9vZ3RlIHdhbmRlbHQsIGlzIGhldCBnb2VkIG9tIGhvb2d0ZXppZWt0ZSBpbiBkZSBnYXRlbiB0ZSBob3VkZW4uIE9vayBoZXQgd2VlciBlbiBkZSB0ZW1wZXJhdHV1ciBrdW5uZW4gaW5lZW5zIG9tc2xhYW4uIEVlbiBhYW50YWwgd2FuZGVsaW5nZW4gZGllIGRlIG1vZWl0ZSB3YWFyZCB6aWpuOlxyXG48dWw+XHJcbiBcdDxsaT5TbGlkaW5nIFNhbmRzIFRyYWlsOiBvbmdldmVlciAxNy0yMCBraWxvbWV0ZXI8L2xpPlxyXG4gXHQ8bGk+UGEgS2Enb2FvOiAwLDY0IGtpbG9tZXRlcjwvbGk+XHJcbiBcdDxsaT5Ib3NtZXIgR3JvdmU6IDAsODcga2lsb21ldGVyPC9saT5cclxuIFx0PGxpPkhhbGVtYXUndSBUcmFpbDogMyw2IGtpbG9tZXRlcjwvbGk+XHJcbiBcdDxsaT5QaXBpd2FpIFRyYWlsOiA2LDQga2lsb21ldGVyPC9saT5cclxuIFx0PGxpPkt1bG9hIFBvaW50IFRyYWlsOiAxLDIga2lsb21ldGVyPC9saT5cclxuPC91bD5cclxuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiSGFuZGlnZSBpbmZvIHZvb3IgamUgYmV6b2VrXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzAwMDAwMFwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OlJvYm90byBTbGFifGZvbnRfY2FsbDpSb2JvdG8rU2xhYnx2YXJpYW50OjgwMFwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NTVweDtcIiBtYWluX2hlYWRpbmdfc3R5bGU9XCJmb250LXdlaWdodDo4MDA7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt1bHRpbWF0ZV9pY29uX2xpc3QgaWNvbl9zaXplPVwiMjVcIl1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLWNsb2NrLW9cIiBjb250ZW50X2ZvbnRfc2l6ZT1cImRlc2t0b3A6MTZweDtcIl0yNC83IGVuIDM2NSBkYWdlbiBnZW9wZW5kXHJcblZvb3Igem9uc29wa29tc3Qgb3AgZGUgSGFsZWFrYWxhIGtyYXRlciBtb2V0IGplIDxhIGhyZWY9XCJodHRwczovL3d3dy5yZWNyZWF0aW9uLmdvdi90aWNrZXQvZmFjaWxpdHkvMjUzNzMxXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5yZXNlcnZlcmVuPC9hPlsvdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy10aHVtYnMtdXBcIiBjb250ZW50X2ZvbnRfc2l6ZT1cImRlc2t0b3A6MTZweDtcIl1CZXN0ZSBwZXJpb2RlOiBtZWksIHNlcHRlbWJlciwgb2t0b2JlclsvdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy1kb2xsYXIgdXNkXCIgY29udGVudF9mb250X3NpemU9XCJkZXNrdG9wOjE2cHg7XCJdJDMwWy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bL3VsdGltYXRlX2ljb25fbGlzdF1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIGNvbnRlbnRfcGxhY2VtZW50PVwibWlkZGxlXCIgZnVsbF93aWR0aD1cInN0cmV0Y2hfcm93XCIgY29udGVudF90ZXh0X2FsaWdtZW50PVwiY2VudGVyXCIgY3NzPVwiLnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fVwiIHBhcmFsbGF4X2JhY2tncm91bmRfaW1hZ2U9XCIzODM2XCJdW3ZjX2NvbHVtbiB0aGJfY29sb3I9XCJ0aGItbGlnaHQtY29sdW1uXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIk9oZSdPIEd1bGNoXCIgaGVhZGluZ190YWc9XCJwXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiI2ZmZmZmZlwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjQ1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NTVweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjEwcHhcIl1baGV5dXNhX2hlYWRpbmcgdGFnPVwiaDRcIiB0ZXh0X2FsaWduPVwiY2VudGVyXCIgaGVhZGluZz1cIlNldmVuIHNlY3JldCBwb29sc1wiIGZvbnRfc2l6ZT1cIjUwXCIgbGluZV9oZWlnaHQ9XCIxXCIgZm9udF9jb2xvcj1cIiNmZmZmZmZcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bcGFyYWxsYXhfcm93IGVuYWJsZV9tb2JpbGU9XCJwYXJhbGxheC1lbmFibGUtbW9iaWxlXCIgaW1hZ2U9XCIxNzMyNlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCJdW3ZjX2NvbHVtbl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiTWVlciBIYXdhaWlcIiBmb250X2NvbnRhaW5lcj1cInRhZzpkaXZ8Zm9udF9zaXplOjQwfHRleHRfYWxpZ246Y2VudGVyXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt0aGJfcG9zdGdyaWQgc3R5bGU9XCJzdHlsZTExXCIgY29sdW1ucz1cIjRcIiBzb3VyY2U9XCJwb3N0X3R5cGU6cG9zdHxieV9pZDotNDc5MiwtNDczOCwtNDcxNCwtNDY4OSwxNTA2MiwxNzMxOCwxNDkwNywxNDI1MFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XSIsInBvc3RfdGl0bGUiOiJIYWxlYWthbGEgTmF0aW9uYWwgUGFyayIsInBvc3RfbGluayI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvaGFsZWFrYWxhLW5hdGlvbmFsLXBhcmsvIiwicG9zdF9mZWF0dXJlZF9pbWFnZSI6IjxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiSGVsZWFrYWxhIE5hdGlvbmFsIFBhcmsgb3AgTWF1aVwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMy8wOS9oYWxlYWthbGEtbnAtMzAweDIwMC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj4iLCJwb3N0X2NhdGVnb3JpZXMiOiJIYWxlYWthbGEgTmF0aW9uYWwgUGFyayIsInBvc3RfdGFncyI6Ikhhd2FpaSIsIiVfd3BiX3Nob3J0Y29kZXNfY3VzdG9tX2NzcyUiOiIudmNfY3VzdG9tXzE2MDg2NjY1MTk0OTJ7YmFja2dyb3VuZC1jb2xvcjogI2VhZWFlYSAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTYwODY2Njg4NTQ5N3tiYWNrZ3JvdW5kLWltYWdlOiB1cmwoaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMC8wOC9iYWNrZ3JvdW5kLWhleXVzYS1uYXR1dXItMS5naWY/aWQ9MzA4OCkgIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fSIsIiVpbmxpbmVfZmVhdHVyZWRfaW1hZ2UlIjoiMCIsIiVfZWRpdF9sb2NrJSI6IjE2OTQ4NzM2NzM6MiIsIiVfZWRpdF9sYXN0JSI6IjIiLCIlX3RodW1ibmFpbF9pZCUiOiIxNzMxOSIsIiVfaGlkZV9mZWF0dXJlZCUiOm51bGwsIiVfd3BiX3ZjX2pzX3N0YXR1cyUiOiJ0cnVlIiwiJXBvc3QtcHJpbWFyeS1jYXRlZ29yeSUiOiJhdXRvIiwiJWZlYXR1cmVkX2ltYWdlX292ZXJyaWRlJSI6Im9mZiIsIiVhcnRpY2xlX3N0eWxlX292ZXJyaWRlJSI6Im9uIiwiJXBvc3Rfc3R5bGUlIjoic3R5bGUxMSIsIiVwb3N0X2dhbGxlcnlfc3R5bGUlIjoibGlnaHRib3giLCIlcG9zdF9yZXZpZXclIjoib2ZmIiwiJXBvc3RfcmV2aWV3X3N0eWxlJSI6InN0eWxlMSIsIiVwb3N0X3Jldmlld19hdmVyYWdlJSI6IjUwIiwiJV95b2FzdF93cHNlb19jb250ZW50X3Njb3JlJSI6IjMwIiwiJV95b2FzdF93cHNlb19mb2N1c2tleXdvcmRzJSI6IltdIiwiJV95b2FzdF93cHNlb19rZXl3b3Jkc3lub255bXMlIjoiW1wiXCJdIiwiJV95b2FzdF93cHNlb19mb2N1c2t3JSI6IkhhbGVha2FsYSBOYXRpb25hbCBQYXJrIiwiJV95b2FzdF93cHNlb19tZXRhZGVzYyUiOiJJbiBIYXdhaWkgbGlndCBoZXQgSGFsZWFrYWxhIE5hdGlvbmFsIFBhcmssIGVlbiBwYXJrIGJlc3RhYW5kIHVpdCBlZW4gdnVsa2FhbmxhbmRzY2hhcC4gVGlwcyB2b29yIGVlbiBiZXpvZWsgYWFuIGhldCBIYWxlYWthbGEgTmF0aW9uYWwgUGFyay4iLCIlX3lvYXN0X3dwc2VvX2xpbmtkZXglIjoiODQiLCIlX3dwZ21wX2xvY2F0aW9uX2FkZHJlc3MlIjoiSGF3YVx1MDBlZiwgVmVyZW5pZ2RlIFN0YXRlbiIsIiVfd3BnbXBfbG9jYXRpb25fY2l0eSUiOiIiLCIlX3dwZ21wX2xvY2F0aW9uX3N0YXRlJSI6Ikhhd2FcdTAwZWYiLCIlX3dwZ21wX2xvY2F0aW9uX2NvdW50cnklIjoiVmVyZW5pZ2RlIFN0YXRlbiIsIiVfd3BnbXBfbWV0YWJveF9sYXRpdHVkZSUiOiIyMC43MjAzODI2IiwiJV93cGdtcF9tZXRhYm94X2xvbmdpdHVkZSUiOiItMTU2LjE1NTE1MjQiLCIlX3dwZ21wX21ldGFib3hfbG9jYXRpb25fcmVkaXJlY3QlIjoibWFya2VyIiwiJV93cGdtcF9tZXRhYm94X2N1c3RvbV9saW5rJSI6IiIsIiVfd3BnbXBfbWFwX2lkJSI6ImE6MTp7aTowO3M6MTpcIjdcIjt9IiwiJV93cGdtcF9tZXRhYm94X21hcmtlcl9pZCUiOiIiLCIlX3dwZ21wX21ldGFib3hfdGF4b21vbWllc190ZXJtcyUiOiIiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6IiIsIiVfeW9hc3Rfd3BzZW9fZXN0aW1hdGVkLXJlYWRpbmctdGltZS1taW51dGVzJSI6IjUiLCIlX3lvYXN0X3dwc2VvX3ByaW1hcnlfY2F0ZWdvcnklIjoiMjMzIiwiJV93d3Nfc3VwcG9ydF9jb250YWN0X251bWJlciUiOiIiLCIlX3d3c19hYm91dF9zdXBwb3J0X3RleHQlIjoiIiwiJV93d3NfdHJpZ2dlcl9idXR0b25fdGV4dCUiOiIiLCIlX3d3c19wcmVkZWZpbmVkX3RleHQlIjoiIiwiJV95b2FzdF93cHNlb193b3JkcHJvb2ZfdGltZXN0YW1wJSI6IiIsIiVfeW9hc3RfaW5kZXhub3dfbGFzdF9waW5nJSI6IjE2OTQ4NzM3ODEiLCIlX2xhc3RfZWRpdG9yX3VzZWRfamV0cGFjayUiOiJjbGFzc2ljLWVkaXRvciIsIiVfd3Bfb2xkX2RhdGUlIjoiMjAyMy0wOC0xOCIsInRheG9ub215PWNhdGVnb3J5IjoiSGFsZWFrYWxhIE5hdGlvbmFsIFBhcmsiLCJ0YXhvbm9teT1wb3N0X3RhZyI6Ikhhd2FpaSIsInRheG9ub215PXBvc3RfZm9ybWF0IjoiIiwidGF4b25vbXk9dGhiLXJlYWN0aW9ucyI6IiIsInRheG9ub215PXRoYi1zcG9uc29ycyI6IiJ9fSwiaWQiOjE3NDAwLCJpbmZvd2luZG93X2Rpc2FibGUiOmZhbHNlfSx7InNvdXJjZSI6InBvc3QiLCJ0aXRsZSI6IlRpcHMgdm9vciBiZXppZW5zd2FhcmRpZ2hlZGVuIGluIEhvbm9sdWx1IiwiaW5mb3dpbmRvd19jb250ZW50IjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZyBcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiSG9ub2x1bHUgT2FodVwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMy8wOC9ob25vbHVsdS0zMDB4MjAwLmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmdcIj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZyBmYy1pdGVtLW5vLXBhZGRpbmdcIj5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tdGl0bGUgZmMtaXRlbS1wcmltYXJ5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2VcIj5UaXBzIHZvb3IgYmV6aWVuc3dhYXJkaWdoZWRlbiBpbiBIb25vbHVsdTwvZGl2PlxyXG4gICAgICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1jb250ZW50IGZjLWl0ZW0tYm9keS10ZXh0LWNvbG9yXCI+e21hcmtlcl9hZGRyZXNzfTwvZGl2PlxyXG4gICAgICAgIDwvZGl2PlxyXG4gICAgPC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtY2xlYXJcIj48L2Rpdj5cclxuPC9kaXY+IiwiYWRkcmVzcyI6IlNhbmliZWwgSXNsYW5kLCBGbG9yaWRhLCBWZXJlbmlnZGUgU3RhdGVuIiwibG9jYXRpb24iOnsibGF0IjoiMjYuNDQzMzk3MiIsInN0YXRlIjoiRmxvcmlkYSIsImNvdW50cnkiOiJWZXJlbmlnZGUgU3RhdGVuIiwibG5nIjoiLTgyLjExMTUxMTkiLCJvbmNsaWNrX2FjdGlvbiI6Im1hcmtlciIsInJlZGlyZWN0X3Blcm1hbGluayI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvYmV6aWVuc3dhYXJkaWdoZWRlbi1ob25vbHVsdS8iLCJ6b29tIjoxMiwiZXh0cmFfZmllbGRzIjp7InBvc3RfZXhjZXJwdCI6IiIsInBvc3RfY29udGVudCI6Ilt2Y19yb3ddW3ZjX2NvbHVtbl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjI1cHhcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMjVweFwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIkJlemllbnN3YWFyZGlnaGVkZW4gaW4gSG9ub2x1bHVcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMjgyODI4XCIgYWxpZ25tZW50PVwibGVmdFwiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6MzBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XUhldCBlaWxhbmQgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd2F0LXRlLWRvZW4tb2FodS1oYXdhaWkvXCI+PHN0cm9uZz5PYWh1PC9zdHJvbmc+PC9hPiBiZXN0YWF0IHVpdCA1IHZlcnNjaGlsbGVuZGUgcmVnaW8ncywgXHUwMGU5XHUwMGU5biBkYWFydmFuIGlzIEhvbm9sdWx1LiBIb25vbHVsdSBpcyBkZSBob29mZHN0YWQgdmFuIGRlIHN0YWF0IDxhIGhyZWY9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL2hhd2FpaS9cIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPkhhd2FpaTwvYT4gZW4gZGFhcm5hYXN0IG9vayBkZSBncm9vdHN0ZSBzdGFkIHZhbiBIYXdhaWkuIEhldCBpcyBlZW4gYnJ1aXNlbmRlIHN0YWQgbWV0IHZlZWwgcmVzdGF1cmFudHMsIGhpc3RvcmlzY2hlIHBsYWF0c2VuLCBtdXNlYSwgYmV6aWVuc3dhYXJkaWdoZWRlbiwgd2lua2VscyBlbiB6ZWxmcyBkZSBuYXR1dXIgaXMgbm9vaXQgdmVyIHdlZy4gRGVuayBhYW4gc3VyZmVuIG9wIFdhaWtpa2kgQmVhY2gsIHdhbmRlbGVuIGJpaiBEaWFtb25kIEhlYWQgb2Ygc25vcmtlbGVuIGluIEhhbmF1bWEgQmF5LiBIb25vbHVsdSBpcyBkZSBwZXJmZWN0ZSBwbGVrIHZvb3IgZGUgc3RhcnQgdmFuIGplIHJlaXMgb3AgSGF3YWlpLjxzdHJvbmc+XHJcbjwvc3Ryb25nPlsvdmNfY29sdW1uX3RleHRdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IGNzcz1cIi52Y19jdXN0b21fMTQ3MjMwNzUwMjI5MHtwYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O3BhZGRpbmctYm90dG9tOiAyNXB4ICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW5dW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI3NXB4XCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiVGlwcyB2b29yIGJlemllbnN3YWFyZGlnaGVkZW4gaW4gSG9ub2x1bHVcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjYjM0YTRjXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6NTVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDo2MHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNzVweFwiXVt2Y19yb3dfaW5uZXIgY3NzPVwiLnZjX2N1c3RvbV8xNTgyOTcwNzA0OTAze3BhZGRpbmctdG9wOiAxMHB4ICFpbXBvcnRhbnQ7cGFkZGluZy1yaWdodDogMTBweCAhaW1wb3J0YW50O3BhZGRpbmctYm90dG9tOiAxMHB4ICFpbXBvcnRhbnQ7cGFkZGluZy1sZWZ0OiAxMHB4ICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzNcIl1bdmNfc2luZ2xlX2ltYWdlIGltYWdlPVwiMTczMTZcIiBpbWdfc2l6ZT1cImxhcmdlXCIgYWRkX2NhcHRpb249XCJ5ZXNcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJMb2xhbmkgUGFsYWNlXCIgaGVhZGluZ190YWc9XCJoM1wiIG1haW5faGVhZGluZ19jb2xvcj1cIiMyODI4MjhcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjMwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF1cclxuPHAgc3R5bGU9XCJ0ZXh0LWFsaWduOiBjZW50ZXI7XCI+RVx1MDBlOW4ga29uaW5rbGlqayBwYWxlaXMgaXMgZXIgdGUgdmluZGVuIGluIEFtZXJpa2EgZW4gZGllIHN0YWF0IGluIEhvbm9sdWx1LiBIZXQgSW9sYW5pIHBhbGVpcyB3YXMgZGUgdm9vcm1hbGlnZSByZXNpZGVudGllIHZhbiBoZXQgc3RhYXRzaG9vZmQgdmFuIEhhd2FpaSB1aXQgZGUgdGlqZCBkYXQgSGF3YWlpIG5vZyBlZW4ga29uaW5nIGhhZC4gS2FsYWthdWEgd2FzIGRlIGVlcnN0ZSBrb25pbmcgaW4gMTg3OSwgZGUgbGFhdHN0ZSB3YXMga29uaW5naW4gTGlsaXVva2FsYW5pIGluIDE4OTMuIEplIGt1bnQgaGV0IHBhbGVpcyBiZXpvZWtlbiwgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmlvbGFuaXBhbGFjZS5vcmcvdmlzaXQvXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5yZXNlcnZlcmVuPC9hPiBpcyBhYW4gdGUgcmFkZW4uPC9wPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzNcIl1bdmNfc2luZ2xlX2ltYWdlIGltYWdlPVwiNjcxNlwiIGltZ19zaXplPVwibGFyZ2VcIiBhZGRfY2FwdGlvbj1cInllc1wiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIkhhbmF1bWEgQmF5IE5hdHVyZSBQcmVzZXJ2ZVwiIGhlYWRpbmdfdGFnPVwiaDNcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMjgyODI4XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozMHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdXHJcbjxwIHN0eWxlPVwidGV4dC1hbGlnbjogY2VudGVyO1wiPkhhbmF1bWEgQmF5IGlzIGRlIHBlcmZlY3RlIGVzY2FwZSBpbiBkZSBidXVydCB2YW4gSG9ub2x1bHUgb20gdGUgcmVsYXhlbiBvcCBoZXQgc3RyYW5kLiBEZSBrdXN0IGJlc3RhYXQgdWl0IHJlZGVsaWprIG9uZGllcCB3YXRlciBlbiBpcyBkYWFyZG9vciBvb2sgZ2VzY2hpa3Qgb20gdGUgc25vcmtlbGVuLiBFciB6d2VtbWVuIHRyb3Bpc2NoZSB2aXNzZW4gbmlldCB2ZXIgdWl0IGRlIGt1c3QuIEhhbmF1bWEgQmF5IGlzIGFsbGVlbiBwZXIgYXV0byBvZiB1YmVyIHRlIGJlem9la2VuLCBlciBnYWFuIGdlZW4gdG91cmJ1c3NlbiBkaWUga2FudCBvcC4gT21kYXQgaGV0IHN0YXRlIHBhcmsgaXMsIGRpZW4gamUgPGEgaHJlZj1cImh0dHBzOi8vcHJvczYuaG5sLmluZm8vXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj50aWNrZXRzIHRlIGtvcGVuIChlbiByZXNlcnZlcmVuKTwvYT4gdm9vciBkZSBwYXJrZWVycGxhYXRzLjwvcD5cclxuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8zXCJdW3ZjX3NpbmdsZV9pbWFnZSBpbWFnZT1cIjE3Mjg5XCIgaW1nX3NpemU9XCJsYXJnZVwiIGFkZF9jYXB0aW9uPVwieWVzXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiTWFrYXB1J3UgUG9pbnQgTGlnaHRob3VzZSB0cmFpbFwiIGhlYWRpbmdfdGFnPVwiaDNcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMjgyODI4XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozMHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdXHJcbjxwIHN0eWxlPVwidGV4dC1hbGlnbjogY2VudGVyO1wiPk9tIGhldCBNYWthcHUndSBQb2ludCBMaWdodGhvdXNlIHRlIGJlcmVpa2VuLCBrdW4gamUgZGUgMyBraWxvbWV0ZXIgbGFuZ2UgTWFrYXB1J3UgUG9pbnQgTGlnaHRob3VzZSBUcmFpbCB3YW5kZWxlbi4gRWVuIHJlbGF0aWVmIG1ha2tlbGlqa2Ugcm91dGUgd2FhcmJpaiBqZSBvbmRlcndlZyBrYW5zIGhlYnQgb20gd2Fsdmlzc2VuIHRlIHppZW4gKHR1c3NlbiBub3ZlbWJlciBlbiBtZWkpLiBEZSB2dXVydG9yZW4gd2VyZCBpbiAxOTA5IGdlYm91d2QuIE5pZXQgYWxsZWVuIG9uZGVyd2VnLCBtYWFyIG9vayBoaWVyIGhlYiBqZSBlZW4gZ29lZCB1aXR6aWNodCBvcCBkZSBvY2VhYW4uPC9wPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVt2Y19yb3dfaW5uZXIgY3NzPVwiLnZjX2N1c3RvbV8xNTgyOTcwNzA0OTAze3BhZGRpbmctdG9wOiAxMHB4ICFpbXBvcnRhbnQ7cGFkZGluZy1yaWdodDogMTBweCAhaW1wb3J0YW50O3BhZGRpbmctYm90dG9tOiAxMHB4ICFpbXBvcnRhbnQ7cGFkZGluZy1sZWZ0OiAxMHB4ICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzNcIl1bdmNfc2luZ2xlX2ltYWdlIGltYWdlPVwiMTAwMTlcIiBpbWdfc2l6ZT1cImxhcmdlXCIgYWRkX2NhcHRpb249XCJ5ZXNcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJLb2tvIENyYXRlciBUcmFpbFwiIGhlYWRpbmdfdGFnPVwiaDNcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMjgyODI4XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozMHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdXHJcbjxwIHN0eWxlPVwidGV4dC1hbGlnbjogY2VudGVyO1wiPkRlIEtva28gQ3JhdGVyIFRyYWlsIGlzIGVlbiB0cmFpbCB2YW4gb25nZXZlZXIgNSBraWxvbWV0ZXIgbmFhciBkZSB0b3AgdmFuIGRlIEtva28gSGVhZCBDcmF0ZXIuIEVlbiByb3V0ZSBsYW5ncyBtZWVyIGRhbiAxMDAwIHRyZWRlbiBkaWUgZ2VtYWFrdCB6aWpuIHZhbiBvdWRlIHNwb29yYmllbHplbi4gT3AgZGUgdG9wIHZhbiBoZXQgcGFkIGtyaWpnIGplIGVlbiBwYW5vcmFtaXNjaCB1aXR6aWNodCBvcCBoZXQgSGFuYXVtYSBCYXkgTmF0dXJlIFByZXNlcnZlIGVuIERpYW1vbmQgSGVhZCBTdGF0ZSBNb251bWVudC4gWm9yZyBkYXQgamUgZ29lZCB2b29yYmVyZWlkIG9wIHBhZCBnYWF0IG1ldCBnb2VkZSBzY2hvZW5lbiBlbiB2b2xkb2VuZGUgd2F0ZXIuIFdpbCBqZSBlY2h0IGRlIHVsdGllbWUgZXJ2YXJpbmc/IEtvbSBkYW4gdm9vciAwNS4wMCB1dXIgYmlqIGRlIHRyYWlsIG9tIGdlZW4gbGFzdCB0ZSBoZWJiZW4gdmFuIGRlIGhpdHRlIGVuIGRlIHpvbiB6aWVuIG9wa29tZW4uIE5lZW0gd2VsIGVlbiBob29mZGxhbXAgbWVlIGFscyBqZSBkaXQgZ2FhdCBkb2VuLjwvcD5cclxuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8zXCJdW3ZjX3NpbmdsZV9pbWFnZSBpbWFnZT1cIjE3MzE1XCIgaW1nX3NpemU9XCJsYXJnZVwiIGFkZF9jYXB0aW9uPVwieWVzXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiQmlzaG9wIE11c2V1bVwiIGhlYWRpbmdfdGFnPVwiaDNcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMjgyODI4XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozMHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdXHJcbjxwIHN0eWxlPVwidGV4dC1hbGlnbjogY2VudGVyO1wiPkN1bHR1dXItIGVuIGdlc2NoaWVkZW5pc2xpZWZoZWJiZXJzIGt1bm5lbiBlZW4gYmV6b2VrIGJyZW5nZW4gYWFuIGhldCBCaXNob3AgTXVzZXVtIGluIEhvbm9sdWx1LiBIZXQgaXMgZWVuIG11c2V1bSB2b29yIGdlc2NoaWVkZW5pcyBlbiB3ZXRlbnNjaGFwIGVuIGRlIGdyb290c3RlIG9wIEhhd2FpaS4gSmUgdmluZHQgZXIgZWVuIGVub3JtZSBjb2xsZWN0ZSBQb2x5bmVzaXNjaGUgY3VsdHVyZWxlIGFydGVmYWN0ZW4gZW4gbmF0dXVyaGlzdG9yaXNjaGUgYmV6aWVuc3dhYXJkaWdoZWRlbi4gRGFhcm5hYXN0IGt1biBqZSBtZWVyIHRlIHdldGVuIGtvbWVuIG92ZXIgZGUgSGF3YWlpYWFuc2UgY3VsdHV1ci48L3A+XHJcblsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvM1wiXVt2Y19zaW5nbGVfaW1hZ2UgaW1hZ2U9XCIxMDAxOVwiIGltZ19zaXplPVwibGFyZ2VcIiBhZGRfY2FwdGlvbj1cInllc1wiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIk1hbm9hIEZhbGxzXCIgaGVhZGluZ190YWc9XCJoM1wiIG1haW5faGVhZGluZ19jb2xvcj1cIiMyODI4MjhcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjMwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF1cclxuPHAgc3R5bGU9XCJ0ZXh0LWFsaWduOiBjZW50ZXI7XCI+T3Agb25nZXZlZXIgOCBraWxvbWV0ZXIgdGVuIG5vb3Jkb29zdGVuIHZhbiBIb25vbHVsdSBsaWd0IGRlIE1hbm9hIEZhbGxzLiBEZSA0NSBtZXRlciBob2dlIHdhdGVydmFsIGlzIG1ha2tlbGlqayB0ZSBiZXJlaWtlbiwgZGUgdHJhaWwgZXIgbmFhciB0b2UgaXMgb25nZXZlZXIgMSw1IGtpbG9tZXRlci4gVG9jaCBpcyBhYW4gdGUgcmFkZW4gZ29lZGUgc2Nob2VuZW4gYWFuIHRlIGRvZW4sIGhldCBwYWQga2FuIG5hbWVsaWprIGdsYWQgemlqbi4gSmUgd2FuZGVsdCBkb29yIGVlbiByZWdlbndvdWQgbGFuZHNjaGFwIHdhYXIgb29rIGVua2VsZSBzY2VuZXMgdmFuIEp1cmFzc2ljIFBhcmsgemlqbiBvcGdlbm9tZW4uIE9tIGRlIGRydWt0ZSB0ZSB2ZXJtaWpkZW4gcmFkZW4gd2UgYWFuIG9tIHZvb3IgMTAuMDAgdXVyIHRlIGtvbWVuLiBFciBpcyBnZWVuIHRvZWdhbmdzcHJpanMsIG1hYXIgamUgZGllbnQgd2VsIHBhcmtlZXJnZWxkIHRlIGJldGFsZW4uIEplIGt1bnQgb29rIG1ldCBidXMgNSBuYWFyIGRlIHdhdGVydmFsbGVuLjwvcD5cclxuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNzVweFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIiBmdWxsX3dpZHRoPVwic3RyZXRjaF9yb3dcIiBjb250ZW50X3RleHRfYWxpZ21lbnQ9XCJjZW50ZXJcIiBjc3M9XCIudmNfY3VzdG9tXzE1ODc2NTkyOTkwNzF7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDtiYWNrZ3JvdW5kLWNvbG9yOiAjMDAwMDAwICFpbXBvcnRhbnQ7fVwiIHBhcmFsbGF4X2JhY2tncm91bmRfaW1hZ2U9XCIzODM2XCJdW3ZjX2NvbHVtbiB0aGJfY29sb3I9XCJ0aGItbGlnaHQtY29sdW1uXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIldhaWtpa2kgQmVhY2ggZW4gRGlhbW9uZCBIZWFkXCIgaGVhZGluZ190YWc9XCJwXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiI2ZmZmZmZlwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjY1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NzBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW2hleXVzYV9oZWFkaW5nIHRhZz1cImRpdlwiIHRleHRfYWxpZ249XCJjZW50ZXJcIiBoZWFkaW5nPVwiVHdlZSBwdWJsaWVrc3RyZWtrZXJzXCIgZm9udF9zaXplPVwiNTBcIiBsaW5lX2hlaWdodD1cIjUwXCIgZm9udF9jb2xvcj1cIiNmZmZmZmZcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bcGFyYWxsYXhfcm93IG9wYWNpdHk9XCI4NVwiIGVuYWJsZV9tb2JpbGU9XCJwYXJhbGxheC1lbmFibGUtbW9iaWxlXCIgaW1hZ2U9XCIxNzM5MlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgdGhiX3Jvd19wYWRkaW5nPVwidHJ1ZVwiIHRoYl9jb2x1bW5fcGFkZGluZz1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMjVweFwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjUvNlwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiUGVhcmwgSGFyYm9yXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjMwfHRleHRfYWxpZ246bGVmdHxjb2xvcjolMjMyODI4Mjh8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1baGV5dXNhX2hlYWRpbmcgdGFnPVwiZGl2XCIgaGVhZGluZz1cIlN0dWtqZSBnZXNjaGllZGVuaXNcIiBmb250X3NpemU9XCI0MFwiIGxpbmVfaGVpZ2h0PVwiNDBcIiBmb250X2NvbG9yPVwiIzI4MjgyOFwiXVt2Y19jb2x1bW5fdGV4dF1cclxuPHAgc3R5bGU9XCJ0ZXh0LWFsaWduOiBsZWZ0O1wiPkhvZXdlbCBoZXQgaWV0cyB1aXQgZGUgYnV1cnQgdmFuIEhvbm9sdWx1IGxpZ3QsIGlzIGhldCA8YSBocmVmPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9wZWFybC1oYXJib3IvXCI+UGVhcmwgSGFyYm9yPC9hPiBOYXRpb25hbCBNZW1vcmlhbCBhYW4gdGUgcmFkZW4gb20gdGUgYmV6b2VrZW4uIEplIHZpbmR0IGVyIGhldCBVU1MgQXJpem9uYSBNZW1vcmlhbCwgZWVuIGxhYXRzdGUgcnVzdHBsYWF0cyB2b29yIG1lZXIgZGFuIDkwMCBtYXRyb3plbiBlbiBtYXJpbmllcnMgZGllIG9tZ2Vrb21lbiB6aWpuIHRpamRlbnMgZGUgYWFudmFsIG9wIFBlYXJsIEhhcmJvci4gT3AgNyBkZWNlbWJlciAxOTQxIHdlcmQgZGUgYmFzaXMgYWFuZ2V2YWxsZW4gZG9vciBKYXBhbnNlIHZsaWVndHVpZ2VuLiBFZW4gZ2V6b25rZW4gc2xhZ3NjaGlwIGhlcmlubmVydCBhYW4gZGUgYWFudmFsLiBFZW4gYmV6b2VrIGFhbiBkZSBVU1MgQXJpem9uYSBNZW1vcmlhbCBpcyBncmF0aXMsIG1hYXIgamUgZGllbnQgdmFuIHRlIHZvcmVuIGVlbiB0aWpkc2xvdCB0ZSByZXNlcnZlcmVuLjwvcD5cclxuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvMlwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIyNXB4XCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjEwMCVcIl1bdGhiX2ltYWdlIHJldGluYT1cInJldGluYV9zaXplXCIgZnVsbF93aWR0aD1cInRydWVcIiBpbWFnZT1cIjE0MzA0XCJdWy90aGJfaW1hZ2VdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiB0aGJfcm93X3BhZGRpbmc9XCJ0cnVlXCIgdGhiX2NvbHVtbl9wYWRkaW5nPVwidHJ1ZVwiIGNvbnRlbnRfcGxhY2VtZW50PVwibWlkZGxlXCJdW3ZjX2NvbHVtbiB3aWR0aD1cIjEvMlwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCIxMDAlXCJdW3RoYl9pbWFnZSByZXRpbmE9XCJyZXRpbmFfc2l6ZVwiIGZ1bGxfd2lkdGg9XCJ0cnVlXCIgaW1hZ2U9XCIxNTI1NlwiXVsvdGhiX2ltYWdlXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvMlwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjUvNlwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiV2Fpa2lraSBCZWFjaFwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgzfGZvbnRfc2l6ZTozMHx0ZXh0X2FsaWduOmxlZnR8Y29sb3I6JTIzMjgyODI4fGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW2hleXVzYV9oZWFkaW5nIHRhZz1cImRpdlwiIGhlYWRpbmc9XCJUcm9waXNjaCBwYXJhZGlqc1wiIGZvbnRfc2l6ZT1cIjQwXCIgbGluZV9oZWlnaHQ9XCI0MFwiIGZvbnRfY29sb3I9XCIjMjgyODI4XCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48cCBzdHlsZT1cInRleHQtYWxpZ246IGxlZnQ7XCI+RGUgd2lqayBXYWlraWtpIGluIEhvbm9sdWx1IGlzIGFsIGphcmVuIGVlbiBnZWxpZWZkZSBwbGVrLiBEZSByZWRlbj8gSGV0IHByYWNodGlnZSBzdHJhbmQgZGF0IGlubWlkZGVscyB3ZXJlbGRiZXJvZW1kIGlzLiBKZSB2aW5kdCBlciB6YWNodGUgemFuZHN0cmFuZGVuIGVuIGhvZ2UgZ29sdmVuIHRpamRlbnMgZGUgd2ludGVybWFhbmRlbi4gVm9vciBzdXJmZXJzIGVlbiB3YWxoYWxsYSBlbiBvbSB0ZSBzbm9ya2VsZW4gaXMgV2Fpa2lraSBwZXJmZWN0LCBtYWFyIG9vayB2b29yIG1lbnNlbiBkaWUgZXIga29tZW4gb20gdGUgb250c3Bhbm5lbi4gR3JlbnplbmQgYWFuIFdhaWtpa2kgQmVhY2ggbGlnZ2VuIHRhbCB2YW4gcmVzdGF1cmFudHMgZW4gd2lua2Vscy4gRGFhcm5hYXN0IGtpamtlbiB2ZWxlIGhvdGVscyB1aXQgb3AgV2Fpa2lraSBCZWFjaC48L3A+XHJcblsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIiBjc3M9XCIudmNfY3VzdG9tXzE2ODk5NTYyODA3MzF7cGFkZGluZy10b3A6IDUwcHggIWltcG9ydGFudDtwYWRkaW5nLWJvdHRvbTogNTBweCAhaW1wb3J0YW50O2JhY2tncm91bmQtaW1hZ2U6IHVybChodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIxLzA4L2FsbC1kYXktdXNhLWJhY2tncm91bmQuZ2lmP2lkPTg0MDgpICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMi8zXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW2hleXVzYV9oZWFkaW5nIHRhZz1cImRpdlwiIGhlYWRpbmc9XCJIYW5kaWdlIGluZm8gdmFuIGRlIHJlZGFjdGllXCIgZm9udF9zaXplPVwiNDNcIiBsaW5lX2hlaWdodD1cIjQ1XCIgZm9udF9jb2xvcj1cIiNiMzRhNGNcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkVzc2VudGlcdTAwZWJsZSB0aXBzIHZvb3IgcmVpemVuIG5hYXIgSG9ub2x1bHU6XCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDN8Zm9udF9zaXplOjI1fHRleHRfYWxpZ246bGVmdHxjb2xvcjolMjMyODI4Mjh8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OlJvYm90byUyMFNsYWIlM0ExMDAlMkMzMDAlMkNyZWd1bGFyJTJDNzAwfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19yb3dfaW5uZXIgYm94X3NoYWRvdz1cImxhcmdlLXNoYWRvd1wiIGNzcz1cIi52Y19jdXN0b21fMTY4OTk1NTQ4NjA4N3tiYWNrZ3JvdW5kLWNvbG9yOiAjZmZmZmZmICFpbXBvcnRhbnQ7Ym9yZGVyLXJhZGl1czogMTBweCAhaW1wb3J0YW50O31cIl1bdmNfY29sdW1uX2lubmVyXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIyNXB4XCJdW3VsdGltYXRlX2ljb25fbGlzdCBpY29uX3NpemU9XCI2NVwiIGljb25fbWFyZ2luPVwiMTBcIl1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbl90eXBlPVwiY3VzdG9tXCIgaWNvbl9pbWc9XCJpZF4xNjc1OHx1cmxeaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMy8wNy9oZXl1c2EtZXhwZXJ0LXRpcC5wbmd8Y2FwdGlvbl5IZXkhVVNBIEV4cGVydCBUaXAgb3ZlciByZWl6ZW4gbmFhciBBbWVyaWthfGFsdF5IZXkhVVNBIEV4cGVydCBUaXAgb3ZlciByZWl6ZW4gbmFhciBBbWVyaWthfHRpdGxlXkhleSFVU0EgRXhwZXJ0IFRpcCBvdmVyIHJlaXplbiBuYWFyIEFtZXJpa2F8ZGVzY3JpcHRpb25eSGV5IVVTQSBFeHBlcnQgVGlwIG92ZXIgcmVpemVuIG5hYXIgQW1lcmlrYVwiIGNvbnRlbnRfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgY29udGVudF9mb250X3NpemU9XCJkZXNrdG9wOjI1cHg7XCIgY29udGVudF9mb250X2NvbG9yPVwiIzI4MjgyOFwiXUhleSFVU0FcclxucGVyc29vbmxpamtlIHRpcHM6Wy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bL3VsdGltYXRlX2ljb25fbGlzdF1bdmNfY29sdW1uX3RleHRdXHJcbjx1bD5cclxuIFx0PGxpPkhvZSBsYW5nIHZlcmJsaWp2ZW4/IDM8ZW0+XHUwMGEwdm9sbGUgZGFnZW48L2VtPjwvbGk+XHJcbiBcdDxsaT5BdXRvIG5vZGlnP1x1MDBhMDxlbT48YSBocmVmPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9hdXRvLWh1cmVuLWluLWFtZXJpa2EvXCI+SHV1cmF1dG88L2E+IGlzIG5vb2R6YWtlbGlqazwvZW0+PC9saT5cclxuIFx0PGxpPkJlc3RlIHBlcmlvZGU/IDxlbT5UdXNzZW4gbWlkZGVuIGFwcmlsIGVuIGJlZ2luIGp1bmkgZW4gdHVzc2VuIHNlcHRlbWJlciBlbiBtaWRkZW4gZGVjZW1iZXI8L2VtPjwvbGk+XHJcbiBcdDxsaT5EcnVrc3RlIG1hYW5kZW4/IDxlbT5NaWRkZW4gZGVjZW1iZXIgdG90IG1hYXJ0PC9lbT48L2xpPlxyXG4gXHQ8bGk+V2FybXN0ZSBtYWFuZD8gPGVtPkF1Z3VzdHVzPC9lbT48L2xpPlxyXG4gXHQ8bGk+TWVlc3RlIHJlZ2VuPyA8ZW0+Tm92ZW1iZXIsIGRlY2VtYmVyIGVuIGphbnVhcmk8L2VtPjwvbGk+XHJcbiBcdDxsaT5Ib3RlbCBhYW5iZXZlbGluZ2VuOiA8YSBocmVmPVwiaHR0cHM6Ly93d3cuYm9va2luZy5jb20vaG90ZWwvdXMvaGFsZWt1bGFuaS5lbi5odG1sP2FpZD03OTU4NDk4JmFtcDtub19yb29tcz0xJmFtcDtncm91cF9hZHVsdHM9MiZhbXA7bGFiZWw9SG9ub2x1bHVoYWxla3VsYW5pXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5IYWxla3VsYW5pPC9hPiB8PGEgaHJlZj1cImh0dHBzOi8vd3d3LmJvb2tpbmcuY29tL2hvdGVsL3VzL3RoZS1rYWhhbGEtYW5kLXJlc29ydC5lbi5odG1sP2FpZD03OTU4NDk4JmFtcDtub19yb29tcz0xJmFtcDtncm91cF9hZHVsdHM9MiZhbXA7bGFiZWw9SG9ub2x1bHVrYWhhbGFyZXNvcnRcIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPkthaGFsYSBIb3RlbCAmYW1wOyBSZXNvcnQ8L2E+IHwgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmJvb2tpbmcuY29tL2hvdGVsL3VzL2hhd2FpaS1wcmljZS13YWlraWtpLmVuLmh0bWw/YWlkPTc5NTg0OTgmYW1wO25vX3Jvb21zPTEmYW1wO2dyb3VwX2FkdWx0cz0yJmFtcDtsYWJlbD1Ib25vbHVsdXByaW5jZXdhaWtpa2lcIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPlByaW5jZSBXYWlraWtpPC9hPjwvbGk+XHJcbjwvdWw+XHJcblsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIk1lZXIgSGF3YWlpXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzI4MjgyOFwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjQ1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NTBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bZnVsbHdpZHRoX3Jvd11bdGhiX3Bvc3RncmlkIGNvbHVtbnM9XCI0XCIgc291cmNlPVwicG9zdF90eXBlOnBvc3R8YnlfaWQ6LTE2NTA3LC0xNjQwMCwtMTYzNDIsLTE2MTc0LC0xNTM1NSwtMTUxNjMsLTQ3MjUsLTE1NTksMTcyODQsMTQ5MDcsMTUyNDksMTQyNTBcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd10iLCJwb3N0X3RpdGxlIjoiVGlwcyB2b29yIGJlemllbnN3YWFyZGlnaGVkZW4gaW4gSG9ub2x1bHUiLCJwb3N0X2xpbmsiOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL2JlemllbnN3YWFyZGlnaGVkZW4taG9ub2x1bHUvIiwicG9zdF9mZWF0dXJlZF9pbWFnZSI6IjxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiSG9ub2x1bHUgT2FodVwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMy8wOC9ob25vbHVsdS0zMDB4MjAwLmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6IlN0ZWRlbnRyaXBzIiwicG9zdF90YWdzIjoiSGF3YWlpIiwiJV93cGJfc2hvcnRjb2Rlc19jdXN0b21fY3NzJSI6Ii52Y19jdXN0b21fMTQ3MjMwNzUwMjI5MHtwYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O3BhZGRpbmctYm90dG9tOiAyNXB4ICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTU4NzY1OTI5OTA3MXtwYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O2JhY2tncm91bmQtY29sb3I6ICMwMDAwMDAgIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNjg5OTU2MjgwNzMxe3BhZGRpbmctdG9wOiA1MHB4ICFpbXBvcnRhbnQ7cGFkZGluZy1ib3R0b206IDUwcHggIWltcG9ydGFudDtiYWNrZ3JvdW5kLWltYWdlOiB1cmwoaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMS8wOC9hbGwtZGF5LXVzYS1iYWNrZ3JvdW5kLmdpZj9pZD04NDA4KSAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE1ODI5NzA3MDQ5MDN7cGFkZGluZy10b3A6IDEwcHggIWltcG9ydGFudDtwYWRkaW5nLXJpZ2h0OiAxMHB4ICFpbXBvcnRhbnQ7cGFkZGluZy1ib3R0b206IDEwcHggIWltcG9ydGFudDtwYWRkaW5nLWxlZnQ6IDEwcHggIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNTgyOTcwNzA0OTAze3BhZGRpbmctdG9wOiAxMHB4ICFpbXBvcnRhbnQ7cGFkZGluZy1yaWdodDogMTBweCAhaW1wb3J0YW50O3BhZGRpbmctYm90dG9tOiAxMHB4ICFpbXBvcnRhbnQ7cGFkZGluZy1sZWZ0OiAxMHB4ICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTY4OTk1NTQ4NjA4N3tiYWNrZ3JvdW5kLWNvbG9yOiAjZmZmZmZmICFpbXBvcnRhbnQ7Ym9yZGVyLXJhZGl1czogMTBweCAhaW1wb3J0YW50O30iLCIlX2VkaXRfbG9jayUiOiIxNjk0ODczMTk3OjIiLCIlX2VkaXRfbGFzdCUiOiIyIiwiJV93cGJfdmNfanNfc3RhdHVzJSI6InRydWUiLCIlcG9zdC1wcmltYXJ5LWNhdGVnb3J5JSI6IjE2IiwiJWZlYXR1cmVkX2ltYWdlX292ZXJyaWRlJSI6Im9mZiIsIiVhcnRpY2xlX3N0eWxlX292ZXJyaWRlJSI6Im9uIiwiJXBvc3Rfc3R5bGUlIjoic3R5bGU1IiwiJXBvc3RfZ2FsbGVyeV9zdHlsZSUiOiJsaWdodGJveCIsIiVwb3N0X3JldmlldyUiOiJvZmYiLCIlcG9zdF9yZXZpZXdfc3R5bGUlIjoic3R5bGUxIiwiJXBvc3RfcmV2aWV3X2F2ZXJhZ2UlIjoiNTAiLCIldGhiX2FsbF9jb3VudHMlIjoiMCIsIiVleGVjdXRpdmVfc3VtbWFyeSUiOiIiLCIldGhiLXJlYWN0aW9ucy12b3RlcyUiOiIxIiwiJV9oaWRlX2ZlYXR1cmVkJSI6bnVsbCwiJV93cF9vbGRfZGF0ZSUiOiIyMDIwLTA2LTE3IiwiJWlubGluZV9mZWF0dXJlZF9pbWFnZSUiOiIwIiwiJV95b2FzdF93cHNlb19mb2N1c2t3JSI6Ikhvbm9sdWx1IiwiJV95b2FzdF93cHNlb190aXRsZSUiOiJXYXQgdGUgZG9lbiBpbiBIb25vbHVsdSUlc2VwJSUgJSVzaXRlbmFtZSUlIiwiJV95b2FzdF93cHNlb19tZXRhZGVzYyUiOiJEZSBncm9vdHN0ZSBzdGFkIHZhbiBIYXdhaWksIEhvbm9sdWx1LiBXYXQgdGUgZG9lbiBpbiBIb25vbHVsdT8gVGlwcyB2b29yIGJlemllbnN3YWFyZGlnaGVkZW4gaW4gSG9ub2x1bHUuIiwiJV95b2FzdF93cHNlb19saW5rZGV4JSI6Ijc1IiwiJV95b2FzdF93cHNlb19jb250ZW50X3Njb3JlJSI6IjYwIiwiJV95b2FzdF93cHNlb19mb2N1c2tleXdvcmRzJSI6IltdIiwiJV95b2FzdF93cHNlb19rZXl3b3Jkc3lub255bXMlIjoiW1wid2F0IHRlIGRvZW4gb3AgSG9ub2x1bHVcIl0iLCIlX3dwZ21wX2xvY2F0aW9uX2FkZHJlc3MlIjoiU2FuaWJlbCBJc2xhbmQsIEZsb3JpZGEsIFZlcmVuaWdkZSBTdGF0ZW4iLCIlX3dwZ21wX2xvY2F0aW9uX2NpdHklIjoiIiwiJV93cGdtcF9sb2NhdGlvbl9zdGF0ZSUiOiJGbG9yaWRhIiwiJV93cGdtcF9sb2NhdGlvbl9jb3VudHJ5JSI6IlZlcmVuaWdkZSBTdGF0ZW4iLCIlX3dwZ21wX21ldGFib3hfbGF0aXR1ZGUlIjoiMjYuNDQzMzk3MiIsIiVfd3BnbXBfbWV0YWJveF9sb25naXR1ZGUlIjoiLTgyLjExMTUxMTkiLCIlX3dwZ21wX21ldGFib3hfbG9jYXRpb25fcmVkaXJlY3QlIjoibWFya2VyIiwiJV93cGdtcF9tZXRhYm94X2N1c3RvbV9saW5rJSI6IiIsIiVfd3BnbXBfbWFwX2lkJSI6ImE6MTp7aTowO3M6MTpcIjdcIjt9IiwiJV93cGdtcF9tZXRhYm94X21hcmtlcl9pZCUiOiJhOjE6e2k6MDtzOjE6XCIyXCI7fSIsIiVfd3BnbXBfbWV0YWJveF90YXhvbW9taWVzX3Rlcm1zJSI6IiIsIiVfd3BnbXBfZXh0ZW5zaW9uc19maWVsZHMlIjoiIiwiJV95b2FzdF93cHNlb19lc3RpbWF0ZWQtcmVhZGluZy10aW1lLW1pbnV0ZXMlIjoiNiIsIiVfd3dzX3N1cHBvcnRfY29udGFjdF9udW1iZXIlIjoiIiwiJV93d3NfYWJvdXRfc3VwcG9ydF90ZXh0JSI6IiIsIiVfd3dzX3RyaWdnZXJfYnV0dG9uX3RleHQlIjoiIiwiJV93d3NfcHJlZGVmaW5lZF90ZXh0JSI6IiIsIiVfeW9hc3RfaW5kZXhub3dfbGFzdF9waW5nJSI6IjE2OTQ4NzMzMDMiLCIlX3lvYXN0X3dwc2VvX3dvcmRwcm9vZl90aW1lc3RhbXAlIjoiIiwiJV9sYXN0X2VkaXRvcl91c2VkX2pldHBhY2slIjoiY2xhc3NpYy1lZGl0b3IiLCIlX3lvYXN0X3dwc2VvX3ByaW1hcnlfY2F0ZWdvcnklIjoiNjIiLCIlcG9zdF92aWElIjoiIiwiJV90aHVtYm5haWxfaWQlIjoiMTcyODciLCIlc3RhbmRhcmQtZmVhdHVyZWQtY3JlZGl0JSI6IiIsInRheG9ub215PWNhdGVnb3J5IjoiU3RlZGVudHJpcHMiLCJ0YXhvbm9teT1wb3N0X3RhZyI6Ikhhd2FpaSIsInRheG9ub215PXBvc3RfZm9ybWF0IjoiIiwidGF4b25vbXk9dGhiLXJlYWN0aW9ucyI6IiIsInRheG9ub215PXRoYi1zcG9uc29ycyI6IiJ9LCJpY29uIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyNC8wMy9tdXNlYS1pY29uLnBuZyJ9LCJpZCI6MTczODgsImluZm93aW5kb3dfZGlzYWJsZSI6ZmFsc2UsImNhdGVnb3JpZXMiOlt7Imljb24iOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDI0LzAzL211c2VhLWljb24ucG5nIiwibmFtZSI6Ik11c2VhIiwiaWQiOiIyIiwidHlwZSI6ImNhdGVnb3J5IiwiZXh0ZW5zaW9uX2ZpZWxkcyI6eyJjYXRfb3JkZXIiOiIifX1dfSx7InNvdXJjZSI6InBvc3QiLCJ0aXRsZSI6Ikxha2UgVGFob2UiLCJpbmZvd2luZG93X2NvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nIFwiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJMYWtlIFRhaG9lIGluIE5ldmFkYVwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMy8wOC9zYW5keS1oYXJib3ItYmVhY2gtbGFrZS10YWhvZS0zMDB4MjAwLmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmdcIj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZyBmYy1pdGVtLW5vLXBhZGRpbmdcIj5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tdGl0bGUgZmMtaXRlbS1wcmltYXJ5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2VcIj5MYWtlIFRhaG9lPC9kaXY+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3JcIj57bWFya2VyX2FkZHJlc3N9PC9kaXY+XHJcbiAgICAgICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1jbGVhclwiPjwvZGl2PlxyXG48L2Rpdj4iLCJhZGRyZXNzIjoiTGFrZSBUYWhvZSwgVmVyZW5pZ2RlIFN0YXRlbiIsImxvY2F0aW9uIjp7ImxhdCI6IjM5LjA5Njg0OTMiLCJjb3VudHJ5IjoiVmVyZW5pZ2RlIFN0YXRlbiIsImxuZyI6Ii0xMjAuMDMyMzUwNyIsIm9uY2xpY2tfYWN0aW9uIjoibWFya2VyIiwicmVkaXJlY3RfcGVybWFsaW5rIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9sYWtlLXRhaG9lLyIsInpvb20iOjEyLCJleHRyYV9maWVsZHMiOnsicG9zdF9leGNlcnB0IjoiIiwicG9zdF9jb250ZW50IjoiW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIl1bdmNfY29sdW1uIHdpZHRoPVwiMS8yXCJdW3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX3RleHRdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjg1JVwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiTGFrZSBUYWhvZVwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTozNXx0ZXh0X2FsaWduOmxlZnR8Y29sb3I6JTIzMDAwMDAwXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1MYWtlIFRhaG9lIGlzIGVlbiBncm9vdCBtZWVyIGRhdCBqZSB2aW5kdCBvcCBkZSBncmVucyB0dXNzZW4gQ2FsaWZvcm5pXHUwMGViIGVuIE5ldmFkYS4gSGV0IGlzIFx1MDBlOVx1MDBlOW4gdmFuIGRlIG1lZXN0IHBvcHVsYWlyZSBiZXN0ZW1taW5nZW4gaW4gZGUgcmVnaW8sIHZvb3JhbCB2ZWVsIGxvY2FscyBnYWFuIGdyYWFnIG5hYXIgTGFrZSBUYWhvZS4gSGV0IGlzIGVlbiB6b21lci0gZW4gd2ludGVyYmVzdGVtbWluZywgd2FhcmRvb3IgTGFrZSBUYWhvZSBoZXQgaGVsZSBqYWFyIGRvb3IgZ2V3aWxkIGlzLiBJbiBkZSB6b21lcm1hYW5kZW4ga3VuIGplIGVyIHdhbmRlbGVuLCB6d2VtbWVuIGVuIGJvb3QgdmFyZW4uIEluIGRlIHdpbnRlcm1hYW5kZW4gemlqbiBlciB2ZXJzY2hpbGxlbmRlIHNraWdlYmllZGVuIG9tIHRlIGJlem9la2VuLiBUaXBzIHZvb3IgZWVuIGJlem9layBhYW4gTGFrZSBUYWhvZS5bL3ZjX2NvbHVtbl90ZXh0XVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiSGV5IVVTQSBUaXA6XCIgZm9udF9jb250YWluZXI9XCJ0YWc6ZGl2fGZvbnRfc2l6ZToxNXx0ZXh0X2FsaWduOmxlZnR8Y29sb3I6JTIzYjM0YTRjfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJCb2VrIGplIGhvdGVsIGluIFNvdXRoIExha2UgVGFob2Ugb2YgU3RhdGVsaW5lLiBabyBrdW4gamUgZW4gaGV0IG1lZXIgZW4gZGUgb21nZXZpbmcgdmVya2VubmVuIVwiIGZvbnRfY29udGFpbmVyPVwidGFnOmRpdnxmb250X3NpemU6MjB8dGV4dF9hbGlnbjpsZWZ0fGNvbG9yOiUyMzI4MjgyOFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OlJvYm90byUyMFNsYWIlM0ExMDAlMkMzMDAlMkNyZWd1bGFyJTJDNzAwfGZvbnRfc3R5bGU6MTAwJTIwbGlnaHQlMjByZWd1bGFyJTNBMTAwJTNBbm9ybWFsXCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyBiZ190eXBlPVwiYmdfY29sb3JcIiBiZ19jb2xvcl92YWx1ZT1cIiNlZGVkZWRcIiBjc3M9XCIudmNfY3VzdG9tXzE2MTI5NTA1NDA4MTR7YmFja2dyb3VuZC1jb2xvcjogI2VkZWRlZCAhaW1wb3J0YW50O31cIl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjIvM1wiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJMYWtlIFRhaG9lXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjM1fHRleHRfYWxpZ246Y2VudGVyfGNvbG9yOiUyMzAwMDAwMFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxwIHN0eWxlPVwidGV4dC1hbGlnbjogY2VudGVyO1wiPkxha2UgVGFob2UgaXMgaGV0IG9wIFx1MDBlOVx1MDBlOW4gbmEgZGllcHN0ZSBtZWVyIGluIEFtZXJpa2EuIEhldCBtZWVyIG9udHN0b25kIGRvb3IgZWVuIGdlb2xvZ2lzY2hlIGJyZXVrIHdhYXJkb29yIGxhbmQgYWFuIGJlaWRlIGthbnRlbiBvbWhvb2cgZ2VzdHV3ZCB3ZXJkLiBMYWtlIFRhaG9lIG9udHN0b25kIGRvb3Igc2NodWl2ZW5kZSBnbGV0c2plcnMuIEhldCBtZWVyIHdvcmR0IGdldm9lZCBkb29yIHZlcnNjaGlsbGVuZGUgYmVyZ3N0cm9tZW4sIGVyIGlzIHNsZWNodHMgMSB1aXRzdHJvb206IGRlIFRydWNrZWUuIFZvb3JkYXQgTGFrZSBUYWhvZSBlZW4gcG9wdWxhaXJlIHRvZXJpc3Rpc2NoZSBiZXN0ZW1taW5nIHdlcmQsIGxlZWZkZW4gZXIgV2FzaG8taW5kaWFuZW4gaW4gZGUgcmVnaW8uIE9wIGhldCBtb21lbnQgZGF0IGVyIGdvdWQgZW4gemlsdmVyIHdlcmQgZ2V2b25kZW4gcm9uZCAxODQwLCB3ZXJkIGhldCBlZW4gYmVsYW5ncmlqa2UgcGxlay4gRXIga3dhbWVuIHZha2FudGllb29yZGVuLCB2aWxsYSdzLCBjYXNpbm8ncyBlbiB3aW50ZXJzcG9ydGdlYmllZGVuIGRpZSBlcnZvb3Igem9yZ2VuIGRhdCBMYWtlIFRhaG9lIGhldCBoZWxlIGphYXIgZG9vciBlZW4gZ2V3aWxkZSBiZXN0ZW1taW5nIGlzLjwvcD5cclxuWy92Y19jb2x1bW5fdGV4dF1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIGNvbnRlbnRfcGxhY2VtZW50PVwibWlkZGxlXCIgZnVsbF93aWR0aD1cInN0cmV0Y2hfcm93XCIgY29udGVudF90ZXh0X2FsaWdtZW50PVwiY2VudGVyXCIgY3NzPVwiLnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fVwiIHBhcmFsbGF4X2JhY2tncm91bmRfaW1hZ2U9XCIzODM2XCJdW3ZjX2NvbHVtbiB0aGJfY29sb3I9XCJ0aGItbGlnaHQtY29sdW1uXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiTGFrZSBUYWhvZVwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTo1NXx0ZXh0X2FsaWduOmNlbnRlcnxjb2xvcjolMjNmZmZmZmZ8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1baGV5dXNhX2hlYWRpbmcgdGFnPVwiZGl2XCIgdGV4dF9hbGlnbj1cImNlbnRlclwiIGhlYWRpbmc9XCJIZXQgaGVsZSBqYWFyIGRvb3IgZWVuIGJlc3RlbW1pbmcgb20gdGUgYmV6b2VrZW5cIiBmb250X3NpemU9XCI0MFwiIGxpbmVfaGVpZ2h0PVwiNDBcIiBmb250X2NvbG9yPVwiIzI4MjgyOFwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVtwYXJhbGxheF9yb3cgZW5hYmxlX21vYmlsZT1cInBhcmFsbGF4LWVuYWJsZS1tb2JpbGVcIiBpbWFnZT1cIjE3MjEyXCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNzVweFwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt2Y19zaW5nbGVfaW1hZ2UgaW1hZ2U9XCIxNzIxNVwiIGltZ19zaXplPVwibGFyZ2VcIiBhbGlnbm1lbnQ9XCJjZW50ZXJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkxha2UgVGFob2UgaW4gZGUgd2ludGVyXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjIwfHRleHRfYWxpZ246bGVmdHxjb2xvcjolMjMwMDAwMDB8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdTGFrZSBUYWhvZSBpcyBcdTAwZTlcdTAwZTluIHZhbiBkZSBiZXN0ZSA8YSBocmVmPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9za2llbi1pbi1hbWVyaWthL1wiPndpbnRlcnNwb3J0Z2ViaWVkZW4gaW4gQW1lcmlrYTwvYT4uIE1ldCBiaWpuYSBlZW4gbWlsam9lbiBiZXpvZWtlcnMgcGVyIGphYXIsIHN0YWF0IGhldCBpbiBkZSB0b3AgMTAgdmFuIHdpbnRlcnNwb3J0YmVzdGVtbWluZ2VuLiBEZSBtZWVzdGUgc2tpZ2ViaWVkZW4gbGlnZ2VuIGFhbiBkZSBub29yZGthbnQgdmFuIGhldCBnZWJpZWQgYmlqIFRydWNrZWUgZW4gUmVuby4gSW4gaGV0IHp1aWRlbiBpcyBIZWF2ZW5seSBNb3VudGFpbiBSZXNvcnQgZWVuIGdyb290IHNraWdlYmllZC4gSW4gMTk2MCB2b25kZW4gZGUgT2x5bXBpc2NoZSBXaW50ZXJzcGVsZW4gcGxhYXRzIGluIFBhbGlzYWRlcyBUYWhvZSwgaGV0IHR3ZWVkZSBncm9vdHN0ZSBza2lnZWJpZWQuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3ZjX3NpbmdsZV9pbWFnZSBpbWFnZT1cIjE3MjE0XCIgaW1nX3NpemU9XCJsYXJnZVwiIGFsaWdubWVudD1cImNlbnRlclwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiTGFrZSBUYWhvZSBpbiBkZSB6b21lclwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZToyMHx0ZXh0X2FsaWduOmxlZnR8Y29sb3I6JTIzMDAwMDAwfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XVZhbmFmIGRlIGxhdGUgbGVudGUgdG90IGluIGhldCBiZWdpbiB2YW4gZGUgaGVyZnN0IGlzIExha2UgVGFob2UgZWVuIGdld2lsZGUgYmVzdGVtbWluZyB2b29yIHZvb3JhbCBpbndvbmVycyB2YW4gQ2FsaWZvcm5pXHUwMGViIGVuIE5ldmFkYS4gRGUgbWVlc3RlIHRvZXJpc3RlbiBraWV6ZW4gZXIgdm9vciBvbSByaWNodGluZyA8YSBocmVmPVwiaHR0cHM6Ly93d3cuYm9va2luZy5jb20vc2VhcmNocmVzdWx0cy5lbi5odG1sP2NpdHk9MjAwMTYwODcmYW1wO2FpZD03OTU4NDk4JmFtcDtub19yb29tcz0xJmFtcDtncm91cF9hZHVsdHM9MiZhbXA7bGFiZWw9bGFrZXRhaG9lc291dGhsYWtlXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5Tb3V0aCBMYWtlIFRhaG9lPC9hPiBlbiA8YSBocmVmPVwiaHR0cHM6Ly93d3cuYm9va2luZy5jb20vc2VhcmNocmVzdWx0cy5lbi5odG1sP2NpdHk9MjAwNzkzMzkmYW1wO2FpZD03OTU4NDk4JmFtcDtub19yb29tcz0xJmFtcDtncm91cF9hZHVsdHM9MiZhbXA7bGFiZWw9bGFrZXRhaG9lc3RhdGVsaW5lXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5TdGF0ZWxpbmU8L2E+IHRlIHJlaXplbi4gRWVuIGFuZGVyZSBwb3B1bGFpcmUgcGxlayBpbiBoZXQgbm9vcmRlbiBpcyBLaW5ncyBCZWFjaC4gRGl0IHppam4gb29rIGRlIHBsZWtrZW4gd2FhciBqZSB2ZWxlIHdhdGVyc3BvcnQgYWN0aXZpdGVpdGVuIHpvYWxzIDxhIGhyZWY9XCJodHRwczovL3d3dy5nZXR5b3VyZ3VpZGUubmwvbGFrZS10YWhvZS1sODg5L2xha2UtdGFob2Uta2FqYWt2ZXJodXVyLWFhbi1kZS1ub29yZGt1c3QtdDI0OTMzNy8/cGFydG5lcl9pZD1ETUQyVkw0JmFtcDt1dG1fbWVkaXVtPW9ubGluZV9wdWJsaXNoZXImYW1wO2NtcD1sYWtldGFob2VrYWpha1wiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+a2FqYWtrZW48L2E+IG9mIDxhIGhyZWY9XCJodHRwczovL3d3dy5nZXR5b3VyZ3VpZGUubmwvbGFrZS10YWhvZS1sODg5L2xha2UtdGFob2UtdmVyaHV1ci12YW4tc3RhbmQtdXAtcGFkZGxlYm9hcmRzLWFhbi1kZS1ub29yZGt1c3QtdDI0OTk4Ny8/cGFydG5lcl9pZD1ETUQyVkw0JmFtcDt1dG1fbWVkaXVtPW9ubGluZV9wdWJsaXNoZXImYW1wO2NtcD1sYWtldGFob2VzdXBwXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5zdXBwZW48L2E+IGt1bnQgb25kZXJuZW1lbi4gT29rIHdhbmRlbGVuIGVuIDxhIGhyZWY9XCJodHRwczovL3d3dy5nZXR5b3VyZ3VpZGUubmwvaW5jbGluZS12aWxsYWdlLWwxNDk5NTMvbGFrZS10YWhvZS1zdGFkc2ZpZXRzLWRhZ3Zlcmh1dXItdDQ0NTMzMC8/cGFydG5lcl9pZD1ETUQyVkw0JmFtcDt1dG1fbWVkaXVtPW9ubGluZV9wdWJsaXNoZXImYW1wO2NtcD1sYWtldGFob2VmaWV0c1wiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+ZmlldHNlbjwvYT4gemlqbiBwb3B1bGFpciBpbiBMYWtlIFRhaG9lLiBFciB6aWpuIHZlcnNjaGlsbGVuZGUgdHJhaWxzIGVuIGZpZXRzcGFkZW4uIEhldCBsYW5nc3RlIGVuIGJlcm9lbWRzdGUgd2FuZGVscGFkIGlzIGRlIFRhaG9lIFJpbSBUcmFpbCwgZWVuIHJvdXRlIHZhbiAyNzAga2lsb21ldGVyIHJvbmRvbSBoZXQgbWVlci5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI3NXB4XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiIGZ1bGxfd2lkdGg9XCJzdHJldGNoX3Jvd1wiIGNvbnRlbnRfdGV4dF9hbGlnbWVudD1cImNlbnRlclwiIGNzcz1cIi52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O31cIiBwYXJhbGxheF9iYWNrZ3JvdW5kX2ltYWdlPVwiMzgzNlwiXVt2Y19jb2x1bW4gdGhiX2NvbG9yPVwidGhiLWxpZ2h0LWNvbHVtblwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt0aGJfcG9zdGJhY2tncm91bmQgc291cmNlPVwic2l6ZToxfHBvc3RfdHlwZTpwb3N0fGJ5X2lkOi0xNjE5LC02NjcsMTQ4MzBcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNzVweFwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMi8zXCJdW2hleXVzYV9oZWFkaW5nIHRhZz1cImRpdlwiIHRleHRfYWxpZ249XCJjZW50ZXJcIiBoZWFkaW5nPVwiT250ZGVrIG1lZXIgbmF0dXVyIGluIGRlIGJ1dXJ0XCIgZm9udF9zaXplPVwiNDBcIiBsaW5lX2hlaWdodD1cIjQwXCIgZm9udF9jb2xvcj1cIiMyODI4MjhcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJOb2cgbWVlciBOZXZhZGFcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMjgyODI4XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6NDBweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDo0NXB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjI1cHhcIl1bdGhiX3Bvc3RiYWNrZ3JvdW5kIHN0eWxlPVwic3R5bGUyXCIgc291cmNlPVwiYnlfaWQ6LTE1NjQ0LC0xNTYyNywtMTU1ODAsLTgxMDUsLTEyNjIsLTIyNjcsLTU3MiwtNTQ1LDM3MjAsMTIxNDgsNDQ2MCw0NjYzXCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddIiwicG9zdF90aXRsZSI6Ikxha2UgVGFob2UiLCJwb3N0X2xpbmsiOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL2xha2UtdGFob2UvIiwicG9zdF9mZWF0dXJlZF9pbWFnZSI6IjxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiTGFrZSBUYWhvZSBpbiBOZXZhZGFcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjIwMFwiIHNyYz1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjMvMDgvc2FuZHktaGFyYm9yLWJlYWNoLWxha2UtdGFob2UtMzAweDIwMC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj4iLCJwb3N0X2NhdGVnb3JpZXMiOiJOYXR1dXJnZWJpZWRlbiIsInBvc3RfdGFncyI6Ik5ldmFkYSIsIiVfd3BiX3Nob3J0Y29kZXNfY3VzdG9tX2NzcyUiOiIudmNfY3VzdG9tXzE2MTI5NTA1NDA4MTR7YmFja2dyb3VuZC1jb2xvcjogI2VkZWRlZCAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fSIsIiVpbmxpbmVfZmVhdHVyZWRfaW1hZ2UlIjoiMCIsIiVfZWRpdF9sYXN0JSI6IjIiLCIlX2VkaXRfbG9jayUiOiIxNjkzMzgwNTk5OjIiLCIlX3dwYl92Y19qc19zdGF0dXMlIjoidHJ1ZSIsIiVwb3N0LXByaW1hcnktY2F0ZWdvcnklIjoiMzIiLCIlZmVhdHVyZWRfaW1hZ2Vfb3ZlcnJpZGUlIjoib2ZmIiwiJWFydGljbGVfc3R5bGVfb3ZlcnJpZGUlIjoib24iLCIlcG9zdF9zdHlsZSUiOiJzdHlsZTUiLCIlcG9zdF9nYWxsZXJ5X3N0eWxlJSI6ImxpZ2h0Ym94IiwiJXBvc3RfcmV2aWV3JSI6Im9mZiIsIiVwb3N0X3Jldmlld19zdHlsZSUiOiJzdHlsZTEiLCIlcG9zdF9yZXZpZXdfYXZlcmFnZSUiOiI1MCIsIiVzdGFuZGFyZC1mZWF0dXJlZC1jcmVkaXQlIjoiIiwiJV9oaWRlX2ZlYXR1cmVkJSI6bnVsbCwiJXBvc3Rfc291cmNlJSI6IiIsIiVfdGh1bWJuYWlsX2lkJSI6IjE3MjEzIiwiJV95b2FzdF93cHNlb19mb2N1c2t3JSI6Ikxha2UgVGFob2UiLCIlX3lvYXN0X3dwc2VvX21ldGFkZXNjJSI6IkVlbiB2YW4gZGUgbWVyZW4gaW4gTmV2YWRhIGlzIExha2UgVGFob2UuIEVlbiB6b21lci0gZW4gd2ludGVyc3BvcnQgYmVzdGVtbWluZyBpbiBBbWVyaWthLiBCZW5pZXV3ZCB3YXQgamUgYmlqIExha2UgVGFob2Uga3VudCBkb2VuPyIsIiVfeW9hc3Rfd3BzZW9fbGlua2RleCUiOiI0NyIsIiVfeW9hc3Rfd3BzZW9fY29udGVudF9zY29yZSUiOiI2MCIsIiVfeW9hc3Rfd3BzZW9fZm9jdXNrZXl3b3JkcyUiOiJbXSIsIiVfeW9hc3Rfd3BzZW9fa2V5d29yZHN5bm9ueW1zJSI6IltcIlwiXSIsIiVfd3BnbXBfbG9jYXRpb25fYWRkcmVzcyUiOiJMYWtlIFRhaG9lLCBWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9sb2NhdGlvbl9jaXR5JSI6IiIsIiVfd3BnbXBfbG9jYXRpb25fc3RhdGUlIjoiIiwiJV93cGdtcF9sb2NhdGlvbl9jb3VudHJ5JSI6IlZlcmVuaWdkZSBTdGF0ZW4iLCIlX3dwZ21wX21ldGFib3hfbGF0aXR1ZGUlIjoiMzkuMDk2ODQ5MyIsIiVfd3BnbXBfbWV0YWJveF9sb25naXR1ZGUlIjoiLTEyMC4wMzIzNTA3IiwiJV93cGdtcF9tZXRhYm94X2xvY2F0aW9uX3JlZGlyZWN0JSI6Im1hcmtlciIsIiVfd3BnbXBfbWV0YWJveF9jdXN0b21fbGluayUiOiIiLCIlX3dwZ21wX21hcF9pZCUiOiJhOjE6e2k6MDtzOjE6XCI3XCI7fSIsIiVfd3BnbXBfbWV0YWJveF9tYXJrZXJfaWQlIjoiYToxOntpOjA7czoxOlwiN1wiO30iLCIlX3dwZ21wX21ldGFib3hfdGF4b21vbWllc190ZXJtcyUiOiIiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6IiIsIiVfeW9hc3Rfd3BzZW9fZXN0aW1hdGVkLXJlYWRpbmctdGltZS1taW51dGVzJSI6IjMiLCIlX3lvYXN0X3dwc2VvX3ByaW1hcnlfY2F0ZWdvcnklIjoiMjI3IiwiJV93d3Nfc3VwcG9ydF9jb250YWN0X251bWJlciUiOiIiLCIlX3d3c19hYm91dF9zdXBwb3J0X3RleHQlIjoiIiwiJV93d3NfdHJpZ2dlcl9idXR0b25fdGV4dCUiOiIiLCIlX3d3c19wcmVkZWZpbmVkX3RleHQlIjoiIiwiJV95b2FzdF9pbmRleG5vd19sYXN0X3BpbmclIjoiMTY5MzM4MDU5NiIsIiVfeW9hc3Rfd3BzZW9fd29yZHByb29mX3RpbWVzdGFtcCUiOiIiLCIlX2xhc3RfZWRpdG9yX3VzZWRfamV0cGFjayUiOiJjbGFzc2ljLWVkaXRvciIsInRheG9ub215PWNhdGVnb3J5IjoiTmF0dXVyZ2ViaWVkZW4iLCJ0YXhvbm9teT1wb3N0X3RhZyI6Ik5ldmFkYSIsInRheG9ub215PXBvc3RfZm9ybWF0IjoiIiwidGF4b25vbXk9dGhiLXJlYWN0aW9ucyI6IiIsInRheG9ub215PXRoYi1zcG9uc29ycyI6IiJ9LCJpY29uIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMS8wNC9wYXJrZW4ucG5nIn0sImlkIjoxNzIxMCwiaW5mb3dpbmRvd19kaXNhYmxlIjpmYWxzZSwiY2F0ZWdvcmllcyI6W3siaWNvbiI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjEvMDQvcGFya2VuLnBuZyIsIm5hbWUiOiJOYXRpb25hbGUgUGFya2VuIiwiaWQiOiI3IiwidHlwZSI6ImNhdGVnb3J5IiwiZXh0ZW5zaW9uX2ZpZWxkcyI6eyJjYXRfb3JkZXIiOiIifX1dfSx7InNvdXJjZSI6InBvc3QiLCJ0aXRsZSI6IkdyZWF0IEJhc2luIE5hdGlvbmFsIFBhcmsiLCJpbmZvd2luZG93X2NvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nIFwiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJHcmVhdCBCYXNpbiBOYXRpb25hbCBQYXJrIGluIE5ldmFkYVwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMy8wOC9ncmVhdC1iYXNpbi1uYXRpb25hbC1wYXJrLTMwMHgyMDAuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZ1wiPlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nIGZjLWl0ZW0tbm8tcGFkZGluZ1wiPlxyXG4gICAgICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS10aXRsZSBmYy1pdGVtLXByaW1hcnktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZVwiPkdyZWF0IEJhc2luIE5hdGlvbmFsIFBhcms8L2Rpdj5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tY29udGVudCBmYy1pdGVtLWJvZHktdGV4dC1jb2xvclwiPnttYXJrZXJfYWRkcmVzc308L2Rpdj5cclxuICAgICAgICA8L2Rpdj5cclxuICAgIDwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWNsZWFyXCI+PC9kaXY+XHJcbjwvZGl2PiIsImFkZHJlc3MiOiJOZXZhZGEsIFZlcmVuaWdkZSBTdGF0ZW4iLCJsb2NhdGlvbiI6eyJsYXQiOiIzOC45Mjk5Nzk4Iiwic3RhdGUiOiJOZXZhZGEiLCJjb3VudHJ5IjoiVmVyZW5pZ2RlIFN0YXRlbiIsImxuZyI6Ii0xMTQuMjYzMzc4NyIsIm9uY2xpY2tfYWN0aW9uIjoibWFya2VyIiwicmVkaXJlY3RfcGVybWFsaW5rIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9ncmVhdC1iYXNpbi1uYXRpb25hbC1wYXJrLyIsInpvb20iOjEyLCJleHRyYV9maWVsZHMiOnsicG9zdF9leGNlcnB0IjoiIiwicG9zdF9jb250ZW50IjoiW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIl1bdmNfY29sdW1uIHdpZHRoPVwiMS8yXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjEwMCVcIl1bdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS8yXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJHcmVhdCBCYXNpbiBOYXRpb25hbCBQYXJrXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjM1fHRleHRfYWxpZ246bGVmdHxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1IZXQgR3JlYXQgQmFzaW4gTmF0aW9uYWwgUGFyayBpcyBlZW4gbmF0aW9uYWFsIHBhcmsgZGF0IGVlbiByZWRlbGlqayBvbmhlcmJlcmd6YWFtIHdvZXN0aWpuZ2ViaWVkIG9tdmF0LiBIZXQgbGlndCBpbiBkZSBzdGFhdCBOZXZhZGEgdGVnZW4gZGUgZ3JlbnMgbWV0IFV0YWguIEhvZXdlbCBoZXQgZ3Jvb3RzdGUgZGVlbCB1aXQgd29lc3Rpam4gYmVzdGFhdCwgemlqbiBlciBvb2sgYmVyZ3RvcHBlbiwgZ2xldHNqZXJzIGVuIGJvc3NlbiB0ZSB2aW5kZW4gaW4gaGV0IHBhcmsuIERpdCBrb210IGRvb3JkYXQgamUgYWxsZSBlY29zeXN0ZW1lbiB2aW5kdCBpbiBoZXQgR3JlYXQgQmFzaW4gTmF0aW9uYWwgUGFyay4gSGV0IG5vb3JkZWxpamtlIGRlZWwgdmFuIGhldCBuYXRpb25hbGUgcGFyayBpcyBoZXQgYmVzdCBiZXJlaWtiYWFyLCBoaWVyIGxvb3B0IGRlIFdoZWVsZXIgUGVhayBTY2VuaWMgRHJpdmUgZGllIGplIGFsIHJpamRlbmQga3VudCBhZmxlZ2dlbiBvbSB1aXR6aWNodHB1bnRlbiB0ZSBiZXpvZWtlbiBlbiB3YW5kZWxpbmdlbiB0ZSBtYWtlbi4gVGlwcyB2b29yIGVlbiBiZXpvZWsgYWFuIGhldCBHcmVhdCBCYXNpbiBOYXRpb25hbCBQYXJrLlsvdmNfY29sdW1uX3RleHRdW3VsdGltYXRlX2ljb25fbGlzdCBpY29uX3NpemU9XCIyMFwiXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtYXV0b21vYmlsZSBjYXJcIl00NzYga2lsb21ldGVyIHZhbmFmIExhcyBWZWdhc1svdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy10cmVlXCJdPHNwYW4gY2xhc3M9XCJMcnpYciBrbm8tZnZcIj4zMTIga21cdTAwYjIgb3BwZXJ2bGFrdGU8L3NwYW4+Wy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLXBhd1wiXTYxIHZlcnNjaGlsbGVuZGUgc29vcnRlbiBkaWVyZW4sIDIzOCB2ZXJzY2hpbGxlbmRlIHNvb3J0ZW4gdm9nZWxzWy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bL3VsdGltYXRlX2ljb25fbGlzdF1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIGNzcz1cIi52Y19jdXN0b21fMTYwODY2NjUxOTQ5MntiYWNrZ3JvdW5kLWNvbG9yOiAjZWFlYWVhICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMi8zXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIldhYXJvbSBHcmVhdCBCYXNpbj9cIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MzV8dGV4dF9hbGlnbjpjZW50ZXJ8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxwIHN0eWxlPVwidGV4dC1hbGlnbjogY2VudGVyO1wiPkdyZWF0IEJhc2luIE5hdGlvbmFsIFBhcmsgaXMgb25kZXJkZWVsIHZhbiBHcmVhdCBCYXNpbiwgb29rIHdlbCBHcm90ZSBCZWtrZW4gZ2Vub2VtZC4gSGV0IGdlYmllZCBsaWd0IHR1c3NlbiBkZSBSb2NreSBNb3VudGFpbnMgZW4gZGUgU2llcnJhIE5ldmFkYSBlbiBoZWVmdCBncm90ZW5kZWVscyBlZW4gd29lc3Rpam5rbGltYWF0LiBIZXQgd29yZHQgR3JlYXQgQmFzaW4gZ2Vub2VtZCBvbWRhdCBoZXQgcmVnZW53YXRlciBkYXQgaGllciB0ZXJlY2h0IGtvbXQgbmlldCBhZmdldm9lcmQgd29yZHQgbmFhciBkZSBvY2VhYW4sIG1hYXIgaW4gZGUgZ3JvbmR3YXRlciBiZWtrZW4gdGVyZWNodCBrb210LiBIaWVyZG9vciBpcyBlciBlZW4gZ3JvdGUgdmFyaWF0aWUgaW4gZmxvcmEgZW4gZmF1bmEgdGUgdmluZGVuIGluIGhldCBnZWJpZWQuIERhYXJuYWFzdCB6aWpuIGFsbGUgc29vcnRlbiBlY28gc3lzdGVtZW4gdmVydGVnZW53b29yZGlnZCBpbiBoZXQgR3JlYXQgQmFzaW4gTmF0aW9uYWwgUGFyay48L3A+XHJcblsvdmNfY29sdW1uX3RleHRdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI3NXB4XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIiBmdWxsX3dpZHRoPVwic3RyZXRjaF9yb3dcIiBjb250ZW50X3RleHRfYWxpZ21lbnQ9XCJjZW50ZXJcIiBjc3M9XCIudmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9XCIgcGFyYWxsYXhfYmFja2dyb3VuZF9pbWFnZT1cIjM4MzZcIl1bdmNfY29sdW1uIHRoYl9jb2xvcj1cInRoYi1saWdodC1jb2x1bW5cIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJXaGVlbGVyIFNjZW5pYyBEcml2ZSBpbiBHcmVhdCBCYXNpbiBOYXRpb25hbCBQYXJrXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjc1fHRleHRfYWxpZ246Y2VudGVyfGNvbG9yOiUyM2ZmZmZmZnxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVtoZXl1c2FfaGVhZGluZyB0YWc9XCJoNFwiIHRleHRfYWxpZ249XCJjZW50ZXJcIiBoZWFkaW5nPVwiRGUgcm91dGUgb20gdGUgcmlqZGVuIGluIGhldCBwYXJrXCIgZm9udF9zaXplPVwiNTBcIiBsaW5lX2hlaWdodD1cIjFcIiBmb250X2NvbG9yPVwiI2ZmZmZmZlwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVtwYXJhbGxheF9yb3cgZW5hYmxlX21vYmlsZT1cInBhcmFsbGF4LWVuYWJsZS1tb2JpbGVcIiBpbWFnZT1cIjE3MjA0XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIl1bdmNfY29sdW1uXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJGYWN0cyBHcmVhdCBCYXNpbiBOYXRpb25hbCBQYXJrXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjI1fHRleHRfYWxpZ246bGVmdFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdVm9vcmRhdCBoZXQgZ2ViaWVkIHdlcmQgYmV3b29uZCBtZXQgbWlqbndlcmtlcnMgaW4gZGUgMTllIGVldXcsIHdvb25kZW4gZXIgdmVyc2NoaWxsZW5kZSBpbmhlZW1zZSBzdGFtbWVuIGluIGhldCBnZWJpZWQuIERvb3IgbWlkZGVsIHZhbiByb3RzdGVrZW5pbmdlbiBpcyB0ZSB6aWVuIGRhdCBoZXQgcGFyayBhbCBqYXJlbiBiZXdvb25kIHdlcmQuIEluIGRlIDE5ZSBlZXV3IGxpZXBlbiB2ZXJzY2hpbGxlbmRlIGV4cGVkaXRpZXMgZG9vciBoZXQgR3JlYXQgQmFzaW4uIEhldCB3ZXJkIGVlbiBiZWxhbmdyaWprZSByb3V0ZSByaWNodGluZyBoZXQgd2VzdGVuLCBvb2sgd2VsIGRlIENhbGlmb3JuaWEgVHJhaWwuIE5hIGRlIHZvbmRzdCB2YW4gemlsdmVyIGVuIGdvdWQga3dhbWVuIGRlIGVlcnN0ZSBtaWpuYmVkcmlqdmVuIGluIGRlIHJlZ2lvIG1ldCBkYWFyYmlqIG9vayBkZSBrb21zdCB2YW4gbWlqbndlcmtlcnMgZW4gYm9lcmVuLiBFXHUwMGU5biBkYWFydmFuIGlzIEFic2Fsb20gTGVobWFuIGRpZSB6aWpuIHZvZWRzZWwgdmVyYm91d2RlIHZvb3IgbWlqbndlcmtlcnMuIEhpaiB3YXMgZGVnZW5lIGRpZSBpbiAxODg1IGRlIGdyb3R0ZW4gb250ZGVrdGUgZGllIG51IHppam4gbmFhbSBkcmFnZW4uWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJXYXQgdGUgZG9lbiBpbiBHcmVhdCBCYXNpbiBOYXRpb25hbCBQYXJrXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjI1fHRleHRfYWxpZ246bGVmdFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdSGV0IEdyZWF0IEJhc2luIE5hdGlvbmFsIFBhcmsgZWVuIHJlbGF0aWVmIGtsZWluIG5hdGlvbmFsIHBhcmsgaW4gQW1lcmlrYS4gV2lsIGplIGhldCBwYXJrIGJlem9la2VuPyBQYWsgZGFuIGhldCBub29yZGVsaWprZSBkZWVsIHZhbiBoZXQgcGFyay4gSGllciB2aW5kIGplIGRlIDxzdHJvbmc+V2hlZWxlciBQZWFrIFNjZW5pYyBkcml2ZTwvc3Ryb25nPiBkaWUgamUgbGFuZ3MgdWl0a2lqa3B1bnRlbiBicmVuZ3Qgd2FhciBvb2sgd2FuZGVscm91dGVzIGJlZ2lubmVuLiBIZXQgaG9vZ3N0ZSBwdW50IGlzIGRlIFdoZWVsZXIgUGVhayBtZXQgMzk4MSBtZXRlci4gRWVuIGFuZGVyZSBiZXppZW5zd2FhcmRpZ2hlaWQgZGllIGRlIG1vZWl0ZSB3YWFyZCBpcyB6aWpuIGRlIDxzdHJvbmc+TGVobWFuIENhdmVzPC9zdHJvbmc+LiBFZW4gaW5kcnVrd2Vra2VuZGUgZ3JvdCBkaWUgamUgYWxsZWVuIG9uZGVyIGJlZ2VsZWlkaW5nIGt1bnQgYmV6b2VrZW4uIEJpaiBkZSA8c3Ryb25nPkJha2VyIEFyY2hlb2xvZ2ljYWwgU2l0PC9zdHJvbmc+ZSB2aW5kIGplIGVlbiBvdWRlIG5lZGVyemV0dGluZyB2YW4gZGUgRnJlbW9udCBpbmRpYW5lbiB1aXQgZGUgMTNlIGVldXcuIFZhbiBkZXplIGdyb2VwIGluZGlhbmVuIHppam4gb29rIG5vZyBzcG9yZW4gdGUgemllbiBiaWogZGUgPHN0cm9uZz5VcHBlciBQaWN0b2dyYXBoIENhdmU8L3N0cm9uZz4uIEVlbiBiZXppZW5zd2FhcmRpZ2hlaWQgZGllIHJlbGF0aWVmIG1vZWlsaWprIHRlIGJlem9la2VuIGlzLCBpcyBkZSA8c3Ryb25nPkxleGluZ3RvbiBBcmNoPC9zdHJvbmc+LiBIaWVydm9vciBtb2V0IGplIDIwIGtpbG9tZXRlciByaWpkZW4gb3AgZWVuIG9udmVyaGFyZGUgd2VnIGVuIDUsNSBraWxvbWV0ZXIgd2FuZGVsZW4uIERhYXJuYWFzdCBpcyBoZXQgZ2ViaWVkIGVlbiBEYXJrIFNreSBQYXJrIHdhYXJkb29yIHN0ZXJyZW4ga2lqa2VuIGhpZXIgcGVyZmVjdCBrYW4uWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIk92ZXJuYWNodGVuIGluIEdyZWF0IEJhc2luIE5hdGlvbmFsIFBhcmtcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MjV8dGV4dF9hbGlnbjpsZWZ0XCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1JbiBoZXQgR3JlYXQgQmFzaW4gTmF0aW9uYWwgUGFyayB2aW5kIGplIGdlZW4gbW9nZWxpamtoZWRlbiB2b29yIGhvdGVscyBvZiBjYWJpbnMuIEhpZXJ2b29yIGt1biBqZSBoZXQgYmVzdGUga2llemVuIHZvb3IgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmJvb2tpbmcuY29tL3NlYXJjaHJlc3VsdHMuZW4uaHRtbD9jaXR5PTIwMDc4ODM0JmFtcDthaWQ9Nzk1ODQ5OCZhbXA7bm9fcm9vbXM9MSZhbXA7Z3JvdXBfYWR1bHRzPTImYW1wO2xhYmVsPWdyZWF0YmFzaW5ucGJha2VyXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5CYWtlcjwvYT4gaW4gTmV2YWRhLiBNb2NodGVuIGhpZXIgZ2VlbiBvcHRpZXMgbWVlciB6aWpuLCBkYW4gaXMgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmJvb2tpbmcuY29tL3NlYXJjaHJlc3VsdHMuZW4uaHRtbD9jaXR5PTIwMDc4OTgwJmFtcDthaWQ9Nzk1ODQ5OCZhbXA7bm9fcm9vbXM9MSZhbXA7Z3JvdXBfYWR1bHRzPTImYW1wO2xhYmVsPWdyZWF0YmFzaW5ucGVseVwiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+RWx5PC9hPiBlZW4gaWV0cyBncm90ZXJlIHBsZWsgb20gdGUgb3Zlcm5hY2h0ZW4uIEluIGhldCBwYXJrIHplbGYgdmluZCBqZSBhbGxlZW4gbW9nZWxpamtoZWRlbiBvbSB0ZSBrYW1wZXJlbi4gRXIgemlqbiA1IGNhbXBncm91bmRzIHdhYXIgamUga3VudCBvdmVybmFjaHRlbjogVXBwZXIgTGVobWFuIENyZWVrLCBMb3dlciBMZWhtYW4gQ3JlZWssIEJha2VyIENyZWVrLCBHcmV5IENsaWZmcyBlbiBXaGVlbGVyIFBlYWsuIFplIGhlYmJlbiBhbGxlbWFhbCB0b2lsZXR0ZW4sIHBpY2tuaWNrIHRhZmVscyBlbiBjYW1wZmlyZSBncmlsbHMuIEVyIGt1bm5lbiA4IG1lbnNlbiBzbGFwZW4sIDMgdGVudGVuIGVuIDIgYXV0bydzLiBMb3dlciBMZWhtYW4gQ3JlZWsgaXMgZGUgZW5pZ2UgZGllIGhldCBoZWxlIGphYXIgZ2VvcGVuZCBpcy4gUmVzZXJ2ZXJpbmdlbiBkaWVuZW4gZ2VtYWFrdCB0ZSB3b3JkZW4gdm9vciBVcHBlciBMZWhtYW4gQ3JlZWsgZW4gV2hlZWxlciBQZWFrIENhbXBncm91bmRzLiBWb29yIEdyZXkgQ2xpZmZzIENhbXBncm91bmQga3VuIGplIG9vayByZXNlcnZlcmVuLCBtYWFyIGRpZW4gamUgd2VsIG1pbmltYWFsIDIgbmFjaHRlbiB0ZSBibGlqdmVuLiBSZXNlcnZlcmVuIGthbiB2aWEgPGEgaHJlZj1cImh0dHBzOi8vd3d3LnJlY3JlYXRpb24uZ292L1wiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+UmVjcmVhdGlvbi5Hb3Y8L2E+LlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiQmVzdGUgcmVpc3BlcmlvZGUgR3JlYXQgQmFzaW4gTmF0aW9uYWwgUGFya1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZToyNXx0ZXh0X2FsaWduOmxlZnRcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XURlIGJlc3RlIHBlcmlvZGUgdm9vciBlZW4gYmV6b2VrIGFhbiBoZXQgR3JlYXQgQmFzaW4gTmF0aW9uYWwgUGFyayBpcyBpbiBkZSB6b21lcm1hYW5kZW4gb2YgaW4gZGUgaGVyZnN0LiBEZSB3YXJtc3RlIG1hYW5kIGlzIGp1bmkuIE92ZXJpZ2VucyBpcyBoZXQgbW9nZWxpamtoZWlkIG9tIGluIGRlemUgbWFhbmRlbiBlZW4gem9tZXJzZSBvbndlZXJzYnVpIHRlIHRyZWZmZW4sIHZhYWsga29tZW5kZSBkZXplIGFhbiBoZXQgZWluZGUgdmFuIGRlIG1pZGRhZy5cdTAwYTAgSW4gZGUgd2ludGVybWFhbmRlbiBrYW4gZXIgc25lZXV3IHZhbGxlbiBlbiBrb3VkIHppam4uIERlIHdhbmRlbHJvdXRlcyBpbiBkZSBsYWdlciBnZWxlZ2VuIGRlbGVuIHppam4gbWVlc3RhbCB2YW5hZiBkZSBsYXRlIGxlbnRlIHRvdCBiZWdpbiB2YW4gZGUgaGVyZnN0IHNuZWV1d3ZyaWouWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiIGZ1bGxfd2lkdGg9XCJzdHJldGNoX3Jvd1wiIGNvbnRlbnRfdGV4dF9hbGlnbWVudD1cImNlbnRlclwiIGNzcz1cIi52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O31cIiBwYXJhbGxheF9iYWNrZ3JvdW5kX2ltYWdlPVwiMzgzNlwiXVt2Y19jb2x1bW4gdGhiX2NvbG9yPVwidGhiLWxpZ2h0LWNvbHVtblwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJUcmFpbHMgaW4gR3JlYXQgQmFzaW4gTmF0aW9uYWwgUGFya1wiIGhlYWRpbmdfdGFnPVwicFwiIG1haW5faGVhZGluZ19jb2xvcj1cIiNmZmZmZmZcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDo0NXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjU1cHg7XCIgbWFyZ2luX2Rlc2lnbl90YWJfdGV4dD1cIlwiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMTBweFwiXVtoZXl1c2FfaGVhZGluZyB0YWc9XCJoNFwiIHRleHRfYWxpZ249XCJjZW50ZXJcIiBoZWFkaW5nPVwiT250ZGVrIGhldCBwYXJrIG9wIFx1MDBlOVx1MDBlOW4gdmFuIGRlIHdhbmRlbHBhZGVuXCIgZm9udF9zaXplPVwiNTBcIiBsaW5lX2hlaWdodD1cIjFcIiBmb250X2NvbG9yPVwiI2ZmZmZmZlwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVtwYXJhbGxheF9yb3cgZW5hYmxlX21vYmlsZT1cInBhcmFsbGF4LWVuYWJsZS1tb2JpbGVcIiBpbWFnZT1cIjE3MjA1XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjc3M9XCIudmNfY3VzdG9tXzE2MDg2NjY4ODU0OTd7YmFja2dyb3VuZC1pbWFnZTogdXJsKGh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjAvMDgvYmFja2dyb3VuZC1oZXl1c2EtbmF0dXVyLTEuZ2lmP2lkPTMwODgpICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW5dW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiV2FuZGVsZW4gaW4gR3JlYXQgQmFzaW4gTmF0aW9uYWwgUGFya1wiIG1haW5faGVhZGluZ19jb2xvcj1cIiMwMDAwMDBcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDo1NXB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdSW4gR3JlYXQgQmFzaW4gTmF0aW9uYWwgUGFyayB6aWpuIHZlcnNjaGlsbGVuZGUgbW9nZWxpamtoZWRlbiBvbSB0ZSB3YW5kZWxlbi4gRXIgemlqbiAxMiB0cmFpbHMgaW4gaGV0IHBhcmsgZGllIGplIGt1bnQgbG9wZW4sIGRlemUgdmFyaVx1MDBlYnJlbiB2YW4gMCw1IGtpbG9tZXRlciB0b3QgMjEga2lsb21ldGVyIGVuIG9vayBpbiBkZSBtb2VpbGlqa2hlaWQgdmFuIGRlIHRyYWlsIHppdHRlbiB2ZXJzY2hpbGxlbi4gSmUgaGVidCBtYWtrZWxpamtlIHdhbmRlbGluZ2VuLCBtYWFyIG9vayB3YW5kZWxpbmdlbiB3YWFyIHZlZWwgZXJ2YXJpbmcgdm9vciB2ZXJlaXN0IGlzLlx1MDBhMCBFZW4gYWFudGFsIHdhbmRlbHJvdXRlcyBpbiBHcmVhdCBCYXNpbiBOYXRpb25hbCBQYXJrIGRpZSBqZSBrdW50IGxvcGVuOlxyXG48dWw+XHJcbiBcdDxsaT5BbHBpbmUgTGFrZXMgTG9vcCBUcmFpbCAtIDQsNCBrbSAtIGVhc3k8L2xpPlxyXG4gXHQ8bGk+QnJpc3RsZWNvbmUgVHJhaWwgLSA5LDIga20gLSBtb2RlcmF0ZTwvbGk+XHJcbiBcdDxsaT5CcmlzdGxlY29uZSBlbiBHbGFjaWVyIFRyYWlsIC0gMTUga20gLSB1cHBlciBtb2RlcmF0ZTwvbGk+XHJcbiBcdDxsaT5Nb3VudGFpbiBWaWV3IE5hdHVyZSBUcmFpbCAtIDAsNSBrbSAtIGVhc3k8L2xpPlxyXG4gXHQ8bGk+TGVobWFuIENyZWVrIC0gMTAsMyBrbSAtIG1vZGVyYXRlPC9saT5cclxuIFx0PGxpPk9zY2Vhb2xhIERpdGNoIC0gMTQsOCBrbSAtIGVhc3kgLyBtb2RlcmF0ZTwvbGk+XHJcbjwvdWw+XHJcblsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIkhhbmRpZ2UgaW5mbyB2b29yIGplIGJlem9la1wiIG1haW5faGVhZGluZ19jb2xvcj1cIiMwMDAwMDBcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpSb2JvdG8gU2xhYnxmb250X2NhbGw6Um9ib3RvK1NsYWJ8dmFyaWFudDo4MDBcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjU1cHg7XCIgbWFpbl9oZWFkaW5nX3N0eWxlPVwiZm9udC13ZWlnaHQ6ODAwO1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdWx0aW1hdGVfaWNvbl9saXN0IGljb25fc2l6ZT1cIjI1XCJdW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy1jbG9jay1vXCIgY29udGVudF9mb250X3NpemU9XCJkZXNrdG9wOjE2cHg7XCJdMjQvNyBlbiAzNjUgZGFnZW4gZ2VvcGVuZFsvdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy10aHVtYnMtdXBcIiBjb250ZW50X2ZvbnRfc2l6ZT1cImRlc2t0b3A6MTZweDtcIl1CZXN0ZSBwZXJpb2RlOiB6b21lciBlbiBoZXJmc3RbL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtZG9sbGFyIHVzZFwiIGNvbnRlbnRfZm9udF9zaXplPVwiZGVza3RvcDoxNnB4O1wiXUdyYXRpc1svdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dWy91bHRpbWF0ZV9pY29uX2xpc3RdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiIGZ1bGxfd2lkdGg9XCJzdHJldGNoX3Jvd1wiIGNvbnRlbnRfdGV4dF9hbGlnbWVudD1cImNlbnRlclwiIGNzcz1cIi52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O31cIiBwYXJhbGxheF9iYWNrZ3JvdW5kX2ltYWdlPVwiMzgzNlwiXVt2Y19jb2x1bW4gdGhiX2NvbG9yPVwidGhiLWxpZ2h0LWNvbHVtblwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJXaGVlbGVyIFBlYWtcIiBoZWFkaW5nX3RhZz1cInBcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjZmZmZmZmXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6NDVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDo1NXB4O1wiIG1hcmdpbl9kZXNpZ25fdGFiX3RleHQ9XCJcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjEwcHhcIl1baGV5dXNhX2hlYWRpbmcgdGFnPVwiaDRcIiB0ZXh0X2FsaWduPVwiY2VudGVyXCIgaGVhZGluZz1cIk1ldCAzOTgyIG1ldGVyIGhldCBob29nc3RlIHB1bnQgdmFuIEdyZWF0IEJhc2luIE5hdGlvbmFsIFBhcmtcIiBmb250X3NpemU9XCI1MFwiIGxpbmVfaGVpZ2h0PVwiMVwiIGZvbnRfY29sb3I9XCIjZmZmZmZmXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3BhcmFsbGF4X3JvdyBlbmFibGVfbW9iaWxlPVwicGFyYWxsYXgtZW5hYmxlLW1vYmlsZVwiIGltYWdlPVwiMTcyMDZcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiXVt2Y19jb2x1bW5dW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIk1lZXIgbmF0aW9uYWxlIHBhcmtlblwiIGZvbnRfY29udGFpbmVyPVwidGFnOmRpdnxmb250X3NpemU6NDB8dGV4dF9hbGlnbjpjZW50ZXJcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3RoYl9wb3N0Z3JpZCBzdHlsZT1cInN0eWxlMTFcIiBjb2x1bW5zPVwiNFwiIHNvdXJjZT1cInBvc3RfdHlwZTpwb3N0fGJ5X2lkOjQ3MzgsNDcxNCw0Njg5LDQ3OTJcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd10iLCJwb3N0X3RpdGxlIjoiR3JlYXQgQmFzaW4gTmF0aW9uYWwgUGFyayIsInBvc3RfbGluayI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvZ3JlYXQtYmFzaW4tbmF0aW9uYWwtcGFyay8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJHcmVhdCBCYXNpbiBOYXRpb25hbCBQYXJrIGluIE5ldmFkYVwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMy8wOC9ncmVhdC1iYXNpbi1uYXRpb25hbC1wYXJrLTMwMHgyMDAuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+IiwicG9zdF9jYXRlZ29yaWVzIjoiR3JlYXQgQmFzaW4gTmF0aW9uYWwgUGFyayIsInBvc3RfdGFncyI6Ik5ldmFkYSIsIiVfd3BiX3Nob3J0Y29kZXNfY3VzdG9tX2NzcyUiOiIudmNfY3VzdG9tXzE2MDg2NjY1MTk0OTJ7YmFja2dyb3VuZC1jb2xvcjogI2VhZWFlYSAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTYwODY2Njg4NTQ5N3tiYWNrZ3JvdW5kLWltYWdlOiB1cmwoaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMC8wOC9iYWNrZ3JvdW5kLWhleXVzYS1uYXR1dXItMS5naWY/aWQ9MzA4OCkgIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fSIsIiVpbmxpbmVfZmVhdHVyZWRfaW1hZ2UlIjoiMCIsIiVfZWRpdF9sb2NrJSI6IjE2OTI1MDk0OTE6MiIsIiVfZWRpdF9sYXN0JSI6IjIiLCIlX3RodW1ibmFpbF9pZCUiOiIxNzIwMyIsIiVfaGlkZV9mZWF0dXJlZCUiOm51bGwsIiVfd3BiX3ZjX2pzX3N0YXR1cyUiOiJ0cnVlIiwiJXBvc3QtcHJpbWFyeS1jYXRlZ29yeSUiOiJhdXRvIiwiJWZlYXR1cmVkX2ltYWdlX292ZXJyaWRlJSI6Im9mZiIsIiVhcnRpY2xlX3N0eWxlX292ZXJyaWRlJSI6Im9uIiwiJXBvc3Rfc3R5bGUlIjoic3R5bGUxMSIsIiVwb3N0X2dhbGxlcnlfc3R5bGUlIjoibGlnaHRib3giLCIlcG9zdF9yZXZpZXclIjoib2ZmIiwiJXBvc3RfcmV2aWV3X3N0eWxlJSI6InN0eWxlMSIsIiVwb3N0X3Jldmlld19hdmVyYWdlJSI6IjUwIiwiJV95b2FzdF93cHNlb19jb250ZW50X3Njb3JlJSI6IjYwIiwiJV95b2FzdF93cHNlb19mb2N1c2tleXdvcmRzJSI6IltdIiwiJV95b2FzdF93cHNlb19rZXl3b3Jkc3lub255bXMlIjoiW1wiXCJdIiwiJV95b2FzdF93cHNlb19mb2N1c2t3JSI6IkdyZWF0IEJhc2luIE5hdGlvbmFsIFBhcmsiLCIlX3lvYXN0X3dwc2VvX21ldGFkZXNjJSI6IkluIE5ldmFkYSBsaWd0IGhldCBHcmVhdCBCYXNpbiBOYXRpb25hbCBQYXJrLCBlZW4gcmVsYXRpZWYgb25iZWtlbmQgbmF0aW9uYWwgcGFyay4gVGlwcyB2b29yIGVlbiBiZXpvZWsgYWFuIGhldCBHcmVhdCBCYXNpbiBOYXRpb25hbCBQYXJrLiIsIiVfeW9hc3Rfd3BzZW9fbGlua2RleCUiOiI4MSIsIiVfd3BnbXBfbG9jYXRpb25fYWRkcmVzcyUiOiJOZXZhZGEsIFZlcmVuaWdkZSBTdGF0ZW4iLCIlX3dwZ21wX2xvY2F0aW9uX2NpdHklIjoiIiwiJV93cGdtcF9sb2NhdGlvbl9zdGF0ZSUiOiJOZXZhZGEiLCIlX3dwZ21wX2xvY2F0aW9uX2NvdW50cnklIjoiVmVyZW5pZ2RlIFN0YXRlbiIsIiVfd3BnbXBfbWV0YWJveF9sYXRpdHVkZSUiOiIzOC45Mjk5Nzk4IiwiJV93cGdtcF9tZXRhYm94X2xvbmdpdHVkZSUiOiItMTE0LjI2MzM3ODciLCIlX3dwZ21wX21ldGFib3hfbG9jYXRpb25fcmVkaXJlY3QlIjoibWFya2VyIiwiJV93cGdtcF9tZXRhYm94X2N1c3RvbV9saW5rJSI6IiIsIiVfd3BnbXBfbWFwX2lkJSI6ImE6MTp7aTowO3M6MTpcIjdcIjt9IiwiJV93cGdtcF9tZXRhYm94X21hcmtlcl9pZCUiOiIiLCIlX3dwZ21wX21ldGFib3hfdGF4b21vbWllc190ZXJtcyUiOiIiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6IiIsIiVfeW9hc3Rfd3BzZW9fZXN0aW1hdGVkLXJlYWRpbmctdGltZS1taW51dGVzJSI6IjYiLCIlX3lvYXN0X3dwc2VvX3ByaW1hcnlfY2F0ZWdvcnklIjoiMjMyIiwiJV93d3Nfc3VwcG9ydF9jb250YWN0X251bWJlciUiOiIiLCIlX3d3c19hYm91dF9zdXBwb3J0X3RleHQlIjoiIiwiJV93d3NfdHJpZ2dlcl9idXR0b25fdGV4dCUiOiIiLCIlX3d3c19wcmVkZWZpbmVkX3RleHQlIjoiIiwiJV95b2FzdF93cHNlb193b3JkcHJvb2ZfdGltZXN0YW1wJSI6IiIsIiVfeW9hc3RfaW5kZXhub3dfbGFzdF9waW5nJSI6IjE2OTI1MDk1MzAiLCIlX2xhc3RfZWRpdG9yX3VzZWRfamV0cGFjayUiOiJjbGFzc2ljLWVkaXRvciIsIiVfd3Bfb2xkX2RhdGUlIjoiMjAyMy0wOC0xOCIsInRheG9ub215PWNhdGVnb3J5IjoiR3JlYXQgQmFzaW4gTmF0aW9uYWwgUGFyayIsInRheG9ub215PXBvc3RfdGFnIjoiTmV2YWRhIiwidGF4b25vbXk9cG9zdF9mb3JtYXQiOiIiLCJ0YXhvbm9teT10aGItcmVhY3Rpb25zIjoiIiwidGF4b25vbXk9dGhiLXNwb25zb3JzIjoiIn19LCJpZCI6MTcxOTksImluZm93aW5kb3dfZGlzYWJsZSI6ZmFsc2V9LHsic291cmNlIjoicG9zdCIsInRpdGxlIjoiR3VhZGFsdXBlIE1vdW50YWlucyBOYXRpb25hbCBQYXJrIiwiaW5mb3dpbmRvd19jb250ZW50IjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZyBcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiR3VhZGFsdXBlIE1vdW50YWlucyBOYXRpb25hbCBQYXJrXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMzBcIiBzcmM9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIzLzA4L1RyYWlscy1pbi1HdWFkYWx1cGUtTW91bnRhaW5zLU5hdGlvbmFsLVBhcmstMzAweDIzMC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmcgZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+R3VhZGFsdXBlIE1vdW50YWlucyBOYXRpb25hbCBQYXJrPC9kaXY+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3JcIj57bWFya2VyX2FkZHJlc3N9PC9kaXY+XHJcbiAgICAgICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1jbGVhclwiPjwvZGl2PlxyXG48L2Rpdj4iLCJhZGRyZXNzIjoiRGVsbCBDaXR5LCBUZXhhcyA3OTg0NywgVmVyZW5pZ2RlIFN0YXRlbiIsImxvY2F0aW9uIjp7ImxhdCI6IjMxLjkyMzMzMDI5OTk5OTk5IiwiY2l0eSI6IkRlbGwgQ2l0eSIsInN0YXRlIjoiVGV4YXMiLCJjb3VudHJ5IjoiVmVyZW5pZ2RlIFN0YXRlbiIsImxuZyI6Ii0xMDQuODY2MzEwOSIsIm9uY2xpY2tfYWN0aW9uIjoibWFya2VyIiwicmVkaXJlY3RfcGVybWFsaW5rIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9ndWFkYWx1cGUtbW91bnRhaW5zLW5hdGlvbmFsLXBhcmsvIiwiem9vbSI6MTIsImV4dHJhX2ZpZWxkcyI6eyJwb3N0X2V4Y2VycHQiOiIiLCJwb3N0X2NvbnRlbnQiOiJbdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiMTAwJVwiXVt2Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkd1YWRhbHVwZSBNb3VudGFpbnMgTmF0aW9uYWwgUGFya1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTozNXx0ZXh0X2FsaWduOmxlZnR8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdRGUgc3RhYXQgVGV4YXMgaGVlZnQgZWVuIHR3ZWV0YWwgbmF0aW9uYWxlIHBhcmtlbiwgZGUgYmVrZW5kc3RlIGlzIEJpZyBCZW5kIE5hdGlvbmFsIFBhcmsuIERlIGFuZGVyZSBpcyBoZXQgbWluZGVyIGJla2VuZGUgR3VhZGFsdXBlIE1vdW50YWlucyBOYXRpb25hbCBQYXJrLiBIZXQgbmF0aW9uYWxlIHBhcmsgbGlndCB0ZWdlbiBkZSBncmVucyBtZXQgTmV3IE1leGljbyBlbiBiZXN0YWF0IHZvb3IgaGV0IGdyb290c3RlIGRlZWwgdWl0IHdpbGRlcm5pcy4gRVx1MDBlOW4gdmFuIGRlIHJlZGVuZW4gd2Fhcm9tIGhldCBtaW5kZXIgYmVrZW5kIGlzIGVuIGJlem9jaHQgd29yZHQuIEVyIHppam4gbmlldCB2ZWVsIHZvb3J6aWVuaW5nZW4gaW4gaGV0IHBhcmssIG1hYXIgdG9jaCBlZW4gYWFudGFsIHByYWNodGlnZSBuYXR1dXJsaWprZSBiZXppZW5zd2FhcmRpZ2hlZGVuIGRpZSBkZSBtb2VpdGUgd2FhcmQgemlqbi4gVGlwcyB2b29yIGVlbiBiZXpvZWsgYWFuIGhldCBHdWFkYWx1cGUgTW91bnRhaW5zIE5hdGlvbmFsIFBhcmsuWy92Y19jb2x1bW5fdGV4dF1bdWx0aW1hdGVfaWNvbl9saXN0IGljb25fc2l6ZT1cIjIwXCJdW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy1hdXRvbW9iaWxlIGNhclwiXTgyNSBraWxvbWV0ZXIgdmFuYWYgRGFsbGFzWy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLXRyZWVcIl08c3BhbiBjbGFzcz1cIkxyelhyIGtuby1mdlwiPjM0OSBrbVx1MDBiMiBvcHBlcnZsYWt0ZTwvc3Bhbj5bL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtcGF3XCJdNjAgdmVyc2NoaWxsZW5kZSBzb29ydGVuIGRpZXJlbiwgMjg5IHZlcnNjaGlsbGVuZGUgc29vcnRlbiB2b2dlbHNbL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVsvdWx0aW1hdGVfaWNvbl9saXN0XVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY3NzPVwiLnZjX2N1c3RvbV8xNjA4NjY2NTE5NDkye2JhY2tncm91bmQtY29sb3I6ICNlYWVhZWEgIWltcG9ydGFudDt9XCJdW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIyLzNcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNzVweFwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiRWV1d2Vub3VkZSBnZXNjaGllZGVuaXMgdmFuIGhldCBHdWFkYWx1cGUgTW91bnRhaW5zIE5hdGlvbmFsIFBhcmtcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MzV8dGV4dF9hbGlnbjpjZW50ZXJ8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxwIHN0eWxlPVwidGV4dC1hbGlnbjogY2VudGVyO1wiPkFyY2hlb2xvZ2lzY2ggYmV3aWpzIGhlZWZ0IGFhbmdldG9vbmQgZGF0IGVyIGFsIG1lZXIgZGFuIDEwLjAwMCBqYWFyIG1lbnNlbiBoZWJiZW4gZ2V3b29uZCBpbiBoZXQgZ2ViaWVkIGRhdCBudSBoZXQgR3VhZGFsdXBlIE1vdW50YWlucyBOYXRpb25hbCBQYXJrIGdlbm9lbWQgd29yZHQuIFVpdCBhYXJkZXdlcmssIHJvdHN0ZWtlbmluZ2VuIGVuIGdldm9uZGVuIG1hbmRlbiBibGlqa3QgZGF0IGphZ2VycyBhbCBqYXJlbiBhY3RpZWYgd2FyZW4gaW4gaGV0IGdlYmllZCBlbiBkYXQgZXIgZ3Jvb3Qgd2lsZCByb25kbGllcC4gSW4gZGUgMTZlIGVldXcga3dhbWVuIGRlIGVlcnN0ZSBFdXJvcGVhbmVuIG5hYXIgaGV0IGdlYmllZCwgZGUgU3BhbmphYXJkZW4uIEVjaHRlciB2ZXN0aWdkZW4gemUgemljaCBuaWV0IGluIGhldCBnZWJpZWQsIG1hYXIgZGUgcGFhcmRlbiBkaWUgemUgbWVlbmFtZW4gd2FyZW4gZWVuIGFhbndpbnN0IHZvb3IgZGUgaW5oZWVtc2Ugc3RhbW1lbi48L3A+XHJcblsvdmNfY29sdW1uX3RleHRdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI3NXB4XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIiBmdWxsX3dpZHRoPVwic3RyZXRjaF9yb3dcIiBjb250ZW50X3RleHRfYWxpZ21lbnQ9XCJjZW50ZXJcIiBjc3M9XCIudmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9XCIgcGFyYWxsYXhfYmFja2dyb3VuZF9pbWFnZT1cIjM4MzZcIl1bdmNfY29sdW1uIHRoYl9jb2xvcj1cInRoYi1saWdodC1jb2x1bW5cIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJFbCBDYXB0YWluIEd1YWRhbHVwZSBNb3VudGFpbnMgTmF0aW9uYWwgUGFya1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTo3NXx0ZXh0X2FsaWduOmNlbnRlcnxjb2xvcjolMjNmZmZmZmZ8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1baGV5dXNhX2hlYWRpbmcgdGFnPVwiaDRcIiB0ZXh0X2FsaWduPVwiY2VudGVyXCIgaGVhZGluZz1cIkVsIENhcHRhaW4gdmFyaWFudCB2YW4gWW9zZW1pdGVcIiBmb250X3NpemU9XCI1MFwiIGxpbmVfaGVpZ2h0PVwiMVwiIGZvbnRfY29sb3I9XCIjZmZmZmZmXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3BhcmFsbGF4X3JvdyBlbmFibGVfbW9iaWxlPVwicGFyYWxsYXgtZW5hYmxlLW1vYmlsZVwiIGltYWdlPVwiMTcxNjlcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiXVt2Y19jb2x1bW5dW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkZhY3RzIEd1YWRhbHVwZSBNb3VudGFpbnMgTmF0aW9uYWwgUGFya1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZToyNXx0ZXh0X2FsaWduOmxlZnRcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XUFhbiBoZXQgZWluZGUgdmFuIGRlIEFtZXJpa2FhbnNlIEJ1cmdlcm9vcmxvZyB3ZXJkZW4gZGUgaW5oZWVtc2Ugc3RhbW1lbiB1aXRnZWRhYWdkIGRvb3JkYXQgZXIgZWVuIG5pZXV3ZSB0cmFuc3BvcnRyb3V0ZSBkb29yIGhldCBnZWJpZWQgbGllcC4gRGUgQW1lcmlrYWFuc2UgdHJhbnNwb3J0cm91dGUgYnJhY2h0IHR1c3NlbiAxODQwIGVuIDE4NTAgdmVsZSBpbW1pZ3JhbnRlbiB2YW4gb29zdCBuYWFyIHdlc3QuIERlIHJvdXRlIHdlcmQgcmVnZWxtYXRpZyBkb2Vsd2l0IHZhbiBhYW52YWxsZW4gdmFuIGluaGVlbXNlIHN0YW1tZW4sIHdhYXJkb29yIGVlbiBDYXZhbHJ5IFJlZ2ltZW50IGhldCBiZXZlbCBrcmVlZyBvbSBkZXplIHRlIHN0b3BwZW4uIFR3ZWUga2FtcGVuIHZhbiBNZXNjYWxlcm8gQXBhY2hlIHdlcmRlbiB2ZXJuaWV0aWdkIGVuIG5hYXIgQW1lcmlrYWFuc2UgcmVzZXJ2YXRlbiBnZWRyZXZlbi4gRVx1MDBlOW4gdmFuIGRlIGVlcnN0ZSBFdXJvcGVzZSBrb2xvbmlzdGVuIGluIGhldCBHdWFkYWx1cGUgZ2ViaWVkIHdhcyBGZWxpeCBNY0tpdHRyaWNrIGRpZSBpbiAxODcwIG1ldCB2ZWUgd2Vya3RlLlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiV2F0IHRlIGRvZW4gaW4gR3VhZGFsdXBlIE1vdW50YWlucyBOYXRpb25hbCBQYXJrXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjI1fHRleHRfYWxpZ246bGVmdFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdSG9ld2VsIEd1YWRhbHVwZSBNb3VudGFpbnMgTmF0aW9uYWwgUGFyayBlZW4gcmVsYXRpZWYgb25iZWtlbmRlIGJlemllbnN3YWFyZGlnaGVpZCBpcyBpbiBUZXhhcywgYmV2YXQgaGV0IHdlbCBoZXQgbGV0dGVybGlqa2UgaG9vZ3RlcHVudCB2YW4gZGUgc3RhYXQuIERlIEd1YWRhbHVwZSBwZWFrIGlzIG1ldCAyNjY3IG1ldGVyIGhvb2d0ZSBkZSBob29nc3RlIHBsZWsgdmFuIFRleGFzLiBKZSBrdW50IGRlemUgdHJvdXdlbnMgb29rIGJla2xpbW1lbiB2aWEgZGUgR3VhZGFsdXBlIFBlYWsgVHJhaWwuIEJpaiBoZXQgUGluZSBTcHJpbmdzIFZpc2l0b3IgQ2VudGVyIGtyaWpnIGplIG1lZXIgaW5mb3JtYXRpZSBvdmVyIGhldCBwYXJrIGVuIHRldmVucyBrdW4gamUgZXIgZWVuIGZpbG0ga2lqa2VuLiBBbmRlcmUgaG9vZ3RlcHVudGVuIGluIGhldCBHdWFkYWx1cGUgTmF0aW9uYWwgUGFyayB6aWpuIGRlIEZyaWpvbGUgUmFuY2gsIE1jS2l0dHJpY2sgQ2FueW9uLCBEb2cgQ2FueW9uIGVuIEVsIENhcHRhaW4uIERlIGxhYXRzdGdlbm9lbWRlIGlzIGRlIFRleGFzIHZhcmlhbnQgb3AgZGUgRWwgQ2FwdGFpbiBpbiA8YSBocmVmPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC95b3NlbWl0ZS1uYXRpb25hbC1wYXJrLWNhbGlmb3JuaWUvXCI+WW9zZW1pdGUgTmF0aW9uYWwgUGFyazwvYT4uIEVlbiBtYXNzaWV2ZSByb3RzYmxvayBkYXQgMzAwIG1ldGVyIGJvdmVuIGhldCBsYW5kc2NoYXAgdWl0c3RlZWt0LiBEYWFybmFhc3QgaXMgR3VhZGFsdXBlIE1vdW50YWlucyBOUCBlZW4gd2FsaGFsbGEgdm9vciB2b2dlbGxpZWZoZWJiZXJzLCBtYWFyIGxpZWZzdCAyNjkgdmVyc2NoaWxsZW5kZSBzb29ydGVuIHppam4gZXIgdGUgdmluZGVuLlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJPdmVybmFjaHRlbiBpbiBHdWFkYWx1cGUgTW91bnRhaW5zIE5hdGlvbmFsIFBhcmtcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MjV8dGV4dF9hbGlnbjpsZWZ0XCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1FciB6aWpuIGhldCBHdWFkYWx1cGUgTW91bnRhaW5zIE5hdGlvbmFsIFBhcmsgZ2VlbiBtb2dlbGlqa2hlZGVuIG9tIHRlIG92ZXJuYWNodGVuIGluIGhvdGVscywgbG9kZ2VzIG9mIGNhYmlucy4gRGUgYmVzdGUgcGxlayBkYWFydm9vciBpcyA8YSBocmVmPVwiaHR0cHM6Ly93d3cuYm9va2luZy5jb20vc2VhcmNocmVzdWx0cy5lbi5odG1sP2NpdHk9MjAwMTIwMjcmYW1wO2FpZD03OTU4NDk4JmFtcDtub19yb29tcz0xJmFtcDtncm91cF9hZHVsdHM9MiZhbXA7bGFiZWw9R3VhZGFsdXBlY2Fyc2xiYWRcIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPkNhcmxzYmFkPC9hPiBpbiBOZXcgTWV4aWNvIGluIGhldCBub29yZGVuLCA8YSBocmVmPVwiaHR0cHM6Ly93d3cuYm9va2luZy5jb20vc2VhcmNocmVzdWx0cy5lbi5odG1sP2NpdHk9MjAxMzIwNDgmYW1wO2FpZD03OTU4NDk4JmFtcDtub19yb29tcz0xJmFtcDtncm91cF9hZHVsdHM9MiZhbXA7bGFiZWw9R3VhZGFsdXBldmFuaG9yblwiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+VmFuIEhvcm48L2E+IGluIGhldCB6dWlkZW4gZW4gaW4gaGV0IHp1aWR3ZXN0ZW4gPGEgaHJlZj1cImh0dHBzOi8vd3d3LmJvb2tpbmcuY29tL3NlYXJjaHJlc3VsdHMuZW4uaHRtbD9jaXR5PTIwMTAyNTEwJmFtcDthaWQ9Nzk1ODQ5OCZhbXA7bm9fcm9vbXM9MSZhbXA7Z3JvdXBfYWR1bHRzPTImYW1wO2xhYmVsPUd1YWRhbHVwZWRlbGxjaXR5XCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5EZWwgQ2l0eTwvYT4sIGJlaWRlbiBpbiBUZXhhcy4gSW4gaGV0IHBhcmsgdmluZCBqZSBhbGxlZW4gbW9nZWxpamtoZWRlbiBvbSB0ZSBvdmVybmFjaHRlbiBvcCBcdTAwZTlcdTAwZTluIHZhbiBkZSB0d2VlIGNhbXBpbmdzOiBQaW5lIFNwcmluZ3MgZW4gRG9nIENhbnlvbi4gQmVpZGVuIHppam4gc2ltcGVsZSBjYW1waW5ncywgbWFhciB3ZWwgbWV0IHdhdGVyZmFjaWxpdGVpdGVuIChnZWVuIGRvdWNoZSkgZW4gdG9pbGV0dGVuLiBEZSBjYW1waW5ncyBrdW5uZW4gZ2VyZXNlcnZlZXJkIHdvcmRlbiB2aWEgPGEgaHJlZj1cImh0dHBzOi8vd3d3LnJlY3JlYXRpb24uZ292L1wiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+UmVjcmVhdGlvbi5nb3Y8L2E+LlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiQmVzdGUgcmVpc3BlcmlvZGUgR3VhZGFsdXBlIE1vdW50YWlucyBOYXRpb25hbCBQYXJrXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjI1fHRleHRfYWxpZ246bGVmdFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdRGUgYmVzdGUgcGVyaW9kZSB2b29yIGVlbiBiZXpvZWsgYWFuIGhldCBHdWFkYWx1cGUgTW91bnRhaW5zIE5hdGlvbmFsIFBhcmsgaXMgZGUgaGVyZnN0LiBJbiBkZSB6b21lciBrYW4gaGV0IGVyZyB3YXJtIHppam4gaW4gaGV0IGdlYmllZC4gSW4gZGUgaGVyZnN0IGt1biBqZSBkZSB2ZXJhbmRlcmluZyB2YW4gZGUgYmxhZGVyZW4gbWVlbWFrZW4uIElldHMgZGF0IG92ZXJpZ2VucyByZWRlbGlqayB3YXQgbWVuc2VuIHRyZWt0LCBkdXMgaGV0IGthbiBlciBkcnVrIHppam4uWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiIGZ1bGxfd2lkdGg9XCJzdHJldGNoX3Jvd1wiIGNvbnRlbnRfdGV4dF9hbGlnbWVudD1cImNlbnRlclwiIGNzcz1cIi52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O31cIiBwYXJhbGxheF9iYWNrZ3JvdW5kX2ltYWdlPVwiMzgzNlwiXVt2Y19jb2x1bW4gdGhiX2NvbG9yPVwidGhiLWxpZ2h0LWNvbHVtblwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJUcmFpbHMgaW4gR3VhZGFsdXBlIE1vdW50YWlucyBOYXRpb25hbCBQYXJrXCIgaGVhZGluZ190YWc9XCJwXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiI2ZmZmZmZlwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjQ1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NTVweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjEwcHhcIl1baGV5dXNhX2hlYWRpbmcgdGFnPVwiaDRcIiB0ZXh0X2FsaWduPVwiY2VudGVyXCIgaGVhZGluZz1cIk9udGRlayBoZXQgcGFyayBvcCBlZW4gdmFuIGRlIHdhbmRlbHBhZGVuXCIgZm9udF9zaXplPVwiNTBcIiBsaW5lX2hlaWdodD1cIjFcIiBmb250X2NvbG9yPVwiI2ZmZmZmZlwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVtwYXJhbGxheF9yb3cgZW5hYmxlX21vYmlsZT1cInBhcmFsbGF4LWVuYWJsZS1tb2JpbGVcIiBpbWFnZT1cIjE3MTcxXCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjc3M9XCIudmNfY3VzdG9tXzE2MDg2NjY4ODU0OTd7YmFja2dyb3VuZC1pbWFnZTogdXJsKGh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjAvMDgvYmFja2dyb3VuZC1oZXl1c2EtbmF0dXVyLTEuZ2lmP2lkPTMwODgpICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW5dW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiV2FuZGVsZW4gaW4gR3VhZGFsdXBlIE1vdW50YWlucyBOYXRpb25hbCBQYXJrXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzAwMDAwMFwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjU1cHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF1HdWFkYWx1cGUgTW91bnRhaW5zIE5hdGlvbmFsIFBhcmsga3VuIGplIHByaW1hIHdhbmRlbGVuZCB2ZXJrZW5uZW4uIEVyIHppam4gbWVlciBkYW4gMTI1IGtpbG9tZXRlciBhYW4gdHJhaWxzIHRlIHZpbmRlbiBpbiBoZXQgcGFyay5cdTAwYTAgSmUga3VudCBlciBtYWtrZWxpamtlIHdhbmRlbGluZ2VuIG1ha2VuLCBtYWFyIG9vayBtZWVyZGFhZ3NlIHdhbmRlbGluZ2VuLiBFZW4gYWFudGFsIHdhbmRlbGluZ2VuIGRpZSBqZSBrdW50IG1ha2VuIHppam46XHJcbjx1bD5cclxuIFx0PGxpPlNtaXRoIFNwcmluZyBMb29wIC0gMyw3IGttPC9saT5cclxuIFx0PGxpPkRldmlscyBIYWxsIFRyYWlsIC0gNiwxIGttPC9saT5cclxuIFx0PGxpPkd1YWRhbHVwZSBQZWFrIFRyYWlsIC0gMTMsNiBrbTwvbGk+XHJcbiBcdDxsaT5QaW5lcnkgVHJhaWwgLSAyLDQga208L2xpPlxyXG4gXHQ8bGk+RWwgQ2FwdGFpbiAvIFNhbHQgQmFzaW4gT3Zlcmxvb2sgVHJhaWwgLSAxOCBrbTwvbGk+XHJcbiBcdDxsaT5NY0tpdHRyaWNrIENhbnlvbiBUcmFpbCAtIDExIGttPC9saT5cclxuPC91bD5cclxuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiSGFuZGlnZSBpbmZvIHZvb3IgamUgYmV6b2VrXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzAwMDAwMFwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OlJvYm90byBTbGFifGZvbnRfY2FsbDpSb2JvdG8rU2xhYnx2YXJpYW50OjgwMFwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NTVweDtcIiBtYWluX2hlYWRpbmdfc3R5bGU9XCJmb250LXdlaWdodDo4MDA7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt1bHRpbWF0ZV9pY29uX2xpc3QgaWNvbl9zaXplPVwiMjVcIl1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLWNsb2NrLW9cIiBjb250ZW50X2ZvbnRfc2l6ZT1cImRlc2t0b3A6MTZweDtcIl0yNC83IGVuIDM2NSBkYWdlbiBnZW9wZW5kWy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLXRodW1icy11cFwiIGNvbnRlbnRfZm9udF9zaXplPVwiZGVza3RvcDoxNnB4O1wiXUJlc3RlIHBlcmlvZGU6IGhlcmZzdFsvdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy1kb2xsYXIgdXNkXCIgY29udGVudF9mb250X3NpemU9XCJkZXNrdG9wOjE2cHg7XCJdU3RhbmRhcmQgRW50cmFuY2UgUGFzczogJDEwXHJcbkFubnVhbCBFbnRyYW5jZSBQYXNzOiAkMzVbL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVsvdWx0aW1hdGVfaWNvbl9saXN0XVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIiBmdWxsX3dpZHRoPVwic3RyZXRjaF9yb3dcIiBjb250ZW50X3RleHRfYWxpZ21lbnQ9XCJjZW50ZXJcIiBjc3M9XCIudmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9XCIgcGFyYWxsYXhfYmFja2dyb3VuZF9pbWFnZT1cIjM4MzZcIl1bdmNfY29sdW1uIHRoYl9jb2xvcj1cInRoYi1saWdodC1jb2x1bW5cIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiR3VhZGFsdXBlIFBlYWtcIiBoZWFkaW5nX3RhZz1cInBcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjZmZmZmZmXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6NDVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDo1NXB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMTBweFwiXVtoZXl1c2FfaGVhZGluZyB0YWc9XCJoNFwiIHRleHRfYWxpZ249XCJjZW50ZXJcIiBoZWFkaW5nPVwiRGUgaG9vZ3N0ZSBiZXJnIHZhbiBUZXhhc1wiIGZvbnRfc2l6ZT1cIjUwXCIgbGluZV9oZWlnaHQ9XCIxXCIgZm9udF9jb2xvcj1cIiNmZmZmZmZcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bcGFyYWxsYXhfcm93IGVuYWJsZV9tb2JpbGU9XCJwYXJhbGxheC1lbmFibGUtbW9iaWxlXCIgaW1hZ2U9XCIxNzE3MFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCJdW3ZjX2NvbHVtbl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiTWVlciBuYXRpb25hbGUgcGFya2VuXCIgZm9udF9jb250YWluZXI9XCJ0YWc6ZGl2fGZvbnRfc2l6ZTo0MHx0ZXh0X2FsaWduOmNlbnRlclwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdGhiX3Bvc3RncmlkIHN0eWxlPVwic3R5bGUxMVwiIGNvbHVtbnM9XCI0XCIgc291cmNlPVwicG9zdF90eXBlOnBvc3R8YnlfaWQ6NDczOCw0NzE0LDQ2ODksNDc5MlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XSIsInBvc3RfdGl0bGUiOiJHdWFkYWx1cGUgTW91bnRhaW5zIE5hdGlvbmFsIFBhcmsiLCJwb3N0X2xpbmsiOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL2d1YWRhbHVwZS1tb3VudGFpbnMtbmF0aW9uYWwtcGFyay8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJHdWFkYWx1cGUgTW91bnRhaW5zIE5hdGlvbmFsIFBhcmtcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjIzMFwiIHNyYz1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjMvMDgvVHJhaWxzLWluLUd1YWRhbHVwZS1Nb3VudGFpbnMtTmF0aW9uYWwtUGFyay0zMDB4MjMwLmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6Ikd1YWRhbHVwZSBNb3VudGFpbnMgTmF0aW9uYWwgUGFyayIsInBvc3RfdGFncyI6IlRleGFzIiwiJV93cGJfc2hvcnRjb2Rlc19jdXN0b21fY3NzJSI6Ii52Y19jdXN0b21fMTYwODY2NjUxOTQ5MntiYWNrZ3JvdW5kLWNvbG9yOiAjZWFlYWVhICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNjA4NjY2ODg1NDk3e2JhY2tncm91bmQtaW1hZ2U6IHVybChodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIwLzA4L2JhY2tncm91bmQtaGV5dXNhLW5hdHV1ci0xLmdpZj9pZD0zMDg4KSAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9IiwiJWlubGluZV9mZWF0dXJlZF9pbWFnZSUiOiIwIiwiJV9lZGl0X2xvY2slIjoiMTY5MjI2MTM1NzoyIiwiJV9lZGl0X2xhc3QlIjoiMiIsIiVfdGh1bWJuYWlsX2lkJSI6IjE3MTc5IiwiJV9oaWRlX2ZlYXR1cmVkJSI6bnVsbCwiJV93cGJfdmNfanNfc3RhdHVzJSI6InRydWUiLCIlcG9zdC1wcmltYXJ5LWNhdGVnb3J5JSI6ImF1dG8iLCIlZmVhdHVyZWRfaW1hZ2Vfb3ZlcnJpZGUlIjoib2ZmIiwiJWFydGljbGVfc3R5bGVfb3ZlcnJpZGUlIjoib24iLCIlcG9zdF9zdHlsZSUiOiJzdHlsZTExIiwiJXBvc3RfZ2FsbGVyeV9zdHlsZSUiOiJsaWdodGJveCIsIiVwb3N0X3JldmlldyUiOiJvZmYiLCIlcG9zdF9yZXZpZXdfc3R5bGUlIjoic3R5bGUxIiwiJXBvc3RfcmV2aWV3X2F2ZXJhZ2UlIjoiNTAiLCIlX3lvYXN0X3dwc2VvX2NvbnRlbnRfc2NvcmUlIjoiMzAiLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza2V5d29yZHMlIjoiW10iLCIlX3lvYXN0X3dwc2VvX2tleXdvcmRzeW5vbnltcyUiOiJbXCJcIl0iLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza3clIjoiR3VhZGFsdXBlIE1vdW50YWlucyBOYXRpb25hbCBQYXJrIiwiJV95b2FzdF93cHNlb19tZXRhZGVzYyUiOiJJbiBUZXhhcyBsaWd0IGhldCBHdWFkYWx1cGUgTW91bnRhaW5zIE5hdGlvbmFsIFBhcmssIGVlbiByZWxhdGllZiBvbmJla2VuZGUgYmV6aWVuc3dhYXJkaWdoZWlkIFRpcHMgdm9vciBlZW4gYmV6b2VrIGFhbiBoZXQgR3VhZGFsdXBlIE5hdGlvbmFsIFBhcmsuIiwiJV95b2FzdF93cHNlb19saW5rZGV4JSI6IjgyIiwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6IkRlbGwgQ2l0eSwgVGV4YXMgNzk4NDcsIFZlcmVuaWdkZSBTdGF0ZW4iLCIlX3dwZ21wX2xvY2F0aW9uX2NpdHklIjoiRGVsbCBDaXR5IiwiJV93cGdtcF9sb2NhdGlvbl9zdGF0ZSUiOiJUZXhhcyIsIiVfd3BnbXBfbG9jYXRpb25fY291bnRyeSUiOiJWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9tZXRhYm94X2xhdGl0dWRlJSI6IjMxLjkyMzMzMDI5OTk5OTk5IiwiJV93cGdtcF9tZXRhYm94X2xvbmdpdHVkZSUiOiItMTA0Ljg2NjMxMDkiLCIlX3dwZ21wX21ldGFib3hfbG9jYXRpb25fcmVkaXJlY3QlIjoibWFya2VyIiwiJV93cGdtcF9tZXRhYm94X2N1c3RvbV9saW5rJSI6IiIsIiVfd3BnbXBfbWFwX2lkJSI6ImE6MTp7aTowO3M6MTpcIjdcIjt9IiwiJV93cGdtcF9tZXRhYm94X21hcmtlcl9pZCUiOiIiLCIlX3dwZ21wX21ldGFib3hfdGF4b21vbWllc190ZXJtcyUiOiIiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6IiIsIiVfeW9hc3Rfd3BzZW9fZXN0aW1hdGVkLXJlYWRpbmctdGltZS1taW51dGVzJSI6IjUiLCIlX3lvYXN0X3dwc2VvX3ByaW1hcnlfY2F0ZWdvcnklIjoiMjMxIiwiJV93d3Nfc3VwcG9ydF9jb250YWN0X251bWJlciUiOiIiLCIlX3d3c19hYm91dF9zdXBwb3J0X3RleHQlIjoiIiwiJV93d3NfdHJpZ2dlcl9idXR0b25fdGV4dCUiOiIiLCIlX3d3c19wcmVkZWZpbmVkX3RleHQlIjoiIiwiJV95b2FzdF93cHNlb193b3JkcHJvb2ZfdGltZXN0YW1wJSI6IiIsIiVfeW9hc3RfaW5kZXhub3dfbGFzdF9waW5nJSI6IjE2OTIyNjEzMDIiLCIlX2xhc3RfZWRpdG9yX3VzZWRfamV0cGFjayUiOiJjbGFzc2ljLWVkaXRvciIsInRheG9ub215PWNhdGVnb3J5IjoiR3VhZGFsdXBlIE1vdW50YWlucyBOYXRpb25hbCBQYXJrIiwidGF4b25vbXk9cG9zdF90YWciOiJUZXhhcyIsInRheG9ub215PXBvc3RfZm9ybWF0IjoiIiwidGF4b25vbXk9dGhiLXJlYWN0aW9ucyI6IiIsInRheG9ub215PXRoYi1zcG9uc29ycyI6IiJ9fSwiaWQiOjE3MTU2LCJpbmZvd2luZG93X2Rpc2FibGUiOmZhbHNlfSx7InNvdXJjZSI6InBvc3QiLCJ0aXRsZSI6IkdyYW5kIENhbnlvbiBoZWxpa29wdGVydmx1Y2h0IiwiaW5mb3dpbmRvd19jb250ZW50IjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZyBcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiSGVsaWtvcHRlcnZsdWNodCBpbiBkZSBHcmFuZCBDYW55b25cIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjIyNVwiIHNyYz1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjMvMDgvZ3JhbmQtY2FueW9uLWhlbGlrb3B0ZXJ2bHVjaHQtMzAweDIyNS5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmcgZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+R3JhbmQgQ2FueW9uIGhlbGlrb3B0ZXJ2bHVjaHQ8L2Rpdj5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tY29udGVudCBmYy1pdGVtLWJvZHktdGV4dC1jb2xvclwiPnttYXJrZXJfYWRkcmVzc308L2Rpdj5cclxuICAgICAgICA8L2Rpdj5cclxuICAgIDwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWNsZWFyXCI+PC9kaXY+XHJcbjwvZGl2PiIsImNvbnRlbnQiOiJFZW4gendldmVuZCBwbGF0Zm9ybSB2YW4gZ2xhcyBib3ZlbiBkZSBHcmFuZCBDYW55b24sIGR1cmYgamlqIGhldCBhYW4/IiwiYWRkcmVzcyI6IkdyYW5kIENhbnlvbiwgQXJpem9uYSA4NjA1MiwgVmVyZW5pZ2RlIFN0YXRlbiIsImxvY2F0aW9uIjp7ImxhdCI6IjM2LjA5OTc2MzA5OTk5OTk5Iiwic3RhdGUiOiJBcml6b25hIiwiY291bnRyeSI6IlZlcmVuaWdkZSBTdGF0ZW4iLCJsbmciOiItMTEyLjExMjQ4NDYiLCJvbmNsaWNrX2FjdGlvbiI6Im1hcmtlciIsInJlZGlyZWN0X3Blcm1hbGluayI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvZ3JhbmQtY2FueW9uLWhlbGlrb3B0ZXJ2bHVjaHQvIiwiem9vbSI6MTIsImV4dHJhX2ZpZWxkcyI6eyJwb3N0X2V4Y2VycHQiOiJFZW4gendldmVuZCBwbGF0Zm9ybSB2YW4gZ2xhcyBib3ZlbiBkZSBHcmFuZCBDYW55b24sIGR1cmYgamlqIGhldCBhYW4/IiwicG9zdF9jb250ZW50IjoiW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIl1bdmNfY29sdW1uIHdpZHRoPVwiMS8yXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG5cclxuWy92Y19jb2x1bW5fdGV4dF1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiODUlXCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvMlwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzMHB4XCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJHcmFuZCBDYW55b24gaGVsaWtvcHRlcnZsdWNodFwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTozNXx0ZXh0X2FsaWduOmxlZnR8Y29sb3I6JTIzMDAwMDAwfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XURlIEdyYW5kIENhbnlvbiwgbWlzc2NoaWVuIHdlbCBcdTAwZTlcdTAwZTluIHZhbiBkZSBtb29pc3RlIHBsZWtrZW4gb20gZWVuIGhlbGlrb3B0ZXJ2bHVjaHQgdGUgYm9la2VuLiBIZXQgaXMgZWVuIGZhbnRhc3Rpc2NoZSBlcnZhcmluZyBvbSBkZSBHcmFuZCBDYW55b24gdGUgemllbiB2YW51aXQgZWVuIGhlbGlrb3B0ZXIuIE9udGRlayBkZSBDb2xvcmFkbyBSaXZlciBkaWUga3JvbmtlbHQgZG9vciBkZSBHcmFuZCBDYW55b24gdmFuYWYgZWVuIGhvb2d0ZSB2YW4gbWVlciBkYW4gMTAwMCBtZXRlci5cdTAwYTAgRXIgemlqbiB2ZXJzY2hpbGxlbmRlIGhlbGlrb3B0ZXJ2bHVjaHRlbiBtb2dlbGlqayBpbiBoZXQgR3JhbmQgQ2FueW9uIE5hdGlvbmFsIFBhcmsuIEJla2lqayBoaWVyIGRlIG9wdGllcyB2b29yIGhldCBib2VrZW4gdmFuIGVlbiBoZWxpa29wdGVydmx1Y2h0IG92ZXIgZGUgR3JhbmQgQ2FueW9uLlsvdmNfY29sdW1uX3RleHRdW3VsdGltYXRlX2ljb25fbGlzdCBpY29uX3NpemU9XCIxOFwiIGljb25fbWFyZ2luPVwiMTVcIl1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLWFycm93cy12XCJdMTAwMCBtZXRlciBob29ndGVbL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtZG9sbGFyIHVzZFwiXSQyMzAtJDM2NSBwZXIgcGVyc29vblsvdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dWy91bHRpbWF0ZV9pY29uX2xpc3RdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyBiZ190eXBlPVwiYmdfY29sb3JcIiBiZ19jb2xvcl92YWx1ZT1cIiNlZGVkZWRcIiBjc3M9XCIudmNfY3VzdG9tXzE2MTI5NDk1Mzc1NjR7YmFja2dyb3VuZC1jb2xvcjogI2VkZWRlZCAhaW1wb3J0YW50O31cIl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjIvM1wiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJPdmVyIGhldCBHcmFuZCBDYW55b24gTmF0aW9uYWwgUGFya1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTozNXx0ZXh0X2FsaWduOmNlbnRlcnxjb2xvcjolMjMwMDAwMDBcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48cCBzdHlsZT1cInRleHQtYWxpZ246IGNlbnRlcjtcIj5FZW4gYmV6b2VrIGFhbiBkZSBHcmFuZCBDYW55b24gaXMgXHUwMGU5XHUwMGU5biB2YW4gZGUgbW9vaXN0ZSBlcnZhcmluZ2VuIGluIEFtZXJpa2Egb20gbWVlIHRlIG1ha2VuLiBIZXQgbGFuZHNjaGFwIGlzIG92ZXJ3ZWxkaWdlbmQgb20gdGUgemllbi4gU2luZHMgMTk3OSBiZWhvb3J0IGRlIEdyYW5kIENhbnlvbiB0b3Qgd2VyZWxkZXJmZ29lZCBlbiBpcyBoZXQgXHUwMGU5XHUwMGU5biB2YW4gZGUgemV2ZW4gd2VyZWxkd29uZGVyZW4uIFVpdGtpamtlbiBvdmVyIGRlIGVub3JtZSBjYW55b24gaXMgb3AgaWVkZXJlIHBsZWsgaW4gaGV0IHBhcmsgd2VlciBhbmRlcnMsIGllZGVyZSBrZWVyIHppZSBqZSB3ZWVyIGlldHMgc3BlY3RhY3VsYWlycyB2b29yYmlqIGtvbWVuLiBMYWF0IHN0YWFuIHdhbm5lZXIgamUgZXIgbWV0IGVlbiBoZWxpa29wdGVyIG92ZXJoZWVuIHZsaWVndC4gRWVuIGVydmFyaW5nIG9tIG5vb2l0IHdlZXIgdGUgdmVyZ2V0ZW4hPC9wPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIiBmdWxsX3dpZHRoPVwic3RyZXRjaF9yb3dcIiBjb250ZW50X3RleHRfYWxpZ21lbnQ9XCJjZW50ZXJcIiBjc3M9XCIudmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9XCIgcGFyYWxsYXhfYmFja2dyb3VuZF9pbWFnZT1cIjM4MzZcIl1bdmNfY29sdW1uIHRoYl9jb2xvcj1cInRoYi1saWdodC1jb2x1bW5cIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJPcCAxMDAwIG1ldGVyIGJvdmVuIGRlIEdyYW5kIENhbnlvbiB2bGllZ2VuXCIgZm9udF9jb250YWluZXI9XCJ0YWc6ZGl2fGZvbnRfc2l6ZTo3NXx0ZXh0X2FsaWduOmNlbnRlcnxsaW5lX2hlaWdodDoxLjRcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW2hleXVzYV9oZWFkaW5nIHRhZz1cImRpdlwiIHRleHRfYWxpZ249XCJjZW50ZXJcIiBoZWFkaW5nPVwiRHVyZiBqaWogaGV0IGFhbj9cIiBmb250X3NpemU9XCI1MFwiIGxpbmVfaGVpZ2h0PVwiNTBcIiBmb250X2NvbG9yPVwiI2ZmZmZmZlwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVtwYXJhbGxheF9yb3cgZW5hYmxlX21vYmlsZT1cInBhcmFsbGF4LWVuYWJsZS1tb2JpbGVcIiBpbWFnZT1cIjE3MDY0XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyBkaXNhYmxlX2VsZW1lbnQ9XCJ5ZXNcIl1bdmNfY29sdW1uIHdpZHRoPVwiMi8zXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiVGlja2V0cyB2b29yIFRoZSBHcmFuZCBDYW55b24gU2t5d2Fsa1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTozMHx0ZXh0X2FsaWduOmxlZnR8Y29sb3I6JTIzMDAwMDAwfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XUplIGt1bnQgdm9vciBlZW4gYmV6b2VrIGFhbiBkZSBTa3l3YWxrIHZlcnNjaGlsbGVuZGUgdGlja2V0cyBrb3Blbi4gWm8ga3VuIGplIGVlbiBsb3MgdGlja2V0IGFhbnNjaGFmZmVuIGVuIHplbGYgZGUgcml0IG1ha2VuIHJpY2h0aW5nIGRlIEdyYW5kIENhbnlvbiBTa3l3YWxrLCBtYWFyIGVyIHppam4gb29rIGRpdmVyc2Ugb3B0aWVzIHZvb3IgdG91cnMgcmljaHRpbmcgZGUgU2t5d2FsayBkaWUgYWFuIHRlIHJhZGVuIHppam4uXHJcblxyXG5bL3ZjX2NvbHVtbl90ZXh0XVt1bHRfYnV0dG9ucyBidG5fdGl0bGU9XCJCZXN0ZWwgamUgdGlja2V0c1wiIGJ0bl9saW5rPVwidXJsOmh0dHBzJTNBJTJGJTJGZ3JhbmRjYW55b253ZXN0LmNvbSUyRlwiIGJ0bl9zaXplPVwidWJ0bi1sYXJnZVwiIGJ0bl90aXRsZV9jb2xvcj1cIiNmZmZmZmZcIiBidG5fYmdfY29sb3I9XCIjYjM0YTRjXCIgYnRuX2hvdmVyPVwidWJ0bi1sZWZ0LWJnXCIgYnRuX2JnX2NvbG9yX2hvdmVyPVwiIzUzMWEyM1wiIGJ0bl90aXRsZV9jb2xvcl9ob3Zlcj1cIiNmZmZmZmZcIiBpY29uX3NpemU9XCIzMlwiIGJ0bl9pY29uX3Bvcz1cInVidG4tc2VwLWljb24tYXQtbGVmdFwiIGJ0bl9mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBidG5fZm9udF9zaXplPVwiZGVza3RvcDoxNXB4O1wiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzNcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIlByYWt0aXNjaGUgaW5mb3JtYXRpZVwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTozMHx0ZXh0X2FsaWduOmxlZnR8Y29sb3I6JTIzMDAwMDAwfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3VsdGltYXRlX2ljb25fbGlzdCBpY29uX3NpemU9XCIxOFwiIGljb25fbWFyZ2luPVwiMTVcIl1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLW1hcC1tYXJrZXJcIl08c3Ryb25nPjgwOCBFYWdsZSBQb2ludCBSb2FkLCBQZWFjaCBTcHJpbmdzIEFyaXpvbmE8L3N0cm9uZz5bL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtY2xvY2stb1wiXTxzdHJvbmc+RGFnZWxpamtzIHZhbiAwOC4wMCAtIDE4LjAwIHV1ciwgbGFhdHN0ZSB0aWNrZXRzIHdvcmRlbiByb25kIDE1LjMwIHV1ciB2ZXJrb2NodDwvc3Ryb25nPlsvdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dWy91bHRpbWF0ZV9pY29uX2xpc3RdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIl1bdmNfY29sdW1uXVt2Y19lbXB0eV9zcGFjZV1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMi8zXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiSGVsaWtvcHRlcnZsdWNodCBvdmVyIGRlIEdyYW5kIENhbnlvbiBib2VrZW5cIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjYjM0YTRjXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MzVweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjQwcHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdXHJcbjxwIHN0eWxlPVwidGV4dC1hbGlnbjogY2VudGVyO1wiPkJla2lqayBkZSB2ZXJzY2hpbGxlbmRlIG9wdGllcyB2b29yIGhlbGlrb3B0ZXJ2bHVjaHRlbiBpbmNsdXNpZWYgZGUgcHJpanplbiB2b29yIGVlbiBoZWxpa29wdGVydmx1Y2h0IGluIGRlIEdyYW5kIENhbnlvbjwvcD5cclxuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8zXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiSGVsaWtvcHRlcnZsdWNodCBvdmVyIGRlIFdlc3QgUmltIHZhbiBkZSBHcmFuZCBDYW55b25cIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjYjM0YTRjXCIgYWxpZ25tZW50PVwibGVmdFwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozMHB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIl1bL3VsdGltYXRlX2hlYWRpbmddW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiVmFuYWYgXHUyMGFjMjM2XCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiI2M1OWM0ZFwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyMHB4O1wiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX21hcmdpbj1cIm1hcmdpbi10b3A6NXB4O21hcmdpbi1ib3R0b206NXB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdTWV0IGVlbiBoZWxpa29wdGVyIHZsaWVnZW4gb3ZlciBkZSBXZXN0IFJpbSB2YW4gZGUgR3JhbmQgQ2FueW9uIGVuIG9vayBub2cgZWVucyBvcCBkZSBib2RlbSB2YW4gZGUgR3JhbmQgQ2FueW9uIHN0YWFuPyBEYW4gaXMgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmdldHlvdXJndWlkZS5ubC9raW5nbWFuLWw5ODMyMi9hcml6b25hLWhlbGlrb3B0ZXItZW4tbGFuZGluZ3N0b3VyLWdyYW5kLWNhbnlvbi13ZXN0LXJpbS10MjkxMzY1Lz9wYXJ0bmVyX2lkPURNRDJWTDQmYW1wO3V0bV9tZWRpdW09b25saW5lX3B1Ymxpc2hlciZhbXA7Y21wPWhlbGlrb3B0ZXJ2bHVjaHRncmFuZGNhbnlvbndlc3RyaW1pbnRla3N0XCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5kZXplIHZsdWNodDwvYT4gZ2VzY2hpa3Qgdm9vciBqb3UuIEVlcnN0IGJla2lqayBqZSBkZSBHcmFuZCBDYW55b24gdmFuYWYgb25nZXZlZXIgMTAwMCBtZXRlciBob29ndGUsIGRhYXJuYSBkYWFsIGplIGFmIG5hYXIgZGUgbGFuZGluZ3NwbGFhdHMgb3Agc2xlY2h0cyA5MCBtZXRlciB2YW4gZGUgQ29sb3JhZG8gUml2ZXIuIEhpZXIgaGViIGplIDIwIG1pbnV0ZW4gZGUgdGlqZCBvbSBmb3RvJ3MgdGUgbWFrZW4gdm9vcmRhdCBqZSB0ZXJ1Z3ZsaWVndCBuYWFyIFdlc3QgUmltIEFpcnBvcnQuWy92Y19jb2x1bW5fdGV4dF1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJQcmFrdGlzY2hlIGluZm9ybWF0aWVcIiBoZWFkaW5nX3RhZz1cImRpdlwiIG1haW5faGVhZGluZ19jb2xvcj1cIiMyODI4MjhcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjBweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6Um9ib3RvIFNsYWJ8Zm9udF9jYWxsOlJvYm90bytTbGFifHZhcmlhbnQ6MzAwXCIgbWFpbl9oZWFkaW5nX3N0eWxlPVwiZm9udC13ZWlnaHQ6MzAwO1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdPGI+SGFuZGlnOjwvYj5cdTAwYTAgVmVyZ2VldCBqZSBjYW1lcmEgbmlldCBtZWUgdGUgbmVtZW5cclxuPGI+VmVydHJlazwvYj46IEdyYW5kIENhbnlvbiBXZXN0IEFpcnBvcnRcclxuPGI+TGV0IG9wPC9iPjogQmlqIGRlIGhlbGlrb3B0ZXJ2bHVjaHQgaXMgaGV0IGdld2ljaHQgYmVsYW5ncmlqaywgYmVuIGplIHp3YWFyZGVyIGRhbiAxMzUga2lsbyBkaWVuIGplIDIgcGxla2tlbiB0ZSBrb3Blbi4gS2luZGVyZW4gb3VkZXIgZGFuIDIgamFhciBtb2V0ZW4gZWVuIHppdHBsYWF0cyBrb3Blbi4gSmUgaGVidCBkYWFybmFhc3QgZWVuIHRvZWdhbmdzYmV3aWpzIG5vZGlnIHZvb3IgZGUgR3JhbmQgQ2FueW9uIHdlc3RbL3ZjX2NvbHVtbl90ZXh0XVt1bHRfYnV0dG9ucyBidG5fdGl0bGU9XCJCb2VrIGRlemUgdG91clwiIGJ0bl9saW5rPVwidXJsOmh0dHBzJTNBJTJGJTJGd3d3LmdldHlvdXJndWlkZS5ubCUyRmtpbmdtYW4tbDk4MzIyJTJGYXJpem9uYS1oZWxpa29wdGVyLWVuLWxhbmRpbmdzdG91ci1ncmFuZC1jYW55b24td2VzdC1yaW0tdDI5MTM2NSUyRiUzRnBhcnRuZXJfaWQlM0RETUQyVkw0JTI2dXRtX21lZGl1bSUzRG9ubGluZV9wdWJsaXNoZXIlMjZjbXAlM0RoZWxpa29wdGVydmx1Y2h0Z3JhbmRjYW55b253ZXN0cmltYnV0dG9ufHRpdGxlOkJvZWslMjBkZXplJTIwdG91cnx0YXJnZXQ6X2JsYW5rXCIgYnRuX3RpdGxlX2NvbG9yPVwiI2ZmZmZmZlwiIGJ0bl9iZ19jb2xvcj1cIiNiMzRhNGNcIiBidG5faG92ZXI9XCJ1YnRuLWxlZnQtYmdcIiBidG5fYmdfY29sb3JfaG92ZXI9XCIjNTMxYTIzXCIgaWNvbl9zaXplPVwiMzJcIiBidG5faWNvbl9wb3M9XCJ1YnRuLXNlcC1pY29uLWF0LWxlZnRcIiBidG5fZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgYnRuX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MThweDtcIiBidG5fbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjIwcHg7XCJdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvM1wiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIkhlbGlrb3B0ZXJ2bHVjaHQgb3ZlciBkZSBTb3V0aCBSaW0gdmFuIGRlIEdyYW5kIENhbnlvblwiIG1haW5faGVhZGluZ19jb2xvcj1cIiNiMzRhNGNcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjMwcHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiXVsvdWx0aW1hdGVfaGVhZGluZ11bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJWYW5hZiBcdTIwYWMyOTBcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjYzU5YzRkXCIgYWxpZ25tZW50PVwibGVmdFwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjIwcHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbWFyZ2luPVwibWFyZ2luLXRvcDo1cHg7bWFyZ2luLWJvdHRvbTo1cHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF1NZXQgZGV6ZSA8YSBocmVmPVwiaHR0cHM6Ly93d3cuZ2V0eW91cmd1aWRlLm5sL2dyYW5kLWNhbnlvbi12aWxsYWdlLWwxMTc0NjUvZ3JhbmQtY2FueW9uLWRhbmNlci1oZWxpa29wdGVydG91ci12YW51aXQtc291dGgtcmltLXQ3ODA3Lz9wYXJ0bmVyX2lkPURNRDJWTDQmYW1wO3V0bV9tZWRpdW09b25saW5lX3B1Ymxpc2hlciZhbXA7Y21wPWhlbGlrb3B0ZXJ2bHVjaHRncmFuZGNhbnlvbnNvdXRocmltaW50ZWtzdFwiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+aGVsaWtvcHRlcnZsdWNodDwvYT4gdmxpZWcgamUgb3ZlciBkZSB6dWlkZWxpamtlIHJhbmQgdmFuIGRlIEdyYW5kIENhbnlvbiBlbiBrdW4gamUgb25kZXIgYW5kZXJlIGhldCBLYWliYWIgTmF0aW9uYWwgRm9yZXN0IHppZW4gdmFudWl0IGRlIGx1Y2h0LiBKZSB2bGllZ3QgdmlhIGRlIFRvd2VyIG9mIFJhIG5hYXIgaGV0IG5vb3JkZW4gb20gZGUgRHJhZ29uIENvcnJpZG9yIHRlIGJla2lqa2VuLiBEaXQgaXMgaGV0IGRpZXBzdGUgZGVlbCB2YW4gZGUgR3JhbmQgQ2FueW9uLiBJbiAyNSBtaW51dGVuIHppZSBqZSBwcmFjaHRpZ2Ugcm90c2xhZ2VuIHZhbiBkZSBHcmFuZCBDYW55b24gdmFudWl0IGRlIGx1Y2h0LlsvdmNfY29sdW1uX3RleHRdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiUHJha3Rpc2NoZSBpbmZvcm1hdGllXCIgaGVhZGluZ190YWc9XCJkaXZcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMjgyODI4XCIgYWxpZ25tZW50PVwibGVmdFwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjIwcHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OlJvYm90byBTbGFifGZvbnRfY2FsbDpSb2JvdG8rU2xhYnx2YXJpYW50OjMwMFwiIG1haW5faGVhZGluZ19zdHlsZT1cImZvbnQtd2VpZ2h0OjMwMDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XTxiPkR1dXI6PC9iPlx1MDBhMCAyNSBtaW51dGVuXHJcbjxiPlZlcnRyZWs8L2I+OiAxMDcgQ29yc2FpciBEci4sIEdyYW5kIENhbnlvblxyXG48Yj5MZXQgb3A6IDwvYj5Lb20gbWluaW1hYWwgNDAgbWludXRlbiB2YW4gdGUgdm9yZW4gYmlqIGRlIHRlcm1pbmFsLCBwYXNzYWdpZXJzIGRpZSBtZWVyIGRhbiAxMzUga2lsbyB3ZWdlbiBtb2V0ZW4gMiBzdG9lbGVuIGtvcGVuLlsvdmNfY29sdW1uX3RleHRdW3VsdF9idXR0b25zIGJ0bl90aXRsZT1cIkJvZWsgZGV6ZSB0b3VyXCIgYnRuX2xpbms9XCJ1cmw6aHR0cHMlM0ElMkYlMkZ3d3cuZ2V0eW91cmd1aWRlLm5sJTJGZ3JhbmQtY2FueW9uLXZpbGxhZ2UtbDExNzQ2NSUyRmdyYW5kLWNhbnlvbi1kYW5jZXItaGVsaWtvcHRlcnRvdXItdmFudWl0LXNvdXRoLXJpbS10NzgwNyUyRiUzRnBhcnRuZXJfaWQlM0RETUQyVkw0JTI2dXRtX21lZGl1bSUzRG9ubGluZV9wdWJsaXNoZXIlMjZjbXAlM0RoZWxpa29wdGVydmx1Y2h0Z3JhbmRjYW55b25zb3V0aHJpbWJ1dHRvbnx0aXRsZTpCb2VrJTIwamUlMjB0aWNrZXRzfHRhcmdldDpfYmxhbmtcIiBidG5fdGl0bGVfY29sb3I9XCIjZmZmZmZmXCIgYnRuX2JnX2NvbG9yPVwiI2IzNGE0Y1wiIGJ0bl9ob3Zlcj1cInVidG4tbGVmdC1iZ1wiIGJ0bl9iZ19jb2xvcl9ob3Zlcj1cIiM1MzFhMjNcIiBpY29uX3NpemU9XCIzMlwiIGJ0bl9pY29uX3Bvcz1cInVidG4tc2VwLWljb24tYXQtbGVmdFwiIGJ0bl9mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBidG5fZm9udF9zaXplPVwiZGVza3RvcDoxOHB4O1wiIGJ0bl9saW5lX2hlaWdodD1cImRlc2t0b3A6MjBweDtcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8zXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiSGVsaWtvcHRlcnZsdWNodCBHcmFuZCBDYW55b24gdmFudWl0IExhcyBWZWdhcyBvdmVyIGRlIFdlc3QgUmltXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiI2IzNGE0Y1wiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6MzBweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIlZhbmFmIFx1MjBhYzM2NFwiIG1haW5faGVhZGluZ19jb2xvcj1cIiNjNTljNGRcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjBweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19tYXJnaW49XCJtYXJnaW4tdG9wOjVweDttYXJnaW4tYm90dG9tOjVweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XUJlbiBqZSBpbiBMYXMgVmVnYXMgZW4gd2lsIGplIGVlbiBoZWxpa29wdGVydmx1Y2h0IG1ha2VuIG92ZXIgZGUgR3JhbmQgQ2FueW9uPyBEYW4gaXMgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmdldHlvdXJndWlkZS5ubC9sYXMtdmVnYXMtbDU4L2dyYW5kLWNhbnlvbi1oZWxpa29wdGVyYXZvbnR1dXItd2VzdC1yaW0tdmx1Y2h0LXQ0Mzg1OTcvP3BhcnRuZXJfaWQ9RE1EMlZMNCZhbXA7dXRtX21lZGl1bT1vbmxpbmVfcHVibGlzaGVyJmFtcDtjbXA9aGVsaWtvcHRlcnZsdWNodGdyYW5kY2FueW9ubGFzdmVnYXN3ZXN0cmltaW50ZWtzdFwiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+ZGV6ZSB2bHVjaHQ8L2E+IGVlbiBhYW5yYWRlci4gSmUgd29yZHQgb3BnZWhhYWxkIG1ldCBlZW4gYnVzamUgYmlqIGplIGhvdGVsIGFhbiBkZSBMYXMgVmVnYXMgU3RyaXAgb20gdmVydm9sZ2VucyBlZW4gZm90b3N0b3AgdGUgbWFrZW4gYmlqIGRlIEhvb3ZlciBEYW0gQnlwYXNzIEJyaWRnZS4gRGFhcm5hIHN0YXAgamUgYWFuIGJvb3JkIHZhbiBkZSBoZWxpa29wdGVyIG9tIGRlIHdlc3RyYW5kIHZhbiBkZSBHcmFuZCBDYW55b24gdGUgYmVraWprZW4gdGVyd2lqbCBqZSBvbmRlciBqZSBkZSBDb2xvcmFkbyBSaXZlciB6aWV0IHN0cm9tZW4uIE5hIGVlbiB2bHVjaHQgdmFuIDIwIG1pbnV0ZW4ga29tIGplIHRlcnVnIG9wIGRlIHJhbmNoIHZvb3IgZWVuIGx1bmNoLiBKZSBrdW50IGV2ZW50dWVlbCBqZSB0cmlwIG5vZyB1aXRicmVpZGVuIG1ldCBlZW4gcml0amUgcGVyIHBhYXJkIG9mIEFUVi5bL3ZjX2NvbHVtbl90ZXh0XVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIlByYWt0aXNjaGUgaW5mb3JtYXRpZVwiIGhlYWRpbmdfdGFnPVwiZGl2XCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzI4MjgyOFwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyMHB4O1wiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpSb2JvdG8gU2xhYnxmb250X2NhbGw6Um9ib3RvK1NsYWJ8dmFyaWFudDozMDBcIiBtYWluX2hlYWRpbmdfc3R5bGU9XCJmb250LXdlaWdodDozMDA7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF08Yj5EdXVyOiA8L2I+Nyw1LTggdXVyXHUwMGEwPGI+XHJcbkhhbmRpZzo8L2I+XHUwMGEwIE9waGFsZW4gYmlqIGRlIG1lZXN0ZSBob3RlbHMsIGx1bmNoIGluYmVncmVwZW5cclxuPGI+VmVydHJlazwvYj46IEVpZ2VuIGhvdGVsXHJcbjxiPkxldCBvcDwvYj46IFBlcnNvbmVuIHp3YWFyZGVyIGRhbiAxMzUga2lsbyBtb2V0ZW4gZWVuIGV4dHJhIHN0b2VsIGtvcGVuWy92Y19jb2x1bW5fdGV4dF1bdWx0X2J1dHRvbnMgYnRuX3RpdGxlPVwiQm9layBkZXplIHRvdXJcIiBidG5fbGluaz1cInVybDpodHRwcyUzQSUyRiUyRnd3dy5nZXR5b3VyZ3VpZGUubmwlMkZsYXMtdmVnYXMtbDU4JTJGZ3JhbmQtY2FueW9uLWhlbGlrb3B0ZXJhdm9udHV1ci13ZXN0LXJpbS12bHVjaHQtdDQzODU5NyUyRiUzRnBhcnRuZXJfaWQlM0RETUQyVkw0JTI2dXRtX21lZGl1bSUzRG9ubGluZV9wdWJsaXNoZXIlMjZjbXAlM0RoZWxpa29wdGVydmx1Y2h0Z3JhbmRjYW55b25sYXN2ZWdhc3dlc3RyaW1idXR0b258dGl0bGU6Qm9layUyMGRlemUlMjB0b3VyfHRhcmdldDpfYmxhbmtcIiBidG5fdGl0bGVfY29sb3I9XCIjZmZmZmZmXCIgYnRuX2JnX2NvbG9yPVwiI2IzNGE0Y1wiIGJ0bl9ob3Zlcj1cInVidG4tbGVmdC1iZ1wiIGJ0bl9iZ19jb2xvcl9ob3Zlcj1cIiM1MzFhMjNcIiBpY29uX3NpemU9XCIzMlwiIGJ0bl9pY29uX3Bvcz1cInVidG4tc2VwLWljb24tYXQtbGVmdFwiIGJ0bl9mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBidG5fZm9udF9zaXplPVwiZGVza3RvcDoxOHB4O1wiIGJ0bl9saW5lX2hlaWdodD1cImRlc2t0b3A6MjBweDtcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTUlXCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiIGZ1bGxfd2lkdGg9XCJzdHJldGNoX3Jvd1wiIGNvbnRlbnRfdGV4dF9hbGlnbWVudD1cImNlbnRlclwiIGNzcz1cIi52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O31cIiBwYXJhbGxheF9iYWNrZ3JvdW5kX2ltYWdlPVwiMzgzNlwiXVt2Y19jb2x1bW4gdGhiX2NvbG9yPVwidGhiLWxpZ2h0LWNvbHVtblwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIk9wdGllcyBoZWxpa29wdGVydmx1Y2h0ZW4gaW4gZGUgR3JhbmQgQ2FueW9uXCIgZm9udF9jb250YWluZXI9XCJ0YWc6ZGl2fGZvbnRfc2l6ZTo3NXx0ZXh0X2FsaWduOmNlbnRlcnxsaW5lX2hlaWdodDoxLjZcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1baGV5dXNhX2hlYWRpbmcgdGFnPVwiZGl2XCIgdGV4dF9hbGlnbj1cImNlbnRlclwiIGhlYWRpbmc9XCJCaWogc29tbWlnZSB2bHVjaHRlbiBrdW4gamUgbGFuZGVuIGluIGRlIEdyYW5kIENhbnlvblwiIGZvbnRfc2l6ZT1cIjUwXCIgbGluZV9oZWlnaHQ9XCI1MFwiIGZvbnRfY29sb3I9XCIjZmZmZmZmXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3BhcmFsbGF4X3JvdyBlbmFibGVfbW9iaWxlPVwicGFyYWxsYXgtZW5hYmxlLW1vYmlsZVwiIGltYWdlPVwiMTcwNjVcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW5dW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJBbmRlcmUgYXJ0aWtlbGVuIG92ZXIgZGUgR3JhbmQgQ2FueW9uXCIgZm9udF9jb250YWluZXI9XCJ0YWc6ZGl2fGZvbnRfc2l6ZTo1NXx0ZXh0X2FsaWduOmNlbnRlcnxjb2xvcjolMjMwMDAwMDBcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bdGhiX3Bvc3RncmlkIHN0eWxlPVwic3R5bGUyMFwiIGNvbHVtbnM9XCI0XCIgc291cmNlPVwicG9zdF90eXBlOnBvc3R8YnlfaWQ6MzIyMywzMjA4LDE5NzEsMTMxNzlcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd10iLCJwb3N0X3RpdGxlIjoiR3JhbmQgQ2FueW9uIGhlbGlrb3B0ZXJ2bHVjaHQiLCJwb3N0X2xpbmsiOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL2dyYW5kLWNhbnlvbi1oZWxpa29wdGVydmx1Y2h0LyIsInBvc3RfZmVhdHVyZWRfaW1hZ2UiOiI8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIkhlbGlrb3B0ZXJ2bHVjaHQgaW4gZGUgR3JhbmQgQ2FueW9uXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMjVcIiBzcmM9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIzLzA4L2dyYW5kLWNhbnlvbi1oZWxpa29wdGVydmx1Y2h0LTMwMHgyMjUuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+IiwicG9zdF9jYXRlZ29yaWVzIjoiR3JhbmQgQ2FueW9uIE5hdGlvbmFsIFBhcmsiLCJwb3N0X3RhZ3MiOiJBcml6b25hIiwiJV93cGJfc2hvcnRjb2Rlc19jdXN0b21fY3NzJSI6Ii52Y19jdXN0b21fMTYxMjk0OTUzNzU2NHtiYWNrZ3JvdW5kLWNvbG9yOiAjZWRlZGVkICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9IiwiJV9lZGl0X2xhc3QlIjoiMTAiLCIlX2VkaXRfbG9jayUiOiIxNzEzNjAzNTUyOjEwIiwiJV93cGJfdmNfanNfc3RhdHVzJSI6InRydWUiLCIlcG9zdC1wcmltYXJ5LWNhdGVnb3J5JSI6IjY1IiwiJWZlYXR1cmVkX2ltYWdlX292ZXJyaWRlJSI6Im9mZiIsIiVhcnRpY2xlX3N0eWxlX292ZXJyaWRlJSI6Im9uIiwiJXBvc3Rfc3R5bGUlIjoic3R5bGU1IiwiJXBvc3RfZ2FsbGVyeV9zdHlsZSUiOiJsaWdodGJveCIsIiVwb3N0X3JldmlldyUiOiJvZmYiLCIlcG9zdF9yZXZpZXdfc3R5bGUlIjoic3R5bGUxIiwiJXBvc3RfcmV2aWV3X2F2ZXJhZ2UlIjoiNTAiLCIlc3RhbmRhcmQtZmVhdHVyZWQtY3JlZGl0JSI6IiIsIiVfaGlkZV9mZWF0dXJlZCUiOm51bGwsIiVwb3N0X3NvdXJjZSUiOiIiLCIlX3RodW1ibmFpbF9pZCUiOiIxNzA2MyIsIiVfeW9hc3Rfd3BzZW9fZm9jdXNrdyUiOiJHcmFuZCBDYW55b24gaGVsaWtvcHRlcnZsdWNodCIsIiVfeW9hc3Rfd3BzZW9fdGl0bGUlIjoiR3JhbmQgQ2FueW9uIGhlbGlrb3B0ZXJ2bHVjaHQgJSVwYWdlJSUgJSVzZXAlJSAlJXNpdGVuYW1lJSUiLCIlX3lvYXN0X3dwc2VvX21ldGFkZXNjJSI6IkdyYW5kIENhbnlvbiBoZWxpa29wdGVydmx1Y2h0IGlzIGVlbiB2YW4gZGUgZ2FhZnN0ZSBlcnZhcmluZ2VuIGluIGRlIGJ1dXJ0IHZhbiBkZSBHcmFuZCBDYW55b24uIFN0YXAgaW4gZGUgaGVsaWtvcHRlciB2b29yIGVlbiBmYW50YXN0aXNjaCB1aXR6aWNodCEiLCIlX3lvYXN0X3dwc2VvX2xpbmtkZXglIjoiNzUiLCIlX3lvYXN0X3dwc2VvX2NvbnRlbnRfc2NvcmUlIjoiNjAiLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza2V5d29yZHMlIjoiW10iLCIlX3lvYXN0X3dwc2VvX2tleXdvcmRzeW5vbnltcyUiOiJbXCJcIl0iLCIlaW5saW5lX2ZlYXR1cmVkX2ltYWdlJSI6IjAiLCIlX3dwZ21wX2xvY2F0aW9uX2FkZHJlc3MlIjoiR3JhbmQgQ2FueW9uLCBBcml6b25hIDg2MDUyLCBWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9sb2NhdGlvbl9jaXR5JSI6IiIsIiVfd3BnbXBfbG9jYXRpb25fc3RhdGUlIjoiQXJpem9uYSIsIiVfd3BnbXBfbG9jYXRpb25fY291bnRyeSUiOiJWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9tZXRhYm94X2xhdGl0dWRlJSI6IjM2LjA5OTc2MzA5OTk5OTk5IiwiJV93cGdtcF9tZXRhYm94X2xvbmdpdHVkZSUiOiItMTEyLjExMjQ4NDYiLCIlX3dwZ21wX21ldGFib3hfbG9jYXRpb25fcmVkaXJlY3QlIjoibWFya2VyIiwiJV93cGdtcF9tZXRhYm94X2N1c3RvbV9saW5rJSI6IiIsIiVfd3BnbXBfbWFwX2lkJSI6ImE6MTp7aTowO3M6MTpcIjdcIjt9IiwiJV93cGdtcF9tZXRhYm94X21hcmtlcl9pZCUiOiJhOjE6e2k6MDtzOjE6XCI1XCI7fSIsIiVfd3BnbXBfbWV0YWJveF90YXhvbW9taWVzX3Rlcm1zJSI6IiIsIiVfd3BnbXBfZXh0ZW5zaW9uc19maWVsZHMlIjoiIiwiJV95b2FzdF93cHNlb19lc3RpbWF0ZWQtcmVhZGluZy10aW1lLW1pbnV0ZXMlIjoiNiIsIiVfd3dzX3N1cHBvcnRfY29udGFjdF9udW1iZXIlIjoiIiwiJV93d3NfYWJvdXRfc3VwcG9ydF90ZXh0JSI6IiIsIiVfd3dzX3RyaWdnZXJfYnV0dG9uX3RleHQlIjoiIiwiJV93d3NfcHJlZGVmaW5lZF90ZXh0JSI6IiIsIiVfeW9hc3Rfd3BzZW9fd29yZHByb29mX3RpbWVzdGFtcCUiOiIiLCIlX3lvYXN0X3dwc2VvX3ByaW1hcnlfY2F0ZWdvcnklIjoiMzMiLCIlX3lvYXN0X2luZGV4bm93X2xhc3RfcGluZyUiOiIxNzEzNjAzNDQ5IiwiJV9sYXN0X2VkaXRvcl91c2VkX2pldHBhY2slIjoiY2xhc3NpYy1lZGl0b3IiLCIlYWN0aXZlZXJfc3VibWVudSUiOiIwIiwiJV9hY3RpdmVlcl9zdWJtZW51JSI6ImZpZWxkXzY1OTNmNTIxZTk3YzIiLCJ0YXhvbm9teT1jYXRlZ29yeSI6IkdyYW5kIENhbnlvbiBOYXRpb25hbCBQYXJrIiwidGF4b25vbXk9cG9zdF90YWciOiJBcml6b25hIiwidGF4b25vbXk9cG9zdF9mb3JtYXQiOiIiLCJ0YXhvbm9teT10aGItcmVhY3Rpb25zIjoiIiwidGF4b25vbXk9dGhiLXNwb25zb3JzIjoiIn0sImljb24iOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIxLzA0L2JlemllbnN3YWFyZGlnaGVpZC5wbmcifSwiaWQiOjE3MDYwLCJpbmZvd2luZG93X2Rpc2FibGUiOmZhbHNlLCJjYXRlZ29yaWVzIjpbeyJpY29uIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMS8wNC9iZXppZW5zd2FhcmRpZ2hlaWQucG5nIiwibmFtZSI6IkJlemllbnN3YWFyZGlnaGVkZW4iLCJpZCI6IjUiLCJ0eXBlIjoiY2F0ZWdvcnkiLCJleHRlbnNpb25fZmllbGRzIjp7ImNhdF9vcmRlciI6IiJ9fV19LHsic291cmNlIjoicG9zdCIsInRpdGxlIjoiUmlzZU5ZIG9wIFRpbWVzIFNxdWFyZSIsImluZm93aW5kb3dfY29udGVudCI6IjxkaXYgY2xhc3M9XCJmYy1pdGVtLWJveCBmYy1pdGVtLW5vLXBhZGRpbmcgXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIkRlIHZsdWNodHNpbXVsYXRvciBhdHRyYWN0aWUgUmlzZU5ZIG9wIFRpbWVzIFNxdWFyZVwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMy8wNy9yaXNlbnktdGltZXMtc3F1YXJlLW1hbmhhdHRhbi0zMDB4MjAwLmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmdcIj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZyBmYy1pdGVtLW5vLXBhZGRpbmdcIj5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tdGl0bGUgZmMtaXRlbS1wcmltYXJ5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2VcIj5SaXNlTlkgb3AgVGltZXMgU3F1YXJlPC9kaXY+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3JcIj57bWFya2VyX2FkZHJlc3N9PC9kaXY+XHJcbiAgICAgICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1jbGVhclwiPjwvZGl2PlxyXG48L2Rpdj4iLCJhZGRyZXNzIjoiMTYwIFcgNDV0aCBTdCwgTmV3IFlvcmssIE5ZIDEwMDM2LCBWZXJlbmlnZGUgU3RhdGVuIiwibG9jYXRpb24iOnsibGF0IjoiNDAuNzU3NjIwNjk5OTk5OTkiLCJjaXR5IjoiTmV3IFlvcmsiLCJzdGF0ZSI6Ik5ldyBZb3JrIiwiY291bnRyeSI6IlZlcmVuaWdkZSBTdGF0ZW4iLCJsbmciOiItNzMuOTg1MTc2MDk5OTk5OTkiLCJvbmNsaWNrX2FjdGlvbiI6Im1hcmtlciIsInJlZGlyZWN0X3Blcm1hbGluayI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvcmlzZW55LW9wLXRpbWVzLXNxdWFyZS8iLCJ6b29tIjoxMiwiZXh0cmFfZmllbGRzIjp7InBvc3RfZXhjZXJwdCI6IiIsInBvc3RfY29udGVudCI6Ilt2Y19yb3ddW3ZjX2NvbHVtbl1baGV5dXNhX2hlYWRpbmcgdGFnPVwiZGl2XCIgdGV4dF9hbGlnbj1cImNlbnRlclwiIGhlYWRpbmc9XCJWbGllZyBvdmVyIE5ldyBZb3JrXCIgZm9udF9zaXplPVwiNTVcIiBsaW5lX2hlaWdodD1cIjYwXCIgZm9udF9jb2xvcj1cIiNiMzRhNGNcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMi8zXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJPbnRkZWsgUmlzZU5ZIG9wIFRpbWVzIFNxdWFyZVwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTo0NXx0ZXh0X2FsaWduOmNlbnRlcnxjb2xvcjolMjMyODI4Mjh8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxwIHN0eWxlPVwidGV4dC1hbGlnbjogY2VudGVyO1wiPjxhIGhyZWY9XCJodHRwczovL3d3dy5nZXR5b3VyZ3VpZGUubmwvbmV3LXlvcmstbDU5L25ldy15b3JrLWNpdHktcmlzZW55LWV4cGVyaWVuY2UtdGlja2V0LXQzNjk3OTYvP3BhcnRuZXJfaWQ9RE1EMlZMNCZhbXA7dXRtX21lZGl1bT1vbmxpbmVfcHVibGlzaGVyJmFtcDtjbXA9aGV5dXNhLXdlYnNpdGUtcmlzZW55XCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5SaXNlTlk8L2E+IG9wIFRpbWVzIFNxdWFyZSBpbiBOZXcgWW9yayBpcyBkXHUwMGU5IG5pZXV3c3RlIGF0dHJhY3RpZSBlbiBlcnZhcmluZyBpbiBNYW5oYXR0YW4uIEplIG9udGRla3QgZGUgc3RhZCB2YW51aXQgZWVuIGhlZWwgYW5kZXIgcGVyc3BlY3RpZWY6IGRhdCB2YW4gZWVuIHZvZ2VsLiBUaWpkZW5zIDxhIGhyZWY9XCJodHRwczovL3d3dy5nZXR5b3VyZ3VpZGUubmwvbmV3LXlvcmstbDU5L25ldy15b3JrLWNpdHktcmlzZW55LWV4cGVyaWVuY2UtdGlja2V0LXQzNjk3OTYvP3BhcnRuZXJfaWQ9RE1EMlZMNCZhbXA7dXRtX21lZGl1bT1vbmxpbmVfcHVibGlzaGVyJmFtcDtjbXA9aGV5dXNhLXdlYnNpdGUtcmlzZW55XCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5lZW4gdW5pZWtlIHZsdWNodDwvYT4gdmxpZWcgamUgbGFuZ3MgZGUgdmVyc2NoaWxsZW5kZSBhdHRyYWN0aWVzIGVuIGJlemllbnN3YWFyZGlnaGVkZW4gdmFuIE5ldyBZb3JrLiBUaWpkZW5zIGRlemUgdmx1Y2h0IGVydmFhciBqZSBlZmZlY3RlbiBhbHMgd2luZCwgd2F0ZXIgZW4gZ2V1ciB3YWFyZG9vciBkZSB2bHVjaHQgblx1MDBmM2cgcmVhbGlzdGlzY2hlciB3b3JkdC4gRWVuIHZlcmdlbGlqa2JhcmUgYXR0cmFjdGllIGt1biBqZSB2aW5kZW4gaW4gV2FsdCBEaXNuZXkgV29ybGQ6IFNvYXJpbicgaW4gRXBjb3QuPC9wPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVt1bHRfYnV0dG9ucyBidG5fdGl0bGU9XCJUSUNLRVRTXCIgYnRuX2xpbms9XCJ1cmw6aHR0cHMlM0ElMkYlMkZ3d3cuZ2V0eW91cmd1aWRlLm5sJTJGbmV3LXlvcmstbDU5JTJGbmV3LXlvcmstY2l0eS1yaXNlbnktZXhwZXJpZW5jZS10aWNrZXQtdDM2OTc5NiUyRiUzRnBhcnRuZXJfaWQlM0RETUQyVkw0JTI2dXRtX21lZGl1bSUzRG9ubGluZV9wdWJsaXNoZXIlMjZjbXAlM0RoZXl1c2Etd2Vic2l0ZS1yaXNlbnl8dGl0bGU6UmlzZU5ZJTIwVGlja2V0c3x0YXJnZXQ6X2JsYW5rXCIgYnRuX2FsaWduPVwidWJ0bi1jZW50ZXJcIiBidG5fdGl0bGVfY29sb3I9XCIjZmZmZmZmXCIgYnRuX2JnX2NvbG9yPVwiI2IzNGE0Y1wiIGJ0bl9ob3Zlcj1cInVidG4tbGVmdC1iZ1wiIGJ0bl9iZ19jb2xvcl9ob3Zlcj1cIiM1MzFhMjNcIiBpY29uX3NpemU9XCIzMlwiIGJ0bl9pY29uX3Bvcz1cInVidG4tc2VwLWljb24tYXQtbGVmdFwiIGJ0bl9mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBidG5fZm9udF9zaXplPVwiZGVza3RvcDoxOHB4O1wiIGJ0bl9saW5lX2hlaWdodD1cImRlc2t0b3A6MjBweDtcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjk1JVwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIiBjc3M9XCIudmNfY3VzdG9tXzE2OTA4MTkxOTIyNTZ7YmFja2dyb3VuZC1jb2xvcjogIzAwMDAwMCAhaW1wb3J0YW50O31cIl1bdmNfY29sdW1uXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVtoZXl1c2FfaGVhZGluZyB0YWc9XCJkaXZcIiB0ZXh0X2FsaWduPVwiY2VudGVyXCIgaGVhZGluZz1cIlVuaWVrZSBhdHRyYWN0aWVzIGluIGRlIEJpZyBBcHBsZVwiIGZvbnRfc2l6ZT1cIjU1XCIgbGluZV9oZWlnaHQ9XCI2MFwiIGZvbnRfY29sb3I9XCIjZmZmZmZmXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJWbGllZyBhbHMgZWVuIHZvZ2VsIG92ZXIgTmV3IFlvcmtcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoM3xmb250X3NpemU6NDV8dGV4dF9hbGlnbjpjZW50ZXJ8Y29sb3I6JTIzZmZmZmZmfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3BhcmFsbGF4X3JvdyBvcGFjaXR5PVwiOTBcIiBpbWFnZT1cIjE2OTcxXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjEwMCVcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IGNzcz1cIi52Y19jdXN0b21fMTY4ODk3NzA3MDU0MntiYWNrZ3JvdW5kLWNvbG9yOiAjZjdmN2Y3ICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW5dW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTUlXCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjIvM1wiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiVm9nZWx2bHVjaHQgb3ZlciBOZXcgWW9yayBtZXQgUmlzZU5ZXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjQ1fHRleHRfYWxpZ246Y2VudGVyfGNvbG9yOiUyMzI4MjgyOHxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1cclxuPHAgc3R5bGU9XCJ0ZXh0LWFsaWduOiBjZW50ZXI7XCI+RGUgd2luZCBkb29yIGplIGhhcmVuLCB3YXRlcnNwZXR0ZXJzIGVuIGRlIGdldXJlbiB2YW4gTmV3IFlvcmsgQ2l0eS4gVGlqZGVucyBkZXplIGlubm92YXRpZXZlIHZsdWNodHNpbXVsYXRpZSB2bGllZyBqZSBvdmVyIE5ldyBZb3JrLiBIZXQgZW5vcm1lIHZpZGVvc2NoZXJtIHZhbiBSaXNlTlkgaW4gY29tYmluYXRpZSBtZXQgamUgYmV3ZWdlbmRlIHN0b2VsIGRvZXQgamUgaGVsZW1hYWwgdmVyZ2V0ZW4gZGF0IGRpdCBuaWV0IFx1MDBlOWNodCBpcy4gSmUgbmVlbXQgcGxhYXRzIGluIGVlbiBzdG9lbCBlbiB2bGllZ3QgZG9vciBkZSBzdGFkLiBFZW4gNERYIElNQVgtZXJ2YXJpbmcgbWV0IHdpbmQsIG1pc3QsIGdldXIsIHdhdGVyIGluIGVlbiBiZXdlZ2VuZGUgc3RvZWwuPC9wPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVt1bHRfYnV0dG9ucyBidG5fdGl0bGU9XCJUSUNLRVRTXCIgYnRuX2xpbms9XCJ1cmw6aHR0cHMlM0ElMkYlMkZ3d3cuZ2V0eW91cmd1aWRlLm5sJTJGbmV3LXlvcmstbDU5JTJGbmV3LXlvcmstY2l0eS1yaXNlbnktZXhwZXJpZW5jZS10aWNrZXQtdDM2OTc5NiUyRiUzRnBhcnRuZXJfaWQlM0RETUQyVkw0JTI2dXRtX21lZGl1bSUzRG9ubGluZV9wdWJsaXNoZXIlMjZjbXAlM0RoZXl1c2Etd2Vic2l0ZS1yaXNlbnl8dGl0bGU6UmlzZU5ZJTIwVGlja2V0c3x0YXJnZXQ6X2JsYW5rXCIgYnRuX2FsaWduPVwidWJ0bi1jZW50ZXJcIiBidG5fdGl0bGVfY29sb3I9XCIjZmZmZmZmXCIgYnRuX2JnX2NvbG9yPVwiI2IzNGE0Y1wiIGJ0bl9ob3Zlcj1cInVidG4tbGVmdC1iZ1wiIGJ0bl9iZ19jb2xvcl9ob3Zlcj1cIiM1MzFhMjNcIiBpY29uX3NpemU9XCIzMlwiIGJ0bl9pY29uX3Bvcz1cInVidG4tc2VwLWljb24tYXQtbGVmdFwiIGJ0bl9mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBidG5fZm9udF9zaXplPVwiZGVza3RvcDoxOHB4O1wiIGJ0bl9saW5lX2hlaWdodD1cImRlc2t0b3A6MjBweDtcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW3ZjX2VtcHR5X3NwYWNlXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIiBjc3M9XCIudmNfY3VzdG9tXzE2OTA4MTcwNzI4Nzl7YmFja2dyb3VuZC1jb2xvcjogIzAwMDAwMCAhaW1wb3J0YW50O31cIl1bdmNfY29sdW1uXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVtoZXl1c2FfaGVhZGluZyB0YWc9XCJkaXZcIiB0ZXh0X2FsaWduPVwiY2VudGVyXCIgaGVhZGluZz1cIk1lbW9yYWJpbGlhIHZhbiB0ZWxldmlzaWUsIGZpbG0sIG1vZGUsIG11emllayAmYW1wOyBCcm9hZHdheVwiIGZvbnRfc2l6ZT1cIjU1XCIgbGluZV9oZWlnaHQ9XCI2MFwiIGZvbnRfY29sb3I9XCIjZmZmZmZmXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJPbnRkZWsgZGUgaG9vZ3RlcHVudGVuIHZhbiBOZXcgWW9yayBpbiBSaXNlTllcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoM3xmb250X3NpemU6NDV8dGV4dF9hbGlnbjpjZW50ZXJ8Y29sb3I6JTIzZmZmZmZmfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3BhcmFsbGF4X3JvdyBvcGFjaXR5PVwiODVcIiBpbWFnZT1cIjE2OTcyXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjEwMCVcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IGNzcz1cIi52Y19jdXN0b21fMTY5MDgxOTI4NTMxN3tiYWNrZ3JvdW5kLWNvbG9yOiAjZjJmMmYyICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW5dW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzNcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIlRIRU1BUlVJTVRFU1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgzfGZvbnRfc2l6ZToyNXx0ZXh0X2FsaWduOmxlZnR8Y29sb3I6JTIzMjgyODI4fGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XVZvb3JkYXQgamUgUmlzZU5ZIHZsdWNodCBiZWdpbnQgb250ZGVrIGplIE5ldyBZb3JrIHZpYSB6ZXZlbiB2ZXJzY2hpbGxlbmRlIHphbGVuIGRpZSBlbGsgZWVuIGVpZ2VuIHRoZW1hIGhlYmJlbi4gVmFuIHRlbGV2aXNpZSB0b3QgQnJvYWR3YXksIGZpbG0sIG1vZGUsIG11emllayBlbiBkZSBza3lsaW5lIHZhbiBOZXcgWW9yay4gSW4gZGV6ZSBtaW5pLWV4cG9zaXRpZXMga29tIGplIG1lZXIgdGUgd2V0ZW4gb3ZlciBkZXplIHRoZW1hJ3MgbWFhciB2aW5kIGplIG9vayBiZXJvZW1kZSBpY29uZW4gdmFuIE5ldyBZb3JrLiBab2FscyBkZSBiYW5rIHZhbiBkZSB0ZWxldmlzaWVzZXJpZSBGcmllbmRzLCBvcCBkZSBzZXQgdmFuIGRlIGxhdGUgbmlnaHQgc2hvdyBlbiBrb3N0dXVtcyB1aXQgbXVzaWNhbHMuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8zXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJJbnRyb2R1Y3RpZWZpbG0gaW5nZXNwcm9rZW4gZG9vciBhY3RldXIgSmVmZiBHb2xkYmx1bVwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgzfGZvbnRfc2l6ZToyNXx0ZXh0X2FsaWduOmxlZnR8Y29sb3I6JTIzMjgyODI4fGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XVZvb3JkYXQgamUgUmlzZU5ZIGF2b250dXVyIGJlZ2ludCwgc3RhcnQgamUgaW4gZGUgbmFnZWJvdXdkZSBtZXRyb2hhbHRlIENpdHkgSGFsbCB2YW4gTmV3IFlvcmsgd2FhciBqZSBlZW4ga29ydGUgZmlsbSBrcmlqZ3QgdGUgemllbiB2YW4gZGUgYmVrcm9vbmRlIGRvY3VtZW50YWlyZW1ha2VyIFJpYyBCdXJucy4gRGUgZmlsbSB3b3JkdCB2ZXJ0ZWxkIGRvb3IgYWN0ZXVyIEplZmYgR29sZGJsdW0sIGJla2VuZCB2YW4gSnVyYXNzaWMgUGFyay5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzNcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIklkZWFhbCB2b29yIHRpamRlbnMgZWVuIHJlZ2VuYWNodGlnZSBkYWdcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoM3xmb250X3NpemU6MjV8dGV4dF9hbGlnbjpsZWZ0fGNvbG9yOiUyMzI4MjgyOHxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1FZW4gYmV6b2VrIGFhbiBSaXNlTlkgaXMgZWVuIGlkZWFsZSBhY3Rpdml0ZWl0IHRpamRlbnMgZWVuIHJlZ2VuYWNodGlnZSBkYWcgaW4gTmV3IFlvcmsuIE9vayB2b29yIG1lbnNlbiBkaWUgaG9vZ3RldnJlZXMgaGViYmVuLCBrdW5uZW4gdmlhIGRlemUgc2ltdWxhdGllIHRcdTAwZjNjaCBvdmVyIE5ldyBZb3JrIHZsaWVnZW4uIEplIGt1bnQgaGllciBlZW4gdXVydGplIE5ldyBZb3JrIG9wIGVlbiBhbmRlcmUgbWFuaWVyIGJlbGV2ZW4sIGV2ZW4gdmxpZWdlbiBvdmVyIGRlIHN0YWQgXHUwMGU5biBoZXQgbGljaHQgY2VudHJhYWwgb3AgVGltZXMgU3F1YXJlLlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjEwMCVcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IGNvbnRlbnRfcGxhY2VtZW50PVwibWlkZGxlXCIgY3NzPVwiLnZjX2N1c3RvbV8xNjkwODE3MDcyODc5e2JhY2tncm91bmQtY29sb3I6ICMwMDAwMDAgIWltcG9ydGFudDt9XCJdW3ZjX2NvbHVtbl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1baGV5dXNhX2hlYWRpbmcgdGFnPVwiZGl2XCIgdGV4dF9hbGlnbj1cImNlbnRlclwiIGhlYWRpbmc9XCJJbmdlc3Byb2tlbiBkb29yIGFjdGV1ciBKZWZmIEdvbGRibHVtXCIgZm9udF9zaXplPVwiNTVcIiBsaW5lX2hlaWdodD1cIjYwXCIgZm9udF9jb2xvcj1cIiNmZmZmZmZcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIk9udGRlayBOZXcgWW9yayBpbiBlZW4gcmVwbGljYSB2YW4gbWV0cm9oYWx0ZSBDaXR5IEhhbGxcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoM3xmb250X3NpemU6NDV8dGV4dF9hbGlnbjpjZW50ZXJ8Y29sb3I6JTIzZmZmZmZmfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3BhcmFsbGF4X3JvdyBvcGFjaXR5PVwiODVcIiBpbWFnZT1cIjE2OTc0XCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjEwMCVcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt2Y19jb2x1bW5fdGV4dF1cclxuXHJcblsvdmNfY29sdW1uX3RleHRdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjEwMCVcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS8yXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIlRpY2tldHMgUmlzZU5ZIG9wIFRpbWVzIFNxdWFyZVwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTozNXx0ZXh0X2FsaWduOmxlZnR8Y29sb3I6JTIzMDAwMDAwXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt1bHRpbWF0ZV9pY29uX2xpc3QgaWNvbl9zaXplPVwiMThcIiBpY29uX21hcmdpbj1cIjE1XCJdW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy1sb2NhdGlvbi1hcnJvd1wiXTE2MCBXZXN0IDQ1dGggU3RyZWV0IChUaW1lcyBTcXVhcmUpWy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bL3VsdGltYXRlX2ljb25fbGlzdF1bdmNfY29sdW1uX3RleHRdSW4gZWVuIG5vdGVuZG9wIGVlbiBvbnR6ZXR0ZW5kIGxldWtlIGF0dHJhY3RpZSEgSWRlYWFsIHRpamRlbnMgc2xlY2h0IHdlZXIsIG1hYXIgemVrZXIgXHUwMGYzXHUwMGYzayBkZSBtb2VpdGUgYWxzIGplIHdhdCBsYW5nZXIgaW4gZGUgYnV1cnQgdmFuIFRpbWVzIFNxdWFyZSB3aWx0IGJsaWp2ZW4uIERlIDxhIGhyZWY9XCJodHRwczovL3d3dy5nZXR5b3VyZ3VpZGUubmwvbmV3LXlvcmstbDU5L25ldy15b3JrLWNpdHktcmlzZW55LWV4cGVyaWVuY2UtdGlja2V0LXQzNjk3OTYvP3BhcnRuZXJfaWQ9RE1EMlZMNCZhbXA7dXRtX21lZGl1bT1vbmxpbmVfcHVibGlzaGVyJmFtcDtjbXA9aGV5dXNhLXdlYnNpdGUtcmlzZW55XCI+UmlzZU5ZIHNpbXVsYXRpZTwvYT4gaXMgaW5kcnVrd2Vra2VuZCwgbWV0IGVlbiAxODAgZ3JhZGVuIDhLIHNjaGVybSBtZXQgZWVuIGRvb3JzbmVkZSB2YW4gMTIgbWV0ZXIgd2FhciBqZSBvcCA5IG1ldGVyIGhvb2d0ZSB2bGllZ3QuWy92Y19jb2x1bW5fdGV4dF1bdWx0aW1hdGVfaWNvbl9saXN0IGljb25fc2l6ZT1cIjE4XCIgaWNvbl9tYXJnaW49XCIxNVwiXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtYXJyb3dzLXZcIl0xMiBtZXRlciBob29nIHNjaGVybVsvdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy1wbGFuZVwiXUplICd2bGllZ3QnIG9wIDkgbWV0ZXIgaG9vZ3RlWy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLWNhbGVuZGFyXCJdMzY1IGRhZ2VuIHBlciBqYWFyIGdlb3BlbmRbL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtZG9sbGFyIHVzZFwiXVZhbmFmIFx1MjBhYzMyIHBlciBwZXJzb29uWy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bL3VsdGltYXRlX2ljb25fbGlzdF1bdmNfcm93X2lubmVyIHRoYl9tYXhfd2lkdGg9XCJcIl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiNS82XCIgYm94X3NoYWRvdz1cImxhcmdlLXNoYWRvd1wiIHRoYl9ib3JkZXJfcmFkaXVzPVwiMTBweFwiIGNzcz1cIi52Y19jdXN0b21fMTU4NjQyMjU4NzI1NXtwYWRkaW5nLXRvcDogMTVweCAhaW1wb3J0YW50O3BhZGRpbmctcmlnaHQ6IDE1cHggIWltcG9ydGFudDtwYWRkaW5nLWJvdHRvbTogMTVweCAhaW1wb3J0YW50O3BhZGRpbmctbGVmdDogMTVweCAhaW1wb3J0YW50O31cIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIlRpcDpcIiBmb250X2NvbnRhaW5lcj1cInRhZzpkaXZ8Zm9udF9zaXplOjE1fHRleHRfYWxpZ246bGVmdHxjb2xvcjolMjNiMzRhNGN8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIlJpc2VOWSBpcyBlZW4gbGV1a2UgYXR0cmFjdGllIG9tIHNhbWVuIG1ldCBqZSBraW5kZXJlbiB0ZSBkb2VuLiBNYWFyIGxldCBvcCwga2luZGVyZW4gbW9ldGVuIG1pbmltYWFsIDEgbWV0ZXIgZ3Jvb3QgemlqbiBvbSB0ZSBtb2dlbiBtZWV2bGllZ2VuLlwiIGZvbnRfY29udGFpbmVyPVwidGFnOmRpdnxmb250X3NpemU6MjB8dGV4dF9hbGlnbjpsZWZ0fGNvbG9yOiUyMzI4MjgyOFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OlJvYm90byUyMFNsYWIlM0ExMDAlMkMzMDAlMkNyZWd1bGFyJTJDNzAwfGZvbnRfc3R5bGU6MTAwJTIwbGlnaHQlMjByZWd1bGFyJTNBMTAwJTNBbm9ybWFsXCJdW3VsdF9idXR0b25zIGJ0bl90aXRsZT1cIkJlc3RlbCBqZSB0aWNrZXRzXCIgYnRuX2xpbms9XCJ1cmw6aHR0cHMlM0ElMkYlMkZ3d3cuZ2V0eW91cmd1aWRlLm5sJTJGbmV3LXlvcmstbDU5JTJGbmV3LXlvcmstY2l0eS1yaXNlbnktZXhwZXJpZW5jZS10aWNrZXQtdDM2OTc5NiUyRiUzRnBhcnRuZXJfaWQlM0RETUQyVkw0JTI2dXRtX21lZGl1bSUzRG9ubGluZV9wdWJsaXNoZXIlMjZjbXAlM0RoZXl1c2Etd2Vic2l0ZS1yaXNlbnl8dGl0bGU6QmVzdGVsJTIwamUlMjB0aWNrZXRzJTIwdm9vciUyMFJpc2VOWXx0YXJnZXQ6X2JsYW5rXCIgYnRuX3NpemU9XCJ1YnRuLWxhcmdlXCIgYnRuX3RpdGxlX2NvbG9yPVwiI2ZmZmZmZlwiIGJ0bl9iZ19jb2xvcj1cIiNiMzRhNGNcIiBidG5faG92ZXI9XCJ1YnRuLWxlZnQtYmdcIiBidG5fYmdfY29sb3JfaG92ZXI9XCIjNTMxYTIzXCIgYnRuX3RpdGxlX2NvbG9yX2hvdmVyPVwiI2ZmZmZmZlwiIGljb25fc2l6ZT1cIjMyXCIgYnRuX2ljb25fcG9zPVwidWJ0bi1zZXAtaWNvbi1hdC1sZWZ0XCIgYnRuX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIGJ0bl9mb250X3NpemU9XCJkZXNrdG9wOjE1cHg7XCJdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyBjc3M9XCIudmNfY3VzdG9tXzE2MjA4ODc1NDA5MzZ7YmFja2dyb3VuZC1jb2xvcjogI2RhZGFkYSAhaW1wb3J0YW50O31cIl1bdmNfY29sdW1uXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjIvM1wiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIlZlZWxnZXN0ZWxkZSB2cmFnZW4gb3ZlciBSaXNlTllcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX3N0eWxlPVwiZm9udC13ZWlnaHQ6ODAwO1wiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjQ1cHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDo1MHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt2Y190b2dnbGUgdGl0bGU9XCJXYXQga29zdCBlZW4gdGlja2V0IHZvb3IgUmlzZU5ZXCIgY3VzdG9tX2ZvbnRfY29udGFpbmVyPVwidGFnOmgzfGZvbnRfc2l6ZToyMHx0ZXh0X2FsaWduOmxlZnR8bGluZV9oZWlnaHQ6MjVcIiBjdXN0b21fZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6UGxheWZhaXIlMjBEaXNwbGF5JTNBcmVndWxhciUyQ2l0YWxpYyUyQzcwMCUyQzcwMGl0YWxpYyUyQzkwMCUyQzkwMGl0YWxpY3xmb250X3N0eWxlOjcwMCUyMGJvbGQlMjByZWd1bGFyJTNBNzAwJTNBbm9ybWFsXCIgdXNlX2N1c3RvbV9oZWFkaW5nPVwidHJ1ZVwiXUplIGhlYnQgdGlja2V0cyB2YW5hZiAzMCsgZXVyb1svdmNfdG9nZ2xlXVt2Y190b2dnbGUgdGl0bGU9XCJXYXQgaXMgZGUgYmVzdGUgdGlqZCBvbSBSaXNlTlkgdGUgYmV6b2VrZW4/XCIgY3VzdG9tX2ZvbnRfY29udGFpbmVyPVwidGFnOmgzfGZvbnRfc2l6ZToyMHx0ZXh0X2FsaWduOmxlZnR8bGluZV9oZWlnaHQ6MjVcIiBjdXN0b21fZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6UGxheWZhaXIlMjBEaXNwbGF5JTNBcmVndWxhciUyQ2l0YWxpYyUyQzcwMCUyQzcwMGl0YWxpYyUyQzkwMCUyQzkwMGl0YWxpY3xmb250X3N0eWxlOjcwMCUyMGJvbGQlMjByZWd1bGFyJTNBNzAwJTNBbm9ybWFsXCIgdXNlX2N1c3RvbV9oZWFkaW5nPVwidHJ1ZVwiXVRpamRlbnMgZGUgb2NodGVuZCBpcyBSaXNlTlkgaGV0IG1pbnN0IGRydWsuWy92Y190b2dnbGVdW3ZjX3RvZ2dsZSB0aXRsZT1cIkhvZSBsYW5nIGR1dXJ0IGVlbiBiZXpvZWsgYWFuIFJpc2VOWVwiIGN1c3RvbV9mb250X2NvbnRhaW5lcj1cInRhZzpoM3xmb250X3NpemU6MjB8dGV4dF9hbGlnbjpsZWZ0fGxpbmVfaGVpZ2h0OjI1XCIgY3VzdG9tX2dvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OlBsYXlmYWlyJTIwRGlzcGxheSUzQXJlZ3VsYXIlMkNpdGFsaWMlMkM3MDAlMkM3MDBpdGFsaWMlMkM5MDAlMkM5MDBpdGFsaWN8Zm9udF9zdHlsZTo3MDAlMjBib2xkJTIwcmVndWxhciUzQTcwMCUzQW5vcm1hbFwiIHVzZV9jdXN0b21faGVhZGluZz1cInRydWVcIl1KZSBiZW50IG9uZ2V2ZWVyIFx1MDBlOVx1MDBlOW4gdXVyIGt3aWp0IHZvb3IgZWVuIGJlem9layBhYW4gUmlzZU5ZWy92Y190b2dnbGVdW3ZjX3RvZ2dsZSB0aXRsZT1cIldhdCBpcyBSaXNlTlkgb3AgVGltZXMgU3F1YXJlXCIgY3VzdG9tX2ZvbnRfY29udGFpbmVyPVwidGFnOmgzfGZvbnRfc2l6ZToyMHx0ZXh0X2FsaWduOmxlZnR8bGluZV9oZWlnaHQ6MjVcIiBjdXN0b21fZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6UGxheWZhaXIlMjBEaXNwbGF5JTNBcmVndWxhciUyQ2l0YWxpYyUyQzcwMCUyQzcwMGl0YWxpYyUyQzkwMCUyQzkwMGl0YWxpY3xmb250X3N0eWxlOjcwMCUyMGJvbGQlMjByZWd1bGFyJTNBNzAwJTNBbm9ybWFsXCIgdXNlX2N1c3RvbV9oZWFkaW5nPVwidHJ1ZVwiXVJpc2VOWSBpcyBlZW4gdmx1Y2h0c2ltdWxhdG9yIGF0dHJhY3RpZSB2ZXJnZWxpamtiYWFyIG1ldCBTb2FyaW4nIGluIEVwY290LCBEaXNuZXkgV29ybGQuIFx1MDBkM1x1MDBmM2sgaW4gTGFzIFZlZ2FzIGt1biBqZSB2bGllZ2VuIGluICdGbHlPdmVyJyBlZW4gdmVyZ2VsaWprYmFyZSBhdHRyYWN0aWUgYWxzIFJpc2VOWS5bL3ZjX3RvZ2dsZV1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjgwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiT29rIGxldWsgb20gdGUgZG9lbiBpbiBOZXcgWW9ya1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmRpdnxmb250X3NpemU6NTV8dGV4dF9hbGlnbjpjZW50ZXJ8Y29sb3I6JTIzMDAwMDAwXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3RoYl9wb3N0Z3JpZCBzdHlsZT1cInN0eWxlMjBcIiBjb2x1bW5zPVwiNFwiIHNvdXJjZT1cInBvc3RfdHlwZTpwb3N0fGJ5X2lkOjEwMjUxLDE1NTksNTA2LDI5OFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XSIsInBvc3RfdGl0bGUiOiJSaXNlTlkgb3AgVGltZXMgU3F1YXJlIiwicG9zdF9saW5rIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9yaXNlbnktb3AtdGltZXMtc3F1YXJlLyIsInBvc3RfZmVhdHVyZWRfaW1hZ2UiOiI8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIkRlIHZsdWNodHNpbXVsYXRvciBhdHRyYWN0aWUgUmlzZU5ZIG9wIFRpbWVzIFNxdWFyZVwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMy8wNy9yaXNlbnktdGltZXMtc3F1YXJlLW1hbmhhdHRhbi0zMDB4MjAwLmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6IkJlemllbnN3YWFyZGlnaGVkZW4gTmV3IFlvcmsiLCJwb3N0X3RhZ3MiOiIiLCIlX2xhc3RfZWRpdG9yX3VzZWRfamV0cGFjayUiOiJjbGFzc2ljLWVkaXRvciIsIiVfZWRpdF9sb2NrJSI6IjE3MTE2MTU0ODM6MiIsIiVfZWRpdF9sYXN0JSI6IjEiLCIlX2hpZGVfZmVhdHVyZWQlIjpudWxsLCIlX3dwZ21wX2xvY2F0aW9uX2FkZHJlc3MlIjoiMTYwIFcgNDV0aCBTdCwgTmV3IFlvcmssIE5ZIDEwMDM2LCBWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9sb2NhdGlvbl9jaXR5JSI6Ik5ldyBZb3JrIiwiJV93cGdtcF9sb2NhdGlvbl9zdGF0ZSUiOiJOZXcgWW9yayIsIiVfd3BnbXBfbG9jYXRpb25fY291bnRyeSUiOiJWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9tZXRhYm94X2xhdGl0dWRlJSI6IjQwLjc1NzYyMDY5OTk5OTk5IiwiJV93cGdtcF9tZXRhYm94X2xvbmdpdHVkZSUiOiItNzMuOTg1MTc2MDk5OTk5OTkiLCIlX3dwZ21wX21ldGFib3hfbG9jYXRpb25fcmVkaXJlY3QlIjoibWFya2VyIiwiJV93cGdtcF9tZXRhYm94X2N1c3RvbV9saW5rJSI6IiIsIiVfd3BnbXBfbWFwX2lkJSI6ImE6MTp7aTowO3M6MTpcIjdcIjt9IiwiJV93cGdtcF9tZXRhYm94X21hcmtlcl9pZCUiOiJhOjE6e2k6MDtzOjE6XCI1XCI7fSIsIiVfd3BnbXBfbWV0YWJveF90YXhvbW9taWVzX3Rlcm1zJSI6IiIsIiVfd3BnbXBfZXh0ZW5zaW9uc19maWVsZHMlIjoiIiwiJV93d3Nfc3VwcG9ydF9jb250YWN0X251bWJlciUiOiIiLCIlX3d3c19hYm91dF9zdXBwb3J0X3RleHQlIjoiIiwiJV93d3NfdHJpZ2dlcl9idXR0b25fdGV4dCUiOiIiLCIlX3d3c19wcmVkZWZpbmVkX3RleHQlIjoiIiwiJV93cGJfdmNfanNfc3RhdHVzJSI6InRydWUiLCIlX3lvYXN0X3dwc2VvX2NvbnRlbnRfc2NvcmUlIjoiNjAiLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza2V5d29yZHMlIjoiW10iLCIlX3lvYXN0X3dwc2VvX2tleXdvcmRzeW5vbnltcyUiOiJbXCJcIl0iLCIlX3lvYXN0X3dwc2VvX2VzdGltYXRlZC1yZWFkaW5nLXRpbWUtbWludXRlcyUiOiI0IiwiJV95b2FzdF93cHNlb193b3JkcHJvb2ZfdGltZXN0YW1wJSI6IiIsIiVwb3N0LXByaW1hcnktY2F0ZWdvcnklIjoiYXV0byIsIiVmZWF0dXJlZF9pbWFnZV9vdmVycmlkZSUiOiJvZmYiLCIlYXJ0aWNsZV9zdHlsZV9vdmVycmlkZSUiOiJvbiIsIiVwb3N0X3N0eWxlJSI6InN0eWxlNSIsIiVwb3N0X2dhbGxlcnlfc3R5bGUlIjoibGlnaHRib3giLCIlcG9zdF9yZXZpZXclIjoib2ZmIiwiJXBvc3RfcmV2aWV3X3N0eWxlJSI6InN0eWxlMSIsIiVwb3N0X3Jldmlld19hdmVyYWdlJSI6IjUwIiwiJWlubGluZV9mZWF0dXJlZF9pbWFnZSUiOiIwIiwiJV93cGJfc2hvcnRjb2Rlc19jdXN0b21fY3NzJSI6Ii52Y19jdXN0b21fMTY5MDgxOTE5MjI1NntiYWNrZ3JvdW5kLWNvbG9yOiAjMDAwMDAwICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTY4ODk3NzA3MDU0MntiYWNrZ3JvdW5kLWNvbG9yOiAjZjdmN2Y3ICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTY5MDgxNzA3Mjg3OXtiYWNrZ3JvdW5kLWNvbG9yOiAjMDAwMDAwICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTY5MDgxOTI4NTMxN3tiYWNrZ3JvdW5kLWNvbG9yOiAjZjJmMmYyICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTY5MDgxNzA3Mjg3OXtiYWNrZ3JvdW5kLWNvbG9yOiAjMDAwMDAwICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTYyMDg4NzU0MDkzNntiYWNrZ3JvdW5kLWNvbG9yOiAjZGFkYWRhICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTU4NjQyMjU4NzI1NXtwYWRkaW5nLXRvcDogMTVweCAhaW1wb3J0YW50O3BhZGRpbmctcmlnaHQ6IDE1cHggIWltcG9ydGFudDtwYWRkaW5nLWJvdHRvbTogMTVweCAhaW1wb3J0YW50O3BhZGRpbmctbGVmdDogMTVweCAhaW1wb3J0YW50O30iLCIlX3lvYXN0X3dwc2VvX3ByaW1hcnlfY2F0ZWdvcnklIjoiMTQiLCIlX3lvYXN0X2luZGV4bm93X2xhc3RfcGluZyUiOiIxNjkwODgyNDI0IiwiJV95b2FzdF93cHNlb19mb2N1c2t3JSI6IlJpc2VOWSBvcCBUaW1lcyBTcXVhcmUiLCIlX3lvYXN0X3dwc2VvX21ldGFkZXNjJSI6IlJpc2VOWSBvcCBUaW1lcyBTcXVhcmUgaW4gTmV3IFlvcmsgaXMgZWVuIHNpbXVsYXRpZSBhdHRyYWN0aWUgd2FhcmJpaiBqZSB2bGllZ3Qgb3ZlciBkZSBzdGFkLiBcdTI3MTQgS29vcCBqZSBSaXNlTlkgdGlja2V0cyBoaWVyISIsIiVfeW9hc3Rfd3BzZW9fbGlua2RleCUiOiI3MyIsIiVfdGh1bWJuYWlsX2lkJSI6IjE2OTc2IiwidGF4b25vbXk9Y2F0ZWdvcnkiOiJCZXppZW5zd2FhcmRpZ2hlZGVuIE5ldyBZb3JrIiwidGF4b25vbXk9cG9zdF90YWciOiIiLCJ0YXhvbm9teT1wb3N0X2Zvcm1hdCI6IiIsInRheG9ub215PXRoYi1yZWFjdGlvbnMiOiIiLCJ0YXhvbm9teT10aGItc3BvbnNvcnMiOiIifSwiaWNvbiI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjEvMDQvYmV6aWVuc3dhYXJkaWdoZWlkLnBuZyJ9LCJpZCI6MTY5NTUsImluZm93aW5kb3dfZGlzYWJsZSI6ZmFsc2UsImNhdGVnb3JpZXMiOlt7Imljb24iOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIxLzA0L2JlemllbnN3YWFyZGlnaGVpZC5wbmciLCJuYW1lIjoiQmV6aWVuc3dhYXJkaWdoZWRlbiIsImlkIjoiNSIsInR5cGUiOiJjYXRlZ29yeSIsImV4dGVuc2lvbl9maWVsZHMiOnsiY2F0X29yZGVyIjoiIn19XX0seyJzb3VyY2UiOiJwb3N0IiwidGl0bGUiOiJNYWRhbWUgVHVzc2F1ZHMgaW4gTG9zIEFuZ2VsZXMiLCJpbmZvd2luZG93X2NvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nIFwiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJNYWRhbWUgVHVzc2F1ZHMgTG9zIEFuZ2VsZXNcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjIwMFwiIHNyYz1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjMvMDcvbWFkYW1lLXR1c3NhdWRzLTMwMHgyMDAuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZ1wiPlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nIGZjLWl0ZW0tbm8tcGFkZGluZ1wiPlxyXG4gICAgICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS10aXRsZSBmYy1pdGVtLXByaW1hcnktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZVwiPk1hZGFtZSBUdXNzYXVkcyBpbiBMb3MgQW5nZWxlczwvZGl2PlxyXG4gICAgICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1jb250ZW50IGZjLWl0ZW0tYm9keS10ZXh0LWNvbG9yXCI+e21hcmtlcl9hZGRyZXNzfTwvZGl2PlxyXG4gICAgICAgIDwvZGl2PlxyXG4gICAgPC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtY2xlYXJcIj48L2Rpdj5cclxuPC9kaXY+IiwiYWRkcmVzcyI6IjY5MzMgSG9sbHl3b29kIEJsdmQsIExvcyBBbmdlbGVzLCBDQSA5MDAyOCwgVmVyZW5pZ2RlIFN0YXRlbiIsImxvY2F0aW9uIjp7ImxhdCI6IjM0LjEwMTcyMjUiLCJjaXR5IjoiTG9zIEFuZ2VsZXMiLCJzdGF0ZSI6IkNhbGlmb3JuaWEiLCJjb3VudHJ5IjoiVmVyZW5pZ2RlIFN0YXRlbiIsImxuZyI6Ii0xMTguMzQxNTA2NSIsIm9uY2xpY2tfYWN0aW9uIjoibWFya2VyIiwicmVkaXJlY3RfcGVybWFsaW5rIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9tYWRhbWUtdHVzc2F1ZHMtaW4tbG9zLWFuZ2VsZXMvIiwiem9vbSI6MTIsImV4dHJhX2ZpZWxkcyI6eyJwb3N0X2V4Y2VycHQiOiIiLCJwb3N0X2NvbnRlbnQiOiJbdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5fdGV4dF1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiODUlXCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvMlwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiTWFkYW1lIFR1c3NhdWRzIGluIE5ldyBZb3JrIGJlem9la2VuXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjM1fHRleHRfYWxpZ246bGVmdHxjb2xvcjolMjMwMDAwMDBcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XTxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5Ib2V3ZWwgamUgaW4gTG9zIEFuZ2VsZXMgZGUga2FucyBoZWJ0IG9tIGJlcm9lbWRoZWRlbiBvcCBzdHJhYXQgdGVnZW4gdGUga29tZW4sIGlzIGRlIHBsZWsgb20gYmVyb2VtZGhlZGVuIHRlIHNwb3R0ZW4gaXMgbmF0dXVybGlqayBiaWogTWFkYW1lIFR1c3NhdWRzLiBOYXR1dXJsaWprIGdhYXQgaGV0IGhpZXIgb20gaHVuIHdhc3NlbiBiZWVsZCB2ZXJzaWUsIHRvY2ggYmxpamZ0IE1hZGFtZSBUdXNzYXVkcyBlZW4gbGV1a2UgYWN0aXZpdGVpdCB2b29yIGpvbmcgZW4gb3VkLiBCZWtpamsgaG9ldmVlbCBiZXJvZW1kaGVkZW4gamlqIGhlcmtlbnQgaW4gaGV0IE1hZGFtZSBUdXNzYXVkcyBlbiBiZXN0ZWwgYWx2YXN0IGplIDxhIGhyZWY9XCJodHRwczovL3d3dy5nZXR5b3VyZ3VpZGUubmwvaG9sbHl3b29kLWw5NjE5Ni9ob2xseXdvb2QtdGlja2V0cy12b29yLW1hZGFtZS10dXNzYXVkcy10MTAwNDcvP3BhcnRuZXJfaWQ9RE1EMlZMNCZhbXA7dXRtX21lZGl1bT1vbmxpbmVfcHVibGlzaGVyJmFtcDtjbXA9bWFkYW1ldHVzc2F1ZHNsb3NhbmdlbGVzaW50cm90ZWtzdFwiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+dGlja2V0cyBvbmxpbmU8L2E+ITwvc3Bhbj5bL3ZjX2NvbHVtbl90ZXh0XVt1bHRpbWF0ZV9pY29uX2xpc3QgaWNvbl9zaXplPVwiMThcIiBpY29uX21hcmdpbj1cIjE1XCJdW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy1jYWxlbmRhclwiXTM2NSBkYWdlbiBwZXIgamFhciBnZW9wZW5kWy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLWRvbGxhciB1c2RcIl1WYW5hZiA8c3BhbiBjbGFzcz1cInN0aWNreS1ib29raW5nLWFzc2lzdGFudF9fcHJpY2VcIiBkYXRhLXYtMzVlMjc1MmM9XCJcIj5cdTIwYWMzbzwvc3Bhbj5bL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVsvdWx0aW1hdGVfaWNvbl9saXN0XVt1bHRfYnV0dG9ucyBidG5fdGl0bGU9XCJCZXN0ZWwgamUgdGlja2V0c1wiIGJ0bl9saW5rPVwidXJsOmh0dHBzJTNBJTJGJTJGd3d3LmdldHlvdXJndWlkZS5ubCUyRmhvbGx5d29vZC1sOTYxOTYlMkZob2xseXdvb2QtdGlja2V0cy12b29yLW1hZGFtZS10dXNzYXVkcy10MTAwNDclMkYlM0ZwYXJ0bmVyX2lkJTNERE1EMlZMNCUyNnV0bV9tZWRpdW0lM0RvbmxpbmVfcHVibGlzaGVyJTI2Y21wJTNEbWFkYW1ldHVzc2F1ZHNsb3NhbmdlbGVzYnV0dG9uYm92ZW58dGl0bGU6QmVzdGVsJTIwamUlMjB0aWNrZXRzfHRhcmdldDpfYmxhbmtcIiBidG5fc2l6ZT1cInVidG4tbGFyZ2VcIiBidG5fdGl0bGVfY29sb3I9XCIjZmZmZmZmXCIgYnRuX2JnX2NvbG9yPVwiI2IzNGE0Y1wiIGJ0bl9ob3Zlcj1cInVidG4tbGVmdC1iZ1wiIGJ0bl9iZ19jb2xvcl9ob3Zlcj1cIiM1MzFhMjNcIiBidG5fdGl0bGVfY29sb3JfaG92ZXI9XCIjZmZmZmZmXCIgaWNvbl9zaXplPVwiMzJcIiBidG5faWNvbl9wb3M9XCJ1YnRuLXNlcC1pY29uLWF0LWxlZnRcIiBidG5fZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgYnRuX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MTVweDtcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW5dW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IGJnX3R5cGU9XCJiZ19jb2xvclwiIGJnX2NvbG9yX3ZhbHVlPVwiI2VkZWRlZFwiIGNzcz1cIi52Y19jdXN0b21fMTYxMjk0OTUzNzU2NHtiYWNrZ3JvdW5kLWNvbG9yOiAjZWRlZGVkICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMi8zXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIk1hZGFtZSBUdXNzYXVkc1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTozNXx0ZXh0X2FsaWduOmNlbnRlcnxjb2xvcjolMjMwMDAwMDBcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48cCBzdHlsZT1cInRleHQtYWxpZ246IGNlbnRlcjtcIj5PcCAzIHZlcmRpZXBpbmdlbiBrdW4gamUgc2VsZmllcyBtYWtlbiBtZXQgZGUgd2Fzc2VuIGJlZWxkIHZlcnNpZSB2YW4gdmVsZSBiZXJvZW1kaGVkZW4uIFNpbmRzIDIwMDkga3VuIGplIDEyNSB2ZXJzY2hpbGxlbmRlIHdhc3NlbiBiZWVsZGVuIGJla2lqa2VuIGluIE1hZGFtZSBUdXNzYXVkcyBvcCBkZSBIb2xseXdvb2QgQm91bGV2YXJkIGluIExvcyBBbmdlbGVzLiBEZSBlZXJzdGUgdHdlZSBiZXJvZW1kaGVkZW4gb3AgZGUgbG9jYXRpZSBpbiBMb3MgQW5nZWxlcyB3YXJlbiBCZXlvbmNlIGVuIEphbWllIEZveHguIE9vaXQgd2VyZCBNYWRhbWUgVHVzc2F1ZHMgYmVkYWNodCBkb29yIE1hcmlhIFR1c3NhdWQsIGRpZSBpbiAxNzc4IGhhYXIgZWVyc3RlIGJlZWxkIG1hYWt0ZS4gRWVuIGFhbnRhbCBqYXJlbiBlcm5hIHdlcmRlbiBoYWFyIHdhc3NlbiBiZWVsZGVuIHRlbnRvb25nZXN0ZWxkIGluIEVuZ2VsYW5kLiBTaW5kcyBoYWFyIG92ZXJsaWpkZW4gemlqbiBkZSBiZWVsZGVuIHRlIGJla2lqa2VuIGluIE1hZGFtZSBUdXNzYXVkcyBpbiBMb25kZW4sIGRlIGxvY2F0aWUgdmFuIGhldCBodWlkaWdlIG11c2V1bSBpbiBkZSBzdGFkLiBTaW5kcyBkZSBvcGVuaW5nIGluIExvbmRvbiB6aWpuIGVyIG1lZXIgZGFuIDI1IHZlc3RpZ2luZ2VuIHZhbiBNYWRhbWUgVHVzc2F1ZHMgZ2VvcGVuZCB3ZXJlbGR3aWpkLjwvcD5cclxuWy92Y19jb2x1bW5fdGV4dF1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW5dW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI3NXB4XCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJEZXplIHJ1aW10ZXMgbWFnIGplIG5pZXQgbWlzc2VuIGluIE1hZGFtZSBUdXNzYXVkcyBpbiBOZXcgWW9ya1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTozNXx0ZXh0X2FsaWduOmNlbnRlcnxjb2xvcjolMjMwMDAwMDBcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8zXCJdW3ZjX3NpbmdsZV9pbWFnZSBpbWFnZT1cIjE2OTUwXCIgaW1nX3NpemU9XCJsYXJnZVwiIGFsaWdubWVudD1cImNlbnRlclwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiQS0gbGlzdCBQYXJ0eVwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZToyMHx0ZXh0X2FsaWduOmxlZnR8Y29sb3I6JTIzMDAwMDAwfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XTxzcGFuIHN0eWxlPVwiZm9udC13ZWlnaHQ6IDQwMDtcIj5HYSBsYW5ncyBkZSByZWQgY2FycGV0IHN0YWFuIG9tIGplIGZhdm9yaWV0ZSBjZWxlYnJpdGllcyB0ZSB6aWVuIGRpZSB2b29yIGplIHBvc2VyZW4gYWxzb2YgamlqIGRlIHBhcGFyYXp6aSBiZW50LiBTdGVycmVuIGFscyBEd2F5bmUgSm9obnNvbiwgS3lsaWUgSmVubmVyLCBBbmdlbGluYSBKb2xpZSwgTWVyeWwgU3RyZWVwIGVuIEFyaWFuYSBHcmFuZGUga29tZW4gYWxsZW1hYWwgdm9vcmJpai48L3NwYW4+Wy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8zXCJdW3ZjX3NpbmdsZV9pbWFnZSBpbWFnZT1cIjE2OTQxXCIgaW1nX3NpemU9XCJsYXJnZVwiIGFsaWdubWVudD1cImNlbnRlclwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiU3Bpcml0IG9mIEhvbGx5d29vZFwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZToyMHx0ZXh0X2FsaWduOmxlZnR8Y29sb3I6JTIzMDAwMDAwfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XU9udGRlayBkZSBHb2xkZW4gQWdlIG9mIENpbmVtYSBpbiBNYWRhbWUgVHVzc2F1ZHMgaW4gTG9zIEFuZ2VsZXMuIFZlcnNjaGlsbGVuZGUgSG9sbHl3b29kIGdlbnJlIHdvcmRlbiB1aXRnZWxpY2h0IGluIGRpdCBkZWVsIHZhbiBoZXQgbXVzZXVtLiBHYSBvcCBkZSBmb3RvIG1ldCBzdGVycmVuIGFscyBNYXJpbHluIE1vbnJvZSwgQ2hhcmxpZSBDaGFwbGluLCBKdWR5IEdhcmxhbmQgZW4gRnJlZCBBc3RhaXJlLlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvM1wiXVt2Y19zaW5nbGVfaW1hZ2UgaW1hZ2U9XCIxNjk0MlwiIGltZ19zaXplPVwibGFyZ2VcIiBhbGlnbm1lbnQ9XCJjZW50ZXJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIk11c2ljXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjIwfHRleHRfYWxpZ246bGVmdHxjb2xvcjolMjMwMDAwMDB8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdT250bW9ldCBkZSBncm9vdHN0ZSBtdXppa2FsZSBzdGVycmVuIHZhbiBhZmdlbG9wZW4gamFyZW4gaW4gZGUgTXVzaWMgUm9vbS4gR2Egb3AgZGUgZm90byBtZXQgZGUgS2luZyBvZiBQb3AgTWljaGFlbCBKYWNrc29uLCBiZWtpamsgTGl0dGxlIE1vbnN0ZXJzIHZhbiBMYWR5IEdhZ2EgZW4gbmF0dXVybGlqayBrdW5uZW4gc3RlcnJlbiBhbHMgQmV5b25jZSwgU2hha2lyYSBlbiBMaWwgTmFzIFggbmlldCBvbnRicmVrZW4uWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNzVweFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIiBmdWxsX3dpZHRoPVwic3RyZXRjaF9yb3dcIiBjb250ZW50X3RleHRfYWxpZ21lbnQ9XCJjZW50ZXJcIiBjc3M9XCIudmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9XCIgcGFyYWxsYXhfYmFja2dyb3VuZF9pbWFnZT1cIjM4MzZcIl1bdmNfY29sdW1uIHRoYl9jb2xvcj1cInRoYi1saWdodC1jb2x1bW5cIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJTcG90IHZlcnNjaGlsbGVuZGUgYmVyb2VtZGhlZGVuXCIgZm9udF9jb250YWluZXI9XCJ0YWc6ZGl2fGZvbnRfc2l6ZTo3NXx0ZXh0X2FsaWduOmNlbnRlcnxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVtoZXl1c2FfaGVhZGluZyB0YWc9XCJkaXZcIiB0ZXh0X2FsaWduPVwiY2VudGVyXCIgaGVhZGluZz1cIkdhIG9wIGRlIGZvdG8gbWV0IER3YXluZSBgYFRoZSBSb2NrYGAgSm9obnNvblwiIGZvbnRfc2l6ZT1cIjUwXCIgbGluZV9oZWlnaHQ9XCI1MFwiIGZvbnRfY29sb3I9XCIjZmZmZmZmXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3BhcmFsbGF4X3JvdyBlbmFibGVfbW9iaWxlPVwicGFyYWxsYXgtZW5hYmxlLW1vYmlsZVwiIGltYWdlPVwiMTY5MjJcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW5dW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW4gd2lkdGg9XCIyLzNcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJUaWNrZXRzIHZvb3IgTWFkYW1lIFR1c3NhdWRzXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjMwfHRleHRfYWxpZ246bGVmdHxjb2xvcjolMjMwMDAwMDB8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdVm9vciBqZSBiZXpvZWsgYWFuIE1hZGFtZSBUdXNzYXVkcyBrdW4gamUgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmdldHlvdXJndWlkZS5ubC9ob2xseXdvb2QtbDk2MTk2L2hvbGx5d29vZC10aWNrZXRzLXZvb3ItbWFkYW1lLXR1c3NhdWRzLXQxMDA0Ny8/cGFydG5lcl9pZD1ETUQyVkw0JmFtcDt1dG1fbWVkaXVtPW9ubGluZV9wdWJsaXNoZXImYW1wO2NtcD1tYWRhbWV0dXNzYXVkc2xvc2FuZ2VsZXN0ZWtzdHRpY2tldFwiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+b25saW5lIGVlbiB0aWNrZXQgYWFuc2NoYWZmZW48L2E+LiBabyBoZWIgamUgZ2VnYXJhbmRlZXJkIHRvZWdhbmcgdG90IGhldCBtdXNldW0uIFZvb3IgZGUgTWFydmVsIFVuaXZlcnNlIDREIGV4cGVyaWVuY2UgZGllbiBqZSBlZW4gZXh0cmEgdGlja2V0IGFhbiB0ZSBzY2hhZmZlbi5bL3ZjX2NvbHVtbl90ZXh0XVt1bHRfYnV0dG9ucyBidG5fdGl0bGU9XCJCZXN0ZWwgamUgdGlja2V0c1wiIGJ0bl9saW5rPVwidXJsOmh0dHBzJTNBJTJGJTJGd3d3LmdldHlvdXJndWlkZS5ubCUyRmhvbGx5d29vZC1sOTYxOTYlMkZob2xseXdvb2QtdGlja2V0cy12b29yLW1hZGFtZS10dXNzYXVkcy10MTAwNDclMkYlM0ZwYXJ0bmVyX2lkJTNERE1EMlZMNCUyNnV0bV9tZWRpdW0lM0RvbmxpbmVfcHVibGlzaGVyJTI2Y21wJTNEbWFkYW1ldHVzc2F1ZHNsb3NhbmdlbGVzYnV0dG9ub25kZXJ8dGFyZ2V0Ol9ibGFua1wiIGJ0bl9zaXplPVwidWJ0bi1sYXJnZVwiIGJ0bl90aXRsZV9jb2xvcj1cIiNmZmZmZmZcIiBidG5fYmdfY29sb3I9XCIjYjM0YTRjXCIgYnRuX2hvdmVyPVwidWJ0bi1sZWZ0LWJnXCIgYnRuX2JnX2NvbG9yX2hvdmVyPVwiIzUzMWEyM1wiIGJ0bl90aXRsZV9jb2xvcl9ob3Zlcj1cIiNmZmZmZmZcIiBpY29uX3NpemU9XCIzMlwiIGJ0bl9pY29uX3Bvcz1cInVidG4tc2VwLWljb24tYXQtbGVmdFwiIGJ0bl9mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBidG5fZm9udF9zaXplPVwiZGVza3RvcDoxNXB4O1wiXVt2Y19yb3dfaW5uZXIgdGhiX21heF93aWR0aD1cIlwiXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS8zXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJQcmFrdGlzY2hlIGluZm9ybWF0aWVcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MzB8dGV4dF9hbGlnbjpsZWZ0fGNvbG9yOiUyMzAwMDAwMHxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt1bHRpbWF0ZV9pY29uX2xpc3QgaWNvbl9zaXplPVwiMThcIiBpY29uX21hcmdpbj1cIjE1XCJdW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy1tYXAtbWFya2VyXCJdPHN0cm9uZz42OTMzIEhvbGx5d29vZCBCbHZkPC9zdHJvbmc+Wy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLWNsb2NrLW9cIl08c3Ryb25nPk1hYW5kYWcgdC9tIHpvbmRhZzogMTAuMDAgdG90IDIwLjAwIHV1clxyXG5NZXQgdWl0em9uZGVyaW5nIHZhbiBkaW5zZGFnOiAxMC4wMC0xOC4wMCB1dXI8L3N0cm9uZz5bL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVsvdWx0aW1hdGVfaWNvbl9saXN0XVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgY3NzPVwiLnZjX2N1c3RvbV8xNjIwODg3NTQwOTM2e2JhY2tncm91bmQtY29sb3I6ICNkYWRhZGEgIWltcG9ydGFudDt9XCJdW3ZjX2NvbHVtbl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIyLzNcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJWZWVsZ2VzdGVsZGUgdnJhZ2VuIG92ZXIgTWFkYW1lIFR1c3NhdWRzXCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19zdHlsZT1cImZvbnQtd2VpZ2h0OjgwMDtcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDo0NXB4O1wiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NTBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bdmNfdG9nZ2xlIHRpdGxlPVwiV2F0IGtvc3QgZWVuIHRpY2tldCB2b29yIE1hZGFtZSBUdXNzYXVkc1wiIGN1c3RvbV9mb250X2NvbnRhaW5lcj1cInRhZzpoM3xmb250X3NpemU6MjB8dGV4dF9hbGlnbjpsZWZ0fGxpbmVfaGVpZ2h0OjI1XCIgY3VzdG9tX2dvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OlBsYXlmYWlyJTIwRGlzcGxheSUzQXJlZ3VsYXIlMkNpdGFsaWMlMkM3MDAlMkM3MDBpdGFsaWMlMkM5MDAlMkM5MDBpdGFsaWN8Zm9udF9zdHlsZTo3MDAlMjBib2xkJTIwcmVndWxhciUzQTcwMCUzQW5vcm1hbFwiIHVzZV9jdXN0b21faGVhZGluZz1cInRydWVcIl1KZSBoZWJ0IHRpY2tldHMgdmFuYWYgMzAgZXVyb1svdmNfdG9nZ2xlXVt2Y190b2dnbGUgdGl0bGU9XCJXYXQgaXMgZGUgYmVzdGUgdGlqZCBvbSBNYWRhbWUgVHVzc2F1ZHMgdGUgYmV6b2VrZW4/XCIgY3VzdG9tX2ZvbnRfY29udGFpbmVyPVwidGFnOmgzfGZvbnRfc2l6ZToyMHx0ZXh0X2FsaWduOmxlZnR8bGluZV9oZWlnaHQ6MjVcIiBjdXN0b21fZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6UGxheWZhaXIlMjBEaXNwbGF5JTNBcmVndWxhciUyQ2l0YWxpYyUyQzcwMCUyQzcwMGl0YWxpYyUyQzkwMCUyQzkwMGl0YWxpY3xmb250X3N0eWxlOjcwMCUyMGJvbGQlMjByZWd1bGFyJTNBNzAwJTNBbm9ybWFsXCIgdXNlX2N1c3RvbV9oZWFkaW5nPVwidHJ1ZVwiXURlIGJlc3RlIHRpamQgb20gTWFkYW1lIFR1c3NhdWRzIHRlIGJlem9la2VuIGlzIGluIGRlIHZyb2VnZSBtb3JnZW4uIE9wIGRhdCB0aWpkc3RpcCBpcyBoZXQgcnVzdGlnZXIgZGFuIG1pZGRlbiBvcCBkZSBkYWcuWy92Y190b2dnbGVdW3ZjX3RvZ2dsZSB0aXRsZT1cIkhvZSBsYW5nIGR1dXJ0IGVlbiBiZXpvZWsgYWFuIE1hZGFtZSBUdXNzYXVkcz9cIiBjdXN0b21fZm9udF9jb250YWluZXI9XCJ0YWc6aDN8Zm9udF9zaXplOjIwfHRleHRfYWxpZ246bGVmdHxsaW5lX2hlaWdodDoyNVwiIGN1c3RvbV9nb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpQbGF5ZmFpciUyMERpc3BsYXklM0FyZWd1bGFyJTJDaXRhbGljJTJDNzAwJTJDNzAwaXRhbGljJTJDOTAwJTJDOTAwaXRhbGljfGZvbnRfc3R5bGU6NzAwJTIwYm9sZCUyMHJlZ3VsYXIlM0E3MDAlM0Fub3JtYWxcIiB1c2VfY3VzdG9tX2hlYWRpbmc9XCJ0cnVlXCJdSmUgYmVudCBvbmdldmVlciAxLDUgdXVyIGt3aWp0IHZvb3IgZWVuIGJlem9layBhYW4gTWFkYW1lIFR1c3NhdWRzWy92Y190b2dnbGVdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI4MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIiBmdWxsX3dpZHRoPVwic3RyZXRjaF9yb3dcIiBjb250ZW50X3RleHRfYWxpZ21lbnQ9XCJjZW50ZXJcIiBjc3M9XCIudmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9XCIgcGFyYWxsYXhfYmFja2dyb3VuZF9pbWFnZT1cIjM4MzZcIl1bdmNfY29sdW1uIHRoYl9jb2xvcj1cInRoYi1saWdodC1jb2x1bW5cIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiQW1lcmlrYWFuc2UgcG9wc3RlcnJlblwiIGhlYWRpbmdfdGFnPVwiZGl2XCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiI2ZmZmZmZlwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjc1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVtoZXl1c2FfaGVhZGluZyB0YWc9XCJkaXZcIiB0ZXh0X2FsaWduPVwiY2VudGVyXCIgaGVhZGluZz1cIkFyaWFuZSBHcmFuZGVcIiBmb250X3NpemU9XCI1MFwiIGxpbmVfaGVpZ2h0PVwiNTBcIiBmb250X2NvbG9yPVwiI2ZmZmZmZlwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVtwYXJhbGxheF9yb3cgZW5hYmxlX21vYmlsZT1cInBhcmFsbGF4LWVuYWJsZS1tb2JpbGVcIiBpbWFnZT1cIjE2OTQ5XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiT29rIGxldWsgb20gdGUgZG9lbiBpbiBMb3MgQW5nZWxlc1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmRpdnxmb250X3NpemU6NTV8dGV4dF9hbGlnbjpjZW50ZXJ8Y29sb3I6JTIzMDAwMDAwXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3RoYl9wb3N0Z3JpZCBzdHlsZT1cInN0eWxlMjBcIiBjb2x1bW5zPVwiNFwiIHNvdXJjZT1cInBvc3RfdHlwZTpwb3N0fGJ5X2lkOi0xMDI1MSwtMTU1OSwtNTA2LC0yOTgsODI5OSw1MTIxLDEyODY1LDUwMDNcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd10iLCJwb3N0X3RpdGxlIjoiTWFkYW1lIFR1c3NhdWRzIGluIExvcyBBbmdlbGVzIiwicG9zdF9saW5rIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9tYWRhbWUtdHVzc2F1ZHMtaW4tbG9zLWFuZ2VsZXMvIiwicG9zdF9mZWF0dXJlZF9pbWFnZSI6IjxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiTWFkYW1lIFR1c3NhdWRzIExvcyBBbmdlbGVzXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMDBcIiBzcmM9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIzLzA3L21hZGFtZS10dXNzYXVkcy0zMDB4MjAwLmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6IkJlemllbnN3YWFyZGlnaGVkZW4gTG9zIEFuZ2VsZXMiLCJwb3N0X3RhZ3MiOiIiLCIlX3dwYl9zaG9ydGNvZGVzX2N1c3RvbV9jc3MlIjoiLnZjX2N1c3RvbV8xNjEyOTQ5NTM3NTY0e2JhY2tncm91bmQtY29sb3I6ICNlZGVkZWQgIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTYyMDg4NzU0MDkzNntiYWNrZ3JvdW5kLWNvbG9yOiAjZGFkYWRhICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O30iLCIlaW5saW5lX2ZlYXR1cmVkX2ltYWdlJSI6IjAiLCIlX2VkaXRfbGFzdCUiOiIyIiwiJV9lZGl0X2xvY2slIjoiMTY5MDgxOTY5MToxIiwiJV93cGJfdmNfanNfc3RhdHVzJSI6InRydWUiLCIlcG9zdC1wcmltYXJ5LWNhdGVnb3J5JSI6IjUyIiwiJWZlYXR1cmVkX2ltYWdlX292ZXJyaWRlJSI6Im9mZiIsIiVhcnRpY2xlX3N0eWxlX292ZXJyaWRlJSI6Im9uIiwiJXBvc3Rfc3R5bGUlIjoic3R5bGU1IiwiJXBvc3RfZ2FsbGVyeV9zdHlsZSUiOiJsaWdodGJveCIsIiVwb3N0X3JldmlldyUiOiJvZmYiLCIlcG9zdF9yZXZpZXdfc3R5bGUlIjoic3R5bGUxIiwiJXBvc3RfcmV2aWV3X2F2ZXJhZ2UlIjoiNTAiLCIlc3RhbmRhcmQtZmVhdHVyZWQtY3JlZGl0JSI6IiIsIiVfaGlkZV9mZWF0dXJlZCUiOm51bGwsIiVwb3N0X3NvdXJjZSUiOiIiLCIlX3RodW1ibmFpbF9pZCUiOiIxNjk0MyIsIiVfeW9hc3Rfd3BzZW9fZm9jdXNrdyUiOiJNYWRhbWUgVHVzc2F1ZHMgaW4gTG9zIEFuZ2VsZXMiLCIlX3lvYXN0X3dwc2VvX3RpdGxlJSI6Ik1hZGFtZSBUdXNzYXVkcyBpbiBMb3MgQW5nZWxlcyUlcGFnZSUlICUlc2VwJSUgJSVzaXRlbmFtZSUlIiwiJV95b2FzdF93cHNlb19tZXRhZGVzYyUiOiJFZW4gbGV1a2UgYXR0cmFjdGllIGlzIE1hZGFtZSBUdXNzYXVkcyBpbiBMb3MgQW5nZWxlcy4gSGV0IHdhc3NlbmJlZWxkZW4gbXVzZXVtIGlzIGRlIHBsZWsgb20gYmVyb2VtZGhlZGVuIHRlIHNwb3R0ZW4gZW4gc2VsZmllcyB0ZSBtYWtlbi4gS29vcCBoaWVyIGplIHRpY2tldHMuIiwiJV95b2FzdF93cHNlb19saW5rZGV4JSI6Ijc3IiwiJV95b2FzdF93cHNlb19jb250ZW50X3Njb3JlJSI6IjMwIiwiJV95b2FzdF93cHNlb19mb2N1c2tleXdvcmRzJSI6IltdIiwiJV95b2FzdF93cHNlb19rZXl3b3Jkc3lub255bXMlIjoiW1wiVGlja2V0cyBNYWRhbWUgVHVzc2F1ZHNcIl0iLCIlX3dwZ21wX2xvY2F0aW9uX2FkZHJlc3MlIjoiNjkzMyBIb2xseXdvb2QgQmx2ZCwgTG9zIEFuZ2VsZXMsIENBIDkwMDI4LCBWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9sb2NhdGlvbl9jaXR5JSI6IkxvcyBBbmdlbGVzIiwiJV93cGdtcF9sb2NhdGlvbl9zdGF0ZSUiOiJDYWxpZm9ybmlhIiwiJV93cGdtcF9sb2NhdGlvbl9jb3VudHJ5JSI6IlZlcmVuaWdkZSBTdGF0ZW4iLCIlX3dwZ21wX21ldGFib3hfbGF0aXR1ZGUlIjoiMzQuMTAxNzIyNSIsIiVfd3BnbXBfbWV0YWJveF9sb25naXR1ZGUlIjoiLTExOC4zNDE1MDY1IiwiJV93cGdtcF9tZXRhYm94X2xvY2F0aW9uX3JlZGlyZWN0JSI6Im1hcmtlciIsIiVfd3BnbXBfbWV0YWJveF9jdXN0b21fbGluayUiOiIiLCIlX3dwZ21wX21hcF9pZCUiOiJhOjE6e2k6MDtzOjE6XCI3XCI7fSIsIiVfd3BnbXBfbWV0YWJveF9tYXJrZXJfaWQlIjoiYToxOntpOjA7czoxOlwiMlwiO30iLCIlX3dwZ21wX21ldGFib3hfdGF4b21vbWllc190ZXJtcyUiOiIiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6IiIsIiVfeW9hc3Rfd3BzZW9fZXN0aW1hdGVkLXJlYWRpbmctdGltZS1taW51dGVzJSI6IjQiLCIlX3lvYXN0X3dwc2VvX3ByaW1hcnlfY2F0ZWdvcnklIjoiNTIiLCIlX3d3c19zdXBwb3J0X2NvbnRhY3RfbnVtYmVyJSI6IiIsIiVfd3dzX2Fib3V0X3N1cHBvcnRfdGV4dCUiOiIiLCIlX3d3c190cmlnZ2VyX2J1dHRvbl90ZXh0JSI6IiIsIiVfd3dzX3ByZWRlZmluZWRfdGV4dCUiOiIiLCIlX3lvYXN0X2luZGV4bm93X2xhc3RfcGluZyUiOiIxNjkwODA3MTEyIiwiJV9sYXN0X2VkaXRvcl91c2VkX2pldHBhY2slIjoiY2xhc3NpYy1lZGl0b3IiLCIlX3lvYXN0X3dwc2VvX3dvcmRwcm9vZl90aW1lc3RhbXAlIjoiIiwiJXBvc3RfdmlhJSI6W3sidGl0bGUiOiJGb3RvJ3MgXHUwMGE5IE1hZGFtZSBUdXNzYXVkcyAoTWFkYW1lIFR1c3NhdWRzIFVTQSkgLyAgTWVybGluIEVudGVydGFpbm1lbnRzIEx0ZCIsInBvc3Rfc291cmNlX3VybCI6Imh0dHBzOi8vd3d3Lm1hZGFtZXR1c3NhdWRzLmNvbS8ifV0sInRheG9ub215PWNhdGVnb3J5IjoiQmV6aWVuc3dhYXJkaWdoZWRlbiBMb3MgQW5nZWxlcyIsInRheG9ub215PXBvc3RfdGFnIjoiIiwidGF4b25vbXk9cG9zdF9mb3JtYXQiOiIiLCJ0YXhvbm9teT10aGItcmVhY3Rpb25zIjoiIiwidGF4b25vbXk9dGhiLXNwb25zb3JzIjoiIn0sImljb24iOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDI0LzAzL211c2VhLWljb24ucG5nIn0sImlkIjoxNjkyOCwiaW5mb3dpbmRvd19kaXNhYmxlIjpmYWxzZSwiY2F0ZWdvcmllcyI6W3siaWNvbiI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjQvMDMvbXVzZWEtaWNvbi5wbmciLCJuYW1lIjoiTXVzZWEiLCJpZCI6IjIiLCJ0eXBlIjoiY2F0ZWdvcnkiLCJleHRlbnNpb25fZmllbGRzIjp7ImNhdF9vcmRlciI6IiJ9fV19LHsic291cmNlIjoicG9zdCIsInRpdGxlIjoiUGFsbSBCZWFjaCAmIzAzODsgV2VzdCBQYWxtIEJlYWNoIGluIEZsb3JpZGEiLCJpbmZvd2luZG93X2NvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nIFwiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJXZXN0IHBhbG0gQmVhY2hcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjIyNVwiIHNyYz1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjMvMDcvd2VzdC1wYWxtLWJlYWNoLTEtMzAweDIyNS5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmcgZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+UGFsbSBCZWFjaCAmIzAzODsgV2VzdCBQYWxtIEJlYWNoIGluIEZsb3JpZGE8L2Rpdj5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tY29udGVudCBmYy1pdGVtLWJvZHktdGV4dC1jb2xvclwiPnttYXJrZXJfYWRkcmVzc308L2Rpdj5cclxuICAgICAgICA8L2Rpdj5cclxuICAgIDwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWNsZWFyXCI+PC9kaXY+XHJcbjwvZGl2PiIsImFkZHJlc3MiOiJTYW5pYmVsIElzbGFuZCwgRmxvcmlkYSwgVmVyZW5pZ2RlIFN0YXRlbiIsImxvY2F0aW9uIjp7ImxhdCI6IjI2LjQ0MzM5NzIiLCJzdGF0ZSI6IkZsb3JpZGEiLCJjb3VudHJ5IjoiVmVyZW5pZ2RlIFN0YXRlbiIsImxuZyI6Ii04Mi4xMTE1MTE5Iiwib25jbGlja19hY3Rpb24iOiJtYXJrZXIiLCJyZWRpcmVjdF9wZXJtYWxpbmsiOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3BhbG0tYmVhY2gtZmxvcmlkYS8iLCJ6b29tIjoxMiwiZXh0cmFfZmllbGRzIjp7InBvc3RfZXhjZXJwdCI6IiIsInBvc3RfY29udGVudCI6Ilt2Y19yb3ddW3ZjX2NvbHVtbl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjI1cHhcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMjVweFwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIlBhbG0gQmVhY2ggJmFtcDsgV2VzdCBQYWxtIEJlYWNoXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzI4MjgyOFwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjMwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF08c3Ryb25nPlBhbG0gQmVhY2ggZW4gV2VzdCBQYWxtIEJlYWNoIGluIEZsb3JpZGEgemlqbiB0d2VlIHBsZWtrZW4gZGllIGdvZWQgdGUgY29tYmluZXJlbiB6aWpuLiBIZXQgZWlsYW5kIFBhbG0gQmVhY2ggbGlndCB2b29yIGRlIGt1c3QgdmFuIFdlc3QgUGFsbSBCZWFjaCBlbiBpcyB0ZSBiZXJlaWtlbiB2aWEgZWVuIHZhbiBkZSAzIGJydWdnZW4uIFdlc3QgUGFsbSBCZWFjaCB3b3JkdCBnZXppZW4gYWxzIGhldCBTdC4gVHJvcGV6IHZhbiBGbG9yaWRhLCBkYXQgZ2VsZHQgb29rIGVuaWdzemlucyB2b29yIFBhbG0gQmVhY2ggbWV0IGhldCBwbHVzcHVudCBkYXQgUGFsbSBCZWFjaCBzdHJhbmRlbiBoZWVmdCwgV2VzdCBQYWxtIEJlYWNoIG5pZXQuIE9tZGF0IGJlaWRlIHBsZWtrZW4gZ29lZCBzYW1lbiB0ZSBiZXpvZWtlbiB6aWpuLCB0aXBzIHZvb3Igem93ZWwgUGFsbSBCZWFjaCBhbHMgV2VzdCBQYWxtIEJlYWNoLlxyXG48L3N0cm9uZz5bL3ZjX2NvbHVtbl90ZXh0XVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI3NXB4XCJdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyBjc3M9XCIudmNfY3VzdG9tXzE0NzIzMDc1MDIyOTB7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDtwYWRkaW5nLWJvdHRvbTogMjVweCAhaW1wb3J0YW50O31cIl1bdmNfY29sdW1uXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNzVweFwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIldhdCBqZSBuaWV0IG1hZyBtaXNzZW4gaW4gUGFsbSBCZWFjaFwiIG1haW5faGVhZGluZ19jb2xvcj1cIiNiMzRhNGNcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDo1NXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjYwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF1cclxuPHAgc3R5bGU9XCJ0ZXh0LWFsaWduOiBjZW50ZXI7XCI+UGFsbSBCZWFjaCBpcyBcdTAwZTlcdTAwZTluIHZhbiBkZSBwb3N0Y29kZXMgaW4gQW1lcmlrYSB3YWFydmFuIGplIHdlZXQgZGF0IGVyIHZlZWwgcmlqa2UgbWVuc2VuIHdvbmVuLCBuZXQgem9hbHMgOTAyMTAgaW4gTG9zIEFuZ2VsZXMuIEhldCBpcyBkZSBmYXZvcmlldGUgYmVzdGVtbWluZyB2YW4gdmVsZSByaWprZSBvdmVyd2ludGVyYWFycy4gT3Agc2xlY2h0cyAyIHV1ciB2YW4gTWlhbWksIG9mIG1hYXIgMSB1dXIgbWV0IGRlIDxhIGhyZWY9XCJodHRwczovL3d3dy5nb2JyaWdodGxpbmUuY29tL1wiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+QnJpZ2h0bGluZTwvYT4gdHJlaW4sIGlzIFBhbG0gQmVhY2ggZWVuIGFsIGdsaXR0ZXIgZW4gZ2xhbW91ci4gVG9jaCBob2VmIGplIG5pZXQgcmlqayBlbiBiZXJvZW1kIHRlIHppam4gb20gdGUgZ2VuaWV0ZW4gdmFuIFBhbG0gQmVhY2guIEplIGhlYnQgZXIgcHJhY2h0aWdlIHN0cmFuZGVuIGVuIG5hdHV1ciwga3VudCBlciB3aW5rZWxlbiwgbXVzZWEgYmV6b2VrZW4gZW4gZGluZXJlbiBiaWogZmlqbmUgcmVzdGF1cmFudHMsIGdlbm9lZyBtb2dlbGlqa2hlZGVuIHZvb3IgaWVkZXJlZW4uPC9wPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI3NXB4XCJdW3ZjX3Jvd19pbm5lciBjc3M9XCIudmNfY3VzdG9tXzE1ODI5NzA3MDQ5MDN7cGFkZGluZy10b3A6IDEwcHggIWltcG9ydGFudDtwYWRkaW5nLXJpZ2h0OiAxMHB4ICFpbXBvcnRhbnQ7cGFkZGluZy1ib3R0b206IDEwcHggIWltcG9ydGFudDtwYWRkaW5nLWxlZnQ6IDEwcHggIWltcG9ydGFudDt9XCJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvNFwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIk1hciBhIExhZ29cIiBoZWFkaW5nX3RhZz1cImgzXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzI4MjgyOFwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6MzBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XVxyXG48cCBzdHlsZT1cInRleHQtYWxpZ246IGNlbnRlcjtcIj5NYXItQS1MYWdvLCB2b29yIHZlbGVuIGJla2VuZCB2YW53ZWdlIG91ZCBwcmVzaWRlbnQgVHJ1bXAuIEhldCBodWlzIGlzIHNpbmRzIDE5ODUgaW4gemlqbiBiZXppdC4gSGllcnZvb3Igd2VyZCBkZSBsdXh1ZXV6ZSB2aWxsYSBkb29yIGRlIGVpZ2VuYXJlbiBhYW4gZGUgQW1lcmlrYWFuc2Ugb3ZlcmhlaWQgZ2VzY2hvbmtlbiBhbHMgdG9ldmx1Y2h0c29vcmQgdm9vciBwcmVzaWRlbnRlbi4gSGV0IHdlcmQgbm9vaXQgdm9vciBkaXQgZG9lbCBnZWJydWlrdCB0b3RkYXQgVHJ1bXAgaGV0IGtvY2h0LiBOYWFzdCBUcnVtcCBicmFjaHRlbiBvb2sgdmVsZSBhbmRlcmUgYmVyb2VtZGhlZGVuIGh1biB0aWpkIGRvb3IgaW4gTWFyLUEtTGFnby4gSW4gMTk5NCBnaW5nZW4gTWljaGFlbCBKYWNrc29uIGVuIExpc2EgTWFyaWUgUHJlc2xleSBvcCBodXdlbGlqa3NyZWlzIGluIGRlIHZpbGEuPC9wPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzRcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJTdHJhbmRlbiB2YW4gUGFsbSBCZWFjaFwiIGhlYWRpbmdfdGFnPVwiaDNcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMjgyODI4XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozMHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdXHJcbjxwIHN0eWxlPVwidGV4dC1hbGlnbjogY2VudGVyO1wiPk1ldCBlZW4gZW5vcm1lIGt1c3RsaWpuIGhlZWZ0IFBhbG0gQmVhY2ggdmVlbCB0ZSBiaWVkZW4gdm9vciBzdHJhbmRsaWVmaGViYmVycy4gRW5rZWxlIHRpcHMgdm9vciBtb29pZSBzdHJhbmRlbiB6aWpuOlxyXG4tIExha2UgV29ydGggQmVhY2ggLSBmYW1pbGllc1xyXG4tIFBlYW51dCBJc2xhbmQgLSBwYXJ0eVxyXG4tIERlbHJheSBCZWFjaCAtIGxpZmVndWFyZHNcclxuLSBKb2huIEQuIE1hY0FydGh1ciBTdGF0ZSBQYXJrIC0gZmFtaWxpZXMgZW4gbmF0dXVybGllZmhlYmJlcnNcclxuLSBKdW5vIEJlYWNoIC0gbG9jYWxzPC9wPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzRcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJKb2huIEQuIE1hY2FydGh1ciBCZWFjaCBTdGF0ZSBQYXJrXCIgaGVhZGluZ190YWc9XCJoM1wiIG1haW5faGVhZGluZ19jb2xvcj1cIiMyODI4MjhcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjMwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF1cclxuPHAgc3R5bGU9XCJ0ZXh0LWFsaWduOiBjZW50ZXI7XCI+SGV0IEpvaG4gRC4gTWFjQXJ0aHVyIEJlYWNoIFN0YXRlIFBhcmsgZ2VlZnQgbmF0dXVybGllZmhlYmJlcnMgZGUgbW9nZWxpamtoZWlkIG9tIHJvbmRvbSBQYWxtIEJlYWNoIGRlIG5hdHV1ciBpbiB0ZSBnYWFuLiBIZXQgaXMgaGV0IGVuaWdlIHN0YWF0c3BhcmsgaW4gUGFsbSBCZWFjaCBDb3VudHkgZW4gaXMgNDM2IGhlY3RhcmUgZ3Jvb3QuIE5hdHV1cmxpamsga3VubmVuIG9uZ2VyZXB0ZSBzdHJhbmRlbiwgZHVpbmVuIGVuIHZlZWwgZ3JvZW4gbmlldCBvbnRicmVrZW4uIEplIGhlYnQgbW9nZWxpamtoZWRlbiBvbSB3aWxkZSBkaWVyZW4gdGUgemllbiwgd2Fhcm9uZGVyIGJlZHJlaWdkZSBkaWVyZW4uIEVlbiBsZXVrZSBtYW5pZXIgb20gaGV0IHBhcmsgdGUgdmVya2VubmVuLCBpcyBhbCBzbm9ya2VsZW5kLjwvcD5cclxuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS80XCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiRmxhZ2xlciBNdXNldW1cIiBoZWFkaW5nX3RhZz1cImgzXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzI4MjgyOFwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6MzBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XVxyXG48cCBzdHlsZT1cInRleHQtYWxpZ246IGNlbnRlcjtcIj5FZW4gdmFuIGRlIGJlbGFuZ3JpamtzdGUgbWVuc2VuIGluIGRlIG9udHdpa2tlbGluZyB2YW4gUGFsbSBCZWFjaCBpcyBIZW5yeSBNb3JyaXNvbiBGbGFnbGVyLiBEZSBtZWRlb3ByaWNodGVyIHZhbiBTdGFuZGFyZCBPaWwgZGllIGhldCBlaWxhbmQgYWxzIGVlbiBwZXJmZWN0IHRvZXZsdWNodHNvb3JkIHphZyB2b29yIHppam4gcmlqa2UgZW4gYmVyb2VtZGUgdnJpZW5kZW4uIERvb3IgaGV0IGFhbmxlZ2dlbiB2YW4gZGUgc3Bvb3JsaWpuLCBvcCB6aWpuIGluaXRpYXRpZWYsIHdlcmQgUGFsbSBCZWFjaCBncm9vdC4gSW4gaGV0IEZsYWdsZXIgTXVzZXVtLCBkYXQgaW4gaGV0IHdpbnRlcmh1aXMgaXMgZ2V2ZXN0aWdkIGRhdCBoaWogemlqbiB2cm91dyBjYWRlYXUgZ2FmIGluIDE5MDIsIHZpbmQgamUgYWxsZXJsZWkgYXJ0ZWZhY3RlbiB1aXQgaGV0IGxldmVuIHZhbiBGbGFnbGVyLiBIZXQgbXVzZXVtIGJlc2NoaWt0IG92ZXIgNzUga2FtZXJzIGVuIGhlcmJlcmd0IG9uZGVyIGFuZGVyZSB6aWpuIHByaXZcdTAwZTktdHJlaW4gd2Fnb24uPC9wPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI3NXB4XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiIGZ1bGxfd2lkdGg9XCJzdHJldGNoX3Jvd1wiIGNvbnRlbnRfdGV4dF9hbGlnbWVudD1cImNlbnRlclwiIGNzcz1cIi52Y19jdXN0b21fMTU4NzY1OTI5OTA3MXtwYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O2JhY2tncm91bmQtY29sb3I6ICMwMDAwMDAgIWltcG9ydGFudDt9XCIgcGFyYWxsYXhfYmFja2dyb3VuZF9pbWFnZT1cIjM4MzZcIl1bdmNfY29sdW1uIHRoYl9jb2xvcj1cInRoYi1saWdodC1jb2x1bW5cIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiUGFsbSBCZWFjaFwiIGhlYWRpbmdfdGFnPVwicFwiIG1haW5faGVhZGluZ19jb2xvcj1cIiNmZmZmZmZcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDo2NXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjcwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVtoZXl1c2FfaGVhZGluZyB0YWc9XCJkaXZcIiB0ZXh0X2FsaWduPVwiY2VudGVyXCIgaGVhZGluZz1cIlRhbCB2YW4gbW9vaWUgc3RyYW5kZW5cIiBmb250X3NpemU9XCI1MFwiIGxpbmVfaGVpZ2h0PVwiNTBcIiBmb250X2NvbG9yPVwiI2ZmZmZmZlwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVtwYXJhbGxheF9yb3cgb3BhY2l0eT1cIjg1XCIgZW5hYmxlX21vYmlsZT1cInBhcmFsbGF4LWVuYWJsZS1tb2JpbGVcIiBpbWFnZT1cIjE2NTc2XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIldhdCBqZSBuaWV0IG1hZyBtaXNzZW4gaW4gV2VzdCBQYWxtIEJlYWNoXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiI2IzNGE0Y1wiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjU1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NjBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XVxyXG48cCBzdHlsZT1cInRleHQtYWxpZ246IGNlbnRlcjtcIj5XZXN0IFBhbG0gQmVhY2ggaXMgZWVuIGxldmVuZGlnZSBzdGFkIGluIEZsb3JpZGEgbWV0IGVlbiBsdXhlIGltYWdvLiBFciBoYW5ndCBlZW4gcmVsYXh0ZSBzZmVlciwgaGV0IGlzIGVyIGxla2tlciB3ZWVyIGhldCBoZWxlIGphYXIgZG9vciBlbiBlciB6aWpuIGdlbm9lZyBkaW5nZW4gb20gdGUgZG9lbi4gWm93ZWwgdm9vciBuYXR1dXItLCBjdWx0dXVyLSBhbHMgc2hvcCBsaWVmaGViYmVycyB6aWpuIGVyIHRhbCB2YW4gZGluZ2VuIG9tIHRlIG9uZGVybmVtZW4uIFRpcHMgdm9vciBoZXQgdmVya2VubmVuIHZhbiBXZXN0IFBhbG0gQmVhY2guPC9wPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVt2Y19yb3dfaW5uZXIgY3NzPVwiLnZjX2N1c3RvbV8xNTgyOTcwNzA0OTAze3BhZGRpbmctdG9wOiAxMHB4ICFpbXBvcnRhbnQ7cGFkZGluZy1yaWdodDogMTBweCAhaW1wb3J0YW50O3BhZGRpbmctYm90dG9tOiAxMHB4ICFpbXBvcnRhbnQ7cGFkZGluZy1sZWZ0OiAxMHB4ICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzRcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJBbnRpcXVlIFJvd1wiIGhlYWRpbmdfdGFnPVwiaDNcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMjgyODI4XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozMHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdXHJcbjxwIHN0eWxlPVwidGV4dC1hbGlnbjogY2VudGVyO1wiPkluIFdlc3QgUGFsbSBCZWFjaCB2aW5kIGplIGVlbiB1bmlla2UgcGxlayB2b29yIGFudGlla2xpZWZoZWJiZXJzOyBBbnRpcXVlIFJvdy4gSmUgdmluZHQgaGllciBtZWVyIGRhbiA0MCBhbnRpZWtlIHdpbmtlbHMuIFplIGxpZ2dlbiBhbGxlbWFhbCBvcCBsb29wYWZzdGFuZCB2YW4gZWxrYWFyIHdhYXJkb29yIGhldCBtYWtrZWxpamsgaXMgb20gemUgdGUgYmV6b2VrZW4uIERlbmsgYWFuIGFudGllayB1aXQgZGUgMTdlIHRvdCAyMGUgZWV1dywga3Vuc3QsIHZpbnRhZ2UgZW4gbW9kZXJuZSBtZXViZWxzLCBlciBpcyB2YW4gYWxsZXMgdGUgdmluZGVuIGluIEFudGlxdWUgUm93LjwvcD5cclxuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS80XCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiTm9ydGh3b29kIFZpbGxhZ2VcIiBoZWFkaW5nX3RhZz1cImgzXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzI4MjgyOFwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6MzBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XVxyXG48cCBzdHlsZT1cInRleHQtYWxpZ246IGNlbnRlcjtcIj5FZW4gbGV1a2Ugd2lqayBpbiBXZXN0IFBhbG0gQmVhY2ggaXMgTm9ydGh3b29kIFZpbGxhZ2UuIFZlbGUgZ2Vib3V3ZW4gaW4gTm9ydGh3b29kIFZpbGxhZ2UgZGF0ZXJlbiB1aXQgMTkyMCBlbiAxOTMwIGVuIGRhYXJkb29yIGhlZWZ0IGRlIHdpamsgZWVuIGVpZ2VuIGthcmFrdGVyIGVuIGNoYXJtZS4gSmUgdmluZHQgZXIgdmVlbCB3aW5rZWxzLCByZXN0YXVyYW50cyBlbiBnYWxlcmllXHUwMGVibi4gRGFhcm5hYXN0IHdvcmRlbiBlciBnZWR1cmVuZGUgaGV0IGhlbGUgamFhciB2ZXJzY2hpbGxlbmRlIGV2ZW5lbWVudGVuIGdlb3JnYW5pc2VlcmQuPC9wPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzRcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJXZXN0IFBhbG0gQmVhY2ggWm9vXCIgaGVhZGluZ190YWc9XCJoM1wiIG1haW5faGVhZGluZ19jb2xvcj1cIiMyODI4MjhcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjMwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF1cclxuPHAgc3R5bGU9XCJ0ZXh0LWFsaWduOiBjZW50ZXI7XCI+SW4gaGV0IERyZWhlciBQYXJrIGluIFdlc3QgUGFsbSBCZWFjaCBsaWd0IGRlIFdlc3QgUGFsbSBCZWFjaCBab28sIGVlbiBkaWVyZW50dWluIG1ldCBtZWVyIGRhbiBob25kZXJkZW4gZGllcmVuLiBEZSBwbGVrIG9tIHRpamdlcnMsIG90dGVycywgc2NoaWxkcGFkZGVuLCBtYWFyIG9vayBNZXhpY2FhbnNlIHJldXplbnNwaW5uZW4gdGUgemllbi4gRWVuIGlkZWFsZSBnZXppbnNhY3Rpdml0ZWl0IG9tIHRlIGRvZW4gaW4gV2VzdCBQYWxtIEJlYWNoLiBXZXN0IFBhbG0gQmVhY2ggWm9vIHdlcmQgb3BnZXJpY2h0IGluIDE5NTcgZW4gaXMgc2luZHNkaWVuIGVlbiBiZWxhbmdyaWprZSBhdHRyYWN0aWUgdmFuIGRlIHN0YWQuIEhldCBpcyBnZXJpY2h0IG9wIGhldCBiZXNjaGVybWVuIHZhbiBiZWRyZWlnZGUgZGllcnNvb3J0ZW4gZW4gbmF0dXVyYmVob3VkLiBOZWVtIG9uZ2V2ZWVyIDEtMiB1dXIgZGUgdGlqZCB2b29yIGVlbiBiZXpvZWsgYWFuIGRlIGRpZXJlbnR1aW4uPC9wPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzRcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJSb3NlbWFyeSBTcXVhcmVcIiBoZWFkaW5nX3RhZz1cImgzXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzI4MjgyOFwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6MzBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XVxyXG48cCBzdHlsZT1cInRleHQtYWxpZ246IGNlbnRlcjtcIj5FZW4gZ29lZGUgbWFuaWVyIG9tIGtlbm5pcyB0ZSBtYWtlbiBtZXQgV2VzdCBQYWxtIEJlYWNoIGlzIGRvb3IgZWVuIGJlem9layB0ZSBicmVuZ2VuIGFhbiBSb3NlbWFyeSBTcXVhcmUuIEhldCBjZW50cmFhbCBnZWxlZ2VuIHBsZWluIGluIGRlIHN0YWQgc3RhYXQgdm9sIG1ldCBnZWJvdXdlbiBpbiBtZWRpdGVycmFuZSBzdGlqbCwgcGFsbWJvbWVuIGVuIGlzIG9tcmluZ2QgZG9vciBzZmVlcnZvbGxlIHN0cmF0ZW4uIEhpZXIgdmluZCBqZSB0YWwgdmFuIGxldWtlIGJvZXRpZWtzLCBjYWZcdTAwZTlzIGVuIHJlc3RhdXJhbnRzLjwvcD5cclxuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIHRoYl9yb3dfcGFkZGluZz1cInRydWVcIiB0aGJfY29sdW1uX3BhZGRpbmc9XCJ0cnVlXCIgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIl1bdmNfY29sdW1uIHdpZHRoPVwiMS8yXCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiNS82XCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJNYW5hdGVlIExhZ29vblwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTozMHx0ZXh0X2FsaWduOmxlZnR8Y29sb3I6JTIzMjgyODI4fGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW2hleXVzYV9oZWFkaW5nIHRhZz1cImRpdlwiIGhlYWRpbmc9XCJTcG90IGRlIG1hbmF0ZWVcIiBmb250X3NpemU9XCI0MFwiIGxpbmVfaGVpZ2h0PVwiNDBcIiBmb250X2NvbG9yPVwiIzI4MjgyOFwiXVt2Y19jb2x1bW5fdGV4dF1cclxuPHAgc3R5bGU9XCJ0ZXh0LWFsaWduOiBsZWZ0O1wiPkluIEZsb3JpZGEgaGViIGplIHZlcnNjaGlsbGVuZGUgcGxla2tlbiBvbSBkZSB1bmlla2UgaW53b25lciB2YW4gaGV0IHdhdGVyIHRlIHppZW46IGRlIDxhIGhyZWY9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL21hbmF0ZWVzLWZsb3JpZGEvXCI+bWFuYXRlZTwvYT4uIERlIG1hbmF0ZWUsIG9vayB3ZWwgemVla29lLCBpcyBlZW4gdW5pZWsgZGllciBpbiBGbG9yaWRhIGRpZSBqZSBoZXQgYmVzdGUga3VudCB6aWVuIGluIGRlIHdpbnRlcm1hYW5kZW4uIElldHMgdGVuIG5vb3JkZW4gdmFuIFdlc3QgUGFsbSBCZWFjaCB2ZXJ6YW1lbGRlbiBtYW5hdGVlcyBpbiBkZSBidXVydCB2YW4gZGUgRmxvcmlkYSBQb3dlciAmYW1wOyBMaWdodCBmYWNpbGl0ZWl0LiBWYW53ZWdlIGRlIHdhcm0gd2F0ZXJzdHJvb20gZWVuIGlkZWFsZSBwbGVrIHZvb3IgZGV6ZSBkaWVyZW4uIFZhbmFmIGRlemUgcGxlayBrdW4gamUgZGUgbWFuYXRlZXMgcGVyZmVjdCB6aWVuIHp3ZW1tZW4uPC9wPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS8yXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjEwMCVcIl1bdGhiX2ltYWdlIHJldGluYT1cInJldGluYV9zaXplXCIgZnVsbF93aWR0aD1cInRydWVcIiBpbWFnZT1cIjE1MzY1XCJdWy90aGJfaW1hZ2VdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiB0aGJfcm93X3BhZGRpbmc9XCJ0cnVlXCIgdGhiX2NvbHVtbl9wYWRkaW5nPVwidHJ1ZVwiIGNvbnRlbnRfcGxhY2VtZW50PVwibWlkZGxlXCJdW3ZjX2NvbHVtbiB3aWR0aD1cIjEvMlwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCIxMDAlXCJdW3RoYl9pbWFnZSByZXRpbmE9XCJyZXRpbmFfc2l6ZVwiIGZ1bGxfd2lkdGg9XCJ0cnVlXCIgaW1hZ2U9XCIxNjcwMVwiXVsvdGhiX2ltYWdlXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvMlwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjUvNlwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiUGVhbnV0IElzbGFuZFwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgzfGZvbnRfc2l6ZTozMHx0ZXh0X2FsaWduOmxlZnR8Y29sb3I6JTIzMjgyODI4fGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW2hleXVzYV9oZWFkaW5nIHRhZz1cImRpdlwiIGhlYWRpbmc9XCJUcm9waXNjaCBwYXJhZGlqc1wiIGZvbnRfc2l6ZT1cIjQwXCIgbGluZV9oZWlnaHQ9XCI0MFwiIGZvbnRfY29sb3I9XCIjMjgyODI4XCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48cCBzdHlsZT1cInRleHQtYWxpZ246IGxlZnQ7XCI+VHVzc2VuIFdlc3QgUGFsbSBCZWFjaCBlbiBQYWxtIEJlYWNoIHZpbmQgamUgaGV0IGVpbGFuZCBQZWFudXQgSXNsYW5kLiBIZXQgNzkgaGVjdGFyZSBncm90ZSBlaWxhbmQgbGlndCBpbiBkZSBtb25kaW5nIHZhbiBMYWtlIFdvcnRoIElubGV0LiBFZW4gdHJvcGlzY2ggcGFyYWRpanMgbWV0IG9uZ2VyZXB0ZSB3aXR0ZSBzdHJhbmRlbiwgcGFsbWJvbWVuIGVuIGhlbGRlciB3YXRlciBkYXQgdWl0bm9kaWd0IG9tIHRlIHdhdGVyc3BvcnRlbiBlbiB0ZSBzbm9ya2VsZW4uIEplIGt1bnQgZXIgdHJvcGlzY2hlIHZpc3NlbiB6aWVuLCB6ZWVzdGVycmVuIGVuIG1pc3NjaGllbiB6ZWxmcyBtYW5hdGVlcy4gT3AgaGV0IGVpbGFuZCBrdW4gamUgZGUgbnVjbGVhaXJlIGJ1bmtlciBiZXpvZWtlbiBkaWUgSm9obiBGLiBLZW5uZWR5IGJvdXdkZSB0aWpkZW5zIGRlIEtvdWRlIE9vcmxvZy48L3A+XHJcblsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIiBmdWxsX3dpZHRoPVwic3RyZXRjaF9yb3dcIiBjb250ZW50X3RleHRfYWxpZ21lbnQ9XCJjZW50ZXJcIiBjc3M9XCIudmNfY3VzdG9tXzE1ODc2NTkyOTkwNzF7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDtiYWNrZ3JvdW5kLWNvbG9yOiAjMDAwMDAwICFpbXBvcnRhbnQ7fVwiIHBhcmFsbGF4X2JhY2tncm91bmRfaW1hZ2U9XCIzODM2XCJdW3ZjX2NvbHVtbiB0aGJfY29sb3I9XCJ0aGItbGlnaHQtY29sdW1uXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIldlc3QgUGFsbSBCZWFjaFwiIGhlYWRpbmdfdGFnPVwicFwiIG1haW5faGVhZGluZ19jb2xvcj1cIiNmZmZmZmZcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDo2NXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjcwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVtoZXl1c2FfaGVhZGluZyB0YWc9XCJkaXZcIiB0ZXh0X2FsaWduPVwiY2VudGVyXCIgaGVhZGluZz1cIlN0YWQgbWV0IGVlbiBsdXhlIGltYWdvXCIgZm9udF9zaXplPVwiNTBcIiBsaW5lX2hlaWdodD1cIjUwXCIgZm9udF9jb2xvcj1cIiNmZmZmZmZcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bcGFyYWxsYXhfcm93IG9wYWNpdHk9XCI4NVwiIGVuYWJsZV9tb2JpbGU9XCJwYXJhbGxheC1lbmFibGUtbW9iaWxlXCIgaW1hZ2U9XCIxNjU3OFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIiBjc3M9XCIudmNfY3VzdG9tXzE2ODk5NTYyODA3MzF7cGFkZGluZy10b3A6IDUwcHggIWltcG9ydGFudDtwYWRkaW5nLWJvdHRvbTogNTBweCAhaW1wb3J0YW50O2JhY2tncm91bmQtaW1hZ2U6IHVybChodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIxLzA4L2FsbC1kYXktdXNhLWJhY2tncm91bmQuZ2lmP2lkPTg0MDgpICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMi8zXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW2hleXVzYV9oZWFkaW5nIHRhZz1cImRpdlwiIGhlYWRpbmc9XCJIYW5kaWdlIGluZm8gdmFuIGRlIHJlZGFjdGllXCIgZm9udF9zaXplPVwiNDNcIiBsaW5lX2hlaWdodD1cIjQ1XCIgZm9udF9jb2xvcj1cIiNiMzRhNGNcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkVzc2VudGlcdTAwZWJsZSB0aXBzIHZvb3IgcmVpemVuIG5hYXIgUGFsbSBCZWFjaDpcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoM3xmb250X3NpemU6MjV8dGV4dF9hbGlnbjpsZWZ0fGNvbG9yOiUyMzI4MjgyOHxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6Um9ib3RvJTIwU2xhYiUzQTEwMCUyQzMwMCUyQ3JlZ3VsYXIlMkM3MDB8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX3Jvd19pbm5lciBib3hfc2hhZG93PVwibGFyZ2Utc2hhZG93XCIgY3NzPVwiLnZjX2N1c3RvbV8xNjg5OTU1NDg2MDg3e2JhY2tncm91bmQtY29sb3I6ICNmZmZmZmYgIWltcG9ydGFudDtib3JkZXItcmFkaXVzOiAxMHB4ICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW5faW5uZXJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjI1cHhcIl1bdWx0aW1hdGVfaWNvbl9saXN0IGljb25fc2l6ZT1cIjY1XCIgaWNvbl9tYXJnaW49XCIxMFwiXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uX3R5cGU9XCJjdXN0b21cIiBpY29uX2ltZz1cImlkXjE2NzU4fHVybF5odHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIzLzA3L2hleXVzYS1leHBlcnQtdGlwLnBuZ3xjYXB0aW9uXkhleSFVU0EgRXhwZXJ0IFRpcCBvdmVyIHJlaXplbiBuYWFyIEFtZXJpa2F8YWx0XkhleSFVU0EgRXhwZXJ0IFRpcCBvdmVyIHJlaXplbiBuYWFyIEFtZXJpa2F8dGl0bGVeSGV5IVVTQSBFeHBlcnQgVGlwIG92ZXIgcmVpemVuIG5hYXIgQW1lcmlrYXxkZXNjcmlwdGlvbl5IZXkhVVNBIEV4cGVydCBUaXAgb3ZlciByZWl6ZW4gbmFhciBBbWVyaWthXCIgY29udGVudF9mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBjb250ZW50X2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBjb250ZW50X2ZvbnRfY29sb3I9XCIjMjgyODI4XCJdSGV5IVVTQVxyXG5wZXJzb29ubGlqa2UgdGlwczpbL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVsvdWx0aW1hdGVfaWNvbl9saXN0XVt2Y19jb2x1bW5fdGV4dF1cclxuPHVsPlxyXG4gXHQ8bGk+SG9lIGxhbmcgdmVyYmxpanZlbj8gPGVtPjQ8L2VtPjxlbT5cdTAwYTB2b2xsZSBkYWdlbjwvZW0+PC9saT5cclxuIFx0PGxpPkF1dG8gbm9kaWc/XHUwMGEwPGVtPjxhIGhyZWY9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL2F1dG8taHVyZW4taW4tYW1lcmlrYS9cIj5IdXVyYXV0bzwvYT4gaXMgbm9vZHpha2VsaWprPC9lbT48L2xpPlxyXG4gXHQ8bGk+QmVzdGUgcGVyaW9kZT8gPGVtPlR1c3NlbiBhcHJpbCBlbiBtZWkgZW4gc2VwdGVtYmVyIGVuIG9rdG9iZXI8L2VtPjwvbGk+XHJcbiBcdDxsaT5EcnVrc3RlIG1hYW5kZW4/IDxlbT5KdWxpLCBkZWNlbWJlciBlbiBmZWJydWFyaTwvZW0+PC9saT5cclxuIFx0PGxpPldhcm1zdGUgbWFhbmQ/IDxlbT5BdWd1c3R1czwvZW0+PC9saT5cclxuIFx0PGxpPk1lZXN0ZSByZWdlbj8gPGVtPkp1bmksIGF1Z3VzdHVzIGVuIHNlcHRlbWJlcjwvZW0+PC9saT5cclxuIFx0PGxpPkhvdGVsIGFhbmJldmVsaW5nZW4gdm9vciBQYWxtIEJlYWNoOiA8YSBocmVmPVwiaHR0cHM6Ly93d3cuYm9va2luZy5jb20vaG90ZWwvdXMvdGhlLWJyZWFrZXJzLXBhbG0tYmVhY2guZW4uaHRtbD9haWQ9Nzk1ODQ5OCZhbXA7bm9fcm9vbXM9MSZhbXA7Z3JvdXBfYWR1bHRzPTImYW1wO2xhYmVsPXBhbG1iZWFjaGJyZWFrZXJzXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5UaGUgQnJlYWtlcnMgUGFsbSBCZWFjaDwvYT58IDxhIGhyZWY9XCJodHRwczovL3d3dy5ib29raW5nLmNvbS9ob3RlbC91cy9oYW1tb24tYXZlLmVuLmh0bWw/YWlkPTc5NTg0OTgmYW1wO25vX3Jvb21zPTEmYW1wO2dyb3VwX2FkdWx0cz0yJmFtcDtsYWJlbD1wYWxtYmVhY2hjb2xvbnlcIj5UaGUgQ29sb255IEhvdGVsPC9hPjwvbGk+XHJcbjwvdWw+XHJcblsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIk9udGRlayBpbiBGbG9yaWRhXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzI4MjgyOFwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjQ1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NTBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bZnVsbHdpZHRoX3Jvd11bdGhiX3Bvc3RncmlkIGNvbHVtbnM9XCI0XCIgc291cmNlPVwicG9zdF90eXBlOnBvc3R8YnlfaWQ6LTE2MTc0LDE1MzU1LC0xNTE2MywtNDcyNSwtMTU1OSwxNjM0MiwxNjQwMCwxNjUwN1wiXVsvdmNfY29sdW1uXVsvdmNfcm93XSIsInBvc3RfdGl0bGUiOiJQYWxtIEJlYWNoICYjMDM4OyBXZXN0IFBhbG0gQmVhY2ggaW4gRmxvcmlkYSIsInBvc3RfbGluayI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvcGFsbS1iZWFjaC1mbG9yaWRhLyIsInBvc3RfZmVhdHVyZWRfaW1hZ2UiOiI8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIldlc3QgcGFsbSBCZWFjaFwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjI1XCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMy8wNy93ZXN0LXBhbG0tYmVhY2gtMS0zMDB4MjI1LmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6IlN0ZWRlbnRyaXBzIiwicG9zdF90YWdzIjoiRmxvcmlkYSIsIiVfd3BiX3Nob3J0Y29kZXNfY3VzdG9tX2NzcyUiOiIudmNfY3VzdG9tXzE0NzIzMDc1MDIyOTB7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDtwYWRkaW5nLWJvdHRvbTogMjVweCAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE1ODc2NTkyOTkwNzF7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDtiYWNrZ3JvdW5kLWNvbG9yOiAjMDAwMDAwICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTU4NzY1OTI5OTA3MXtwYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O2JhY2tncm91bmQtY29sb3I6ICMwMDAwMDAgIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNjg5OTU2MjgwNzMxe3BhZGRpbmctdG9wOiA1MHB4ICFpbXBvcnRhbnQ7cGFkZGluZy1ib3R0b206IDUwcHggIWltcG9ydGFudDtiYWNrZ3JvdW5kLWltYWdlOiB1cmwoaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMS8wOC9hbGwtZGF5LXVzYS1iYWNrZ3JvdW5kLmdpZj9pZD04NDA4KSAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE1ODI5NzA3MDQ5MDN7cGFkZGluZy10b3A6IDEwcHggIWltcG9ydGFudDtwYWRkaW5nLXJpZ2h0OiAxMHB4ICFpbXBvcnRhbnQ7cGFkZGluZy1ib3R0b206IDEwcHggIWltcG9ydGFudDtwYWRkaW5nLWxlZnQ6IDEwcHggIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNTgyOTcwNzA0OTAze3BhZGRpbmctdG9wOiAxMHB4ICFpbXBvcnRhbnQ7cGFkZGluZy1yaWdodDogMTBweCAhaW1wb3J0YW50O3BhZGRpbmctYm90dG9tOiAxMHB4ICFpbXBvcnRhbnQ7cGFkZGluZy1sZWZ0OiAxMHB4ICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTY4OTk1NTQ4NjA4N3tiYWNrZ3JvdW5kLWNvbG9yOiAjZmZmZmZmICFpbXBvcnRhbnQ7Ym9yZGVyLXJhZGl1czogMTBweCAhaW1wb3J0YW50O30iLCIlX2VkaXRfbG9jayUiOiIxNjkyMTAxNDIyOjIiLCIlX2VkaXRfbGFzdCUiOiIyIiwiJV93cGJfdmNfanNfc3RhdHVzJSI6InRydWUiLCIlcG9zdC1wcmltYXJ5LWNhdGVnb3J5JSI6IjE2IiwiJWZlYXR1cmVkX2ltYWdlX292ZXJyaWRlJSI6Im9mZiIsIiVhcnRpY2xlX3N0eWxlX292ZXJyaWRlJSI6Im9uIiwiJXBvc3Rfc3R5bGUlIjoic3R5bGU1IiwiJXBvc3RfZ2FsbGVyeV9zdHlsZSUiOiJsaWdodGJveCIsIiVwb3N0X3JldmlldyUiOiJvZmYiLCIlcG9zdF9yZXZpZXdfc3R5bGUlIjoic3R5bGUxIiwiJXBvc3RfcmV2aWV3X2F2ZXJhZ2UlIjoiNTAiLCIldGhiX2FsbF9jb3VudHMlIjoiMCIsIiVleGVjdXRpdmVfc3VtbWFyeSUiOiIiLCIldGhiLXJlYWN0aW9ucy12b3RlcyUiOiIxIiwiJV9oaWRlX2ZlYXR1cmVkJSI6bnVsbCwiJV93cF9vbGRfZGF0ZSUiOiIyMDIwLTA2LTE3IiwiJWlubGluZV9mZWF0dXJlZF9pbWFnZSUiOiIwIiwiJV95b2FzdF93cHNlb19mb2N1c2t3JSI6IlBhbG0gQmVhY2ggRmxvcmlkYSIsIiVfeW9hc3Rfd3BzZW9fdGl0bGUlIjoiUGFsbSBCZWFjaCUlc2VwJSUgJSVzaXRlbmFtZSUlIiwiJV95b2FzdF93cHNlb19tZXRhZGVzYyUiOiJFZW4gd2FhciBwYXJhZGlqcyB2b29yIGRlIGt1c3QgdmFuIEZsb3JpZGEsIFBhbG0gQmVhY2guIEJlbmlldXdkIHdhdCBqZSBrdW50IGRvZW4gaW4gUGFsbSBCZWFjaCBlbiBvbWdldmluZz8iLCIlX3lvYXN0X3dwc2VvX2xpbmtkZXglIjoiNzgiLCIlX3lvYXN0X3dwc2VvX2NvbnRlbnRfc2NvcmUlIjoiOTAiLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza2V5d29yZHMlIjoiW10iLCIlX3lvYXN0X3dwc2VvX2tleXdvcmRzeW5vbnltcyUiOiJbXCJcIl0iLCIlX3dwZ21wX2xvY2F0aW9uX2FkZHJlc3MlIjoiU2FuaWJlbCBJc2xhbmQsIEZsb3JpZGEsIFZlcmVuaWdkZSBTdGF0ZW4iLCIlX3dwZ21wX2xvY2F0aW9uX2NpdHklIjoiIiwiJV93cGdtcF9sb2NhdGlvbl9zdGF0ZSUiOiJGbG9yaWRhIiwiJV93cGdtcF9sb2NhdGlvbl9jb3VudHJ5JSI6IlZlcmVuaWdkZSBTdGF0ZW4iLCIlX3dwZ21wX21ldGFib3hfbGF0aXR1ZGUlIjoiMjYuNDQzMzk3MiIsIiVfd3BnbXBfbWV0YWJveF9sb25naXR1ZGUlIjoiLTgyLjExMTUxMTkiLCIlX3dwZ21wX21ldGFib3hfbG9jYXRpb25fcmVkaXJlY3QlIjoibWFya2VyIiwiJV93cGdtcF9tZXRhYm94X2N1c3RvbV9saW5rJSI6IiIsIiVfd3BnbXBfbWFwX2lkJSI6ImE6MTp7aTowO3M6MTpcIjdcIjt9IiwiJV93cGdtcF9tZXRhYm94X21hcmtlcl9pZCUiOiJhOjE6e2k6MDtzOjE6XCIyXCI7fSIsIiVfd3BnbXBfbWV0YWJveF90YXhvbW9taWVzX3Rlcm1zJSI6IiIsIiVfd3BnbXBfZXh0ZW5zaW9uc19maWVsZHMlIjoiIiwiJV95b2FzdF93cHNlb19lc3RpbWF0ZWQtcmVhZGluZy10aW1lLW1pbnV0ZXMlIjoiNyIsIiVfd3dzX3N1cHBvcnRfY29udGFjdF9udW1iZXIlIjoiIiwiJV93d3NfYWJvdXRfc3VwcG9ydF90ZXh0JSI6IiIsIiVfd3dzX3RyaWdnZXJfYnV0dG9uX3RleHQlIjoiIiwiJV93d3NfcHJlZGVmaW5lZF90ZXh0JSI6IiIsIiVfeW9hc3RfaW5kZXhub3dfbGFzdF9waW5nJSI6IjE2OTIxMDE1MjciLCIlX3lvYXN0X3dwc2VvX3dvcmRwcm9vZl90aW1lc3RhbXAlIjoiIiwiJV9sYXN0X2VkaXRvcl91c2VkX2pldHBhY2slIjoiY2xhc3NpYy1lZGl0b3IiLCIlX3lvYXN0X3dwc2VvX3ByaW1hcnlfY2F0ZWdvcnklIjoiNjIiLCIlcG9zdF92aWElIjpbeyJ0aXRsZSI6IlBlYW51dCBJc2xhbmQgXHUwMGE5IFBldGVyIFcuIENyb3NzIiwicG9zdF9zb3VyY2VfdXJsIjoidmlzaXRmbG9yaWRhLmNvbSJ9LHsidGl0bGUiOiJXZXN0IFBhbG0gQmVhY2ggXHUwMGE5IE5QSSBQcm9kdWN0aW9ucyIsInBvc3Rfc291cmNlX3VybCI6InZpc2l0ZmxvcmlkYS5jb20ifV0sIiVfdGh1bWJuYWlsX2lkJSI6IjE2NzAzIiwiJXN0YW5kYXJkLWZlYXR1cmVkLWNyZWRpdCUiOiJcdTAwYTkgTlBJIFByb2R1Y3Rpb25zIiwidGF4b25vbXk9Y2F0ZWdvcnkiOiJTdGVkZW50cmlwcyIsInRheG9ub215PXBvc3RfdGFnIjoiRmxvcmlkYSIsInRheG9ub215PXBvc3RfZm9ybWF0IjoiIiwidGF4b25vbXk9dGhiLXJlYWN0aW9ucyI6IiIsInRheG9ub215PXRoYi1zcG9uc29ycyI6IiJ9LCJpY29uIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyNC8wMy9tdXNlYS1pY29uLnBuZyJ9LCJpZCI6MTY1MjEsImluZm93aW5kb3dfZGlzYWJsZSI6ZmFsc2UsImNhdGVnb3JpZXMiOlt7Imljb24iOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDI0LzAzL211c2VhLWljb24ucG5nIiwibmFtZSI6Ik11c2VhIiwiaWQiOiIyIiwidHlwZSI6ImNhdGVnb3J5IiwiZXh0ZW5zaW9uX2ZpZWxkcyI6eyJjYXRfb3JkZXIiOiIifX1dfSx7InNvdXJjZSI6InBvc3QiLCJ0aXRsZSI6IldpbmRsZXkgS2V5IEZvc3NpbCBSZWVmIEdlb2xvZ2ljYWwgU3RhdGUgUGFyayIsImluZm93aW5kb3dfY29udGVudCI6IjxkaXYgY2xhc3M9XCJmYy1pdGVtLWJveCBmYy1pdGVtLW5vLXBhZGRpbmcgXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIk92ZXJibGlqZnNlbGVuIHZhbiBvdWRlIG1hY2hpbmVzIG9tIGthbGtzdGVlbiB0ZSBkZWx2ZW4gaW4gV2luZGxleSBLZXkgRm9zc2lsIFJlZWYgR2VvbG9naWNhbCBTdGF0ZSBQYXJrXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMDBcIiBzcmM9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIzLzA3L3dpbmRsZXkta2V5LWZvc3NpbC1yZWVmLXN0YXRlLXBhcmstb3ZlcmJsaWpmc2VsZW4tMzAweDIwMC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmcgZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+V2luZGxleSBLZXkgRm9zc2lsIFJlZWYgR2VvbG9naWNhbCBTdGF0ZSBQYXJrPC9kaXY+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3JcIj57bWFya2VyX2FkZHJlc3N9PC9kaXY+XHJcbiAgICAgICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1jbGVhclwiPjwvZGl2PlxyXG48L2Rpdj4iLCJhZGRyZXNzIjoiODQ5MDAgT3ZlcnNlYXMgSHd5LCBJc2xhbW9yYWRhLCBGTCAzMzAzNiwgVmVyZW5pZ2RlIFN0YXRlbiIsImxvY2F0aW9uIjp7ImxhdCI6IjI0Ljk1NzEyMzUiLCJjaXR5IjoiSXNsYW1vcmFkYSIsInN0YXRlIjoiRmxvcmlkYSIsImNvdW50cnkiOiJWZXJlbmlnZGUgU3RhdGVuIiwibG5nIjoiLTgwLjU5NTExNDc5OTk5OTk5Iiwib25jbGlja19hY3Rpb24iOiJtYXJrZXIiLCJyZWRpcmVjdF9wZXJtYWxpbmsiOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dpbmRsZXkta2V5LWZvc3NpbC1yZWVmLWdlb2xvZ2ljYWwtc3RhdGUtcGFyay8iLCJ6b29tIjoxMiwiZXh0cmFfZmllbGRzIjp7InBvc3RfZXhjZXJwdCI6IiIsInBvc3RfY29udGVudCI6Ilt2Y19yb3cgY3NzPVwiLnZjX2N1c3RvbV8xNjg5MzIxNTkzMzAze2JhY2tncm91bmQtaW1hZ2U6IHVybChodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIwLzA4L2JhY2tncm91bmQtaGV5dXNhLW5hdHV1ci0xLmdpZj9pZD0zMDg4KSAhaW1wb3J0YW50O31cIl1bdmNfY29sdW1uXVtoZXl1c2FfaGVhZGluZyB0YWc9XCJkaXZcIiB0ZXh0X2FsaWduPVwiY2VudGVyXCIgaGVhZGluZz1cIkZsb3JpZGEgU3RhdGUgUGFya1wiIGZvbnRfc2l6ZT1cIjU1XCIgbGluZV9oZWlnaHQ9XCI2MFwiIGZvbnRfY29sb3I9XCIjODdhMzc1XCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjIvM1wiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiV2luZGxleSBLZXkgRm9zc2lsIFJlZWYgR2VvbG9naWNhbCBTdGF0ZSBQYXJrXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjQ1fHRleHRfYWxpZ246Y2VudGVyfGNvbG9yOiUyMzI4MjgyOHxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiRGUgZ2VzY2hpZWRlbmlzIHZhbiBLZXkgTGltZXN0b25lIChrYWxrc3RlZW4pXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDN8Zm9udF9zaXplOjM1fHRleHRfYWxpZ246Y2VudGVyfGNvbG9yOiUyMzI4MjgyOHxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6Um9ib3RvJTIwU2xhYiUzQTEwMCUyQzMwMCUyQ3JlZ3VsYXIlMkM3MDB8Zm9udF9zdHlsZTozMDAlMjBsaWdodCUyMHJlZ3VsYXIlM0EzMDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxwIHN0eWxlPVwidGV4dC1hbGlnbjogY2VudGVyO1wiPkRlIEZsb3JpZGEgS2V5cyB6aWpuIG9uZ2V2ZWVyIDEzMC4wMDAgamFhciBnZWxlZGVuIG9udHN0YWFuIGRvb3IgZWVuIGNvbWJpbmF0aWUgdmFuIGdlb2xvZ2lzY2hlIGFjdGl2aXRlaXQuIERlIGVpbGFuZGVuIGJlc3RhYW4gdWl0IGtvcmFhbHJpZmZlbiBkaWUgbWlsam9lbmVuIGphcmVuIGdlbGVkZW4gemlqbiBnZXZvcm1kIGVuIHZlcnZvbGdlbnMgYmVkZWt0IHdlcmRlbiBkb29yIHNlZGltZW50ZW4uIERvb3IgdGVrdG9uaXNjaGUgYmV3ZWdpbmdlbiBlbiBzdGlqZ2luZyB2YW4gZGUgemVlc3BpZWdlbCBvbnRzdG9uZGVuIHVpdGVpbmRlbGlqayBkZSBlaWxhbmRlbi4gSGV0IHJlc3VsdGFhdCBpcyBlZW4gdW5pZWtlIGFyY2hpcGVsIHZhbiBwcmFjaHRpZ2UgZWlsYW5kZW4gZW4ga29yYWFscmlmZmVuLiBKYXJlbmxhbmcgd2VyZCBpbiBkZSBncm9ldmUgdmFuIGRpdCBXaW5kbGV5IEtleSBGb3NzaWwgUmVlZiBHZW9sb2dpY2FsIFN0YXRlIFBhcmsgaGV0IGJlcm9lbWRlICdLZXkgTGltZXN0b25lJyBnZWRvbHZlbi4gRGl0IGthbGtzdGVlbiBpcyBvbmRlciBhbmRlcmUgZ2VicnVpa3Qgdm9vciBkZSBGbG9yaWRhIEVhc3QgQ29hc3QgUmFpbHJvYWQgZW4gb20gdmVyc2NoaWxsZW5kZSBnZWJvdXdlbiBpbiBDb3JhbCBHYWJsZXMgaW4gTWlhbWkgdGUgYm91d2VuLjwvcD5cclxuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjk1JVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIyNXB4XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiMTAwJVwiXVt2Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkVkdWNhdGllZiBTdGF0ZSBQYXJrIGluIEZsb3JpZGFcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoM3xmb250X3NpemU6MzV8dGV4dF9hbGlnbjpsZWZ0fGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3RoYl9pY29ubGlzdCBpY29uPVwiZmFzIGZhLW1hcC1tYXJrZXItYWx0XCIgbGlzdF9jb250ZW50PVwiODQ5MDAgT3ZlcnNlYXMgSGlnaHdheSB8IElzbGFtb3JhZGFcIl1bdmNfY29sdW1uX3RleHRdRGl0IEZsb3JpZGEgU3RhdGUgUGFyayB3b3JkdCBvbnRlcmVjaHQgdmFhayBvdmVyZ2VzbGFnZW4gZG9vciBiZXpvZWtlcnMgZGllIHJpY2h0aW5nIEtleSBXZXN0IHJpamRlbi4gSGV0IG1vZXQgZGFuIG9vayBvcGJva3NlbiB0ZWdlbiBwb3B1bGFpcmUgcGFya2VuIGFscyA8YSBocmVmPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9qb2huLXBlbm5la2FtcC1jb3JhbC1yZWVmLXN0YXRlLXBhcmsvXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5Kb2huIFBlbm5la2FtcCBDb3JhbCBSZWVmIFN0YXRlIFBhcms8L2E+IGVuIDxhIGhyZWY9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL2JhaGlhLWhvbmRhLXN0YXRlLXBhcmsvXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5CYWhpYSBIb25kYTwvYT4uIFdhYXIgamUgaW4gZGV6ZSBwYXJrZW4gdm9vcmFsIGt1bnQgZ2VuaWV0ZW4gdmFuIGRlIG5hdHV1ciwgc3RyYW5kIGVuIHNub3JrZWxlbiwgaGVlZnQgV2luZGxleSBLZXkgRm9zc2lsIFJlZWYgR2VvbG9naWNhbCBTdGF0ZSBQYXJrIHZvb3JhbCBlZW4gZWR1Y2F0aWV2ZSBvcHpldCBuYWFzdCB2ZXJzY2hpbGxlbmRlIG1vb2llIHRyYWlscy5bL3ZjX2NvbHVtbl90ZXh0XVt1bHRpbWF0ZV9pY29uX2xpc3QgaWNvbl9zaXplPVwiMjBcIl1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLWRvbGxhciB1c2RcIl08c3BhbiBjbGFzcz1cIkxyelhyIGtuby1mdlwiPjIsNTAgcGVyIHBlcnNvb248L3NwYW4+Wy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLWF1dG9tb2JpbGUgY2FyXCJdMTMxIGtpbG9tZXRlciB2YW4gTWlhbWlbL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtdHJlZVwiXTxzcGFuIGNsYXNzPVwiTHJ6WHIga25vLWZ2XCI+NDAgc29vcnRlbiBib21lbjwvc3Bhbj5bL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtYmFuayBpbnN0aXR1dGlvbiB1bml2ZXJzaXR5XCJdPHNwYW4gY2xhc3M9XCJMcnpYciBrbm8tZnZcIj5LbGVpbiBtdXNldW08L3NwYW4+Wy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLWxvY2F0aW9uLWFycm93XCJdPHNwYW4gY2xhc3M9XCJMcnpYciBrbm8tZnZcIj4yLDQga2lsb21ldGVyIHRyYWlsczwvc3Bhbj5bL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVsvdWx0aW1hdGVfaWNvbl9saXN0XVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMjVweFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIiBmdWxsX3dpZHRoPVwic3RyZXRjaF9yb3dcIiBjb250ZW50X3RleHRfYWxpZ21lbnQ9XCJjZW50ZXJcIiBjc3M9XCIudmNfY3VzdG9tXzE2NDAwNjY5MDc0Mzl7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDtiYWNrZ3JvdW5kLWNvbG9yOiAjMDAwMDAwICFpbXBvcnRhbnQ7fVwiIHBhcmFsbGF4X2JhY2tncm91bmRfaW1hZ2U9XCIzODM2XCJdW3ZjX2NvbHVtbiB0aGJfY29sb3I9XCJ0aGItbGlnaHQtY29sdW1uXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNzVweFwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiS2Fsa3N0ZWVuZ3JvZXZlIHZvb3IgSGVucnkgRmxhZ2xlcidzIHNwb29ybGlqblwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTo1NXx0ZXh0X2FsaWduOmNlbnRlcnxjb2xvcjolMjNmZmZmZmZ8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1baGV5dXNhX2hlYWRpbmcgdGFnPVwiZGl2XCIgdGV4dF9hbGlnbj1cImNlbnRlclwiIGhlYWRpbmc9XCJIZW5yeSBGbGFnbGVyJ3MgT3ZlcnNlYXMgUmFpbHJvYWRcIiBmb250X3NpemU9XCI2MFwiIGxpbmVfaGVpZ2h0PVwiNjVcIiBmb250X2NvbG9yPVwiI2ZmZmZmZlwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNzVweFwiXVtwYXJhbGxheF9yb3cgb3BhY2l0eT1cIjkwXCIgZW5hYmxlX21vYmlsZT1cInBhcmFsbGF4LWVuYWJsZS1tb2JpbGVcIiBpbWFnZT1cIjE2NjI5XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjc3M9XCIudmNfY3VzdG9tXzE2MDg2NjY4ODU0OTd7YmFja2dyb3VuZC1pbWFnZTogdXJsKGh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjAvMDgvYmFja2dyb3VuZC1oZXl1c2EtbmF0dXVyLTEuZ2lmP2lkPTMwODgpICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW5dW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiV2FuZGVsaW5nZW4gJmFtcDsgdHJhaWxzXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzAwMDAwMFwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjU1cHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF1IZXQgV2luZGxleSBLZXkgRm9zc2lsIFJlZWYgR2VvbG9naWNhbCBTdGF0ZSBQYXJrIGluIDxhIGhyZWY9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL2lzbGFtb3JhZGEtZmxvcmlkYS1rZXlzL1wiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+SXNsYW1vcmFkYTwvYT4gc3RhYXQgdm9vcmFsIGJla2VuZCBvbSB6aWpuIGdlb2xvZ2lzY2hlIGdlc2NoaWVkZW5pcyBlbiBpcyBtaW5kZXIgZWVuIHBhcmsgb20gdGUgd2FuZGVsZW4uIERlIGJpam5hIDIsNSBraWxvbWV0ZXIgYWFuIHRyYWlscyBzdGFhbiBkYW4gb29rIGluIGhldCB0ZWtlbiB2YW4geiduIHRpamQgYWxzIGthbGtzdGVlbmdyb2V2ZS4gSmUgcGFzc2VlcnQgbGFuZ3MgcGxla2tlbiB3YWFyIGthbGtzdGVlbiBnZWRvbHZlbiBpcy4gSmUgemlldCBvdWRlIGFwcGFyYXR1dXIgdWl0IGRlIHZyb2VnZSBqYXJlbiAxOTAwIGVuIHJlc3RhbnRlbiB2YW4ga2Fsa3N0ZWVuLiBIZXQgcGFyayBsaWd0IG9vayB6byduIHR3ZWUgYSBkcmllIG1ldGVyIGRpZXAsIHZhbndlZ2UgaGV0IHVpdGdlaGFrdGUga2Fsa3N0ZWVuLlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIkhhbmRpZ2UgaW5mbyB2b29yIGplIGJlem9la1wiIG1haW5faGVhZGluZ19jb2xvcj1cIiMwMDAwMDBcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpSb2JvdG8gU2xhYnxmb250X2NhbGw6Um9ib3RvK1NsYWJ8dmFyaWFudDo4MDBcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjU1cHg7XCIgbWFpbl9oZWFkaW5nX3N0eWxlPVwiZm9udC13ZWlnaHQ6ODAwO1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdWx0aW1hdGVfaWNvbl9saXN0IGljb25fc2l6ZT1cIjI1XCJdW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy1jbG9jay1vXCIgY29udGVudF9mb250X3NpemU9XCJkZXNrdG9wOjE2cHg7XCJdR2VvcGVuZCB2YW5hZiA4LjAwIHV1ciB0b3QgMTc6MDAgdXVyLiBHZXNsb3RlbiBvcCBkaW5zZGFnIGVuIHdvZW5zZGFnLlsvdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy10aHVtYnMtdXBcIiBjb250ZW50X2ZvbnRfc2l6ZT1cImRlc2t0b3A6MTZweDtcIl1FciB6aWpuIGdyYXRpcyByYW5nZXItdG91cnMgb20gMTA6MDAgdXVyICdzIG1vcmdlbnMgZW4gb20gMTQ6MDAgdXVyWy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLXBhd1wiIGNvbnRlbnRfZm9udF9zaXplPVwiZGVza3RvcDoxNnB4O1wiXVZvZ2VscyBlbiBrbGVpbmUgZGllcmVuIHNwb3R0ZW5bL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtdGludFwiIGNvbnRlbnRfZm9udF9zaXplPVwiZGVza3RvcDoxNnB4O1wiXUdyYXRpcyBkcmlua3dhdGVyZm9udGVpblsvdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dWy91bHRpbWF0ZV9pY29uX2xpc3RdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIGNvbnRlbnRfcGxhY2VtZW50PVwibWlkZGxlXCIgZnVsbF93aWR0aD1cInN0cmV0Y2hfcm93XCIgY29udGVudF90ZXh0X2FsaWdtZW50PVwiY2VudGVyXCIgY3NzPVwiLnZjX2N1c3RvbV8xNjQwMDY2OTA3NDM5e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7YmFja2dyb3VuZC1jb2xvcjogIzAwMDAwMCAhaW1wb3J0YW50O31cIiBwYXJhbGxheF9iYWNrZ3JvdW5kX2ltYWdlPVwiMzgzNlwiXVt2Y19jb2x1bW4gdGhiX2NvbG9yPVwidGhiLWxpZ2h0LWNvbHVtblwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzc1cHhcIl1baGV5dXNhX2hlYWRpbmcgdGFnPVwiZGl2XCIgdGV4dF9hbGlnbj1cImNlbnRlclwiIGhlYWRpbmc9XCJMZWVyIG1lZXIgb3ZlciBkZSBGbG9yaWRhIEtleXMgZW4geiduIGdlc2NoaWVkZW5pc1wiIGZvbnRfc2l6ZT1cIjYwXCIgbGluZV9oZWlnaHQ9XCI2NVwiIGZvbnRfY29sb3I9XCIjZmZmZmZmXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJLbGVpbiBtdXNldW0gdmFuIFdpbmRsZXkgS2V5IEZvc3NpbCBSZWVmIEdlb2xvZ2ljYWwgU3RhdGUgUGFya1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTo1NXx0ZXh0X2FsaWduOmNlbnRlcnxjb2xvcjolMjNmZmZmZmZ8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzc1cHhcIl1bcGFyYWxsYXhfcm93IG9wYWNpdHk9XCI5MFwiIGVuYWJsZV9tb2JpbGU9XCJwYXJhbGxheC1lbmFibGUtbW9iaWxlXCIgaW1hZ2U9XCIxNjYzM1wiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgdGhiX3Jvd19wYWRkaW5nPVwidHJ1ZVwiIHRoYl9jb2x1bW5fcGFkZGluZz1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCI1LzZcIl1baGV5dXNhX2hlYWRpbmcgdGFnPVwiZGl2XCIgaGVhZGluZz1cIkhhbmRpZyBvbSB0ZSB3ZXRlbiFcIiBmb250X3NpemU9XCI0MFwiIGxpbmVfaGVpZ2h0PVwiNDBcIiBmb250X2NvbG9yPVwiIzI4MjgyOFwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiSG9lIGtvbSBqZSBiaWogV2luZGxleSBLZXkgRm9zc2lsIFJlZWYgR2VvbG9naWNhbCBTdGF0ZSBQYXJrP1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgzfGZvbnRfc2l6ZTozMHx0ZXh0X2FsaWduOmxlZnR8Y29sb3I6JTIzMjgyODI4fGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XU9wIGRlIHJvdXRlIHZhbiBNaWFtaSBuYWFyIEtleSBXZXN0IHZpYSBkZSBPdmVyc2VhcyBIaWdod2F5IGtvbSBqZSBXaW5kbGV5IEtleSBGb3NzaWwgUmVlZiBHZW9sb2dpY2FsIFN0YXRlIFBhcmsgdGVnZW4gYWFuIGplIHJlY2h0ZXJrYW50LiBIZXQgcGFyayBsaWd0IG9uZ2V2ZWVyIDIwIG1pbnV0ZW4gcmlqZGVuIHZhbmFmIDxhIGhyZWY9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL2tleS1sYXJnby9cIj5LZXkgTGFyZ288L2E+LiBEaXQgRmxvcmlkYSBTdGF0ZSBQYXJrIGhlZWZ0IGdlZW4gZ3JvdGUgZW50cmVlIGVuIGplIHJpamR0IGVyIGdlbWFra2VsaWprIHZvb3JiaWosIGdvZWQgb3BsZXR0ZW4gZHVzIVsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiMTAwJVwiXVt0aGJfaW1hZ2UgcmV0aW5hPVwicmV0aW5hX3NpemVcIiBmdWxsX3dpZHRoPVwidHJ1ZVwiIGltYWdlPVwiMTY2MzVcIl1bL3RoYl9pbWFnZV1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIHRoYl9yb3dfcGFkZGluZz1cInRydWVcIiB0aGJfY29sdW1uX3BhZGRpbmc9XCJ0cnVlXCIgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIl1bdmNfY29sdW1uIHdpZHRoPVwiMS8yXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjEwMCVcIl1bdGhiX2ltYWdlIHJldGluYT1cInJldGluYV9zaXplXCIgZnVsbF93aWR0aD1cInRydWVcIiBpbWFnZT1cIjE2NjM3XCJdWy90aGJfaW1hZ2VdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvMlwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjUvNlwiXVtoZXl1c2FfaGVhZGluZyB0YWc9XCJkaXZcIiBoZWFkaW5nPVwiQWJzb2x1dXQgZWVuIHR1c3NlbnN0b3Agd2FhcmQhXCIgZm9udF9zaXplPVwiNDBcIiBsaW5lX2hlaWdodD1cIjQwXCIgZm9udF9jb2xvcj1cIiMyODI4MjhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIldhdCB0ZSBkb2VuIGluIGhldCBXaW5kbGV5IEtleSBGb3NzaWwgUmVlZiBHZW9sb2dpY2FsIFN0YXRlIFBhcmtcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoM3xmb250X3NpemU6MzB8dGV4dF9hbGlnbjpsZWZ0fGNvbG9yOiUyMzI4MjgyOHxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1IZXQgcGFyayBpcyB2b29yYWwgYmlqem9uZGVyIG9tZGF0IGplIGhpZXIgb250ZGVrdCBkYXQgZGUgZWlsYW5kZW4gdmFuIGRlIEZsb3JpZGEgS2V5cywgb25kZXIgZGUgZ3JvbmQsIGJlc3RhYW4gdWl0IGthbGtzdGVlbi4gU3RlZW4gd2FhciBqZSBmb3NzaWVsZW4gaW4ga3VudCB2aW5kZW4gZW4gemVsZnMgZGUgdm9ybWVuIHZhbiBoZXQga29yYWFsIGhlcmtlbnQuIE9wIGRlIGdyb3RlIHZsYWt0ZSBsaWdnZW4gbm9nIHJlc3RlbiB2YW4ga2Fsa3N0ZW5lbiBibG9ra2VuIGRpZSBvbmJydWlrYmFhciB3YXJlbi4gSmUgemlldCBncm90ZSBtYWNoaW5lcyB3YWFybWVlIHplIGRlIGJsb2trZW4gdWl0aGFrdGVuIGVuIGxvb3B0IGxldHRlcmxpamsgb3ZlciBmb3NzaWVsZW4uWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiB0aGJfcm93X3BhZGRpbmc9XCJ0cnVlXCIgdGhiX2NvbHVtbl9wYWRkaW5nPVwidHJ1ZVwiIGNvbnRlbnRfcGxhY2VtZW50PVwibWlkZGxlXCJdW3ZjX2NvbHVtbiB3aWR0aD1cIjEvMlwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjUvNlwiXVtoZXl1c2FfaGVhZGluZyB0YWc9XCJkaXZcIiBoZWFkaW5nPVwiSG9lIHdlcmt0ZSB6byduIGdyb2V2ZT9cIiBmb250X3NpemU9XCI0MFwiIGxpbmVfaGVpZ2h0PVwiNDBcIiBmb250X2NvbG9yPVwiIzI4MjgyOFwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiRHVpZGVsaWprZSB1aXRsZWcgb3ZlciBkZSBrYWxrc3RlZW5ncm9ldmUgZGllIHRvdCBkZSBqYXJlbiAnNjAgbm9nIGluIHdlcmtpbmcgd2FzLlwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgzfGZvbnRfc2l6ZTozMHx0ZXh0X2FsaWduOmxlZnR8Y29sb3I6JTIzMjgyODI4fGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XU92ZXJhbCBpbiBoZXQgcGFyayBrb20gamUgb3VkZSBtYWNoaW5lcyB0ZWdlbiB3YWFybWVlIHplIGRlIGJsb2trZW4gJ0tleSBMYXJnbyBMaW1lc3RvbmUnIGhha3RlbiBlbiB2ZXJwbGFhdHN0ZW4uIEJpaiBhbGxlIG92ZXJnZWJsZXZlbiBtYWNoaW5lcyB3b3JkdCBkb29yIG1pZGRlbCB2YW4gYm9yZGVuIHVpdGdlbGVnZCBob2UgemUgd2Vya3RlbiBlbiB3YWFydm9vciB6ZSBkaWVuZGVuLiBKZSBrb210IG9wIGRlemUgbWFuaWVyIHZlZWwgdGUgd2V0ZW4gb3ZlciBkZSBkZWx2aW5nIHZhbiBoZXQga2Fsa3N0ZWVuLlxyXG5cclxuTWVlciB3ZXRlbj8gQ2hlY2sgZGUgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmZsb3JpZGFzdGF0ZXBhcmtzLm9yZy9XaW5kbGV5S2V5XCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5vZmZpY2lcdTAwZWJsZSBGbG9yaWRhIFN0YXRlIFBhcms8L2E+IHBhZ2luYVsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiMTAwJVwiXVt0aGJfaW1hZ2UgcmV0aW5hPVwicmV0aW5hX3NpemVcIiBmdWxsX3dpZHRoPVwidHJ1ZVwiIGltYWdlPVwiMTY2NDBcIl1bL3RoYl9pbWFnZV1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW5dW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjIvM1wiXVtoZXl1c2FfaGVhZGluZyB0YWc9XCJkaXZcIiB0ZXh0X2FsaWduPVwiY2VudGVyXCIgaGVhZGluZz1cIk9udGRlayBtZWVyIG5hdHV1ciBpbiBkZSBidXVydFwiIGZvbnRfc2l6ZT1cIjQwXCIgbGluZV9oZWlnaHQ9XCI0MFwiIGZvbnRfY29sb3I9XCIjMjgyODI4XCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiTm9nIG1lZXIgRmxvcmlkYVwiIG1haW5faGVhZGluZ19jb2xvcj1cIiMyODI4MjhcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDo0MHB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjQ1cHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMjVweFwiXVt0aGJfcG9zdGJhY2tncm91bmQgc3R5bGU9XCJzdHlsZTJcIiBzb3VyY2U9XCJieV9pZDotMTYxOTIsLTE2MjA0LDE2MTc0LDE2MTI2LC0xNTY0NCwtMTU2MTQsLTE1NTgwLC04MTA1LC0xMjYyLC0yMjY3LC01NzIsLTU0NSwxNjMwMFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XSIsInBvc3RfdGl0bGUiOiJXaW5kbGV5IEtleSBGb3NzaWwgUmVlZiBHZW9sb2dpY2FsIFN0YXRlIFBhcmsiLCJwb3N0X2xpbmsiOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dpbmRsZXkta2V5LWZvc3NpbC1yZWVmLWdlb2xvZ2ljYWwtc3RhdGUtcGFyay8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJPdmVyYmxpamZzZWxlbiB2YW4gb3VkZSBtYWNoaW5lcyBvbSBrYWxrc3RlZW4gdGUgZGVsdmVuIGluIFdpbmRsZXkgS2V5IEZvc3NpbCBSZWVmIEdlb2xvZ2ljYWwgU3RhdGUgUGFya1wiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMy8wNy93aW5kbGV5LWtleS1mb3NzaWwtcmVlZi1zdGF0ZS1wYXJrLW92ZXJibGlqZnNlbGVuLTMwMHgyMDAuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+IiwicG9zdF9jYXRlZ29yaWVzIjoiU3RhdGUgUGFya3MiLCJwb3N0X3RhZ3MiOiJGbG9yaWRhIiwiJV9sYXN0X2VkaXRvcl91c2VkX2pldHBhY2slIjoiY2xhc3NpYy1lZGl0b3IiLCIlX2VkaXRfbG9jayUiOiIxNjg5MzI5NjY1OjEiLCIlX2VkaXRfbGFzdCUiOiIxIiwiJV90aHVtYm5haWxfaWQlIjoiMTY1NTQiLCIlX3lvYXN0X2luZGV4bm93X2xhc3RfcGluZyUiOiIxNjg5MzI1NDU1IiwiJV9oaWRlX2ZlYXR1cmVkJSI6bnVsbCwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6Ijg0OTAwIE92ZXJzZWFzIEh3eSwgSXNsYW1vcmFkYSwgRkwgMzMwMzYsIFZlcmVuaWdkZSBTdGF0ZW4iLCIlX3dwZ21wX2xvY2F0aW9uX2NpdHklIjoiSXNsYW1vcmFkYSIsIiVfd3BnbXBfbG9jYXRpb25fc3RhdGUlIjoiRmxvcmlkYSIsIiVfd3BnbXBfbG9jYXRpb25fY291bnRyeSUiOiJWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9tZXRhYm94X2xhdGl0dWRlJSI6IjI0Ljk1NzEyMzUiLCIlX3dwZ21wX21ldGFib3hfbG9uZ2l0dWRlJSI6Ii04MC41OTUxMTQ3OTk5OTk5OSIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiN1wiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6ImE6MTp7aTowO3M6MTpcIjNcIjt9IiwiJV93cGdtcF9tZXRhYm94X3RheG9tb21pZXNfdGVybXMlIjoiTjsiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6Ik47IiwiJV93d3Nfc3VwcG9ydF9jb250YWN0X251bWJlciUiOiIiLCIlX3d3c19hYm91dF9zdXBwb3J0X3RleHQlIjoiIiwiJV93d3NfdHJpZ2dlcl9idXR0b25fdGV4dCUiOiIiLCIlX3d3c19wcmVkZWZpbmVkX3RleHQlIjoiIiwiJV93cGJfdmNfanNfc3RhdHVzJSI6InRydWUiLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza2V5d29yZHMlIjoiW10iLCIlX3lvYXN0X3dwc2VvX2tleXdvcmRzeW5vbnltcyUiOiJbXCJcIl0iLCIlX3lvYXN0X3dwc2VvX2VzdGltYXRlZC1yZWFkaW5nLXRpbWUtbWludXRlcyUiOiI0IiwiJV95b2FzdF93cHNlb193b3JkcHJvb2ZfdGltZXN0YW1wJSI6IiIsIiVwb3N0LXByaW1hcnktY2F0ZWdvcnklIjoiYXV0byIsIiVmZWF0dXJlZF9pbWFnZV9vdmVycmlkZSUiOiJvZmYiLCIlYXJ0aWNsZV9zdHlsZV9vdmVycmlkZSUiOiJvbiIsIiVwb3N0X3N0eWxlJSI6InN0eWxlNSIsIiVwb3N0X2dhbGxlcnlfc3R5bGUlIjoibGlnaHRib3giLCIlcG9zdF9yZXZpZXclIjoib2ZmIiwiJXBvc3RfcmV2aWV3X3N0eWxlJSI6InN0eWxlMSIsIiVwb3N0X3Jldmlld19hdmVyYWdlJSI6IjUwIiwiJWlubGluZV9mZWF0dXJlZF9pbWFnZSUiOiIwIiwiJV95b2FzdF93cHNlb19wcmltYXJ5X2NhdGVnb3J5JSI6IjE3MCIsIiVfeW9hc3Rfd3BzZW9fY29udGVudF9zY29yZSUiOiIzMCIsIiVfd3BiX3Nob3J0Y29kZXNfY3VzdG9tX2NzcyUiOiIudmNfY3VzdG9tXzE2ODkzMjE1OTMzMDN7YmFja2dyb3VuZC1pbWFnZTogdXJsKGh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjAvMDgvYmFja2dyb3VuZC1oZXl1c2EtbmF0dXVyLTEuZ2lmP2lkPTMwODgpICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTY0MDA2NjkwNzQzOXtwYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O2JhY2tncm91bmQtY29sb3I6ICMwMDAwMDAgIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNjA4NjY2ODg1NDk3e2JhY2tncm91bmQtaW1hZ2U6IHVybChodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIwLzA4L2JhY2tncm91bmQtaGV5dXNhLW5hdHV1ci0xLmdpZj9pZD0zMDg4KSAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE2NDAwNjY5MDc0Mzl7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDtiYWNrZ3JvdW5kLWNvbG9yOiAjMDAwMDAwICFpbXBvcnRhbnQ7fSIsIiVfeW9hc3Rfd3BzZW9fZm9jdXNrdyUiOiJXaW5kbGV5IEtleSIsIiVfeW9hc3Rfd3BzZW9fbWV0YWRlc2MlIjoiRGl0IGJpanpvbmRlcmUgRmxvcmlkYSBTdGF0ZSBQYXJrIHdvcmR0IG9udGVyZWNodCBvdmVyZ2VzbGFnZW4uIEplIGtvbXQgaGllciBtZWVyIHRlIHdldGVuIG92ZXIgS2V5IExhcmdvIExpbWVzdG9uZSBpbiBkZSBvdWRlIGthbGtzdGVlbmdyb2V2ZS4iLCIlX3lvYXN0X3dwc2VvX2xpbmtkZXglIjoiNzUiLCJ0YXhvbm9teT1jYXRlZ29yeSI6IlN0YXRlIFBhcmtzIiwidGF4b25vbXk9cG9zdF90YWciOiJGbG9yaWRhIiwidGF4b25vbXk9cG9zdF9mb3JtYXQiOiIiLCJ0YXhvbm9teT10aGItcmVhY3Rpb25zIjoiIiwidGF4b25vbXk9dGhiLXNwb25zb3JzIjoiIn0sImljb24iOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDI0LzAzL3BhcmstaWNvbi5wbmcifSwiaWQiOjE2NTUzLCJpbmZvd2luZG93X2Rpc2FibGUiOmZhbHNlLCJjYXRlZ29yaWVzIjpbeyJpY29uIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyNC8wMy9wYXJrLWljb24ucG5nIiwibmFtZSI6IlBhcmtlbiIsImlkIjoiMyIsInR5cGUiOiJjYXRlZ29yeSIsImV4dGVuc2lvbl9maWVsZHMiOnsiY2F0X29yZGVyIjoiIn19XX0seyJzb3VyY2UiOiJwb3N0IiwidGl0bGUiOiJCaWxsIEJhZ2dzIENhcGUgRmxvcmlkYSBTdGF0ZSBQYXJrIiwiaW5mb3dpbmRvd19jb250ZW50IjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZyBcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiQmlsbCBCYWdncyBDYXBlIEZsb3JpZGEgU3RhdGUgUGFya1wiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMTY5XCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMy8wNi9CaWxsLUJhZ2dzLUNhcGUtRmxvcmlkYS1TdGF0ZS1QYXJrLWFlcmlhbC0zMDB4MTY5LmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmdcIj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZyBmYy1pdGVtLW5vLXBhZGRpbmdcIj5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tdGl0bGUgZmMtaXRlbS1wcmltYXJ5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2VcIj5CaWxsIEJhZ2dzIENhcGUgRmxvcmlkYSBTdGF0ZSBQYXJrPC9kaXY+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3JcIj57bWFya2VyX2FkZHJlc3N9PC9kaXY+XHJcbiAgICAgICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1jbGVhclwiPjwvZGl2PlxyXG48L2Rpdj4iLCJhZGRyZXNzIjoiMTIwMCBDcmFuZG9uIEJsdmQsIEtleSBCaXNjYXluZSwgRkwgMzMxNDksIFZlcmVuaWdkZSBTdGF0ZW4iLCJsb2NhdGlvbiI6eyJsYXQiOiIyNS42NzU1MjE3IiwiY2l0eSI6IktleSBCaXNjYXluZSIsInN0YXRlIjoiRmxvcmlkYSIsImNvdW50cnkiOiJWZXJlbmlnZGUgU3RhdGVuIiwibG5nIjoiLTgwLjE1OTA2NzciLCJvbmNsaWNrX2FjdGlvbiI6Im1hcmtlciIsInJlZGlyZWN0X3Blcm1hbGluayI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvYmlsbC1iYWdncy1jYXBlLWZsb3JpZGEtc3RhdGUtcGFyay8iLCJ6b29tIjoxMiwiZXh0cmFfZmllbGRzIjp7InBvc3RfZXhjZXJwdCI6IiIsInBvc3RfY29udGVudCI6Ilt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCJdW3ZjX2NvbHVtbiB3aWR0aD1cIjEvMlwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCIxMDAlXCJdW3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvMlwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiQmlsbCBCYWdncyBDYXBlIEZsb3JpZGEgU3RhdGUgUGFya1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTozNXx0ZXh0X2FsaWduOmxlZnR8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdT3AgaGV0IGVpbGFuZCBLZXkgQmlzY2F5bmUgdmluZCBqZSBoZXQgQmlsbCBCYWdncyBDYXBlIEZsb3JpZGEgU3RhdGUgUGFyay4gVmFuYWYgRG93bnRvd24gTWlhbWkgbWFra2VsaWprIHRlIGJlcmVpa2VuIG1ldCBkZSBicnVnLiBIZXQgc3RhYXRzcGFyayBuZWVtdCBvbmdldmVlciBlZW4gZGVyZGUgdmFuIGhldCBlaWxhbmQgaW4gYmVzbGFnLiBEZSBzdHJhbmRlbiB2YW4gaGV0IEJpbGwgQmFnZ3MgQ2FwZSBGbG9yaWRhIFN0YXRlIFBhcmsgc3RhYW4gdmFhayBpbiBoZXQgbGlqc3RqZSBtZXQgZGUgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvbW9vaXN0ZS1zdHJhbmRlbi1hbWVyaWthL1wiPm1vb2lzdGUgc3RyYW5kZW4gdmFuIEFtZXJpa2E8L2E+LiBFZW4gZ29lZGUgcmVkZW4gb20gZWVucyBlZW4gYmV6b2VrIHRlIG5lbWVuIGFhbiBoZXQgc3RhYXRzcGFyayB2b29yIGRlIGt1c3QgdmFuIE1pYW1pLlsvdmNfY29sdW1uX3RleHRdW3VsdGltYXRlX2ljb25fbGlzdCBpY29uX3NpemU9XCIyMFwiXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtYXV0b21vYmlsZSBjYXJcIl0xNCBraWxvbWV0ZXIgdmFuIE1pYW1pWy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLXRyZWVcIl08c3BhbiBjbGFzcz1cIkxyelhyIGtuby1mdlwiPjE2MCBoZWN0YXJlPC9zcGFuPlsvdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dWy91bHRpbWF0ZV9pY29uX2xpc3RdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjc3M9XCIudmNfY3VzdG9tXzE2MDg2NjY1MTk0OTJ7YmFja2dyb3VuZC1jb2xvcjogI2VhZWFlYSAhaW1wb3J0YW50O31cIl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjIvM1wiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI3NXB4XCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJPbnRzdGFhbiB2YW4gaGV0IEJpbGwgQmFnZ3MgQ2FwZSBGbG9yaWRhIFN0YXRlIFBhcmtcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MzV8dGV4dF9hbGlnbjpjZW50ZXJ8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdQ2FwZSBGbG9yaWRhLCB6b2FscyBoZXQgZ2ViaWVkIHZhbiBvb3JzcHJvbmcgaGVldCwgd29yZHQgdm9vciBoZXQgZWVyc3QgZ2Vub2VtZCBpbiAxNTEzIHRvZW4gZWVuIFNwYWFuc2UgZXhwZWRpdGllIG9wIGRlIHBsZWsgYWFua3dhbS4gTGFuZ2UgdGlqZCB3b29uZGVuIGVyIFNlbWlub2xlIGluZGlhbmVuIG9wIGhldCBlaWxhbmQuIEluIGRlIDE5ZSBlZXV3IHdlcmQgaGV0IEJpbGwgQmFnZ3MgQ2FwZSBGbG9yaWRhIFN0YXRlIFBhcmsgZWVuIHBsZWsgdm9vciBCbGFjayBTZW1pbm9sZSBpbmRpYW5lbiBkaWUgaGllcnZhbmRhYW4gb250c25hcHRlbiBuYWFyIGRlIEJhaGFtYSdzLiBTaW5kcyAyMDA0IHN0YWF0IGVyIGVlbiBtYXJrZXIgZGllIGhlcmlubmVydCBhYW4gZGV6ZSBwZXJpb2RlLiBIZXQgZ2ViaWVkIG9wIEtleSBCaXNjYXluZSBoZWV0dGUgbGFuZ2UgdGlqZCBDYXBlIEZsb3JpZGEsIHBhcyBsYXRlciB3ZXJkIGhldCB2ZXJub2VtZCBuYWFyIEJpbGwgQmFnZ3MsIHJlZGFjdGV1ciB2YW4gTWlhbWkgTmV3cy4gQmlsbCBCYWdncyB6ZXR0ZSB6aWNoIGluIHZvb3IgaGV0IGJlaG91ZCB2YW4gZGUgbmF0dXVyIGluIGRpdCBnZWJpZWQuWy92Y19jb2x1bW5fdGV4dF1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiIGZ1bGxfd2lkdGg9XCJzdHJldGNoX3Jvd1wiIGNvbnRlbnRfdGV4dF9hbGlnbWVudD1cImNlbnRlclwiIGNzcz1cIi52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O31cIiBwYXJhbGxheF9iYWNrZ3JvdW5kX2ltYWdlPVwiMzgzNlwiXVt2Y19jb2x1bW4gdGhiX2NvbG9yPVwidGhiLWxpZ2h0LWNvbHVtblwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkJpbGwgQmFnZ3MgQ2FwZSBGbG9yaWRhIFN0YXRlIFBhcmtcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6NzV8dGV4dF9hbGlnbjpjZW50ZXJ8Y29sb3I6JTIzZmZmZmZmfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW2hleXVzYV9oZWFkaW5nIHRhZz1cImRpdlwiIHRleHRfYWxpZ249XCJjZW50ZXJcIiBoZWFkaW5nPVwiRWVuIHZhbiBkZSBtb29pc3RlIHN0cmFuZGVuIHZhbiBBbWVyaWthXCIgZm9udF9zaXplPVwiNTBcIiBsaW5lX2hlaWdodD1cIjUwXCIgZm9udF9jb2xvcj1cIiNmZmZmZmZcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bcGFyYWxsYXhfcm93IGVuYWJsZV9tb2JpbGU9XCJwYXJhbGxheC1lbmFibGUtbW9iaWxlXCIgaW1hZ2U9XCIxNjMwNVwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCJdW3ZjX2NvbHVtbl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiSG9lIGtvbSBqZSBiaWogaGV0IEJpbGwgQmFnZ3MgQ2FwZSBGbG9yaWRhIFN0YXRlIFBhcms/XCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjI1fHRleHRfYWxpZ246bGVmdFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdQmlsbCBCYWdncyBDYXBlIEZsb3JpZGEgU3RhdGUgUGFyayBsaWd0IHZvb3IgZGUga3VzdCB2YW4gPGEgaHJlZj1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvbWlhbWkvXCI+TWlhbWk8L2E+IG9wIGhldCBlaWxhbmQgS2V5IEJpc2NheW5lLiBIZXQgaXMgdmFuYWYgRG93bnRvd24gTWlhbWkgbWFra2VsaWprIHRlIGJlcmVpa2VuIG1ldCBkZSBhdXRvLiBJbiBzbGVjaHRzIHR3aW50aWcgbWludXRlbiBiZW4gamUgYWwgaW4gaGV0IHBhcmsuIEluIGRlIHdlZWtlbmRlbiBrYW4gaGV0IGVyIGRydWsgemlqbiBlbiB3b3JkdCBlciBtZXQgaGV0IHZvbCBpcyB2b2wgcHJpbmNpcGUgZ2V3ZXJrdC5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIk92ZXJuYWNodGVuIGluIEJpbGwgQmFnZ3MgQ2FwZSBGbG9yaWRhIFN0YXRlIFBhcmtcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MjV8dGV4dF9hbGlnbjpsZWZ0XCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1KZSBrdW50IGhlbGFhcyBuaWV0IG92ZXJuYWNodGVuIGluIGhldCBCaWxsIEJhZ2dzIENhcGUgRmxvcmlkYSBTdGF0ZSBQYXJrLiBBbGxlZW4gbWV0IGRlIGJvb3Qga3VuIGplIGFhbm1lcmVuIGluIGRlIE5vIE5hbWUgSGFyYm9yLiBWb29yIG9uZ2V2ZWVyIDIwIGV1cm8gcGVyIG5hY2h0LCBwZXIgYm9vdCBrdW4gamUgaGllciBlZW4gbmFjaHRqZSBkb29yYnJlbmdlbi4gV2lsIGplIG92ZXJuYWNodGVuIGluIGVlbiBob3RlbD8gRGFuIHJhZGVuIHdlXHUwMGEwPGEgaHJlZj1cImh0dHBzOi8vd3d3LmJvb2tpbmcuY29tL3NlYXJjaHJlc3VsdHMuZW4uaHRtbD9jaXR5PTIwMDIyODI3JmFtcDthaWQ9Nzk1ODQ5OCZhbXA7bm9fcm9vbXM9MSZhbXA7Z3JvdXBfYWR1bHRzPTImYW1wO2xhYmVsPWJpbGxiYWdnc3N0YXRlcGFya2tleWJpc2NheW5lXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5LZXkgQmlzY2F5bmU8L2E+IGFhbi4gT3ZlcmlnZW5zIGt1biBqZSBoZXQgQmlsbCBCYWdncyBDYXBlIEZsb3JpZGEgU3RhdGUgUGFyayBvb2sgcHJpbWEgYWxzIGRhZ3RyaXAgYmV6b2VrZW4gdmFudWl0IE1pYW1pLlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJXYXQgdGUgZG9lbiBpbiBoZXQgQmlsbCBCYWdncyBDYXBlIEZsb3JpZGEgU3RhdGUgUGFya1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZToyNXx0ZXh0X2FsaWduOmxlZnRcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XUhldCBzdHJhbmQgdmFuIGhldCBCaWxsIEJhZ2dzIENhcGUgRmxvcmlkYSBTdGF0ZSBQYXJrIGlzIGVlbiB2YW4gZGUgdm9vcm5hYW1zdGUgcmVkZW5lbiBvbSBoZXQgcGFyayB0ZSBiZXpvZWtlbi4gTmlldHMgdm9vciBuaWV0cyBoYWFsdCBkZXplIGFsIGphcmVuIGxpanN0amVzIG1ldCBkZSBtb29pc3RlIHN0cmFuZGVuIHZhbiBBbWVyaWthLlx1MDBhMCBab3dlbCBhYW4gZGUgQXRsYW50aXNjaGUgT2NlYWFuIGFscyBCaXNjYXluZSBCYXkgdm9uZCBqZSBlZW4gcHJhY2h0aWdlIGt1c3RsaWpuLiBKZSBrdW50IG9wIGhldCBlaWxhbmQgZmlldHNlbiBlbiB3YW5kZWxlbiwgbWFhciB2ZXJ3YWNodCBnZWVuIGxhbmdlIHBhZGVuLiBBbCB3YW5kZWxlbmQga3VuIGplIHdlbCBlZW4ga2lqa2plIG5lbWVuIGJpaiBkZSBNYW5ncm92ZSBXZXRsYW5kcyBvZiBsYW5ncyBkZSBrdXN0IHdhbmRlbGVuLiBad2VtbWVuIGVuIHNub3JrZWxlbiBrYW4gb3AgdmVyc2NoaWxsZW5kZSBwbGVra2VuLCBuZXQgYWxzIHZpc3Nlbiwga2Fub1x1MDBlYm4gZW4ga2FqYWtrZW4uIE9wIGhldCBlaWxhbmQgdmluZCBqZSBub2cgZWVuIHZ1dXJ0b3JlbiBkaWUgZGUgbW9laXRlIHdhYXJkIGlzIG9tIHRlIGJlem9la2VuLiBIZXQgaXMgaGV0IG91ZHN0ZSBnZWJvdXcgdmFuIFp1aWQgRmxvcmlkYSBlbiBzdGFhdCBhbCBzaW5kcyAxODI1IG9wIENhcGUgRmxvcmlkYS5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkJlc3RlIHJlaXNwZXJpb2RlIG9tIGhldCBCaWxsIEJhZ2dzIENhcGUgRmxvcmlkYSBTdGF0ZSBQYXJrIHRlIGJlem9la2VuXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjI1fHRleHRfYWxpZ246bGVmdFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdRmxvcmlkYSBpcyBlZW4gc3RhYXQgZGllIGplIGhldCBoZWxlIGphYXIga3VudCBiZXpvZWtlbiwgem8gb29rIGhldCBCaWxsIEJhZ2dzIENhcGUgRmxvcmlkYSBTdGF0ZSBQYXJrLiBXaWwgamUgaGV0IHBhcmsgYmV6b2VrZW4gbWV0IGRlIG1pbnN0ZSBrYW5zIG9wIHJlZ2VuPyBEYW4gemlqbiBkZSBtYWFuZGVuIGphbnVhcmksIGZlYnJ1YXJpIGVuIG1hYXJ0IGRlIGJlc3RlIHBlcmlvZGUgb20gaGV0IHBhcmsgdGUgYmV6b2VrZW4uWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiIGZ1bGxfd2lkdGg9XCJzdHJldGNoX3Jvd1wiIGNvbnRlbnRfdGV4dF9hbGlnbWVudD1cImNlbnRlclwiIGNzcz1cIi52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O31cIiBwYXJhbGxheF9iYWNrZ3JvdW5kX2ltYWdlPVwiMzgzNlwiXVt2Y19jb2x1bW4gdGhiX2NvbG9yPVwidGhiLWxpZ2h0LWNvbHVtblwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIldhbmRlbGVuIGluIGhldCBwYXJrXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjc1fHRleHRfYWxpZ246Y2VudGVyfGNvbG9yOiUyM2ZmZmZmZnxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVtoZXl1c2FfaGVhZGluZyB0YWc9XCJkaXZcIiB0ZXh0X2FsaWduPVwiY2VudGVyXCIgaGVhZGluZz1cIlBlcmZlY3RlIG1hbmllciBvbSB0ZSBvbnRkZWtrZW5cIiBmb250X3NpemU9XCI1MFwiIGxpbmVfaGVpZ2h0PVwiNTBcIiBmb250X2NvbG9yPVwiI2ZmZmZmZlwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVtwYXJhbGxheF9yb3cgZW5hYmxlX21vYmlsZT1cInBhcmFsbGF4LWVuYWJsZS1tb2JpbGVcIiBpbWFnZT1cIjE2MzA0XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjc3M9XCIudmNfY3VzdG9tXzE2MDg2NjY4ODU0OTd7YmFja2dyb3VuZC1pbWFnZTogdXJsKGh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjAvMDgvYmFja2dyb3VuZC1oZXl1c2EtbmF0dXVyLTEuZ2lmP2lkPTMwODgpICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW5dW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiV2FuZGVsaW5nZW4gJmFtcDsgdHJhaWxzXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzAwMDAwMFwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjU1cHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF1EZSBiZWxhbmdyaWprc3RlIHJlZGVuIG9tIGhldCBCaWxsIEJhZ2dzIENhcGUgRmxvcmlkYSBTdGF0ZSBQYXJrIHRlIGJlem9la2VuIHppam4gZGUgc3RyYW5kZW4uIFdhbmRlbGVuIGlzIG1vZ2VsaWprIGluIGhldCBwYXJrLCBtYWFyIHZlcndhY2h0IGdlZW4gZW5vcm0gbGFuZ2Ugd2FuZGVscGFkZW4uIEluIGhldCB3ZXN0ZW4gdmFuIGhldCBwYXJrIGxpZ2dlbiBuYXR1cmUgdHJhaWxzIGVuIGluIGhldCBub29yZGVuIHZpbmQgamUgZWVuIHRyYWlsIG5hYXIgZGUgbWFuZ3JvdmUgd2V0bGFuZHMuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiSGFuZGlnZSBpbmZvIHZvb3IgamUgYmV6b2VrXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzAwMDAwMFwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OlJvYm90byBTbGFifGZvbnRfY2FsbDpSb2JvdG8rU2xhYnx2YXJpYW50OjgwMFwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NTVweDtcIiBtYWluX2hlYWRpbmdfc3R5bGU9XCJmb250LXdlaWdodDo4MDA7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt1bHRpbWF0ZV9pY29uX2xpc3QgaWNvbl9zaXplPVwiMjVcIl1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLWNsb2NrLW9cIiBjb250ZW50X2ZvbnRfc2l6ZT1cImRlc2t0b3A6MTZweDtcIl0zNjUgZGFnZW4gcGVyIGphYXIgLSB2YW5hZiA4LjAwIHV1ciB0b3Qgem9uc29uZGVyZ2FuZ1svdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy1kb2xsYXIgdXNkXCIgY29udGVudF9mb250X3NpemU9XCJkZXNrdG9wOjE2cHg7XCJdVG9lZ2FuZyBtZXQgZWVuIGF1dG8gJDYgLSAyIHRvdCA4IHBlcnNvbmVuXHJcblRvZWdhbmcgdm9vciB2b2V0Z2FuZ2VycyAkMlsvdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy10aHVtYnMtdXBcIiBjb250ZW50X2ZvbnRfc2l6ZT1cImRlc2t0b3A6MTZweDtcIl1CZXN0ZSBwZXJpb2RlOiBoZWxlIGphYXIgLSBtaW5zdGUgcmVnZW4gaW4gamFudWFyaSwgZmVicnVhcmkgZW4gbWFhcnRbL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVsvdWx0aW1hdGVfaWNvbl9saXN0XVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNzVweFwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMi8zXCJdW2hleXVzYV9oZWFkaW5nIHRhZz1cImRpdlwiIHRleHRfYWxpZ249XCJjZW50ZXJcIiBoZWFkaW5nPVwiT250ZGVrIG1lZXIgbmF0dXVyIGluIGRlIGJ1dXJ0XCIgZm9udF9zaXplPVwiNDBcIiBsaW5lX2hlaWdodD1cIjQwXCIgZm9udF9jb2xvcj1cIiMyODI4MjhcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJOb2cgbWVlciBGbG9yaWRhXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzI4MjgyOFwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjQwcHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NDVweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIyNXB4XCJdW3RoYl9wb3N0YmFja2dyb3VuZCBzdHlsZT1cInN0eWxlMlwiIHNvdXJjZT1cImJ5X2lkOi0xNTY0NCwtMTU2MTQsLTE1NTgwLC04MTA1LC0xMjYyLC0yMjY3LC01NzIsLTU0NSwxNjIwNCwxNjE3NCwxNjE5MiwxNjEyNlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XSIsInBvc3RfdGl0bGUiOiJCaWxsIEJhZ2dzIENhcGUgRmxvcmlkYSBTdGF0ZSBQYXJrIiwicG9zdF9saW5rIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9iaWxsLWJhZ2dzLWNhcGUtZmxvcmlkYS1zdGF0ZS1wYXJrLyIsInBvc3RfZmVhdHVyZWRfaW1hZ2UiOiI8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIkJpbGwgQmFnZ3MgQ2FwZSBGbG9yaWRhIFN0YXRlIFBhcmtcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjE2OVwiIHNyYz1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjMvMDYvQmlsbC1CYWdncy1DYXBlLUZsb3JpZGEtU3RhdGUtUGFyay1hZXJpYWwtMzAweDE2OS5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj4iLCJwb3N0X2NhdGVnb3JpZXMiOiJTdGF0ZSBQYXJrcyIsInBvc3RfdGFncyI6IkZsb3JpZGEiLCIlX3dwYl9zaG9ydGNvZGVzX2N1c3RvbV9jc3MlIjoiLnZjX2N1c3RvbV8xNjA4NjY2NTE5NDkye2JhY2tncm91bmQtY29sb3I6ICNlYWVhZWEgIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE2MDg2NjY4ODU0OTd7YmFja2dyb3VuZC1pbWFnZTogdXJsKGh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjAvMDgvYmFja2dyb3VuZC1oZXl1c2EtbmF0dXVyLTEuZ2lmP2lkPTMwODgpICFpbXBvcnRhbnQ7fSIsIiVpbmxpbmVfZmVhdHVyZWRfaW1hZ2UlIjoiMCIsIiVfZWRpdF9sb2NrJSI6IjE2ODkzMjQ4MTE6MSIsIiVfZWRpdF9sYXN0JSI6IjIiLCIlX2hpZGVfZmVhdHVyZWQlIjpudWxsLCIlX3dwYl92Y19qc19zdGF0dXMlIjoidHJ1ZSIsIiVwb3N0LXByaW1hcnktY2F0ZWdvcnklIjoiYXV0byIsIiVmZWF0dXJlZF9pbWFnZV9vdmVycmlkZSUiOiJvZmYiLCIlYXJ0aWNsZV9zdHlsZV9vdmVycmlkZSUiOiJvbiIsIiVwb3N0X3N0eWxlJSI6InN0eWxlMTEiLCIlcG9zdF9nYWxsZXJ5X3N0eWxlJSI6ImxpZ2h0Ym94IiwiJXBvc3RfcmV2aWV3JSI6Im9mZiIsIiVwb3N0X3Jldmlld19zdHlsZSUiOiJzdHlsZTEiLCIlcG9zdF9yZXZpZXdfYXZlcmFnZSUiOiI1MCIsIiVfeW9hc3Rfd3BzZW9fY29udGVudF9zY29yZSUiOiIzMCIsIiVfeW9hc3Rfd3BzZW9fZm9jdXNrZXl3b3JkcyUiOiJbXSIsIiVfeW9hc3Rfd3BzZW9fa2V5d29yZHN5bm9ueW1zJSI6IltcIkJpbGwgQmFnZ3MgQ2FwZSBGbG9yaWRhIFN0YXRlIFBhcmtcIl0iLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza3clIjoiQmlsbCBCYWdncyBDYXBlIEZsb3JpZGEgU3RhdGUgUGFyayIsIiVfeW9hc3Rfd3BzZW9fbWV0YWRlc2MlIjoiT250ZGVrIEJpbGwgQmFnZ3MgQ2FwZSBGbG9yaWRhIFN0YXRlIFBhcmsgaW4gZGUgc3RhYXQgRmxvcmlkYS4gQmVuaWV1d2Qgd2F0IGplIGVyIGt1bnQgZG9lbj8gVGlwcyB2b29yIEJpbGwgQmFnZ3MgQ2FwZSBGbG9yaWRhIFN0YXRlIFBhcmsuIiwiJV95b2FzdF93cHNlb19saW5rZGV4JSI6IjQ4IiwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6IjEyMDAgQ3JhbmRvbiBCbHZkLCBLZXkgQmlzY2F5bmUsIEZMIDMzMTQ5LCBWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9sb2NhdGlvbl9jaXR5JSI6IktleSBCaXNjYXluZSIsIiVfd3BnbXBfbG9jYXRpb25fc3RhdGUlIjoiRmxvcmlkYSIsIiVfd3BnbXBfbG9jYXRpb25fY291bnRyeSUiOiJWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9tZXRhYm94X2xhdGl0dWRlJSI6IjI1LjY3NTUyMTciLCIlX3dwZ21wX21ldGFib3hfbG9uZ2l0dWRlJSI6Ii04MC4xNTkwNjc3IiwiJV93cGdtcF9tZXRhYm94X2xvY2F0aW9uX3JlZGlyZWN0JSI6Im1hcmtlciIsIiVfd3BnbXBfbWV0YWJveF9jdXN0b21fbGluayUiOiIiLCIlX3dwZ21wX21hcF9pZCUiOiJhOjE6e2k6MDtzOjE6XCI3XCI7fSIsIiVfd3BnbXBfbWV0YWJveF9tYXJrZXJfaWQlIjoiTjsiLCIlX3dwZ21wX21ldGFib3hfdGF4b21vbWllc190ZXJtcyUiOiJOOyIsIiVfd3BnbXBfZXh0ZW5zaW9uc19maWVsZHMlIjoiTjsiLCIlX3lvYXN0X3dwc2VvX2VzdGltYXRlZC1yZWFkaW5nLXRpbWUtbWludXRlcyUiOiI0IiwiJV95b2FzdF93cHNlb19wcmltYXJ5X2NhdGVnb3J5JSI6IjE3MCIsIiVfeW9hc3Rfd3BzZW9fdGl0bGUlIjoiQmlsbCBCYWdncyBDYXBlIEZsb3JpZGEgU3RhdGUgUGFyayAlJXBhZ2UlJSAlJXNlcCUlICUlc2l0ZW5hbWUlJSIsIiVfd3dzX3N1cHBvcnRfY29udGFjdF9udW1iZXIlIjoiIiwiJV93d3NfYWJvdXRfc3VwcG9ydF90ZXh0JSI6IiIsIiVfd3dzX3RyaWdnZXJfYnV0dG9uX3RleHQlIjoiIiwiJV93d3NfcHJlZGVmaW5lZF90ZXh0JSI6IiIsIiVfeW9hc3Rfd3BzZW9fd29yZHByb29mX3RpbWVzdGFtcCUiOiIiLCIlX3lvYXN0X2luZGV4bm93X2xhc3RfcGluZyUiOiIxNjg3ODU4MTIzIiwiJV9sYXN0X2VkaXRvcl91c2VkX2pldHBhY2slIjoiY2xhc3NpYy1lZGl0b3IiLCIlc3RhbmRhcmQtZmVhdHVyZWQtY3JlZGl0JSI6IiIsIiVfdGh1bWJuYWlsX2lkJSI6IjE2MzAzIiwidGF4b25vbXk9Y2F0ZWdvcnkiOiJTdGF0ZSBQYXJrcyIsInRheG9ub215PXBvc3RfdGFnIjoiRmxvcmlkYSIsInRheG9ub215PXBvc3RfZm9ybWF0IjoiIiwidGF4b25vbXk9dGhiLXJlYWN0aW9ucyI6IiIsInRheG9ub215PXRoYi1zcG9uc29ycyI6IiJ9LCJpY29uIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMS8wNi9zdGFuZGFhcmQtbG9jYXRpZS5wbmcifSwiaWQiOjE2MzAwLCJpbmZvd2luZG93X2Rpc2FibGUiOmZhbHNlfSx7InNvdXJjZSI6InBvc3QiLCJ0aXRsZSI6Ik9sZXRhIFJpdmVyIFN0YXRlIFBhcmsiLCJpbmZvd2luZG93X2NvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nIFwiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJVaXR6aWNodCBPbGV0YSByaXZlciBTdGF0ZSBQYXJrXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIxNjlcIiBzcmM9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIzLzA2L29sZXRhLXJpdmVyLXBhcmstMzAweDE2OS5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmcgZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+T2xldGEgUml2ZXIgU3RhdGUgUGFyazwvZGl2PlxyXG4gICAgICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1jb250ZW50IGZjLWl0ZW0tYm9keS10ZXh0LWNvbG9yXCI+e21hcmtlcl9hZGRyZXNzfTwvZGl2PlxyXG4gICAgICAgIDwvZGl2PlxyXG4gICAgPC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtY2xlYXJcIj48L2Rpdj5cclxuPC9kaXY+IiwiYWRkcmVzcyI6IjM0MDAgTkUgMTYzcmQgU3QsIE5vcnRoIE1pYW1pIEJlYWNoLCBGTCAzMzE2MCwgVmVyZW5pZ2RlIFN0YXRlbiIsImxvY2F0aW9uIjp7ImxhdCI6IjI1LjkyNzk1NDciLCJjaXR5IjoiTm9ydGggTWlhbWkgQmVhY2giLCJzdGF0ZSI6IkZsb3JpZGEiLCJjb3VudHJ5IjoiVmVyZW5pZ2RlIFN0YXRlbiIsImxuZyI6Ii04MC4xMzU5NTQzIiwib25jbGlja19hY3Rpb24iOiJtYXJrZXIiLCJyZWRpcmVjdF9wZXJtYWxpbmsiOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL29sZXRhLXJpdmVyLXN0YXRlLXBhcmsvIiwiem9vbSI6MTIsImV4dHJhX2ZpZWxkcyI6eyJwb3N0X2V4Y2VycHQiOiIiLCJwb3N0X2NvbnRlbnQiOiJbdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiMTAwJVwiXVt2Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIk9sZXRhIFJpdmVyIFN0YXRlIFBhcmtcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MzV8dGV4dF9hbGlnbjpsZWZ0fGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XUhldCBPbGV0YSBSaXZlciBTdGF0ZSBQYXJrIGlzIGVlbiBzdGFhdHNwYXJrIGluIEZsb3JpZGEgbmV0IHRlbiBub29yZGVuIHZhbiBNaWFtaS4gRGUgbmFhbSBrb210IHZhbiBkZSBPbGV0YSBSaXZpZXIgZGllIGVyIGRvb3JoZWVuIHN0cm9vbXQuIEluIGhldCBwYXJrIHZpbmQgamUgZWVuIGdyb3RlIGNvbmNlbnRyYXRpZSBDYXN1YXJpbmEgYm9tZW4sIG9vayB3ZWwgZGUgQXVzdHJhbGlhbiBQaW5lLiBIb2V3ZWwgZGUgcml2aWVyIGVlbiBncm90ZSBwdWJsaWVrc3RyZWtrZXIgaXMgdm9vciB6b3dlbCBsb2NhbHMgYWxzIHRvZXJpc3RlbiwgaXMgZXIgbWVlciB0ZSBkb2VuIGluIGhldCBPbGV0YSBSaXZlciBTdGF0ZSBQYXJrLiBPcCBzbGVjaHRzIDMwIG1pbnV0ZW4gdmFuIE1pYW1pIGt1biBqZSBpbiBoZXQgZ3Jvb3RzdGUgc3RhZHNwYXJrIHZhbiBGbG9yaWRhIGdlbmlldGVuIHZhbiBwcmFjaHRpZ2UgbmF0dXVyLCBhY3Rpdml0ZWl0ZW4gb2YgZ2V3b29uIGhlZXJsaWprIHJlbGF4ZW4uWy92Y19jb2x1bW5fdGV4dF1bdWx0aW1hdGVfaWNvbl9saXN0IGljb25fc2l6ZT1cIjIwXCJdW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy1hdXRvbW9iaWxlIGNhclwiXTMwIGtpbG9tZXRlciB2YW4gTWlhbWlbL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtdHJlZVwiXTxzcGFuIGNsYXNzPVwiTHJ6WHIga25vLWZ2XCI+NCwyIGttMjwvc3Bhbj5bL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVsvdWx0aW1hdGVfaWNvbl9saXN0XVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY3NzPVwiLnZjX2N1c3RvbV8xNjA4NjY2NTE5NDkye2JhY2tncm91bmQtY29sb3I6ICNlYWVhZWEgIWltcG9ydGFudDt9XCJdW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIyLzNcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNzVweFwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiT250c3RhYW4gdmFuIGhldCBPbGV0YSBSaXZlciBTdGF0ZSBQYXJrXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjM1fHRleHRfYWxpZ246Y2VudGVyfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XURlIHJpdmllciBPbGV0YSBpcyBkZSBiZWxhbmdyaWprc3RlIGFkZXIgdmFuIGhldCBnZWJpZWQuIEhpZXJ2b29yIGt3YW1lbiBtZW5zZW4gYWwgc2luZHMgNTAwIHZvb3IgQ2hyaXN0dXMgbmFhciBkZSByZWdpby4gRGVzdGlqZHMgd2VyZGVuIGRlIG9ldmVycyB2YW4gZGUgcml2aWVyIGdlYnJ1aWt0IGFscyBrYW1wZWVydGVycmVpbiB2b29yIGRlIFRlcXVlc3RhIGluZGlhbmVuLiBMYXRlciB3ZXJkIGhldCBnZWJpZWQgZWVuIHRpamRlIGJlemV0IGRvb3IgQW1lcmlrYWFuc2UgdHJvZXBlbiB0aWpkZW5zIGRlIFR3ZWVkZSBTZW1pbm9sZSBvb3Jsb2cgKDE4NDEpLiBTaW5kcyBlaW5kIDE4MDAgd2VyZCBoZXQgZ2ViaWVkIHN0ZWVkcyBtZWVyIGVuIG1lZXIgYmV2b2xrdCBlbiBpbiAxOTIyIHdlcmQgZGUgbmFhbSBCaWcgU25ha2UgQ3JlZWsgdmVyYW5kZXJkIG5hYXIgT2xldGEgUml2aWVyLiBWcm9lZ2VyIHN0cm9vbWRlIGRlIHJpdmllciBub2cgbmFhciBkZSA8YSBocmVmPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9ldmVyZ2xhZGVzLW5hdGlvbmFsLXBhcmsvXCI+RXZlcmdsYWRlczwvYT4sIGlubWlkZGVscyBuaWV0IG1lZXIuWy92Y19jb2x1bW5fdGV4dF1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiIGZ1bGxfd2lkdGg9XCJzdHJldGNoX3Jvd1wiIGNvbnRlbnRfdGV4dF9hbGlnbWVudD1cImNlbnRlclwiIGNzcz1cIi52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O31cIiBwYXJhbGxheF9iYWNrZ3JvdW5kX2ltYWdlPVwiMzgzNlwiXVt2Y19jb2x1bW4gdGhiX2NvbG9yPVwidGhiLWxpZ2h0LWNvbHVtblwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIk9sZXRhIHJpdmVyIFN0YXRlIFBhcmtcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6NzV8dGV4dF9hbGlnbjpjZW50ZXJ8Y29sb3I6JTIzZmZmZmZmfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW2hleXVzYV9oZWFkaW5nIHRhZz1cImRpdlwiIHRleHRfYWxpZ249XCJjZW50ZXJcIiBoZWFkaW5nPVwiUGVyZmVjdGUgcGxlayBvbSB0ZSBrYWpha2tlbiwgc3VwcGVuIG9mIGthbm9cdTAwZWJuXCIgZm9udF9zaXplPVwiNTBcIiBsaW5lX2hlaWdodD1cIjUwXCIgZm9udF9jb2xvcj1cIiNmZmZmZmZcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bcGFyYWxsYXhfcm93IGVuYWJsZV9tb2JpbGU9XCJwYXJhbGxheC1lbmFibGUtbW9iaWxlXCIgaW1hZ2U9XCIxNjI4MFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCJdW3ZjX2NvbHVtbl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiSG9lIGtvbSBqZSBiaWogaGV0IE9sZXRhIFJpdmVyIFN0YXRlIFBhcms/XCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjI1fHRleHRfYWxpZ246bGVmdFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdSGV0IE9sZXRhIFJpdmVyIFN0YXRlIFBhcmsgbGlndCB0ZW4gbm9vcmRlbiB2YW4gTWlhbWksIGluIGRlIGJ1dXJ0IHZhbiA8YSBocmVmPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9taWFtaS1ub3J0aC1iZWFjaC9cIj5Ob3J0aCBNaWFtaTwvYT4uIEluIHNsZWNodHMgMzAgbWludXRlbiBzdGEgamUgaW4gaGV0IHBhcmssIGVlbiBjb21wbGVldCBhbmRlcmUgd2VyZWxkIG1ldCBtYW5ncm92ZWJvc3NlbiBlbiBoZXQgc2NoaWxkZXJhY2h0aWdlIEJpc2NheW5lIEJheSwga29ydG9tIGVlbiBuYXR1dXJsaWprZSBvYXNlLlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiT3Zlcm5hY2h0ZW4gaW4gT2xldGEgUml2ZXIgU3RhdGUgUGFya1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZToyNXx0ZXh0X2FsaWduOmxlZnRcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XUplIGt1bnQgb3Zlcm5hY2h0ZW4gaW4gaGV0IE9sZXRhIFJpdmVyIFN0YXRlIFBhcmssIHplaSBoZXQgb3AgZWVuIHByaW1pdGlldmUgbWFuaWVyLiBFciBiZXZpbmRlbiB6aWNoIGNhYmlucyBlbiBrYW1wZWVycGxla2tlbiB2b29yIGpldWdkIGluIGhldCBwYXJrLiBFciB6aWpuIGdlZW4ga29vay0gb2YgZG91Y2hlZ2VsZWdlbmhlZGVuLCBtYWFyIGRlIGNhYmlucyB6aWpuIHdlbCB1aXRnZXJ1c3QgbWV0IGFpcmNvLiBXaWwgamUgb3Zlcm5hY2h0ZW4gaW4gZWVuIGhvdGVsPyBEYW4gcmFkZW4gd2UgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmJvb2tpbmcuY29tL3NlYXJjaHJlc3VsdHMuZW4uaHRtbD9jaXR5PTIwMDIzMzY2JmFtcDthaWQ9Nzk1ODQ5OCZhbXA7bm9fcm9vbXM9MSZhbXA7Z3JvdXBfYWR1bHRzPTImYW1wO2xhYmVsPW9sZXRhcml2ZXJub3J0aG1pYW1pXCIgdGFyZ2V0PVwiX2JsYW5rXCIgcmVsPVwibm9vcGVuZXJcIj5Ob3J0aCBNaWFtaTwvYT4gYWFuIG9mIDxhIGhyZWY9XCJodHRwczovL3d3dy5ib29raW5nLmNvbS9zZWFyY2hyZXN1bHRzLmVuLmh0bWw/Y2l0eT0yMDAyMzE4MiZhbXA7YWlkPTc5NTg0OTgmYW1wO25vX3Jvb21zPTEmYW1wO2dyb3VwX2FkdWx0cz0yJmFtcDtsYWJlbD1vbGV0YXJpdmVybWlhbWliZWFjaFwiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+TWlhbWkgQmVhY2g8L2E+LiBEYWFyIHppam4gZ2Vub2VnIGhvdGVscyBlbiB2YW4gZGFhcnVpdCBrdW4gamUgaGV0IHBhcmsgYmV6b2VrZW4uWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIldhdCB0ZSBkb2VuIGluIGhldCBPbGV0YSBSaXZlciBTdGF0ZSBQYXJrXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjI1fHRleHRfYWxpZ246bGVmdFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdRGUgYmVsYW5ncmlqa3N0ZSByZWRlbiBvbSBPbGV0YSBSaXZlciBTdGF0ZSBQYXJrIHRlIGJlem9la2VuIGlzIGhldCBwcmFjaHRpZ2Uga2FubyBnZWJpZWQuIERlIHJpdmllciBpcyBvbXJpbmdkIGRvb3IgbWFuZ3JvdmUgYm9zc2VuIHdhYXJkb29yIGhldCBlZW4gZXJ2YXJpbmcgb3AgemljaCBpcyBvbSBkb29yaGVlbiB0ZSBwZWRkZWxlbi4gTmF0dXVybGlqayBrdW4gamUgaGllciBvb2sga2FqYWtrZW4gb2YgU3VwcGVuLiBad2VtbWVuIGthbiBvdmVyaWdlbnMgYWxsZWVuIGluIGhldCB6b3V0d2F0ZXIgZ2VkZWVsdGUgdmFuIEJpc2NheW5lIEJheS4gRWVuIGFuZGVyZSBhY3Rpdml0ZWl0IGRpZSBqZSBpbiBoZXQgT2xldGEgUml2ZXIgU3RhdGUgUGFyayBrdW50IGRvZW4gaXMgZmlldHNlbi4gRXIgaXMgb25nZXZlZXIgMjAtMjUga2lsb21ldGVyIGFhbiBvZmYtcm9hZCBwYWRlbiB2b29yIG1vdW50YWluYmlrZXJzLiBWb29yIGJlZ2lubmVycyB6aWpuIGVyIG1ha2tlbGlqa2VyZSB0cmFpbHMuIERlIGdlYXNmYWx0ZWVyZGUgcGFkZW4gemlqbiBldmVudHVlZWwgb29rIGdlc2NoaWt0IHZvb3Igc2thdGVycy4gRGFhcm5hYXN0IGlzIGhldCBwYXJrIGVlbiBwZXJmZWN0ZSBwbGVrIG9tIHdpbGRsaWZlIHpvYWxzIHJlaWdlcnMsIGxlcGVsYWFycywgZG9sZmlqbmVuIG9mIDxhIGhyZWY9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL21hbmF0ZWVzLWZsb3JpZGEvXCI+bWFuYXRlZXM8L2E+IHRlIHppZW4uWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJCZXN0ZSByZWlzcGVyaW9kZSBvbSBoZXQgT2xldGEgUml2ZXIgU3RhdGUgUGFyayB0ZSBiZXpvZWtlblwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZToyNXx0ZXh0X2FsaWduOmxlZnRcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XUZsb3JpZGEgaXMgZWVuIHN0YWF0IGRpZSBqZSBoZXQgaGVsZSBqYWFyIGt1bnQgYmV6b2VrZW4sIHpvIG9vayBoZXQgT2xldGEgUml2ZXIgU3RhdGUgUGFyay4gV2lsIGplIGhldCBwYXJrIGJlem9la2VuIG1ldCBkZSBtaW5zdGUga2FucyBvcCByZWdlbj8gRGFuIHppam4gZGUgbWFhbmRlbiBqYW51YXJpLCBmZWJydWFyaSBlbiBtYWFydCBkZSBiZXN0ZSBwZXJpb2RlIG9tIGhldCBwYXJrIHRlIGJlem9la2VuLlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIiBmdWxsX3dpZHRoPVwic3RyZXRjaF9yb3dcIiBjb250ZW50X3RleHRfYWxpZ21lbnQ9XCJjZW50ZXJcIiBjc3M9XCIudmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9XCIgcGFyYWxsYXhfYmFja2dyb3VuZF9pbWFnZT1cIjM4MzZcIl1bdmNfY29sdW1uIHRoYl9jb2xvcj1cInRoYi1saWdodC1jb2x1bW5cIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJPbGV0YSBSaXZlciBTdGF0ZSBQYXJrXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjc1fHRleHRfYWxpZ246Y2VudGVyfGNvbG9yOiUyM2ZmZmZmZnxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVtoZXl1c2FfaGVhZGluZyB0YWc9XCJkaXZcIiB0ZXh0X2FsaWduPVwiY2VudGVyXCIgaGVhZGluZz1cIlBlcmZlY3RlIGVzY2FwZSB2YW51aXQgTWlhbWlcIiBmb250X3NpemU9XCI1MFwiIGxpbmVfaGVpZ2h0PVwiNTBcIiBmb250X2NvbG9yPVwiI2ZmZmZmZlwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVtwYXJhbGxheF9yb3cgZW5hYmxlX21vYmlsZT1cInBhcmFsbGF4LWVuYWJsZS1tb2JpbGVcIiBpbWFnZT1cIjE2MjkyXCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjc3M9XCIudmNfY3VzdG9tXzE2MDg2NjY4ODU0OTd7YmFja2dyb3VuZC1pbWFnZTogdXJsKGh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjAvMDgvYmFja2dyb3VuZC1oZXl1c2EtbmF0dXVyLTEuZ2lmP2lkPTMwODgpICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW5dW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiV2FuZGVsaW5nZW4gJmFtcDsgdHJhaWxzXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzAwMDAwMFwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjU1cHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF1EZSBiZWxhbmdyaWprc3RlIHJlZGVuIG9tIGhldCBPbGV0YSBSaXZlciBTdGF0ZSBQYXJrIHRlIGJlem9la2VuIHppam4gZGUgd2F0ZXJhY3Rpdml0ZWl0ZW4uIFdhbmRlbGVuIGlzIG1vZ2VsaWprLCBtYWFyIGVyIGlzIHNsZWNodHMgXHUwMGU5XHUwMGU5biB3YW5kZWxwYWQgdmFuIG9uZ2V2ZWVyIDUga2lsb21ldGVyLiBWb29yIG1vdW50YWluYmlrZW4gemlqbiBlciBtZWVyIG1vZ2VsaWpraGVkZW4uIEplIGhlYnQgb25nZXZlZXIgMTYga2lsb21ldGVyIGFhbiAnaW50ZXJtZWRpYXRlJyBtb3VudGFpbmJpa2UgdHJhY2tzLiBWb29yIGJlZ2lubmVycyBpcyBlciBlZW4gcGFkIHZhbiA2LDUga2lsb21ldGVyIGVuIDUga2lsb21ldGVyLlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIkhhbmRpZ2UgaW5mbyB2b29yIGplIGJlem9la1wiIG1haW5faGVhZGluZ19jb2xvcj1cIiMwMDAwMDBcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpSb2JvdG8gU2xhYnxmb250X2NhbGw6Um9ib3RvK1NsYWJ8dmFyaWFudDo4MDBcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjU1cHg7XCIgbWFpbl9oZWFkaW5nX3N0eWxlPVwiZm9udC13ZWlnaHQ6ODAwO1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdWx0aW1hdGVfaWNvbl9saXN0IGljb25fc2l6ZT1cIjI1XCJdW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy1jbG9jay1vXCIgY29udGVudF9mb250X3NpemU9XCJkZXNrdG9wOjE2cHg7XCJdMzY1IGRhZ2VuIHBlciBqYWFyIC0gdmFuYWYgOC4wMCB1dXIgdG90IHpvbnNvbmRlcmdhbmdbL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtZG9sbGFyIHVzZFwiIGNvbnRlbnRfZm9udF9zaXplPVwiZGVza3RvcDoxNnB4O1wiXVRvZWdhbmcgbWV0IGVlbiBhdXRvICQ2IC0gMiB0b3QgOCBwZXJzb25lblxyXG5Ub2VnYW5nIHZvb3Igdm9ldGdhbmdlcnMgJDJbL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtdGh1bWJzLXVwXCIgY29udGVudF9mb250X3NpemU9XCJkZXNrdG9wOjE2cHg7XCJdQmVzdGUgcGVyaW9kZTogaGVsZSBqYWFyIC0gbWluc3RlIHJlZ2VuIGluIGphbnVhcmksIGZlYnJ1YXJpIGVuIG1hYXJ0Wy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bL3VsdGltYXRlX2ljb25fbGlzdF1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW5dW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjIvM1wiXVtoZXl1c2FfaGVhZGluZyB0YWc9XCJkaXZcIiB0ZXh0X2FsaWduPVwiY2VudGVyXCIgaGVhZGluZz1cIk9udGRlayBtZWVyIG5hdHV1ciBpbiBkZSBidXVydFwiIGZvbnRfc2l6ZT1cIjQwXCIgbGluZV9oZWlnaHQ9XCI0MFwiIGZvbnRfY29sb3I9XCIjMjgyODI4XCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiTm9nIG1lZXIgRmxvcmlkYVwiIG1haW5faGVhZGluZ19jb2xvcj1cIiMyODI4MjhcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDo0MHB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjQ1cHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMjVweFwiXVt0aGJfcG9zdGJhY2tncm91bmQgc3R5bGU9XCJzdHlsZTJcIiBzb3VyY2U9XCJieV9pZDotMTU2NDQsLTE1NjE0LC0xNTU4MCwtODEwNSwtMTI2MiwtMjI2NywtNTcyLC01NDUsMTYyMDQsMTYxNzQsMTYxOTIsMTYxMjZcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd10iLCJwb3N0X3RpdGxlIjoiT2xldGEgUml2ZXIgU3RhdGUgUGFyayIsInBvc3RfbGluayI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvb2xldGEtcml2ZXItc3RhdGUtcGFyay8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJVaXR6aWNodCBPbGV0YSByaXZlciBTdGF0ZSBQYXJrXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIxNjlcIiBzcmM9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIzLzA2L29sZXRhLXJpdmVyLXBhcmstMzAweDE2OS5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj4iLCJwb3N0X2NhdGVnb3JpZXMiOiJTdGF0ZSBQYXJrcyIsInBvc3RfdGFncyI6IkZsb3JpZGEiLCIlX3dwYl9zaG9ydGNvZGVzX2N1c3RvbV9jc3MlIjoiLnZjX2N1c3RvbV8xNjA4NjY2NTE5NDkye2JhY2tncm91bmQtY29sb3I6ICNlYWVhZWEgIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE2MDg2NjY4ODU0OTd7YmFja2dyb3VuZC1pbWFnZTogdXJsKGh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjAvMDgvYmFja2dyb3VuZC1oZXl1c2EtbmF0dXVyLTEuZ2lmP2lkPTMwODgpICFpbXBvcnRhbnQ7fSIsIiVpbmxpbmVfZmVhdHVyZWRfaW1hZ2UlIjoiMCIsIiVfZWRpdF9sb2NrJSI6IjE2ODc4NTgwNTY6MiIsIiVfZWRpdF9sYXN0JSI6IjIiLCIlX2hpZGVfZmVhdHVyZWQlIjpudWxsLCIlX3dwYl92Y19qc19zdGF0dXMlIjoidHJ1ZSIsIiVwb3N0LXByaW1hcnktY2F0ZWdvcnklIjoiYXV0byIsIiVmZWF0dXJlZF9pbWFnZV9vdmVycmlkZSUiOiJvZmYiLCIlYXJ0aWNsZV9zdHlsZV9vdmVycmlkZSUiOiJvbiIsIiVwb3N0X3N0eWxlJSI6InN0eWxlMTEiLCIlcG9zdF9nYWxsZXJ5X3N0eWxlJSI6ImxpZ2h0Ym94IiwiJXBvc3RfcmV2aWV3JSI6Im9mZiIsIiVwb3N0X3Jldmlld19zdHlsZSUiOiJzdHlsZTEiLCIlcG9zdF9yZXZpZXdfYXZlcmFnZSUiOiI1MCIsIiVfeW9hc3Rfd3BzZW9fY29udGVudF9zY29yZSUiOiIzMCIsIiVfeW9hc3Rfd3BzZW9fZm9jdXNrZXl3b3JkcyUiOiJbXSIsIiVfeW9hc3Rfd3BzZW9fa2V5d29yZHN5bm9ueW1zJSI6IltcIlwiXSIsIiVfeW9hc3Rfd3BzZW9fZm9jdXNrdyUiOiJPbGV0YSBSaXZlciBTdGF0ZSBQYXJrIiwiJV95b2FzdF93cHNlb19tZXRhZGVzYyUiOiJPbnRkZWsgT2xldGEgUml2ZXIgU3RhdGUgUGFyayBpbiBkZSBzdGFhdCBGbG9yaWRhLiBCZW5pZXV3ZCB3YXQgamUgZXIga3VudCBkb2VuPyBUaXBzIHZvb3IgamUgYmV6b2VrIGFhbiBPbGV0YSBSaXZlciBTdGF0ZSBQYXJrLiIsIiVfeW9hc3Rfd3BzZW9fbGlua2RleCUiOiI4MiIsIiVfd3BnbXBfbG9jYXRpb25fYWRkcmVzcyUiOiIzNDAwIE5FIDE2M3JkIFN0LCBOb3J0aCBNaWFtaSBCZWFjaCwgRkwgMzMxNjAsIFZlcmVuaWdkZSBTdGF0ZW4iLCIlX3dwZ21wX2xvY2F0aW9uX2NpdHklIjoiTm9ydGggTWlhbWkgQmVhY2giLCIlX3dwZ21wX2xvY2F0aW9uX3N0YXRlJSI6IkZsb3JpZGEiLCIlX3dwZ21wX2xvY2F0aW9uX2NvdW50cnklIjoiVmVyZW5pZ2RlIFN0YXRlbiIsIiVfd3BnbXBfbWV0YWJveF9sYXRpdHVkZSUiOiIyNS45Mjc5NTQ3IiwiJV93cGdtcF9tZXRhYm94X2xvbmdpdHVkZSUiOiItODAuMTM1OTU0MyIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiN1wiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6Ik47IiwiJV93cGdtcF9tZXRhYm94X3RheG9tb21pZXNfdGVybXMlIjoiTjsiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6Ik47IiwiJV95b2FzdF93cHNlb19lc3RpbWF0ZWQtcmVhZGluZy10aW1lLW1pbnV0ZXMlIjoiNCIsIiVfeW9hc3Rfd3BzZW9fcHJpbWFyeV9jYXRlZ29yeSUiOiIxNzAiLCIlX3lvYXN0X3dwc2VvX3RpdGxlJSI6Ik9sZXRhIFJpdmVyIFN0YXRlIFBhcmsgJSVwYWdlJSUgJSVzZXAlJSAlJXNpdGVuYW1lJSUiLCIlX3d3c19zdXBwb3J0X2NvbnRhY3RfbnVtYmVyJSI6IiIsIiVfd3dzX2Fib3V0X3N1cHBvcnRfdGV4dCUiOiIiLCIlX3d3c190cmlnZ2VyX2J1dHRvbl90ZXh0JSI6IiIsIiVfd3dzX3ByZWRlZmluZWRfdGV4dCUiOiIiLCIlX3lvYXN0X3dwc2VvX3dvcmRwcm9vZl90aW1lc3RhbXAlIjoiIiwiJV95b2FzdF9pbmRleG5vd19sYXN0X3BpbmclIjoiMTY4Nzg1NzkzNyIsIiVfbGFzdF9lZGl0b3JfdXNlZF9qZXRwYWNrJSI6ImNsYXNzaWMtZWRpdG9yIiwiJXN0YW5kYXJkLWZlYXR1cmVkLWNyZWRpdCUiOiIiLCIlX3RodW1ibmFpbF9pZCUiOiIxNjI4MSIsInRheG9ub215PWNhdGVnb3J5IjoiU3RhdGUgUGFya3MiLCJ0YXhvbm9teT1wb3N0X3RhZyI6IkZsb3JpZGEiLCJ0YXhvbm9teT1wb3N0X2Zvcm1hdCI6IiIsInRheG9ub215PXRoYi1yZWFjdGlvbnMiOiIiLCJ0YXhvbm9teT10aGItc3BvbnNvcnMiOiIifSwiaWNvbiI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjEvMDYvc3RhbmRhYXJkLWxvY2F0aWUucG5nIn0sImlkIjoxNjI3OCwiaW5mb3dpbmRvd19kaXNhYmxlIjpmYWxzZX0seyJzb3VyY2UiOiJwb3N0IiwidGl0bGUiOiJIYW1idXJnZXJzICYjMDM4OyB2bGllZ3R1aWdzcG90dGVuOiBJbi1OLU91dCBpbiBMb3MgQW5nZWxlcyIsImluZm93aW5kb3dfY29udGVudCI6IjxkaXYgY2xhc3M9XCJmYy1pdGVtLWJveCBmYy1pdGVtLW5vLXBhZGRpbmcgXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIkhhbWJ1cmdlcnMgZXRlbiBiaWogSW4tTi1PdXQgQnVyZ2VyIGVuIHZsaWVndHVpZ2VuIHNwb3R0ZW4gbmFiaWogTEFYIGluIExvcyBBbmdlbGVzXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMDBcIiBzcmM9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIzLzA2L0luLU4tT3V0LUJ1cmdlci1iaWotTEFYLWFpcnBvcnQtMzAweDIwMC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmcgZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+SGFtYnVyZ2VycyAmIzAzODsgdmxpZWd0dWlnc3BvdHRlbjogSW4tTi1PdXQgaW4gTG9zIEFuZ2VsZXM8L2Rpdj5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tY29udGVudCBmYy1pdGVtLWJvZHktdGV4dC1jb2xvclwiPnttYXJrZXJfYWRkcmVzc308L2Rpdj5cclxuICAgICAgICA8L2Rpdj5cclxuICAgIDwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWNsZWFyXCI+PC9kaXY+XHJcbjwvZGl2PiIsImFkZHJlc3MiOiI5MTQ5IFMgU2VwdWx2ZWRhIEJsdmQsIExvcyBBbmdlbGVzLCBDQSA5MDA0NSwgVmVyZW5pZ2RlIFN0YXRlbiIsImxvY2F0aW9uIjp7ImxhdCI6IjMzLjk1Mzc3NDEiLCJjaXR5IjoiTG9zIEFuZ2VsZXMiLCJzdGF0ZSI6IkNhbGlmb3JuaWEiLCJjb3VudHJ5IjoiVmVyZW5pZ2RlIFN0YXRlbiIsImxuZyI6Ii0xMTguMzk2NzA4OCIsIm9uY2xpY2tfYWN0aW9uIjoibWFya2VyIiwicmVkaXJlY3RfcGVybWFsaW5rIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC92bGllZ3R1aWdzcG90dGVuLWluLW4tb3V0LWluLWxvcy1hbmdlbGVzLyIsInpvb20iOjEyLCJleHRyYV9maWVsZHMiOnsicG9zdF9leGNlcnB0IjoiIiwicG9zdF9jb250ZW50IjoiW3ZjX3Jvd11bdmNfY29sdW1uXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt2Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiT3ZlciBJbi1OLU91dCBCdXJnZXJcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MzV8dGV4dF9hbGlnbjpsZWZ0fGNvbG9yOiUyM2IzNGE0Y3xsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF08c3Ryb25nPkhldCBpcyBcdTAwZTlcdTAwZTluIHZhbiBkZSBtZWVzdCBnZWxpZWZkZSBmYXN0Zm9vZGtldGVucyB2YW4gQW1lcmlrYTogSW4tTi1PdXQgQnVyZ2VyLCBiZWtlbmQgdmFud2VnZSB6aWpuICdzZWNyZXQgbWVudScsIHZyaWVuZGVsaWprIHBlcnNvbmVlbCBlbiB2b2xnZW5zIHZlbGVuIGRcdTAwZTkgbGVra2Vyc3RlIGZhc3Rmb29kLWJ1cmdlcnMuIERlIGtldGVuIHdlcmQgaW4gMTk0OCBvcGdlcmljaHQgaW4gQmFsZHdpbiBQYXJrLCBDYWxpZm9ybmlcdTAwZWIsIGRvb3IgSGFycnkgZW4gRXN0aGVyIFNueWRlciBlbiBoZWVmdCBpbm1pZGRlbHMgbWVlciBkYW4gMzgwIGZpbGlhbGVuLjwvc3Ryb25nPlxyXG5cclxuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMi8zXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkljb25pc2NoZSBJbi1OLU91dCBCdXJnZXIgbG9jYXRpZSBpbiBMb3MgQW5nZWxlc1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTo0NXx0ZXh0X2FsaWduOmNlbnRlcnxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1cclxuPHAgc3R5bGU9XCJ0ZXh0LWFsaWduOiBjZW50ZXI7XCI+RWVuIGljb25pc2NoIGZpbGlhYWwgdmFuIEluLU4tT3V0IEJ1cmdlciB2aW5kIGplIG5hYmlqIGRlIGludGVybmF0aW9uYWxlIGx1Y2h0aGF2ZW4gdmFuIDxhIGhyZWY9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL2xvcy1hbmdlbGVzL1wiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+TG9zIEFuZ2VsZXM8L2E+OiBMQVguIFRlcndpamwgamUgc211bHQgdmFuIGplICdEb3VibGUtRG91YmxlJyBtZXQgZGUgYmVyb2VtZGUgJ0luLU4tT3V0IHNwcmVhZCcsIGt1biBqZSB2bGllZ3R1aWdlbiBzcG90dGVuIGRpZSBkZSBsdWNodGhhdmVuIHZhbiBMb3MgQW5nZWxlcyBuYWRlcmVuLiBPbnplIGJlc3RlIHRpcCBpcyBkYW4gb29rOiA8ZW0+R2EgYnVpdGVuIHppdHRlbjwvZW0+LiBEZSB2bGllZ3R1aWdlbiBwYXNzZXJlbiBvcCBvbmdldmVlciA1MCBtZXRlciBob29ndGUgdm9vcmJpaiwgd2FhcmRvb3IgaGV0IGJpam5hIGxpamt0IGFsc29mIGplIHplIGt1bnQgYWFucmFrZW4uPC9wPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI3NXB4XCJdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5NSVcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIGNvbnRlbnRfcGxhY2VtZW50PVwibWlkZGxlXCIgZnVsbF93aWR0aD1cInN0cmV0Y2hfcm93XCIgY29udGVudF90ZXh0X2FsaWdtZW50PVwiY2VudGVyXCIgY3NzPVwiLnZjX2N1c3RvbV8xNjg3NjAzNTgzNTg5e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7YmFja2dyb3VuZC1jb2xvcjogIzAwMDAwMCAhaW1wb3J0YW50O31cIiBwYXJhbGxheF9iYWNrZ3JvdW5kX2ltYWdlPVwiMzgzNlwiXVt2Y19jb2x1bW4gdGhiX2NvbG9yPVwidGhiLWxpZ2h0LWNvbHVtblwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIlZlcmdlZXQgbmlldCB0ZSB6d2FhaWVuIVwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTo3NXx0ZXh0X2FsaWduOmNlbnRlcnxjb2xvcjolMjNmZmZmZmZ8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1baGV5dXNhX2hlYWRpbmcgdGFnPVwiZGl2XCIgdGV4dF9hbGlnbj1cImNlbnRlclwiIGhlYWRpbmc9XCJQYXNzZXJlbmRlIHZsaWVndHVpZ2VuIHZvb3JiaWogSW4tTi1PdXQgQnVyZ2VyXCIgZm9udF9zaXplPVwiNDVcIiBsaW5lX2hlaWdodD1cIjUwXCIgZm9udF9jb2xvcj1cIiNmZmZmZmZcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bcGFyYWxsYXhfcm93IG9wYWNpdHk9XCI5MFwiIGVuYWJsZV9tb2JpbGU9XCJwYXJhbGxheC1lbmFibGUtbW9iaWxlXCIgaW1hZ2U9XCIxNjI1MlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5NSVcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzNcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxoMz5Hcm9vdHN0ZSBwYXNzYWdpZXJzdmxpZWd0dWlnIHRlciB3ZXJlbGQ8L2gzPlxyXG5BYW5nZXppZW4gTEFYIFx1MDBlOVx1MDBlOW4gdmFuIGRlIGRydWtzdGUgbHVjaHRoYXZlbnMgdGVyIHdlcmVsZCBpcyBtZXQgd2VpbmlnIGJlc2NoaWtiYXJlIHNsb3RzIChsYW5kaW5nc3JlY2h0ZW4pLCB3b3JkdCBkb29yIG1lZXJkZXJlIG1hYXRzY2hhcHBpamVuIGRlIEEzODAgaW5nZXpldCwgaGV0IGdyb290c3RlIHBhc3NhZ2llcnN0b2VzdGVsIHRlciB3ZXJlbGQuIE9uZGVyIGFuZGVyZSBFbWlyYXRlcywgU2luZ2Fwb3JlIEFpcmxpbmVzIGVuIFFhbnRhcyB2bGllZ2VuIG1ldCBkZXplIHJldXMgbmFhciBMb3MgQW5nZWxlcy5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzNcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxoMz5LbGVpbiBwYXJrIHZcdTAwZjNcdTAwZjNyIEluLU4tT3V0IEJ1cmdlciBpbiBMQTwvaDM+XHJcbldpbCBqZSBkZSB2bGllZ3R1aWdlbiBsZXR0ZXJsaWprIG92ZXIgamUgaGVlbiB6aWVuIHZsaWVnZW4/IEdhIGRhbiBuYWFyIGhldCBrbGVpbmUgZHJpZWhvZWtpZyBwYXJramUgZGF0IHZvb3IgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmluLW4tb3V0LmNvbVwiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+SW4tTi1PdXQgQnVyZ2VyPC9hPiBsaWd0LiBKZSBiZW50IG92ZXJpZ2VucyBuaWV0IGRlIGVuaWdlLCB3YW50IGRpdCBpcyBkXHUwMGU5IHBsZWsgb20gdmxpZWd0dWlnZW4gdGUgc3BvdHRlbi4gWmUgdmxpZWdlbiBuYW1lbGlqayBsZXR0ZXJsaWprIG92ZXIgamUgaGVlbiFbL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzNcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxoMz5XYWFyIGxpZ3QgZGV6ZSBob3RzcG90IGluIExvcyBBbmdlbGVzPzwvaDM+XHJcblpldCBoZXQgdm9sZ2VuZGUgYWRyZXMgaW4gamUgbmF2aWdhdGllOiA5MTQ5IFMgU2VwdWx2ZWRhIEJsdmQsIExvcyBBbmdlbGVzLCBDQSA5MDA0NVsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJWbGllZ3R1aWdzcG90dGVuIG5hYmlqIExBWCBiaWogSW4tTi1PdXQgQnVyZ2VyXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDN8Zm9udF9zaXplOjQ1fHRleHRfYWxpZ246Y2VudGVyfGNvbG9yOiUyM2IzNGE0Y3xsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiRGUgaW5kcnVrd2Vra2VuZGUgQTM4MCB2bGllZ3Qgdm9vcmJpalwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgzfGZvbnRfc2l6ZTo0NXx0ZXh0X2FsaWduOmNlbnRlcnxjb2xvcjolMjMyODI4Mjh8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OlJvYm90byUyMFNsYWIlM0ExMDAlMkMzMDAlMkNyZWd1bGFyJTJDNzAwfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIyNXB4XCJdW3RoYl9pbWFnZV9zbGlkZXIgbGlnaHRib3g9XCJtZnAtZ2FsbGVyeVwiIGltYWdlcz1cIjE2MjUwLDE2MjUxLDE2MjUyXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjk1JVwiXVsvdmNfY29sdW1uXVsvdmNfcm93XSIsInBvc3RfdGl0bGUiOiJIYW1idXJnZXJzICYjMDM4OyB2bGllZ3R1aWdzcG90dGVuOiBJbi1OLU91dCBpbiBMb3MgQW5nZWxlcyIsInBvc3RfbGluayI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvdmxpZWd0dWlnc3BvdHRlbi1pbi1uLW91dC1pbi1sb3MtYW5nZWxlcy8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJIYW1idXJnZXJzIGV0ZW4gYmlqIEluLU4tT3V0IEJ1cmdlciBlbiB2bGllZ3R1aWdlbiBzcG90dGVuIG5hYmlqIExBWCBpbiBMb3MgQW5nZWxlc1wiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMy8wNi9Jbi1OLU91dC1CdXJnZXItYmlqLUxBWC1haXJwb3J0LTMwMHgyMDAuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+IiwicG9zdF9jYXRlZ29yaWVzIjoiRXRlbiBlbiBkcmlua2VuIiwicG9zdF90YWdzIjoiQ2FsaWZvcm5pXHUwMGViIiwiJV9sYXN0X2VkaXRvcl91c2VkX2pldHBhY2slIjoiY2xhc3NpYy1lZGl0b3IiLCIlX2VkaXRfbG9jayUiOiIxNjg3NjMyNDAwOjEiLCIlX2VkaXRfbGFzdCUiOiIxIiwiJV90aHVtYm5haWxfaWQlIjoiMTYyNDgiLCIlX3lvYXN0X2luZGV4bm93X2xhc3RfcGluZyUiOiIxNjg3NjMyMzk3IiwiJV9oaWRlX2ZlYXR1cmVkJSI6bnVsbCwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6IjkxNDkgUyBTZXB1bHZlZGEgQmx2ZCwgTG9zIEFuZ2VsZXMsIENBIDkwMDQ1LCBWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9sb2NhdGlvbl9jaXR5JSI6IkxvcyBBbmdlbGVzIiwiJV93cGdtcF9sb2NhdGlvbl9zdGF0ZSUiOiJDYWxpZm9ybmlhIiwiJV93cGdtcF9sb2NhdGlvbl9jb3VudHJ5JSI6IlZlcmVuaWdkZSBTdGF0ZW4iLCIlX3dwZ21wX21ldGFib3hfbGF0aXR1ZGUlIjoiMzMuOTUzNzc0MSIsIiVfd3BnbXBfbWV0YWJveF9sb25naXR1ZGUlIjoiLTExOC4zOTY3MDg4IiwiJV93cGdtcF9tZXRhYm94X2xvY2F0aW9uX3JlZGlyZWN0JSI6Im1hcmtlciIsIiVfd3BnbXBfbWV0YWJveF9jdXN0b21fbGluayUiOiIiLCIlX3dwZ21wX21hcF9pZCUiOiJhOjE6e2k6MDtzOjE6XCI3XCI7fSIsIiVfd3BnbXBfbWV0YWJveF9tYXJrZXJfaWQlIjoiYToxOntpOjA7czoyOlwiMTVcIjt9IiwiJV93cGdtcF9tZXRhYm94X3RheG9tb21pZXNfdGVybXMlIjoiTjsiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6Ik47IiwiJV93d3Nfc3VwcG9ydF9jb250YWN0X251bWJlciUiOiIiLCIlX3d3c19hYm91dF9zdXBwb3J0X3RleHQlIjoiIiwiJV93d3NfdHJpZ2dlcl9idXR0b25fdGV4dCUiOiIiLCIlX3d3c19wcmVkZWZpbmVkX3RleHQlIjoiIiwiJV93cGJfdmNfanNfc3RhdHVzJSI6InRydWUiLCIlX3lvYXN0X3dwc2VvX2NvbnRlbnRfc2NvcmUlIjoiOTAiLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza2V5d29yZHMlIjoiW10iLCIlX3lvYXN0X3dwc2VvX2tleXdvcmRzeW5vbnltcyUiOiJbXCJcIl0iLCIlX3lvYXN0X3dwc2VvX2VzdGltYXRlZC1yZWFkaW5nLXRpbWUtbWludXRlcyUiOiIyIiwiJV95b2FzdF93cHNlb193b3JkcHJvb2ZfdGltZXN0YW1wJSI6IiIsIiVwb3N0LXByaW1hcnktY2F0ZWdvcnklIjoiYXV0byIsIiVmZWF0dXJlZF9pbWFnZV9vdmVycmlkZSUiOiJvZmYiLCIlYXJ0aWNsZV9zdHlsZV9vdmVycmlkZSUiOiJvbiIsIiVwb3N0X3N0eWxlJSI6InN0eWxlNSIsIiVwb3N0X2dhbGxlcnlfc3R5bGUlIjoibGlnaHRib3giLCIlcG9zdF9yZXZpZXclIjoib2ZmIiwiJXBvc3RfcmV2aWV3X3N0eWxlJSI6InN0eWxlMSIsIiVwb3N0X3Jldmlld19hdmVyYWdlJSI6IjUwIiwiJWlubGluZV9mZWF0dXJlZF9pbWFnZSUiOiIwIiwiJV95b2FzdF93cHNlb19wcmltYXJ5X2NhdGVnb3J5JSI6IjY2IiwiJV95b2FzdF93cHNlb19mb2N1c2t3JSI6IkluLU4tT3V0IEJ1cmdlciBMQVgiLCIlX3lvYXN0X3dwc2VvX21ldGFkZXNjJSI6IlNtdWxsZW4gdmFuIGJhbWJ1cmdlcnMgYmlqIEluLU4tT3V0IEJ1cmdlciBcdTAwZTluIHZsaWVndHVpZ3Nwb3R0ZW4gYmlqIExBWCBpbiBMb3MgQW5nZWxlcy4gRGUgdG9lc3RlbGxlbiB2bGllZ2VuIG9wIDUwbSBob29ndGUgdm9vcmJpaiEiLCIlX3lvYXN0X3dwc2VvX2xpbmtkZXglIjoiNzIiLCIlX3dwYl9zaG9ydGNvZGVzX2N1c3RvbV9jc3MlIjoiLnZjX2N1c3RvbV8xNjg3NjAzNTgzNTg5e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7YmFja2dyb3VuZC1jb2xvcjogIzAwMDAwMCAhaW1wb3J0YW50O30iLCJ0YXhvbm9teT1jYXRlZ29yeSI6IkV0ZW4gZW4gZHJpbmtlbiIsInRheG9ub215PXBvc3RfdGFnIjoiQ2FsaWZvcm5pXHUwMGViIiwidGF4b25vbXk9cG9zdF9mb3JtYXQiOiIiLCJ0YXhvbm9teT10aGItcmVhY3Rpb25zIjoiIiwidGF4b25vbXk9dGhiLXNwb25zb3JzIjoiIn0sImljb24iOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIxLzA0L2Zvb2QucG5nIn0sImlkIjoxNjI0NywiaW5mb3dpbmRvd19kaXNhYmxlIjpmYWxzZSwiY2F0ZWdvcmllcyI6W3siaWNvbiI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjEvMDQvZm9vZC5wbmciLCJuYW1lIjoiRm9vZCIsImlkIjoiMTUiLCJ0eXBlIjoiY2F0ZWdvcnkiLCJleHRlbnNpb25fZmllbGRzIjp7ImNhdF9vcmRlciI6IiJ9fV19LHsic291cmNlIjoicG9zdCIsInRpdGxlIjoiRmxvcmlkYSBDYXZlcm5zIFN0YXRlIFBhcmsiLCJpbmZvd2luZG93X2NvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nIFwiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJHcm90dGVuIEZsb3JpZGEgQ2F2ZXJuc1wiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMTY5XCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMy8wNi9mbG9yaWRhLWNhdmVybnMtMzAweDE2OS5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmcgZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+RmxvcmlkYSBDYXZlcm5zIFN0YXRlIFBhcms8L2Rpdj5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tY29udGVudCBmYy1pdGVtLWJvZHktdGV4dC1jb2xvclwiPnttYXJrZXJfYWRkcmVzc308L2Rpdj5cclxuICAgICAgICA8L2Rpdj5cclxuICAgIDwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWNsZWFyXCI+PC9kaXY+XHJcbjwvZGl2PiIsImFkZHJlc3MiOiIzMzQ1IENhdmVybnMgUmQsIE1hcmlhbm5hLCBGTCAzMjQ0NiwgVmVyZW5pZ2RlIFN0YXRlbiIsImxvY2F0aW9uIjp7ImxhdCI6IjMwLjgxNTAwOTUiLCJjaXR5IjoiTWFyaWFubmEiLCJzdGF0ZSI6IkZsb3JpZGEiLCJjb3VudHJ5IjoiVmVyZW5pZ2RlIFN0YXRlbiIsImxuZyI6Ii04NS4yMzE4NTgxOTk5OTk5OSIsIm9uY2xpY2tfYWN0aW9uIjoibWFya2VyIiwicmVkaXJlY3RfcGVybWFsaW5rIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9mbG9yaWRhLWNhdmVybnMtc3RhdGUtcGFyay8iLCJ6b29tIjoxMiwiZXh0cmFfZmllbGRzIjp7InBvc3RfZXhjZXJwdCI6IiIsInBvc3RfY29udGVudCI6Ilt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCJdW3ZjX2NvbHVtbiB3aWR0aD1cIjEvMlwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCIxMDAlXCJdW3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvMlwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiRmxvcmlkYSBDYXZlcm5zIFN0YXRlIFBhcmtcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MzV8dGV4dF9hbGlnbjpsZWZ0fGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XUhldCBGbG9yaWRhIENhdmVybnMgU3RhdGUgUGFyayBpcyBlZW4gc3RhYXRzcGFyayBpbiBGbG9yaWRhIGRhdCBiZWtlbmQgaXMgZ2V3b3JkZW4gdmFud2VnZSBkZSBncm90dGVuIGluIGhldCBnZWJpZWQuIEhldCBpcyBuYW1lbGlqayBkZSBlbmlnZSBzdGFhdHNwYXJrIGluIEZsb3JpZGEgbWV0IGdyb3R0ZW4gZGllIHRvZWdhbmtlbGlqayB6aWpuIHZvb3IgaGV0IHB1YmxpZWsuIERlIGthbGtzdGVlbmdyb3R0ZW4gemlqbiBlZW4gcHVibGlla3N0cmVra2VyIGluIGRlIHN0YWF0LiBKZSBrdW50IGVyIHN0YWxhZ21pZXRlbiwgc3RhbGFjdGlldGVuIGVuIHN0cm9vbXN0ZW5lbiB6aWVuIGRpZSBnZXZvcm1kIHppam4gZG9vciBlcm9zaWUuIE5hYXN0IGRlIGdyb3R0ZW4gYmllZHQgaGV0IHN0YWF0c3Bhcmsgbm9nIG1lZXIgbW9nZWxpamtoZWRlbiB0b3QgYWN0aXZpdGVpdGVuLiBCZW5pZXV3ZCB3ZWxrZSBkYXQgemlqbj8gTGVlcyBtZWVyIG92ZXIgaGV0IEZsb3JpZGEgQ2F2ZXJucyBTdGF0ZSBQYXJrLlsvdmNfY29sdW1uX3RleHRdW3VsdGltYXRlX2ljb25fbGlzdCBpY29uX3NpemU9XCIyMFwiXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtYXV0b21vYmlsZSBjYXJcIl0xMDAga2lsb21ldGVyIHZhbiBUYWxsYWhhc3NlZVsvdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy10cmVlXCJdPHNwYW4gY2xhc3M9XCJMcnpYciBrbm8tZnZcIj41ODYgaGVjdGFyZTwvc3Bhbj5bL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVsvdWx0aW1hdGVfaWNvbl9saXN0XVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY3NzPVwiLnZjX2N1c3RvbV8xNjA4NjY2NTE5NDkye2JhY2tncm91bmQtY29sb3I6ICNlYWVhZWEgIWltcG9ydGFudDt9XCJdW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIyLzNcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNzVweFwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiT250c3RhYW4gdmFuIEZsb3JpZGEgQ2F2ZXJucyBTdGF0ZSBQYXJrXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjM1fHRleHRfYWxpZ246Y2VudGVyfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XURlIGdlc2NoaWVkZW5pcyB2YW4gZGUgZ3JvdHRlbiBpbiBoZXQgRmxvcmlkYSBDYXZlcm5zIFN0YXRlIFBhcmsgZ2FhdCB6byduIDM4IG1pbGpvZW4gamFhciB0ZXJ1Zy4gRGUgemVlc3BpZWdlbCB3YXMgZGVzdGlqZHMgZWVuIHN0dWsgaG9nZXIgZW4gZGUga3VzdHZsYWt0ZXMgaW4gRmxvcmlkYSBrd2FtZW4gb25kZXIgd2F0ZXIgdGUgc3RhYW4uIFNjaGVscGVuLCBrb3JhYWwgZW4gc2VkaW1lbnRlbiBob29wdGVuIHppY2ggb3Agb3AgZGUgemVlYm9kZW0uIE1ldCBoZXQgZGFsZW4gdmFuIHplZXNwaWVnZWwgdmVyaGFyZGRlIGRpdCB0b3Qga2Fsa3N0ZWVuLiBJbiBkZSBqYXJlbiBlcm5hIGxvc3RlIHp1dXIgZ3JvbmR3YXRlciBzcGxldGVuIG9uZGVyIGhldCBvcHBlcnZsYWsgd2FhcmRvb3IgZXIgZG9vcmdhbmdlbiBpbiBkZSBncm90dGVuIGt3YW1lbi4gSGllcmRvb3Igb250c3RvbmRlbiBlciBzdGFsYWN0aWV0ZW4sIHN0YWxhZ21pZXRlbiBlbiBhbmRlcmUgZ3JvdGZvcm1hdGllcy4gRWVuIHBlcmZlY3RlIHBsZWsgdm9vciBibGluZGUgZ3JvdGtyZWVmdGVuLCBncm90c2FsYW1hbmRlcnMgZW4gdmxlZXJtdWl6ZW4uWy92Y19jb2x1bW5fdGV4dF1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiIGZ1bGxfd2lkdGg9XCJzdHJldGNoX3Jvd1wiIGNvbnRlbnRfdGV4dF9hbGlnbWVudD1cImNlbnRlclwiIGNzcz1cIi52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O31cIiBwYXJhbGxheF9iYWNrZ3JvdW5kX2ltYWdlPVwiMzgzNlwiXVt2Y19jb2x1bW4gdGhiX2NvbG9yPVwidGhiLWxpZ2h0LWNvbHVtblwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkZsb3JpZGEgQ2F2ZXJucyBTdGF0ZSBQYXJrXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjc1fHRleHRfYWxpZ246Y2VudGVyfGNvbG9yOiUyM2ZmZmZmZnxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVtoZXl1c2FfaGVhZGluZyB0YWc9XCJkaXZcIiB0ZXh0X2FsaWduPVwiY2VudGVyXCIgaGVhZGluZz1cIk1lZXIgZGFuIGFsbGVlbiBncm90dGVuXCIgZm9udF9zaXplPVwiNTBcIiBsaW5lX2hlaWdodD1cIjUwXCIgZm9udF9jb2xvcj1cIiNmZmZmZmZcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bcGFyYWxsYXhfcm93IGVuYWJsZV9tb2JpbGU9XCJwYXJhbGxheC1lbmFibGUtbW9iaWxlXCIgaW1hZ2U9XCIxNjIwMlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCJdW3ZjX2NvbHVtbl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiSG9lIGtvbSBqZSBiaWogaGV0IEZsb3JpZGEgQ2F2ZXJucyBTdGF0ZSBQYXJrP1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZToyNXx0ZXh0X2FsaWduOmxlZnRcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XUhldCBGbG9yaWRhIENhdmVybnMgU3RhdGUgUGFyayBsaWd0IGluIGhldCBub29yZHdlc3RlbiB2YW4gRmxvcmlkYS4gRGUgYmVrZW5kc3RlIHN0YWQgaW4gZGUgYnV1cnQgaXMgVGFsbGFoYXNzZWUgZGF0IG9wIHJ1aW0gMTAwIGtpbG9tZXRlciByaWpkZW4gbGlndC4gRWVuIGlldHMga2xlaW5lcmUgc3RhZCBpcyBNYXJpYW5uYSwgZGF0IG9wIHNsZWNodHMgNSBraWxvbWV0ZXIgbGlndC5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIk92ZXJuYWNodGVuIGluIEZsb3JpZGEgQ2F2ZXJucyBTdGF0ZSBQYXJrXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjI1fHRleHRfYWxpZ246bGVmdFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdSW4gaGV0IEZsb3JpZGEgQ2F2ZXJucyBTdGF0ZSBQYXJrIGlzIGVyIHBsZWsgb20gdGUga2FtcGVyZW4gaW4gZWVuIHRlbnQgb2YgY2FtcGVyLiBFciB6aWpuIDM4IHBsZWtrZW4gYmVzY2hpa2JhYXIuIFdpbCBqZSBvdmVybmFjaHRlbiBpbiBlZW4gaG90ZWw/IERhbiBrYW4gaW4gPGEgaHJlZj1cImh0dHBzOi8vd3d3LmJvb2tpbmcuY29tL3NlYXJjaHJlc3VsdHMuZW4uaHRtbD9jaXR5PTIwMDIzMTE0JmFtcDthaWQ9Nzk1ODQ5OCZhbXA7bm9fcm9vbXM9MSZhbXA7Z3JvdXBfYWR1bHRzPTImYW1wO2xhYmVsPWZsb3JpZGFjYXZlcm5zc3RhdGVwYXJrbWFyaWFuYVwiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+TWFyaWFubmE8L2E+IGRhdCBvcCA1IGtpbG9tZXRlciB2YW4gaGV0IHBhcmsgbGlndC5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiV2F0IHRlIGRvZW4gaW4gaGV0IEZsb3JpZGEgQ2F2ZXJucyBTdGF0ZSBQYXJrXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjI1fHRleHRfYWxpZ246bGVmdFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdRGUgYmVsYW5ncmlqa3N0ZSB0cmVrcGxlaXN0ZXIgaW4gaGV0IEZsb3JpZGEgQ2F2ZXJucyBTdGF0ZSBQYXJrIHppam4gbmF0dXVybGlqayBkZSBncm90dGVuLiBEZXplIHppam4gYWxsZWVuIHRlIGJlem9la2VuIG1ldCBlZW4gdG91ci4gSW4gaGV0IGhvb2dzZWl6b2VuIHdvcmRlbiBkZXplIDcgZGFnZW4gcGVyIHdlZWsgZ2VnZXZlbiwgemUgZHVyZW4gb25nZXZlZXIgNDUgbWludXRlbi4gSmUga3VudCB0aWNrZXRzIGtvcGVuIGluIGhldCBwYXJrIGVuIGhldCB3ZXJrdCBvcCBiYXNpcyB2YW4gZmlyc3QgY29tZSwgZmlyc3Qgc2VydmVkLiBBbmRlcmUgYWN0aXZpdGVpdGVuIGRpZSBqZSBrdW50IG9uZGVybmVtZW4gaW4gaGV0IEZsb3JpZGEgQ2F2ZXJucyBTdGF0ZSBQYXJrIHppam4gZmlldHNlbiwgd2FuZGVsZW4sIHBhYXJkcmlqZGVuLCBrYW5vXHUwMGVibiBlbiB6d2VtbWVuLiBWb29yIGhldCB3YW5kZWxlbiwgZmlldHNlbiBlbiBwYWFyZHJpamRlbiB6aWpuIHZlcnNjaGlsbGVuZGUgcm91dGVzIHVpdGdlemV0IG9tIHRlIHZvbGdlbi4gRW4gbmlldCB0ZSB2ZXJnZXRlbiwgdm9vciBkZSBsaWVmaGViYmVyIGlzIGVyIGVlbiA5IGhvbGUgZ29sZmJhYW4uWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJCZXN0ZSByZWlzcGVyaW9kZSBvbSBoZXQgRmxvcmlkYSBDYXZlcm5zIFN0YXRlIFBhcmsgdGUgYmV6b2VrZW5cIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MjV8dGV4dF9hbGlnbjpsZWZ0XCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1GbG9yaWRhIGlzIGVlbiBzdGFhdCBkaWUgamUgaGV0IGhlbGUgamFhciBrdW50IGJlem9la2VuLCB6byBvb2sgZGUgZ3JvdHRlbiBpbiBoZXQgRmxvcmlkYSBDYXZlcm5zIFN0YXRlIFBhcmsuIEluIGhldCBob29nc2Vpem9lbiB3b3JkZW4gZXIgYWxsZSBkYWdlbiB0b3VycyBnZWdldmVuIGRvb3IgZGUgZ3JvdHRlbiwgaGllcmRvb3IgYmVuIGplIGlldHMgbWluZGVyIGFmaGFua2VsaWprIHZhbiBkZSB0aWpkZW4gdmFuIGRlIHRvdXJzLlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY3NzPVwiLnZjX2N1c3RvbV8xNjA4NjY2ODg1NDk3e2JhY2tncm91bmQtaW1hZ2U6IHVybChodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIwLzA4L2JhY2tncm91bmQtaGV5dXNhLW5hdHV1ci0xLmdpZj9pZD0zMDg4KSAhaW1wb3J0YW50O31cIl1bdmNfY29sdW1uXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIldhbmRlbGluZ2VuICZhbXA7IHRyYWlsc1wiIG1haW5faGVhZGluZ19jb2xvcj1cIiMwMDAwMDBcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDo1NXB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdRGUgYmVsYW5ncmlqa3N0ZSByZWRlbiBvbSBoZXQgRmxvcmlkYSBDYXZlcm5zIFN0YXRlIFBhcmsgdGUgYmV6b2VrZW4gemlqbiBuYXR1dXJsaWprIGRlIGdyb3R0ZW4uIFRvY2ggemlqbiBlciBlZW4gZHJpZXRhbCB0cmFpbHMgZGllIGplIGt1bnQgbG9wZW4gaW4gaGV0IHBhcms6XHJcbjx1bD5cclxuIFx0PGxpPkJsdWZmIGFuZCBCZWVjaCBNYWdub2xpYSBUcmFpbDwvbGk+XHJcbiBcdDxsaT5TaW5raG9sZSBUcmFpbDwvbGk+XHJcbiBcdDxsaT5CdW1wbm9zZSBUcmFpbDwvbGk+XHJcbjwvdWw+XHJcbkRlIHRyYWlscyBpbiBoZXQgRmxvcmlkYSBDYXZlcm5zIFN0YXRlIFBhcmsgemlqbiBvdmVyaWdlbnMgbXVsdGktdXNlLCBkdXMga3VubmVuIG9vayBnZWJydWlrdCB3b3JkZW4gdm9vciBmaWV0c2VuIGVuIHBhYXJkcmlqZGVuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiSGFuZGlnZSBpbmZvIHZvb3IgamUgYmV6b2VrXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzAwMDAwMFwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OlJvYm90byBTbGFifGZvbnRfY2FsbDpSb2JvdG8rU2xhYnx2YXJpYW50OjgwMFwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NTVweDtcIiBtYWluX2hlYWRpbmdfc3R5bGU9XCJmb250LXdlaWdodDo4MDA7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt1bHRpbWF0ZV9pY29uX2xpc3QgaWNvbl9zaXplPVwiMjVcIl1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLWNsb2NrLW9cIiBjb250ZW50X2ZvbnRfc2l6ZT1cImRlc2t0b3A6MTZweDtcIl0zNjUgZGFnZW4gcGVyIGphYXIgLSB2YW5hZiA4LjAwIHV1ciB0b3Qgem9uc29uZGVyZ2FuZ1svdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy1kb2xsYXIgdXNkXCIgY29udGVudF9mb250X3NpemU9XCJkZXNrdG9wOjE2cHg7XCJdVG9lZ2FuZyBtZXQgZWVuIGF1dG8gJDUgLSAyIHRvdCA4IHBlcnNvbmVuXHJcblRvZWdhbmcgdm9vciB2b2V0Z2FuZ2VycyAkMlsvdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy10aHVtYnMtdXBcIiBjb250ZW50X2ZvbnRfc2l6ZT1cImRlc2t0b3A6MTZweDtcIl1CZXN0ZSBwZXJpb2RlOiBoZWxlIGphYXJbL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVsvdWx0aW1hdGVfaWNvbl9saXN0XVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNzVweFwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMi8zXCJdW2hleXVzYV9oZWFkaW5nIHRhZz1cImRpdlwiIHRleHRfYWxpZ249XCJjZW50ZXJcIiBoZWFkaW5nPVwiT250ZGVrIG1lZXIgbmF0dXVyIGluIGRlIGJ1dXJ0XCIgZm9udF9zaXplPVwiNDBcIiBsaW5lX2hlaWdodD1cIjQwXCIgZm9udF9jb2xvcj1cIiMyODI4MjhcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJOb2cgbWVlciBGbG9yaWRhXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzI4MjgyOFwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjQwcHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NDVweDtcIiBtYXJnaW5fZGVzaWduX3RhYl90ZXh0PVwiXCJdWy91bHRpbWF0ZV9oZWFkaW5nXVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMjVweFwiXVt0aGJfcG9zdGJhY2tncm91bmQgc3R5bGU9XCJzdHlsZTJcIiBzb3VyY2U9XCJieV9pZDotMTU2NDQsLTE1NjE0LC0xNTU4MCwtODEwNSwtMTI2MiwtMjI2NywtNTcyLC01NDUsMTYxMjYsMTYyMDQsMTYyNzgsMTYxNzRcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd10iLCJwb3N0X3RpdGxlIjoiRmxvcmlkYSBDYXZlcm5zIFN0YXRlIFBhcmsiLCJwb3N0X2xpbmsiOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL2Zsb3JpZGEtY2F2ZXJucy1zdGF0ZS1wYXJrLyIsInBvc3RfZmVhdHVyZWRfaW1hZ2UiOiI8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIkdyb3R0ZW4gRmxvcmlkYSBDYXZlcm5zXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIxNjlcIiBzcmM9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIzLzA2L2Zsb3JpZGEtY2F2ZXJucy0zMDB4MTY5LmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6IlN0YXRlIFBhcmtzIiwicG9zdF90YWdzIjoiRmxvcmlkYSIsIiVfd3BiX3Nob3J0Y29kZXNfY3VzdG9tX2NzcyUiOiIudmNfY3VzdG9tXzE2MDg2NjY1MTk0OTJ7YmFja2dyb3VuZC1jb2xvcjogI2VhZWFlYSAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNjA4NjY2ODg1NDk3e2JhY2tncm91bmQtaW1hZ2U6IHVybChodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIwLzA4L2JhY2tncm91bmQtaGV5dXNhLW5hdHV1ci0xLmdpZj9pZD0zMDg4KSAhaW1wb3J0YW50O30iLCIlaW5saW5lX2ZlYXR1cmVkX2ltYWdlJSI6IjAiLCIlX2VkaXRfbG9jayUiOiIxNjg4NzMwNTYxOjIiLCIlX2VkaXRfbGFzdCUiOiIyIiwiJV90aHVtYm5haWxfaWQlIjoiMTYyMTYiLCIlX2hpZGVfZmVhdHVyZWQlIjpudWxsLCIlX3dwYl92Y19qc19zdGF0dXMlIjoidHJ1ZSIsIiVwb3N0LXByaW1hcnktY2F0ZWdvcnklIjoiYXV0byIsIiVmZWF0dXJlZF9pbWFnZV9vdmVycmlkZSUiOiJvZmYiLCIlYXJ0aWNsZV9zdHlsZV9vdmVycmlkZSUiOiJvbiIsIiVwb3N0X3N0eWxlJSI6InN0eWxlMTEiLCIlcG9zdF9nYWxsZXJ5X3N0eWxlJSI6ImxpZ2h0Ym94IiwiJXBvc3RfcmV2aWV3JSI6Im9mZiIsIiVwb3N0X3Jldmlld19zdHlsZSUiOiJzdHlsZTEiLCIlcG9zdF9yZXZpZXdfYXZlcmFnZSUiOiI1MCIsIiVfeW9hc3Rfd3BzZW9fY29udGVudF9zY29yZSUiOiIzMCIsIiVfeW9hc3Rfd3BzZW9fZm9jdXNrZXl3b3JkcyUiOiJbXSIsIiVfeW9hc3Rfd3BzZW9fa2V5d29yZHN5bm9ueW1zJSI6IltcIkZsb3JpZGEgQ2F2ZXJuc1wiXSIsIiVfeW9hc3Rfd3BzZW9fZm9jdXNrdyUiOiJGbG9yaWRhIENhdmVybnMgU3RhdGUgUGFyayIsIiVfeW9hc3Rfd3BzZW9fbWV0YWRlc2MlIjoiT250ZGVrIEZsb3JpZGEgQ2F2ZXJucyBTdGF0ZSBQYXJrIGluIGRlIHN0YWF0IEZsb3JpZGEuIEJlbmlldXdkIHdhdCBqZSBlciBrdW50IGRvZW4/IFRpcHMgdm9vciBqZSBiZXpvZWsgYWFuIGRlIGdyb3R0ZW4gaW4gRmxvcmlkYS4iLCIlX3lvYXN0X3dwc2VvX2xpbmtkZXglIjoiNDYiLCIlX3dwZ21wX2xvY2F0aW9uX2FkZHJlc3MlIjoiMzM0NSBDYXZlcm5zIFJkLCBNYXJpYW5uYSwgRkwgMzI0NDYsIFZlcmVuaWdkZSBTdGF0ZW4iLCIlX3dwZ21wX2xvY2F0aW9uX2NpdHklIjoiTWFyaWFubmEiLCIlX3dwZ21wX2xvY2F0aW9uX3N0YXRlJSI6IkZsb3JpZGEiLCIlX3dwZ21wX2xvY2F0aW9uX2NvdW50cnklIjoiVmVyZW5pZ2RlIFN0YXRlbiIsIiVfd3BnbXBfbWV0YWJveF9sYXRpdHVkZSUiOiIzMC44MTUwMDk1IiwiJV93cGdtcF9tZXRhYm94X2xvbmdpdHVkZSUiOiItODUuMjMxODU4MTk5OTk5OTkiLCIlX3dwZ21wX21ldGFib3hfbG9jYXRpb25fcmVkaXJlY3QlIjoibWFya2VyIiwiJV93cGdtcF9tZXRhYm94X2N1c3RvbV9saW5rJSI6IiIsIiVfd3BnbXBfbWFwX2lkJSI6ImE6MTp7aTowO3M6MTpcIjdcIjt9IiwiJV93cGdtcF9tZXRhYm94X21hcmtlcl9pZCUiOiJOOyIsIiVfd3BnbXBfbWV0YWJveF90YXhvbW9taWVzX3Rlcm1zJSI6Ik47IiwiJV93cGdtcF9leHRlbnNpb25zX2ZpZWxkcyUiOiJOOyIsIiVfeW9hc3Rfd3BzZW9fZXN0aW1hdGVkLXJlYWRpbmctdGltZS1taW51dGVzJSI6IjQiLCIlX3lvYXN0X3dwc2VvX3ByaW1hcnlfY2F0ZWdvcnklIjoiMTcwIiwiJV95b2FzdF93cHNlb190aXRsZSUiOiJGbG9yaWRhIENhdmVybnMgU3RhdGUgUGFyayAlJXBhZ2UlJSAlJXNlcCUlICUlc2l0ZW5hbWUlJSIsIiVfd3dzX3N1cHBvcnRfY29udGFjdF9udW1iZXIlIjoiIiwiJV93d3NfYWJvdXRfc3VwcG9ydF90ZXh0JSI6IiIsIiVfd3dzX3RyaWdnZXJfYnV0dG9uX3RleHQlIjoiIiwiJV93d3NfcHJlZGVmaW5lZF90ZXh0JSI6IiIsIiVfeW9hc3Rfd3BzZW9fd29yZHByb29mX3RpbWVzdGFtcCUiOiIiLCIlX3lvYXN0X2luZGV4bm93X2xhc3RfcGluZyUiOiIxNjg3NzczMzM3IiwiJV9sYXN0X2VkaXRvcl91c2VkX2pldHBhY2slIjoiY2xhc3NpYy1lZGl0b3IiLCIlc3RhbmRhcmQtZmVhdHVyZWQtY3JlZGl0JSI6IiBcdTAwYTkgRG9yb3RoeSBUaGFtZXMiLCJ0YXhvbm9teT1jYXRlZ29yeSI6IlN0YXRlIFBhcmtzIiwidGF4b25vbXk9cG9zdF90YWciOiJGbG9yaWRhIiwidGF4b25vbXk9cG9zdF9mb3JtYXQiOiIiLCJ0YXhvbm9teT10aGItcmVhY3Rpb25zIjoiIiwidGF4b25vbXk9dGhiLXNwb25zb3JzIjoiIn0sImljb24iOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIxLzA2L3N0YW5kYWFyZC1sb2NhdGllLnBuZyJ9LCJpZCI6MTYxOTIsImluZm93aW5kb3dfZGlzYWJsZSI6ZmFsc2V9LHsic291cmNlIjoicG9zdCIsInRpdGxlIjoiU2FuaWJlbCBJc2xhbmQiLCJpbmZvd2luZG93X2NvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nIFwiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJTYW5pYmVsIElzbGFuZFwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMTY5XCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMy8wNi92dXVydG9yZW4tc2FuaWJlbC1pc2xhbmQtMzAweDE2OS5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmcgZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+U2FuaWJlbCBJc2xhbmQ8L2Rpdj5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tY29udGVudCBmYy1pdGVtLWJvZHktdGV4dC1jb2xvclwiPnttYXJrZXJfYWRkcmVzc308L2Rpdj5cclxuICAgICAgICA8L2Rpdj5cclxuICAgIDwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWNsZWFyXCI+PC9kaXY+XHJcbjwvZGl2PiIsImFkZHJlc3MiOiJTYW5pYmVsIElzbGFuZCwgRmxvcmlkYSwgVmVyZW5pZ2RlIFN0YXRlbiIsImxvY2F0aW9uIjp7ImxhdCI6IjI2LjQ0MzM5NzIiLCJzdGF0ZSI6IkZsb3JpZGEiLCJjb3VudHJ5IjoiVmVyZW5pZ2RlIFN0YXRlbiIsImxuZyI6Ii04Mi4xMTE1MTE5Iiwib25jbGlja19hY3Rpb24iOiJtYXJrZXIiLCJyZWRpcmVjdF9wZXJtYWxpbmsiOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3NhbmliZWwtaXNsYW5kLyIsInpvb20iOjEyLCJleHRyYV9maWVsZHMiOnsicG9zdF9leGNlcnB0IjoiIiwicG9zdF9jb250ZW50IjoiW3ZjX3Jvd11bdmNfY29sdW1uXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjI1cHhcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMjVweFwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIlNhbmliZWwgSXNsYW5kXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzI4MjgyOFwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjMwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF08c3Ryb25nPlNhbmliZWwgSXNsYW5kIGluIEZsb3JpZGEsIGJla2VuZCB2YW53ZWdlIGRlIHByYWNodGlnZSB3aXR0ZSBzdHJhbmRlbiBkaWUgb29rIG5vZyBlZW5zIHZvbCBsaWdnZW4gbWV0IGRlIG1lZXN0IG1vb2llIHNjaGVscGVuLiBUZWwgZGFhciBub2cgZWVucyBwYWxtYm9tZW4gZW4gZWVuIGtuYWxibGF1d2UgemVlIGJpaiBvcCBlbiBqZSBoZWJ0IGVlbiB3YWFyIHBhcmFkaWpzIG9tIHRlIGJlem9la2VuLiBEZSBuYXR1dXIgaXMgbm9nIG9uZ2VyZXB0IGVuIGplIHZpbmR0IGVyIHRhbCB2YW4gcHJhY2h0aWdlIHZvZ2Vscy4gQmVuaWV1d2Qgd2F0IGplIG5pZXQgbWFnIG1pc3NlbiBvcCBTYW5pYmVsIElzbGFuZD9cclxuPC9zdHJvbmc+Wy92Y19jb2x1bW5fdGV4dF1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMjVweFwiXVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIiBjc3M9XCIudmNfY3VzdG9tXzE1ODI5MDYyNDE5NDB7cGFkZGluZy10b3A6IDUwcHggIWltcG9ydGFudDtwYWRkaW5nLWJvdHRvbTogNTBweCAhaW1wb3J0YW50O2JhY2tncm91bmQtY29sb3I6ICNlMmUyZTIgIWltcG9ydGFudDt9XCJdW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIyLzNcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJUcm9waXNjaCBlaWxhbmQgaW4gRmxvcmlkYVwiIG1haW5faGVhZGluZ19jb2xvcj1cIiMyODI4MjhcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjMwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF1cclxuPHAgc3R5bGU9XCJ0ZXh0LWFsaWduOiBjZW50ZXI7XCI+UGFyZWx3aXR0ZSBzdHJhbmRlbiwgaGVsZGVyYmxhdXdlIHplZSwgcHJhY2h0aWdlIHNjaGVscGVuLCBvbmdlcmVwdGUgbmF0dXVyIGVuIHZlZWwgd2lsZGxpZmUsIGRhdCBtb2V0IHdlbCBlZW4gcGFyYWRpanMgemlqbi4gRGl0IHBhcmFkaWpzIHdvcmR0IG9vayB3ZWwgU2FuaWJlbCBJc2xhbmQgZ2Vub2VtZCBlbiBsaWd0IHZvb3IgZGUga3VzdCB2YW4gRm9ydCBNeWVycy4gSmUga3VudCBlciB3YW5kZWxlbiwgZmlldHNlbiwga2FqYWtrZW4sIGthbm9cdTAwZWJuIG9mIGdld29vbiByZWxheGVuIG9wIGhldCBzdHJhbmQuIEFhbiBTYW5pYmVsIElzbGFuZCBsaWd0IG5vZyBlZW4ga2xlaW4gZWlsYW5kIGRpZSBqZSBwZXIgYnJ1ZyBrdW50IGJlcmVpa2VuOyBDYXB0aXZhIElzbGFuZC4gSGV0IGVpbGFuZCBpcyBhbXBlciA2LDUga2lsb21ldGVyIGxhbmcgZW4gbWF4aW1hYWwgMSBraWxvbWV0ZXIgYnJlZWQuIE9vayBoaWVyIHZpbmQgamUgcHJhY2h0aWdlIHN0cmFuZGVuLCBoZXQgZ3Jvb3RzdGUgZGVlbCB2YW4gaGV0IGVpbGFuZCBpcyBiZXN0ZW1kIHZvb3IgZGUgbmF0dXVyLjwvcD5cclxuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiIGZ1bGxfd2lkdGg9XCJzdHJldGNoX3Jvd1wiIGNvbnRlbnRfdGV4dF9hbGlnbWVudD1cImNlbnRlclwiIGNzcz1cIi52Y19jdXN0b21fMTU4NzY1OTI5OTA3MXtwYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O2JhY2tncm91bmQtY29sb3I6ICMwMDAwMDAgIWltcG9ydGFudDt9XCIgcGFyYWxsYXhfYmFja2dyb3VuZF9pbWFnZT1cIjM4MzZcIl1bdmNfY29sdW1uIHRoYl9jb2xvcj1cInRoYi1saWdodC1jb2x1bW5cIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiV2FuZGVsIG92ZXIgaGV0IHN0cmFuZCBvcCBTYW5pYmVsIElzbGFuZFwiIGhlYWRpbmdfdGFnPVwicFwiIG1haW5faGVhZGluZ19jb2xvcj1cIiNmZmZmZmZcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDo2NXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjcwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVtoZXl1c2FfaGVhZGluZyB0YWc9XCJkaXZcIiB0ZXh0X2FsaWduPVwiY2VudGVyXCIgaGVhZGluZz1cIkVuIG9udGRlayBkZSBtb29pc3RlIHNjaGVscGVuXCIgZm9udF9zaXplPVwiNTBcIiBsaW5lX2hlaWdodD1cIjUwXCIgZm9udF9jb2xvcj1cIiNmZmZmZmZcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bcGFyYWxsYXhfcm93IG9wYWNpdHk9XCI4NVwiIGVuYWJsZV9tb2JpbGU9XCJwYXJhbGxheC1lbmFibGUtbW9iaWxlXCIgaW1hZ2U9XCIxNjIwOFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgY3NzPVwiLnZjX2N1c3RvbV8xNDcyMzA3NTAyMjkwe3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7cGFkZGluZy1ib3R0b206IDI1cHggIWltcG9ydGFudDt9XCJdW3ZjX2NvbHVtbl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJXYXQgamUgbmlldCBtYWcgbWlzc2VuIG9wIFNhbmliZWwgSXNsYW5kXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiI2IzNGE0Y1wiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjU1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NjBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bdmNfcm93X2lubmVyIGNzcz1cIi52Y19jdXN0b21fMTU4Mjk3MDcwNDkwM3twYWRkaW5nLXRvcDogMTBweCAhaW1wb3J0YW50O3BhZGRpbmctcmlnaHQ6IDEwcHggIWltcG9ydGFudDtwYWRkaW5nLWJvdHRvbTogMTBweCAhaW1wb3J0YW50O3BhZGRpbmctbGVmdDogMTBweCAhaW1wb3J0YW50O31cIl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS80XCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiSi5OLiBEaW5nIERhcmxpbmcgTmF0aW9uYWwgV2lsZGxpZmUgUmVmdWdlXCIgaGVhZGluZ190YWc9XCJoM1wiIG1haW5faGVhZGluZ19jb2xvcj1cIiMyODI4MjhcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjMwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19jb2x1bW5fdGV4dF1cclxuPHAgc3R5bGU9XCJ0ZXh0LWFsaWduOiBjZW50ZXI7XCI+SGV0IEouTi4gRGluZyBEYXJsaW5nIE5hdGlvbmFsIFdpbGRsaWZlIFJlZnVnZSBsaWd0IGFhbiBkZSBub29yZGt1c3QgdmFuIFNhbmliZWwgSXNsYW5kLiBIZXQgcmVzZXJ2YWF0IHN0YWF0IGJla2VuZCBvbSBkZSBncm90ZSBlbiBkaXZlcnNlIHZvZ2VscG9wdWxhdGllLiBabyBrdW4gamUgZXIgb25kZXIgYW5kZXJlIHJvemUgbGVwZWxhYXJzIGVuIGliaXNzZW4gemllbi4gRXIgendlbW1lbiBvb2sgZG9sZmlqbmVuIGVuIG1hbmF0ZWVzIGluIGRlIHdhdGVyZW4gdmFuIGhldCBKLk4uIERpbmcgRGFybGluZyBOYXRpb25hbCBXaWxkbGlmZSBSZWZ1Z2UuIEplIGt1bnQgaGV0IHJlc2VydmFhdCBvbnRkZWtrZW4gcGVyIGF1dG8sIGZpZXRzLCBrYW5vIG9mIGthamFrLiBWb29yIGhldCBodXJlbiB2YW5cdTAwYTAga2FubydzIGVuIGthamFrcyBtb2V0IGplIGluIFRhcnBvbiBCYXkgemlqbi48L3A+XHJcblsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvNFwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIlNhbmliZWwgTGlnaHRob3VzZVwiIGhlYWRpbmdfdGFnPVwiaDNcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMjgyODI4XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozMHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdXHJcbjxwIHN0eWxlPVwidGV4dC1hbGlnbjogY2VudGVyO1wiPlNpbmRzIDE4ODQgc3RhYXQgc3RhYXQgZXIgZWVuIDMwIG1ldGVyIGhvZ2UgdnV1cnRvcmVuIG9wIFNhbmliZWwgSXNsYW5kLiBEZSB0b3JlbiBpcyBub2cgaW4gZ2VicnVpayB3YWFyZG9vciBoZXQgaGVsYWFzIG5pZXQgbW9nZWxpamsgaXMgb20gaGVtIHRlIGJlemljaHRpZ2VuLiBUb2NoIGt1biBqZSBkZSB2dXVydG9yZW4gbWVlbmVtZW4gdGlqZGVucyBqZSBiZXpvZWsgYWFuIFNhbmliZWwgSXNsYW5kLiBKZSB2aW5kdCBoZW0gbmFtZWxpamsgb3AgaGV0IG1lZXN0IG9vc3RlbGlqa2UgcHVudGplIHZhbiBoZXQgZWlsYW5kIGVuIG9wIGRlIHN0cmFuZGVuIHJvbmRvbSBrdW4gamUgZ29lZCBuYWFyIHNjaGVscGVuIHpvZWtlbi48L3A+XHJcblsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvNFwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIlN0cmFuZGVuIHZhbiBTYW5pYmVsIElzbGFuZFwiIGhlYWRpbmdfdGFnPVwiaDNcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMjgyODI4XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozMHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdXHJcbjxwIHN0eWxlPVwidGV4dC1hbGlnbjogY2VudGVyO1wiPkRlIGJlbGFuZ3JpamtzdGUgdHJla3BsZWlzdGVyIHZhbiBTYW5pYmVsIElzbGFuZCB6aWpuIGRlIHN0cmFuZGVuLiBOaWV0IGFsbGVlbiB2YW53ZWdlIGhldCB6YW5kLCBoZXQgaXMgdm9vcmFsIGRlIHBsZWsgb20gcHJhY2h0aWdlIHNjaGVscGVuIHRlIHZpbmRlbi4gRG9vciBkZSBsaWdnaW5nIHZhbiBoZXQgZWlsYW5kIGtvbWVuIGVyIG1ldCBkZSBHb2xmc3Ryb29tIHByYWNodGlnZSBzY2hlbHBlbiBtZWUgbmFhciBTYW5pYmVsLiBIZXQgaXMgZWVuIHZhbiBkZSBtb29pc3RlIHBsZWtrZW4gdGVyIHdlcmVsZCBvbSBzY2hlbHBlbiB0ZSB2aW5kZW4uIEVyIHppam4gNSB2ZXJzY2hpbGxlbmRlIHN0cmFuZG9wZ2FuZ2VuLCBtYWFyIEJvd21hbnMgaXMgdmVycmV3ZWcgaGV0IHBvcHVsYWlyc3QuIEhpZXIgdmluZCBqZSBnZWVuIGJlYm91d2luZyBsYW5ncyBoZXQgc3RyYW5kLiBXYW5kZWwgb3ZlciBoZXQgc3RyYW5kLCB6aWUgcGVsaWthbmVuIGxvcGVuLCBvbnRkZWsgZG9sZmlqbmVuIGluIGRlIG9jZWFhbiBlbiB2aW5kIGRlIG1vb2lzdGUgc2NoZWxwZW4uIERlemUgbWFnIGplIG92ZXJpZ2VucyBuaWV0IG1lZW5lbWVuITwvcD5cclxuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS80XCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiT2xkIFRvd24gU2FuaWJlbFwiIGhlYWRpbmdfdGFnPVwiaDNcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMjgyODI4XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozMHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdXHJcbjxwIHN0eWxlPVwidGV4dC1hbGlnbjogY2VudGVyO1wiPk9wIGhldCBvb3N0ZWxpamtlIGRlZWwgdmFuIGhldCBlaWxhbmQgdmluZCBqZSBoZXQgb3VkZSBzdGFkc2RlZWwsIG9vayB3ZWwgT2xkIFRvd24gZ2Vub2VtZC4gSGV0IHdlcmQgZ2V2b3JtZCBpbiAxOTc0IGRvb3IgZGUgYWFubGVnIHZhbiBkZSBob29mZHdlZyBkaWUgZGUgdmVlcmJvb3QgdmVydmluZy4gRGUgZW5pZ2UgZ2Vib3V3ZW4gZGllIG9wIGhldCBlaWxhbmQgc3RhYW4sIHppam4gaW4gZGllIHBlcmlvZGUgZ2Vib3V3ZC4gRG9vciBtaWRkZWwgdmFuIGVlbiB3YW5kZWxyb3V0ZSB2YW4gNCBraWxvbWV0ZXIga29tIGplIGxhbmdzIGFsbGUgaGlzdG9yaXNjaGUgYmV6aWVuc3dhYXJkaWdoZWRlbiBpbiBPbGQgVG93bi48L3A+XHJcblsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiIGNvbnRlbnRfcGxhY2VtZW50PVwibWlkZGxlXCIgZnVsbF93aWR0aD1cInN0cmV0Y2hfcm93XCIgY29udGVudF90ZXh0X2FsaWdtZW50PVwiY2VudGVyXCIgY3NzPVwiLnZjX2N1c3RvbV8xNTg3NjU5Mjk5MDcxe3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7YmFja2dyb3VuZC1jb2xvcjogIzAwMDAwMCAhaW1wb3J0YW50O31cIiBwYXJhbGxheF9iYWNrZ3JvdW5kX2ltYWdlPVwiMzgzNlwiXVt2Y19jb2x1bW4gdGhiX2NvbG9yPVwidGhiLWxpZ2h0LWNvbHVtblwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJQYXJhZGlqcyBpbiBGbG9yaWRhXCIgaGVhZGluZ190YWc9XCJwXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiI2ZmZmZmZlwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjY1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NzBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW2hleXVzYV9oZWFkaW5nIHRhZz1cImRpdlwiIHRleHRfYWxpZ249XCJjZW50ZXJcIiBoZWFkaW5nPVwiRGUgc3RyYW5kZW4gdmFuIFNhbmliZWwgSXNsYW5kXCIgZm9udF9zaXplPVwiNTBcIiBsaW5lX2hlaWdodD1cIjUwXCIgZm9udF9jb2xvcj1cIiNmZmZmZmZcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bcGFyYWxsYXhfcm93IG9wYWNpdHk9XCI4NVwiIGVuYWJsZV9tb2JpbGU9XCJwYXJhbGxheC1lbmFibGUtbW9iaWxlXCIgaW1hZ2U9XCIxNjIwN1wiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIk9udGRlayBpbiBGbG9yaWRhXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzI4MjgyOFwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjQ1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NTBweDtcIiBtYXJnaW5fZGVzaWduX3RhYl90ZXh0PVwiXCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW2Z1bGx3aWR0aF9yb3ddW3RoYl9wb3N0Z3JpZCBjb2x1bW5zPVwiNFwiIHNvdXJjZT1cInBvc3RfdHlwZTpwb3N0fGJ5X2lkOjE2MTc0LDE1MzU1LDE1MTYzLDQ3MjUsLTE1NTlcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd10iLCJwb3N0X3RpdGxlIjoiU2FuaWJlbCBJc2xhbmQiLCJwb3N0X2xpbmsiOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3NhbmliZWwtaXNsYW5kLyIsInBvc3RfZmVhdHVyZWRfaW1hZ2UiOiI8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIlNhbmliZWwgSXNsYW5kXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIxNjlcIiBzcmM9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIzLzA2L3Z1dXJ0b3Jlbi1zYW5pYmVsLWlzbGFuZC0zMDB4MTY5LmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6Ik5hdHV1cmdlYmllZGVuIiwicG9zdF90YWdzIjoiRmxvcmlkYSIsIiVfd3BiX3Nob3J0Y29kZXNfY3VzdG9tX2NzcyUiOiIudmNfY3VzdG9tXzE1ODI5MDYyNDE5NDB7cGFkZGluZy10b3A6IDUwcHggIWltcG9ydGFudDtwYWRkaW5nLWJvdHRvbTogNTBweCAhaW1wb3J0YW50O2JhY2tncm91bmQtY29sb3I6ICNlMmUyZTIgIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNTg3NjU5Mjk5MDcxe3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7YmFja2dyb3VuZC1jb2xvcjogIzAwMDAwMCAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE0NzIzMDc1MDIyOTB7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDtwYWRkaW5nLWJvdHRvbTogMjVweCAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE1ODc2NTkyOTkwNzF7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDtiYWNrZ3JvdW5kLWNvbG9yOiAjMDAwMDAwICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTU4Mjk3MDcwNDkwM3twYWRkaW5nLXRvcDogMTBweCAhaW1wb3J0YW50O3BhZGRpbmctcmlnaHQ6IDEwcHggIWltcG9ydGFudDtwYWRkaW5nLWJvdHRvbTogMTBweCAhaW1wb3J0YW50O3BhZGRpbmctbGVmdDogMTBweCAhaW1wb3J0YW50O30iLCIlX2VkaXRfbG9jayUiOiIxNjg5MDc4OTcxOjIiLCIlX2VkaXRfbGFzdCUiOiIyIiwiJV93cGJfdmNfanNfc3RhdHVzJSI6InRydWUiLCIlcG9zdC1wcmltYXJ5LWNhdGVnb3J5JSI6IjE2IiwiJWZlYXR1cmVkX2ltYWdlX292ZXJyaWRlJSI6Im9mZiIsIiVhcnRpY2xlX3N0eWxlX292ZXJyaWRlJSI6Im9uIiwiJXBvc3Rfc3R5bGUlIjoic3R5bGU1IiwiJXBvc3RfZ2FsbGVyeV9zdHlsZSUiOiJsaWdodGJveCIsIiVwb3N0X3JldmlldyUiOiJvZmYiLCIlcG9zdF9yZXZpZXdfc3R5bGUlIjoic3R5bGUxIiwiJXBvc3RfcmV2aWV3X2F2ZXJhZ2UlIjoiNTAiLCIldGhiX2FsbF9jb3VudHMlIjoiMCIsIiVleGVjdXRpdmVfc3VtbWFyeSUiOiIiLCIldGhiLXJlYWN0aW9ucy12b3RlcyUiOiIxIiwiJV9oaWRlX2ZlYXR1cmVkJSI6bnVsbCwiJV93cF9vbGRfZGF0ZSUiOiIyMDIwLTA2LTE3IiwiJWlubGluZV9mZWF0dXJlZF9pbWFnZSUiOiIwIiwiJV95b2FzdF93cHNlb19mb2N1c2t3JSI6IlNhbmliZWwgSXNsYW5kIiwiJV95b2FzdF93cHNlb190aXRsZSUiOiJTYW5pYmVsIElzbGFuZCUlc2VwJSUgJSVzaXRlbmFtZSUlIiwiJV95b2FzdF93cHNlb19tZXRhZGVzYyUiOiJFZW4gd2FhciBwYXJhZGlqcyB2b29yIGRlIGt1c3QgdmFuIEZsb3JpZGEsIFNhbmliZWwgSXNsYW5kLiBCZW5pZXV3ZCB3YXQgamUga3VudCBkb2VuIG9wIFNhbmliZWwgSXNsYW5kPyBMZWVzIGRhbiBvbnplIHRpcHMgdm9vciBTYW5pYmVsIiwiJV95b2FzdF93cHNlb19saW5rZGV4JSI6Ijc1IiwiJV95b2FzdF93cHNlb19jb250ZW50X3Njb3JlJSI6IjYwIiwiJV95b2FzdF93cHNlb19mb2N1c2tleXdvcmRzJSI6IltdIiwiJV95b2FzdF93cHNlb19rZXl3b3Jkc3lub255bXMlIjoiW1wiXCJdIiwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6IlNhbmliZWwgSXNsYW5kLCBGbG9yaWRhLCBWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9sb2NhdGlvbl9jaXR5JSI6IiIsIiVfd3BnbXBfbG9jYXRpb25fc3RhdGUlIjoiRmxvcmlkYSIsIiVfd3BnbXBfbG9jYXRpb25fY291bnRyeSUiOiJWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9tZXRhYm94X2xhdGl0dWRlJSI6IjI2LjQ0MzM5NzIiLCIlX3dwZ21wX21ldGFib3hfbG9uZ2l0dWRlJSI6Ii04Mi4xMTE1MTE5IiwiJV93cGdtcF9tZXRhYm94X2xvY2F0aW9uX3JlZGlyZWN0JSI6Im1hcmtlciIsIiVfd3BnbXBfbWV0YWJveF9jdXN0b21fbGluayUiOiIiLCIlX3dwZ21wX21hcF9pZCUiOiJhOjE6e2k6MDtzOjE6XCI3XCI7fSIsIiVfd3BnbXBfbWV0YWJveF9tYXJrZXJfaWQlIjoiYToxOntpOjA7czoxOlwiMlwiO30iLCIlX3dwZ21wX21ldGFib3hfdGF4b21vbWllc190ZXJtcyUiOiJOOyIsIiVfd3BnbXBfZXh0ZW5zaW9uc19maWVsZHMlIjoiTjsiLCIlX3RodW1ibmFpbF9pZCUiOiIxNjIwOSIsIiVfeW9hc3Rfd3BzZW9fZXN0aW1hdGVkLXJlYWRpbmctdGltZS1taW51dGVzJSI6IjQiLCIlX3d3c19zdXBwb3J0X2NvbnRhY3RfbnVtYmVyJSI6IiIsIiVfd3dzX2Fib3V0X3N1cHBvcnRfdGV4dCUiOiIiLCIlX3d3c190cmlnZ2VyX2J1dHRvbl90ZXh0JSI6IiIsIiVfd3dzX3ByZWRlZmluZWRfdGV4dCUiOiIiLCIlX3lvYXN0X2luZGV4bm93X2xhc3RfcGluZyUiOiIxNjg5MDc5MTAwIiwiJV95b2FzdF93cHNlb193b3JkcHJvb2ZfdGltZXN0YW1wJSI6IiIsIiVfbGFzdF9lZGl0b3JfdXNlZF9qZXRwYWNrJSI6ImNsYXNzaWMtZWRpdG9yIiwiJV95b2FzdF93cHNlb19wcmltYXJ5X2NhdGVnb3J5JSI6IjIyNyIsInRheG9ub215PWNhdGVnb3J5IjoiTmF0dXVyZ2ViaWVkZW4iLCJ0YXhvbm9teT1wb3N0X3RhZyI6IkZsb3JpZGEiLCJ0YXhvbm9teT1wb3N0X2Zvcm1hdCI6IiIsInRheG9ub215PXRoYi1yZWFjdGlvbnMiOiIiLCJ0YXhvbm9teT10aGItc3BvbnNvcnMiOiIifSwiaWNvbiI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjQvMDMvbXVzZWEtaWNvbi5wbmcifSwiaWQiOjE2MjA0LCJpbmZvd2luZG93X2Rpc2FibGUiOmZhbHNlLCJjYXRlZ29yaWVzIjpbeyJpY29uIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyNC8wMy9tdXNlYS1pY29uLnBuZyIsIm5hbWUiOiJNdXNlYSIsImlkIjoiMiIsInR5cGUiOiJjYXRlZ29yeSIsImV4dGVuc2lvbl9maWVsZHMiOnsiY2F0X29yZGVyIjoiIn19XX0seyJzb3VyY2UiOiJwb3N0IiwidGl0bGUiOiJMYWtlIFBsYWNpZCIsImluZm93aW5kb3dfY29udGVudCI6IjxkaXYgY2xhc3M9XCJmYy1pdGVtLWJveCBmYy1pdGVtLW5vLXBhZGRpbmcgXCI+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtZmVhdHVyZS1pbWdcIj48aW1nIGxvYWRpbmc9XCJsYXp5XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGFsdD1cIkxha2UgUGxhY2lkXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMjNcIiBzcmM9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIzLzA0L2xha2UtcGxhY2lkLTEtMzAweDIyMy5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmcgZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+TGFrZSBQbGFjaWQ8L2Rpdj5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tY29udGVudCBmYy1pdGVtLWJvZHktdGV4dC1jb2xvclwiPnttYXJrZXJfYWRkcmVzc308L2Rpdj5cclxuICAgICAgICA8L2Rpdj5cclxuICAgIDwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWNsZWFyXCI+PC9kaXY+XHJcbjwvZGl2PiIsImFkZHJlc3MiOiJMYWtlIFBsYWNpZCwgTmV3IFlvcmsgMTI5NDYsIFZlcmVuaWdkZSBTdGF0ZW4iLCJsb2NhdGlvbiI6eyJsYXQiOiI0NC4yNzk0OTExIiwiY2l0eSI6Ik5vcnRoIEVsYmEiLCJzdGF0ZSI6Ik5ldyBZb3JrIiwiY291bnRyeSI6IlZlcmVuaWdkZSBTdGF0ZW4iLCJsbmciOiItNzMuOTc5ODcxMyIsIm9uY2xpY2tfYWN0aW9uIjoibWFya2VyIiwicmVkaXJlY3RfcGVybWFsaW5rIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9sYWtlLXBsYWNpZC8iLCJ6b29tIjoxMiwiZXh0cmFfZmllbGRzIjp7InBvc3RfZXhjZXJwdCI6IiIsInBvc3RfY29udGVudCI6Ilt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCJdW3ZjX2NvbHVtbiB3aWR0aD1cIjEvMlwiXVt2Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl90ZXh0XVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI4NSVcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS8yXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkxha2UgUGxhY2lkXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjM1fHRleHRfYWxpZ246bGVmdHxjb2xvcjolMjMwMDAwMDBcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XUxha2UgUGxhY2lkIGlzIGVlbiBydXN0aWcgZG9ycGplIGluIGRlIHN0YWF0IE5ldyBZb3JrLiBIZXQgbGlndCBtaWRkZW4gaW4gaGV0IEFkaXJvbmRhY2tzIG5hdHV1cmdlYmllZC4gTWlzc2NoaWVuIGJpaiBzb21taWdlbiBiZWtlbmQgdmFuIGRlIE9seW1waXNjaGUgV2ludGVyc3BlbGVuIHZhbiAxOTMyIGVuIDE5ODAuIEhldCBkb3JwamUgaXMgZ2VsZWdlbiBhYW4gaGV0IGdlbGlqa25hbWlnZSBtZWVyIGRhdCB6b3dlbCBpbiBkZSB6b21lcm1hYW5kZW4gYWxzIGluIGRlIHdpbnRlcm1hYW5kZW4gZ2Vub2VnIGFjdGl2aXRlaXRlbiBiaWVkdCEgTGFrZSBQbGFjaWQgaXMgZWVuIHZhbiBkZSAzMDAwIG1lcmVuIGRpZSBpbiBoZXQgZ2ViaWVkIGxpZ2dlbiBlbiBpbiBjb21iaW5hdGllIG1ldCBoZXQgZG9ycCBoZXQgYmV6b2VrZW4gd2FhcmQuWy92Y19jb2x1bW5fdGV4dF1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkhleSFVU0EgVGlwOlwiIGZvbnRfY29udGFpbmVyPVwidGFnOmRpdnxmb250X3NpemU6MTV8dGV4dF9hbGlnbjpsZWZ0fGNvbG9yOiUyM2IzNGE0Y3xsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiQm9layBqZSBob3RlbCBpbiBkZSBidXVydCB2YW4gTGFrZSBQbGFjaWQuIFpvIGt1biBqZSBlbiBoZXQgbWVlciBlbiBkZSBvbWdldmluZyB2ZXJrZW5uZW4hXCIgZm9udF9jb250YWluZXI9XCJ0YWc6ZGl2fGZvbnRfc2l6ZToyMHx0ZXh0X2FsaWduOmxlZnR8Y29sb3I6JTIzMjgyODI4XCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6Um9ib3RvJTIwU2xhYiUzQTEwMCUyQzMwMCUyQ3JlZ3VsYXIlMkM3MDB8Zm9udF9zdHlsZToxMDAlMjBsaWdodCUyMHJlZ3VsYXIlM0ExMDAlM0Fub3JtYWxcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW5dW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IGJnX3R5cGU9XCJiZ19jb2xvclwiIGJnX2NvbG9yX3ZhbHVlPVwiI2VkZWRlZFwiIGNzcz1cIi52Y19jdXN0b21fMTYxMjk1MDU0MDgxNHtiYWNrZ3JvdW5kLWNvbG9yOiAjZWRlZGVkICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMi8zXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkxha2UgUGxhY2lkXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjM1fHRleHRfYWxpZ246Y2VudGVyfGNvbG9yOiUyMzAwMDAwMFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxwIHN0eWxlPVwidGV4dC1hbGlnbjogY2VudGVyO1wiPkluIGRlIDxhIGhyZWY9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL2FkaXJvbmRhY2tzL1wiPkFkaXJvbmRhY2tzPC9hPiB2aW5kIGplIExha2UgUGxhY2lkLCBlZW4gbWVlciBnZWxlZ2VuIGFhbiBoZXQgZ2VsaWprbmFtaWdlIGRvcnBqZS4gSGV0IG1lZXIgaGVlZnQgZWVuIGRpZXB0ZSB2YW4gb25nZXZlZXIgMTUgbWV0ZXIgZW4gaXMgOC44IGttMiBncm9vdC4gT3AgaGV0IG1lZXIgdmluZCBqZSAzIGVpbGFuZGplcyBtZXQgZGUgbmFhbSBCdWNrLCBNb29zZSBlbiBIYXdrLiBMZXVrIG9tIHRlIHdldGVuIGlzIGRhdCBoZXQgbWVlciBkZSBpbndvbmVycyB2b29yemlldCB2YW4gZHJpbmt3YXRlci4gVmFudWl0IGRlIGJlcmdlbiBzdHJvb210IGhldCB3YXRlciBoZXQgbWVlciBpbi4gUm9uZG9tIGhldCBtZWVyIHN0YWFuIG9uZ2V2ZWVyIDMwMCB3b25pbmdlbiwgbWFhciBkaWUgemlqbiBkZSBoZWxmdCB2YW4gZGUgdGlqZCBsZWVnIHdhYXJkb29yIGhldCB3YXRlciBtZWVzdGFsIHNjaG9vbiBibGlqZnQuPC9wPlxyXG5bL3ZjX2NvbHVtbl90ZXh0XVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIiBmdWxsX3dpZHRoPVwic3RyZXRjaF9yb3dcIiBjb250ZW50X3RleHRfYWxpZ21lbnQ9XCJjZW50ZXJcIiBjc3M9XCIudmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9XCIgcGFyYWxsYXhfYmFja2dyb3VuZF9pbWFnZT1cIjM4MzZcIl1bdmNfY29sdW1uIHRoYl9jb2xvcj1cInRoYi1saWdodC1jb2x1bW5cIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJMYWtlIFBsYWNpZFwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTo1NXx0ZXh0X2FsaWduOmNlbnRlcnxjb2xvcjolMjNmZmZmZmZ8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1baGV5dXNhX2hlYWRpbmcgdGFnPVwiZGl2XCIgdGV4dF9hbGlnbj1cImNlbnRlclwiIGhlYWRpbmc9XCJIZXQgaGVsZSBqYWFyIGRvb3IgZWVuIGJlc3RlbW1pbmcgb20gdGUgYmV6b2VrZW5cIiBmb250X3NpemU9XCI0MFwiIGxpbmVfaGVpZ2h0PVwiNDBcIiBmb250X2NvbG9yPVwiIzI4MjgyOFwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVtwYXJhbGxheF9yb3cgZW5hYmxlX21vYmlsZT1cInBhcmFsbGF4LWVuYWJsZS1tb2JpbGVcIiBpbWFnZT1cIjE1NjA5XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNzVweFwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvM1wiXVt2Y19zaW5nbGVfaW1hZ2UgaW1hZ2U9XCIxNTYxN1wiIGltZ19zaXplPVwibGFyZ2VcIiBhbGlnbm1lbnQ9XCJjZW50ZXJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkxha2UgUGxhY2lkIGVuIGRlIE9seW1waXNjaGUgU3BlbGVuXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjIwfHRleHRfYWxpZ246bGVmdHxjb2xvcjolMjMwMDAwMDB8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdWm93ZWwgaW4gMTkzMiBhbHMgMTk4MCB2b25kZW4gZGUgT2x5bXBpc2NoZSBXaW50ZXJzcGVsZW4gcGxhYXRzIGluIExha2UgUGxhY2lkLiBFZW4gdW5pZWtlIGdlYmV1cnRlbmlzIHZvb3IgZGl0IHJlbGF0aWVmIGtsZWluZSBzdGFkamUuIEluIGhldCBMYWtlIFBsYWNpZCBPbHltcGljIE11c2V1bSBsZWVzIGplIGFsbGVzIG92ZXIgZGV6ZSBnZWJldXJ0ZW5pc3NlbiBlbiBrdW4gamUgZWVuIHVpdGdlYnJlaWRlIGNvbGxlY3RpZSB2YW4gZGUgc3BlbGVuIHRlcnVnIHppZW4uIEJla2lqayBmYWtrZWxzLCBtZWRhaWxsZXMgZW4gYW5kZXJlIHZvb3J3ZXJwZW4gdmFuIGRlIE9TLiBOYXR1dXJsaWprIGhvb3IgamUgb29rIG1lZXIgb3ZlciBkZSBiaXphcnJlIHdlZHN0cmlqZCB2YW4gZGUgaWpzaG9ja2V5ZXJzIGRpZSBoZXQgbWFjaHRpZ2UgUnVzbGFuZCB3aXN0ZW4gdGUgdmVyc2xhYW4gaW4gMTk4MC5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzNcIl1bdmNfc2luZ2xlX2ltYWdlIGltYWdlPVwiMTU2MTlcIiBpbWdfc2l6ZT1cImxhcmdlXCIgYWxpZ25tZW50PVwiY2VudGVyXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJMYWtlIFBsYWNpZCBpbiBkZSB6b21lclwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZToyMHx0ZXh0X2FsaWduOmxlZnR8Y29sb3I6JTIzMDAwMDAwfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XUhldCBmaWpuZSBhYW4gTGFrZSBQbGFjaWQgaXMgZGF0IGhldCBpbiBhbGxlIGphYXJnZXRpamRlbiBnb2VkIHRlIGJlem9la2VuIGlzLiBJbiBkZSB6b21lcm1hYW5kZW4ga3VuIGplIGVyIG1vdW50YWluYmlrZW4sIGZpZXRzZW4sIHdhbmRlbGVuIGVuIHZpc3Nlbi4gSmUga3VudCBlciBiaWp2b29yYmVlbGQgZGUgMjAwIGtpbG9tZXRlciBsYW5nZSBOb3J0aHZpbGxlLVBsYWNpZC1UcmFpbCBsb3Blbi4gTWluZGVyIHppbiBvbSB2ZWVsIGtpbG9tZXRlcnMgdGUgbWFrZW4gbWFhciB0b2NoIGVlbiB1aXR6aWNodCBtZWUgdGUgcGFra2VuPyBOZWVtIGRhbiBkZSBnb25kZWwgbmFhciBkZSBXaGl0ZWZhY2UgYmVyZy4gVmVyZGVyIGt1biBqZSBvb2sgZ29sZmVuIHJvbmRvbSBMYWtlIFBsYWNpZCwgZGUgYmFhbiB3YXMgZGUgZWVyc3RlIGluIEFtZXJpa2EgaW4gMTg5OC4gRW4gbmlldCB0ZSB2ZXJnZXRlbiB6aWpuIGVyIG9wIGhldCB3YXRlciB2ZXJzY2hpbGxlbmRlIGFjdGl2aXRlaXRlbiBvbSB0ZSBvbmRlcm5lbWVuLlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvM1wiXVt2Y19zaW5nbGVfaW1hZ2UgaW1hZ2U9XCIxNTYxOFwiIGltZ19zaXplPVwibGFyZ2VcIiBhbGlnbm1lbnQ9XCJjZW50ZXJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkxha2UgUGxhY2lkIGluIGRlIHdpbnRlclwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZToyMHx0ZXh0X2FsaWduOmxlZnR8Y29sb3I6JTIzMDAwMDAwfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XU1ldCB0d2VlIGtlZXIgZGUgb3JnYW5pc2F0aWUgdmFuIGRlIE9seW1waXNjaGUgU3BlbGVuIG9wIHppY2gsIG1vZXQgamUgamUgaGllciBvb2sgaW4gZGUgd2ludGVyIGt1bm5lbiB2ZXJtYWtlbi4gTGFrZSBQbGFjaWQgaXMgZWVuIHZhbiBkZSBwbGVra2VuIHdhYXIgamUga3VuIHNub3dib2FyZGVuIGVuIDxhIGhyZWY9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3NraWVuLWluLWFtZXJpa2EvXCI+c2tpXHUwMGVibiBpbiBBbWVyaWthPC9hPi4gT3AgaGV0IG1lZXIga3VuIGplIG1ldCB2b3JzdCBzY2hhYXRzZW4gZW4gb29rIGlqc2tsaW1tZW4gaXMgZWVuIHBvcHVsYWlyZSBhY3Rpdml0ZWl0IGluIGRlIHdpbnRlci4gRGFhcm5hYXN0IHppam4gZXIgaW4gaGV0IGdlYmllZCBlZW4gYWFudGFsIGxhbmdsYXVmIHRyYWNrcy5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI3NXB4XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiIGZ1bGxfd2lkdGg9XCJzdHJldGNoX3Jvd1wiIGNvbnRlbnRfdGV4dF9hbGlnbWVudD1cImNlbnRlclwiIGNzcz1cIi52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O31cIiBwYXJhbGxheF9iYWNrZ3JvdW5kX2ltYWdlPVwiMzgzNlwiXVt2Y19jb2x1bW4gdGhiX2NvbG9yPVwidGhiLWxpZ2h0LWNvbHVtblwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt0aGJfcG9zdGJhY2tncm91bmQgc291cmNlPVwic2l6ZToxfHBvc3RfdHlwZTpwb3N0fGJ5X2lkOi0xNjE5LC02NjcsMTQ4MzBcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNzVweFwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMi8zXCJdW2hleXVzYV9oZWFkaW5nIHRhZz1cImRpdlwiIHRleHRfYWxpZ249XCJjZW50ZXJcIiBoZWFkaW5nPVwiT250ZGVrIG1lZXIgbmF0dXVyIGluIGRlIGJ1dXJ0XCIgZm9udF9zaXplPVwiNDBcIiBsaW5lX2hlaWdodD1cIjQwXCIgZm9udF9jb2xvcj1cIiMyODI4MjhcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJOb2cgbWVlciBOZXcgWW9yayBzdGFhdFwiIG1haW5faGVhZGluZ19jb2xvcj1cIiMyODI4MjhcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDo0MHB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjQ1cHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bL3ZjX3Jvd19pbm5lcl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMjVweFwiXVt0aGJfcG9zdGJhY2tncm91bmQgc3R5bGU9XCJzdHlsZTJcIiBzb3VyY2U9XCJieV9pZDoxNTU4MCw4MTA1LC0xMjYyLC0yMjY3LC01NzIsLTU0NSwxNTY0NCwxNTYyN1wiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XSIsInBvc3RfdGl0bGUiOiJMYWtlIFBsYWNpZCIsInBvc3RfbGluayI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvbGFrZS1wbGFjaWQvIiwicG9zdF9mZWF0dXJlZF9pbWFnZSI6IjxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiTGFrZSBQbGFjaWRcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjIyM1wiIHNyYz1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjMvMDQvbGFrZS1wbGFjaWQtMS0zMDB4MjIzLmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6Ik5hdHV1cmdlYmllZGVuIiwicG9zdF90YWdzIjoiTmV3IFlvcmsiLCIlX3dwYl9zaG9ydGNvZGVzX2N1c3RvbV9jc3MlIjoiLnZjX2N1c3RvbV8xNjEyOTUwNTQwODE0e2JhY2tncm91bmQtY29sb3I6ICNlZGVkZWQgIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O30iLCIlaW5saW5lX2ZlYXR1cmVkX2ltYWdlJSI6IjAiLCIlX2VkaXRfbGFzdCUiOiIyIiwiJV9lZGl0X2xvY2slIjoiMTY4MTMwMjIwMjoyIiwiJV93cGJfdmNfanNfc3RhdHVzJSI6InRydWUiLCIlcG9zdC1wcmltYXJ5LWNhdGVnb3J5JSI6IjMyIiwiJWZlYXR1cmVkX2ltYWdlX292ZXJyaWRlJSI6Im9mZiIsIiVhcnRpY2xlX3N0eWxlX292ZXJyaWRlJSI6Im9uIiwiJXBvc3Rfc3R5bGUlIjoic3R5bGU1IiwiJXBvc3RfZ2FsbGVyeV9zdHlsZSUiOiJsaWdodGJveCIsIiVwb3N0X3JldmlldyUiOiJvZmYiLCIlcG9zdF9yZXZpZXdfc3R5bGUlIjoic3R5bGUxIiwiJXBvc3RfcmV2aWV3X2F2ZXJhZ2UlIjoiNTAiLCIlc3RhbmRhcmQtZmVhdHVyZWQtY3JlZGl0JSI6IiIsIiVfaGlkZV9mZWF0dXJlZCUiOm51bGwsIiVwb3N0X3NvdXJjZSUiOiIiLCIlX3RodW1ibmFpbF9pZCUiOiIxNTYyMCIsIiVfeW9hc3Rfd3BzZW9fZm9jdXNrdyUiOiJMYWtlIFBsYWNpZCIsIiVfeW9hc3Rfd3BzZW9fbWV0YWRlc2MlIjoiRWVuIHZhbiBkZSBtZXJlbiBpbiBkZSBBZGlyb25kYWNrcyBpcyBMYWtlIFBsYWNpZC4gQmVuaWV1d2Qgd2F0IGplIGJpaiBMYWtlIFBsYWNpZCBlbiBoZXQgZ2VsaWprbmFtaWdlIGRvcnBqZSBrdW50IGRvZW4/IiwiJV95b2FzdF93cHNlb19saW5rZGV4JSI6IjczIiwiJV95b2FzdF93cHNlb19jb250ZW50X3Njb3JlJSI6IjkwIiwiJV95b2FzdF93cHNlb19mb2N1c2tleXdvcmRzJSI6IltdIiwiJV95b2FzdF93cHNlb19rZXl3b3Jkc3lub255bXMlIjoiW1wiSG9yc2VzaG9lIGJlbmQgXCJdIiwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6Ikxha2UgUGxhY2lkLCBOZXcgWW9yayAxMjk0NiwgVmVyZW5pZ2RlIFN0YXRlbiIsIiVfd3BnbXBfbG9jYXRpb25fY2l0eSUiOiJOb3J0aCBFbGJhIiwiJV93cGdtcF9sb2NhdGlvbl9zdGF0ZSUiOiJOZXcgWW9yayIsIiVfd3BnbXBfbG9jYXRpb25fY291bnRyeSUiOiJWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9tZXRhYm94X2xhdGl0dWRlJSI6IjQ0LjI3OTQ5MTEiLCIlX3dwZ21wX21ldGFib3hfbG9uZ2l0dWRlJSI6Ii03My45Nzk4NzEzIiwiJV93cGdtcF9tZXRhYm94X2xvY2F0aW9uX3JlZGlyZWN0JSI6Im1hcmtlciIsIiVfd3BnbXBfbWV0YWJveF9jdXN0b21fbGluayUiOiIiLCIlX3dwZ21wX21hcF9pZCUiOiJhOjE6e2k6MDtzOjE6XCI3XCI7fSIsIiVfd3BnbXBfbWV0YWJveF9tYXJrZXJfaWQlIjoiYToxOntpOjA7czoxOlwiN1wiO30iLCIlX3dwZ21wX21ldGFib3hfdGF4b21vbWllc190ZXJtcyUiOiJOOyIsIiVfd3BnbXBfZXh0ZW5zaW9uc19maWVsZHMlIjoiTjsiLCIlX3lvYXN0X3dwc2VvX2VzdGltYXRlZC1yZWFkaW5nLXRpbWUtbWludXRlcyUiOiIzIiwiJV95b2FzdF93cHNlb19wcmltYXJ5X2NhdGVnb3J5JSI6IjIyNyIsIiVfd3dzX3N1cHBvcnRfY29udGFjdF9udW1iZXIlIjoiIiwiJV93d3NfYWJvdXRfc3VwcG9ydF90ZXh0JSI6IiIsIiVfd3dzX3RyaWdnZXJfYnV0dG9uX3RleHQlIjoiIiwiJV93d3NfcHJlZGVmaW5lZF90ZXh0JSI6IiIsIiVfeW9hc3RfaW5kZXhub3dfbGFzdF9waW5nJSI6IjE2ODEzMDIzMTgiLCIlX3lvYXN0X3dwc2VvX3dvcmRwcm9vZl90aW1lc3RhbXAlIjoiIiwiJV9sYXN0X2VkaXRvcl91c2VkX2pldHBhY2slIjoiY2xhc3NpYy1lZGl0b3IiLCJ0YXhvbm9teT1jYXRlZ29yeSI6Ik5hdHV1cmdlYmllZGVuIiwidGF4b25vbXk9cG9zdF90YWciOiJOZXcgWW9yayIsInRheG9ub215PXBvc3RfZm9ybWF0IjoiIiwidGF4b25vbXk9dGhiLXJlYWN0aW9ucyI6IiIsInRheG9ub215PXRoYi1zcG9uc29ycyI6IiJ9LCJpY29uIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMS8wNC9wYXJrZW4ucG5nIn0sImlkIjoxNTYxNCwiaW5mb3dpbmRvd19kaXNhYmxlIjpmYWxzZSwiY2F0ZWdvcmllcyI6W3siaWNvbiI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjEvMDQvcGFya2VuLnBuZyIsIm5hbWUiOiJOYXRpb25hbGUgUGFya2VuIiwiaWQiOiI3IiwidHlwZSI6ImNhdGVnb3J5IiwiZXh0ZW5zaW9uX2ZpZWxkcyI6eyJjYXRfb3JkZXIiOiIifX1dfSx7InNvdXJjZSI6InBvc3QiLCJ0aXRsZSI6IlZvbGNhbm9lcyBOYXRpb25hbCBQYXJrIiwiaW5mb3dpbmRvd19jb250ZW50IjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZyBcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwidm9sY2Fub2VzIG5hdGlvbmFsIHBhcmtcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjIwMFwiIHNyYz1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjMvMDIvdm9sY2Fub2VzLW5hdGlvbmFsLXBhcmstMzAweDIwMC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nXCI+XHJcbiAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmcgZmMtaXRlbS1uby1wYWRkaW5nXCI+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLXRpdGxlIGZjLWl0ZW0tcHJpbWFyeS10ZXh0LWNvbG9yIGZjLWl0ZW0tdG9wLXNwYWNlXCI+Vm9sY2Fub2VzIE5hdGlvbmFsIFBhcms8L2Rpdj5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tY29udGVudCBmYy1pdGVtLWJvZHktdGV4dC1jb2xvclwiPnttYXJrZXJfYWRkcmVzc308L2Rpdj5cclxuICAgICAgICA8L2Rpdj5cclxuICAgIDwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWNsZWFyXCI+PC9kaXY+XHJcbjwvZGl2PiIsImFkZHJlc3MiOiJIYXdhaWkgVm9sY2Fub2VzIE5hdGlvbmFsIFBhcmssIEhJIDk2Nzg1LCBWZXJlbmlnZGUgU3RhdGVuIiwibG9jYXRpb24iOnsibGF0IjoiMTkuNDI5MDU0MyIsImNpdHkiOiJIYXdhaWkgVm9sY2Fub2VzIE5hdGlvbmFsIFBhcmsiLCJzdGF0ZSI6Ikhhd2FpaSIsImNvdW50cnkiOiJWZXJlbmlnZGUgU3RhdGVuIiwibG5nIjoiLTE1NS4yNTY4ODkyIiwib25jbGlja19hY3Rpb24iOiJtYXJrZXIiLCJyZWRpcmVjdF9wZXJtYWxpbmsiOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3ZvbGNhbm9lcy1uYXRpb25hbC1wYXJrLyIsInpvb20iOjEyLCJleHRyYV9maWVsZHMiOnsicG9zdF9leGNlcnB0IjoiIiwicG9zdF9jb250ZW50IjoiW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIl1bdmNfY29sdW1uIHdpZHRoPVwiMS8yXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjEwMCVcIl1bdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS8yXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJWb2xjYW5vZXMgTmF0aW9uYWwgUGFya1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTozNXx0ZXh0X2FsaWduOmxlZnR8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdRGUgZWlsYW5kZW4gdmFuIEhhd2FpaSBiZXN0YWFuIHVpdCBwcmFjaHRpZ2UgbmF0dXVyLiBFXHUwMGU5biB2YW4gZGUgbmF0aW9uYWxlIHBhcmtlbiB2YW4gPGEgaHJlZj1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvaGF3YWlpL1wiPkhhd2FpaTwvYT4gaXMgVm9sY2Fub2VzIE5hdGlvbmFsIFBhcmsgb3AgaGV0IGVpbGFuZCBIYXdhaWkuIEVlbiBwYXJrIGRhdCByZWRlbGlqayB1bmllayBpcy4gSGV0IGhlcmJlcmd0IHR3ZWUgdmFuIGRlIG1lZXN0IGJpanpvbmRlcmUgdnVsa2FuZW4gdGVyIHdlcmVsZDogS2lsYXVlYSBlbiBNYXVuYSBMb2EuIERlIGVlcnN0ZSBpcyBkZSBtZWVzdCBhY3RpZXZlIHZ1bGthYW4gdGVyIHdlcmVsZCBlbiBNYXVuYSBMb2EgZGUgZ3Jvb3RzdGUuIEVlbiBnb2VkZSByZWRlbiBvbSBlZW4gYmV6b2VrIHRlIGJyZW5nZW4gYWFuIFZvbGNhbm9lcyBOYXRpb25hbCBQYXJrLlsvdmNfY29sdW1uX3RleHRdW3VsdGltYXRlX2ljb25fbGlzdCBpY29uX3NpemU9XCIyMFwiXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtdHJlZVwiXTxzcGFuIGNsYXNzPVwiTHJ6WHIga25vLWZ2XCI+MTM0Nyw5IGttXHUwMGIyIG9wcGVydmxha3RlPC9zcGFuPlsvdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dWy91bHRpbWF0ZV9pY29uX2xpc3RdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjc3M9XCIudmNfY3VzdG9tXzE2MDg2NjY1MTk0OTJ7YmFja2dyb3VuZC1jb2xvcjogI2VhZWFlYSAhaW1wb3J0YW50O31cIl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjIvM1wiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI3NXB4XCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJWb2xjYW5vZXMgTmF0aW9uYWwgUGFyayBnZXZhYXJsaWprP1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTozNXx0ZXh0X2FsaWduOmNlbnRlcnxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1cclxuPHAgc3R5bGU9XCJ0ZXh0LWFsaWduOiBjZW50ZXI7XCI+QmlqIGVlbiBwYXJrIG1ldCAyIGFjdGlldmUgdnVsa2FuZW4gZGVuayBqZSB2YXN0IGFhbiBkZSB2ZWlsaWdoZWlkLiBXYW50IGhvZSBnZXZhYXJsaWprIGlzIGhldCBWb2xjYW5vZXMgTmF0aW9uYWwgUGFyayBlbiBob2UgZ3Jvb3QgaXMgZGUga2FucyBvcCBlZW4gdWl0YmFyc3Rpbmc/IFpvIHZvbmRlbiBlciBpbiBtZWkgMjAxOCBleHBsb3NpZXMgcGxhYXRzIGluIGhldCBLaWxhdWVhIGdlYmllZC4gSGllcmJpaiBrd2FtZW4gZ2lmdGlnZSBhc3dvbGtlbiB2cmlqIGVuIHZvbmRlbiBlciBrbGVpbmUgYWFyZGJldmluZ2VuIHBsYWF0cy4gRGVsZW4gdmFuIGhldCBwYXJrIHdlcmRlbiBnZXNsb3RlbiBlbiBwYXMgaW4gc2VwdGVtYmVyIDIwMTggd2VlciBnZW9wZW5kLiBWYW5hZiAyMDIyIGlzIGhldCBncm9vdHN0ZSBkZWVsIHdlZXIgb3Blbi4gRGUgS2lsYXVlYSB2dWxrYWFuIGlzIHZhbmFmIDIwMDggd2VlciBhY3RpZWYgZW4gd29yZHQgaW4gZGUgZ2F0ZW4gZ2Vob3VkZW4uIERlIGthbnMgYmxpamZ0IGFhbndlemlnIGRhdCBqZSBvcCBIYXdhaWkgYmVudCBlbiBqZSBiZXpvZWsgbW9ldCB1aXRzdGVsbGVuIHZhbndlZ2UgdnVsa2FuaXNjaGUgYWN0aXZpdGVpdGVuLjwvcD5cclxuWy92Y19jb2x1bW5fdGV4dF1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiIGZ1bGxfd2lkdGg9XCJzdHJldGNoX3Jvd1wiIGNvbnRlbnRfdGV4dF9hbGlnbWVudD1cImNlbnRlclwiIGNzcz1cIi52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O31cIiBwYXJhbGxheF9iYWNrZ3JvdW5kX2ltYWdlPVwiMzgzNlwiXVt2Y19jb2x1bW4gdGhiX2NvbG9yPVwidGhiLWxpZ2h0LWNvbHVtblwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkNyYXRlciBSaW0gRHJpdmVcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6NzV8dGV4dF9hbGlnbjpjZW50ZXJ8Y29sb3I6JTIzZmZmZmZmfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJTY2hhZGUgdmFuIGVlbiBhYXJkYmV2aW5nXCIgZm9udF9jb250YWluZXI9XCJ0YWc6ZGl2fGZvbnRfc2l6ZTo0NXx0ZXh0X2FsaWduOmNlbnRlcnxjb2xvcjolMjNmZmZmZmZ8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkRhbmNpbmclMjBTY3JpcHQlM0FyZWd1bGFyJTJDNzAwfGZvbnRfc3R5bGU6NzAwJTIwYm9sZCUyMHJlZ3VsYXIlM0E3MDAlM0Fub3JtYWxcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bcGFyYWxsYXhfcm93IGVuYWJsZV9tb2JpbGU9XCJwYXJhbGxheC1lbmFibGUtbW9iaWxlXCIgaW1hZ2U9XCIxNTA3MlwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCJdW3ZjX2NvbHVtbl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvM1wiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiRmFjdHMgVm9sY2Fub2VzIE5hdGlvbmFsIFBhcmtcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MjV8dGV4dF9hbGlnbjpsZWZ0XCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1IZXQgVm9sY2Fub2VzIE5hdGlvbmFsIFBhcmsgaXMgZWVuIHVuaWVrIHBhcmsgaW4gQW1lcmlrYS4gRGUgdnVsa2FuaXNjaGUgbGFuZHNjaGFwcGVuIGhlYmJlbiBlZW4gdW5pZWsgZWNvIHN5c3RlZW0gbWV0IGJpanpvbmRlcmUgZmxvcmEgZW4gZmF1bmEuIEhldCBnZWJpZWQgaXMgc2luZHMgMTkxNiBlZW4gbmF0aW9uYWFsIHBhcmsgZGF0IGJpam5hIGhldCBnZWhlbGUgZWlsYW5kIEhhd2FpaSBiZXNsYWF0LiBTaW5kcyAxOTg3IGJlaG9vcnQgVm9sY2Fub2VzIE5hdGlvbmFsIFBhcmsgdG90IFVORVNDTyBXZXJlbGRlcmZnb2VkLlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvM1wiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiQmVzdGUgcmVpc3BlcmlvZGUgVm9sY2Fub2VzIE5hdGlvbmFsIFBhcmtcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MjV8dGV4dF9hbGlnbjpsZWZ0XCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1EZSBiZXN0ZSBwZXJpb2RlIG9tIFZvbGNhbm9lcyBOYXRpb25hbCBQYXJrIHRlIGJlem9la2VuIGlzIGVpZ2VubGlqayBoZXQgaGVsZSBqYWFyIGRvb3IuIERlIHRlbXBlcmF0dXJlbiB2ZXJzY2hpbGxlbmRlIGdlZHVyZW5kZSBoZXQgamFhciBuaWV0IHZlZWwgb3AgSGF3YWlpLiBJbiBmZWJydWFyaSwgbWFhcnQsIG9rdG9iZXIsIG5vdmVtYmVyIGVuIGRlY2VtYmVyIGhlYiBqZSBkZSBtZWVzdGUga2FucyBvcCByZWdlbi5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzNcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIk92ZXJuYWNodGVuIGluIFZvbGNhbm9lcyBOYXRpb25hbCBQYXJrXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjI1fHRleHRfYWxpZ246bGVmdFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdQmlqIGhldCBWb2xjYW5vZXMgTmF0aW9uYWwgUGFyayB6aWpuIHZlcnNjaGlsbGVuZGUgb3B0aWVzIG9tIHRlIG92ZXJuYWNodGVuLiBKZSBrdW50IGVlbiBhY2NvbW1vZGF0aWUgYm9la2VuIGluIGhldCA8YSBocmVmPVwiaHR0cHM6Ly93d3cuYm9va2luZy5jb20vaG90ZWwvdXMva2lsYXVlYS1sb2RnZS1hbXAtcmVzdGF1cmFudC5lbi5odG1sP2FpZD03OTU4NDk4JmFtcDtub19yb29tcz0xJmFtcDtncm91cF9hZHVsdHM9MiZhbXA7bGFiZWw9dm9sY2Fub2Vza2lsYXVlYVwiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+S2lsYXVlYSBMb2RnZSBhbmQgUmVzdGF1cmFudDwvYT4uIEplIGxvZ2VlcnQgaGllciB2bGFrYmlqIGhldCBwYXJrLiBFZW4gaWRlYWxlIHVpdHZhbHNiYXNpcyBvbSBoZXQgcGFyayB0ZSB2ZXJrZW5uZW4uIFdpbCBqZSBlY2h0IGluIGhldCBwYXJrIG92ZXJuYWNodGVuPyBEYW4gaXMgPGEgaHJlZj1cImh0dHBzOi8vaGF3YWlpdm9sY2Fub2hvdXNlLmNvbS9cIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPlZvbGNhbm8gSG91c2U8L2E+IGVlbiBnb2VkZSBvcHRpZS4gSmUgc2xhYXB0IGhpZXIgdmxha2JpaiBkZSB2dWxrYWFuLlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCJdW3ZjX2NvbHVtbl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lcl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIldhdCB0ZSBkb2VuIGluIFZvbGNhbm9lcyBOYXRpb25hbCBQYXJrXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjM1fHRleHRfYWxpZ246Y2VudGVyfGNvbG9yOiUyM2IzNGE0Y1wiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdSGV0IFZvbGNhbm9lcyBOYXRpb25hbCBQYXJrIGJpZWR0IHZvbGRvZW5kZSBtb2dlbGlqa2hlZGVuIHF1YSBiZXppZW5zd2FhcmRpZ2hlZGVuLiBKZSBrdW50IGluIHByaW5jaXBlIGluIGVlbiBkYWcgdmVlbCB6aWVuIGluIGhldCBwYXJrLCBtYWFyIG1vY2h0IGplIG9vayBlZW4gYWFudGFsIHdhbmRlbGluZ2VuIHdpbGxlbiBtYWtlbiwgbmVlbSBkYW4gaWV0cyBtZWVyIHRpamQuIEVlbiBhYW50YWwgdGlwcyB2b29yIGFjdGl2aXRlaXRlbiBlbiBiZXppZW5zd2FhcmRpZ2hlZGVuIGluIFZvbGNhbm9lcyBOYXRpb25hbCBQYXJrLlsvdmNfY29sdW1uX3RleHRdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMjVweFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbiB3aWR0aD1cIjEvMlwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI3MCVcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkNyYXRlciBSaW1cIiBmb250X2NvbnRhaW5lcj1cInRhZzpoM3xmb250X3NpemU6MzB8dGV4dF9hbGlnbjpsZWZ0XCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19zaW5nbGVfaW1hZ2UgaW1hZ2U9XCIxNTA2N1wiIGltZ19zaXplPVwibGFyZ2VcIl1bdmNfY29sdW1uX3RleHRdRGUgbWFra2VsaWprc3RlIG1hbmllciBvbSBWb2xjYW5vZXMgTmF0aW9uYWwgUGFyayB0ZSB2ZXJrZW5uZW4gaXMgdmlhIGRlIENyYXRlciBSaW0gRHJpdmUuIERlIHJvbmR3ZWcgZG9vciBoZXQgcGFyayBiaWVkdCBqZSBkZSBtb2dlbGlqa2hlZGVuIG9tIG9uZGVyd2VnIHZhbiBhbGxlcyB0ZSB6aWVuIGVuIHRlIHN0b3BwZW4gYmlqIGJlemllbnN3YWFyZGlnaGVkZW4gb2Ygd2FuZGVsaW5nZW4uIEplIGJlbnQgb25nZXZlZXIgMS0yIHV1ciBvbmRlcndlZyBpbiBkZSBhdXRvLiBTdG9wIGJpanZvb3JiZWVsZCBiaWogaGV0IEphZ2dhciBNdXNldW0gb20gbWVlciB0ZSB3ZXRlbiB0ZSBrb21lbiBvdmVyIHZ1bGthbmVuIG9mIGdhIGVydWl0IGJpaiB2ZXJzY2hpbGxlbmRlIHVpdGtpamtwdW50ZW4gb20gZGUgdnVsa2FuZW4gdGUgYmVraWprZW4uWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS8yXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJLaWxhdWVhIG91dGxvb2tcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoM3xmb250X3NpemU6MzB8dGV4dF9hbGlnbjpsZWZ0XCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19zaW5nbGVfaW1hZ2UgaW1hZ2U9XCIxNTA2NFwiIGltZ19zaXplPVwibGFyZ2VcIl1bdmNfY29sdW1uX3RleHRdRWVuIHByYWNodGlnZSBwbGVrIG9tIHVpdCB0ZSBraWprZW4gb3ZlciBlZW4gYWN0aWV2ZSB2dWxrYWFuOiBkZSBLaWxhdWVhIE91dGxvb2suIFZhbmFmIGhpZXIga3VuIGplIHZ1bGthYW4gZ29lZCB6aWVuLiBWb29yYWwgaW4gZGUgb2NodGVuZCBlbiBhdm9uZCBlZW4gZ29lZGUgcGxlayBvbSBkaXQgbmF0dXVyZmVub21lZW4gdGUgYmVraWprZW4uWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW5dW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiNzAlXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJDaGFpbiBvZiBDcmF0ZXJzIFJvYWRcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoM3xmb250X3NpemU6MzB8dGV4dF9hbGlnbjpsZWZ0XCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19zaW5nbGVfaW1hZ2UgaW1hZ2U9XCIxNTA2NlwiIGltZ19zaXplPVwibGFyZ2VcIl1bdmNfY29sdW1uX3RleHRdRWVuIGFuZGVyZSBtYW5pZXIgb20gaGV0IHBhcmsgdGUgdmVya2VubmVuIGlzIHZpYSBkZSBDaGFpbiBvZiBDcmF0ZXJzIFJvYWQuIEVlbiAzMCBraWxvbWV0ZXIgbGFuZ2Ugd2VnIGRpZSBqZSBsYW5ncyB2ZXJzY2hpbGxlbmRlIGtyYXRlcnMgYnJlbmd0LiBPdmVyaWdlbnMgaXMgZXIgYWx0aWpkIGVlbiBrYW5zIGRhdCBkZSB3ZWcgb25kZXJicm9rZW4gd29yZHQgZG9vciBrb2xrZW5kZSBsYXZhIHN0cm9tZW4uIEplIGt1bnQgZGUgdm9sZ2VuZGUga3JhdGVycyB6aWVuIG9uZGVyd2VnOiBMdWEgTWFudSwgUGF1YWhpIGVuIEtlYWxha29tby4gT25kZXJ3ZWcgaGViIGplIGRlIG1vZ2VsaWpraGVkZW4gb20gdmVyc2NoaWxsZW5kZSB3YW5kZWxpbmdlbiB0ZSBtYWtlbi5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzJcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIlZpc2l0b3IgQ2VudGVyXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDN8Zm9udF9zaXplOjMwfHRleHRfYWxpZ246bGVmdFwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfc2luZ2xlX2ltYWdlIGltYWdlPVwiMTUwNjhcIiBpbWdfc2l6ZT1cImxhcmdlXCJdW3ZjX2NvbHVtbl90ZXh0XVdpbCBqZSBtZWVyIHdldGVuIG92ZXIgdnVsa2FuZW4/IERhbiBpcyBlZW4gYmV6b2VrIGFhbiBoZXQgYmV6b2VrZXJzY2VudHJ1bSBhYW4gdGUgcmFkZW4uIEhldCBjZW50cnVtIGlzIGRhZ2VsaWprcyBnZW9wZW5kIGVuIGJpZWR0IGplIGRhYXJuYWFzdCBvb2sgYWxsZSBpbmZvcm1hdGllIHZvb3Igd2FuZGVsaW5nZW4gZW4gY29uZGl0aWVzIHZhbiBkZSByb3V0ZXMuIEVyIGRyYWFpdCByZWdlbG1hdGlnIGVlbiBmaWxtIG92ZXIgaGV0IG9udHN0YWFuIHZhbiBoZXQgcGFyay5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIiBmdWxsX3dpZHRoPVwic3RyZXRjaF9yb3dcIiBjb250ZW50X3RleHRfYWxpZ21lbnQ9XCJjZW50ZXJcIiBjc3M9XCIudmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9XCIgcGFyYWxsYXhfYmFja2dyb3VuZF9pbWFnZT1cIjM4MzZcIl1bdmNfY29sdW1uIHRoYl9jb2xvcj1cInRoYi1saWdodC1jb2x1bW5cIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiVHJhaWxzIGluIFZvbGNhbm9lcyBOYXRpb25hbCBQYXJrXCIgaGVhZGluZ190YWc9XCJwXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiI2ZmZmZmZlwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjQ1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NTVweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjEwcHhcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJPbnRkZWsgaGV0IHBhcmsgb3AgZWVuIHZhbiBkZSB3YW5kZWxwYWRlblwiIGhlYWRpbmdfdGFnPVwicFwiIG1haW5faGVhZGluZ19jb2xvcj1cIiNmZmZmZmZcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OlJvYm90byBTbGFifGZvbnRfY2FsbDpSb2JvdG8rU2xhYnx2YXJpYW50OjkwMFwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6MzBweDtcIiBtYWluX2hlYWRpbmdfc3R5bGU9XCJmb250LXdlaWdodDo5MDA7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVtwYXJhbGxheF9yb3cgZW5hYmxlX21vYmlsZT1cInBhcmFsbGF4LWVuYWJsZS1tb2JpbGVcIiBpbWFnZT1cIjE1MDcxXCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjc3M9XCIudmNfY3VzdG9tXzE2MDg2NjY4ODU0OTd7YmFja2dyb3VuZC1pbWFnZTogdXJsKGh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjAvMDgvYmFja2dyb3VuZC1oZXl1c2EtbmF0dXVyLTEuZ2lmP2lkPTMwODgpICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW5dW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiV2FuZGVsZW4gaW4gVm9sY2Fub2VzIE5hdGlvbmFsIFBhcmtcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMDAwMDAwXCIgYWxpZ25tZW50PVwibGVmdFwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NTVweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XUhvZXdlbCBqZSBoZXQgbWlzc2NoaWVuIG5pZXQgdmVyd2FjaHQsIGt1biBqZSB0b2NoIGdvZWQgd2FuZGVsZW4gaW4gaGV0IFZvbGNhbm9lcyBOYXRpb25hbCBQYXJrLiBFZW4gdm9vcmJlZWxkIHZhbiBlZW4gbW9vaWUgcm91dGUgaXMgZGUgRGV2YXN0YXRpb24gVHJhaWwuIEVlbiBtYWtrZWxpamsgdG9lZ2Fua2VsaWprZSByb3V0ZSB2YW4gMS42IGtpbG9tZXRlciBsYW5ncyBkZSByZXN0YW50ZW4gdmFuIGRlIHVpdGJhcnN0aW5nIHZhbiBkZSBLaWxhdWVhIGluIDE5NTkuIE1lZXIgd2V0ZW4gb3ZlciBkZSBmbG9yYSBlbiBmYXVuYSBpbiBWb2xjYW5vZXMgTmF0aW9uYWwgUGFyaz8gV2FuZGVsIGRhbiBkZSBLaXB1a2FwdWF1bHUgVHJhaWwuIEluIDIga2lsb21ldGVyIGtvbSBqZSBtZWVyIHRlIHdldGVuIG92ZXIgZGUgemVsZHphbWUgcGxhbnRlbiBlbiBkaWVyZW4gaW4gaGV0IHBhcmsuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiSGFuZGlnZSBpbmZvIHZvb3IgamUgYmV6b2VrXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzAwMDAwMFwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OlJvYm90byBTbGFifGZvbnRfY2FsbDpSb2JvdG8rU2xhYnx2YXJpYW50OjgwMFwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NTVweDtcIiBtYWluX2hlYWRpbmdfc3R5bGU9XCJmb250LXdlaWdodDo4MDA7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt1bHRpbWF0ZV9pY29uX2xpc3QgaWNvbl9zaXplPVwiMjVcIl1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLWNsb2NrLW9cIiBjb250ZW50X2ZvbnRfc2l6ZT1cImRlc2t0b3A6MTZweDtcIl08c3Ryb25nPjI0LzcgZ2VvcGVuZCwgNyBkYWdlbiBwZXIgd2Vlazwvc3Ryb25nPlsvdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy10aHVtYnMtdXBcIiBjb250ZW50X2ZvbnRfc2l6ZT1cImRlc2t0b3A6MTZweDtcIl1CZXN0ZSBwZXJpb2RlOiBoZWxlIGphYXJbL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtZG9sbGFyIHVzZFwiIGNvbnRlbnRfZm9udF9zaXplPVwiZGVza3RvcDoxNnB4O1wiXTcgZGFhZ3NlIHBhcyB2b29yIGF1dG8nczogJDMwXHJcbjcgZGFhZ3NlIHBhcyB2b29yIHZvZXRnYW5nZXJzOiAkMTVbL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVsvdWx0aW1hdGVfaWNvbl9saXN0XVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIiBmdWxsX3dpZHRoPVwic3RyZXRjaF9yb3dcIiBjb250ZW50X3RleHRfYWxpZ21lbnQ9XCJjZW50ZXJcIiBjc3M9XCIudmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9XCIgcGFyYWxsYXhfYmFja2dyb3VuZF9pbWFnZT1cIjM4MzZcIl1bdmNfY29sdW1uIHRoYl9jb2xvcj1cInRoYi1saWdodC1jb2x1bW5cIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiVm9sY2Fub2VzIE5hdGlvbmFsIFBhcmtcIiBoZWFkaW5nX3RhZz1cInBcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjZmZmZmZmXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6NDVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDo1NXB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMTBweFwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIlZ1bGthbmlzY2hlIGxhbmRzY2hhcHBlblwiIGhlYWRpbmdfdGFnPVwicFwiIG1haW5faGVhZGluZ19jb2xvcj1cIiNmZmZmZmZcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OlJvYm90byBTbGFifGZvbnRfY2FsbDpSb2JvdG8rU2xhYnx2YXJpYW50OjkwMFwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6MzBweDtcIiBtYWluX2hlYWRpbmdfc3R5bGU9XCJmb250LXdlaWdodDo5MDA7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVtwYXJhbGxheF9yb3cgZW5hYmxlX21vYmlsZT1cInBhcmFsbGF4LWVuYWJsZS1tb2JpbGVcIiBpbWFnZT1cIjE1MDc0XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIl1bdmNfY29sdW1uXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJNZWVyIG5hdGlvbmFsZSBwYXJrZW5cIiBmb250X2NvbnRhaW5lcj1cInRhZzpkaXZ8Zm9udF9zaXplOjQwfHRleHRfYWxpZ246Y2VudGVyXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt0aGJfcG9zdGdyaWQgc3R5bGU9XCJzdHlsZTExXCIgY29sdW1ucz1cIjRcIiBzb3VyY2U9XCJwb3N0X3R5cGU6cG9zdHxieV9pZDo0NzM4LDQ3MTQsNDY4OSw0NzkyXCJdWy92Y19jb2x1bW5dWy92Y19yb3ddIiwicG9zdF90aXRsZSI6IlZvbGNhbm9lcyBOYXRpb25hbCBQYXJrIiwicG9zdF9saW5rIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC92b2xjYW5vZXMtbmF0aW9uYWwtcGFyay8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJ2b2xjYW5vZXMgbmF0aW9uYWwgcGFya1wiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMy8wMi92b2xjYW5vZXMtbmF0aW9uYWwtcGFyay0zMDB4MjAwLmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6IlZvbGNhbm9lcyBOYXRpb25hbCBQYXJrIiwicG9zdF90YWdzIjoiSGF3YWlpIiwiJV93cGJfc2hvcnRjb2Rlc19jdXN0b21fY3NzJSI6Ii52Y19jdXN0b21fMTYwODY2NjUxOTQ5MntiYWNrZ3JvdW5kLWNvbG9yOiAjZWFlYWVhICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNjA4NjY2ODg1NDk3e2JhY2tncm91bmQtaW1hZ2U6IHVybChodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIwLzA4L2JhY2tncm91bmQtaGV5dXNhLW5hdHV1ci0xLmdpZj9pZD0zMDg4KSAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9IiwiJWlubGluZV9mZWF0dXJlZF9pbWFnZSUiOiIwIiwiJV9lZGl0X2xvY2slIjoiMTY5NDg3MzI3NjoyIiwiJV9lZGl0X2xhc3QlIjoiMiIsIiVfdGh1bWJuYWlsX2lkJSI6IjE1MDY1IiwiJV9oaWRlX2ZlYXR1cmVkJSI6bnVsbCwiJV93cGJfdmNfanNfc3RhdHVzJSI6InRydWUiLCIlcG9zdC1wcmltYXJ5LWNhdGVnb3J5JSI6ImF1dG8iLCIlZmVhdHVyZWRfaW1hZ2Vfb3ZlcnJpZGUlIjoib2ZmIiwiJWFydGljbGVfc3R5bGVfb3ZlcnJpZGUlIjoib24iLCIlcG9zdF9zdHlsZSUiOiJzdHlsZTExIiwiJXBvc3RfZ2FsbGVyeV9zdHlsZSUiOiJsaWdodGJveCIsIiVwb3N0X3JldmlldyUiOiJvZmYiLCIlcG9zdF9yZXZpZXdfc3R5bGUlIjoic3R5bGUxIiwiJXBvc3RfcmV2aWV3X2F2ZXJhZ2UlIjoiNTAiLCIlX3lvYXN0X3dwc2VvX2NvbnRlbnRfc2NvcmUlIjoiMzAiLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza2V5d29yZHMlIjoiW10iLCIlX3lvYXN0X3dwc2VvX2tleXdvcmRzeW5vbnltcyUiOiJbXCJcIl0iLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza3clIjoiVm9sY2Fub2VzIE5hdGlvbmFsIFBhcmsiLCIlX3lvYXN0X3dwc2VvX21ldGFkZXNjJSI6IkluIEhhd2FpaSBsaWd0IGhldCBWb2xjYW5vZXMgTmF0aW9uYWwgUGFyay4gVGlwcyB2b29yIGVlbiBiZXpvZWsgYWFuIGhldCBWb2xjYW5vZXMgTmF0aW9uYWwgUGFyay4iLCIlX3lvYXN0X3dwc2VvX2xpbmtkZXglIjoiODEiLCIlX3dwZ21wX2xvY2F0aW9uX2FkZHJlc3MlIjoiSGF3YWlpIFZvbGNhbm9lcyBOYXRpb25hbCBQYXJrLCBISSA5Njc4NSwgVmVyZW5pZ2RlIFN0YXRlbiIsIiVfd3BnbXBfbG9jYXRpb25fY2l0eSUiOiJIYXdhaWkgVm9sY2Fub2VzIE5hdGlvbmFsIFBhcmsiLCIlX3dwZ21wX2xvY2F0aW9uX3N0YXRlJSI6Ikhhd2FpaSIsIiVfd3BnbXBfbG9jYXRpb25fY291bnRyeSUiOiJWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9tZXRhYm94X2xhdGl0dWRlJSI6IjE5LjQyOTA1NDMiLCIlX3dwZ21wX21ldGFib3hfbG9uZ2l0dWRlJSI6Ii0xNTUuMjU2ODg5MiIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiN1wiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6IiIsIiVfd3BnbXBfbWV0YWJveF90YXhvbW9taWVzX3Rlcm1zJSI6IiIsIiVfd3BnbXBfZXh0ZW5zaW9uc19maWVsZHMlIjoiIiwiJV95b2FzdF93cHNlb19lc3RpbWF0ZWQtcmVhZGluZy10aW1lLW1pbnV0ZXMlIjoiNSIsIiVfeW9hc3Rfd3BzZW9fcHJpbWFyeV9jYXRlZ29yeSUiOiIyMjUiLCIlX3d3c19zdXBwb3J0X2NvbnRhY3RfbnVtYmVyJSI6IiIsIiVfd3dzX2Fib3V0X3N1cHBvcnRfdGV4dCUiOiIiLCIlX3d3c190cmlnZ2VyX2J1dHRvbl90ZXh0JSI6IiIsIiVfd3dzX3ByZWRlZmluZWRfdGV4dCUiOiIiLCIlX3lvYXN0X3dwc2VvX3dvcmRwcm9vZl90aW1lc3RhbXAlIjoiIiwiJV95b2FzdF9pbmRleG5vd19sYXN0X3BpbmclIjoiMTY5NDg3MzQwMSIsIiVfbGFzdF9lZGl0b3JfdXNlZF9qZXRwYWNrJSI6ImNsYXNzaWMtZWRpdG9yIiwidGF4b25vbXk9Y2F0ZWdvcnkiOiJWb2xjYW5vZXMgTmF0aW9uYWwgUGFyayIsInRheG9ub215PXBvc3RfdGFnIjoiSGF3YWlpIiwidGF4b25vbXk9cG9zdF9mb3JtYXQiOiIiLCJ0YXhvbm9teT10aGItcmVhY3Rpb25zIjoiIiwidGF4b25vbXk9dGhiLXNwb25zb3JzIjoiIn19LCJpZCI6MTUwNjIsImluZm93aW5kb3dfZGlzYWJsZSI6ZmFsc2V9LHsic291cmNlIjoicG9zdCIsInRpdGxlIjoiTm9NbyBTb0hvIiwiaW5mb3dpbmRvd19jb250ZW50IjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZyBcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiRWVuIGthbWVyIGluIGhldCAjd293IGhvdGVsIE5vTW8gU29IbyBpbiBOZXcgWW9yayBDaXR5LlwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMy8wMi9Ob21vLVNvaG8tUHJlbWl1bS1LaW5nLTMwMHgyMDAuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZ1wiPlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nIGZjLWl0ZW0tbm8tcGFkZGluZ1wiPlxyXG4gICAgICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS10aXRsZSBmYy1pdGVtLXByaW1hcnktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZVwiPk5vTW8gU29IbzwvZGl2PlxyXG4gICAgICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1jb250ZW50IGZjLWl0ZW0tYm9keS10ZXh0LWNvbG9yXCI+e21hcmtlcl9hZGRyZXNzfTwvZGl2PlxyXG4gICAgICAgIDwvZGl2PlxyXG4gICAgPC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtY2xlYXJcIj48L2Rpdj5cclxuPC9kaXY+IiwiY29udGVudCI6IkFsbGVlbiBhbCB2b29yIGhldCB1aXR6aWNodCB2YW51aXQgZGUgRGVsZnRzIGJsYXV3ZSBrYW1lcnMsIHdpbCBqZSBoaWVyIGxvZ2VyZW4uIEhldCBOb01vIGluIGRlIHdpamsgU29IbyBpcyAjd293LiAiLCJhZGRyZXNzIjoiOSBDcm9zYnkgU3QsIE5ldyBZb3JrLCBOWSAxMDAxMywgVmVyZW5pZ2RlIFN0YXRlbiIsImxvY2F0aW9uIjp7ImxhdCI6IjQwLjcxOTgzNTM2Mjk1NDkyNSIsImNpdHkiOiJOZXcgWW9yayIsInN0YXRlIjoiTmV3IFlvcmsiLCJjb3VudHJ5IjoiVmVyZW5pZ2RlIFN0YXRlbiIsImxuZyI6Ii03NC4wMDAwODQ5ODY1MDgxNyIsIm9uY2xpY2tfYWN0aW9uIjoibWFya2VyIiwicmVkaXJlY3RfcGVybWFsaW5rIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9ob3RlbHMvb3Zlcm5hY2h0ZW4taW4tbmV3LXlvcmstY2l0eS9ub21vLXNvaG8vIiwiem9vbSI6MTIsImV4dHJhX2ZpZWxkcyI6eyJwb3N0X2V4Y2VycHQiOiJBbGxlZW4gYWwgdm9vciBoZXQgdWl0emljaHQgdmFudWl0IGRlIERlbGZ0cyBibGF1d2Uga2FtZXJzLCB3aWwgamUgaGllciBsb2dlcmVuLiBIZXQgTm9NbyBpbiBkZSB3aWprIFNvSG8gaXMgI3dvdy4gIiwicG9zdF9jb250ZW50IjoiW3ZjX3Jvd11bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjIvM1wiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCIjd293IGhvdGVsIGluIFNvSG9cIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6NDVweDtcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjUwcHg7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIjkgQ3Jvc2J5IFN0cmVldCwgU29IbywgTWFuaGF0dGFuXCIgaGVhZGluZ190YWc9XCJkaXZcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpPc3dhbGR8Zm9udF9jYWxsOk9zd2FsZFwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjMwcHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozNXB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdXHJcbjxwIHN0eWxlPVwidGV4dC1hbGlnbjogY2VudGVyO1wiPlx1MmI1MFx1ZmUwZlx1MmI1MFx1ZmUwZlx1MmI1MFx1ZmUwZlx1MmI1MFx1ZmUwZjwvcD5cclxuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJOb01vIFNvSG8gSG90ZWxcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozMHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCIkJCRcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjYzU5YzRkXCIgYWxpZ25tZW50PVwibGVmdFwiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6MzBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XURlIHNmZWVyIHppdCBlciBhbCBtZXRlZW4gZ29lZCBpbiB3YW5uZWVyIGplIG5hYXIgZGUgbG9iYnkgdmFuIGhldCBOb01vIFNvSG8gd2FuZGVsdC4gRG9vciBlZW4gaGFhZyB2YW4gd2VlbGRlcmlnIGdyb2VuZSBwbGFudGVuLCBiZWxhbmQgamUgaW4gZWVuICNjb29sZSBsb2JieSBtZXQgbmVvbiwgZ3JvdGUgc2NoaWxkZXJpamVuIG1ldCBtb2Rlcm5lIGt1bnN0IGVuIHZlZWwga2xldXIuIFpvIHN0b2VyIGVuIGtsZXVycmlqayBkZSBwdWJsaWVrZSBydWltdGVzIHppam4sIHpvYWxzIGRlIGJhciwgaGV0IHJlc3RhdXJhbnQsIHpvIHNlcmVlbiBlbiB6YWNodCB6aWpuIGRlIGhvdGVsa2FtZXJzLiBEZSBEZWxmdHMgQmxhdXdlIHZsb2VyYmVkZWtraW5nIGVuIGt1c3NlbnMgbWV0IGFudGllayBibGF1dyBwYXRyb29uIGdldmVuIGRlIG92ZXJ3ZWdlbmRlIGxpY2h0ZSBlbiBydXN0aWdlIGthbWVyIGVlbiBrbGV1cmtuYWxsZXIuIERlIGthbWVyIGlzIGVlbiBoZWVmdCB0aWtrZWx0amUgRnJhbnNlIExvdWlzIFhJVi1zdGlqbCBpbiBtb2Rlcm5lIHVpdHZvZXJpbmcuIFZlZWwgd2l0IGVuIGxpY2h0ZSB0aW50ZW4sIG9tIGRlIGtuYWxibGF1d2UgdmxvZXJiZWRla2tpbmcgbmF0dXVybGlqayBpbiBldmVud2ljaHQgdGUgYnJlbmdlbi4gRW4gZGFuLi4uIGRhdCB1aXR6aWNodC4gQWxsZWVuIGFsIGRhYXJ2b29yIHdpbCBqZSBoaWVyIGxvZ2VyZW4hWy92Y19jb2x1bW5fdGV4dF1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJHZXNlbGVjdGVlcmQgZG9vciBIZXkhVVNBXCIgYWxpZ25tZW50PVwibGVmdFwiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OlJvYm90byBTbGFifGZvbnRfY2FsbDpSb2JvdG8rU2xhYnx2YXJpYW50OjgwMFwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjIwcHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19zdHlsZT1cImZvbnQtd2VpZ2h0OjgwMDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XU5vTW8gU29IbyBpcyBkb29yIEhleSFVU0EgZ2VzZWxlY3RlZXJkIG9tZGF0IGRpdCBlZW4gaG90ZWwgaXMgbWV0IGVlbiBlaWdlbiwgdW5pZWtlIHN0aWpsLiBHbGl0dGVyIGVuIGdsYW1vdXIgd29yZHQgYWZnZXdpc3NlbGQgbWV0IGVlbiBpbmR1c3RyaVx1MDBlYmxlIHRvdWNoLiBEZSBrYW1lcnMgemlqbiBydWltIGVuIGxpY2h0IG1ldCBnZXdlbGRpZyB1aXR6aWNodCBvcCBkZSBza3lsaW5lIHZhbiBOZXcgWW9yay4gSGV0IHVsdGllbWUgQmlnIEFwcGxlIGdldm9lbCBpbiBlZW4gc3RvZXIgaG90ZWwgaW4gaGV0IGhpcHBlIFNvSG8uWy92Y19jb2x1bW5fdGV4dF1bdWx0X2J1dHRvbnMgYnRuX3RpdGxlPVwiQm9layBlZW4ga2FtZXJcIiBidG5fbGluaz1cInVybDpodHRwcyUzQSUyRiUyRnd3dy5ib29raW5nLmNvbSUyRmhvdGVsJTJGdXMlMkZub21vLXNvaG8uZW4uaHRtbCUzRmFpZCUzRDc5NTg0OTglMjZub19yb29tcyUzRDElMjZncm91cF9hZHVsdHMlM0QyJTI2bGFiZWwlM0Rob3RlbGNvbGxlY3Rpb24taG90ZWxwYWdlLW5vbW8tc29ob3x0aXRsZTpCb2VrJTIwZWVuJTIwa2FtZXJ8dGFyZ2V0Ol9ibGFua1wiIGJ0bl90aXRsZV9jb2xvcj1cIiNmZmZmZmZcIiBidG5fYmdfY29sb3I9XCIjYjM0YTRjXCIgYnRuX2hvdmVyPVwidWJ0bi1ib3R0b20tYmdcIiBidG5fYmdfY29sb3JfaG92ZXI9XCIjNTMxYTIzXCIgaWNvbl9zaXplPVwiMzJcIiBidG5faWNvbl9wb3M9XCJ1YnRuLXNlcC1pY29uLWF0LWxlZnRcIiBidG5fZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgYnRuX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjBweDtcIiBidG5fbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjI1cHg7XCJdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVt2Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3ZjX3Jvd19pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjIvM1wiXVt0aGJfaW1hZ2Vfc2xpZGVyIGxpZ2h0Ym94PVwibWZwLWdhbGxlcnlcIiB0aGJfZXF1YWxfaGVpZ2h0PVwidHJ1ZVwiIGF1dG9wbGF5PVwidHJ1ZVwiIGltYWdlcz1cIjE0Nzc2LDE0Nzc3LDE0NzY3LDE0NzY4LDE0NzY5LDE0NzcwLDE0NzcxLDE0NzcyLDE0Nzc5LDE0NzczLDE0Nzc1LDE0Nzc0LDE0Nzc4XCJdWy92Y19jb2x1bW5faW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvNlwiXVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfc2luZ2xlX2ltYWdlIGltYWdlPVwiMTQ3NzNcIiBpbWdfc2l6ZT1cImxhcmdlXCIgYWRkX2NhcHRpb249XCJ5ZXNcIiBzdHlsZT1cInZjX2JveF9zaGFkb3dfM2RcIl1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8yXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiUG9wdWxhaXJlIGZhY2lsaXRlaXRlblwiIGhlYWRpbmdfdGFnPVwiaDNcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozMHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfY29sdW1uX3RleHRdRGUgd2lqayBTb0hvIGlzIFx1MDBlOVx1MDBlOW4gdmFuIGRlIGhpcHN0ZSB2YW4gTmV3IFlvcmsuIEluIGRlIGJ1dXJ0IGt1biBqZSBnZXdlbGRpZyBzaG9wcGVuLCBlciB6aWpuIHRhbGxvemUgaG90c3BvdHMsIGNvY2t0YWlsYmFycyBlbiBvbSBkZSBob2VrIGJlZ2ludCBDaGluYXRvd24uWy92Y19jb2x1bW5fdGV4dF1bdGhiX2ljb25saXN0IGljb249XCJmYXMgZmEtbWFwLW1hcmtlci1hbHRcIiBsaXN0X2NvbnRlbnQ9XCJUb3Bsb2NhdGllIGluIFNvSG9cIl1bdGhiX2ljb25saXN0IGljb249XCJmYXMgZmEtd2lmaVwiIGxpc3RfY29udGVudD1cIkdyYXRpcyBXaUZpXCJdW3RoYl9pY29ubGlzdCBpY29uPVwiZmFzIGZhLWdsYXNzLWNoZWVyc1wiIGxpc3RfY29udGVudD1cIkJhclwiXVt0aGJfaWNvbmxpc3QgaWNvbj1cImZhcyBmYS1iaW5vY3VsYXJzXCIgbGlzdF9jb250ZW50PVwiUm9vZnRvcFwiXVt0aGJfaWNvbmxpc3QgaWNvbj1cImZhcyBmYS1iZWRcIiBsaXN0X2NvbnRlbnQ9XCJDb21mb3J0YWJlbGUgYmVkZGVuXCJdW3RoYl9pY29ubGlzdCBpY29uPVwiZmFzIGZhLXJ1bm5pbmdcIiBsaXN0X2NvbnRlbnQ9XCJHeW1cIl1bdGhiX2ljb25saXN0IGljb249XCJmYXMgZmEtdXRlbnNpbHNcIiBsaXN0X2NvbnRlbnQ9XCJSZXN0YXVyYW50XCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjI1cHhcIl1bdWx0X2J1dHRvbnMgYnRuX3RpdGxlPVwiQm9layBlZW4ga2FtZXJcIiBidG5fbGluaz1cInVybDpodHRwcyUzQSUyRiUyRnd3dy5ib29raW5nLmNvbSUyRmhvdGVsJTJGdXMlMkZub21vLXNvaG8uZW4uaHRtbCUzRmFpZCUzRDc5NTg0OTglMjZub19yb29tcyUzRDElMjZncm91cF9hZHVsdHMlM0QyJTI2bGFiZWwlM0Rob3RlbGNvbGxlY3Rpb24taG90ZWxwYWdlLW5vbW8tc29ob3x0aXRsZTpCb2VrJTIwZWVuJTIwa2FtZXJ8dGFyZ2V0Ol9ibGFua1wiIGJ0bl90aXRsZV9jb2xvcj1cIiNmZmZmZmZcIiBidG5fYmdfY29sb3I9XCIjYjM0YTRjXCIgYnRuX2hvdmVyPVwidWJ0bi1ib3R0b20tYmdcIiBidG5fYmdfY29sb3JfaG92ZXI9XCIjNTMxYTIzXCIgaWNvbl9zaXplPVwiMzJcIiBidG5faWNvbl9wb3M9XCJ1YnRuLXNlcC1pY29uLWF0LWxlZnRcIiBidG5fZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgYnRuX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjBweDtcIiBidG5fbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjI1cHg7XCJdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNzVweFwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIkFuZGVyZSBob3RlbHMgaW4gTmV3IFlvcmsgQ2l0eTpcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjYjM0YTRjXCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjQ1cHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDo1MHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMjVweFwiXVt0aGJfcG9zdGdyaWQgc3R5bGU9XCJzdHlsZTRcIiBjb2x1bW5zPVwiNFwiIHNvdXJjZT1cInNpemU6OHxwb3N0X3R5cGU6cG9zdHxjYXRlZ29yaWVzOjEwOVwiXVsvdmNfY29sdW1uXVsvdmNfcm93XSIsInBvc3RfdGl0bGUiOiJOb01vIFNvSG8iLCJwb3N0X2xpbmsiOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL2hvdGVscy9vdmVybmFjaHRlbi1pbi1uZXcteW9yay1jaXR5L25vbW8tc29oby8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJFZW4ga2FtZXIgaW4gaGV0ICN3b3cgaG90ZWwgTm9NbyBTb0hvIGluIE5ldyBZb3JrIENpdHkuXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMDBcIiBzcmM9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIzLzAyL05vbW8tU29oby1QcmVtaXVtLUtpbmctMzAweDIwMC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj4iLCJwb3N0X2NhdGVnb3JpZXMiOiJPdmVybmFjaHRlbiBpbiBOZXcgWW9yayBDaXR5IiwicG9zdF90YWdzIjoiTmV3IFlvcmsiLCIlaW5saW5lX2ZlYXR1cmVkX2ltYWdlJSI6IjAiLCIlX2VkaXRfbG9jayUiOiIxNzE0NTcwNjY5OjIiLCIlX2VkaXRfbGFzdCUiOiIyIiwiJV95b2FzdF93cHNlb19wcmltYXJ5X2NhdGVnb3J5JSI6IjEwOSIsIiVfdGh1bWJuYWlsX2lkJSI6IjE0NzY0IiwiJV9oaWRlX2ZlYXR1cmVkJSI6bnVsbCwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6IjkgQ3Jvc2J5IFN0LCBOZXcgWW9yaywgTlkgMTAwMTMsIFZlcmVuaWdkZSBTdGF0ZW4iLCIlX3dwZ21wX2xvY2F0aW9uX2NpdHklIjoiTmV3IFlvcmsiLCIlX3dwZ21wX2xvY2F0aW9uX3N0YXRlJSI6Ik5ldyBZb3JrIiwiJV93cGdtcF9sb2NhdGlvbl9jb3VudHJ5JSI6IlZlcmVuaWdkZSBTdGF0ZW4iLCIlX3dwZ21wX21ldGFib3hfbGF0aXR1ZGUlIjoiNDAuNzE5ODM1MzYyOTU0OTI1IiwiJV93cGdtcF9tZXRhYm94X2xvbmdpdHVkZSUiOiItNzQuMDAwMDg0OTg2NTA4MTciLCIlX3dwZ21wX21ldGFib3hfbG9jYXRpb25fcmVkaXJlY3QlIjoibWFya2VyIiwiJV93cGdtcF9tZXRhYm94X2N1c3RvbV9saW5rJSI6IiIsIiVfd3BnbXBfbWFwX2lkJSI6ImE6MTp7aTowO3M6MTpcIjdcIjt9IiwiJV93cGdtcF9tZXRhYm94X21hcmtlcl9pZCUiOiJhOjE6e2k6MDtzOjI6XCIxM1wiO30iLCIlX3dwZ21wX21ldGFib3hfdGF4b21vbWllc190ZXJtcyUiOiJOOyIsIiVfd3BnbXBfZXh0ZW5zaW9uc19maWVsZHMlIjoiTjsiLCIlX3dwYl92Y19qc19zdGF0dXMlIjoidHJ1ZSIsIiVfeW9hc3Rfd3BzZW9fY29udGVudF9zY29yZSUiOiI5MCIsIiVfeW9hc3Rfd3BzZW9fZm9jdXNrZXl3b3JkcyUiOiJbXSIsIiVfeW9hc3Rfd3BzZW9fa2V5d29yZHN5bm9ueW1zJSI6IltcIlwiXSIsIiVfeW9hc3Rfd3BzZW9fZXN0aW1hdGVkLXJlYWRpbmctdGltZS1taW51dGVzJSI6IjIiLCIlcG9zdC1wcmltYXJ5LWNhdGVnb3J5JSI6ImF1dG8iLCIlZmVhdHVyZWRfaW1hZ2Vfb3ZlcnJpZGUlIjoib2ZmIiwiJXN0YW5kYXJkLWZlYXR1cmVkLWNyZWRpdCUiOiJCcmVubmFuIE1jTmljaG9sIC0gTm9NbyBTb0hvIiwiJWFydGljbGVfc3R5bGVfb3ZlcnJpZGUlIjoib24iLCIlcG9zdF9zdHlsZSUiOiJzdHlsZTUiLCIlcG9zdF9nYWxsZXJ5X3N0eWxlJSI6ImxpZ2h0Ym94IiwiJXBvc3RfcmV2aWV3JSI6Im9mZiIsIiVwb3N0X3Jldmlld19zdHlsZSUiOiJzdHlsZTEiLCIlcG9zdF9yZXZpZXdfYXZlcmFnZSUiOiI1MCIsIiVfeW9hc3Rfd3BzZW9fZm9jdXNrdyUiOiJtYWRlIGhvdGVsIiwiJV95b2FzdF93cHNlb19tZXRhZGVzYyUiOiJEaXQgI3dvdyBob3RlbCBzdHJhYWx0IGdsaXR0ZXIgZW4gZ2xhbW91ciB1aXQuIE1vZGVybkhhdXMgU29IbyBpcyBlZW4gaG90ZWwgXHUwMGUwIGxhIFNleCBhbmQgVGhlIENpdHkuIEVlbiBiaWp6b25kZXIgaG90ZWwgbWV0IGFsbHVyZS4iLCIlX3lvYXN0X3dwc2VvX2xpbmtkZXglIjoiNDEiLCIlcG9zdF9zb3VyY2UlIjpbeyJ0aXRsZSI6Ik5vTW8gU29IbyIsInBvc3Rfc291cmNlX3VybCI6Imh0dHBzOi8vd3d3Lm5vbW9zb2hvLmNvbSJ9XSwiJV95b2FzdF9pbmRleG5vd19sYXN0X3BpbmclIjoiMTY3ODU0NDQ3MyIsIiVfd3dzX3N1cHBvcnRfY29udGFjdF9udW1iZXIlIjoiIiwiJV93d3NfYWJvdXRfc3VwcG9ydF90ZXh0JSI6IiIsIiVfd3dzX3RyaWdnZXJfYnV0dG9uX3RleHQlIjoiIiwiJV93d3NfcHJlZGVmaW5lZF90ZXh0JSI6IiIsIiVfeW9hc3Rfd3BzZW9fd29yZHByb29mX3RpbWVzdGFtcCUiOiIiLCIlZXhlY3V0aXZlX3N1bW1hcnklIjoiRGVsZnRzIGJsYXV3IHBhc3QgYmlqIGpvdSEiLCIlX2xhc3RfZWRpdG9yX3VzZWRfamV0cGFjayUiOiJjbGFzc2ljLWVkaXRvciIsInRheG9ub215PWNhdGVnb3J5IjoiT3Zlcm5hY2h0ZW4gaW4gTmV3IFlvcmsgQ2l0eSIsInRheG9ub215PXBvc3RfdGFnIjoiTmV3IFlvcmsiLCJ0YXhvbm9teT1wb3N0X2Zvcm1hdCI6IiIsInRheG9ub215PXRoYi1yZWFjdGlvbnMiOiIiLCJ0YXhvbm9teT10aGItc3BvbnNvcnMiOiIifSwiaWNvbiI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjEvMDQvaG90ZWwucG5nIn0sImlkIjoxNDc2MywiaW5mb3dpbmRvd19kaXNhYmxlIjpmYWxzZSwiY2F0ZWdvcmllcyI6W3siaWNvbiI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjEvMDQvaG90ZWwucG5nIiwibmFtZSI6IkhvdGVscyIsImlkIjoiMTMiLCJ0eXBlIjoiY2F0ZWdvcnkiLCJleHRlbnNpb25fZmllbGRzIjp7ImNhdF9vcmRlciI6IiJ9fV19LHsic291cmNlIjoicG9zdCIsInRpdGxlIjoiSGlnaCBSb2xsZXIgaW4gTGFzIFZlZ2FzIiwiaW5mb3dpbmRvd19jb250ZW50IjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZyBcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiSGlnaCBSb2xsZXIgTGlucSBQcm9tZW5hZGVcIiB3aWR0aD1cIjMwMFwiIGhlaWdodD1cIjIwMFwiIHNyYz1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjMvMDEvaGlnaC1yb2xsZXItbGFzLXZlZ2FzLTMwMHgyMDAuanBnXCIgY2xhc3M9XCJ3cC1wb3N0LWltYWdlICAgd3BnbXBfZmVhdHVyZWRfaW1hZ2VcIiA+PC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZ1wiPlxyXG4gICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtY29udGVudC1wYWRkaW5nIGZjLWl0ZW0tbm8tcGFkZGluZ1wiPlxyXG4gICAgICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS10aXRsZSBmYy1pdGVtLXByaW1hcnktdGV4dC1jb2xvciBmYy1pdGVtLXRvcC1zcGFjZVwiPkhpZ2ggUm9sbGVyIGluIExhcyBWZWdhczwvZGl2PlxyXG4gICAgICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbS1jb250ZW50IGZjLWl0ZW0tYm9keS10ZXh0LWNvbG9yXCI+e21hcmtlcl9hZGRyZXNzfTwvZGl2PlxyXG4gICAgICAgIDwvZGl2PlxyXG4gICAgPC9kaXY+XHJcbiAgICA8ZGl2IGNsYXNzPVwiZmMtY2xlYXJcIj48L2Rpdj5cclxuPC9kaXY+IiwiY29udGVudCI6IkJvb3R0b2NodCB2YW4gOTAgbWludXRlbiBvdmVyIGRlIEh1ZHNvbiBlbiBFYXN0IFJpdmVyIiwiYWRkcmVzcyI6IjM1NDUgUyBMYXMgVmVnYXMgQmx2ZCwgTGFzIFZlZ2FzLCBOViA4OTEwOSwgVmVyZW5pZ2RlIFN0YXRlbiIsImxvY2F0aW9uIjp7ImxhdCI6IjM2LjExNzYzMjQiLCJjaXR5IjoiTGFzIFZlZ2FzIiwic3RhdGUiOiJOZXZhZGEiLCJjb3VudHJ5IjoiVmVyZW5pZ2RlIFN0YXRlbiIsImxuZyI6Ii0xMTUuMTY4Mjk0Iiwib25jbGlja19hY3Rpb24iOiJtYXJrZXIiLCJyZWRpcmVjdF9wZXJtYWxpbmsiOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL2hpZ2gtcm9sbGVyLWxhcy12ZWdhcy8iLCJ6b29tIjoxMiwiZXh0cmFfZmllbGRzIjp7InBvc3RfZXhjZXJwdCI6IkJvb3R0b2NodCB2YW4gOTAgbWludXRlbiBvdmVyIGRlIEh1ZHNvbiBlbiBFYXN0IFJpdmVyIiwicG9zdF9jb250ZW50IjoiW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIl1bdmNfY29sdW1uIHdpZHRoPVwiMS8yXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG5cclxuWy92Y19jb2x1bW5fdGV4dF1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiODUlXCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvMlwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzMHB4XCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJIaWdoIFJvbGxlclwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZTozNXx0ZXh0X2FsaWduOmxlZnR8Y29sb3I6JTIzMDAwMDAwfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XVZhbiB2ZXJyZSB6aWUgamUgaGVtIGFsIGJvdmVuIGRlIExpbnEgUHJvbWVuYWRlIHVpdHN0ZWtlbjsgZGUgSGlnaCBSb2xsZXIuIEhldCByZXV6ZW5yYWQgaXMgZWVuIHZhbiBkZSBncm9vdHN0ZSB0ZXIgd2VyZWxkIGVuIG5hdHV1cmxpamsga2FuIGVyIGluIExhcyBWZWdhcyBuaWV0IGVlbiBvbnRicmVrZW4uIE1ldCBlZW4gaG9vZ3RlIHZhbiAxNjggbWV0ZXIgZ2VlZnQgZGUgSGlnaCBSb2xsZXIgbmF0dXVybGlqayBwcmFjaHRpZ2UgcGFub3JhbWlzY2hlIHVpdHppY2h0ZW4gb3ZlciBWZWdhcy4gRWVuIHZhbiBkZSBkaW5nZW4gb20gdG9lIHRlIHZvZWdlbiBhYW4gamUgbGlqc3RqZSBtZXQgYmV6aWVuc3dhYXJkaWdoZWRlbiBpbiBMYXMgVmVnYXMuWy92Y19jb2x1bW5fdGV4dF1bdWx0aW1hdGVfaWNvbl9saXN0IGljb25fc2l6ZT1cIjE4XCIgaWNvbl9tYXJnaW49XCIxNVwiXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtZG9sbGFyIHVzZFwiXVZhbmFmICQyMyB2b29yIGVlbiB2b2x3YXNzZW5lWy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLWRvbGxhciB1c2RcIl1WYW5hZiAkOCw1MCB2b29yIGVlbiBraW5kWy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bL3VsdGltYXRlX2ljb25fbGlzdF1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW5dW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IGJnX3R5cGU9XCJiZ19jb2xvclwiIGJnX2NvbG9yX3ZhbHVlPVwiI2VkZWRlZFwiIGNzcz1cIi52Y19jdXN0b21fMTYxMjk0OTUzNzU2NHtiYWNrZ3JvdW5kLWNvbG9yOiAjZWRlZGVkICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMi8zXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJIaWdoIFJvbGxlciBMYXMgVmVnYXNcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MzV8dGV4dF9hbGlnbjpjZW50ZXJ8Y29sb3I6JTIzMDAwMDAwXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1IZWIgamUgZ2VlbiBob29ndGV2cmVlcz8gU3RhcCBkYW4gaW4gaGV0IHJldXplbnJhZCBvbSBMYXMgVmVnYXMgdmFudWl0IGRlIGx1Y2h0IHRlIGJla2lqa2VuLiBJbiBvbmdldmVlciAzMCBtaW51dGVuIHppZSBqZSBkZSBjb250b3VyZW4gdmFuIGRlIHN0YWQgZGllIG9tcmluZ2Qgd29yZHQgZG9vciBlZW4gd29lc3Rpam5sYW5kc2NoYXAuIEFhbiBoZXQgcmV1emVucmFkIHppdHRlbiAyOCBjYWJpbnMgdmFud2FhcnVpdCBqZSBlZW4gMzYwIGdyYWRlbiBvdmVyemljaHQgaGVidC4gSW4gem8nbiBjYWJpbiBrdW5uZW4gbWF4aW1hYWwgNDAgcGVyc29uZW4uIFRpamRlbnMgaGV0IHJvbmRqZSBob29yIGplIHZpYSBlZW4gdHYgaW5mb3JtYXRpZSBvdmVyIHdhdCBqZSBpbiBkZSBvbWdldmluZyB6aWV0LiBKZSB2aW5kdCBUaGUgSGlnaCBSb2xsZXIgb3AgZGUgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvbGlucS1wcm9tZW5hZGUvXCI+TGlucSBQcm9tZW5hZGU8L2E+LiBFZW4gcGxlayBuZXQgYnVpdGVuIFRoZSBTdHJpcCB3YWFyIGplIGt1bnQgc2hvcHBlbiwgbGVra2VyIHVpdCBldGVuIGt1bnQgZW4ga3VudCBnZW5pZXRlbiB2YW4gYWN0aXZpdGVpdGVuIG9mIHNob3dzLlsvdmNfY29sdW1uX3RleHRdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiIGZ1bGxfd2lkdGg9XCJzdHJldGNoX3Jvd1wiIGNvbnRlbnRfdGV4dF9hbGlnbWVudD1cImNlbnRlclwiIGNzcz1cIi52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O31cIiBwYXJhbGxheF9iYWNrZ3JvdW5kX2ltYWdlPVwiMzgzNlwiXVt2Y19jb2x1bW4gdGhiX2NvbG9yPVwidGhiLWxpZ2h0LWNvbHVtblwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkhpZ2ggUm9sbGVyIExhcyBWZWdhc1wiIGZvbnRfY29udGFpbmVyPVwidGFnOmRpdnxmb250X3NpemU6NzV8dGV4dF9hbGlnbjpjZW50ZXJ8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIlN0YXAgaW4gXHUwMGU5XHUwMGU5biB2YW4gZGUgMjggY2FiaW5zIG9tIExhcyBWZWdhcyB0ZSBiZWtpamtlblwiIGZvbnRfY29udGFpbmVyPVwidGFnOmRpdnxmb250X3NpemU6NDV8dGV4dF9hbGlnbjpjZW50ZXJcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpEYW5jaW5nJTIwU2NyaXB0JTNBcmVndWxhciUyQzcwMHxmb250X3N0eWxlOjcwMCUyMGJvbGQlMjByZWd1bGFyJTNBNzAwJTNBbm9ybWFsXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3BhcmFsbGF4X3JvdyBlbmFibGVfbW9iaWxlPVwicGFyYWxsYXgtZW5hYmxlLW1vYmlsZVwiIGltYWdlPVwiMTQ2NjJcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW5dW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW4gd2lkdGg9XCIyLzNcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJUaWNrZXRzIHZvb3IgZGUgSGlnaCBSb2xsZXJcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MzB8dGV4dF9hbGlnbjpsZWZ0fGNvbG9yOiUyMzAwMDAwMHxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1FciB6aWpuIHR3ZWUgdmVyc2NoaWxsZW5kZSBzb29ydGVuIHRpY2tldHMgdm9vciBUaGUgSGlnaCBSb2xsZXI7IGRhZyB0aWNrZXRzIGVuIGFueXRpbWUvbmlnaHR0aW1lIHRpY2tldHMuIEplIGt1bnQgamUgdGlja2V0cyB2YW4gdGUgdm9yZW4gb25saW5lIGtvcGVuLlsvdmNfY29sdW1uX3RleHRdW3VsdF9idXR0b25zIGJ0bl90aXRsZT1cIkJlc3RlbCBqZSB0aWNrZXRzXCIgYnRuX2xpbms9XCJ1cmw6aHR0cHMlM0ElMkYlMkZ3d3cuZ2V0eW91cmd1aWRlLmNvbSUyRmxhcy12ZWdhcy1sNTglMkZ0aGUtaGlnaC1yb2xsZXItcmlkZS1hdC10aGUtbGlucS10aWNrZXQtdDI3MDUyMiUyRiUzRnBhcnRuZXJfaWQlM0RETUQyVkw0JTI2dXRtX21lZGl1bSUzRG9ubGluZV9wdWJsaXNoZXIlMjZwbGFjZW1lbnQlM0QlMjUyMm90aGVyJTI1MjIlMjZjbXAlM0RoaWdocm9sbGVybGFzdmVnYXNcIiBidG5fc2l6ZT1cInVidG4tbGFyZ2VcIiBidG5fdGl0bGVfY29sb3I9XCIjZmZmZmZmXCIgYnRuX2JnX2NvbG9yPVwiI2IzNGE0Y1wiIGJ0bl9ob3Zlcj1cInVidG4tbGVmdC1iZ1wiIGJ0bl9iZ19jb2xvcl9ob3Zlcj1cIiM1MzFhMjNcIiBidG5fdGl0bGVfY29sb3JfaG92ZXI9XCIjZmZmZmZmXCIgaWNvbl9zaXplPVwiMzJcIiBidG5faWNvbl9wb3M9XCJ1YnRuLXNlcC1pY29uLWF0LWxlZnRcIiBidG5fZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgYnRuX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MTVweDtcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIlRpY2tldHMgdm9vciBUaGUgSGlnaCBSb2xsZXIgbWV0IEhhcHB5IEhvdXJcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MzB8dGV4dF9hbGlnbjpsZWZ0fGNvbG9yOiUyMzAwMDAwMHxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1UaWpkZW5zIGhldCBzcGVjdGFjdWxhaXJlIHVpdHppY2h0IGdlbmlldGVuIG1ldCBlZW4gZHJhbmtqZT8gRGFuIGt1biBqZSBzcGVjaWFsZSB0aWNrZXRzIGtvcGVuIHZvb3IgVGhlIEhpZ2ggUm9sbGVyIG1ldCBlZW4gSGFwcHkgSG91ci4gVGlqZGVucyBkZSByaXQgaGViIGplIG9uYmVwZXJrdCB0b2VnYW5nIHRvdCBkcmFua2plcy5bL3ZjX2NvbHVtbl90ZXh0XVt1bHRfYnV0dG9ucyBidG5fdGl0bGU9XCJCZXN0ZWwgamUgSGFwcHkgSG91ciB0aWNrZXRzXCIgYnRuX2xpbms9XCJ1cmw6aHR0cHMlM0ElMkYlMkZ3d3cuZ2V0eW91cmd1aWRlLmNvbSUyRmxhcy12ZWdhcy1sNTglMkZ0aGUtaGlnaC1yb2xsZXItcmlkZS1hdC10aGUtbGlucS10aWNrZXQtdDQzNjczNSUyRiUzRnBhcnRuZXJfaWQlM0RETUQyVkw0JTI2dXRtX21lZGl1bSUzRG9ubGluZV9wdWJsaXNoZXIlMjZwbGFjZW1lbnQlM0QlMjUyMm90aGVyJTI1MjIlMjZjbXAlM0RoaWdocm9sbGVybGFzdmVnYXNoYXBweWhvdXJcIiBidG5fc2l6ZT1cInVidG4tbGFyZ2VcIiBidG5fdGl0bGVfY29sb3I9XCIjZmZmZmZmXCIgYnRuX2JnX2NvbG9yPVwiI2IzNGE0Y1wiIGJ0bl9ob3Zlcj1cInVidG4tbGVmdC1iZ1wiIGJ0bl9iZ19jb2xvcl9ob3Zlcj1cIiM1MzFhMjNcIiBidG5fdGl0bGVfY29sb3JfaG92ZXI9XCIjZmZmZmZmXCIgaWNvbl9zaXplPVwiMzJcIiBidG5faWNvbl9wb3M9XCJ1YnRuLXNlcC1pY29uLWF0LWxlZnRcIiBidG5fZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgYnRuX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MTVweDtcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS8zXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJQcmFrdGlzY2hlIGluZm9ybWF0aWVcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MzB8dGV4dF9hbGlnbjpsZWZ0fGNvbG9yOiUyMzAwMDAwMHxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt1bHRpbWF0ZV9pY29uX2xpc3QgaWNvbl9zaXplPVwiMThcIiBpY29uX21hcmdpbj1cIjE1XCJdW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy1tYXAtbWFya2VyXCJdPHN0cm9uZz4zNTQ1IFMgTGFzIFZlZ2FzIEJsdmQ8L3N0cm9uZz5bL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtY2xvY2stb1wiXTxzdHJvbmc+TWFhbmRhZyAtIGRvbmRlcmRhZzogMTQuMDAtMDAuMDAgdXVyXHJcblZyaWpkYWcgLSB6b25kYWc6IDEyLjAwLTAwLjAwIHV1cjwvc3Ryb25nPlsvdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dWy91bHRpbWF0ZV9pY29uX2xpc3RdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiIGZ1bGxfd2lkdGg9XCJzdHJldGNoX3Jvd1wiIGNvbnRlbnRfdGV4dF9hbGlnbWVudD1cImNlbnRlclwiIGNzcz1cIi52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O31cIiBwYXJhbGxheF9iYWNrZ3JvdW5kX2ltYWdlPVwiMzgzNlwiXVt2Y19jb2x1bW4gdGhiX2NvbG9yPVwidGhiLWxpZ2h0LWNvbHVtblwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIlVpdHppY2h0IG92ZXIgTGFzIFZlZ2FzXCIgZm9udF9jb250YWluZXI9XCJ0YWc6ZGl2fGZvbnRfc2l6ZTo3NXx0ZXh0X2FsaWduOmNlbnRlcnxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jdXN0b21faGVhZGluZyB0ZXh0PVwiQmVraWprIGRlIGNvbnRvdXJlbiB2YW4gZGUgc3RhZFwiIGZvbnRfY29udGFpbmVyPVwidGFnOmRpdnxmb250X3NpemU6NDV8dGV4dF9hbGlnbjpjZW50ZXJcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpEYW5jaW5nJTIwU2NyaXB0JTNBcmVndWxhciUyQzcwMHxmb250X3N0eWxlOjcwMCUyMGJvbGQlMjByZWd1bGFyJTNBNzAwJTNBbm9ybWFsXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3BhcmFsbGF4X3JvdyBlbmFibGVfbW9iaWxlPVwicGFyYWxsYXgtZW5hYmxlLW1vYmlsZVwiIGltYWdlPVwiMTQ2NjRcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IHRoYl9mdWxsX3dpZHRoPVwidHJ1ZVwiXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMi8zXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiTWVlciBmb3RvJ3MgdmFuIGRlIEhpZ2ggUm9sbGVyXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiI2IzNGE0Y1wiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjQ1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NTBweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3RoYl9pbWFnZV9zbGlkZXIgaW1hZ2VzPVwiMTQ2NjMsMTQ2NjEsMTQ2NjYsMTQ2NjdcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVsvdmNfY29sdW1uXVt2Y19jb2x1bW4gd2lkdGg9XCIxLzZcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93XVt2Y19jb2x1bW5dW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJBbmRlcmUgbGV1a2UgYXJ0aWtlbGVuXCIgZm9udF9jb250YWluZXI9XCJ0YWc6ZGl2fGZvbnRfc2l6ZTo1NXx0ZXh0X2FsaWduOmNlbnRlcnxjb2xvcjolMjMwMDAwMDBcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bdGhiX3Bvc3RncmlkIHN0eWxlPVwic3R5bGUyMFwiIGNvbHVtbnM9XCI0XCIgc291cmNlPVwicG9zdF90eXBlOnBvc3R8YnlfaWQ6MTQ0MDYsMTM3NjEsMTI1ODQsMjM4OFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XSIsInBvc3RfdGl0bGUiOiJIaWdoIFJvbGxlciBpbiBMYXMgVmVnYXMiLCJwb3N0X2xpbmsiOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL2hpZ2gtcm9sbGVyLWxhcy12ZWdhcy8iLCJwb3N0X2ZlYXR1cmVkX2ltYWdlIjoiPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJIaWdoIFJvbGxlciBMaW5xIFByb21lbmFkZVwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMy8wMS9oaWdoLXJvbGxlci1sYXMtdmVnYXMtMzAweDIwMC5qcGdcIiBjbGFzcz1cIndwLXBvc3QtaW1hZ2UgICB3cGdtcF9mZWF0dXJlZF9pbWFnZVwiID48L2Rpdj4iLCJwb3N0X2NhdGVnb3JpZXMiOiJCZXppZW5zd2FhcmRpZ2hlZGVuIExhcyBWZWdhcyIsInBvc3RfdGFncyI6Ik5ldmFkYSIsIiVfd3BiX3Nob3J0Y29kZXNfY3VzdG9tX2NzcyUiOiIudmNfY3VzdG9tXzE2MTI5NDk1Mzc1NjR7YmFja2dyb3VuZC1jb2xvcjogI2VkZWRlZCAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE1ODI5MDY4ODI5MTd7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDt9LnZjX2N1c3RvbV8xNTgyOTA2ODgyOTE3e3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7fSIsIiVfZWRpdF9sYXN0JSI6IjEiLCIlX2VkaXRfbG9jayUiOiIxNjc1MzMyNzg4OjIiLCIlX3dwYl92Y19qc19zdGF0dXMlIjoidHJ1ZSIsIiVwb3N0LXByaW1hcnktY2F0ZWdvcnklIjoiNjUiLCIlZmVhdHVyZWRfaW1hZ2Vfb3ZlcnJpZGUlIjoib2ZmIiwiJWFydGljbGVfc3R5bGVfb3ZlcnJpZGUlIjoib24iLCIlcG9zdF9zdHlsZSUiOiJzdHlsZTUiLCIlcG9zdF9nYWxsZXJ5X3N0eWxlJSI6ImxpZ2h0Ym94IiwiJXBvc3RfcmV2aWV3JSI6Im9mZiIsIiVwb3N0X3Jldmlld19zdHlsZSUiOiJzdHlsZTEiLCIlcG9zdF9yZXZpZXdfYXZlcmFnZSUiOiI1MCIsIiVzdGFuZGFyZC1mZWF0dXJlZC1jcmVkaXQlIjoiIiwiJV9oaWRlX2ZlYXR1cmVkJSI6bnVsbCwiJXBvc3Rfc291cmNlJSI6IiIsIiVfdGh1bWJuYWlsX2lkJSI6IjE0NDExIiwiJV95b2FzdF93cHNlb19mb2N1c2t3JSI6IkhpZ2ggUm9sbGVyIiwiJV95b2FzdF93cHNlb190aXRsZSUiOiJIaWdoIFJvbGxlciBMYXMgVmVnYXMgJSVwYWdlJSUgJSVzZXAlJSAlJXNpdGVuYW1lJSUiLCIlX3lvYXN0X3dwc2VvX21ldGFkZXNjJSI6IkhldCByZXV6ZW5yYWQgb3AgZGUgTGlucSBQcm9tZW5hZGUga2FuIG5pZXQgb250YnJla2VuIHRpamRlbnMgZWVuIGJlem9layBhYW4gTGFzIFZlZ2FzLiBCZWtpamsgaGllciBkZSB0aWNrZXRzIHZvb3IgVGhlIEhpZ2ggUm9sbGVyIExhcyBWZWdhcyIsIiVfeW9hc3Rfd3BzZW9fbGlua2RleCUiOiIzNiIsIiVfeW9hc3Rfd3BzZW9fY29udGVudF9zY29yZSUiOiIzMCIsIiVfeW9hc3Rfd3BzZW9fZm9jdXNrZXl3b3JkcyUiOiJbXSIsIiVfeW9hc3Rfd3BzZW9fa2V5d29yZHN5bm9ueW1zJSI6IltcIkhpZ2ggUm9sbGVyIExhcyBWZWdhc1wiXSIsIiVpbmxpbmVfZmVhdHVyZWRfaW1hZ2UlIjoiMCIsIiVfd3BnbXBfbG9jYXRpb25fYWRkcmVzcyUiOiIzNTQ1IFMgTGFzIFZlZ2FzIEJsdmQsIExhcyBWZWdhcywgTlYgODkxMDksIFZlcmVuaWdkZSBTdGF0ZW4iLCIlX3dwZ21wX2xvY2F0aW9uX2NpdHklIjoiTGFzIFZlZ2FzIiwiJV93cGdtcF9sb2NhdGlvbl9zdGF0ZSUiOiJOZXZhZGEiLCIlX3dwZ21wX2xvY2F0aW9uX2NvdW50cnklIjoiVmVyZW5pZ2RlIFN0YXRlbiIsIiVfd3BnbXBfbWV0YWJveF9sYXRpdHVkZSUiOiIzNi4xMTc2MzI0IiwiJV93cGdtcF9tZXRhYm94X2xvbmdpdHVkZSUiOiItMTE1LjE2ODI5NCIsIiVfd3BnbXBfbWV0YWJveF9sb2NhdGlvbl9yZWRpcmVjdCUiOiJtYXJrZXIiLCIlX3dwZ21wX21ldGFib3hfY3VzdG9tX2xpbmslIjoiIiwiJV93cGdtcF9tYXBfaWQlIjoiYToxOntpOjA7czoxOlwiN1wiO30iLCIlX3dwZ21wX21ldGFib3hfbWFya2VyX2lkJSI6ImE6MTp7aTowO3M6MTpcIjVcIjt9IiwiJV93cGdtcF9tZXRhYm94X3RheG9tb21pZXNfdGVybXMlIjoiTjsiLCIlX3dwZ21wX2V4dGVuc2lvbnNfZmllbGRzJSI6Ik47IiwiJV95b2FzdF93cHNlb19lc3RpbWF0ZWQtcmVhZGluZy10aW1lLW1pbnV0ZXMlIjoiMyIsIiVfd3dzX3N1cHBvcnRfY29udGFjdF9udW1iZXIlIjoiIiwiJV93d3NfYWJvdXRfc3VwcG9ydF90ZXh0JSI6IiIsIiVfd3dzX3RyaWdnZXJfYnV0dG9uX3RleHQlIjoiIiwiJV93d3NfcHJlZGVmaW5lZF90ZXh0JSI6IiIsIiVfeW9hc3Rfd3BzZW9fd29yZHByb29mX3RpbWVzdGFtcCUiOiIiLCIlX3lvYXN0X3dwc2VvX3ByaW1hcnlfY2F0ZWdvcnklIjoiNTQiLCIlX3lvYXN0X2luZGV4bm93X2xhc3RfcGluZyUiOiIxNjc3MDE0ODQyIiwiJV9sYXN0X2VkaXRvcl91c2VkX2pldHBhY2slIjoiY2xhc3NpYy1lZGl0b3IiLCJ0YXhvbm9teT1jYXRlZ29yeSI6IkJlemllbnN3YWFyZGlnaGVkZW4gTGFzIFZlZ2FzIiwidGF4b25vbXk9cG9zdF90YWciOiJOZXZhZGEiLCJ0YXhvbm9teT1wb3N0X2Zvcm1hdCI6IiIsInRheG9ub215PXRoYi1yZWFjdGlvbnMiOiIiLCJ0YXhvbm9teT10aGItc3BvbnNvcnMiOiIifSwiaWNvbiI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvd3AtY29udGVudC91cGxvYWRzLzIwMjEvMDQvYmV6aWVuc3dhYXJkaWdoZWlkLnBuZyJ9LCJpZCI6MTQ2NjAsImluZm93aW5kb3dfZGlzYWJsZSI6ZmFsc2UsImNhdGVnb3JpZXMiOlt7Imljb24iOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIxLzA0L2JlemllbnN3YWFyZGlnaGVpZC5wbmciLCJuYW1lIjoiQmV6aWVuc3dhYXJkaWdoZWRlbiIsImlkIjoiNSIsInR5cGUiOiJjYXRlZ29yeSIsImV4dGVuc2lvbl9maWVsZHMiOnsiY2F0X29yZGVyIjoiIn19XX0seyJzb3VyY2UiOiJwb3N0IiwidGl0bGUiOiJab24sIHplZSAmIzAzODsgc3RyYW5kIGluIEJyb29rbHluIiwiaW5mb3dpbmRvd19jb250ZW50IjoiPGRpdiBjbGFzcz1cImZjLWl0ZW0tYm94IGZjLWl0ZW0tbm8tcGFkZGluZyBcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiQ29uZXkgSXNsYW5kXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMjVcIiBzcmM9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIzLzAxL2NvbmV5LWlzbGFuZC1iZWFjaC0zMDB4MjI1LmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmdcIj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZyBmYy1pdGVtLW5vLXBhZGRpbmdcIj5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tdGl0bGUgZmMtaXRlbS1wcmltYXJ5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2VcIj5ab24sIHplZSAmIzAzODsgc3RyYW5kIGluIEJyb29rbHluPC9kaXY+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3JcIj57bWFya2VyX2FkZHJlc3N9PC9kaXY+XHJcbiAgICAgICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1jbGVhclwiPjwvZGl2PlxyXG48L2Rpdj4iLCJhZGRyZXNzIjoiMTA3MSA1dGggQXZlLCBOZXcgWW9yaywgTlkgMTAxMjgsIFZlcmVuaWdkZSBTdGF0ZW4iLCJsb2NhdGlvbiI6eyJsYXQiOiI0MC43ODI5Nzk2IiwiY2l0eSI6Ik5ldyBZb3JrIiwic3RhdGUiOiJOZXcgWW9yayIsImNvdW50cnkiOiJWZXJlbmlnZGUgU3RhdGVuIiwibG5nIjoiLTczLjk1ODk3MDYiLCJvbmNsaWNrX2FjdGlvbiI6Im1hcmtlciIsInJlZGlyZWN0X3Blcm1hbGluayI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvc3RyYW5kZW4tYnJvb2tseW4vIiwiem9vbSI6MTIsImV4dHJhX2ZpZWxkcyI6eyJwb3N0X2V4Y2VycHQiOiIiLCJwb3N0X2NvbnRlbnQiOiJbdmNfcm93XVt2Y19jb2x1bW5dW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19yb3dfaW5uZXJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvMlwiXVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzJcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMjVweFwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIlpvbiwgemVlICZhbXA7IHN0cmFuZCBpbiBCcm9va2x5blwiIG1haW5faGVhZGluZ19jb2xvcj1cIiMyODI4MjhcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjI1cHg7XCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozMHB4O1wiIG1hcmdpbl9kZXNpZ25fdGFiX3RleHQ9XCJcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2NvbHVtbl90ZXh0XTxzdHJvbmc+RGUgem9tZXJzIGluIE5ldyBZb3JrIHppam4gd2FybSwgdGVtcGVyYXR1cmVuIGJvdmVuIGRlIDM1IGdyYWRlbiB6aWpuIGdlZW4gdWl0em9uZGVyaW5nLiBEZSBtZWVzdGUgbG9jYWxzIGtpZXplbiBlcnZvb3Igb20gZGUgc3RhZCB0ZSB2ZXJsYXRlbi4gR2VsdWtraWcga3VubmVuIGRlIGFjaHRlcmJsaWp2ZXJzIHJpY2h0aW5nIGRlIHN0cmFuZGVuIHZhbiBOZXcgWW9yay4gU3RyYW5kZW4/IEluIEJyb29rbHluIHppam4gZXIgMyBwbGVra2VuIHdhYXIgamUga3VudCBnZW5pZXRlbiB2YW4gem9uLCB6ZWUgZW4gc3RyYW5kLlx1MDBhMDwvc3Ryb25nPlxyXG5cclxuPHN0cm9uZz5cdTAwYTA8L3N0cm9uZz5bL3ZjX2NvbHVtbl90ZXh0XVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIyNXB4XCJdWy92Y19jb2x1bW5faW5uZXJdWy92Y19yb3dfaW5uZXJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiIGZ1bGxfd2lkdGg9XCJzdHJldGNoX3Jvd1wiIGNvbnRlbnRfdGV4dF9hbGlnbWVudD1cImNlbnRlclwiIGNzcz1cIi52Y19jdXN0b21fMTU4NzY1OTI5OTA3MXtwYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O2JhY2tncm91bmQtY29sb3I6ICMwMDAwMDAgIWltcG9ydGFudDt9XCIgcGFyYWxsYXhfYmFja2dyb3VuZF9pbWFnZT1cIjM4MzZcIl1bdmNfY29sdW1uIHRoYl9jb2xvcj1cInRoYi1saWdodC1jb2x1bW5cIl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiTWFuaGF0dGFuIEJlYWNoXCIgaGVhZGluZ190YWc9XCJwXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiI2ZmZmZmZlwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjY1cHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NzBweDtcIiBtYXJnaW5fZGVzaWduX3RhYl90ZXh0PVwiXCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIkhldCBtb29pc3RlIHN0cmFuZCB2YW4gQnJvb2tseW4/XCIgaGVhZGluZ190YWc9XCJkaXZcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjZmZmZmZmXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6NDVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpEYW5jaW5nIFNjcmlwdHxmb250X2NhbGw6RGFuY2luZytTY3JpcHR8dmFyaWFudDo3MDBcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjUwcHg7XCIgbWFpbl9oZWFkaW5nX3N0eWxlPVwiZm9udC13ZWlnaHQ6NzAwO1wiIG1hcmdpbl9kZXNpZ25fdGFiX3RleHQ9XCJcIl1bL3VsdGltYXRlX2hlYWRpbmddW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjM1MHB4XCJdW3BhcmFsbGF4X3JvdyBvcGFjaXR5PVwiODVcIiBlbmFibGVfbW9iaWxlPVwicGFyYWxsYXgtZW5hYmxlLW1vYmlsZVwiIGltYWdlPVwiMTQ1MThcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd11bdmNfcm93IGNzcz1cIi52Y19jdXN0b21fMTQ3MjMwNzUwMjI5MHtwYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O3BhZGRpbmctYm90dG9tOiAyNXB4ICFpbXBvcnRhbnQ7fVwiXVt2Y19jb2x1bW5dW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI3NXB4XCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiU3RyYW5kZW4gaW4gQnJvb2tseW5cIiBoZWFkaW5nX3RhZz1cInBcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjYjM0YTRjXCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6NTVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDo2MHB4O1wiIG1hcmdpbl9kZXNpZ25fdGFiX3RleHQ9XCJcIl1bL3VsdGltYXRlX2hlYWRpbmddW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiRGUgcGxlayBvbSBldmVuIGFmIHRlIGtvZWxlbiBpbiBkZSB6b21lclwiIG1haW5faGVhZGluZ19jb2xvcj1cIiMyODI4MjhcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDo0NXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OlJvYm90byBTbGFifGZvbnRfY2FsbDpSb2JvdG8rU2xhYnx2YXJpYW50OjMwMFwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NTBweDtcIiBtYWluX2hlYWRpbmdfc3R5bGU9XCJmb250LXdlaWdodDozMDA7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI3NXB4XCJdW3ZjX3Jvd19pbm5lciBjc3M9XCIudmNfY3VzdG9tXzE1ODI5NzA3MDQ5MDN7cGFkZGluZy10b3A6IDEwcHggIWltcG9ydGFudDtwYWRkaW5nLXJpZ2h0OiAxMHB4ICFpbXBvcnRhbnQ7cGFkZGluZy1ib3R0b206IDEwcHggIWltcG9ydGFudDtwYWRkaW5nLWxlZnQ6IDEwcHggIWltcG9ydGFudDt9XCJdW3ZjX2NvbHVtbl9pbm5lciB3aWR0aD1cIjEvM1wiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIkJyaWdodG9uIEJlYWNoXCIgaGVhZGluZ190YWc9XCJoM1wiIG1haW5faGVhZGluZ19jb2xvcj1cIiMyMjM2NTZcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDozMHB4O1wiIG1hcmdpbl9kZXNpZ25fdGFiX3RleHQ9XCJcIl1bL3VsdGltYXRlX2hlYWRpbmddW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiQnJvb2tseW5cIiBoZWFkaW5nX3RhZz1cInBcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjYjM0YTRjXCIgYWxpZ25tZW50PVwibGVmdFwiIG1haW5faGVhZGluZ19mb250X3NpemU9XCJkZXNrdG9wOjIwcHg7XCIgbWFpbl9oZWFkaW5nX2ZvbnRfZmFtaWx5PVwiZm9udF9mYW1pbHk6QWxmYSBTbGFiIE9uZXxmb250X2NhbGw6QWxmYStTbGFiK09uZVwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6MjFweDtcIl1bL3VsdGltYXRlX2hlYWRpbmddW3VsdGltYXRlX2ljb25fbGlzdCBpY29uX3NpemU9XCIxOFwiIGljb25fbWFyZ2luPVwiMTVcIl1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLW1hcC1tYXJrZXJcIl08c3Ryb25nPkJyaWdodG9uIEJlYWNoPC9zdHJvbmc+Wy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLXN1YndheVwiXTxzdHJvbmc+RGVrYWxiIEF2ZW51ZSB8IFEgfCBCPC9zdHJvbmc+Wy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bL3VsdGltYXRlX2ljb25fbGlzdF1bdmNfY29sdW1uX3RleHRdSW4gaGV0IHp1aWRlbGlqa2UgZ2VkZWVsdGUgdmFuIEJyb29rbHluLCBncmVuemVuZCBhYW4gQ29uZXkgSXNsYW5kLCBsaWd0IEJyaWdodG9uIEJlYWNoLiBPb2l0IGluIDE2NDUgZ2Vrb2NodCB2YW4gZGUgaW5kaWFuZW4gdm9vciBlZW4gcGlzdG9vbCwgZWVuIGRla2VuIGVuIGVlbiB3YXRlcmtva2VyLiBEZXN0aWpkcyB2b29yYWwgZWVuIHRlcnJlaW4gdm9sIHphbmQgd2FhciBkaXZlcnNlIGJvZXJkZXJpamVuIG9wIHN0b25kZW4uIEluIDE4Njggd2VyZCBoZXQgZWVyc3RlIHJlc29ydCBnZWJvdXdkIG9wIGhldCB0ZXJyZWluIEJyaWdodG9uIEJlYWNoLCBpbiBlZW4gcGVyaW9kZSB3YWFyaW4gQ29uZXkgSXNsYW5kIHN0ZWVkcyBtZWVyIGluIHZlcnZhbCByYWFrdGUuIE9vayBlZW4gZWlnZW4gYW11c2VtZW50c2dlYmllZCBcdTIwMThCcmlnaHRvbiBQaWtlXHUyMDE5IGtvbiBuaWV0IG9udGJyZWtlbi4gTmEgZWVuIGZhdGFsZSBicmFuZCBpbiAxOTE5LCBibGVlZiBhbGxlZW4gaGV0IHN0cmFuZCBvdmVyIGFscyB0cmVrcGxlaXN0ZXIgdm9vciBkZSBidXVydC4gRGUgd2lqayBrcmVlZyBkZSBiaWpuYWFtIFx1MjAxOExpdHRsZSBPZGVzc2FcdTIwMTksIG5hYXIgZWVuIHN0YWQgaW4gT2VrcmFcdTAwZWZuZSB2YW53ZWdlIGRlIHZlbGUgSm9vZHNlIGltbWlncmFudGVuIHVpdCBSdXNsYW5kIGVuIE9la3JhXHUwMGVmbmUgZGllIG5hIGRlIFR3ZWVkZSBXZXJlbGQgT29ybG9nIHJpY2h0aW5nIEJyb29rbHluIGt3YW1lbi5cclxuXHJcbkhvZXdlbCBoZXQgZHVzIG9wIHJlbGF0aWVmIGtvcnRlIGFmc3RhbmQgbGlndCB2YW4gQ29uZXkgSXNsYW5kIGlzIEJyaWdodG9uIEJlYWNoIGVlbiBzdHVrIHJlbGF4dGVyIG9tIG5hYXIgaGV0IHN0cmFuZCB0ZSBnYWFuLiBKZSBoZWJ0IG5pZXQgaGV0IGxhd2FhaSB2YW4gYWxsZSBhdHRyYWN0aWVzIGFhbiBkZSBib2FyZHdhbGsgYmlqIENvbmV5IElzbGFuZCwgbWFhciBlZW4gcmVsYXRpZWYgcnVzdGlnIHBsZWtqZSBvbSB0ZSBnZW5pZXRlbiBtZXQgbW9vaSB3ZWVyLiBLbGFhciBtZXQgZWVuIGRhZ2plIHN0cmFuZD8gRHVpayBkYW4gbm9nIGV2ZW4gTGl0dGxlIE9kZXNzYSBpbiB2b29yIGdvZWRlIHJlc3RhdXJhbnRzIGVuIG5hY2h0Y2x1YnMuWy92Y19jb2x1bW5fdGV4dF1bL3ZjX2NvbHVtbl9pbm5lcl1bdmNfY29sdW1uX2lubmVyIHdpZHRoPVwiMS8zXCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiQ29uZXkgQmVhY2hcIiBoZWFkaW5nX3RhZz1cImgzXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzIyMzY1NlwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjMwcHg7XCIgbWFyZ2luX2Rlc2lnbl90YWJfdGV4dD1cIlwiXVsvdWx0aW1hdGVfaGVhZGluZ11bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJCcm9va2x5blwiIGhlYWRpbmdfdGFnPVwicFwiIG1haW5faGVhZGluZ19jb2xvcj1cIiNiMzRhNGNcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjBweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDoyMXB4O1wiIG1hcmdpbl9kZXNpZ25fdGFiX3RleHQ9XCJcIl1bL3VsdGltYXRlX2hlYWRpbmddW3VsdGltYXRlX2ljb25fbGlzdCBpY29uX3NpemU9XCIxOFwiIGljb25fbWFyZ2luPVwiMTVcIl1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLW1hcC1tYXJrZXJcIl08c3Ryb25nPkNvbmV5IElzbGFuZFx1MDBhMDwvc3Ryb25nPlsvdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy1zdWJ3YXlcIl08c3Ryb25nPkNvbmV5IElzbGFuZCAtIFN0aWxsd2VsbCBBdmVudWUgfCBEIHwgRiB8IE4gfCBRPC9zdHJvbmc+Wy91bHRpbWF0ZV9pY29uX2xpc3RfaXRlbV1bL3VsdGltYXRlX2ljb25fbGlzdF1bdmNfY29sdW1uX3RleHRdSGV0IG1lZXN0IGJla2VuZGUgc3RyYW5kIHZhbiBCcm9va2x5biBlbiBOZXcgWW9yazogQ29uZXkgQmVhY2guIEplIHZpbmR0IGRlIHdpamsgaW4gaGV0IHp1aWR3ZXN0ZWxpamtlIGRlZWwgdmFuIEJyb29rbHluLiBEZSBlZXJzdGUgdm9ybWVuIHZhbiB0b2VyaXNtZSBlbiB2ZXJtYWFrIGJlZ29ubmVuIGFsIHJvbmQgMTg2MCBpbiBkZSBidXVydC4gVHdpbnRpZyBqYWFyIGxhdGVyIHdhcmVuIGRhYXIgYWwgYW11c2VtZW50c3BhcmtlbiB0ZSB2aW5kZW4sIHBhcmtlbiBtZXQgaWNvbmlzY2hlIGF0dHJhY3RpZXMgZGllIG5vZyBzdGVlZHMgaW4gZGUgd2lqayB0ZSB2aW5kZW4gemlqbi4gVG90IG5ldCBuYSBkZSBUd2VlZGUgV2VyZWxkb29ybG9nIHdhcmVuIGhldCBub2cgZ2xvcmllZGFnZW4gdm9vciBDb25leSBJc2xhbmQuIExhbmd6YW1lcmhhbmQgd2VyZCBkZSB3aWprIGdldGVpc3RlcmQgZG9vciBzb2NpYWxlIHByb2JsZW1lbi4gUGFzIHRlZ2VuIGhldCBlaW5kZSB2YW4gZGUgamFyZW4gXHUyMDE5ODAsIGJlZ2luIGphcmVuIFx1MjAxOTkwIHdlcmQgZGUgd2lqayBsYW5nemFhbSB3ZWVyIGRlIHdpamsgem9hbHMgd2UgZGllIG51IGtlbm5lbi4gRWVuIHdpamsgbWV0IGVlbiBub3N0YWxnaXNjaCB0aW50amUgZG9vciBkZSB2ZWxlIG9vcnNwcm9ua2VsaWprZSBhdHRyYWN0aWVzIGVuIHNmZWVyIGRpZSBlciBub2cgaGFuZ3QuXHJcblxyXG5IZXQgaWNvbmlzY2hlIDxhIGhyZWY9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL25ldy15b3JrL2NvbmV5LWlzbGFuZC9cIj5Db25leSBJc2xhbmQ8L2E+IGlzIG9uZ2V2ZWVyIDUga2lsb21ldGVyIGxhbmcgZW4gYmV2aW5kdCB6aWNoIGFhbiBkZSBDb25leSBJc2xhbmQgQm9hcmR3YWxrLiBad2VtbWVuIGluIGRlIHplZSBrYW4gdHVzc2VuIDEwLjAwIHV1ciBlbiAxOC4wMCB1dXIgd2FubmVlciBkZSBsaWZlZ3VhcmRzIGFhbndlemlnIHppam4uIENvbmV5IElzbGFuZCBCZWFjaCBiaWVkdCBtZWVyIGRhbiBhbGxlZW4gemVlIGVuIHN0cmFuZCwgd2FudCBkZSBvbXJpbmdlbmRlIHdpamsgQ29uZXkgSXNsYW5kIGJpZWR0IHRhbCB2YW4gdmVybWFhayBlbiB2ZWxlIHBsZWtrZW4gb20gdGUgZXRlbi4gVmVyZ2VldCBuaWV0IGRlIGJlcm9lbWRlIGhvdGRvZyB2YW4gTmF0aGFuXHUyMDE5cyBGYW1vdXMgdGUgcHJvYmVyZW4gb2Ygc3RhcCBpbiBkZSBiZWZhYW1kZSBXb25kZXIgV2hlZWwgdm9vciBlZW4gcm9uZGplIHJldXplbnJhZC5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzNcIl1bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJNYW5oYXR0YW4gQmVhY2hcIiBoZWFkaW5nX3RhZz1cImgzXCIgbWFpbl9oZWFkaW5nX2NvbG9yPVwiIzIyMzY1NlwiIGFsaWdubWVudD1cImxlZnRcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDoyNXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjMwcHg7XCIgbWFyZ2luX2Rlc2lnbl90YWJfdGV4dD1cIlwiXVsvdWx0aW1hdGVfaGVhZGluZ11bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJCcm9va2x5blwiIGhlYWRpbmdfdGFnPVwicFwiIG1haW5faGVhZGluZ19jb2xvcj1cIiNiMzRhNGNcIiBhbGlnbm1lbnQ9XCJsZWZ0XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6MjBweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDoyMXB4O1wiIG1hcmdpbl9kZXNpZ25fdGFiX3RleHQ9XCJcIl1bL3VsdGltYXRlX2hlYWRpbmddW3VsdGltYXRlX2ljb25fbGlzdCBpY29uX3NpemU9XCIxOFwiIGljb25fbWFyZ2luPVwiMTVcIl1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLW1hcC1tYXJrZXJcIl08c3Ryb25nPk1hbmhhdHRhbiBCZWFjaDwvc3Ryb25nPlsvdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dW3VsdGltYXRlX2ljb25fbGlzdF9pdGVtIGljb249XCJEZWZhdWx0cy1zdWJ3YXlcIl08c3Ryb25nPlNoZWVwc2hlYWQgQmF5IHwgQjwvc3Ryb25nPlsvdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dWy91bHRpbWF0ZV9pY29uX2xpc3RdW3ZjX2NvbHVtbl90ZXh0XU1hbmhhdHRhbiBCZWFjaCB3YXMgb29pdCBoZXQgbWVlc3QgbHV4ZSB2YW4gZGUgZHJpZSBncm90ZSByZXNvcnRzIGRpZSBuYSBkZSBBbWVyaWthYW5zZSBCdXJnZXJvb3Jsb2cgdWl0IGRlIGdyb25kIHdlcmRlbiBnZXN0YW1wdCBvcCBDb25leSBJc2xhbmQuIE1ldCBkZSBrb21zdCB2YW4gaGV0IE1hbmhhdHRhbiBCZWFjaCBIb3RlbCAoMTg3NykgZW4gbGF0ZXIgaGV0IG5vZyBncm90ZXJlIE9yaWVudGFsIEhvdGVsICgxODgwKSB3ZXJkIE1hbmhhdHRhbiBCZWFjaCBkZXN0aWpkcyBlZW4gcGxlayB3YWFyIGR1aXplbmRlbiBiZXpvZWtlcnMgb3AgYWYga3dhbWVuLiBUZWwgZGFhcmJpaiBkZSBjb25jZXJ0ZW4gdmFuIGJlcm9lbWRlIGNvbXBvbmlzdGVuIGluIGRlemUgaG90ZWxzIGVuIGRlIHZ1dXJ3ZXJrc2hvd3Mgb3AgaGV0IHN0cmFuZCBlbiBNYW5oYXR0YW4gQmVhY2ggd2VyZCBlZW4gYmVyb2VtZGUgem9tZXJiYWRwbGFhdHMuIEhlbGFhcyBsaWVwIGRlIGhvdGVsaW5kdXN0cmllIHRlcnVnIGluIGhldCBnZWJpZWQsIHdhYXJvcCBOZXcgWW9yayBDaXR5IFBhcmtzIGRlIHdpamsgb210b3ZlcmRlIHRvdCBlZW4gd29vbndpamsgZW4gTWFuaGF0dGFuIEJlYWNoIFBhcmsuIE9tIGRlIGRydWsgdmFuIENvbmV5IElzbGFuZCBlbiBCcmlnaHRvbiBCZWFjaCB0ZSB2ZXJsaWNodGVuLCB3YXMgZGFhciBNYW5oYXR0YW4gQmVhY2guXHJcblxyXG5Ib2V3ZWwgdmFhayBnZWRhY2h0IHdvcmR0IGRhdCBDb25leSBCZWFjaCBoZXQgYmVzdGUgc3RyYW5kIGlzIHZhbiBCcm9va2x5biwgZ2FhdCBkZXplIHRpdGVsIHRvY2ggbmFhciBNYW5oYXR0YW4gQmVhY2guIFBvcHVsYWlyIGluIGRlIHpvbWVyLCBpcyBNYW5oYXR0YW4gQmVhY2ggZ2VzY2hpa3Qgdm9vciBmYW1pbGllcyBlbiBhbHMgamUgb3Agem9layBiZW50IG5hYXIgZWVuIGFjdGlldmUgZGFnIGluIGRlIHpvbi4gSmUgdmluZHQgb3AgTWFuaGF0dGFuIEJlYWNoIHBsZWtrZW4gb20gdGUgYmFyYmVjdWVcdTAwZWJuLCBwaWNrbmlja2VuIGVuIHNwb3J0ZW4uIEVlbiBpZGVhbGUgY29tYmkgdHVzc2VuIHJlbGF4ZW4gaW4gZGUgem9uLCBsZWtrZXIgZXRlbiBlbiBhY3RpZWYgemlqbi5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVsvdmNfcm93X2lubmVyXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI3NXB4XCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3cgdGhiX2Z1bGxfd2lkdGg9XCJ0cnVlXCIgY29udGVudF9wbGFjZW1lbnQ9XCJtaWRkbGVcIiBmdWxsX3dpZHRoPVwic3RyZXRjaF9yb3dcIiBjb250ZW50X3RleHRfYWxpZ21lbnQ9XCJjZW50ZXJcIiBjc3M9XCIudmNfY3VzdG9tXzE1ODc2NTkyOTkwNzF7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDtiYWNrZ3JvdW5kLWNvbG9yOiAjMDAwMDAwICFpbXBvcnRhbnQ7fVwiIHBhcmFsbGF4X2JhY2tncm91bmRfaW1hZ2U9XCIzODM2XCJdW3ZjX2NvbHVtbiB0aGJfY29sb3I9XCJ0aGItbGlnaHQtY29sdW1uXCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVt1bHRpbWF0ZV9oZWFkaW5nIG1haW5faGVhZGluZz1cIkJyaWdodG9uIEJlYWNoIFwiIGhlYWRpbmdfdGFnPVwicFwiIG1haW5faGVhZGluZ19jb2xvcj1cIiNmZmZmZmZcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDo2NXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkFsZmEgU2xhYiBPbmV8Zm9udF9jYWxsOkFsZmErU2xhYitPbmVcIiBtYWluX2hlYWRpbmdfbGluZV9oZWlnaHQ9XCJkZXNrdG9wOjcwcHg7XCIgbWFyZ2luX2Rlc2lnbl90YWJfdGV4dD1cIlwiXVsvdWx0aW1hdGVfaGVhZGluZ11bdWx0aW1hdGVfaGVhZGluZyBtYWluX2hlYWRpbmc9XCJQZXJmZWN0ZSBlc2NhcGUgb3AgZWVuIHdhcm1lIGRhZyBpbiBOWUNcIiBoZWFkaW5nX3RhZz1cImRpdlwiIG1haW5faGVhZGluZ19jb2xvcj1cIiNmZmZmZmZcIiBtYWluX2hlYWRpbmdfZm9udF9zaXplPVwiZGVza3RvcDo0NXB4O1wiIG1haW5faGVhZGluZ19mb250X2ZhbWlseT1cImZvbnRfZmFtaWx5OkRhbmNpbmcgU2NyaXB0fGZvbnRfY2FsbDpEYW5jaW5nK1NjcmlwdHx2YXJpYW50OjcwMFwiIG1haW5faGVhZGluZ19saW5lX2hlaWdodD1cImRlc2t0b3A6NTBweDtcIiBtYWluX2hlYWRpbmdfc3R5bGU9XCJmb250LXdlaWdodDo3MDA7XCJdWy91bHRpbWF0ZV9oZWFkaW5nXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIzNTBweFwiXVtwYXJhbGxheF9yb3cgb3BhY2l0eT1cIjg1XCIgZW5hYmxlX21vYmlsZT1cInBhcmFsbGF4LWVuYWJsZS1tb2JpbGVcIiBpbWFnZT1cIjE0NTE2XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3VsdGltYXRlX2hlYWRpbmcgbWFpbl9oZWFkaW5nPVwiT29rIGxldWsgaW4gTmV3IFlvcmsgQ2l0eTpcIiBoZWFkaW5nX3RhZz1cInBcIiBtYWluX2hlYWRpbmdfY29sb3I9XCIjMjgyODI4XCIgbWFpbl9oZWFkaW5nX2ZvbnRfc2l6ZT1cImRlc2t0b3A6NDVweDtcIiBtYWluX2hlYWRpbmdfZm9udF9mYW1pbHk9XCJmb250X2ZhbWlseTpBbGZhIFNsYWIgT25lfGZvbnRfY2FsbDpBbGZhK1NsYWIrT25lXCIgbWFpbl9oZWFkaW5nX2xpbmVfaGVpZ2h0PVwiZGVza3RvcDo1MHB4O1wiXVsvdWx0aW1hdGVfaGVhZGluZ11bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiNTBweFwiXVtmdWxsd2lkdGhfcm93XVt0aGJfcG9zdGdyaWQgY29sdW1ucz1cIjRcIiBzb3VyY2U9XCJwb3N0X3R5cGU6cG9zdHxieV9pZDoxNTk0LDEzMTIsNDA4LDE1NTlcIl1bL3ZjX2NvbHVtbl1bL3ZjX3Jvd10iLCJwb3N0X3RpdGxlIjoiWm9uLCB6ZWUgJiMwMzg7IHN0cmFuZCBpbiBCcm9va2x5biIsInBvc3RfbGluayI6Imh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvc3RyYW5kZW4tYnJvb2tseW4vIiwicG9zdF9mZWF0dXJlZF9pbWFnZSI6IjxkaXYgY2xhc3M9XCJmYy1mZWF0dXJlLWltZ1wiPjxpbWcgbG9hZGluZz1cImxhenlcIiBkZWNvZGluZz1cImFzeW5jXCIgYWx0PVwiQ29uZXkgSXNsYW5kXCIgd2lkdGg9XCIzMDBcIiBoZWlnaHQ9XCIyMjVcIiBzcmM9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIzLzAxL2NvbmV5LWlzbGFuZC1iZWFjaC0zMDB4MjI1LmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PiIsInBvc3RfY2F0ZWdvcmllcyI6IlN0ZWRlbnRyaXBzIiwicG9zdF90YWdzIjoiTmV3IFlvcmsiLCIlX3dwYl9zaG9ydGNvZGVzX2N1c3RvbV9jc3MlIjoiLnZjX2N1c3RvbV8xNTg3NjU5Mjk5MDcxe3BhZGRpbmctdG9wOiAyNXB4ICFpbXBvcnRhbnQ7YmFja2dyb3VuZC1jb2xvcjogIzAwMDAwMCAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE0NzIzMDc1MDIyOTB7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDtwYWRkaW5nLWJvdHRvbTogMjVweCAhaW1wb3J0YW50O30udmNfY3VzdG9tXzE1ODc2NTkyOTkwNzF7cGFkZGluZy10b3A6IDI1cHggIWltcG9ydGFudDtiYWNrZ3JvdW5kLWNvbG9yOiAjMDAwMDAwICFpbXBvcnRhbnQ7fS52Y19jdXN0b21fMTU4Mjk3MDcwNDkwM3twYWRkaW5nLXRvcDogMTBweCAhaW1wb3J0YW50O3BhZGRpbmctcmlnaHQ6IDEwcHggIWltcG9ydGFudDtwYWRkaW5nLWJvdHRvbTogMTBweCAhaW1wb3J0YW50O3BhZGRpbmctbGVmdDogMTBweCAhaW1wb3J0YW50O30iLCIlX2VkaXRfbG9jayUiOiIxNjc1MTc1NDUwOjIiLCIlX2VkaXRfbGFzdCUiOiIxIiwiJV93cGJfdmNfanNfc3RhdHVzJSI6InRydWUiLCIlcG9zdC1wcmltYXJ5LWNhdGVnb3J5JSI6ImF1dG8iLCIlZmVhdHVyZWRfaW1hZ2Vfb3ZlcnJpZGUlIjoib2ZmIiwiJWFydGljbGVfc3R5bGVfb3ZlcnJpZGUlIjoib24iLCIlcG9zdF9zdHlsZSUiOiJzdHlsZTUiLCIlcG9zdF9nYWxsZXJ5X3N0eWxlJSI6ImxpZ2h0Ym94IiwiJXBvc3RfcmV2aWV3JSI6Im9mZiIsIiVwb3N0X3Jldmlld19zdHlsZSUiOiJzdHlsZTEiLCIlcG9zdF9yZXZpZXdfYXZlcmFnZSUiOiI1MCIsIiV0aGJfYWxsX2NvdW50cyUiOiIwIiwiJWV4ZWN1dGl2ZV9zdW1tYXJ5JSI6IiIsIiV0aGItcmVhY3Rpb25zLXZvdGVzJSI6IjEiLCIlX2hpZGVfZmVhdHVyZWQlIjpudWxsLCIlX3dwX29sZF9kYXRlJSI6IjIwMjAtMDYtMTciLCIlaW5saW5lX2ZlYXR1cmVkX2ltYWdlJSI6IjAiLCIlX3lvYXN0X3dwc2VvX2ZvY3Vza3clIjoiU3RyYW5kZW4gaW4gQnJvb2tseW4iLCIlX3lvYXN0X3dwc2VvX3RpdGxlJSI6IlN0cmFuZGVuIGluIEJyb29rbHluICUlcGFnZSUlICUlc2VwJSUgJSVzaXRlbmFtZSUlIiwiJV95b2FzdF93cHNlb19tZXRhZGVzYyUiOiJCZW4gamUgaW4gZGUgem9tZXIgaW4gTmV3IFlvcmsgZW4gd2lsIGplIGVyZ2VucyB6d2VtbWVuPyBDaGVjayBkYW4gZGV6ZSBzdHJhbmRlbiBpbiBCcm9va2x5biBvbSBlZW4gZHVpayB0ZSBuZW1lbiBpbiBkZSB6ZWUuIiwiJV95b2FzdF93cHNlb19saW5rZGV4JSI6Ijc3IiwiJV95b2FzdF93cHNlb19jb250ZW50X3Njb3JlJSI6IjMwIiwiJV95b2FzdF93cHNlb19mb2N1c2tleXdvcmRzJSI6IltdIiwiJV95b2FzdF93cHNlb19rZXl3b3Jkc3lub255bXMlIjoiW1wiXCJdIiwiJV93cGdtcF9sb2NhdGlvbl9hZGRyZXNzJSI6IjEwNzEgNXRoIEF2ZSwgTmV3IFlvcmssIE5ZIDEwMTI4LCBWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9sb2NhdGlvbl9jaXR5JSI6Ik5ldyBZb3JrIiwiJV93cGdtcF9sb2NhdGlvbl9zdGF0ZSUiOiJOZXcgWW9yayIsIiVfd3BnbXBfbG9jYXRpb25fY291bnRyeSUiOiJWZXJlbmlnZGUgU3RhdGVuIiwiJV93cGdtcF9tZXRhYm94X2xhdGl0dWRlJSI6IjQwLjc4Mjk3OTYiLCIlX3dwZ21wX21ldGFib3hfbG9uZ2l0dWRlJSI6Ii03My45NTg5NzA2IiwiJV93cGdtcF9tZXRhYm94X2xvY2F0aW9uX3JlZGlyZWN0JSI6Im1hcmtlciIsIiVfd3BnbXBfbWV0YWJveF9jdXN0b21fbGluayUiOiIiLCIlX3dwZ21wX21hcF9pZCUiOiJhOjE6e2k6MDtzOjE6XCI3XCI7fSIsIiVfd3BnbXBfbWV0YWJveF9tYXJrZXJfaWQlIjoiYToxOntpOjA7czoxOlwiMlwiO30iLCIlX3dwZ21wX21ldGFib3hfdGF4b21vbWllc190ZXJtcyUiOiJOOyIsIiVfd3BnbXBfZXh0ZW5zaW9uc19maWVsZHMlIjoiTjsiLCIlX3lvYXN0X3dwc2VvX2VzdGltYXRlZC1yZWFkaW5nLXRpbWUtbWludXRlcyUiOiI1IiwiJV93d3Nfc3VwcG9ydF9jb250YWN0X251bWJlciUiOiIiLCIlX3d3c19hYm91dF9zdXBwb3J0X3RleHQlIjoiIiwiJV93d3NfdHJpZ2dlcl9idXR0b25fdGV4dCUiOiIiLCIlX3d3c19wcmVkZWZpbmVkX3RleHQlIjoiIiwiJV95b2FzdF93cHNlb193b3JkcHJvb2ZfdGltZXN0YW1wJSI6IiIsIiVfeW9hc3Rfd3BzZW9fcHJpbWFyeV9jYXRlZ29yeSUiOiI2MiIsIiVwb3N0X3ZpYSUiOnsiMSI6eyJ0aXRsZSI6IiIsInBvc3Rfc291cmNlX3VybCI6IiJ9fSwiJV95b2FzdF9pbmRleG5vd19sYXN0X3BpbmclIjoiMTY3NzAxNDg0OSIsIiVfbGFzdF9lZGl0b3JfdXNlZF9qZXRwYWNrJSI6ImNsYXNzaWMtZWRpdG9yIiwiJV90aHVtYm5haWxfaWQlIjoiMTQ1MjAiLCJ0YXhvbm9teT1jYXRlZ29yeSI6IlN0ZWRlbnRyaXBzIiwidGF4b25vbXk9cG9zdF90YWciOiJOZXcgWW9yayIsInRheG9ub215PXBvc3RfZm9ybWF0IjoiIiwidGF4b25vbXk9dGhiLXJlYWN0aW9ucyI6IiIsInRheG9ub215PXRoYi1zcG9uc29ycyI6IiJ9LCJpY29uIjoiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyNC8wMy9tdXNlYS1pY29uLnBuZyJ9LCJpZCI6MTQ1MTIsImluZm93aW5kb3dfZGlzYWJsZSI6ZmFsc2UsImNhdGVnb3JpZXMiOlt7Imljb24iOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDI0LzAzL211c2VhLWljb24ucG5nIiwibmFtZSI6Ik11c2VhIiwiaWQiOiIyIiwidHlwZSI6ImNhdGVnb3J5IiwiZXh0ZW5zaW9uX2ZpZWxkcyI6eyJjYXRfb3JkZXIiOiIifX1dfSx7InNvdXJjZSI6InBvc3QiLCJ0aXRsZSI6IlVuaWVrZSBhdHRyYWN0aWUgZW4gbWVlciBvcCBkZSBMaW5xIFByb21lbmFkZSBpbiBMYXMgVmVnYXMiLCJpbmZvd2luZG93X2NvbnRlbnQiOiI8ZGl2IGNsYXNzPVwiZmMtaXRlbS1ib3ggZmMtaXRlbS1uby1wYWRkaW5nIFwiPlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWZlYXR1cmUtaW1nXCI+PGltZyBsb2FkaW5nPVwibGF6eVwiIGRlY29kaW5nPVwiYXN5bmNcIiBhbHQ9XCJMaW5xIFByb21lbmFkZVwiIHdpZHRoPVwiMzAwXCIgaGVpZ2h0PVwiMjAwXCIgc3JjPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC93cC1jb250ZW50L3VwbG9hZHMvMjAyMy8wMS9saW5xLXByb21lbmFkZS0zMDB4MjAwLmpwZ1wiIGNsYXNzPVwid3AtcG9zdC1pbWFnZSAgIHdwZ21wX2ZlYXR1cmVkX2ltYWdlXCIgPjwvZGl2PlxyXG4gICAgPGRpdiBjbGFzcz1cImZjLWl0ZW1jb250ZW50LXBhZGRpbmdcIj5cclxuICAgICAgICA8ZGl2IGNsYXNzPVwiZmMtaXRlbWNvbnRlbnQtcGFkZGluZyBmYy1pdGVtLW5vLXBhZGRpbmdcIj5cclxuICAgICAgICAgICAgPGRpdiBjbGFzcz1cImZjLWl0ZW0tdGl0bGUgZmMtaXRlbS1wcmltYXJ5LXRleHQtY29sb3IgZmMtaXRlbS10b3Atc3BhY2VcIj5Vbmlla2UgYXR0cmFjdGllIGVuIG1lZXIgb3AgZGUgTGlucSBQcm9tZW5hZGUgaW4gTGFzIFZlZ2FzPC9kaXY+XHJcbiAgICAgICAgICAgIDxkaXYgY2xhc3M9XCJmYy1pdGVtLWNvbnRlbnQgZmMtaXRlbS1ib2R5LXRleHQtY29sb3JcIj57bWFya2VyX2FkZHJlc3N9PC9kaXY+XHJcbiAgICAgICAgPC9kaXY+XHJcbiAgICA8L2Rpdj5cclxuICAgIDxkaXYgY2xhc3M9XCJmYy1jbGVhclwiPjwvZGl2PlxyXG48L2Rpdj4iLCJhZGRyZXNzIjoiMzU0NSBTIExhcyBWZWdhcyBCbHZkLCBMYXMgVmVnYXMsIE5WIDg5MTA5LCBWZXJlbmlnZGUgU3RhdGVuIiwibG9jYXRpb24iOnsibGF0IjoiMzYuMTE3NzgwMSIsImNpdHkiOiJMYXMgVmVnYXMiLCJzdGF0ZSI6Ik5ldmFkYSIsImNvdW50cnkiOiJWZXJlbmlnZGUgU3RhdGVuIiwibG5nIjoiLTExNS4xNzI1NzQ4Iiwib25jbGlja19hY3Rpb24iOiJtYXJrZXIiLCJyZWRpcmVjdF9wZXJtYWxpbmsiOiJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL2xpbnEtcHJvbWVuYWRlLyIsInpvb20iOjEyLCJleHRyYV9maWVsZHMiOnsicG9zdF9leGNlcnB0IjoiIiwicG9zdF9jb250ZW50IjoiW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIl1bdmNfY29sdW1uIHdpZHRoPVwiMS8yXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG5cclxuWy92Y19jb2x1bW5fdGV4dF1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiODUlXCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjEvMlwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCIyNXB4XCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJPbnRkZWsgZGUgdmVyc2NoaWxsZW5kZSBtb2dlbGlqa2hlZGVuIG9wIGRlIExpbnEgUHJvbWVuYWRlXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjM1fHRleHRfYWxpZ246bGVmdHxjb2xvcjolMjMyODI4Mjh8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxkaXYgY2xhc3M9XCJwYWdlXCIgdGl0bGU9XCJQYWdlIDFcIj5cclxuPGRpdiBjbGFzcz1cInNlY3Rpb25cIj5cclxuPGRpdiBjbGFzcz1cImxheW91dEFyZWFcIj5cclxuPGRpdiBjbGFzcz1cImNvbHVtblwiPlxyXG5cclxuT2tlLCBkZSBTdHJpcCBpcyBuYXR1dXJsaWprIGRlIGdyb290c3RlIHB1YmxpZWtzdHJla2tlciBpbiBMYXMgVmVnYXMuIE1hYXIgZWVuIGFuZGVyIGJlemllbnN3YWFyZGlnaGVpZCBkaWUgbmlldCBrYW4gb250YnJla2VuIHRpamRlbnMgZWVuIGJlem9layBhYW4gTGFzIFZlZ2FzIGlzIGRlIExpbnEgUHJvbWVuYWRlLiBFZW4gZ2V3ZWxkaWdlIHBsZWsgaW4gVmVnYXMgb20gdW5pZWtlIGF0dHJhY3RpZXMsIHZlcnNjaGlsbGVuZGUgd2lua2VscyBlbiByZXN0YXVyYW50cyB0ZSBiZXpvZWtlbi4gVmFudWl0IGRlIHZlcnRlIHppZSBqZSBlZW4gdmFuIGRlIGhvb2ZkYXR0cmFjdGllcyBhbCBlciBib3ZlbnVpdCBzdGVrZW47IGRlIEhpZ2ggUm9sbGVyLiBIZXQgZ2lnYW50aXNjaGUgcmV1emVucmFkIGRhdCBqZSBlZW4gcGFub3JhbWlzY2ggdWl0emljaHQgYmllZHQgb3AgVGhlIFN0cmlwLiBJcyBkaXQgaWV0cyB0ZSBob29nIHZvb3IgamU/IERhbiB6aWpuIGVyIG5vZyB0YWwgdmFuIGFuZGVyZSBiZXppZW5zd2FhcmRpZ2hlZGVuIG9mIHdpbmtlbHMgZW4gcmVzdGF1cmFudHMgb20gdGUgYmV6b2VrZW4uIEVlbiBhYW50YWwgdGlwcyBvbSBhbGxlcyB1aXQgZWVuIGJlem9layBhYW4gZGUgTGlucSBQcm9tZW5hZGUgdGUgaGFsZW4uIDxzcGFuIHN0eWxlPVwiZm9udC1mYW1pbHk6IC1hcHBsZS1zeXN0ZW0sIEJsaW5rTWFjU3lzdGVtRm9udCwgJ1NlZ29lIFVJJywgUm9ib3RvLCBPeHlnZW4tU2FucywgVWJ1bnR1LCBDYW50YXJlbGwsICdIZWx2ZXRpY2EgTmV1ZScsIHNhbnMtc2VyaWY7XCI+XHUwMGEwPC9zcGFuPlxyXG5cclxuPC9kaXY+XHJcbjwvZGl2PlxyXG48L2Rpdj5cclxuPC9kaXY+XHJcblsvdmNfY29sdW1uX3RleHRdW3VsdGltYXRlX2ljb25fbGlzdCBpY29uX3NpemU9XCIxOFwiIGljb25fbWFyZ2luPVwiMTVcIl1bdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW0gaWNvbj1cIkRlZmF1bHRzLWNhbGVuZGFyXCJdMzY1IGRhZ2VuIHBlciBqYWFyIGdlb3BlbmRbL3VsdGltYXRlX2ljb25fbGlzdF9pdGVtXVt1bHRpbWF0ZV9pY29uX2xpc3RfaXRlbSBpY29uPVwiRGVmYXVsdHMtZG9sbGFyIHVzZFwiXUdyYXRpc1svdWx0aW1hdGVfaWNvbl9saXN0X2l0ZW1dWy91bHRpbWF0ZV9pY29uX2xpc3RdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3Jvd11bdmNfY29sdW1uXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyBiZ190eXBlPVwiYmdfY29sb3JcIiBiZ19jb2xvcl92YWx1ZT1cIiNlZGVkZWRcIiBjc3M9XCIudmNfY3VzdG9tXzE2MTI5NTA1NDA4MTR7YmFja2dyb3VuZC1jb2xvcjogI2VkZWRlZCAhaW1wb3J0YW50O31cIl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dW3ZjX2NvbHVtbiB3aWR0aD1cIjIvM1wiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW2Z1bGx3aWR0aF9yb3cgY29udGVudF93aWR0aD1cIjkwJVwiXVt2Y19lbXB0eV9zcGFjZSBoZWlnaHQ9XCI1MHB4XCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJXYXQgaXMgcHJlY2llcyBkZSBMaW5xIFByb21lbmFkZT9cIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MzV8dGV4dF9hbGlnbjpjZW50ZXJ8Y29sb3I6JTIzMjgyODI4fGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XVxyXG48ZGl2IGNsYXNzPVwicGFnZVwiIHRpdGxlPVwiUGFnZSAxXCI+XHJcbjxkaXYgY2xhc3M9XCJzZWN0aW9uXCI+XHJcbjxkaXYgY2xhc3M9XCJsYXlvdXRBcmVhXCI+XHJcbjxkaXYgY2xhc3M9XCJjb2x1bW5cIj5cclxuPHAgc3R5bGU9XCJ0ZXh0LWFsaWduOiBjZW50ZXI7XCI+RGUgbmFhbSBMaW5xIFByb21lbmFkZSBrYW4gdmVyd2FycmVuZCB6aWpuIHdhbm5lZXIgamUgZWVyZGVyIGluIExhcyBWZWdhcyBiZW50IGdld2Vlc3QuIEhldCBnZWJpZWQgaGVlZnQgZGUgYWZnZWxvcGVuIGphcmVuIHZlcnNjaGlsbGVuZGUgbmFtZW4gZ2VoYWQuIExpbnEga29tdCB2YW4gZGUgbmFhbSB2YW4gaGV0IGNhc2lubyBkYXQgZ3JlbnN0IGFhbiBkZSBwcm9tZW5hZGUuIFNpbmRzIGVpbmQgMjAxNCBoZWV0IGhldCBnZWJpZWQgVGhlIExpbnEgUHJvbWVuYWRlLiBXYXQgaXMgZGUgTGlucSBQcm9tZW5hZGUgcHJlY2llcz8gSGV0IGlzIGVpZ2VubGlqayBlZW4gd2FuZGVsZ2ViaWVkIGluIGRlIGJ1aXRlbmx1Y2h0IHdhYXIgamUgdmVlbCByZXN0YXVyYW50cywgd2lua2VscywgYmFycywgc2hvd3MgZW4gYW5kZXJlIGF0dHJhY3RpZXMga3VudCB2aW5kZW4uPC9wPlxyXG5cclxuPC9kaXY+XHJcbjwvZGl2PlxyXG48L2Rpdj5cclxuPC9kaXY+XHJcblsvdmNfY29sdW1uX3RleHRdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjUwcHhcIl1bL3ZjX2NvbHVtbl1bdmNfY29sdW1uIHdpZHRoPVwiMS82XCJdWy92Y19jb2x1bW5dWy92Y19yb3ddW3ZjX3JvdyB0aGJfZnVsbF93aWR0aD1cInRydWVcIiBjb250ZW50X3BsYWNlbWVudD1cIm1pZGRsZVwiIGZ1bGxfd2lkdGg9XCJzdHJldGNoX3Jvd1wiIGNvbnRlbnRfdGV4dF9hbGlnbWVudD1cImNlbnRlclwiIGNzcz1cIi52Y19jdXN0b21fMTU4MjkwNjg4MjkxN3twYWRkaW5nLXRvcDogMjVweCAhaW1wb3J0YW50O31cIiBwYXJhbGxheF9iYWNrZ3JvdW5kX2ltYWdlPVwiMzgzNlwiXVt2Y19jb2x1bW4gdGhiX2NvbG9yPVwidGhiLWxpZ2h0LWNvbHVtblwiXVtmdWxsd2lkdGhfcm93IGNvbnRlbnRfd2lkdGg9XCI5MCVcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1baGV5dXNhX2hlYWRpbmcgdGFnPVwiZGl2XCIgdGV4dF9hbGlnbj1cImNlbnRlclwiIGhlYWRpbmc9XCJIaWdoIFJvbGxlciBvcCBkZSBMaW5xIFByb21lbmFkZVwiIGZvbnRfc2l6ZT1cIjU1XCIgbGluZV9oZWlnaHQ9XCI2MFwiIGZvbnRfY29sb3I9XCIjZmZmZmZmXCJdW3ZjX2N1c3RvbV9oZWFkaW5nIHRleHQ9XCJFZW4gdmFuIGRlIGhvb2dzdGUgdGVyIHdlcmVsZFwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgzfGZvbnRfc2l6ZTo0NXx0ZXh0X2FsaWduOmNlbnRlcnxjb2xvcjolMjNmZmZmZmZ8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfZW1wdHlfc3BhY2UgaGVpZ2h0PVwiMzUwcHhcIl1bcGFyYWxsYXhfcm93IGVuYWJsZV9tb2JpbGU9XCJwYXJhbGxheC1lbmFibGUtbW9iaWxlXCIgaW1hZ2U9XCIxNDQxMVwiXVsvdmNfY29sdW1uXVsvdmNfcm93XVt2Y19yb3ddW3ZjX2NvbHVtbl1bZnVsbHdpZHRoX3JvdyBjb250ZW50X3dpZHRoPVwiOTAlXCJdW3ZjX2VtcHR5X3NwYWNlIGhlaWdodD1cIjc1cHhcIl1bdmNfcm93X2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzNcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIkF0dHJhY3RpZSBvcCBkZSBMaW5xIFByb21lbmFkZVwiIGZvbnRfY29udGFpbmVyPVwidGFnOmgyfGZvbnRfc2l6ZToyMHx0ZXh0X2FsaWduOmxlZnR8Y29sb3I6JTIzMDAwMDAwfGxpbmVfaGVpZ2h0OjFcIiBnb29nbGVfZm9udHM9XCJmb250X2ZhbWlseTpBbGZhJTIwU2xhYiUyME9uZSUzQXJlZ3VsYXJ8Zm9udF9zdHlsZTo0MDAlMjByZWd1bGFyJTNBNDAwJTNBbm9ybWFsXCJdW3ZjX2NvbHVtbl90ZXh0XURlIGdyb290c3RlIHB1YmxpZWtzdHJla2tlciBvcCBkZSBMaW5xIFByb21lbmFkZSwgb29rIGxldHRlcmxpamssIGlzIGhldCByZXV6ZW5yYWQgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvaGlnaC1yb2xsZXItbGFzLXZlZ2FzL1wiPlRoZSBIaWdoIFJvbGxlcjwvYT4uIERpdCBpcyBlZW4gdmFuIGRlIGhvb2dzdGUgdGVyIHdlcmVsZCwgYWxsZWVuIGluIER1YmFpIHZpbmQgamUgZWVuIGhvZ2VyZS4gSGV0IHJldXplbnJhZCwgbWV0IGVlbiBob29ndGUgdmFuIDE2OCBtZXRlciwgaGVlZnQgMjggY2FiaW5zIHdhYXIgb25nZXZlZXIgNDAgbWVuc2VuIGluIGt1bm5lbi4gSmUga3Jpamd0IHZhbnVpdCBkZSBjYWJpbnMgZWVuIDM2MCBncmFkZW4gdWl0emljaHQgb3ZlciA8YSBocmVmPVwiaHR0cHM6Ly93d3cuaGV5dXNhLmNvbS9ubC9sYXMtdmVnYXMvdGhlLXN0cmlwLWxhcy12ZWdhcy9cIj5UaGUgU3RyaXA8L2E+IGVuIExhcyBWZWdhcy5cclxuXHJcbkVlbiBhbmRlcmUgYXR0cmFjdGllLCBpZXRzIG1lZXIgZG9vciBhZHJlbmFsaW5lIGp1bmtpZXMsIGlzIGRlIDxhIGhyZWY9XCJodHRwczovL3d3dy5oZXl1c2EuY29tL25sL2xhcy12ZWdhcy9mbHktbGlucS16aXBsaW5lL1wiPkZseSBMaW5xIFppcGxpbmU8L2E+LiBMYWF0IGplIHZhc3RtYWtlbiBiaWogZGUgc3RhcnQgb3AgZGUgTGFzIFZlZ2FzIEJvdWxldmFyZCBlbiB2bGllZyBvcCBlZW4gaG9vZ3RlIHZhbiAxMiB2ZXJkaWVwaW5nZW4gYm92ZW4gZGUgTElOUSBQcm9tZW5hZGUuIEdlbmlldCB2YW4gaGV0IHVpdHppY2h0IG92ZXIgZGUgTGlucSBQcm9tZW5hZGUgd2FubmVlciB2aWEgamUgZWVuIHppcGxpbmUgZG9vciBMYXMgVmVnYXMgZ2FhdC4gSmUga3VudCB6aXR0ZW5kIG9mIGFscyBlZW4gc3VwZXJoZWxkIHZpYSBkZSB6aXBsaW5lIGRlIHJpdCBtYWtlbi5cclxuXHJcbkVlbiBwb3B1bGFpcmUgcGxlayBpcyBkZSA8YSBocmVmPVwiaHR0cHM6Ly93d3cuYnJvb2tseW5ib3dsLmNvbS9cIiB0YXJnZXQ9XCJfYmxhbmtcIiByZWw9XCJub29wZW5lclwiPkJyb29rbHluIEJvd2w8L2E+LiBOaWV0IGFsbGVlbiBkZSBwbGVrIG9tIHRlIGJvd2xlbiBpbiBMYXMgVmVnYXMsIGplIGt1bnQgZXIgb29rIGdlemVsbGlnIGlldHMgZXRlbiBvZiBkcmlua2VuLiBEYWFybmFhc3QgemlqbiBlciB0YWwgdmFuIHNob3dzIGVuIGFuZGVyZSBldmVuZW1lbnRlbi5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzNcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIlNob3BwZW4gb3AgZGUgTGlucSBQcm9tZW5hZGVcIiBmb250X2NvbnRhaW5lcj1cInRhZzpoMnxmb250X3NpemU6MjB8dGV4dF9hbGlnbjpsZWZ0fGNvbG9yOiUyMzAwMDAwMHxsaW5lX2hlaWdodDoxXCIgZ29vZ2xlX2ZvbnRzPVwiZm9udF9mYW1pbHk6QWxmYSUyMFNsYWIlMjBPbmUlM0FyZWd1bGFyfGZvbnRfc3R5bGU6NDAwJTIwcmVndWxhciUzQTQwMCUzQW5vcm1hbFwiXVt2Y19jb2x1bW5fdGV4dF1cclxuPGRpdiBjbGFzcz1cInBhZ2VcIiB0aXRsZT1cIlBhZ2UgMVwiPlxyXG48ZGl2IGNsYXNzPVwic2VjdGlvblwiPlxyXG48ZGl2IGNsYXNzPVwibGF5b3V0QXJlYVwiPlxyXG48ZGl2IGNsYXNzPVwiY29sdW1uXCI+XHJcblxyXG5PcCBkZSBMaW5xIFByb21lbmFkZSBoZWIgamUgdmVyc2NoaWxsZW5kZSBtb2dlbGlqa2hlZGVuIG9tIHRlIDxhIGhyZWY9XCJodHRwczovL3d3dy5jYWVzYXJzLmNvbS9saW5xL3RoaW5ncy10by1kby9zaG9wcGluZ1wiIHRhcmdldD1cIl9ibGFua1wiIHJlbD1cIm5vb3BlbmVyXCI+c2hvcHBlbjwvYT4uIFdhdCBkZW5rIGplIHZhbiBpY29uaXNjaGUgSGFybGV5IERhdmlkc29uIHByb2R1Y3Rlbj8gT2YgZGUgY29va2llcyB2YW4gSG9ub2x1bHUgQ29va2llIENvbXBhbnkuIE9vayB2b29yIGtsZWRpbmcgemlqbiBlciB2ZXJzY2hpbGxlbmRlIHdpbmtlbHMgd2FhciBqZSB0ZXJlY2h0IGt1bnQuIERhYXJuYWFzdCB6aWpuIGVyIGVlbiBhYW50YWwgd2lua2VscyBtZXQgYWNjZXNzb2lyZXMgZW4gbmF0dXVybGlqayBrdW5uZW4gZ2lmdCBzaG9wcyB2b29yIHNvdXZlbmlycyBvb2sgbmlldCBvbnRicmVrZW4gb3AgZGUgTGlucSBQcm9tZW5hZGUuXHJcblxyXG48L2Rpdj5cclxuPC9kaXY+XHJcbjwvZGl2PlxyXG48L2Rpdj5cclxuPHNwYW4gc3R5bGU9XCJmb250LXdlaWdodDogNDAwO1wiPlx1MDBhMDwvc3Bhbj5bL3ZjX2NvbHVtbl90ZXh0XVsvdmNfY29sdW1uX2lubmVyXVt2Y19jb2x1bW5faW5uZXIgd2lkdGg9XCIxLzNcIl1bdmNfY3VzdG9tX2hlYWRpbmcgdGV4dD1cIlJlc3RhdXJhbnRzIExpbnEgUHJvbWVuYWRlXCIgZm9udF9jb250YWluZXI9XCJ0YWc6aDJ8Zm9udF9zaXplOjIwfHRleHRfYWxpZ246bGVmdHxjb2xvcjolMjMwMDAwMDB8bGluZV9oZWlnaHQ6MVwiIGdvb2dsZV9mb250cz1cImZvbnRfZmFtaWx5OkFsZmElMjBTbGFiJTIwT25lJTNBcmVndWxhcnxmb250X3N0eWxlOjQwMCUyMHJlZ3VsYXIlM0E0MDAlM0Fub3JtYWxcIl1bdmNfY29sdW1uX3RleHRdXHJcbjxkaXYgY2xhc3M9XCJwYWdlXCIgdGl0bGU9XCJQYWdlIDFcIj5cclxuPGRpdiBjbGFzcz1cInNlY3Rpb25cIj5cclxuPGRpdiBjbGFzcz1cImxheW91dEFyZWFcIj5cclxuPGRpdiBjbGFzcz1cImNvbHVtblwiPlxyXG5cclxuTWV0IG1lZXIgZGFuIDM1IHJlc3RhdXJhbnRzIGhlYiBqZSBlZW4gZ29lZGUgcmVkZW4gb20gbm9nIGxhbmdlciBvcCBkZSBMaW5xIFByb21lbmFkZSB0ZSBibGlqdmVuLiBFbmtlbGUgZmF2b3JpZXRlbiB6aWpuOlxyXG48dWw+XHJcbiBcdDxsaT5JIExvdmUgU3VnYXI6IGVpZ2VubGlqayBsaWprdCBkaXQgZWVuIGdpZ2FudGlzY2hlIHNub2Vwd2lua2VsLCBtYWFyIGplIGt1bnQgZXIgb29rIHNub2VwIGdlcmVsYXRlZXJkZSBkcmFua2plcyBkcmlua2VuLiBFbm9ybSBmb3RvZ2VuaWVrIG92ZXJpZ2VuczwvbGk+XHJcbiBcdDxsaT5BbWVyaWNhbiBCZWVyOiBCaWVyIHByb2V2ZW4gdWl0IGFsbGUgPGEgaHJlZj1cImh0dHBzOi8vd3d3LmhleXVzYS5jb20vbmwvYWxsZS01MC1zdGF0ZW4tdmFuLWFtZXJpa2EvXCI+c3RhdGVuIHZhbiBBbWVyaWthPC9hPj8gRGFuIG1vZXQgamUgbmFhciBBbWVyaWNhbiBCZWVyPC9saT5cclxuIFx0PGxpPkZhdm9yaXRlIEJpc3RybzogRXRlbiBpbiBGcmFuc2Ugc3RpamwgbWV0IGVlbiBBbWVyaWthYW5zIHRpbnRqZTwvbGk+XHJcbiBcdDxsaT5NaW51czUgSWNlYmFyOiBNaWRkZW4gaW4gZGUgd29lc3Rpam4gZHJhbmtqZXMgZG9lbiBpbiBkZSBrb3U/IEdlbmlldCBiaWogTWludXM1IEljZWJhciB2YW4gdmVyc2NoaWxsZW5kZSBjb2NrdGFpbHM8L2xpPlxyXG4gXHQ8bGk+R29yZG9uIFJhbXNheSBGaXNoIGFuZCBDaGlwczogRWVuIGtsYXNzaWVrZSBmaXNoIGFuZCBjaGlwcyBoYWFsIGplIGJpaiBoZXQgcmVzdGF1cmFudCB2YW4gR29yZG9uIFJhbXNheSBvcCBkZSBMaW5xIFByb21lbmFkZTwvbGk+XHJcbiBcdDxsaT5Jbi1OLU91dCBCdXJnZXI6IERlIHBsZWsgb20gZWVuIGJ1cmdlciB0ZSBzY29yZW48L2xpPlxyXG48L3VsPlxyXG48L2Rpdj5cc