Politiet ADVARER:
-
Oslo: Politiet påkjørt, gjerningsperson stakk fra stedet
-
Ukraina: Har avslørt nettverk som planla å drepe Zelenskyj
-
Forsinkelser på Sørlandsbanen: - Kan ta tid
-
Stjal verdier for 700 000 - ber om tips
-
Politiet advarer mot svindel
-
- Må nøye seg med høstvær
-
Fastlege dømt for grovt bedrageri
-
Kenguru på rømmen i Skåne
-
Hatkriminalitet øker
-
Drammen: To lastebiler krasjet
Raser mot TV 2
Magefett-formelen:Borte på 10 uker
Annonsørinnhold
I kveld kan duvinne 398 millioner
i samarbeid med Norsk- Hun måi fengsel
Lindas (36) oppskrift:Kiloene renner av!
Annonsørinnhold
Hvilken markise bør duvelge til hjemmet ditt?
i samarbeid medWyI8c3R5bGU+LmZqSnl2RS5makp5dkUuZmpKeXZFLmZqSnl2RXtoZWlnaHQ6MDtwYWRkaW5nLWJvdHRvbTo1MCU7fS8qIXNjKi8gLmV6VlpvTS5lelZab00uZXpWWm9NLmV6VlpvTXtoZWlnaHQ6MDtwYWRkaW5nLWJvdHRvbTo1OS4zOCU7fS8qIXNjKi8gLmZuUURIYi5mblFESGIuZm5RREhiLmZuUURIYntoZWlnaHQ6MDtwYWRkaW5nLWJvdHRvbTo0OS44OSU7fS8qIXNjKi8gLmJjanFzTS5iY2pxc00uYmNqcXNNLmJjanFzTXtoZWlnaHQ6MDtwYWRkaW5nLWJvdHRvbTo2Ny40MiU7fS8qIXNjKi8gLkZ2SWJ6LkZ2SWJ6LkZ2SWJ6LkZ2SWJ6e2hlaWdodDowO3BhZGRpbmctYm90dG9tOjY0LjA2JTt9Lyohc2MqLyAua3ZpQXJ5Lmt2aUFyeS5rdmlBcnkua3ZpQXJ5e2hlaWdodDowO3BhZGRpbmctYm90dG9tOjQ5LjkxJTt9Lyohc2MqLyAuYm95eGdkLmJveXhnZC5ib3l4Z2QuYm95eGdke2hlaWdodDowO3BhZGRpbmctYm90dG9tOjU0LjQ3JTt9Lyohc2MqLyAuamxHcEZ3LmpsR3BGdy5qbEdwRncuamxHcEZ3e2hlaWdodDowO3BhZGRpbmctYm90dG9tOjEwNC45NyU7fS8qIXNjKi8gLmpBU2tORC5qQVNrTkQuakFTa05ELmpBU2tORHtoZWlnaHQ6MDtwYWRkaW5nLWJvdHRvbTo2NS41NiU7fS8qIXNjKi8gLmpsa0dydi5qbGtHcnYuamxrR3J2Lmpsa0dydntoZWlnaHQ6MDtwYWRkaW5nLWJvdHRvbTo4OC41NSU7fS8qIXNjKi8gLmtkU3RsRC5rZFN0bEQua2RTdGxELmtkU3RsRHtoZWlnaHQ6MDtwYWRkaW5nLWJvdHRvbTo3OS42OCU7fS8qIXNjKi8gLmRIR3doQy5kSEd3aEMuZEhHd2hDLmRIR3doQ3toZWlnaHQ6MDtwYWRkaW5nLWJvdHRvbTo1NC4yMiU7fS8qIXNjKi8gLmZYelp5Wi5mWHpaeVouZlh6WnlaLmZYelp5WntoZWlnaHQ6MDtwYWRkaW5nLWJvdHRvbTo5Mi45OCU7fS8qIXNjKi8gLmxsV214SS5sbFdteEkubGxXbXhJLmxsV214SXtoZWlnaHQ6MDtwYWRkaW5nLWJvdHRvbTo4Mi41OCU7fS8qIXNjKi8gLmJuYllGei5ibmJZRnouYm5iWUZ6LmJuYllGentoZWlnaHQ6MDtwYWRkaW5nLWJvdHRvbTo5MS4wNCU7fS8qIXNjKi8gLnJIU0diLnJIU0diLnJIU0diLnJIU0die2hlaWdodDowO3BhZGRpbmctYm90dG9tOjYxLjg3JTt9Lyohc2MqLyAuaEdNTmxLLmhHTU5sSy5oR01ObEsuaEdNTmxLe2hlaWdodDowO3BhZGRpbmctYm90dG9tOjg5LjglO30vKiFzYyovIC5pdUpPdUouaXVKT3VKLml1Sk91Si5pdUpPdUp7aGVpZ2h0OjA7cGFkZGluZy1ib3R0b206MTM4LjU1JTt9Lyohc2MqLyAuaHBaUFFtLmhwWlBRbS5ocFpQUW0uaHBaUFFte2hlaWdodDowO3BhZGRpbmctYm90dG9tOjY4LjY1JTt9Lyohc2MqLyAuWVRJa0kuWVRJa0kuWVRJa0kuWVRJa0l7aGVpZ2h0OjA7cGFkZGluZy1ib3R0b206NTUuNDclO30vKiFzYyovIC5sbWRqblYubG1kam5WLmxtZGpuVi5sbWRqblZ7aGVpZ2h0OjA7cGFkZGluZy1ib3R0b206NTUuOTMlO30vKiFzYyovIC5pZEtDSHMuaWRLQ0hzLmlkS0NIcy5pZEtDSHN7aGVpZ2h0OjA7cGFkZGluZy1ib3R0b206NTAuOTMlO30vKiFzYyovIC5oeVRLTE0uaHlUS0xNLmh5VEtMTS5oeVRLTE17aGVpZ2h0OjA7cGFkZGluZy1ib3R0b206NzkuNTglO30vKiFzYyovIC5wUllMbC5wUllMbC5wUllMbC5wUllMbHtoZWlnaHQ6MDtwYWRkaW5nLWJvdHRvbTo1MS43NSU7fS8qIXNjKi8gLkpGbWdSLkpGbWdSLkpGbWdSLkpGbWdSe2hlaWdodDowO3BhZGRpbmctYm90dG9tOjEwOS4yJTt9Lyohc2MqLyAuZHdvRmhpLmR3b0ZoaS5kd29GaGkuZHdvRmhpe2hlaWdodDowO3BhZGRpbmctYm90dG9tOjU3Ljk2JTt9Lyohc2MqLyAuaVlPa29rLmlZT2tvay5pWU9rb2suaVlPa29re2hlaWdodDowO3BhZGRpbmctYm90dG9tOjUxLjg3JTt9Lyohc2MqLyAuZ3hwSVJWLmd4cElSVi5neHBJUlYuZ3hwSVJWe2hlaWdodDowO3BhZGRpbmctYm90dG9tOjU1LjQ2JTt9Lyohc2MqLyAuZW5NVU8uZW5NVU8uZW5NVU8uZW5NVU97aGVpZ2h0OjA7cGFkZGluZy1ib3R0b206OTEuNTQlO30vKiFzYyovIC5iQ0JuTHYuYkNCbkx2LmJDQm5Mdi5iQ0JuTHZ7aGVpZ2h0OjA7cGFkZGluZy1ib3R0b206NTcuMzElO30vKiFzYyovIC5oTHFvaGQuaExxb2hkLmhMcW9oZC5oTHFvaGR7aGVpZ2h0OjA7cGFkZGluZy1ib3R0b206NjQuMzclO30vKiFzYyovIC5mb1FSS1ouZm9RUktaLmZvUVJLWi5mb1FSS1p7aGVpZ2h0OjA7cGFkZGluZy1ib3R0b206MTE5LjY1JTt9Lyohc2MqLyAua0xaVXlmLmtMWlV5Zi5rTFpVeWYua0xaVXlme2hlaWdodDowO3BhZGRpbmctYm90dG9tOjYwLjkzJTt9Lyohc2MqLyAuaXhoQU14Lml4aEFNeC5peGhBTXguaXhoQU14e2hlaWdodDowO3BhZGRpbmctYm90dG9tOjU0LjQzJTt9Lyohc2MqLyAuZ0NnWEZYLmdDZ1hGWC5nQ2dYRlguZ0NnWEZYe2hlaWdodDowO3BhZGRpbmctYm90dG9tOjg5LjA1JTt9Lyohc2MqLyAuaUdxUExCLmlHcVBMQi5pR3FQTEIuaUdxUExCe2hlaWdodDowO3BhZGRpbmctYm90dG9tOjgwJTt9Lyohc2MqLyAuU3BKUmEuU3BKUmEuU3BKUmEuU3BKUmF7aGVpZ2h0OjA7cGFkZGluZy1ib3R0b206NzcuMzYlO30vKiFzYyovIC5lQVlYWS5lQVlYWS5lQVlYWS5lQVlYWXtoZWlnaHQ6MDtwYWRkaW5nLWJvdHRvbTo1OC43NSU7fS8qIXNjKi8gLmpKRHVOcy5qSkR1TnMuakpEdU5zLmpKRHVOc3toZWlnaHQ6MDtwYWRkaW5nLWJvdHRvbTo1Ny41JTt9Lyohc2MqLyAuYlpJY09kLmJaSWNPZC5iWkljT2QuYlpJY09ke2hlaWdodDowO3BhZGRpbmctYm90dG9tOjU5LjA2JTt9Lyohc2MqLyAuZ2pBb2xyLmdqQW9sci5nakFvbHIuZ2pBb2xye2hlaWdodDowO3BhZGRpbmctYm90dG9tOjUzLjc1JTt9Lyohc2MqLyBkYXRhLXN0eWxlZC5nMzY3W2lkPVwieF9fc2MtMWFuN3Z1MS0wXCJde2NvbnRlbnQ6XCJmakp5dkUsZXpWWm9NLGZuUURIYixiY2pxc00sRnZJYnosa3ZpQXJ5LGJveXhnZCxqbEdwRncsakFTa05ELGpsa0dydixrZFN0bEQsZEhHd2hDLGZYelp5WixsbFdteEksYm5iWUZ6LHJIU0diLGhHTU5sSyxpdUpPdUosaHBaUFFtLFlUSWtJLGxtZGpuVixpZEtDSHMsaHlUS0xNLHBSWUxsLEpGbWdSLGR3b0ZoaSxpWU9rb2ssZ3hwSVJWLGVuTVVPLGJDQm5MdixoTHFvaGQsZm9RUktaLGtMWlV5ZixpeGhBTXgsZ0NnWEZYLGlHcVBMQixTcEpSYSxlQVlYWSxqSkR1TnMsYlpJY09kLGdqQW9scixcIn0vKiFzYyovIC5qaUdWVmouamlHVlZqLmppR1ZWai5qaUdWVmp7Zm9udC1zaXplOjMuNWVtIWltcG9ydGFudDt9Lyohc2MqLyBAbWVkaWEgb25seSBzY3JlZW4gYW5kIChtYXgtd2lkdGg6NjQwcHgpey5qaUdWVmouamlHVlZqLmppR1ZWai5qaUdWVmp7Zm9udC1zaXplOjEuMmVtIWltcG9ydGFudDt9fS8qIXNjKi8gLmJXU25WUy5iV1NuVlMuYldTblZTLmJXU25WU3tmb250LXNpemU6My45ZW0haW1wb3J0YW50O30vKiFzYyovIEBtZWRpYSBvbmx5IHNjcmVlbiBhbmQgKG1heC13aWR0aDo2NDBweCl7LmJXU25WUy5iV1NuVlMuYldTblZTLmJXU25WU3tmb250LXNpemU6MS4zZW0haW1wb3J0YW50O319Lyohc2MqLyAuaHJWY0ROLmhyVmNETi5oclZjRE4uaHJWY0ROe2ZvbnQtc2l6ZTo0LjllbSFpbXBvcnRhbnQ7fS8qIXNjKi8gQG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAobWF4LXdpZHRoOjY0MHB4KXsuaHJWY0ROLmhyVmNETi5oclZjRE4uaHJWY0ROe2ZvbnQtc2l6ZToxLjdlbSFpbXBvcnRhbnQ7fX0vKiFzYyovIC5nUEl4ZWEuZ1BJeGVhLmdQSXhlYS5nUEl4ZWF7Zm9udC1zaXplOjMuM2VtIWltcG9ydGFudDt9Lyohc2MqLyBAbWVkaWEgb25seSBzY3JlZW4gYW5kIChtYXgtd2lkdGg6NjQwcHgpey5nUEl4ZWEuZ1BJeGVhLmdQSXhlYS5nUEl4ZWF7Zm9udC1zaXplOjEuMWVtIWltcG9ydGFudDt9fS8qIXNjKi8gLmRCV1FSaS5kQldRUmkuZEJXUVJpLmRCV1FSaXtmb250LXNpemU6NC43ZW0haW1wb3J0YW50O30vKiFzYyovIEBtZWRpYSBvbmx5IHNjcmVlbiBhbmQgKG1heC13aWR0aDo2NDBweCl7LmRCV1FSaS5kQldRUmkuZEJXUVJpLmRCV1FSaXtmb250LXNpemU6MS42ZW0haW1wb3J0YW50O319Lyohc2MqLyAuYnd6d0JYLmJ3endCWC5id3p3QlguYnd6d0JYe2ZvbnQtc2l6ZTo1LjFlbSFpbXBvcnRhbnQ7fS8qIXNjKi8gQG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAobWF4LXdpZHRoOjY0MHB4KXsuYnd6d0JYLmJ3endCWC5id3p3QlguYnd6d0JYe2ZvbnQtc2l6ZToxLjhlbSFpbXBvcnRhbnQ7fX0vKiFzYyovIC5mdGV0U1EuZnRldFNRLmZ0ZXRTUS5mdGV0U1F7Zm9udC1zaXplOjQuOGVtIWltcG9ydGFudDt9Lyohc2MqLyBAbWVkaWEgb25seSBzY3JlZW4gYW5kIChtYXgtd2lkdGg6NjQwcHgpey5mdGV0U1EuZnRldFNRLmZ0ZXRTUS5mdGV0U1F7Zm9udC1zaXplOjEuN2VtIWltcG9ydGFudDt9fS8qIXNjKi8gLmZaSkZ2cS5mWkpGdnEuZlpKRnZxLmZaSkZ2cXtmb250LXNpemU6Ny45ZW0haW1wb3J0YW50O30vKiFzYyovIEBtZWRpYSBvbmx5IHNjcmVlbiBhbmQgKG1heC13aWR0aDo2NDBweCl7LmZaSkZ2cS5mWkpGdnEuZlpKRnZxLmZaSkZ2cXtmb250LXNpemU6Mi44ZW0haW1wb3J0YW50O319Lyohc2MqLyAuY0dMclNHLmNHTHJTRy5jR0xyU0cuY0dMclNHe2ZvbnQtc2l6ZTo0LjNlbSFpbXBvcnRhbnQ7fS8qIXNjKi8gQG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAobWF4LXdpZHRoOjY0MHB4KXsuY0dMclNHLmNHTHJTRy5jR0xyU0cuY0dMclNHe2ZvbnQtc2l6ZToxLjZlbSFpbXBvcnRhbnQ7fX0vKiFzYyovIC5pbmtzRVYuaW5rc0VWLmlua3NFVi5pbmtzRVZ7Zm9udC1zaXplOjMuNmVtIWltcG9ydGFudDt9Lyohc2MqLyBAbWVkaWEgb25seSBzY3JlZW4gYW5kIChtYXgtd2lkdGg6NjQwcHgpey5pbmtzRVYuaW5rc0VWLmlua3NFVi5pbmtzRVZ7Zm9udC1zaXplOjEuM2VtIWltcG9ydGFudDt9fS8qIXNjKi8gLmVtYXhiYi5lbWF4YmIuZW1heGJiLmVtYXhiYntmb250LXNpemU6NC43ZW0haW1wb3J0YW50O30vKiFzYyovIEBtZWRpYSBvbmx5IHNjcmVlbiBhbmQgKG1heC13aWR0aDo2NDBweCl7LmVtYXhiYi5lbWF4YmIuZW1heGJiLmVtYXhiYntmb250LXNpemU6MS43ZW0haW1wb3J0YW50O319Lyohc2MqLyAuYnh0dVpKLmJ4dHVaSi5ieHR1WkouYnh0dVpKe2ZvbnQtc2l6ZTo1LjZlbSFpbXBvcnRhbnQ7fS8qIXNjKi8gQG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAobWF4LXdpZHRoOjY0MHB4KXsuYnh0dVpKLmJ4dHVaSi5ieHR1WkouYnh0dVpKe2ZvbnQtc2l6ZToyZW0haW1wb3J0YW50O319Lyohc2MqLyAuZEx3cWhKLmRMd3FoSi5kTHdxaEouZEx3cWhKe2ZvbnQtc2l6ZTozLjllbSFpbXBvcnRhbnQ7fS8qIXNjKi8gQG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAobWF4LXdpZHRoOjY0MHB4KXsuZEx3cWhKLmRMd3FoSi5kTHdxaEouZEx3cWhKe2ZvbnQtc2l6ZToxLjRlbSFpbXBvcnRhbnQ7fX0vKiFzYyovIC5jVmxMRWQuY1ZsTEVkLmNWbExFZC5jVmxMRWR7Zm9udC1zaXplOjIuOWVtIWltcG9ydGFudDt9Lyohc2MqLyBAbWVkaWEgb25seSBzY3JlZW4gYW5kIChtYXgtd2lkdGg6NjQwcHgpey5jVmxMRWQuY1ZsTEVkLmNWbExFZC5jVmxMRWR7Zm9udC1zaXplOjEuMWVtIWltcG9ydGFudDt9fS8qIXNjKi8gLmN5Vlh6Zi5jeVZYemYuY3lWWHpmLmN5Vlh6Zntmb250LXNpemU6Mi4zZW0haW1wb3J0YW50O30vKiFzYyovIEBtZWRpYSBvbmx5IHNjcmVlbiBhbmQgKG1heC13aWR0aDo2NDBweCl7LmN5Vlh6Zi5jeVZYemYuY3lWWHpmLmN5Vlh6Zntmb250LXNpemU6MC44ZW0haW1wb3J0YW50O319Lyohc2MqLyAuaW9hLURnQy5pb2EtRGdDLmlvYS1EZ0MuaW9hLURnQ3tmb250LXNpemU6NC41ZW0haW1wb3J0YW50O30vKiFzYyovIEBtZWRpYSBvbmx5IHNjcmVlbiBhbmQgKG1heC13aWR0aDo2NDBweCl7LmlvYS1EZ0MuaW9hLURnQy5pb2EtRGdDLmlvYS1EZ0N7Zm9udC1zaXplOjEuNGVtIWltcG9ydGFudDt9fS8qIXNjKi8gLmNKY05Jbi5jSmNOSW4uY0pjTkluLmNKY05Jbntmb250LXNpemU6NC41ZW0haW1wb3J0YW50O30vKiFzYyovIEBtZWRpYSBvbmx5IHNjcmVlbiBhbmQgKG1heC13aWR0aDo2NDBweCl7LmNKY05Jbi5jSmNOSW4uY0pjTkluLmNKY05Jbntmb250LXNpemU6MS41ZW0haW1wb3J0YW50O319Lyohc2MqLyAuakdTVGR6LmpHU1Rkei5qR1NUZHouakdTVGR6e2ZvbnQtc2l6ZTo0LjZlbSFpbXBvcnRhbnQ7fS8qIXNjKi8gQG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAobWF4LXdpZHRoOjY0MHB4KXsuakdTVGR6LmpHU1Rkei5qR1NUZHouakdTVGR6e2ZvbnQtc2l6ZToxLjZlbSFpbXBvcnRhbnQ7fX0vKiFzYyovIC5ia2drZHAuYmtna2RwLmJrZ2tkcC5ia2drZHB7Zm9udC1zaXplOjQuOGVtIWltcG9ydGFudDt9Lyohc2MqLyBAbWVkaWEgb25seSBzY3JlZW4gYW5kIChtYXgtd2lkdGg6NjQwcHgpey5ia2drZHAuYmtna2RwLmJrZ2tkcC5ia2drZHB7Zm9udC1zaXplOjEuNmVtIWltcG9ydGFudDt9fS8qIXNjKi8gLmtOaEdnWC5rTmhHZ1gua05oR2dYLmtOaEdnWHtmb250LXNpemU6My44ZW0haW1wb3J0YW50O30vKiFzYyovIEBtZWRpYSBvbmx5IHNjcmVlbiBhbmQgKG1heC13aWR0aDo2NDBweCl7LmtOaEdnWC5rTmhHZ1gua05oR2dYLmtOaEdnWHtmb250LXNpemU6MS4zZW0haW1wb3J0YW50O319Lyohc2MqLyAud3BXTEcud3BXTEcud3BXTEcud3BXTEd7Zm9udC1zaXplOjMuNGVtIWltcG9ydGFudDt9Lyohc2MqLyBAbWVkaWEgb25seSBzY3JlZW4gYW5kIChtYXgtd2lkdGg6NjQwcHgpey53cFdMRy53cFdMRy53cFdMRy53cFdMR3tmb250LXNpemU6MS4yZW0haW1wb3J0YW50O319Lyohc2MqLyAuZEplbnJFLmRKZW5yRS5kSmVuckUuZEplbnJFe2ZvbnQtc2l6ZTo2LjVlbSFpbXBvcnRhbnQ7fS8qIXNjKi8gQG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAobWF4LXdpZHRoOjY0MHB4KXsuZEplbnJFLmRKZW5yRS5kSmVuckUuZEplbnJFe2ZvbnQtc2l6ZToyLjNlbSFpbXBvcnRhbnQ7fX0vKiFzYyovIC5jbmFLa00uY25hS2tNLmNuYUtrTS5jbmFLa017Zm9udC1zaXplOjIuNWVtIWltcG9ydGFudDt9Lyohc2MqLyBAbWVkaWEgb25seSBzY3JlZW4gYW5kIChtYXgtd2lkdGg6NjQwcHgpey5jbmFLa00uY25hS2tNLmNuYUtrTS5jbmFLa017Zm9udC1zaXplOjAuOWVtIWltcG9ydGFudDt9fS8qIXNjKi8gLnpXc2NFLnpXc2NFLnpXc2NFLnpXc2NFe2ZvbnQtc2l6ZToyLjNlbSFpbXBvcnRhbnQ7fS8qIXNjKi8gQG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAobWF4LXdpZHRoOjY0MHB4KXsueldzY0UueldzY0UueldzY0UueldzY0V7Zm9udC1zaXplOjAuN2VtIWltcG9ydGFudDt9fS8qIXNjKi8gLmpDa0x2Uy5qQ2tMdlMuakNrTHZTLmpDa0x2U3tmb250LXNpemU6Ny4zZW0haW1wb3J0YW50O30vKiFzYyovIEBtZWRpYSBvbmx5IHNjcmVlbiBhbmQgKG1heC13aWR0aDo2NDBweCl7LmpDa0x2Uy5qQ2tMdlMuakNrTHZTLmpDa0x2U3tmb250LXNpemU6Mi42ZW0haW1wb3J0YW50O319Lyohc2MqLyAuZXJwQ2hvLmVycENoby5lcnBDaG8uZXJwQ2hve2ZvbnQtc2l6ZToyLjdlbSFpbXBvcnRhbnQ7fS8qIXNjKi8gQG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAobWF4LXdpZHRoOjY0MHB4KXsuZXJwQ2hvLmVycENoby5lcnBDaG8uZXJwQ2hve2ZvbnQtc2l6ZToxZW0haW1wb3J0YW50O319Lyohc2MqLyAuYnZYcVhuLmJ2WHFYbi5idlhxWG4uYnZYcVhue2ZvbnQtc2l6ZTozLjdlbSFpbXBvcnRhbnQ7fS8qIXNjKi8gQG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAobWF4LXdpZHRoOjY0MHB4KXsuYnZYcVhuLmJ2WHFYbi5idlhxWG4uYnZYcVhue2ZvbnQtc2l6ZToxLjRlbSFpbXBvcnRhbnQ7fX0vKiFzYyovIC5pS2FsaFAuaUthbGhQLmlLYWxoUC5pS2FsaFB7Zm9udC1zaXplOjcuN2VtIWltcG9ydGFudDt9Lyohc2MqLyBAbWVkaWEgb25seSBzY3JlZW4gYW5kIChtYXgtd2lkdGg6NjQwcHgpey5pS2FsaFAuaUthbGhQLmlLYWxoUC5pS2FsaFB7Zm9udC1zaXplOjIuN2VtIWltcG9ydGFudDt9fS8qIXNjKi8gLmpFaHZ0dy5qRWh2dHcuakVodnR3LmpFaHZ0d3tmb250LXNpemU6My4xZW0haW1wb3J0YW50O30vKiFzYyovIEBtZWRpYSBvbmx5IHNjcmVlbiBhbmQgKG1heC13aWR0aDo2NDBweCl7LmpFaHZ0dy5qRWh2dHcuakVodnR3LmpFaHZ0d3tmb250LXNpemU6MS4xZW0haW1wb3J0YW50O319Lyohc2MqLyAuZERLZURRLmRES2VEUS5kREtlRFEuZERLZURRe2ZvbnQtc2l6ZToxLjllbSFpbXBvcnRhbnQ7fS8qIXNjKi8gQG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAobWF4LXdpZHRoOjY0MHB4KXsuZERLZURRLmRES2VEUS5kREtlRFEuZERLZURRe2ZvbnQtc2l6ZTowLjZlbSFpbXBvcnRhbnQ7fX0vKiFzYyovIC5jRnRDTi5jRnRDTi5jRnRDTi5jRnRDTntmb250LXNpemU6Mi4yZW0haW1wb3J0YW50O30vKiFzYyovIEBtZWRpYSBvbmx5IHNjcmVlbiBhbmQgKG1heC13aWR0aDo2NDBweCl7LmNGdENOLmNGdENOLmNGdENOLmNGdENOe2ZvbnQtc2l6ZTowLjdlbSFpbXBvcnRhbnQ7fX0vKiFzYyovIC5lUW9WYVMuZVFvVmFTLmVRb1ZhUy5lUW9WYVN7Zm9udC1zaXplOjUuNWVtIWltcG9ydGFudDt9Lyohc2MqLyBAbWVkaWEgb25seSBzY3JlZW4gYW5kIChtYXgtd2lkdGg6NjQwcHgpey5lUW9WYVMuZVFvVmFTLmVRb1ZhUy5lUW9WYVN7Zm9udC1zaXplOjJlbSFpbXBvcnRhbnQ7fX0vKiFzYyovIC5lUHVTd08uZVB1U3dPLmVQdVN3Ty5lUHVTd097Zm9udC1zaXplOjguM2VtIWltcG9ydGFudDt9Lyohc2MqLyBAbWVkaWEgb25seSBzY3JlZW4gYW5kIChtYXgtd2lkdGg6NjQwcHgpey5lUHVTd08uZVB1U3dPLmVQdVN3Ty5lUHVTd097Zm9udC1zaXplOjIuOWVtIWltcG9ydGFudDt9fS8qIXNjKi8gLmRRU0NCUi5kUVNDQlIuZFFTQ0JSLmRRU0NCUntmb250LXNpemU6Ni43ZW0haW1wb3J0YW50O30vKiFzYyovIEBtZWRpYSBvbmx5IHNjcmVlbiBhbmQgKG1heC13aWR0aDo2NDBweCl7LmRRU0NCUi5kUVNDQlIuZFFTQ0JSLmRRU0NCUntmb250LXNpemU6Mi40ZW0haW1wb3J0YW50O319Lyohc2MqLyAuZVlHQ2tkLmVZR0NrZC5lWUdDa2QuZVlHQ2tke2ZvbnQtc2l6ZTo3LjdlbSFpbXBvcnRhbnQ7fS8qIXNjKi8gQG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAobWF4LXdpZHRoOjY0MHB4KXsuZVlHQ2tkLmVZR0NrZC5lWUdDa2QuZVlHQ2tke2ZvbnQtc2l6ZToyLjllbSFpbXBvcnRhbnQ7fX0vKiFzYyovIC5pamljZHouaWppY2R6LmlqaWNkei5pamljZHp7Zm9udC1zaXplOjIuOGVtIWltcG9ydGFudDt9Lyohc2MqLyBAbWVkaWEgb25seSBzY3JlZW4gYW5kIChtYXgtd2lkdGg6NjQwcHgpey5pamljZHouaWppY2R6LmlqaWNkei5pamljZHp7Zm9udC1zaXplOjFlbSFpbXBvcnRhbnQ7fX0vKiFzYyovIC5oakdLS3EuaGpHS0txLmhqR0tLcS5oakdLS3F7Zm9udC1zaXplOjYuN2VtIWltcG9ydGFudDt9Lyohc2MqLyBAbWVkaWEgb25seSBzY3JlZW4gYW5kIChtYXgtd2lkdGg6NjQwcHgpey5oakdLS3EuaGpHS0txLmhqR0tLcS5oakdLS3F7Zm9udC1zaXplOjIuM2VtIWltcG9ydGFudDt9fS8qIXNjKi8gLmpZS3h6WC5qWUt4elguallLeHpYLmpZS3h6WHtmb250LXNpemU6MTAuMWVtIWltcG9ydGFudDt9Lyohc2MqLyBAbWVkaWEgb25seSBzY3JlZW4gYW5kIChtYXgtd2lkdGg6NjQwcHgpey5qWUt4elguallLeHpYLmpZS3h6WC5qWUt4elh7Zm9udC1zaXplOjMuNmVtIWltcG9ydGFudDt9fS8qIXNjKi8gLmhzUGVpYS5oc1BlaWEuaHNQZWlhLmhzUGVpYXtmb250LXNpemU6NC4xZW0haW1wb3J0YW50O30vKiFzYyovIEBtZWRpYSBvbmx5IHNjcmVlbiBhbmQgKG1heC13aWR0aDo2NDBweCl7LmhzUGVpYS5oc1BlaWEuaHNQZWlhLmhzUGVpYXtmb250LXNpemU6MS40ZW0haW1wb3J0YW50O319Lyohc2MqLyAuZGZzZXJQLmRmc2VyUC5kZnNlclAuZGZzZXJQe2ZvbnQtc2l6ZTozLjFlbSFpbXBvcnRhbnQ7fS8qIXNjKi8gQG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAobWF4LXdpZHRoOjY0MHB4KXsuZGZzZXJQLmRmc2VyUC5kZnNlclAuZGZzZXJQe2ZvbnQtc2l6ZToxZW0haW1wb3J0YW50O319Lyohc2MqLyAuakpybk5mLmpKcm5OZi5qSnJuTmYuakpybk5me2ZvbnQtc2l6ZTo1LjdlbSFpbXBvcnRhbnQ7fS8qIXNjKi8gQG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAobWF4LXdpZHRoOjY0MHB4KXsuakpybk5mLmpKcm5OZi5qSnJuTmYuakpybk5me2ZvbnQtc2l6ZToyLjFlbSFpbXBvcnRhbnQ7fX0vKiFzYyovIC5pWGpkTFkuaVhqZExZLmlYamRMWS5pWGpkTFl7Zm9udC1zaXplOjQuNWVtIWltcG9ydGFudDt9Lyohc2MqLyBAbWVkaWEgb25seSBzY3JlZW4gYW5kIChtYXgtd2lkdGg6NjQwcHgpey5pWGpkTFkuaVhqZExZLmlYamRMWS5pWGpkTFl7Zm9udC1zaXplOjEuNmVtIWltcG9ydGFudDt9fS8qIXNjKi8gLmRXek1uQS5kV3pNbkEuZFd6TW5BLmRXek1uQXtmb250LXNpemU6NS43ZW0haW1wb3J0YW50O30vKiFzYyovIEBtZWRpYSBvbmx5IHNjcmVlbiBhbmQgKG1heC13aWR0aDo2NDBweCl7LmRXek1uQS5kV3pNbkEuZFd6TW5BLmRXek1uQXtmb250LXNpemU6MmVtIWltcG9ydGFudDt9fS8qIXNjKi8gLmZORGhEeS5mTkRoRHkuZk5EaER5LmZORGhEeXtmb250LXNpemU6Mi43ZW0haW1wb3J0YW50O30vKiFzYyovIEBtZWRpYSBvbmx5IHNjcmVlbiBhbmQgKG1heC13aWR0aDo2NDBweCl7LmZORGhEeS5mTkRoRHkuZk5EaER5LmZORGhEeXtmb250LXNpemU6MC45ZW0haW1wb3J0YW50O319Lyohc2MqLyAuY3RXcU5zLmN0V3FOcy5jdFdxTnMuY3RXcU5ze2ZvbnQtc2l6ZTo3ZW0haW1wb3J0YW50O30vKiFzYyovIEBtZWRpYSBvbmx5IHNjcmVlbiBhbmQgKG1heC13aWR0aDo2NDBweCl7LmN0V3FOcy5jdFdxTnMuY3RXcU5zLmN0V3FOc3tmb250LXNpemU6Mi41ZW0haW1wb3J0YW50O319Lyohc2MqLyAuZkZBaVRLLmZGQWlUSy5mRkFpVEsuZkZBaVRLe2ZvbnQtc2l6ZTo1LjVlbSFpbXBvcnRhbnQ7fS8qIXNjKi8gQG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAobWF4LXdpZHRoOjY0MHB4KXsuZkZBaVRLLmZGQWlUSy5mRkFpVEsuZkZBaVRLe2ZvbnQtc2l6ZToxLjllbSFpbXBvcnRhbnQ7fX0vKiFzYyovIC5rd0x1YUIua3dMdWFCLmt3THVhQi5rd0x1YUJ7Zm9udC1zaXplOjJlbSFpbXBvcnRhbnQ7fS8qIXNjKi8gQG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAobWF4LXdpZHRoOjY0MHB4KXsua3dMdWFCLmt3THVhQi5rd0x1YUIua3dMdWFCe2ZvbnQtc2l6ZTowLjdlbSFpbXBvcnRhbnQ7fX0vKiFzYyovIC5pTkh5aWUuaU5IeWllLmlOSHlpZS5pTkh5aWV7Zm9udC1zaXplOjIuMWVtIWltcG9ydGFudDt9Lyohc2MqLyBAbWVkaWEgb25seSBzY3JlZW4gYW5kIChtYXgtd2lkdGg6NjQwcHgpey5pTkh5aWUuaU5IeWllLmlOSHlpZS5pTkh5aWV7Zm9udC1zaXplOjAuN2VtIWltcG9ydGFudDt9fS8qIXNjKi8gLmpYREJBVC5qWERCQVQualhEQkFULmpYREJBVHtmb250LXNpemU6My42ZW0haW1wb3J0YW50O30vKiFzYyovIEBtZWRpYSBvbmx5IHNjcmVlbiBhbmQgKG1heC13aWR0aDo2NDBweCl7LmpYREJBVC5qWERCQVQualhEQkFULmpYREJBVHtmb250LXNpemU6MS4xZW0haW1wb3J0YW50O319Lyohc2MqLyAuY1ptb3RNLmNabW90TS5jWm1vdE0uY1ptb3RNe2ZvbnQtc2l6ZToyLjllbSFpbXBvcnRhbnQ7fS8qIXNjKi8gQG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAobWF4LXdpZHRoOjY0MHB4KXsuY1ptb3RNLmNabW90TS5jWm1vdE0uY1ptb3RNe2ZvbnQtc2l6ZTowLjllbSFpbXBvcnRhbnQ7fX0vKiFzYyovIC5qZnZNV0ouamZ2TVdKLmpmdk1XSi5qZnZNV0p7Zm9udC1zaXplOjIuOGVtIWltcG9ydGFudDt9Lyohc2MqLyBAbWVkaWEgb25seSBzY3JlZW4gYW5kIChtYXgtd2lkdGg6NjQwcHgpey5qZnZNV0ouamZ2TVdKLmpmdk1XSi5qZnZNV0p7Zm9udC1zaXplOjAuOWVtIWltcG9ydGFudDt9fS8qIXNjKi8gLmhlanVRRC5oZWp1UUQuaGVqdVFELmhlanVRRHtmb250LXNpemU6Ni41ZW0haW1wb3J0YW50O30vKiFzYyovIEBtZWRpYSBvbmx5IHNjcmVlbiBhbmQgKG1heC13aWR0aDo2NDBweCl7LmhlanVRRC5oZWp1UUQuaGVqdVFELmhlanVRRHtmb250LXNpemU6Mi40ZW0haW1wb3J0YW50O319Lyohc2MqLyAua0JPb2diLmtCT29nYi5rQk9vZ2Iua0JPb2die2ZvbnQtc2l6ZTo2ZW0haW1wb3J0YW50O30vKiFzYyovIEBtZWRpYSBvbmx5IHNjcmVlbiBhbmQgKG1heC13aWR0aDo2NDBweCl7LmtCT29nYi5rQk9vZ2Iua0JPb2diLmtCT29nYntmb250LXNpemU6Mi4zZW0haW1wb3J0YW50O319Lyohc2MqLyAua1F6cENKLmtRenBDSi5rUXpwQ0oua1F6cENKe2ZvbnQtc2l6ZTo3LjFlbSFpbXBvcnRhbnQ7fS8qIXNjKi8gQG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAobWF4LXdpZHRoOjY0MHB4KXsua1F6cENKLmtRenBDSi5rUXpwQ0oua1F6cENKe2ZvbnQtc2l6ZToyLjdlbSFpbXBvcnRhbnQ7fX0vKiFzYyovIC5kZGJDSlouZGRiQ0paLmRkYkNKWi5kZGJDSlp7Zm9udC1zaXplOjUuOWVtIWltcG9ydGFudDt9Lyohc2MqLyBAbWVkaWEgb25seSBzY3JlZW4gYW5kIChtYXgtd2lkdGg6NjQwcHgpey5kZGJDSlouZGRiQ0paLmRkYkNKWi5kZGJDSlp7Zm9udC1zaXplOjIuMWVtIWltcG9ydGFudDt9fS8qIXNjKi8gLmdORGlCZi5nTkRpQmYuZ05EaUJmLmdORGlCZntmb250LXNpemU6Ni42ZW0haW1wb3J0YW50O30vKiFzYyovIEBtZWRpYSBvbmx5IHNjcmVlbiBhbmQgKG1heC13aWR0aDo2NDBweCl7LmdORGlCZi5nTkRpQmYuZ05EaUJmLmdORGlCZntmb250LXNpemU6Mi4zZW0haW1wb3J0YW50O319Lyohc2MqLyAuZ1JMSndOLmdSTEp3Ti5nUkxKd04uZ1JMSndOe2ZvbnQtc2l6ZTo1LjNlbSFpbXBvcnRhbnQ7fS8qIXNjKi8gQG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAobWF4LXdpZHRoOjY0MHB4KXsuZ1JMSndOLmdSTEp3Ti5nUkxKd04uZ1JMSndOe2ZvbnQtc2l6ZToxLjhlbSFpbXBvcnRhbnQ7fX0vKiFzYyovIC5kZmd2cG4uZGZndnBuLmRmZ3Zwbi5kZmd2cG57Zm9udC1zaXplOjUuNGVtIWltcG9ydGFudDt9Lyohc2MqLyBAbWVkaWEgb25seSBzY3JlZW4gYW5kIChtYXgtd2lkdGg6NjQwcHgpey5kZmd2cG4uZGZndnBuLmRmZ3Zwbi5kZmd2cG57Zm9udC1zaXplOjEuOWVtIWltcG9ydGFudDt9fS8qIXNjKi8gLmppanh1US5qaWp4dVEuamlqeHVRLmppanh1UXtmb250LXNpemU6OS4yZW0haW1wb3J0YW50O30vKiFzYyovIEBtZWRpYSBvbmx5IHNjcmVlbiBhbmQgKG1heC13aWR0aDo2NDBweCl7Lmppanh1US5qaWp4dVEuamlqeHVRLmppanh1UXtmb250LXNpemU6My4yZW0haW1wb3J0YW50O319Lyohc2MqLyAua3VrZUNzLmt1a2VDcy5rdWtlQ3Mua3VrZUNze2ZvbnQtc2l6ZTo2LjRlbSFpbXBvcnRhbnQ7fS8qIXNjKi8gQG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAobWF4LXdpZHRoOjY0MHB4KXsua3VrZUNzLmt1a2VDcy5rdWtlQ3Mua3VrZUNze2ZvbnQtc2l6ZToyLjJlbSFpbXBvcnRhbnQ7fX0vKiFzYyovIC5iV3p6a1UuYld6emtVLmJXenprVS5iV3p6a1V7Zm9udC1zaXplOjcuNWVtIWltcG9ydGFudDt9Lyohc2MqLyBAbWVkaWEgb25seSBzY3JlZW4gYW5kIChtYXgtd2lkdGg6NjQwcHgpey5iV3p6a1UuYld6emtVLmJXenprVS5iV3p6a1V7Zm9udC1zaXplOjIuNmVtIWltcG9ydGFudDt9fS8qIXNjKi8gLmlGbEVtSy5pRmxFbUsuaUZsRW1LLmlGbEVtS3tmb250LXNpemU6Mi45ZW0haW1wb3J0YW50O30vKiFzYyovIEBtZWRpYSBvbmx5IHNjcmVlbiBhbmQgKG1heC13aWR0aDo2NDBweCl7LmlGbEVtSy5pRmxFbUsuaUZsRW1LLmlGbEVtS3tmb250LXNpemU6MWVtIWltcG9ydGFudDt9fS8qIXNjKi8gLmRBLURvaHouZEEtRG9oei5kQS1Eb2h6LmRBLURvaHp7Zm9udC1zaXplOjcuOGVtIWltcG9ydGFudDt9Lyohc2MqLyBAbWVkaWEgb25seSBzY3JlZW4gYW5kIChtYXgtd2lkdGg6NjQwcHgpey5kQS1Eb2h6LmRBLURvaHouZEEtRG9oei5kQS1Eb2h6e2ZvbnQtc2l6ZToyLjhlbSFpbXBvcnRhbnQ7fX0vKiFzYyovIC5mZ1lZWEYuZmdZWVhGLmZnWVlYRi5mZ1lZWEZ7Zm9udC1zaXplOjExLjZlbSFpbXBvcnRhbnQ7fS8qIXNjKi8gQG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAobWF4LXdpZHRoOjY0MHB4KXsuZmdZWVhGLmZnWVlYRi5mZ1lZWEYuZmdZWVhGe2ZvbnQtc2l6ZTo0LjFlbSFpbXBvcnRhbnQ7fX0vKiFzYyovIC5nVlJXQUIuZ1ZSV0FCLmdWUldBQi5nVlJXQUJ7Zm9udC1zaXplOjQuM2VtIWltcG9ydGFudDt9Lyohc2MqLyBAbWVkaWEgb25seSBzY3JlZW4gYW5kIChtYXgtd2lkdGg6NjQwcHgpey5nVlJXQUIuZ1ZSV0FCLmdWUldBQi5nVlJXQUJ7Zm9udC1zaXplOjEuNWVtIWltcG9ydGFudDt9fS8qIXNjKi8gLmJlRE5wWi5iZUROcFouYmVETnBaLmJlRE5wWntmb250LXNpemU6MS44ZW0haW1wb3J0YW50O30vKiFzYyovIEBtZWRpYSBvbmx5IHNjcmVlbiBhbmQgKG1heC13aWR0aDo2NDBweCl7LmJlRE5wWi5iZUROcFouYmVETnBaLmJlRE5wWntmb250LXNpemU6MC42ZW0haW1wb3J0YW50O319Lyohc2MqLyAuaFJYYVhyLmhSWGFYci5oUlhhWHIuaFJYYVhye2ZvbnQtc2l6ZTo0LjRlbSFpbXBvcnRhbnQ7fS8qIXNjKi8gQG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAobWF4LXdpZHRoOjY0MHB4KXsuaFJYYVhyLmhSWGFYci5oUlhhWHIuaFJYYVhye2ZvbnQtc2l6ZToxLjRlbSFpbXBvcnRhbnQ7fX0vKiFzYyovIC5reHphS2wua3h6YUtsLmt4emFLbC5reHphS2x7Zm9udC1zaXplOjIuNmVtIWltcG9ydGFudDt9Lyohc2MqLyBAbWVkaWEgb25seSBzY3JlZW4gYW5kIChtYXgtd2lkdGg6NjQwcHgpey5reHphS2wua3h6YUtsLmt4emFLbC5reHphS2x7Zm9udC1zaXplOjFlbSFpbXBvcnRhbnQ7fX0vKiFzYyovIC5sZFRqZ0gubGRUamdILmxkVGpnSC5sZFRqZ0h7Zm9udC1zaXplOjYuOWVtIWltcG9ydGFudDt9Lyohc2MqLyBAbWVkaWEgb25seSBzY3JlZW4gYW5kIChtYXgtd2lkdGg6NjQwcHgpey5sZFRqZ0gubGRUamdILmxkVGpnSC5sZFRqZ0h7Zm9udC1zaXplOjIuNGVtIWltcG9ydGFudDt9fS8qIXNjKi8gLkx6Qm5XLkx6Qm5XLkx6Qm5XLkx6Qm5Xe2ZvbnQtc2l6ZTo0LjRlbSFpbXBvcnRhbnQ7fS8qIXNjKi8gQG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAobWF4LXdpZHRoOjY0MHB4KXsuTHpCblcuTHpCblcuTHpCblcuTHpCbld7Zm9udC1zaXplOjEuNWVtIWltcG9ydGFudDt9fS8qIXNjKi8gLmp0Q1h2QS5qdENYdkEuanRDWHZBLmp0Q1h2QXtmb250LXNpemU6NS4yZW0haW1wb3J0YW50O30vKiFzYyovIEBtZWRpYSBvbmx5IHNjcmVlbiBhbmQgKG1heC13aWR0aDo2NDBweCl7Lmp0Q1h2QS5qdENYdkEuanRDWHZBLmp0Q1h2QXtmb250LXNpemU6MS44ZW0haW1wb3J0YW50O319Lyohc2MqLyAuZFBvZUZvLmRQb2VGby5kUG9lRm8uZFBvZUZve2ZvbnQtc2l6ZToyZW0haW1wb3J0YW50O30vKiFzYyovIEBtZWRpYSBvbmx5IHNjcmVlbiBhbmQgKG1heC13aWR0aDo2NDBweCl7LmRQb2VGby5kUG9lRm8uZFBvZUZvLmRQb2VGb3tmb250LXNpemU6MC42ZW0haW1wb3J0YW50O319Lyohc2MqLyAuYndHUXJ0LmJ3R1FydC5id0dRcnQuYndHUXJ0e2ZvbnQtc2l6ZTozLjRlbSFpbXBvcnRhbnQ7fS8qIXNjKi8gQG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAobWF4LXdpZHRoOjY0MHB4KXsuYndHUXJ0LmJ3R1FydC5id0dRcnQuYndHUXJ0e2ZvbnQtc2l6ZToxLjFlbSFpbXBvcnRhbnQ7fX0vKiFzYyovIC5oYndpa3QuaGJ3aWt0Lmhid2lrdC5oYndpa3R7Zm9udC1zaXplOjZlbSFpbXBvcnRhbnQ7fS8qIXNjKi8gQG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAobWF4LXdpZHRoOjY0MHB4KXsuaGJ3aWt0Lmhid2lrdC5oYndpa3QuaGJ3aWt0e2ZvbnQtc2l6ZToyLjFlbSFpbXBvcnRhbnQ7fX0vKiFzYyovIC5GU3NPTy5GU3NPTy5GU3NPTy5GU3NPT3tmb250LXNpemU6OS42ZW0haW1wb3J0YW50O30vKiFzYyovIEBtZWRpYSBvbmx5IHNjcmVlbiBhbmQgKG1heC13aWR0aDo2NDBweCl7LkZTc09PLkZTc09PLkZTc09PLkZTc09Pe2ZvbnQtc2l6ZTozLjRlbSFpbXBvcnRhbnQ7fX0vKiFzYyovIC5lcG9KekQuZXBvSnpELmVwb0p6RC5lcG9KekR7Zm9udC1zaXplOjMuMmVtIWltcG9ydGFudDt9Lyohc2MqLyBAbWVkaWEgb25seSBzY3JlZW4gYW5kIChtYXgtd2lkdGg6NjQwcHgpey5lcG9KekQuZXBvSnpELmVwb0p6RC5lcG9KekR7Zm9udC1zaXplOjEuMWVtIWltcG9ydGFudDt9fS8qIXNjKi8gLmtWSk5QUi5rVkpOUFIua1ZKTlBSLmtWSk5QUntmb250LXNpemU6Mi41ZW0haW1wb3J0YW50O30vKiFzYyovIEBtZWRpYSBvbmx5IHNjcmVlbiBhbmQgKG1heC13aWR0aDo2NDBweCl7LmtWSk5QUi5rVkpOUFIua1ZKTlBSLmtWSk5QUntmb250LXNpemU6MC44ZW0haW1wb3J0YW50O319Lyohc2MqLyAuaVlnQnZBLmlZZ0J2QS5pWWdCdkEuaVlnQnZBe2ZvbnQtc2l6ZToyLjRlbSFpbXBvcnRhbnQ7fS8qIXNjKi8gQG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAobWF4LXdpZHRoOjY0MHB4KXsuaVlnQnZBLmlZZ0J2QS5pWWdCdkEuaVlnQnZBe2ZvbnQtc2l6ZTowLjhlbSFpbXBvcnRhbnQ7fX0vKiFzYyovIC5mSWV5Q3guZklleUN4LmZJZXlDeC5mSWV5Q3h7Zm9udC1zaXplOjMuN2VtIWltcG9ydGFudDt9Lyohc2MqLyBAbWVkaWEgb25seSBzY3JlZW4gYW5kIChtYXgtd2lkdGg6NjQwcHgpey5mSWV5Q3guZklleUN4LmZJZXlDeC5mSWV5Q3h7Zm9udC1zaXplOjEuMmVtIWltcG9ydGFudDt9fS8qIXNjKi8gLmtMQnZmdC5rTEJ2ZnQua0xCdmZ0LmtMQnZmdHtmb250LXNpemU6Ny40ZW0haW1wb3J0YW50O30vKiFzYyovIEBtZWRpYSBvbmx5IHNjcmVlbiBhbmQgKG1heC13aWR0aDo2NDBweCl7LmtMQnZmdC5rTEJ2ZnQua0xCdmZ0LmtMQnZmdHtmb250LXNpemU6Mi42ZW0haW1wb3J0YW50O319Lyohc2MqLyAuaFF4QVlQLmhReEFZUC5oUXhBWVAuaFF4QVlQe2ZvbnQtc2l6ZTo1LjhlbSFpbXBvcnRhbnQ7fS8qIXNjKi8gQG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAobWF4LXdpZHRoOjY0MHB4KXsuaFF4QVlQLmhReEFZUC5oUXhBWVAuaFF4QVlQe2ZvbnQtc2l6ZToyZW0haW1wb3J0YW50O319Lyohc2MqLyAuY0tsU0lDLmNLbFNJQy5jS2xTSUMuY0tsU0lDe2ZvbnQtc2l6ZTozLjVlbSFpbXBvcnRhbnQ7fS8qIXNjKi8gQG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAobWF4LXdpZHRoOjY0MHB4KXsuY0tsU0lDLmNLbFNJQy5jS2xTSUMuY0tsU0lDe2ZvbnQtc2l6ZToxLjNlbSFpbXBvcnRhbnQ7fX0vKiFzYyovIC5mbnVWT0IuZm51Vk9CLmZudVZPQi5mbnVWT0J7Zm9udC1zaXplOjIuMWVtIWltcG9ydGFudDt9Lyohc2MqLyBAbWVkaWEgb25seSBzY3JlZW4gYW5kIChtYXgtd2lkdGg6NjQwcHgpey5mbnVWT0IuZm51Vk9CLmZudVZPQi5mbnVWT0J7Zm9udC1zaXplOjAuOGVtIWltcG9ydGFudDt9fS8qIXNjKi8gLmNVWEtPRi5jVVhLT0YuY1VYS09GLmNVWEtPRntmb250LXNpemU6N2VtIWltcG9ydGFudDt9Lyohc2MqLyBAbWVkaWEgb25seSBzY3JlZW4gYW5kIChtYXgtd2lkdGg6NjQwcHgpey5jVVhLT0YuY1VYS09GLmNVWEtPRi5jVVhLT0Z7Zm9udC1zaXplOjIuNGVtIWltcG9ydGFudDt9fS8qIXNjKi8gLmJYRGd3cC5iWERnd3AuYlhEZ3dwLmJYRGd3cHtmb250LXNpemU6Ni4xZW0haW1wb3J0YW50O30vKiFzYyovIEBtZWRpYSBvbmx5IHNjcmVlbiBhbmQgKG1heC13aWR0aDo2NDBweCl7LmJYRGd3cC5iWERnd3AuYlhEZ3dwLmJYRGd3cHtmb250LXNpemU6Mi4yZW0haW1wb3J0YW50O319Lyohc2MqLyAuanpFSkFFLmp6RUpBRS5qekVKQUUuanpFSkFFe2ZvbnQtc2l6ZToxMC4zZW0haW1wb3J0YW50O30vKiFzYyovIEBtZWRpYSBvbmx5IHNjcmVlbiBhbmQgKG1heC13aWR0aDo2NDBweCl7Lmp6RUpBRS5qekVKQUUuanpFSkFFLmp6RUpBRXtmb250LXNpemU6My43ZW0haW1wb3J0YW50O319Lyohc2MqLyAuZ2xPcXFJLmdsT3FxSS5nbE9xcUkuZ2xPcXFJe2ZvbnQtc2l6ZTo0LjNlbSFpbXBvcnRhbnQ7fS8qIXNjKi8gQG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAobWF4LXdpZHRoOjY0MHB4KXsuZ2xPcXFJLmdsT3FxSS5nbE9xcUkuZ2xPcXFJe2ZvbnQtc2l6ZToxLjRlbSFpbXBvcnRhbnQ7fX0vKiFzYyovIC5qSXlUREsuakl5VERLLmpJeVRESy5qSXlUREt7Zm9udC1zaXplOjRlbSFpbXBvcnRhbnQ7fS8qIXNjKi8gQG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAobWF4LXdpZHRoOjY0MHB4KXsuakl5VERLLmpJeVRESy5qSXlUREsuakl5VERLe2ZvbnQtc2l6ZToxLjNlbSFpbXBvcnRhbnQ7fX0vKiFzYyovIC5kWGEtRFZRLmRYYS1EVlEuZFhhLURWUS5kWGEtRFZRe2ZvbnQtc2l6ZTozLjVlbSFpbXBvcnRhbnQ7fS8qIXNjKi8gQG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAobWF4LXdpZHRoOjY0MHB4KXsuZFhhLURWUS5kWGEtRFZRLmRYYS1EVlEuZFhhLURWUXtmb250LXNpemU6MS4xZW0haW1wb3J0YW50O319Lyohc2MqLyAudHFHa2cudHFHa2cudHFHa2cudHFHa2d7Zm9udC1zaXplOjUuM2VtIWltcG9ydGFudDt9Lyohc2MqLyBAbWVkaWEgb25seSBzY3JlZW4gYW5kIChtYXgtd2lkdGg6NjQwcHgpey50cUdrZy50cUdrZy50cUdrZy50cUdrZ3tmb250LXNpemU6MS45ZW0haW1wb3J0YW50O319Lyohc2MqLyAuYmNDZnVKLmJjQ2Z1Si5iY0NmdUouYmNDZnVKe2ZvbnQtc2l6ZTo0LjJlbSFpbXBvcnRhbnQ7fS8qIXNjKi8gQG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAobWF4LXdpZHRoOjY0MHB4KXsuYmNDZnVKLmJjQ2Z1Si5iY0NmdUouYmNDZnVKe2ZvbnQtc2l6ZToxLjRlbSFpbXBvcnRhbnQ7fX0vKiFzYyovIC5qZGdNelUuamRnTXpVLmpkZ016VS5qZGdNelV7Zm9udC1zaXplOjNlbSFpbXBvcnRhbnQ7fS8qIXNjKi8gQG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAobWF4LXdpZHRoOjY0MHB4KXsuamRnTXpVLmpkZ016VS5qZGdNelUuamRnTXpVe2ZvbnQtc2l6ZToxZW0haW1wb3J0YW50O319Lyohc2MqLyAuZ0xITEV2LmdMSExFdi5nTEhMRXYuZ0xITEV2e2ZvbnQtc2l6ZTozZW0haW1wb3J0YW50O30vKiFzYyovIEBtZWRpYSBvbmx5IHNjcmVlbiBhbmQgKG1heC13aWR0aDo2NDBweCl7LmdMSExFdi5nTEhMRXYuZ0xITEV2LmdMSExFdntmb250LXNpemU6MS4xZW0haW1wb3J0YW50O319Lyohc2MqLyAuaXRraU5KLml0a2lOSi5pdGtpTkouaXRraU5Ke2ZvbnQtc2l6ZToyLjRlbSFpbXBvcnRhbnQ7fS8qIXNjKi8gQG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAobWF4LXdpZHRoOjY0MHB4KXsuaXRraU5KLml0a2lOSi5pdGtpTkouaXRraU5Ke2ZvbnQtc2l6ZTowLjllbSFpbXBvcnRhbnQ7fX0vKiFzYyovIC5nZ1VTb24uZ2dVU29uLmdnVVNvbi5nZ1VTb257Zm9udC1zaXplOjIuMWVtIWltcG9ydGFudDt9Lyohc2MqLyBAbWVkaWEgb25seSBzY3JlZW4gYW5kIChtYXgtd2lkdGg6NjQwcHgpey5nZ1VTb24uZ2dVU29uLmdnVVNvbi5nZ1VTb257Zm9udC1zaXplOjAuNmVtIWltcG9ydGFudDt9fS8qIXNjKi8gLmhwUVNnbC5ocFFTZ2wuaHBRU2dsLmhwUVNnbHtmb250LXNpemU6MS43ZW0haW1wb3J0YW50O30vKiFzYyovIEBtZWRpYSBvbmx5IHNjcmVlbiBhbmQgKG1heC13aWR0aDo2NDBweCl7LmhwUVNnbC5ocFFTZ2wuaHBRU2dsLmhwUVNnbHtmb250LXNpemU6MC41ZW0haW1wb3J0YW50O319Lyohc2MqLyBkYXRhLXN0eWxlZC5nMzY4W2lkPVwieF9fcHQ4dHprLTBcIl17Y29udGVudDpcImppR1ZWaixiV1NuVlMsaHJWY0ROLGdQSXhlYSxkQldRUmksYnd6d0JYLGZ0ZXRTUSxmWkpGdnEsY0dMclNHLGlua3NFVixlbWF4YmIsYnh0dVpKLGRMd3FoSixjVmxMRWQsY3lWWHpmLGlvYS1EZ0MsY0pjTkluLGpHU1Rkeixia2drZHAsa05oR2dYLHdwV0xHLGRKZW5yRSxjbmFLa00seldzY0UsakNrTHZTLGVycENobyxidlhxWG4saUthbGhQLGpFaHZ0dyxkREtlRFEsY0Z0Q04sZVFvVmFTLGVQdVN3TyxkUVNDQlIsZVlHQ2tkLGlqaWNkeixoakdLS3EsallLeHpYLGhzUGVpYSxkZnNlclAsakpybk5mLGlYamRMWSxkV3pNbkEsZk5EaER5LGN0V3FOcyxmRkFpVEssa3dMdWFCLGlOSHlpZSxqWERCQVQsY1ptb3RNLGpmdk1XSixoZWp1UUQsa0JPb2diLGtRenBDSixkZGJDSlosZ05EaUJmLGdSTEp3TixkZmd2cG4samlqeHVRLGt1a2VDcyxiV3p6a1UsaUZsRW1LLGRBLURvaHosZmdZWVhGLGdWUldBQixiZUROcFosaFJYYVhyLGt4emFLbCxsZFRqZ0gsTHpCblcsanRDWHZBLGRQb2VGbyxid0dRcnQsaGJ3aWt0LEZTc09PLGVwb0p6RCxrVkpOUFIsaVlnQnZBLGZJZXlDeCxrTEJ2ZnQsaFF4QVlQLGNLbFNJQyxmbnVWT0IsY1VYS09GLGJYRGd3cCxqekVKQUUsZ2xPcXFJLGpJeVRESyxkWGEtRFZRLHRxR2tnLGJjQ2Z1SixqZGdNelUsZ0xITEV2LGl0a2lOSixnZ1VTb24saHBRU2dsLFwifS8qIXNjKi8gPC9zdHlsZT48ZGl2IGNsYXNzPVwicm93IHhyb3cgZmxleC1pbml0aWFsXCI+PGRpdiBpZD1cImFwb3MtbmV0Ym9hcmQzXCIgY2xhc3M9XCJhZHVuaXQtd3JhcHBlciBjb2x1bW5zIHNtYWxsLTggbWVkaXVtLTggbGFyZ2UtOCB0cmFjay1lbGVtZW50ICBcIiBkYXRhLWZyb209XCJ4YXZpZXJcIj48ZGl2IGlkPVwiYWQtbmV0Ym9hcmQzXCIgY2xhc3M9XCJhZHVuaXQgR29vZ2xlQWN0aXZlVmlld0VsZW1lbnQgc21hbGwtNTgweDUwMCBtZWRpdW0tNTgweDUwMCBsYXJnZS01ODB4NTAwXCIgaXRlbXNjb3BlPVwiXCIgaXRlbVR5cGU9XCJodHRwczovL3NjaGVtYS5vcmcvV1BBZEJsb2NrXCIgZGF0YS1zaXplcz1cIltbNTgwLDQwMF0sWzU4MCw1MDBdLCZxdW90O2ZsdWlkJnF1b3Q7XVwiIGRhdGEtc2xvdD1cIi84NTc4L2RhZ2JsYWRldC5uby9mb3JzaWRlXCIgZGF0YS1sb2FkLW9uPVwidmlld1wiIGRhdGEtY29sbGFwc2U9XCJmYWxzZVwiIGRhdGEtZXhwYW5kPVwiZmFsc2VcIiBkYXRhLW91dC1vZi1wYWdlPVwiZmFsc2VcIiBqc29uPVwieyZxdW90O3RhcmdldGluZyZxdW90OzogeyZxdW90O3BvcyZxdW90OzomcXVvdDtuZXRib2FyZDMmcXVvdDssJnF1b3Q7cGxhdGZvcm0mcXVvdDs6JnF1b3Q7d29sdmVyaW5lJnF1b3Q7fX1cIj48L2Rpdj48L2Rpdj48ZGl2IGNsYXNzPVwieGF2aWVyIGNvbHVtbnMgc21hbGwtNCBtZWRpdW0tNCBsYXJnZS00XCI+PGRpdiBjbGFzcz1cInJvdyB4cm93IGZsZXgtY29sdW1uXCI+PGFydGljbGUgY2xhc3M9XCJwcmV2aWV3IGNvbHVtbnMgc21hbGwtMTIgbWVkaXVtLTEyIGxhcmdlLTEyXCIgZGF0YS1jeGVuc2VfdGFnPVwiY2VyZWJyb1wiIGRhdGEtY3hlbmNlX3dpZGdldD1cInBsdXNzLW1vZGVsLWZyb250XCIgZGF0YS1sYWJlbD1cInBsdXNzXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIi0gRGV0IGtyYXNqZXQgbGl0dCBmb3IgbWVnXCIgaHJlZj1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9ramVuZGlzL2RldC1rcmFzamV0LWxpdHQtZm9yLW1lZy84MTMyNjA3M1wiPjxmaWd1cmUgY2xhc3M9XCJ4X19zYy0xYW43dnUxLTAgZmpKeXZFXCI+PHBpY3R1cmU+PGltZyBkYXRhLWRlZmVyPVwidmlld1wiIHRpdGxlPVwiSW1hZ2U6IC0gRGV0IGtyYXNqZXQgbGl0dCBmb3IgbWVnXCIgYWx0PVwiSW1hZ2U6IC0gRGV0IGtyYXNqZXQgbGl0dCBmb3IgbWVnXCIgZGVjb2Rpbmc9XCJhc3luY1wiIGNsYXNzPVwibGF6eWxvYWRcIiBkYXRhLXNyYz1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9pbWFnZXMvP2ltYWdlSWQ9ODEzMjY5NjcmYW1wO3Bhbm95PTAmYW1wO3Bhbm94PTAmYW1wO3Bhbm93PTEwMCZhbXA7cGFub2g9MTAwJmFtcDtoZWlnaHR5PTAmYW1wO2hlaWdodHc9MTAwJmFtcDtoZWlnaHRoPTEwMCZhbXA7aGVpZ2h0eD0wJmFtcDt3aWR0aD0zMjAmYW1wO2hlaWdodD0xNjAmYW1wO2NvbXByZXNzaW9uPTcwXCIgc3JjPVwiZGF0YTppbWFnZS9wbmc7YmFzZTY0LGlWQk9SdzBLR2dvQUFBQU5TVWhFVWdBQUFCQUFBQUFKQ0FZQUFBQTdLcXd5QUFBQUYwbEVRVlI0Mm1OOCsrYjlmd1lLQU9Pb0FhTUdBQUVBNHVraUNVQ2JXMGNBQUFBQVNVVk9SSzVDWUlJPVwiIGxvYWRpbmc9XCJsYXp5XCIgZmV0Y2hQcmlvcml0eT1cImF1dG9cIi8+PC9waWN0dXJlPjxkaXYgY2xhc3M9XCJmaWd1cmUtbG9nb1wiPjxkaXYgY2xhc3M9XCJsb2dvXCI+PHN2ZyB4bWxucz1cImh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnXCIgd2lkdGg9XCIyNFwiIGhlaWdodD1cIjI0XCIgdmlld0JveD1cIjAgMCAyNCAyNFwiIGZpbGw9XCJub25lXCIgc3Ryb2tlPVwiY3VycmVudENvbG9yXCIgc3Ryb2tlLXdpZHRoPVwiM1wiPjxsaW5lIHgxPVwiMTJcIiB5MT1cIjVcIiB4Mj1cIjEyXCIgeTI9XCIxOVwiPjwvbGluZT48bGluZSB4MT1cIjVcIiB5MT1cIjEyXCIgeDI9XCIxOVwiIHkyPVwiMTJcIj48L2xpbmU+PC9zdmc+PC9kaXY+PC9kaXY+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGppR1ZWaiB0aXRsZSBkeW5hbWljLXNpemluZ1wiPi0gRGV0IGtyYXNqZXQ8L3NwYW4+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBiV1NuVlMgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5saXR0IGZvciBtZWc8L3NwYW4+PC9oMz48L2hlYWRlcj48L2E+PC9hcnRpY2xlPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTEyIG1lZGl1bS0xMiBsYXJnZS0xMlwiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJ2aWRlby1tZXRhcG9wLW1vZGVsXCIgZGF0YS1sYWJlbD1cInZpZGVvXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIi0gVmlsIGbDuHJlIHRpbCB1dHJ5ZGRlbHNlXCIgaHJlZj1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby92aWRlby8tdmlsLWZvcmUtdGlsLXV0cnlkZGVsc2UvTUJiczI4VDJcIj48ZmlndXJlIGNsYXNzPVwieF9fc2MtMWFuN3Z1MS0wIGZqSnl2RVwiPjxwaWN0dXJlPjxpbWcgZGF0YS1kZWZlcj1cInZpZXdcIiB0aXRsZT1cIkltYWdlOiAtIFZpbCBmw7hyZSB0aWwgdXRyeWRkZWxzZVwiIGFsdD1cIkltYWdlOiAtIFZpbCBmw7hyZSB0aWwgdXRyeWRkZWxzZVwiIGRlY29kaW5nPVwiYXN5bmNcIiBjbGFzcz1cImxhenlsb2FkXCIgZGF0YS1zcmM9XCJodHRwczovL2Nkbi5qd3BsYXllci5jb20vdGh1bWJzL01CYnMyOFQyLTcyMC5qcGdcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PGRpdiBjbGFzcz1cImZpZ3VyZS1sb2dvXCI+PGRpdiBjbGFzcz1cImxvZ29cIj48c3ZnIHhtbG5zPVwiaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmdcIiB3aWR0aD1cIjI0XCIgaGVpZ2h0PVwiMjRcIiB2aWV3Qm94PVwiMCAwIDI0IDI0XCIgZmlsbD1cImN1cnJlbnRDb2xvclwiIHN0cm9rZT1cImN1cnJlbnRDb2xvclwiIHN0cm9rZS13aWR0aD1cIjJcIiBzdHJva2UtbGluZWNhcD1cInJvdW5kXCIgc3Ryb2tlLWxpbmVqb2luPVwicm91bmRcIiBjbGFzcz1cImZlYXRoZXIgZmVhdGhlci1wbGF5XCI+PHBvbHlnb24gcG9pbnRzPVwiNSAzIDE5IDEyIDUgMjEgNSAzXCI+PC9wb2x5Z29uPjwvc3ZnPjwvZGl2PjwvZGl2PjwvZmlndXJlPjxoZWFkZXI+PGgzIGNsYXNzPVwieGF2aWVyLWhlYWRsaW5lIGhlYWRsaW5lXCI+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBoclZjRE4gdGl0bGUgZHluYW1pYy1zaXppbmdcIj4tIFZpbCBmw7hyZTwvc3Bhbj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGdQSXhlYSB0aXRsZSBkeW5hbWljLXNpemluZ1wiPnRpbCB1dHJ5ZGRlbHNlPC9zcGFuPjwvaDM+PC9oZWFkZXI+PC9hPjwvYXJ0aWNsZT48L2Rpdj48L2Rpdj48L2Rpdj48ZGl2IGNsYXNzPVwicm93IHhyb3cgZmxleC1pbml0aWFsXCI+PGFydGljbGUgY2xhc3M9XCJwcmV2aWV3IGNvbHVtbnMgc21hbGwtNiBtZWRpdW0tNiBsYXJnZS02XCIgZGF0YS1jeGVuc2VfdGFnPVwiY2VyZWJyb1wiIGRhdGEtY3hlbmNlX3dpZGdldD1cImRhZ2JsYWRldC1tb2RlbC1mcm9udFwiIGRhdGEtbGFiZWw9XCJcIiBkYXRhLWZyb209XCJ4YXZpZXJcIiBkYXRhLXJldmVyc2VJbWFnZVRleHRPcmRlcj1cImZhbHNlXCI+PGEgdGFyZ2V0PVwiX3NlbGZcIiBhcmlhLWxhYmVsPVwiLSBNw6UgbsO4eWUgc2VnIG1lZCBow7hzdHbDpnJcIiBocmVmPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL255aGV0ZXIvbWEtbm95ZS1zZWctbWVkLWhvc3R2YWVyLzgxMzY4MTU3XCI+PGZpZ3VyZSBjbGFzcz1cInhfX3NjLTFhbjd2dTEtMCBlelZab01cIj48cGljdHVyZT48aW1nIGRhdGEtZGVmZXI9XCJ2aWV3XCIgdGl0bGU9XCJJbWFnZTogLSBNw6UgbsO4eWUgc2VnIG1lZCBow7hzdHbDpnJcIiBhbHQ9XCJJbWFnZTogLSBNw6UgbsO4eWUgc2VnIG1lZCBow7hzdHbDpnJcIiBkZWNvZGluZz1cImFzeW5jXCIgY2xhc3M9XCJsYXp5bG9hZFwiIGRhdGEtc3JjPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2ltYWdlcy8/aW1hZ2VJZD04MTM2ODE2OSZhbXA7cGFub3k9MCZhbXA7cGFub3g9MCZhbXA7cGFub3c9MTAwJmFtcDtwYW5vaD0xMDAmYW1wO2hlaWdodHc9MTAwJmFtcDtoZWlnaHRoPTEwMCZhbXA7aGVpZ2h0eT0wJmFtcDtoZWlnaHR4PTAmYW1wO3dpZHRoPTQ4NSZhbXA7aGVpZ2h0PTI4OCZhbXA7Y29tcHJlc3Npb249NzBcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGRCV1FSaSB0aXRsZSBkeW5hbWljLXNpemluZ1wiPi0gTcOlIG7DuHllIHNlZzwvc3Bhbj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGJ3endCWCB0aXRsZSBkeW5hbWljLXNpemluZ1wiPm1lZCBow7hzdHbDpnI8L3NwYW4+PC9oMz48L2hlYWRlcj48L2E+PC9hcnRpY2xlPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTYgbWVkaXVtLTYgbGFyZ2UtNlwiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJkYWdibGFkZXQtbW9kZWwtZnJvbnRcIiBkYXRhLWxhYmVsPVwiXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIlV0IG1vdCBMw7hrZTotIExhdHRlcmxpZ1wiIGhyZWY9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8va2plbmRpcy91dC1tb3QtbG9rZS1sYXR0ZXJsaWcvODEzNjQyODZcIj48ZmlndXJlIGNsYXNzPVwieF9fc2MtMWFuN3Z1MS0wIGZuUURIYlwiPjxwaWN0dXJlPjxpbWcgZGF0YS1kZWZlcj1cInZpZXdcIiB0aXRsZT1cIkltYWdlOiBVdCBtb3QgTMO4a2U6LSBMYXR0ZXJsaWdcIiBhbHQ9XCJJbWFnZTogVXQgbW90IEzDuGtlOi0gTGF0dGVybGlnXCIgZGVjb2Rpbmc9XCJhc3luY1wiIGNsYXNzPVwibGF6eWxvYWRcIiBkYXRhLXNyYz1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9pbWFnZXMvP2ltYWdlSWQ9ODEzNjQ2ODYmYW1wO3Bhbm95PTUwLjU3NDcxMjY0MzY3OCZhbXA7cGFub3c9ODEuMDk4MzM5NDYzNjAyJmFtcDtwYW5vaD0yMC44ODEyMjU4NjIwNjkmYW1wO3Bhbm94PTAuNzY2MjgzNTI0OTA0MjEmYW1wO2hlaWdodHk9NDIuMTMzMzMzMzMzMzMzJmFtcDtoZWlnaHR4PTExLjc4NTcxNDI4NTcxNCZhbXA7aGVpZ2h0dz0zMi43MzgwOTUmYW1wO2hlaWdodGg9MzkuNjQ0NDQ0MjY2NjY3JmFtcDt3aWR0aD00ODUmYW1wO2hlaWdodD0yNDImYW1wO2NvbXByZXNzaW9uPTcwXCIgc3JjPVwiZGF0YTppbWFnZS9wbmc7YmFzZTY0LGlWQk9SdzBLR2dvQUFBQU5TVWhFVWdBQUFCQUFBQUFKQ0FZQUFBQTdLcXd5QUFBQUYwbEVRVlI0Mm1OOCsrYjlmd1lLQU9Pb0FhTUdBQUVBNHVraUNVQ2JXMGNBQUFBQVNVVk9SSzVDWUlJPVwiIGxvYWRpbmc9XCJsYXp5XCIgZmV0Y2hQcmlvcml0eT1cImF1dG9cIi8+PC9waWN0dXJlPjwvZmlndXJlPjxoZWFkZXI+PGgzIGNsYXNzPVwieGF2aWVyLWhlYWRsaW5lIGhlYWRsaW5lXCI+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBmdGV0U1EgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5VdCBtb3QgTMO4a2U6LTwvc3Bhbj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGZaSkZ2cSB0aXRsZSBkeW5hbWljLXNpemluZ1wiPkxhdHRlcmxpZzwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PC9kaXY+PGRpdiBjbGFzcz1cInJvdyB4cm93IGZsZXgtaW5pdGlhbFwiPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTYgbWVkaXVtLTYgbGFyZ2UtNiBiZy15ZWxsb3dcIiBkYXRhLWN4ZW5zZV90YWc9XCJjZXJlYnJvXCIgZGF0YS1jeGVuY2Vfd2lkZ2V0PVwiZGFnYmxhZGV0LW1vZGVsLWZyb250XCIgZGF0YS1sYWJlbD1cIlwiIGRhdGEtZnJvbT1cInhhdmllclwiIGRhdGEtcmV2ZXJzZUltYWdlVGV4dE9yZGVyPVwiZmFsc2VcIj48YSB0YXJnZXQ9XCJfc2VsZlwiIGFyaWEtbGFiZWw9XCJEdWtrZXQgb3BwIHDDpSBQdXRpbi1pbm5zZXR0ZWxzZVwiIGhyZWY9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vbnloZXRlci9kdWtrZXQtb3BwLXBhLXB1dGluLWlubnNldHRlbHNlLzgxMzY3NDkyXCI+PGZpZ3VyZSBjbGFzcz1cInhfX3NjLTFhbjd2dTEtMCBiY2pxc01cIj48cGljdHVyZT48aW1nIGRhdGEtZGVmZXI9XCJ2aWV3XCIgdGl0bGU9XCJJbWFnZTogRHVra2V0IG9wcCBww6UgUHV0aW4taW5uc2V0dGVsc2VcIiBhbHQ9XCJJbWFnZTogRHVra2V0IG9wcCBww6UgUHV0aW4taW5uc2V0dGVsc2VcIiBkZWNvZGluZz1cImFzeW5jXCIgY2xhc3M9XCJsYXp5bG9hZFwiIGRhdGEtc3JjPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2ltYWdlcy8/aW1hZ2VJZD04MTM2NzUxNSZhbXA7cGFub3k9MCZhbXA7cGFub3g9MCZhbXA7cGFub3c9MTAwJmFtcDtwYW5vaD01MC43MTQyODU3MTQyODYmYW1wO2hlaWdodHg9MzEuMjIxNzE5NDU3MDE0JmFtcDtoZWlnaHR3PTQwLjcyMzk4MTkwMDQ1MiZhbXA7aGVpZ2h0aD0xMDAmYW1wO2hlaWdodHk9MCZhbXA7d2lkdGg9NDg1JmFtcDtoZWlnaHQ9MzI3JmFtcDtjb21wcmVzc2lvbj03MFwiIHNyYz1cImRhdGE6aW1hZ2UvcG5nO2Jhc2U2NCxpVkJPUncwS0dnb0FBQUFOU1VoRVVnQUFBQkFBQUFBSkNBWUFBQUE3S3F3eUFBQUFGMGxFUVZSNDJtTjgrK2I5ZndZS0FPT29BYU1HQUFFQTR1a2lDVUNiVzBjQUFBQUFTVVZPUks1Q1lJST1cIiBsb2FkaW5nPVwibGF6eVwiIGZldGNoUHJpb3JpdHk9XCJhdXRvXCIvPjwvcGljdHVyZT48L2ZpZ3VyZT48aGVhZGVyPjxoMyBjbGFzcz1cInhhdmllci1oZWFkbGluZSBoZWFkbGluZVwiPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgY0dMclNHIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+RHVra2V0IG9wcCBww6U8L3NwYW4+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBpbmtzRVYgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5QdXRpbi1pbm5zZXR0ZWxzZTwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PGFydGljbGUgY2xhc3M9XCJwcmV2aWV3IGNvbHVtbnMgc21hbGwtNiBtZWRpdW0tNiBsYXJnZS02XCIgZGF0YS1jeGVuc2VfdGFnPVwiY2VyZWJyb1wiIGRhdGEtY3hlbmNlX3dpZGdldD1cImRhZ2JsYWRldC1tb2RlbC1mcm9udFwiIGRhdGEtbGFiZWw9XCJcIiBkYXRhLWZyb209XCJ4YXZpZXJcIiBkYXRhLXJldmVyc2VJbWFnZVRleHRPcmRlcj1cImZhbHNlXCI+PGEgdGFyZ2V0PVwiX3NlbGZcIiBhcmlhLWxhYmVsPVwiVHJ1ZXIgdmVzdGxpZ2Ugc3RhdHNsZWRlcmU6IC0gSW5mYW50aWxlIHRvc2tlclwiIGhyZWY9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vbnloZXRlci90cnVlci12ZXN0bGlnZS1zdGF0c2xlZGVyZS1pbmZhbnRpbGUtdG9za2VyLzgxMzY1MjE0XCI+PGZpZ3VyZSBjbGFzcz1cInhfX3NjLTFhbjd2dTEtMCBmblFESGJcIj48cGljdHVyZT48aW1nIGRhdGEtZGVmZXI9XCJ2aWV3XCIgdGl0bGU9XCJJbWFnZTogVHJ1ZXIgdmVzdGxpZ2Ugc3RhdHNsZWRlcmU6IC0gSW5mYW50aWxlIHRvc2tlclwiIGFsdD1cIkltYWdlOiBUcnVlciB2ZXN0bGlnZSBzdGF0c2xlZGVyZTogLSBJbmZhbnRpbGUgdG9za2VyXCIgZGVjb2Rpbmc9XCJhc3luY1wiIGNsYXNzPVwibGF6eWxvYWRcIiBkYXRhLXNyYz1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9pbWFnZXMvP2ltYWdlSWQ9ODAwODM4MDAmYW1wO3Bhbm95PTAmYW1wO3Bhbm94PTAmYW1wO3Bhbm93PTEwMCZhbXA7cGFub2g9MTAwJmFtcDtoZWlnaHR3PTEwMCZhbXA7aGVpZ2h0eD0wJmFtcDtoZWlnaHRoPTEwMCZhbXA7aGVpZ2h0eT0wJmFtcDt3aWR0aD00ODUmYW1wO2hlaWdodD0yNDImYW1wO2NvbXByZXNzaW9uPTcwXCIgc3JjPVwiZGF0YTppbWFnZS9wbmc7YmFzZTY0LGlWQk9SdzBLR2dvQUFBQU5TVWhFVWdBQUFCQUFBQUFKQ0FZQUFBQTdLcXd5QUFBQUYwbEVRVlI0Mm1OOCsrYjlmd1lLQU9Pb0FhTUdBQUVBNHVraUNVQ2JXMGNBQUFBQVNVVk9SSzVDWUlJPVwiIGxvYWRpbmc9XCJsYXp5XCIgZmV0Y2hQcmlvcml0eT1cImF1dG9cIi8+PC9waWN0dXJlPjwvZmlndXJlPjxoZWFkZXI+PGgzIGNsYXNzPVwieGF2aWVyLWhlYWRsaW5lIGhlYWRsaW5lXCI+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBlbWF4YmIgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5UcnVlciB2ZXN0bGlnZTwvc3Bhbj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGJ4dHVaSiB0aXRsZSBkeW5hbWljLXNpemluZ1wiPnN0YXRzbGVkZXJlOjwvc3Bhbj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGRMd3FoSiB0aXRsZSBkeW5hbWljLXNpemluZ1wiPi0gSW5mYW50aWxlIHRvc2tlcjwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PC9kaXY+PGRpdiBjbGFzcz1cInJvdyB4cm93IGZsZXgtaW5pdGlhbFwiPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTQgbWVkaXVtLTQgbGFyZ2UtNCBiZy1ibGFja1wiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJ2aWRlby1tZXRhcG9wLW1vZGVsXCIgZGF0YS1sYWJlbD1cInZpZGVvXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIlN0ZXJrZSBiaWxkZXI6IFNwcmVuZ2VyIGkgaMOlbmRhXCIgaHJlZj1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby92aWRlby9za3Jla2tiaWxkZXItaGVyLXNwcmVuZ2VyLWRldC9jQXRKZlJqaVwiPjxmaWd1cmUgY2xhc3M9XCJ4X19zYy0xYW43dnUxLTAgRnZJYnogbW92aW5nLWltYWdlLWNvbnRhaW5lclwiPjx2aWRlbyBtdXRlZD1cIlwiIGxvb3A9XCJcIiBkYXRhLXZpZGVvLWRlZmVyPVwidmlld1wiIHByZWxvYWQ9XCJub25lXCIgdGl0bGU9XCJJbWFnZTogU3RlcmtlIGJpbGRlcjogU3ByZW5nZXIgaSBow6VuZGFcIiBjbGFzcz1cIm1vdmluZy1pbWFnZVwiIHBsYXlzaW5saW5lPVwiXCIgcG9zdGVyPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2ltYWdlcy84MTM2NDY0OS5qcGc/aW1hZ2VJZD04MTM2NDY0OSZhbXA7eD0wLjAwMDAwMCZhbXA7eT0wLjAwMDAwMCZhbXA7Y3JvcHc9MC4wMDAwMDAmYW1wO2Nyb3BoPTAuMDAwMDAwJmFtcDt3aWR0aD0zMjAmYW1wO2hlaWdodD0yMDVcIiBkaXNhYmxlcmVtb3RlcGxheWJhY2s9XCJcIj48c291cmNlIHNyYz1cImh0dHBzOi8vc25pcHAuZGJzdGF0aWMubm8vMjAyNC8wNS8wNi9lYTkxZTNjYy0zNDY4LTQ3ZmMtYWZmNy0yYTcwYjI1N2VkNzcvZ2lmXzFfc3ByZW5nZXJfaGFuZGEud2VibVwiIHR5cGU9XCJ2aWRlby93ZWJtXCIvPjxzb3VyY2Ugc3JjPVwiaHR0cHM6Ly9zbmlwcC5kYnN0YXRpYy5uby8yMDI0LzA1LzA2L2VhOTFlM2NjLTM0NjgtNDdmYy1hZmY3LTJhNzBiMjU3ZWQ3Ny9naWZfMV9zcHJlbmdlcl9oYW5kYS5tcDRcIiB0eXBlPVwidmlkZW8vbXA0XCIvPjwvdmlkZW8+PGRpdiBjbGFzcz1cImZpZ3VyZS1sb2dvXCI+PGRpdiBjbGFzcz1cImxvZ29cIj48c3ZnIHhtbG5zPVwiaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmdcIiB3aWR0aD1cIjI0XCIgaGVpZ2h0PVwiMjRcIiB2aWV3Qm94PVwiMCAwIDI0IDI0XCIgZmlsbD1cImN1cnJlbnRDb2xvclwiIHN0cm9rZT1cImN1cnJlbnRDb2xvclwiIHN0cm9rZS13aWR0aD1cIjJcIiBzdHJva2UtbGluZWNhcD1cInJvdW5kXCIgc3Ryb2tlLWxpbmVqb2luPVwicm91bmRcIiBjbGFzcz1cImZlYXRoZXIgZmVhdGhlci1wbGF5XCI+PHBvbHlnb24gcG9pbnRzPVwiNSAzIDE5IDEyIDUgMjEgNSAzXCI+PC9wb2x5Z29uPjwvc3ZnPjwvZGl2PjwvZGl2PjwvZmlndXJlPjxoZWFkZXI+PGgzIGNsYXNzPVwieGF2aWVyLWhlYWRsaW5lIGhlYWRsaW5lXCI+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBjVmxMRWQgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5TdGVya2UgYmlsZGVyOjwvc3Bhbj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGN5Vlh6ZiB0aXRsZSBkeW5hbWljLXNpemluZ1wiPlNwcmVuZ2VyIGkgaMOlbmRhPC9zcGFuPjwvaDM+PC9oZWFkZXI+PC9hPjwvYXJ0aWNsZT48YXJ0aWNsZSBjbGFzcz1cInByZXZpZXcgY29sdW1ucyBzbWFsbC00IG1lZGl1bS00IGxhcmdlLTRcIiBkYXRhLWN4ZW5zZV90YWc9XCJjZXJlYnJvXCIgZGF0YS1jeGVuY2Vfd2lkZ2V0PVwicGx1c3MtbW9kZWwtZnJvbnRcIiBkYXRhLWxhYmVsPVwicGx1c3NcIiBkYXRhLWZyb209XCJ4YXZpZXJcIiBkYXRhLXJldmVyc2VJbWFnZVRleHRPcmRlcj1cImZhbHNlXCI+PGEgdGFyZ2V0PVwiX3NlbGZcIiBhcmlhLWxhYmVsPVwiw4VwbmVyIG9tIGxpdnN2YWxnZXRcIiBocmVmPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2tqZW5kaXMvYXBuZXItb20tbGl2c3ZhbGdldC84MTA1ODYyMFwiPjxmaWd1cmUgY2xhc3M9XCJ4X19zYy0xYW43dnUxLTAgZmpKeXZFXCI+PHBpY3R1cmU+PGltZyBkYXRhLWRlZmVyPVwidmlld1wiIHRpdGxlPVwiSW1hZ2U6IMOFcG5lciBvbSBsaXZzdmFsZ2V0XCIgYWx0PVwiSW1hZ2U6IMOFcG5lciBvbSBsaXZzdmFsZ2V0XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGNsYXNzPVwibGF6eWxvYWRcIiBkYXRhLXNyYz1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9pbWFnZXMvP2ltYWdlSWQ9ODEwNTg2NDUmYW1wO3Bhbm94PTAmYW1wO3Bhbm93PTEwMCZhbXA7cGFub2g9MTAwJmFtcDtwYW5veT0wJmFtcDtoZWlnaHR3PTEwMCZhbXA7aGVpZ2h0eT0wJmFtcDtoZWlnaHR4PTAmYW1wO2hlaWdodGg9MTAwJmFtcDt3aWR0aD0zMjAmYW1wO2hlaWdodD0xNjAmYW1wO2NvbXByZXNzaW9uPTcwXCIgc3JjPVwiZGF0YTppbWFnZS9wbmc7YmFzZTY0LGlWQk9SdzBLR2dvQUFBQU5TVWhFVWdBQUFCQUFBQUFKQ0FZQUFBQTdLcXd5QUFBQUYwbEVRVlI0Mm1OOCsrYjlmd1lLQU9Pb0FhTUdBQUVBNHVraUNVQ2JXMGNBQUFBQVNVVk9SSzVDWUlJPVwiIGxvYWRpbmc9XCJsYXp5XCIgZmV0Y2hQcmlvcml0eT1cImF1dG9cIi8+PC9waWN0dXJlPjxkaXYgY2xhc3M9XCJmaWd1cmUtbG9nb1wiPjxkaXYgY2xhc3M9XCJsb2dvXCI+PHN2ZyB4bWxucz1cImh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnXCIgd2lkdGg9XCIyNFwiIGhlaWdodD1cIjI0XCIgdmlld0JveD1cIjAgMCAyNCAyNFwiIGZpbGw9XCJub25lXCIgc3Ryb2tlPVwiY3VycmVudENvbG9yXCIgc3Ryb2tlLXdpZHRoPVwiM1wiPjxsaW5lIHgxPVwiMTJcIiB5MT1cIjVcIiB4Mj1cIjEyXCIgeTI9XCIxOVwiPjwvbGluZT48bGluZSB4MT1cIjVcIiB5MT1cIjEyXCIgeDI9XCIxOVwiIHkyPVwiMTJcIj48L2xpbmU+PC9zdmc+PC9kaXY+PC9kaXY+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGlvYS1EZ0MgdGl0bGUgZHluYW1pYy1zaXppbmdcIj7DhXBuZXIgb208L3NwYW4+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBjSmNOSW4gdGl0bGUgZHluYW1pYy1zaXppbmdcIj5saXZzdmFsZ2V0PC9zcGFuPjwvaDM+PC9oZWFkZXI+PC9hPjwvYXJ0aWNsZT48ZGl2IGlkPVwiYXBvcy1tZWRpdW0tcmVjdGFuZ2xlM1wiIGNsYXNzPVwiYWR1bml0LXdyYXBwZXIgY29sdW1ucyBzbWFsbC00IG1lZGl1bS00IGxhcmdlLTQgdHJhY2stZWxlbWVudCAgXCIgZGF0YS1mcm9tPVwieGF2aWVyXCI+PGRpdiBpZD1cImFkLW1lZGl1bS1yZWN0YW5nbGUzXCIgY2xhc3M9XCJhZHVuaXQgR29vZ2xlQWN0aXZlVmlld0VsZW1lbnQgc21hbGwtMzIweDI1MCBtZWRpdW0tMzIweDI1MCBsYXJnZS0zMjB4MjUwXCIgaXRlbXNjb3BlPVwiXCIgaXRlbVR5cGU9XCJodHRwczovL3NjaGVtYS5vcmcvV1BBZEJsb2NrXCIgZGF0YS1zaXplcz1cIltbMzIwLDI1MF0sWzMwMCwyNTBdLCZxdW90O2ZsdWlkJnF1b3Q7XVwiIGRhdGEtc2xvdD1cIi84NTc4L2RhZ2JsYWRldC5uby9mb3JzaWRlXCIgZGF0YS1sb2FkLW9uPVwidmlld1wiIGRhdGEtY29sbGFwc2U9XCJmYWxzZVwiIGRhdGEtZXhwYW5kPVwiZmFsc2VcIiBkYXRhLW91dC1vZi1wYWdlPVwiZmFsc2VcIiBqc29uPVwieyZxdW90O3RhcmdldGluZyZxdW90OzogeyZxdW90O3BvcyZxdW90OzomcXVvdDttZWRpdW0tcmVjdGFuZ2xlMyZxdW90OywmcXVvdDtwbGF0Zm9ybSZxdW90OzomcXVvdDt3b2x2ZXJpbmUmcXVvdDt9fVwiPjwvZGl2PjwvZGl2PjwvZGl2PjxkaXYgY2xhc3M9XCJyb3cgeHJvdyBmbGV4LWluaXRpYWxcIj48YXJ0aWNsZSBjbGFzcz1cInByZXZpZXcgY29sdW1ucyBzbWFsbC03IG1lZGl1bS03IGxhcmdlLTdcIiBkYXRhLWN4ZW5zZV90YWc9XCJjZXJlYnJvXCIgZGF0YS1jeGVuY2Vfd2lkZ2V0PVwiZGFnYmxhZGV0LW1vZGVsLWZyb250XCIgZGF0YS1sYWJlbD1cIlwiIGRhdGEtZnJvbT1cInhhdmllclwiIGRhdGEtcmV2ZXJzZUltYWdlVGV4dE9yZGVyPVwiZmFsc2VcIj48YSB0YXJnZXQ9XCJfc2VsZlwiIGFyaWEtbGFiZWw9XCLDhXBuZXIgZm9yIGJvbWJlXCIgaHJlZj1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9zcG9ydC9hcG5lci1mb3ItYm9tYmUvODEzNjU3MzdcIj48ZmlndXJlIGNsYXNzPVwieF9fc2MtMWFuN3Z1MS0wIGt2aUFyeVwiPjxwaWN0dXJlPjxpbWcgZGF0YS1kZWZlcj1cInZpZXdcIiB0aXRsZT1cIkltYWdlOiDDhXBuZXIgZm9yIGJvbWJlXCIgYWx0PVwiSW1hZ2U6IMOFcG5lciBmb3IgYm9tYmVcIiBkZWNvZGluZz1cImFzeW5jXCIgY2xhc3M9XCJsYXp5bG9hZFwiIGRhdGEtc3JjPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2ltYWdlcy8/aW1hZ2VJZD04MTM2NTgyOSZhbXA7cGFub3c9NTUuNDA4OTcwOTc2MjUzJmFtcDtwYW5vaD0yOC4xNzQ2MDMxNzQ2MDMmYW1wO3Bhbm95PTE5LjQ0NDQ0NDQ0NDQ0NCZhbXA7cGFub3g9MzcuNzMwODcwNzEyNDAxJmFtcDtoZWlnaHR5PTAmYW1wO2hlaWdodHg9NDEuMTc2NDcwNTg4MjM1JmFtcDtoZWlnaHR3PTQwLjcyMzk4MTkwMDQ1MiZhbXA7aGVpZ2h0aD0xMDAmYW1wO3dpZHRoPTU2NyZhbXA7aGVpZ2h0PTI4MyZhbXA7Y29tcHJlc3Npb249NzBcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGpHU1RkeiB0aXRsZSBkeW5hbWljLXNpemluZ1wiPsOFcG5lciBmb3IgYm9tYmU8L3NwYW4+PC9oMz48L2hlYWRlcj48L2E+PC9hcnRpY2xlPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTUgbWVkaXVtLTUgbGFyZ2UtNVwiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJkYWdibGFkZXQtbW9kZWwtZnJvbnRcIiBkYXRhLWxhYmVsPVwiXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIkhhc3RlbcO4dGU6IMKrTsOmciBrb2xsYXBzwrtcIiBocmVmPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL255aGV0ZXIvaGFzdGVtb3RlLW5hZXIta29sbGFwcy84MTM1ODUwNlwiPjxmaWd1cmUgY2xhc3M9XCJ4X19zYy0xYW43dnUxLTAgYm95eGdkXCI+PHBpY3R1cmU+PGltZyBkYXRhLWRlZmVyPVwidmlld1wiIHRpdGxlPVwiSW1hZ2U6IEhhc3RlbcO4dGU6IMKrTsOmciBrb2xsYXBzwrtcIiBhbHQ9XCJJbWFnZTogSGFzdGVtw7h0ZTogwqtOw6ZyIGtvbGxhcHPCu1wiIGRlY29kaW5nPVwiYXN5bmNcIiBjbGFzcz1cImxhenlsb2FkXCIgZGF0YS1zcmM9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vaW1hZ2VzLz9pbWFnZUlkPTgxMzU4NjEyJmFtcDtwYW5veD0wJmFtcDtwYW5vdz0xMDAmYW1wO3Bhbm9oPTEwMCZhbXA7cGFub3k9MCZhbXA7aGVpZ2h0eT0wJmFtcDtoZWlnaHR4PTAmYW1wO2hlaWdodHc9MTAwJmFtcDtoZWlnaHRoPTEwMCZhbXA7d2lkdGg9NDAyJmFtcDtoZWlnaHQ9MjE5JmFtcDtjb21wcmVzc2lvbj03MFwiIHNyYz1cImRhdGE6aW1hZ2UvcG5nO2Jhc2U2NCxpVkJPUncwS0dnb0FBQUFOU1VoRVVnQUFBQkFBQUFBSkNBWUFBQUE3S3F3eUFBQUFGMGxFUVZSNDJtTjgrK2I5ZndZS0FPT29BYU1HQUFFQTR1a2lDVUNiVzBjQUFBQUFTVVZPUks1Q1lJST1cIiBsb2FkaW5nPVwibGF6eVwiIGZldGNoUHJpb3JpdHk9XCJhdXRvXCIvPjwvcGljdHVyZT48L2ZpZ3VyZT48aGVhZGVyPjxoMyBjbGFzcz1cInhhdmllci1oZWFkbGluZSBoZWFkbGluZVwiPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgYmtna2RwIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+SGFzdGVtw7h0ZTo8L3NwYW4+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBrTmhHZ1ggdGl0bGUgZHluYW1pYy1zaXppbmdcIj7Cq07DpnIga29sbGFwc8K7PC9zcGFuPjwvaDM+PC9oZWFkZXI+PC9hPjwvYXJ0aWNsZT48L2Rpdj48ZGl2IGNsYXNzPVwicm93IHhyb3cgZmxleC1pbml0aWFsXCI+PGFydGljbGUgY2xhc3M9XCJwcmV2aWV3IGNvbHVtbnMgc21hbGwtNSBtZWRpdW0tNSBsYXJnZS01XCIgZGF0YS1jeGVuc2VfdGFnPVwiY2VyZWJyb1wiIGRhdGEtY3hlbmNlX3dpZGdldD1cImRhZ2JsYWRldC1tb2RlbC1mcm9udFwiIGRhdGEtbGFiZWw9XCJtZW5pbmdlclwiIGRhdGEtZnJvbT1cInhhdmllclwiIGRhdGEtcmV2ZXJzZUltYWdlVGV4dE9yZGVyPVwiZmFsc2VcIj48YSB0YXJnZXQ9XCJfc2VsZlwiIGFyaWEtbGFiZWw9XCJIYXIgZGUgaGFtIG7DpT9cIiBocmVmPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL21lbmluZ2VyL2hhci1kZS1oYW0tbmEvODEzNjI4MzBcIj48ZmlndXJlIGNsYXNzPVwieF9fc2MtMWFuN3Z1MS0wIGpsR3BGd1wiPjxwaWN0dXJlPjxpbWcgZGF0YS1kZWZlcj1cInZpZXdcIiB0aXRsZT1cIkltYWdlOiBIYXIgZGUgaGFtIG7DpT9cIiBhbHQ9XCJJbWFnZTogSGFyIGRlIGhhbSBuw6U/XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGNsYXNzPVwibGF6eWxvYWRcIiBkYXRhLXNyYz1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9pbWFnZXMvP2ltYWdlSWQ9ODEzNTIyNDgmYW1wO3Bhbm93PTY2LjA2ODkxNzcyMTUxOSZhbXA7cGFub2g9MzMuNTQzOTcxNTYzOTgxJmFtcDtwYW5veT0xMC45MDA0NzM5MzM2NDkmYW1wO3Bhbm94PTEwLjc1OTQ5MzY3MDg4NiZhbXA7aGVpZ2h0dz0yNy45NjgxNTU3NjMyNCZhbXA7aGVpZ2h0eT00LjU2MzkyNTIzMzY0NDkmYW1wO2hlaWdodHg9MjYuODY4NjkxNTg4Nzg1JmFtcDtoZWlnaHRoPTY4LjEyMDQ1Nzk0MzkyNSZhbXA7d2lkdGg9NDAyJmFtcDtoZWlnaHQ9NDIyJmFtcDtjb21wcmVzc2lvbj03MFwiIHNyYz1cImRhdGE6aW1hZ2UvcG5nO2Jhc2U2NCxpVkJPUncwS0dnb0FBQUFOU1VoRVVnQUFBQkFBQUFBSkNBWUFBQUE3S3F3eUFBQUFGMGxFUVZSNDJtTjgrK2I5ZndZS0FPT29BYU1HQUFFQTR1a2lDVUNiVzBjQUFBQUFTVVZPUks1Q1lJST1cIiBsb2FkaW5nPVwibGF6eVwiIGZldGNoUHJpb3JpdHk9XCJhdXRvXCIvPjwvcGljdHVyZT48ZGl2IGNsYXNzPVwiZmlndXJlLWxvZ29cIj48ZGl2IGNsYXNzPVwibG9nb1wiPjxkaXYgY2xhc3M9XCJtZW5pbmdlclwiIHN0eWxlPVwicGFkZGluZzo1cHhcIj48c3ZnIHhtbG5zPVwiaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmdcIiB3aWR0aD1cIjEwXCIgaGVpZ2h0PVwiMTBcIiB2aWV3Qm94PVwiMCAwIDI0IDI0XCIgZmlsbD1cIiM1NzkwOTBcIiBzdHJva2U9XCIjNTc5MDkwXCIgc3Ryb2tlLXdpZHRoPVwiMlwiIHN0cm9rZS1saW5lY2FwPVwicm91bmRcIiBzdHJva2UtbGluZWpvaW49XCJyb3VuZFwiIGNsYXNzPVwiZmVhdGhlciBmZWF0aGVyLWNpcmNsZVwiPjxjaXJjbGUgY3g9XCIxMlwiIGN5PVwiMTJcIiByPVwiMTBcIj48L2NpcmNsZT48L3N2Zz48c3BhbiBjbGFzcz1cIm1lbmluZ2VyLXRleHRcIj5NRU5JTkdFUjwvc3Bhbj48L2Rpdj48L2Rpdj48L2Rpdj48L2ZpZ3VyZT48aGVhZGVyPjxoMyBjbGFzcz1cInhhdmllci1oZWFkbGluZSBoZWFkbGluZVwiPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgd3BXTEcgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5IYXIgZGUgaGFtIG7DpT88L3NwYW4+PC9oMz48L2hlYWRlcj48L2E+PC9hcnRpY2xlPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTcgbWVkaXVtLTcgbGFyZ2UtN1wiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJkYWdibGFkZXQtbW9kZWwtZnJvbnRcIiBkYXRhLWxhYmVsPVwiXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIlRhciBncmVwIGV0dGVyIGRhdGluZy1rYW9zXCIgaHJlZj1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9ueWhldGVyL3Rhci1ncmVwLWV0dGVyLWRhdGluZy1rYW9zLzgxMzY3MDQ0XCI+PGZpZ3VyZSBjbGFzcz1cInhfX3NjLTFhbjd2dTEtMCBrdmlBcnlcIj48cGljdHVyZT48aW1nIGRhdGEtZGVmZXI9XCJ2aWV3XCIgdGl0bGU9XCJJbWFnZTogVGFyIGdyZXAgZXR0ZXIgZGF0aW5nLWthb3NcIiBhbHQ9XCJJbWFnZTogVGFyIGdyZXAgZXR0ZXIgZGF0aW5nLWthb3NcIiBkZWNvZGluZz1cImFzeW5jXCIgY2xhc3M9XCJsYXp5bG9hZFwiIGRhdGEtc3JjPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2ltYWdlcy8/aW1hZ2VJZD04MTM2NzA1NCZhbXA7cGFub3g9MCZhbXA7cGFub3c9MTAwJmFtcDtwYW5vaD04NC41Njg4MzUwOTgzMzYmYW1wO3Bhbm95PTAmYW1wO2hlaWdodHc9MTAwJmFtcDtoZWlnaHRoPTg0LjU2ODgzNTA5ODMzNiZhbXA7aGVpZ2h0eT0wJmFtcDtoZWlnaHR4PTAmYW1wO3dpZHRoPTU2NyZhbXA7aGVpZ2h0PTI4MyZhbXA7Y29tcHJlc3Npb249NzBcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGJ4dHVaSiB0aXRsZSBkeW5hbWljLXNpemluZ1wiPlRhciBncmVwIGV0dGVyPC9zcGFuPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgZEplbnJFIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+ZGF0aW5nLWthb3M8L3NwYW4+PC9oMz48L2hlYWRlcj48L2E+PC9hcnRpY2xlPjwvZGl2PjxkaXYgY2xhc3M9XCJyb3cgeHJvdyBmbGV4LWluaXRpYWxcIj48ZGl2IGlkPVwiYXBvcy1uZXRib2FyZDRcIiBjbGFzcz1cImFkdW5pdC13cmFwcGVyIGNvbHVtbnMgc21hbGwtOCBtZWRpdW0tOCBsYXJnZS04IHRyYWNrLWVsZW1lbnQgIFwiIGRhdGEtZnJvbT1cInhhdmllclwiPjxkaXYgaWQ9XCJhZC1uZXRib2FyZDRcIiBjbGFzcz1cImFkdW5pdCBHb29nbGVBY3RpdmVWaWV3RWxlbWVudCBzbWFsbC01ODB4NTAwIG1lZGl1bS01ODB4NTAwIGxhcmdlLTU4MHg1MDBcIiBpdGVtc2NvcGU9XCJcIiBpdGVtVHlwZT1cImh0dHBzOi8vc2NoZW1hLm9yZy9XUEFkQmxvY2tcIiBkYXRhLXNpemVzPVwiW1s1ODAsNDAwXSxbNTgwLDUwMF0sJnF1b3Q7Zmx1aWQmcXVvdDtdXCIgZGF0YS1zbG90PVwiLzg1NzgvZGFnYmxhZGV0Lm5vL2ZvcnNpZGVcIiBkYXRhLWxvYWQtb249XCJ2aWV3XCIgZGF0YS1jb2xsYXBzZT1cImZhbHNlXCIgZGF0YS1leHBhbmQ9XCJmYWxzZVwiIGRhdGEtb3V0LW9mLXBhZ2U9XCJmYWxzZVwiIGpzb249XCJ7JnF1b3Q7dGFyZ2V0aW5nJnF1b3Q7OiB7JnF1b3Q7cG9zJnF1b3Q7OiZxdW90O25ldGJvYXJkNCZxdW90OywmcXVvdDtwbGF0Zm9ybSZxdW90OzomcXVvdDt3b2x2ZXJpbmUmcXVvdDt9fVwiPjwvZGl2PjwvZGl2PjxkaXYgY2xhc3M9XCJ4YXZpZXIgY29sdW1ucyBzbWFsbC00IG1lZGl1bS00IGxhcmdlLTRcIj48ZGl2IGNsYXNzPVwicm93IHhyb3cgZmxleC1jb2x1bW5cIj48YXJ0aWNsZSBjbGFzcz1cInByZXZpZXcgY29sdW1ucyBzbWFsbC0xMiBtZWRpdW0tMTIgbGFyZ2UtMTIgYmctcmVkXCIgZGF0YS1jeGVuc2VfdGFnPVwiY2VyZWJyb1wiIGRhdGEtY3hlbmNlX3dpZGdldD1cInZpZGVvLW1ldGFwb3AtbW9kZWxcIiBkYXRhLWxhYmVsPVwidmlkZW9cIiBkYXRhLWZyb209XCJ4YXZpZXJcIiBkYXRhLXJldmVyc2VJbWFnZVRleHRPcmRlcj1cImZhbHNlXCI+PGEgdGFyZ2V0PVwiX3NlbGZcIiBhcmlhLWxhYmVsPVwiSXVlbC12aWRlbyBza2FwZXIgcmFiYWxkZXJcIiBocmVmPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL3ZpZGVvL2FtYWxpZS1pdWVsLWtsaXBwLXNrYXBlci1yYWJhbGRlci9jbnRTUjcxeVwiPjxmaWd1cmUgY2xhc3M9XCJ4X19zYy0xYW43dnUxLTAgZmpKeXZFIG1vdmluZy1pbWFnZS1jb250YWluZXJcIj48dmlkZW8gbXV0ZWQ9XCJcIiBsb29wPVwiXCIgZGF0YS12aWRlby1kZWZlcj1cInZpZXdcIiBwcmVsb2FkPVwibm9uZVwiIHRpdGxlPVwiSW1hZ2U6IEl1ZWwtdmlkZW8gc2thcGVyIHJhYmFsZGVyXCIgY2xhc3M9XCJtb3ZpbmctaW1hZ2VcIiBwbGF5c2lubGluZT1cIlwiIHBvc3Rlcj1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9pbWFnZXMvODEzNjEzOTcuanBnP2ltYWdlSWQ9ODEzNjEzOTcmYW1wO3g9MC4wMDAwMDAmYW1wO3k9MC4wMDAwMDAmYW1wO2Nyb3B3PTEwMC4wMDAwMDAmYW1wO2Nyb3BoPTgwLjAzNjI5OCZhbXA7d2lkdGg9MzIwJmFtcDtoZWlnaHQ9MTYwXCIgZGlzYWJsZXJlbW90ZXBsYXliYWNrPVwiXCI+PHNvdXJjZSBzcmM9XCJodHRwczovL3NuaXBwLmRic3RhdGljLm5vLzIwMjQvMDQvMzAvZDBlYjhiNTYtNjdjYy00YjhiLWE5YjUtMWY0YTZmOTVlY2E4L2dpZl9pdWVsXzIud2VibVwiIHR5cGU9XCJ2aWRlby93ZWJtXCIvPjxzb3VyY2Ugc3JjPVwiaHR0cHM6Ly9zbmlwcC5kYnN0YXRpYy5uby8yMDI0LzA0LzMwL2QwZWI4YjU2LTY3Y2MtNGI4Yi1hOWI1LTFmNGE2Zjk1ZWNhOC9naWZfaXVlbF8yLm1wNFwiIHR5cGU9XCJ2aWRlby9tcDRcIi8+PC92aWRlbz48ZGl2IGNsYXNzPVwiZmlndXJlLWxvZ29cIj48ZGl2IGNsYXNzPVwibG9nb1wiPjxzdmcgeG1sbnM9XCJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2Z1wiIHdpZHRoPVwiMjRcIiBoZWlnaHQ9XCIyNFwiIHZpZXdCb3g9XCIwIDAgMjQgMjRcIiBmaWxsPVwiY3VycmVudENvbG9yXCIgc3Ryb2tlPVwiY3VycmVudENvbG9yXCIgc3Ryb2tlLXdpZHRoPVwiMlwiIHN0cm9rZS1saW5lY2FwPVwicm91bmRcIiBzdHJva2UtbGluZWpvaW49XCJyb3VuZFwiIGNsYXNzPVwiZmVhdGhlciBmZWF0aGVyLXBsYXlcIj48cG9seWdvbiBwb2ludHM9XCI1IDMgMTkgMTIgNSAyMSA1IDNcIj48L3BvbHlnb24+PC9zdmc+PC9kaXY+PC9kaXY+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGRMd3FoSiB0aXRsZSBkeW5hbWljLXNpemluZ1wiPkl1ZWwtdmlkZW88L3NwYW4+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBjbmFLa00gdGl0bGUgZHluYW1pYy1zaXppbmdcIj5za2FwZXIgcmFiYWxkZXI8L3NwYW4+PC9oMz48L2hlYWRlcj48L2E+PC9hcnRpY2xlPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTEyIG1lZGl1bS0xMiBsYXJnZS0xMlwiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJwbHVzcy1tb2RlbC1mcm9udFwiIGRhdGEtbGFiZWw9XCJwbHVzc1wiIGRhdGEtZnJvbT1cInhhdmllclwiIGRhdGEtcmV2ZXJzZUltYWdlVGV4dE9yZGVyPVwiZmFsc2VcIj48YSB0YXJnZXQ9XCJfc2VsZlwiIGFyaWEtbGFiZWw9XCJDaHJpc3RpbmEgKDI1KSB2aXNlciBrcm9wcGVuOiAtIEZvcm7DuHlkXCIgaHJlZj1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby90ZW1hL2NocmlzdGluYS0yNS12aXNlci1rcm9wcGVuLWZvcm5veWQvODEzMDc3NTNcIj48ZmlndXJlIGNsYXNzPVwieF9fc2MtMWFuN3Z1MS0wIGZqSnl2RVwiPjxwaWN0dXJlPjxpbWcgZGF0YS1kZWZlcj1cInZpZXdcIiB0aXRsZT1cIkltYWdlOiBDaHJpc3RpbmEgKDI1KSB2aXNlciBrcm9wcGVuOiAtIEZvcm7DuHlkXCIgYWx0PVwiSW1hZ2U6IENocmlzdGluYSAoMjUpIHZpc2VyIGtyb3BwZW46IC0gRm9ybsO4eWRcIiBkZWNvZGluZz1cImFzeW5jXCIgY2xhc3M9XCJsYXp5bG9hZFwiIGRhdGEtc3JjPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2ltYWdlcy8/aW1hZ2VJZD04MTMwODUzNSZhbXA7cGFub3k9MjMuOTcwMDM3NDUzMTg0JmFtcDtwYW5veD0wJmFtcDtwYW5vdz0xMDAmYW1wO3Bhbm9oPTI3LjcxNTM1NTgwNTI0MyZhbXA7aGVpZ2h0dz0xMDAmYW1wO2hlaWdodGg9MTAwJmFtcDtoZWlnaHR4PTAmYW1wO2hlaWdodHk9MCZhbXA7d2lkdGg9MzIwJmFtcDtoZWlnaHQ9MTYwJmFtcDtjb21wcmVzc2lvbj03MFwiIHNyYz1cImRhdGE6aW1hZ2UvcG5nO2Jhc2U2NCxpVkJPUncwS0dnb0FBQUFOU1VoRVVnQUFBQkFBQUFBSkNBWUFBQUE3S3F3eUFBQUFGMGxFUVZSNDJtTjgrK2I5ZndZS0FPT29BYU1HQUFFQTR1a2lDVUNiVzBjQUFBQUFTVVZPUks1Q1lJST1cIiBsb2FkaW5nPVwibGF6eVwiIGZldGNoUHJpb3JpdHk9XCJhdXRvXCIvPjwvcGljdHVyZT48ZGl2IGNsYXNzPVwiZmlndXJlLWxvZ29cIj48ZGl2IGNsYXNzPVwibG9nb1wiPjxzdmcgeG1sbnM9XCJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2Z1wiIHdpZHRoPVwiMjRcIiBoZWlnaHQ9XCIyNFwiIHZpZXdCb3g9XCIwIDAgMjQgMjRcIiBmaWxsPVwibm9uZVwiIHN0cm9rZT1cImN1cnJlbnRDb2xvclwiIHN0cm9rZS13aWR0aD1cIjNcIj48bGluZSB4MT1cIjEyXCIgeTE9XCI1XCIgeDI9XCIxMlwiIHkyPVwiMTlcIj48L2xpbmU+PGxpbmUgeDE9XCI1XCIgeTE9XCIxMlwiIHgyPVwiMTlcIiB5Mj1cIjEyXCI+PC9saW5lPjwvc3ZnPjwvZGl2PjwvZGl2PjwvZmlndXJlPjxoZWFkZXI+PGgzIGNsYXNzPVwieGF2aWVyLWhlYWRsaW5lIGhlYWRsaW5lXCI+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCB6V3NjRSB0aXRsZSBkeW5hbWljLXNpemluZ1wiPkNocmlzdGluYSAoMjUpIHZpc2VyPC9zcGFuPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgeldzY0UgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5rcm9wcGVuOiAtIEZvcm7DuHlkPC9zcGFuPjwvaDM+PC9oZWFkZXI+PC9hPjwvYXJ0aWNsZT48L2Rpdj48L2Rpdj48L2Rpdj48ZGl2IGNsYXNzPVwicm93IHhyb3cgZmxleC1pbml0aWFsXCI+PGFydGljbGUgY2xhc3M9XCJwcmV2aWV3IGNvbHVtbnMgc21hbGwtNiBtZWRpdW0tNiBsYXJnZS02XCIgZGF0YS1jeGVuc2VfdGFnPVwiY2VyZWJyb1wiIGRhdGEtY3hlbmNlX3dpZGdldD1cImRhZ2JsYWRldC1tb2RlbC1mcm9udFwiIGRhdGEtbGFiZWw9XCJcIiBkYXRhLWZyb209XCJ4YXZpZXJcIiBkYXRhLXJldmVyc2VJbWFnZVRleHRPcmRlcj1cImZhbHNlXCI+PGEgdGFyZ2V0PVwiX3NlbGZcIiBhcmlhLWxhYmVsPVwiLSBMw7hnbmVyLCB0eXYgb2cgbW9yZGVyXCIgaHJlZj1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9ueWhldGVyL2xvZ25lci10eXYtb2ctbW9yZGVyLzgxMzY2ODQ4XCI+PGZpZ3VyZSBjbGFzcz1cInhfX3NjLTFhbjd2dTEtMCBmblFESGJcIj48cGljdHVyZT48aW1nIGRhdGEtZGVmZXI9XCJ2aWV3XCIgdGl0bGU9XCJJbWFnZTogLSBMw7hnbmVyLCB0eXYgb2cgbW9yZGVyXCIgYWx0PVwiSW1hZ2U6IC0gTMO4Z25lciwgdHl2IG9nIG1vcmRlclwiIGRlY29kaW5nPVwiYXN5bmNcIiBjbGFzcz1cImxhenlsb2FkXCIgZGF0YS1zcmM9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vaW1hZ2VzLz9pbWFnZUlkPTgwOTkyMDg3JmFtcDtwYW5vdz0xMDAmYW1wO3Bhbm9oPTEwMCZhbXA7cGFub3k9MCZhbXA7cGFub3g9MCZhbXA7aGVpZ2h0eD0wJmFtcDtoZWlnaHR3PTEwMCZhbXA7aGVpZ2h0aD0xMDAmYW1wO2hlaWdodHk9MCZhbXA7d2lkdGg9NDg1JmFtcDtoZWlnaHQ9MjQyJmFtcDtjb21wcmVzc2lvbj03MFwiIHNyYz1cImRhdGE6aW1hZ2UvcG5nO2Jhc2U2NCxpVkJPUncwS0dnb0FBQUFOU1VoRVVnQUFBQkFBQUFBSkNBWUFBQUE3S3F3eUFBQUFGMGxFUVZSNDJtTjgrK2I5ZndZS0FPT29BYU1HQUFFQTR1a2lDVUNiVzBjQUFBQUFTVVZPUks1Q1lJST1cIiBsb2FkaW5nPVwibGF6eVwiIGZldGNoUHJpb3JpdHk9XCJhdXRvXCIvPjwvcGljdHVyZT48L2ZpZ3VyZT48aGVhZGVyPjxoMyBjbGFzcz1cInhhdmllci1oZWFkbGluZSBoZWFkbGluZVwiPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgakNrTHZTIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+LSBMw7hnbmVyLDwvc3Bhbj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGZ0ZXRTUSB0aXRsZSBkeW5hbWljLXNpemluZ1wiPnR5diBvZyBtb3JkZXI8L3NwYW4+PC9oMz48L2hlYWRlcj48L2E+PC9hcnRpY2xlPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTYgbWVkaXVtLTYgbGFyZ2UtNiBiZy1yZWRcIiBkYXRhLWN4ZW5zZV90YWc9XCJjZXJlYnJvXCIgZGF0YS1jeGVuY2Vfd2lkZ2V0PVwiZGFnYmxhZGV0LW1vZGVsLWZyb250XCIgZGF0YS1sYWJlbD1cIlwiIGRhdGEtZnJvbT1cInhhdmllclwiIGRhdGEtcmV2ZXJzZUltYWdlVGV4dE9yZGVyPVwiZmFsc2VcIj48YSB0YXJnZXQ9XCJfc2VsZlwiIGFyaWEtbGFiZWw9XCJEZXR0ZSB0cnVlciBzaWtrZXJoZXRlbiB1bmRlciBFdXJvdmlzaW9uXCIgaHJlZj1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9ueWhldGVyL2RldHRlLXRydWVyLXNpa2tlcmhldGVuLXVuZGVyLWV1cm92aXNpb24vODEzNjMzMzlcIj48ZmlndXJlIGNsYXNzPVwieF9fc2MtMWFuN3Z1MS0wIGpBU2tORFwiPjxwaWN0dXJlPjxpbWcgZGF0YS1kZWZlcj1cInZpZXdcIiB0aXRsZT1cIkltYWdlOiBEZXR0ZSB0cnVlciBzaWtrZXJoZXRlbiB1bmRlciBFdXJvdmlzaW9uXCIgYWx0PVwiSW1hZ2U6IERldHRlIHRydWVyIHNpa2tlcmhldGVuIHVuZGVyIEV1cm92aXNpb25cIiBkZWNvZGluZz1cImFzeW5jXCIgY2xhc3M9XCJsYXp5bG9hZFwiIGRhdGEtc3JjPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2ltYWdlcy8/aW1hZ2VJZD04MTM2NDUyNSZhbXA7cGFub3k9MCZhbXA7cGFub3g9MCZhbXA7cGFub3c9MTAwJmFtcDtwYW5vaD0xMDAmYW1wO2hlaWdodGg9MTAwJmFtcDtoZWlnaHR5PTAmYW1wO2hlaWdodHg9MCZhbXA7aGVpZ2h0dz0xMDAmYW1wO3dpZHRoPTQ4NSZhbXA7aGVpZ2h0PTMxOCZhbXA7Y29tcHJlc3Npb249NzBcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGVycENobyB0aXRsZSBkeW5hbWljLXNpemluZ1wiPkRldHRlIHRydWVyIHNpa2tlcmhldGVuPC9zcGFuPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgYnZYcVhuIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+dW5kZXIgRXVyb3Zpc2lvbjwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PC9kaXY+PGRpdiBjbGFzcz1cInJvdyB4cm93IGZsZXgtaW5pdGlhbFwiPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTcgbWVkaXVtLTcgbGFyZ2UtN1wiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJkYWdibGFkZXQtbW9kZWwtZnJvbnRcIiBkYXRhLWxhYmVsPVwiXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIlNqb2trcHJpcyFcIiBocmVmPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL3Nwb3J0L2VsbGV2aWxsZS1tYXRwcmlzZXIvODEzNjM3MzJcIj48ZmlndXJlIGNsYXNzPVwieF9fc2MtMWFuN3Z1MS0wIGt2aUFyeVwiPjxwaWN0dXJlPjxpbWcgZGF0YS1kZWZlcj1cInZpZXdcIiB0aXRsZT1cIkltYWdlOiBTam9ra3ByaXMhXCIgYWx0PVwiSW1hZ2U6IFNqb2trcHJpcyFcIiBkZWNvZGluZz1cImFzeW5jXCIgY2xhc3M9XCJsYXp5bG9hZFwiIGRhdGEtc3JjPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2ltYWdlcy8/aW1hZ2VJZD04MTM2Mzc5MCZhbXA7cGFub3k9MCZhbXA7cGFub3g9MCZhbXA7cGFub3c9MTAwJmFtcDtwYW5vaD0xMDAmYW1wO2hlaWdodHg9MCZhbXA7aGVpZ2h0dz0xMDAmYW1wO2hlaWdodGg9MTAwJmFtcDtoZWlnaHR5PTAmYW1wO3dpZHRoPTU2NyZhbXA7aGVpZ2h0PTI4MyZhbXA7Y29tcHJlc3Npb249NzBcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGlLYWxoUCB0aXRsZSBkeW5hbWljLXNpemluZ1wiPlNqb2trcHJpcyE8L3NwYW4+PC9oMz48L2hlYWRlcj48L2E+PC9hcnRpY2xlPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTUgbWVkaXVtLTUgbGFyZ2UtNVwiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJkYWdibGFkZXQtbW9kZWwtZnJvbnRcIiBkYXRhLWxhYmVsPVwiXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIk1vZGVsbC1pa29uIGTDuGRlXCIgaHJlZj1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9ramVuZGlzL21vZGVsbC1pa29uLWRvZGUvODEzNjA0MjBcIj48ZmlndXJlIGNsYXNzPVwieF9fc2MtMWFuN3Z1MS0wIGpsa0dydlwiPjxwaWN0dXJlPjxpbWcgZGF0YS1kZWZlcj1cInZpZXdcIiB0aXRsZT1cIkltYWdlOiBNb2RlbGwtaWtvbiBkw7hkZVwiIGFsdD1cIkltYWdlOiBNb2RlbGwtaWtvbiBkw7hkZVwiIGRlY29kaW5nPVwiYXN5bmNcIiBjbGFzcz1cImxhenlsb2FkXCIgZGF0YS1zcmM9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vaW1hZ2VzLz9pbWFnZUlkPTgxMzYwNjEzJmFtcDtwYW5veD0wLjE1NzIzMzAxODg2NzkzJmFtcDtwYW5vdz05OS44NDI3NjY5ODExMzImYW1wO3Bhbm9oPTQ2LjI4NDUwMDYzNjk0MyZhbXA7cGFub3k9MTcuODM0Mzk0OTA0NDU5JmFtcDtoZWlnaHR5PTAuMjIzNzE0MDkzOTU5NzQmYW1wO2hlaWdodHg9NTEuNzQxMjkzNTMyMzM4JmFtcDtoZWlnaHR3PTQ1LjYwNTMwNjQ2NzY2MiZhbXA7aGVpZ2h0aD05OS43NzYyODU5MDYwNCZhbXA7d2lkdGg9NDAyJmFtcDtoZWlnaHQ9MzU2JmFtcDtjb21wcmVzc2lvbj03MFwiIHNyYz1cImRhdGE6aW1hZ2UvcG5nO2Jhc2U2NCxpVkJPUncwS0dnb0FBQUFOU1VoRVVnQUFBQkFBQUFBSkNBWUFBQUE3S3F3eUFBQUFGMGxFUVZSNDJtTjgrK2I5ZndZS0FPT29BYU1HQUFFQTR1a2lDVUNiVzBjQUFBQUFTVVZPUks1Q1lJST1cIiBsb2FkaW5nPVwibGF6eVwiIGZldGNoUHJpb3JpdHk9XCJhdXRvXCIvPjwvcGljdHVyZT48L2ZpZ3VyZT48aGVhZGVyPjxoMyBjbGFzcz1cInhhdmllci1oZWFkbGluZSBoZWFkbGluZVwiPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgakVodnR3IHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+TW9kZWxsLWlrb24gZMO4ZGU8L3NwYW4+PC9oMz48L2hlYWRlcj48L2E+PC9hcnRpY2xlPjwvZGl2PjxkaXYgY2xhc3M9XCJyb3cgeHJvdyBmbGV4LWluaXRpYWxcIj48YXJ0aWNsZSBjbGFzcz1cInByZXZpZXcgY29sdW1ucyBzbWFsbC00IG1lZGl1bS00IGxhcmdlLTRcIiBkYXRhLWN4ZW5zZV90YWc9XCJjZXJlYnJvXCIgZGF0YS1jeGVuY2Vfd2lkZ2V0PVwicGx1c3MtbW9kZWwtZnJvbnRcIiBkYXRhLWxhYmVsPVwicGx1c3NcIiBkYXRhLWZyb209XCJ4YXZpZXJcIiBkYXRhLXJldmVyc2VJbWFnZVRleHRPcmRlcj1cImZhbHNlXCI+PGEgdGFyZ2V0PVwiX3NlbGZcIiBhcmlhLWxhYmVsPVwiTGF2dCBzdG9mZnNraWZ0ZS1zdHVkaWU6IC0gQmVkcmUgZW5uIExldmF4aW5cIiBocmVmPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL3RlbWEvbGF2dC1zdG9mZnNraWZ0ZS1zdHVkaWUtYmVkcmUtZW5uLWxldmF4aW4vODEzMTk5NzZcIj48ZmlndXJlIGNsYXNzPVwieF9fc2MtMWFuN3Z1MS0wIGtkU3RsRFwiPjxwaWN0dXJlPjxpbWcgZGF0YS1kZWZlcj1cInZpZXdcIiB0aXRsZT1cIkltYWdlOiBMYXZ0IHN0b2Zmc2tpZnRlLXN0dWRpZTogLSBCZWRyZSBlbm4gTGV2YXhpblwiIGFsdD1cIkltYWdlOiBMYXZ0IHN0b2Zmc2tpZnRlLXN0dWRpZTogLSBCZWRyZSBlbm4gTGV2YXhpblwiIGRlY29kaW5nPVwiYXN5bmNcIiBjbGFzcz1cImxhenlsb2FkXCIgZGF0YS1zcmM9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vaW1hZ2VzLz9pbWFnZUlkPTgxMzUwNTgyJmFtcDtwYW5vaD0xMDAmYW1wO3Bhbm95PTAmYW1wO3Bhbm94PTAmYW1wO3Bhbm93PTEwMCZhbXA7aGVpZ2h0eD0wJmFtcDtoZWlnaHR3PTEwMCZhbXA7aGVpZ2h0aD0xMDAmYW1wO2hlaWdodHk9MCZhbXA7d2lkdGg9MzIwJmFtcDtoZWlnaHQ9MjU1JmFtcDtjb21wcmVzc2lvbj03MFwiIHNyYz1cImRhdGE6aW1hZ2UvcG5nO2Jhc2U2NCxpVkJPUncwS0dnb0FBQUFOU1VoRVVnQUFBQkFBQUFBSkNBWUFBQUE3S3F3eUFBQUFGMGxFUVZSNDJtTjgrK2I5ZndZS0FPT29BYU1HQUFFQTR1a2lDVUNiVzBjQUFBQUFTVVZPUks1Q1lJST1cIiBsb2FkaW5nPVwibGF6eVwiIGZldGNoUHJpb3JpdHk9XCJhdXRvXCIvPjwvcGljdHVyZT48ZGl2IGNsYXNzPVwiZmlndXJlLWxvZ29cIj48ZGl2IGNsYXNzPVwibG9nb1wiPjxzdmcgeG1sbnM9XCJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2Z1wiIHdpZHRoPVwiMjRcIiBoZWlnaHQ9XCIyNFwiIHZpZXdCb3g9XCIwIDAgMjQgMjRcIiBmaWxsPVwibm9uZVwiIHN0cm9rZT1cImN1cnJlbnRDb2xvclwiIHN0cm9rZS13aWR0aD1cIjNcIj48bGluZSB4MT1cIjEyXCIgeTE9XCI1XCIgeDI9XCIxMlwiIHkyPVwiMTlcIj48L2xpbmU+PGxpbmUgeDE9XCI1XCIgeTE9XCIxMlwiIHgyPVwiMTlcIiB5Mj1cIjEyXCI+PC9saW5lPjwvc3ZnPjwvZGl2PjwvZGl2PjwvZmlndXJlPjxoZWFkZXI+PGgzIGNsYXNzPVwieGF2aWVyLWhlYWRsaW5lIGhlYWRsaW5lXCI+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBkREtlRFEgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5MYXZ0IHN0b2Zmc2tpZnRlLXN0dWRpZTo8L3NwYW4+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBjRnRDTiB0aXRsZSBkeW5hbWljLXNpemluZ1wiPi0gQmVkcmUgZW5uIExldmF4aW48L3NwYW4+PC9oMz48L2hlYWRlcj48L2E+PC9hcnRpY2xlPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTQgbWVkaXVtLTQgbGFyZ2UtNCBiZy1ibGFja1wiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJ2aWRlby1tZXRhcG9wLW1vZGVsXCIgZGF0YS1sYWJlbD1cInZpZGVvXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIlBvbGl0aWV0IGRlbGVyIHZpZGVvXCIgaHJlZj1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby92aWRlby9maWxtZXItcnlzdGVuZGUtZm9yYmlram9yaW5nLXN0cmFmZmVzL3ZrdUhBYTczXCI+PGZpZ3VyZSBjbGFzcz1cInhfX3NjLTFhbjd2dTEtMCBmakp5dkUgbW92aW5nLWltYWdlLWNvbnRhaW5lclwiPjx2aWRlbyBtdXRlZD1cIlwiIGxvb3A9XCJcIiBkYXRhLXZpZGVvLWRlZmVyPVwidmlld1wiIHByZWxvYWQ9XCJub25lXCIgdGl0bGU9XCJJbWFnZTogUG9saXRpZXQgZGVsZXIgdmlkZW9cIiBjbGFzcz1cIm1vdmluZy1pbWFnZVwiIHBsYXlzaW5saW5lPVwiXCIgcG9zdGVyPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2ltYWdlcy84MTM2NDMzOC5qcGc/aW1hZ2VJZD04MTM2NDMzOCZhbXA7eD0wLjAwMDAwMCZhbXA7eT0wLjAwMDAwMCZhbXA7Y3JvcHc9MC4wMDAwMDAmYW1wO2Nyb3BoPTAuMDAwMDAwJmFtcDt3aWR0aD0zMjAmYW1wO2hlaWdodD0xNjBcIiBkaXNhYmxlcmVtb3RlcGxheWJhY2s9XCJcIj48c291cmNlIHNyYz1cImh0dHBzOi8vc25pcHAuZGJzdGF0aWMubm8vMjAyNC8wNS8wNi84MWE1MmJiNC0zZDcyLTQ1YjUtOWNjMC1hYzQ2MzY5NTY1ZmUvZ2lmMi53ZWJtXCIgdHlwZT1cInZpZGVvL3dlYm1cIi8+PHNvdXJjZSBzcmM9XCJodHRwczovL3NuaXBwLmRic3RhdGljLm5vLzIwMjQvMDUvMDYvODFhNTJiYjQtM2Q3Mi00NWI1LTljYzAtYWM0NjM2OTU2NWZlL2dpZjIubXA0XCIgdHlwZT1cInZpZGVvL21wNFwiLz48L3ZpZGVvPjxkaXYgY2xhc3M9XCJmaWd1cmUtbG9nb1wiPjxkaXYgY2xhc3M9XCJsb2dvXCI+PHN2ZyB4bWxucz1cImh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnXCIgd2lkdGg9XCIyNFwiIGhlaWdodD1cIjI0XCIgdmlld0JveD1cIjAgMCAyNCAyNFwiIGZpbGw9XCJjdXJyZW50Q29sb3JcIiBzdHJva2U9XCJjdXJyZW50Q29sb3JcIiBzdHJva2Utd2lkdGg9XCIyXCIgc3Ryb2tlLWxpbmVjYXA9XCJyb3VuZFwiIHN0cm9rZS1saW5lam9pbj1cInJvdW5kXCIgY2xhc3M9XCJmZWF0aGVyIGZlYXRoZXItcGxheVwiPjxwb2x5Z29uIHBvaW50cz1cIjUgMyAxOSAxMiA1IDIxIDUgM1wiPjwvcG9seWdvbj48L3N2Zz48L2Rpdj48L2Rpdj48L2ZpZ3VyZT48aGVhZGVyPjxoMyBjbGFzcz1cInhhdmllci1oZWFkbGluZSBoZWFkbGluZVwiPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgZVFvVmFTIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+UG9saXRpZXQ8L3NwYW4+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBpbmtzRVYgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5kZWxlciB2aWRlbzwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PGRpdiBpZD1cImFwb3MtbWVkaXVtLXJlY3RhbmdsZS1wZXJ6M1wiIGNsYXNzPVwiYWR1bml0LXdyYXBwZXIgY29sdW1ucyBzbWFsbC00IG1lZGl1bS00IGxhcmdlLTQgdHJhY2stZWxlbWVudCAgXCIgZGF0YS1mcm9tPVwieGF2aWVyXCI+PGRpdiBpZD1cImFkLW1lZGl1bS1yZWN0YW5nbGUtcGVyejNcIiBjbGFzcz1cImFkdW5pdCBHb29nbGVBY3RpdmVWaWV3RWxlbWVudCBzbWFsbC0zMjB4MjUwIG1lZGl1bS0zMjB4MjUwIGxhcmdlLTMyMHgyNTBcIiBpdGVtc2NvcGU9XCJcIiBpdGVtVHlwZT1cImh0dHBzOi8vc2NoZW1hLm9yZy9XUEFkQmxvY2tcIiBkYXRhLXNpemVzPVwiW1szMjAsMjUwXSxbMzAwLDI1MF0sJnF1b3Q7Zmx1aWQmcXVvdDtdXCIgZGF0YS1zbG90PVwiLzg1NzgvZGFnYmxhZGV0Lm5vL2ZvcnNpZGVcIiBkYXRhLWxvYWQtb249XCJ2aWV3XCIgZGF0YS1jb2xsYXBzZT1cImZhbHNlXCIgZGF0YS1leHBhbmQ9XCJmYWxzZVwiIGRhdGEtb3V0LW9mLXBhZ2U9XCJmYWxzZVwiIGpzb249XCJ7JnF1b3Q7dGFyZ2V0aW5nJnF1b3Q7OiB7JnF1b3Q7cG9zJnF1b3Q7OiZxdW90O21lZGl1bS1yZWN0YW5nbGUtcGVyejMmcXVvdDssJnF1b3Q7cGxhdGZvcm0mcXVvdDs6JnF1b3Q7d29sdmVyaW5lJnF1b3Q7fX1cIj48L2Rpdj48L2Rpdj48L2Rpdj48ZGl2IGNsYXNzPVwicm93IHhyb3cgZmxleC1pbml0aWFsXCI+PGFydGljbGUgY2xhc3M9XCJwcmV2aWV3IGNvbHVtbnMgc21hbGwtNiBtZWRpdW0tNiBsYXJnZS02XCIgZGF0YS1jeGVuc2VfdGFnPVwiY2VyZWJyb1wiIGRhdGEtY3hlbmNlX3dpZGdldD1cImRhZ2JsYWRldC1tb2RlbC1mcm9udFwiIGRhdGEtbGFiZWw9XCJcIiBkYXRhLWZyb209XCJ4YXZpZXJcIiBkYXRhLXJldmVyc2VJbWFnZVRleHRPcmRlcj1cImZhbHNlXCI+PGEgdGFyZ2V0PVwiX3NlbGZcIiBhcmlhLWxhYmVsPVwiRMO4ZGUgYXYgYnJ5c3RrcmVmdFwiIGhyZWY9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vbnloZXRlci9kb2RlLWF2LWJyeXN0a3JlZnQvODEzNjM1NDBcIj48ZmlndXJlIGNsYXNzPVwieF9fc2MtMWFuN3Z1MS0wIGRIR3doQ1wiPjxwaWN0dXJlPjxpbWcgZGF0YS1kZWZlcj1cInZpZXdcIiB0aXRsZT1cIkltYWdlOiBEw7hkZSBhdiBicnlzdGtyZWZ0XCIgYWx0PVwiSW1hZ2U6IETDuGRlIGF2IGJyeXN0a3JlZnRcIiBkZWNvZGluZz1cImFzeW5jXCIgY2xhc3M9XCJsYXp5bG9hZFwiIGRhdGEtc3JjPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2ltYWdlcy8/aW1hZ2VJZD04MTM2MzYxMSZhbXA7cGFub3k9Mi4xNjU2MDUwOTU1NDE0JmFtcDtwYW5veD03LjMyMzIzMjMyMzIzMjMmYW1wO3Bhbm93PTgzLjU4NTg1ODU4NTg1OSZhbXA7cGFub2g9MzUuNTM3MTkwMDgyNjQ1JmFtcDtoZWlnaHR3PTUzLjU3MTQyODU3MTQyOSZhbXA7aGVpZ2h0aD01NC4wNDQxMTc2NDcwNTkmYW1wO2hlaWdodHk9MCZhbXA7aGVpZ2h0eD0yMy4yMTQyODU3MTQyODYmYW1wO3dpZHRoPTQ4NSZhbXA7aGVpZ2h0PTI2MyZhbXA7Y29tcHJlc3Npb249NzBcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGVQdVN3TyB0aXRsZSBkeW5hbWljLXNpemluZ1wiPkTDuGRlIGF2PC9zcGFuPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgZFFTQ0JSIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+YnJ5c3RrcmVmdDwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PGFydGljbGUgY2xhc3M9XCJwcmV2aWV3IGNvbHVtbnMgc21hbGwtNiBtZWRpdW0tNiBsYXJnZS02IGJnLXJlZFwiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJkYWdibGFkZXQtbW9kZWwtZnJvbnRcIiBkYXRhLWxhYmVsPVwiXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIk7DpWRlbMO4cyBtZWxkaW5nXCIgaHJlZj1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9zcG9ydC9uYWRlbG9zLW1lbGRpbmcvODEzNTk5NzdcIj48ZmlndXJlIGNsYXNzPVwieF9fc2MtMWFuN3Z1MS0wIGZuUURIYlwiPjxwaWN0dXJlPjxpbWcgZGF0YS1kZWZlcj1cInZpZXdcIiB0aXRsZT1cIkltYWdlOiBOw6VkZWzDuHMgbWVsZGluZ1wiIGFsdD1cIkltYWdlOiBOw6VkZWzDuHMgbWVsZGluZ1wiIGRlY29kaW5nPVwiYXN5bmNcIiBjbGFzcz1cImxhenlsb2FkXCIgZGF0YS1zcmM9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vaW1hZ2VzLz9pbWFnZUlkPTgxMzYwMDEwJmFtcDtwYW5veD0wJmFtcDtwYW5vdz0xMDAmYW1wO3Bhbm9oPTQ0LjkzNjcwODg2MDc1OSZhbXA7cGFub3k9MTMuOTI0MDUwNjMyOTExJmFtcDtoZWlnaHR4PTAmYW1wO2hlaWdodHc9MTAwJmFtcDtoZWlnaHRoPTEwMCZhbXA7aGVpZ2h0eT0wJmFtcDt3aWR0aD00ODUmYW1wO2hlaWdodD0yNDImYW1wO2NvbXByZXNzaW9uPTcwXCIgc3JjPVwiZGF0YTppbWFnZS9wbmc7YmFzZTY0LGlWQk9SdzBLR2dvQUFBQU5TVWhFVWdBQUFCQUFBQUFKQ0FZQUFBQTdLcXd5QUFBQUYwbEVRVlI0Mm1OOCsrYjlmd1lLQU9Pb0FhTUdBQUVBNHVraUNVQ2JXMGNBQUFBQVNVVk9SSzVDWUlJPVwiIGxvYWRpbmc9XCJsYXp5XCIgZmV0Y2hQcmlvcml0eT1cImF1dG9cIi8+PC9waWN0dXJlPjwvZmlndXJlPjxoZWFkZXI+PGgzIGNsYXNzPVwieGF2aWVyLWhlYWRsaW5lIGhlYWRsaW5lXCI+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBlWUdDa2QgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5Ow6VkZWzDuHM8L3NwYW4+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBlWUdDa2QgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5tZWxkaW5nPC9zcGFuPjwvaDM+PC9oZWFkZXI+PC9hPjwvYXJ0aWNsZT48L2Rpdj48ZGl2IGNsYXNzPVwicm93IHhyb3cgZmxleC1pbml0aWFsXCI+PGFydGljbGUgY2xhc3M9XCJwcmV2aWV3IGNvbHVtbnMgc21hbGwtNiBtZWRpdW0tNiBsYXJnZS02IGJnLXllbGxvd1wiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJkYWdibGFkZXQtbW9kZWwtZnJvbnRcIiBkYXRhLWxhYmVsPVwiXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIkFyYmVpZHNwbGFzc2VuIGkgc29yZ1wiIGhyZWY9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vc3BvcnQvYXJiZWlkc3BsYXNzZW4taS1zb3JnLzgxMzY1NTQ5XCI+PGZpZ3VyZSBjbGFzcz1cInhfX3NjLTFhbjd2dTEtMCBmWHpaeVpcIj48cGljdHVyZT48aW1nIGRhdGEtZGVmZXI9XCJ2aWV3XCIgdGl0bGU9XCJJbWFnZTogQXJiZWlkc3BsYXNzZW4gaSBzb3JnXCIgYWx0PVwiSW1hZ2U6IEFyYmVpZHNwbGFzc2VuIGkgc29yZ1wiIGRlY29kaW5nPVwiYXN5bmNcIiBjbGFzcz1cImxhenlsb2FkXCIgZGF0YS1zcmM9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vaW1hZ2VzLz9pbWFnZUlkPTgxMzU4NjQ4JmFtcDtwYW5veD0wJmFtcDtwYW5vdz0xMDAmYW1wO3Bhbm9oPTEwMCZhbXA7cGFub3k9MCZhbXA7aGVpZ2h0eT0wJmFtcDtoZWlnaHR4PTAmYW1wO2hlaWdodHc9MTAwJmFtcDtoZWlnaHRoPTEwMCZhbXA7d2lkdGg9NDg1JmFtcDtoZWlnaHQ9NDUxJmFtcDtjb21wcmVzc2lvbj03MFwiIHNyYz1cImRhdGE6aW1hZ2UvcG5nO2Jhc2U2NCxpVkJPUncwS0dnb0FBQUFOU1VoRVVnQUFBQkFBQUFBSkNBWUFBQUE3S3F3eUFBQUFGMGxFUVZSNDJtTjgrK2I5ZndZS0FPT29BYU1HQUFFQTR1a2lDVUNiVzBjQUFBQUFTVVZPUks1Q1lJST1cIiBsb2FkaW5nPVwibGF6eVwiIGZldGNoUHJpb3JpdHk9XCJhdXRvXCIvPjwvcGljdHVyZT48L2ZpZ3VyZT48aGVhZGVyPjxoMyBjbGFzcz1cInhhdmllci1oZWFkbGluZSBoZWFkbGluZVwiPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgaWppY2R6IHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+QXJiZWlkc3BsYXNzZW4gaSBzb3JnPC9zcGFuPjwvaDM+PC9oZWFkZXI+PC9hPjwvYXJ0aWNsZT48YXJ0aWNsZSBjbGFzcz1cInByZXZpZXcgY29sdW1ucyBzbWFsbC02IG1lZGl1bS02IGxhcmdlLTZcIiBkYXRhLWN4ZW5zZV90YWc9XCJjZXJlYnJvXCIgZGF0YS1jeGVuY2Vfd2lkZ2V0PVwiZGFnYmxhZGV0LW1vZGVsLWZyb250XCIgZGF0YS1sYWJlbD1cIlwiIGRhdGEtZnJvbT1cInhhdmllclwiIGRhdGEtcmV2ZXJzZUltYWdlVGV4dE9yZGVyPVwiZmFsc2VcIj48YSB0YXJnZXQ9XCJfc2VsZlwiIGFyaWEtbGFiZWw9XCItIEV0IGhqZXJ0ZSBhdiBndWxsXCIgaHJlZj1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9ueWhldGVyL2V0LWhqZXJ0ZS1hdi1ndWxsLzgxMzY1OTQxXCI+PGZpZ3VyZSBjbGFzcz1cInhfX3NjLTFhbjd2dTEtMCBmblFESGJcIj48cGljdHVyZT48aW1nIGRhdGEtZGVmZXI9XCJ2aWV3XCIgdGl0bGU9XCJJbWFnZTogLSBFdCBoamVydGUgYXYgZ3VsbFwiIGFsdD1cIkltYWdlOiAtIEV0IGhqZXJ0ZSBhdiBndWxsXCIgZGVjb2Rpbmc9XCJhc3luY1wiIGNsYXNzPVwibGF6eWxvYWRcIiBkYXRhLXNyYz1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9pbWFnZXMvP2ltYWdlSWQ9ODEzNjYwMDUmYW1wO3Bhbm95PTAmYW1wO3Bhbm94PTAmYW1wO3Bhbm93PTEwMCZhbXA7cGFub2g9MTAwJmFtcDtoZWlnaHR3PTEwMCZhbXA7aGVpZ2h0eT0wJmFtcDtoZWlnaHR4PTAmYW1wO2hlaWdodGg9MTAwJmFtcDt3aWR0aD00ODUmYW1wO2hlaWdodD0yNDImYW1wO2NvbXByZXNzaW9uPTcwXCIgc3JjPVwiZGF0YTppbWFnZS9wbmc7YmFzZTY0LGlWQk9SdzBLR2dvQUFBQU5TVWhFVWdBQUFCQUFBQUFKQ0FZQUFBQTdLcXd5QUFBQUYwbEVRVlI0Mm1OOCsrYjlmd1lLQU9Pb0FhTUdBQUVBNHVraUNVQ2JXMGNBQUFBQVNVVk9SSzVDWUlJPVwiIGxvYWRpbmc9XCJsYXp5XCIgZmV0Y2hQcmlvcml0eT1cImF1dG9cIi8+PC9waWN0dXJlPjwvZmlndXJlPjxoZWFkZXI+PGgzIGNsYXNzPVwieGF2aWVyLWhlYWRsaW5lIGhlYWRsaW5lXCI+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBoakdLS3EgdGl0bGUgZHluYW1pYy1zaXppbmdcIj4tIEV0IGhqZXJ0ZTwvc3Bhbj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGpZS3h6WCB0aXRsZSBkeW5hbWljLXNpemluZ1wiPmF2IGd1bGw8L3NwYW4+PC9oMz48L2hlYWRlcj48L2E+PC9hcnRpY2xlPjwvZGl2PjxkaXYgY2xhc3M9XCJyb3cgeHJvdyBmbGV4LWluaXRpYWxcIj48ZGl2IGlkPVwiYXBvcy1uZXRib2FyZDVcIiBjbGFzcz1cImFkdW5pdC13cmFwcGVyIGNvbHVtbnMgc21hbGwtOCBtZWRpdW0tOCBsYXJnZS04IHRyYWNrLWVsZW1lbnQgIFwiIGRhdGEtZnJvbT1cInhhdmllclwiPjxkaXYgaWQ9XCJhZC1uZXRib2FyZDVcIiBjbGFzcz1cImFkdW5pdCBHb29nbGVBY3RpdmVWaWV3RWxlbWVudCBzbWFsbC01ODB4NTAwIG1lZGl1bS01ODB4NTAwIGxhcmdlLTU4MHg1MDBcIiBpdGVtc2NvcGU9XCJcIiBpdGVtVHlwZT1cImh0dHBzOi8vc2NoZW1hLm9yZy9XUEFkQmxvY2tcIiBkYXRhLXNpemVzPVwiW1s1ODAsNDAwXSxbNTgwLDUwMF0sJnF1b3Q7Zmx1aWQmcXVvdDtdXCIgZGF0YS1zbG90PVwiLzg1NzgvZGFnYmxhZGV0Lm5vL2ZvcnNpZGVcIiBkYXRhLWxvYWQtb249XCJ2aWV3XCIgZGF0YS1jb2xsYXBzZT1cImZhbHNlXCIgZGF0YS1leHBhbmQ9XCJmYWxzZVwiIGRhdGEtb3V0LW9mLXBhZ2U9XCJmYWxzZVwiIGpzb249XCJ7JnF1b3Q7dGFyZ2V0aW5nJnF1b3Q7OiB7JnF1b3Q7cG9zJnF1b3Q7OiZxdW90O25ldGJvYXJkNSZxdW90OywmcXVvdDtwbGF0Zm9ybSZxdW90OzomcXVvdDt3b2x2ZXJpbmUmcXVvdDt9fVwiPjwvZGl2PjwvZGl2PjxkaXYgY2xhc3M9XCJ4YXZpZXIgY29sdW1ucyBzbWFsbC00IG1lZGl1bS00IGxhcmdlLTRcIj48ZGl2IGNsYXNzPVwicm93IHhyb3cgZmxleC1jb2x1bW5cIj48YXJ0aWNsZSBjbGFzcz1cInByZXZpZXcgY29sdW1ucyBzbWFsbC0xMiBtZWRpdW0tMTIgbGFyZ2UtMTJcIiBkYXRhLWN4ZW5zZV90YWc9XCJjZXJlYnJvXCIgZGF0YS1jeGVuY2Vfd2lkZ2V0PVwicGx1c3MtbW9kZWwtZnJvbnRcIiBkYXRhLWxhYmVsPVwicGx1c3NcIiBkYXRhLWZyb209XCJ4YXZpZXJcIiBkYXRhLXJldmVyc2VJbWFnZVRleHRPcmRlcj1cImZhbHNlXCI+PGEgdGFyZ2V0PVwiX3NlbGZcIiBhcmlhLWxhYmVsPVwiQXZrbGVkZCBww6UgYnlzdHJhbmRhOiBWaXNlciBrcm9wcGVuXCIgaHJlZj1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby90ZW1hL2F2a2xlZGQtcGEtYnlzdHJhbmRhZm9ybm95ZC1tZWQtcnVtcGEvODEzNDQ5NDFcIj48ZmlndXJlIGNsYXNzPVwieF9fc2MtMWFuN3Z1MS0wIGZqSnl2RVwiPjxwaWN0dXJlPjxpbWcgZGF0YS1kZWZlcj1cInZpZXdcIiB0aXRsZT1cIkltYWdlOiBBdmtsZWRkIHDDpSBieXN0cmFuZGE6IFZpc2VyIGtyb3BwZW5cIiBhbHQ9XCJJbWFnZTogQXZrbGVkZCBww6UgYnlzdHJhbmRhOiBWaXNlciBrcm9wcGVuXCIgZGVjb2Rpbmc9XCJhc3luY1wiIGNsYXNzPVwibGF6eWxvYWRcIiBkYXRhLXNyYz1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9pbWFnZXMvP2ltYWdlSWQ9ODEzNTAzMDYmYW1wO3Bhbm95PTIxLjA1MjYzMTU3ODk0NyZhbXA7cGFub3g9MC4xNjc1MDc1Mzc2ODg0NCZhbXA7cGFub3c9MTAwLjE2NzUwNzUzNzY5JmFtcDtwYW5vaD01MC42MjY1NzE0Mjg1NzEmYW1wO2hlaWdodHk9MC4yNDE1NTA3MjQ2Mzc2OCZhbXA7aGVpZ2h0eD0yNy40MDM4NDYxNTM4NDYmYW1wO2hlaWdodHc9NDAuNTQ0ODc1JmFtcDtoZWlnaHRoPTEwMC4yNDE1NTA3MjQ2NCZhbXA7d2lkdGg9MzIwJmFtcDtoZWlnaHQ9MTYwJmFtcDtjb21wcmVzc2lvbj03MFwiIHNyYz1cImRhdGE6aW1hZ2UvcG5nO2Jhc2U2NCxpVkJPUncwS0dnb0FBQUFOU1VoRVVnQUFBQkFBQUFBSkNBWUFBQUE3S3F3eUFBQUFGMGxFUVZSNDJtTjgrK2I5ZndZS0FPT29BYU1HQUFFQTR1a2lDVUNiVzBjQUFBQUFTVVZPUks1Q1lJST1cIiBsb2FkaW5nPVwibGF6eVwiIGZldGNoUHJpb3JpdHk9XCJhdXRvXCIvPjwvcGljdHVyZT48ZGl2IGNsYXNzPVwiZmlndXJlLWxvZ29cIj48ZGl2IGNsYXNzPVwibG9nb1wiPjxzdmcgeG1sbnM9XCJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2Z1wiIHdpZHRoPVwiMjRcIiBoZWlnaHQ9XCIyNFwiIHZpZXdCb3g9XCIwIDAgMjQgMjRcIiBmaWxsPVwibm9uZVwiIHN0cm9rZT1cImN1cnJlbnRDb2xvclwiIHN0cm9rZS13aWR0aD1cIjNcIj48bGluZSB4MT1cIjEyXCIgeTE9XCI1XCIgeDI9XCIxMlwiIHkyPVwiMTlcIj48L2xpbmU+PGxpbmUgeDE9XCI1XCIgeTE9XCIxMlwiIHgyPVwiMTlcIiB5Mj1cIjEyXCI+PC9saW5lPjwvc3ZnPjwvZGl2PjwvZGl2PjwvZmlndXJlPjxoZWFkZXI+PGgzIGNsYXNzPVwieGF2aWVyLWhlYWRsaW5lIGhlYWRsaW5lXCI+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBiV1NuVlMgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5BdmtsZWRkIHDDpTwvc3Bhbj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGhzUGVpYSB0aXRsZSBkeW5hbWljLXNpemluZ1wiPmJ5c3RyYW5kYTo8L3NwYW4+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBkZnNlclAgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5WaXNlciBrcm9wcGVuPC9zcGFuPjwvaDM+PC9oZWFkZXI+PC9hPjwvYXJ0aWNsZT48YXJ0aWNsZSBjbGFzcz1cInByZXZpZXcgY29sdW1ucyBzbWFsbC0xMiBtZWRpdW0tMTIgbGFyZ2UtMTIgYmcteWVsbG93XCIgZGF0YS1jeGVuc2VfdGFnPVwiY2VyZWJyb1wiIGRhdGEtY3hlbmNlX3dpZGdldD1cInZpZGVvLW1ldGFwb3AtbW9kZWxcIiBkYXRhLWxhYmVsPVwidmlkZW9cIiBkYXRhLWZyb209XCJ4YXZpZXJcIiBkYXRhLXJldmVyc2VJbWFnZVRleHRPcmRlcj1cImZhbHNlXCI+PGEgdGFyZ2V0PVwiX3NlbGZcIiBhcmlhLWxhYmVsPVwiSGFyIGZvciBteWUgdmVrdFwiIGhyZWY9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vdmlkZW8vc2V0dC1vdmVyLTEzLW1pbGxpb25lci1nYW5nZXIvN09DNVA5T21cIj48ZmlndXJlIGNsYXNzPVwieF9fc2MtMWFuN3Z1MS0wIGZqSnl2RSBtb3ZpbmctaW1hZ2UtY29udGFpbmVyXCI+PHZpZGVvIG11dGVkPVwiXCIgbG9vcD1cIlwiIGRhdGEtdmlkZW8tZGVmZXI9XCJ2aWV3XCIgcHJlbG9hZD1cIm5vbmVcIiB0aXRsZT1cIkltYWdlOiBIYXIgZm9yIG15ZSB2ZWt0XCIgY2xhc3M9XCJtb3ZpbmctaW1hZ2VcIiBwbGF5c2lubGluZT1cIlwiIHBvc3Rlcj1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9pbWFnZXMvODEzNjAxMjUuanBnP2ltYWdlSWQ9ODEzNjAxMjUmYW1wO3g9MC4wMDAwMDAmYW1wO3k9MC4wMDAwMDAmYW1wO2Nyb3B3PTAuMDAwMDAwJmFtcDtjcm9waD0wLjAwMDAwMCZhbXA7d2lkdGg9MzIwJmFtcDtoZWlnaHQ9MTYwXCIgZGlzYWJsZXJlbW90ZXBsYXliYWNrPVwiXCI+PHNvdXJjZSBzcmM9XCJodHRwczovL3NuaXBwLmRic3RhdGljLm5vLzIwMjMvMDkvMTMvMmZkMWFhZmEtNzI1Yi00MDRlLWIzMDktYWJkMDg0ZGUxNDYzL2dpZjMud2VibVwiIHR5cGU9XCJ2aWRlby93ZWJtXCIvPjxzb3VyY2Ugc3JjPVwiaHR0cHM6Ly9zbmlwcC5kYnN0YXRpYy5uby8yMDIzLzA5LzEzLzJmZDFhYWZhLTcyNWItNDA0ZS1iMzA5LWFiZDA4NGRlMTQ2My9naWYzLm1wNFwiIHR5cGU9XCJ2aWRlby9tcDRcIi8+PC92aWRlbz48ZGl2IGNsYXNzPVwiZmlndXJlLWxvZ29cIj48ZGl2IGNsYXNzPVwibG9nb1wiPjxzdmcgeG1sbnM9XCJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2Z1wiIHdpZHRoPVwiMjRcIiBoZWlnaHQ9XCIyNFwiIHZpZXdCb3g9XCIwIDAgMjQgMjRcIiBmaWxsPVwiY3VycmVudENvbG9yXCIgc3Ryb2tlPVwiY3VycmVudENvbG9yXCIgc3Ryb2tlLXdpZHRoPVwiMlwiIHN0cm9rZS1saW5lY2FwPVwicm91bmRcIiBzdHJva2UtbGluZWpvaW49XCJyb3VuZFwiIGNsYXNzPVwiZmVhdGhlciBmZWF0aGVyLXBsYXlcIj48cG9seWdvbiBwb2ludHM9XCI1IDMgMTkgMTIgNSAyMSA1IDNcIj48L3BvbHlnb24+PC9zdmc+PC9kaXY+PC9kaXY+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGpKcm5OZiB0aXRsZSBkeW5hbWljLXNpemluZ1wiPkhhciBmb3I8L3NwYW4+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBjR0xyU0cgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5teWUgdmVrdDwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PC9kaXY+PC9kaXY+PC9kaXY+PGRpdiBjbGFzcz1cInJvdyB4cm93IGZsZXgtaW5pdGlhbFwiPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTcgbWVkaXVtLTcgbGFyZ2UtN1wiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJkYWdibGFkZXQtbW9kZWwtZnJvbnRcIiBkYXRhLWxhYmVsPVwiXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIlNqb2trZXJ0ZSB2ZXJkZW4gLSBzw6UgZMO4ZGUgaHVuXCIgaHJlZj1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9rdWx0dXIvc2pva2tlcnRlLXZlcmRlbi1zYS1kb2RlLWh1bi84MTMzOTkzOFwiPjxmaWd1cmUgY2xhc3M9XCJ4X19zYy0xYW43dnUxLTAga3ZpQXJ5XCI+PHBpY3R1cmU+PGltZyBkYXRhLWRlZmVyPVwidmlld1wiIHRpdGxlPVwiSW1hZ2U6IFNqb2trZXJ0ZSB2ZXJkZW4gLSBzw6UgZMO4ZGUgaHVuXCIgYWx0PVwiSW1hZ2U6IFNqb2trZXJ0ZSB2ZXJkZW4gLSBzw6UgZMO4ZGUgaHVuXCIgZGVjb2Rpbmc9XCJhc3luY1wiIGNsYXNzPVwibGF6eWxvYWRcIiBkYXRhLXNyYz1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9pbWFnZXMvP2ltYWdlSWQ9ODEzNDAyNTMmYW1wO3Bhbm93PTk5Ljg0Mjc2Njk4MTEzMiZhbXA7cGFub3k9OS40NDg4MTg4OTc2Mzc4JmFtcDtwYW5vaD01Ny4yMTc4NDcyNDQwOTQmYW1wO3Bhbm94PTAuMTU3MjMzMDE4ODY3OTMmYW1wO2hlaWdodHk9MCZhbXA7aGVpZ2h0eD02Mi42ODI5MjY4MjkyNjgmYW1wO2hlaWdodHc9MjIuMzU3NzIzNDE0NjM0JmFtcDtoZWlnaHRoPTYwLjQzMzYwNDA2NTA0MSZhbXA7d2lkdGg9NTY3JmFtcDtoZWlnaHQ9MjgzJmFtcDtjb21wcmVzc2lvbj03MFwiIHNyYz1cImRhdGE6aW1hZ2UvcG5nO2Jhc2U2NCxpVkJPUncwS0dnb0FBQUFOU1VoRVVnQUFBQkFBQUFBSkNBWUFBQUE3S3F3eUFBQUFGMGxFUVZSNDJtTjgrK2I5ZndZS0FPT29BYU1HQUFFQTR1a2lDVUNiVzBjQUFBQUFTVVZPUks1Q1lJST1cIiBsb2FkaW5nPVwibGF6eVwiIGZldGNoUHJpb3JpdHk9XCJhdXRvXCIvPjwvcGljdHVyZT48L2ZpZ3VyZT48aGVhZGVyPjxoMyBjbGFzcz1cInhhdmllci1oZWFkbGluZSBoZWFkbGluZVwiPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgaVhqZExZIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+U2pva2tlcnRlIHZlcmRlbjwvc3Bhbj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGRXek1uQSB0aXRsZSBkeW5hbWljLXNpemluZ1wiPi0gc8OlIGTDuGRlIGh1bjwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PGFydGljbGUgY2xhc3M9XCJwcmV2aWV3IGNvbHVtbnMgc21hbGwtNSBtZWRpdW0tNSBsYXJnZS01XCIgZGF0YS1jeGVuc2VfdGFnPVwiY2VyZWJyb1wiIGRhdGEtY3hlbmNlX3dpZGdldD1cImRhZ2JsYWRldC1tb2RlbC1mcm9udFwiIGRhdGEtbGFiZWw9XCJcIiBkYXRhLWZyb209XCJ4YXZpZXJcIiBkYXRhLXJldmVyc2VJbWFnZVRleHRPcmRlcj1cImZhbHNlXCI+PGEgdGFyZ2V0PVwiX3NlbGZcIiBhcmlhLWxhYmVsPVwiS3JpdGlra2VuIGhhZ2xlcjogLSBGb3JzdHlycmVuZGVcIiBocmVmPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2tqZW5kaXMva3JpdGlra2VuLWhhZ2xlci1mb3JzdHlycmVuZGUvODEzNjUzMTJcIj48ZmlndXJlIGNsYXNzPVwieF9fc2MtMWFuN3Z1MS0wIGxsV214SVwiPjxwaWN0dXJlPjxpbWcgZGF0YS1kZWZlcj1cInZpZXdcIiB0aXRsZT1cIkltYWdlOiBLcml0aWtrZW4gaGFnbGVyOiAtIEZvcnN0eXJyZW5kZVwiIGFsdD1cIkltYWdlOiBLcml0aWtrZW4gaGFnbGVyOiAtIEZvcnN0eXJyZW5kZVwiIGRlY29kaW5nPVwiYXN5bmNcIiBjbGFzcz1cImxhenlsb2FkXCIgZGF0YS1zcmM9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vaW1hZ2VzLz9pbWFnZUlkPTgxMzY1MzE4JmFtcDtwYW5vdz0xMDAmYW1wO3Bhbm9oPTQ4Ljk2NTUxNzI0MTM3OSZhbXA7cGFub3k9MCZhbXA7cGFub3g9MCZhbXA7aGVpZ2h0eT0wJmFtcDtoZWlnaHR4PTMwLjg0MTEyMTQ5NTMyNyZhbXA7aGVpZ2h0dz00Mi4wNTYwNzQ3NjYzNTUmYW1wO2hlaWdodGg9MTAwJmFtcDt3aWR0aD00MDImYW1wO2hlaWdodD0zMzImYW1wO2NvbXByZXNzaW9uPTcwXCIgc3JjPVwiZGF0YTppbWFnZS9wbmc7YmFzZTY0LGlWQk9SdzBLR2dvQUFBQU5TVWhFVWdBQUFCQUFBQUFKQ0FZQUFBQTdLcXd5QUFBQUYwbEVRVlI0Mm1OOCsrYjlmd1lLQU9Pb0FhTUdBQUVBNHVraUNVQ2JXMGNBQUFBQVNVVk9SSzVDWUlJPVwiIGxvYWRpbmc9XCJsYXp5XCIgZmV0Y2hQcmlvcml0eT1cImF1dG9cIi8+PC9waWN0dXJlPjwvZmlndXJlPjxoZWFkZXI+PGgzIGNsYXNzPVwieGF2aWVyLWhlYWRsaW5lIGhlYWRsaW5lXCI+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBnUEl4ZWEgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5Lcml0aWtrZW4gaGFnbGVyOjwvc3Bhbj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGtOaEdnWCB0aXRsZSBkeW5hbWljLXNpemluZ1wiPi0gRm9yc3R5cnJlbmRlPC9zcGFuPjwvaDM+PC9oZWFkZXI+PC9hPjwvYXJ0aWNsZT48L2Rpdj48ZGl2IGNsYXNzPVwicm93IHhyb3cgZmxleC1pbml0aWFsXCI+PGFydGljbGUgY2xhc3M9XCJwcmV2aWV3IGNvbHVtbnMgc21hbGwtNSBtZWRpdW0tNSBsYXJnZS01XCIgZGF0YS1jeGVuc2VfdGFnPVwiY2VyZWJyb1wiIGRhdGEtY3hlbmNlX3dpZGdldD1cImRhZ2JsYWRldC1tb2RlbC1mcm9udFwiIGRhdGEtbGFiZWw9XCJcIiBkYXRhLWZyb209XCJ4YXZpZXJcIiBkYXRhLXJldmVyc2VJbWFnZVRleHRPcmRlcj1cImZhbHNlXCI+PGEgdGFyZ2V0PVwiX3NlbGZcIiBhcmlhLWxhYmVsPVwiT20ga2rDpnJsaWdoZXRzbGl2ZXQ6IC0gU3TDpXIgYnJhIHRpbFwiIGhyZWY9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8va2plbmRpcy9vbS1ramFlcmxpZ2hldHNsaXZldC1zdGFyLWJyYS10aWwvODEzNjMxNjdcIj48ZmlndXJlIGNsYXNzPVwieF9fc2MtMWFuN3Z1MS0wIGJuYllGelwiPjxwaWN0dXJlPjxpbWcgZGF0YS1kZWZlcj1cInZpZXdcIiB0aXRsZT1cIkltYWdlOiBPbSBrasOmcmxpZ2hldHNsaXZldDogLSBTdMOlciBicmEgdGlsXCIgYWx0PVwiSW1hZ2U6IE9tIGtqw6ZybGlnaGV0c2xpdmV0OiAtIFN0w6VyIGJyYSB0aWxcIiBkZWNvZGluZz1cImFzeW5jXCIgY2xhc3M9XCJsYXp5bG9hZFwiIGRhdGEtc3JjPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2ltYWdlcy8/aW1hZ2VJZD04MTM2Mzg3MSZhbXA7cGFub3k9MTEuMzIwNzU0NzE2OTgxJmFtcDtwYW5veD0wJmFtcDtwYW5vdz05OS44NDI3NjY5ODExMzImYW1wO3Bhbm9oPTIyLjg1MTE1MjgzMDE4OSZhbXA7aGVpZ2h0eD0wJmFtcDtoZWlnaHR3PTEwMCZhbXA7aGVpZ2h0aD0xMDAmYW1wO2hlaWdodHk9MCZhbXA7d2lkdGg9NDAyJmFtcDtoZWlnaHQ9MzY2JmFtcDtjb21wcmVzc2lvbj03MFwiIHNyYz1cImRhdGE6aW1hZ2UvcG5nO2Jhc2U2NCxpVkJPUncwS0dnb0FBQUFOU1VoRVVnQUFBQkFBQUFBSkNBWUFBQUE3S3F3eUFBQUFGMGxFUVZSNDJtTjgrK2I5ZndZS0FPT29BYU1HQUFFQTR1a2lDVUNiVzBjQUFBQUFTVVZPUks1Q1lJST1cIiBsb2FkaW5nPVwibGF6eVwiIGZldGNoUHJpb3JpdHk9XCJhdXRvXCIvPjwvcGljdHVyZT48L2ZpZ3VyZT48aGVhZGVyPjxoMyBjbGFzcz1cInhhdmllci1oZWFkbGluZSBoZWFkbGluZVwiPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgZk5EaER5IHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+T20ga2rDpnJsaWdoZXRzbGl2ZXQ6PC9zcGFuPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgakdTVGR6IHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+LSBTdMOlciBicmEgdGlsPC9zcGFuPjwvaDM+PC9oZWFkZXI+PC9hPjwvYXJ0aWNsZT48YXJ0aWNsZSBjbGFzcz1cInByZXZpZXcgY29sdW1ucyBzbWFsbC03IG1lZGl1bS03IGxhcmdlLTdcIiBkYXRhLWN4ZW5zZV90YWc9XCJjZXJlYnJvXCIgZGF0YS1jeGVuY2Vfd2lkZ2V0PVwiZGFnYmxhZGV0LW1vZGVsLWZyb250XCIgZGF0YS1sYWJlbD1cIlwiIGRhdGEtZnJvbT1cInhhdmllclwiIGRhdGEtcmV2ZXJzZUltYWdlVGV4dE9yZGVyPVwiZmFsc2VcIj48YSB0YXJnZXQ9XCJfc2VsZlwiIGFyaWEtbGFiZWw9XCJPdmVycmFza2VyIG1lZCBhdnNsw7hyaW5nXCIgaHJlZj1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9ramVuZGlzL292ZXJyYXNrZXItbWVkLWF2c2xvcmluZy84MTM2NjUxNFwiPjxmaWd1cmUgY2xhc3M9XCJ4X19zYy0xYW43dnUxLTAga3ZpQXJ5XCI+PHBpY3R1cmU+PGltZyBkYXRhLWRlZmVyPVwidmlld1wiIHRpdGxlPVwiSW1hZ2U6IE92ZXJyYXNrZXIgbWVkIGF2c2zDuHJpbmdcIiBhbHQ9XCJJbWFnZTogT3ZlcnJhc2tlciBtZWQgYXZzbMO4cmluZ1wiIGRlY29kaW5nPVwiYXN5bmNcIiBjbGFzcz1cImxhenlsb2FkXCIgZGF0YS1zcmM9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vaW1hZ2VzLz9pbWFnZUlkPTgxMzY2Njg5JmFtcDtwYW5veD0yNC42MDU2NzgyMzM0MzgmYW1wO3Bhbm95PTIwLjI3NjQ5NzY5NTg1MyZhbXA7cGFub3c9NjYuMjQ2MDU2NzgyMzM0JmFtcDtwYW5vaD0zMi43MTg4OTQwMDkyMTcmYW1wO2hlaWdodHc9MTAwJmFtcDtoZWlnaHRoPTEwMCZhbXA7aGVpZ2h0eT0wJmFtcDtoZWlnaHR4PTAmYW1wO3dpZHRoPTU2NyZhbXA7aGVpZ2h0PTI4MyZhbXA7Y29tcHJlc3Npb249NzBcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGN0V3FOcyB0aXRsZSBkeW5hbWljLXNpemluZ1wiPk92ZXJyYXNrZXI8L3NwYW4+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBmRkFpVEsgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5tZWQgYXZzbMO4cmluZzwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PC9kaXY+PGRpdiBjbGFzcz1cInJvdyB4cm93IGZsZXgtaW5pdGlhbFwiPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTQgbWVkaXVtLTQgbGFyZ2UtNFwiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJwbHVzcy1tb2RlbC1mcm9udFwiIGRhdGEtbGFiZWw9XCJwbHVzc1wiIGRhdGEtZnJvbT1cInhhdmllclwiIGRhdGEtcmV2ZXJzZUltYWdlVGV4dE9yZGVyPVwiZmFsc2VcIj48YSB0YXJnZXQ9XCJfc2VsZlwiIGFyaWEtbGFiZWw9XCJTdHVkaWU6IFRyZSBzZXRuaW5nZXIgYXZzbMO4cmVyIG5hcnNpc3Npc3RlblwiIGhyZWY9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vdGVtYS9zdHVkaWUtdHJlLXNldG5pbmdlci1hdnNsb3Jlci1uYXJzaXNzaXN0ZW4vODEzNjEwNDdcIj48ZmlndXJlIGNsYXNzPVwieF9fc2MtMWFuN3Z1MS0wIHJIU0diXCI+PHBpY3R1cmU+PGltZyBkYXRhLWRlZmVyPVwidmlld1wiIHRpdGxlPVwiSW1hZ2U6IFN0dWRpZTogVHJlIHNldG5pbmdlciBhdnNsw7hyZXIgbmFyc2lzc2lzdGVuXCIgYWx0PVwiSW1hZ2U6IFN0dWRpZTogVHJlIHNldG5pbmdlciBhdnNsw7hyZXIgbmFyc2lzc2lzdGVuXCIgZGVjb2Rpbmc9XCJhc3luY1wiIGNsYXNzPVwibGF6eWxvYWRcIiBkYXRhLXNyYz1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9pbWFnZXMvP2ltYWdlSWQ9ODEzNjc2MDEmYW1wO3Bhbm93PTk5Ljg5MzY3NDY0MTE0OCZhbXA7cGFub3k9MTcuMjY2MTg3MDUwMzYmYW1wO3Bhbm94PTAmYW1wO3Bhbm9oPTUwLjkxOTI2NjE4NzA1JmFtcDtoZWlnaHR3PTQwLjk5NDQyMDA5MTMyNCZhbXA7aGVpZ2h0aD05OS44NDc3OTQ1MjA1NDgmYW1wO2hlaWdodHk9MCZhbXA7aGVpZ2h0eD0yMS45MTc4MDgyMTkxNzgmYW1wO3dpZHRoPTMyMCZhbXA7aGVpZ2h0PTE5OCZhbXA7Y29tcHJlc3Npb249NzBcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PGRpdiBjbGFzcz1cImZpZ3VyZS1sb2dvXCI+PGRpdiBjbGFzcz1cImxvZ29cIj48c3ZnIHhtbG5zPVwiaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmdcIiB3aWR0aD1cIjI0XCIgaGVpZ2h0PVwiMjRcIiB2aWV3Qm94PVwiMCAwIDI0IDI0XCIgZmlsbD1cIm5vbmVcIiBzdHJva2U9XCJjdXJyZW50Q29sb3JcIiBzdHJva2Utd2lkdGg9XCIzXCI+PGxpbmUgeDE9XCIxMlwiIHkxPVwiNVwiIHgyPVwiMTJcIiB5Mj1cIjE5XCI+PC9saW5lPjxsaW5lIHgxPVwiNVwiIHkxPVwiMTJcIiB4Mj1cIjE5XCIgeTI9XCIxMlwiPjwvbGluZT48L3N2Zz48L2Rpdj48L2Rpdj48L2ZpZ3VyZT48aGVhZGVyPjxoMyBjbGFzcz1cInhhdmllci1oZWFkbGluZSBoZWFkbGluZVwiPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAga3dMdWFCIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+U3R1ZGllOiBUcmUgc2V0bmluZ2VyPC9zcGFuPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgaU5IeWllIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+YXZzbMO4cmVyIG5hcnNpc3Npc3Rlbjwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PGFydGljbGUgY2xhc3M9XCJwcmV2aWV3IGNvbHVtbnMgc21hbGwtNCBtZWRpdW0tNCBsYXJnZS00XCIgZGF0YS1jeGVuc2VfdGFnPVwiY2VyZWJyb1wiIGRhdGEtY3hlbmNlX3dpZGdldD1cInZpZGVvLW1ldGFwb3AtbW9kZWxcIiBkYXRhLWxhYmVsPVwidmlkZW9cIiBkYXRhLWZyb209XCJ4YXZpZXJcIiBkYXRhLXJldmVyc2VJbWFnZVRleHRPcmRlcj1cImZhbHNlXCI+PGEgdGFyZ2V0PVwiX3NlbGZcIiBhcmlhLWxhYmVsPVwiQW5ncmVwIGR5cHQgaW5uZSBpIFJ1c3NsYW5kXCIgaHJlZj1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby92aWRlby9hbmdyZXAtZHlwdC1pbm5lLWktcnVzc2xhbmQvUVFhTXdidzBcIj48ZmlndXJlIGNsYXNzPVwieF9fc2MtMWFuN3Z1MS0wIGZqSnl2RVwiPjxwaWN0dXJlPjxpbWcgZGF0YS1kZWZlcj1cInZpZXdcIiB0aXRsZT1cIkltYWdlOiBBbmdyZXAgZHlwdCBpbm5lIGkgUnVzc2xhbmRcIiBhbHQ9XCJJbWFnZTogQW5ncmVwIGR5cHQgaW5uZSBpIFJ1c3NsYW5kXCIgZGVjb2Rpbmc9XCJhc3luY1wiIGNsYXNzPVwibGF6eWxvYWRcIiBkYXRhLXNyYz1cImh0dHBzOi8vY2RuLmp3cGxheWVyLmNvbS90aHVtYnMvUVFhTXdidzAtNzIwLmpwZ1wiIHNyYz1cImRhdGE6aW1hZ2UvcG5nO2Jhc2U2NCxpVkJPUncwS0dnb0FBQUFOU1VoRVVnQUFBQkFBQUFBSkNBWUFBQUE3S3F3eUFBQUFGMGxFUVZSNDJtTjgrK2I5ZndZS0FPT29BYU1HQUFFQTR1a2lDVUNiVzBjQUFBQUFTVVZPUks1Q1lJST1cIiBsb2FkaW5nPVwibGF6eVwiIGZldGNoUHJpb3JpdHk9XCJhdXRvXCIvPjwvcGljdHVyZT48ZGl2IGNsYXNzPVwiZmlndXJlLWxvZ29cIj48ZGl2IGNsYXNzPVwibG9nb1wiPjxzdmcgeG1sbnM9XCJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2Z1wiIHdpZHRoPVwiMjRcIiBoZWlnaHQ9XCIyNFwiIHZpZXdCb3g9XCIwIDAgMjQgMjRcIiBmaWxsPVwiY3VycmVudENvbG9yXCIgc3Ryb2tlPVwiY3VycmVudENvbG9yXCIgc3Ryb2tlLXdpZHRoPVwiMlwiIHN0cm9rZS1saW5lY2FwPVwicm91bmRcIiBzdHJva2UtbGluZWpvaW49XCJyb3VuZFwiIGNsYXNzPVwiZmVhdGhlciBmZWF0aGVyLXBsYXlcIj48cG9seWdvbiBwb2ludHM9XCI1IDMgMTkgMTIgNSAyMSA1IDNcIj48L3BvbHlnb24+PC9zdmc+PC9kaXY+PC9kaXY+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGpYREJBVCB0aXRsZSBkeW5hbWljLXNpemluZ1wiPkFuZ3JlcCBkeXB0PC9zcGFuPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgY1ptb3RNIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+aW5uZSBpIFJ1c3NsYW5kPC9zcGFuPjwvaDM+PC9oZWFkZXI+PC9hPjwvYXJ0aWNsZT48ZGl2IGlkPVwiYXBvcy1tZWRpdW0tcmVjdGFuZ2xlLXBlcno0XCIgY2xhc3M9XCJhZHVuaXQtd3JhcHBlciBjb2x1bW5zIHNtYWxsLTQgbWVkaXVtLTQgbGFyZ2UtNCB0cmFjay1lbGVtZW50ICBcIiBkYXRhLWZyb209XCJ4YXZpZXJcIj48ZGl2IGlkPVwiYWQtbWVkaXVtLXJlY3RhbmdsZS1wZXJ6NFwiIGNsYXNzPVwiYWR1bml0IEdvb2dsZUFjdGl2ZVZpZXdFbGVtZW50IHNtYWxsLTMyMHgyNTAgbWVkaXVtLTMyMHgyNTAgbGFyZ2UtMzIweDI1MFwiIGl0ZW1zY29wZT1cIlwiIGl0ZW1UeXBlPVwiaHR0cHM6Ly9zY2hlbWEub3JnL1dQQWRCbG9ja1wiIGRhdGEtc2l6ZXM9XCJbWzMyMCwyNTBdLFszMDAsMjUwXSwmcXVvdDtmbHVpZCZxdW90O11cIiBkYXRhLXNsb3Q9XCIvODU3OC9kYWdibGFkZXQubm8vZm9yc2lkZVwiIGRhdGEtbG9hZC1vbj1cInZpZXdcIiBkYXRhLWNvbGxhcHNlPVwiZmFsc2VcIiBkYXRhLWV4cGFuZD1cImZhbHNlXCIgZGF0YS1vdXQtb2YtcGFnZT1cImZhbHNlXCIganNvbj1cInsmcXVvdDt0YXJnZXRpbmcmcXVvdDs6IHsmcXVvdDtwb3MmcXVvdDs6JnF1b3Q7bWVkaXVtLXJlY3RhbmdsZS1wZXJ6NCZxdW90OywmcXVvdDtwbGF0Zm9ybSZxdW90OzomcXVvdDt3b2x2ZXJpbmUmcXVvdDt9fVwiPjwvZGl2PjwvZGl2PjwvZGl2PjxkaXYgY2xhc3M9XCJyb3cgeHJvdyBmbGV4LWluaXRpYWxcIj48YXJ0aWNsZSBjbGFzcz1cInByZXZpZXcgY29sdW1ucyBzbWFsbC01IG1lZGl1bS01IGxhcmdlLTVcIiBkYXRhLWN4ZW5zZV90YWc9XCJjZXJlYnJvXCIgZGF0YS1jeGVuY2Vfd2lkZ2V0PVwiZGFnYmxhZGV0LW1vZGVsLWZyb250XCIgZGF0YS1sYWJlbD1cIlwiIGRhdGEtZnJvbT1cInhhdmllclwiIGRhdGEtcmV2ZXJzZUltYWdlVGV4dE9yZGVyPVwiZmFsc2VcIj48YSB0YXJnZXQ9XCJfc2VsZlwiIGFyaWEtbGFiZWw9XCJTcGVrdWxhc2pvbmVyIGV0dGVyIGZseS1vYnNlcnZhc2pvblwiIGhyZWY9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8va2plbmRpcy9zcGVrdWxhc2pvbmVyLWV0dGVyLWZseS1vYnNlcnZhc2pvbi84MTM2Mzc4NVwiPjxmaWd1cmUgY2xhc3M9XCJ4X19zYy0xYW43dnUxLTAgaEdNTmxLXCI+PHBpY3R1cmU+PGltZyBkYXRhLWRlZmVyPVwidmlld1wiIHRpdGxlPVwiSW1hZ2U6IFNwZWt1bGFzam9uZXIgZXR0ZXIgZmx5LW9ic2VydmFzam9uXCIgYWx0PVwiSW1hZ2U6IFNwZWt1bGFzam9uZXIgZXR0ZXIgZmx5LW9ic2VydmFzam9uXCIgZGVjb2Rpbmc9XCJhc3luY1wiIGNsYXNzPVwibGF6eWxvYWRcIiBkYXRhLXNyYz1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9pbWFnZXMvP2ltYWdlSWQ9ODEzNjQyMDQmYW1wO3Bhbm94PTM4LjA1OTcwMTQ5MjUzNyZhbXA7cGFub3c9NTIuMjM4ODA1OTcwMTQ5JmFtcDtwYW5vaD0yMi43NTY0MTAyNTY0MSZhbXA7cGFub3k9MTQuMTAyNTY0MTAyNTY0JmFtcDtoZWlnaHR5PTEyLjk2Mjk2Mjk2Mjk2MyZhbXA7aGVpZ2h0eD0zOC44NDg5MjA4NjMzMDkmYW1wO2hlaWdodHc9MzIuMzc0MTAwNzE5NDI0JmFtcDtoZWlnaHRoPTY4LjA1NTU1NTU1NTU1NiZhbXA7d2lkdGg9NDAyJmFtcDtoZWlnaHQ9MzYxJmFtcDtjb21wcmVzc2lvbj03MFwiIHNyYz1cImRhdGE6aW1hZ2UvcG5nO2Jhc2U2NCxpVkJPUncwS0dnb0FBQUFOU1VoRVVnQUFBQkFBQUFBSkNBWUFBQUE3S3F3eUFBQUFGMGxFUVZSNDJtTjgrK2I5ZndZS0FPT29BYU1HQUFFQTR1a2lDVUNiVzBjQUFBQUFTVVZPUks1Q1lJST1cIiBsb2FkaW5nPVwibGF6eVwiIGZldGNoUHJpb3JpdHk9XCJhdXRvXCIvPjwvcGljdHVyZT48L2ZpZ3VyZT48aGVhZGVyPjxoMyBjbGFzcz1cInhhdmllci1oZWFkbGluZSBoZWFkbGluZVwiPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgamZ2TVdKIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+U3Bla3VsYXNqb25lciBldHRlcjwvc3Bhbj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGppR1ZWaiB0aXRsZSBkeW5hbWljLXNpemluZ1wiPmZseS1vYnNlcnZhc2pvbjwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PGFydGljbGUgY2xhc3M9XCJwcmV2aWV3IGNvbHVtbnMgc21hbGwtNyBtZWRpdW0tNyBsYXJnZS03XCIgZGF0YS1jeGVuc2VfdGFnPVwiY2VyZWJyb1wiIGRhdGEtY3hlbmNlX3dpZGdldD1cImRhZ2JsYWRldC1tb2RlbC1mcm9udFwiIGRhdGEtbGFiZWw9XCJcIiBkYXRhLWZyb209XCJ4YXZpZXJcIiBkYXRhLXJldmVyc2VJbWFnZVRleHRPcmRlcj1cImZhbHNlXCI+PGEgdGFyZ2V0PVwiX3NlbGZcIiBhcmlhLWxhYmVsPVwiLSBGb3J2ZW50ZXIgYXQgQXAgcnlkZGVyIG9wcFwiIGhyZWY9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vbnloZXRlci9mb3J2ZW50ZXItYXQtYXAtcnlkZGVyLW9wcC84MTM1NzM3OVwiPjxmaWd1cmUgY2xhc3M9XCJ4X19zYy0xYW43dnUxLTAga3ZpQXJ5XCI+PHBpY3R1cmU+PGltZyBkYXRhLWRlZmVyPVwidmlld1wiIHRpdGxlPVwiSW1hZ2U6IC0gRm9ydmVudGVyIGF0IEFwIHJ5ZGRlciBvcHBcIiBhbHQ9XCJJbWFnZTogLSBGb3J2ZW50ZXIgYXQgQXAgcnlkZGVyIG9wcFwiIGRlY29kaW5nPVwiYXN5bmNcIiBjbGFzcz1cImxhenlsb2FkXCIgZGF0YS1zcmM9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vaW1hZ2VzLz9pbWFnZUlkPTgxMzU3NTAzJmFtcDtwYW5veT0xMS41MTUxNTE1MTUxNTImYW1wO3Bhbm94PTAmYW1wO3Bhbm93PTk5Ljg0ODQ4NDU0NTQ1NSZhbXA7cGFub2g9NDUuMjUyNTI0ODQ4NDg1JmFtcDtoZWlnaHR5PTAmYW1wO2hlaWdodHc9MTAwJmFtcDtoZWlnaHRoPTEwMCZhbXA7aGVpZ2h0eD0wJmFtcDt3aWR0aD01NjcmYW1wO2hlaWdodD0yODMmYW1wO2NvbXByZXNzaW9uPTcwXCIgc3JjPVwiZGF0YTppbWFnZS9wbmc7YmFzZTY0LGlWQk9SdzBLR2dvQUFBQU5TVWhFVWdBQUFCQUFBQUFKQ0FZQUFBQTdLcXd5QUFBQUYwbEVRVlI0Mm1OOCsrYjlmd1lLQU9Pb0FhTUdBQUVBNHVraUNVQ2JXMGNBQUFBQVNVVk9SSzVDWUlJPVwiIGxvYWRpbmc9XCJsYXp5XCIgZmV0Y2hQcmlvcml0eT1cImF1dG9cIi8+PC9waWN0dXJlPjwvZmlndXJlPjxoZWFkZXI+PGgzIGNsYXNzPVwieGF2aWVyLWhlYWRsaW5lIGhlYWRsaW5lXCI+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBkV3pNbkEgdGl0bGUgZHluYW1pYy1zaXppbmdcIj4tIEZvcnZlbnRlciBhdDwvc3Bhbj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGZGQWlUSyB0aXRsZSBkeW5hbWljLXNpemluZ1wiPkFwIHJ5ZGRlciBvcHA8L3NwYW4+PC9oMz48L2hlYWRlcj48L2E+PC9hcnRpY2xlPjwvZGl2PjxkaXYgY2xhc3M9XCJyb3cgeHJvdyBmbGV4LWluaXRpYWxcIj48YXJ0aWNsZSBjbGFzcz1cInByZXZpZXcgY29sdW1ucyBzbWFsbC03IG1lZGl1bS03IGxhcmdlLTcgYmcteWVsbG93XCIgZGF0YS1jeGVuc2VfdGFnPVwiY2VyZWJyb1wiIGRhdGEtY3hlbmNlX3dpZGdldD1cImRhZ2JsYWRldC1tb2RlbC1mcm9udFwiIGRhdGEtbGFiZWw9XCJcIiBkYXRhLWZyb209XCJ4YXZpZXJcIiBkYXRhLXJldmVyc2VJbWFnZVRleHRPcmRlcj1cImZhbHNlXCI+PGEgdGFyZ2V0PVwiX3NlbGZcIiBhcmlhLWxhYmVsPVwiS2FsbGVyIGhqZW0gYW1iYXNzYWTDuHIgaSBSdXNzbGFuZFwiIGhyZWY9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vbnloZXRlci9rYWxsZXItaGplbS1hbWJhc3NhZG9yLWktcnVzc2xhbmQvODEzNjIyMjZcIj48ZmlndXJlIGNsYXNzPVwieF9fc2MtMWFuN3Z1MS0wIGt2aUFyeVwiPjxwaWN0dXJlPjxpbWcgZGF0YS1kZWZlcj1cInZpZXdcIiB0aXRsZT1cIkltYWdlOiBLYWxsZXIgaGplbSBhbWJhc3NhZMO4ciBpIFJ1c3NsYW5kXCIgYWx0PVwiSW1hZ2U6IEthbGxlciBoamVtIGFtYmFzc2Fkw7hyIGkgUnVzc2xhbmRcIiBkZWNvZGluZz1cImFzeW5jXCIgY2xhc3M9XCJsYXp5bG9hZFwiIGRhdGEtc3JjPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2ltYWdlcy8/aW1hZ2VJZD04MTM2MjI1NCZhbXA7cGFub3k9MCZhbXA7cGFub3g9MCZhbXA7cGFub3c9MTAwJmFtcDtwYW5vaD0xMDAmYW1wO2hlaWdodHc9MTAwJmFtcDtoZWlnaHRoPTEwMCZhbXA7aGVpZ2h0eT0wJmFtcDtoZWlnaHR4PTAmYW1wO3dpZHRoPTU2NyZhbXA7aGVpZ2h0PTI4MyZhbXA7Y29tcHJlc3Npb249NzBcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGhlanVRRCB0aXRsZSBkeW5hbWljLXNpemluZ1wiPkthbGxlciBoamVtPC9zcGFuPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAga0JPb2diIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+YW1iYXNzYWTDuHI8L3NwYW4+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBrUXpwQ0ogdGl0bGUgZHluYW1pYy1zaXppbmdcIj5pIFJ1c3NsYW5kPC9zcGFuPjwvaDM+PC9oZWFkZXI+PC9hPjwvYXJ0aWNsZT48YXJ0aWNsZSBjbGFzcz1cInByZXZpZXcgY29sdW1ucyBzbWFsbC01IG1lZGl1bS01IGxhcmdlLTVcIiBkYXRhLWN4ZW5zZV90YWc9XCJjZXJlYnJvXCIgZGF0YS1jeGVuY2Vfd2lkZ2V0PVwiZGFnYmxhZGV0LW1vZGVsLWZyb250XCIgZGF0YS1sYWJlbD1cIlwiIGRhdGEtZnJvbT1cInhhdmllclwiIGRhdGEtcmV2ZXJzZUltYWdlVGV4dE9yZGVyPVwiZmFsc2VcIj48YSB0YXJnZXQ9XCJfc2VsZlwiIGFyaWEtbGFiZWw9XCJGbGVyZSBmbHkgbcOlIHNudVwiIGhyZWY9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vbnloZXRlci9mbGVyZS1mbHktbWEtc251LzgxMzYwNzU5XCI+PGZpZ3VyZSBjbGFzcz1cInhfX3NjLTFhbjd2dTEtMCBpdUpPdUpcIj48cGljdHVyZT48aW1nIGRhdGEtZGVmZXI9XCJ2aWV3XCIgdGl0bGU9XCJJbWFnZTogRmxlcmUgZmx5IG3DpSBzbnVcIiBhbHQ9XCJJbWFnZTogRmxlcmUgZmx5IG3DpSBzbnVcIiBkZWNvZGluZz1cImFzeW5jXCIgY2xhc3M9XCJsYXp5bG9hZFwiIGRhdGEtc3JjPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2ltYWdlcy8/aW1hZ2VJZD04MTM2MDc5NyZhbXA7cGFub3c9MTAwJmFtcDtwYW5veT0wJmFtcDtwYW5vaD0xMDAmYW1wO3Bhbm94PTAmYW1wO2hlaWdodHc9MTAwJmFtcDtoZWlnaHR5PTAmYW1wO2hlaWdodHg9MCZhbXA7aGVpZ2h0aD0xMDAmYW1wO3dpZHRoPTQwMiZhbXA7aGVpZ2h0PTU1NyZhbXA7Y29tcHJlc3Npb249NzBcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIHdwV0xHIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+RmxlcmUgZmx5IG3DpSBzbnU8L3NwYW4+PC9oMz48L2hlYWRlcj48L2E+PC9hcnRpY2xlPjwvZGl2PjxkaXYgY2xhc3M9XCJyb3cgeHJvdyBmbGV4LWluaXRpYWxcIj48ZGl2IGlkPVwiYXBvcy1zbWFydGJhbm5lcjJcIiBjbGFzcz1cImFkdW5pdC13cmFwcGVyIGNvbHVtbnMgc21hbGwtMTIgbWVkaXVtLTEyIGxhcmdlLTEyIHRyYWNrLWVsZW1lbnQgIFwiIGRhdGEtZnJvbT1cInhhdmllclwiPjxkaXYgaWQ9XCJhZC1zbWFydGJhbm5lcjJcIiBjbGFzcz1cImFkdW5pdCBHb29nbGVBY3RpdmVWaWV3RWxlbWVudCBzbWFsbC05ODB4YXV0byBtZWRpdW0tOTgweGF1dG8gbGFyZ2UtOTgweGF1dG9cIiBpdGVtc2NvcGU9XCJcIiBpdGVtVHlwZT1cImh0dHBzOi8vc2NoZW1hLm9yZy9XUEFkQmxvY2tcIiBkYXRhLXNpemVzPVwiW1s5ODAsNjAwXSxbOTgwLDMwMF0sWzk3MCwyNTBdLCZxdW90O2ZsdWlkJnF1b3Q7XVwiIGRhdGEtc2xvdD1cIi84NTc4L2RhZ2JsYWRldC5uby9mb3JzaWRlXCIgZGF0YS1sb2FkLW9uPVwidmlld1wiIGRhdGEtY29sbGFwc2U9XCJ0cnVlXCIgZGF0YS1leHBhbmQ9XCJmYWxzZVwiIGRhdGEtb3V0LW9mLXBhZ2U9XCJmYWxzZVwiIGpzb249XCJ7JnF1b3Q7dGFyZ2V0aW5nJnF1b3Q7OiB7JnF1b3Q7cG9zJnF1b3Q7OiZxdW90O3NtYXJ0YmFubmVyMiZxdW90OywmcXVvdDtwbGF0Zm9ybSZxdW90OzomcXVvdDt3b2x2ZXJpbmUmcXVvdDt9fVwiPjwvZGl2PjwvZGl2PjwvZGl2PjxkaXYgY2xhc3M9XCJyb3cgeHJvdyBmbGV4LWluaXRpYWxcIj48YXJ0aWNsZSBjbGFzcz1cInByZXZpZXcgY29sdW1ucyBzbWFsbC02IG1lZGl1bS02IGxhcmdlLTZcIiBkYXRhLWN4ZW5zZV90YWc9XCJjZXJlYnJvXCIgZGF0YS1jeGVuY2Vfd2lkZ2V0PVwiZGFnYmxhZGV0LW1vZGVsLWZyb250XCIgZGF0YS1sYWJlbD1cIlwiIGRhdGEtZnJvbT1cInhhdmllclwiIGRhdGEtcmV2ZXJzZUltYWdlVGV4dE9yZGVyPVwiZmFsc2VcIj48YSB0YXJnZXQ9XCJfc2VsZlwiIGFyaWEtbGFiZWw9XCJHam9yZGUgc2tyZWtrZnVubjogRWtza2rDpnJlc3RlbiBkw7htdFwiIGhyZWY9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vbnloZXRlci9nam9yZGUtc2tyZWtrZnVubi1la3NramFlcmVzdGVuLWRvbXQvODEzNjAyMTFcIj48ZmlndXJlIGNsYXNzPVwieF9fc2MtMWFuN3Z1MS0wIGhwWlBRbVwiPjxwaWN0dXJlPjxpbWcgZGF0YS1kZWZlcj1cInZpZXdcIiB0aXRsZT1cIkltYWdlOiBHam9yZGUgc2tyZWtrZnVubjogRWtza2rDpnJlc3RlbiBkw7htdFwiIGFsdD1cIkltYWdlOiBHam9yZGUgc2tyZWtrZnVubjogRWtza2rDpnJlc3RlbiBkw7htdFwiIGRlY29kaW5nPVwiYXN5bmNcIiBjbGFzcz1cImxhenlsb2FkXCIgZGF0YS1zcmM9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vaW1hZ2VzLz9pbWFnZUlkPTgxMjczMDQ3JmFtcDtwYW5veD0wJmFtcDtwYW5veT0wJmFtcDtwYW5vdz0xMDAmYW1wO3Bhbm9oPTEwMCZhbXA7aGVpZ2h0eT0wJmFtcDtoZWlnaHR4PTAmYW1wO2hlaWdodHc9MTAwJmFtcDtoZWlnaHRoPTEwMCZhbXA7d2lkdGg9NDg1JmFtcDtoZWlnaHQ9MzMzJmFtcDtjb21wcmVzc2lvbj03MFwiIHNyYz1cImRhdGE6aW1hZ2UvcG5nO2Jhc2U2NCxpVkJPUncwS0dnb0FBQUFOU1VoRVVnQUFBQkFBQUFBSkNBWUFBQUE3S3F3eUFBQUFGMGxFUVZSNDJtTjgrK2I5ZndZS0FPT29BYU1HQUFFQTR1a2lDVUNiVzBjQUFBQUFTVVZPUks1Q1lJST1cIiBsb2FkaW5nPVwibGF6eVwiIGZldGNoUHJpb3JpdHk9XCJhdXRvXCIvPjwvcGljdHVyZT48L2ZpZ3VyZT48aGVhZGVyPjxoMyBjbGFzcz1cInhhdmllci1oZWFkbGluZSBoZWFkbGluZVwiPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgd3BXTEcgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5Ham9yZGUgc2tyZWtrZnVubjo8L3NwYW4+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCB3cFdMRyB0aXRsZSBkeW5hbWljLXNpemluZ1wiPkVrc2tqw6ZyZXN0ZW4gZMO4bXQ8L3NwYW4+PC9oMz48L2hlYWRlcj48L2E+PC9hcnRpY2xlPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTYgbWVkaXVtLTYgbGFyZ2UtNlwiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJkYWdibGFkZXQtbW9kZWwtZnJvbnRcIiBkYXRhLWxhYmVsPVwiXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIk9tIGZsw7hydGVuOiAtIFPDpSBramVra1wiIGhyZWY9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8va2plbmRpcy9vbS1mbG9ydGVuLXNhLWtqZWtrLzgxMzUxMDc2XCI+PGZpZ3VyZSBjbGFzcz1cInhfX3NjLTFhbjd2dTEtMCBmblFESGJcIj48cGljdHVyZT48aW1nIGRhdGEtZGVmZXI9XCJ2aWV3XCIgdGl0bGU9XCJJbWFnZTogT20gZmzDuHJ0ZW46IC0gU8OlIGtqZWtrXCIgYWx0PVwiSW1hZ2U6IE9tIGZsw7hydGVuOiAtIFPDpSBramVra1wiIGRlY29kaW5nPVwiYXN5bmNcIiBjbGFzcz1cImxhenlsb2FkXCIgZGF0YS1zcmM9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vaW1hZ2VzLz9pbWFnZUlkPTgxMzUxNTYzJmFtcDtwYW5veT01LjIwMjMxMjEzODcyODMmYW1wO3Bhbm93PTEwMCZhbXA7cGFub2g9NDEuMDQwNDYyNDI3NzQ2JmFtcDtwYW5veD0wJmFtcDtoZWlnaHR5PTAmYW1wO2hlaWdodHg9MCZhbXA7aGVpZ2h0dz0xMDAmYW1wO2hlaWdodGg9MTAwJmFtcDt3aWR0aD00ODUmYW1wO2hlaWdodD0yNDImYW1wO2NvbXByZXNzaW9uPTcwXCIgc3JjPVwiZGF0YTppbWFnZS9wbmc7YmFzZTY0LGlWQk9SdzBLR2dvQUFBQU5TVWhFVWdBQUFCQUFBQUFKQ0FZQUFBQTdLcXd5QUFBQUYwbEVRVlI0Mm1OOCsrYjlmd1lLQU9Pb0FhTUdBQUVBNHVraUNVQ2JXMGNBQUFBQVNVVk9SSzVDWUlJPVwiIGxvYWRpbmc9XCJsYXp5XCIgZmV0Y2hQcmlvcml0eT1cImF1dG9cIi8+PC9waWN0dXJlPjwvZmlndXJlPjxoZWFkZXI+PGgzIGNsYXNzPVwieGF2aWVyLWhlYWRsaW5lIGhlYWRsaW5lXCI+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBkZGJDSlogdGl0bGUgZHluYW1pYy1zaXppbmdcIj5PbSBmbMO4cnRlbjo8L3NwYW4+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBnTkRpQmYgdGl0bGUgZHluYW1pYy1zaXppbmdcIj4tIFPDpSBramVrazwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PC9kaXY+PGRpdiBjbGFzcz1cInJvdyB4cm93IGZsZXgtaW5pdGlhbFwiPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTUgbWVkaXVtLTUgbGFyZ2UtNVwiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJkYWdibGFkZXQtbW9kZWwtZnJvbnRcIiBkYXRhLWxhYmVsPVwiXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIkZ1bGwgZm9ydmlycmluZzogLSBGb2xrIGdyw6V0XCIgaHJlZj1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9zcG9ydC9mdWxsLWZvcnZpcnJpbmctZm9say1ncmF0LzgxMzU3MTE0XCI+PGZpZ3VyZSBjbGFzcz1cInhfX3NjLTFhbjd2dTEtMCBZVElrSVwiPjxwaWN0dXJlPjxpbWcgZGF0YS1kZWZlcj1cInZpZXdcIiB0aXRsZT1cIkltYWdlOiBGdWxsIGZvcnZpcnJpbmc6IC0gRm9sayBncsOldFwiIGFsdD1cIkltYWdlOiBGdWxsIGZvcnZpcnJpbmc6IC0gRm9sayBncsOldFwiIGRlY29kaW5nPVwiYXN5bmNcIiBjbGFzcz1cImxhenlsb2FkXCIgZGF0YS1zcmM9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vaW1hZ2VzLz9pbWFnZUlkPTgxMzU3NDEyJmFtcDtwYW5veT0yNy44MDI2OTA1ODI5NiZhbXA7cGFub3g9MTUuNTY4ODYyMjc1NDQ5JmFtcDtwYW5vdz02Mi44NzQyNTE0OTcwMDYmYW1wO3Bhbm9oPTMxLjgzODU2NTAyMjQyMiZhbXA7aGVpZ2h0eT0yMCZhbXA7aGVpZ2h0dz0yMy45MzYxNzAyMTI3NjYmYW1wO2hlaWdodGg9NTguOCZhbXA7aGVpZ2h0eD0xOC4zNTEwNjM4Mjk3ODcmYW1wO3dpZHRoPTQwMiZhbXA7aGVpZ2h0PTIyMyZhbXA7Y29tcHJlc3Npb249NzBcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGtOaEdnWCB0aXRsZSBkeW5hbWljLXNpemluZ1wiPkZ1bGwgZm9ydmlycmluZzo8L3NwYW4+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBnUkxKd04gdGl0bGUgZHluYW1pYy1zaXppbmdcIj4tIEZvbGsgZ3LDpXQ8L3NwYW4+PC9oMz48L2hlYWRlcj48L2E+PC9hcnRpY2xlPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTcgbWVkaXVtLTcgbGFyZ2UtN1wiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJkYWdibGFkZXQtbW9kZWwtZnJvbnRcIiBkYXRhLWxhYmVsPVwiXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIi0gRm9sayBibGlyIGdhbGVcIiBocmVmPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2tqZW5kaXMvZm9say1ibGlyLWdhbGUvODEzNjE0MDZcIj48ZmlndXJlIGNsYXNzPVwieF9fc2MtMWFuN3Z1MS0wIGt2aUFyeVwiPjxwaWN0dXJlPjxpbWcgZGF0YS1kZWZlcj1cInZpZXdcIiB0aXRsZT1cIkltYWdlOiAtIEZvbGsgYmxpciBnYWxlXCIgYWx0PVwiSW1hZ2U6IC0gRm9sayBibGlyIGdhbGVcIiBkZWNvZGluZz1cImFzeW5jXCIgY2xhc3M9XCJsYXp5bG9hZFwiIGRhdGEtc3JjPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2ltYWdlcy8/aW1hZ2VJZD04MTM2MTQ0NyZhbXA7cGFub3k9Ni4yMzE0NTQwMDU5MzQ3JmFtcDtwYW5vdz0xMDAmYW1wO3Bhbm9oPTIxLjA2ODI0OTI1ODE2JmFtcDtwYW5veD0wJmFtcDtoZWlnaHR5PTAmYW1wO2hlaWdodHg9MCZhbXA7aGVpZ2h0dz0xMDAmYW1wO2hlaWdodGg9MTAwJmFtcDt3aWR0aD01NjcmYW1wO2hlaWdodD0yODMmYW1wO2NvbXByZXNzaW9uPTcwXCIgc3JjPVwiZGF0YTppbWFnZS9wbmc7YmFzZTY0LGlWQk9SdzBLR2dvQUFBQU5TVWhFVWdBQUFCQUFBQUFKQ0FZQUFBQTdLcXd5QUFBQUYwbEVRVlI0Mm1OOCsrYjlmd1lLQU9Pb0FhTUdBQUVBNHVraUNVQ2JXMGNBQUFBQVNVVk9SSzVDWUlJPVwiIGxvYWRpbmc9XCJsYXp5XCIgZmV0Y2hQcmlvcml0eT1cImF1dG9cIi8+PC9waWN0dXJlPjwvZmlndXJlPjxoZWFkZXI+PGgzIGNsYXNzPVwieGF2aWVyLWhlYWRsaW5lIGhlYWRsaW5lXCI+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBkZmd2cG4gdGl0bGUgZHluYW1pYy1zaXppbmdcIj4tIEZvbGsgYmxpciBnYWxlPC9zcGFuPjwvaDM+PC9oZWFkZXI+PC9hPjwvYXJ0aWNsZT48L2Rpdj48ZGl2IGNsYXNzPVwicm93IHhyb3cgZmxleC1pbml0aWFsXCI+PGFydGljbGUgY2xhc3M9XCJwcmV2aWV3IGNvbHVtbnMgc21hbGwtNCBtZWRpdW0tNCBsYXJnZS00XCIgZGF0YS1jeGVuc2VfdGFnPVwiY2VyZWJyb1wiIGRhdGEtY3hlbmNlX3dpZGdldD1cInBsdXNzLW1vZGVsLWZyb250XCIgZGF0YS1sYWJlbD1cInBsdXNzXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIlRlc3RldCDDqW4gdGluZyAtIGZpa2sgZXJla3Nqb25lbiB0aWxiYWtlXCIgaHJlZj1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby90ZW1hL3Rlc3RldC1uLXRpbmctZmlray1lcmVrc2pvbmVuLXRpbGJha2UvODEyMDEwMjRcIj48ZmlndXJlIGNsYXNzPVwieF9fc2MtMWFuN3Z1MS0wIGxtZGpuVlwiPjxwaWN0dXJlPjxpbWcgZGF0YS1kZWZlcj1cInZpZXdcIiB0aXRsZT1cIkltYWdlOiBUZXN0ZXQgw6luIHRpbmcgLSBmaWtrIGVyZWtzam9uZW4gdGlsYmFrZVwiIGFsdD1cIkltYWdlOiBUZXN0ZXQgw6luIHRpbmcgLSBmaWtrIGVyZWtzam9uZW4gdGlsYmFrZVwiIGRlY29kaW5nPVwiYXN5bmNcIiBjbGFzcz1cImxhenlsb2FkXCIgZGF0YS1zcmM9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vaW1hZ2VzLz9pbWFnZUlkPTgxMjA4MDY2JmFtcDtwYW5veD0wJmFtcDtwYW5vdz0xMDAmYW1wO3Bhbm9oPTEwMCZhbXA7cGFub3k9MCZhbXA7aGVpZ2h0eT0wJmFtcDtoZWlnaHR4PTAmYW1wO2hlaWdodHc9MTAwJmFtcDtoZWlnaHRoPTEwMCZhbXA7d2lkdGg9MzIwJmFtcDtoZWlnaHQ9MTc5JmFtcDtjb21wcmVzc2lvbj03MFwiIHNyYz1cImRhdGE6aW1hZ2UvcG5nO2Jhc2U2NCxpVkJPUncwS0dnb0FBQUFOU1VoRVVnQUFBQkFBQUFBSkNBWUFBQUE3S3F3eUFBQUFGMGxFUVZSNDJtTjgrK2I5ZndZS0FPT29BYU1HQUFFQTR1a2lDVUNiVzBjQUFBQUFTVVZPUks1Q1lJST1cIiBsb2FkaW5nPVwibGF6eVwiIGZldGNoUHJpb3JpdHk9XCJhdXRvXCIvPjwvcGljdHVyZT48ZGl2IGNsYXNzPVwiZmlndXJlLWxvZ29cIj48ZGl2IGNsYXNzPVwibG9nb1wiPjxzdmcgeG1sbnM9XCJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2Z1wiIHdpZHRoPVwiMjRcIiBoZWlnaHQ9XCIyNFwiIHZpZXdCb3g9XCIwIDAgMjQgMjRcIiBmaWxsPVwibm9uZVwiIHN0cm9rZT1cImN1cnJlbnRDb2xvclwiIHN0cm9rZS13aWR0aD1cIjNcIj48bGluZSB4MT1cIjEyXCIgeTE9XCI1XCIgeDI9XCIxMlwiIHkyPVwiMTlcIj48L2xpbmU+PGxpbmUgeDE9XCI1XCIgeTE9XCIxMlwiIHgyPVwiMTlcIiB5Mj1cIjEyXCI+PC9saW5lPjwvc3ZnPjwvZGl2PjwvZGl2PjwvZmlndXJlPjxoZWFkZXI+PGgzIGNsYXNzPVwieGF2aWVyLWhlYWRsaW5lIGhlYWRsaW5lXCI+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBpTkh5aWUgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5UZXN0ZXQgw6luIHRpbmcgLSBmaWtrPC9zcGFuPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgY3lWWHpmIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+ZXJla3Nqb25lbiB0aWxiYWtlPC9zcGFuPjwvaDM+PC9oZWFkZXI+PC9hPjwvYXJ0aWNsZT48YXJ0aWNsZSBjbGFzcz1cInByZXZpZXcgY29sdW1ucyBzbWFsbC00IG1lZGl1bS00IGxhcmdlLTQgYmcteWVsbG93XCIgZGF0YS1jeGVuc2VfdGFnPVwiY2VyZWJyb1wiIGRhdGEtY3hlbmNlX3dpZGdldD1cInZpZGVvLW1ldGFwb3AtbW9kZWxcIiBkYXRhLWxhYmVsPVwidmlkZW9cIiBkYXRhLWZyb209XCJ4YXZpZXJcIiBkYXRhLXJldmVyc2VJbWFnZVRleHRPcmRlcj1cImZhbHNlXCI+PGEgdGFyZ2V0PVwiX3NlbGZcIiBhcmlhLWxhYmVsPVwiQmVpc3RldCBhbmdyaXBlcjogLSBTam9ra2VyZW5kZSBzeW5cIiBocmVmPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL3ZpZGVvL2JlaXN0ZXQtYW5ncmlwZXIvcE1nMm9yRWdcIj48ZmlndXJlIGNsYXNzPVwieF9fc2MtMWFuN3Z1MS0wIGlkS0NIcyBtb3ZpbmctaW1hZ2UtY29udGFpbmVyXCI+PHZpZGVvIG11dGVkPVwiXCIgbG9vcD1cIlwiIGRhdGEtdmlkZW8tZGVmZXI9XCJ2aWV3XCIgcHJlbG9hZD1cIm5vbmVcIiB0aXRsZT1cIkltYWdlOiBCZWlzdGV0IGFuZ3JpcGVyOiAtIFNqb2trZXJlbmRlIHN5blwiIGNsYXNzPVwibW92aW5nLWltYWdlXCIgcGxheXNpbmxpbmU9XCJcIiBwb3N0ZXI9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vaW1hZ2VzLzgxMzY2MDA5LmpwZz9pbWFnZUlkPTgxMzY2MDA5JmFtcDt4PTAuMDAwMDAwJmFtcDt5PTAuMDAwMDAwJmFtcDtjcm9wdz0wLjAwMDAwMCZhbXA7Y3JvcGg9MC4wMDAwMDAmYW1wO3dpZHRoPTMyMCZhbXA7aGVpZ2h0PTE2M1wiIGRpc2FibGVyZW1vdGVwbGF5YmFjaz1cIlwiPjxzb3VyY2Ugc3JjPVwiaHR0cHM6Ly9zbmlwcC5kYnN0YXRpYy5uby8yMDI0LzA1LzA2L2UyNGE4NTM2LWM0YjgtNGM5OC04MWJlLTY5ZmU1NzFiOTdkYy9naWZmbG9kaGVzdC53ZWJtXCIgdHlwZT1cInZpZGVvL3dlYm1cIi8+PHNvdXJjZSBzcmM9XCJodHRwczovL3NuaXBwLmRic3RhdGljLm5vLzIwMjQvMDUvMDYvZTI0YTg1MzYtYzRiOC00Yzk4LTgxYmUtNjlmZTU3MWI5N2RjL2dpZmZsb2RoZXN0Lm1wNFwiIHR5cGU9XCJ2aWRlby9tcDRcIi8+PC92aWRlbz48ZGl2IGNsYXNzPVwiZmlndXJlLWxvZ29cIj48ZGl2IGNsYXNzPVwibG9nb1wiPjxzdmcgeG1sbnM9XCJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2Z1wiIHdpZHRoPVwiMjRcIiBoZWlnaHQ9XCIyNFwiIHZpZXdCb3g9XCIwIDAgMjQgMjRcIiBmaWxsPVwiY3VycmVudENvbG9yXCIgc3Ryb2tlPVwiY3VycmVudENvbG9yXCIgc3Ryb2tlLXdpZHRoPVwiMlwiIHN0cm9rZS1saW5lY2FwPVwicm91bmRcIiBzdHJva2UtbGluZWpvaW49XCJyb3VuZFwiIGNsYXNzPVwiZmVhdGhlciBmZWF0aGVyLXBsYXlcIj48cG9seWdvbiBwb2ludHM9XCI1IDMgMTkgMTIgNSAyMSA1IDNcIj48L3BvbHlnb24+PC9zdmc+PC9kaXY+PC9kaXY+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGN5Vlh6ZiB0aXRsZSBkeW5hbWljLXNpemluZ1wiPkJlaXN0ZXQgYW5ncmlwZXI6PC9zcGFuPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgY0Z0Q04gdGl0bGUgZHluYW1pYy1zaXppbmdcIj4tIFNqb2trZXJlbmRlIHN5bjwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PGRpdiBpZD1cImFwb3MtbWVkaXVtLXJlY3RhbmdsZTRcIiBjbGFzcz1cImFkdW5pdC13cmFwcGVyIGNvbHVtbnMgc21hbGwtNCBtZWRpdW0tNCBsYXJnZS00IHRyYWNrLWVsZW1lbnQgIFwiIGRhdGEtZnJvbT1cInhhdmllclwiPjxkaXYgaWQ9XCJhZC1tZWRpdW0tcmVjdGFuZ2xlNFwiIGNsYXNzPVwiYWR1bml0IEdvb2dsZUFjdGl2ZVZpZXdFbGVtZW50IHNtYWxsLTMyMHgyNTAgbWVkaXVtLTMyMHgyNTAgbGFyZ2UtMzIweDI1MFwiIGl0ZW1zY29wZT1cIlwiIGl0ZW1UeXBlPVwiaHR0cHM6Ly9zY2hlbWEub3JnL1dQQWRCbG9ja1wiIGRhdGEtc2l6ZXM9XCJbWzMyMCwyNTBdLFszMDAsMjUwXSwmcXVvdDtmbHVpZCZxdW90O11cIiBkYXRhLXNsb3Q9XCIvODU3OC9kYWdibGFkZXQubm8vZm9yc2lkZVwiIGRhdGEtbG9hZC1vbj1cInZpZXdcIiBkYXRhLWNvbGxhcHNlPVwiZmFsc2VcIiBkYXRhLWV4cGFuZD1cImZhbHNlXCIgZGF0YS1vdXQtb2YtcGFnZT1cImZhbHNlXCIganNvbj1cInsmcXVvdDt0YXJnZXRpbmcmcXVvdDs6IHsmcXVvdDtwb3MmcXVvdDs6JnF1b3Q7bWVkaXVtLXJlY3RhbmdsZTQmcXVvdDssJnF1b3Q7cGxhdGZvcm0mcXVvdDs6JnF1b3Q7d29sdmVyaW5lJnF1b3Q7fX1cIj48L2Rpdj48L2Rpdj48L2Rpdj48ZGl2IGNsYXNzPVwicm93IHhyb3cgZmxleC1pbml0aWFsXCI+PGFydGljbGUgY2xhc3M9XCJwcmV2aWV3IGNvbHVtbnMgc21hbGwtNiBtZWRpdW0tNiBsYXJnZS02XCIgZGF0YS1jeGVuc2VfdGFnPVwiY2VyZWJyb1wiIGRhdGEtY3hlbmNlX3dpZGdldD1cImRhZ2JsYWRldC1tb2RlbC1mcm9udFwiIGRhdGEtbGFiZWw9XCJcIiBkYXRhLWZyb209XCJ4YXZpZXJcIiBkYXRhLXJldmVyc2VJbWFnZVRleHRPcmRlcj1cImZhbHNlXCI+PGEgdGFyZ2V0PVwiX3NlbGZcIiBhcmlhLWxhYmVsPVwiU2tpbGxlciBsYWdcIiBocmVmPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL3Nwb3J0L3NraWxsZXItbGFnLzgxMzU4Mzk3XCI+PGZpZ3VyZSBjbGFzcz1cInhfX3NjLTFhbjd2dTEtMCBoeVRLTE1cIj48cGljdHVyZT48aW1nIGRhdGEtZGVmZXI9XCJ2aWV3XCIgdGl0bGU9XCJJbWFnZTogU2tpbGxlciBsYWdcIiBhbHQ9XCJJbWFnZTogU2tpbGxlciBsYWdcIiBkZWNvZGluZz1cImFzeW5jXCIgY2xhc3M9XCJsYXp5bG9hZFwiIGRhdGEtc3JjPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2ltYWdlcy8/aW1hZ2VJZD04MTM1ODQwNyZhbXA7cGFub3k9Ny42NjY5ODQzMjYwMTg4JmFtcDtwYW5veD0wJmFtcDtwYW5vdz0xMDAmYW1wO3Bhbm9oPTIyLjI1NzA1MzI5MTUzNiZhbXA7aGVpZ2h0eD0wJmFtcDtoZWlnaHR3PTkyLjc4MzUwNTE1NDYzOSZhbXA7aGVpZ2h0aD0xMDAmYW1wO2hlaWdodHk9MCZhbXA7d2lkdGg9NDg1JmFtcDtoZWlnaHQ9Mzg2JmFtcDtjb21wcmVzc2lvbj03MFwiIHNyYz1cImRhdGE6aW1hZ2UvcG5nO2Jhc2U2NCxpVkJPUncwS0dnb0FBQUFOU1VoRVVnQUFBQkFBQUFBSkNBWUFBQUE3S3F3eUFBQUFGMGxFUVZSNDJtTjgrK2I5ZndZS0FPT29BYU1HQUFFQTR1a2lDVUNiVzBjQUFBQUFTVVZPUks1Q1lJST1cIiBsb2FkaW5nPVwibGF6eVwiIGZldGNoUHJpb3JpdHk9XCJhdXRvXCIvPjwvcGljdHVyZT48L2ZpZ3VyZT48aGVhZGVyPjxoMyBjbGFzcz1cInhhdmllci1oZWFkbGluZSBoZWFkbGluZVwiPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgZ05EaUJmIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+U2tpbGxlciBsYWc8L3NwYW4+PC9oMz48L2hlYWRlcj48L2E+PC9hcnRpY2xlPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTYgbWVkaXVtLTYgbGFyZ2UtNlwiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJkYWdibGFkZXQtbW9kZWwtZnJvbnRcIiBkYXRhLWxhYmVsPVwiXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIlZhcnNsZXIgYXZnasO4cmVsc2VcIiBocmVmPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL3Nwb3J0L3ZhcnNsZXItYXZnam9yZWxzZS84MTM2MzMxMFwiPjxmaWd1cmUgY2xhc3M9XCJ4X19zYy0xYW43dnUxLTAgZm5RREhiXCI+PHBpY3R1cmU+PGltZyBkYXRhLWRlZmVyPVwidmlld1wiIHRpdGxlPVwiSW1hZ2U6IFZhcnNsZXIgYXZnasO4cmVsc2VcIiBhbHQ9XCJJbWFnZTogVmFyc2xlciBhdmdqw7hyZWxzZVwiIGRlY29kaW5nPVwiYXN5bmNcIiBjbGFzcz1cImxhenlsb2FkXCIgZGF0YS1zcmM9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vaW1hZ2VzLz9pbWFnZUlkPTgxMzYzMzI3JmFtcDtwYW5veT0xOS45MTM0MTk5MTM0MiZhbXA7cGFub3g9MjcuMDg5MzM3MTc1NzkzJmFtcDtwYW5vdz02MC41MTg3MzE5ODg0NzMmYW1wO3Bhbm9oPTMwLjczNTkzMDczNTkzMSZhbXA7aGVpZ2h0eD00NC45MTAxNzk2NDA3MTkmYW1wO2hlaWdodHc9MjYuOTQ2MTA3Nzg0NDMxJmFtcDtoZWlnaHRoPTY2LjIxNjIxNjIxNjIxNiZhbXA7aGVpZ2h0eT0xOC4wMTgwMTgwMTgwMTgmYW1wO3dpZHRoPTQ4NSZhbXA7aGVpZ2h0PTI0MiZhbXA7Y29tcHJlc3Npb249NzBcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGppanh1USB0aXRsZSBkeW5hbWljLXNpemluZ1wiPlZhcnNsZXI8L3NwYW4+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBrdWtlQ3MgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5hdmdqw7hyZWxzZTwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PC9kaXY+PGRpdiBjbGFzcz1cInJvdyB4cm93IGZsZXgtaW5pdGlhbFwiPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTYgbWVkaXVtLTYgbGFyZ2UtNlwiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJkYWdibGFkZXQtbW9kZWwtZnJvbnRcIiBkYXRhLWxhYmVsPVwiXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIkh5Z2dlbGlnIGtyZWZ0bnloZXRcIiBocmVmPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL255aGV0ZXIvbmVkZ2FuZy1pLWtyZWZ0dGlsZmVsbGVyLzgxMzY1NTQ1XCI+PGZpZ3VyZSBjbGFzcz1cInhfX3NjLTFhbjd2dTEtMCBmblFESGJcIj48cGljdHVyZT48aW1nIGRhdGEtZGVmZXI9XCJ2aWV3XCIgdGl0bGU9XCJJbWFnZTogSHlnZ2VsaWcga3JlZnRueWhldFwiIGFsdD1cIkltYWdlOiBIeWdnZWxpZyBrcmVmdG55aGV0XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGNsYXNzPVwibGF6eWxvYWRcIiBkYXRhLXNyYz1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9pbWFnZXMvP2ltYWdlSWQ9ODEzNjU1NjYmYW1wO3Bhbm95PTIwJmFtcDtwYW5veD0wJmFtcDtwYW5vdz0xMDAmYW1wO3Bhbm9oPTUwLjcxNDI4NTcxNDI4NiZhbXA7aGVpZ2h0eD0zMy40ODQxNjI4OTU5MjgmYW1wO2hlaWdodHc9NDAuNzIzOTgxOTAwNDUyJmFtcDtoZWlnaHRoPTEwMCZhbXA7aGVpZ2h0eT0wJmFtcDt3aWR0aD00ODUmYW1wO2hlaWdodD0yNDImYW1wO2NvbXByZXNzaW9uPTcwXCIgc3JjPVwiZGF0YTppbWFnZS9wbmc7YmFzZTY0LGlWQk9SdzBLR2dvQUFBQU5TVWhFVWdBQUFCQUFBQUFKQ0FZQUFBQTdLcXd5QUFBQUYwbEVRVlI0Mm1OOCsrYjlmd1lLQU9Pb0FhTUdBQUVBNHVraUNVQ2JXMGNBQUFBQVNVVk9SSzVDWUlJPVwiIGxvYWRpbmc9XCJsYXp5XCIgZmV0Y2hQcmlvcml0eT1cImF1dG9cIi8+PC9waWN0dXJlPjwvZmlndXJlPjxoZWFkZXI+PGgzIGNsYXNzPVwieGF2aWVyLWhlYWRsaW5lIGhlYWRsaW5lXCI+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBiV3p6a1UgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5IeWdnZWxpZzwvc3Bhbj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGt1a2VDcyB0aXRsZSBkeW5hbWljLXNpemluZ1wiPmtyZWZ0bnloZXQ8L3NwYW4+PC9oMz48L2hlYWRlcj48L2E+PC9hcnRpY2xlPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTYgbWVkaXVtLTYgbGFyZ2UtNlwiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJkYWdibGFkZXQtbW9kZWwtZnJvbnRcIiBkYXRhLWxhYmVsPVwiXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIi0gQXAgZXIgbsOlIHDDpSByZXR0IHZlaVwiIGhyZWY9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vbnloZXRlci9hcC1lci1uYS1wYS1yZXR0LXZlaS84MTMyMjI5M1wiPjxmaWd1cmUgY2xhc3M9XCJ4X19zYy0xYW43dnUxLTAgcFJZTGxcIj48cGljdHVyZT48aW1nIGRhdGEtZGVmZXI9XCJ2aWV3XCIgdGl0bGU9XCJJbWFnZTogLSBBcCBlciBuw6UgcMOlIHJldHQgdmVpXCIgYWx0PVwiSW1hZ2U6IC0gQXAgZXIgbsOlIHDDpSByZXR0IHZlaVwiIGRlY29kaW5nPVwiYXN5bmNcIiBjbGFzcz1cImxhenlsb2FkXCIgZGF0YS1zcmM9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vaW1hZ2VzLz9pbWFnZUlkPTgxMzU4MjQ4JmFtcDtwYW5veT0zNS42MTY0MzgzNTYxNjQmYW1wO3Bhbm94PTAmYW1wO3Bhbm93PTk5Ljg0ODQ4NDU0NTQ1NSZhbXA7cGFub2g9NTEuMTQxNTUyMDU0Nzk1JmFtcDtoZWlnaHR4PTE5LjM5NjU1MTcyNDEzOCZhbXA7aGVpZ2h0dz00MS4yMzU2MzE4OTY1NTImYW1wO2hlaWdodGg9OTkuNzg0OTQ1ODA2NDUyJmFtcDtoZWlnaHR5PTAmYW1wO3dpZHRoPTQ4NSZhbXA7aGVpZ2h0PTI1MSZhbXA7Y29tcHJlc3Npb249NzBcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGRRU0NCUiB0aXRsZSBkeW5hbWljLXNpemluZ1wiPi0gQXAgZXIgbsOlPC9zcGFuPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgZ05EaUJmIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+cMOlIHJldHQgdmVpPC9zcGFuPjwvaDM+PC9oZWFkZXI+PC9hPjwvYXJ0aWNsZT48L2Rpdj48ZGl2IGNsYXNzPVwicm93IHhyb3cgZmxleC1pbml0aWFsXCI+PGRpdiBpZD1cImFwb3MtbmV0Ym9hcmQ2XCIgY2xhc3M9XCJhZHVuaXQtd3JhcHBlciBjb2x1bW5zIHNtYWxsLTggbWVkaXVtLTggbGFyZ2UtOCB0cmFjay1lbGVtZW50ICBcIiBkYXRhLWZyb209XCJ4YXZpZXJcIj48ZGl2IGlkPVwiYWQtbmV0Ym9hcmQ2XCIgY2xhc3M9XCJhZHVuaXQgR29vZ2xlQWN0aXZlVmlld0VsZW1lbnQgc21hbGwtNTgweDUwMCBtZWRpdW0tNTgweDUwMCBsYXJnZS01ODB4NTAwXCIgaXRlbXNjb3BlPVwiXCIgaXRlbVR5cGU9XCJodHRwczovL3NjaGVtYS5vcmcvV1BBZEJsb2NrXCIgZGF0YS1zaXplcz1cIltbNTgwLDQwMF0sWzU4MCw1MDBdLCZxdW90O2ZsdWlkJnF1b3Q7XVwiIGRhdGEtc2xvdD1cIi84NTc4L2RhZ2JsYWRldC5uby9mb3JzaWRlXCIgZGF0YS1sb2FkLW9uPVwidmlld1wiIGRhdGEtY29sbGFwc2U9XCJmYWxzZVwiIGRhdGEtZXhwYW5kPVwiZmFsc2VcIiBkYXRhLW91dC1vZi1wYWdlPVwiZmFsc2VcIiBqc29uPVwieyZxdW90O3RhcmdldGluZyZxdW90OzogeyZxdW90O3BvcyZxdW90OzomcXVvdDtuZXRib2FyZDYmcXVvdDssJnF1b3Q7cGxhdGZvcm0mcXVvdDs6JnF1b3Q7d29sdmVyaW5lJnF1b3Q7fX1cIj48L2Rpdj48L2Rpdj48ZGl2IGNsYXNzPVwieGF2aWVyIGNvbHVtbnMgc21hbGwtNCBtZWRpdW0tNCBsYXJnZS00XCI+PGRpdiBjbGFzcz1cInJvdyB4cm93IGZsZXgtY29sdW1uXCI+PGFydGljbGUgY2xhc3M9XCJwcmV2aWV3IGNvbHVtbnMgc21hbGwtMTIgbWVkaXVtLTEyIGxhcmdlLTEyXCIgZGF0YS1jeGVuc2VfdGFnPVwiY2VyZWJyb1wiIGRhdGEtY3hlbmNlX3dpZGdldD1cInZpZGVvLW1ldGFwb3AtbW9kZWxcIiBkYXRhLWxhYmVsPVwidmlkZW9cIiBkYXRhLWZyb209XCJ4YXZpZXJcIiBkYXRhLXJldmVyc2VJbWFnZVRleHRPcmRlcj1cImZhbHNlXCI+PGEgdGFyZ2V0PVwiX3NlbGZcIiBhcmlhLWxhYmVsPVwiQW5ncmVwIGhlbGlrb3B0cmU6IFRvIHBpbG90ZXIgZMO4ZGVcIiBocmVmPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL3ZpZGVvL2FuZ3JlcC1oZWxpa29wdHJlLXRvLXBpbG90ZXItZG9kZS94YzJWNlhYdVwiPjxmaWd1cmUgY2xhc3M9XCJ4X19zYy0xYW43dnUxLTAgZmpKeXZFXCI+PHBpY3R1cmU+PGltZyBkYXRhLWRlZmVyPVwidmlld1wiIHRpdGxlPVwiSW1hZ2U6IEFuZ3JlcCBoZWxpa29wdHJlOiBUbyBwaWxvdGVyIGTDuGRlXCIgYWx0PVwiSW1hZ2U6IEFuZ3JlcCBoZWxpa29wdHJlOiBUbyBwaWxvdGVyIGTDuGRlXCIgZGVjb2Rpbmc9XCJhc3luY1wiIGNsYXNzPVwibGF6eWxvYWRcIiBkYXRhLXNyYz1cImh0dHBzOi8vY2RuLmp3cGxheWVyLmNvbS90aHVtYnMveGMyVjZYWHUtNzIwLmpwZ1wiIHNyYz1cImRhdGE6aW1hZ2UvcG5nO2Jhc2U2NCxpVkJPUncwS0dnb0FBQUFOU1VoRVVnQUFBQkFBQUFBSkNBWUFBQUE3S3F3eUFBQUFGMGxFUVZSNDJtTjgrK2I5ZndZS0FPT29BYU1HQUFFQTR1a2lDVUNiVzBjQUFBQUFTVVZPUks1Q1lJST1cIiBsb2FkaW5nPVwibGF6eVwiIGZldGNoUHJpb3JpdHk9XCJhdXRvXCIvPjwvcGljdHVyZT48ZGl2IGNsYXNzPVwiZmlndXJlLWxvZ29cIj48ZGl2IGNsYXNzPVwibG9nb1wiPjxzdmcgeG1sbnM9XCJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2Z1wiIHdpZHRoPVwiMjRcIiBoZWlnaHQ9XCIyNFwiIHZpZXdCb3g9XCIwIDAgMjQgMjRcIiBmaWxsPVwiY3VycmVudENvbG9yXCIgc3Ryb2tlPVwiY3VycmVudENvbG9yXCIgc3Ryb2tlLXdpZHRoPVwiMlwiIHN0cm9rZS1saW5lY2FwPVwicm91bmRcIiBzdHJva2UtbGluZWpvaW49XCJyb3VuZFwiIGNsYXNzPVwiZmVhdGhlciBmZWF0aGVyLXBsYXlcIj48cG9seWdvbiBwb2ludHM9XCI1IDMgMTkgMTIgNSAyMSA1IDNcIj48L3BvbHlnb24+PC9zdmc+PC9kaXY+PC9kaXY+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGN5Vlh6ZiB0aXRsZSBkeW5hbWljLXNpemluZ1wiPkFuZ3JlcCBoZWxpa29wdHJlOjwvc3Bhbj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGlGbEVtSyB0aXRsZSBkeW5hbWljLXNpemluZ1wiPlRvIHBpbG90ZXIgZMO4ZGU8L3NwYW4+PC9oMz48L2hlYWRlcj48L2E+PC9hcnRpY2xlPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTEyIG1lZGl1bS0xMiBsYXJnZS0xMlwiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJwbHVzcy1tb2RlbC1mcm9udFwiIGRhdGEtbGFiZWw9XCJwbHVzc1wiIGRhdGEtZnJvbT1cInhhdmllclwiIGRhdGEtcmV2ZXJzZUltYWdlVGV4dE9yZGVyPVwiZmFsc2VcIj48YSB0YXJnZXQ9XCJfc2VsZlwiIGFyaWEtbGFiZWw9XCJCb2JpbC1ndWlkZTogLSBWZWxnIGRpc3NlIVwiIGhyZWY9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vdGVtYS9ib2JpbC1ndWlkZS12ZWxnLWRpc3NlLzgxMjY0Mjc2XCI+PGZpZ3VyZSBjbGFzcz1cInhfX3NjLTFhbjd2dTEtMCBmakp5dkVcIj48cGljdHVyZT48aW1nIGRhdGEtZGVmZXI9XCJ2aWV3XCIgdGl0bGU9XCJJbWFnZTogQm9iaWwtZ3VpZGU6IC0gVmVsZyBkaXNzZSFcIiBhbHQ9XCJJbWFnZTogQm9iaWwtZ3VpZGU6IC0gVmVsZyBkaXNzZSFcIiBkZWNvZGluZz1cImFzeW5jXCIgY2xhc3M9XCJsYXp5bG9hZFwiIGRhdGEtc3JjPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2ltYWdlcy8/aW1hZ2VJZD04MTMxNjQ2NiZhbXA7cGFub3k9MCZhbXA7cGFub3g9MCZhbXA7cGFub3c9MTAwJmFtcDtwYW5vaD0xMDAmYW1wO2hlaWdodHk9MCZhbXA7aGVpZ2h0dz0xMDAmYW1wO2hlaWdodGg9MTAwJmFtcDtoZWlnaHR4PTAmYW1wO3dpZHRoPTMyMCZhbXA7aGVpZ2h0PTE2MCZhbXA7Y29tcHJlc3Npb249NzBcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PGRpdiBjbGFzcz1cImZpZ3VyZS1sb2dvXCI+PGRpdiBjbGFzcz1cImxvZ29cIj48c3ZnIHhtbG5zPVwiaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmdcIiB3aWR0aD1cIjI0XCIgaGVpZ2h0PVwiMjRcIiB2aWV3Qm94PVwiMCAwIDI0IDI0XCIgZmlsbD1cIm5vbmVcIiBzdHJva2U9XCJjdXJyZW50Q29sb3JcIiBzdHJva2Utd2lkdGg9XCIzXCI+PGxpbmUgeDE9XCIxMlwiIHkxPVwiNVwiIHgyPVwiMTJcIiB5Mj1cIjE5XCI+PC9saW5lPjxsaW5lIHgxPVwiNVwiIHkxPVwiMTJcIiB4Mj1cIjE5XCIgeTI9XCIxMlwiPjwvbGluZT48L3N2Zz48L2Rpdj48L2Rpdj48L2ZpZ3VyZT48aGVhZGVyPjxoMyBjbGFzcz1cInhhdmllci1oZWFkbGluZSBoZWFkbGluZVwiPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgamlHVlZqIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+Qm9iaWwtZ3VpZGU6PC9zcGFuPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgamlHVlZqIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+LSBWZWxnIGRpc3NlITwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PC9kaXY+PC9kaXY+PC9kaXY+PGRpdiBjbGFzcz1cInJvdyB4cm93IGZsZXgtaW5pdGlhbFwiPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTcgbWVkaXVtLTcgbGFyZ2UtN1wiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJkYWdibGFkZXQtbW9kZWwtZnJvbnRcIiBkYXRhLWxhYmVsPVwiXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIi0gS29tbWVyIHRpbCDDpSBkw7hcIiBocmVmPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL3Nwb3J0L2tvbW1lci10aWwtYS1kby84MTM1NzkzNlwiPjxmaWd1cmUgY2xhc3M9XCJ4X19zYy0xYW43dnUxLTAga3ZpQXJ5XCI+PHBpY3R1cmU+PGltZyBkYXRhLWRlZmVyPVwidmlld1wiIHRpdGxlPVwiSW1hZ2U6IC0gS29tbWVyIHRpbCDDpSBkw7hcIiBhbHQ9XCJJbWFnZTogLSBLb21tZXIgdGlsIMOlIGTDuFwiIGRlY29kaW5nPVwiYXN5bmNcIiBjbGFzcz1cImxhenlsb2FkXCIgZGF0YS1zcmM9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vaW1hZ2VzLz9pbWFnZUlkPTgxMzU3OTQ3JmFtcDtwYW5vdz0xMDAmYW1wO3Bhbm9oPTQ0LjM3NSZhbXA7cGFub3k9MzMuNzUmYW1wO3Bhbm94PTAmYW1wO2hlaWdodHk9MCZhbXA7aGVpZ2h0eD03Ljc3MjAyMDcyNTM4ODYmYW1wO2hlaWdodHc9NDYuNjMyMTI0MzUyMzMyJmFtcDtoZWlnaHRoPTEwMCZhbXA7d2lkdGg9NTY3JmFtcDtoZWlnaHQ9MjgzJmFtcDtjb21wcmVzc2lvbj03MFwiIHNyYz1cImRhdGE6aW1hZ2UvcG5nO2Jhc2U2NCxpVkJPUncwS0dnb0FBQUFOU1VoRVVnQUFBQkFBQUFBSkNBWUFBQUE3S3F3eUFBQUFGMGxFUVZSNDJtTjgrK2I5ZndZS0FPT29BYU1HQUFFQTR1a2lDVUNiVzBjQUFBQUFTVVZPUks1Q1lJST1cIiBsb2FkaW5nPVwibGF6eVwiIGZldGNoUHJpb3JpdHk9XCJhdXRvXCIvPjwvcGljdHVyZT48L2ZpZ3VyZT48aGVhZGVyPjxoMyBjbGFzcz1cInhhdmllci1oZWFkbGluZSBoZWFkbGluZVwiPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgZEEtRG9oeiB0aXRsZSBkeW5hbWljLXNpemluZ1wiPi0gS29tbWVyPC9zcGFuPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgZmdZWVhGIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+dGlsIMOlIGTDuDwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PGFydGljbGUgY2xhc3M9XCJwcmV2aWV3IGNvbHVtbnMgc21hbGwtNSBtZWRpdW0tNSBsYXJnZS01XCIgZGF0YS1jeGVuc2VfdGFnPVwiY2VyZWJyb1wiIGRhdGEtY3hlbmNlX3dpZGdldD1cImRhZ2JsYWRldC1tb2RlbC1mcm9udFwiIGRhdGEtbGFiZWw9XCJcIiBkYXRhLWZyb209XCJ4YXZpZXJcIiBkYXRhLXJldmVyc2VJbWFnZVRleHRPcmRlcj1cImZhbHNlXCI+PGEgdGFyZ2V0PVwiX3NlbGZcIiBhcmlhLWxhYmVsPVwiT3ZlcnJhc2tldDogRHVra2V0IG9wcFwiIGhyZWY9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8va2plbmRpcy9vdmVycmFza2V0LWR1a2tldC1vcHAvODEzNjA2NjhcIj48ZmlndXJlIGNsYXNzPVwieF9fc2MtMWFuN3Z1MS0wIEpGbWdSXCI+PHBpY3R1cmU+PGltZyBkYXRhLWRlZmVyPVwidmlld1wiIHRpdGxlPVwiSW1hZ2U6IE92ZXJyYXNrZXQ6IER1a2tldCBvcHBcIiBhbHQ9XCJJbWFnZTogT3ZlcnJhc2tldDogRHVra2V0IG9wcFwiIGRlY29kaW5nPVwiYXN5bmNcIiBjbGFzcz1cImxhenlsb2FkXCIgZGF0YS1zcmM9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vaW1hZ2VzLz9pbWFnZUlkPTgxMzYwNTA3JmFtcDtwYW5veT0yOS44NDEyNjk4NDEyNyZhbXA7cGFub3g9MCZhbXA7cGFub3c9MTAwJmFtcDtwYW5vaD0yMi41Mzk2ODI1Mzk2ODMmYW1wO2hlaWdodHg9MCZhbXA7aGVpZ2h0dz0xMDAmYW1wO2hlaWdodGg9MTAwJmFtcDtoZWlnaHR5PTAmYW1wO3dpZHRoPTQwMiZhbXA7aGVpZ2h0PTQzOSZhbXA7Y29tcHJlc3Npb249NzBcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGRCV1FSaSB0aXRsZSBkeW5hbWljLXNpemluZ1wiPk92ZXJyYXNrZXQ6PC9zcGFuPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgaHJWY0ROIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+RHVra2V0IG9wcDwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PC9kaXY+PGRpdiBjbGFzcz1cInJvdyB4cm93IGZsZXgtaW5pdGlhbFwiPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTUgbWVkaXVtLTUgbGFyZ2UtNVwiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJkYWdibGFkZXQtbW9kZWwtZnJvbnRcIiBkYXRhLWxhYmVsPVwiXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIk55ZSBkZXRhbGplcjogU2t1dHQgaSBob2RldFwiIGhyZWY9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vbnloZXRlci9ueWUtZGV0YWxqZXItc2t1dHQtaS1ob2RldC84MTMyNjI0MlwiPjxmaWd1cmUgY2xhc3M9XCJ4X19zYy0xYW43dnUxLTAgZHdvRmhpXCI+PHBpY3R1cmU+PGltZyBkYXRhLWRlZmVyPVwidmlld1wiIHRpdGxlPVwiSW1hZ2U6IE55ZSBkZXRhbGplcjogU2t1dHQgaSBob2RldFwiIGFsdD1cIkltYWdlOiBOeWUgZGV0YWxqZXI6IFNrdXR0IGkgaG9kZXRcIiBkZWNvZGluZz1cImFzeW5jXCIgY2xhc3M9XCJsYXp5bG9hZFwiIGRhdGEtc3JjPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2ltYWdlcy8/aW1hZ2VJZD04MTM2MTA1NCZhbXA7cGFub3g9MCZhbXA7cGFub3c9MTAwJmFtcDtwYW5vaD0xMDAmYW1wO3Bhbm95PTAmYW1wO2hlaWdodHk9MCZhbXA7aGVpZ2h0eD0wJmFtcDtoZWlnaHR3PTEwMCZhbXA7aGVpZ2h0aD0xMDAmYW1wO3dpZHRoPTQwMiZhbXA7aGVpZ2h0PTIzMyZhbXA7Y29tcHJlc3Npb249NzBcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGdWUldBQiB0aXRsZSBkeW5hbWljLXNpemluZ1wiPk55ZSBkZXRhbGplcjo8L3NwYW4+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBnVlJXQUIgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5Ta3V0dCBpIGhvZGV0PC9zcGFuPjwvaDM+PC9oZWFkZXI+PC9hPjwvYXJ0aWNsZT48YXJ0aWNsZSBjbGFzcz1cInByZXZpZXcgY29sdW1ucyBzbWFsbC03IG1lZGl1bS03IGxhcmdlLTdcIiBkYXRhLWN4ZW5zZV90YWc9XCJjZXJlYnJvXCIgZGF0YS1jeGVuY2Vfd2lkZ2V0PVwiZGFnYmxhZGV0LW1vZGVsLWZyb250XCIgZGF0YS1sYWJlbD1cIlwiIGRhdGEtZnJvbT1cInhhdmllclwiIGRhdGEtcmV2ZXJzZUltYWdlVGV4dE9yZGVyPVwiZmFsc2VcIj48YSB0YXJnZXQ9XCJfc2VsZlwiIGFyaWEtbGFiZWw9XCJTcMOlciBnb2R0IG55dHRcIiBocmVmPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL255aGV0ZXIvc3Bhci1nb2R0LW55dHQvODEzNjA3OTFcIj48ZmlndXJlIGNsYXNzPVwieF9fc2MtMWFuN3Z1MS0wIGt2aUFyeVwiPjxwaWN0dXJlPjxpbWcgZGF0YS1kZWZlcj1cInZpZXdcIiB0aXRsZT1cIkltYWdlOiBTcMOlciBnb2R0IG55dHRcIiBhbHQ9XCJJbWFnZTogU3DDpXIgZ29kdCBueXR0XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGNsYXNzPVwibGF6eWxvYWRcIiBkYXRhLXNyYz1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9pbWFnZXMvP2ltYWdlSWQ9ODEzNjEzOTEmYW1wO3Bhbm95PTI3LjE0Mjg1NzE0Mjg1NyZhbXA7cGFub3g9MCZhbXA7cGFub2g9NTAuNzE0Mjg1NzE0Mjg2JmFtcDtwYW5vdz0xMDAmYW1wO2hlaWdodHg9MTQuNDc5NjM4MDA5MDUmYW1wO2hlaWdodHk9MCZhbXA7aGVpZ2h0dz00MC43MjM5ODE5MDA0NTImYW1wO2hlaWdodGg9MTAwJmFtcDt3aWR0aD01NjcmYW1wO2hlaWdodD0yODMmYW1wO2NvbXByZXNzaW9uPTcwXCIgc3JjPVwiZGF0YTppbWFnZS9wbmc7YmFzZTY0LGlWQk9SdzBLR2dvQUFBQU5TVWhFVWdBQUFCQUFBQUFKQ0FZQUFBQTdLcXd5QUFBQUYwbEVRVlI0Mm1OOCsrYjlmd1lLQU9Pb0FhTUdBQUVBNHVraUNVQ2JXMGNBQUFBQVNVVk9SSzVDWUlJPVwiIGxvYWRpbmc9XCJsYXp5XCIgZmV0Y2hQcmlvcml0eT1cImF1dG9cIi8+PC9waWN0dXJlPjwvZmlndXJlPjxoZWFkZXI+PGgzIGNsYXNzPVwieGF2aWVyLWhlYWRsaW5lIGhlYWRsaW5lXCI+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBmRkFpVEsgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5TcMOlciBnb2R0IG55dHQ8L3NwYW4+PC9oMz48L2hlYWRlcj48L2E+PC9hcnRpY2xlPjwvZGl2PjxkaXYgY2xhc3M9XCJyb3cgeHJvdyBmbGV4LWluaXRpYWxcIj48YXJ0aWNsZSBjbGFzcz1cInByZXZpZXcgY29sdW1ucyBzbWFsbC00IG1lZGl1bS00IGxhcmdlLTRcIiBkYXRhLWN4ZW5zZV90YWc9XCJjZXJlYnJvXCIgZGF0YS1jeGVuY2Vfd2lkZ2V0PVwidmlkZW8tbWV0YXBvcC1tb2RlbFwiIGRhdGEtbGFiZWw9XCJ2aWRlb1wiIGRhdGEtZnJvbT1cInhhdmllclwiIGRhdGEtcmV2ZXJzZUltYWdlVGV4dE9yZGVyPVwiZmFsc2VcIj48YSB0YXJnZXQ9XCJfc2VsZlwiIGFyaWEtbGFiZWw9XCJQcm9kdWtzam9uZW4gbcOlIGJyeXRlIGlublwiIGhyZWY9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vdmlkZW8vcHJvZHVrc2pvbmVuLW1hLWJyeXRlLWlubi9nYUFoMXZ5aVwiPjxmaWd1cmUgY2xhc3M9XCJ4X19zYy0xYW43dnUxLTAgZmpKeXZFXCI+PHBpY3R1cmU+PGltZyBkYXRhLWRlZmVyPVwidmlld1wiIHRpdGxlPVwiSW1hZ2U6IFByb2R1a3Nqb25lbiBtw6UgYnJ5dGUgaW5uXCIgYWx0PVwiSW1hZ2U6IFByb2R1a3Nqb25lbiBtw6UgYnJ5dGUgaW5uXCIgZGVjb2Rpbmc9XCJhc3luY1wiIGNsYXNzPVwibGF6eWxvYWRcIiBkYXRhLXNyYz1cImh0dHBzOi8vY2RuLmp3cGxheWVyLmNvbS90aHVtYnMvZ2FBaDF2eWktNzIwLmpwZ1wiIHNyYz1cImRhdGE6aW1hZ2UvcG5nO2Jhc2U2NCxpVkJPUncwS0dnb0FBQUFOU1VoRVVnQUFBQkFBQUFBSkNBWUFBQUE3S3F3eUFBQUFGMGxFUVZSNDJtTjgrK2I5ZndZS0FPT29BYU1HQUFFQTR1a2lDVUNiVzBjQUFBQUFTVVZPUks1Q1lJST1cIiBsb2FkaW5nPVwibGF6eVwiIGZldGNoUHJpb3JpdHk9XCJhdXRvXCIvPjwvcGljdHVyZT48ZGl2IGNsYXNzPVwiZmlndXJlLWxvZ29cIj48ZGl2IGNsYXNzPVwibG9nb1wiPjxzdmcgeG1sbnM9XCJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2Z1wiIHdpZHRoPVwiMjRcIiBoZWlnaHQ9XCIyNFwiIHZpZXdCb3g9XCIwIDAgMjQgMjRcIiBmaWxsPVwiY3VycmVudENvbG9yXCIgc3Ryb2tlPVwiY3VycmVudENvbG9yXCIgc3Ryb2tlLXdpZHRoPVwiMlwiIHN0cm9rZS1saW5lY2FwPVwicm91bmRcIiBzdHJva2UtbGluZWpvaW49XCJyb3VuZFwiIGNsYXNzPVwiZmVhdGhlciBmZWF0aGVyLXBsYXlcIj48cG9seWdvbiBwb2ludHM9XCI1IDMgMTkgMTIgNSAyMSA1IDNcIj48L3BvbHlnb24+PC9zdmc+PC9kaXY+PC9kaXY+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGRmc2VyUCB0aXRsZSBkeW5hbWljLXNpemluZ1wiPlByb2R1a3Nqb25lbjwvc3Bhbj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGppR1ZWaiB0aXRsZSBkeW5hbWljLXNpemluZ1wiPm3DpSBicnl0ZSBpbm48L3NwYW4+PC9oMz48L2hlYWRlcj48L2E+PC9hcnRpY2xlPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTQgbWVkaXVtLTQgbGFyZ2UtNFwiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJwbHVzcy1tb2RlbC1mcm9udFwiIGRhdGEtbGFiZWw9XCJwbHVzc1wiIGRhdGEtZnJvbT1cInhhdmllclwiIGRhdGEtcmV2ZXJzZUltYWdlVGV4dE9yZGVyPVwiZmFsc2VcIj48YSB0YXJnZXQ9XCJfc2VsZlwiIGFyaWEtbGFiZWw9XCJTbGFua2VzZW50ZXItZm9ybWVsZW46IE5lZCA4IGtpbG9cIiBocmVmPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL3RlbWEvc2xhbmtlc2VudGVyLWZvcm1lbGVuLW5lZC04LWtpbG8vODEyMzkxNzFcIj48ZmlndXJlIGNsYXNzPVwieF9fc2MtMWFuN3Z1MS0wIGlZT2tva1wiPjxwaWN0dXJlPjxpbWcgZGF0YS1kZWZlcj1cInZpZXdcIiB0aXRsZT1cIkltYWdlOiBTbGFua2VzZW50ZXItZm9ybWVsZW46IE5lZCA4IGtpbG9cIiBhbHQ9XCJJbWFnZTogU2xhbmtlc2VudGVyLWZvcm1lbGVuOiBOZWQgOCBraWxvXCIgZGVjb2Rpbmc9XCJhc3luY1wiIGNsYXNzPVwibGF6eWxvYWRcIiBkYXRhLXNyYz1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9pbWFnZXMvP2ltYWdlSWQ9ODEyNDEzNTImYW1wO3Bhbm94PTI4LjQyMTA1MjYzMTU3OSZhbXA7cGFub3c9NDUuODA5NTA0OTg5MTU0JmFtcDtwYW5vaD03NC40MTQyNDUzNjA4MjUmYW1wO3Bhbm95PTEzJmFtcDtoZWlnaHR5PTQuMDg2MDIxOTM1NDgzOSZhbXA7aGVpZ2h0eD0zNS40Nzk0NTIwNTQ3OTUmYW1wO2hlaWdodHc9MTIuNTU3MDc3NTM0MjQ3JmFtcDtoZWlnaHRoPTk1LjkxMzk3ODA2NDUxNiZhbXA7d2lkdGg9MzIwJmFtcDtoZWlnaHQ9MTY2JmFtcDtjb21wcmVzc2lvbj03MFwiIHNyYz1cImRhdGE6aW1hZ2UvcG5nO2Jhc2U2NCxpVkJPUncwS0dnb0FBQUFOU1VoRVVnQUFBQkFBQUFBSkNBWUFBQUE3S3F3eUFBQUFGMGxFUVZSNDJtTjgrK2I5ZndZS0FPT29BYU1HQUFFQTR1a2lDVUNiVzBjQUFBQUFTVVZPUks1Q1lJST1cIiBsb2FkaW5nPVwibGF6eVwiIGZldGNoUHJpb3JpdHk9XCJhdXRvXCIvPjwvcGljdHVyZT48ZGl2IGNsYXNzPVwiZmlndXJlLWxvZ29cIj48ZGl2IGNsYXNzPVwibG9nb1wiPjxzdmcgeG1sbnM9XCJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2Z1wiIHdpZHRoPVwiMjRcIiBoZWlnaHQ9XCIyNFwiIHZpZXdCb3g9XCIwIDAgMjQgMjRcIiBmaWxsPVwibm9uZVwiIHN0cm9rZT1cImN1cnJlbnRDb2xvclwiIHN0cm9rZS13aWR0aD1cIjNcIj48bGluZSB4MT1cIjEyXCIgeTE9XCI1XCIgeDI9XCIxMlwiIHkyPVwiMTlcIj48L2xpbmU+PGxpbmUgeDE9XCI1XCIgeTE9XCIxMlwiIHgyPVwiMTlcIiB5Mj1cIjEyXCI+PC9saW5lPjwvc3ZnPjwvZGl2PjwvZGl2PjwvZmlndXJlPjxoZWFkZXI+PGgzIGNsYXNzPVwieGF2aWVyLWhlYWRsaW5lIGhlYWRsaW5lXCI+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBiZUROcFogdGl0bGUgZHluYW1pYy1zaXppbmdcIj5TbGFua2VzZW50ZXItZm9ybWVsZW46PC9zcGFuPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgaFJYYVhyIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+TmVkIDgga2lsbzwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PGRpdiBpZD1cImFwb3MtbWVkaXVtLXJlY3RhbmdsZTVcIiBjbGFzcz1cImFkdW5pdC13cmFwcGVyIGNvbHVtbnMgc21hbGwtNCBtZWRpdW0tNCBsYXJnZS00IHRyYWNrLWVsZW1lbnQgIFwiIGRhdGEtZnJvbT1cInhhdmllclwiPjxkaXYgaWQ9XCJhZC1tZWRpdW0tcmVjdGFuZ2xlNVwiIGNsYXNzPVwiYWR1bml0IEdvb2dsZUFjdGl2ZVZpZXdFbGVtZW50IHNtYWxsLTMyMHgyNTAgbWVkaXVtLTMyMHgyNTAgbGFyZ2UtMzIweDI1MFwiIGl0ZW1zY29wZT1cIlwiIGl0ZW1UeXBlPVwiaHR0cHM6Ly9zY2hlbWEub3JnL1dQQWRCbG9ja1wiIGRhdGEtc2l6ZXM9XCJbWzMyMCwyNTBdLFszMDAsMjUwXSwmcXVvdDtmbHVpZCZxdW90O11cIiBkYXRhLXNsb3Q9XCIvODU3OC9kYWdibGFkZXQubm8vZm9yc2lkZVwiIGRhdGEtbG9hZC1vbj1cInZpZXdcIiBkYXRhLWNvbGxhcHNlPVwiZmFsc2VcIiBkYXRhLWV4cGFuZD1cImZhbHNlXCIgZGF0YS1vdXQtb2YtcGFnZT1cImZhbHNlXCIganNvbj1cInsmcXVvdDt0YXJnZXRpbmcmcXVvdDs6IHsmcXVvdDtwb3MmcXVvdDs6JnF1b3Q7bWVkaXVtLXJlY3RhbmdsZTUmcXVvdDssJnF1b3Q7cGxhdGZvcm0mcXVvdDs6JnF1b3Q7d29sdmVyaW5lJnF1b3Q7fX1cIj48L2Rpdj48L2Rpdj48L2Rpdj48ZGl2IGNsYXNzPVwicm93IHhyb3cgZmxleC1pbml0aWFsXCI+PGFydGljbGUgY2xhc3M9XCJwcmV2aWV3IGNvbHVtbnMgc21hbGwtNiBtZWRpdW0tNiBsYXJnZS02XCIgZGF0YS1jeGVuc2VfdGFnPVwiY2VyZWJyb1wiIGRhdGEtY3hlbmNlX3dpZGdldD1cImRhZ2JsYWRldC1tb2RlbC1mcm9udFwiIGRhdGEtbGFiZWw9XCJcIiBkYXRhLWZyb209XCJ4YXZpZXJcIiBkYXRhLXJldmVyc2VJbWFnZVRleHRPcmRlcj1cImZhbHNlXCI+PGEgdGFyZ2V0PVwiX3NlbGZcIiBhcmlhLWxhYmVsPVwiQXZzbMO4cmVyIHVramVudCBmYW1pbGllYsOlbmRcIiBocmVmPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2tqZW5kaXMvYXZzbG9yZXItdWtqZW50LWZhbWlsaWViYW5kLzgxMzU1NTA0XCI+PGZpZ3VyZSBjbGFzcz1cInhfX3NjLTFhbjd2dTEtMCBneHBJUlZcIj48cGljdHVyZT48aW1nIGRhdGEtZGVmZXI9XCJ2aWV3XCIgdGl0bGU9XCJJbWFnZTogQXZzbMO4cmVyIHVramVudCBmYW1pbGllYsOlbmRcIiBhbHQ9XCJJbWFnZTogQXZzbMO4cmVyIHVramVudCBmYW1pbGllYsOlbmRcIiBkZWNvZGluZz1cImFzeW5jXCIgY2xhc3M9XCJsYXp5bG9hZFwiIGRhdGEtc3JjPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2ltYWdlcy8/aW1hZ2VJZD04MTM1NTYyOCZhbXA7cGFub3k9Ni4yNzMwNjI3MzA2MjczJmFtcDtwYW5veD0wJmFtcDtwYW5vdz05OS44NDI3NjY5ODExMzImYW1wO3Bhbm9oPTI2LjgxNDI2Nzg5NjY3OSZhbXA7aGVpZ2h0dz0xMDAmYW1wO2hlaWdodGg9MTAwJmFtcDtoZWlnaHR5PTAmYW1wO2hlaWdodHg9MCZhbXA7d2lkdGg9NDg1JmFtcDtoZWlnaHQ9MjY5JmFtcDtjb21wcmVzc2lvbj03MFwiIHNyYz1cImRhdGE6aW1hZ2UvcG5nO2Jhc2U2NCxpVkJPUncwS0dnb0FBQUFOU1VoRVVnQUFBQkFBQUFBSkNBWUFBQUE3S3F3eUFBQUFGMGxFUVZSNDJtTjgrK2I5ZndZS0FPT29BYU1HQUFFQTR1a2lDVUNiVzBjQUFBQUFTVVZPUks1Q1lJST1cIiBsb2FkaW5nPVwibGF6eVwiIGZldGNoUHJpb3JpdHk9XCJhdXRvXCIvPjwvcGljdHVyZT48L2ZpZ3VyZT48aGVhZGVyPjxoMyBjbGFzcz1cInhhdmllci1oZWFkbGluZSBoZWFkbGluZVwiPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgZ1ZSV0FCIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+QXZzbMO4cmVyIHVramVudDwvc3Bhbj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGJ4dHVaSiB0aXRsZSBkeW5hbWljLXNpemluZ1wiPmZhbWlsaWViw6VuZDwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PGFydGljbGUgY2xhc3M9XCJwcmV2aWV3IGNvbHVtbnMgc21hbGwtNiBtZWRpdW0tNiBsYXJnZS02XCIgZGF0YS1jeGVuc2VfdGFnPVwiY2VyZWJyb1wiIGRhdGEtY3hlbmNlX3dpZGdldD1cImRhZ2JsYWRldC1tb2RlbC1mcm9udFwiIGRhdGEtbGFiZWw9XCJcIiBkYXRhLWZyb209XCJ4YXZpZXJcIiBkYXRhLXJldmVyc2VJbWFnZVRleHRPcmRlcj1cImZhbHNlXCI+PGEgdGFyZ2V0PVwiX3NlbGZcIiBhcmlhLWxhYmVsPVwiLSBEYSBzdGFydGV0IHNwZXRha2tlbGV0XCIgaHJlZj1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9ueWhldGVyL2RhLXN0YXJ0ZXQtc3BldGFra2VsZXQvODEzNDQyODBcIj48ZmlndXJlIGNsYXNzPVwieF9fc2MtMWFuN3Z1MS0wIGZuUURIYlwiPjxwaWN0dXJlPjxpbWcgZGF0YS1kZWZlcj1cInZpZXdcIiB0aXRsZT1cIkltYWdlOiAtIERhIHN0YXJ0ZXQgc3BldGFra2VsZXRcIiBhbHQ9XCJJbWFnZTogLSBEYSBzdGFydGV0IHNwZXRha2tlbGV0XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGNsYXNzPVwibGF6eWxvYWRcIiBkYXRhLXNyYz1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9pbWFnZXMvP2ltYWdlSWQ9ODEzNDg1MjQmYW1wO3Bhbm95PTAmYW1wO3Bhbm93PTEwMCZhbXA7cGFub2g9MTAwJmFtcDtwYW5veD0wJmFtcDtoZWlnaHR5PTAmYW1wO2hlaWdodHg9MzkuNzE5NjI2MTY4MjI0JmFtcDtoZWlnaHR3PTQxLjEyMTQ5NTMyNzEwMyZhbXA7aGVpZ2h0aD0xMDAmYW1wO3dpZHRoPTQ4NSZhbXA7aGVpZ2h0PTI0MiZhbXA7Y29tcHJlc3Npb249NzBcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGRkYkNKWiB0aXRsZSBkeW5hbWljLXNpemluZ1wiPi0gRGEgc3RhcnRldDwvc3Bhbj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGRXek1uQSB0aXRsZSBkeW5hbWljLXNpemluZ1wiPnNwZXRha2tlbGV0PC9zcGFuPjwvaDM+PC9oZWFkZXI+PC9hPjwvYXJ0aWNsZT48L2Rpdj48ZGl2IGNsYXNzPVwicm93IHhyb3cgZmxleC1pbml0aWFsXCI+PGFydGljbGUgY2xhc3M9XCJwcmV2aWV3IGNvbHVtbnMgc21hbGwtNSBtZWRpdW0tNSBsYXJnZS01IGJnLXllbGxvd1wiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJkYWdibGFkZXQtbW9kZWwtZnJvbnRcIiBkYXRhLWxhYmVsPVwiXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIkVrdGVtYW5uZW4gcMOlZ3JlcGV0IGV0dGVyIGZvcnN2aW5uaW5nZW5cIiBocmVmPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL255aGV0ZXIvZWt0ZW1hbm5lbi1wYWdyZXBldC1ldHRlci1mb3JzdmlubmluZ2VuLzgxMzY0MDIwXCI+PGZpZ3VyZSBjbGFzcz1cInhfX3NjLTFhbjd2dTEtMCBlbk1VT1wiPjxwaWN0dXJlPjxpbWcgZGF0YS1kZWZlcj1cInZpZXdcIiB0aXRsZT1cIkltYWdlOiBFa3RlbWFubmVuIHDDpWdyZXBldCBldHRlciBmb3JzdmlubmluZ2VuXCIgYWx0PVwiSW1hZ2U6IEVrdGVtYW5uZW4gcMOlZ3JlcGV0IGV0dGVyIGZvcnN2aW5uaW5nZW5cIiBkZWNvZGluZz1cImFzeW5jXCIgY2xhc3M9XCJsYXp5bG9hZFwiIGRhdGEtc3JjPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2ltYWdlcy8/aW1hZ2VJZD04MTM2NDA0MSZhbXA7cGFub3g9MCZhbXA7cGFub3c9MTAwJmFtcDtwYW5vaD0xMDAmYW1wO3Bhbm95PTAmYW1wO2hlaWdodHk9MCZhbXA7aGVpZ2h0eD0wJmFtcDtoZWlnaHR3PTEwMCZhbXA7aGVpZ2h0aD0xMDAmYW1wO3dpZHRoPTQwMiZhbXA7aGVpZ2h0PTM2OCZhbXA7Y29tcHJlc3Npb249NzBcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGN5Vlh6ZiB0aXRsZSBkeW5hbWljLXNpemluZ1wiPkVrdGVtYW5uZW4gcMOlZ3JlcGV0PC9zcGFuPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAga3h6YUtsIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+ZXR0ZXIgZm9yc3Zpbm5pbmdlbjwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PGFydGljbGUgY2xhc3M9XCJwcmV2aWV3IGNvbHVtbnMgc21hbGwtNyBtZWRpdW0tNyBsYXJnZS03XCIgZGF0YS1jeGVuc2VfdGFnPVwiY2VyZWJyb1wiIGRhdGEtY3hlbmNlX3dpZGdldD1cImRhZ2JsYWRldC1tb2RlbC1mcm9udFwiIGRhdGEtbGFiZWw9XCJcIiBkYXRhLWZyb209XCJ4YXZpZXJcIiBkYXRhLXJldmVyc2VJbWFnZVRleHRPcmRlcj1cImZhbHNlXCI+PGEgdGFyZ2V0PVwiX3NlbGZcIiBhcmlhLWxhYmVsPVwiQW5rbGFnZXM6IC0gU3Rvcm0gaSB2YW5uZ2xhc3NcIiBocmVmPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2tqZW5kaXMvYW5rbGFnZXMtc3Rvcm0taS12YW5uZ2xhc3MvODEzNTY5MzNcIj48ZmlndXJlIGNsYXNzPVwieF9fc2MtMWFuN3Z1MS0wIGt2aUFyeVwiPjxwaWN0dXJlPjxpbWcgZGF0YS1kZWZlcj1cInZpZXdcIiB0aXRsZT1cIkltYWdlOiBBbmtsYWdlczogLSBTdG9ybSBpIHZhbm5nbGFzc1wiIGFsdD1cIkltYWdlOiBBbmtsYWdlczogLSBTdG9ybSBpIHZhbm5nbGFzc1wiIGRlY29kaW5nPVwiYXN5bmNcIiBjbGFzcz1cImxhenlsb2FkXCIgZGF0YS1zcmM9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vaW1hZ2VzLz9pbWFnZUlkPTgxMzUwNjAwJmFtcDtwYW5veD0wJmFtcDtwYW5vdz0xMDAmYW1wO3Bhbm9oPTI2Ljk5NjE5NzcxODYzMSZhbXA7cGFub3k9OS4xMjU0NzUyODUxNzExJmFtcDtoZWlnaHR5PTAmYW1wO2hlaWdodHg9MCZhbXA7aGVpZ2h0dz0xMDAmYW1wO2hlaWdodGg9MTAwJmFtcDt3aWR0aD01NjcmYW1wO2hlaWdodD0yODMmYW1wO2NvbXByZXNzaW9uPTcwXCIgc3JjPVwiZGF0YTppbWFnZS9wbmc7YmFzZTY0LGlWQk9SdzBLR2dvQUFBQU5TVWhFVWdBQUFCQUFBQUFKQ0FZQUFBQTdLcXd5QUFBQUYwbEVRVlI0Mm1OOCsrYjlmd1lLQU9Pb0FhTUdBQUVBNHVraUNVQ2JXMGNBQUFBQVNVVk9SSzVDWUlJPVwiIGxvYWRpbmc9XCJsYXp5XCIgZmV0Y2hQcmlvcml0eT1cImF1dG9cIi8+PC9waWN0dXJlPjwvZmlndXJlPjxoZWFkZXI+PGgzIGNsYXNzPVwieGF2aWVyLWhlYWRsaW5lIGhlYWRsaW5lXCI+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBnVlJXQUIgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5BbmtsYWdlczogLSBTdG9ybTwvc3Bhbj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGxkVGpnSCB0aXRsZSBkeW5hbWljLXNpemluZ1wiPmkgdmFubmdsYXNzPC9zcGFuPjwvaDM+PC9oZWFkZXI+PC9hPjwvYXJ0aWNsZT48L2Rpdj48ZGl2IGNsYXNzPVwicm93IHhyb3cgZmxleC1pbml0aWFsXCI+PGRpdiBpZD1cImFwb3MtbmV0Ym9hcmQ3XCIgY2xhc3M9XCJhZHVuaXQtd3JhcHBlciBjb2x1bW5zIHNtYWxsLTggbWVkaXVtLTggbGFyZ2UtOCB0cmFjay1lbGVtZW50ICBcIiBkYXRhLWZyb209XCJ4YXZpZXJcIj48ZGl2IGlkPVwiYWQtbmV0Ym9hcmQ3XCIgY2xhc3M9XCJhZHVuaXQgR29vZ2xlQWN0aXZlVmlld0VsZW1lbnQgc21hbGwtNTgweDUwMCBtZWRpdW0tNTgweDUwMCBsYXJnZS01ODB4NTAwXCIgaXRlbXNjb3BlPVwiXCIgaXRlbVR5cGU9XCJodHRwczovL3NjaGVtYS5vcmcvV1BBZEJsb2NrXCIgZGF0YS1zaXplcz1cIltbNTgwLDQwMF0sWzU4MCw1MDBdLCZxdW90O2ZsdWlkJnF1b3Q7XVwiIGRhdGEtc2xvdD1cIi84NTc4L2RhZ2JsYWRldC5uby9mb3JzaWRlXCIgZGF0YS1sb2FkLW9uPVwidmlld1wiIGRhdGEtY29sbGFwc2U9XCJmYWxzZVwiIGRhdGEtZXhwYW5kPVwiZmFsc2VcIiBkYXRhLW91dC1vZi1wYWdlPVwiZmFsc2VcIiBqc29uPVwieyZxdW90O3RhcmdldGluZyZxdW90OzogeyZxdW90O3BvcyZxdW90OzomcXVvdDtuZXRib2FyZDcmcXVvdDssJnF1b3Q7cGxhdGZvcm0mcXVvdDs6JnF1b3Q7d29sdmVyaW5lJnF1b3Q7fX1cIj48L2Rpdj48L2Rpdj48ZGl2IGNsYXNzPVwieGF2aWVyIGNvbHVtbnMgc21hbGwtNCBtZWRpdW0tNCBsYXJnZS00XCI+PGRpdiBjbGFzcz1cInJvdyB4cm93IGZsZXgtY29sdW1uXCI+PGFydGljbGUgY2xhc3M9XCJwcmV2aWV3IGNvbHVtbnMgc21hbGwtMTIgbWVkaXVtLTEyIGxhcmdlLTEyXCIgZGF0YS1jeGVuc2VfdGFnPVwiY2VyZWJyb1wiIGRhdGEtY3hlbmNlX3dpZGdldD1cInBsdXNzLW1vZGVsLWZyb250XCIgZGF0YS1sYWJlbD1cInBsdXNzXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIlVza2lmdGV0IGJvOiBVbm5nw6Ugc21lbGxcIiBocmVmPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL3RlbWEvdXNraWZ0ZXQtYm8tdW5uZ2Etc21lbGwvODEyMDYxOTlcIj48ZmlndXJlIGNsYXNzPVwieF9fc2MtMWFuN3Z1MS0wIGZqSnl2RVwiPjxwaWN0dXJlPjxpbWcgZGF0YS1kZWZlcj1cInZpZXdcIiB0aXRsZT1cIkltYWdlOiBVc2tpZnRldCBibzogVW5uZ8OlIHNtZWxsXCIgYWx0PVwiSW1hZ2U6IFVza2lmdGV0IGJvOiBVbm5nw6Ugc21lbGxcIiBkZWNvZGluZz1cImFzeW5jXCIgY2xhc3M9XCJsYXp5bG9hZFwiIGRhdGEtc3JjPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2ltYWdlcy8/aW1hZ2VJZD04MTI0NjAzNyZhbXA7cGFub3k9MCZhbXA7cGFub3g9MCZhbXA7cGFub3c9MTAwJmFtcDtwYW5vaD0xMDAmYW1wO2hlaWdodHk9MCZhbXA7aGVpZ2h0eD0wJmFtcDtoZWlnaHRoPTEwMCZhbXA7aGVpZ2h0dz0xMDAmYW1wO3dpZHRoPTMyMCZhbXA7aGVpZ2h0PTE2MCZhbXA7Y29tcHJlc3Npb249NzBcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PGRpdiBjbGFzcz1cImZpZ3VyZS1sb2dvXCI+PGRpdiBjbGFzcz1cImxvZ29cIj48c3ZnIHhtbG5zPVwiaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmdcIiB3aWR0aD1cIjI0XCIgaGVpZ2h0PVwiMjRcIiB2aWV3Qm94PVwiMCAwIDI0IDI0XCIgZmlsbD1cIm5vbmVcIiBzdHJva2U9XCJjdXJyZW50Q29sb3JcIiBzdHJva2Utd2lkdGg9XCIzXCI+PGxpbmUgeDE9XCIxMlwiIHkxPVwiNVwiIHgyPVwiMTJcIiB5Mj1cIjE5XCI+PC9saW5lPjxsaW5lIHgxPVwiNVwiIHkxPVwiMTJcIiB4Mj1cIjE5XCIgeTI9XCIxMlwiPjwvbGluZT48L3N2Zz48L2Rpdj48L2Rpdj48L2ZpZ3VyZT48aGVhZGVyPjxoMyBjbGFzcz1cInhhdmllci1oZWFkbGluZSBoZWFkbGluZVwiPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAga05oR2dYIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+VXNraWZ0ZXQgYm86PC9zcGFuPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgamlHVlZqIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+VW5uZ8OlIHNtZWxsPC9zcGFuPjwvaDM+PC9oZWFkZXI+PC9hPjwvYXJ0aWNsZT48YXJ0aWNsZSBjbGFzcz1cInByZXZpZXcgY29sdW1ucyBzbWFsbC0xMiBtZWRpdW0tMTIgbGFyZ2UtMTJcIiBkYXRhLWN4ZW5zZV90YWc9XCJjZXJlYnJvXCIgZGF0YS1jeGVuY2Vfd2lkZ2V0PVwidmlkZW8tbWV0YXBvcC1tb2RlbFwiIGRhdGEtbGFiZWw9XCJ2aWRlb1wiIGRhdGEtZnJvbT1cInhhdmllclwiIGRhdGEtcmV2ZXJzZUltYWdlVGV4dE9yZGVyPVwiZmFsc2VcIj48YSB0YXJnZXQ9XCJfc2VsZlwiIGFyaWEtbGFiZWw9XCJIaXNzZXIgcMOlIHNlZyDCq2FsbGXCu1wiIGhyZWY9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vdmlkZW8vaGlzc2VyLXBhLXNlZy1hbGxlL2RmTnJqNW5wXCI+PGZpZ3VyZSBjbGFzcz1cInhfX3NjLTFhbjd2dTEtMCBmakp5dkVcIj48cGljdHVyZT48aW1nIGRhdGEtZGVmZXI9XCJ2aWV3XCIgdGl0bGU9XCJJbWFnZTogSGlzc2VyIHDDpSBzZWcgwqthbGxlwrtcIiBhbHQ9XCJJbWFnZTogSGlzc2VyIHDDpSBzZWcgwqthbGxlwrtcIiBkZWNvZGluZz1cImFzeW5jXCIgY2xhc3M9XCJsYXp5bG9hZFwiIGRhdGEtc3JjPVwiaHR0cHM6Ly9jZG4uandwbGF5ZXIuY29tL3RodW1icy9kZk5yajVucC03MjAuanBnXCIgc3JjPVwiZGF0YTppbWFnZS9wbmc7YmFzZTY0LGlWQk9SdzBLR2dvQUFBQU5TVWhFVWdBQUFCQUFBQUFKQ0FZQUFBQTdLcXd5QUFBQUYwbEVRVlI0Mm1OOCsrYjlmd1lLQU9Pb0FhTUdBQUVBNHVraUNVQ2JXMGNBQUFBQVNVVk9SSzVDWUlJPVwiIGxvYWRpbmc9XCJsYXp5XCIgZmV0Y2hQcmlvcml0eT1cImF1dG9cIi8+PC9waWN0dXJlPjxkaXYgY2xhc3M9XCJmaWd1cmUtbG9nb1wiPjxkaXYgY2xhc3M9XCJsb2dvXCI+PHN2ZyB4bWxucz1cImh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnXCIgd2lkdGg9XCIyNFwiIGhlaWdodD1cIjI0XCIgdmlld0JveD1cIjAgMCAyNCAyNFwiIGZpbGw9XCJjdXJyZW50Q29sb3JcIiBzdHJva2U9XCJjdXJyZW50Q29sb3JcIiBzdHJva2Utd2lkdGg9XCIyXCIgc3Ryb2tlLWxpbmVjYXA9XCJyb3VuZFwiIHN0cm9rZS1saW5lam9pbj1cInJvdW5kXCIgY2xhc3M9XCJmZWF0aGVyIGZlYXRoZXItcGxheVwiPjxwb2x5Z29uIHBvaW50cz1cIjUgMyAxOSAxMiA1IDIxIDUgM1wiPjwvcG9seWdvbj48L3N2Zz48L2Rpdj48L2Rpdj48L2ZpZ3VyZT48aGVhZGVyPjxoMyBjbGFzcz1cInhhdmllci1oZWFkbGluZSBoZWFkbGluZVwiPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgakdTVGR6IHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+SGlzc2VyIHDDpTwvc3Bhbj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIEx6Qm5XIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+c2VnIMKrYWxsZcK7PC9zcGFuPjwvaDM+PC9oZWFkZXI+PC9hPjwvYXJ0aWNsZT48L2Rpdj48L2Rpdj48L2Rpdj48ZGl2IGNsYXNzPVwicm93IHhyb3cgZmxleC1pbml0aWFsXCI+PGFydGljbGUgY2xhc3M9XCJwcmV2aWV3IGNvbHVtbnMgc21hbGwtNiBtZWRpdW0tNiBsYXJnZS02XCIgZGF0YS1jeGVuc2VfdGFnPVwiY2VyZWJyb1wiIGRhdGEtY3hlbmNlX3dpZGdldD1cImRhZ2JsYWRldC1tb2RlbC1mcm9udFwiIGRhdGEtbGFiZWw9XCJcIiBkYXRhLWZyb209XCJ4YXZpZXJcIiBkYXRhLXJldmVyc2VJbWFnZVRleHRPcmRlcj1cImZhbHNlXCI+PGEgdGFyZ2V0PVwiX3NlbGZcIiBhcmlhLWxhYmVsPVwiWWRteWtldFwiIGhyZWY9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vc3BvcnQveWRteWtldC84MTM2MzkzNlwiPjxmaWd1cmUgY2xhc3M9XCJ4X19zYy0xYW43dnUxLTAgZm5RREhiXCI+PHBpY3R1cmU+PGltZyBkYXRhLWRlZmVyPVwidmlld1wiIHRpdGxlPVwiSW1hZ2U6IFlkbXlrZXRcIiBhbHQ9XCJJbWFnZTogWWRteWtldFwiIGRlY29kaW5nPVwiYXN5bmNcIiBjbGFzcz1cImxhenlsb2FkXCIgZGF0YS1zcmM9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vaW1hZ2VzLz9pbWFnZUlkPTgxMzY0NzY3JmFtcDtwYW5veT00LjE2NjY2NjY2NjY2NjcmYW1wO3Bhbm94PTAmYW1wO3Bhbm93PTEwMCZhbXA7cGFub2g9NDkuMzA1NTU1NTU1NTU2JmFtcDtoZWlnaHR5PTAmYW1wO2hlaWdodHg9NTEuMTYyNzkwNjk3Njc0JmFtcDtoZWlnaHR3PTQxLjg2MDQ2NTExNjI3OSZhbXA7aGVpZ2h0aD0xMDAmYW1wO3dpZHRoPTQ4NSZhbXA7aGVpZ2h0PTI0MiZhbXA7Y29tcHJlc3Npb249NzBcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGJXenprVSB0aXRsZSBkeW5hbWljLXNpemluZ1wiPllkbXlrZXQ8L3NwYW4+PC9oMz48L2hlYWRlcj48L2E+PC9hcnRpY2xlPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTYgbWVkaXVtLTYgbGFyZ2UtNlwiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJkYWdibGFkZXQtbW9kZWwtZnJvbnRcIiBkYXRhLWxhYmVsPVwiXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIi0gVWJlaGFnZWxpZ1wiIGhyZWY9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8va2plbmRpcy91YmVoYWdlbGlnLzgxMzQzMjM3XCI+PGZpZ3VyZSBjbGFzcz1cInhfX3NjLTFhbjd2dTEtMCBiQ0JuTHZcIj48cGljdHVyZT48aW1nIGRhdGEtZGVmZXI9XCJ2aWV3XCIgdGl0bGU9XCJJbWFnZTogLSBVYmVoYWdlbGlnXCIgYWx0PVwiSW1hZ2U6IC0gVWJlaGFnZWxpZ1wiIGRlY29kaW5nPVwiYXN5bmNcIiBjbGFzcz1cImxhenlsb2FkXCIgZGF0YS1zcmM9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vaW1hZ2VzLz9pbWFnZUlkPTgxMzQ0NjY4JmFtcDtwYW5veT05LjQ1OTQ1OTQ1OTQ1OTUmYW1wO3Bhbm94PTAuMjQzOTAyNDM5MDI0MzkmYW1wO3Bhbm93PTEwMC4yNDM5MDI0MzkwMiZhbXA7cGFub2g9NDYuOTU5NDU5NDU5NDU5JmFtcDtoZWlnaHR3PTQzLjk2OTg0OTI0NjIzMSZhbXA7aGVpZ2h0aD0xMDAuMzQ5NjUwMzQ5NjUmYW1wO2hlaWdodHk9MC4zNDk2NTAzNDk2NTAzNSZhbXA7aGVpZ2h0eD0yNi4xMzA2NTMyNjYzMzImYW1wO3dpZHRoPTQ4NSZhbXA7aGVpZ2h0PTI3OCZhbXA7Y29tcHJlc3Npb249NzBcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGp0Q1h2QSB0aXRsZSBkeW5hbWljLXNpemluZ1wiPi0gVWJlaGFnZWxpZzwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PC9kaXY+PGRpdiBjbGFzcz1cInJvdyB4cm93IGZsZXgtaW5pdGlhbFwiPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTQgbWVkaXVtLTQgbGFyZ2UtNFwiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJ2aWRlby1tZXRhcG9wLW1vZGVsXCIgZGF0YS1sYWJlbD1cInZpZGVvXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIlNhdHRlIG5ha2Vua3JhdlwiIGhyZWY9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vdmlkZW8vc2F0dGUtbmFrZW5rcmF2L0pzcFBLVDNXXCI+PGZpZ3VyZSBjbGFzcz1cInhfX3NjLTFhbjd2dTEtMCBoTHFvaGRcIj48cGljdHVyZT48aW1nIGRhdGEtZGVmZXI9XCJ2aWV3XCIgdGl0bGU9XCJJbWFnZTogU2F0dGUgbmFrZW5rcmF2XCIgYWx0PVwiSW1hZ2U6IFNhdHRlIG5ha2Vua3JhdlwiIGRlY29kaW5nPVwiYXN5bmNcIiBjbGFzcz1cImxhenlsb2FkXCIgZGF0YS1zcmM9XCJodHRwczovL2Nkbi5qd3BsYXllci5jb20vdGh1bWJzL0pzcFBLVDNXLTcyMC5qcGdcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PGRpdiBjbGFzcz1cImZpZ3VyZS1sb2dvXCI+PGRpdiBjbGFzcz1cImxvZ29cIj48c3ZnIHhtbG5zPVwiaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmdcIiB3aWR0aD1cIjI0XCIgaGVpZ2h0PVwiMjRcIiB2aWV3Qm94PVwiMCAwIDI0IDI0XCIgZmlsbD1cImN1cnJlbnRDb2xvclwiIHN0cm9rZT1cImN1cnJlbnRDb2xvclwiIHN0cm9rZS13aWR0aD1cIjJcIiBzdHJva2UtbGluZWNhcD1cInJvdW5kXCIgc3Ryb2tlLWxpbmVqb2luPVwicm91bmRcIiBjbGFzcz1cImZlYXRoZXIgZmVhdGhlci1wbGF5XCI+PHBvbHlnb24gcG9pbnRzPVwiNSAzIDE5IDEyIDUgMjEgNSAzXCI+PC9wb2x5Z29uPjwvc3ZnPjwvZGl2PjwvZGl2PjwvZmlndXJlPjxoZWFkZXI+PGgzIGNsYXNzPVwieGF2aWVyLWhlYWRsaW5lIGhlYWRsaW5lXCI+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBmTkRoRHkgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5TYXR0ZSBuYWtlbmtyYXY8L3NwYW4+PC9oMz48L2hlYWRlcj48L2E+PC9hcnRpY2xlPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTQgbWVkaXVtLTQgbGFyZ2UtNFwiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJwbHVzcy1tb2RlbC1mcm9udFwiIGRhdGEtbGFiZWw9XCJwbHVzc1wiIGRhdGEtZnJvbT1cInhhdmllclwiIGRhdGEtcmV2ZXJzZUltYWdlVGV4dE9yZGVyPVwiZmFsc2VcIj48YSB0YXJnZXQ9XCJfc2VsZlwiIGFyaWEtbGFiZWw9XCJPbSBhbmdzdGVuOiAtIFRyb2RkZSBqZWcgc2t1bGxlIGTDuFwiIGhyZWY9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8va2plbmRpcy9vbS1hbmdzdGVuLXRyb2RkZS1qZWctc2t1bGxlLWRvLzgxMTc0NDgwXCI+PGZpZ3VyZSBjbGFzcz1cInhfX3NjLTFhbjd2dTEtMCBpZEtDSHNcIj48cGljdHVyZT48aW1nIGRhdGEtZGVmZXI9XCJ2aWV3XCIgdGl0bGU9XCJJbWFnZTogT20gYW5nc3RlbjogLSBUcm9kZGUgamVnIHNrdWxsZSBkw7hcIiBhbHQ9XCJJbWFnZTogT20gYW5nc3RlbjogLSBUcm9kZGUgamVnIHNrdWxsZSBkw7hcIiBkZWNvZGluZz1cImFzeW5jXCIgY2xhc3M9XCJsYXp5bG9hZFwiIGRhdGEtc3JjPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2ltYWdlcy8/aW1hZ2VJZD04MTE3OTUzNCZhbXA7cGFub3k9Ny4wNDIyNTM1MjExMjY4JmFtcDtwYW5veD0wJmFtcDtwYW5vdz0xMDAmYW1wO3Bhbm9oPTUwJmFtcDtoZWlnaHR3PTQxLjk1MjIzMzY0NDg2JmFtcDtoZWlnaHRoPTk5Ljg0Nzc5NDUyMDU0OCZhbXA7aGVpZ2h0eT0wJmFtcDtoZWlnaHR4PTIzLjM2NDQ4NTk4MTMwOCZhbXA7d2lkdGg9MzIwJmFtcDtoZWlnaHQ9MTYzJmFtcDtjb21wcmVzc2lvbj03MFwiIHNyYz1cImRhdGE6aW1hZ2UvcG5nO2Jhc2U2NCxpVkJPUncwS0dnb0FBQUFOU1VoRVVnQUFBQkFBQUFBSkNBWUFBQUE3S3F3eUFBQUFGMGxFUVZSNDJtTjgrK2I5ZndZS0FPT29BYU1HQUFFQTR1a2lDVUNiVzBjQUFBQUFTVVZPUks1Q1lJST1cIiBsb2FkaW5nPVwibGF6eVwiIGZldGNoUHJpb3JpdHk9XCJhdXRvXCIvPjwvcGljdHVyZT48ZGl2IGNsYXNzPVwiZmlndXJlLWxvZ29cIj48ZGl2IGNsYXNzPVwibG9nb1wiPjxzdmcgeG1sbnM9XCJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2Z1wiIHdpZHRoPVwiMjRcIiBoZWlnaHQ9XCIyNFwiIHZpZXdCb3g9XCIwIDAgMjQgMjRcIiBmaWxsPVwibm9uZVwiIHN0cm9rZT1cImN1cnJlbnRDb2xvclwiIHN0cm9rZS13aWR0aD1cIjNcIj48bGluZSB4MT1cIjEyXCIgeTE9XCI1XCIgeDI9XCIxMlwiIHkyPVwiMTlcIj48L2xpbmU+PGxpbmUgeDE9XCI1XCIgeTE9XCIxMlwiIHgyPVwiMTlcIiB5Mj1cIjEyXCI+PC9saW5lPjwvc3ZnPjwvZGl2PjwvZGl2PjwvZmlndXJlPjxoZWFkZXI+PGgzIGNsYXNzPVwieGF2aWVyLWhlYWRsaW5lIGhlYWRsaW5lXCI+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBkUG9lRm8gdGl0bGUgZHluYW1pYy1zaXppbmdcIj5PbSBhbmdzdGVuOiAtIFRyb2RkZTwvc3Bhbj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGJ3R1FydCB0aXRsZSBkeW5hbWljLXNpemluZ1wiPmplZyBza3VsbGUgZMO4PC9zcGFuPjwvaDM+PC9oZWFkZXI+PC9hPjwvYXJ0aWNsZT48ZGl2IGlkPVwiYXBvcy1tZWRpdW0tcmVjdGFuZ2xlNlwiIGNsYXNzPVwiYWR1bml0LXdyYXBwZXIgY29sdW1ucyBzbWFsbC00IG1lZGl1bS00IGxhcmdlLTQgdHJhY2stZWxlbWVudCAgXCIgZGF0YS1mcm9tPVwieGF2aWVyXCI+PGRpdiBpZD1cImFkLW1lZGl1bS1yZWN0YW5nbGU2XCIgY2xhc3M9XCJhZHVuaXQgR29vZ2xlQWN0aXZlVmlld0VsZW1lbnQgc21hbGwtMzIweDI1MCBtZWRpdW0tMzIweDI1MCBsYXJnZS0zMjB4MjUwXCIgaXRlbXNjb3BlPVwiXCIgaXRlbVR5cGU9XCJodHRwczovL3NjaGVtYS5vcmcvV1BBZEJsb2NrXCIgZGF0YS1zaXplcz1cIltbMzIwLDI1MF0sWzMwMCwyNTBdLCZxdW90O2ZsdWlkJnF1b3Q7XVwiIGRhdGEtc2xvdD1cIi84NTc4L2RhZ2JsYWRldC5uby9mb3JzaWRlXCIgZGF0YS1sb2FkLW9uPVwidmlld1wiIGRhdGEtY29sbGFwc2U9XCJmYWxzZVwiIGRhdGEtZXhwYW5kPVwiZmFsc2VcIiBkYXRhLW91dC1vZi1wYWdlPVwiZmFsc2VcIiBqc29uPVwieyZxdW90O3RhcmdldGluZyZxdW90OzogeyZxdW90O3BvcyZxdW90OzomcXVvdDttZWRpdW0tcmVjdGFuZ2xlNiZxdW90OywmcXVvdDtwbGF0Zm9ybSZxdW90OzomcXVvdDt3b2x2ZXJpbmUmcXVvdDt9fVwiPjwvZGl2PjwvZGl2PjwvZGl2PjxkaXYgY2xhc3M9XCJyb3cgeHJvdyBmbGV4LWluaXRpYWxcIj48YXJ0aWNsZSBjbGFzcz1cInByZXZpZXcgY29sdW1ucyBzbWFsbC03IG1lZGl1bS03IGxhcmdlLTdcIiBkYXRhLWN4ZW5zZV90YWc9XCJjZXJlYnJvXCIgZGF0YS1jeGVuY2Vfd2lkZ2V0PVwiZGFnYmxhZGV0LW1vZGVsLWZyb250XCIgZGF0YS1sYWJlbD1cIlwiIGRhdGEtZnJvbT1cInhhdmllclwiIGRhdGEtcmV2ZXJzZUltYWdlVGV4dE9yZGVyPVwiZmFsc2VcIj48YSB0YXJnZXQ9XCJfc2VsZlwiIGFyaWEtbGFiZWw9XCJLbGFyIGJlc2tqZWQ6IC0gSWRpb3RlclwiIGhyZWY9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vc3BvcnQva2xhci1iZXNramVkLWlkaW90ZXIvODEzNTkxODlcIj48ZmlndXJlIGNsYXNzPVwieF9fc2MtMWFuN3Z1MS0wIGt2aUFyeVwiPjxwaWN0dXJlPjxpbWcgZGF0YS1kZWZlcj1cInZpZXdcIiB0aXRsZT1cIkltYWdlOiBLbGFyIGJlc2tqZWQ6IC0gSWRpb3RlclwiIGFsdD1cIkltYWdlOiBLbGFyIGJlc2tqZWQ6IC0gSWRpb3RlclwiIGRlY29kaW5nPVwiYXN5bmNcIiBjbGFzcz1cImxhenlsb2FkXCIgZGF0YS1zcmM9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vaW1hZ2VzLz9pbWFnZUlkPTgxMzU5MjMzJmFtcDtwYW5veT0xMi4xNDI4NTcxNDI4NTcmYW1wO3Bhbm94PTAmYW1wO3Bhbm93PTEwMCZhbXA7cGFub2g9NTAuNzE0Mjg1NzE0Mjg2JmFtcDtoZWlnaHR5PTAmYW1wO2hlaWdodHc9NDAuNzIzOTgxOTAwNDUyJmFtcDtoZWlnaHRoPTEwMCZhbXA7aGVpZ2h0eD0xOS40NTcwMTM1NzQ2NjEmYW1wO3dpZHRoPTU2NyZhbXA7aGVpZ2h0PTI4MyZhbXA7Y29tcHJlc3Npb249NzBcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGhid2lrdCB0aXRsZSBkeW5hbWljLXNpemluZ1wiPktsYXIgYmVza2plZDo8L3NwYW4+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBGU3NPTyB0aXRsZSBkeW5hbWljLXNpemluZ1wiPi0gSWRpb3Rlcjwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PGFydGljbGUgY2xhc3M9XCJwcmV2aWV3IGNvbHVtbnMgc21hbGwtNSBtZWRpdW0tNSBsYXJnZS01XCIgZGF0YS1jeGVuc2VfdGFnPVwiY2VyZWJyb1wiIGRhdGEtY3hlbmNlX3dpZGdldD1cImRhZ2JsYWRldC1tb2RlbC1mcm9udFwiIGRhdGEtbGFiZWw9XCJcIiBkYXRhLWZyb209XCJ4YXZpZXJcIiBkYXRhLXJldmVyc2VJbWFnZVRleHRPcmRlcj1cImZhbHNlXCI+PGEgdGFyZ2V0PVwiX3NlbGZcIiBhcmlhLWxhYmVsPVwiLSBNaW5uZXIgb20gQUtQXCIgaHJlZj1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9ueWhldGVyL21pbm5lci1vbS1ha3AvODEzNTQyMjNcIj48ZmlndXJlIGNsYXNzPVwieF9fc2MtMWFuN3Z1MS0wIGZvUVJLWlwiPjxwaWN0dXJlPjxpbWcgZGF0YS1kZWZlcj1cInZpZXdcIiB0aXRsZT1cIkltYWdlOiAtIE1pbm5lciBvbSBBS1BcIiBhbHQ9XCJJbWFnZTogLSBNaW5uZXIgb20gQUtQXCIgZGVjb2Rpbmc9XCJhc3luY1wiIGNsYXNzPVwibGF6eWxvYWRcIiBkYXRhLXNyYz1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9pbWFnZXMvP2ltYWdlSWQ9ODEzNTczMjUmYW1wO3Bhbm94PTAmYW1wO3Bhbm95PTEwLjk3NTYwOTc1NjA5OCZhbXA7cGFub3c9OTkuODQ4NDg0NTQ1NDU1JmFtcDtwYW5vaD00NS41Mjg0NTQ4NzgwNDkmYW1wO2hlaWdodHk9MCZhbXA7aGVpZ2h0eD0wJmFtcDtoZWlnaHR3PTEwMCZhbXA7aGVpZ2h0aD0xMDAmYW1wO3dpZHRoPTQwMiZhbXA7aGVpZ2h0PTQ4MSZhbXA7Y29tcHJlc3Npb249NzBcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGVwb0p6RCB0aXRsZSBkeW5hbWljLXNpemluZ1wiPi0gTWlubmVyIG9tIEFLUDwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PC9kaXY+PGRpdiBjbGFzcz1cInJvdyB4cm93IGZsZXgtaW5pdGlhbFwiPjxkaXYgaWQ9XCJhcG9zLW5ldGJvYXJkOFwiIGNsYXNzPVwiYWR1bml0LXdyYXBwZXIgY29sdW1ucyBzbWFsbC04IG1lZGl1bS04IGxhcmdlLTggdHJhY2stZWxlbWVudCAgXCIgZGF0YS1mcm9tPVwieGF2aWVyXCI+PGRpdiBpZD1cImFkLW5ldGJvYXJkOFwiIGNsYXNzPVwiYWR1bml0IEdvb2dsZUFjdGl2ZVZpZXdFbGVtZW50IHNtYWxsLTU4MHg1MDAgbWVkaXVtLTU4MHg1MDAgbGFyZ2UtNTgweDUwMFwiIGl0ZW1zY29wZT1cIlwiIGl0ZW1UeXBlPVwiaHR0cHM6Ly9zY2hlbWEub3JnL1dQQWRCbG9ja1wiIGRhdGEtc2l6ZXM9XCJbWzU4MCw0MDBdLFs1ODAsNTAwXSwmcXVvdDtmbHVpZCZxdW90O11cIiBkYXRhLXNsb3Q9XCIvODU3OC9kYWdibGFkZXQubm8vZm9yc2lkZVwiIGRhdGEtbG9hZC1vbj1cInZpZXdcIiBkYXRhLWNvbGxhcHNlPVwiZmFsc2VcIiBkYXRhLWV4cGFuZD1cImZhbHNlXCIgZGF0YS1vdXQtb2YtcGFnZT1cImZhbHNlXCIganNvbj1cInsmcXVvdDt0YXJnZXRpbmcmcXVvdDs6IHsmcXVvdDtwb3MmcXVvdDs6JnF1b3Q7bmV0Ym9hcmQ4JnF1b3Q7LCZxdW90O3BsYXRmb3JtJnF1b3Q7OiZxdW90O3dvbHZlcmluZSZxdW90O319XCI+PC9kaXY+PC9kaXY+PGRpdiBjbGFzcz1cInhhdmllciBjb2x1bW5zIHNtYWxsLTQgbWVkaXVtLTQgbGFyZ2UtNFwiPjxkaXYgY2xhc3M9XCJyb3cgeHJvdyBmbGV4LWNvbHVtblwiPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTEyIG1lZGl1bS0xMiBsYXJnZS0xMlwiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJwbHVzcy1tb2RlbC1mcm9udFwiIGRhdGEtbGFiZWw9XCJwbHVzc1wiIGRhdGEtZnJvbT1cInhhdmllclwiIGRhdGEtcmV2ZXJzZUltYWdlVGV4dE9yZGVyPVwiZmFsc2VcIj48YSB0YXJnZXQ9XCJfc2VsZlwiIGFyaWEtbGFiZWw9XCJIYW5uZSAoMzApIGt1dHRldCBkZXR0ZTogS3ZpdHQgZWtzZW1cIiBocmVmPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL3RlbWEvaGFubmUtMzAta3V0dGV0LWRldHRlLWt2aXR0LWVrc2VtLzgxMjQ2OTU4XCI+PGZpZ3VyZSBjbGFzcz1cInhfX3NjLTFhbjd2dTEtMCBmakp5dkVcIj48cGljdHVyZT48aW1nIGRhdGEtZGVmZXI9XCJ2aWV3XCIgdGl0bGU9XCJJbWFnZTogSGFubmUgKDMwKSBrdXR0ZXQgZGV0dGU6IEt2aXR0IGVrc2VtXCIgYWx0PVwiSW1hZ2U6IEhhbm5lICgzMCkga3V0dGV0IGRldHRlOiBLdml0dCBla3NlbVwiIGRlY29kaW5nPVwiYXN5bmNcIiBjbGFzcz1cImxhenlsb2FkXCIgZGF0YS1zcmM9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vaW1hZ2VzLz9pbWFnZUlkPTgxMjQ2OTc5JmFtcDtwYW5veD0yNi4xOTA0NzYxOTA0NzYmYW1wO3Bhbm95PTYuNTkzNDA2NTkzNDA2NiZhbXA7cGFub3c9NDUuNDU0NTQ1NDU0NTQ1JmFtcDtwYW5vaD03OC4wMjE5NzgwMjE5NzgmYW1wO2hlaWdodHc9MTIuMjc4MzA4MzIxOTY1JmFtcDtoZWlnaHRoPTEwMCZhbXA7aGVpZ2h0eT0wJmFtcDtoZWlnaHR4PTMzLjY4MjgzMDkzMDUzNyZhbXA7d2lkdGg9MzIwJmFtcDtoZWlnaHQ9MTYwJmFtcDtjb21wcmVzc2lvbj03MFwiIHNyYz1cImRhdGE6aW1hZ2UvcG5nO2Jhc2U2NCxpVkJPUncwS0dnb0FBQUFOU1VoRVVnQUFBQkFBQUFBSkNBWUFBQUE3S3F3eUFBQUFGMGxFUVZSNDJtTjgrK2I5ZndZS0FPT29BYU1HQUFFQTR1a2lDVUNiVzBjQUFBQUFTVVZPUks1Q1lJST1cIiBsb2FkaW5nPVwibGF6eVwiIGZldGNoUHJpb3JpdHk9XCJhdXRvXCIvPjwvcGljdHVyZT48ZGl2IGNsYXNzPVwiZmlndXJlLWxvZ29cIj48ZGl2IGNsYXNzPVwibG9nb1wiPjxzdmcgeG1sbnM9XCJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2Z1wiIHdpZHRoPVwiMjRcIiBoZWlnaHQ9XCIyNFwiIHZpZXdCb3g9XCIwIDAgMjQgMjRcIiBmaWxsPVwibm9uZVwiIHN0cm9rZT1cImN1cnJlbnRDb2xvclwiIHN0cm9rZS13aWR0aD1cIjNcIj48bGluZSB4MT1cIjEyXCIgeTE9XCI1XCIgeDI9XCIxMlwiIHkyPVwiMTlcIj48L2xpbmU+PGxpbmUgeDE9XCI1XCIgeTE9XCIxMlwiIHgyPVwiMTlcIiB5Mj1cIjEyXCI+PC9saW5lPjwvc3ZnPjwvZGl2PjwvZGl2PjwvZmlndXJlPjxoZWFkZXI+PGgzIGNsYXNzPVwieGF2aWVyLWhlYWRsaW5lIGhlYWRsaW5lXCI+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBrVkpOUFIgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5IYW5uZSAoMzApIGt1dHRldDwvc3Bhbj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGlZZ0J2QSB0aXRsZSBkeW5hbWljLXNpemluZ1wiPmRldHRlOiBLdml0dCBla3NlbTwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PGFydGljbGUgY2xhc3M9XCJwcmV2aWV3IGNvbHVtbnMgc21hbGwtMTIgbWVkaXVtLTEyIGxhcmdlLTEyXCIgZGF0YS1jeGVuc2VfdGFnPVwiY2VyZWJyb1wiIGRhdGEtY3hlbmNlX3dpZGdldD1cInZpZGVvLW1ldGFwb3AtbW9kZWxcIiBkYXRhLWxhYmVsPVwidmlkZW9cIiBkYXRhLWZyb209XCJ4YXZpZXJcIiBkYXRhLXJldmVyc2VJbWFnZVRleHRPcmRlcj1cImZhbHNlXCI+PGEgdGFyZ2V0PVwiX3NlbGZcIiBhcmlhLWxhYmVsPVwiTnkgZmxhdXNlIGZyYSBwcmVzaWRlbnRlblwiIGhyZWY9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vdmlkZW8vbnktZmxhdXNlLWZyYS1wcmVzaWRlbnRlbi94QjZIa2NSNFwiPjxmaWd1cmUgY2xhc3M9XCJ4X19zYy0xYW43dnUxLTAgZmpKeXZFXCI+PHBpY3R1cmU+PGltZyBkYXRhLWRlZmVyPVwidmlld1wiIHRpdGxlPVwiSW1hZ2U6IE55IGZsYXVzZSBmcmEgcHJlc2lkZW50ZW5cIiBhbHQ9XCJJbWFnZTogTnkgZmxhdXNlIGZyYSBwcmVzaWRlbnRlblwiIGRlY29kaW5nPVwiYXN5bmNcIiBjbGFzcz1cImxhenlsb2FkXCIgZGF0YS1zcmM9XCJodHRwczovL2Nkbi5qd3BsYXllci5jb20vdGh1bWJzL3hCNkhrY1I0LTcyMC5qcGdcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PGRpdiBjbGFzcz1cImZpZ3VyZS1sb2dvXCI+PGRpdiBjbGFzcz1cImxvZ29cIj48c3ZnIHhtbG5zPVwiaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmdcIiB3aWR0aD1cIjI0XCIgaGVpZ2h0PVwiMjRcIiB2aWV3Qm94PVwiMCAwIDI0IDI0XCIgZmlsbD1cImN1cnJlbnRDb2xvclwiIHN0cm9rZT1cImN1cnJlbnRDb2xvclwiIHN0cm9rZS13aWR0aD1cIjJcIiBzdHJva2UtbGluZWNhcD1cInJvdW5kXCIgc3Ryb2tlLWxpbmVqb2luPVwicm91bmRcIiBjbGFzcz1cImZlYXRoZXIgZmVhdGhlci1wbGF5XCI+PHBvbHlnb24gcG9pbnRzPVwiNSAzIDE5IDEyIDUgMjEgNSAzXCI+PC9wb2x5Z29uPjwvc3ZnPjwvZGl2PjwvZGl2PjwvZmlndXJlPjxoZWFkZXI+PGgzIGNsYXNzPVwieGF2aWVyLWhlYWRsaW5lIGhlYWRsaW5lXCI+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBid0dRcnQgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5OeSBmbGF1c2UgZnJhPC9zcGFuPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgZklleUN4IHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+cHJlc2lkZW50ZW48L3NwYW4+PC9oMz48L2hlYWRlcj48L2E+PC9hcnRpY2xlPjwvZGl2PjwvZGl2PjwvZGl2PjxkaXYgY2xhc3M9XCJyb3cgeHJvdyBmbGV4LWluaXRpYWxcIj48YXJ0aWNsZSBjbGFzcz1cInByZXZpZXcgY29sdW1ucyBzbWFsbC00IG1lZGl1bS00IGxhcmdlLTRcIiBkYXRhLWN4ZW5zZV90YWc9XCJjZXJlYnJvXCIgZGF0YS1jeGVuY2Vfd2lkZ2V0PVwidmlkZW8tbWV0YXBvcC1tb2RlbFwiIGRhdGEtbGFiZWw9XCJ2aWRlb1wiIGRhdGEtZnJvbT1cInhhdmllclwiIGRhdGEtcmV2ZXJzZUltYWdlVGV4dE9yZGVyPVwiZmFsc2VcIj48YSB0YXJnZXQ9XCJfc2VsZlwiIGFyaWEtbGFiZWw9XCJUcm9yIGlra2Ugc2luZSBlZ25lIMO4eW5lXCIgaHJlZj1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby92aWRlby90cm9yLWlra2Utc2luZS1lZ25lLW95bmUvTllvWTB6Y3pcIj48ZmlndXJlIGNsYXNzPVwieF9fc2MtMWFuN3Z1MS0wIGZqSnl2RVwiPjxwaWN0dXJlPjxpbWcgZGF0YS1kZWZlcj1cInZpZXdcIiB0aXRsZT1cIkltYWdlOiBUcm9yIGlra2Ugc2luZSBlZ25lIMO4eW5lXCIgYWx0PVwiSW1hZ2U6IFRyb3IgaWtrZSBzaW5lIGVnbmUgw7h5bmVcIiBkZWNvZGluZz1cImFzeW5jXCIgY2xhc3M9XCJsYXp5bG9hZFwiIGRhdGEtc3JjPVwiaHR0cHM6Ly9jZG4uandwbGF5ZXIuY29tL3RodW1icy9OWW9ZMHpjei03MjAuanBnXCIgc3JjPVwiZGF0YTppbWFnZS9wbmc7YmFzZTY0LGlWQk9SdzBLR2dvQUFBQU5TVWhFVWdBQUFCQUFBQUFKQ0FZQUFBQTdLcXd5QUFBQUYwbEVRVlI0Mm1OOCsrYjlmd1lLQU9Pb0FhTUdBQUVBNHVraUNVQ2JXMGNBQUFBQVNVVk9SSzVDWUlJPVwiIGxvYWRpbmc9XCJsYXp5XCIgZmV0Y2hQcmlvcml0eT1cImF1dG9cIi8+PC9waWN0dXJlPjxkaXYgY2xhc3M9XCJmaWd1cmUtbG9nb1wiPjxkaXYgY2xhc3M9XCJsb2dvXCI+PHN2ZyB4bWxucz1cImh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnXCIgd2lkdGg9XCIyNFwiIGhlaWdodD1cIjI0XCIgdmlld0JveD1cIjAgMCAyNCAyNFwiIGZpbGw9XCJjdXJyZW50Q29sb3JcIiBzdHJva2U9XCJjdXJyZW50Q29sb3JcIiBzdHJva2Utd2lkdGg9XCIyXCIgc3Ryb2tlLWxpbmVjYXA9XCJyb3VuZFwiIHN0cm9rZS1saW5lam9pbj1cInJvdW5kXCIgY2xhc3M9XCJmZWF0aGVyIGZlYXRoZXItcGxheVwiPjxwb2x5Z29uIHBvaW50cz1cIjUgMyAxOSAxMiA1IDIxIDUgM1wiPjwvcG9seWdvbj48L3N2Zz48L2Rpdj48L2Rpdj48L2ZpZ3VyZT48aGVhZGVyPjxoMyBjbGFzcz1cInhhdmllci1oZWFkbGluZSBoZWFkbGluZVwiPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgYmtna2RwIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+VHJvciBpa2tlPC9zcGFuPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgaUZsRW1LIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+c2luZSBlZ25lIMO4eW5lPC9zcGFuPjwvaDM+PC9oZWFkZXI+PC9hPjwvYXJ0aWNsZT48YXJ0aWNsZSBjbGFzcz1cInByZXZpZXcgY29sdW1ucyBzbWFsbC00IG1lZGl1bS00IGxhcmdlLTRcIiBkYXRhLWN4ZW5zZV90YWc9XCJjZXJlYnJvXCIgZGF0YS1jeGVuY2Vfd2lkZ2V0PVwicGx1c3MtbW9kZWwtZnJvbnRcIiBkYXRhLWxhYmVsPVwicGx1c3NcIiBkYXRhLWZyb209XCJ4YXZpZXJcIiBkYXRhLXJldmVyc2VJbWFnZVRleHRPcmRlcj1cImZhbHNlXCI+PGEgdGFyZ2V0PVwiX3NlbGZcIiBhcmlhLWxhYmVsPVwiVXRybyBww6UgdmVubmlubmV0dXI6IEhlciBza2plciBkZXRcIiBocmVmPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL3RlbWEvdXRyby1wYS12ZW5uaW5uZXR1cmhlci1za2plci1kZXQvODExNDk3MzRcIj48ZmlndXJlIGNsYXNzPVwieF9fc2MtMWFuN3Z1MS0wIGtMWlV5ZlwiPjxwaWN0dXJlPjxpbWcgZGF0YS1kZWZlcj1cInZpZXdcIiB0aXRsZT1cIkltYWdlOiBVdHJvIHDDpSB2ZW5uaW5uZXR1cjogSGVyIHNramVyIGRldFwiIGFsdD1cIkltYWdlOiBVdHJvIHDDpSB2ZW5uaW5uZXR1cjogSGVyIHNramVyIGRldFwiIGRlY29kaW5nPVwiYXN5bmNcIiBjbGFzcz1cImxhenlsb2FkXCIgZGF0YS1zcmM9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vaW1hZ2VzLz9pbWFnZUlkPTgxMTcxNTI1JmFtcDtwYW5veT0wJmFtcDtwYW5veD0wLjE2MDI1NjczMDc2OTIzJmFtcDtwYW5vdz0xMDAuMTYwMjU2NzMwNzcmYW1wO3Bhbm9oPTUxLjMxODk0NTMyMzc0MSZhbXA7aGVpZ2h0eT0wLjIyODMxMDk1ODkwNDExJmFtcDtoZWlnaHR3PTQwLjYwNjA2MDkwOTA5MSZhbXA7aGVpZ2h0aD0xMDAuMjI4MzEwOTU4OSZhbXA7aGVpZ2h0eD0yNy43MjcyNzI3MjcyNzMmYW1wO3dpZHRoPTMyMCZhbXA7aGVpZ2h0PTE5NSZhbXA7Y29tcHJlc3Npb249NzBcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PGRpdiBjbGFzcz1cImZpZ3VyZS1sb2dvXCI+PGRpdiBjbGFzcz1cImxvZ29cIj48c3ZnIHhtbG5zPVwiaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmdcIiB3aWR0aD1cIjI0XCIgaGVpZ2h0PVwiMjRcIiB2aWV3Qm94PVwiMCAwIDI0IDI0XCIgZmlsbD1cIm5vbmVcIiBzdHJva2U9XCJjdXJyZW50Q29sb3JcIiBzdHJva2Utd2lkdGg9XCIzXCI+PGxpbmUgeDE9XCIxMlwiIHkxPVwiNVwiIHgyPVwiMTJcIiB5Mj1cIjE5XCI+PC9saW5lPjxsaW5lIHgxPVwiNVwiIHkxPVwiMTJcIiB4Mj1cIjE5XCIgeTI9XCIxMlwiPjwvbGluZT48L3N2Zz48L2Rpdj48L2Rpdj48L2ZpZ3VyZT48aGVhZGVyPjxoMyBjbGFzcz1cInhhdmllci1oZWFkbGluZSBoZWFkbGluZVwiPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgaU5IeWllIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+VXRybyBww6UgdmVubmlubmV0dXI6PC9zcGFuPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgYndHUXJ0IHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+SGVyIHNramVyIGRldDwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PGRpdiBpZD1cImFwb3MtbWVkaXVtLXJlY3RhbmdsZTdcIiBjbGFzcz1cImFkdW5pdC13cmFwcGVyIGNvbHVtbnMgc21hbGwtNCBtZWRpdW0tNCBsYXJnZS00IHRyYWNrLWVsZW1lbnQgIFwiIGRhdGEtZnJvbT1cInhhdmllclwiPjxkaXYgaWQ9XCJhZC1tZWRpdW0tcmVjdGFuZ2xlN1wiIGNsYXNzPVwiYWR1bml0IEdvb2dsZUFjdGl2ZVZpZXdFbGVtZW50IHNtYWxsLTMyMHgyNTAgbWVkaXVtLTMyMHgyNTAgbGFyZ2UtMzIweDI1MFwiIGl0ZW1zY29wZT1cIlwiIGl0ZW1UeXBlPVwiaHR0cHM6Ly9zY2hlbWEub3JnL1dQQWRCbG9ja1wiIGRhdGEtc2l6ZXM9XCJbWzMyMCwyNTBdLFszMDAsMjUwXSwmcXVvdDtmbHVpZCZxdW90O11cIiBkYXRhLXNsb3Q9XCIvODU3OC9kYWdibGFkZXQubm8vZm9yc2lkZVwiIGRhdGEtbG9hZC1vbj1cInZpZXdcIiBkYXRhLWNvbGxhcHNlPVwiZmFsc2VcIiBkYXRhLWV4cGFuZD1cImZhbHNlXCIgZGF0YS1vdXQtb2YtcGFnZT1cImZhbHNlXCIganNvbj1cInsmcXVvdDt0YXJnZXRpbmcmcXVvdDs6IHsmcXVvdDtwb3MmcXVvdDs6JnF1b3Q7bWVkaXVtLXJlY3RhbmdsZTcmcXVvdDssJnF1b3Q7cGxhdGZvcm0mcXVvdDs6JnF1b3Q7d29sdmVyaW5lJnF1b3Q7fX1cIj48L2Rpdj48L2Rpdj48L2Rpdj48ZGl2IGNsYXNzPVwicm93IHhyb3cgZmxleC1pbml0aWFsXCI+PGFydGljbGUgY2xhc3M9XCJwcmV2aWV3IGNvbHVtbnMgc21hbGwtNiBtZWRpdW0tNiBsYXJnZS02XCIgZGF0YS1jeGVuc2VfdGFnPVwiY2VyZWJyb1wiIGRhdGEtY3hlbmNlX3dpZGdldD1cImRhZ2JsYWRldC1tb2RlbC1mcm9udFwiIGRhdGEtbGFiZWw9XCJcIiBkYXRhLWZyb209XCJ4YXZpZXJcIiBkYXRhLXJldmVyc2VJbWFnZVRleHRPcmRlcj1cImZhbHNlXCI+PGEgdGFyZ2V0PVwiX3NlbGZcIiBhcmlhLWxhYmVsPVwiLSBTdmFyIHDDpSB2ZXN0bGlnZSB0cnVzbGVyXCIgaHJlZj1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9ueWhldGVyL3N2YXItcGEtdmVzdGxpZ2UtdHJ1c2xlci84MTM2MTIzNlwiPjxmaWd1cmUgY2xhc3M9XCJ4X19zYy0xYW43dnUxLTAgaXhoQU14XCI+PHBpY3R1cmU+PGltZyBkYXRhLWRlZmVyPVwidmlld1wiIHRpdGxlPVwiSW1hZ2U6IC0gU3ZhciBww6UgdmVzdGxpZ2UgdHJ1c2xlclwiIGFsdD1cIkltYWdlOiAtIFN2YXIgcMOlIHZlc3RsaWdlIHRydXNsZXJcIiBkZWNvZGluZz1cImFzeW5jXCIgY2xhc3M9XCJsYXp5bG9hZFwiIGRhdGEtc3JjPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2ltYWdlcy8/aW1hZ2VJZD04MTM2NDA4NSZhbXA7cGFub3c9NjIuMDU4ODIzNTI5NDEyJmFtcDtwYW5vaD0zMC42MzgyOTc4NzIzNCZhbXA7cGFub3k9MTYuNTk1NzQ0NjgwODUxJmFtcDtwYW5veD0zMC4yOTQxMTc2NDcwNTkmYW1wO2hlaWdodHg9MCZhbXA7aGVpZ2h0dz0xMDAmYW1wO2hlaWdodGg9MTAwJmFtcDtoZWlnaHR5PTAmYW1wO3dpZHRoPTQ4NSZhbXA7aGVpZ2h0PTI2NCZhbXA7Y29tcHJlc3Npb249NzBcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGtMQnZmdCB0aXRsZSBkeW5hbWljLXNpemluZ1wiPi0gU3ZhciBww6U8L3NwYW4+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBMekJuVyB0aXRsZSBkeW5hbWljLXNpemluZ1wiPnZlc3RsaWdlIHRydXNsZXI8L3NwYW4+PC9oMz48L2hlYWRlcj48L2E+PC9hcnRpY2xlPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTYgbWVkaXVtLTYgbGFyZ2UtNlwiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJkYWdibGFkZXQtbW9kZWwtZnJvbnRcIiBkYXRhLWxhYmVsPVwiXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIi0gR2Fuc2tlIGhqZXJ0ZWtudXN0XCIgaHJlZj1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9ramVuZGlzL2dhbnNrZS1oamVydGVrbnVzdC84MTM1OTcyOFwiPjxmaWd1cmUgY2xhc3M9XCJ4X19zYy0xYW43dnUxLTAgZm5RREhiXCI+PHBpY3R1cmU+PGltZyBkYXRhLWRlZmVyPVwidmlld1wiIHRpdGxlPVwiSW1hZ2U6IC0gR2Fuc2tlIGhqZXJ0ZWtudXN0XCIgYWx0PVwiSW1hZ2U6IC0gR2Fuc2tlIGhqZXJ0ZWtudXN0XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGNsYXNzPVwibGF6eWxvYWRcIiBkYXRhLXNyYz1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9pbWFnZXMvP2ltYWdlSWQ9Nzk2MDIyNjAmYW1wO3Bhbm94PTAmYW1wO3Bhbm95PTguNTcxNDI4NTcxNDI4NiZhbXA7cGFub3c9MTAwJmFtcDtwYW5vaD0yMC4yODU3MTQyODU3MTQmYW1wO2hlaWdodHk9MCZhbXA7aGVpZ2h0eD0wJmFtcDtoZWlnaHR3PTEwMCZhbXA7aGVpZ2h0aD05OCZhbXA7d2lkdGg9NDg1JmFtcDtoZWlnaHQ9MjQyJmFtcDtjb21wcmVzc2lvbj03MFwiIHNyYz1cImRhdGE6aW1hZ2UvcG5nO2Jhc2U2NCxpVkJPUncwS0dnb0FBQUFOU1VoRVVnQUFBQkFBQUFBSkNBWUFBQUE3S3F3eUFBQUFGMGxFUVZSNDJtTjgrK2I5ZndZS0FPT29BYU1HQUFFQTR1a2lDVUNiVzBjQUFBQUFTVVZPUks1Q1lJST1cIiBsb2FkaW5nPVwibGF6eVwiIGZldGNoUHJpb3JpdHk9XCJhdXRvXCIvPjwvcGljdHVyZT48L2ZpZ3VyZT48aGVhZGVyPjxoMyBjbGFzcz1cInhhdmllci1oZWFkbGluZSBoZWFkbGluZVwiPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAga0xCdmZ0IHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+LSBHYW5za2U8L3NwYW4+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBoUXhBWVAgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5oamVydGVrbnVzdDwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PC9kaXY+PGRpdiBjbGFzcz1cInJvdyB4cm93IGZsZXgtaW5pdGlhbFwiPjxkaXYgY2xhc3M9XCJ4YXZpZXIgY29sdW1ucyBzbWFsbC00IG1lZGl1bS00IGxhcmdlLTRcIj48ZGl2IGNsYXNzPVwicm93IHhyb3cgZmxleC1jb2x1bW5cIj48YXJ0aWNsZSBjbGFzcz1cInByZXZpZXcgY29sdW1ucyBzbWFsbC0xMiBtZWRpdW0tMTIgbGFyZ2UtMTJcIiBkYXRhLWN4ZW5zZV90YWc9XCJjZXJlYnJvXCIgZGF0YS1jeGVuY2Vfd2lkZ2V0PVwicGx1c3MtbW9kZWwtZnJvbnRcIiBkYXRhLWxhYmVsPVwicGx1c3NcIiBkYXRhLWZyb209XCJ4YXZpZXJcIiBkYXRhLXJldmVyc2VJbWFnZVRleHRPcmRlcj1cImZhbHNlXCI+PGEgdGFyZ2V0PVwiX3NlbGZcIiBhcmlhLWxhYmVsPVwiTnllIHNqb2trZnVubjogS29ibGVyIEFESEQgdGlsIGxpZGVsc2VcIiBocmVmPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL3RlbWEvbnllLXNqb2trZnVubi1rb2JsZXItYWRoZC10aWwtbGlkZWxzZS84MTI1MzE2MlwiPjxmaWd1cmUgY2xhc3M9XCJ4X19zYy0xYW43dnUxLTAgZmpKeXZFXCI+PHBpY3R1cmU+PGltZyBkYXRhLWRlZmVyPVwidmlld1wiIHRpdGxlPVwiSW1hZ2U6IE55ZSBzam9ra2Z1bm46IEtvYmxlciBBREhEIHRpbCBsaWRlbHNlXCIgYWx0PVwiSW1hZ2U6IE55ZSBzam9ra2Z1bm46IEtvYmxlciBBREhEIHRpbCBsaWRlbHNlXCIgZGVjb2Rpbmc9XCJhc3luY1wiIGNsYXNzPVwibGF6eWxvYWRcIiBkYXRhLXNyYz1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9pbWFnZXMvP2ltYWdlSWQ9ODEyNTM3MjAmYW1wO3Bhbm95PTAmYW1wO3Bhbm93PTEwMCZhbXA7cGFub2g9MTAwJmFtcDtwYW5veD0wJmFtcDtoZWlnaHR5PTAmYW1wO2hlaWdodHg9MCZhbXA7aGVpZ2h0dz0xMDAmYW1wO2hlaWdodGg9MTAwJmFtcDt3aWR0aD0zMjAmYW1wO2hlaWdodD0xNjAmYW1wO2NvbXByZXNzaW9uPTcwXCIgc3JjPVwiZGF0YTppbWFnZS9wbmc7YmFzZTY0LGlWQk9SdzBLR2dvQUFBQU5TVWhFVWdBQUFCQUFBQUFKQ0FZQUFBQTdLcXd5QUFBQUYwbEVRVlI0Mm1OOCsrYjlmd1lLQU9Pb0FhTUdBQUVBNHVraUNVQ2JXMGNBQUFBQVNVVk9SSzVDWUlJPVwiIGxvYWRpbmc9XCJsYXp5XCIgZmV0Y2hQcmlvcml0eT1cImF1dG9cIi8+PC9waWN0dXJlPjxkaXYgY2xhc3M9XCJmaWd1cmUtbG9nb1wiPjxkaXYgY2xhc3M9XCJsb2dvXCI+PHN2ZyB4bWxucz1cImh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnXCIgd2lkdGg9XCIyNFwiIGhlaWdodD1cIjI0XCIgdmlld0JveD1cIjAgMCAyNCAyNFwiIGZpbGw9XCJub25lXCIgc3Ryb2tlPVwiY3VycmVudENvbG9yXCIgc3Ryb2tlLXdpZHRoPVwiM1wiPjxsaW5lIHgxPVwiMTJcIiB5MT1cIjVcIiB4Mj1cIjEyXCIgeTI9XCIxOVwiPjwvbGluZT48bGluZSB4MT1cIjVcIiB5MT1cIjEyXCIgeDI9XCIxOVwiIHkyPVwiMTJcIj48L2xpbmU+PC9zdmc+PC9kaXY+PC9kaXY+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGlGbEVtSyB0aXRsZSBkeW5hbWljLXNpemluZ1wiPk55ZSBzam9ra2Z1bm46PC9zcGFuPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgYndHUXJ0IHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+S29ibGVyIEFESEQ8L3NwYW4+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBia2drZHAgdGl0bGUgZHluYW1pYy1zaXppbmdcIj50aWwgbGlkZWxzZTwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PGFydGljbGUgY2xhc3M9XCJwcmV2aWV3IGNvbHVtbnMgc21hbGwtMTIgbWVkaXVtLTEyIGxhcmdlLTEyIGJnLXJlZFwiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJ2aWRlby1tZXRhcG9wLW1vZGVsXCIgZGF0YS1sYWJlbD1cInZpZGVvXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIlNsaWsgZ8OlciBkZXQgbWVkIFR1dmEgRmVsbG1hblwiIGhyZWY9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vdmlkZW8vLXZhZXJ0LWV0LWluc2FuZS1hci8xTDBMZ0cxWlwiPjxmaWd1cmUgY2xhc3M9XCJ4X19zYy0xYW43dnUxLTAgZmpKeXZFIG1vdmluZy1pbWFnZS1jb250YWluZXJcIj48dmlkZW8gbXV0ZWQ9XCJcIiBsb29wPVwiXCIgZGF0YS12aWRlby1kZWZlcj1cInZpZXdcIiBwcmVsb2FkPVwibm9uZVwiIHRpdGxlPVwiSW1hZ2U6IFNsaWsgZ8OlciBkZXQgbWVkIFR1dmEgRmVsbG1hblwiIGNsYXNzPVwibW92aW5nLWltYWdlXCIgcGxheXNpbmxpbmU9XCJcIiBwb3N0ZXI9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vaW1hZ2VzLzgxMzU1NDk4LmpwZz9pbWFnZUlkPTgxMzU1NDk4JmFtcDt4PTAuMDAwMDAwJmFtcDt5PTAuMDAwMDAwJmFtcDtjcm9wdz0wLjAwMDAwMCZhbXA7Y3JvcGg9MC4wMDAwMDAmYW1wO3dpZHRoPTMyMCZhbXA7aGVpZ2h0PTE2MFwiIGRpc2FibGVyZW1vdGVwbGF5YmFjaz1cIlwiPjxzb3VyY2Ugc3JjPVwiaHR0cHM6Ly9zbmlwcC5kYnN0YXRpYy5uby8yMDI0LzA1LzA0LzJiZTg5NzY2LTBkMzItNGI5My04YjhmLWY0ZmNiOTY1NzM5Ni9naWYud2VibVwiIHR5cGU9XCJ2aWRlby93ZWJtXCIvPjxzb3VyY2Ugc3JjPVwiaHR0cHM6Ly9zbmlwcC5kYnN0YXRpYy5uby8yMDI0LzA1LzA0LzJiZTg5NzY2LTBkMzItNGI5My04YjhmLWY0ZmNiOTY1NzM5Ni9naWYubXA0XCIgdHlwZT1cInZpZGVvL21wNFwiLz48L3ZpZGVvPjxkaXYgY2xhc3M9XCJmaWd1cmUtbG9nb1wiPjxkaXYgY2xhc3M9XCJsb2dvXCI+PHN2ZyB4bWxucz1cImh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnXCIgd2lkdGg9XCIyNFwiIGhlaWdodD1cIjI0XCIgdmlld0JveD1cIjAgMCAyNCAyNFwiIGZpbGw9XCJjdXJyZW50Q29sb3JcIiBzdHJva2U9XCJjdXJyZW50Q29sb3JcIiBzdHJva2Utd2lkdGg9XCIyXCIgc3Ryb2tlLWxpbmVjYXA9XCJyb3VuZFwiIHN0cm9rZS1saW5lam9pbj1cInJvdW5kXCIgY2xhc3M9XCJmZWF0aGVyIGZlYXRoZXItcGxheVwiPjxwb2x5Z29uIHBvaW50cz1cIjUgMyAxOSAxMiA1IDIxIDUgM1wiPjwvcG9seWdvbj48L3N2Zz48L2Rpdj48L2Rpdj48L2ZpZ3VyZT48aGVhZGVyPjxoMyBjbGFzcz1cInhhdmllci1oZWFkbGluZSBoZWFkbGluZVwiPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgY0tsU0lDIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+U2xpayBnw6VyIGRldDwvc3Bhbj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGZudVZPQiB0aXRsZSBkeW5hbWljLXNpemluZ1wiPm1lZCBUdXZhIEZlbGxtYW48L3NwYW4+PC9oMz48L2hlYWRlcj48L2E+PC9hcnRpY2xlPjwvZGl2PjwvZGl2PjxkaXYgaWQ9XCJhcG9zLW5ldGJvYXJkOVwiIGNsYXNzPVwiYWR1bml0LXdyYXBwZXIgY29sdW1ucyBzbWFsbC04IG1lZGl1bS04IGxhcmdlLTggdHJhY2stZWxlbWVudCAgXCIgZGF0YS1mcm9tPVwieGF2aWVyXCI+PGRpdiBpZD1cImFkLW5ldGJvYXJkOVwiIGNsYXNzPVwiYWR1bml0IEdvb2dsZUFjdGl2ZVZpZXdFbGVtZW50IHNtYWxsLTU4MHg1MDAgbWVkaXVtLTU4MHg1MDAgbGFyZ2UtNTgweDUwMFwiIGl0ZW1zY29wZT1cIlwiIGl0ZW1UeXBlPVwiaHR0cHM6Ly9zY2hlbWEub3JnL1dQQWRCbG9ja1wiIGRhdGEtc2l6ZXM9XCJbWzU4MCw0MDBdLFs1ODAsNTAwXSwmcXVvdDtmbHVpZCZxdW90O11cIiBkYXRhLXNsb3Q9XCIvODU3OC9kYWdibGFkZXQubm8vZm9yc2lkZVwiIGRhdGEtbG9hZC1vbj1cInZpZXdcIiBkYXRhLWNvbGxhcHNlPVwiZmFsc2VcIiBkYXRhLWV4cGFuZD1cImZhbHNlXCIgZGF0YS1vdXQtb2YtcGFnZT1cImZhbHNlXCIganNvbj1cInsmcXVvdDt0YXJnZXRpbmcmcXVvdDs6IHsmcXVvdDtwb3MmcXVvdDs6JnF1b3Q7bmV0Ym9hcmQ5JnF1b3Q7LCZxdW90O3BsYXRmb3JtJnF1b3Q7OiZxdW90O3dvbHZlcmluZSZxdW90O319XCI+PC9kaXY+PC9kaXY+PC9kaXY+PGRpdiBjbGFzcz1cInJvdyB4cm93IGZsZXgtaW5pdGlhbFwiPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTUgbWVkaXVtLTUgbGFyZ2UtNVwiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJkYWdibGFkZXQtbW9kZWwtZnJvbnRcIiBkYXRhLWxhYmVsPVwiXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIlRyZWtrZXIgc2VnIHV2ZW50ZXRcIiBocmVmPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2tqZW5kaXMvdHJla2tlci1zZWctdXZlbnRldC84MTM2NTE5MFwiPjxmaWd1cmUgY2xhc3M9XCJ4X19zYy0xYW43dnUxLTAgZ0NnWEZYXCI+PHBpY3R1cmU+PGltZyBkYXRhLWRlZmVyPVwidmlld1wiIHRpdGxlPVwiSW1hZ2U6IFRyZWtrZXIgc2VnIHV2ZW50ZXRcIiBhbHQ9XCJJbWFnZTogVHJla2tlciBzZWcgdXZlbnRldFwiIGRlY29kaW5nPVwiYXN5bmNcIiBjbGFzcz1cImxhenlsb2FkXCIgZGF0YS1zcmM9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vaW1hZ2VzLz9pbWFnZUlkPTgxMzY1MTk0JmFtcDtwYW5veD0wJmFtcDtwYW5vdz0xMDAmYW1wO3Bhbm9oPTQ1LjIyMjkyOTkzNjMwNiZhbXA7cGFub3k9MCZhbXA7aGVpZ2h0eT0wJmFtcDtoZWlnaHR3PTQ1LjkxODM2NzM0NjkzOSZhbXA7aGVpZ2h0aD0xMDAmYW1wO2hlaWdodHg9MjguMDYxMjI0NDg5Nzk2JmFtcDt3aWR0aD00MDImYW1wO2hlaWdodD0zNTgmYW1wO2NvbXByZXNzaW9uPTcwXCIgc3JjPVwiZGF0YTppbWFnZS9wbmc7YmFzZTY0LGlWQk9SdzBLR2dvQUFBQU5TVWhFVWdBQUFCQUFBQUFKQ0FZQUFBQTdLcXd5QUFBQUYwbEVRVlI0Mm1OOCsrYjlmd1lLQU9Pb0FhTUdBQUVBNHVraUNVQ2JXMGNBQUFBQVNVVk9SSzVDWUlJPVwiIGxvYWRpbmc9XCJsYXp5XCIgZmV0Y2hQcmlvcml0eT1cImF1dG9cIi8+PC9waWN0dXJlPjwvZmlndXJlPjxoZWFkZXI+PGgzIGNsYXNzPVwieGF2aWVyLWhlYWRsaW5lIGhlYWRsaW5lXCI+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBjVVhLT0YgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5UcmVra2VyPC9zcGFuPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgZEJXUVJpIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+c2VnIHV2ZW50ZXQ8L3NwYW4+PC9oMz48L2hlYWRlcj48L2E+PC9hcnRpY2xlPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTcgbWVkaXVtLTcgbGFyZ2UtN1wiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJkYWdibGFkZXQtbW9kZWwtZnJvbnRcIiBkYXRhLWxhYmVsPVwiXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIkJsaXIgYW5rbGFnZXQgZm9yIGp1a3NcIiBocmVmPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2tqZW5kaXMvYmxpci1hbmtsYWdldC1mb3ItanVrcy84MTM2MzQ1OFwiPjxmaWd1cmUgY2xhc3M9XCJ4X19zYy0xYW43dnUxLTAga3ZpQXJ5XCI+PHBpY3R1cmU+PGltZyBkYXRhLWRlZmVyPVwidmlld1wiIHRpdGxlPVwiSW1hZ2U6IEJsaXIgYW5rbGFnZXQgZm9yIGp1a3NcIiBhbHQ9XCJJbWFnZTogQmxpciBhbmtsYWdldCBmb3IganVrc1wiIGRlY29kaW5nPVwiYXN5bmNcIiBjbGFzcz1cImxhenlsb2FkXCIgZGF0YS1zcmM9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vaW1hZ2VzLz9pbWFnZUlkPTgxMzYzNzA3JmFtcDtwYW5veT0xLjI1Nzg2MTYzNTIyMDEmYW1wO3Bhbm94PTAuMTU3MjMzMDE4ODY3OTMmYW1wO3Bhbm93PTk5Ljg0Mjc2Njk4MTEzMiZhbXA7cGFub2g9NDUuNzAyMzA1NjYwMzc3JmFtcDtoZWlnaHR4PTE4LjE4MTgxODE4MTgxOCZhbXA7aGVpZ2h0dz00Ni4yOTYyOTU5NTk1OTYmYW1wO2hlaWdodGg9OTkuNzc2Mjg1OTA2MDQmYW1wO2hlaWdodHk9MCZhbXA7d2lkdGg9NTY3JmFtcDtoZWlnaHQ9MjgzJmFtcDtjb21wcmVzc2lvbj03MFwiIHNyYz1cImRhdGE6aW1hZ2UvcG5nO2Jhc2U2NCxpVkJPUncwS0dnb0FBQUFOU1VoRVVnQUFBQkFBQUFBSkNBWUFBQUE3S3F3eUFBQUFGMGxFUVZSNDJtTjgrK2I5ZndZS0FPT29BYU1HQUFFQTR1a2lDVUNiVzBjQUFBQUFTVVZPUks1Q1lJST1cIiBsb2FkaW5nPVwibGF6eVwiIGZldGNoUHJpb3JpdHk9XCJhdXRvXCIvPjwvcGljdHVyZT48L2ZpZ3VyZT48aGVhZGVyPjxoMyBjbGFzcz1cInhhdmllci1oZWFkbGluZSBoZWFkbGluZVwiPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgYlhEZ3dwIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+QmxpciBhbmtsYWdldDwvc3Bhbj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGp6RUpBRSB0aXRsZSBkeW5hbWljLXNpemluZ1wiPmZvciBqdWtzPC9zcGFuPjwvaDM+PC9oZWFkZXI+PC9hPjwvYXJ0aWNsZT48L2Rpdj48ZGl2IGNsYXNzPVwicm93IHhyb3cgZmxleC1pbml0aWFsXCI+PGFydGljbGUgY2xhc3M9XCJwcmV2aWV3IGNvbHVtbnMgc21hbGwtNCBtZWRpdW0tNCBsYXJnZS00XCIgZGF0YS1jeGVuc2VfdGFnPVwiY2VyZWJyb1wiIGRhdGEtY3hlbmNlX3dpZGdldD1cInZpZGVvLW1ldGFwb3AtbW9kZWxcIiBkYXRhLWxhYmVsPVwidmlkZW9cIiBkYXRhLWZyb209XCJ4YXZpZXJcIiBkYXRhLXJldmVyc2VJbWFnZVRleHRPcmRlcj1cImZhbHNlXCI+PGEgdGFyZ2V0PVwiX3NlbGZcIiBhcmlhLWxhYmVsPVwiRnJhbmtyaWtlOiAtIE9wcGZhdHRldCBzb20gdHJ1c3NlbFwiIGhyZWY9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vdmlkZW8vZnJhbmtyaWtlLW9wcGZhdHRldC1zb20tdHJ1c3NlbC9reGJqNzBhUlwiPjxmaWd1cmUgY2xhc3M9XCJ4X19zYy0xYW43dnUxLTAgZmpKeXZFXCI+PHBpY3R1cmU+PGltZyBkYXRhLWRlZmVyPVwidmlld1wiIHRpdGxlPVwiSW1hZ2U6IEZyYW5rcmlrZTogLSBPcHBmYXR0ZXQgc29tIHRydXNzZWxcIiBhbHQ9XCJJbWFnZTogRnJhbmtyaWtlOiAtIE9wcGZhdHRldCBzb20gdHJ1c3NlbFwiIGRlY29kaW5nPVwiYXN5bmNcIiBjbGFzcz1cImxhenlsb2FkXCIgZGF0YS1zcmM9XCJodHRwczovL2Nkbi5qd3BsYXllci5jb20vdGh1bWJzL2t4Ymo3MGFSLTcyMC5qcGdcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PGRpdiBjbGFzcz1cImZpZ3VyZS1sb2dvXCI+PGRpdiBjbGFzcz1cImxvZ29cIj48c3ZnIHhtbG5zPVwiaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmdcIiB3aWR0aD1cIjI0XCIgaGVpZ2h0PVwiMjRcIiB2aWV3Qm94PVwiMCAwIDI0IDI0XCIgZmlsbD1cImN1cnJlbnRDb2xvclwiIHN0cm9rZT1cImN1cnJlbnRDb2xvclwiIHN0cm9rZS13aWR0aD1cIjJcIiBzdHJva2UtbGluZWNhcD1cInJvdW5kXCIgc3Ryb2tlLWxpbmVqb2luPVwicm91bmRcIiBjbGFzcz1cImZlYXRoZXIgZmVhdGhlci1wbGF5XCI+PHBvbHlnb24gcG9pbnRzPVwiNSAzIDE5IDEyIDUgMjEgNSAzXCI+PC9wb2x5Z29uPjwvc3ZnPjwvZGl2PjwvZGl2PjwvZmlndXJlPjxoZWFkZXI+PGgzIGNsYXNzPVwieGF2aWVyLWhlYWRsaW5lIGhlYWRsaW5lXCI+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBnbE9xcUkgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5GcmFua3Jpa2U6PC9zcGFuPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgakl5VERLIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+LSBPcHBmYXR0ZXQ8L3NwYW4+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBmSWV5Q3ggdGl0bGUgZHluYW1pYy1zaXppbmdcIj5zb20gdHJ1c3NlbDwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PGFydGljbGUgY2xhc3M9XCJwcmV2aWV3IGNvbHVtbnMgc21hbGwtNCBtZWRpdW0tNCBsYXJnZS00XCIgZGF0YS1jeGVuc2VfdGFnPVwiY2VyZWJyb1wiIGRhdGEtY3hlbmNlX3dpZGdldD1cInBsdXNzLW1vZGVsLWZyb250XCIgZGF0YS1sYWJlbD1cIlwiIGRhdGEtZnJvbT1cInhhdmllclwiIGRhdGEtcmV2ZXJzZUltYWdlVGV4dE9yZGVyPVwiZmFsc2VcIj48YSB0YXJnZXQ9XCJfc2VsZlwiIGFyaWEtbGFiZWw9XCJRdWl6IHVrZSAxNzogU2ltZW5zIHRpIGtqYXBwZSFcIiBocmVmPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL255aGV0ZXIvcXVpei11a2UtMTctc2ltZW5zLXRpLWtqYXBwZS84MTMxMzkyNFwiPjxmaWd1cmUgY2xhc3M9XCJ4X19zYy0xYW43dnUxLTAgaUdxUExCXCI+PHBpY3R1cmU+PGltZyBkYXRhLWRlZmVyPVwidmlld1wiIHRpdGxlPVwiSW1hZ2U6IFF1aXogdWtlIDE3OiBTaW1lbnMgdGkga2phcHBlIVwiIGFsdD1cIkltYWdlOiBRdWl6IHVrZSAxNzogU2ltZW5zIHRpIGtqYXBwZSFcIiBkZWNvZGluZz1cImFzeW5jXCIgY2xhc3M9XCJsYXp5bG9hZFwiIGRhdGEtc3JjPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2ltYWdlcy8/aW1hZ2VJZD04MTA1Njc4MyZhbXA7cGFub3c9MTAwJmFtcDtwYW5vaD01MC43MTQyODU3MTQyODYmYW1wO3Bhbm95PTAmYW1wO3Bhbm94PTAmYW1wO2hlaWdodHg9MCZhbXA7aGVpZ2h0dz0xMDAmYW1wO2hlaWdodGg9MTAwJmFtcDtoZWlnaHR5PTAmYW1wO3dpZHRoPTMyMCZhbXA7aGVpZ2h0PTI1NiZhbXA7Y29tcHJlc3Npb249NzBcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGRYYS1EVlEgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5RdWl6IHVrZSAxNzo8L3NwYW4+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBrVkpOUFIgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5TaW1lbnMgdGkga2phcHBlITwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PGRpdiBpZD1cImFwb3MtbWVkaXVtLXJlY3RhbmdsZThcIiBjbGFzcz1cImFkdW5pdC13cmFwcGVyIGNvbHVtbnMgc21hbGwtNCBtZWRpdW0tNCBsYXJnZS00IHRyYWNrLWVsZW1lbnQgIFwiIGRhdGEtZnJvbT1cInhhdmllclwiPjxkaXYgaWQ9XCJhZC1tZWRpdW0tcmVjdGFuZ2xlOFwiIGNsYXNzPVwiYWR1bml0IEdvb2dsZUFjdGl2ZVZpZXdFbGVtZW50IHNtYWxsLTMyMHgyNTAgbWVkaXVtLTMyMHgyNTAgbGFyZ2UtMzIweDI1MFwiIGl0ZW1zY29wZT1cIlwiIGl0ZW1UeXBlPVwiaHR0cHM6Ly9zY2hlbWEub3JnL1dQQWRCbG9ja1wiIGRhdGEtc2l6ZXM9XCJbWzMyMCwyNTBdLFszMDAsMjUwXSwmcXVvdDtmbHVpZCZxdW90O11cIiBkYXRhLXNsb3Q9XCIvODU3OC9kYWdibGFkZXQubm8vZm9yc2lkZVwiIGRhdGEtbG9hZC1vbj1cInZpZXdcIiBkYXRhLWNvbGxhcHNlPVwiZmFsc2VcIiBkYXRhLWV4cGFuZD1cImZhbHNlXCIgZGF0YS1vdXQtb2YtcGFnZT1cImZhbHNlXCIganNvbj1cInsmcXVvdDt0YXJnZXRpbmcmcXVvdDs6IHsmcXVvdDtwb3MmcXVvdDs6JnF1b3Q7bWVkaXVtLXJlY3RhbmdsZTgmcXVvdDssJnF1b3Q7cGxhdGZvcm0mcXVvdDs6JnF1b3Q7d29sdmVyaW5lJnF1b3Q7fX1cIj48L2Rpdj48L2Rpdj48L2Rpdj48ZGl2IGNsYXNzPVwicm93IHhyb3cgZmxleC1pbml0aWFsXCI+PGFydGljbGUgY2xhc3M9XCJwcmV2aWV3IGNvbHVtbnMgc21hbGwtNyBtZWRpdW0tNyBsYXJnZS03XCIgZGF0YS1jeGVuc2VfdGFnPVwiY2VyZWJyb1wiIGRhdGEtY3hlbmNlX3dpZGdldD1cImRhZ2JsYWRldC1tb2RlbC1mcm9udFwiIGRhdGEtbGFiZWw9XCJcIiBkYXRhLWZyb209XCJ4YXZpZXJcIiBkYXRhLXJldmVyc2VJbWFnZVRleHRPcmRlcj1cImZhbHNlXCI+PGEgdGFyZ2V0PVwiX3NlbGZcIiBhcmlhLWxhYmVsPVwiRGVyZm9yIGdqb3JkZSBOUksgZW5kcmluZ2VyXCIgaHJlZj1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby9ramVuZGlzL2RlcmZvci1nam9yZGUtbnJrLWVuZHJpbmdlci84MTM1MTA2OVwiPjxmaWd1cmUgY2xhc3M9XCJ4X19zYy0xYW43dnUxLTAga3ZpQXJ5XCI+PHBpY3R1cmU+PGltZyBkYXRhLWRlZmVyPVwidmlld1wiIHRpdGxlPVwiSW1hZ2U6IERlcmZvciBnam9yZGUgTlJLIGVuZHJpbmdlclwiIGFsdD1cIkltYWdlOiBEZXJmb3IgZ2pvcmRlIE5SSyBlbmRyaW5nZXJcIiBkZWNvZGluZz1cImFzeW5jXCIgY2xhc3M9XCJsYXp5bG9hZFwiIGRhdGEtc3JjPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2ltYWdlcy8/aW1hZ2VJZD04MTM1MTE1MSZhbXA7cGFub3g9MCZhbXA7cGFub3c9MTAwJmFtcDtwYW5vaD0yNC42NTI3Nzc3Nzc3NzgmYW1wO3Bhbm95PTIyLjU2OTQ0NDQ0NDQ0NCZhbXA7aGVpZ2h0eT03LjYxOTA0NzYxOTA0NzYmYW1wO2hlaWdodHg9MTkuODY3NTQ5NjY4ODc0JmFtcDtoZWlnaHR3PTU5LjYwMjY0OTAwNjYyMyZhbXA7aGVpZ2h0aD03MCZhbXA7d2lkdGg9NTY3JmFtcDtoZWlnaHQ9MjgzJmFtcDtjb21wcmVzc2lvbj03MFwiIHNyYz1cImRhdGE6aW1hZ2UvcG5nO2Jhc2U2NCxpVkJPUncwS0dnb0FBQUFOU1VoRVVnQUFBQkFBQUFBSkNBWUFBQUE3S3F3eUFBQUFGMGxFUVZSNDJtTjgrK2I5ZndZS0FPT29BYU1HQUFFQTR1a2lDVUNiVzBjQUFBQUFTVVZPUks1Q1lJST1cIiBsb2FkaW5nPVwibGF6eVwiIGZldGNoUHJpb3JpdHk9XCJhdXRvXCIvPjwvcGljdHVyZT48L2ZpZ3VyZT48aGVhZGVyPjxoMyBjbGFzcz1cInhhdmllci1oZWFkbGluZSBoZWFkbGluZVwiPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgZGRiQ0paIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+RGVyZm9yIGdqb3JkZTwvc3Bhbj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIHRxR2tnIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+TlJLIGVuZHJpbmdlcjwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PGFydGljbGUgY2xhc3M9XCJwcmV2aWV3IGNvbHVtbnMgc21hbGwtNSBtZWRpdW0tNSBsYXJnZS01XCIgZGF0YS1jeGVuc2VfdGFnPVwiY2VyZWJyb1wiIGRhdGEtY3hlbmNlX3dpZGdldD1cImRhZ2JsYWRldC1tb2RlbC1mcm9udFwiIGRhdGEtbGFiZWw9XCJcIiBkYXRhLWZyb209XCJ4YXZpZXJcIiBkYXRhLXJldmVyc2VJbWFnZVRleHRPcmRlcj1cImZhbHNlXCI+PGEgdGFyZ2V0PVwiX3NlbGZcIiBhcmlhLWxhYmVsPVwiLSBTaSB1bm5za3lsZCB0aWwga29uZ2VuIVwiIGhyZWY9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vbnloZXRlci9zaS11bm5za3lsZC10aWwta29uZ2VuLzgxMzYzMzE5XCI+PGZpZ3VyZSBjbGFzcz1cInhfX3NjLTFhbjd2dTEtMCBTcEpSYVwiPjxwaWN0dXJlPjxpbWcgZGF0YS1kZWZlcj1cInZpZXdcIiB0aXRsZT1cIkltYWdlOiAtIFNpIHVubnNreWxkIHRpbCBrb25nZW4hXCIgYWx0PVwiSW1hZ2U6IC0gU2kgdW5uc2t5bGQgdGlsIGtvbmdlbiFcIiBkZWNvZGluZz1cImFzeW5jXCIgY2xhc3M9XCJsYXp5bG9hZFwiIGRhdGEtc3JjPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2ltYWdlcy8/aW1hZ2VJZD04MTM2NDQ5MCZhbXA7cGFub3g9MCZhbXA7cGFub3c9MTAwJmFtcDtwYW5vaD0xMDAmYW1wO3Bhbm95PTAmYW1wO2hlaWdodHk9MCZhbXA7aGVpZ2h0eD0wJmFtcDtoZWlnaHR3PTEwMCZhbXA7aGVpZ2h0aD0xMDAmYW1wO3dpZHRoPTQwMiZhbXA7aGVpZ2h0PTMxMSZhbXA7Y29tcHJlc3Npb249NzBcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGJjQ2Z1SiB0aXRsZSBkeW5hbWljLXNpemluZ1wiPi0gU2kgdW5uc2t5bGQ8L3NwYW4+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBqdENYdkEgdGl0bGUgZHluYW1pYy1zaXppbmdcIj50aWwga29uZ2VuITwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PC9kaXY+PGRpdiBjbGFzcz1cInJvdyB4cm93IGZsZXgtaW5pdGlhbFwiPjxkaXYgaWQ9XCJhcG9zLW5ldGJvYXJkMTBcIiBjbGFzcz1cImFkdW5pdC13cmFwcGVyIGNvbHVtbnMgc21hbGwtOCBtZWRpdW0tOCBsYXJnZS04IHRyYWNrLWVsZW1lbnQgIFwiIGRhdGEtZnJvbT1cInhhdmllclwiPjxkaXYgaWQ9XCJhZC1uZXRib2FyZDEwXCIgY2xhc3M9XCJhZHVuaXQgR29vZ2xlQWN0aXZlVmlld0VsZW1lbnQgc21hbGwtNTgweDUwMCBtZWRpdW0tNTgweDUwMCBsYXJnZS01ODB4NTAwXCIgaXRlbXNjb3BlPVwiXCIgaXRlbVR5cGU9XCJodHRwczovL3NjaGVtYS5vcmcvV1BBZEJsb2NrXCIgZGF0YS1zaXplcz1cIltbNTgwLDQwMF0sWzU4MCw1MDBdLCZxdW90O2ZsdWlkJnF1b3Q7XVwiIGRhdGEtc2xvdD1cIi84NTc4L2RhZ2JsYWRldC5uby9mb3JzaWRlXCIgZGF0YS1sb2FkLW9uPVwidmlld1wiIGRhdGEtY29sbGFwc2U9XCJmYWxzZVwiIGRhdGEtZXhwYW5kPVwiZmFsc2VcIiBkYXRhLW91dC1vZi1wYWdlPVwiZmFsc2VcIiBqc29uPVwieyZxdW90O3RhcmdldGluZyZxdW90OzogeyZxdW90O3BvcyZxdW90OzomcXVvdDtuZXRib2FyZDEwJnF1b3Q7LCZxdW90O3BsYXRmb3JtJnF1b3Q7OiZxdW90O3dvbHZlcmluZSZxdW90O319XCI+PC9kaXY+PC9kaXY+PGRpdiBjbGFzcz1cInhhdmllciBjb2x1bW5zIHNtYWxsLTQgbWVkaXVtLTQgbGFyZ2UtNFwiPjxkaXYgY2xhc3M9XCJyb3cgeHJvdyBmbGV4LWNvbHVtblwiPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTEyIG1lZGl1bS0xMiBsYXJnZS0xMlwiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJwbHVzcy1tb2RlbC1mcm9udFwiIGRhdGEtbGFiZWw9XCJwbHVzc1wiIGRhdGEtZnJvbT1cInhhdmllclwiIGRhdGEtcmV2ZXJzZUltYWdlVGV4dE9yZGVyPVwiZmFsc2VcIj48YSB0YXJnZXQ9XCJfc2VsZlwiIGFyaWEtbGFiZWw9XCJEZW4gZmFybGlnc3RlIC0gb2cgbWluc3QgZmFybGlnZSBzbnVzZW5cIiBocmVmPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL3RlbWEvZGVuLWZhcmxpZ3N0ZS1vZy1taW5zdC1mYXJsaWdlLXNudXNlbi84MTIwNjQwM1wiPjxmaWd1cmUgY2xhc3M9XCJ4X19zYy0xYW43dnUxLTAgZmpKeXZFXCI+PHBpY3R1cmU+PGltZyBkYXRhLWRlZmVyPVwidmlld1wiIHRpdGxlPVwiSW1hZ2U6IERlbiBmYXJsaWdzdGUgLSBvZyBtaW5zdCBmYXJsaWdlIHNudXNlblwiIGFsdD1cIkltYWdlOiBEZW4gZmFybGlnc3RlIC0gb2cgbWluc3QgZmFybGlnZSBzbnVzZW5cIiBkZWNvZGluZz1cImFzeW5jXCIgY2xhc3M9XCJsYXp5bG9hZFwiIGRhdGEtc3JjPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2ltYWdlcy8/aW1hZ2VJZD04MTIxMjI3MCZhbXA7cGFub3g9MCZhbXA7cGFub3c9OTkuNzU5NjE1Mzg0NjE1JmFtcDtwYW5vaD01OS43NDU3NjI3MTE4NjQmYW1wO3Bhbm95PTExLjg2NDQwNjc3OTY2MSZhbXA7aGVpZ2h0eD0zMS43NjQ3MDU4ODIzNTMmYW1wO2hlaWdodHk9MC4zNDQ4Mjc1ODYyMDY5JmFtcDtoZWlnaHR3PTM0LjcwNTg4MjM1Mjk0MSZhbXA7aGVpZ2h0aD0xMDAuMzQ0ODI3NTg2MjEmYW1wO3dpZHRoPTMyMCZhbXA7aGVpZ2h0PTE2MCZhbXA7Y29tcHJlc3Npb249NzBcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PGRpdiBjbGFzcz1cImZpZ3VyZS1sb2dvXCI+PGRpdiBjbGFzcz1cImxvZ29cIj48c3ZnIHhtbG5zPVwiaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmdcIiB3aWR0aD1cIjI0XCIgaGVpZ2h0PVwiMjRcIiB2aWV3Qm94PVwiMCAwIDI0IDI0XCIgZmlsbD1cIm5vbmVcIiBzdHJva2U9XCJjdXJyZW50Q29sb3JcIiBzdHJva2Utd2lkdGg9XCIzXCI+PGxpbmUgeDE9XCIxMlwiIHkxPVwiNVwiIHgyPVwiMTJcIiB5Mj1cIjE5XCI+PC9saW5lPjxsaW5lIHgxPVwiNVwiIHkxPVwiMTJcIiB4Mj1cIjE5XCIgeTI9XCIxMlwiPjwvbGluZT48L3N2Zz48L2Rpdj48L2Rpdj48L2ZpZ3VyZT48aGVhZGVyPjxoMyBjbGFzcz1cInhhdmllci1oZWFkbGluZSBoZWFkbGluZVwiPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAga1ZKTlBSIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+RGVuIGZhcmxpZ3N0ZSAtIG9nPC9zcGFuPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgaU5IeWllIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+bWluc3QgZmFybGlnZSBzbnVzZW48L3NwYW4+PC9oMz48L2hlYWRlcj48L2E+PC9hcnRpY2xlPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTEyIG1lZGl1bS0xMiBsYXJnZS0xMlwiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJ2aWRlby1tZXRhcG9wLW1vZGVsXCIgZGF0YS1sYWJlbD1cInZpZGVvXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIsOFdHRlw6VyaW5nIHLDuHJlciBkb21tZXJuZSAtIGbDpXIgZ3VsbGtuYXBwXCIgaHJlZj1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby92aWRlby9hdHRlYXJpbmctcm9yZXItZG9tbWVybmUtZmFyLWd1bGxrbmFwcC9IWmROWHhreFwiPjxmaWd1cmUgY2xhc3M9XCJ4X19zYy0xYW43dnUxLTAgZmpKeXZFXCI+PHBpY3R1cmU+PGltZyBkYXRhLWRlZmVyPVwidmlld1wiIHRpdGxlPVwiSW1hZ2U6IMOFdHRlw6VyaW5nIHLDuHJlciBkb21tZXJuZSAtIGbDpXIgZ3VsbGtuYXBwXCIgYWx0PVwiSW1hZ2U6IMOFdHRlw6VyaW5nIHLDuHJlciBkb21tZXJuZSAtIGbDpXIgZ3VsbGtuYXBwXCIgZGVjb2Rpbmc9XCJhc3luY1wiIGNsYXNzPVwibGF6eWxvYWRcIiBkYXRhLXNyYz1cImh0dHBzOi8vY2RuLmp3cGxheWVyLmNvbS90aHVtYnMvSFpkTlh4a3gtNzIwLmpwZ1wiIHNyYz1cImRhdGE6aW1hZ2UvcG5nO2Jhc2U2NCxpVkJPUncwS0dnb0FBQUFOU1VoRVVnQUFBQkFBQUFBSkNBWUFBQUE3S3F3eUFBQUFGMGxFUVZSNDJtTjgrK2I5ZndZS0FPT29BYU1HQUFFQTR1a2lDVUNiVzBjQUFBQUFTVVZPUks1Q1lJST1cIiBsb2FkaW5nPVwibGF6eVwiIGZldGNoUHJpb3JpdHk9XCJhdXRvXCIvPjwvcGljdHVyZT48ZGl2IGNsYXNzPVwiZmlndXJlLWxvZ29cIj48ZGl2IGNsYXNzPVwibG9nb1wiPjxzdmcgeG1sbnM9XCJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2Z1wiIHdpZHRoPVwiMjRcIiBoZWlnaHQ9XCIyNFwiIHZpZXdCb3g9XCIwIDAgMjQgMjRcIiBmaWxsPVwiY3VycmVudENvbG9yXCIgc3Ryb2tlPVwiY3VycmVudENvbG9yXCIgc3Ryb2tlLXdpZHRoPVwiMlwiIHN0cm9rZS1saW5lY2FwPVwicm91bmRcIiBzdHJva2UtbGluZWpvaW49XCJyb3VuZFwiIGNsYXNzPVwiZmVhdGhlciBmZWF0aGVyLXBsYXlcIj48cG9seWdvbiBwb2ludHM9XCI1IDMgMTkgMTIgNSAyMSA1IDNcIj48L3BvbHlnb24+PC9zdmc+PC9kaXY+PC9kaXY+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGlGbEVtSyB0aXRsZSBkeW5hbWljLXNpemluZ1wiPsOFdHRlw6VyaW5nIHLDuHJlcjwvc3Bhbj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGppR1ZWaiB0aXRsZSBkeW5hbWljLXNpemluZ1wiPmRvbW1lcm5lIC08L3NwYW4+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBnUEl4ZWEgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5mw6VyIGd1bGxrbmFwcDwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PC9kaXY+PC9kaXY+PC9kaXY+PGRpdiBjbGFzcz1cInJvdyB4cm93IGZsZXgtaW5pdGlhbFwiPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTQgbWVkaXVtLTQgbGFyZ2UtNFwiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJ2aWRlby1tZXRhcG9wLW1vZGVsXCIgZGF0YS1sYWJlbD1cInZpZGVvXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIk9wcGRhZ2VyIHJ1c3Npc2sgc3Bpb25kcm9uZVwiIGhyZWY9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vdmlkZW8vb3BwZGFnZXItcnVzc2lzay1zcGlvbmRyb25lLzhkY29YMFY2XCI+PGZpZ3VyZSBjbGFzcz1cInhfX3NjLTFhbjd2dTEtMCBmakp5dkVcIj48cGljdHVyZT48aW1nIGRhdGEtZGVmZXI9XCJ2aWV3XCIgdGl0bGU9XCJJbWFnZTogT3BwZGFnZXIgcnVzc2lzayBzcGlvbmRyb25lXCIgYWx0PVwiSW1hZ2U6IE9wcGRhZ2VyIHJ1c3Npc2sgc3Bpb25kcm9uZVwiIGRlY29kaW5nPVwiYXN5bmNcIiBjbGFzcz1cImxhenlsb2FkXCIgZGF0YS1zcmM9XCJodHRwczovL2Nkbi5qd3BsYXllci5jb20vdGh1bWJzLzhkY29YMFY2LTcyMC5qcGdcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PGRpdiBjbGFzcz1cImZpZ3VyZS1sb2dvXCI+PGRpdiBjbGFzcz1cImxvZ29cIj48c3ZnIHhtbG5zPVwiaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmdcIiB3aWR0aD1cIjI0XCIgaGVpZ2h0PVwiMjRcIiB2aWV3Qm94PVwiMCAwIDI0IDI0XCIgZmlsbD1cImN1cnJlbnRDb2xvclwiIHN0cm9rZT1cImN1cnJlbnRDb2xvclwiIHN0cm9rZS13aWR0aD1cIjJcIiBzdHJva2UtbGluZWNhcD1cInJvdW5kXCIgc3Ryb2tlLWxpbmVqb2luPVwicm91bmRcIiBjbGFzcz1cImZlYXRoZXIgZmVhdGhlci1wbGF5XCI+PHBvbHlnb24gcG9pbnRzPVwiNSAzIDE5IDEyIDUgMjEgNSAzXCI+PC9wb2x5Z29uPjwvc3ZnPjwvZGl2PjwvZGl2PjwvZmlndXJlPjxoZWFkZXI+PGgzIGNsYXNzPVwieGF2aWVyLWhlYWRsaW5lIGhlYWRsaW5lXCI+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBrVkpOUFIgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5PcHBkYWdlciBydXNzaXNrPC9zcGFuPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgYldTblZTIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+c3Bpb25kcm9uZTwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PGFydGljbGUgY2xhc3M9XCJwcmV2aWV3IGNvbHVtbnMgc21hbGwtNCBtZWRpdW0tNCBsYXJnZS00XCIgZGF0YS1jeGVuc2VfdGFnPVwiY2VyZWJyb1wiIGRhdGEtY3hlbmNlX3dpZGdldD1cInBsdXNzLW1vZGVsLWZyb250XCIgZGF0YS1sYWJlbD1cInBsdXNzXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIlV0cm9za2FwOiBIdm9yZm9yIHNramVyIGRldCBtZWQgbWVnP1wiIGhyZWY9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vdGVtYS91dHJvc2thcC1odm9yZm9yc2tqZXItZGV0LW1lZC1tZWcvODEyMDYxMzlcIj48ZmlndXJlIGNsYXNzPVwieF9fc2MtMWFuN3Z1MS0wIGVBWVhZXCI+PHBpY3R1cmU+PGltZyBkYXRhLWRlZmVyPVwidmlld1wiIHRpdGxlPVwiSW1hZ2U6IFV0cm9za2FwOiBIdm9yZm9yIHNramVyIGRldCBtZWQgbWVnP1wiIGFsdD1cIkltYWdlOiBVdHJvc2thcDogSHZvcmZvciBza2plciBkZXQgbWVkIG1lZz9cIiBkZWNvZGluZz1cImFzeW5jXCIgY2xhc3M9XCJsYXp5bG9hZFwiIGRhdGEtc3JjPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2ltYWdlcy8/aW1hZ2VJZD04MTI0ODA4NCZhbXA7cGFub3k9MCZhbXA7cGFub3g9MCZhbXA7cGFub3c9MTAwJmFtcDtwYW5vaD0xMDAmYW1wO2hlaWdodHc9MTAwJmFtcDtoZWlnaHRoPTEwMCZhbXA7aGVpZ2h0eT0wJmFtcDtoZWlnaHR4PTAmYW1wO3dpZHRoPTMyMCZhbXA7aGVpZ2h0PTE4OCZhbXA7Y29tcHJlc3Npb249NzBcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PGRpdiBjbGFzcz1cImZpZ3VyZS1sb2dvXCI+PGRpdiBjbGFzcz1cImxvZ29cIj48c3ZnIHhtbG5zPVwiaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmdcIiB3aWR0aD1cIjI0XCIgaGVpZ2h0PVwiMjRcIiB2aWV3Qm94PVwiMCAwIDI0IDI0XCIgZmlsbD1cIm5vbmVcIiBzdHJva2U9XCJjdXJyZW50Q29sb3JcIiBzdHJva2Utd2lkdGg9XCIzXCI+PGxpbmUgeDE9XCIxMlwiIHkxPVwiNVwiIHgyPVwiMTJcIiB5Mj1cIjE5XCI+PC9saW5lPjxsaW5lIHgxPVwiNVwiIHkxPVwiMTJcIiB4Mj1cIjE5XCIgeTI9XCIxMlwiPjwvbGluZT48L3N2Zz48L2Rpdj48L2Rpdj48L2ZpZ3VyZT48aGVhZGVyPjxoMyBjbGFzcz1cInhhdmllci1oZWFkbGluZSBoZWFkbGluZVwiPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgaVlnQnZBIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+VXRyb3NrYXA6IEh2b3Jmb3I8L3NwYW4+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBjRnRDTiB0aXRsZSBkeW5hbWljLXNpemluZ1wiPnNramVyIGRldCBtZWQgbWVnPzwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PGRpdiBpZD1cImFwb3MtbWVkaXVtLXJlY3RhbmdsZTlcIiBjbGFzcz1cImFkdW5pdC13cmFwcGVyIGNvbHVtbnMgc21hbGwtNCBtZWRpdW0tNCBsYXJnZS00IHRyYWNrLWVsZW1lbnQgIFwiIGRhdGEtZnJvbT1cInhhdmllclwiPjxkaXYgaWQ9XCJhZC1tZWRpdW0tcmVjdGFuZ2xlOVwiIGNsYXNzPVwiYWR1bml0IEdvb2dsZUFjdGl2ZVZpZXdFbGVtZW50IHNtYWxsLTMyMHgyNTAgbWVkaXVtLTMyMHgyNTAgbGFyZ2UtMzIweDI1MFwiIGl0ZW1zY29wZT1cIlwiIGl0ZW1UeXBlPVwiaHR0cHM6Ly9zY2hlbWEub3JnL1dQQWRCbG9ja1wiIGRhdGEtc2l6ZXM9XCJbWzMyMCwyNTBdLFszMDAsMjUwXSwmcXVvdDtmbHVpZCZxdW90O11cIiBkYXRhLXNsb3Q9XCIvODU3OC9kYWdibGFkZXQubm8vZm9yc2lkZVwiIGRhdGEtbG9hZC1vbj1cInZpZXdcIiBkYXRhLWNvbGxhcHNlPVwiZmFsc2VcIiBkYXRhLWV4cGFuZD1cImZhbHNlXCIgZGF0YS1vdXQtb2YtcGFnZT1cImZhbHNlXCIganNvbj1cInsmcXVvdDt0YXJnZXRpbmcmcXVvdDs6IHsmcXVvdDtwb3MmcXVvdDs6JnF1b3Q7bWVkaXVtLXJlY3RhbmdsZTkmcXVvdDssJnF1b3Q7cGxhdGZvcm0mcXVvdDs6JnF1b3Q7d29sdmVyaW5lJnF1b3Q7fX1cIj48L2Rpdj48L2Rpdj48L2Rpdj48ZGl2IGNsYXNzPVwicm93IHhyb3cgZmxleC1pbml0aWFsXCI+PGRpdiBpZD1cImFwb3MtbmV0Ym9hcmQxMVwiIGNsYXNzPVwiYWR1bml0LXdyYXBwZXIgY29sdW1ucyBzbWFsbC04IG1lZGl1bS04IGxhcmdlLTggdHJhY2stZWxlbWVudCAgXCIgZGF0YS1mcm9tPVwieGF2aWVyXCI+PGRpdiBpZD1cImFkLW5ldGJvYXJkMTFcIiBjbGFzcz1cImFkdW5pdCBHb29nbGVBY3RpdmVWaWV3RWxlbWVudCBzbWFsbC01ODB4NTAwIG1lZGl1bS01ODB4NTAwIGxhcmdlLTU4MHg1MDBcIiBpdGVtc2NvcGU9XCJcIiBpdGVtVHlwZT1cImh0dHBzOi8vc2NoZW1hLm9yZy9XUEFkQmxvY2tcIiBkYXRhLXNpemVzPVwiW1s1ODAsNDAwXSxbNTgwLDUwMF0sJnF1b3Q7Zmx1aWQmcXVvdDtdXCIgZGF0YS1zbG90PVwiLzg1NzgvZGFnYmxhZGV0Lm5vL2ZvcnNpZGVcIiBkYXRhLWxvYWQtb249XCJ2aWV3XCIgZGF0YS1jb2xsYXBzZT1cImZhbHNlXCIgZGF0YS1leHBhbmQ9XCJmYWxzZVwiIGRhdGEtb3V0LW9mLXBhZ2U9XCJmYWxzZVwiIGpzb249XCJ7JnF1b3Q7dGFyZ2V0aW5nJnF1b3Q7OiB7JnF1b3Q7cG9zJnF1b3Q7OiZxdW90O25ldGJvYXJkMTEmcXVvdDssJnF1b3Q7cGxhdGZvcm0mcXVvdDs6JnF1b3Q7d29sdmVyaW5lJnF1b3Q7fX1cIj48L2Rpdj48L2Rpdj48ZGl2IGNsYXNzPVwieGF2aWVyIGNvbHVtbnMgc21hbGwtNCBtZWRpdW0tNCBsYXJnZS00XCI+PGRpdiBjbGFzcz1cInJvdyB4cm93IGZsZXgtY29sdW1uXCI+PGFydGljbGUgY2xhc3M9XCJwcmV2aWV3IGNvbHVtbnMgc21hbGwtMTIgbWVkaXVtLTEyIGxhcmdlLTEyXCIgZGF0YS1jeGVuc2VfdGFnPVwiY2VyZWJyb1wiIGRhdGEtY3hlbmNlX3dpZGdldD1cInBsdXNzLW1vZGVsLWZyb250XCIgZGF0YS1sYWJlbD1cInBsdXNzXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIlRyZSBncmVwIHN0eXJrZXIgaGplcnRldCByYXNrZXN0XCIgaHJlZj1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby90ZW1hL3RyZS1ncmVwLXN0eXJrZXItaGplcnRldC1yYXNrZXN0LzgxMTAxOTcwXCI+PGZpZ3VyZSBjbGFzcz1cInhfX3NjLTFhbjd2dTEtMCBmakp5dkVcIj48cGljdHVyZT48aW1nIGRhdGEtZGVmZXI9XCJ2aWV3XCIgdGl0bGU9XCJJbWFnZTogVHJlIGdyZXAgc3R5cmtlciBoamVydGV0IHJhc2tlc3RcIiBhbHQ9XCJJbWFnZTogVHJlIGdyZXAgc3R5cmtlciBoamVydGV0IHJhc2tlc3RcIiBkZWNvZGluZz1cImFzeW5jXCIgY2xhc3M9XCJsYXp5bG9hZFwiIGRhdGEtc3JjPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL2ltYWdlcy8/aW1hZ2VJZD04MTEwOTE1NiZhbXA7cGFub3g9MCZhbXA7cGFub3c9MTAwJmFtcDtwYW5vaD0xMDAmYW1wO3Bhbm95PTAmYW1wO2hlaWdodHk9MCZhbXA7aGVpZ2h0eD0wJmFtcDtoZWlnaHR3PTEwMCZhbXA7aGVpZ2h0aD0xMDAmYW1wO3dpZHRoPTMyMCZhbXA7aGVpZ2h0PTE2MCZhbXA7Y29tcHJlc3Npb249NzBcIiBzcmM9XCJkYXRhOmltYWdlL3BuZztiYXNlNjQsaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQUJBQUFBQUpDQVlBQUFBN0txd3lBQUFBRjBsRVFWUjQybU44KytiOWZ3WUtBT09vQWFNR0FBRUE0dWtpQ1VDYlcwY0FBQUFBU1VWT1JLNUNZSUk9XCIgbG9hZGluZz1cImxhenlcIiBmZXRjaFByaW9yaXR5PVwiYXV0b1wiLz48L3BpY3R1cmU+PGRpdiBjbGFzcz1cImZpZ3VyZS1sb2dvXCI+PGRpdiBjbGFzcz1cImxvZ29cIj48c3ZnIHhtbG5zPVwiaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmdcIiB3aWR0aD1cIjI0XCIgaGVpZ2h0PVwiMjRcIiB2aWV3Qm94PVwiMCAwIDI0IDI0XCIgZmlsbD1cIm5vbmVcIiBzdHJva2U9XCJjdXJyZW50Q29sb3JcIiBzdHJva2Utd2lkdGg9XCIzXCI+PGxpbmUgeDE9XCIxMlwiIHkxPVwiNVwiIHgyPVwiMTJcIiB5Mj1cIjE5XCI+PC9saW5lPjxsaW5lIHgxPVwiNVwiIHkxPVwiMTJcIiB4Mj1cIjE5XCIgeTI9XCIxMlwiPjwvbGluZT48L3N2Zz48L2Rpdj48L2Rpdj48L2ZpZ3VyZT48aGVhZGVyPjxoMyBjbGFzcz1cInhhdmllci1oZWFkbGluZSBoZWFkbGluZVwiPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgZk5EaER5IHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+VHJlIGdyZXAgc3R5cmtlcjwvc3Bhbj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGpkZ016VSB0aXRsZSBkeW5hbWljLXNpemluZ1wiPmhqZXJ0ZXQgcmFza2VzdDwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PGFydGljbGUgY2xhc3M9XCJwcmV2aWV3IGNvbHVtbnMgc21hbGwtMTIgbWVkaXVtLTEyIGxhcmdlLTEyIGJnLXJlZFwiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJ2aWRlby1tZXRhcG9wLW1vZGVsXCIgZGF0YS1sYWJlbD1cInZpZGVvXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIktvbmZyb250ZXJlcyBhdiBNYWRzIEhhbnNlblwiIGhyZWY9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vdmlkZW8vbWFkcy1oYW5zZW4tb2ctZXJuYS1zb2xiZXJnLWktaGV0LWRlYmF0dC9mNXdtMWtEbFwiPjxmaWd1cmUgY2xhc3M9XCJ4X19zYy0xYW43dnUxLTAgZmpKeXZFIG1vdmluZy1pbWFnZS1jb250YWluZXJcIj48dmlkZW8gbXV0ZWQ9XCJcIiBsb29wPVwiXCIgZGF0YS12aWRlby1kZWZlcj1cInZpZXdcIiBwcmVsb2FkPVwibm9uZVwiIHRpdGxlPVwiSW1hZ2U6IEtvbmZyb250ZXJlcyBhdiBNYWRzIEhhbnNlblwiIGNsYXNzPVwibW92aW5nLWltYWdlXCIgcGxheXNpbmxpbmU9XCJcIiBwb3N0ZXI9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vaW1hZ2VzLzgxMzU4Nzc4LmpwZz9pbWFnZUlkPTgxMzU4Nzc4JmFtcDt4PTAuMDAwMDAwJmFtcDt5PTAuMDAwMDAwJmFtcDtjcm9wdz0wLjAwMDAwMCZhbXA7Y3JvcGg9MC4wMDAwMDAmYW1wO3dpZHRoPTMyMCZhbXA7aGVpZ2h0PTE2MFwiIGRpc2FibGVyZW1vdGVwbGF5YmFjaz1cIlwiPjxzb3VyY2Ugc3JjPVwiaHR0cHM6Ly9zbmlwcC5kYnN0YXRpYy5uby8yMDI0LzA1LzA0L2UxMTk4ZGIwLWRjNjctNGE2NC1iNGVlLWMwNjNmMmE4YmUyYy9ndWxscnV0ZW5naWZzLndlYm1cIiB0eXBlPVwidmlkZW8vd2VibVwiLz48c291cmNlIHNyYz1cImh0dHBzOi8vc25pcHAuZGJzdGF0aWMubm8vMjAyNC8wNS8wNC9lMTE5OGRiMC1kYzY3LTRhNjQtYjRlZS1jMDYzZjJhOGJlMmMvZ3VsbHJ1dGVuZ2lmcy5tcDRcIiB0eXBlPVwidmlkZW8vbXA0XCIvPjwvdmlkZW8+PGRpdiBjbGFzcz1cImZpZ3VyZS1sb2dvXCI+PGRpdiBjbGFzcz1cImxvZ29cIj48c3ZnIHhtbG5zPVwiaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmdcIiB3aWR0aD1cIjI0XCIgaGVpZ2h0PVwiMjRcIiB2aWV3Qm94PVwiMCAwIDI0IDI0XCIgZmlsbD1cImN1cnJlbnRDb2xvclwiIHN0cm9rZT1cImN1cnJlbnRDb2xvclwiIHN0cm9rZS13aWR0aD1cIjJcIiBzdHJva2UtbGluZWNhcD1cInJvdW5kXCIgc3Ryb2tlLWxpbmVqb2luPVwicm91bmRcIiBjbGFzcz1cImZlYXRoZXIgZmVhdGhlci1wbGF5XCI+PHBvbHlnb24gcG9pbnRzPVwiNSAzIDE5IDEyIDUgMjEgNSAzXCI+PC9wb2x5Z29uPjwvc3ZnPjwvZGl2PjwvZGl2PjwvZmlndXJlPjxoZWFkZXI+PGgzIGNsYXNzPVwieGF2aWVyLWhlYWRsaW5lIGhlYWRsaW5lXCI+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBnTEhMRXYgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5Lb25mcm9udGVyZXM8L3NwYW4+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBpdGtpTkogdGl0bGUgZHluYW1pYy1zaXppbmdcIj5hdiBNYWRzIEhhbnNlbjwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PC9kaXY+PC9kaXY+PC9kaXY+PGRpdiBjbGFzcz1cInJvdyB4cm93IGZsZXgtaW5pdGlhbFwiPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTQgbWVkaXVtLTQgbGFyZ2UtNFwiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJ2aWRlby1tZXRhcG9wLW1vZGVsXCIgZGF0YS1sYWJlbD1cInZpZGVvXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIk5hYm9rcmFuZ2VsZW4gZ8OlciB2ZXJkZW4gcnVuZHQ6IC0gR3J1c29tdFwiIGhyZWY9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vdmlkZW8vbmFib2tyYW5nZWxlbi1nYXItdmVyZGVuLXJ1bmR0LWdydXNvbXQvN3lJaEZHZ2NcIj48ZmlndXJlIGNsYXNzPVwieF9fc2MtMWFuN3Z1MS0wIGpKRHVOc1wiPjxwaWN0dXJlPjxpbWcgZGF0YS1kZWZlcj1cInZpZXdcIiB0aXRsZT1cIkltYWdlOiBOYWJva3JhbmdlbGVuIGfDpXIgdmVyZGVuIHJ1bmR0OiAtIEdydXNvbXRcIiBhbHQ9XCJJbWFnZTogTmFib2tyYW5nZWxlbiBnw6VyIHZlcmRlbiBydW5kdDogLSBHcnVzb210XCIgZGVjb2Rpbmc9XCJhc3luY1wiIGNsYXNzPVwibGF6eWxvYWRcIiBkYXRhLXNyYz1cImh0dHBzOi8vY2RuLmp3cGxheWVyLmNvbS90aHVtYnMvN3lJaEZHZ2MtNzIwLmpwZ1wiIHNyYz1cImRhdGE6aW1hZ2UvcG5nO2Jhc2U2NCxpVkJPUncwS0dnb0FBQUFOU1VoRVVnQUFBQkFBQUFBSkNBWUFBQUE3S3F3eUFBQUFGMGxFUVZSNDJtTjgrK2I5ZndZS0FPT29BYU1HQUFFQTR1a2lDVUNiVzBjQUFBQUFTVVZPUks1Q1lJST1cIiBsb2FkaW5nPVwibGF6eVwiIGZldGNoUHJpb3JpdHk9XCJhdXRvXCIvPjwvcGljdHVyZT48ZGl2IGNsYXNzPVwiZmlndXJlLWxvZ29cIj48ZGl2IGNsYXNzPVwibG9nb1wiPjxzdmcgeG1sbnM9XCJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2Z1wiIHdpZHRoPVwiMjRcIiBoZWlnaHQ9XCIyNFwiIHZpZXdCb3g9XCIwIDAgMjQgMjRcIiBmaWxsPVwiY3VycmVudENvbG9yXCIgc3Ryb2tlPVwiY3VycmVudENvbG9yXCIgc3Ryb2tlLXdpZHRoPVwiMlwiIHN0cm9rZS1saW5lY2FwPVwicm91bmRcIiBzdHJva2UtbGluZWpvaW49XCJyb3VuZFwiIGNsYXNzPVwiZmVhdGhlciBmZWF0aGVyLXBsYXlcIj48cG9seWdvbiBwb2ludHM9XCI1IDMgMTkgMTIgNSAyMSA1IDNcIj48L3BvbHlnb24+PC9zdmc+PC9kaXY+PC9kaXY+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIHpXc2NFIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+TmFib2tyYW5nZWxlbiBnw6VyPC9zcGFuPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgYmVETnBaIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+dmVyZGVuIHJ1bmR0OiAtIEdydXNvbXQ8L3NwYW4+PC9oMz48L2hlYWRlcj48L2E+PC9hcnRpY2xlPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTQgbWVkaXVtLTQgbGFyZ2UtNFwiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJwbHVzcy1tb2RlbC1mcm9udFwiIGRhdGEtbGFiZWw9XCJwbHVzc1wiIGRhdGEtZnJvbT1cInhhdmllclwiIGRhdGEtcmV2ZXJzZUltYWdlVGV4dE9yZGVyPVwiZmFsc2VcIj48YSB0YXJnZXQ9XCJfc2VsZlwiIGFyaWEtbGFiZWw9XCJBcnZlZmVsbGE6IExpbGxlc8O4c3RlciBmaWtrIG92ZXJmw7hydCBmYW1pbGllaHl0dGFcIiBocmVmPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL3RlbWEvYXJ2ZWZlbGxhLWxpbGxlc29zdGVyLWZpa2stb3ZlcmZvcnQtZmFtaWxpZWh5dHRhLzgwOTYzNjI1XCI+PGZpZ3VyZSBjbGFzcz1cInhfX3NjLTFhbjd2dTEtMCBiWkljT2RcIj48cGljdHVyZT48aW1nIGRhdGEtZGVmZXI9XCJ2aWV3XCIgdGl0bGU9XCJJbWFnZTogQXJ2ZWZlbGxhOiBMaWxsZXPDuHN0ZXIgZmlrayBvdmVyZsO4cnQgZmFtaWxpZWh5dHRhXCIgYWx0PVwiSW1hZ2U6IEFydmVmZWxsYTogTGlsbGVzw7hzdGVyIGZpa2sgb3ZlcmbDuHJ0IGZhbWlsaWVoeXR0YVwiIGRlY29kaW5nPVwiYXN5bmNcIiBjbGFzcz1cImxhenlsb2FkXCIgZGF0YS1zcmM9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vaW1hZ2VzLz9pbWFnZUlkPTgwOTYzNjMwJmFtcDtwYW5veT0yNi45NTAzNTQ2MDk5MjkmYW1wO3Bhbm94PTAmYW1wO3Bhbm93PTk5Ljg0Mjc2Njk4MTEzMiZhbXA7cGFub2g9NTEuNTM2NjQyNTUzMTkxJmFtcDtoZWlnaHR3PTQxLjEwNjEyODI1MTEyMSZhbXA7aGVpZ2h0aD05OS43NzYyODU5MDYwNCZhbXA7aGVpZ2h0eT0wLjIyMzcxNDA5Mzk1OTc0JmFtcDtoZWlnaHR4PTI3LjgwMjY5MDU4Mjk2JmFtcDt3aWR0aD0zMjAmYW1wO2hlaWdodD0xODkmYW1wO2NvbXByZXNzaW9uPTcwXCIgc3JjPVwiZGF0YTppbWFnZS9wbmc7YmFzZTY0LGlWQk9SdzBLR2dvQUFBQU5TVWhFVWdBQUFCQUFBQUFKQ0FZQUFBQTdLcXd5QUFBQUYwbEVRVlI0Mm1OOCsrYjlmd1lLQU9Pb0FhTUdBQUVBNHVraUNVQ2JXMGNBQUFBQVNVVk9SSzVDWUlJPVwiIGxvYWRpbmc9XCJsYXp5XCIgZmV0Y2hQcmlvcml0eT1cImF1dG9cIi8+PC9waWN0dXJlPjxkaXYgY2xhc3M9XCJmaWd1cmUtbG9nb1wiPjxkaXYgY2xhc3M9XCJsb2dvXCI+PHN2ZyB4bWxucz1cImh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnXCIgd2lkdGg9XCIyNFwiIGhlaWdodD1cIjI0XCIgdmlld0JveD1cIjAgMCAyNCAyNFwiIGZpbGw9XCJub25lXCIgc3Ryb2tlPVwiY3VycmVudENvbG9yXCIgc3Ryb2tlLXdpZHRoPVwiM1wiPjxsaW5lIHgxPVwiMTJcIiB5MT1cIjVcIiB4Mj1cIjEyXCIgeTI9XCIxOVwiPjwvbGluZT48bGluZSB4MT1cIjVcIiB5MT1cIjEyXCIgeDI9XCIxOVwiIHkyPVwiMTJcIj48L2xpbmU+PC9zdmc+PC9kaXY+PC9kaXY+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGdnVVNvbiB0aXRsZSBkeW5hbWljLXNpemluZ1wiPkFydmVmZWxsYTogTGlsbGVzw7hzdGVyPC9zcGFuPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgaHBRU2dsIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+ZmlrayBvdmVyZsO4cnQgZmFtaWxpZWh5dHRhPC9zcGFuPjwvaDM+PC9oZWFkZXI+PC9hPjwvYXJ0aWNsZT48ZGl2IGlkPVwiYXBvcy1tZWRpdW0tcmVjdGFuZ2xlMTBcIiBjbGFzcz1cImFkdW5pdC13cmFwcGVyIGNvbHVtbnMgc21hbGwtNCBtZWRpdW0tNCBsYXJnZS00IHRyYWNrLWVsZW1lbnQgIFwiIGRhdGEtZnJvbT1cInhhdmllclwiPjxkaXYgaWQ9XCJhZC1tZWRpdW0tcmVjdGFuZ2xlMTBcIiBjbGFzcz1cImFkdW5pdCBHb29nbGVBY3RpdmVWaWV3RWxlbWVudCBzbWFsbC0zMjB4MjUwIG1lZGl1bS0zMjB4MjUwIGxhcmdlLTMyMHgyNTBcIiBpdGVtc2NvcGU9XCJcIiBpdGVtVHlwZT1cImh0dHBzOi8vc2NoZW1hLm9yZy9XUEFkQmxvY2tcIiBkYXRhLXNpemVzPVwiW1szMjAsMjUwXSxbMzAwLDI1MF0sJnF1b3Q7Zmx1aWQmcXVvdDtdXCIgZGF0YS1zbG90PVwiLzg1NzgvZGFnYmxhZGV0Lm5vL2ZvcnNpZGVcIiBkYXRhLWxvYWQtb249XCJ2aWV3XCIgZGF0YS1jb2xsYXBzZT1cImZhbHNlXCIgZGF0YS1leHBhbmQ9XCJmYWxzZVwiIGRhdGEtb3V0LW9mLXBhZ2U9XCJmYWxzZVwiIGpzb249XCJ7JnF1b3Q7dGFyZ2V0aW5nJnF1b3Q7OiB7JnF1b3Q7cG9zJnF1b3Q7OiZxdW90O21lZGl1bS1yZWN0YW5nbGUxMCZxdW90OywmcXVvdDtwbGF0Zm9ybSZxdW90OzomcXVvdDt3b2x2ZXJpbmUmcXVvdDt9fVwiPjwvZGl2PjwvZGl2PjwvZGl2PjxkaXYgY2xhc3M9XCJyb3cgeHJvdyBmbGV4LWluaXRpYWxcIj48ZGl2IGNsYXNzPVwieGF2aWVyIGNvbHVtbnMgc21hbGwtNCBtZWRpdW0tNCBsYXJnZS00XCI+PGRpdiBjbGFzcz1cInJvdyB4cm93IGZsZXgtY29sdW1uXCI+PGFydGljbGUgY2xhc3M9XCJwcmV2aWV3IGNvbHVtbnMgc21hbGwtMTIgbWVkaXVtLTEyIGxhcmdlLTEyXCIgZGF0YS1jeGVuc2VfdGFnPVwiY2VyZWJyb1wiIGRhdGEtY3hlbmNlX3dpZGdldD1cInZpZGVvLW1ldGFwb3AtbW9kZWxcIiBkYXRhLWxhYmVsPVwidmlkZW9cIiBkYXRhLWZyb209XCJ4YXZpZXJcIiBkYXRhLXJldmVyc2VJbWFnZVRleHRPcmRlcj1cImZhbHNlXCI+PGEgdGFyZ2V0PVwiX3NlbGZcIiBhcmlhLWxhYmVsPVwiLSBIYSBkZWcgdGlsIGhlbHZldGUgdmVrayFcIiBocmVmPVwiaHR0cHM6Ly93d3cuZGFnYmxhZGV0Lm5vL3ZpZGVvLy1oYS1kZWctdGlsLWhlbHZldGUtdmVray9DMnFubGZDMFwiPjxmaWd1cmUgY2xhc3M9XCJ4X19zYy0xYW43dnUxLTAgZmpKeXZFXCI+PHBpY3R1cmU+PGltZyBkYXRhLWRlZmVyPVwidmlld1wiIHRpdGxlPVwiSW1hZ2U6IC0gSGEgZGVnIHRpbCBoZWx2ZXRlIHZla2shXCIgYWx0PVwiSW1hZ2U6IC0gSGEgZGVnIHRpbCBoZWx2ZXRlIHZla2shXCIgZGVjb2Rpbmc9XCJhc3luY1wiIGNsYXNzPVwibGF6eWxvYWRcIiBkYXRhLXNyYz1cImh0dHBzOi8vY2RuLmp3cGxheWVyLmNvbS90aHVtYnMvQzJxbmxmQzAtNzIwLmpwZ1wiIHNyYz1cImRhdGE6aW1hZ2UvcG5nO2Jhc2U2NCxpVkJPUncwS0dnb0FBQUFOU1VoRVVnQUFBQkFBQUFBSkNBWUFBQUE3S3F3eUFBQUFGMGxFUVZSNDJtTjgrK2I5ZndZS0FPT29BYU1HQUFFQTR1a2lDVUNiVzBjQUFBQUFTVVZPUks1Q1lJST1cIiBsb2FkaW5nPVwibGF6eVwiIGZldGNoUHJpb3JpdHk9XCJhdXRvXCIvPjwvcGljdHVyZT48ZGl2IGNsYXNzPVwiZmlndXJlLWxvZ29cIj48ZGl2IGNsYXNzPVwibG9nb1wiPjxzdmcgeG1sbnM9XCJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2Z1wiIHdpZHRoPVwiMjRcIiBoZWlnaHQ9XCIyNFwiIHZpZXdCb3g9XCIwIDAgMjQgMjRcIiBmaWxsPVwiY3VycmVudENvbG9yXCIgc3Ryb2tlPVwiY3VycmVudENvbG9yXCIgc3Ryb2tlLXdpZHRoPVwiMlwiIHN0cm9rZS1saW5lY2FwPVwicm91bmRcIiBzdHJva2UtbGluZWpvaW49XCJyb3VuZFwiIGNsYXNzPVwiZmVhdGhlciBmZWF0aGVyLXBsYXlcIj48cG9seWdvbiBwb2ludHM9XCI1IDMgMTkgMTIgNSAyMSA1IDNcIj48L3BvbHlnb24+PC9zdmc+PC9kaXY+PC9kaXY+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGJXU25WUyB0aXRsZSBkeW5hbWljLXNpemluZ1wiPi0gSGEgZGVnIHRpbDwvc3Bhbj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGdQSXhlYSB0aXRsZSBkeW5hbWljLXNpemluZ1wiPmhlbHZldGUgdmVrayE8L3NwYW4+PC9oMz48L2hlYWRlcj48L2E+PC9hcnRpY2xlPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTEyIG1lZGl1bS0xMiBsYXJnZS0xMlwiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJwbHVzcy1tb2RlbC1mcm9udFwiIGRhdGEtbGFiZWw9XCJwbHVzc1wiIGRhdGEtZnJvbT1cInhhdmllclwiIGRhdGEtcmV2ZXJzZUltYWdlVGV4dE9yZGVyPVwiZmFsc2VcIj48YSB0YXJnZXQ9XCJfc2VsZlwiIGFyaWEtbGFiZWw9XCJGaWJyb215YWxnaTogRWZmZWt0aXZ0IG1vdCBzbWVydGVyXCIgaHJlZj1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby90ZW1hL2ZpYnJvbXlhbGdpLWVmZmVrdGl2dC1tb3Qtc21lcnRlci84MTM0MjU3OFwiPjxmaWd1cmUgY2xhc3M9XCJ4X19zYy0xYW43dnUxLTAgZmpKeXZFXCI+PHBpY3R1cmU+PGltZyBkYXRhLWRlZmVyPVwidmlld1wiIHRpdGxlPVwiSW1hZ2U6IEZpYnJvbXlhbGdpOiBFZmZla3RpdnQgbW90IHNtZXJ0ZXJcIiBhbHQ9XCJJbWFnZTogRmlicm9teWFsZ2k6IEVmZmVrdGl2dCBtb3Qgc21lcnRlclwiIGRlY29kaW5nPVwiYXN5bmNcIiBjbGFzcz1cImxhenlsb2FkXCIgZGF0YS1zcmM9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vaW1hZ2VzLz9pbWFnZUlkPTgxMzY1NTUzJmFtcDtwYW5veT0wJmFtcDtwYW5veD0wJmFtcDtwYW5vdz0xMDAmYW1wO3Bhbm9oPTEwMCZhbXA7aGVpZ2h0eT0wJmFtcDtoZWlnaHR3PTEwMCZhbXA7aGVpZ2h0aD0xMDAmYW1wO2hlaWdodHg9MCZhbXA7d2lkdGg9MzIwJmFtcDtoZWlnaHQ9MTYwJmFtcDtjb21wcmVzc2lvbj03MFwiIHNyYz1cImRhdGE6aW1hZ2UvcG5nO2Jhc2U2NCxpVkJPUncwS0dnb0FBQUFOU1VoRVVnQUFBQkFBQUFBSkNBWUFBQUE3S3F3eUFBQUFGMGxFUVZSNDJtTjgrK2I5ZndZS0FPT29BYU1HQUFFQTR1a2lDVUNiVzBjQUFBQUFTVVZPUks1Q1lJST1cIiBsb2FkaW5nPVwibGF6eVwiIGZldGNoUHJpb3JpdHk9XCJhdXRvXCIvPjwvcGljdHVyZT48ZGl2IGNsYXNzPVwiZmlndXJlLWxvZ29cIj48ZGl2IGNsYXNzPVwibG9nb1wiPjxzdmcgeG1sbnM9XCJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2Z1wiIHdpZHRoPVwiMjRcIiBoZWlnaHQ9XCIyNFwiIHZpZXdCb3g9XCIwIDAgMjQgMjRcIiBmaWxsPVwibm9uZVwiIHN0cm9rZT1cImN1cnJlbnRDb2xvclwiIHN0cm9rZS13aWR0aD1cIjNcIj48bGluZSB4MT1cIjEyXCIgeTE9XCI1XCIgeDI9XCIxMlwiIHkyPVwiMTlcIj48L2xpbmU+PGxpbmUgeDE9XCI1XCIgeTE9XCIxMlwiIHgyPVwiMTlcIiB5Mj1cIjEyXCI+PC9saW5lPjwvc3ZnPjwvZGl2PjwvZGl2PjwvZmlndXJlPjxoZWFkZXI+PGgzIGNsYXNzPVwieGF2aWVyLWhlYWRsaW5lIGhlYWRsaW5lXCI+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBqaUdWVmogdGl0bGUgZHluYW1pYy1zaXppbmdcIj5GaWJyb215YWxnaTo8L3NwYW4+PHNwYW4gY2xhc3M9XCJ4X19wdDh0emstMCBrd0x1YUIgdGl0bGUgZHluYW1pYy1zaXppbmdcIj5FZmZla3RpdnQgbW90IHNtZXJ0ZXI8L3NwYW4+PC9oMz48L2hlYWRlcj48L2E+PC9hcnRpY2xlPjwvZGl2PjwvZGl2PjxkaXYgaWQ9XCJhcG9zLW5ldGJvYXJkMTJcIiBjbGFzcz1cImFkdW5pdC13cmFwcGVyIGNvbHVtbnMgc21hbGwtOCBtZWRpdW0tOCBsYXJnZS04IHRyYWNrLWVsZW1lbnQgIFwiIGRhdGEtZnJvbT1cInhhdmllclwiPjxkaXYgaWQ9XCJhZC1uZXRib2FyZDEyXCIgY2xhc3M9XCJhZHVuaXQgR29vZ2xlQWN0aXZlVmlld0VsZW1lbnQgc21hbGwtNTgweDUwMCBtZWRpdW0tNTgweDUwMCBsYXJnZS01ODB4NTAwXCIgaXRlbXNjb3BlPVwiXCIgaXRlbVR5cGU9XCJodHRwczovL3NjaGVtYS5vcmcvV1BBZEJsb2NrXCIgZGF0YS1zaXplcz1cIltbNTgwLDQwMF0sWzU4MCw1MDBdLCZxdW90O2ZsdWlkJnF1b3Q7XVwiIGRhdGEtc2xvdD1cIi84NTc4L2RhZ2JsYWRldC5uby9mb3JzaWRlXCIgZGF0YS1sb2FkLW9uPVwidmlld1wiIGRhdGEtY29sbGFwc2U9XCJmYWxzZVwiIGRhdGEtZXhwYW5kPVwiZmFsc2VcIiBkYXRhLW91dC1vZi1wYWdlPVwiZmFsc2VcIiBqc29uPVwieyZxdW90O3RhcmdldGluZyZxdW90OzogeyZxdW90O3BvcyZxdW90OzomcXVvdDtuZXRib2FyZDEyJnF1b3Q7LCZxdW90O3BsYXRmb3JtJnF1b3Q7OiZxdW90O3dvbHZlcmluZSZxdW90O319XCI+PC9kaXY+PC9kaXY+PC9kaXY+PGRpdiBjbGFzcz1cInJvdyB4cm93IGZsZXgtaW5pdGlhbFwiPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTQgbWVkaXVtLTQgbGFyZ2UtNFwiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJ2aWRlby1tZXRhcG9wLW1vZGVsXCIgZGF0YS1sYWJlbD1cInZpZGVvXCIgZGF0YS1mcm9tPVwieGF2aWVyXCIgZGF0YS1yZXZlcnNlSW1hZ2VUZXh0T3JkZXI9XCJmYWxzZVwiPjxhIHRhcmdldD1cIl9zZWxmXCIgYXJpYS1sYWJlbD1cIlBhc3Nhc2plcmVuIHJhc2VyIC0gc8OlIHNramVyIGRldHRlXCIgaHJlZj1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby92aWRlby9wYXNzYXNqZXJlbi1yYXNlci1zYS1za2plci1kZXR0ZS96VW82dnh4Z1wiPjxmaWd1cmUgY2xhc3M9XCJ4X19zYy0xYW43dnUxLTAgZ2pBb2xyXCI+PHBpY3R1cmU+PGltZyBkYXRhLWRlZmVyPVwidmlld1wiIHRpdGxlPVwiSW1hZ2U6IFBhc3Nhc2plcmVuIHJhc2VyIC0gc8OlIHNramVyIGRldHRlXCIgYWx0PVwiSW1hZ2U6IFBhc3Nhc2plcmVuIHJhc2VyIC0gc8OlIHNramVyIGRldHRlXCIgZGVjb2Rpbmc9XCJhc3luY1wiIGNsYXNzPVwibGF6eWxvYWRcIiBkYXRhLXNyYz1cImh0dHBzOi8vY2RuLmp3cGxheWVyLmNvbS90aHVtYnMvelVvNnZ4eGctNzIwLmpwZ1wiIHNyYz1cImRhdGE6aW1hZ2UvcG5nO2Jhc2U2NCxpVkJPUncwS0dnb0FBQUFOU1VoRVVnQUFBQkFBQUFBSkNBWUFBQUE3S3F3eUFBQUFGMGxFUVZSNDJtTjgrK2I5ZndZS0FPT29BYU1HQUFFQTR1a2lDVUNiVzBjQUFBQUFTVVZPUks1Q1lJST1cIiBsb2FkaW5nPVwibGF6eVwiIGZldGNoUHJpb3JpdHk9XCJhdXRvXCIvPjwvcGljdHVyZT48ZGl2IGNsYXNzPVwiZmlndXJlLWxvZ29cIj48ZGl2IGNsYXNzPVwibG9nb1wiPjxzdmcgeG1sbnM9XCJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2Z1wiIHdpZHRoPVwiMjRcIiBoZWlnaHQ9XCIyNFwiIHZpZXdCb3g9XCIwIDAgMjQgMjRcIiBmaWxsPVwiY3VycmVudENvbG9yXCIgc3Ryb2tlPVwiY3VycmVudENvbG9yXCIgc3Ryb2tlLXdpZHRoPVwiMlwiIHN0cm9rZS1saW5lY2FwPVwicm91bmRcIiBzdHJva2UtbGluZWpvaW49XCJyb3VuZFwiIGNsYXNzPVwiZmVhdGhlciBmZWF0aGVyLXBsYXlcIj48cG9seWdvbiBwb2ludHM9XCI1IDMgMTkgMTIgNSAyMSA1IDNcIj48L3BvbHlnb24+PC9zdmc+PC9kaXY+PC9kaXY+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGlZZ0J2QSB0aXRsZSBkeW5hbWljLXNpemluZ1wiPlBhc3Nhc2plcmVuIHJhc2VyPC9zcGFuPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgaUZsRW1LIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+LSBzw6Ugc2tqZXIgZGV0dGU8L3NwYW4+PC9oMz48L2hlYWRlcj48L2E+PC9hcnRpY2xlPjxhcnRpY2xlIGNsYXNzPVwicHJldmlldyBjb2x1bW5zIHNtYWxsLTQgbWVkaXVtLTQgbGFyZ2UtNFwiIGRhdGEtY3hlbnNlX3RhZz1cImNlcmVicm9cIiBkYXRhLWN4ZW5jZV93aWRnZXQ9XCJwbHVzcy1tb2RlbC1mcm9udFwiIGRhdGEtbGFiZWw9XCJwbHVzc1wiIGRhdGEtZnJvbT1cInhhdmllclwiIGRhdGEtcmV2ZXJzZUltYWdlVGV4dE9yZGVyPVwiZmFsc2VcIj48YSB0YXJnZXQ9XCJfc2VsZlwiIGFyaWEtbGFiZWw9XCJEZWxlciBtZXRvZGVuOiBLaWxvZW5lIHJhc3RlXCIgaHJlZj1cImh0dHBzOi8vd3d3LmRhZ2JsYWRldC5uby90ZW1hL2RlbGVyLW1ldG9kZW4ta2lsb2VuZS1yYXN0ZS84MTE1NTQwNFwiPjxmaWd1cmUgY2xhc3M9XCJ4X19zYy0xYW43dnUxLTAgZmpKeXZFXCI+PHBpY3R1cmU+PGltZyBkYXRhLWRlZmVyPVwidmlld1wiIHRpdGxlPVwiSW1hZ2U6IERlbGVyIG1ldG9kZW46IEtpbG9lbmUgcmFzdGVcIiBhbHQ9XCJJbWFnZTogRGVsZXIgbWV0b2RlbjogS2lsb2VuZSByYXN0ZVwiIGRlY29kaW5nPVwiYXN5bmNcIiBjbGFzcz1cImxhenlsb2FkXCIgZGF0YS1zcmM9XCJodHRwczovL3d3dy5kYWdibGFkZXQubm8vaW1hZ2VzLz9pbWFnZUlkPTgxMTczMTQ3JmFtcDtwYW5vdz01NS41NTU1NTU3MzMzMzMmYW1wO3Bhbm9oPTc4LjM4ODI3OTEyMDg3OSZhbXA7cGFub3k9Ny42OTIzMDc2OTIzMDc3JmFtcDtwYW5veD0yMS44NjY2NjY2NjY2NjcmYW1wO2hlaWdodHk9MS4yNSZhbXA7aGVpZ2h0eD01MS4wMDc3NTE5Mzc5ODQmYW1wO2hlaWdodHc9MTMuODUwMTI5MzAyMzI2JmFtcDtoZWlnaHRoPTkxLjQ1ODMzMzc1JmFtcDt3aWR0aD0zMjAmYW1wO2hlaWdodD0xNjAmYW1wO2NvbXByZXNzaW9uPTcwXCIgc3JjPVwiZGF0YTppbWFnZS9wbmc7YmFzZTY0LGlWQk9SdzBLR2dvQUFBQU5TVWhFVWdBQUFCQUFBQUFKQ0FZQUFBQTdLcXd5QUFBQUYwbEVRVlI0Mm1OOCsrYjlmd1lLQU9Pb0FhTUdBQUVBNHVraUNVQ2JXMGNBQUFBQVNVVk9SSzVDWUlJPVwiIGxvYWRpbmc9XCJsYXp5XCIgZmV0Y2hQcmlvcml0eT1cImF1dG9cIi8+PC9waWN0dXJlPjxkaXYgY2xhc3M9XCJmaWd1cmUtbG9nb1wiPjxkaXYgY2xhc3M9XCJsb2dvXCI+PHN2ZyB4bWxucz1cImh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnXCIgd2lkdGg9XCIyNFwiIGhlaWdodD1cIjI0XCIgdmlld0JveD1cIjAgMCAyNCAyNFwiIGZpbGw9XCJub25lXCIgc3Ryb2tlPVwiY3VycmVudENvbG9yXCIgc3Ryb2tlLXdpZHRoPVwiM1wiPjxsaW5lIHgxPVwiMTJcIiB5MT1cIjVcIiB4Mj1cIjEyXCIgeTI9XCIxOVwiPjwvbGluZT48bGluZSB4MT1cIjVcIiB5MT1cIjEyXCIgeDI9XCIxOVwiIHkyPVwiMTJcIj48L2xpbmU+PC9zdmc+PC9kaXY+PC9kaXY+PC9maWd1cmU+PGhlYWRlcj48aDMgY2xhc3M9XCJ4YXZpZXItaGVhZGxpbmUgaGVhZGxpbmVcIj48c3BhbiBjbGFzcz1cInhfX3B0OHR6ay0wIGpmdk1XSiB0aXRsZSBkeW5hbWljLXNpemluZ1wiPkRlbGVyIG1ldG9kZW46PC9zcGFuPjxzcGFuIGNsYXNzPVwieF9fcHQ4dHprLTAgZ1BJeGVhIHRpdGxlIGR5bmFtaWMtc2l6aW5nXCI+S2lsb2VuZSByYXN0ZTwvc3Bhbj48L2gzPjwvaGVhZGVyPjwvYT48L2FydGljbGU+PGRpdiBpZD1cImFwb3MtbWVkaXVtLXJlY3RhbmdsZTExXCIgY2xhc3M9XCJhZHVuaXQtd3JhcHBlciBjb2x1bW5zIHNtYWxsLTQgbWVkaXVtLTQgbGFyZ2UtNCB0cmFjay1lbGVtZW50ICBcIiBkYXRhLWZyb209XCJ4YXZpZXJcIj48ZGl2IGlkPVwiYWQtbWVkaXVtLXJlY3RhbmdsZTExXCIgY2xhc3M9XCJhZHVuaXQgR29vZ2xlQWN0aXZlVmlld0VsZW1lbnQgc21hbGwtMzIweDI1MCBtZWRpdW0tMzIweDI1MCBsYXJnZS0zMjB4MjUwXCIgaXRlbXNjb3BlPVwiXCIgaXRlbVR5cGU9XCJodHRwczovL3NjaGVtYS5vcmcvV1BBZEJsb2NrXCIgZGF0YS1zaXplcz1cIltbMzIwLDI1MF0sWzMwMCwyNTBdLCZxdW90O2ZsdWlkJnF1b3Q7XVwiIGRhdGEtc2xvdD1cIi84NTc4L2RhZ2JsYWRldC5uby9mb3JzaWRlXCIgZGF0YS1sb2FkLW9uPVwidmlld1wiIGRhdGEtY29sbGFwc2U9XCJmYWxzZVwiIGRhdGEtZXhwYW5kPVwiZmFsc2VcIiBkYXRhLW91dC1vZi1wYWdlPVwiZmFsc2VcIiBqc29uPVwieyZxdW90O3RhcmdldGluZyZxdW90OzogeyZxdW90O3BvcyZxdW90OzomcXVvdDttZWRpdW0tcmVjdGFuZ2xlMTEmcXVvdDssJnF1b3Q7cGxhdGZvcm0mcXVvdDs6JnF1b3Q7d29sdmVyaW5lJnF1b3Q7fX1cIj48L2Rpdj48L2Rpdj48L2Rpdj4iXQ==