YTo2OntpOjA7czo4ODMwOiIJCQkJPHNlY3Rpb24gaWQ9Im1pZGRsZSI+DQoJCQkJPGRpdiBjbGFzcz0id3JhcCIgaWQ9ImJvZHlGb3JtYXQxIj4NCgkJCQk8ZGl2IGNsYXNzPSJyb3cxIGR0IGNvbHVtbnMyMyI+PCEtLU1JRERMRSBST1cxIFNUQVJUUy0tPg0KCQkJCTxkaXYgY2xhc3M9ImNvbC0yIHdpZGVDb2x1bW4gaXAgbHMgZGV0YWlsX3BtXzE1Ij48IS0tTUlERExFIFJPVzEgQ09MLTIgU1RBUlRTLS0+DQoJCQkJDQoJCQkJCQkJCQk8ZGl2IGNsYXNzPSJoMSI+PGgxPlNlcnZpY2UgQ3JldyAvIEFzc3QuIFdhaXRlciAvIENvdW50ZXIgU3RhZmYvIEtpdGNoZW4gSGVscGVyPC9oMT48L2Rpdj4NCgkJCQkJPHAgY2xhc3M9ImJyZWFkY3J1bWIgYXIgdXUgc21hbGwiPiA8YSBocmVmPSJodHRwOi8vd3d3LmhvcGVzZm9yZXZlci5jb20vIj5Ib21lPC9hPg0KCQkJCQkNCgkJCQkJCQkJCQkJPGIgY2xhc3M9ImZmdiBwMnB4Ij4mcnNhcXVvOzwvYj48YSBocmVmPSJodHRwOi8vd3d3LmhvcGVzZm9yZXZlci5jb20vY3VycmVudC1qb2JzLmh0bSIgdGl0bGU9IkN1cnJlbnQgSm9icyI+Q3VycmVudCBKb2JzPC9hPiAgCQkJDQoJCQkJCQkJCQkJCQ0KCQkJCQk8YiBjbGFzcz0iZmZ2IHAycHgiPiZyc2FxdW87PC9iPiBTZXJ2aWNlIENyZXcgLyBBc3N0LiBXYWl0ZXIgLyBDb3VudGVyIFN0YWZmLyBLaXRjaGVuIEhlbHBlcjwvcD4NCgkJCQkJCQkJCTxwIGNsYXNzPSJtYjVweCI+PGkgY2xhc3M9ImZhIGZhLWJyaWVmY2FzZSBtcjdweCBmbCB3MTVweCBhbHBoYTUwIj48L2k+IEZyZXNoZXI8L3A+DQoJCQkJDQoJCQkJCQkJCQkNCgkJCQkJPGRpdj4NCgkJCQkJPGZvcm0gbmFtZT0iZnJtdmFjZGV0YWlsIiBtZXRob2Q9InBvc3QiIGFjdGlvbj0iZW5xdWlyeS1mb3JtLTEwMDA5Lmh0bSI+DQoJCQkJCTxpbnB1dCBzdHlsZT0icGFkZGluZzo3cHggMTVweDsiIGNsYXNzPSJidXR0b24gYiBmZm9zIiB0eXBlPSJzdWJtaXQiIHZhbHVlPSJBUFBMWSBOT1cgISIgLz4NCgkJCQkJPGlucHV0IHR5cGU9ImhpZGRlbiIgbmFtZT0iY2F0YWxvZ19taSIgdmFsdWU9IjI5NjE1NSI+DQoJCQkJCTxpbnB1dCB0eXBlPSJoaWRkZW4iIG5hbWU9ImVucV90eXBlIiB2YWx1ZT0iMiI+PGlucHV0IHR5cGU9ImhpZGRlbiIgbmFtZT0idmFjYW5jeV9pZCIgdmFsdWU9IjM2MDY1MiI+PGlucHV0IHR5cGU9ImhpZGRlbiIgbmFtZT0ic3ViamVjdCIgdmFsdWU9IkFwcGxpZWQgZm9yIFNlcnZpY2UgQ3JldyAvIEFzc3QuIFdhaXRlciAvIENvdW50ZXIgc3RhZmYvIEtpdGNoZW4gSGVscGVyIj4NCgkJCQkJPC9mb3JtPg0KCQkJCQk8L2Rpdj4NCgkJCQ0KCQkJCQkJDQoJCQkJDQoJCQkJPGJyPg0KCQkJCTxkaXYgY2xhc3M9ImJkclQgcHQyMHB4Ij4NCgkJCQk8cCBjbGFzcz0ieGxhcmdlIGIiPkpvYiBEZXNjcmlwdGlvbjwvcD4NCgkJCQk8cCBjbGFzcz0iYWogbXQxMHB4Ij5RdWFsaWZpY2F0aW9uOiBTU0MvSFNDIOKAk1BBU1MvRkFJTCBDYW4gQXBwbHkgPGJyIC8+CkV4cGVyaWVuY2U6IEZyZXNoZXIgJiBFeHBlcmllbmNlZCBib3RoIGNhbiBBcHBseSAoT05MWSBNQUxFKSA8YnIgLz4KRHV0eTogMTAgSG91cnMgKEluY2x1ZGluZyBMdW5jaCAmIFByYXllciBUaW1lKSAvIDYgRGF5IGEgd2VlazxiciAvPgpDb250cmFjdCBQZXJpb2Q6IDIgeWVhcnM8YnIgLz4KQWdlIExpbWl0OiAyMi0zNSB5ZWFycyB3aXRoIHZhbGlkIFBhc3Nwb3J0IDxiciAvPgpJbmR1c3RyeSBUeXBlOiBGb29kIFJldGFpbDxiciAvPgpTQUxBUlkgOiA5MDBTUiszMDBTUihGb29kKSA9IDEyMDAgU1IgKDEwIGhycyBEdXR5KSAod2hpY2ggY29tZXMgdG8gYXBwcm94LiBJTlIgMjAsMDAwLz0gUE08YnIgLz4KPGJyIC8+CkRpcmVjdCBDbGllbnQgSW50ZXJ2aWV3IGF0IDxiciAvPgo8YnIgLz4KMXN0IEpVTkUgMjAxNSBhdCBNVU1CQUk8YnIgLz4KMm5kIEpVTkUgMjAxNSBhdCBIWURFUkFCQUQsPGJyIC8+CjNyZCBKVU5FIDIwMTUgYXQgQ09DSElOIDxiciAvPgo1dGggSlVORSAyMDE1IGF0IEtPTEtBVFRBPGJyIC8+CjxiciAvPgpKT0IgREVTQ1JJUFRJT046ICAgICAgIDxiciAvPgoxKSBUaGUgQ2FuZGlkYXRlcyB3aWxsIGJlIHdvcmtpbmcgYXMgU0VSVklDRSBDUkVXLyBBU1NULldBSVRFUi9DT1VOVEVSIFNUQUZGIEtJVENIRU4gSEVMUEVSIEZvciAiS1VEVSBSRVNUQVVSQU5UUyBPVVRMRVNUIGhlbHBpbmcgQW5kIEFzc2lzdGluZyBpbiBLaXRjaGVuIFdvcmtzLCBDdXR0aW5nLCBDaG9wcGluZyBBbmQgQ2xlYW5pbmcgKENsZWFuaW5nIEtpdGNoZW4gQXJlYSwgSW5zaWRlIEFuZCBPdXRzaWRlIFJlc3RhdXJhbnQgT3V0bGV0cyk8YnIgLz4KMikgVGhlIENhbmRpZGF0ZXMgd2lsbCBncmFkdWFsbHkgYmUgbWFkZSB0byB3b3JrIGFzIFNhbmR3aWNoIE1ha2VycyBPciBTYWxhZCBNYWtlcnMgVG8gYmUgd29ya2luZyBvbiBGcnllcnMgQW5kIEFzIENhc2hpZXJzLCBEZXBlbmRpbmcgb24gdGhlaXIgYWJpbGl0eSB0byBsZWFybiB0aGUgc2tpbGxzLjxiciAvPgozKSBUaGUgQ2FuZGlkYXRlcyBzaG91bGQgYmUgeW91bmcsIGdvb2QgbG9va2luZyAmIHByZXNlbnRhYmxlLjxiciAvPgo0KSBUaGUgQ2FuZGlkYXRlcyBzaG91bGQgYmUgYWJsZSB0byBzcGVhayAmIHVuZGVyc3RhbmQgQmFzaWMgRW5nbGlzaC48YnIgLz4KPGJyIC8+Ck9uIFNlbGVjdGlvbiwgVmlzYSAmIEFpciBUaWNrZXQgd2lsbCBiZSBwcm92aWRlZCBieSB0aGUgY2xpZW50LiA8YnIgLz4KPGJyIC8+CkJFTkVGSVRTIGF0IFNhdWRpIEFyYWJpYTogPGJyIC8+Ci0gQWNjb21tb2RhdGlvbiBieSBDb21wYW55PGJyIC8+Ci0gVHJhbnNwb3J0IGJ5IENvbXBhbnk8YnIgLz4KLSBNZWRpY2FsLyBJbnN1cmFuY2UgYnkgQ29tcGFueTxiciAvPgotIE90aGVyIEJlbmVmaXRzIEFzIFBlciBLU0EgTEFCT1VSIExBVzwvcD4NCgkJCQkNCgkJCQk8dGFibGUgY2xhc3M9IncxMDAgZm9ybVRhYmxlIGJkcjAgbXQxMHB4Ij4JCQkJDQoJCQkJCQkJCQkJCTx0cj4NCgkJCQkJCQk8dGQgY2xhc3M9IncyMiBhbHBoYTc1IHA1cHgiPlNhbGFyeTwvdGQ+DQoJCQkJCQkJPHRkIGNsYXNzPSJwNXB4Ij4gMSAgTGFjICA3NSBUaG91c2FuZCAgVG8gIDIgIExhYyAgMjUgVGhvdXNhbmQgIFAuQS48L3RkPg0KCQkJCQkJCTwvdHI+CQkJCQ0KCQkJCQkJCQkJCQkNCgkJCQkJPHRyPg0KCQkJCQk8dGQgY2xhc3M9IncyMiBhbHBoYTc1IHA1cHgiPkluZHVzdHJ5PC90ZD4NCgkJCQkJPHRkIGNsYXNzPSJwNXB4Ij5GcmVzaGVyIC8gVHJhaW5lZTwvdGQ+DQoJCQkJCTwvdHI+DQoJCQkJCQkJCQk8dHI+DQoJCQkJPHRkIGNsYXNzPSJ3MjIgYWxwaGE3NSBwNXB4Ij5Xb3JrIEV4cGVyaWVuY2U8L3RkPg0KCQkJCTx0ZCBjbGFzcz0icDVweCI+RnJlc2hlcjwvdGQ+DQoJCQkJPC90cj4NCgkJCQkJCQkJCTx0cj4NCgkJCQkJPHRkIGNsYXNzPSJ3MjIgYWxwaGE3NSBwNXB4Ij5RdWFsaWZpY2F0aW9uPC90ZD4NCgkJCQkJPHRkIGNsYXNzPSJwNXB4Ij5IaWdoZXIgU2Vjb25kYXJ5LCBWb2NhdGlvbmFsIENvdXJzZTwvdGQ+DQoJCQkJCTwvdHI+CQkJCQkNCgkJCQkJCQkJCQ0KCQkJCTwvdGFibGU+DQoJCQkJDQoJCQkJDQoJCQkJPC9kaXY+DQoJCQkJDQoJCQkJPGJyPg0KCQkJCTxkaXYgY2xhc3M9ImJkclQgcHQyMHB4Ij4NCgkJCQkJCQkJCTxwIGNsYXNzPSJ4bGFyZ2UgYiI+S2V5IFNraWxsczwvcD4NCgkJCQkJPGRpdiBjbGFzcz0ibXQxMHB4IGRpZiI+DQoJCQkJCQkJCQkJCTxzcGFuIGNsYXNzPSJibiBkaWIgcDVweDEwcHggYzJweCBoZWFkVnIgbXI3cHggbWI3cHgiPnNlcnZpY2UgY3Jldzwvc3Bhbj4NCgkJCQkJCQkJCQkJPC9kaXY+DQoJCQkJCQkJCQk8L2Rpdj4NCgkJCQkNCgkJCQkNCgkJCQk8YnI+DQoJCQkJPGRpdiBjbGFzcz0iYmRyVCBwdDIwcHgiPg0KCQkJCTxwIGNsYXNzPSJ4bGFyZ2UgYiI+Q29tcGFueSBQcm9maWxlPC9wPg0KCQkJCTxkaXYgY2xhc3M9Im10MTBweCI+DQoJCQkJDQoJCQkJCQkJCQk8dGFibGUgY2xhc3M9IncxMDAgZm9ybVRhYmxlIGJkcjAgbXQ1cHgiPg0KCQkJCQkJCQkJCQk8dHI+DQoJCQkJCQk8dGQgY2xhc3M9IncyMiBhbHBoYTc1IHA1cHggdmF0Ij5Db21wYW55IE5hbWU8L3RkPg0KCQkJCQkJPHRkIGNsYXNzPSJwNXB4IHZhdCI+PHAgY2xhc3M9ImRpZiBiIj5IT1BFUyBGT1JFVkVSIENPTlNVTFRBTkNZIFBWVC4gTFRELjwvcD48L3RkPg0KCQkJCQkJPC90cj4NCgkJCQkJCQkJCQkJCTx0cj4NCgkJCQkJCTx0ZCBjbGFzcz0idzIyIGFscGhhNzUgcDVweCB2YXQiPkFib3V0IENvbXBhbnk8L3RkPg0KCQkJCQkJPHRkIGNsYXNzPSJwNXB4IHZhdCI+VGhlc2UgcmVxdWlyZW1lbnRzIGlzIGZvciBvdXIgYXNzb2NpYXRlJmFjaXJjO4CZcyBjbGllbnQgaW4gU0FVREkgQVJBQklBIFtGUkVFIFJFQ1JVSVRNRU5UXTwvdGQ+DQoJCQkJCQk8L3RyPg0KCQkJCQkJCQkJCQkJPHRyPg0KCQkJCQkJPHRkIGNsYXNzPSJ3MjIgYWxwaGE3NSBwNXB4Ij5Db250YWN0IFBlcnNvbjwvdGQ+DQoJCQkJCQk8dGQgY2xhc3M9InA1cHgiPkRISVJFTiBBREFOSTwvdGQ+DQoJCQkJCQk8L3RyPgkJCQkJDQoJCQkJCQkJCQkJCQk8dHI+DQoJCQkJCQk8dGQgY2xhc3M9IncyMiBhbHBoYTc1IHA1cHgiPk1vYmlsZSA8L3RkPg0KCQkJCQkJPHRkIGNsYXNzPSJwNXB4Ij45MS05ODIwODA1MjI1IDwvdGQ+DQoJCQkJCQk8L3RyPg0KCQkJCQkJCQkJCQkJPHRyPg0KCQkJCQkJPHRkIGNsYXNzPSJ3MjIgYWxwaGE3NSBwNXB4Ij5FbWFpbCBJRDwvdGQ+DQoJCQkJCQk8dGQgY2xhc3M9InA1cHgiPjxhIGhyZWY9Im1haWx0bzpkaGlyZW5AaG9wZXNmb3JldmVyLmNvbSI+IGRoaXJlbkBob3Blc2ZvcmV2ZXIuY29tIDwvYT48L3RkPg0KCQkJCQkJPC90cj4NCgkJCQkJCQkJCQkNCgkJCQkJPC90YWJsZT4NCgkJCQkJCQkJCQ0KCQkJCTxiciAvPg0KCQkJCQ0KCQkJCQkJCQkJDQoJCQkJCTxkaXYgY2xhc3M9ImJkclQgcHQyMHB4Ij4NCgkJCQkJPGZvcm0gbmFtZT0iZnJtdmFjZGV0YWlsIiBtZXRob2Q9InBvc3QiIGFjdGlvbj0iZW5xdWlyeS1mb3JtLTEwMDA5Lmh0bSI+DQoJCQkJCTxpbnB1dCBzdHlsZT0icGFkZGluZzo3cHggMTVweDsiIGNsYXNzPSJidXR0b24gYiBmZm9zIiB0eXBlPSJzdWJtaXQiIHZhbHVlPSJBUFBMWSBOT1cgISIgLz4NCgkJCQkJPGlucHV0IHR5cGU9ImhpZGRlbiIgbmFtZT0iY2F0YWxvZ19taSIgdmFsdWU9IjI5NjE1NSI+DQoJCQkJCTxpbnB1dCB0eXBlPSJoaWRkZW4iIG5hbWU9ImVucV90eXBlIiB2YWx1ZT0iMiI+PGlucHV0IHR5cGU9ImhpZGRlbiIgbmFtZT0idmFjYW5jeV9pZCIgdmFsdWU9IjM2MDY1MiI+PGlucHV0IHR5cGU9ImhpZGRlbiIgbmFtZT0ic3ViamVjdCIgdmFsdWU9IkFwcGxpZWQgZm9yIFNlcnZpY2UgQ3JldyAvIEFzc3QuIFdhaXRlciAvIENvdW50ZXIgc3RhZmYvIEtpdGNoZW4gSGVscGVyIj4NCgkJCQkJPC9mb3JtPg0KCQkJCQk8L2Rpdj4NCgkJCQ0KCQkJCQkJCQkJPC9kaXY+DQoJCQkJPC9kaXY+CQkJDQoJCQkJDQoJCQkJPCEtLU1JRERMRSBST1cxIENPTC0yIEVORFMtLT4gDQoJCQkJPC9kaXY+DQoJCQkJPGRpdiBjbGFzcz0iY29sLTMgdGhpbkNvbHVtbiI+PCEtLU1JRERMRSBST1cxIENPTC0xIFNUQVJUUy0tPg0KCQkJCQ0KCQkJCTxkaXYgY2xhc3M9ImNvbHVtbl9Cb3ggbWMiPg0KCQkJCTxkaXYgY2xhc3M9InRjbCBidWxsZXQgZGl2aWRlciI+DQoJCQkJPGRpdiBjbGFzcz0iaCBoMiI+PGIgY2xhc3M9InBsdXNNaW51cyI+PC9iPg0KCQkJCTxoMj5Kb2JzIGJ5IExvY2F0aW9uPC9oMj4NCgkJCQk8L2Rpdj4NCgkJCQk8ZGl2IGNsYXNzPSJpYyBzaG93SGlkZV9ycCI+DQoJCQkJPGRpdiBjbGFzcz0ibXQxMHB4Ij4NCgkJCQkJCQkJCTxzcGFuIGNsYXNzPSJkaWIgcDVweDEwcHggYzJweCBoZWFkVnIgbXI3cHggbWI3cHggIj48YSBjbGFzcz0iZGlmIiBocmVmPSJqb2JzLWluLW11bWJhaS5odG0iIHRpdGxlPSJKb2JzIGluIE11bWJhaSI+TXVtYmFpPC9hPiA8YiBjbGFzcz0iYWxwaGE1MCBibiBzbWFsbCI+KDMpPC9iPjwvc3Bhbj4NCgkJCQkJCQkJCQk8c3BhbiBjbGFzcz0iZGliIHA1cHgxMHB4IGMycHggaGVhZFZyIG1yN3B4IG1iN3B4ICI+PGEgY2xhc3M9ImRpZiIgaHJlZj0iam9icy1pbi1jaGVubmFpLmh0bSIgdGl0bGU9IkpvYnMgaW4gQ2hlbm5haSI+Q2hlbm5haTwvYT4gPGIgY2xhc3M9ImFscGhhNTAgYm4gc21hbGwiPigxKTwvYj48L3NwYW4+DQoJCQkJCQkJCQkJCTxzcGFuIGNsYXNzPSJkaWIgcDVweDEwcHggYzJweCBoZWFkVnIgbXI3cHggbWI3cHggIj48YSBjbGFzcz0iZGlmIiBocmVmPSJqb2JzLWluLXNhdWRpLWFyYWJpYS5odG0iIHRpdGxlPSJKb2JzIGluIFNhdWRpIEFyYWJpYSI+U2F1ZGkgQXJhYmlhPC9hPiA8YiBjbGFzcz0iYWxwaGE1MCBibiBzbWFsbCI+KDEpPC9iPjwvc3Bhbj4NCgkJCQkJCQkJCQk8L2Rpdj4NCgkJCQk8L2Rpdj4NCgkJCQk8L2Rpdj4NCgkJCQk8L2Rpdj4NCgkJCQkNCgkJCQk8ZGl2IGNsYXNzPSJjb2x1bW5fQm94IG1jIj4NCgkJCQk8ZGl2IGNsYXNzPSJ0Y2wgYnVsbGV0IGRpdmlkZXIiPg0KCQkJCTxkaXYgY2xhc3M9ImggaDIiPjxiIGNsYXNzPSJwbHVzTWludXMiPjwvYj4NCgkJCQk8aDI+Sm9icyBieSBGdW5jdGlvbmFsIEFyZWE8L2gyPg0KCQkJCTwvZGl2Pg0KCQkJCTxkaXYgY2xhc3M9ImljIHNob3dIaWRlX3JwIj4NCgkJCQk8ZGl2IGNsYXNzPSJtdDEwcHgiPg0KCQkJCQkJCQkJPHNwYW4gY2xhc3M9ImRpYiBwNXB4MTBweCBjMnB4IGhlYWRWciBtcjdweCBtYjdweCAiPjxhIGNsYXNzPSJkaWYiIGhyZWY9ImpvYnMtaW4tYmFua2luZy1maWQuaHRtIiB0aXRsZT0iQmFua2luZyAvIEludmVzdG1lbnRzIC8gU3RvY2sgTWFya2V0IC8gRmluYW5jaWFsIFNlcnZpY2VzIEpvYnMiPkJhbmtpbmcgLyBJbnZlc3RtZW50cyAvIFN0b2NrIE1hcmtldCAvIEZpbmFuY2lhbCBTZXJ2aWNlczwvYT4gPGIgY2xhc3M9ImFscGhhNTAgYm4gc21hbGwiPigyKTwvYj48L3NwYW4+DQoJCQkJCQkJCQkJPHNwYW4gY2xhc3M9ImRpYiBwNXB4MTBweCBjMnB4IGhlYWRWciBtcjdweCBtYjdweCAiPjxhIGNsYXNzPSJkaWYiIGhyZWY9ImpvYnMtaW4tZnJlc2gtZ3JhZHVhdGUtZmlkLmh0bSIgdGl0bGU9IkZyZXNoZXIgLyBUcmFpbmVlIEpvYnMiPkZyZXNoZXIgLyBUcmFpbmVlPC9hPiA8YiBjbGFzcz0iYWxwaGE1MCBibiBzbWFsbCI+KDEpPC9iPjwvc3Bhbj4NCgkJCQkJCQkJCQk8c3BhbiBjbGFzcz0iZGliIHA1cHgxMHB4IGMycHggaGVhZFZyIG1yN3B4IG1iN3B4ICI+PGEgY2xhc3M9ImRpZiIgaHJlZj0iam9icy1pbi1mcm9udC1vZmZpY2UtZGF0YS1lbnRyeS1maWQuaHRtIiB0aXRsZT0iRnJvbnQgT2ZmaWNlIC8gRXhlY3V0aXZlIEFzc2lzdGFudCAvIERhdGEgRW50cnkgSm9icyI+RnJvbnQgT2ZmaWNlIC8gRXhlY3V0aXZlIEFzc2lzdGFudCAvIERhdGEgRW50cnk8L2E+IDxiIGNsYXNzPSJhbHBoYTUwIGJuIHNtYWxsIj4oMSk8L2I+PC9zcGFuPg0KCQkJCQkJCQkJCTxzcGFuIGNsYXNzPSJkaWIgcDVweDEwcHggYzJweCBoZWFkVnIgbXI3cHggbWI3cHggIj48YSBjbGFzcz0iZGlmIiBocmVmPSJqb2JzLWluLWVjb21tZXJjZS1pbnRlcm5ldC1tYXJrZXRpbmctZmlkLmh0bSIgdGl0bGU9IklUIFNvZnR3YXJlIC0gRWNvbW1lcmNlIC8gSW50ZXJuZXQgVGVjaG5vbG9naWVzIEpvYnMiPklUIFNvZnR3YXJlIC0gRWNvbW1lcmNlIC8gSW50ZXJuZXQgVGVjaG5vbG9naWVzPC9hPiA8YiBjbGFzcz0iYWxwaGE1MCBibiBzbWFsbCI+KDEpPC9iPjwvc3Bhbj4NCgkJCQkJCQkJCQ0KCQkJCTwvZGl2Pg0KCQkJCTwvZGl2Pg0KCQkJCTwvZGl2Pg0KCQkJCTwvZGl2Pg0KCQkJCQ0KCQkJCTwvZGl2Pg0KCQkJCTwhLS1NSURETEUgUk9XMSBDT0wtMSBFTkRTLS0+DQoJCQkJDQoJCQkJPCEtLU1JRERMRSBST1cxIEVORFMtLT4gDQoJCQkJPC9kaXY+DQoJCQkJPGJyPjxicj4NCgkJCQk8L2Rpdj4NCgkJCQk8L3NlY3Rpb24+DQoJCQkJPHNjcmlwdD4NCgkJCQkJd2luZG93LmFkZEV2ZW50TGlzdGVuZXIoIkRPTUNvbnRlbnRMb2FkZWQiLCBmdW5jdGlvbigpew0KCQkJCQkJalF1ZXJ5KGRvY3VtZW50KS5vbigiY2xpY2siLCAiLnNob3dhbGxzcGFuIiwgZnVuY3Rpb24oKXsNCgkJCQkJCQlpZihqUXVlcnkodGhpcykuYXR0cigiZGF0YS10YXJnZXQiKSA9PT0gJ3Nob3cnKXsNCgkJCQkJCQkJalF1ZXJ5KHRoaXMpLnRleHQoIlZpZXcgTGVzcyIpOw0KCQkJCQkJCQlqUXVlcnkodGhpcykuYXR0cigiZGF0YS10YXJnZXQiLCAiaGlkZSIpOw0KCQkJCQkJCQlqUXVlcnkodGhpcykuY2xvc2VzdCgiZGl2IikuZmluZCgiLnNwYW5saXN0IikucmVtb3ZlQ2xhc3MoImRuIik7DQoJCQkJCQkJfWVsc2V7DQoJCQkJCQkJCWpRdWVyeSh0aGlzKS50ZXh0KCJWaWV3IE1vcmUiKTsNCgkJCQkJCQkJalF1ZXJ5KHRoaXMpLmF0dHIoImRhdGEtdGFyZ2V0IiwgInNob3ciKTsNCgkJCQkJCQkJalF1ZXJ5KHRoaXMpLmNsb3Nlc3QoImRpdiIpLmZpbmQoIi5zcGFubGlzdCIpLmFkZENsYXNzKCJkbiIpOw0KCQkJCQkJCX0NCgkJCQkJCX0pOw0KCQkJCQl9KTsNCgkJCQk8L3NjcmlwdD4NCgkJCQkJPHNjcmlwdD4NCgkkLmFqYXgoew0KCSAgdXJsOiAiaHR0cHM6Ly93d3cucGxhY2VtZW50aW5kaWEuY29tL2pvYl9wb3N0aW5nX3ZpZXcucGhwIiwNCgkgIHR5cGU6ICJQT1NUIiwNCgkgIGRhdGFUeXBlOiAnaHRtbCcsDQoJICBkYXRhOiB7am9iX3ZpZXdfaWQ6ICdMMXBxYzJsdWQxSXlkbXRRVDFaa1FraDZjMVl3ZHowOScsZGF0YV90eXBlOiAnUkV4elJtdzFjbVJzZGxoNllrSmxWVVpCTm5BNFVUMDknfSwNCgkgIGNhY2hlIDogZmFsc2UsDQoJICBhc3luYzogdHJ1ZQ0KCSAgDQoJfSkuZG9uZShmdW5jdGlvbihyZXNwKSB7DQoJICAvL2FsZXJ0KHJlc3ApDQoJfSk7DQoJPC9zY3JpcHQ+DQoJIjtpOjE7czoxMTE6IlNlcnZpY2UgQ3JldyAvIEFzc3QuIFdhaXRlciAvIENvdW50ZXIgc3RhZmYvIEtpdGNoZW4gSGVscGVyIEpvYnMgaW4gU2F1ZGkgQXJhYmlhIC0gVmFjYW5jeSBpbiBGcmVzaGVyIC8gVHJhaW5lZSI7aToyO3M6MzEzOiJTZXJ2aWNlIENyZXcgLyBBc3N0LiBXYWl0ZXIgLyBDb3VudGVyIHN0YWZmLyBLaXRjaGVuIEhlbHBlciBKb2JzLFNlcnZpY2UgQ3JldyAvIEFzc3QuIFdhaXRlciAvIENvdW50ZXIgc3RhZmYvIEtpdGNoZW4gSGVscGVyIEpvYnMgaW4gLFNlcnZpY2UgQ3JldyAvIEFzc3QuIFdhaXRlciAvIENvdW50ZXIgc3RhZmYvIEtpdGNoZW4gSGVscGVyIFZhY2FuY3kgaW4gLFNlcnZpY2UgQ3JldyAvIEFzc3QuIFdhaXRlciAvIENvdW50ZXIgc3RhZmYvIEtpdGNoZW4gSGVscGVyIGpvYnMgaW4gU2F1ZGkgQXJhYmlhLEZyZXNoZXIgLyBUcmFpbmVlIGpvYnMgaW4gIjtpOjM7czoyNTU6IkFwcGx5IGZvciBTZXJ2aWNlIENyZXcgLyBBc3N0LiBXYWl0ZXIgLyBDb3VudGVyIHN0YWZmLyBLaXRjaGVuIEhlbHBlciBKb2JzIGluICBTYXVkaSBBcmFiaWEgLSBTZXJ2aWNlIENyZXcgLyBBc3N0LiBXYWl0ZXIgLyBDb3VudGVyIHN0YWZmLyBLaXRjaGVuIEhlbHBlciBWYWNhbmN5ICBpbiBGcmVzaGVyIC8gVHJhaW5lZSAsIEtleSBTa2lsbHMgYXJlIHNlcnZpY2UgY3JldywgRnJlc2hlciAvIFRyYWluZWUgam9icyBpbiAgIFNhdWRpIEFyYWJpYSI7aTo0O3M6MjAxOToiDQoJCTxzY3JpcHQgdHlwZT0iYXBwbGljYXRpb24vbGQranNvbiI+DQoJCXsNCgkJICAiQGNvbnRleHQiOiAiaHR0cDovL3NjaGVtYS5vcmciLA0KCQkgICJAdHlwZSI6ICJKb2JQb3N0aW5nIiwNCgkJICAidGl0bGUiOiAiU2VydmljZSBDcmV3IC8gQXNzdC4gV2FpdGVyIC8gQ291bnRlciBzdGFmZi8gS2l0Y2hlbiBIZWxwZXIiLA0KCQkgICJiYXNlU2FsYXJ5IjogIiAxICBMYWMgIDc1IFRob3VzYW5kICBUbyAgMiAgTGFjICAyNSBUaG91c2FuZCAiLA0KCQkgICJkZXNjcmlwdGlvbiI6ICJRdWFsaWZpY2F0aW9uOiBTU0MvSFNDIOKAk1BBU1MvRkFJTCBDYW4gQXBwbHkgCkV4cGVyaWVuY2U6IEZyZXNoZXIgJiBFeHBlcmllbmNlZCBib3RoIGNhbiBBcHBseSAoT05MWSBNQUxFKSAKRHV0eTogMTAgSG91cnMgKEluY2x1ZGluZyBMdW5jaCAmIFByYXllciBUaW1lKSAvIDYgRGF5IGEgd2VlawpDb250cmFjdCBQZXJpb2Q6IDIgeWVhcnMKQWdlIExpbWl0OiAyMi0zNSB5ZWFycyB3aXRoIHZhbGlkIFBhc3Nwb3J0IApJbmR1c3RyeSBUeXBlOiBGb29kIFJldGFpbApTQUxBUlkgOiA5MDBTUiszMDBTUihGb29kKSA9IDEyMDAgU1IgKDEwIGhycyBEdXR5KSAod2hpY2ggY29tZXMgdG8gYXBwcm94LiBJTlIgMjAsMDAwLz0gUE0KCkRpcmVjdCBDbGllbnQgSW50ZXJ2aWV3IGF0IAoKMXN0IEpVTkUgMjAxNSBhdCBNVU1CQUkKMm5kIEpVTkUgMjAxNSBhdCBIWURFUkFCQUQsCjNyZCBKVU5FIDIwMTUgYXQgQ09DSElOIAo1dGggSlVORSAyMDE1IGF0IEtPTEtBVFRBCgpKT0IgREVTQ1JJUFRJT046ICAgICAgIAoxKSBUaGUgQ2FuZGlkYXRlcyB3aWxsIGJlIHdvcmtpbmcgYXMgU0VSVklDRSBDUkVXLyBBU1NULldBSVRFUi9DT1VOVEVSIFNUQUZGIEtJVENIRU4gSEVMUEVSIEZvciAiS1VEVSBSRVNUQVVSQU5UUyBPVVRMRVNUIGhlbHBpbmcgQW5kIEFzc2lzdGluZyBpbiBLaXRjaGVuIFdvcmtzLCBDdXR0aW5nLCBDaG9wcGluZyBBbmQgQ2xlYW5pbmcgKENsZWFuaW5nIEtpdGNoZW4gQXJlYSwgSW5zaWRlIEFuZCBPdXRzaWRlIFJlc3RhdXJhbnQgT3V0bGV0cykKMikgVGhlIENhbmRpZGF0ZXMgd2lsbCBncmFkdWFsbHkgYmUgbWFkZSB0byB3b3JrIGFzIFNhbmR3aWNoIE1ha2VycyBPciBTYWxhZCBNYWtlcnMgVG8gYmUgd29ya2luZyBvbiBGcnllcnMgQW5kIEFzIENhc2hpZXJzLCBEZXBlbmRpbmcgb24gdGhlaXIgYWJpbGl0eSB0byBsZWFybiB0aGUgc2tpbGxzLgozKSBUaGUgQ2FuZGlkYXRlcyBzaG91bGQgYmUgeW91bmcsIGdvb2QgbG9va2luZyAmIHByZXNlbnRhYmxlLgo0KSBUaGUgQ2FuZGlkYXRlcyBzaG91bGQgYmUgYWJsZSB0byBzcGVhayAmIHVuZGVyc3RhbmQgQmFzaWMgRW5nbGlzaC4KCk9uIFNlbGVjdGlvbiwgVmlzYSAmIEFpciBUaWNrZXQgd2lsbCBiZSBwcm92aWRlZCBieSB0aGUgY2xpZW50LiAKCkJFTkVGSVRTIGF0IFNhdWRpIEFyYWJpYTogCi0gQWNjb21tb2RhdGlvbiBieSBDb21wYW55Ci0gVHJhbnNwb3J0IGJ5IENvbXBhbnkKLSBNZWRpY2FsLyBJbnN1cmFuY2UgYnkgQ29tcGFueQotIE90aGVyIEJlbmVmaXRzIEFzIFBlciBLU0EgTEFCT1VSIExBVyIsDQoJCSAgImVkdWNhdGlvblJlcXVpcmVtZW50cyI6ICJIaWdoZXIgU2Vjb25kYXJ5LCBWb2NhdGlvbmFsIENvdXJzZSIsDQoJCSAgImV4cGVyaWVuY2VSZXF1aXJlbWVudHMiOiAiRnJlc2hlciIsDQoJCSAgImluZHVzdHJ5IjogIkZyZXNoZXIgLyBUcmFpbmVlIiwNCgkJICAiam9iTG9jYXRpb24iOiB7DQoJCSAgICAiQHR5cGUiOiAiUGxhY2UiLA0KCQkgICAgImFkZHJlc3MiOiB7DQoJCSAgICAgICJAdHlwZSI6ICJQb3N0YWxBZGRyZXNzIiwNCgkJICAgICAgImFkZHJlc3NMb2NhbGl0eSI6ICIiLA0KCQkgICAgICAiYWRkcmVzc1JlZ2lvbiI6ICIiDQoJCSAgICB9DQoJCSAgfSwNCgkJICJxdWFsaWZpY2F0aW9ucyI6ICJIaWdoZXIgU2Vjb25kYXJ5LCBWb2NhdGlvbmFsIENvdXJzZSIsDQoJCSAgICAgInNraWxscyI6ICJzZXJ2aWNlIGNyZXciDQoJCSAgfQ0KCQk8L3NjcmlwdD4NCgkJIjtpOjU7Tjt9