REDROOM
PHP 8.2.31
Path:
Logout
Edit File
Size: 204.47 KB
Close
/home/nshryvcy/lscache/priv/3/3/2/3324b003d06dd8e8
Text
Base64
TFNDSLKKhGi6kYRoCAD1AoIA4gAEAAAACwIAAE8uAwAAAAAA8wEUAC90b3Vycy9ldmVyZXN0LWJhc2UtY2FtcC10cmVrLXZpYS1zYWxsZXJpLyNfbHNjYWNoZV92YXJ5PWNvbW1lbnRlcjsrd2VicAB+Y29tbWVudF9hdXRob3JfOGNiMDM3OTEyZTQ1YTkwZmY2ZmVjMjY1OTM3NzQ3MTg9VGhvbWFzZnV0O2NvbW1lbnRfYXV0aG9yX2VtYWlsXzhjYjAzNzkxMmU0NWE5MGZmNmZlYzI2NTkzNzc0NzE4PWFuZHJleS5kb24ueCU0MGdtYWlsLmNvbTtAMTA5LjE3Mi44OC4xMzAxNjNfdGFnX3ByaXYscHVibGljOjE2M19IVFRQLjIwMCxwdWJsaWM6MTYzX3Byb2R1Y3QscHVibGljOjE2M19VUkwuMGIyMTNjYTFlNjEwZWI2MWM5YzM3ZjY3ZmVlYWZhM2IscHVibGljOjE2M19Qby4xMzAzLHB1YmxpYzoxNjNfWC1Qb3dlcmVkLUJ5OiBQSFAvOC4xLjMyDQpDb250ZW50LVR5cGU6IHRleHQvaHRtbDsgY2hhcnNldD1VVEYtOA0KTGluazogPGh0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS93cC1qc29uLz47IHJlbD0iaHR0cHM6Ly9hcGkudy5vcmcvIg0KTGluazogPGh0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS93cC1qc29uL3dwL3YyL3Byb2R1Y3QvMTMwMz47IHJlbD0iYWx0ZXJuYXRlIjsgdHlwZT0iYXBwbGljYXRpb24vanNvbiINCkxpbms6IDxodHRwczovL2hpbWFsdG91cmlzbS5jb20vP3A9MTMwMz47IHJlbD1zaG9ydGxpbmsNClgtTGl0ZVNwZWVkLUNhY2hlLUNvbnRyb2w6IHByaXZhdGUsbWF4LWFnZT0xODAwDQpYLUxpdGVTcGVlZC1UYWc6IDE2M190YWdfcHJpdixwdWJsaWM6MTYzX0hUVFAuMjAwLHB1YmxpYzoxNjNfcHJvZHVjdCxwdWJsaWM6MTYzX1VSTC4wYjIxM2NhMWU2MTBlYjYxYzljMzdmNjdmZWVhZmEzYixwdWJsaWM6MTYzX1BvLjEzMDMscHVibGljOjE2M18NCkV0YWc6ICIxMjcxLTE3NTM1MTY3MjI7OzsiDQoNCjwhRE9DVFlQRSBodG1sPgo8aHRtbCBsYW5nPSJlbi1VUyI+CjxoZWFkPgoJPG1ldGEgY2hhcnNldD0iVVRGLTgiPgo8bWV0YSBuYW1lPSJkZXNjcmlwdGlvbiIgY29udGVudD0iUGlvbmVlciBpbiBIaWtpbmcgaW4gTmVwYWwgc2luY2UgMjAwOCI+CjxtZXRhIG5hbWU9InZpZXdwb3J0IiBjb250ZW50PSJ3aWR0aD1kZXZpY2Utd2lkdGgsIGluaXRpYWwtc2NhbGU9MS4wIj4KPHRpdGxlPkV2ZXJlc3QgQmFzZSBDYW1wIFRyZWsgdmlhIFNhbGxlcmkgJiM4MjExOyBIaW1hbCBUb3VyaXNtPC90aXRsZT4KPG1ldGEgbmFtZT0ncm9ib3RzJyBjb250ZW50PSdtYXgtaW1hZ2UtcHJldmlldzpsYXJnZScgLz4KPGxpbmsgcmVsPSdkbnMtcHJlZmV0Y2gnIGhyZWY9Jy8vZm9udHMuZ29vZ2xlYXBpcy5jb20nIC8+CjxsaW5rIHJlbD0iYWx0ZXJuYXRlIiB0eXBlPSJhcHBsaWNhdGlvbi9yc3MreG1sIiB0aXRsZT0iSGltYWwgVG91cmlzbSAmcmFxdW87IEZlZWQiIGhyZWY9Imh0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS9mZWVkLyIgLz4KPGxpbmsgcmVsPSJhbHRlcm5hdGUiIHR5cGU9ImFwcGxpY2F0aW9uL3Jzcyt4bWwiIHRpdGxlPSJIaW1hbCBUb3VyaXNtICZyYXF1bzsgQ29tbWVudHMgRmVlZCIgaHJlZj0iaHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL2NvbW1lbnRzL2ZlZWQvIiAvPgo8bGluayByZWw9ImFsdGVybmF0ZSIgdHlwZT0iYXBwbGljYXRpb24vcnNzK3htbCIgdGl0bGU9IkhpbWFsIFRvdXJpc20gJnJhcXVvOyBFdmVyZXN0IEJhc2UgQ2FtcCBUcmVrIHZpYSBTYWxsZXJpIENvbW1lbnRzIEZlZWQiIGhyZWY9Imh0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS90b3Vycy9ldmVyZXN0LWJhc2UtY2FtcC10cmVrLXZpYS1zYWxsZXJpL2ZlZWQvIiAvPgo8c2NyaXB0IHR5cGU9InRleHQvamF2YXNjcmlwdCI+CndpbmRvdy5fd3BlbW9qaVNldHRpbmdzID0geyJiYXNlVXJsIjoiaHR0cHM6XC9cL3Mudy5vcmdcL2ltYWdlc1wvY29yZVwvZW1vamlcLzE0LjAuMFwvNzJ4NzJcLyIsImV4dCI6Ii5wbmciLCJzdmdVcmwiOiJodHRwczpcL1wvcy53Lm9yZ1wvaW1hZ2VzXC9jb3JlXC9lbW9qaVwvMTQuMC4wXC9zdmdcLyIsInN2Z0V4dCI6Ii5zdmciLCJzb3VyY2UiOnsiY29uY2F0ZW1vamkiOiJodHRwczpcL1wvaGltYWx0b3VyaXNtLmNvbVwvd3AtaW5jbHVkZXNcL2pzXC93cC1lbW9qaS1yZWxlYXNlLm1pbi5qcz92ZXI9Ni4yLjYifX07Ci8qISBUaGlzIGZpbGUgaXMgYXV0by1nZW5lcmF0ZWQgKi8KIWZ1bmN0aW9uKGUsYSx0KXt2YXIgbixyLG8saT1hLmNyZWF0ZUVsZW1lbnQoImNhbnZhcyIpLHA9aS5nZXRDb250ZXh0JiZpLmdldENvbnRleHQoIjJkIik7ZnVuY3Rpb24gcyhlLHQpe3AuY2xlYXJSZWN0KDAsMCxpLndpZHRoLGkuaGVpZ2h0KSxwLmZpbGxUZXh0KGUsMCwwKTtlPWkudG9EYXRhVVJMKCk7cmV0dXJuIHAuY2xlYXJSZWN0KDAsMCxpLndpZHRoLGkuaGVpZ2h0KSxwLmZpbGxUZXh0KHQsMCwwKSxlPT09aS50b0RhdGFVUkwoKX1mdW5jdGlvbiBjKGUpe3ZhciB0PWEuY3JlYXRlRWxlbWVudCgic2NyaXB0Iik7dC5zcmM9ZSx0LmRlZmVyPXQudHlwZT0idGV4dC9qYXZhc2NyaXB0IixhLmdldEVsZW1lbnRzQnlUYWdOYW1lKCJoZWFkIilbMF0uYXBwZW5kQ2hpbGQodCl9Zm9yKG89QXJyYXkoImZsYWciLCJlbW9qaSIpLHQuc3VwcG9ydHM9e2V2ZXJ5dGhpbmc6ITAsZXZlcnl0aGluZ0V4Y2VwdEZsYWc6ITB9LHI9MDtyPG8ubGVuZ3RoO3IrKyl0LnN1cHBvcnRzW29bcl1dPWZ1bmN0aW9uKGUpe2lmKHAmJnAuZmlsbFRleHQpc3dpdGNoKHAudGV4dEJhc2VsaW5lPSJ0b3AiLHAuZm9udD0iNjAwIDMycHggQXJpYWwiLGUpe2Nhc2UiZmxhZyI6cmV0dXJuIHMoIlx1ZDgzY1x1ZGZmM1x1ZmUwZlx1MjAwZFx1MjZhN1x1ZmUwZiIsIlx1ZDgzY1x1ZGZmM1x1ZmUwZlx1MjAwYlx1MjZhN1x1ZmUwZiIpPyExOiFzKCJcdWQ4M2NcdWRkZmFcdWQ4M2NcdWRkZjMiLCJcdWQ4M2NcdWRkZmFcdTIwMGJcdWQ4M2NcdWRkZjMiKSYmIXMoIlx1ZDgzY1x1ZGZmNFx1ZGI0MFx1ZGM2N1x1ZGI0MFx1ZGM2Mlx1ZGI0MFx1ZGM2NVx1ZGI0MFx1ZGM2ZVx1ZGI0MFx1ZGM2N1x1ZGI0MFx1ZGM3ZiIsIlx1ZDgzY1x1ZGZmNFx1MjAwYlx1ZGI0MFx1ZGM2N1x1MjAwYlx1ZGI0MFx1ZGM2Mlx1MjAwYlx1ZGI0MFx1ZGM2NVx1MjAwYlx1ZGI0MFx1ZGM2ZVx1MjAwYlx1ZGI0MFx1ZGM2N1x1MjAwYlx1ZGI0MFx1ZGM3ZiIpO2Nhc2UiZW1vamkiOnJldHVybiFzKCJcdWQ4M2VcdWRlZjFcdWQ4M2NcdWRmZmJcdTIwMGRcdWQ4M2VcdWRlZjJcdWQ4M2NcdWRmZmYiLCJcdWQ4M2VcdWRlZjFcdWQ4M2NcdWRmZmJcdTIwMGJcdWQ4M2VcdWRlZjJcdWQ4M2NcdWRmZmYiKX1yZXR1cm4hMX0ob1tyXSksdC5zdXBwb3J0cy5ldmVyeXRoaW5nPXQuc3VwcG9ydHMuZXZlcnl0aGluZyYmdC5zdXBwb3J0c1tvW3JdXSwiZmxhZyIhPT1vW3JdJiYodC5zdXBwb3J0cy5ldmVyeXRoaW5nRXhjZXB0RmxhZz10LnN1cHBvcnRzLmV2ZXJ5dGhpbmdFeGNlcHRGbGFnJiZ0LnN1cHBvcnRzW29bcl1dKTt0LnN1cHBvcnRzLmV2ZXJ5dGhpbmdFeGNlcHRGbGFnPXQuc3VwcG9ydHMuZXZlcnl0aGluZ0V4Y2VwdEZsYWcmJiF0LnN1cHBvcnRzLmZsYWcsdC5ET01SZWFkeT0hMSx0LnJlYWR5Q2FsbGJhY2s9ZnVuY3Rpb24oKXt0LkRPTVJlYWR5PSEwfSx0LnN1cHBvcnRzLmV2ZXJ5dGhpbmd8fChuPWZ1bmN0aW9uKCl7dC5yZWFkeUNhbGxiYWNrKCl9LGEuYWRkRXZlbnRMaXN0ZW5lcj8oYS5hZGRFdmVudExpc3RlbmVyKCJET01Db250ZW50TG9hZGVkIixuLCExKSxlLmFkZEV2ZW50TGlzdGVuZXIoImxvYWQiLG4sITEpKTooZS5hdHRhY2hFdmVudCgib25sb2FkIixuKSxhLmF0dGFjaEV2ZW50KCJvbnJlYWR5c3RhdGVjaGFuZ2UiLGZ1bmN0aW9uKCl7ImNvbXBsZXRlIj09PWEucmVhZHlTdGF0ZSYmdC5yZWFkeUNhbGxiYWNrKCl9KSksKGU9dC5zb3VyY2V8fHt9KS5jb25jYXRlbW9qaT9jKGUuY29uY2F0ZW1vamkpOmUud3BlbW9qaSYmZS50d2Vtb2ppJiYoYyhlLnR3ZW1vamkpLGMoZS53cGVtb2ppKSkpfSh3aW5kb3csZG9jdW1lbnQsd2luZG93Ll93cGVtb2ppU2V0dGluZ3MpOwo8L3NjcmlwdD4KPHN0eWxlIHR5cGU9InRleHQvY3NzIj4KaW1nLndwLXNtaWxleSwKaW1nLmVtb2ppIHsKCWRpc3BsYXk6IGlubGluZSAhaW1wb3J0YW50OwoJYm9yZGVyOiBub25lICFpbXBvcnRhbnQ7Cglib3gtc2hhZG93OiBub25lICFpbXBvcnRhbnQ7CgloZWlnaHQ6IDFlbSAhaW1wb3J0YW50OwoJd2lkdGg6IDFlbSAhaW1wb3J0YW50OwoJbWFyZ2luOiAwIDAuMDdlbSAhaW1wb3J0YW50OwoJdmVydGljYWwtYWxpZ246IC0wLjFlbSAhaW1wb3J0YW50OwoJYmFja2dyb3VuZDogbm9uZSAhaW1wb3J0YW50OwoJcGFkZGluZzogMCAhaW1wb3J0YW50Owp9Cjwvc3R5bGU+Cgk8bGluayByZWw9J3N0eWxlc2hlZXQnIGlkPSd3cC1ibG9jay1saWJyYXJ5LWNzcycgaHJlZj0naHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL3dwLWluY2x1ZGVzL2Nzcy9kaXN0L2Jsb2NrLWxpYnJhcnkvc3R5bGUubWluLmNzcz92ZXI9Ni4yLjYnIHR5cGU9J3RleHQvY3NzJyBtZWRpYT0nYWxsJyAvPgo8bGluayByZWw9J3N0eWxlc2hlZXQnIGlkPSd3Yy1ibG9ja3MtdmVuZG9ycy1zdHlsZS1jc3MnIGhyZWY9J2h0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS93cC1jb250ZW50L3BsdWdpbnMvd29vY29tbWVyY2UvcGFja2FnZXMvd29vY29tbWVyY2UtYmxvY2tzL2J1aWxkL3djLWJsb2Nrcy12ZW5kb3JzLXN0eWxlLmNzcz92ZXI9OS42LjYnIHR5cGU9J3RleHQvY3NzJyBtZWRpYT0nYWxsJyAvPgo8bGluayByZWw9J3N0eWxlc2hlZXQnIGlkPSd3Yy1ibG9ja3Mtc3R5bGUtY3NzJyBocmVmPSdodHRwczovL2hpbWFsdG91cmlzbS5jb20vd3AtY29udGVudC9wbHVnaW5zL3dvb2NvbW1lcmNlL3BhY2thZ2VzL3dvb2NvbW1lcmNlLWJsb2Nrcy9idWlsZC93Yy1ibG9ja3Mtc3R5bGUuY3NzP3Zlcj05LjYuNicgdHlwZT0ndGV4dC9jc3MnIG1lZGlhPSdhbGwnIC8+CjxsaW5rIHJlbD0nc3R5bGVzaGVldCcgaWQ9J2NsYXNzaWMtdGhlbWUtc3R5bGVzLWNzcycgaHJlZj0naHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL3dwLWluY2x1ZGVzL2Nzcy9jbGFzc2ljLXRoZW1lcy5taW4uY3NzP3Zlcj02LjIuNicgdHlwZT0ndGV4dC9jc3MnIG1lZGlhPSdhbGwnIC8+CjxzdHlsZSBpZD0nZ2xvYmFsLXN0eWxlcy1pbmxpbmUtY3NzJyB0eXBlPSd0ZXh0L2Nzcyc+CmJvZHl7LS13cC0tcHJlc2V0LS1jb2xvci0tYmxhY2s6ICMwMDAwMDA7LS13cC0tcHJlc2V0LS1jb2xvci0tY3lhbi1ibHVpc2gtZ3JheTogI2FiYjhjMzstLXdwLS1wcmVzZXQtLWNvbG9yLS13aGl0ZTogI2ZmZmZmZjstLXdwLS1wcmVzZXQtLWNvbG9yLS1wYWxlLXBpbms6ICNmNzhkYTc7LS13cC0tcHJlc2V0LS1jb2xvci0tdml2aWQtcmVkOiAjY2YyZTJlOy0td3AtLXByZXNldC0tY29sb3ItLWx1bWlub3VzLXZpdmlkLW9yYW5nZTogI2ZmNjkwMDstLXdwLS1wcmVzZXQtLWNvbG9yLS1sdW1pbm91cy12aXZpZC1hbWJlcjogI2ZjYjkwMDstLXdwLS1wcmVzZXQtLWNvbG9yLS1saWdodC1ncmVlbi1jeWFuOiAjN2JkY2I1Oy0td3AtLXByZXNldC0tY29sb3ItLXZpdmlkLWdyZWVuLWN5YW46ICMwMGQwODQ7LS13cC0tcHJlc2V0LS1jb2xvci0tcGFsZS1jeWFuLWJsdWU6ICM4ZWQxZmM7LS13cC0tcHJlc2V0LS1jb2xvci0tdml2aWQtY3lhbi1ibHVlOiAjMDY5M2UzOy0td3AtLXByZXNldC0tY29sb3ItLXZpdmlkLXB1cnBsZTogIzliNTFlMDstLXdwLS1wcmVzZXQtLWdyYWRpZW50LS12aXZpZC1jeWFuLWJsdWUtdG8tdml2aWQtcHVycGxlOiBsaW5lYXItZ3JhZGllbnQoMTM1ZGVnLHJnYmEoNiwxNDcsMjI3LDEpIDAlLHJnYigxNTUsODEsMjI0KSAxMDAlKTstLXdwLS1wcmVzZXQtLWdyYWRpZW50LS1saWdodC1ncmVlbi1jeWFuLXRvLXZpdmlkLWdyZWVuLWN5YW46IGxpbmVhci1ncmFkaWVudCgxMzVkZWcscmdiKDEyMiwyMjAsMTgwKSAwJSxyZ2IoMCwyMDgsMTMwKSAxMDAlKTstLXdwLS1wcmVzZXQtLWdyYWRpZW50LS1sdW1pbm91cy12aXZpZC1hbWJlci10by1sdW1pbm91cy12aXZpZC1vcmFuZ2U6IGxpbmVhci1ncmFkaWVudCgxMzVkZWcscmdiYSgyNTIsMTg1LDAsMSkgMCUscmdiYSgyNTUsMTA1LDAsMSkgMTAwJSk7LS13cC0tcHJlc2V0LS1ncmFkaWVudC0tbHVtaW5vdXMtdml2aWQtb3JhbmdlLXRvLXZpdmlkLXJlZDogbGluZWFyLWdyYWRpZW50KDEzNWRlZyxyZ2JhKDI1NSwxMDUsMCwxKSAwJSxyZ2IoMjA3LDQ2LDQ2KSAxMDAlKTstLXdwLS1wcmVzZXQtLWdyYWRpZW50LS12ZXJ5LWxpZ2h0LWdyYXktdG8tY3lhbi1ibHVpc2gtZ3JheTogbGluZWFyLWdyYWRpZW50KDEzNWRlZyxyZ2IoMjM4LDIzOCwyMzgpIDAlLHJnYigxNjksMTg0LDE5NSkgMTAwJSk7LS13cC0tcHJlc2V0LS1ncmFkaWVudC0tY29vbC10by13YXJtLXNwZWN0cnVtOiBsaW5lYXItZ3JhZGllbnQoMTM1ZGVnLHJnYig3NCwyMzQsMjIwKSAwJSxyZ2IoMTUxLDEyMCwyMDkpIDIwJSxyZ2IoMjA3LDQyLDE4NikgNDAlLHJnYigyMzgsNDQsMTMwKSA2MCUscmdiKDI1MSwxMDUsOTgpIDgwJSxyZ2IoMjU0LDI0OCw3NikgMTAwJSk7LS13cC0tcHJlc2V0LS1ncmFkaWVudC0tYmx1c2gtbGlnaHQtcHVycGxlOiBsaW5lYXItZ3JhZGllbnQoMTM1ZGVnLHJnYigyNTUsMjA2LDIzNikgMCUscmdiKDE1MiwxNTAsMjQwKSAxMDAlKTstLXdwLS1wcmVzZXQtLWdyYWRpZW50LS1ibHVzaC1ib3JkZWF1eDogbGluZWFyLWdyYWRpZW50KDEzNWRlZyxyZ2IoMjU0LDIwNSwxNjUpIDAlLHJnYigyNTQsNDUsNDUpIDUwJSxyZ2IoMTA3LDAsNjIpIDEwMCUpOy0td3AtLXByZXNldC0tZ3JhZGllbnQtLWx1bWlub3VzLWR1c2s6IGxpbmVhci1ncmFkaWVudCgxMzVkZWcscmdiKDI1NSwyMDMsMTEyKSAwJSxyZ2IoMTk5LDgxLDE5MikgNTAlLHJnYig2NSw4OCwyMDgpIDEwMCUpOy0td3AtLXByZXNldC0tZ3JhZGllbnQtLXBhbGUtb2NlYW46IGxpbmVhci1ncmFkaWVudCgxMzVkZWcscmdiKDI1NSwyNDUsMjAzKSAwJSxyZ2IoMTgyLDIyNywyMTIpIDUwJSxyZ2IoNTEsMTY3LDE4MSkgMTAwJSk7LS13cC0tcHJlc2V0LS1ncmFkaWVudC0tZWxlY3RyaWMtZ3Jhc3M6IGxpbmVhci1ncmFkaWVudCgxMzVkZWcscmdiKDIwMiwyNDgsMTI4KSAwJSxyZ2IoMTEzLDIwNiwxMjYpIDEwMCUpOy0td3AtLXByZXNldC0tZ3JhZGllbnQtLW1pZG5pZ2h0OiBsaW5lYXItZ3JhZGllbnQoMTM1ZGVnLHJnYigyLDMsMTI5KSAwJSxyZ2IoNDAsMTE2LDI1MikgMTAwJSk7LS13cC0tcHJlc2V0LS1kdW90b25lLS1kYXJrLWdyYXlzY2FsZTogdXJsKCcjd3AtZHVvdG9uZS1kYXJrLWdyYXlzY2FsZScpOy0td3AtLXByZXNldC0tZHVvdG9uZS0tZ3JheXNjYWxlOiB1cmwoJyN3cC1kdW90b25lLWdyYXlzY2FsZScpOy0td3AtLXByZXNldC0tZHVvdG9uZS0tcHVycGxlLXllbGxvdzogdXJsKCcjd3AtZHVvdG9uZS1wdXJwbGUteWVsbG93Jyk7LS13cC0tcHJlc2V0LS1kdW90b25lLS1ibHVlLXJlZDogdXJsKCcjd3AtZHVvdG9uZS1ibHVlLXJlZCcpOy0td3AtLXByZXNldC0tZHVvdG9uZS0tbWlkbmlnaHQ6IHVybCgnI3dwLWR1b3RvbmUtbWlkbmlnaHQnKTstLXdwLS1wcmVzZXQtLWR1b3RvbmUtLW1hZ2VudGEteWVsbG93OiB1cmwoJyN3cC1kdW90b25lLW1hZ2VudGEteWVsbG93Jyk7LS13cC0tcHJlc2V0LS1kdW90b25lLS1wdXJwbGUtZ3JlZW46IHVybCgnI3dwLWR1b3RvbmUtcHVycGxlLWdyZWVuJyk7LS13cC0tcHJlc2V0LS1kdW90b25lLS1ibHVlLW9yYW5nZTogdXJsKCcjd3AtZHVvdG9uZS1ibHVlLW9yYW5nZScpOy0td3AtLXByZXNldC0tZm9udC1zaXplLS1zbWFsbDogMTNweDstLXdwLS1wcmVzZXQtLWZvbnQtc2l6ZS0tbWVkaXVtOiAyMHB4Oy0td3AtLXByZXNldC0tZm9udC1zaXplLS1sYXJnZTogMzZweDstLXdwLS1wcmVzZXQtLWZvbnQtc2l6ZS0teC1sYXJnZTogNDJweDstLXdwLS1wcmVzZXQtLXNwYWNpbmctLTIwOiAwLjQ0cmVtOy0td3AtLXByZXNldC0tc3BhY2luZy0tMzA6IDAuNjdyZW07LS13cC0tcHJlc2V0LS1zcGFjaW5nLS00MDogMXJlbTstLXdwLS1wcmVzZXQtLXNwYWNpbmctLTUwOiAxLjVyZW07LS13cC0tcHJlc2V0LS1zcGFjaW5nLS02MDogMi4yNXJlbTstLXdwLS1wcmVzZXQtLXNwYWNpbmctLTcwOiAzLjM4cmVtOy0td3AtLXByZXNldC0tc3BhY2luZy0tODA6IDUuMDZyZW07LS13cC0tcHJlc2V0LS1zaGFkb3ctLW5hdHVyYWw6IDZweCA2cHggOXB4IHJnYmEoMCwgMCwgMCwgMC4yKTstLXdwLS1wcmVzZXQtLXNoYWRvdy0tZGVlcDogMTJweCAxMnB4IDUwcHggcmdiYSgwLCAwLCAwLCAwLjQpOy0td3AtLXByZXNldC0tc2hhZG93LS1zaGFycDogNnB4IDZweCAwcHggcmdiYSgwLCAwLCAwLCAwLjIpOy0td3AtLXByZXNldC0tc2hhZG93LS1vdXRsaW5lZDogNnB4IDZweCAwcHggLTNweCByZ2JhKDI1NSwgMjU1LCAyNTUsIDEpLCA2cHggNnB4IHJnYmEoMCwgMCwgMCwgMSk7LS13cC0tcHJlc2V0LS1zaGFkb3ctLWNyaXNwOiA2cHggNnB4IDBweCByZ2JhKDAsIDAsIDAsIDEpO306d2hlcmUoLmlzLWxheW91dC1mbGV4KXtnYXA6IDAuNWVtO31ib2R5IC5pcy1sYXlvdXQtZmxvdyA+IC5hbGlnbmxlZnR7ZmxvYXQ6IGxlZnQ7bWFyZ2luLWlubGluZS1zdGFydDogMDttYXJnaW4taW5saW5lLWVuZDogMmVtO31ib2R5IC5pcy1sYXlvdXQtZmxvdyA+IC5hbGlnbnJpZ2h0e2Zsb2F0OiByaWdodDttYXJnaW4taW5saW5lLXN0YXJ0OiAyZW07bWFyZ2luLWlubGluZS1lbmQ6IDA7fWJvZHkgLmlzLWxheW91dC1mbG93ID4gLmFsaWduY2VudGVye21hcmdpbi1sZWZ0OiBhdXRvICFpbXBvcnRhbnQ7bWFyZ2luLXJpZ2h0OiBhdXRvICFpbXBvcnRhbnQ7fWJvZHkgLmlzLWxheW91dC1jb25zdHJhaW5lZCA+IC5hbGlnbmxlZnR7ZmxvYXQ6IGxlZnQ7bWFyZ2luLWlubGluZS1zdGFydDogMDttYXJnaW4taW5saW5lLWVuZDogMmVtO31ib2R5IC5pcy1sYXlvdXQtY29uc3RyYWluZWQgPiAuYWxpZ25yaWdodHtmbG9hdDogcmlnaHQ7bWFyZ2luLWlubGluZS1zdGFydDogMmVtO21hcmdpbi1pbmxpbmUtZW5kOiAwO31ib2R5IC5pcy1sYXlvdXQtY29uc3RyYWluZWQgPiAuYWxpZ25jZW50ZXJ7bWFyZ2luLWxlZnQ6IGF1dG8gIWltcG9ydGFudDttYXJnaW4tcmlnaHQ6IGF1dG8gIWltcG9ydGFudDt9Ym9keSAuaXMtbGF5b3V0LWNvbnN0cmFpbmVkID4gOndoZXJlKDpub3QoLmFsaWdubGVmdCk6bm90KC5hbGlnbnJpZ2h0KTpub3QoLmFsaWduZnVsbCkpe21heC13aWR0aDogdmFyKC0td3AtLXN0eWxlLS1nbG9iYWwtLWNvbnRlbnQtc2l6ZSk7bWFyZ2luLWxlZnQ6IGF1dG8gIWltcG9ydGFudDttYXJnaW4tcmlnaHQ6IGF1dG8gIWltcG9ydGFudDt9Ym9keSAuaXMtbGF5b3V0LWNvbnN0cmFpbmVkID4gLmFsaWdud2lkZXttYXgtd2lkdGg6IHZhcigtLXdwLS1zdHlsZS0tZ2xvYmFsLS13aWRlLXNpemUpO31ib2R5IC5pcy1sYXlvdXQtZmxleHtkaXNwbGF5OiBmbGV4O31ib2R5IC5pcy1sYXlvdXQtZmxleHtmbGV4LXdyYXA6IHdyYXA7YWxpZ24taXRlbXM6IGNlbnRlcjt9Ym9keSAuaXMtbGF5b3V0LWZsZXggPiAqe21hcmdpbjogMDt9OndoZXJlKC53cC1ibG9jay1jb2x1bW5zLmlzLWxheW91dC1mbGV4KXtnYXA6IDJlbTt9Lmhhcy1ibGFjay1jb2xvcntjb2xvcjogdmFyKC0td3AtLXByZXNldC0tY29sb3ItLWJsYWNrKSAhaW1wb3J0YW50O30uaGFzLWN5YW4tYmx1aXNoLWdyYXktY29sb3J7Y29sb3I6IHZhcigtLXdwLS1wcmVzZXQtLWNvbG9yLS1jeWFuLWJsdWlzaC1ncmF5KSAhaW1wb3J0YW50O30uaGFzLXdoaXRlLWNvbG9ye2NvbG9yOiB2YXIoLS13cC0tcHJlc2V0LS1jb2xvci0td2hpdGUpICFpbXBvcnRhbnQ7fS5oYXMtcGFsZS1waW5rLWNvbG9ye2NvbG9yOiB2YXIoLS13cC0tcHJlc2V0LS1jb2xvci0tcGFsZS1waW5rKSAhaW1wb3J0YW50O30uaGFzLXZpdmlkLXJlZC1jb2xvcntjb2xvcjogdmFyKC0td3AtLXByZXNldC0tY29sb3ItLXZpdmlkLXJlZCkgIWltcG9ydGFudDt9Lmhhcy1sdW1pbm91cy12aXZpZC1vcmFuZ2UtY29sb3J7Y29sb3I6IHZhcigtLXdwLS1wcmVzZXQtLWNvbG9yLS1sdW1pbm91cy12aXZpZC1vcmFuZ2UpICFpbXBvcnRhbnQ7fS5oYXMtbHVtaW5vdXMtdml2aWQtYW1iZXItY29sb3J7Y29sb3I6IHZhcigtLXdwLS1wcmVzZXQtLWNvbG9yLS1sdW1pbm91cy12aXZpZC1hbWJlcikgIWltcG9ydGFudDt9Lmhhcy1saWdodC1ncmVlbi1jeWFuLWNvbG9ye2NvbG9yOiB2YXIoLS13cC0tcHJlc2V0LS1jb2xvci0tbGlnaHQtZ3JlZW4tY3lhbikgIWltcG9ydGFudDt9Lmhhcy12aXZpZC1ncmVlbi1jeWFuLWNvbG9ye2NvbG9yOiB2YXIoLS13cC0tcHJlc2V0LS1jb2xvci0tdml2aWQtZ3JlZW4tY3lhbikgIWltcG9ydGFudDt9Lmhhcy1wYWxlLWN5YW4tYmx1ZS1jb2xvcntjb2xvcjogdmFyKC0td3AtLXByZXNldC0tY29sb3ItLXBhbGUtY3lhbi1ibHVlKSAhaW1wb3J0YW50O30uaGFzLXZpdmlkLWN5YW4tYmx1ZS1jb2xvcntjb2xvcjogdmFyKC0td3AtLXByZXNldC0tY29sb3ItLXZpdmlkLWN5YW4tYmx1ZSkgIWltcG9ydGFudDt9Lmhhcy12aXZpZC1wdXJwbGUtY29sb3J7Y29sb3I6IHZhcigtLXdwLS1wcmVzZXQtLWNvbG9yLS12aXZpZC1wdXJwbGUpICFpbXBvcnRhbnQ7fS5oYXMtYmxhY2stYmFja2dyb3VuZC1jb2xvcntiYWNrZ3JvdW5kLWNvbG9yOiB2YXIoLS13cC0tcHJlc2V0LS1jb2xvci0tYmxhY2spICFpbXBvcnRhbnQ7fS5oYXMtY3lhbi1ibHVpc2gtZ3JheS1iYWNrZ3JvdW5kLWNvbG9ye2JhY2tncm91bmQtY29sb3I6IHZhcigtLXdwLS1wcmVzZXQtLWNvbG9yLS1jeWFuLWJsdWlzaC1ncmF5KSAhaW1wb3J0YW50O30uaGFzLXdoaXRlLWJhY2tncm91bmQtY29sb3J7YmFja2dyb3VuZC1jb2xvcjogdmFyKC0td3AtLXByZXNldC0tY29sb3ItLXdoaXRlKSAhaW1wb3J0YW50O30uaGFzLXBhbGUtcGluay1iYWNrZ3JvdW5kLWNvbG9ye2JhY2tncm91bmQtY29sb3I6IHZhcigtLXdwLS1wcmVzZXQtLWNvbG9yLS1wYWxlLXBpbmspICFpbXBvcnRhbnQ7fS5oYXMtdml2aWQtcmVkLWJhY2tncm91bmQtY29sb3J7YmFja2dyb3VuZC1jb2xvcjogdmFyKC0td3AtLXByZXNldC0tY29sb3ItLXZpdmlkLXJlZCkgIWltcG9ydGFudDt9Lmhhcy1sdW1pbm91cy12aXZpZC1vcmFuZ2UtYmFja2dyb3VuZC1jb2xvcntiYWNrZ3JvdW5kLWNvbG9yOiB2YXIoLS13cC0tcHJlc2V0LS1jb2xvci0tbHVtaW5vdXMtdml2aWQtb3JhbmdlKSAhaW1wb3J0YW50O30uaGFzLWx1bWlub3VzLXZpdmlkLWFtYmVyLWJhY2tncm91bmQtY29sb3J7YmFja2dyb3VuZC1jb2xvcjogdmFyKC0td3AtLXByZXNldC0tY29sb3ItLWx1bWlub3VzLXZpdmlkLWFtYmVyKSAhaW1wb3J0YW50O30uaGFzLWxpZ2h0LWdyZWVuLWN5YW4tYmFja2dyb3VuZC1jb2xvcntiYWNrZ3JvdW5kLWNvbG9yOiB2YXIoLS13cC0tcHJlc2V0LS1jb2xvci0tbGlnaHQtZ3JlZW4tY3lhbikgIWltcG9ydGFudDt9Lmhhcy12aXZpZC1ncmVlbi1jeWFuLWJhY2tncm91bmQtY29sb3J7YmFja2dyb3VuZC1jb2xvcjogdmFyKC0td3AtLXByZXNldC0tY29sb3ItLXZpdmlkLWdyZWVuLWN5YW4pICFpbXBvcnRhbnQ7fS5oYXMtcGFsZS1jeWFuLWJsdWUtYmFja2dyb3VuZC1jb2xvcntiYWNrZ3JvdW5kLWNvbG9yOiB2YXIoLS13cC0tcHJlc2V0LS1jb2xvci0tcGFsZS1jeWFuLWJsdWUpICFpbXBvcnRhbnQ7fS5oYXMtdml2aWQtY3lhbi1ibHVlLWJhY2tncm91bmQtY29sb3J7YmFja2dyb3VuZC1jb2xvcjogdmFyKC0td3AtLXByZXNldC0tY29sb3ItLXZpdmlkLWN5YW4tYmx1ZSkgIWltcG9ydGFudDt9Lmhhcy12aXZpZC1wdXJwbGUtYmFja2dyb3VuZC1jb2xvcntiYWNrZ3JvdW5kLWNvbG9yOiB2YXIoLS13cC0tcHJlc2V0LS1jb2xvci0tdml2aWQtcHVycGxlKSAhaW1wb3J0YW50O30uaGFzLWJsYWNrLWJvcmRlci1jb2xvcntib3JkZXItY29sb3I6IHZhcigtLXdwLS1wcmVzZXQtLWNvbG9yLS1ibGFjaykgIWltcG9ydGFudDt9Lmhhcy1jeWFuLWJsdWlzaC1ncmF5LWJvcmRlci1jb2xvcntib3JkZXItY29sb3I6IHZhcigtLXdwLS1wcmVzZXQtLWNvbG9yLS1jeWFuLWJsdWlzaC1ncmF5KSAhaW1wb3J0YW50O30uaGFzLXdoaXRlLWJvcmRlci1jb2xvcntib3JkZXItY29sb3I6IHZhcigtLXdwLS1wcmVzZXQtLWNvbG9yLS13aGl0ZSkgIWltcG9ydGFudDt9Lmhhcy1wYWxlLXBpbmstYm9yZGVyLWNvbG9ye2JvcmRlci1jb2xvcjogdmFyKC0td3AtLXByZXNldC0tY29sb3ItLXBhbGUtcGluaykgIWltcG9ydGFudDt9Lmhhcy12aXZpZC1yZWQtYm9yZGVyLWNvbG9ye2JvcmRlci1jb2xvcjogdmFyKC0td3AtLXByZXNldC0tY29sb3ItLXZpdmlkLXJlZCkgIWltcG9ydGFudDt9Lmhhcy1sdW1pbm91cy12aXZpZC1vcmFuZ2UtYm9yZGVyLWNvbG9ye2JvcmRlci1jb2xvcjogdmFyKC0td3AtLXByZXNldC0tY29sb3ItLWx1bWlub3VzLXZpdmlkLW9yYW5nZSkgIWltcG9ydGFudDt9Lmhhcy1sdW1pbm91cy12aXZpZC1hbWJlci1ib3JkZXItY29sb3J7Ym9yZGVyLWNvbG9yOiB2YXIoLS13cC0tcHJlc2V0LS1jb2xvci0tbHVtaW5vdXMtdml2aWQtYW1iZXIpICFpbXBvcnRhbnQ7fS5oYXMtbGlnaHQtZ3JlZW4tY3lhbi1ib3JkZXItY29sb3J7Ym9yZGVyLWNvbG9yOiB2YXIoLS13cC0tcHJlc2V0LS1jb2xvci0tbGlnaHQtZ3JlZW4tY3lhbikgIWltcG9ydGFudDt9Lmhhcy12aXZpZC1ncmVlbi1jeWFuLWJvcmRlci1jb2xvcntib3JkZXItY29sb3I6IHZhcigtLXdwLS1wcmVzZXQtLWNvbG9yLS12aXZpZC1ncmVlbi1jeWFuKSAhaW1wb3J0YW50O30uaGFzLXBhbGUtY3lhbi1ibHVlLWJvcmRlci1jb2xvcntib3JkZXItY29sb3I6IHZhcigtLXdwLS1wcmVzZXQtLWNvbG9yLS1wYWxlLWN5YW4tYmx1ZSkgIWltcG9ydGFudDt9Lmhhcy12aXZpZC1jeWFuLWJsdWUtYm9yZGVyLWNvbG9ye2JvcmRlci1jb2xvcjogdmFyKC0td3AtLXByZXNldC0tY29sb3ItLXZpdmlkLWN5YW4tYmx1ZSkgIWltcG9ydGFudDt9Lmhhcy12aXZpZC1wdXJwbGUtYm9yZGVyLWNvbG9ye2JvcmRlci1jb2xvcjogdmFyKC0td3AtLXByZXNldC0tY29sb3ItLXZpdmlkLXB1cnBsZSkgIWltcG9ydGFudDt9Lmhhcy12aXZpZC1jeWFuLWJsdWUtdG8tdml2aWQtcHVycGxlLWdyYWRpZW50LWJhY2tncm91bmR7YmFja2dyb3VuZDogdmFyKC0td3AtLXByZXNldC0tZ3JhZGllbnQtLXZpdmlkLWN5YW4tYmx1ZS10by12aXZpZC1wdXJwbGUpICFpbXBvcnRhbnQ7fS5oYXMtbGlnaHQtZ3JlZW4tY3lhbi10by12aXZpZC1ncmVlbi1jeWFuLWdyYWRpZW50LWJhY2tncm91bmR7YmFja2dyb3VuZDogdmFyKC0td3AtLXByZXNldC0tZ3JhZGllbnQtLWxpZ2h0LWdyZWVuLWN5YW4tdG8tdml2aWQtZ3JlZW4tY3lhbikgIWltcG9ydGFudDt9Lmhhcy1sdW1pbm91cy12aXZpZC1hbWJlci10by1sdW1pbm91cy12aXZpZC1vcmFuZ2UtZ3JhZGllbnQtYmFja2dyb3VuZHtiYWNrZ3JvdW5kOiB2YXIoLS13cC0tcHJlc2V0LS1ncmFkaWVudC0tbHVtaW5vdXMtdml2aWQtYW1iZXItdG8tbHVtaW5vdXMtdml2aWQtb3JhbmdlKSAhaW1wb3J0YW50O30uaGFzLWx1bWlub3VzLXZpdmlkLW9yYW5nZS10by12aXZpZC1yZWQtZ3JhZGllbnQtYmFja2dyb3VuZHtiYWNrZ3JvdW5kOiB2YXIoLS13cC0tcHJlc2V0LS1ncmFkaWVudC0tbHVtaW5vdXMtdml2aWQtb3JhbmdlLXRvLXZpdmlkLXJlZCkgIWltcG9ydGFudDt9Lmhhcy12ZXJ5LWxpZ2h0LWdyYXktdG8tY3lhbi1ibHVpc2gtZ3JheS1ncmFkaWVudC1iYWNrZ3JvdW5ke2JhY2tncm91bmQ6IHZhcigtLXdwLS1wcmVzZXQtLWdyYWRpZW50LS12ZXJ5LWxpZ2h0LWdyYXktdG8tY3lhbi1ibHVpc2gtZ3JheSkgIWltcG9ydGFudDt9Lmhhcy1jb29sLXRvLXdhcm0tc3BlY3RydW0tZ3JhZGllbnQtYmFja2dyb3VuZHtiYWNrZ3JvdW5kOiB2YXIoLS13cC0tcHJlc2V0LS1ncmFkaWVudC0tY29vbC10by13YXJtLXNwZWN0cnVtKSAhaW1wb3J0YW50O30uaGFzLWJsdXNoLWxpZ2h0LXB1cnBsZS1ncmFkaWVudC1iYWNrZ3JvdW5ke2JhY2tncm91bmQ6IHZhcigtLXdwLS1wcmVzZXQtLWdyYWRpZW50LS1ibHVzaC1saWdodC1wdXJwbGUpICFpbXBvcnRhbnQ7fS5oYXMtYmx1c2gtYm9yZGVhdXgtZ3JhZGllbnQtYmFja2dyb3VuZHtiYWNrZ3JvdW5kOiB2YXIoLS13cC0tcHJlc2V0LS1ncmFkaWVudC0tYmx1c2gtYm9yZGVhdXgpICFpbXBvcnRhbnQ7fS5oYXMtbHVtaW5vdXMtZHVzay1ncmFkaWVudC1iYWNrZ3JvdW5ke2JhY2tncm91bmQ6IHZhcigtLXdwLS1wcmVzZXQtLWdyYWRpZW50LS1sdW1pbm91cy1kdXNrKSAhaW1wb3J0YW50O30uaGFzLXBhbGUtb2NlYW4tZ3JhZGllbnQtYmFja2dyb3VuZHtiYWNrZ3JvdW5kOiB2YXIoLS13cC0tcHJlc2V0LS1ncmFkaWVudC0tcGFsZS1vY2VhbikgIWltcG9ydGFudDt9Lmhhcy1lbGVjdHJpYy1ncmFzcy1ncmFkaWVudC1iYWNrZ3JvdW5ke2JhY2tncm91bmQ6IHZhcigtLXdwLS1wcmVzZXQtLWdyYWRpZW50LS1lbGVjdHJpYy1ncmFzcykgIWltcG9ydGFudDt9Lmhhcy1taWRuaWdodC1ncmFkaWVudC1iYWNrZ3JvdW5ke2JhY2tncm91bmQ6IHZhcigtLXdwLS1wcmVzZXQtLWdyYWRpZW50LS1taWRuaWdodCkgIWltcG9ydGFudDt9Lmhhcy1zbWFsbC1mb250LXNpemV7Zm9udC1zaXplOiB2YXIoLS13cC0tcHJlc2V0LS1mb250LXNpemUtLXNtYWxsKSAhaW1wb3J0YW50O30uaGFzLW1lZGl1bS1mb250LXNpemV7Zm9udC1zaXplOiB2YXIoLS13cC0tcHJlc2V0LS1mb250LXNpemUtLW1lZGl1bSkgIWltcG9ydGFudDt9Lmhhcy1sYXJnZS1mb250LXNpemV7Zm9udC1zaXplOiB2YXIoLS13cC0tcHJlc2V0LS1mb250LXNpemUtLWxhcmdlKSAhaW1wb3J0YW50O30uaGFzLXgtbGFyZ2UtZm9udC1zaXple2ZvbnQtc2l6ZTogdmFyKC0td3AtLXByZXNldC0tZm9udC1zaXplLS14LWxhcmdlKSAhaW1wb3J0YW50O30KLndwLWJsb2NrLW5hdmlnYXRpb24gYTp3aGVyZSg6bm90KC53cC1lbGVtZW50LWJ1dHRvbikpe2NvbG9yOiBpbmhlcml0O30KOndoZXJlKC53cC1ibG9jay1jb2x1bW5zLmlzLWxheW91dC1mbGV4KXtnYXA6IDJlbTt9Ci53cC1ibG9jay1wdWxscXVvdGV7Zm9udC1zaXplOiAxLjVlbTtsaW5lLWhlaWdodDogMS42O30KPC9zdHlsZT4KPGxpbmsgcmVsPSdzdHlsZXNoZWV0JyBpZD0nY29udGFjdC1mb3JtLTctY3NzJyBocmVmPSdodHRwczovL2hpbWFsdG91cmlzbS5jb20vd3AtY29udGVudC9wbHVnaW5zL2NvbnRhY3QtZm9ybS03L2luY2x1ZGVzL2Nzcy9zdHlsZXMuY3NzP3Zlcj01LjcuNS4xJyB0eXBlPSd0ZXh0L2NzcycgbWVkaWE9J2FsbCcgLz4KPGxpbmsgcmVsPSdzdHlsZXNoZWV0JyBpZD0nd29vY29tbWVyY2UtbGF5b3V0LWNzcycgaHJlZj0naHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL3dwLWNvbnRlbnQvcGx1Z2lucy93b29jb21tZXJjZS9hc3NldHMvY3NzL3dvb2NvbW1lcmNlLWxheW91dC5jc3M/dmVyPTcuNS4xJyB0eXBlPSd0ZXh0L2NzcycgbWVkaWE9J2FsbCcgLz4KPGxpbmsgcmVsPSdzdHlsZXNoZWV0JyBpZD0nd29vY29tbWVyY2Utc21hbGxzY3JlZW4tY3NzJyBocmVmPSdodHRwczovL2hpbWFsdG91cmlzbS5jb20vd3AtY29udGVudC9wbHVnaW5zL3dvb2NvbW1lcmNlL2Fzc2V0cy9jc3Mvd29vY29tbWVyY2Utc21hbGxzY3JlZW4uY3NzP3Zlcj03LjUuMScgdHlwZT0ndGV4dC9jc3MnIG1lZGlhPSdvbmx5IHNjcmVlbiBhbmQgKG1heC13aWR0aDogNzY4cHgpJyAvPgo8bGluayByZWw9J3N0eWxlc2hlZXQnIGlkPSd3b29jb21tZXJjZS1nZW5lcmFsLWNzcycgaHJlZj0naHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL3dwLWNvbnRlbnQvcGx1Z2lucy93b29jb21tZXJjZS9hc3NldHMvY3NzL3dvb2NvbW1lcmNlLmNzcz92ZXI9Ny41LjEnIHR5cGU9J3RleHQvY3NzJyBtZWRpYT0nYWxsJyAvPgo8c3R5bGUgaWQ9J3dvb2NvbW1lcmNlLWlubGluZS1pbmxpbmUtY3NzJyB0eXBlPSd0ZXh0L2Nzcyc+Ci53b29jb21tZXJjZSBmb3JtIC5mb3JtLXJvdyAucmVxdWlyZWQgeyB2aXNpYmlsaXR5OiB2aXNpYmxlOyB9Cjwvc3R5bGU+CjxsaW5rIHJlbD0nc3R5bGVzaGVldCcgaWQ9J21lZ2FtZW51LWNzcycgaHJlZj0naHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy9tYXhtZWdhbWVudS9zdHlsZS5jc3M/dmVyPTYxZGZmMicgdHlwZT0ndGV4dC9jc3MnIG1lZGlhPSdhbGwnIC8+CjxsaW5rIHJlbD0nc3R5bGVzaGVldCcgaWQ9J2Rhc2hpY29ucy1jc3MnIGhyZWY9J2h0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS93cC1pbmNsdWRlcy9jc3MvZGFzaGljb25zLm1pbi5jc3M/dmVyPTYuMi42JyB0eXBlPSd0ZXh0L2NzcycgbWVkaWE9J2FsbCcgLz4KPGxpbmsgcmVsPSdzdHlsZXNoZWV0JyBpZD0ndGhlbWUtYWRkb25zLWNzcycgaHJlZj0naHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL3dwLWNvbnRlbnQvdGhlbWVzL2FkdmVudHVyZS10b3Vycy9hc3NldHMvY3NzbGliL3RoZW1lLWFkZG9ucy5taW4uY3NzP3Zlcj0zLjEuNScgdHlwZT0ndGV4dC9jc3MnIG1lZGlhPSdhbGwnIC8+CjxsaW5rIHJlbD0nc3R5bGVzaGVldCcgaWQ9J2FkdmVudHVyZS10b3Vycy1zdHlsZS1jc3MnIGhyZWY9Jy8vaGltYWx0b3VyaXNtLmNvbS93cC1jb250ZW50L3VwbG9hZHMvYWR2ZW50dXJlLXRvdXJzLWFzc2V0cy9tYWluLWN1c3RvbS5jc3M/dmVyPTYuMi42JyB0eXBlPSd0ZXh0L2NzcycgbWVkaWE9J2FsbCcgLz4KPGxpbmsgcmVsPSdzdHlsZXNoZWV0JyBpZD0ndGhlbWUtZm9udC1nb29nbGUtZm9udHMtY3NzJyBocmVmPScvL2ZvbnRzLmdvb2dsZWFwaXMuY29tL2Nzcz9mYW1pbHk9T3h5Z2VuJTNBNDAwbm9ybWFsJTJDNzAwbm9ybWFsJTdDS2F1c2hhbitTY3JpcHQlM0E0MDBub3JtYWwmIzAzODt2ZXI9Ni4yLjYnIHR5cGU9J3RleHQvY3NzJyBtZWRpYT0nYWxsJyAvPgo8bGluayByZWw9J3N0eWxlc2hlZXQnIGlkPSdjaGlsZC1zdHlsZS1jc3MnIGhyZWY9J2h0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS93cC1jb250ZW50L3RoZW1lcy9hZHZlbnR1cmUtdG91cnMtY2hpbGQvc3R5bGUuY3NzP3Zlcj02LjIuNicgdHlwZT0ndGV4dC9jc3MnIG1lZGlhPSdhbGwnIC8+CjxsaW5rIHJlbD0nc3R5bGVzaGVldCcgaWQ9J2ljb25zLWZvbnQtZmYyMjQwNmE3MmRkODFhNDk0MjBhYTJlNDNhMGVlNjAtY3NzJyBocmVmPSdodHRwczovL2hpbWFsdG91cmlzbS5jb20vd3AtY29udGVudC90aGVtZXMvYWR2ZW50dXJlLXRvdXJzL2Fzc2V0cy9jc3NsaWIvYWR2ZW50dXJlLXRvdXJzLWljb25zLmNzcz92ZXI9Ni4yLjYnIHR5cGU9J3RleHQvY3NzJyBtZWRpYT0nYWxsJyAvPgo8bGluayByZWw9J3N0eWxlc2hlZXQnIGlkPSd0bW0tY3NzJyBocmVmPSdodHRwczovL2hpbWFsdG91cmlzbS5jb20vd3AtY29udGVudC9wbHVnaW5zL3RlYW0tbWVtYmVycy9pbmMvY3NzL3RtbV9zdHlsZS5jc3M/dmVyPTYuMi42JyB0eXBlPSd0ZXh0L2NzcycgbWVkaWE9J2FsbCcgLz4KPHNjcmlwdCB0eXBlPSd0ZXh0L2phdmFzY3JpcHQnIHNyYz0naHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL3dwLWluY2x1ZGVzL2pzL2pxdWVyeS9qcXVlcnkubWluLmpzP3Zlcj0zLjYuNCcgaWQ9J2pxdWVyeS1jb3JlLWpzJz48L3NjcmlwdD4KPHNjcmlwdCB0eXBlPSd0ZXh0L2phdmFzY3JpcHQnIHNyYz0naHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL3dwLWluY2x1ZGVzL2pzL2pxdWVyeS9qcXVlcnktbWlncmF0ZS5taW4uanM/dmVyPTMuNC4wJyBpZD0nanF1ZXJ5LW1pZ3JhdGUtanMnPjwvc2NyaXB0Pgo8c2NyaXB0IHR5cGU9J3RleHQvamF2YXNjcmlwdCcgc3JjPSdodHRwczovL2hpbWFsdG91cmlzbS5jb20vd3AtY29udGVudC9wbHVnaW5zL3dvb2NvbW1lcmNlL2Fzc2V0cy9qcy9qcXVlcnktYmxvY2t1aS9qcXVlcnkuYmxvY2tVSS5taW4uanM/dmVyPTIuNy4wLXdjLjcuNS4xJyBpZD0nanF1ZXJ5LWJsb2NrdWktanMnPjwvc2NyaXB0Pgo8c2NyaXB0IHR5cGU9J3RleHQvamF2YXNjcmlwdCcgaWQ9J3djLWFkZC10by1jYXJ0LWpzLWV4dHJhJz4KLyogPCFbQ0RBVEFbICovCnZhciB3Y19hZGRfdG9fY2FydF9wYXJhbXMgPSB7ImFqYXhfdXJsIjoiXC93cC1hZG1pblwvYWRtaW4tYWpheC5waHAiLCJ3Y19hamF4X3VybCI6IlwvP3djLWFqYXg9JSVlbmRwb2ludCUlIiwiaTE4bl92aWV3X2NhcnQiOiJWaWV3IGNhcnQiLCJjYXJ0X3VybCI6Imh0dHBzOlwvXC9oaW1hbHRvdXJpc20uY29tXC9jYXJ0XC8iLCJpc19jYXJ0IjoiIiwiY2FydF9yZWRpcmVjdF9hZnRlcl9hZGQiOiJubyJ9OwovKiBdXT4gKi8KPC9zY3JpcHQ+CjxzY3JpcHQgdHlwZT0ndGV4dC9qYXZhc2NyaXB0JyBzcmM9J2h0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS93cC1jb250ZW50L3BsdWdpbnMvd29vY29tbWVyY2UvYXNzZXRzL2pzL2Zyb250ZW5kL2FkZC10by1jYXJ0Lm1pbi5qcz92ZXI9Ny41LjEnIGlkPSd3Yy1hZGQtdG8tY2FydC1qcyc+PC9zY3JpcHQ+CjxzY3JpcHQgdHlwZT0ndGV4dC9qYXZhc2NyaXB0JyBzcmM9J2h0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS93cC1jb250ZW50L3BsdWdpbnMvanNfY29tcG9zZXIvYXNzZXRzL2pzL3ZlbmRvcnMvd29vY29tbWVyY2UtYWRkLXRvLWNhcnQuanM/dmVyPTYuOS4wJyBpZD0ndmNfd29vY29tbWVyY2UtYWRkLXRvLWNhcnQtanMtanMnPjwvc2NyaXB0Pgo8bGluayByZWw9Imh0dHBzOi8vYXBpLncub3JnLyIgaHJlZj0iaHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL3dwLWpzb24vIiAvPjxsaW5rIHJlbD0iYWx0ZXJuYXRlIiB0eXBlPSJhcHBsaWNhdGlvbi9qc29uIiBocmVmPSJodHRwczovL2hpbWFsdG91cmlzbS5jb20vd3AtanNvbi93cC92Mi9wcm9kdWN0LzEzMDMiIC8+PGxpbmsgcmVsPSJFZGl0VVJJIiB0eXBlPSJhcHBsaWNhdGlvbi9yc2QreG1sIiB0aXRsZT0iUlNEIiBocmVmPSJodHRwczovL2hpbWFsdG91cmlzbS5jb20veG1scnBjLnBocD9yc2QiIC8+CjxsaW5rIHJlbD0id2x3bWFuaWZlc3QiIHR5cGU9ImFwcGxpY2F0aW9uL3dsd21hbmlmZXN0K3htbCIgaHJlZj0iaHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL3dwLWluY2x1ZGVzL3dsd21hbmlmZXN0LnhtbCIgLz4KPG1ldGEgbmFtZT0iZ2VuZXJhdG9yIiBjb250ZW50PSJXb3JkUHJlc3MgNi4yLjYiIC8+CjxtZXRhIG5hbWU9ImdlbmVyYXRvciIgY29udGVudD0iV29vQ29tbWVyY2UgNy41LjEiIC8+CjxsaW5rIHJlbD0iY2Fub25pY2FsIiBocmVmPSJodHRwczovL2hpbWFsdG91cmlzbS5jb20vdG91cnMvZXZlcmVzdC1iYXNlLWNhbXAtdHJlay12aWEtc2FsbGVyaS8iIC8+CjxsaW5rIHJlbD0nc2hvcnRsaW5rJyBocmVmPSdodHRwczovL2hpbWFsdG91cmlzbS5jb20vP3A9MTMwMycgLz4KPGxpbmsgcmVsPSJhbHRlcm5hdGUiIHR5cGU9ImFwcGxpY2F0aW9uL2pzb24rb2VtYmVkIiBocmVmPSJodHRwczovL2hpbWFsdG91cmlzbS5jb20vd3AtanNvbi9vZW1iZWQvMS4wL2VtYmVkP3VybD1odHRwcyUzQSUyRiUyRmhpbWFsdG91cmlzbS5jb20lMkZ0b3VycyUyRmV2ZXJlc3QtYmFzZS1jYW1wLXRyZWstdmlhLXNhbGxlcmklMkYiIC8+CjxsaW5rIHJlbD0iYWx0ZXJuYXRlIiB0eXBlPSJ0ZXh0L3htbCtvZW1iZWQiIGhyZWY9Imh0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS93cC1qc29uL29lbWJlZC8xLjAvZW1iZWQ/dXJsPWh0dHBzJTNBJTJGJTJGaGltYWx0b3VyaXNtLmNvbSUyRnRvdXJzJTJGZXZlcmVzdC1iYXNlLWNhbXAtdHJlay12aWEtc2FsbGVyaSUyRiYjMDM4O2Zvcm1hdD14bWwiIC8+Cgk8bm9zY3JpcHQ+PHN0eWxlPi53b29jb21tZXJjZS1wcm9kdWN0LWdhbGxlcnl7IG9wYWNpdHk6IDEgIWltcG9ydGFudDsgfTwvc3R5bGU+PC9ub3NjcmlwdD4KCTxtZXRhIG5hbWU9ImdlbmVyYXRvciIgY29udGVudD0iUG93ZXJlZCBieSBXUEJha2VyeSBQYWdlIEJ1aWxkZXIgLSBkcmFnIGFuZCBkcm9wIHBhZ2UgYnVpbGRlciBmb3IgV29yZFByZXNzLiIvPgo8bWV0YSBuYW1lPSJnZW5lcmF0b3IiIGNvbnRlbnQ9IlBvd2VyZWQgYnkgU2xpZGVyIFJldm9sdXRpb24gNi42LjUgLSByZXNwb25zaXZlLCBNb2JpbGUtRnJpZW5kbHkgU2xpZGVyIFBsdWdpbiBmb3IgV29yZFByZXNzIHdpdGggY29tZm9ydGFibGUgZHJhZyBhbmQgZHJvcCBpbnRlcmZhY2UuIiAvPgo8c2NyaXB0PmZ1bmN0aW9uIHNldFJFVlN0YXJ0U2l6ZShlKXsKCQkJLy93aW5kb3cucmVxdWVzdEFuaW1hdGlvbkZyYW1lKGZ1bmN0aW9uKCkgewoJCQkJd2luZG93LlJTSVcgPSB3aW5kb3cuUlNJVz09PXVuZGVmaW5lZCA/IHdpbmRvdy5pbm5lcldpZHRoIDogd2luZG93LlJTSVc7CgkJCQl3aW5kb3cuUlNJSCA9IHdpbmRvdy5SU0lIPT09dW5kZWZpbmVkID8gd2luZG93LmlubmVySGVpZ2h0IDogd2luZG93LlJTSUg7CgkJCQl0cnkgewoJCQkJCXZhciBwdyA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKGUuYykucGFyZW50Tm9kZS5vZmZzZXRXaWR0aCwKCQkJCQkJbmV3aDsKCQkJCQlwdyA9IHB3PT09MCB8fCBpc05hTihwdykgfHwgKGUubD09ImZ1bGx3aWR0aCIgfHwgZS5sYXlvdXQ9PSJmdWxsd2lkdGgiKSA/IHdpbmRvdy5SU0lXIDogcHc7CgkJCQkJZS50YWJ3ID0gZS50YWJ3PT09dW5kZWZpbmVkID8gMCA6IHBhcnNlSW50KGUudGFidyk7CgkJCQkJZS50aHVtYncgPSBlLnRodW1idz09PXVuZGVmaW5lZCA/IDAgOiBwYXJzZUludChlLnRodW1idyk7CgkJCQkJZS50YWJoID0gZS50YWJoPT09dW5kZWZpbmVkID8gMCA6IHBhcnNlSW50KGUudGFiaCk7CgkJCQkJZS50aHVtYmggPSBlLnRodW1iaD09PXVuZGVmaW5lZCA/IDAgOiBwYXJzZUludChlLnRodW1iaCk7CgkJCQkJZS50YWJoaWRlID0gZS50YWJoaWRlPT09dW5kZWZpbmVkID8gMCA6IHBhcnNlSW50KGUudGFiaGlkZSk7CgkJCQkJZS50aHVtYmhpZGUgPSBlLnRodW1iaGlkZT09PXVuZGVmaW5lZCA/IDAgOiBwYXJzZUludChlLnRodW1iaGlkZSk7CgkJCQkJZS5taCA9IGUubWg9PT11bmRlZmluZWQgfHwgZS5taD09IiIgfHwgZS5taD09PSJhdXRvIiA/IDAgOiBwYXJzZUludChlLm1oLDApOwoJCQkJCWlmKGUubGF5b3V0PT09ImZ1bGxzY3JlZW4iIHx8IGUubD09PSJmdWxsc2NyZWVuIikKCQkJCQkJbmV3aCA9IE1hdGgubWF4KGUubWgsd2luZG93LlJTSUgpOwoJCQkJCWVsc2V7CgkJCQkJCWUuZ3cgPSBBcnJheS5pc0FycmF5KGUuZ3cpID8gZS5ndyA6IFtlLmd3XTsKCQkJCQkJZm9yICh2YXIgaSBpbiBlLnJsKSBpZiAoZS5nd1tpXT09PXVuZGVmaW5lZCB8fCBlLmd3W2ldPT09MCkgZS5nd1tpXSA9IGUuZ3dbaS0xXTsKCQkJCQkJZS5naCA9IGUuZWw9PT11bmRlZmluZWQgfHwgZS5lbD09PSIiIHx8IChBcnJheS5pc0FycmF5KGUuZWwpICYmIGUuZWwubGVuZ3RoPT0wKT8gZS5naCA6IGUuZWw7CgkJCQkJCWUuZ2ggPSBBcnJheS5pc0FycmF5KGUuZ2gpID8gZS5naCA6IFtlLmdoXTsKCQkJCQkJZm9yICh2YXIgaSBpbiBlLnJsKSBpZiAoZS5naFtpXT09PXVuZGVmaW5lZCB8fCBlLmdoW2ldPT09MCkgZS5naFtpXSA9IGUuZ2hbaS0xXTsKCQkJCQkJCQkJCQkKCQkJCQkJdmFyIG5sID0gbmV3IEFycmF5KGUucmwubGVuZ3RoKSwKCQkJCQkJCWl4ID0gMCwKCQkJCQkJCXNsOwoJCQkJCQllLnRhYncgPSBlLnRhYmhpZGU+PXB3ID8gMCA6IGUudGFidzsKCQkJCQkJZS50aHVtYncgPSBlLnRodW1iaGlkZT49cHcgPyAwIDogZS50aHVtYnc7CgkJCQkJCWUudGFiaCA9IGUudGFiaGlkZT49cHcgPyAwIDogZS50YWJoOwoJCQkJCQllLnRodW1iaCA9IGUudGh1bWJoaWRlPj1wdyA/IDAgOiBlLnRodW1iaDsKCQkJCQkJZm9yICh2YXIgaSBpbiBlLnJsKSBubFtpXSA9IGUucmxbaV08d2luZG93LlJTSVcgPyAwIDogZS5ybFtpXTsKCQkJCQkJc2wgPSBubFswXTsKCQkJCQkJZm9yICh2YXIgaSBpbiBubCkgaWYgKHNsPm5sW2ldICYmIG5sW2ldPjApIHsgc2wgPSBubFtpXTsgaXg9aTt9CgkJCQkJCXZhciBtID0gcHc+KGUuZ3dbaXhdK2UudGFidytlLnRodW1idykgPyAxIDogKHB3LShlLnRhYncrZS50aHVtYncpKSAvIChlLmd3W2l4XSk7CgkJCQkJCW5ld2ggPSAgKGUuZ2hbaXhdICogbSkgKyAoZS50YWJoICsgZS50aHVtYmgpOwoJCQkJCX0KCQkJCQl2YXIgZWwgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZChlLmMpOwoJCQkJCWlmIChlbCE9PW51bGwgJiYgZWwpIGVsLnN0eWxlLmhlaWdodCA9IG5ld2grInB4IjsKCQkJCQllbCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKGUuYysiX3dyYXBwZXIiKTsKCQkJCQlpZiAoZWwhPT1udWxsICYmIGVsKSB7CgkJCQkJCWVsLnN0eWxlLmhlaWdodCA9IG5ld2grInB4IjsKCQkJCQkJZWwuc3R5bGUuZGlzcGxheSA9ICJibG9jayI7CgkJCQkJfQoJCQkJfSBjYXRjaChlKXsKCQkJCQljb25zb2xlLmxvZygiRmFpbHVyZSBhdCBQcmVzaXplIG9mIFNsaWRlcjoiICsgZSkKCQkJCX0KCQkJLy99KTsKCQkgIH07PC9zY3JpcHQ+CgkJPHN0eWxlIHR5cGU9InRleHQvY3NzIiBpZD0id3AtY3VzdG9tLWNzcyI+CgkJCS50b3Vycy10YWJzIC5uYXYtdGFicyB7CiAgICBtYXJnaW46IDA7CiAgICBib3JkZXItYm90dG9tOiAzcHggc29saWQgIzQ3YTBmZjsKICAgIHdpZHRoOiA5MDBweDsKfQoKLm1hcmdpbi10b3AgewogICAgbWFyZ2luLXRvcDogMHB4Owp9CgouZm9vdGVyIC53aWRnZXRfX3RpdGxlIHsKICAgIHBhZGRpbmctdG9wOiAzMHB4Owp9CgouaGVhZGVyX19pbmZvX19pdGVtewoJb3BhY2l0eToxMDA7Cn0KCi5tYXJnaW4tYm90dG9tLWxhcmdlIHsKICAgIG1hcmdpbi1ib3R0b206IC0yMHB4Owp9CQk8L3N0eWxlPgoJCTxub3NjcmlwdD48c3R5bGU+IC53cGJfYW5pbWF0ZV93aGVuX2FsbW9zdF92aXNpYmxlIHsgb3BhY2l0eTogMTsgfTwvc3R5bGU+PC9ub3NjcmlwdD48c3R5bGUgdHlwZT0idGV4dC9jc3MiPi8qKiBNZWdhIE1lbnUgQ1NTOiBmcyAqKi88L3N0eWxlPgo8L2hlYWQ+Cjxib2R5IGNsYXNzPSJwcm9kdWN0LXRlbXBsYXRlLWRlZmF1bHQgc2luZ2xlIHNpbmdsZS1wcm9kdWN0IHBvc3RpZC0xMzAzIHRoZW1lLWFkdmVudHVyZS10b3VycyB3b29jb21tZXJjZSB3b29jb21tZXJjZS1wYWdlIHdvb2NvbW1lcmNlLW5vLWpzIG1lZ2EtbWVudS1oZWFkZXItbWVudSB3cGItanMtY29tcG9zZXIganMtY29tcC12ZXItNi45LjAgdmNfcmVzcG9uc2l2ZSB0b3VyLXNpbmdsZSI+Cgk8ZGl2IGNsYXNzPSJsYXlvdXQtY29udGVudCI+CjxkaXYgY2xhc3M9ImhlYWRlci13cmFwIj48ZGl2IGNsYXNzPSJoZWFkZXItd3JhcF9fYmFja2xvZyI+PC9kaXY+PGhlYWRlciBjbGFzcz0iaGVhZGVyIiByb2xlPSJiYW5uZXIiPgoJPGRpdiBjbGFzcz0iY29udGFpbmVyIj4KCQk8ZGl2IGNsYXNzPSJoZWFkZXJfX2luZm8iPgoJPGRpdiBjbGFzcz0iaGVhZGVyX19pbmZvX19pdGVtcy1sZWZ0Ij48ZGl2IGNsYXNzPSJoZWFkZXJfX2luZm9fX2l0ZW0gaGVhZGVyX19pbmZvX19pdGVtLS1waG9uZSI+PGkgY2xhc3M9ImZhIGZhLXBob25lIj48L2k+Kzk3NyA5ODUxMTA0MTA3PC9kaXY+PGRpdiBjbGFzcz0iaGVhZGVyX19pbmZvX19pdGVtIGhlYWRlcl9faW5mb19faXRlbS0tY2xvY2siPjxpIGNsYXNzPSJmYSBmYS1jbG9jay1vIj48L2k+MDk6MDAgQS5NIC0gMDY6MDAgUC5NLjwvZGl2PjwvZGl2PgoKCTxkaXYgY2xhc3M9ImhlYWRlcl9faW5mb19faXRlbXMtcmlnaHQiPgoJCTxkaXYgY2xhc3M9ImhlYWRlcl9faW5mb19faXRlbSBoZWFkZXJfX2luZm9fX2l0ZW0tLWRlbGltaXRlciBoZWFkZXJfX2luZm9fX2l0ZW0tLXNvY2lhbC1pY29ucyI+PGEgaHJlZj0iIyI+PGkgY2xhc3M9ImZhIGZhLWZhY2Vib29rIj48L2k+PC9hPjxhIGhyZWY9IiMiPjxpIGNsYXNzPSJmYSBmYS10d2l0dGVyIj48L2k+PC9hPjxhIGhyZWY9IiMiPjxpIGNsYXNzPSJmYSBmYS1pbnN0YWdyYW0iPjwvaT48L2E+PC9kaXY+CQk8ZGl2IGNsYXNzPSJoZWFkZXJfX2luZm9fX2l0ZW0gaGVhZGVyX19pbmZvX19pdGVtLS1kZWxpbWl0ZXIgaGVhZGVyX19pbmZvX19pdGVtLS1zaG9waW5nLWNhcnQiPgo8YSBocmVmPSJodHRwczovL2hpbWFsdG91cmlzbS5jb20vY2FydC8iPjxpIGNsYXNzPSJmYSBmYS1zaG9wcGluZy1jYXJ0Ij48L2k+PC9hPjwvZGl2PgoKCQk8ZGl2IGNsYXNzPSJoZWFkZXJfX2luZm9fX2l0ZW0gaGVhZGVyX19pbmZvX19pdGVtLS1kZWxpbWl0ZXIgaGVhZGVyX19pbmZvX19pdGVtLS1zZWFyY2giPjxhIGhyZWY9IiNzZWFyY2gtZm9ybS1oZWFkZXIiIGNsYXNzPSJwb3B1cC1zZWFyY2gtZm9ybSIgZGF0YS1lZmZlY3Q9Im1mcC16b29tLWluIj48aSBjbGFzcz0iZmEgZmEtc2VhcmNoIj48L2k+PC9hPjwvZGl2PgoKPGRpdiBpZD0ic2VhcmNoLWZvcm0taGVhZGVyIiBjbGFzcz0ic2VhcmNoLWZvcm0tcG9wdXAgc2VhcmNoLWZvcm0tcG9wdXAtLWhpZGUgbWZwLXdpdGgtYW5pbSBtZnAtaGlkZSAiPgoJPGZvcm0gcm9sZT0ic2VhcmNoIiBtZXRob2Q9ImdldCIgY2xhc3M9InNlYXJjaC1mb3JtIiBhY3Rpb249Imh0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS8iPgoJCQkJPGxhYmVsPgoJCQkJCTxzcGFuIGNsYXNzPSJzY3JlZW4tcmVhZGVyLXRleHQiPlNlYXJjaCBmb3I6PC9zcGFuPgoJCQkJCTxpbnB1dCB0eXBlPSJzZWFyY2giIGNsYXNzPSJzZWFyY2gtZmllbGQiIHBsYWNlaG9sZGVyPSJTZWFyY2ggJmhlbGxpcDsiIHZhbHVlPSIiIG5hbWU9InMiIC8+CgkJCQk8L2xhYmVsPgoJCQkJPGlucHV0IHR5cGU9InN1Ym1pdCIgY2xhc3M9InNlYXJjaC1zdWJtaXQiIHZhbHVlPSJTZWFyY2giIC8+CgkJCTwvZm9ybT48L2Rpdj4KCTwvZGl2Pgo8L2Rpdj4KCQk8ZGl2IGNsYXNzPSJoZWFkZXJfX2NvbnRlbnQtd3JhcCI+CgkJCTxkaXYgY2xhc3M9InJvdyI+CgkJCQk8ZGl2IGNsYXNzPSJjb2wtbWQtMTIgaGVhZGVyX19jb250ZW50Ij4KCQkJCQkKPGRpdiBjbGFzcz0ibG9nbyBsb2dvLS1pbWFnZSI+PGEgaWQ9ImxvZ29MaW5rIiBocmVmPSJodHRwczovL2hpbWFsdG91cmlzbS5jb20vIj48aW1nIGlkPSJub3JtYWxJbWFnZUxvZ28iIHNyYz0iaHR0cDovL2hpbWFsdG91cmlzbS5jb20vd3AtY29udGVudC91cGxvYWRzLzIwMjIvMTIvTG9nby5wbmciIGFsdD0iSGltYWwgVG91cmlzbSIgdGl0bGU9IlBpb25lZXIgaW4gSGlraW5nIGluIE5lcGFsIHNpbmNlIDIwMDgiPjxpbWcgaWQ9InJldGluYUltYWdlTG9nbyIgc3JjPSJodHRwOi8vaGltYWx0b3VyaXNtLmNvbS93cC1jb250ZW50L3VwbG9hZHMvMjAyMi8xMi9Mb2dvLnBuZyIgYWx0PSJIaW1hbCBUb3VyaXNtIiB0aXRsZT0iUGlvbmVlciBpbiBIaWtpbmcgaW4gTmVwYWwgc2luY2UgMjAwOCI+PC9hPjwvZGl2PgkJCQkJCQkJCQk8bmF2IGNsYXNzPSJtYWluLW5hdi1oZWFkZXIiIHJvbGU9Im5hdmlnYXRpb24iPgoJCQkJCQk8ZGl2IGlkPSJtZWdhLW1lbnUtd3JhcC1oZWFkZXItbWVudSIgY2xhc3M9Im1lZ2EtbWVudS13cmFwIj48ZGl2IGNsYXNzPSJtZWdhLW1lbnUtdG9nZ2xlIj48ZGl2IGNsYXNzPSJtZWdhLXRvZ2dsZS1ibG9ja3MtbGVmdCI+PC9kaXY+PGRpdiBjbGFzcz0ibWVnYS10b2dnbGUtYmxvY2tzLWNlbnRlciI+PC9kaXY+PGRpdiBjbGFzcz0ibWVnYS10b2dnbGUtYmxvY2tzLXJpZ2h0Ij48ZGl2IGNsYXNzPSdtZWdhLXRvZ2dsZS1ibG9jayBtZWdhLW1lbnUtdG9nZ2xlLWFuaW1hdGVkLWJsb2NrIG1lZ2EtdG9nZ2xlLWJsb2NrLTAnIGlkPSdtZWdhLXRvZ2dsZS1ibG9jay0wJz48YnV0dG9uIGFyaWEtbGFiZWw9IlRvZ2dsZSBNZW51IiBjbGFzcz0ibWVnYS10b2dnbGUtYW5pbWF0ZWQgbWVnYS10b2dnbGUtYW5pbWF0ZWQtc2xpZGVyIiB0eXBlPSJidXR0b24iIGFyaWEtZXhwYW5kZWQ9ImZhbHNlIj4KICAgICAgICAgICAgICAgICAgPHNwYW4gY2xhc3M9Im1lZ2EtdG9nZ2xlLWFuaW1hdGVkLWJveCI+CiAgICAgICAgICAgICAgICAgICAgPHNwYW4gY2xhc3M9Im1lZ2EtdG9nZ2xlLWFuaW1hdGVkLWlubmVyIj48L3NwYW4+CiAgICAgICAgICAgICAgICAgIDwvc3Bhbj4KICAgICAgICAgICAgICAgIDwvYnV0dG9uPjwvZGl2PjwvZGl2PjwvZGl2Pjx1bCBpZD0ibWVnYS1tZW51LWhlYWRlci1tZW51IiBjbGFzcz0ibWVnYS1tZW51IG1heC1tZWdhLW1lbnUgbWVnYS1tZW51LWhvcml6b250YWwgbWVnYS1uby1qcyIgZGF0YS1ldmVudD0iaG92ZXJfaW50ZW50IiBkYXRhLWVmZmVjdD0iZmFkZV91cCIgZGF0YS1lZmZlY3Qtc3BlZWQ9IjIwMCIgZGF0YS1lZmZlY3QtbW9iaWxlPSJkaXNhYmxlZCIgZGF0YS1lZmZlY3Qtc3BlZWQtbW9iaWxlPSIwIiBkYXRhLW1vYmlsZS1mb3JjZS13aWR0aD0iZmFsc2UiIGRhdGEtc2Vjb25kLWNsaWNrPSJnbyIgZGF0YS1kb2N1bWVudC1jbGljaz0iY29sbGFwc2UiIGRhdGEtdmVydGljYWwtYmVoYXZpb3VyPSJzdGFuZGFyZCIgZGF0YS1icmVha3BvaW50PSI3NjgiIGRhdGEtdW5iaW5kPSJ0cnVlIiBkYXRhLW1vYmlsZS1zdGF0ZT0iY29sbGFwc2VfYWxsIiBkYXRhLW1vYmlsZS1kaXJlY3Rpb249InZlcnRpY2FsIiBkYXRhLWhvdmVyLWludGVudC10aW1lb3V0PSIzMDAiIGRhdGEtaG92ZXItaW50ZW50LWludGVydmFsPSIxMDAiPjxsaSBjbGFzcz0nbWVnYS1tZW51LWl0ZW0gbWVnYS1tZW51LWl0ZW0tdHlwZS1wb3N0X3R5cGUgbWVnYS1tZW51LWl0ZW0tb2JqZWN0LXBhZ2UgbWVnYS1tZW51LWl0ZW0taG9tZSBtZWdhLWFsaWduLWJvdHRvbS1sZWZ0IG1lZ2EtbWVudS1mbHlvdXQgbWVnYS1tZW51LWl0ZW0tMTQ3MycgaWQ9J21lZ2EtbWVudS1pdGVtLTE0NzMnPjxhIGNsYXNzPSJtZWdhLW1lbnUtbGluayIgaHJlZj0iaHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tLyIgdGFiaW5kZXg9IjAiPkhvbWU8L2E+PC9saT48bGkgY2xhc3M9J21lZ2EtbWVudS1pdGVtIG1lZ2EtbWVudS1pdGVtLXR5cGUtdGF4b25vbXkgbWVnYS1tZW51LWl0ZW0tb2JqZWN0LXRvdXJfY2F0ZWdvcnkgbWVnYS1jdXJyZW50LXByb2R1Y3QtYW5jZXN0b3IgbWVnYS1jdXJyZW50LW1lbnUtYW5jZXN0b3IgbWVnYS1jdXJyZW50LW1lbnUtcGFyZW50IG1lZ2EtY3VycmVudC1wcm9kdWN0LXBhcmVudCBtZWdhLW1lbnUtaXRlbS1oYXMtY2hpbGRyZW4gbWVnYS1hbGlnbi1ib3R0b20tbGVmdCBtZWdhLW1lbnUtZmx5b3V0IG1lZ2EtbWVudS1pdGVtLTE0NzQnIGlkPSdtZWdhLW1lbnUtaXRlbS0xNDc0Jz48YSBjbGFzcz0ibWVnYS1tZW51LWxpbmsiIGhyZWY9Imh0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS90b3VyLWNhdGVnb3J5L2Rlc3RpbmF0aW9ucy8iIGFyaWEtZXhwYW5kZWQ9ImZhbHNlIiB0YWJpbmRleD0iMCI+RGVzdGluYXRpb25zPHNwYW4gY2xhc3M9Im1lZ2EtaW5kaWNhdG9yIj48L3NwYW4+PC9hPgo8dWwgY2xhc3M9Im1lZ2Etc3ViLW1lbnUiPgo8bGkgY2xhc3M9J21lZ2EtbWVudS1pdGVtIG1lZ2EtbWVudS1pdGVtLXR5cGUtdGF4b25vbXkgbWVnYS1tZW51LWl0ZW0tb2JqZWN0LXRvdXJfY2F0ZWdvcnkgbWVnYS1jdXJyZW50LXByb2R1Y3QtYW5jZXN0b3IgbWVnYS1jdXJyZW50LW1lbnUtYW5jZXN0b3IgbWVnYS1jdXJyZW50LW1lbnUtcGFyZW50IG1lZ2EtY3VycmVudC1wcm9kdWN0LXBhcmVudCBtZWdhLW1lbnUtaXRlbS1oYXMtY2hpbGRyZW4gbWVnYS1tZW51LWl0ZW0tMTQ3NScgaWQ9J21lZ2EtbWVudS1pdGVtLTE0NzUnPjxhIGNsYXNzPSJtZWdhLW1lbnUtbGluayIgaHJlZj0iaHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL3RvdXItY2F0ZWdvcnkvbmVwYWwvIiBhcmlhLWV4cGFuZGVkPSJmYWxzZSI+TmVwYWw8c3BhbiBjbGFzcz0ibWVnYS1pbmRpY2F0b3IiPjwvc3Bhbj48L2E+Cgk8dWwgY2xhc3M9Im1lZ2Etc3ViLW1lbnUiPgo8bGkgY2xhc3M9J21lZ2EtbWVudS1pdGVtIG1lZ2EtbWVudS1pdGVtLXR5cGUtdGF4b25vbXkgbWVnYS1tZW51LWl0ZW0tb2JqZWN0LXRvdXJfY2F0ZWdvcnkgbWVnYS1jdXJyZW50LW1lbnUtYW5jZXN0b3IgbWVnYS1tZW51LWl0ZW0taGFzLWNoaWxkcmVuIG1lZ2EtbWVudS1pdGVtLTE0NzYnIGlkPSdtZWdhLW1lbnUtaXRlbS0xNDc2Jz48YSBjbGFzcz0ibWVnYS1tZW51LWxpbmsiIGhyZWY9Imh0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS90b3VyLWNhdGVnb3J5L25lcGFsLXRyZWtraW5nLyIgYXJpYS1leHBhbmRlZD0iZmFsc2UiPk5lcGFsIFRyZWtraW5nPHNwYW4gY2xhc3M9Im1lZ2EtaW5kaWNhdG9yIj48L3NwYW4+PC9hPgoJCTx1bCBjbGFzcz0ibWVnYS1zdWItbWVudSI+CjxsaSBjbGFzcz0nbWVnYS1tZW51LWl0ZW0gbWVnYS1tZW51LWl0ZW0tdHlwZS10YXhvbm9teSBtZWdhLW1lbnUtaXRlbS1vYmplY3QtdG91cl9jYXRlZ29yeSBtZWdhLWN1cnJlbnQtcHJvZHVjdC1hbmNlc3RvciBtZWdhLWN1cnJlbnQtbWVudS1hbmNlc3RvciBtZWdhLWN1cnJlbnQtbWVudS1wYXJlbnQgbWVnYS1jdXJyZW50LXByb2R1Y3QtcGFyZW50IG1lZ2EtbWVudS1pdGVtLWhhcy1jaGlsZHJlbiBtZWdhLW1lbnUtaXRlbS0xNDc4JyBpZD0nbWVnYS1tZW51LWl0ZW0tMTQ3OCc+PGEgY2xhc3M9Im1lZ2EtbWVudS1saW5rIiBocmVmPSJodHRwczovL2hpbWFsdG91cmlzbS5jb20vdG91ci1jYXRlZ29yeS9ldmVyZXN0LXJlZ2lvbi8iIGFyaWEtZXhwYW5kZWQ9ImZhbHNlIj5FdmVyZXN0IFJlZ2lvbjxzcGFuIGNsYXNzPSJtZWdhLWluZGljYXRvciI+PC9zcGFuPjwvYT4KCQkJPHVsIGNsYXNzPSJtZWdhLXN1Yi1tZW51Ij4KPGxpIGNsYXNzPSdtZWdhLW1lbnUtaXRlbSBtZWdhLW1lbnUtaXRlbS10eXBlLXBvc3RfdHlwZSBtZWdhLW1lbnUtaXRlbS1vYmplY3QtcHJvZHVjdCBtZWdhLW1lbnUtaXRlbS0xNDc5JyBpZD0nbWVnYS1tZW51LWl0ZW0tMTQ3OSc+PGEgY2xhc3M9Im1lZ2EtbWVudS1saW5rIiBocmVmPSJodHRwczovL2hpbWFsdG91cmlzbS5jb20vdG91cnMvZXZlcmVzdC1iYXNlLWNhbXAtdHJlay8iPkV2ZXJlc3QgQmFzZSBDYW1wIFRyZWs8L2E+PC9saT48bGkgY2xhc3M9J21lZ2EtbWVudS1pdGVtIG1lZ2EtbWVudS1pdGVtLXR5cGUtcG9zdF90eXBlIG1lZ2EtbWVudS1pdGVtLW9iamVjdC1wcm9kdWN0IG1lZ2EtY3VycmVudC1tZW51LWl0ZW0gbWVnYS1tZW51LWl0ZW0tMTQ4MScgaWQ9J21lZ2EtbWVudS1pdGVtLTE0ODEnPjxhIGNsYXNzPSJtZWdhLW1lbnUtbGluayIgaHJlZj0iaHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL3RvdXJzL2V2ZXJlc3QtYmFzZS1jYW1wLXRyZWstdmlhLXNhbGxlcmkvIiBhcmlhLWN1cnJlbnQ9InBhZ2UiPkV2ZXJlc3QgQmFzZSBDYW1wIFRyZWsgdmlhIFNhbGxlcmk8L2E+PC9saT48bGkgY2xhc3M9J21lZ2EtbWVudS1pdGVtIG1lZ2EtbWVudS1pdGVtLXR5cGUtcG9zdF90eXBlIG1lZ2EtbWVudS1pdGVtLW9iamVjdC1wcm9kdWN0IG1lZ2EtbWVudS1pdGVtLTE0ODQnIGlkPSdtZWdhLW1lbnUtaXRlbS0xNDg0Jz48YSBjbGFzcz0ibWVnYS1tZW51LWxpbmsiIGhyZWY9Imh0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS90b3Vycy9ldmVyZXN0LXZpZXctdHJlay8iPkV2ZXJlc3QgVmlldyBUcmVrPC9hPjwvbGk+PGxpIGNsYXNzPSdtZWdhLW1lbnUtaXRlbSBtZWdhLW1lbnUtaXRlbS10eXBlLXBvc3RfdHlwZSBtZWdhLW1lbnUtaXRlbS1vYmplY3QtcHJvZHVjdCBtZWdhLW1lbnUtaXRlbS0xNDg3JyBpZD0nbWVnYS1tZW51LWl0ZW0tMTQ4Nyc+PGEgY2xhc3M9Im1lZ2EtbWVudS1saW5rIiBocmVmPSJodHRwczovL2hpbWFsdG91cmlzbS5jb20vdG91cnMvZXZlcmVzdC1oaWdoLXBhc3Nlcy10cmVrLyI+RXZlcmVzdCBIaWdoIFBhc3NlcyBUcmVrPC9hPjwvbGk+CQkJPC91bD4KPC9saT48bGkgY2xhc3M9J21lZ2EtbWVudS1pdGVtIG1lZ2EtbWVudS1pdGVtLXR5cGUtdGF4b25vbXkgbWVnYS1tZW51LWl0ZW0tb2JqZWN0LXRvdXJfY2F0ZWdvcnkgbWVnYS1tZW51LWl0ZW0taGFzLWNoaWxkcmVuIG1lZ2EtbWVudS1pdGVtLTE0OTgnIGlkPSdtZWdhLW1lbnUtaXRlbS0xNDk4Jz48YSBjbGFzcz0ibWVnYS1tZW51LWxpbmsiIGhyZWY9Imh0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS90b3VyLWNhdGVnb3J5L2FubmFwdXJuYS1yZWdpb24vIiBhcmlhLWV4cGFuZGVkPSJmYWxzZSI+QW5uYXB1cm5hIFJlZ2lvbjxzcGFuIGNsYXNzPSJtZWdhLWluZGljYXRvciI+PC9zcGFuPjwvYT4KCQkJPHVsIGNsYXNzPSJtZWdhLXN1Yi1tZW51Ij4KPGxpIGNsYXNzPSdtZWdhLW1lbnUtaXRlbSBtZWdhLW1lbnUtaXRlbS10eXBlLXBvc3RfdHlwZSBtZWdhLW1lbnUtaXRlbS1vYmplY3QtcHJvZHVjdCBtZWdhLW1lbnUtaXRlbS0xNDk5JyBpZD0nbWVnYS1tZW51LWl0ZW0tMTQ5OSc+PGEgY2xhc3M9Im1lZ2EtbWVudS1saW5rIiBocmVmPSJodHRwczovL2hpbWFsdG91cmlzbS5jb20vdG91cnMvYW5uYXB1cm5hLWJhc2UtY2FtcC10cmVrLyI+QW5uYXB1cm5hIEJhc2UgQ2FtcCBUcmVrPC9hPjwvbGk+CQkJPC91bD4KPC9saT48bGkgY2xhc3M9J21lZ2EtbWVudS1pdGVtIG1lZ2EtbWVudS1pdGVtLXR5cGUtdGF4b25vbXkgbWVnYS1tZW51LWl0ZW0tb2JqZWN0LXRvdXJfY2F0ZWdvcnkgbWVnYS1tZW51LWl0ZW0tMTUxNicgaWQ9J21lZ2EtbWVudS1pdGVtLTE1MTYnPjxhIGNsYXNzPSJtZWdhLW1lbnUtbGluayIgaHJlZj0iaHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL3RvdXItY2F0ZWdvcnkvbGFuZ3RhbmctcmVnaW9uLyI+TGFuZ3RhbmcgUmVnaW9uPC9hPjwvbGk+PGxpIGNsYXNzPSdtZWdhLW1lbnUtaXRlbSBtZWdhLW1lbnUtaXRlbS10eXBlLXRheG9ub215IG1lZ2EtbWVudS1pdGVtLW9iamVjdC10b3VyX2NhdGVnb3J5IG1lZ2EtbWVudS1pdGVtLWhhcy1jaGlsZHJlbiBtZWdhLW1lbnUtaXRlbS0xNTIxJyBpZD0nbWVnYS1tZW51LWl0ZW0tMTUyMSc+PGEgY2xhc3M9Im1lZ2EtbWVudS1saW5rIiBocmVmPSJodHRwczovL2hpbWFsdG91cmlzbS5jb20vdG91ci1jYXRlZ29yeS9tYW5hc2x1LXJlZ2lvbi8iIGFyaWEtZXhwYW5kZWQ9ImZhbHNlIj5NYW5hc2x1IFJlZ2lvbjxzcGFuIGNsYXNzPSJtZWdhLWluZGljYXRvciI+PC9zcGFuPjwvYT4KCQkJPHVsIGNsYXNzPSJtZWdhLXN1Yi1tZW51Ij4KPGxpIGNsYXNzPSdtZWdhLW1lbnUtaXRlbSBtZWdhLW1lbnUtaXRlbS10eXBlLXBvc3RfdHlwZSBtZWdhLW1lbnUtaXRlbS1vYmplY3QtcHJvZHVjdCBtZWdhLW1lbnUtaXRlbS0xNTI0JyBpZD0nbWVnYS1tZW51LWl0ZW0tMTUyNCc+PGEgY2xhc3M9Im1lZ2EtbWVudS1saW5rIiBocmVmPSJodHRwczovL2hpbWFsdG91cmlzbS5jb20vdG91cnMvbWFuYXNsdS1jaXJjdWl0LXRyZWsvIj5NYW5hc2x1IENpcmN1aXQgVHJlazwvYT48L2xpPgkJCTwvdWw+CjwvbGk+CQk8L3VsPgo8L2xpPjxsaSBjbGFzcz0nbWVnYS1tZW51LWl0ZW0gbWVnYS1tZW51LWl0ZW0tdHlwZS10YXhvbm9teSBtZWdhLW1lbnUtaXRlbS1vYmplY3QtdG91cl9jYXRlZ29yeSBtZWdhLW1lbnUtaXRlbS0xNTMwJyBpZD0nbWVnYS1tZW51LWl0ZW0tMTUzMCc+PGEgY2xhc3M9Im1lZ2EtbWVudS1saW5rIiBocmVmPSJodHRwczovL2hpbWFsdG91cmlzbS5jb20vdG91ci1jYXRlZ29yeS9uZXBhbC10b3VyLyI+TmVwYWwgVG91cjwvYT48L2xpPjxsaSBjbGFzcz0nbWVnYS1tZW51LWl0ZW0gbWVnYS1tZW51LWl0ZW0tdHlwZS10YXhvbm9teSBtZWdhLW1lbnUtaXRlbS1vYmplY3QtdG91cl9jYXRlZ29yeSBtZWdhLW1lbnUtaXRlbS1oYXMtY2hpbGRyZW4gbWVnYS1tZW51LWl0ZW0tMTU0NicgaWQ9J21lZ2EtbWVudS1pdGVtLTE1NDYnPjxhIGNsYXNzPSJtZWdhLW1lbnUtbGluayIgaHJlZj0iaHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL3RvdXItY2F0ZWdvcnkvbmVwYWwtcGVhay1jbGltYmluZy8iIGFyaWEtZXhwYW5kZWQ9ImZhbHNlIj5OZXBhbCBQZWFrIENsaW1iaW5nPHNwYW4gY2xhc3M9Im1lZ2EtaW5kaWNhdG9yIj48L3NwYW4+PC9hPgoJCTx1bCBjbGFzcz0ibWVnYS1zdWItbWVudSI+CjxsaSBjbGFzcz0nbWVnYS1tZW51LWl0ZW0gbWVnYS1tZW51LWl0ZW0tdHlwZS1wb3N0X3R5cGUgbWVnYS1tZW51LWl0ZW0tb2JqZWN0LXByb2R1Y3QgbWVnYS1tZW51LWl0ZW0tMTU1MycgaWQ9J21lZ2EtbWVudS1pdGVtLTE1NTMnPjxhIGNsYXNzPSJtZWdhLW1lbnUtbGluayIgaHJlZj0iaHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL3RvdXJzL21lcmEtcGVhay1jbGltYmluZy8iPk1lcmEgUGVhayBDbGltYmluZzwvYT48L2xpPjxsaSBjbGFzcz0nbWVnYS1tZW51LWl0ZW0gbWVnYS1tZW51LWl0ZW0tdHlwZS1wb3N0X3R5cGUgbWVnYS1tZW51LWl0ZW0tb2JqZWN0LXByb2R1Y3QgbWVnYS1tZW51LWl0ZW0tMTU0OCcgaWQ9J21lZ2EtbWVudS1pdGVtLTE1NDgnPjxhIGNsYXNzPSJtZWdhLW1lbnUtbGluayIgaHJlZj0iaHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL3RvdXJzL2lzbGFuZC1wZWFrLWNsaW1iaW5nLyI+SXNsYW5kIFBlYWsgQ2xpbWJpbmc8L2E+PC9saT4JCTwvdWw+CjwvbGk+PGxpIGNsYXNzPSdtZWdhLW1lbnUtaXRlbSBtZWdhLW1lbnUtaXRlbS10eXBlLXRheG9ub215IG1lZ2EtbWVudS1pdGVtLW9iamVjdC10b3VyX2NhdGVnb3J5IG1lZ2EtbWVudS1pdGVtLTE1NTYnIGlkPSdtZWdhLW1lbnUtaXRlbS0xNTU2Jz48YSBjbGFzcz0ibWVnYS1tZW51LWxpbmsiIGhyZWY9Imh0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS90b3VyLWNhdGVnb3J5L25lcGFsLWhlbGljb3B0ZXItdG91ci8iPk5lcGFsIEhlbGljb3B0ZXIgVG91cjwvYT48L2xpPjxsaSBjbGFzcz0nbWVnYS1tZW51LWl0ZW0gbWVnYS1tZW51LWl0ZW0tdHlwZS10YXhvbm9teSBtZWdhLW1lbnUtaXRlbS1vYmplY3QtdG91cl9jYXRlZ29yeSBtZWdhLW1lbnUtaXRlbS0xNTYxJyBpZD0nbWVnYS1tZW51LWl0ZW0tMTU2MSc+PGEgY2xhc3M9Im1lZ2EtbWVudS1saW5rIiBocmVmPSJodHRwczovL2hpbWFsdG91cmlzbS5jb20vdG91ci1jYXRlZ29yeS9uZXBhbC1mZXN0aXZhbHMtdG91ci8iPk5lcGFsIEZlc3RpdmFscyBUb3VyPC9hPjwvbGk+CTwvdWw+CjwvbGk+PGxpIGNsYXNzPSdtZWdhLW1lbnUtaXRlbSBtZWdhLW1lbnUtaXRlbS10eXBlLXRheG9ub215IG1lZ2EtbWVudS1pdGVtLW9iamVjdC10b3VyX2NhdGVnb3J5IG1lZ2EtbWVudS1pdGVtLTE1NzInIGlkPSdtZWdhLW1lbnUtaXRlbS0xNTcyJz48YSBjbGFzcz0ibWVnYS1tZW51LWxpbmsiIGhyZWY9Imh0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS90b3VyLWNhdGVnb3J5L2JodXRhbi8iPkJodXRhbjwvYT48L2xpPjxsaSBjbGFzcz0nbWVnYS1tZW51LWl0ZW0gbWVnYS1tZW51LWl0ZW0tdHlwZS10YXhvbm9teSBtZWdhLW1lbnUtaXRlbS1vYmplY3QtdG91cl9jYXRlZ29yeSBtZWdhLW1lbnUtaXRlbS0xNTY0JyBpZD0nbWVnYS1tZW51LWl0ZW0tMTU2NCc+PGEgY2xhc3M9Im1lZ2EtbWVudS1saW5rIiBocmVmPSJodHRwczovL2hpbWFsdG91cmlzbS5jb20vdG91ci1jYXRlZ29yeS90aWJldC8iPlRpYmV0PC9hPjwvbGk+PC91bD4KPC9saT48bGkgY2xhc3M9J21lZ2EtbWVudS1pdGVtIG1lZ2EtbWVudS1pdGVtLXR5cGUtY3VzdG9tIG1lZ2EtbWVudS1pdGVtLW9iamVjdC1jdXN0b20gbWVnYS1hbGlnbi1ib3R0b20tbGVmdCBtZWdhLW1lbnUtZmx5b3V0IG1lZ2EtbWVudS1pdGVtLTE1ODQnIGlkPSdtZWdhLW1lbnUtaXRlbS0xNTg0Jz48YSBjbGFzcz0ibWVnYS1tZW51LWxpbmsiIGhyZWY9Imh0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS90b3VyLWNhdGVnb3J5L2RlYWxzLWFuZC1kaXNjb3VudHMvIiB0YWJpbmRleD0iMCI+RGlzY291bnRzICYgT2ZmZXJzPC9hPjwvbGk+PGxpIGNsYXNzPSdtZWdhLW1lbnUtaXRlbSBtZWdhLW1lbnUtaXRlbS10eXBlLWN1c3RvbSBtZWdhLW1lbnUtaXRlbS1vYmplY3QtY3VzdG9tIG1lZ2EtYWxpZ24tYm90dG9tLWxlZnQgbWVnYS1tZW51LWZseW91dCBtZWdhLW1lbnUtaXRlbS0xNTgwJyBpZD0nbWVnYS1tZW51LWl0ZW0tMTU4MCc+PGEgY2xhc3M9Im1lZ2EtbWVudS1saW5rIiBocmVmPSIjIiB0YWJpbmRleD0iMCI+VHJhdmVsIEd1aWRlPC9hPjwvbGk+PGxpIGNsYXNzPSdtZWdhLW1lbnUtaXRlbSBtZWdhLW1lbnUtaXRlbS10eXBlLXBvc3RfdHlwZSBtZWdhLW1lbnUtaXRlbS1vYmplY3QtcGFnZSBtZWdhLWFsaWduLWJvdHRvbS1sZWZ0IG1lZ2EtbWVudS1mbHlvdXQgbWVnYS1tZW51LWl0ZW0tMTYxNScgaWQ9J21lZ2EtbWVudS1pdGVtLTE2MTUnPjxhIGNsYXNzPSJtZWdhLW1lbnUtbGluayIgaHJlZj0iaHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL2NvbnRhY3QtdXMvIiB0YWJpbmRleD0iMCI+Q29udGFjdCBVczwvYT48L2xpPjxsaSBjbGFzcz0nbWVnYS1tZW51LWl0ZW0gbWVnYS1tZW51LWl0ZW0tdHlwZS1jdXN0b20gbWVnYS1tZW51LWl0ZW0tb2JqZWN0LWN1c3RvbSBtZWdhLWFsaWduLWJvdHRvbS1sZWZ0IG1lZ2EtbWVudS1mbHlvdXQgbWVnYS1tZW51LWl0ZW0tMTYyNScgaWQ9J21lZ2EtbWVudS1pdGVtLTE2MjUnPjxhIGNsYXNzPSJtZWdhLW1lbnUtbGluayIgaHJlZj0iIyIgdGFiaW5kZXg9IjAiPkJsb2c8L2E+PC9saT48bGkgY2xhc3M9J21lZ2EtbWVudS1pdGVtIG1lZ2EtbWVudS1pdGVtLXR5cGUtY3VzdG9tIG1lZ2EtbWVudS1pdGVtLW9iamVjdC1jdXN0b20gbWVnYS1tZW51LWl0ZW0taGFzLWNoaWxkcmVuIG1lZ2EtYWxpZ24tYm90dG9tLWxlZnQgbWVnYS1tZW51LWZseW91dCBtZWdhLW1lbnUtaXRlbS0xNTc5JyBpZD0nbWVnYS1tZW51LWl0ZW0tMTU3OSc+PGEgY2xhc3M9Im1lZ2EtbWVudS1saW5rIiBocmVmPSIjIiBhcmlhLWV4cGFuZGVkPSJmYWxzZSIgdGFiaW5kZXg9IjAiPkFib3V0IFVzPHNwYW4gY2xhc3M9Im1lZ2EtaW5kaWNhdG9yIj48L3NwYW4+PC9hPgo8dWwgY2xhc3M9Im1lZ2Etc3ViLW1lbnUiPgo8bGkgY2xhc3M9J21lZ2EtbWVudS1pdGVtIG1lZ2EtbWVudS1pdGVtLXR5cGUtY3VzdG9tIG1lZ2EtbWVudS1pdGVtLW9iamVjdC1jdXN0b20gbWVnYS1tZW51LWl0ZW0tMTg4OScgaWQ9J21lZ2EtbWVudS1pdGVtLTE4ODknPjxhIGNsYXNzPSJtZWdhLW1lbnUtbGluayIgaHJlZj0iaHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL291ci10ZWFtLyI+T3VyIFRlYW08L2E+PC9saT48bGkgY2xhc3M9J21lZ2EtbWVudS1pdGVtIG1lZ2EtbWVudS1pdGVtLXR5cGUtcG9zdF90eXBlIG1lZ2EtbWVudS1pdGVtLW9iamVjdC1wYWdlIG1lZ2EtbWVudS1pdGVtLTE1OTEnIGlkPSdtZWdhLW1lbnUtaXRlbS0xNTkxJz48YSBjbGFzcz0ibWVnYS1tZW51LWxpbmsiIGhyZWY9Imh0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS9ib29raW5nLXRlcm1zLWNvbmRpdGlvbnMvIj5Cb29raW5nIFRlcm1zICYjMDM4OyBDb25kaXRpb25zPC9hPjwvbGk+PGxpIGNsYXNzPSdtZWdhLW1lbnUtaXRlbSBtZWdhLW1lbnUtaXRlbS10eXBlLXBvc3RfdHlwZSBtZWdhLW1lbnUtaXRlbS1vYmplY3QtcGFnZSBtZWdhLW1lbnUtaXRlbS0xNTkyJyBpZD0nbWVnYS1tZW51LWl0ZW0tMTU5Mic+PGEgY2xhc3M9Im1lZ2EtbWVudS1saW5rIiBocmVmPSJodHRwczovL2hpbWFsdG91cmlzbS5jb20vYmFuay1kZXRhaWxzLyI+QmFuayBEZXRhaWxzPC9hPjwvbGk+PGxpIGNsYXNzPSdtZWdhLW1lbnUtaXRlbSBtZWdhLW1lbnUtaXRlbS10eXBlLXBvc3RfdHlwZSBtZWdhLW1lbnUtaXRlbS1vYmplY3QtcGFnZSBtZWdhLW1lbnUtaXRlbS0xNTkzJyBpZD0nbWVnYS1tZW51LWl0ZW0tMTU5Myc+PGEgY2xhc3M9Im1lZ2EtbWVudS1saW5rIiBocmVmPSJodHRwczovL2hpbWFsdG91cmlzbS5jb20vbGVnYWwtZG9jdW1lbnQvIj5MZWdhbCBEb2N1bWVudDwvYT48L2xpPjxsaSBjbGFzcz0nbWVnYS1tZW51LWl0ZW0gbWVnYS1tZW51LWl0ZW0tdHlwZS1wb3N0X3R5cGUgbWVnYS1tZW51LWl0ZW0tb2JqZWN0LXBhZ2UgbWVnYS1tZW51LWl0ZW0tMTU4OScgaWQ9J21lZ2EtbWVudS1pdGVtLTE1ODknPjxhIGNsYXNzPSJtZWdhLW1lbnUtbGluayIgaHJlZj0iaHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL3doby13ZS1hcmUvIj5XaG8gV2UgQXJlPzwvYT48L2xpPjxsaSBjbGFzcz0nbWVnYS1tZW51LWl0ZW0gbWVnYS1tZW51LWl0ZW0tdHlwZS1wb3N0X3R5cGUgbWVnYS1tZW51LWl0ZW0tb2JqZWN0LXBhZ2UgbWVnYS1tZW51LWl0ZW0tMTU5MCcgaWQ9J21lZ2EtbWVudS1pdGVtLTE1OTAnPjxhIGNsYXNzPSJtZWdhLW1lbnUtbGluayIgaHJlZj0iaHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL3doYXQtd2Utb2ZmZXIvIj5XaGF0IFdlIE9mZmVyPzwvYT48L2xpPjwvdWw+CjwvbGk+PC91bD48L2Rpdj4JCQkJCTwvbmF2PgoJCQkJCQkJCQkJPGRpdiBjbGFzcz0iY2xlYXJmaXgiPjwvZGl2PgoJCQkJPC9kaXY+PCEtLSAuaGVhZGVyX19jb250ZW50IC0tPgoJCQk8L2Rpdj4KCQk8L2Rpdj48IS0tIC5oZWFkZXJfX2NvbnRlbnQtd3JhcCAtLT4KCTwvZGl2PjwhLS0gLmNvbnRhaW5lciAtLT4KPC9oZWFkZXI+CjwvZGl2Pgo8ZGl2IGNsYXNzPSJoZWFkZXItc2VjdGlvbiBoZWFkZXItc2VjdGlvbi0td2l0aC1iYW5uZXIgcGFyYWxsYXgtc2VjdGlvbiBwYXJhbGxheC1zZWN0aW9uLS1oZWFkZXIiPgo8ZGl2IGNsYXNzPSJwYXJhbGxheC1pbWFnZSIgc3R5bGU9ImJhY2tncm91bmQtaW1hZ2U6dXJsKGh0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS93cC1jb250ZW50L3VwbG9hZHMvMjAyMi8xMS9uZXBhbC01MzI4NjkxLXNjYWxlZC5qcGcpOyBiYWNrZ3JvdW5kLXJlcGVhdDpyZXBlYXQ7Ij48L2Rpdj4JPGRpdiBjbGFzcz0iY29udGFpbmVyIj4KCQk8ZGl2IGNsYXNzPSJicmVhZGNydW1icyI+PHVsPjxsaT48YSBocmVmPSJodHRwczovL2hpbWFsdG91cmlzbS5jb20iPkhvbWU8L2E+PC9saT48bGk+PGEgaHJlZj0iaHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL3RvdXJzLyI+VG91cnM8L2E+PC9saT48bGk+RXZlcmVzdCBCYXNlIENhbXAgVHJlayB2aWEgU2FsbGVyaTwvbGk+PC91bD48L2Rpdj4JCTxkaXYgY2xhc3M9ImhlYWRlci1zZWN0aW9uX19jb250ZW50Ij4KCQk8aDEgY2xhc3M9ImhlYWRlci1zZWN0aW9uX190aXRsZSI+RXZlcmVzdCBCYXNlIENhbXAgVHJlayB2aWEgU2FsbGVyaTwvaDE+PGRpdiBjbGFzcz0iaGVhZGVyLXNlY3Rpb25fX3JhdGluZyI+PGEgY2xhc3M9ImhlYWRlci1zZWN0aW9uX19yYXRpbmdfX2xpbmsiIGhyZWY9IiNjb21tZW50cyI+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT4oMjIgcmV2aWV3cyk8L2E+PC9kaXY+CQk8L2Rpdj4KCTwvZGl2Pgo8L2Rpdj4KPGRpdiBjbGFzcz0iY29udGFpbmVyIGxheW91dC1jb250YWluZXIgbWFyZ2luLXRvcCBtYXJnaW4tYm90dG9tIj4KCjxkaXYgY2xhc3M9InJvdyB0b3VyLXNpbmdsZS1yaXNlIj4KCTxtYWluIGNsYXNzPSJjb2wtbWQtOSIgcm9sZT0ibWFpbiIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUHJvZHVjdCI+CgkJPGRpdiBjbGFzcz0idG91cnMtdGFicyI+Cgk8dWwgY2xhc3M9Im5hdiBuYXYtdGFicyI+Cgk8bGkgY2xhc3M9ImFjdGl2ZSI+PGEgaHJlZj0iI3RhYmRlc2NyaXB0aW9uIiBkYXRhLXRvZ2dsZT0idGFiIj5EZXRhaWxzPC9hPjwvbGk+PGxpPjxhIGhyZWY9IiN0YWJhdGFiMCIgZGF0YS10b2dnbGU9InRhYiI+Y29zdHM8L2E+PC9saT48bGk+PGEgaHJlZj0iI3RhYmF0YWIxIiBkYXRhLXRvZ2dsZT0idGFiIj5kZXRhaWxlZCBpdGluZXJhcnk8L2E+PC9saT48bGk+PGEgaHJlZj0iI3RhYmF0YWIyIiBkYXRhLXRvZ2dsZT0idGFiIj51c2VmdWwgaW5mb3JtYXRpb248L2E+PC9saT4JPC91bD4KCgk8ZGl2IGNsYXNzPSJ0YWItY29udGVudCI+CgkJCQk8ZGl2IGNsYXNzPSJ0YWItcGFuZSBpbiBhY3RpdmUiIGlkPSJ0YWJkZXNjcmlwdGlvbiI+CgkJCQkJPGRpdiBjbGFzcz0idG91cnMtdGFic19fY29udGVudCBwYWRkaW5nLWFsbCI+CgkJCTx1bCBjbGFzcz0idG91ci1jYXRlZ29yaWVzLWxpc3QgbGlzdC1ibG9jayBsaXN0LWJsb2NrLS10b3VyLXRhYnMiPjxsaT48YSBocmVmPSJodHRwczovL2hpbWFsdG91cmlzbS5jb20vdG91ci1jYXRlZ29yeS9kZXN0aW5hdGlvbnMvIj5EZXN0aW5hdGlvbnM8L2E+PC9saT48bGk+PGEgaHJlZj0iaHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL3RvdXItY2F0ZWdvcnkvZXZlcmVzdC1yZWdpb24vIj5FdmVyZXN0IFJlZ2lvbjwvYT48L2xpPjxsaT48YSBocmVmPSJodHRwczovL2hpbWFsdG91cmlzbS5jb20vdG91ci1jYXRlZ29yeS9uZXBhbC8iPk5lcGFsPC9hPjwvbGk+PC91bD48cD48ZW0+QWx0ZXJuYXRpdmUgb2YgTHVrbGEgRmxpZ2h0IGV4cGVyaWVuY2luZyB0aGUgY291bnRyeXNpZGUgbGlmZXN0eWxlIGFuZCBsYW5kc2NhcGU8L2VtPjwvcD4KPHA+SmVlcCBkcml2ZSB0byBFdmVyZXN0IGlzIGEgdW5pcXVlIHRyaXAgZGVzaWduZWQgd2l0aCBhbiBpbnRlbnRpb24gdG8gZXhwbG9yZSB0aGUgY291bnRyeXNpZGUgbGlmZSB0YWtpbmcgeW91IHRvIHRoZSBiYXNlIG9mIGhpZ2hlc3QgUGVhay0gdGhlIE10LiBFdmVyZXN0LiBObyBkb3VidHMsIHlvdSB3aWxsIGV4cGVyaWVuY2UgdGhlIHJpY2ggY3VsdHVyZSwgdmlsbGFnZSBsaWZlIGFsb25nIHdpdGggdGhlIGJlYXV0aWZ1bCBsYW5kc2NhcGUgYW5kIHRoZSBIaW1hbGF5YXMuPC9wPgo8cD5UcmVrIGJlZ2lucyB3aXRoIGEgaGlnaHdheSBkcml2ZcKgdG8gU2FsbGVyaS7CoFlvdSB3aWxsIGhlYWQgdG93YXJkIHRoZSBPZmYgQmVhdGVuIFRyYWlsIHRha2luZyB5b3UgdG8gdGhlIFNhbGxlcmkgZm9yIEV2ZXJlc3QgVHJlay4gT24gdGhlIHdheSwgeW91IHdpbGwgc2VlIHRoZSBiZWF1dGlmdWwgZmFybWxhbmQsIHRoZSB3ZWxjb21pbmcgYW5kIGhvc3BpdGFibGUgdmlsbGFnZXJzLiBZb3Ugd2lsbCBzdG9wIGF0IFNhbGxlcmkgZnJvbSB3aGVyZSB5b3Ugd2lsbCBjb21tZW5jZSBhIHRyZWsgdG8gU29sdSByZWdpb24uIEl0IHdpbGwgYmUgYSBzbW9vdGggYW5kIHJlbGF4aW5nIHdhbGsgYWxvbmcgdGhlIER1ZGggS29zaGkgUml2ZXIgYWZ0ZXIgY3Jvc3NpbmcgVHJha3NoaW5kbyBMYS4gT24gdGhlIHdheSwgeW91IGNhbiB2aWV3IHNvbWUgb2YgdGhlIG1vdW50YWlucyBpbmNsdWRpbmcgVGhhbXNlcmt1LCBLd2FuZ2RlLCBOdXB0c2UsIExob3RzZSwgQW1hIERhYmxhbSBhcyB3ZWxsIGFzIE10LiBFdmVyZXN0LiBUaGUgY29sb3JmdWwgZmxhZ3MgZmxhdHRlcmluZyBhbGwgdGhlIHdheSB0byB0aGUgRXZlcmVzdCBhbG9uZyB3aXRoIHRoZSBzYWNyZWQgbWFuaS13YWxscywgY2hvcnRlaW5zLCBtb25hc3RlcmllcyBhbmQgd2VsY29taW5nIFNoZXJwYXMgd2lsbCBkZW1vbnN0cmF0ZSB0aGUgSGltYWxheWFuIGN1bHR1cmUgYW5kIHRyYWRpdGlvbi48L3A+CjxwPkluIGFkZGl0aW9uLCBpZiB5b3Ugd2lzaCB0byBleHBsb3JlIEV2ZXJlc3QgcmVnaW9uIGluIGxpbWl0ZWQgdGltZSBlbmpveWluZyBpdHMgbmF0dXJhbCBiZWF1dGllcywgZW5oYW5jZSBjdWx0dXJhbCBleHBlcmllbmNlcywgdGhlbiB5b3UgY291bGQgam9pbiBvdXLCoEV2ZXJlc3QgQmFzZSBDYW1wIFRyZWstMTYgRGF5cy4gWW91IGNvdWxkIGFsc28gam9pbiBvdXIgY2hhbGxlbmdpbmcgdHJla2tpbmcgcm91dGUgdG/CoEV2ZXJlc3QgUmVnaW9uwqBieSBqb2luaW5nIG91csKgRXZlcmVzdCAzIFBhc3NlcyBUcmVra2luZy0xOSBEYXlzwqBvciBtb3JlIHNjZW5pYyByb3V0ZSB0b8KgR29reW8gVmFsbGV5ICZhbXA7IEV2ZXJlc3QgQmFzZSBjYW1wIFRyZWstMTggRGF5cy4gSWYgeW91IHdhbnQgdG8gYWRkIGRheS9zIGNsaW1iaW5nIGV4cGVyaWVuY2Ugd2hpbGUgdHJla2tpbmcgaW4gRXZlcmVzdCBCYXNlIENhbXAsIHlvdSBtYXkgam9pbiBvdXLCoElzbGFuZCBQZWFrLjwvcD4KPHA+SWYgeW91IGFyZSBub3Qgc2F0aXNmaWVkIHdpdGggdGhpcyBpdGluZXJhcnkgb3IgaWYgeW91IHdhbnQgdG8gY3VzdG9taXplIHRoaXMgcGFja2FnZSBpbiB5b3VyIHRpbWVsaW5lIG9yIGJ1ZGdldCwgdGhlbiB5b3UgY291bGQgY29udGFjdCB1cywgb3IgZW1haWwuPC9wPgoJCQk8L2Rpdj4KCQk8L2Rpdj4KCQkJCTxkaXYgY2xhc3M9InRhYi1wYW5lIGZhZGUiIGlkPSJ0YWJhdGFiMCI+CgkJCQkJPGRpdiBjbGFzcz0idG91cnMtdGFic19fY29udGVudCBwYWRkaW5nLWFsbCI+CgkJCTxwPjx1PjxzdHJvbmc+U2VydmljZSBJbmNsdWRlczo8L3N0cm9uZz48L3U+PC9wPgo8dWwgY2xhc3M9ImJvcmRlcmVkLWxpIGluY2x1c2lvbiI+CjxsaT5BaXJwb3J0IHRyYW5zZmVyIHdpdGggYW4gZXNjb3J0IGluIGEgcHJpdmF0ZSB2ZWhpY2xlPC9saT4KPGxpPjMgbmlnaHRz4oCZIGFjY29tbW9kYXRpb24gYXQgVG91cmlzdCBzdGFuZGFyZCBob3RlbCBpbiBLYXRobWFuZHUgd2l0aCBCcmVha2Zhc3Q8L2xpPgo8bGk+RnVsbCBib2FyZCBtZWFscyAoQnJlYWtmYXN0L0x1bmNoL0Rpbm5lcikgZm9sbG93ZWQgd2l0aCB0ZWEgb3IgY29mZmVlIGR1cmluZyB0aGUgdHJlazwvbGk+CjxsaT5BY2NvbW1vZGF0aW9uIGF0IExvY2FsIE1vdW50YWluIExvZGdlIG9yIFRlbnQgZHVyaW5nIHRoZSB0cmVrPC9saT4KPGxpPkhpa2luZyBOZXBhbCBleHBlcmllbmNlZCwgZWNvLWZyaWVuZGx5IEVuZ2xpc2ggc3BlYWtpbmcgbG9jYWwgZ3VpZGUgYW5kIHBvcnRlciAoMSBQb3J0ZXIgZm9yIDIgVHJla2tlcnMpPC9saT4KPGxpPkFsbCB0aGUgZXhwZW5zZXMgb2YgdGhlIGd1aWRlIGFuZCBwb3J0ZXIgaW5jbHVkaW5nIGZvb2QsIGFjY29tbW9kYXRpb24sIHNhbGFyeSwgZXF1aXBtZW50LCBhY2NpZGVudGFsIGluc3VyYW5jZTwvbGk+CjxsaT5UcmVrIHRyYW5zZmVyIHRvIFNhbGxlcmkgaW4gYSBTaGFyaW5nIFZlaGljbGUgKG9wdGlvbiBvZiBhIHByaXZhdGUgdmVoaWNsZSBpcyBhbHNvIGF2YWlsYWJsZSk8L2xpPgo8bGk+QWlyZmFyZSBmb3IgdGhlIHNlY3RvciBMdWtsYS9LYXRobWFuZHU8L2xpPgo8bGk+SGlraW5nIE5lcGFsIER1ZmZsZSBiYWcgZm9yIGVhY2ggdHJla2tlcjwvbGk+CjxsaT5Eb3duIGphY2tldCBhbmQgc2xlZXBpbmcgYmFnIGlmIHJlcXVpcmVkIGZvciB0aGUgdHJla2tlciAobmVlZCB0byByZXR1cm4gZnJvbSBlbmRpbmcgb2YgdGhlIHRyZWspPC9saT4KPGxpPkhpa2luZyBOZXBhbCBULXNoaXJ0LMKgIHRyaXAgYWNoaWV2ZW1lbnQgY2VydGlmaWNhdGU8L2xpPgo8bGk+Rmlyc3QgYWlkIG1lZGljYWwga2l0IGFuZCBPeHkgTWV0ZXIgY2FycmllZCBieSB0aGUgZ3VpZGU8L2xpPgo8bGk+QXBwbGljYWJsZSBQZXJtaXQ8L2xpPgo8bGk+R292ZXJubWVudCB0YXhlcyAmYW1wOyBvZmZpY2Ugc2VydmljZSBjaGFyZ2U8L2xpPgo8L3VsPgo8cD48c3Ryb25nPlNlcnZpY2UgRXhjbHVkZXM6PC9zdHJvbmc+PC9wPgo8dWwgY2xhc3M9ImJvcmRlcmVkLWxpIGV4Y2x1c2lvbiI+CjxsaT5OZXBhbCBWaXNhICYjODIxMTsgKENvc3QtIFVTJC0gMzDCoGZvciAxNSBkYXlzICZhbXA7ICQtIDUwIGZvciAzMCBkYXlzKTwvbGk+CjxsaT5MdW5jaCAmYW1wOyBldmVuaW5nIG1lYWxzIHdoaWxlIGluIEthdGhtYW5kdSAoRXhjZXB0IHdlbGNvbWUvZmFyZXdlbGwgZGlubmVyKTwvbGk+CjxsaT5UcmF2ZWwgaW5zdXJhbmNlPC9saT4KPGxpPkNvc3Qgb2YgcGVyc29uYWwgbmF0dXJlIGV4cGVuc2VzLCBCZXZlcmFnZXMgKE1pbmVyYWwgd2F0ZXIgb3IgY29jYS1jb2xhKSwgY29zdCBvZiBleHRyYSBtZWFscywgc25hY2tzLCBwaG9uZXMgYmlsbHMsIEludGVybmV0LCBXaUZpLCBsYXVuZHJ5LCBldGMuPC9saT4KPGxpPlRvdXIgY29zdCBpbiBjYXNlIHRoZSBoaXN0b3JpY2FsIHRyaXAgdG8gS2F0aG1hbmR1IENpdHk8L2xpPgo8bGk+VGhlIGNvc3QgaW5jdXJyZWQgZHVyaW5nIGVtZXJnZW5jaWVzLCBldmFjdWF0aW9ucywgYW5kIGFueSB1bmZvcmVzZWVuIGNpcmN1bXN0YW5jZXM8L2xpPgo8bGk+VGlwcyBmb3IgQ2xpbWJpbmcgU2hlcnBhL0d1aWRlL3BvcnRlcnMvZHJpdmVyICYjODIzMDs8L2xpPgo8bGk+QW55IG90aGVyIGV4cGVuc2VzIG5vdCBpbmNsdWRlZCBpbiDigJxTZXJ2aWNlIEluY2x1ZGVz4oCdPC9saT4KPC91bD4KCQkJPC9kaXY+CgkJPC9kaXY+CgkJCQk8ZGl2IGNsYXNzPSJ0YWItcGFuZSBmYWRlIiBpZD0idGFiYXRhYjEiPgoJCQkJCTxkaXYgY2xhc3M9InRvdXJzLXRhYnNfX2NvbnRlbnQgcGFkZGluZy1hbGwiPgoJCQk8cD5EYXkgMDHCoMKgwqBBcnJpdmUgS2F0aG1hbmR1IChBbHRpdHVkZTogMTM1MC80NDI4IGZ0LiBNZWFsOiBEaW5uZXIpPC9wPgo8cD5PbiB5b3VyIGFycml2YWwgYXQgS2F0aG1hbmR1IEludGVybmF0aW9uYWwgQWlycG9ydCwgb25lIG9mIG91ciByZXByZXNlbnRhdGl2ZXMgd2lsbCBwaWNrIHVwIHlvdSBhbmQgZXNjb3J0IHlvdSB0byB0aGUgaG90ZWwgYXMgd2VsbCBhcyBoZWxwIHlvdSB0byBjaGVjay1pbiBhdCB0aGUgaG90ZWwuIEFmdGVyIHlvdXIgcmVmcmVzaG1lbnQsIHlvdSB3aWxsIGJlIGJyaWVmZWQgYWJvdXQgdGhlIG5leHQgZGF5IHRyaXAuPC9wPgo8cD5EYXkgMDLCoMKgwqBQcmVwYXJhdGlvbiBkYXkgb3Igc2lnaHRzZWVpbmcgdG91ciBvZiBLYXRobWFuZHUgQ2l0eSAoQWx0aXR1ZGU6IDEzNTAvNDQyOCBmdC4gTWVhbDogQnJlYWtmYXN0KTwvcD4KPHA+QWZ0ZXIgeW91ciBkZWxpZ2h0ZnVsIGJyZWFrZmFzdCwgeW91IHdpbGwgYmUgaW50cm9kdWNlZCB3aXRoIGEgZ3VpZGUgYW5kIHNob3J0bHkgYnJpZWYgYWJvdXQgdGhlIHRyaXAuIElmIHlvdSBhcmUgd2lsbGluZyB0byBleHBsb3JlIHRoZSBIaXN0b3JpY2FsIHBsYWNlcyBpbiBLYXRobWFuZHUsIHdlIHNoYWxsIG9yZ2FuaXplIGl0IGFjY29yZGluZ2x5LiBXZSBzaGFsbCBhcnJhbmdlIGEgZHJpdmVyIGFuZCBhIHRvdXIgZ3VpZGUgd2hvIHdpbGwgdGFrZSB5b3UgdG8gVU5FU0NPIEhlcml0YWdlcyBzaXRlcyBvZiB0aGUgdmFsbGV5IHdoZXJlIHlvdSB3aWxsIG9ic2VydmUgbGl2aW5nIGhlcml0YWdlIG9mIE1lZGlldmFsIE5lcGFsICYjODIxMTsgV2l0bmVzcyB0aGUgYmlnZ2VzdCBIaW5kdSB0ZW1wbGUgb2YgTmVwYWwsIFBhc2h1cGF0aW5hdGggYW5kIGNhcHR1cmUgdGhlIHNhY3JlZCBtb21lbnRzIG9mIEhpbmR1IGRlYXRoIHJpdHVhbCBhdCBBcnlhZ2hhdCBpbiBQYXNodXBhdGluYXRoLiBTdHJvbGwgdGhlIGxpdmVseSBzdHJlZXRzIG9mIEthdGhtYW5kdSBPbGQgTWFya2V0IEFzYW4gdG8gS2F0aG1hbmR1IER1cmJhciBTcXVhcmUgYW5kIHZpc2l0IHRoZSBob21lIG9mIFRoZSBMaXZpbmcgR29kZGVzcyBLdW1hcmksIE5lcGFsZXNlIHN0eWxlIG9mIEFyY2hpdGVjdHVyZSBhcyB3ZWxsIGFzIGFzdG9uaXNoaW5nIHdvb2RlbiBjYXJ2aW5nLiBBIHNob3J0IGRyaXZlIGZyb20gS2F0aG1hbmR1IER1cmJhciBTcXVhcmUgd2lsbCB0YWtlIHlvdSB0byBhIGhpbGx0b3Agc3R1cGEgY2FsbGVkIGFzIOKAnFN3eWFtYmh14oCdIG1lYW5pbmcg4oCcc2VsZiAtZW1lcmdl4oCdIGFuZCBiZWxpZWYgdGhhdCB0aGUgaGlsbCBlbWVyZ2VkIGltcHVsc2l2ZWx5IGZyb20gdGhlIGdyZWF0IGxha2UgdGhhdCBvbmNlIGNvdmVyZWQgS2F0aG1hbmR1IHZhbGxleS48L3A+CjxwPkRheSAwM8KgwqDCoERyaXZlIEthdGhtYW5kdSB0byBTYWxsZXJpIChBbHRpdHVkZTogMjgwMCBtLzkyNDAgZnQuIERyaXZlOiA5LzEwIGhycy4gTWVhbDogQkxEKTwvcD4KPHA+SW4gdGhlIG1vcm5pbmcsIG91ciBndWlkZSB3aWxsIG1lZXQgeW91IGF0IHRoZSBsb2JieSBmb3IgYSBkcml2ZSB0byBTYWxsZXIuIFlvdSB3aWxsIGhhdmUgdGhlIG9wdGlvbiBvZiBkcml2aW5nIGluIGEgcHJpdmF0ZSBKZWVwIG9yIGEgc2hhcmluZyBqZWVwLsKgwqBZb3Ugd2lsbCBiZSBmb2xsb3dpbmcgdGhlIGhpZ2h3YXkgdG93YXJkIEVhc3Rlcm4gTmVwYWwuIENyb3NzaW5nIGEgYnJpZGdlIG92ZXIgdGhlIFN1bmtvc2hpIFJpdmVyLCB5b3Ugd2lsbCByZWFjaCB0byB0aGUgZ3JlZW4gdmFsbGV5LSBPa2hhbGRodW5nYSBhbmQgY29udGludW91c2x5IGRyaXZpbmcsIHdpbGwgdGFrZSB5b3UgdG8gdGhlIFNhbGxlcmktIGVudHJ5IHRvIHRoZSBTb2x1a2h1bWJ1LiBGcm9tIGhlcmUsIHlvdSBjYW4gdGFrZSBhIGZpcnN0IHZpZXcgb2YgdGhlIE10LiBFdmVyZXN0LiBPdmVybmlnaHQgYXQgTW91bnRhaW4gTG9kZ2UuIE1lYWw6IEJMRC48L3A+CjxwPkRheSAwNMKgwqDCoFRyZWsgdG8gVGFrc2luZG8gKEFsdGl0dWRlOiAyOTYwIG0vOTc2OCBmdC4gVHJlazogNS82IGhycy4gTWVhbDogQkxEKTwvcD4KPHA+VG9kYXkgeW91IHdpbGwgYmUgdHJla2tpbmcgYWxvbmcgdGhlIHZpbGxhZ2Ugcm9hZCB2aWV3aW5nIHRoZSBOdW1idXIgSGltYWwuIFRoZSB0cmFpbCBvZmZlcnMgYSBwaWN0dXJlc3F1ZSBsYW5kc2NhcGUsIHZpbGxhZ2UgbGlmZSwgYW5kIHRoZSBwZW9wbGUuIE9uIHJlYWNoaW5nIHRoZSBUYWtzaW5kbywgeW91IHdpbGwgYmUgY2hlY2staW4gYXQgdGhlIGxvY2FsIGxvZGdlcy4gQWZ0ZXJub29uLCB5b3UgY2FuIGFsc28gdmlzaXQgdGhlIENoZWVzZSBGYWN0b3J5IGFuZCB0aGUgc3Vycm91bmRpbmcuIE1lYWw6IEJMRDwvcD4KPHA+RGF5IDA1wqDCoMKgVHJlayB0byBLaGFyaWtob2xhwqDCoMKgKEFsdGl0dWRlOiAyMDQwIG0vNjczMiBmdC4gVHJlazogNS82IGhycy4gTWVhbDogQkxEKTwvcD4KPHA+Rm9sbG93aW5nIHRoZSB2aWxsYWdlIHRyYWlsLCB5b3Ugd2lsbCByZWFjaCB0byB0aGUgTnVudGhhbGEsIGFsc28gY2FsbGVkIGFzIE1hbmlkaW5nbWEuIEhlcmUsIHlvdSB3aWxsIGJlIHN0YXlpbmcgZm9yIGx1bmNoLiBUaGVuLCB3YWxraW5nIGFsb25nIHRoZSB2aWxsYWdlIHRyYWlsIGFuZCBjcm9zc2luZyBhIHN1c3BlbnNpb24gYnJpZGdlLCB5b3Ugd2lsbCByZWFjaCB0byB0aGUgS2FyaWtob2xhIHdoZXJlIHlvdSBhcmUgc3BlbmRpbmcgeW91ciBvdmVybmlnaHQuIEl0IGlzIGEgYmVhdXRpZnVsIHZpbGxhZ2Ugd2l0aCB0aGUgZmx1dHRlcmluZyBwcmF5ZXIgZmxhZ3MsIG1hbmkgd2FsbHMsIGFuZCBIeWRybyBQb3dlciBzdGF0aW9uIGFzIHdlbGwuIFlvdSBjYW4gYWxzbyB2aWV3IHRoZSBLaHVtYmlsaWEuIE92ZXJuaWdodCBhdCBNb3VudGFpbiBMb2RnZS4gTWVhbDogQkxEPC9wPgo8cD5EYXkgMDbCoMKgwqBUcmVrIHRvIFBhaXlhIMKgKEFsdGl0dWRlOiAyNzMwIG0vOTAxMCBmdC4gVHJlazogNS82IGhycy4gTWVhbDogQkxEKTwvcD4KPHA+RGVzY2VuZGluZyB0b3dhcmRzIGEgc21hbGwgc3RyZWFtIGFuZCBjcm9zc2luZyBhIHdvb2RlbiBicmlkZ2UsIHlvdSB3aWxsIGNvbnRpbnVlIHRvIHdhbGsgaW4gdGhlIHVwaGlsbCB0cmFpbC4gT24gdGhlIHdheSB5b3Ugd2lsbCBjcm9zcyB0aGUgQnVwc2EgVmlsbGFnZSwgaW4tcm91dGVzLCB5b3UgY2FuIHNlZSBzb21lIHdhdGVyLWRyaXZlbiBtaWxscy4gWW91IHdpbGwgdGhlbiByZWFjaCB0byBQYWl5YSB3aGVyZSB5b3Ugd2lsbCBzcGVuZCB5b3VyIG92ZXJuaWdodC4gTWVhbDogQkxEPC9wPgo8cD5EYXkgMDfCoMKgwqBUcmVrIHRvIFBoYWtkaW5nIChBbHRpdHVkZTogMjYxMCBtLzg2MTMgZnQuIFRyZWs6IDUvNiBocnMuIE1lYWw6IEJMRCk8L3A+CjxwPlRvZGF5LCB5b3Ugd2lsbCBmaW5hbGx5IHJlYWNoIHRoZSBtYWluIGVudHJhbmNlIHRvIEtodW1idS4gRm9sbG93aW5nIHRoZSB1cCBhbmQgZG93biB0cmFpbCBjcm9zc2luZyBzZXZlcmFsIHZpbGxhZ2VzIGFuZCBzdXNwZW5zaW9uIGJyaWRnZSBmb2xsb3dpbmcgRHVkaCBLb3NoaSBSaXZlciwgeW91IHdpbGwgaGVhZCB5b3VyIGpvdXJuZXkgdG8gUGhha2RpbmcuIE9uIHRoZSB3YXksIHlvdSB3aWxsIHBhc3Mgc2V2ZXJhbCBtYW5pLXdhbGxzIGFuZCBib3VsZGVycyBlbmdyYXZlZCB3aXRoIEJ1ZGRoaXN0IHByYXllcnMuIFNwZW5kIG92ZXJuaWdodCBhdCB0aGUgbG9jYWwgbG9kZ2UuPC9wPgo8cD5EYXkgMDjCoMKgwqBUcmVrIHRvIE5hbWNoZSAoQWx0aXR1ZGU7IDM0NDAgbS8xMTM1MiBmdC4gVHJlazogNS82IGhycy4gTWVhbDogQkxEKTwvcD4KPHA+VGhlIHRyZWsgY2hhc2VzIHRoZSBub3J0aGVybiB0cmlhbCB1cCB0aGUgRHVkaCBLb3NpIHZhbGxleSB0byBNb25qby4gQXQgTW9uam8sIHRoZSB0cmVrIG9mZmljaWFsbHkgZW50ZXJzIFNhZ2FybWF0aGEgTmF0aW9uYWwgUGFyayB3aGVyZSB5b3UgaGF2ZSB0byBpc3N1ZSBTYWdhcm1hdGhhIE5hdGlvbmFsIFBhcmsgUGVybWl0IENhcmQuIENvbnRpbnVpbmcgdGhlIHRyYWlsIGFsb25nIHRoZSBzdGVlcCB1cGhpbGwgY2xpbWIgd2hpbGUgc2F2b3JpbmcgdGhlIGZpcnN0IGdsaW1wc2Ugb2YgRXZlcmVzdCwgeW91IHdpbGwgYXJyaXZlIGF0IHRoZSBodWIgb2YgU2hlcnBhLSBOYW1jaGUgQmF6YWFyLiBTcGVuZCB5b3VyIG92ZXJuaWdodCBhdCBsb2NhbCBsb2RnZS48L3A+CjxwPkRheSAwOcKgwqDCoFJlc3QgZGF5IGluIE5hbWNoZSAoQWx0aXR1ZGU7IDM0NDAgbS8xMTM1MiBmdC4gTWVhbDogQkxEKTwvcD4KPHA+SXQgaXMgYSBkYXkgdG8gYWNjbGltYXRpemUgeW91IHdpdGggaGlnaGVyIGVsZXZhdGlvbi4gT24gdGhpcyBkYXksIHlvdSBjYW4gZ28gZm9yIGEgc2hvcnQgaGlrZSB0byBLaHVtanVuZywgYSBiZWF1dGlmdWwgc2V0dGxlbWVudCBvZiBIb3NwaXRhYmxlIFNoZXJwYXMuIE9SLCB5b3UgY2FuIHJvYW0gYXJvdW5kIHRoZSBOYW1jaGUgdGhhdCBvZmZlcnMgSW50ZXJuZXQgQ2FmZXMsIHJlc3RhdXJhbnRzLCBBVE1zLCBhbmQgY29sb3JmdWwgbWFya2V0cy4gRXZlbiwgeW91IGNhbiBlbmpveSB0aGUgdHJhZGl0aW9uYWwgbGl2aW5nIG9mIG1vdW50YWluIGR3ZWxsZXJzIHRoYXQgaXMgZXZlbiBiZWF1dGlmaWVkIGJ5IHRoZSBhd2UtaW5zcGlyaW5nIHN1cnJvdW5kaW5nIGFuZCBoaWdoIGFsdGl0dWRlIGZsb3JhL2ZhdW5hLjwvcD4KPHA+RGF5IDEwwqDCoMKgVHJlayB0byBUZW5nYm9jaGUgKEFsdGl0dWRlOiAzODYwIG0vIDEyNzM4IGZ0LiBUcmVrOiA1LzYgaHJzLiBNZWFsOiBCTEQpPC9wPgo8cD5XaXRoIGRlbGlnaHRmdWwgYnJlYWtmYXN0IGluIE5hbWNoZSwgeW91IHdpbGwgd2FsayBvbiB0aGUgc2lkZSBvZiB0aGUgdmFsbGV5IGFib3ZlIHRoZSBEdWRoIEtvc2hpIFJpdmVyLiBQYXNzaW5nIGJ5IHNldmVyYWwgdmlsbGFnZXMgYW5kIG51bWVyb3VzIHRlYSBzaG9wcywgeW91IHdpbGwgZGVzY2VuZCBzdGVlcGx5IHRvIGEgYnJpZGdlIG92ZXIgdGhlIHJpdmVyIGF0IFBodW5raSBUZW5nYTsgeW91IGNhbiBzZWUgd2F0ZXIgZHJpdmVuIHByYXllciB3aGVlbC4gQWxzbywgaXQgaXMgYW4gaWRlYWwgc3RvcG92ZXIgZm9yIGx1bmNoIHdoZXJlIHlvdSB3aWxsIHRha2UgcmVzdCBmb3IgYSB3aGlsZSBiZWZvcmUgbWFraW5nIHRoZSBzdGVlcCBjbGltYiB0byBUYW5nYm9jaGUuIEFsb25nIHRoZSB0cmFpbCwgeW91IGNhbiBlbmpveSB0aGUgYmVhdXRpZnVsIHJob2RvZGVuZHJvbiBidXNoZXMsIGJpcmRzIGFuZCBzdXBlcmIgbW91bnRhaW5zIHRoYXQgbGV0IHlvdSBmb3JnZXQgYWJvdXQgdGhlIHRpcmluZyB6aWd6YWcgdHJhaWwuIFlvdSB3aWxsIGdldCB0aGUgZmlyc3QgdmlldyBvZiBzcGVjdGFjdWxhciBtb3VudGFpbnMgaW5jbHVkaW5nIE10LiBFdmVyZXN0LCBBbWEgRGFibGFtLCBMaG90c2UgU2hhciwgVGF3YWNoZSwgS2FuZ3RlZ2EsIFRoYW1zZXJrdSwgTnVwdHNlLiBPbmNlIHlvdSByZWFjaCBUZW5nYm9jYmUsIHlvdSBjYW4gZXhwbG9yZSB0aGUgS2h1bWJ1IGxhcmdlc3QgbW9uYXN0ZXJ5LSB0aGUgVGVuZ2JvY2hlIE1vbmFzdGVyeS48L3A+CjxwPkRheSAxMcKgwqDCoFRyZWsgdG8gRGluZ2JvY2hlIChBbHRpdHVkZTogNDQxMCBtLzE0NTUzIGZ0LiBUcmVrOiA1LzYgaHJzLiBNZWFsOiBCTEQpPC9wPgo8cD5TdGFydHMgeW91ciB0cmFpbCBwYXNzaW5nIHRocm91Z2ggbHVzaCBmb3Jlc3RzIG9mIGJpcmNoLCBjb25mZXIgYW5kIHJob2RvZGVuZHJvbiB0cmVlcy4gT24gdGhlIHRyYWlsLCB5b3UgY2FuIGhhdmUgbWVzbWVyaXppbmcgdmlld3Mgb2YgTXQuIEV2ZXJlc3QsIExob3RzZSwgYW5kIEFtYSBEYWJsYW0uIFlvdSBjYW4gc2xvd2x5IHN0ZWVwIGRvd24gdG8gRGVib2NoZSwgdGhlbiBjcm9zcyB0aGUgSW1qYSBSaXZlciB0byBQYW5nYm9jaGUuIEFzY2VuZCB0b3dhcmQgdGhlIHVwcGVyIFBhbmdib2NoZSwgeW91IHdpbGwgdmlzaXQgb25lIG9mIHRoZSBvbGRlc3QgbW9uYXN0ZXJpZXMgb2YgS2h1bWJ1LSB0aGUgUGFuZ2JvY2hlIE1vbmFzdGVyeS4gWW91IHdpbGwgY29udGludWUgeW91ciBoaWtlIHRvIHRoZSBJbWphIFZhbGxleSBhbmQgTG9idWNoZSBSaXZlciBvbiB0aGUgd2F5IHRvIERpbmdib2NoZS4gSXQgaXMgYW4gYXR0cmFjdGl2ZSB2aWxsYWdlIHRoYXQgaXMgYmVhdXRpZmllZCB3aXRoIHRoZSBmaWVsZCBvZiBiYXJsZXksIHBvdGF0b2VzLCBhbmQgYnVja3doZWF0IGFsb25nIHdpdGggZ3JhemluZyBhbmltYWxzLjwvcD4KPHA+RGF5IDEywqDCoMKgUmVzdCBkYXkgZm9yIGFjY2xpbWF0aXphdGlvbiAoQWx0aXR1ZGU6IDQ0MTAgbS8xNDU1MyBmdC4gTWVhbDogQkxEKTwvcD4KPHA+SXQgaXMgYSBkYXkgdG8gYWNjbGltYXRpemUgeW91IGluIHRoZSBoaWdoIGFsdGl0dWRlLiBUb2RheSwgY29uc2lkZXJpbmcgeW91ciBwaHlzaWNhbCBmaXRuZXNzLCB5b3Ugd2lsbCBiZSB0YWtlbiB0byBDaGh1a3VuZyB2YWxsZXkgZm9sbG93aW5nIHRoZSBJbWphIFJpdmVyLiBGcm9tIGhlcmUsIHlvdSBjYW4gdmlldyB0aGUgc3R1bm5pbmcgbW91bnRhaW5zIGFuZCBHbGFjaWVyIGxha2VzIGluY2x1ZGluZyBJc2xhbmQgUGVhayAoNjE4OW0pLCBBbXBodWxhcGNoZSAoNTY2M20pLCBMaG90c2UgU2hhciAoODM4Mm0pIGFuZCBMaG90c2UgKDg1MTZtKS4gVGhlIG1haW4gYWltIG9mIHRvZGF5IGlzIHRvIGFjY2xpbWF0aXplIHlvdSBwcm9wZXJseSBmb3IgbW9yZSBjaGFsbGVuZ2luZyBkYXlzIG9ud2FyZHMuPC9wPgo8cD5EYXkgMTPCoMKgwqBUcmVrIHRvIExvYnVjaGUgKEFsdGl0dWRlOiA0OTEwIG0vMTYyMDMgZnQuIFRyZWs6IDUvNiBocnMuIE1lYWw6IEJMRCk8L3A+CjxwPlRvZGF5LCB0aGUgdHJlayB3aWxsIGNvbnRpbnVlIHVwIHRoZSB2aWxsYWdlIGZyb20gd2hlcmUgeW91IGNhbiBlbmpveSB0aGUgbW91bnRhaW5zIGluY2x1ZGluZyBNdC4gTWFrYWx1LiBZb3Ugd2lsbCB0YWtlIGEgc3RlZXAgY2xpbWIgdG93YXJkcyB0aGUgZm9vdCBvZiB0aGUgS2h1bWJ1IEdsYWNpZXIgYW5kIHJlYWNoIER1Z2xhLiBZb3Ugd2lsbCByZXN0IGZvciBhIHdoaWxlIGFmdGVyIHRha2luZyBsdW5jaCBhdCBsb2NhbCBsb2RnZXMuIFRoZW4sIHlvdSB3aWxsIHdhbGsgb24gdGhlIHRyYWlsIHppZ3phZ3MgdXAgdGhyb3VnaCB0aGUgYm91bGRlcnMgb2YgdGhlIGdsYWNpZXImIzgyMTc7cyB0ZXJtaW5hbCBtb3JhaW5lLiBBdCB0aGUgdG9wIG9mIHRoaXMgY2xpbWIsIHRoZXJlIGFyZSBtYW55IHN0b25lIGNhaXJucywgYnVpbHQgYXMgbWVtb3JpYWxzIHRvIHRoZSBtYW55IFNoZXJwYXMgd2hvIGhhdmUgZGllZCB3aGlsZSBjbGltYmluZyBNdCBFdmVyZXN0LiBUaGUgcGF0aCB0aGVuIGNsaW1icyBnZW50bHkgYWxvbmcgdGhlIGdsYWNpZXIsIHRvIGV2ZW50dWFsbHkgcmVhY2ggdGhlIGNsdXN0ZXIgb2YgaG91c2VzIGF0IExvYnVjaGUuwqBJdCBpcyBzaXR1YXRlZCBpbiB0aGUgYmVuZWF0aCBvZiBMaG90c2UgcmlkZ2UuPC9wPgo8cD5EYXkgMTTCoMKgwqBUcmVrIHRvIEV2ZXJlc3QgQmFzZSBDYW1wLCBiYWNrIHRvIEdvcmFrc2hlcCDCoChBbHRpdHVkZTogRUJDOiA1MzU3bS8xNzY3OCBmdC4gR29yZWtzaGVwOiA1MTQwIG0vMTY5NjAgZnQuIFRyZWs6IDYvNyBocnMuIE1lYWw6IEJMRCk8L3A+CjxwPkl0IGlzIHRoZSBtb3N0IGludGVyZXN0aW5nIGFuZCBjaGFsbGVuZ2luZyBkYXkgb2YgdGhpcyB0cmlwIGFzIHRoZSBkYXkgc3RhcnRzIHdpdGggYSBtaXh0dXJlIG9mIGV4Y2l0ZW1lbnQgYW5kIGFueGlldHkuIFRvZGF5LCB5b3Ugd2lsbCBoaWtlIHVwIHRvIHRoZSBFdmVyZXN0IGJhc2UgY2FtcCBhdCBhbiBhbHRpdHVkZSBvZiA1MzY0IG0uPGJyIC8+CllvdSB3aWxsIGhlYWQgdGhyb3VnaCB0aGUgaG9yaXpvbnRhbCBtb3JhaW5lIG9mIHRoZSBLaHVtYnUgR2xhY2llci4gT24gdGhlIHdheSB0byBHb3Jla3NoZXAsIHlvdSB3aWxsIHdpdG5lc3MgdGhlIG5vcnRoIHJpZGdlIG9mIE10LiBFdmVyZXN0LCBNdC4gUHVtb3JpLCBNdC4gTWFoYWxhbmd1ciwgTXQuIE51cHRzZSBhbmQgbWFueSBtb3JlLiBGdXJ0aGVyIGNsaW1iaW5nIHRocm91Z2ggdGhlIENoYW5ncmkgR2xhY2llciwgeW91IGNhbiBoYXZlIHRoZSBmaXJzdCBnbGltcHNlIG9mIEthbGFwYXR0aGFyLiBZb3Ugd2lsbCBzdG9wIGF0IEdvcmVrc2hlcCBmb3IgYSBsdW5jaDsgdGhlbiBjb250aW51ZSB0byB3YWxrIGZvciB5b3VyIHVsdGltYXRlIGRlc3RpbmF0aW9uLSB0aGUgRXZlcmVzdCBCYXNlIENhbXAuIFRoZSBzcGxlbmRpZCB2aWV3cyBvZiB0aGUgbW91bnRhaW5zIGFuZCBzY2VuYXJpb3MgbWFrZSB0aGUgam91cm5leSBsaXZlbGllciwgZXZlbiBzbnViYmluZyBhbGwgdGhlIHRpcmVzb21lIHdhbGsgaW4gdGhlIHN0ZWVwIHJvdXRlLiBUaGUgdHJpYWwgd2lsbCBsYXN0IGZvciBhcHByb3hpbWF0ZWx5IDMgaG91cnMgZnJvbSBHb3Jla3NoZXAuIE9uY2UgeW91IHJlYWNoIGJhc2UgY2FtcCwgeW91IGNhbiBhY3R1YWxseSBzZWUgdGhlIGRlYWRsaWVzdCByb3V0ZSB0byB0aGUgRXZlcmVzdCB0aGF0IG1ha2VzIHRoZSBqb3VybmV5IG1vcmUgYWR2ZW50dXJvdXMuIFlvdSB3aWxsIGdldCB0byBzcGVuZCBxdWFsaXR5IHRpbWUgZXhwbG9yaW5nIHRoZSBiYXNlIGNhbXAgYW5kIHN1cnJvdW5kaW5nIGFyZWFzIGFuZCByZXR1cm4gdG8gR29yYWsgU2hlcCB0byBzcGVuZCB0aGUgbmlnaHQuPC9wPgo8cD5EYXkgMTXCoMKgwqBUcmVrIHRvIEthbGFwYXR0aGFyLCBiYWNrIHRvIER1Z2hsYSAoQWx0aXR1ZGU6IEthbGFwYXR0aGFyOiA1NTUwIG0vMTgzMTUgZnQuIER6b25nbGE6IDQ2MjAgbS8xNTI0NSBmdC4gVHJlazogNS82IGhycy4gTWVhbDogQkxEKTwvcD4KPHA+TmV4dCB0byBFdmVyZXN0IEJhc2UgY2FtcCwgdGhpcyBkYXkgaXMgdG9vIGV4Y2l0aW5nIGFuZCBhZHZlbnR1cm91cyBoaWtpbmcgdG8gS2FsYXBhdHRoYXIuIFlvdSB3aWxsIGdldCBhbiBlYXJseSBtb3JuaW5nIGNhbGwgZnJvbSBvdXIgZ3VpZGUgdG8gZ2V0IHJlYWR5IHRvIGhpa2UgZmlyc3QgYXQgS2FsYXBhdHRoYXIuIFRoZSByZWFzb24gaXMgdG8gY2F0Y2ggdGhlIHNwYXJrbGluZyB5ZWxsb3dpc2ggc25vd2NhcHBlZCBvdmVyIHRoZSBtb3VudGFpbnMgZXNwZWNpYWxseSBNdC4gRXZlcmVzdCBieSB0aGUgc3RyaWtlIG9mIGV2ZXJ5IHJheSBkdXJpbmcgc3VucmlzZS4gRXZlcnkgc2Vjb25kIGJlY29tZXMgYW4gZXhjaXRpbmcgbW9tZW50IG9mIGEgbGlmZXRpbWU7IHdlbGwsIGRvbuKAmXQgZm9yZ2V0IHRvIGNhcHR1cmUgaW4gY2FtZXJhLiBUaGVuLCB5b3Ugd2lsbCByZXR1cm4gYmFjayB0byBHb3Jla3NoZXAgd2l0aCByZWZyZXNoaW5nIG1vb2QgYW5kIGRlc2NlbmQgYmFjayB0b3dhcmRzIER1Z2xhIHdoZXJlIHlvdSBzcGVuZCB5b3VyIG92ZXJuaWdodC48L3A+CjxwPkRheSAxNsKgwqDCoFRyZWsgdG8gUGFuZ2JvY2hlIChBbHRpdHVkZTogMzkzMCBtLzEyOTcwIGZ0LiBUcmVrOiA1LzYgaHJzLiBNZWFsOiBCTEQpPC9wPgo8cD5Ub2RheSwgeW91IHdpbGwgbW9zdGx5IHRyZWsgZG93bmhpbGwuIEFzIHlvdSByZXRyYWNlIHlvdXIgc3RlcHMgZnJvbSBEdWdsaGEsIHlvdSB3aWxsIGRlc2NlbmQgdG8gUGhlcmljaGUuIFlvdSBjYW4gdmlzaXQgdGhlIEhpbWFsYXlhbiBSZXNjdWUgQXNzb2NpYXRpb24sIGEgdHJla2tlcuKAmXMgYWlkIHBvc3QuIFlvdSB3aWxsIHN0YXkgZm9yIGEgd2hpbGUgZm9yIGx1bmNoLiBUaGVuLCB5b3Ugd2lsbCBjcm9zcyB0aGUgS2h1bWJ1IFJpdmVyIGJ5IGEgd29vZGVuIHN1c3BlbnNpb24gYnJpZGdlIGFuZCBmb2xsb3cgdGhlIEltamEgUml2ZXIgdG8gdGhlIHZpbGxhZ2Ugb2YgUGFuZ2JvY2hlIHdoZXJlIHlvdSB3aWxsIHNwZW5kIHlvdXIgb3Zlcm5pZ2h0LjwvcD4KPHA+RGF5IDE3wqDCoMKgVHJlayB0byBOYW1jaGUgKEFsdGl0dWRlOiAzNDQwIG0vMTEzNTIgZnQuIFRyZWs6IDQvNSBocnMuIE1lYWw6IEJMRCk8L3A+CjxwPkl0IHdpbGwgYmUgdGhlIHN0ZWVwIGRvd24gZm9sbG93aW5nIHRoZSBSaXZlciwgY3Jvc3NpbmcgYSBicmlkZ2UgYW5kIGVuam95aW5nIHRoZSByb3V0ZSBkZWNvcmF0ZWQgd2l0aCBiaXJjaCBhbmQgcmhvZG9kZW5kcm9uIGZvcmVzdC4gWW91ciBzaWdodCB3aWxsIGV2ZW4ga2VlcCBvbiBjYXRjaGluZyBhIGZldyBIaW1hbGF5YW4gZ2lhbnRzIGluY2x1ZGluZyBFdmVyZXN0LCBLd2FuZ2RlLCBUYXdhY2hlLCBOdXB0c2UsIExob3RzZSwgQW1hIERhYmxhbSwgS2FudGVnYSBhbmQgVGhhbXNlcmt1LiBPdmVybmlnaHQgd2lsbCBiZSByZWZyZXNoaW5nIGF0IE5hbWNoZS48L3A+CjxwPkRheSAxOMKgwqDCoFRyZWsgdG8gTHVrbGEgKEFsdGl0dWRlOiAyODQwLyA5MzcyIGZ0LiBUcmVrOiA0LzUgaHJzLiBNZWFsOiBCTEQpPC9wPgo8cD5Ub2RheSBpcyB0aGUgZmluYWwgZGF5IG9mIHRoZSB0cmlwLiBZb3Ugd2lsbCB3YWxrIGZvbGxvd2luZyBEdWRoIEtvc2hpIFJpdmVyIGRvd24gdG8gTHVrbGEuIFlvdSB3aWxsIGhhdmUgYSBjZWxlYnJhdGlvbiB3aXRoIHRoZSBpbnZvbHZlbWVudCBvZiB0aGUgR3VpZGUsIFNoZXJwYSwgYW5kIFBvcnRlcnMgYXMgd2VsbC4gVGhleSB3aWxsIHNlcnZlIHNvbWUgbG9jYWzigJlzIGJlZXIgY2FsbGVkIOKAnENIQU5H4oCdIGFuZCBlbmpveSBwYXJ0eSBsZWFybmluZyBzb21lIGRhbmNlIHN0ZXAgZnJvbSB0cmFkaXRpb25hbCBTaGVycGFzLjwvcD4KPHA+RGF5IDE5wqDCoMKgRmxpZ2h0IHRvIEthdGhtYW5kdSAoQWx0aXR1ZGU6IDEzNTAvNDQyOCBmdC4gRmxpZ2h0OiAzMCBtaW51dGVzIE1lYWw6IEIvRCk8L3A+CjxwPllvdSB3aWxsIGJvYXJkIGEgcGxhbmUgYmFjayB0byBLYXRobWFuZHUuIEFycml2aW5nIGF0IEthdGhtYW5kdSB5b3Ugd2lsbCBiZSB0cmFuc2ZlcnJlZCB0byB5b3VyIGhvdGVsIGFuZCByZXN0IG9mIHRoZSBkYXkgd2lsbCBiZSB5b3VyIGxlaXN1cmUgdGltZS4gWW91IGNhbiBnbyBmb3Igc2hvcHBpbmcsIG1lc3NhZ2UsIG9yIHJlc3QgYXQgdGhlIEhvdGVsLiBFdmVuaW5nIHRpbWUsIHdlIGludml0ZSB5b3UgZm9yIGEgZmFyZXdlbGwgZGlubmVyIGF0IHRoZSBhdXRoZW50aWMgcmVzdGF1cmFudC4gWW91IGNhbiBzaGFyZSB5b3VyIGV4cGVyaWVuY2UsIGZlZWRiYWNrIHVzIGFuZCBnaXZlIHVzIGEgY2hhbmNlIHRvIG1ha2UgeW91ciBldmVuaW5nIGEgd29uZGVyZnVsIHRpbWUuIE92ZXJuaWdodCBhdCBIb3RlbC48L3A+CjxwPkRheSAyMMKgwqDCoERlcGFydHVyZSB0cmFuc2ZlciAoQWx0aXR1ZGU6IDEzNTAvNDQyOCBmdC4gTWVhbDogQik8L3A+CjxwPllvdSB3aWxsIGRlcGFydCBLYXRobWFuZHUgY2FycnlpbmcgbG90cyBvZiBhZHZlbnR1cm91cyBtZW1vcmllcyBvZiB0aGUgRXZlcmVzdCBCYXNlIENhbXAgdHJlay48L3A+CgkJCTwvZGl2PgoJCTwvZGl2PgoJCQkJPGRpdiBjbGFzcz0idGFiLXBhbmUgZmFkZSIgaWQ9InRhYmF0YWIyIj4KCQkJCQk8ZGl2IGNsYXNzPSJ0b3Vycy10YWJzX19jb250ZW50IHBhZGRpbmctYWxsIj4KCQkJPHA+PHN0cm9uZz5OZXBhbCBWaXNhICZhbXA7IEdldHRpbmcgaW50byBOZXBhbDwvc3Ryb25nPjwvcD4KPHA+QWxsIHRoZSBmb3JlaWduIG5hdGlvbmFscyAoZXhjZXB0IEluZGlhbiBuYXRpb25hbHMpIGFyZSByZXF1aXJlZCB0byBkaXNwbGF5IFZpc2Egd2hpbGUgZW50ZXJpbmcgTmVwYWwuIE5lcGFsZXNlIFZpc2EgY2FuIGJlIG9idGFpbmVkIGVpdGhlciBhdCBOZXBhbGVzZSBFbWJhc3N5IG9mIHRoZSByZXNwZWN0aXZlIGNvdW50cnkgb3IgY2FuIGJlIG9idGFpbmVkIGR1cmluZyB5b3VyIGFycml2YWwgYXQgdGhlIEludGVybmF0aW9uYWwgQWlycG9ydCBpbiBLYXRobWFuZHUgb3IgZnJvbSBOZXBhbOKAmXMgYm9yZGVyIGVudHJ5IHBvaW50LiBIb3dldmVyLCBjZXJ0YWluIG5hdGlvbmFscyBhcmUgcmVxdWVzdGVkIHRvIGFycmFuZ2UgVmlzYSBwcmlvciB0byBhcnJpdmFsIGluIE5lcGFsLiBUaGUgbGlzdGVkIGNvdW50cmllcyBhcmUtIEFmZ2hhbmlzdGFuLCBJcmFxLCBDYW1lcm9vbiwgR2hhbmEsIFNvbWFsaWEsIFN3YXppbGFuZCwgUGFsZXN0aW5lLCBaaW1iYWJ3ZSwgTmlnZXJpYSwgRXRoaW9waWEgYW5kIExpYmVyaWEgYW5kIGNhbm5vdCBzZWN1cmUgTmVwYWxlc2UgVmlzYSBvbiBhcnJpdmFsLjwvcD4KPHA+UmVxdWlyZW1lbnRzOiBUcmF2ZWxlciBzaG91bGQgaGF2ZSBhIHZhbGlkIHBhc3Nwb3J0IGZvciBhdCBsZWFzdCBzaXggbW9udGhzLCByZWNlbnQgZGlnaXRhbCBwaG90b3MgKHNpemU6IDEuNSYjODI0MzsgeCAxLjUmIzgyNDM7KSBhbmQgVmlzYSBmZWVzIChlaXRoZXIgVVMkIG9yIGVxdWl2YWxlbnQpIG1lbnRpb25lZCBiZWxvdzo8L3A+CjxwPjxzdHJvbmc+wqDCoMKgwqBWaXNhIEZhY2lsaXR5wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgRHVyYXRpb27CoCDCoCDCoCDCoCDCoCDCoCDCoCDCoEZlZTwvc3Ryb25nPjwvcD4KPHA+TXVsdGlwbGUgZW50cnnCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAxNSBkYXlzwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBVUyQgMzAgb3IgZXF1aXZhbGVudCBOZXBhbGVzZSBjdXJyZW5jeTwvcD4KPHA+TXVsdGlwbGUgZW50cnnCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAzMCBkYXlzwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgVVMkIDUwIG9yIGVxdWl2YWxlbnQgTmVwYWxlc2UgY3VycmVuY3k8L3A+CjxwPk11bHRpcGxlIGVudHJ5wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgOTAgZGF5c8KgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIFVTJCAxMjUgb3IgZXF1aXZhbGVudCBOZXBhbGVzZSBjdXJyZW5jeTwvcD4KPHA+WW91IGNhbiBhbHNvIGRvd25sb2FkIHRoZSBWSVNBIGZvcm0gYW5kIGZpbGwgdXAuIFBsZWFzZSBnbyB0aHJvdWdoIHRoZSBsaW5rIGFzIGJlbG93OjwvcD4KPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5vbmxpbmUubmVwYWxpbW1pZ3JhdGlvbi5nb3YubnAvdG91cmlzdC12aXNhIiB0YXJnZXQ9Il9ibGFuayIgcmVsPSJub29wZW5lciI+aHR0cDovL3d3dy5vbmxpbmUubmVwYWxpbW1pZ3JhdGlvbi5nb3YubnAvdG91cmlzdC12aXNhPC9hPjwvcD4KPHA+PHN0cm9uZz5Hcm91cCBTaXplOjwvc3Ryb25nPjxiciAvPgpGb3IgZ3JvdXAsIHdlIG5vcm1hbGx5IHJ1biB3aXRoIG1pbmltdW0gMiBwZXJzb24gdG8gbWF4aW11bSAxMCBpbiBvdXIgcHVibGlzaGVkIGdyb3VwIGRlcGFydHVyZSBwcm9ncmFtLiBIb3dldmVyLCB0aGVyZSBpcyBubyBiYXJyaWVyIGZvciBhIHByaXZhdGUgdHJpcC4gV2UgY2FuIHJ1biBhIHRyaXAgZm9yIGEgc2luZ2xlIHBlcnNvbiBhbmQgZXZlbiBtb3JlIHRoYW4gMTAgaW4gYSBncm91cC4gTm9ybWFsbHkgZm9yIGEgZ3JvdXAsIHdlIHByb3ZpZGUgMSBtYWluIGd1aWRlLCAxIGFzc2lzdGFuY2UgZ3VpZGUgYWxvbmcgd2l0aCAxIHBvcnRlciBmb3IgZXZlcnkgMiB0cmVra2Vycy4gTW9yZW92ZXIsIGZvciBldmVyeSBhZGRpdGlvbmFsIDIgdHJla2tlcnMsIDEgbW9yZSBhc3Npc3RhbmNlIGFuZCBhIHBvcnRlciB3aWxsIGJlIHByb3ZpZGVkIG1ha2luZyBhIHRlYW0gY29tYmluYXRpb24gYXMgZm9sbG93czo8L3A+CjxwPk1pbmltdW0gdG8gMiBQQVg6IDEgR3VpZGUgYW5kIDEgcG9ydGVyPGJyIC8+CjQtNiBQQVg6IDEgZ3VpZGUsIDEgYXNzaXN0YW5jZSBndWlkZSBhbmQgMyBwb3J0ZXI8YnIgLz4KNy0xMCBQQVg6IDEgZ3VpZGUsIDIgYXNzaXN0YW5jZSBndWlkZSBhbmQgNC81IFBvcnRlcjwvcD4KPHA+PHN0cm9uZz5HdWlkZSBhbmQgVHJpcCBTYWZldHk8L3N0cm9uZz48YnIgLz4KT25jZSwgeW91IGNvbmZpcm0geW91ciB0cmlwLCBpdCBpcyBvdXIgcmVzcG9uc2liaWxpdHkgdG8gbWFrZSB5b3VyIHRyaXAgd29uZGVyZnVsIHdpdGhvdXQgY3JlYXRpbmcgYW55IGRpZmZpY3VsdGllcy4gSGVuY2UsIHdlIGhhdmUgcHJlcGFyZWQgb3VyIGl0aW5lcmFyeSBpbiBzdWNoIGEgd2F5IHRoYXQgaXQgd2lsbCBwcm9wZXJseSBhY2NsaW1hdGl6ZSB5b3UuIEFsc28sIHdlIHJlcXVlc3QgeW91IGluIGFkdmFuY2UgdG8gaGF2ZSByZWd1bGFyIGV4ZXJjaXNlcyBhbmQgbWFrZSBoYWJpdHMgdG8gd2FsayBvbiBhIGRhaWx5IGJhc2lzLiBTaW1pbGFybHksIGR1cmluZyB0aGUgdHJlaywgeW91IHdpbGwgYmUgZnVsbHkgZ3VpZGVkIGJ5IG91ciBwcm9mZXNzaW9uYWwgdHJla2tpbmcgZ3VpZGVzIGFuZCBzdXBwb3J0aW5nIHRlYW0uIFRoZXkgYXJlIHByb3Blcmx5IHRyYWluZWQgaW4gcmVnYXJkcyB0byBzYWZldHkgYW5kIGZpcnN0IGFpZC4gRXZlbiwgd2UgaGF2ZSBldmVyeSBzZXQgdXAgaW4gY2FzZSBvZiBhbiBlbWVyZ2VuY3kgc3VjaCBhcyBoaWdoIGFsdGl0dWRlIG1lZGljaW5lIGFuZCBHYW1tb3cgQmFnIChIaWdoIGFsdGl0dWRlIENoYW1iZXIgYmFnKS4gUGxlYXNlIG5vdGUgSGlnaCBhbHRpdHVkZSBDaGFtYmVyIEJhZyBpcyB1c2VkIHRvIHByb3ZpZGUgaGVhdCBpbiB5b3VyIGJvZHkgYW5kIGl0IGlzIGF2YWlsYWJsZSBvbiBjZXJ0YWluIGNvc3QuIE1vcmVvdmVyLCB0byBsZXQgeW91IGZhbWlsaWFyIHdpdGggYWx0aXR1ZGUsIHlvdSBhcmUgc3VnZ2VzdGVkIHRvIHdhbGsgc2xvdyBhbmQgc3RlYWR5IGFuZCBlbnN1cmUgZm9yIHByb3BlciBhY2NsaW1hdGl6YXRpb24uPC9wPgo8cD5Gb3IgdHJla2tpbmcsIHdlIHByb3ZpZGUgbG9jYWwgZXhwZXJpZW5jZWQgZ3VpZGUgc3BlYWtpbmcgZmx1ZW50IEVuZ2xpc2ggYW5kIGZhbWlsaWFyIHdpdGggdGhlIGxvY2FsIHJvdXRlcywgbGFuZHNjYXBlLCBmbG9yYSwgZmF1bmEgYXMgd2VsbCBhcyBjdWx0dXJlLCBhbmQgdHJhZGl0aW9uIG9mIGNlcnRhaW4gYXJlYXMgYW5kIGxldCB5b3UgZmVlbCBjb21mb3J0YWJsZS4gV2UgZG8gbm90IGVuY291cmFnZSBjaGlsZCBsYWJvdXIsIGhlbmNlLCBvdXIgcG9ydGVyIHdpbGwgYmUgYWJvdmUgMTYgeWVhcnMgdGhhdCBhcmUgbGl2aW5nIGluIHRoZSBIaW1hbGF5YXMgb2YgTmVwYWw7IGFzIHdlbGwgYXMgY2FycmllcyBvbmx5IDIwLTIyIGtnIHdlaWdodCBwZXIgcG9ydGVyLiBOb3JtYWxseSwgdGhlIGd1aWRlIGFuZCBzdXBwb3J0IHRlYW1zIGFyZSBzZWxlY3RlZCB3aXRoIHByb3BlciBhbmFseXppbmcgb2YgdGhlaXIgZXhwZXJpZW5jZSwgbGVhZGVyc2hpcCBza2lsbHMsIGFuZCBwZXJzb25hbCBhcHRpdHVkZS4gT3VyIGd1aWRlcyBhcmUgd2VsbCBmYW1pbGlhciB3aXRoIGRpZmZlcmVudCBzb2NpZXRpZXMgb2YgYWxsIGNhc3RlIGFuZCBjdXN0b21zIGFsb25nIHRoZSB0cmFpbCBhbmQgc2hhcmUgdGhlIGluc2lnaHQgY3VsdHVyZSB3aXRoIHlvdSB0aGF0IGlzIG5vdCBldmVuIG5vdGVkIGluIHRoZSBndWlkZWJvb2suIFRvIG1ha2Ugb3VyIHN0YWZmcyBtb3JlIGZsdWVudCBhbmQgZXhwZXJpZW5jZWQsIHdlIGNvbnNpc3RlbnRseSBwcm92aWRlIHRyYWluaW5nLiBUaGV5IGhhdmUgYmVlbiBwYXJ0aWNpcGF0aW5nIGluIHNwZWNpYWwgdHJhaW5pbmcgcHJvZ3JhbXMgbGlrZSBUcmVra2luZyBndWlkZSB0cmFpbmluZywgUm9jayBjbGltYmluZywgSWNlIGNsaW1iaW5nLCBJbnRlbnNpdmUgV2lsZGVybmVzcyBGaXJzdCBBaWQgYW5kIG1hbnkgbW9yZSB0aGF0IGhhdmUgYmVlbiBjZXJ0aWZpZWQgYW5kIGFwcHJvdmVkIGJ5IE5lcGFsIEdvdmVybm1lbnQuPC9wPgo8cD48c3Ryb25nPkhlYWx0aCBhbmQgRml0bmVzczwvc3Ryb25nPjwvcD4KPHA+V2hpbGUgVHJla2tpbmcgaW4gdGhlIEhpbWFsYXlhcyBvZiBOZXBhbCwgeW91IHdpbGwgYmUgaGlraW5nIHVwIGluIGhpZ2ggYWx0aXR1ZGUsIGhlbmNlIHNsb3cgYW5kIHN0ZWFkeSBpcyB0aGUgbWFpbiBjb25jZXJuIHdoaWNoIGhlbHBzIHlvdSB0byBhY2NsaW1hdGl6ZSBwcm9wZXJseSB3aXRoIHRoZSBhbHRpdHVkZS4gRHVyaW5nIHRyZWtraW5nLCB5b3Ugd2lsbCByZXF1aXJlIHRvIHdhbGsgZm9yIDUtNiBob3VycyBvbiBhdmVyYWdlLiBJZiB5b3UgYXJlIHBsYW5uaW5nIHRvIHRyZWsgaW4gTmVwYWwsIG1ha2Ugc3VyZSB0aGF0IHlvdSBhcmUgaW4gZ29vZCBzaGFwZSBhbmQgZml0bmVzcywgYW5kIGNvbnN1bHQgeW91ciBkb2N0b3Igb3IgZ2VuZXJhbCBwaHlzaWNpYW5zIGFib3V0IHlvdXIgaGVhbHRoLiBZb3Ugc2hvdWxkIGJlIHBoeXNpY2FsbHkgYW5kIG1lbnRhbGx5IHByZXBhcmVkLiBCZWZvcmUgY29tbWVuY2luZyBhIHRyZWssIHdlIHJlY29tbWVuZCB5b3UgdG8gZG8gc29tZSByZWd1bGFyIGV4ZXJjaXNlcywgbWFrZSBoYWJpdHMgdG8gdXNlIHN0YWlycyB0aGFuIHRoZSBlbGV2YXRvciB0aGF0IG1ha2VzIHlvdXIga25lZXMgc3Ryb25nLCBhbmQsIGlmIHBvc3NpYmxlLCBqb2luIHNvbWUgYWVyb2JpY3MsIGd5bXMgYW5kIG1ha2Ugc3VyZSBhYm91dCB5b3VyIGdvb2QgaGVhbHRoLiBJZiB5b3UgYXJlIHVzZWQgdG8gd2l0aCB0aGVzZSBoYWJpdHMsIHlvdSB3aWxsIGRlZmluaXRlbHkgd2FsayBpbiB0aGUgSGltYWxheWFzIG9mIE5lcGFsLiBTaW5jZXJlIHByZXBhcmF0aW9uIGFuZCBzdHJvbmcgZGV0ZXJtaW5hdGlvbiBmb3IgdGhlIHRyaXAgYXJlIHZlcnkgaW1wb3J0YW50IGZvciBtYWtpbmcgeW91ciB0cmlwIGEgd29uZGVyZnVsIG1lbW9yeSBvZiB5b3VyIGxpZmUuIEl0IGlzIG5vdCBjb21wdWxzb3J5IHRvIGhhdmUgYW55IHByZXZpb3VzIGV4cGVyaWVuY2UuIEZvbGxvdyB0aGUgZ3VpZGFuY2UgYW5kIGVuam95IHRoZSB0cmlwLjwvcD4KPHA+PHN0cm9uZz5IaWdoIEFsdGl0dWRlIFNpY2tuZXNzPC9zdHJvbmc+PC9wPgo8cD5BdCBhIGhpZ2hlciBhbHRpdHVkZSwgeW91IHdpbGwgZmVlbCBhIGRlY3JlYXNlIGluIHRoZSBhdmFpbGFiaWxpdHkgb2Ygb3h5Z2VuIGFuZCBzaG9ydGVuIGluIG94eWdlbiBjYXVzZSBhbHRpdHVkZSBzaWNrbmVzcy4gSWYgYSBwZXJzb24gd2Fsa3MgaW4gdGhlIGhpZ2ggYWx0aXR1ZGUgcGFydGljdWxhcmx5IGNsaW1icyB1cCB0b28gcXVpY2tseSwgaGUgbWlnaHQgc3VmZmVyIGZyb20gSGlnaCBhbHRpdHVkZSBzaWNrbmVzcy4gSGVuY2UsIHByb3BlciByZXN0IGlzIHJlcXVpcmVkIGF0IHRoYXQgYWx0aXR1ZGUuIFlvdSBjYW4gY3VyZSBhdCB0aGUgcmlnaHQgdGltZSBrbm93aW5nIGNlcnRhaW4gc3ltcHRvbXMgb2YgQWx0aXR1ZGUgU2lja25lc3MuIENvbW1vbiBzeW1wdG9tcyBhcmUgYSBoZWFkYWNoZSwgbG9zcyBvZiBhcHBldGl0ZSwgdGlyZWRuZXNzIGFuZCBuYXVzZWEsIHZvbWl0aW5nLCBkaXp6aW5lc3MgYW5kIGRpZmZpY3VsdHkgaW4gc2xlZXBpbmcuIFRoZSBiZXN0IHJlbWVkaWVzIHRoYXQgbG9jYWwgYmVsaWVmIGFuZCB0YWtlIGlzIHRha2luZyBnYXJsaWMsIG9yIGdpbmdlciBpbiB0aGUgbW91dGguIEVhdCBkcnkgZm9vZCBhbmQgdGFrZSBsaXF1aWQgYXMgbXVjaCBhcyBwb3NzaWJsZS4gV2UgcmVjb21tZW5kIERpYW1veCBpZiB0aGVyZSBhcmUgbm90IGFueSBvcHRpb25zLiDCoEFsc28sIHdlIHByb3ZpZGUgYW4gZXhwZXJpZW5jZWQgZ3VpZGUgYW5kIHN0YWZmcyBpbiBkZWFsaW5nIHdpdGggdGhlIGVmZmVjdHMgb2YgaGlnaGVyIGFsdGl0dWRlcy4gQXMgdGhleSBhcmUgbmF0aXZlcyBvZiBOZXBhbCwgdGhleSBlYXNpbHkgYWNjbGltYXRpemUgYW5kIHRoZXJlZm9yZSBjYW4gY2FyZSBmb3IgdGhlaXIgY2xpZW50cy4gVGhleSBhcmUgZXF1aXBwZWQgd2l0aCBuZWNlc3NhcnkgbWVkaWNhbCBzdXBwbGllcyBhbmQgd2lsbCBhc3Npc3Qgd2l0aCBiYXNpYyBmaXJzdCBhaWQgdHJlYXRtZW50LiBXZSBkZXNpZ24gb3VyIHRvdXJzIHRvIGVuc3VyZSBjbGllbnRzIGFyZSByZWFkeSBmb3IgaGlnaCBhbHRpdHVkZSBhbmQgYXJyYW5nZSBhbHRlcm5hdGl2ZSBpdGluZXJhcmllcyBmb3IgdGhvc2UgYXQgcmlzay48L3A+CjxwPjxzdHJvbmc+QWNjbGltYXRpemF0aW9uPC9zdHJvbmc+PC9wPgo8cD5XaGlsZSwgdHJla2tpbmcgaW4gdGhlIEhpbWFsYXlhcywgeW91IHdpbGwgd2FsayBpbiB0aGUgVXBzIGRvd24gdHJhaWwgdGFraW5nIHlvdSB0byB0aGUgZWxldmF0aW9uIG92ZXIgMjUwMCBtLiBIZW5jZSwgeW91IG1pZ2h0IGZlZWwgZGlmZmljdWx0IHRvIGJyZWF0aGUgb3IgeW91ciBicmVhdGhpbmcgc3BlZWQgdXAuIEhlbmNlLCBpdCBpcyBtb3N0IGltcG9ydGFudCB0byBmYW1pbGlhcml6ZSB3aXRoIHRoZSBhbHRpdHVkZSBhbmQgbGV0IHlvdSBhZGp1c3Qgd2l0aCB0aGUgZGVjcmVhc2VkIGF2YWlsYWJpbGl0eSBvZiBveHlnZW4gYXQgaGlnaCBhbHRpdHVkZS4gT3VyIGl0aW5lcmFyeSBpcyBkZXNpZ25lZCB3aXRoIHN1ZmZpY2llbnQgZGF5cyB0byBhY2NsaW1hdGl6ZS4gSW4gY2FzZSBvZiBnYWluaW5nIGEgY2VydGFpbiBoZWlnaHQsIHRoZXJlIGlzIGEgcmVzdCBkYXkgd2hlbiB5b3UgY2FuIGV4cGxvcmUgdGhlIGFyZWEgYXMgd2VsbCBhcyB3YWxrIHRvIGhpZ2ggYWx0aXR1ZGUgYW5kIHNsZWVwIG9uIGxvdyBsYW5kLiBMaWtld2lzZSwgeW91IGFyZSBzdWdnZXN0ZWQgdG8gd2FsayBzbG93bHkgYW5kIGNhcmVmdWxseSB3aXRob3V0IGdldHRpbmcgYW55IHN0cmVzc2VzLiBBbHNvLCBmb3IgcHJvcGVyIGFjY2xpbWF0aXphdGlvbiwgeW91IHNob3VsZCBjYXJlIGFib3V0IHlvdXIgZWF0aW5nIGhhYml0cy4gRG9u4oCZdCBmb2N1cyBvbiBKdW5rIGZvb2QgYW5kIGVhdCBhcyBtdWNoIGxpcXVpZCBhcyBwb3NzaWJsZS4gSGFyZCBkcmlua3MgYXJlIG5vdCByZWNvbW1lbmRlZC4gVGhlIHJpZ2h0IHdheSB0byBhY2NsaW1hdGl6ZSBwcm9wZXJseSBpcyB0byB3YWxrIGhpZ2gsIHNsZWVwIGxvdy48L3A+CjxwPjxzdHJvbmc+RGlhbW94IChBY2V0YXpvbGFtaWRlKTwvc3Ryb25nPjwvcD4KPHA+RGlhbW94LCBtb3N0bHkgcmVjb2duaXplZCBkcnVncyBmb3IgYWx0aXR1ZGUgc2lja25lc3MgcHJldmVudGlvbiBhbmQgdHJlYXRtZW50LiBJdCBhbGxvd3MgeW91IHRvIGJyZWF0aGUgZmFzdGVyIHNvIHRoYXQgeW91IG1ldGFib2xpemUgbW9yZSBveHlnZW4sIHRoZXJlYnkgbWluaW1pemluZyB0aGUgc3ltcHRvbXMgY2F1c2VkIGJ5IHBvb3Igb3h5Z2VuYXRpb24uIFRoaXMgaXMgZXNwZWNpYWxseSBoZWxwZnVsIGF0IG5pZ2h0IHdoZW4gcmVzcGlyYXRvcnkgZHJpdmUgaXMgZGVjcmVhc2VkLiBXaGlsZSB1c2luZyBhIERpYW1veCwgaXQgaXMgYWR2aXNhYmxlIHRvIHN0YXJ0IHRha2luZyBpdCAyNCBob3VycyBiZWZvcmUgeW91IGdvIHRvIGFsdGl0dWRlIGFuZCBjb250aW51ZSBmb3IgYXQgbGVhc3QgZml2ZSBkYXlzIGF0IGhpZ2hlciBhbHRpdHVkZS4gVGhlIHJlY29tbWVuZGF0aW9uIG9mIHRoZSBIaW1hbGF5YW4gUmVzY3VlIEFzc29jaWF0aW9uIE1lZGljYWwgQ2xpbmljIGlzIDEyNSBtZy4gdHdpY2UgYSBkYXkgKG1vcm5pbmcgYW5kIG5pZ2h0KS4gKFRoZSBzdGFuZGFyZCBkb3NlIHdhcyAyNTAgbWcuIGJ1dCB0aGVpciByZXNlYXJjaCBzaG93ZWQgbm8gZGlmZmVyZW5jZSBmb3IgbW9zdCBwZW9wbGUgd2l0aCB0aGUgbG93ZXIgZG9zZSwgYWx0aG91Z2ggc29tZSBpbmRpdmlkdWFscyBtYXkgbmVlZCAyNTAgbWcuKSBQb3NzaWJsZSBzaWRlIGVmZmVjdHMgaW5jbHVkZSB0aW5nbGluZyBvZiB0aGUgbGlwcyBhbmQgZmluZ2VydGlwcywgYmx1cnJpbmcgb2YgdmlzaW9uLCBhbmQgYWx0ZXJhdGlvbiBvZiB0YXN0ZS4gVGhlc2Ugc2lkZSBlZmZlY3RzIG1heSBiZSByZWR1Y2VkIHdpdGggdGhlIDEyNSBtZy4gZG9zZS4gU2lkZSBlZmZlY3RzIHN1YnNpZGUgd2hlbiB0aGUgZHJ1ZyBpcyBzdG9wcGVkLiBJdCBpcyBtb3JlIGFwcHJvcHJpYXRlIHRvIGNvbnRhY3QgeW91ciBwaHlzaWNpYW4gZm9yIGEgcHJlc2NyaXB0aW9uLiBTaW5jZSBEaWFtb3ggaXMgYSBzdWxmb25hbWlkZSBkcnVnLCBwZW9wbGUgd2hvIGFyZSBhbGxlcmdpYyB0byBzdWxmYSBkcnVncyBzaG91bGQgbm90IHRha2UgRGlhbW94LiBEaWFtb3ggaGFzIGFsc28gYmVlbiBrbm93biB0byBjYXVzZSBzZXZlcmUgYWxsZXJnaWMgcmVhY3Rpb25zIHRvIHBlb3BsZSB3aXRoIG5vIHByZXZpb3VzIGhpc3Rvcnkgb2YgRGlhbW94IG9yIHN1bGZhIGFsbGVyZ2llcy4gRnJhbmsgSHViYmVsbCBvZiBTT0xPIHJlY29tbWVuZHMgYSB0cmlhbCBjb3Vyc2Ugb2YgdGhlIGRydWcgYmVmb3JlIGdvaW5nIHRvIGEgcmVtb3RlIGxvY2F0aW9uIHdoZXJlIGEgc2V2ZXJlIGFsbGVyZ2ljIHJlYWN0aW9uIGNvdWxkIHByb3ZlIGRpZmZpY3VsdCB0byB0cmVhdC48L3A+CjxwPkhpZ2hseSByZWNvbW1lbmRlZCB0byB0YWtlIGEgdHJpYWwgY291cnNlIGJlZm9yZSBnb2luZyB0byBhIHJlbW90ZSBsb2NhdGlvbiB3aGVyZSBhIHNldmVyZSBhbGxlcmdpYyByZWFjdGlvbiBjb3VsZCBwcm92ZSBkaWZmaWN1bHQgdG8gdHJlYXQgaWYgaXQgb2NjdXJyZWQuPC9wPgo8cD48c3Ryb25nPkFsdGVybmF0aXZlIERydWdzOjwvc3Ryb25nPjwvcD4KPHA+RGV4YW1ldGhhc29uZSAoYSBzdGVyb2lkKSBpcyBhbHNvIGEgcHJlc2NyaWJlZCBkcnVnIHRoYXQgZGVjcmVhc2VzIGJyYWluIGFuZCBvdGhlciBzd2VsbGluZyByZXZlcnNpbmcgdGhlIGVmZmVjdHMgb2YgQU1TLiBUaGUgZG9zZSBpcyB0eXBpY2FsbHkgNCBtZyB0d2ljZSBhIGRheSBmb3IgYSBmZXcgZGF5cyBzdGFydGluZyB3aXRoIHRoZSBhc2NlbnQuIFRoaXMgcHJldmVudHMgbW9zdCBvZiB0aGUgc3ltcHRvbXMgb2YgYWx0aXR1ZGUgaWxsbmVzcyBmcm9tIGRldmVsb3BpbmcuPC9wPgo8cD48c3Ryb25nPkFEVklDRTo8L3N0cm9uZz48L3A+CjxwPkRleGFtZXRoYXNvbmUgaXMgYSBwb3dlcmZ1bCBkcnVnIGFuZCBzaG91bGQgYmUgdXNlZCB3aXRoIGNhdXRpb24gYW5kIG9ubHkgb24gdGhlIGFkdmljZSBvZiBhIHBoeXNpY2lhbiBhbmQgc2hvdWxkIG9ubHkgYmUgdXNlZCB0byBhaWQgYWNjbGltYXRpemF0aW9uIGJ5IHN1ZmZpY2llbnRseSBxdWFsaWZpZWQgcGVyc29ucyBvciB0aG9zZSB3aXRoIHRoZSBuZWNlc3NhcnkgZXhwZXJpZW5jZSBvZiBpdHMgdXNlLjwvcD4KPHA+PHN0cm9uZz5OT1RFOjwvc3Ryb25nPjwvcD4KPHA+SXQgaXMgbW9yZSBhZHZpc2FibGUgdG8gdGFrZSBkcnVncyB0YWtpbmcgcHJvcGVyIHN1Z2dlc3Rpb25zIGZyb20gUGVyc29uYWwgUGh5c2ljaWFucyBhbmQgaW4gY2FzZSBpZiB0aGVyZSBhcmUgbm8gYW55IG9wdGlvbnMuIEluIHRoZSBIaW1hbGF5YXMgb2YgTmVwYWwsIHRoZSBtb3VudGFpbiBkd2VsbGVycyBiZWxpZXZlIGluIHRha2luZyBzb21lIGdhcmxpYyBvciBnaW5nZXIgYWxvbmcgd2l0aCBSZWQgUGVwcGVyIHRvIHByb2R1Y2UgaGVhdCBmb3IgZmFzdCBicmVhdGhpbmcuPC9wPgoJCQk8L2Rpdj4KCQk8L2Rpdj4KCQkKCQk8ZGl2IGNsYXNzPSJzaGFyZS1idXR0b25zIiBkYXRhLXVybHNoYXJlPSJodHRwczovL2hpbWFsdG91cmlzbS5jb20vdG91cnMvZXZlcmVzdC1iYXNlLWNhbXAtdHJlay12aWEtc2FsbGVyaS8iIGRhdGEtaW1hZ2VzaGFyZT0iIj48ZGl2IGNsYXNzPSJzaGFyZS1idXR0b25zX19pdGVtIHNoYXJlLWJ1dHRvbnNfX2l0ZW0tLWZhY2Vib29rIiBkYXRhLWJ0bnR5cGU9ImZhY2Vib29rIj48L2Rpdj48ZGl2IGNsYXNzPSJzaGFyZS1idXR0b25zX19pdGVtIHNoYXJlLWJ1dHRvbnNfX2l0ZW0tLXR3aXR0ZXIiIGRhdGEtYnRudHlwZT0idHdpdHRlciI+PC9kaXY+PGRpdiBjbGFzcz0ic2hhcmUtYnV0dG9uc19faXRlbSBzaGFyZS1idXR0b25zX19pdGVtLS1saW5rZWRpbiIgZGF0YS1idG50eXBlPSJsaW5rZWRpbiI+PC9kaXY+PGRpdiBjbGFzcz0ic2hhcmUtYnV0dG9uc19faXRlbSBzaGFyZS1idXR0b25zX19pdGVtLS1waW50ZXJlc3QiIGRhdGEtYnRudHlwZT0icGludGVyZXN0Ij48L2Rpdj48L2Rpdj4JPC9kaXY+PCEtLSAudGFiLWNvbnRlbnQgLS0+CgoJPGRpdiBjbGFzcz0ic2hhcmUtYnV0dG9ucy1tb2JpbGUtd3JhcHBlciBzZWN0aW9uLXdoaXRlLWJveCBtYXJnaW4tdG9wIHZpc2libGUteHMiPjxkaXYgY2xhc3M9InNoYXJlLWJ1dHRvbnMiIGRhdGEtdXJsc2hhcmU9Imh0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS90b3Vycy9ldmVyZXN0LWJhc2UtY2FtcC10cmVrLXZpYS1zYWxsZXJpLyIgZGF0YS1pbWFnZXNoYXJlPSIiPjxkaXYgY2xhc3M9InNoYXJlLWJ1dHRvbnNfX2l0ZW0gc2hhcmUtYnV0dG9uc19faXRlbS0tZmFjZWJvb2siIGRhdGEtYnRudHlwZT0iZmFjZWJvb2siPjwvZGl2PjxkaXYgY2xhc3M9InNoYXJlLWJ1dHRvbnNfX2l0ZW0gc2hhcmUtYnV0dG9uc19faXRlbS0tdHdpdHRlciIgZGF0YS1idG50eXBlPSJ0d2l0dGVyIj48L2Rpdj48ZGl2IGNsYXNzPSJzaGFyZS1idXR0b25zX19pdGVtIHNoYXJlLWJ1dHRvbnNfX2l0ZW0tLWxpbmtlZGluIiBkYXRhLWJ0bnR5cGU9ImxpbmtlZGluIj48L2Rpdj48ZGl2IGNsYXNzPSJzaGFyZS1idXR0b25zX19pdGVtIHNoYXJlLWJ1dHRvbnNfX2l0ZW0tLXBpbnRlcmVzdCIgZGF0YS1idG50eXBlPSJwaW50ZXJlc3QiPjwvZGl2PjwvZGl2PjwvZGl2PjwvZGl2PjwhLS0gLnRvdXItdGFicyAtLT4KPGRpdiBpZD0iZml4ZWRUb3VyQm9va2luZ0J0bkJveCIgY2xhc3M9InRvdXItZml4ZWQtYm9va2luZy1idG4tYm94Ij48YSBocmVmPSIjdG91ckJvb2tpbmciIGNsYXNzPSJ0b3VyLWZpeGVkLWJvb2tpbmctYnRuLWJveF9fYnRuIGF0YnRuIGF0YnRuLS1zZWNvbmRhcnkiPkJvb2sgbm93PC9hPjwvZGl2PjxtZXRhIGl0ZW1wcm9wPSJuYW1lIiBjb250ZW50PSJFdmVyZXN0IEJhc2UgQ2FtcCBUcmVrIHZpYSBTYWxsZXJpIj48bWV0YSBpdGVtcHJvcD0iZGVzY3JpcHRpb24iIGNvbnRlbnQ9IkFsdGVybmF0aXZlIG9mIEx1a2xhIEZsaWdodCBleHBlcmllbmNpbmcgdGhlIGNvdW50cnlzaWRlIGxpZmVzdHlsZSBhbmQgbGFuZHNjYXBlIEplZXAgZHJpdmUgdG8gRXZlcmVzdCBpcyBhIHVuaXF1ZSB0cmlwIGRlc2lnbmVkIHdpdGggYW4gaW50ZW50aW9uIHRvIGV4cGxvcmUgdGhlIGNvdW50cnlzaWRlIGxpZmUgdGFraW5nIHlvdSB0byB0aGUgYmFzZSBvZiBoaWdoZXN0IFBlYWstIHRoZSBNdC4gRXZlcmVzdC4gTm8gZG91YnRzLCB5b3Ugd2lsbCBleHBlcmllbmNlIHRoZSByaWNoIGN1bHR1cmUsIHZpbGxhZ2UgbGlmZSBhbG9uZyB3aXRoIHRoZSBiZWF1dGlmdWwgbGFuZHNjYXBlIGFuZCB0aGUgSGltYWxheWFzLiBUcmVrIGJlZ2lucyB3aXRoIGEgaGlnaHdheSBkcml2ZcKgdG8gU2FsbGVyaS7CoFlvdSB3aWxsIGhlYWQgdG93YXJkIHRoZSBPZmYgQmVhdGVuIFRyYWlsIHRha2luZyB5b3UgdG8gdGhlIFNhbGxlcmkgZm9yIEV2ZXJlc3QgVHJlay4gT24gdGhlIHdheSwgeW91IHdpbGwgc2VlIHRoZSBiZWF1dGlmdWwgZmFybWxhbmQsIHRoZSB3ZWxjb21pbmcgYW5kIGhvc3BpdGFibGUgdmlsbGFnZXJzLiBZb3Ugd2lsbCBzdG9wIGF0IFNhbGxlcmkgZnJvbSB3aGVyZSB5b3Ugd2lsbCBjb21tZW5jZSBhIHRyZWsgdG8gU29sdSByZWdpb24uIEl0IHdpbGwgYmUgYSBzbW9vdGggYW5kIHJlbGF4aW5nIHdhbGsgYWxvbmcgdGhlIER1ZGggS29zaGkgUml2ZXIgYWZ0ZXIgY3Jvc3NpbmcgVHJha3NoaW5kbyBMYS4gT24gdGhlIHdheSwgeW91IGNhbiB2aWV3IHNvbWUgb2YgdGhlIG1vdW50YWlucyBpbmNsdWRpbmcgVGhhbXNlcmt1LCBLd2FuZ2RlLCBOdXB0c2UsIExob3RzZSwgQW1hIERhYmxhbSBhcyB3ZWxsIGFzIE10LiBFdmVyZXN0LiBUaGUgY29sb3JmdWwgZmxhZ3MgZmxhdHRlcmluZyBhbGwgdGhlIHdheSB0byB0aGUgRXZlcmVzdCBhbG9uZyB3aXRoIHRoZSBzYWNyZWQgbWFuaS13YWxscywgY2hvcnRlaW5zLCBtb25hc3RlcmllcyBhbmQgd2VsY29taW5nIFNoZXJwYXMgd2lsbCBkZW1vbnN0cmF0ZSB0aGUgSGltYWxheWFuIGN1bHR1cmUgYW5kIHRyYWRpdGlvbi4gSW4gYWRkaXRpb24sIGlmIHlvdSB3aXNoIHRvIGV4cGxvcmUgRXZlcmVzdCByZWdpb24gaW4gbGltaXRlZCB0aW1lIGVuam95aW5nIGl0cyBuYXR1cmFsIGJlYXV0aWVzLCBlbmhhbmNlIGN1bHR1cmFsIGV4cGVyaWVuY2VzLCB0aGVuIHlvdSBjb3VsZCBqb2luIG91csKgRXZlcmVzdCBCYXNlIENhbXAgVHJlay0xNiBEYXlzLiBZb3UgY291bGQgYWxzbyBqb2luIG91ciBjaGFsbGVuZ2luZyB0cmVra2luZyByb3V0ZSB0b8KgRXZlcmVzdCBSZWdpb27CoGJ5IGpvaW5pbmcgb3VywqBFdmVyZXN0IDMgUGFzc2VzIFRyZWtraW5nLTE5IERheXPCoG9yIG1vcmUgc2NlbmljIHJvdXRlIHRvwqBHb2t5byBWYWxsZXkgJmFtcDsgRXZlcmVzdCBCYXNlIGNhbXAgVHJlay0xOCBEYXlzLiBJZiB5b3Ugd2FudCB0byBhZGQgZGF5L3MgY2xpbWJpbmcgZXhwZXJpZW5jZSB3aGlsZSB0cmVra2luZyBpbiBFdmVyZXN0IEJhc2UgQ2FtcCwgeW91IG1heSBqb2luIG91csKgSXNsYW5kIFBlYWsuIElmIHlvdSBhcmUgbm90IHNhdGlzZmllZCB3aXRoIHRoaXMgaXRpbmVyYXJ5IG9yIGlmIHlvdSB3YW50IHRvIGN1c3RvbWl6ZSB0aGlzIHBhY2thZ2UgaW4geW91ciB0aW1lbGluZSBvciBidWRnZXQsIHRoZW4geW91IGNvdWxkIGNvbnRhY3QgdXMsIG9yIGVtYWlsLiI+PG1ldGEgaXRlbXByb3A9InVybCIgY29udGVudD0iaHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL3RvdXJzL2V2ZXJlc3QtYmFzZS1jYW1wLXRyZWstdmlhLXNhbGxlcmkvIj4KPHNwYW4gaXRlbXByb3A9Im9mZmVycyIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvT2ZmZXIiPgoJPG1ldGEgaXRlbXByb3A9InByaWNlIiBjb250ZW50PSIxOTU1Ij4KCTxtZXRhIGl0ZW1wcm9wPSJwcmljZUN1cnJlbmN5IiBjb250ZW50PSJVU0QiPgoJPG1ldGEgaXRlbXByb3A9InByaWNlVmFsaWRVbnRpbCIgY29udGVudD0iMjAyNi0xMi0zMSI+Cgk8bWV0YSBpdGVtcHJvcD0idXJsIiBjb250ZW50PSJodHRwczovL2hpbWFsdG91cmlzbS5jb20vdG91cnMvZXZlcmVzdC1iYXNlLWNhbXAtdHJlay12aWEtc2FsbGVyaS8iPgoJPGxpbmsgaXRlbXByb3A9ImF2YWlsYWJpbGl0eSIgaHJlZj0iaHR0cHM6Ly9zY2hlbWEub3JnL0luU3RvY2siPgo8L3NwYW4+CjxzcGFuIGl0ZW1wcm9wPSJhZ2dyZWdhdGVSYXRpbmciIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL0FnZ3JlZ2F0ZVJhdGluZyI+Cgk8bWV0YSBpdGVtcHJvcD0icmF0aW5nVmFsdWUiIGNvbnRlbnQ9IjMuNjgiPgoJPG1ldGEgaXRlbXByb3A9InJldmlld0NvdW50IiBjb250ZW50PSIyMiI+Cjwvc3Bhbj4KPGRpdiBpZD0iY29tbWVudHMiIGNsYXNzPSJ0b3VyLXJldmlld3MgbWFyZ2luLXRvcCI+Cgk8ZGl2IGNsYXNzPSJzZWN0aW9uLXRpdGxlIHRpdGxlIHRpdGxlLS1zbWFsbCB0aXRsZS0tY2VudGVyIHRpdGxlLS1kZWNvcmF0aW9uLWJvdHRvbS1jZW50ZXIgdGl0bGUtLXVuZGVybGluZSI+CgkJPGgzIGNsYXNzPSJ0aXRsZV9fcHJpbWFyeSI+VG91ciBSZXZpZXdzPC9oMz4KCTwvZGl2PgoJPGRpdiBjbGFzcz0ibWFyZ2luLWxlZnQgbWFyZ2luLXJpZ2h0IHBhZGRpbmctdG9wIHBhZGRpbmctYm90dG9tIHRvdXItcmV2aWV3c19fcmF0aW5nLXRvdGFsIj48ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX3JhdGluZy10b3RhbF9fc3RhcnMiPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PC9kaXY+PGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19yYXRpbmctdG90YWxfX3RleHQiPjMuNjggYmFzZWQgb24gMjIgcmV2aWV3czwvZGl2PjwvZGl2Pgk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1zIj4KCQkJCjxkaXYgaWQ9ImNvbW1lbnQtNTEiIGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW0gbWFyZ2luLWxlZnQgbWFyZ2luLXJpZ2h0IHBhZGRpbmctdG9wIHBhZGRpbmctYm90dG9tIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9SZXZpZXciPgoJPHNwYW4gaXRlbXByb3A9Iml0ZW1SZXZpZXdlZCIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUHJvZHVjdCI+CgkJPG1ldGEgaXRlbXByb3A9Im5hbWUiIGNvbnRlbnQ9IkV2ZXJlc3QgQmFzZSBDYW1wIFRyZWsgdmlhIFNhbGxlcmkiPgo8c3BhbiBpdGVtcHJvcD0iYWdncmVnYXRlUmF0aW5nIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9BZ2dyZWdhdGVSYXRpbmciPgoJPG1ldGEgaXRlbXByb3A9InJhdGluZ1ZhbHVlIiBjb250ZW50PSIzLjY4Ij4KCTxtZXRhIGl0ZW1wcm9wPSJyZXZpZXdDb3VudCIgY29udGVudD0iMjIiPgo8L3NwYW4+CTwvc3Bhbj4KCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fY29udGFpbmVyIj4KCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2luZm8iPgoJCQk8aW1nIGFsdD0nJyBzcmM9J2h0dHBzOi8vc2VjdXJlLmdyYXZhdGFyLmNvbS9hdmF0YXIvZjQ4MDQ1NTU1Y2NlNzQ2MmYwYWYyNjY0NGRhZGI5ZmI/cz0xMjImIzAzODtkPW1tJiMwMzg7cj1nJyBzcmNzZXQ9J2h0dHBzOi8vc2VjdXJlLmdyYXZhdGFyLmNvbS9hdmF0YXIvZjQ4MDQ1NTU1Y2NlNzQ2MmYwYWYyNjY0NGRhZGI5ZmI/cz0yNDQmIzAzODtkPW1tJiMwMzg7cj1nIDJ4JyBjbGFzcz0nYXZhdGFyIGF2YXRhci0xMjIgcGhvdG8nIGhlaWdodD0nMTIyJyB3aWR0aD0nMTIyJyBsb2FkaW5nPSdsYXp5JyBkZWNvZGluZz0nYXN5bmMnLz4JCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX25hbWUiIGl0ZW1wcm9wPSJhdXRob3IiIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1BlcnNvbiI+PHNwYW4gaXRlbXByb3A9Im5hbWUiPkRlbm55IE08L3NwYW4+PC9kaXY+CgkJPC9kaXY+CgkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19jb250ZW50Ij4KCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19jb250ZW50X190b3AiPgoJCQkJCQkJCQkJCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19yYXRpbmciPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48L2Rpdj4JCQkJCTxzcGFuIGl0ZW1wcm9wPSJyZXZpZXdSYXRpbmciIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1JhdGluZyI+CgkJCQkJCTxtZXRhIGl0ZW1wcm9wPSJyYXRpbmdWYWx1ZSIgY29udGVudD0iNSI+CgkJCQkJPC9zcGFuPgoJCQkJCQkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fZGF0ZSI+RGVjZW1iZXIgMiwgMjAyMjwvZGl2PgoJCQk8L2Rpdj4KCQkJCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX190ZXh0IiBpdGVtcHJvcD0icmV2aWV3Qm9keSI+PHA+V2Ugd2VyZSBvbiB0aGlzIHRyZWsgdmlhIHNhbGxlcmkuIFdlIGVuam95ZWQgb3VyIHRyaXAgdG8gZXhwbG9yZSBTaGVycGEg4oCYcyBjdWx0dXJlIGFuZCBsb2NhbCBtb25hc3RlcnkgbG93ZXIga2h1bWJ1IGFyZWFzIGluY2x1ZGUgRXZlcmVzdCBCYXNlIENhbXAuSGlnaGx5IHJlY29tbWVuZC48L3A+CjwvZGl2PgoJCQkJCTwvZGl2PgoJPC9kaXY+CjwvZGl2PjwhLS0gI2NvbW1lbnQtIyMgLS0+Cgo8ZGl2IGlkPSJjb21tZW50LTY2IiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtIG1hcmdpbi1sZWZ0IG1hcmdpbi1yaWdodCBwYWRkaW5nLXRvcCBwYWRkaW5nLWJvdHRvbSIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUmV2aWV3Ij4KCTxzcGFuIGl0ZW1wcm9wPSJpdGVtUmV2aWV3ZWQiIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1Byb2R1Y3QiPgoJCTxtZXRhIGl0ZW1wcm9wPSJuYW1lIiBjb250ZW50PSJFdmVyZXN0IEJhc2UgQ2FtcCBUcmVrIHZpYSBTYWxsZXJpIj4KPHNwYW4gaXRlbXByb3A9ImFnZ3JlZ2F0ZVJhdGluZyIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvQWdncmVnYXRlUmF0aW5nIj4KCTxtZXRhIGl0ZW1wcm9wPSJyYXRpbmdWYWx1ZSIgY29udGVudD0iMy42OCI+Cgk8bWV0YSBpdGVtcHJvcD0icmV2aWV3Q291bnQiIGNvbnRlbnQ9IjIyIj4KPC9zcGFuPgk8L3NwYW4+Cgk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRhaW5lciI+CgkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19pbmZvIj4KCQkJPGltZyBhbHQ9Jycgc3JjPSdodHRwczovL3NlY3VyZS5ncmF2YXRhci5jb20vYXZhdGFyL2U2ODMzMGU1MGE2ZTAxZDUzOTA5YjQzNjIzMmZhYmRkP3M9MTIyJiMwMzg7ZD1tbSYjMDM4O3I9Zycgc3Jjc2V0PSdodHRwczovL3NlY3VyZS5ncmF2YXRhci5jb20vYXZhdGFyL2U2ODMzMGU1MGE2ZTAxZDUzOTA5YjQzNjIzMmZhYmRkP3M9MjQ0JiMwMzg7ZD1tbSYjMDM4O3I9ZyAyeCcgY2xhc3M9J2F2YXRhciBhdmF0YXItMTIyIHBob3RvJyBoZWlnaHQ9JzEyMicgd2lkdGg9JzEyMicgbG9hZGluZz0nbGF6eScgZGVjb2Rpbmc9J2FzeW5jJy8+CQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19uYW1lIiBpdGVtcHJvcD0iYXV0aG9yIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9QZXJzb24iPjxzcGFuIGl0ZW1wcm9wPSJuYW1lIj5IYXJpc2ggTmFyYXlhbjwvc3Bhbj48L2Rpdj4KCQk8L2Rpdj4KCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRlbnQiPgoJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRlbnRfX3RvcCI+CgkJCQkJCQkJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX3JhdGluZyI+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjwvZGl2PgkJCQkJPHNwYW4gaXRlbXByb3A9InJldmlld1JhdGluZyIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUmF0aW5nIj4KCQkJCQkJPG1ldGEgaXRlbXByb3A9InJhdGluZ1ZhbHVlIiBjb250ZW50PSI1Ij4KCQkJCQk8L3NwYW4+CgkJCQkJCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19kYXRlIj5EZWNlbWJlciAxNSwgMjAyMjwvZGl2PgoJCQk8L2Rpdj4KCQkJCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX190ZXh0IiBpdGVtcHJvcD0icmV2aWV3Qm9keSI+PHA+V2UgcmVhbGx5IGhhZCBhIGdyZWF0IHRpbWUgZHVyaW5nIHRoaXMgdHJla2tpbmcuVGhhbmkgeW91IHNvIG11Y2ggZm9yIGFycmFuZ2VkIGJ5IEhpbWFsIFRvdXJpc20uPC9wPgo8L2Rpdj4KCQkJCQk8L2Rpdj4KCTwvZGl2Pgo8L2Rpdj48IS0tICNjb21tZW50LSMjIC0tPgoKPGRpdiBpZD0iY29tbWVudC0zMzk0IiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtIG1hcmdpbi1sZWZ0IG1hcmdpbi1yaWdodCBwYWRkaW5nLXRvcCBwYWRkaW5nLWJvdHRvbSIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUmV2aWV3Ij4KCTxzcGFuIGl0ZW1wcm9wPSJpdGVtUmV2aWV3ZWQiIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1Byb2R1Y3QiPgoJCTxtZXRhIGl0ZW1wcm9wPSJuYW1lIiBjb250ZW50PSJFdmVyZXN0IEJhc2UgQ2FtcCBUcmVrIHZpYSBTYWxsZXJpIj4KPHNwYW4gaXRlbXByb3A9ImFnZ3JlZ2F0ZVJhdGluZyIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvQWdncmVnYXRlUmF0aW5nIj4KCTxtZXRhIGl0ZW1wcm9wPSJyYXRpbmdWYWx1ZSIgY29udGVudD0iMy42OCI+Cgk8bWV0YSBpdGVtcHJvcD0icmV2aWV3Q291bnQiIGNvbnRlbnQ9IjIyIj4KPC9zcGFuPgk8L3NwYW4+Cgk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRhaW5lciI+CgkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19pbmZvIj4KCQkJPGltZyBhbHQ9Jycgc3JjPSdodHRwczovL3NlY3VyZS5ncmF2YXRhci5jb20vYXZhdGFyLzNmMTZiODE2ODY2ZDlhZmU1YzZjZWY2ZmViNGJmMWU4P3M9MTIyJiMwMzg7ZD1tbSYjMDM4O3I9Zycgc3Jjc2V0PSdodHRwczovL3NlY3VyZS5ncmF2YXRhci5jb20vYXZhdGFyLzNmMTZiODE2ODY2ZDlhZmU1YzZjZWY2ZmViNGJmMWU4P3M9MjQ0JiMwMzg7ZD1tbSYjMDM4O3I9ZyAyeCcgY2xhc3M9J2F2YXRhciBhdmF0YXItMTIyIHBob3RvJyBoZWlnaHQ9JzEyMicgd2lkdGg9JzEyMicgbG9hZGluZz0nbGF6eScgZGVjb2Rpbmc9J2FzeW5jJy8+CQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19uYW1lIiBpdGVtcHJvcD0iYXV0aG9yIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9QZXJzb24iPjxzcGFuIGl0ZW1wcm9wPSJuYW1lIj5KdWxpZWE8L3NwYW4+PC9kaXY+CgkJPC9kaXY+CgkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19jb250ZW50Ij4KCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19jb250ZW50X190b3AiPgoJCQkJCQkJCQkJCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19yYXRpbmciPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48L2Rpdj4JCQkJCTxzcGFuIGl0ZW1wcm9wPSJyZXZpZXdSYXRpbmciIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1JhdGluZyI+CgkJCQkJCTxtZXRhIGl0ZW1wcm9wPSJyYXRpbmdWYWx1ZSIgY29udGVudD0iNSI+CgkJCQkJPC9zcGFuPgoJCQkJCQkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fZGF0ZSI+RGVjZW1iZXIgMTcsIDIwMjI8L2Rpdj4KCQkJPC9kaXY+CgkJCQkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fdGV4dCIgaXRlbXByb3A9InJldmlld0JvZHkiPjxwPkkgcmVjZW50bHkgY29tcGxldGVkIHRoZSB1bmZvcmdldHRhYmxlIHRyZWsgZnJvbSBTYWxsZXJpIHRvIEV2ZXJlc3QgQmFzZSBDYW1wLCBhbmQgSSB3YW50IHRvIGV4dGVuZCBteSBkZWVwZXN0IGdyYXRpdHVkZSB0byBIaW1hbCBUb3VyaXNtIGZvciBtYWtpbmcgdGhpcyBhZHZlbnR1cmUgdHJ1bHkgZXhjZXB0aW9uYWwuPC9wPgo8cD5UaGUgam91cm5leSBiZWdhbiBpbiBTYWxsZXJpLCBvZmZlcmluZyBhIHVuaXF1ZSBhbmQgbGVzcyBjcm93ZGVkIHJvdXRlIHRvIEVCQy4gVGhpcyBwYXRoIGFsbG93ZWQgbWUgdG8gZXhwZXJpZW5jZSB0aGUgc3R1bm5pbmcgbGFuZHNjYXBlcyBhbmQgdmlicmFudCBsb2NhbCBjdWx0dXJlIGluIGEgd2F5IHRoYXQgdGhlIG1vcmUgY29tbW9uIHJvdXRlcyBtaWdodCBub3Qgb2ZmZXIuIFRoZSBlbnRpcmUgdHJlayB3YXMgaW1wZWNjYWJseSBvcmdhbml6ZWQgYnkgSGltYWwgVG91cmlzbSwgZW5zdXJpbmcgdGhhdCBldmVyeSBkZXRhaWwgd2FzIHRha2VuIGNhcmUgb2YuPC9wPgo8cD5Gcm9tIHRoZSBpbml0aWFsIHBsYW5uaW5nIHN0YWdlcywgdGhlIHRlYW0gYXQgSGltYWwgVG91cmlzbSB3YXMgaW5jcmVkaWJseSBzdXBwb3J0aXZlLiBUaGV5IHByb3ZpZGVkIGNvbXByZWhlbnNpdmUgaW5mb3JtYXRpb24gYWJvdXQgdGhlIHRyZWssIGhlbHBpbmcgbWUgcHJlcGFyZSBib3RoIG1lbnRhbGx5IGFuZCBwaHlzaWNhbGx5LiBUaGVpciBjb21tdW5pY2F0aW9uIHdhcyBwcm9tcHQgYW5kIGNsZWFyLCBlYXNpbmcgYW55IGNvbmNlcm5zIEkgaGFkIGJlZm9yZSBzZXR0aW5nIG91dC48L3A+CjxwPlNwZWNpYWwgdGhhbmtzIHRvIFtHdWlkZeKAmXMgTmFtZV0sIG91ciBrbm93bGVkZ2VhYmxlIGFuZCBmcmllbmRseSBndWlkZS4gSGlzIGV4cGVydGlzZSBhbmQgZW50aHVzaWFzbSB3ZXJlIGV2aWRlbnQgdGhyb3VnaG91dCB0aGUgdHJlaywgZW5oYW5jaW5nIHRoZSBlbnRpcmUgZXhwZXJpZW5jZS4gV2hldGhlciBpdCB3YXMgbmF2aWdhdGluZyBjaGFsbGVuZ2luZyB0ZXJyYWlucyBvciBzaGFyaW5nIHN0b3JpZXMgYWJvdXQgdGhlIHJlZ2lvbiwgW0d1aWRl4oCZcyBOYW1lXSBtYWRlIGV2ZXJ5IG1vbWVudCBtZW1vcmFibGUuPC9wPgo8cD5UaGUgYWNjb21tb2RhdGlvbnMgYW5kIG1lYWxzIGFycmFuZ2VkIGJ5IEhpbWFsIFRvdXJpc20gd2VyZSBleGNlbGxlbnQsIHByb3ZpZGluZyBjb21mb3J0IGFuZCBtdWNoLW5lZWRlZCByZXN0IGFmdGVyIGxvbmcgZGF5cyBvZiB0cmVra2luZy4gVGhlIHN1cHBvcnQgdGVhbSwgaW5jbHVkaW5nIHBvcnRlcnMsIHdhcyBlcXVhbGx5IGNvbW1lbmRhYmxlLjwvcD4KPC9kaXY+CgkJCQkJPC9kaXY+Cgk8L2Rpdj4KPC9kaXY+PCEtLSAjY29tbWVudC0jIyAtLT4KCjxkaXYgaWQ9ImNvbW1lbnQtMzM5MyIgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbSBtYXJnaW4tbGVmdCBtYXJnaW4tcmlnaHQgcGFkZGluZy10b3AgcGFkZGluZy1ib3R0b20iIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1JldmlldyI+Cgk8c3BhbiBpdGVtcHJvcD0iaXRlbVJldmlld2VkIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9Qcm9kdWN0Ij4KCQk8bWV0YSBpdGVtcHJvcD0ibmFtZSIgY29udGVudD0iRXZlcmVzdCBCYXNlIENhbXAgVHJlayB2aWEgU2FsbGVyaSI+CjxzcGFuIGl0ZW1wcm9wPSJhZ2dyZWdhdGVSYXRpbmciIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL0FnZ3JlZ2F0ZVJhdGluZyI+Cgk8bWV0YSBpdGVtcHJvcD0icmF0aW5nVmFsdWUiIGNvbnRlbnQ9IjMuNjgiPgoJPG1ldGEgaXRlbXByb3A9InJldmlld0NvdW50IiBjb250ZW50PSIyMiI+Cjwvc3Bhbj4JPC9zcGFuPgoJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19jb250YWluZXIiPgoJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9faW5mbyI+CgkJCTxpbWcgYWx0PScnIHNyYz0naHR0cHM6Ly9zZWN1cmUuZ3JhdmF0YXIuY29tL2F2YXRhci8zZjE2YjgxNjg2NmQ5YWZlNWM2Y2VmNmZlYjRiZjFlOD9zPTEyMiYjMDM4O2Q9bW0mIzAzODtyPWcnIHNyY3NldD0naHR0cHM6Ly9zZWN1cmUuZ3JhdmF0YXIuY29tL2F2YXRhci8zZjE2YjgxNjg2NmQ5YWZlNWM2Y2VmNmZlYjRiZjFlOD9zPTI0NCYjMDM4O2Q9bW0mIzAzODtyPWcgMngnIGNsYXNzPSdhdmF0YXIgYXZhdGFyLTEyMiBwaG90bycgaGVpZ2h0PScxMjInIHdpZHRoPScxMjInIGxvYWRpbmc9J2xhenknIGRlY29kaW5nPSdhc3luYycvPgkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fbmFtZSIgaXRlbXByb3A9ImF1dGhvciIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUGVyc29uIj48c3BhbiBpdGVtcHJvcD0ibmFtZSI+SnVsaWVhPC9zcGFuPjwvZGl2PgoJCTwvZGl2PgoJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fY29udGVudCI+CgkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fY29udGVudF9fdG9wIj4KCQkJCQkJCQkJCQkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fcmF0aW5nIj48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PC9kaXY+CQkJCQk8c3BhbiBpdGVtcHJvcD0icmV2aWV3UmF0aW5nIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9SYXRpbmciPgoJCQkJCQk8bWV0YSBpdGVtcHJvcD0icmF0aW5nVmFsdWUiIGNvbnRlbnQ9IjUiPgoJCQkJCTwvc3Bhbj4KCQkJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2RhdGUiPkphbnVhcnkgMTcsIDIwMjM8L2Rpdj4KCQkJPC9kaXY+CgkJCQkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fdGV4dCIgaXRlbXByb3A9InJldmlld0JvZHkiPjxwPkkgcmVjZW50bHkgY29tcGxldGVkIHRoZSB1bmZvcmdldHRhYmxlIHRyZWsgZnJvbSBTYWxsZXJpIHRvIEV2ZXJlc3QgQmFzZSBDYW1wLCBhbmQgSSB3YW50IHRvIGV4dGVuZCBteSBkZWVwZXN0IGdyYXRpdHVkZSB0byBIaW1hbCBUb3VyaXNtIGZvciBtYWtpbmcgdGhpcyBhZHZlbnR1cmUgdHJ1bHkgZXhjZXB0aW9uYWwuPC9wPgo8cD5UaGUgam91cm5leSBiZWdhbiBpbiBTYWxsZXJpLCBvZmZlcmluZyBhIHVuaXF1ZSBhbmQgbGVzcyBjcm93ZGVkIHJvdXRlIHRvIEVCQy4gVGhpcyBwYXRoIGFsbG93ZWQgbWUgdG8gZXhwZXJpZW5jZSB0aGUgc3R1bm5pbmcgbGFuZHNjYXBlcyBhbmQgdmlicmFudCBsb2NhbCBjdWx0dXJlIGluIGEgd2F5IHRoYXQgdGhlIG1vcmUgY29tbW9uIHJvdXRlcyBtaWdodCBub3Qgb2ZmZXIuIFRoZSBlbnRpcmUgdHJlayB3YXMgaW1wZWNjYWJseSBvcmdhbml6ZWQgYnkgSGltYWwgVG91cmlzbSwgZW5zdXJpbmcgdGhhdCBldmVyeSBkZXRhaWwgd2FzIHRha2VuIGNhcmUgb2YuPC9wPgo8cD5Gcm9tIHRoZSBpbml0aWFsIHBsYW5uaW5nIHN0YWdlcywgdGhlIHRlYW0gYXQgSGltYWwgVG91cmlzbSB3YXMgaW5jcmVkaWJseSBzdXBwb3J0aXZlLiBUaGV5IHByb3ZpZGVkIGNvbXByZWhlbnNpdmUgaW5mb3JtYXRpb24gYWJvdXQgdGhlIHRyZWssIGhlbHBpbmcgbWUgcHJlcGFyZSBib3RoIG1lbnRhbGx5IGFuZCBwaHlzaWNhbGx5LiBUaGVpciBjb21tdW5pY2F0aW9uIHdhcyBwcm9tcHQgYW5kIGNsZWFyLCBlYXNpbmcgYW55IGNvbmNlcm5zIEkgaGFkIGJlZm9yZSBzZXR0aW5nIG91dC48L3A+CjxwPlNwZWNpYWwgdGhhbmtzIHRvIFtHdWlkZeKAmXMgTmFtZV0sIG91ciBrbm93bGVkZ2VhYmxlIGFuZCBmcmllbmRseSBndWlkZS4gSGlzIGV4cGVydGlzZSBhbmQgZW50aHVzaWFzbSB3ZXJlIGV2aWRlbnQgdGhyb3VnaG91dCB0aGUgdHJlaywgZW5oYW5jaW5nIHRoZSBlbnRpcmUgZXhwZXJpZW5jZS4gV2hldGhlciBpdCB3YXMgbmF2aWdhdGluZyBjaGFsbGVuZ2luZyB0ZXJyYWlucyBvciBzaGFyaW5nIHN0b3JpZXMgYWJvdXQgdGhlIHJlZ2lvbiwgW0d1aWRl4oCZcyBOYW1lXSBtYWRlIGV2ZXJ5IG1vbWVudCBtZW1vcmFibGUuPC9wPgo8cD5UaGUgYWNjb21tb2RhdGlvbnMgYW5kIG1lYWxzIGFycmFuZ2VkIGJ5IEhpbWFsIFRvdXJpc20gd2VyZSBleGNlbGxlbnQsIHByb3ZpZGluZyBjb21mb3J0IGFuZCBtdWNoLW5lZWRlZCByZXN0IGFmdGVyIGxvbmcgZGF5cyBvZiB0cmVra2luZy4gVGhlIHN1cHBvcnQgdGVhbSwgaW5jbHVkaW5nIHBvcnRlcnMsIHdhcyBlcXVhbGx5IGNvbW1lbmRhYmxlLCBhbHdheXMgZW5zdXJpbmcgb3VyIHNhZmV0eSBhbmQgY29tZm9ydC48L3A+CjxwPlJlYWNoaW5nIEV2ZXJlc3QgQmFzZSBDYW1wIHdhcyBhIGRyZWFtIGNvbWUgdHJ1ZS48L3A+CjwvZGl2PgoJCQkJCTwvZGl2PgoJPC9kaXY+CjwvZGl2PjwhLS0gI2NvbW1lbnQtIyMgLS0+Cgo8ZGl2IGlkPSJjb21tZW50LTMxNzUiIGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW0gbWFyZ2luLWxlZnQgbWFyZ2luLXJpZ2h0IHBhZGRpbmctdG9wIHBhZGRpbmctYm90dG9tIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9SZXZpZXciPgoJPHNwYW4gaXRlbXByb3A9Iml0ZW1SZXZpZXdlZCIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUHJvZHVjdCI+CgkJPG1ldGEgaXRlbXByb3A9Im5hbWUiIGNvbnRlbnQ9IkV2ZXJlc3QgQmFzZSBDYW1wIFRyZWsgdmlhIFNhbGxlcmkiPgo8c3BhbiBpdGVtcHJvcD0iYWdncmVnYXRlUmF0aW5nIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9BZ2dyZWdhdGVSYXRpbmciPgoJPG1ldGEgaXRlbXByb3A9InJhdGluZ1ZhbHVlIiBjb250ZW50PSIzLjY4Ij4KCTxtZXRhIGl0ZW1wcm9wPSJyZXZpZXdDb3VudCIgY29udGVudD0iMjIiPgo8L3NwYW4+CTwvc3Bhbj4KCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fY29udGFpbmVyIj4KCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2luZm8iPgoJCQk8aW1nIGFsdD0nJyBzcmM9J2h0dHBzOi8vc2VjdXJlLmdyYXZhdGFyLmNvbS9hdmF0YXIvMDUyMDFjNGE3YzM4YTVlNzlhOGIzYWJjYjJiYmNlZWQ/cz0xMjImIzAzODtkPW1tJiMwMzg7cj1nJyBzcmNzZXQ9J2h0dHBzOi8vc2VjdXJlLmdyYXZhdGFyLmNvbS9hdmF0YXIvMDUyMDFjNGE3YzM4YTVlNzlhOGIzYWJjYjJiYmNlZWQ/cz0yNDQmIzAzODtkPW1tJiMwMzg7cj1nIDJ4JyBjbGFzcz0nYXZhdGFyIGF2YXRhci0xMjIgcGhvdG8nIGhlaWdodD0nMTIyJyB3aWR0aD0nMTIyJyBsb2FkaW5nPSdsYXp5JyBkZWNvZGluZz0nYXN5bmMnLz4JCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX25hbWUiIGl0ZW1wcm9wPSJhdXRob3IiIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1BlcnNvbiI+PHNwYW4gaXRlbXByb3A9Im5hbWUiPk5lZXRhIEFtbTwvc3Bhbj48L2Rpdj4KCQk8L2Rpdj4KCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRlbnQiPgoJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRlbnRfX3RvcCI+CgkJCQkJCQkJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX3JhdGluZyI+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjwvZGl2PgkJCQkJPHNwYW4gaXRlbXByb3A9InJldmlld1JhdGluZyIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUmF0aW5nIj4KCQkJCQkJPG1ldGEgaXRlbXByb3A9InJhdGluZ1ZhbHVlIiBjb250ZW50PSI1Ij4KCQkJCQk8L3NwYW4+CgkJCQkJCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19kYXRlIj5KdWx5IDI5LCAyMDIzPC9kaXY+CgkJCTwvZGl2PgoJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX3RleHQiIGl0ZW1wcm9wPSJyZXZpZXdCb2R5Ij48cD5TYWxsZXJpIHRvIEV2ZXJlc3QgQmFzZSBDYW1wIChFQkMpIGlzIGFuIGFsdGVybmF0aXZlIHRyZWtraW5nIHJvdXRlIHRvIEx1a2xhIGZvciByZWFjaGluZyBFQkMuIFRoaXMgcm91dGUgb2ZmZXJzIGEgbW9yZSBncmFkdWFsIGFzY2VudCwgYWxsb3dpbmcgZm9yIGJldHRlciBhY2NsaW1hdGl6YXRpb24gYW5kIGEgY2hhbmNlIHRvIGV4cGVyaWVuY2UgdGhlIHF1aWV0ZXIgc2lkZSBvZiB0aGUgRXZlcmVzdCByZWdpb24uIEl0IHR5cGljYWxseSB0YWtlcyBhcm91bmQgMTQtMTYgZGF5cyB0byBjb21wbGV0ZSwgZGVwZW5kaW5nIG9uIHlvdXIgcGFjZSBhbmQgaXRpbmVyYXJ5LiBBbG9uZyB0aGUgd2F5LCB5b3UmIzgyMTc7bGwgcGFzcyB0aHJvdWdoIGNoYXJtaW5nIFNoZXJwYSB2aWxsYWdlcywgbHVzaCBmb3Jlc3RzLCBhbmQgc3R1bm5pbmcgbW91bnRhaW4gbGFuZHNjYXBlcy4gT3ZlcmFsbCwgaXQmIzgyMTc7cyBhIHJld2FyZGluZyB0cmVrIHdpdGggZmV3ZXIgY3Jvd2RzIGFuZCBhIGNoYW5jZSB0byBleHBsb3JlIHRoZSBiZWF1dHkgb2YgdGhlIEhpbWFsYXlhcyBhdCBhIHNsb3dlciBwYWNlLiBLcmlzaCBzZWVtcyB0byBoYXZlIHJlY29tbWVuZGVkIGEgZ3JlYXQgdHJla2tpbmcgcm91dGUhPC9wPgo8L2Rpdj4KCQkJCQk8L2Rpdj4KCTwvZGl2Pgo8L2Rpdj48IS0tICNjb21tZW50LSMjIC0tPgoKPGRpdiBpZD0iY29tbWVudC0zMjI0IiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtIG1hcmdpbi1sZWZ0IG1hcmdpbi1yaWdodCBwYWRkaW5nLXRvcCBwYWRkaW5nLWJvdHRvbSIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUmV2aWV3Ij4KCTxzcGFuIGl0ZW1wcm9wPSJpdGVtUmV2aWV3ZWQiIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1Byb2R1Y3QiPgoJCTxtZXRhIGl0ZW1wcm9wPSJuYW1lIiBjb250ZW50PSJFdmVyZXN0IEJhc2UgQ2FtcCBUcmVrIHZpYSBTYWxsZXJpIj4KPHNwYW4gaXRlbXByb3A9ImFnZ3JlZ2F0ZVJhdGluZyIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvQWdncmVnYXRlUmF0aW5nIj4KCTxtZXRhIGl0ZW1wcm9wPSJyYXRpbmdWYWx1ZSIgY29udGVudD0iMy42OCI+Cgk8bWV0YSBpdGVtcHJvcD0icmV2aWV3Q291bnQiIGNvbnRlbnQ9IjIyIj4KPC9zcGFuPgk8L3NwYW4+Cgk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRhaW5lciI+CgkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19pbmZvIj4KCQkJPGltZyBhbHQ9Jycgc3JjPSdodHRwczovL3NlY3VyZS5ncmF2YXRhci5jb20vYXZhdGFyLzYwNjljZTRhZThjZWNmODNiNjlhOGU4MmI5OWIyNzc1P3M9MTIyJiMwMzg7ZD1tbSYjMDM4O3I9Zycgc3Jjc2V0PSdodHRwczovL3NlY3VyZS5ncmF2YXRhci5jb20vYXZhdGFyLzYwNjljZTRhZThjZWNmODNiNjlhOGU4MmI5OWIyNzc1P3M9MjQ0JiMwMzg7ZD1tbSYjMDM4O3I9ZyAyeCcgY2xhc3M9J2F2YXRhciBhdmF0YXItMTIyIHBob3RvJyBoZWlnaHQ9JzEyMicgd2lkdGg9JzEyMicgbG9hZGluZz0nbGF6eScgZGVjb2Rpbmc9J2FzeW5jJy8+CQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19uYW1lIiBpdGVtcHJvcD0iYXV0aG9yIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9QZXJzb24iPjxzcGFuIGl0ZW1wcm9wPSJuYW1lIj5BbnRvbmlhPC9zcGFuPjwvZGl2PgoJCTwvZGl2PgoJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fY29udGVudCI+CgkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fY29udGVudF9fdG9wIj4KCQkJCQkJCQkJCQkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fcmF0aW5nIj48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PC9kaXY+CQkJCQk8c3BhbiBpdGVtcHJvcD0icmV2aWV3UmF0aW5nIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9SYXRpbmciPgoJCQkJCQk8bWV0YSBpdGVtcHJvcD0icmF0aW5nVmFsdWUiIGNvbnRlbnQ9IjUiPgoJCQkJCTwvc3Bhbj4KCQkJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2RhdGUiPk9jdG9iZXIgMSwgMjAyMzwvZGl2PgoJCQk8L2Rpdj4KCQkJCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX190ZXh0IiBpdGVtcHJvcD0icmV2aWV3Qm9keSI+PHA+VGhlIEFubmFwdXJuYSBCYXNlIENhbXAgdHJlayBpcyBhIG1lc21lcml6aW5nIGpvdXJuZXkgdGhyb3VnaCBkaXZlcnNlIGxhbmRzY2FwZXMsIGZyb20gbHVzaCBmb3Jlc3RzIHRvIGhpZ2ggYWxwaW5lIHRlcnJhaW4sIGN1bG1pbmF0aW5nIGluIHVucGFyYWxsZWxlZCB2aWV3cyBvZiB0aGUgQW5uYXB1cm5hIG1hc3NpZi4gVHJhdmVsZXJzIG9mdGVuIHByYWlzZSB0aGUgb3JnYW5pemVycyBmb3IgdGhlaXIgYXR0ZW50aW9uIHRvIGRldGFpbCwgaW5jbHVkaW5nIHdlbGwtcGxhbm5lZCBpdGluZXJhcmllcywgZXhwZXJpZW5jZWQgZ3VpZGVzLCBhbmQgY29tZm9ydGFibGUgYWNjb21tb2RhdGlvbnMgYWxvbmcgdGhlIHdheS4gVGhlIGpvdXJuZXkgaXMgbm90IGp1c3QgYWJvdXQgcmVhY2hpbmcgdGhlIGRlc3RpbmF0aW9uIGJ1dCBhbHNvIGFib3V0IHRoZSBwZW9wbGUgeW91IG1lZXQsIHRoZSBjdWx0dXJhbCBleHBlcmllbmNlcyB5b3UgZW5jb3VudGVyLCBhbmQgdGhlIG1lbW9yaWVzIHlvdSBjcmVhdGUgYWxvbmcgdGhlIHdheS4gTWFueSB0cmVra2VycyBjb25zaWRlciB0aGUgQW5uYXB1cm5hIEJhc2UgQ2FtcCB0cmVrIHRvIGJlIGEgdHJhbnNmb3JtYXRpdmUgZXhwZXJpZW5jZSwgbGVhdmluZyB0aGVtIHdpdGggYSBwcm9mb3VuZCBhcHByZWNpYXRpb24gZm9yIHRoZSBiZWF1dHkgYW5kIG1hamVzdHkgb2YgdGhlIEhpbWFsYXlhcy48L3A+CjwvZGl2PgoJCQkJCTwvZGl2PgoJPC9kaXY+CjwvZGl2PjwhLS0gI2NvbW1lbnQtIyMgLS0+Cgo8ZGl2IGlkPSJjb21tZW50LTMxMTYiIGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW0gbWFyZ2luLWxlZnQgbWFyZ2luLXJpZ2h0IHBhZGRpbmctdG9wIHBhZGRpbmctYm90dG9tIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9SZXZpZXciPgoJPHNwYW4gaXRlbXByb3A9Iml0ZW1SZXZpZXdlZCIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUHJvZHVjdCI+CgkJPG1ldGEgaXRlbXByb3A9Im5hbWUiIGNvbnRlbnQ9IkV2ZXJlc3QgQmFzZSBDYW1wIFRyZWsgdmlhIFNhbGxlcmkiPgo8c3BhbiBpdGVtcHJvcD0iYWdncmVnYXRlUmF0aW5nIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9BZ2dyZWdhdGVSYXRpbmciPgoJPG1ldGEgaXRlbXByb3A9InJhdGluZ1ZhbHVlIiBjb250ZW50PSIzLjY4Ij4KCTxtZXRhIGl0ZW1wcm9wPSJyZXZpZXdDb3VudCIgY29udGVudD0iMjIiPgo8L3NwYW4+CTwvc3Bhbj4KCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fY29udGFpbmVyIj4KCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2luZm8iPgoJCQk8aW1nIGFsdD0nJyBzcmM9J2h0dHBzOi8vc2VjdXJlLmdyYXZhdGFyLmNvbS9hdmF0YXIvMTc2MmUxMzBiYWRiMmM2NTkzZWNiNzBkOWYxYjRmNmI/cz0xMjImIzAzODtkPW1tJiMwMzg7cj1nJyBzcmNzZXQ9J2h0dHBzOi8vc2VjdXJlLmdyYXZhdGFyLmNvbS9hdmF0YXIvMTc2MmUxMzBiYWRiMmM2NTkzZWNiNzBkOWYxYjRmNmI/cz0yNDQmIzAzODtkPW1tJiMwMzg7cj1nIDJ4JyBjbGFzcz0nYXZhdGFyIGF2YXRhci0xMjIgcGhvdG8nIGhlaWdodD0nMTIyJyB3aWR0aD0nMTIyJyBsb2FkaW5nPSdsYXp5JyBkZWNvZGluZz0nYXN5bmMnLz4JCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX25hbWUiIGl0ZW1wcm9wPSJhdXRob3IiIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1BlcnNvbiI+PHNwYW4gaXRlbXByb3A9Im5hbWUiPkpob25zb24gVDwvc3Bhbj48L2Rpdj4KCQk8L2Rpdj4KCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRlbnQiPgoJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRlbnRfX3RvcCI+CgkJCQkJCQkJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX3JhdGluZyI+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjwvZGl2PgkJCQkJPHNwYW4gaXRlbXByb3A9InJldmlld1JhdGluZyIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUmF0aW5nIj4KCQkJCQkJPG1ldGEgaXRlbXByb3A9InJhdGluZ1ZhbHVlIiBjb250ZW50PSI1Ij4KCQkJCQk8L3NwYW4+CgkJCQkJCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19kYXRlIj5BcHJpbCAyNiwgMjAyNDwvZGl2PgoJCQk8L2Rpdj4KCQkJCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX190ZXh0IiBpdGVtcHJvcD0icmV2aWV3Qm9keSI+PHA+VGhlIEV2ZXJlc3QgdHJlayB2aWEgU2FsbGVyaSB3YXMgYW4gb2ZmLXRoZS1iZWF0ZW4tcGF0aCBhZHZlbnR1cmUgdGhhdCBhbGxvd2VkIGZvciBhIG1vcmUgZ3JhZHVhbCBhc2NlbnQgYW5kIGEgZGVlcGVyIGltbWVyc2lvbiBpbnRvIGxvY2FsIFNoZXJwYSBjdWx0dXJlLiBUaGUgbG9uZ2VyIHJvdXRlIGZyb20gU2FsbGVyaSBvZmZlcmVkIGEgdW5pcXVlIHBlcnNwZWN0aXZlLCBwYXNzaW5nIHRocm91Z2ggY2hhcm1pbmcgdmlsbGFnZXMgYW5kIGx1c2ggbGFuZHNjYXBlcyBiZWZvcmUgam9pbmluZyB0aGUgbWFpbiBFdmVyZXN0IHRyYWlsLiBXaGlsZSBpdCBhZGRlZCBhIGZldyBleHRyYSBkYXlzIHRvIHRoZSBqb3VybmV5LCB0aGUgc2xvd2VyIHBhY2UgYWxsb3dlZCBmb3IgYmV0dGVyIGFjY2xpbWF0aXphdGlvbiBhbmQgYSByaWNoZXIgY3VsdHVyYWwgZXhwZXJpZW5jZS4gVGhlIGJyZWF0aHRha2luZyB2aWV3cyBvZiB0aGUgSGltYWxheWFzIGFuZCB0aGUgd2FybSBob3NwaXRhbGl0eSBvZiB0aGUgU2hlcnBhIHBlb3BsZSBtYWRlIGV2ZXJ5IHN0ZXAgd29ydGh3aGlsZS4gQSBmYW50YXN0aWMgYWx0ZXJuYXRpdmUgZm9yIHRob3NlIHNlZWtpbmcgYSBtb3JlIGF1dGhlbnRpYyBhbmQgbGVzcyBjcm93ZGVkIEV2ZXJlc3QgdHJla2tpbmcgZXhwZXJpZW5jZS48L3A+CjwvZGl2PgoJCQkJCTwvZGl2PgoJPC9kaXY+CjwvZGl2PjwhLS0gI2NvbW1lbnQtIyMgLS0+Cgo8ZGl2IGlkPSJjb21tZW50LTMyMTkiIGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW0gbWFyZ2luLWxlZnQgbWFyZ2luLXJpZ2h0IHBhZGRpbmctdG9wIHBhZGRpbmctYm90dG9tIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9SZXZpZXciPgoJPHNwYW4gaXRlbXByb3A9Iml0ZW1SZXZpZXdlZCIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUHJvZHVjdCI+CgkJPG1ldGEgaXRlbXByb3A9Im5hbWUiIGNvbnRlbnQ9IkV2ZXJlc3QgQmFzZSBDYW1wIFRyZWsgdmlhIFNhbGxlcmkiPgo8c3BhbiBpdGVtcHJvcD0iYWdncmVnYXRlUmF0aW5nIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9BZ2dyZWdhdGVSYXRpbmciPgoJPG1ldGEgaXRlbXByb3A9InJhdGluZ1ZhbHVlIiBjb250ZW50PSIzLjY4Ij4KCTxtZXRhIGl0ZW1wcm9wPSJyZXZpZXdDb3VudCIgY29udGVudD0iMjIiPgo8L3NwYW4+CTwvc3Bhbj4KCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fY29udGFpbmVyIj4KCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2luZm8iPgoJCQk8aW1nIGFsdD0nJyBzcmM9J2h0dHBzOi8vc2VjdXJlLmdyYXZhdGFyLmNvbS9hdmF0YXIvODEwYWU0NGU4MGUzZGFlZjY1MTU5MGRhZGU5MzhmOTg/cz0xMjImIzAzODtkPW1tJiMwMzg7cj1nJyBzcmNzZXQ9J2h0dHBzOi8vc2VjdXJlLmdyYXZhdGFyLmNvbS9hdmF0YXIvODEwYWU0NGU4MGUzZGFlZjY1MTU5MGRhZGU5MzhmOTg/cz0yNDQmIzAzODtkPW1tJiMwMzg7cj1nIDJ4JyBjbGFzcz0nYXZhdGFyIGF2YXRhci0xMjIgcGhvdG8nIGhlaWdodD0nMTIyJyB3aWR0aD0nMTIyJyBsb2FkaW5nPSdsYXp5JyBkZWNvZGluZz0nYXN5bmMnLz4JCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX25hbWUiIGl0ZW1wcm9wPSJhdXRob3IiIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1BlcnNvbiI+PHNwYW4gaXRlbXByb3A9Im5hbWUiPlJvYmVydCB0PC9zcGFuPjwvZGl2PgoJCTwvZGl2PgoJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fY29udGVudCI+CgkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fY29udGVudF9fdG9wIj4KCQkJCQkJCQkJCQkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fcmF0aW5nIj48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PC9kaXY+CQkJCQk8c3BhbiBpdGVtcHJvcD0icmV2aWV3UmF0aW5nIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9SYXRpbmciPgoJCQkJCQk8bWV0YSBpdGVtcHJvcD0icmF0aW5nVmFsdWUiIGNvbnRlbnQ9IjUiPgoJCQkJCTwvc3Bhbj4KCQkJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2RhdGUiPk1heSAxLCAyMDI0PC9kaXY+CgkJCTwvZGl2PgoJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX3RleHQiIGl0ZW1wcm9wPSJyZXZpZXdCb2R5Ij48cD5UaGUgdHJlayBmcm9tIFNhbGxlcmkgdG8gRXZlcmVzdCBCYXNlIENhbXAgb2ZmZXJzIGEgdW5pcXVlIGFuZCBsZXNzLXRyYXZlbGVkIHJvdXRlIHRvIHRoZSBpY29uaWMgZGVzdGluYXRpb24uIFRyZWtrZXJzIG9mdGVuIGFwcHJlY2lhdGUgdGhlIG9wcG9ydHVuaXR5IHRvIGV4cGVyaWVuY2UgdGhlIHJ1Z2dlZCBiZWF1dHkgb2YgdGhlIEV2ZXJlc3QgcmVnaW9uIHdoaWxlIGF2b2lkaW5nIHRoZSBjcm93ZGVkIHRyYWlscyBvZiBMdWtsYS4gVGhlIGpvdXJuZXkgdHlwaWNhbGx5IHRha2VzIGEgYml0IGxvbmdlciBidXQgcmV3YXJkcyBoaWtlcnMgd2l0aCBzdHVubmluZyBsYW5kc2NhcGVzLCBjdWx0dXJhbCBlbmNvdW50ZXJzIGluIFNoZXJwYSB2aWxsYWdlcywgYW5kIGEgZ3JhZHVhbCBhY2NsaW1hdGl6YXRpb24gdG8gdGhlIGFsdGl0dWRlLiBNYW55IHRyYXZlbGVycyBmaW5kIHRoaXMgYWx0ZXJuYXRpdmUgcm91dGUgdG8gRXZlcmVzdCBCYXNlIENhbXAgdG8gYmUgYSBmdWxmaWxsaW5nIGFuZCBtZW1vcmFibGUgYWR2ZW50dXJlLCBvZmZlcmluZyBhIG1vcmUgYXV0aGVudGljIEhpbWFsYXlhbiBleHBlcmllbmNlIGF3YXkgZnJvbSB0aGUgY3Jvd2RzLjwvcD4KPC9kaXY+CgkJCQkJPC9kaXY+Cgk8L2Rpdj4KPC9kaXY+PCEtLSAjY29tbWVudC0jIyAtLT4KCjxkaXYgaWQ9ImNvbW1lbnQtMzI0MiIgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbSBtYXJnaW4tbGVmdCBtYXJnaW4tcmlnaHQgcGFkZGluZy10b3AgcGFkZGluZy1ib3R0b20iIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1JldmlldyI+Cgk8c3BhbiBpdGVtcHJvcD0iaXRlbVJldmlld2VkIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9Qcm9kdWN0Ij4KCQk8bWV0YSBpdGVtcHJvcD0ibmFtZSIgY29udGVudD0iRXZlcmVzdCBCYXNlIENhbXAgVHJlayB2aWEgU2FsbGVyaSI+CjxzcGFuIGl0ZW1wcm9wPSJhZ2dyZWdhdGVSYXRpbmciIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL0FnZ3JlZ2F0ZVJhdGluZyI+Cgk8bWV0YSBpdGVtcHJvcD0icmF0aW5nVmFsdWUiIGNvbnRlbnQ9IjMuNjgiPgoJPG1ldGEgaXRlbXByb3A9InJldmlld0NvdW50IiBjb250ZW50PSIyMiI+Cjwvc3Bhbj4JPC9zcGFuPgoJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19jb250YWluZXIiPgoJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9faW5mbyI+CgkJCTxpbWcgYWx0PScnIHNyYz0naHR0cHM6Ly9zZWN1cmUuZ3JhdmF0YXIuY29tL2F2YXRhci8xODQ5MjU1ODE2YTZiM2VjZTM1MTdiODRmNjQ0NjdmZj9zPTEyMiYjMDM4O2Q9bW0mIzAzODtyPWcnIHNyY3NldD0naHR0cHM6Ly9zZWN1cmUuZ3JhdmF0YXIuY29tL2F2YXRhci8xODQ5MjU1ODE2YTZiM2VjZTM1MTdiODRmNjQ0NjdmZj9zPTI0NCYjMDM4O2Q9bW0mIzAzODtyPWcgMngnIGNsYXNzPSdhdmF0YXIgYXZhdGFyLTEyMiBwaG90bycgaGVpZ2h0PScxMjInIHdpZHRoPScxMjInIGxvYWRpbmc9J2xhenknIGRlY29kaW5nPSdhc3luYycvPgkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fbmFtZSIgaXRlbXByb3A9ImF1dGhvciIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUGVyc29uIj48c3BhbiBpdGVtcHJvcD0ibmFtZSI+U2lkbmV5cGx1cm48L3NwYW4+PC9kaXY+CgkJPC9kaXY+CgkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19jb250ZW50Ij4KCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19jb250ZW50X190b3AiPgoJCQkJCQkJCQkJCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19yYXRpbmciPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PC9kaXY+CQkJCQk8c3BhbiBpdGVtcHJvcD0icmV2aWV3UmF0aW5nIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9SYXRpbmciPgoJCQkJCQk8bWV0YSBpdGVtcHJvcD0icmF0aW5nVmFsdWUiIGNvbnRlbnQ9IjQiPgoJCQkJCTwvc3Bhbj4KCQkJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2RhdGUiPk1heSAyLCAyMDI0PC9kaXY+CgkJCTwvZGl2PgoJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX3RleHQiIGl0ZW1wcm9wPSJyZXZpZXdCb2R5Ij48cD7QmNC30YPRh9C10L3QuNC1INCw0L3Qs9C70LjQudGB0LrQvtCz0L4g0Y/Qt9GL0LrQsCDQv9C+INGB0LXRgNC40LDQu9Cw0LwgJiM4MjExOyDQvtGC0LvQuNGH0L3Ri9C5INGB0L/QvtGB0L7QsSDRg9C70YPRh9GI0LDRgtGMINGP0LfRi9C6LiDQodC10YDQuNCw0LvRiyDQtNC70Y8g0LHQsNC30L7QstC+0LPQviDRg9GA0L7QstC90Y8g0L/QvtC80L7Qs9GD0YIg0L7QstC70LDQtNC10YLRjCDQsdCw0LfQvtCy0YvQtSDRhNGA0LDQt9GLLCDQsCDQtNC70Y8gYWR2YW5jZWQgJiM4MjExOyDRgNCw0YHRiNC40YDQuNGC0Ywg0LvQtdC60YHQuNGH0LXRgdC60LjQuSDQt9Cw0L/QsNGBLiDQodGD0LHRgtC40YLRgNGLINCyINGB0LXRgNC40LDQu9Cw0YUg0L3QsCDQsNC90LPQu9C40LnRgdC60L7QvCDQv9C+0LzQvtCz0YPRgiDQsiDQstC+0YHQv9GA0LjRj9GC0LjQuCDQutC+0L3RgtC10LrRgdGC0LAuINCa0LDQuiDRg9GH0LjRgtGMINC40L3Qs9C70LjRiCDQv9C+INGB0LXRgNC40LDQu9Cw0Lw/INCf0YDQvtGB0YLQviDQv9C+0LPRgNGD0LbQsNC50YLQtdGB0Ywg0LIg0LDQvdCz0LvQuNC50YHQutC40Lkg0Y/Qt9GL0Log0YHQvNC+0YLRgNGPINC4INGB0LvRg9GI0LDRjyDQu9GO0LHQuNC80YvQtSDRgdC10YDQuNCw0LvRiyEg0KHQvNC+0YLRgNC10YLRjCDQuCDQuNC30YPRh9Cw0YLRjCDQsNC90LPQu9C40LnRgdC60LjQuSDRj9C30YvQutCwINC80L7QttC90L4g0LfQtNC10YHRjCBbdXJsPWh0dHBzOi8vc2VyaWFseS1uYS1hbmdsaWpza29tLnBwLnVhL11odHRwczovL3NlcmlhbHktbmEtYW5nbGlqc2tvbS5wcC51YS9bL3VybF08L3A+CjwvZGl2PgoJCQkJCTwvZGl2PgoJPC9kaXY+CjwvZGl2PjwhLS0gI2NvbW1lbnQtIyMgLS0+Cgo8ZGl2IGlkPSJjb21tZW50LTMzOTAiIGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW0gbWFyZ2luLWxlZnQgbWFyZ2luLXJpZ2h0IHBhZGRpbmctdG9wIHBhZGRpbmctYm90dG9tIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9SZXZpZXciPgoJPHNwYW4gaXRlbXByb3A9Iml0ZW1SZXZpZXdlZCIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUHJvZHVjdCI+CgkJPG1ldGEgaXRlbXByb3A9Im5hbWUiIGNvbnRlbnQ9IkV2ZXJlc3QgQmFzZSBDYW1wIFRyZWsgdmlhIFNhbGxlcmkiPgo8c3BhbiBpdGVtcHJvcD0iYWdncmVnYXRlUmF0aW5nIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9BZ2dyZWdhdGVSYXRpbmciPgoJPG1ldGEgaXRlbXByb3A9InJhdGluZ1ZhbHVlIiBjb250ZW50PSIzLjY4Ij4KCTxtZXRhIGl0ZW1wcm9wPSJyZXZpZXdDb3VudCIgY29udGVudD0iMjIiPgo8L3NwYW4+CTwvc3Bhbj4KCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fY29udGFpbmVyIj4KCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2luZm8iPgoJCQk8aW1nIGFsdD0nJyBzcmM9J2h0dHBzOi8vc2VjdXJlLmdyYXZhdGFyLmNvbS9hdmF0YXIvMmQxMDNjYTllYzUzMzZmMzU4NzhiMGEwZjhmOWNmYmI/cz0xMjImIzAzODtkPW1tJiMwMzg7cj1nJyBzcmNzZXQ9J2h0dHBzOi8vc2VjdXJlLmdyYXZhdGFyLmNvbS9hdmF0YXIvMmQxMDNjYTllYzUzMzZmMzU4NzhiMGEwZjhmOWNmYmI/cz0yNDQmIzAzODtkPW1tJiMwMzg7cj1nIDJ4JyBjbGFzcz0nYXZhdGFyIGF2YXRhci0xMjIgcGhvdG8nIGhlaWdodD0nMTIyJyB3aWR0aD0nMTIyJyBsb2FkaW5nPSdsYXp5JyBkZWNvZGluZz0nYXN5bmMnLz4JCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX25hbWUiIGl0ZW1wcm9wPSJhdXRob3IiIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1BlcnNvbiI+PHNwYW4gaXRlbXByb3A9Im5hbWUiPkFsZnJlZG9idW08L3NwYW4+PC9kaXY+CgkJPC9kaXY+CgkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19jb250ZW50Ij4KCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19jb250ZW50X190b3AiPgoJCQkJCQkJCQkJCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19yYXRpbmciPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjwvZGl2PgkJCQkJPHNwYW4gaXRlbXByb3A9InJldmlld1JhdGluZyIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUmF0aW5nIj4KCQkJCQkJPG1ldGEgaXRlbXByb3A9InJhdGluZ1ZhbHVlIiBjb250ZW50PSIzIj4KCQkJCQk8L3NwYW4+CgkJCQkJCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19kYXRlIj5NYXkgMTcsIDIwMjQ8L2Rpdj4KCQkJPC9kaXY+CgkJCQkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fdGV4dCIgaXRlbXByb3A9InJldmlld0JvZHkiPjxwPkhlbGxvISA8L3A+CjxwPkkgcmVjZW50bHkgc3R1bWJsZWQgdXBvbiBhbiBpbnRyaWd1aW5nIHdlYnNpdGUgZGVkaWNhdGVkIHRvIGpvYiBzZWVrZXJzIGFuZCBJIHRob3VnaHQgaXQgY291bGQgYmUgdXNlZnVsIHRvIG1hbnkgb2YgeW91IGhlcmUuIFRoaXMgc2l0ZSBpc24mIzgyMTc7dCB5b3VyIHR5cGljYWwgam9iIGJvYXJkOyBpdCBvZmZlcnMgYSB3ZWFsdGggb2YgcmVzb3VyY2VzIHRoYXQgZ28gYmV5b25kIGp1c3QgYWR2ZXJ0aXNpbmcgcG9zaXRpb25zLiA8L3A+CjxwPjxhIGhyZWY9Imh0dHBzOi8vYW1lcmljYW4tY2FtcC1qb2JzLXN1bW1lci0yMDExLm15am9iLmV4cGVydCIgcmVsPSJub2ZvbGxvdyB1Z2MiPmh0dHBzOi8vYW1lcmljYW4tY2FtcC1qb2JzLXN1bW1lci0yMDExLm15am9iLmV4cGVydDwvYT48YnIgLz4KPGEgaHJlZj0iaHR0cHM6Ly9hbWJ1YXRvcnktc3VyZ2VyeS1jZW50ZXItZGlyZWN0b3Itam9iLWR1aXRpZXMubXlqb2IuZXhwZXJ0IiByZWw9Im5vZm9sbG93IHVnYyI+aHR0cHM6Ly9hbWJ1YXRvcnktc3VyZ2VyeS1jZW50ZXItZGlyZWN0b3Itam9iLWR1aXRpZXMubXlqb2IuZXhwZXJ0PC9hPjxiciAvPgo8YSBocmVmPSJodHRwczovL2FydHMtY291bmNpbC1mb3Itbm9ydGhlcm4taXJlbGFuZC1qb2JzLm15am9iLmV4cGVydCIgcmVsPSJub2ZvbGxvdyB1Z2MiPmh0dHBzOi8vYXJ0cy1jb3VuY2lsLWZvci1ub3J0aGVybi1pcmVsYW5kLWpvYnMubXlqb2IuZXhwZXJ0PC9hPjwvcD4KPHA+V2hhdCBkaWZmZXJlbnRpYXRlcyBpdCBpcyBpdHMgY29tcHJlaGVuc2l2ZSBhcHByb2FjaCB0byB0aGUgam9iIHNlYXJjaCBhbmQgY2FyZWVyIGRldmVsb3BtZW50LiBUaGVyZSBhcmUgZGV0YWlsZWQgZ3VpZGVzIG9uIGNyYWZ0aW5nIGEgcmVzdW1lLCB0aXBzIG9uIGhvdyB0byBleGNlbCBpbiBqb2IgaW50ZXJ2aWV3cywgYW5kIHN0cmF0ZWdpZXMgZm9yIHNhbGFyeSBuZWdvdGlhdGlvbi4gUGx1cywgaXQgZmVhdHVyZXMgcmVhbC1saWZlIGNhcmVlciBhZHZpY2UgZnJvbSBpbmR1c3RyeSBwcm9mZXNzaW9uYWxzIGFjcm9zcyBtdWx0aXBsZSBmaWVsZHMuIDwvcD4KPHA+VGhlIHVzZXIgaW50ZXJmYWNlIGlzIHVzZXItZnJpZW5kbHkgYW5kIGVhc3kgdG8gbmF2aWdhdGUsIG1ha2luZyB5b3VyIGpvYiBzZWFyY2ggcHJvY2VzcyBlYXNpZXIuIFdoZXRoZXIgeW91JiM4MjE3O3JlIGp1c3Qgc3RhcnRpbmcgb3V0IGluIHlvdXIgY2FyZWVyIG9yIGxvb2tpbmcgdG8gbWFrZSBhIHNlcmlvdXMgY2hhbmdlLCB0aGlzIHdlYnNpdGUgc2VlbXMgbGlrZSBhIHZhbHVhYmxlIHRvb2wuIDwvcD4KPHA+SWYgeW91JiM4MjE3O3JlIGludGVyZXN0ZWQsIEkgaGlnaGx5IHJlY29tbWVuZCB2aXNpdGluZyBpdC4gSXQgY291bGQgYmUgYSBncmVhdCBhc3NldCBpbiB0YWNrbGluZyB0aGUgY29tcGxpY2F0ZWQgd29ybGQgb2Ygam9iIGh1bnRpbmchIDwvcD4KPHA+V291bGQgbG92ZSB0byBoZWFyIHlvdXIgdGhvdWdodHMgaWYgeW91IGV4cGxvcmUgaXQhPC9wPgo8L2Rpdj4KCQkJCQk8L2Rpdj4KCTwvZGl2Pgo8L2Rpdj48IS0tICNjb21tZW50LSMjIC0tPgoKPGRpdiBpZD0iY29tbWVudC0zMzkxIiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtIG1hcmdpbi1sZWZ0IG1hcmdpbi1yaWdodCBwYWRkaW5nLXRvcCBwYWRkaW5nLWJvdHRvbSIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUmV2aWV3Ij4KCTxzcGFuIGl0ZW1wcm9wPSJpdGVtUmV2aWV3ZWQiIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1Byb2R1Y3QiPgoJCTxtZXRhIGl0ZW1wcm9wPSJuYW1lIiBjb250ZW50PSJFdmVyZXN0IEJhc2UgQ2FtcCBUcmVrIHZpYSBTYWxsZXJpIj4KPHNwYW4gaXRlbXByb3A9ImFnZ3JlZ2F0ZVJhdGluZyIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvQWdncmVnYXRlUmF0aW5nIj4KCTxtZXRhIGl0ZW1wcm9wPSJyYXRpbmdWYWx1ZSIgY29udGVudD0iMy42OCI+Cgk8bWV0YSBpdGVtcHJvcD0icmV2aWV3Q291bnQiIGNvbnRlbnQ9IjIyIj4KPC9zcGFuPgk8L3NwYW4+Cgk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRhaW5lciI+CgkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19pbmZvIj4KCQkJPGltZyBhbHQ9Jycgc3JjPSdodHRwczovL3NlY3VyZS5ncmF2YXRhci5jb20vYXZhdGFyLzg2YzExM2Y1YWJkMGQxNmViNjRiODRkZTJlMzAwNDBjP3M9MTIyJiMwMzg7ZD1tbSYjMDM4O3I9Zycgc3Jjc2V0PSdodHRwczovL3NlY3VyZS5ncmF2YXRhci5jb20vYXZhdGFyLzg2YzExM2Y1YWJkMGQxNmViNjRiODRkZTJlMzAwNDBjP3M9MjQ0JiMwMzg7ZD1tbSYjMDM4O3I9ZyAyeCcgY2xhc3M9J2F2YXRhciBhdmF0YXItMTIyIHBob3RvJyBoZWlnaHQ9JzEyMicgd2lkdGg9JzEyMicgbG9hZGluZz0nbGF6eScgZGVjb2Rpbmc9J2FzeW5jJy8+CQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19uYW1lIiBpdGVtcHJvcD0iYXV0aG9yIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9QZXJzb24iPjxzcGFuIGl0ZW1wcm9wPSJuYW1lIj5Sb2JlcnRzaGF2ZTwvc3Bhbj48L2Rpdj4KCQk8L2Rpdj4KCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRlbnQiPgoJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRlbnRfX3RvcCI+CgkJCQkJCQkJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX3JhdGluZyI+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PC9kaXY+CQkJCQk8c3BhbiBpdGVtcHJvcD0icmV2aWV3UmF0aW5nIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9SYXRpbmciPgoJCQkJCQk8bWV0YSBpdGVtcHJvcD0icmF0aW5nVmFsdWUiIGNvbnRlbnQ9IjMiPgoJCQkJCTwvc3Bhbj4KCQkJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2RhdGUiPk1heSAxNywgMjAyNDwvZGl2PgoJCQk8L2Rpdj4KCQkJCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX190ZXh0IiBpdGVtcHJvcD0icmV2aWV3Qm9keSI+PHA+0JPQtNC1INCa0YPQv9C40YLRjCDQmtC+0LrQsNC40L0g0LIg0JrQuNC10LLQtT8g0KHQkNCZ0KIgJiM4MjExOyBLT0tTLlRPUCDQk9C00LUg0JrRg9C/0LjRgtGMINCa0L7QutCw0LjQvSDQmtC40LXQsj8g0KHQkNCZ0KIgJiM4MjExOyBLT0tTLlRPUCA8L3A+CjxwPjEwMCUg0JTQntCh0KLQkNCS0JrQkCDQotCe0JLQkNCg0JAg0JIg0KDQo9Ca0JggICYjODIxMTsgPGEgaHJlZj0iaHR0cHM6Ly9rb2tzLnRvcC8iIHJlbD0ibm9mb2xsb3cgdWdjIj5odHRwczovL2tva3MudG9wLzwvYT4gPC9wPgo8cD4xMDAlINCX0JDQmtCQ0JfQqyDQntCd0JvQkNCZ0J0g0KfQldCg0JXQlyDQotCV0JvQldCT0KDQkNCc0JwgJiM4MjExOyA8YSBocmVmPSJodHRwczovL2tva3MudG9wLyIgcmVsPSJub2ZvbGxvdyB1Z2MiPmh0dHBzOi8va29rcy50b3AvPC9hPiA8L3A+CjxwPjEwMCUg0JfQkNCa0JvQkNCU0JrQmCDQntCd0JvQkNCZ0J0g0J3QkCDQodCQ0JnQotCVICAmIzgyMTE7IDxhIGhyZWY9Imh0dHBzOi8va29rcy50b3AvIiByZWw9Im5vZm9sbG93IHVnYyI+aHR0cHM6Ly9rb2tzLnRvcC88L2E+IDwvcD4KPHA+0KDQkNCR0J7Qp9CQ0K8g0KHQodCr0JvQmtCQINCU0JvQryDQodCS0K/Ql9CYINChINCe0J/QldCg0JDQotCe0KDQntCcICYjODIxMTsgPGEgaHJlZj0iaHR0cHM6Ly9rb2tzLnRvcC8iIHJlbD0ibm9mb2xsb3cgdWdjIj5odHRwczovL2tva3MudG9wLzwvYT4gPC9wPgo8cD7QmtCj0J/QmNCi0Kwg0JrQntCa0JDQmNCdINCe0J3Qm9CQ0JnQnSDQoSDQlNCe0KHQotCQ0JLQmtCe0JkgJiM4MjExOyA8YSBocmVmPSJodHRwczovL2tva3MudG9wLyIgcmVsPSJub2ZvbGxvdyB1Z2MiPmh0dHBzOi8va29rcy50b3AvPC9hPjxiciAvPgouPGJyIC8+Ci48YnIgLz4KLjxiciAvPgouPGJyIC8+Ci48YnIgLz4KLjxiciAvPgouPGJyIC8+Ci48YnIgLz4KLjxiciAvPgouPGJyIC8+Ci48YnIgLz4KLjxiciAvPgouPGJyIC8+Ci48YnIgLz4KLjxiciAvPgouPGJyIC8+Ci48YnIgLz4KLjxiciAvPgouPGJyIC8+Ci48YnIgLz4KLjxiciAvPgouPGJyIC8+Ci48YnIgLz4KLjxiciAvPgouPGJyIC8+Ci48YnIgLz4KLjxiciAvPgouPGJyIC8+Ci48YnIgLz4KLjxiciAvPgouPGJyIC8+Ci48YnIgLz4KLjxiciAvPgouPGJyIC8+Ci48YnIgLz4KLjxiciAvPgouPGJyIC8+Ci48YnIgLz4KLjxiciAvPgouPGJyIC8+Ci48YnIgLz4KLjxiciAvPgouPGJyIC8+Ci48YnIgLz4KLjxiciAvPgouPGJyIC8+Ci48YnIgLz4KLjxiciAvPgouPGJyIC8+Ci48YnIgLz4KLjxiciAvPgouPGJyIC8+Ci48YnIgLz4K0KLQtdCz0Lgg0L/QvtC40YHQutC+0LLRi9GFINGB0LvQvtCyINC00LvRjyDQt9Cw0L/RgNC+0YHQsCAmIzgyMjA70JrRg9C/0LjRgtGMINCa0L7QutCw0LjQvSDQsiDQmtC40LXQstC1JiM4MjIxOzxiciAvPgrQodC60L7Qu9GM0LrQviDQodGC0L7QuNGCINCa0L7QutCw0LjQvSDQsiDQmtC40LXQstC1INCyINGA0L7Qt9C90LjRhtGDINC4INC90LXRgtC+0LvRjNC60L4/INCa0YLQviDQvtCx0YvRh9C90L4g0L/QvtC60YPQv9Cw0LXRgiDQmtC+0LrQsNC40L0g0LIg0JrQuNC10LLQtSDQuCDQt9Cw0YfQtdC8PyDQmtCw0Log0LjQt9Cz0L7RgtCw0LLQu9C40LLQsNGO0YIg0JrQvtC60LDQuNC9INC60L7RgtC+0YDRi9C5INC80L7QttC90L4g0LrRg9C/0LjRgtGMINCyINCa0LjQtdCy0LUg0Lgg0LrQvtCz0LTQsD88YnIgLz4K0KHQutC+0LvRjNC60L4g0LvQtdGCINGD0LbQtSDQv9GA0L7QtNCw0Y7RgiDQutCw0YfQtdGB0YLQstC10L3QvdGL0Lkg0JrQvtC60LDQuNC9INCyINCa0LjQtdCy0LUg0LfQsNC60LvQsNC00LrQsNC80Lgg0Lgg0LPQtNC1PyDQmtCw0Log0LzQvtC20L3QviDQutGD0L/QuNGC0Ywg0JrQvtC60LDQuNC9INCyINCa0LjQtdCy0LUg0YEg0LTQvtGB0YLQsNCy0LrQvtC5INCyINGA0YPQutC4INC4INC30LAg0YHQutC+0LvRjNC60L4/PGJyIC8+CtCd0LDQtNC10LbQvdC+0YHRgtGMINC/0L7QutGD0L/QvtC6INCa0L7QutCw0LjQvdCwINCyINCa0LjQtdCy0LUg0YEg0LzQsNC60YHQuNC80LDQu9GM0L3QvtC5INGB0LrQvtGA0L7RgdGC0YzRjiDQtNC+0YHRgtCw0LLQutC4INGC0L7QstCw0YDQsCDQsiDRgNGD0LrQuCDRjdGC0L4g0YLQvtGH0L3Qvj8g0JrQsNC60L7QuSDQvNC40L3QuNC80LDQu9GM0L3Ri9C5INC30LDQutCw0Lcg0L/QvtC60YPQv9C60Lgg0JrQvtC60LDQuNC90LAg0LIg0JrQuNC10LLQtSDQv9GA0Lgg0LfQsNC60LDQt9C1INC+0L3Qu9Cw0LnQvT88YnIgLz4K0KHQsNC80YvQuSDQsdGL0YHRgtGA0YvQuSDRgdC/0L7RgdC+0LEg0JrRg9C/0LjRgtGMINCa0L7QutCw0LjQvSDQsiDQmtC40LXQstC1INCx0LXQtyDQv9C+0YHRgNC10LTQvdC40LrQvtCyPyDQmtGD0L/QuNGC0Ywg0LrQvtC60LDQuNC9INCyINC60LjQtdCy0LUg0L3QsCDQv9GA0Y/QvNGD0Y4g0LHQtdC3INGC0YDQtdGC0YzQuNGFINC70LjRhj8g0KHQutC+0LvRjNC60L4g0L3Rg9C20L3QviDQs9GA0LDQvNC8INC00LvRjyDRg9C/0L7RgtGA0LXQsdC70LXQvdC40Y8g0JrQvtC60LDQuNC90LAg0LIg0JrQuNC10LLQtSDQtdGB0LvQuCDRjyDQtNC10LLRg9GI0LrQsD88YnIgLz4K0JzQvtC5INC00YDRg9CzINC30L3QsNC10YIg0LPQtNC1INCx0YvRgdGC0YDQviDQmtGD0L/QuNGC0Ywg0JrQvtC60LDQuNC9INCyINCa0LjQtdCy0LUg0LIg0L3QvtGH0L3QvtC1INCy0YDQtdC80Y8g0YHRg9GC0L7QuiDQsdC10Lcg0L3QvtC80LXRgNCwINGC0LXQu9C10YTQvtC90LAg0LrRg9GA0YzQtdGA0LAsINCy0YHRkSDQv9C+0LvQvdC+0YHRgtGM0Y4g0L7QvdC70LDQudC9INC4INCw0L3QvtC90LjQvNC90L4hPGJyIC8+CtCV0YHQu9C4INC10YHRgtGMINC20LXQu9Cw0L3QuNC1INC/0L7QutGD0L/QsNGC0Ywg0JrQvtC60LDQuNC9INCyINCa0LjQtdCy0LUg0L/QviDRgdCw0LzQvtC5INC00LXQvNC+0LrRgNCw0YLQuNGH0L3QvtC5INC4INC90LjQt9C60L7QuSDRhtC10L3QtSDQv9C+INGB0YDQsNCy0L3QtdC90LjRjiDRgSDQutCw0YfQtdGB0YLQstC+0Lwg0YLQviDQktCw0Lwg0L3QtdGB0L7QvNC90LXQvdC90L4g0L3Rg9C20L3QviDQv9C+0YHQtdGC0LjRgtGMINGB0LDQudGCINC90LAg0LrQvtGC0L7RgNC+0Lwg0L/RgNC+0LTQsNGO0YIg0JrQvtC60LDQuNC9INCyINCa0LjQtdCy0LUg0LLRgdC10LPQtNCwPzxiciAvPgrQmtC+0LrQsNC40L0g0LIg0JrQuNC10LLQtSDQv9C+0YHQu9C1INC60L7RgtC+0YDQvtCz0L4g0L3QtdGCINCz0L7Qu9C+0LLQvdGL0YUg0LHQvtC70LXQuSwg0LvQvtC80L7RgtGLINCyINGB0YPRgdGC0LDQstC1INC4INC70L7QvNC60Lgg0LrQsNC6INC/0L7RgdC70LUg0YPQu9C40YfQvdGL0YUg0L3QsNGA0LrQvtGC0LjQutC+0LI/INCR0LXRgdC/0LvQsNGC0L3QsNGPINC00L7RgdGC0LDQstC60LAg0JrQvtC60LDQuNC90LAg0LIg0JrQuNC10LLQtSDQv9C+INGB0YDQtdC00LDRhSDQutCw0LbQtNC+0LPQviDQvNC10YHRj9GG0LAhPGJyIC8+CtCc0LXQu9C60LjQtSDQuCDQutGA0YPQv9C90YvQtSDQv9C+0LrRg9C/0LrQuCDQmtC+0LrQsNC40L3QsCDQsiDQmtC40LXQstC1LCDQntC/0YLQvtC8INCa0L7QutCw0LjQvSDQsiDQmtC40LXQstC1PyDQkiDRgNC+0LfQvdC40YbRgyDQmtC+0LrQsNC40L0g0LIg0JrQuNC10LLQtT8g0JLRgdGRINGN0YLQviDQsdC10Lcg0L/RgNC+0LHQu9C10Lwg0LzQvtC20LXRgiDQvtCx0LXRgdC/0LXRh9C40YLRjCDQstGB0LXQs9C+INC+0LTQuNC9INGB0LDQudGCINCyINC60YDQsNGC0YfQsNC50YjQuNC1INGB0YDQvtC60LghPGJyIC8+CtCn0LXQu9C+0LXQuiAmIzgyMTE7INCf0LDRg9C6INCy0LzQtdGB0YLQviDQv9Cw0YPRgtC40L3RiyDQv9C70LXRgtGR0YIg0LrQvtC60LDQuNC90L7QstGD0Y4g0L3QuNGC0YwsINC60L7RgtC+0YDRg9GOINC40L3QvtCz0LTQsCDQvNC+0LbQvdC+INC/0LXRgNC10L/Rg9GC0LDRgtGMINGBINCa0L7QutCw0LjQvdC+0Lwg0LIg0JrQuNC10LLQtSDQv9C+INGB0LDQvNC+0Lkg0LTQvtGB0YLRg9C/0L3QvtC5INGG0LXQvdC1INC90LAg0Y3RgtC+0Lwg0YPQt9C60L7Qv9GA0L7RhNC40LvRjNC90L7QvCDRgNGL0L3QutC1ITxiciAvPgrQmtCw0LbQtNCw0Y8g0YHQvtCx0LDQutCwINCyINCa0LjQtdCy0LUg0LfQvdCw0LXRgiDQs9C00LUg0LrRg9C/0LjRgtGMINCa0L7QutCw0LjQvSDQvdCwINGA0L7Qt9Cy0LXRgSDRgtCw0Log0YHQutCw0LfQsNGC0YwsINGA0LDQt9GE0LDRgdC+0LLQsNC90L3Ri9C5INGC0L7QstCw0YAg0LTQviDQvNC40LvQuNCz0YDQsNC80LzQsCDRgSDRgtC+0YfQvdC+0YHRgtGM0Y4g0YjQstC10LnRhtCw0YDRgdC60LjRhSDRh9Cw0YHQvtCyINCa0LjQtdCy0YHQutC40YUg0LrQvtC60LDQuNC90L7QstGL0YUg0LLQtdGB0L7Qsj88YnIgLz4K0JzQvtGPINC80L7Qu9C+0LTQsNGPINC/0L7QtNGA0YPQs9CwINC80L3QtSDQv9C+0LTRgdC60LDQt9Cw0LvQsCDQs9C00LUg0LIg0JrQuNC10LLQtSDQmtGD0L/QuNGC0Ywg0JrQvtC60LDQuNC9INGC0LDQutC+0LPQviDQutCw0YfQtdGB0YLQstCwLCDRh9GC0L4g0L/QvtGC0L7QvCDQstC10YHRjCDQvtGB0YLQsNC70YzQvdC+0Lkg0JrQvtC60LDQuNC9INGC0LIg0JrQuNC10LLQtSDQvNC+0LbQvdC+INCx0YPQtNC10YIg0L/RgNC+0YHRgtC+INCy0YvQutC40L3Rg9GC0Ywg0LIg0LzRg9GB0L7RgNC60YMg0LHQtdC3INGB0L7QvNC90LXQvdC40Y8/PGJyIC8+CtCd0LDRiCDQmtC+0LrQsNC40L0g0LIg0JrQuNC10LLQtS0g0L/RgNC+0YHRgtC+INC/0LXRgNGH0LjQuj8g0J/RgNC+INGC0LDQutC+0Lkg0JrQvtC60LDQuNC9INCyINCa0LjQtdCy0LUg0LTQsNC20LUg0YHQvtGH0LXQvdC40LvQuCDRg9C20LUg0YDQtdC/0YfQuNC6PyDQmtCw0LrQuNC1INC80L7Qu9C+0LTRhtGLINC70Y7QtNC4LCDQutC+0YLQvtGA0YvQtSDQv9C+0L3QuNC80LDRjtGCINCyINC60LDRh9C10YHRgtCy0LUg0Lgg0L7RgdC90L7QstC90YvRhSDQuNC90LPRgNC10LTQuNC10L3RgtCw0YUg0L/RgNC40LPQvtGC0L7QstC70LXQvdC40Y8g0YLQsNC60L7Qs9C+INCa0L7QutCw0LjQvdCwINCyINCa0LjQtdCy0LU/PGJyIC8+CtCc0LXQvdGPINC90LAg0YPQu9C40YbQtSDRgdC/0YDQvtGB0LjQu9C4ICYjODIxMTsg0JPQtNC1INC20LUg0LzRiyDQnNC+0LbQtdC8INCa0YPQv9C40YLRjCDQmtC+0LrQsNC40L0g0LIg0JrQuNC10LLQtT8g0Jgg0Y8g0YEg0LPQvtGA0LTQvtGB0YLRjNGOINC+0YLQstC10YLQuNC7ICYjODIxMTsg0JrQvtC60LDQuNC9INCyINCa0LjQtdCy0LUg0LLRiyDQstGB0LXQs9C00LAg0LzQvtC20LXRgtC1INC/0YDQtdC+0LHRgNC10YHRgtC4INC+0L3Qu9Cw0LnQvSDQvdCwINC+0YTQuNGG0LjQsNC70YzQvdC+0Lwg0LTQvtCy0LXRgNC10L3QvdC+0Lwg0YHQsNC50YLQtSDQutC+0YLQvtGA0YvQuSDQv9GA0L7QtNCw0LXRgiDQmtC+0LrQsNC40L0g0LIg0JrQuNC10LLQtS48YnIgLz4K0JrQsNC60LjQvNC4INGB0L/QvtGB0L7QsdC90L7RgdGC0Y/QvNC4INC+0LHQu9Cw0LTQsNGO0YIg0LvRjtC00LgsINC60L7RgtC+0YDRi9C1INGD0L/QvtGC0YDQtdCx0LvRj9GO0YIg0JrQvtC60LDQuNC9INCyINCa0LjQtdCy0LUg0LHQtdC3INGB0L3QsCDQtNCw0LbQtSDRgtGA0L7QtSDRgdGD0YLQvtC6LCDRgdC/0YDQvtGB0LjRgtC1INCy0Ys/INCQINGPINC+0YLQstC10YfRgyAmIzgyMTE7INGB0L/Rg9GB0YLRjyDQtNCw0LbQtSDRgtGA0Lgg0LTQvdGPINGH0LXQu9C+0LLQtdC6INGD0L/QvtGC0YDQtdCx0LjQstGI0LjQuSDQmtC+0LrQsNC40L0g0LIg0JrQuNC10LLQtSDRh9GD0LLRgdGC0LLRg9C10YIg0L/RgNC40LvQuNCyINGB0LjQuyDQuCDQsdC+0LTRgNC+0YHRgtGMINC90LAgMTAwJSE8YnIgLz4K0JzQvdC1INCyINC30LDQvNCw0YHQutC40YDQvtCy0LDQvdC90L7QuSDQv9C+0YHRi9C70LrQtSDQv9GA0LjQstC10LfQu9C4INCa0L7QutCw0LjQvSDQsiDQmtC40LXQstC1INC+0YfQtdC90Ywg0YXQvtGA0L7RiNC10LPQviDQutCw0YfQtdGB0YLQstCwINGC0L7QstCw0YAg0LTQu9GPINC+0LHQvtGA0L7RgtCwLCDQsdGL0LvQviDQvNC90L7Qs9C+INC90L4g0Y8g0L3QtSDQvtC20LjQtNCw0Lsg0YfRgtC+INCx0YPQtNC10YIg0LHQvtC70YzRiNC1INGH0LXQvCDQvdGD0LbQvdC+PyA8L3A+CjxwPtCe0LHRidC40LUg0KLQtdCz0Lgg0LTQu9GPINCT0YPQs9C7INCx0L7RgiAmIzgyMTE7INCa0YPQv9C40YLRjCDQqNC40YjQutC4INCyINCa0LjQtdCy0LUsINCa0YPQv9C40YLRjCDRjdC60YHRgtCw0LfQuCDQsiDQmtC40LXQstC1ICwg0JrRg9C/0LjRgtGMINCz0LDRiNC40Ygg0LIg0JrQuNC10LLQtSwg0JrRg9C/0LjRgtGMINC80LXRhNC10LTRgNC+0L0g0LIg0JrQuNC10LLQtSwg0JrRg9C/0LjRgtGMINGN0LrRgdGC0LDQt9C4INCyINCa0LjQtdCy0LUsINCa0YPQv9C40YLRjCDQnNCU0JzQkCDQsiDQmtC40LXQstC1LDxiciAvPgrQmtGD0L/QuNGC0Ywg0LvRgdC0INCyINCa0LjQtdCy0LUsINCa0YPQv9C40YLRjCDQkNC80YTQtdGC0LDQvNC40L0g0LIg0JrQuNC10LLQtSwg0JrRg9C/0LjRgtGMINGB0LrQvtGA0L7RgdGC0Ywg0LDQu9GM0YTQsCDQn9CS0J8g0LIg0JrQuNC10LLQtSwg0JrRg9C/0LjRgtGMINCz0LjQtNGA0L7Qv9C+0L3QuNC60YMg0LIg0JrQuNC10LLQtSwg0JrRg9C/0LjRgtGMINC80LXRgtCw0LzRhNC10YLQsNC80LjQvSDQsiDQmtC40LXQstC1LCDQmtGD0L/QuNGC0Ywg0Y3QudGE0L7RgNC10YLQuNC60Lgg0LIg0JrQuNC10LLQtSw8YnIgLz4K0JrRg9C/0LjRgtGMINC30LDQutC70LDQtNC60Lgg0LIg0JrQuNC10LLQtSwg0JrRg9C/0LjRgtGMINCo0JjQqNCa0Jgg0LfQsNC60LvQsNC00LrQvtC5INCyINCa0LjQtdCy0LUgLCDQmtGD0L/QuNGC0Ywg0KHRgtC40LzRg9C70Y/RgtC+0YDRiyDQsiDQmtC40LXQstC1LCDQmtGD0L/QuNGC0Ywg0JPQsNC70LvRjtGG0YvQvdC+0LPQtdC90Ysg0LIg0JrQuNC10LLQtS4g0KLQtdCzINC+0LrQvtC90YfQtdC9PC9wPgo8L2Rpdj4KCQkJCQk8L2Rpdj4KCTwvZGl2Pgo8L2Rpdj48IS0tICNjb21tZW50LSMjIC0tPgoKPGRpdiBpZD0iY29tbWVudC0zNDM4IiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtIG1hcmdpbi1sZWZ0IG1hcmdpbi1yaWdodCBwYWRkaW5nLXRvcCBwYWRkaW5nLWJvdHRvbSIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUmV2aWV3Ij4KCTxzcGFuIGl0ZW1wcm9wPSJpdGVtUmV2aWV3ZWQiIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1Byb2R1Y3QiPgoJCTxtZXRhIGl0ZW1wcm9wPSJuYW1lIiBjb250ZW50PSJFdmVyZXN0IEJhc2UgQ2FtcCBUcmVrIHZpYSBTYWxsZXJpIj4KPHNwYW4gaXRlbXByb3A9ImFnZ3JlZ2F0ZVJhdGluZyIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvQWdncmVnYXRlUmF0aW5nIj4KCTxtZXRhIGl0ZW1wcm9wPSJyYXRpbmdWYWx1ZSIgY29udGVudD0iMy42OCI+Cgk8bWV0YSBpdGVtcHJvcD0icmV2aWV3Q291bnQiIGNvbnRlbnQ9IjIyIj4KPC9zcGFuPgk8L3NwYW4+Cgk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRhaW5lciI+CgkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19pbmZvIj4KCQkJPGltZyBhbHQ9Jycgc3JjPSdodHRwczovL3NlY3VyZS5ncmF2YXRhci5jb20vYXZhdGFyLzBkOTE5YzRjODZkYTYxYzJlOWVlYmEwNGY0YTRlMWEwP3M9MTIyJiMwMzg7ZD1tbSYjMDM4O3I9Zycgc3Jjc2V0PSdodHRwczovL3NlY3VyZS5ncmF2YXRhci5jb20vYXZhdGFyLzBkOTE5YzRjODZkYTYxYzJlOWVlYmEwNGY0YTRlMWEwP3M9MjQ0JiMwMzg7ZD1tbSYjMDM4O3I9ZyAyeCcgY2xhc3M9J2F2YXRhciBhdmF0YXItMTIyIHBob3RvJyBoZWlnaHQ9JzEyMicgd2lkdGg9JzEyMicgbG9hZGluZz0nbGF6eScgZGVjb2Rpbmc9J2FzeW5jJy8+CQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19uYW1lIiBpdGVtcHJvcD0iYXV0aG9yIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9QZXJzb24iPjxzcGFuIGl0ZW1wcm9wPSJuYW1lIj5KYXNvbmhpejwvc3Bhbj48L2Rpdj4KCQk8L2Rpdj4KCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRlbnQiPgoJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRlbnRfX3RvcCI+CgkJCQkJCQkJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX3JhdGluZyI+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PC9kaXY+CQkJCQk8c3BhbiBpdGVtcHJvcD0icmV2aWV3UmF0aW5nIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9SYXRpbmciPgoJCQkJCQk8bWV0YSBpdGVtcHJvcD0icmF0aW5nVmFsdWUiIGNvbnRlbnQ9IjMiPgoJCQkJCTwvc3Bhbj4KCQkJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2RhdGUiPk1heSAyMCwgMjAyNDwvZGl2PgoJCQk8L2Rpdj4KCQkJCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX190ZXh0IiBpdGVtcHJvcD0icmV2aWV3Qm9keSI+PHA+TmV3IFlvcmsgKENOTiBCdXNpbmVzcykuINCb0Y7QsdC+0LLRjCDQkNC80LXRgNC40LrQuCDQuiDQutGA0YvQu9GL0YjQutCw0Lwg0YLQvtC70YzQutC+INCy0YvRgNC+0YHQu9CwINCy0L4g0LLRgNC10LzRjyDQv9Cw0L3QtNC10LzQuNC4LiDQoNC10YHRgtC+0YDQsNC90L3Ri9C1INGB0LXRgtC4INC+0YIgQXBwbGViZWUmIzgyMTc7cyDQtNC+IERvbWlubyYjODIxNztzINC20LTRg9GCINGN0YLQvtCz0L4uPGJyIC8+CtCQ0LrRhtC40LggV2luZ3N0b3AgKFdJTkcpLCDRgdC10YLQuCDQutGD0YDQuNC90YvRhSDQutGA0YvQu9GL0YjQtdC6LCDQstC60LvRjtGH0LDRjtGJ0LXQuSDQvtC60L7Qu9C+IDEzMDAg0LfQsNCy0LXQtNC10L3QuNC5INC/0L4g0LLRgdC10Lkg0YHRgtGA0LDQvdC1INC4INC+0LrQvtC70L4gMTYwINC30LDQstC10LTQtdC90LjQuSDQt9CwINGA0YPQsdC10LbQvtC8LCDQsiDRjdGC0L7QvCDQs9C+0LTRgyDQstGL0YDQvtGB0LvQuCDQv9C+0YfRgtC4INC90LAgNjAlLiDQkNC90LDQu9C40YLQuNC6IE1vcm5pbmdzdGFyINCgLtCU0LYuINCl0L7RgtGC0L7QstC4INGB0LrQsNC30LDQuyDQsiDQvtGC0YfQtdGC0LUg0L3QsCDQv9GA0L7RiNC70L7QuSDQvdC10LTQtdC70LUsINGH0YLQviDRjdGC0LAg0YHQtdGC0Ywg0LLRhdC+0LTQuNGCINCyINGH0LjRgdC70L4g0YDQtdGB0YLQvtGA0LDQvdC+0LIsINC60L7RgtC+0YDRi9C1INC+0YLQtNC10LvQuNC70LjRgdGMLjxiciAvPgrQn9GA0L7QtNCw0LbQuCBXaW5nc3RvcCDRgNC10LfQutC+INCy0YvRgNC+0YHQu9C4INCy0L4g0LLRgNC10LzRjyDQv9Cw0L3QtNC10LzQuNC4LiDQl9CwIDEzINC90LXQtNC10LvRjCwg0LfQsNC60L7QvdGH0LjQstGI0LjRhdGB0Y8gMjcg0LjRjtC90Y8sINC/0YDQvtC00LDQttC4INCyINC30LDQvNC10LTQtdC90LjRj9GFLCDQvtGC0LrRgNGL0YLRi9GFINC90LUg0LzQtdC90LXQtSDQs9C+0LTQsCwg0L/QvtC00YHQutC+0YfQuNC70Lgg0L/QvtGH0YLQuCDQvdCwIDMyJS48YnIgLz4K0JjRgdGF0L7QtNGPINC40Lcg0YHQtdC90YLRj9Cx0YDRjNGB0LrQvtCz0L4g0L7RgtGA0LDRgdC70LXQstC+0LPQviDQvtGC0YfQtdGC0LAsINCx0YDQtdC90LQg0LzQvtC20LXRgiDQv9GA0L7QtNC+0LvQttCw0YLRjCDRgNCw0YHRgtC4INCyINGC0LXRh9C10L3QuNC1INC90LXRgdC60L7Qu9GM0LrQuNGFINC80LXRgdGP0YbQtdCyLiDCq9Ce0YHQvdC+0LLQvdGL0Lwg0LHQsNGA0YzQtdGA0L7QvCDQtNC70Y8gV2luZ3N0b3Ag0LHRi9C70L4g0L7RgtGB0YPRgtGB0YLQstC40LUg0L7RgdCy0LXQtNC+0LzQu9C10L3QvdC+0YHRgtC4INC/0L7RgtGA0LXQsdC40YLQtdC70LXQucK7LCAmIzgyMTE7INC+0YLQvNC10YfQsNC10YLRgdGPINCyINC+0YLRh9C10YLQtSwg0LTQvtCx0LDQstC70Y/Rjywg0YfRgtC+IMKr0YEg0LHRgNC10L3QtNC+0Lwg0L/QvtC30L3QsNC60L7QvNC40LvQvtGB0Ywg0LHQvtC70YzRiNC+0LUg0YfQuNGB0LvQviDQvdC+0LLRi9GFINC60LvQuNC10L3RgtC+0LLCuy48YnIgLz4K0JzQtdC90YzRiNC40LUg0YbQtdC/0Lgg0LrRgNGL0LvRjNC10LIg0YLQsNC60LbQtSDQstGL0YDQvtGB0LvQuC4g0JIgV2luZyBab25lLCDQvdCw0YHRh9C40YLRi9Cy0LDRjtGJ0LXQuSDQvtC60L7Qu9C+IDcwINC30LDQstC10LTQtdC90LjQuSDQsiDQkNC80LXRgNC40LrQtSwg0LfQsCDQv9C+0LvQs9C+0LTQsCDQv9GA0L7QtNCw0LbQuCDQv9C+0LTQvdGP0LvQuNGB0Ywg0L/RgNC40LzQtdGA0L3QviDQvdCwIDI1JSDQv9C+INGB0YDQsNCy0L3QtdC90LjRjiDRgSDQv9GA0LXQtNGL0LTRg9GJ0LjQvCDQv9C10YDQuNC+0LTQvtC8LjxiciAvPgrCq9Ct0YLQviDQsdGL0Lsg0YHQsNC80YvQuSDQsdC+0LvRjNGI0L7QuSDRgNC+0YHRgiDQv9GA0L7QtNCw0LYg0LfQsCDQstGB0LUg0LLRgNC10LzRj8K7LCAmIzgyMTE7INC+0YLQutGA0YvQuyDQlNC40YDQtdC60YLQvtGALjxiciAvPgrQn9C+INGB0LvQvtCy0LDQvCDQs9C10L3QtdGA0LDQu9GM0L3QvtCz0L4g0LTQuNGA0LXQutGC0L7RgNCwINCX0LDQutCwID8/0J7QvNCw0YDQsCwg0L/RgNC+0LTQsNC20LggQXRvbWljIFdpbmdzLCDQvNCw0LvQtdC90YzQutC+0Lkg0YHQtdGC0LgsINGA0LDRgdC/0L7Qu9C+0LbQtdC90L3QvtC5INCyINCd0YzRji3QmdC+0YDQutC1LCDQsiDQvdC10LrQvtGC0L7RgNGL0YUg0LzQtdGB0YLQsNGFINCy0YvRgNC+0YHQu9C4INC00L4gMTAwJS48YnIgLz4K0K3RgtC+0Lkg0L3QvtCy0L7RgdGC0YzRjiDQvdCw0YEg0L/QvtGA0LDQtNC+0LLQsNC70L4g0KHQsNC50YIg0L3QvtCy0L7RgdGC0LXQuSBbdXJsPWh0dHBzOi8vd29ybGRzaWNrcy5ydS9dd29ybGRzaWNrcy5ydVsvdXJsXTxiciAvPgrQlNC10LvQuNC80YHRjyDQvNC90LXQvdC40Y/QvNC4LiDQrdGC0L4g0YXQvtGA0L7RiNCw0Y8g0L3QvtCy0L7RgdGC0Ywg0LjQu9C4INC90LUg0L3Rg9C20L3QsNGPPzwvcD4KPC9kaXY+CgkJCQkJPC9kaXY+Cgk8L2Rpdj4KPC9kaXY+PCEtLSAjY29tbWVudC0jIyAtLT4KCjxkaXYgaWQ9ImNvbW1lbnQtMzUzMCIgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbSBtYXJnaW4tbGVmdCBtYXJnaW4tcmlnaHQgcGFkZGluZy10b3AgcGFkZGluZy1ib3R0b20iIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1JldmlldyI+Cgk8c3BhbiBpdGVtcHJvcD0iaXRlbVJldmlld2VkIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9Qcm9kdWN0Ij4KCQk8bWV0YSBpdGVtcHJvcD0ibmFtZSIgY29udGVudD0iRXZlcmVzdCBCYXNlIENhbXAgVHJlayB2aWEgU2FsbGVyaSI+CjxzcGFuIGl0ZW1wcm9wPSJhZ2dyZWdhdGVSYXRpbmciIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL0FnZ3JlZ2F0ZVJhdGluZyI+Cgk8bWV0YSBpdGVtcHJvcD0icmF0aW5nVmFsdWUiIGNvbnRlbnQ9IjMuNjgiPgoJPG1ldGEgaXRlbXByb3A9InJldmlld0NvdW50IiBjb250ZW50PSIyMiI+Cjwvc3Bhbj4JPC9zcGFuPgoJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19jb250YWluZXIiPgoJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9faW5mbyI+CgkJCTxpbWcgYWx0PScnIHNyYz0naHR0cHM6Ly9zZWN1cmUuZ3JhdmF0YXIuY29tL2F2YXRhci82MDdjNjIyNjkxYjc3OGYyNjQ4YzdkMDcxYTA0ODRkYz9zPTEyMiYjMDM4O2Q9bW0mIzAzODtyPWcnIHNyY3NldD0naHR0cHM6Ly9zZWN1cmUuZ3JhdmF0YXIuY29tL2F2YXRhci82MDdjNjIyNjkxYjc3OGYyNjQ4YzdkMDcxYTA0ODRkYz9zPTI0NCYjMDM4O2Q9bW0mIzAzODtyPWcgMngnIGNsYXNzPSdhdmF0YXIgYXZhdGFyLTEyMiBwaG90bycgaGVpZ2h0PScxMjInIHdpZHRoPScxMjInIGxvYWRpbmc9J2xhenknIGRlY29kaW5nPSdhc3luYycvPgkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fbmFtZSIgaXRlbXByb3A9ImF1dGhvciIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUGVyc29uIj48c3BhbiBpdGVtcHJvcD0ibmFtZSI+QW50aG9ueU9waXNhPC9zcGFuPjwvZGl2PgoJCTwvZGl2PgoJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fY29udGVudCI+CgkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fY29udGVudF9fdG9wIj4KCQkJCQkJCQkJCQkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fcmF0aW5nIj48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjwvZGl2PgkJCQkJPHNwYW4gaXRlbXByb3A9InJldmlld1JhdGluZyIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUmF0aW5nIj4KCQkJCQkJPG1ldGEgaXRlbXByb3A9InJhdGluZ1ZhbHVlIiBjb250ZW50PSI0Ij4KCQkJCQk8L3NwYW4+CgkJCQkJCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19kYXRlIj5NYXkgMjMsIDIwMjQ8L2Rpdj4KCQkJPC9kaXY+CgkJCQkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fdGV4dCIgaXRlbXByb3A9InJldmlld0JvZHkiPjxwPkF0dHJhY3RpdmUgc2VjdGlvbiBvZiBjb250ZW50LiBJIGp1c3Qgc3R1bWJsZWQgdXBvbiB5b3VyIHNpdGUgYW5kIGluIGFjY2Vzc2lvbiBjYXBpdGFsIHRvIGFzc2VydCB0aGF0IEkgZ2V0IGluIGZhY3QgZW5qb3llZCBhY2NvdW50IHlvdXIgYmxvZyBwb3N0cy4gQW55IHdheSBJIHdpbGwgYmUgc3Vic2NyaWJpbmcgdG8geW91ciBmZWVkcyBhbmQgZXZlbiBJIGFjaGlldmVtZW50IHlvdSBhY2Nlc3MgY29uc2lzdGVudGx5IGZhc3QuPGJyIC8+Cmxvb2sgYWxzbyBhdCBteSBwYWdlcyBhbmQgZ2l2ZSBhIHJhdGluZyA8L3A+CjxwPlhFdmlsIGlzIGEgc3RyYWlnaHRmb3J3YXJkLCByYXBpZGx5IGFuZCBlYXN5IG1ldGhvZCBmb3IgY29tcGxldGVseSBhdXRvbWF0ZWQgcmVjb2duaXRpb24gYW5kIGJ5cGFzcyB3aXRoIHRoZSB2YXN0IG1ham9yaXR5IG9mIGNhcHRjaGFzIChDQVBUQ0hBcyksIHdpdGhvdXQgdGhlIHJlcXVpcmUgdG8gYXR0YWNoIGFueSB0aGlyZC1wYXJ0eSBzZXJ2aWNlcy4gPC9wPgo8cD5UaGlzIHN5c3RlbSBWaXJ0dWFsbHkgdG90YWxseSByZXBsYWNlcyBwcm9kdWN0cyBhbmQgc2VydmljZXMgZm9yIGluc3RhbmNlIEFudGlHYXRlIChBbnRpLUNhcHRjaGEpLCBSdUNhcHRjaGEsIERlQ2FwdGNoZXIgYW5kIE90aGVyIGZvbGtzLiBBdCB0aGUgc2FtZSB0aW1lLCBpdCBub3RpY2VhYmx5IGV4Y2VlZHMgdGhlbSBpbiByZWNvZ25pdGlvbiBwYWNlICh0ZW4gc2l0dWF0aW9ucyBvciBldmVuIG1vcmUpIGFuZCBpcyB0b3RhbGx5IGZyZWUuIDwvcD4KPHA+PGEgaHJlZj0iaHR0cHM6Ly9oZWxsb2JpbmUuY29tL2Jicy9ib2FyZC5waHA/Ym9fdGFibGU9ZnJlZSYjMDM4O3dyX2lkPTI0NDIzMSIgcmVsPSJub2ZvbGxvdyB1Z2MiPmh0dHBzOi8vaGVsbG9iaW5lLmNvbS9iYnMvYm9hcmQucGhwP2JvX3RhYmxlPWZyZWUmIzAzODt3cl9pZD0yNDQyMzE8L2E+IGZhc3QgaW5kZXhpbmcgcGFuZGFzPGJyIC8+CjxhIGhyZWY9Imh0dHBzOi8vbWlzdGVyZ2FkZ2V0ZWVyLmNvbS90aGUtY2hyb25pY2xlcy1vZi1zcGVlZHlpbmRleC1nb29nbGUvIiByZWw9Im5vZm9sbG93IHVnYyI+aHR0cHM6Ly9taXN0ZXJnYWRnZXRlZXIuY29tL3RoZS1jaHJvbmljbGVzLW9mLXNwZWVkeWluZGV4LWdvb2dsZS88L2E+IHNwZWVkIGluZGV4IGhvdyB0byBmaXggaW4gaGluZGk8YnIgLz4KPGEgaHJlZj0iaHR0cHM6Ly93d3cua2luby11c3NyLnJ1L3VzZXIvQWxleFNpbmdsZXRhcnkvIiByZWw9Im5vZm9sbG93IHVnYyI+aHR0cHM6Ly93d3cua2luby11c3NyLnJ1L3VzZXIvQWxleFNpbmdsZXRhcnkvPC9hPiBmYXN0IGluZGV4aW5nIGZvciBibG9nZ2VyPGJyIC8+CjxhIGhyZWY9Imh0dHA6Ly9rYWZkcC5vci5rci9iYnMvYm9hcmQucGhwP2JvX3RhYmxlPWZyZWUmIzAzODt3cl9pZD0yMTkwNjkiIHJlbD0ibm9mb2xsb3cgdWdjIj5odHRwOi8va2FmZHAub3Iua3IvYmJzL2JvYXJkLnBocD9ib190YWJsZT1mcmVlJiMwMzg7d3JfaWQ9MjE5MDY5PC9hPiBmYXN0IGluZGV4aW5nIG9wdGlvbnM8YnIgLz4KPGEgaHJlZj0iaHR0cHM6Ly9sZWFybmluZy5sZ20taW50ZXJuYXRpb25hbC5jb20vZm9ydW1zL3VzZXJzL2pldHRtYXEwMDE2MDA5LyIgcmVsPSJub2ZvbGxvdyB1Z2MiPmh0dHBzOi8vbGVhcm5pbmcubGdtLWludGVybmF0aW9uYWwuY29tL2ZvcnVtcy91c2Vycy9qZXR0bWFxMDAxNjAwOS88L2E+IHNvbHZpbmcgY2FwdGNoYTxiciAvPgo8YSBocmVmPSJodHRwOi8vd3d3Lmh1Y2VsbGJpby5jb20vYmJzL2JvYXJkLnBocD9ib190YWJsZT1mcmVlJiMwMzg7d3JfaWQ9Mjc3NDI1IiByZWw9Im5vZm9sbG93IHVnYyI+aHR0cDovL3d3dy5odWNlbGxiaW8uY29tL2Jicy9ib2FyZC5waHA/Ym9fdGFibGU9ZnJlZSYjMDM4O3dyX2lkPTI3NzQyNTwvYT4gY2FwdGNoYSBzZXJ2aWNlPGJyIC8+CjxhIGhyZWY9Imh0dHA6Ly93d3cuY3VuZXN0LmNvLmtyL2Jicy9ib2FyZC5waHA/Ym9fdGFibGU9ZnJlZSYjMDM4O3dyX2lkPTE2MTkyIiByZWw9Im5vZm9sbG93IHVnYyI+aHR0cDovL3d3dy5jdW5lc3QuY28ua3IvYmJzL2JvYXJkLnBocD9ib190YWJsZT1mcmVlJiMwMzg7d3JfaWQ9MTYxOTI8L2E+IFhldmlsIDwvcD4KPHA+QGRAPTwvcD4KPC9kaXY+CgkJCQkJPC9kaXY+Cgk8L2Rpdj4KPC9kaXY+PCEtLSAjY29tbWVudC0jIyAtLT4KCjxkaXYgaWQ9ImNvbW1lbnQtMzUzMSIgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbSBtYXJnaW4tbGVmdCBtYXJnaW4tcmlnaHQgcGFkZGluZy10b3AgcGFkZGluZy1ib3R0b20iIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1JldmlldyI+Cgk8c3BhbiBpdGVtcHJvcD0iaXRlbVJldmlld2VkIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9Qcm9kdWN0Ij4KCQk8bWV0YSBpdGVtcHJvcD0ibmFtZSIgY29udGVudD0iRXZlcmVzdCBCYXNlIENhbXAgVHJlayB2aWEgU2FsbGVyaSI+CjxzcGFuIGl0ZW1wcm9wPSJhZ2dyZWdhdGVSYXRpbmciIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL0FnZ3JlZ2F0ZVJhdGluZyI+Cgk8bWV0YSBpdGVtcHJvcD0icmF0aW5nVmFsdWUiIGNvbnRlbnQ9IjMuNjgiPgoJPG1ldGEgaXRlbXByb3A9InJldmlld0NvdW50IiBjb250ZW50PSIyMiI+Cjwvc3Bhbj4JPC9zcGFuPgoJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19jb250YWluZXIiPgoJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9faW5mbyI+CgkJCTxpbWcgYWx0PScnIHNyYz0naHR0cHM6Ly9zZWN1cmUuZ3JhdmF0YXIuY29tL2F2YXRhci8zOGM0MTY0MWY0MWQxY2M1MGE0OWIyNzM0NzljNzk0ZT9zPTEyMiYjMDM4O2Q9bW0mIzAzODtyPWcnIHNyY3NldD0naHR0cHM6Ly9zZWN1cmUuZ3JhdmF0YXIuY29tL2F2YXRhci8zOGM0MTY0MWY0MWQxY2M1MGE0OWIyNzM0NzljNzk0ZT9zPTI0NCYjMDM4O2Q9bW0mIzAzODtyPWcgMngnIGNsYXNzPSdhdmF0YXIgYXZhdGFyLTEyMiBwaG90bycgaGVpZ2h0PScxMjInIHdpZHRoPScxMjInIGxvYWRpbmc9J2xhenknIGRlY29kaW5nPSdhc3luYycvPgkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fbmFtZSIgaXRlbXByb3A9ImF1dGhvciIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUGVyc29uIj48c3BhbiBpdGVtcHJvcD0ibmFtZSI+Z3Jvd2V4LU51aDwvc3Bhbj48L2Rpdj4KCQk8L2Rpdj4KCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRlbnQiPgoJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRlbnRfX3RvcCI+CgkJCQkJCQkJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX3JhdGluZyI+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PC9kaXY+CQkJCQk8c3BhbiBpdGVtcHJvcD0icmV2aWV3UmF0aW5nIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9SYXRpbmciPgoJCQkJCQk8bWV0YSBpdGVtcHJvcD0icmF0aW5nVmFsdWUiIGNvbnRlbnQ9IjMiPgoJCQkJCTwvc3Bhbj4KCQkJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2RhdGUiPk1heSAyMywgMjAyNDwvZGl2PgoJCQk8L2Rpdj4KCQkJCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX190ZXh0IiBpdGVtcHJvcD0icmV2aWV3Qm9keSI+PHA+0JrQvtC80L/QsNC90LjRjyDCq0dyb3dleCBHcm91cMK7INCx0L7Qu9C10LUgMTUg0LvQtdGCINC+0LrQsNC30YvQstCw0LXRgiDQv9C+0LvQvdGL0Lkg0LrQvtC80L/Qu9C10LrRgSDRg9GB0LvRg9CzINCyINC80LXQttC00YPQvdCw0YDQvtC00L3QvtC8INC70L7Qs9C40YHRgtC40YfQtdGB0LrQvtC8INC90LDQv9GA0LDQstC70LXQvdC40LguINCe0YHQvdC+0LLQvdC+0LUg0L3QsNC/0YDQsNCy0LvQtdC90LjQtSDQtNC10Y/RgtC10LvRjNC90L7RgdGC0Lgg0LfQsNC60LvRjtGH0LDQtdGC0YHRjyDQsiDRgtCw0LzQvtC20LXQvdC90L7QvCDQvtGE0L7RgNC80LvQtdC90LjQuCwg0LAg0YLQsNC60LbQtSDQutC+0L3RgtC10LnQvdC10YDQvdGL0YUg0L/QtdGA0LXQstC+0LfQutCw0YUuINCX0LDQutCw0LbQuNGC0LUg0L/QtdGA0LXQstC+0LfQutC4INCw0LLRgtC+0LzQvtCx0LjQu9GM0L3Ri9C8LCDQvNC+0YDRgdC60LjQvCwg0LLQvtC30LTRg9GI0L3Ri9C8LCDQttC10LvQtdC30L3QvtC00L7RgNC+0LbQvdGL0Lwg0YLRgNCw0L3RgdC/0L7RgNGC0L7QvC4g0KDQsNCx0L7RgtCwINGBINCx0LjQt9C90LXRgdC+0Lwg0YDQsNC30LvQuNGH0L3QvtCz0L4g0YPRgNC+0LLQvdGPOiDQvNC10LvQutC40LwsINC60YDRg9C/0L3Ri9C8LCDQsCDRgtCw0LrQttC1INC/0YDQvtC40LfQstC+0LTRgdGC0LLQtdC90L3Ri9C80Lgg0LrQvtC80L/QsNC90LjRj9C80LgsINC/0YDQtdC00L/RgNC40Y/RgtC40Y/QvNC4INCz0L7RgdGD0LTQsNGA0YHRgtCy0LXQvdC90L7Qs9C+INGD0YDQvtCy0L3Rjy4g0J3QsCDQv9GA0L7RhNC10YHRgdC40L7QvdCw0LvRjNC90L7QvCDRg9GA0L7QstC90LUg0L7QsdC10YHQv9C10YfQuNCy0LDQtdGC0YHRjyDQvtC/0LXRgNCw0YLQuNCy0L3QsNGPINC00L7RgdGC0LDQstC60LAg0LPRgNGD0LfQsCwg0YHQv9C10YbQuNCw0LvQuNGB0YLRiyDRhNC40L3QsNC90YHQvtCy0L4g0L7RgtCy0LXRh9Cw0Y7RgiDQt9CwINGB0L7RhdGA0LDQvdC90L7RgdGC0Ywg0YLQvtCy0LDRgNCwLiDQkCDQv9C+0YLQvtC80YMg0L7QvSDRgtC+0YfQvdC+INC00L7QtdC00LXRgiDQsiDRhtC10LvQvtGB0YLQuCDQuCDRgdC+0YXRgNCw0L3QvdC+0YHRgtC4LiDQndCwINGB0LDQudGC0LUgPGEgaHJlZj0iaHR0cHM6Ly9ncm93ZXgtZ3JvdXAucnUvIiByZWw9Im5vZm9sbG93IHVnYyI+aHR0cHM6Ly9ncm93ZXgtZ3JvdXAucnUvPC9hPiAoPGEgaHJlZj0iaHR0cHM6Ly9ncm93ZXgtZ3JvdXAucnUvIiAvIHJlbD0ibm9mb2xsb3cgdWdjIj7Qu9C+0LPQuNGB0YLQuNGH0LXRgdC60LDRjyDQutC+0LzQv9Cw0L3QuNGPINC80L7RgdC60LLQsDwvYT4gKSDRg9GC0L7Rh9C90LjRgtC1INGC0L4sINC60LDQutC40LUg0YPRgdC70YPQs9C4INC+0LrQsNC30YvQstCw0Y7RgtGB0Y8g0LrQvtC80L/QsNC90LjQtdC5LiDQmiDQtdC1INC/0YDQtdC40LzRg9GJ0LXRgdGC0LLQsNC8INC+0YLQvdC+0YHRj9GCOiA8L3A+CjxwPiYjODIxMTsg0YLRidCw0YLQtdC70YzQvdCw0Y8g0L7RgNCz0LDQvdC40LfQsNGG0LjRjyDQv9C10YDQtdCy0L7Qt9C+0Log0LzQtdC20LTRg9C90LDRgNC+0LTQvdC+0LPQviDRg9GA0L7QstC90Y87PGJyIC8+CiYjODIxMTsg0LTQvtGB0YLRg9C/0L3Ri9C1INGG0LXQvdGLOzxiciAvPgomIzgyMTE7INCy0L7Qt9C80L7QttC90L7RgdGC0Ywg0L7RgtC/0YDQsNCy0LjRgtGMLCDQsiDRgtC+0Lwg0YfQuNGB0LvQtSwg0YHQutC+0YDQvtC/0L7RgNGC0Y/RidC40LXRgdGPINCz0YDRg9C30Ys7PGJyIC8+CiYjODIxMTsg0L7Qv9C10YDQsNGC0LjQstC90L7QtSDQstGL0L/QvtC70L3QtdC90LjQtSDQt9Cw0LrQsNC30LAuIDwvcD4KPHA+0JTQu9GPINCy0YHQtdGFINC60LvQuNC10L3RgtC+0LIg0L/RgNC10LTRg9GB0LzQvtGC0YDQtdC9INGN0LvQtdC60YLRgNC+0L3QvdGL0Lkg0LTQvtC60YPQvNC10L3RgtC+0L7QsdC+0YDQvtGCLCDQtNC+0YHRgtGD0L/QvdGLINCx0LXRgdC/0LvQsNGC0L3Ri9C1INC60L7QvdGB0YPQu9GM0YLQsNGG0LjQuCwg0LXRgdC70Lgg0L3QtdC+0LHRhdC+0LTQuNC80L4g0YfRgtC+LdGC0L4g0YPRgtC+0YfQvdC40YLRjC4g0Jog0LrQsNC20LTQvtC80YMg0LrQu9C40LXQvdGC0YMg0L/RgNC40YHRgtCw0LLQu9GP0LXRgtGB0Y8g0L/QtdGA0YHQvtC90LDQu9GM0L3Ri9C5INC80LXQvdC10LTQttC10YAsINC60L7RgtC+0YDRi9C5INCx0YPQtNC10YIg0LrRg9GA0LjRgNC+0LLQsNGC0Ywg0LLQtdGB0Ywg0L/RgNC+0YbQtdGB0YEuINCS0YHQtSDRgNCw0LHQvtGC0Ysg0LLRi9C/0L7Qu9C90Y/RjtGC0YHRjyDRgdGC0YDQvtCz0L4g0L/QvtC0INC60LvRjtGHLCDQv9C+0Y3RgtC+0LzRgyDQvdC1INC/0YDQuNC00LXRgtGB0Y8g0L3QuCDQviDRh9C10Lwg0L/QtdGA0LXQttC40LLQsNGC0YwuINCT0YDRg9C3INGB0LXRgNGC0LjRhNC40YbQuNGA0YPQtdGC0YHRjy4g0J/RgNC4INC90LXQvtCx0YXQvtC00LjQvNC+0YHRgtC4INC/0YDQtdC00L7RgdGC0LDQstC70Y/QtdGC0YHRjyDQuNC90YTQvtGA0LzQuNGA0L7QstCw0L3QuNC1IDI0LzcuIDwvcD4KPHA+0J7QsdC10YHQv9C10YfQuNCy0LDRjtGC0YHRjyDQstGB0LUg0L/RgNC+0YbQtdGB0YHRiywg0LrQvtGC0L7RgNGL0LUg0YHQstGP0LfQsNC90Ysg0YEg0LvQvtCz0LjRgdGC0LjQutC+0LkuINCc0LjRgdGB0LjRjyDQv9GA0LXQtNC/0YDQuNGP0YLQuNGPINGB0L7RgdGC0L7QuNGCINCyINGC0L7QvCwg0YfRgtC+0LHRiyDQutCw0LbQtNGL0Lkg0LrQu9C40LXQvdGCINC/0L7Qu9GD0YfQuNC7INGB0LXRgNCy0LjRgSDQstGL0YHQvtC60L7Qs9C+INGD0YDQvtCy0L3Rjy4g0J7QvSDQtNCw0LXRgiDQstC+0LfQvNC+0LbQvdC+0YHRgtGMINC+0YDQs9Cw0L3QuNC30L7QstCw0YLRjCDQv9C10YDQtdCy0L7Qt9C60Lgg0LzQtdC20LTRg9C90LDRgNC+0LTQvdC+0LPQviDRg9GA0L7QstC90Y8g0Lgg0YHRgtGA0L7Qs9C+INC/0L7QtCDQutC70Y7Rhywg0LAg0YLQsNC60LbQtSDQsiDQutC+0YDQvtGC0LrQuNC1INGB0YDQvtC60LguINCt0YLQviDQv9C+0LfQstC+0LvQuNGCINC/0YDQsNCy0LjQu9GM0L3QviDRgdGE0L7RgNC80LjRgNC+0LLQsNGC0Ywg0Lgg0YDQsNC30LLQuNGC0Ywg0LHQuNC30L3QtdGBLiDQndCwINC/0YDQtdC00L/RgNC40Y/RgtC40Lgg0LzQsNC60YHQuNC80LDQu9GM0L3QviDRgtGJ0LDRgtC10LvRjNC90L4sINC00LXRgtCw0LvRjNC90L4g0L/QvtC00YXQvtC00Y/RgiDQuiDQv9GA0L7RhtC10YHRgdGDINC+0YDQs9Cw0L3QuNC30LDRhtC40Lgg0L/QtdGA0LXQstC+0LfQvtC6LCDRh9GC0L7QsdGLINCy0YHQtSDQv9GA0L7RiNC70L4g0LjQvNC10L3QvdC+INGC0LDQuiwg0LrQsNC6INC90YPQttC90L4uINCS0L7RgdC/0L7Qu9GM0LfRg9C50YLQtdGB0Ywg0YPRgdC70YPQs9Cw0LzQuCDQutC+0LzQv9Cw0L3QuNC4LCDQutC+0YLQvtGA0L7QuSDQstCw0LbQtdC9INGA0LXQt9GD0LvRjNGC0LDRgi48L3A+CjwvZGl2PgoJCQkJCTwvZGl2PgoJPC9kaXY+CjwvZGl2PjwhLS0gI2NvbW1lbnQtIyMgLS0+Cgo8ZGl2IGlkPSJjb21tZW50LTM1NDkiIGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW0gbWFyZ2luLWxlZnQgbWFyZ2luLXJpZ2h0IHBhZGRpbmctdG9wIHBhZGRpbmctYm90dG9tIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9SZXZpZXciPgoJPHNwYW4gaXRlbXByb3A9Iml0ZW1SZXZpZXdlZCIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUHJvZHVjdCI+CgkJPG1ldGEgaXRlbXByb3A9Im5hbWUiIGNvbnRlbnQ9IkV2ZXJlc3QgQmFzZSBDYW1wIFRyZWsgdmlhIFNhbGxlcmkiPgo8c3BhbiBpdGVtcHJvcD0iYWdncmVnYXRlUmF0aW5nIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9BZ2dyZWdhdGVSYXRpbmciPgoJPG1ldGEgaXRlbXByb3A9InJhdGluZ1ZhbHVlIiBjb250ZW50PSIzLjY4Ij4KCTxtZXRhIGl0ZW1wcm9wPSJyZXZpZXdDb3VudCIgY29udGVudD0iMjIiPgo8L3NwYW4+CTwvc3Bhbj4KCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fY29udGFpbmVyIj4KCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2luZm8iPgoJCQk8aW1nIGFsdD0nJyBzcmM9J2h0dHBzOi8vc2VjdXJlLmdyYXZhdGFyLmNvbS9hdmF0YXIvOTAyZDI5MzJmMmM5NDMzYjE2ZGNkOWI4ODhlYmJiNmI/cz0xMjImIzAzODtkPW1tJiMwMzg7cj1nJyBzcmNzZXQ9J2h0dHBzOi8vc2VjdXJlLmdyYXZhdGFyLmNvbS9hdmF0YXIvOTAyZDI5MzJmMmM5NDMzYjE2ZGNkOWI4ODhlYmJiNmI/cz0yNDQmIzAzODtkPW1tJiMwMzg7cj1nIDJ4JyBjbGFzcz0nYXZhdGFyIGF2YXRhci0xMjIgcGhvdG8nIGhlaWdodD0nMTIyJyB3aWR0aD0nMTIyJyBsb2FkaW5nPSdsYXp5JyBkZWNvZGluZz0nYXN5bmMnLz4JCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX25hbWUiIGl0ZW1wcm9wPSJhdXRob3IiIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1BlcnNvbiI+PHNwYW4gaXRlbXByb3A9Im5hbWUiPkh1YmVydFJoaW5lPC9zcGFuPjwvZGl2PgoJCTwvZGl2PgoJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fY29udGVudCI+CgkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fY29udGVudF9fdG9wIj4KCQkJCQkJCQkJCQkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fcmF0aW5nIj48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PC9kaXY+CQkJCQk8c3BhbiBpdGVtcHJvcD0icmV2aWV3UmF0aW5nIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9SYXRpbmciPgoJCQkJCQk8bWV0YSBpdGVtcHJvcD0icmF0aW5nVmFsdWUiIGNvbnRlbnQ9IjIiPgoJCQkJCTwvc3Bhbj4KCQkJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2RhdGUiPk1heSAyNCwgMjAyNDwvZGl2PgoJCQk8L2Rpdj4KCQkJCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX190ZXh0IiBpdGVtcHJvcD0icmV2aWV3Qm9keSI+PHA+QXJjaGV0eXAgbWFya2V0IERhcmsgd2ViPGJyIC8+CjxhIGhyZWY9Imh0dHBzOi8vZ2l0aHViLmNvbS9BcmNoZXR5cG1hcmtldC9saW5rIiByZWw9Im5vZm9sbG93IHVnYyI+QXJjaGV0eXAgTWFya2V0PC9hPjwvcD4KPC9kaXY+CgkJCQkJPC9kaXY+Cgk8L2Rpdj4KPC9kaXY+PCEtLSAjY29tbWVudC0jIyAtLT4KCjxkaXYgaWQ9ImNvbW1lbnQtMzU3NiIgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbSBtYXJnaW4tbGVmdCBtYXJnaW4tcmlnaHQgcGFkZGluZy10b3AgcGFkZGluZy1ib3R0b20iIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1JldmlldyI+Cgk8c3BhbiBpdGVtcHJvcD0iaXRlbVJldmlld2VkIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9Qcm9kdWN0Ij4KCQk8bWV0YSBpdGVtcHJvcD0ibmFtZSIgY29udGVudD0iRXZlcmVzdCBCYXNlIENhbXAgVHJlayB2aWEgU2FsbGVyaSI+CjxzcGFuIGl0ZW1wcm9wPSJhZ2dyZWdhdGVSYXRpbmciIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL0FnZ3JlZ2F0ZVJhdGluZyI+Cgk8bWV0YSBpdGVtcHJvcD0icmF0aW5nVmFsdWUiIGNvbnRlbnQ9IjMuNjgiPgoJPG1ldGEgaXRlbXByb3A9InJldmlld0NvdW50IiBjb250ZW50PSIyMiI+Cjwvc3Bhbj4JPC9zcGFuPgoJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19jb250YWluZXIiPgoJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9faW5mbyI+CgkJCTxpbWcgYWx0PScnIHNyYz0naHR0cHM6Ly9zZWN1cmUuZ3JhdmF0YXIuY29tL2F2YXRhci85MDJkMjkzMmYyYzk0MzNiMTZkY2Q5Yjg4OGViYmI2Yj9zPTEyMiYjMDM4O2Q9bW0mIzAzODtyPWcnIHNyY3NldD0naHR0cHM6Ly9zZWN1cmUuZ3JhdmF0YXIuY29tL2F2YXRhci85MDJkMjkzMmYyYzk0MzNiMTZkY2Q5Yjg4OGViYmI2Yj9zPTI0NCYjMDM4O2Q9bW0mIzAzODtyPWcgMngnIGNsYXNzPSdhdmF0YXIgYXZhdGFyLTEyMiBwaG90bycgaGVpZ2h0PScxMjInIHdpZHRoPScxMjInIGxvYWRpbmc9J2xhenknIGRlY29kaW5nPSdhc3luYycvPgkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fbmFtZSIgaXRlbXByb3A9ImF1dGhvciIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUGVyc29uIj48c3BhbiBpdGVtcHJvcD0ibmFtZSI+SHViZXJ0UmhpbmU8L3NwYW4+PC9kaXY+CgkJPC9kaXY+CgkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19jb250ZW50Ij4KCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19jb250ZW50X190b3AiPgoJCQkJCQkJCQkJCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19yYXRpbmciPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48L2Rpdj4JCQkJCTxzcGFuIGl0ZW1wcm9wPSJyZXZpZXdSYXRpbmciIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1JhdGluZyI+CgkJCQkJCTxtZXRhIGl0ZW1wcm9wPSJyYXRpbmdWYWx1ZSIgY29udGVudD0iMiI+CgkJCQkJPC9zcGFuPgoJCQkJCQkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fZGF0ZSI+TWF5IDI3LCAyMDI0PC9kaXY+CgkJCTwvZGl2PgoJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX3RleHQiIGl0ZW1wcm9wPSJyZXZpZXdCb2R5Ij48cD5BcmNoZXR5cCBtYXJrZXQgRGFyayB3ZWI8YnIgLz4KPGEgaHJlZj0iaHR0cHM6Ly9tZWRpdW0uY29tL0Bjb3J2ZXRiZXMvYXJjaGV0eXAtbWFya2V0LTMxNzdhY2NlNDlmOCIgcmVsPSJub2ZvbGxvdyB1Z2MiPmh0dHBzOi8vbWVkaXVtLmNvbS9AY29ydmV0YmVzL2FyY2hldHlwLW1hcmtldC0zMTc3YWNjZTQ5Zjg8L2E+PC9wPgo8L2Rpdj4KCQkJCQk8L2Rpdj4KCTwvZGl2Pgo8L2Rpdj48IS0tICNjb21tZW50LSMjIC0tPgoKPGRpdiBpZD0iY29tbWVudC0zNTgwIiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtIG1hcmdpbi1sZWZ0IG1hcmdpbi1yaWdodCBwYWRkaW5nLXRvcCBwYWRkaW5nLWJvdHRvbSIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUmV2aWV3Ij4KCTxzcGFuIGl0ZW1wcm9wPSJpdGVtUmV2aWV3ZWQiIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1Byb2R1Y3QiPgoJCTxtZXRhIGl0ZW1wcm9wPSJuYW1lIiBjb250ZW50PSJFdmVyZXN0IEJhc2UgQ2FtcCBUcmVrIHZpYSBTYWxsZXJpIj4KPHNwYW4gaXRlbXByb3A9ImFnZ3JlZ2F0ZVJhdGluZyIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvQWdncmVnYXRlUmF0aW5nIj4KCTxtZXRhIGl0ZW1wcm9wPSJyYXRpbmdWYWx1ZSIgY29udGVudD0iMy42OCI+Cgk8bWV0YSBpdGVtcHJvcD0icmV2aWV3Q291bnQiIGNvbnRlbnQ9IjIyIj4KPC9zcGFuPgk8L3NwYW4+Cgk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRhaW5lciI+CgkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19pbmZvIj4KCQkJPGltZyBhbHQ9Jycgc3JjPSdodHRwczovL3NlY3VyZS5ncmF2YXRhci5jb20vYXZhdGFyLzkzNDQxZWE0ODc2ZGQ4ZTM1NjAzYzFkNGIzNDhjNDczP3M9MTIyJiMwMzg7ZD1tbSYjMDM4O3I9Zycgc3Jjc2V0PSdodHRwczovL3NlY3VyZS5ncmF2YXRhci5jb20vYXZhdGFyLzkzNDQxZWE0ODc2ZGQ4ZTM1NjAzYzFkNGIzNDhjNDczP3M9MjQ0JiMwMzg7ZD1tbSYjMDM4O3I9ZyAyeCcgY2xhc3M9J2F2YXRhciBhdmF0YXItMTIyIHBob3RvJyBoZWlnaHQ9JzEyMicgd2lkdGg9JzEyMicgbG9hZGluZz0nbGF6eScgZGVjb2Rpbmc9J2FzeW5jJy8+CQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19uYW1lIiBpdGVtcHJvcD0iYXV0aG9yIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9QZXJzb24iPjxzcGFuIGl0ZW1wcm9wPSJuYW1lIj5SaWNoYXJkaGlldHM8L3NwYW4+PC9kaXY+CgkJPC9kaXY+CgkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19jb250ZW50Ij4KCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19jb250ZW50X190b3AiPgoJCQkJCQkJCQkJCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19yYXRpbmciPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PC9kaXY+CQkJCQk8c3BhbiBpdGVtcHJvcD0icmV2aWV3UmF0aW5nIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9SYXRpbmciPgoJCQkJCQk8bWV0YSBpdGVtcHJvcD0icmF0aW5nVmFsdWUiIGNvbnRlbnQ9IjQiPgoJCQkJCTwvc3Bhbj4KCQkJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2RhdGUiPk1heSAyNywgMjAyNDwvZGl2PgoJCQk8L2Rpdj4KCQkJCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX190ZXh0IiBpdGVtcHJvcD0icmV2aWV3Qm9keSI+PHA+QW5zcHJlY2hlbiB2b24gW3VybD1odHRwczovL3d3dy5lYmF5LmNvbS9pdG0vMzk1MzA1OTYwODgwL11Db21wcmVzc29yIEJhbGFuY2luZ1svdXJsXSBBbmxpZWdlbiBiZWkgVmlicm9tZXJhPC9wPgo8L2Rpdj4KCQkJCQk8L2Rpdj4KCTwvZGl2Pgo8L2Rpdj48IS0tICNjb21tZW50LSMjIC0tPgoKPGRpdiBpZD0iY29tbWVudC0zNjQzIiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtIG1hcmdpbi1sZWZ0IG1hcmdpbi1yaWdodCBwYWRkaW5nLXRvcCBwYWRkaW5nLWJvdHRvbSIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUmV2aWV3Ij4KCTxzcGFuIGl0ZW1wcm9wPSJpdGVtUmV2aWV3ZWQiIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1Byb2R1Y3QiPgoJCTxtZXRhIGl0ZW1wcm9wPSJuYW1lIiBjb250ZW50PSJFdmVyZXN0IEJhc2UgQ2FtcCBUcmVrIHZpYSBTYWxsZXJpIj4KPHNwYW4gaXRlbXByb3A9ImFnZ3JlZ2F0ZVJhdGluZyIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvQWdncmVnYXRlUmF0aW5nIj4KCTxtZXRhIGl0ZW1wcm9wPSJyYXRpbmdWYWx1ZSIgY29udGVudD0iMy42OCI+Cgk8bWV0YSBpdGVtcHJvcD0icmV2aWV3Q291bnQiIGNvbnRlbnQ9IjIyIj4KPC9zcGFuPgk8L3NwYW4+Cgk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRhaW5lciI+CgkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19pbmZvIj4KCQkJPGltZyBhbHQ9Jycgc3JjPSdodHRwczovL3NlY3VyZS5ncmF2YXRhci5jb20vYXZhdGFyLzkwMmQyOTMyZjJjOTQzM2IxNmRjZDliODg4ZWJiYjZiP3M9MTIyJiMwMzg7ZD1tbSYjMDM4O3I9Zycgc3Jjc2V0PSdodHRwczovL3NlY3VyZS5ncmF2YXRhci5jb20vYXZhdGFyLzkwMmQyOTMyZjJjOTQzM2IxNmRjZDliODg4ZWJiYjZiP3M9MjQ0JiMwMzg7ZD1tbSYjMDM4O3I9ZyAyeCcgY2xhc3M9J2F2YXRhciBhdmF0YXItMTIyIHBob3RvJyBoZWlnaHQ9JzEyMicgd2lkdGg9JzEyMicgbG9hZGluZz0nbGF6eScgZGVjb2Rpbmc9J2FzeW5jJy8+CQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19uYW1lIiBpdGVtcHJvcD0iYXV0aG9yIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9QZXJzb24iPjxzcGFuIGl0ZW1wcm9wPSJuYW1lIj5IdWJlcnRSaGluZTwvc3Bhbj48L2Rpdj4KCQk8L2Rpdj4KCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRlbnQiPgoJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRlbnRfX3RvcCI+CgkJCQkJCQkJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX3JhdGluZyI+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjwvZGl2PgkJCQkJPHNwYW4gaXRlbXByb3A9InJldmlld1JhdGluZyIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUmF0aW5nIj4KCQkJCQkJPG1ldGEgaXRlbXByb3A9InJhdGluZ1ZhbHVlIiBjb250ZW50PSIyIj4KCQkJCQk8L3NwYW4+CgkJCQkJCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19kYXRlIj5NYXkgMzAsIDIwMjQ8L2Rpdj4KCQkJPC9kaXY+CgkJCQkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fdGV4dCIgaXRlbXByb3A9InJldmlld0JvZHkiPjxwPkFyY2hldHlwIG1hcmtldCBEYXJrIHdlYjxiciAvPgo8YSBocmVmPSJodHRwczovL2dpdGh1Yi5jb20vQXJjaGV0eXAtTWFya2V0L0FyY2hldHlwIiByZWw9Im5vZm9sbG93IHVnYyI+aHR0cHM6Ly9naXRodWIuY29tL0FyY2hldHlwLU1hcmtldC9BcmNoZXR5cDwvYT48L3A+CjwvZGl2PgoJCQkJCTwvZGl2PgoJPC9kaXY+CjwvZGl2PjwhLS0gI2NvbW1lbnQtIyMgLS0+Cgo8ZGl2IGlkPSJjb21tZW50LTM3MzEiIGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW0gbWFyZ2luLWxlZnQgbWFyZ2luLXJpZ2h0IHBhZGRpbmctdG9wIHBhZGRpbmctYm90dG9tIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9SZXZpZXciPgoJPHNwYW4gaXRlbXByb3A9Iml0ZW1SZXZpZXdlZCIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUHJvZHVjdCI+CgkJPG1ldGEgaXRlbXByb3A9Im5hbWUiIGNvbnRlbnQ9IkV2ZXJlc3QgQmFzZSBDYW1wIFRyZWsgdmlhIFNhbGxlcmkiPgo8c3BhbiBpdGVtcHJvcD0iYWdncmVnYXRlUmF0aW5nIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9BZ2dyZWdhdGVSYXRpbmciPgoJPG1ldGEgaXRlbXByb3A9InJhdGluZ1ZhbHVlIiBjb250ZW50PSIzLjY4Ij4KCTxtZXRhIGl0ZW1wcm9wPSJyZXZpZXdDb3VudCIgY29udGVudD0iMjIiPgo8L3NwYW4+CTwvc3Bhbj4KCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fY29udGFpbmVyIj4KCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2luZm8iPgoJCQk8aW1nIGFsdD0nJyBzcmM9J2h0dHBzOi8vc2VjdXJlLmdyYXZhdGFyLmNvbS9hdmF0YXIvOTAyZDI5MzJmMmM5NDMzYjE2ZGNkOWI4ODhlYmJiNmI/cz0xMjImIzAzODtkPW1tJiMwMzg7cj1nJyBzcmNzZXQ9J2h0dHBzOi8vc2VjdXJlLmdyYXZhdGFyLmNvbS9hdmF0YXIvOTAyZDI5MzJmMmM5NDMzYjE2ZGNkOWI4ODhlYmJiNmI/cz0yNDQmIzAzODtkPW1tJiMwMzg7cj1nIDJ4JyBjbGFzcz0nYXZhdGFyIGF2YXRhci0xMjIgcGhvdG8nIGhlaWdodD0nMTIyJyB3aWR0aD0nMTIyJyBsb2FkaW5nPSdsYXp5JyBkZWNvZGluZz0nYXN5bmMnLz4JCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX25hbWUiIGl0ZW1wcm9wPSJhdXRob3IiIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1BlcnNvbiI+PHNwYW4gaXRlbXByb3A9Im5hbWUiPkh1YmVydFJoaW5lPC9zcGFuPjwvZGl2PgoJCTwvZGl2PgoJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fY29udGVudCI+CgkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fY29udGVudF9fdG9wIj4KCQkJCQkJCQkJCQkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fcmF0aW5nIj48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PC9kaXY+CQkJCQk8c3BhbiBpdGVtcHJvcD0icmV2aWV3UmF0aW5nIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9SYXRpbmciPgoJCQkJCQk8bWV0YSBpdGVtcHJvcD0icmF0aW5nVmFsdWUiIGNvbnRlbnQ9IjIiPgoJCQkJCTwvc3Bhbj4KCQkJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2RhdGUiPkp1bmUgNCwgMjAyNDwvZGl2PgoJCQk8L2Rpdj4KCQkJCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX190ZXh0IiBpdGVtcHJvcD0icmV2aWV3Qm9keSI+PHA+QXJjaGV0eXAgbWFya2V0PGJyIC8+CjxhIGhyZWY9Imh0dHBzOi8vZ2l0aHViLmNvbS9BcmNoZXR5cC1NYXJrZXQvQXJjaGV0eXAiIHJlbD0ibm9mb2xsb3cgdWdjIj5odHRwczovL2dpdGh1Yi5jb20vQXJjaGV0eXAtTWFya2V0L0FyY2hldHlwPC9hPjwvcD4KPC9kaXY+CgkJCQkJPC9kaXY+Cgk8L2Rpdj4KPC9kaXY+PCEtLSAjY29tbWVudC0jIyAtLT4KCjxkaXYgaWQ9ImNvbW1lbnQtMzczNCIgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbSBtYXJnaW4tbGVmdCBtYXJnaW4tcmlnaHQgcGFkZGluZy10b3AgcGFkZGluZy1ib3R0b20iIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1JldmlldyI+Cgk8c3BhbiBpdGVtcHJvcD0iaXRlbVJldmlld2VkIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9Qcm9kdWN0Ij4KCQk8bWV0YSBpdGVtcHJvcD0ibmFtZSIgY29udGVudD0iRXZlcmVzdCBCYXNlIENhbXAgVHJlayB2aWEgU2FsbGVyaSI+CjxzcGFuIGl0ZW1wcm9wPSJhZ2dyZWdhdGVSYXRpbmciIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL0FnZ3JlZ2F0ZVJhdGluZyI+Cgk8bWV0YSBpdGVtcHJvcD0icmF0aW5nVmFsdWUiIGNvbnRlbnQ9IjMuNjgiPgoJPG1ldGEgaXRlbXByb3A9InJldmlld0NvdW50IiBjb250ZW50PSIyMiI+Cjwvc3Bhbj4JPC9zcGFuPgoJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19jb250YWluZXIiPgoJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9faW5mbyI+CgkJCTxpbWcgYWx0PScnIHNyYz0naHR0cHM6Ly9zZWN1cmUuZ3JhdmF0YXIuY29tL2F2YXRhci8xODQ5MjU1ODE2YTZiM2VjZTM1MTdiODRmNjQ0NjdmZj9zPTEyMiYjMDM4O2Q9bW0mIzAzODtyPWcnIHNyY3NldD0naHR0cHM6Ly9zZWN1cmUuZ3JhdmF0YXIuY29tL2F2YXRhci8xODQ5MjU1ODE2YTZiM2VjZTM1MTdiODRmNjQ0NjdmZj9zPTI0NCYjMDM4O2Q9bW0mIzAzODtyPWcgMngnIGNsYXNzPSdhdmF0YXIgYXZhdGFyLTEyMiBwaG90bycgaGVpZ2h0PScxMjInIHdpZHRoPScxMjInIGxvYWRpbmc9J2xhenknIGRlY29kaW5nPSdhc3luYycvPgkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fbmFtZSIgaXRlbXByb3A9ImF1dGhvciIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUGVyc29uIj48c3BhbiBpdGVtcHJvcD0ibmFtZSI+QmFycmV0dGpldzwvc3Bhbj48L2Rpdj4KCQk8L2Rpdj4KCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRlbnQiPgoJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRlbnRfX3RvcCI+CgkJCQkJCQkJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX3JhdGluZyI+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjwvZGl2PgkJCQkJPHNwYW4gaXRlbXByb3A9InJldmlld1JhdGluZyIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUmF0aW5nIj4KCQkJCQkJPG1ldGEgaXRlbXByb3A9InJhdGluZ1ZhbHVlIiBjb250ZW50PSIyIj4KCQkJCQk8L3NwYW4+CgkJCQkJCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19kYXRlIj5KdW5lIDQsIDIwMjQ8L2Rpdj4KCQkJPC9kaXY+CgkJCQkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fdGV4dCIgaXRlbXByb3A9InJldmlld0JvZHkiPjxwPkdpbXRhZGllbmlvIGF0dmlydWthaSBpciBzdmVpa2luaW1haSBzdSBnaW10YWRpZW5pdTxiciAvPgo8YSBocmVmPSJodHRwOi8vd29sZmVycy5jby5rci9iYnMvYm9hcmQucGhwP2JvX3RhYmxlPWZyZWUmIzAzODt3cl9pZD0xNDM5MTUiIHJlbD0ibm9mb2xsb3cgdWdjIj5odHRwOi8vd29sZmVycy5jby5rci9iYnMvYm9hcmQucGhwP2JvX3RhYmxlPWZyZWUmIzAzODt3cl9pZD0xNDM5MTU8L2E+PC9wPgo8L2Rpdj4KCQkJCQk8L2Rpdj4KCTwvZGl2Pgo8L2Rpdj48IS0tICNjb21tZW50LSMjIC0tPgoKPGRpdiBpZD0iY29tbWVudC0zNzM1IiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtIG1hcmdpbi1sZWZ0IG1hcmdpbi1yaWdodCBwYWRkaW5nLXRvcCBwYWRkaW5nLWJvdHRvbSIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUmV2aWV3Ij4KCTxzcGFuIGl0ZW1wcm9wPSJpdGVtUmV2aWV3ZWQiIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1Byb2R1Y3QiPgoJCTxtZXRhIGl0ZW1wcm9wPSJuYW1lIiBjb250ZW50PSJFdmVyZXN0IEJhc2UgQ2FtcCBUcmVrIHZpYSBTYWxsZXJpIj4KPHNwYW4gaXRlbXByb3A9ImFnZ3JlZ2F0ZVJhdGluZyIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvQWdncmVnYXRlUmF0aW5nIj4KCTxtZXRhIGl0ZW1wcm9wPSJyYXRpbmdWYWx1ZSIgY29udGVudD0iMy42OCI+Cgk8bWV0YSBpdGVtcHJvcD0icmV2aWV3Q291bnQiIGNvbnRlbnQ9IjIyIj4KPC9zcGFuPgk8L3NwYW4+Cgk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRhaW5lciI+CgkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19pbmZvIj4KCQkJPGltZyBhbHQ9Jycgc3JjPSdodHRwczovL3NlY3VyZS5ncmF2YXRhci5jb20vYXZhdGFyLzg3NzQ2MTcwNTUwMDQwZGIyZGI1NzJiYWY1OTQ3NTZhP3M9MTIyJiMwMzg7ZD1tbSYjMDM4O3I9Zycgc3Jjc2V0PSdodHRwczovL3NlY3VyZS5ncmF2YXRhci5jb20vYXZhdGFyLzg3NzQ2MTcwNTUwMDQwZGIyZGI1NzJiYWY1OTQ3NTZhP3M9MjQ0JiMwMzg7ZD1tbSYjMDM4O3I9ZyAyeCcgY2xhc3M9J2F2YXRhciBhdmF0YXItMTIyIHBob3RvJyBoZWlnaHQ9JzEyMicgd2lkdGg9JzEyMicgbG9hZGluZz0nbGF6eScgZGVjb2Rpbmc9J2FzeW5jJy8+CQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19uYW1lIiBpdGVtcHJvcD0iYXV0aG9yIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9QZXJzb24iPjxzcGFuIGl0ZW1wcm9wPSJuYW1lIj5wcHUtcHJvX1Jlcjwvc3Bhbj48L2Rpdj4KCQk8L2Rpdj4KCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRlbnQiPgoJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRlbnRfX3RvcCI+CgkJCQkJCQkJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX3JhdGluZyI+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PC9kaXY+CQkJCQk8c3BhbiBpdGVtcHJvcD0icmV2aWV3UmF0aW5nIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9SYXRpbmciPgoJCQkJCQk8bWV0YSBpdGVtcHJvcD0icmF0aW5nVmFsdWUiIGNvbnRlbnQ9IjMiPgoJCQkJCTwvc3Bhbj4KCQkJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2RhdGUiPkp1bmUgNCwgMjAyNDwvZGl2PgoJCQk8L2Rpdj4KCQkJCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX190ZXh0IiBpdGVtcHJvcD0icmV2aWV3Qm9keSI+PHA+0J3QsNGI0LAg0LrQvtC80LDQvdC00LAg0LrQstCw0LvQuNGE0LjRhtC40YDQvtCy0LDQvdC90YvRhSDQuNGB0L/QvtC70L3QuNGC0LXQu9C10Lkg0LfQsNCy0LXRgNGI0LXQvdCwINC/0L7QtNCw0YLRjCDQstCw0Lwg0L3QvtCy0LDRgtC+0YDRgdC60LjQtSDQv9C+0LTRhdC+0LTRiywg0LrQvtGC0L7RgNGL0LUg0L3QtSDRgtC+0LvRjNC60L4g0YHQvdCw0LHQtNGP0YIg0L/RgNC+0YfQvdGD0Y4g0L7RhdGA0LDQvdGDINC+0YIg0YXQvtC70L7QtNC90YvRhSDQstC+0LfQtNC10LnRgdGC0LLQuNC5LCDQvdC+INC4INC/0L7QtNCw0YDRj9GCINCy0LDRiNC10LzRgyDQttC40LvRjNGOINC+0YDQuNCz0LjQvdCw0LvRjNC90YvQuSDQstC40LQuPGJyIC8+CtCc0Ysg0LTQtdGP0YLQtdC70YzQvdGLINGBINC90L7QstGL0LzQuCDQvNCw0YLQtdGA0LjQsNC70LDQvNC4LCDQvtCx0LXRgdC/0LXRh9C40LLQsNGPINC00L7Qu9Cz0LjQuSDQt9Cw0L/QsNGBINGN0LrRgdC/0LvRg9Cw0YLQsNGG0LjQuCDQuCDQstC10LvQuNC60L7Qu9C10L/QvdGL0LUg0YDQtdC30YPQu9GM0YLQsNGC0YsuINCj0YLQtdC/0LvQtdC90LjQtSDQvdCw0YDRg9C20L3Ri9GFINC/0L7QstC10YDRhdC90L7RgdGC0LXQuSDigJMg0Y3RgtC+INC90LUg0YLQvtC70YzQutC+INGB0LHQtdGA0LXQttC10L3QuNC1INC90LAg0YLQtdC/0LvQtSwg0L3QviDQuCDQt9Cw0LHQvtGC0LvQuNCy0L7RgdGC0Ywg0L4g0L7QutGA0YPQttCw0Y7RidC10Lkg0L/RgNC40YDQvtC00LUuINCt0L3QtdGA0LPQvtGB0L/QsNGB0LDRjtGJ0LjQtSDRgtC10YXQvdC+0LvQvtCz0LjQuCwg0LrQsNC60L7QstGL0LUg0LzRiyDQuNGB0L/QvtC70YzQt9GD0LXQvCwg0YHQv9C+0YHQvtCx0YHRgtCy0YPRjtGCINC90LUg0YLQvtC70YzQutC+INC00L7QvNGDLCDQvdC+INC4INGB0L7RhdGA0LDQvdC10L3QuNGOINC/0YDQuNGA0L7QtNGLLjxiciAvPgrQodCw0LzQvtC1INC/0LXRgNCy0L7QvtGH0LXRgNC10LTQvdC+0LU6IFt1cmw9aHR0cHM6Ly9wcHUtcHJvZi5ydS9d0KDQtdC80L7QvdGCINC00L7QvNC+0LIg0YPRgtC10L/Qu9C10L3QuNC1INGE0LDRgdCw0LTQvtCyWy91cmxdINGDINC90LDRgSDQvtGC0LrRgNGL0LLQsNC10YLRgdGPINCy0YHQtdCz0L4g0L7RgiAxMjUwINGA0YPQsdC70LXQuSDQt9CwINC80LXRgtGAINC60LLQsNC00YDQsNGC0L3Ri9C5ISDQrdGC0L4g0LTQvtGB0YLRg9C/0L3QvtC1INGA0LXRiNC10L3QuNC1LCDQutC+0YLQvtGA0L7QtSDQv9GA0LXQstGA0LDRgtC40YIg0LLQsNGIINC20LjQu9C40YnQtSDQsiDQuNGB0YLQuNC90L3Ri9C5INC00YPRiNC10LLQvdGL0Lkg0YPQs9C+0LvQvtC6INGBINGB0LrRgNC+0LzQvdGL0LzQuCDQt9Cw0YLRgNCw0YLQsNC80LguPGJyIC8+CtCd0LDRiNC4INC/0YDQvtC40LfQstC10LTQtdC90LjRjyDigJMg0Y3RgtC+INC90LUg0LvQuNGI0Ywg0YLQtdC/0LvQvtC40LfQvtC70Y/RhtC40Y8sINGN0YLQviDRgNCw0LfRgNCw0LHQvtGC0LrQsCDQv9C+0LzQtdGJ0LXQvdC40Y8sINCyINCz0LTQtSDQstGB0LUg0YfQu9C10L0g0L/RgNC10LvQvtC80LvRj9C10YIg0LLQsNGIINC70LjRh9C90YvQuSDQvNCw0L3QtdGA0YMuINCc0Ysg0YPRh9GC0LXQvCDQstGB0LUg0LLQsNGI0Lgg0L/RgNC+0YHRjNCx0YssINGH0YLQvtCx0Ysg0L7RgdGD0YnQtdGB0YLQstC40YLRjCDQstCw0Ygg0LTQvtC8INC10YnQtSDQtNC+0L/QvtC70L3QuNGC0LXQu9GM0L3QviDRg9GO0YLQvdGL0Lwg0Lgg0L/RgNC40LLQu9C10LrQsNGC0LXQu9GM0L3Ri9C8LjxiciAvPgrQn9C+0LTRgNC+0LHQvdC10LUg0L3QsCBbdXJsPWh0dHBzOi8vcHB1LXByb2YucnUvXWh0dHA6Ly9wcHUtcHJvZi5ydS9bL3VybF08YnIgLz4K0J3QtSDQvtGC0LrQu9Cw0LTRi9Cy0LDQudGC0LUg0LTQtdC70LAg0L4g0YHQstC+0LXQvCDQutC+0YDQv9GD0YHQtSDQvdCwINC/0L7RgtC+0LwhINCe0LHRgNCw0YnQsNC50YLQtdGB0Ywg0Log0LjRgdC/0L7Qu9C90LjRgtC10LvRj9C8LCDQuCDQvNGLINGB0LTQtdC70LDQtdC8INCy0LDRiCDQtNCy0L7RgNC10YYg0L3QtSDRgtC+0LvRjNC60L4g0YHQvtCz0YDQtdGC0YvQvCwg0L3QviDQuCDQv9C+INC/0L7RgdC70LXQtNC90LXQuSDQvNC+0LTQtS4g0JfQsNC40L3RgtC10YDQtdGB0L7QstCw0LvQuNGB0Yw/INCf0L7QtNGA0L7QsdC90LXQtSDQviDQvdCw0YjQuNGFINC00LXQu9Cw0YUg0LLRiyDQvNC+0LbQtdGC0LUg0YPQt9C90LDRgtGMINC90LAg0YHQsNC50YLQtSDQutC+0LzQv9Cw0L3QuNC4LiDQlNC+0LHRgNC+INC/0L7QttCw0LvQvtCy0LDRgtGMINCyINC/0YDQvtGB0YLRgNCw0L3RgdGC0LLQviDRg9GO0YLQsCDQuCDRg9GA0L7QstC90Y8uPC9wPgo8L2Rpdj4KCQkJCQk8L2Rpdj4KCTwvZGl2Pgo8L2Rpdj48IS0tICNjb21tZW50LSMjIC0tPgoKPGRpdiBpZD0iY29tbWVudC0zNzY4IiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtIG1hcmdpbi1sZWZ0IG1hcmdpbi1yaWdodCBwYWRkaW5nLXRvcCBwYWRkaW5nLWJvdHRvbSIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUmV2aWV3Ij4KCTxzcGFuIGl0ZW1wcm9wPSJpdGVtUmV2aWV3ZWQiIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1Byb2R1Y3QiPgoJCTxtZXRhIGl0ZW1wcm9wPSJuYW1lIiBjb250ZW50PSJFdmVyZXN0IEJhc2UgQ2FtcCBUcmVrIHZpYSBTYWxsZXJpIj4KPHNwYW4gaXRlbXByb3A9ImFnZ3JlZ2F0ZVJhdGluZyIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvQWdncmVnYXRlUmF0aW5nIj4KCTxtZXRhIGl0ZW1wcm9wPSJyYXRpbmdWYWx1ZSIgY29udGVudD0iMy42OCI+Cgk8bWV0YSBpdGVtcHJvcD0icmV2aWV3Q291bnQiIGNvbnRlbnQ9IjIyIj4KPC9zcGFuPgk8L3NwYW4+Cgk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRhaW5lciI+CgkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19pbmZvIj4KCQkJPGltZyBhbHQ9Jycgc3JjPSdodHRwczovL3NlY3VyZS5ncmF2YXRhci5jb20vYXZhdGFyLzkwMmQyOTMyZjJjOTQzM2IxNmRjZDliODg4ZWJiYjZiP3M9MTIyJiMwMzg7ZD1tbSYjMDM4O3I9Zycgc3Jjc2V0PSdodHRwczovL3NlY3VyZS5ncmF2YXRhci5jb20vYXZhdGFyLzkwMmQyOTMyZjJjOTQzM2IxNmRjZDliODg4ZWJiYjZiP3M9MjQ0JiMwMzg7ZD1tbSYjMDM4O3I9ZyAyeCcgY2xhc3M9J2F2YXRhciBhdmF0YXItMTIyIHBob3RvJyBoZWlnaHQ9JzEyMicgd2lkdGg9JzEyMicgbG9hZGluZz0nbGF6eScgZGVjb2Rpbmc9J2FzeW5jJy8+CQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19uYW1lIiBpdGVtcHJvcD0iYXV0aG9yIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9QZXJzb24iPjxzcGFuIGl0ZW1wcm9wPSJuYW1lIj5IdWJlcnRSaGluZTwvc3Bhbj48L2Rpdj4KCQk8L2Rpdj4KCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRlbnQiPgoJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRlbnRfX3RvcCI+CgkJCQkJCQkJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX3JhdGluZyI+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48L2Rpdj4JCQkJCTxzcGFuIGl0ZW1wcm9wPSJyZXZpZXdSYXRpbmciIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1JhdGluZyI+CgkJCQkJCTxtZXRhIGl0ZW1wcm9wPSJyYXRpbmdWYWx1ZSIgY29udGVudD0iNCI+CgkJCQkJPC9zcGFuPgoJCQkJCQkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fZGF0ZSI+SnVuZSA2LCAyMDI0PC9kaXY+CgkJCTwvZGl2PgoJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX3RleHQiIGl0ZW1wcm9wPSJyZXZpZXdCb2R5Ij48cD5UaGUgRWNvbm9taWNzIG9mIEFyY2hldHlwOiBVbmRlcnN0YW5kaW5nIERhcmtuZXQgTWFya2V0IER5bmFtaWNzPGJyIC8+Ck1hcmtldCBEYXJrbmV0IEFzYXA8YnIgLz4KQ3J5cHRvY3VycmVuY2llcyBhbmQgQ29udHJhYmFuZDogVGhlIEZpbmFuY2lhbCBCYWNrYm9uZSBvZiBBcmNoZXR5cCBNYXJrZXQ8YnIgLz4KRm91bmRlZCBpbiAyMDIxLCBBcmNoZXR5cCBxdWlja2x5IGdhaW5lZCBmYW1lIGluIHRoZSBkYXJrbmV0IGNvbW11bml0eS4gSXQgYmVjYW1lIGtub3duIGFzIGEgaHViIGZvciB0aGUgaWxsZWdhbCB0cmFkZSBvZiBkcnVncywgZmFrZSBkb2N1bWVudHMsIGhhY2tpbmcgdG9vbHMgYW5kIGV2ZW4gd2VhcG9ucy4gVGhlIHNpdGUmIzgyMTc7cyBjcmVhdG9ycyBoYXZlIGRlc2lnbmVkIGl0IHRvIGVtdWxhdGUgdGhlIHVzZXIgZXhwZXJpZW5jZSBvZiBtYWpvciBlLWNvbW1lcmNlIHBsYXRmb3JtcywgbWFraW5nIGl0IGFjY2Vzc2libGUgYW5kIGNvbnZlbmllbnQgZm9yIGV2ZXJ5b25lLjxiciAvPgo8YSBocmVmPSJodHRwczovL2dpdGh1Yi5jb20vQXJjaGV0eXAtbWFya2V0cy9BcmNoZXR5cCIgcmVsPSJub2ZvbGxvdyB1Z2MiPmh0dHBzOi8vZ2l0aHViLmNvbS9BcmNoZXR5cC1tYXJrZXRzL0FyY2hldHlwPC9hPjwvcD4KPC9kaXY+CgkJCQkJPC9kaXY+Cgk8L2Rpdj4KPC9kaXY+PCEtLSAjY29tbWVudC0jIyAtLT4KCjxkaXYgaWQ9ImNvbW1lbnQtMTMyMjUiIGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW0gbWFyZ2luLWxlZnQgbWFyZ2luLXJpZ2h0IHBhZGRpbmctdG9wIHBhZGRpbmctYm90dG9tIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9SZXZpZXciPgoJPHNwYW4gaXRlbXByb3A9Iml0ZW1SZXZpZXdlZCIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUHJvZHVjdCI+CgkJPG1ldGEgaXRlbXByb3A9Im5hbWUiIGNvbnRlbnQ9IkV2ZXJlc3QgQmFzZSBDYW1wIFRyZWsgdmlhIFNhbGxlcmkiPgo8c3BhbiBpdGVtcHJvcD0iYWdncmVnYXRlUmF0aW5nIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9BZ2dyZWdhdGVSYXRpbmciPgoJPG1ldGEgaXRlbXByb3A9InJhdGluZ1ZhbHVlIiBjb250ZW50PSIzLjY4Ij4KCTxtZXRhIGl0ZW1wcm9wPSJyZXZpZXdDb3VudCIgY29udGVudD0iMjIiPgo8L3NwYW4+CTwvc3Bhbj4KCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fY29udGFpbmVyIj4KCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2luZm8iPgoJCQk8aW1nIGFsdD0nJyBzcmM9J2h0dHBzOi8vc2VjdXJlLmdyYXZhdGFyLmNvbS9hdmF0YXIvMTk1NzkzODJiMzUyNmUyMWQyYTBkNGZhZjMzNmUxZjI/cz0xMjImIzAzODtkPW1tJiMwMzg7cj1nJyBzcmNzZXQ9J2h0dHBzOi8vc2VjdXJlLmdyYXZhdGFyLmNvbS9hdmF0YXIvMTk1NzkzODJiMzUyNmUyMWQyYTBkNGZhZjMzNmUxZjI/cz0yNDQmIzAzODtkPW1tJiMwMzg7cj1nIDJ4JyBjbGFzcz0nYXZhdGFyIGF2YXRhci0xMjIgcGhvdG8nIGhlaWdodD0nMTIyJyB3aWR0aD0nMTIyJyBsb2FkaW5nPSdsYXp5JyBkZWNvZGluZz0nYXN5bmMnLz4JCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX25hbWUiIGl0ZW1wcm9wPSJhdXRob3IiIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1BlcnNvbiI+PHNwYW4gaXRlbXByb3A9Im5hbWUiPkN1cnRpc2tlZjwvc3Bhbj48L2Rpdj4KCQk8L2Rpdj4KCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRlbnQiPgoJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRlbnRfX3RvcCI+CgkJCQkJCQkJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX3JhdGluZyI+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48L2Rpdj4JCQkJCTxzcGFuIGl0ZW1wcm9wPSJyZXZpZXdSYXRpbmciIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1JhdGluZyI+CgkJCQkJCTxtZXRhIGl0ZW1wcm9wPSJyYXRpbmdWYWx1ZSIgY29udGVudD0iNCI+CgkJCQkJPC9zcGFuPgoJCQkJCQkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fZGF0ZSI+QXByaWwgNCwgMjAyNTwvZGl2PgoJCQk8L2Rpdj4KCQkJCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX190ZXh0IiBpdGVtcHJvcD0icmV2aWV3Qm9keSI+PHA+0KLQtdC90Lgg0KXQuNC80L7QuiDQuCDQm9C+0LHQvdC4IDwvcD4KPHA+0JDQu9C40L3QsCDQv9GA0L7RgdC90YPQu9Cw0YHRjCDQsiDQutGA0L7RiNC10YfQvdC+0Lkg0LrQstCw0YDRgtC40YDQtSDQvdCwINC+0LrRgNCw0LjQvdC1IFt1cmw9aHR0cHM6Ly9wcm9zMS5wcm9zdGl0dXRraW1vc2t2YS54eXovXdCt0YHQutC+0YDRgiDQpdC40LzQutC4Wy91cmxdLjxiciAvPgrQntGCINGA0LXQt9C60L7Qs9C+INGB0LLQtdGC0LAg0YTQvtC90LDRgNGPINC30LAg0YjRgtC+0YDQvtC5INC30LDQu9C+0LzQuNC70L4g0LLQuNGB0LrQuCDigJQg0YHQvdC+0LLQsCDQutC+0YDQvtGC0LrQuNC5INGB0L7QvSDQv9C10YDQtdC0INC90L7Rh9C90L7QuSDRgdC80LXQvdC+0LkuPGJyIC8+CtCe0L3QsCDQt9Cw0YLRj9C90YPQu9Cw0YHRjCDRgdC40LPQsNGA0LXRgtC+0LksINCz0LvRj9C00Y8g0L3QsCDQv9C+0YLRgNC10YHQutCw0LLRiNC40LXRgdGPINC+0LHQvtC4LiDQlNC10L3RjNCz0Lgg0LfQsCDQsNGA0LXQvdC00YMg0LrQvtC/0LjQu9C60Lgg0L3QtSDQttC00LDQu9C4LjxiciAvPgpbdXJsPWh0dHBzOi8vcHJvczEucHJvc3RpdHV0a2lsb2JuamEueHl6L13QrdC60L7RgNGC0L3QuNGG0YMg0JvQvtCx0L3Rj1svdXJsXSDQstGB0YLRgNC10YLQuNC70LAg0LXRkSDRhdC+0LvQvtC00L3Ri9C8INCy0LXRgtGA0L7QvC4g0JfQtNC10YHRjCDQutC70LjQtdC90YLRiyDQsdGL0LvQuCDQv9GA0L7RidC1IOKAlCDQstC+0LTQuNGC0LXQu9C4INGBINGC0YDQsNGB0YHRiywg0L7QtNC40L3QvtC60LjQtSDQvNGD0LbQuNC60Lgg0LjQtyDRgdC/0LDQu9GM0L3Ri9GFINGA0LDQudC+0L3QvtCyLjxiciAvPgrQmNC90L7Qs9C00LAg0LLQtdC30LvQvjog0L/QvtC/0LDQtNCw0LvQuNGB0YwgwqvQsdC70LDQs9C+0LTQsNGA0L3Ri9C1wrssINC+0YHRgtCw0LLQu9GP0LvQuCDRgdCy0LXRgNGF0YMg0L/QsNGA0YMg0YLRi9GB0Y/Rhy4g0J3QviDRh9Cw0YnQtSDigJQg0YLQvtGA0LMsINGF0LDQvNGB0YLQstC+LCDQsCDRgtC+INC4INC60YPQu9Cw0LrQuC48YnIgLz4K0J7QtNC90LDQttC00Ysg0LfQuNC80L7QuSDQtdGRINC30LDQsdGA0LDQu9C4INCyINC+0YLQtNC10LvQtdC90LjQtS4g0JTQvtC/0YDQvtGBLCDRg9C90LjQttC10L3QuNGPLCDQstC30Y/RgtC60LAgwqvQt9CwINC80L7Qu9GH0LDQvdC40LXCuy4g0J/QvtGB0LvQtSDRjdGC0L7Qs9C+INCQ0LvQuNC90LAg0L3QsNGD0YfQuNC70LDRgdGMINC00L7Qs9C+0LLQsNGA0LjQstCw0YLRjNGB0Y8g0LfQsNGA0LDQvdC10LUuPGJyIC8+CtCaINCy0LXRgdC90LUg0L3QsNC60L7Qv9C40LvQsCDQvdCwINCx0LjQu9C10YIg0LIg0KHQvtGH0LguINCc0LXRh9GC0LDQu9CwINC+INC80L7RgNC1LCDRh9C40YHRgtC+0Lwg0L3QtdCx0LUuINCd0L4g0LrQvtCz0LTQsCDQv9GA0LjRiNC70L4g0LLRgNC10LzRjyDRg9C10LfQttCw0YLRjCwg0L7QsdC90LDRgNGD0LbQuNC70LAsINGH0YLQviDQtNCw0LbQtSDRh9C10LzQvtC00LDQvSDRgdC+0LHRgNCw0YLRjCDRgdGC0YDQsNGI0L3Qvi48YnIgLz4KW3VybD1odHRwczovL3Byb3MxLnByb3N0aXR1dGtpbW9za3ZhLnh5ei9d0KXQuNC80LrQuFsvdXJsXSDQuCBbdXJsPWh0dHBzOi8vcHJvczEucHJvc3RpdHV0a2lsb2JuamEueHl6L13Qm9C+0LHQvdGPWy91cmxdINGB0YLQsNC70Lgg0LXRkSDQutC70LXRgtC60L7QuS48YnIgLz4K0JDQu9C40L3QsCDQv9C+0L3Rj9C70LAg0Y3RgtC+LCDRgdGC0L7RjyDQvdCwINC/0LXRgNGA0L7QvdC1LCDQs9C70Y/QtNGPINC90LAg0YPRhdC+0LTRj9GJ0LjQuSDQv9C+0LXQt9C0LiDQkiDQutCw0YDQvNCw0L3QtSDigJQg0L/QsNGH0LrQsCDRgdC80Y/RgtGL0YUg0LrRg9C/0Y7RgC4g0JfQsNCy0YLRgNCwIOKAlCDQvdC+0LLRi9C5INC00LXQvdGMLiDQmCDQvdC+0LLRi9C5INC60LvQuNC10L3Rgi48L3A+CjwvZGl2PgoJCQkJCTwvZGl2PgoJPC9kaXY+CjwvZGl2PjwhLS0gI2NvbW1lbnQtIyMgLS0+Cgo8ZGl2IGlkPSJjb21tZW50LTEzNDg1IiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtIG1hcmdpbi1sZWZ0IG1hcmdpbi1yaWdodCBwYWRkaW5nLXRvcCBwYWRkaW5nLWJvdHRvbSIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUmV2aWV3Ij4KCTxzcGFuIGl0ZW1wcm9wPSJpdGVtUmV2aWV3ZWQiIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1Byb2R1Y3QiPgoJCTxtZXRhIGl0ZW1wcm9wPSJuYW1lIiBjb250ZW50PSJFdmVyZXN0IEJhc2UgQ2FtcCBUcmVrIHZpYSBTYWxsZXJpIj4KPHNwYW4gaXRlbXByb3A9ImFnZ3JlZ2F0ZVJhdGluZyIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvQWdncmVnYXRlUmF0aW5nIj4KCTxtZXRhIGl0ZW1wcm9wPSJyYXRpbmdWYWx1ZSIgY29udGVudD0iMy42OCI+Cgk8bWV0YSBpdGVtcHJvcD0icmV2aWV3Q291bnQiIGNvbnRlbnQ9IjIyIj4KPC9zcGFuPgk8L3NwYW4+Cgk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRhaW5lciI+CgkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19pbmZvIj4KCQkJPGltZyBhbHQ9Jycgc3JjPSdodHRwczovL3NlY3VyZS5ncmF2YXRhci5jb20vYXZhdGFyLzE5NTc5MzgyYjM1MjZlMjFkMmEwZDRmYWYzMzZlMWYyP3M9MTIyJiMwMzg7ZD1tbSYjMDM4O3I9Zycgc3Jjc2V0PSdodHRwczovL3NlY3VyZS5ncmF2YXRhci5jb20vYXZhdGFyLzE5NTc5MzgyYjM1MjZlMjFkMmEwZDRmYWYzMzZlMWYyP3M9MjQ0JiMwMzg7ZD1tbSYjMDM4O3I9ZyAyeCcgY2xhc3M9J2F2YXRhciBhdmF0YXItMTIyIHBob3RvJyBoZWlnaHQ9JzEyMicgd2lkdGg9JzEyMicgbG9hZGluZz0nbGF6eScgZGVjb2Rpbmc9J2FzeW5jJy8+CQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19uYW1lIiBpdGVtcHJvcD0iYXV0aG9yIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9QZXJzb24iPjxzcGFuIGl0ZW1wcm9wPSJuYW1lIj5Bbm5pZURhZzwvc3Bhbj48L2Rpdj4KCQk8L2Rpdj4KCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRlbnQiPgoJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRlbnRfX3RvcCI+CgkJCQkJCQkJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX3JhdGluZyI+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48L2Rpdj4JCQkJCTxzcGFuIGl0ZW1wcm9wPSJyZXZpZXdSYXRpbmciIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1JhdGluZyI+CgkJCQkJCTxtZXRhIGl0ZW1wcm9wPSJyYXRpbmdWYWx1ZSIgY29udGVudD0iMSI+CgkJCQkJPC9zcGFuPgoJCQkJCQkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fZGF0ZSI+QXByaWwgOSwgMjAyNTwvZGl2PgoJCQk8L2Rpdj4KCQkJCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX190ZXh0IiBpdGVtcHJvcD0icmV2aWV3Qm9keSI+PHA+0JHQvtC70YzRiNCw0Y8g0LrQvtC70LvQtdC60YbQuNGPIFt1cmw9aHR0cHM6Ly9raW5vLnh4eC1zaGFyZS50di9d0L/QvtGA0L3QvtGE0LjQu9GM0LzRiyDQvdCwINGA0YPRgdGB0LrQvtC8Wy91cmxdIOKAlCDRgtC+0LvRjNC60L4g0LTQu9GPINCy0LDRgSEgPC9wPgo8cD7QmNGJ0LXRgtC1INC60LDRh9C10YHRgtCy0LXQvdC90YvQtSDQv9C+0LvQvdC+0LzQtdGC0YDQsNC20L3Ri9C1IFt1cmw9aHR0cHM6Ly9raW5vLnh4eC1zaGFyZS50di9nZW5yZS8lRDAlQTElMjAlRDAlQTAlRDElODMlRDElODElRDElODElRDAlQkElRDAlQjglRDAlQkMlMjAlRDAlQkYlRDAlQjUlRDElODAlRDAlQjUlRDAlQjIlRDAlQkUlRDAlQjQlRDAlQkUlRDAlQkNd0L/QvtGA0L3QvtGE0LjQu9GM0LzRiyDRgSDRgNGD0YHRgdC60L7QuSDQvtC30LLRg9GH0LrQvtC5Wy91cmxdPyDQndCw0Ygg0YHQsNC50YIg0L/RgNC10LTQu9Cw0LPQsNC10YIg0LLQsNC8INC70YPRh9GI0YPRjiDQv9C+0LTQsdC+0YDQutGDINCyIEhELdGE0L7RgNC80LDRgtC1INCx0LXQtyDRgNC10LrQu9Cw0LzRiyDQuCDQvtCz0YDQsNC90LjRh9C10L3QuNC5LiA8L3A+CjxwPtCf0L7Rh9C10LzRgyDRgdGC0L7QuNGCINCy0YvQsdGA0LDRgtGMINC90LDRgTo8YnIgLz4K0KLRi9GB0Y/Rh9C4INGE0LjQu9GM0LzQvtCyINGA0LDQt9C90YvRhSDQttCw0L3RgNC+0LI6INC+0YIg0LrQu9Cw0YHRgdC40LrQuCDQtNC+INC/0YDQtdC80YzQtdGALjxiciAvPgpbdXJsPWh0dHBzOi8va2luby54eHgtc2hhcmUudHYvZ2VucmUvTWFyY19Eb3JjZWxd0J/QvtGA0L3QvtGE0LjQu9GM0LzRiyDQnNCw0YDQuiDQlNC+0YDRgdC10LvRjFsvdXJsXTxiciAvPgrQrdC60YHQutC70Y7Qt9C40LLQvdGL0LUg0LzQsNGC0LXRgNC40LDQu9GLLCDQutC+0YLQvtGA0YvRhSDQvdC10YIg0L3QsCDQtNGA0YPQs9C40YUg0L/Qu9Cw0YLRhNC+0YDQvNCw0YUuPGJyIC8+CtCS0YvRgdC+0LrQsNGPINGB0LrQvtGA0L7RgdGC0Ywg0LfQsNCz0YDRg9C30LrQuCDQuCDRgdGC0LDQsdC40LvRjNC90YvQuSDRgdGC0YDQuNC80LjQvdCzINCx0LXQtyDQt9Cw0LTQtdGA0LbQtdC6LjxiciAvPgrQo9C00L7QsdC90YvQuSDQv9GA0L7RgdC80L7RgtGAINC90LAg0LvRjtCx0L7QvCDRg9GB0YLRgNC+0LnRgdGC0LLQtTog0YHQvNCw0YDRgtGE0L7QvSwg0L/Qu9Cw0L3RiNC10YIsINCf0Jog0LjQu9C4INGC0LXQu9C10LLQuNC30L7RgC48YnIgLz4K0JfQsNGA0LXQs9C40YHRgtGA0LjRgNGD0LnRgtC10YHRjCDRgdC10LnRh9Cw0YEg0Lgg0L7RgtC60YDQvtC50YLQtSDQtNC+0YHRgtGD0L8g0Log0L7Qs9GA0L7QvNC90L7QuSDQutC+0LvQu9C10LrRhtC40Lg8YnIgLz4KW3VybD1odHRwczovL2tpbm8ueHh4LXNoYXJlLnR2L2dlbnJlLyVEMCVBMSUyMCVEMSU4MSVEMSU4RSVEMCVCNiVEMCVCNSVEMSU4MiVEMCVCRSVEMCVCQ13Qv9C+0YDQvdC+0YTQuNC70YzQvNGLINGBINGB0Y7QttC10YLQvtC8Wy91cmxdLjwvcD4KPC9kaXY+CgkJCQkJPC9kaXY+Cgk8L2Rpdj4KPC9kaXY+PCEtLSAjY29tbWVudC0jIyAtLT4KCjxkaXYgaWQ9ImNvbW1lbnQtMTM5NzIiIGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW0gbWFyZ2luLWxlZnQgbWFyZ2luLXJpZ2h0IHBhZGRpbmctdG9wIHBhZGRpbmctYm90dG9tIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9SZXZpZXciPgoJPHNwYW4gaXRlbXByb3A9Iml0ZW1SZXZpZXdlZCIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUHJvZHVjdCI+CgkJPG1ldGEgaXRlbXByb3A9Im5hbWUiIGNvbnRlbnQ9IkV2ZXJlc3QgQmFzZSBDYW1wIFRyZWsgdmlhIFNhbGxlcmkiPgo8c3BhbiBpdGVtcHJvcD0iYWdncmVnYXRlUmF0aW5nIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9BZ2dyZWdhdGVSYXRpbmciPgoJPG1ldGEgaXRlbXByb3A9InJhdGluZ1ZhbHVlIiBjb250ZW50PSIzLjY4Ij4KCTxtZXRhIGl0ZW1wcm9wPSJyZXZpZXdDb3VudCIgY29udGVudD0iMjIiPgo8L3NwYW4+CTwvc3Bhbj4KCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fY29udGFpbmVyIj4KCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2luZm8iPgoJCQk8aW1nIGFsdD0nJyBzcmM9J2h0dHBzOi8vc2VjdXJlLmdyYXZhdGFyLmNvbS9hdmF0YXIvMTk1NzkzODJiMzUyNmUyMWQyYTBkNGZhZjMzNmUxZjI/cz0xMjImIzAzODtkPW1tJiMwMzg7cj1nJyBzcmNzZXQ9J2h0dHBzOi8vc2VjdXJlLmdyYXZhdGFyLmNvbS9hdmF0YXIvMTk1NzkzODJiMzUyNmUyMWQyYTBkNGZhZjMzNmUxZjI/cz0yNDQmIzAzODtkPW1tJiMwMzg7cj1nIDJ4JyBjbGFzcz0nYXZhdGFyIGF2YXRhci0xMjIgcGhvdG8nIGhlaWdodD0nMTIyJyB3aWR0aD0nMTIyJyBsb2FkaW5nPSdsYXp5JyBkZWNvZGluZz0nYXN5bmMnLz4JCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX25hbWUiIGl0ZW1wcm9wPSJhdXRob3IiIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1BlcnNvbiI+PHNwYW4gaXRlbXByb3A9Im5hbWUiPk1hcml5YVN0aWNzPC9zcGFuPjwvZGl2PgoJCTwvZGl2PgoJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fY29udGVudCI+CgkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fY29udGVudF9fdG9wIj4KCQkJCQkJCQkJCQkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fcmF0aW5nIj48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjwvZGl2PgkJCQkJPHNwYW4gaXRlbXByb3A9InJldmlld1JhdGluZyIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUmF0aW5nIj4KCQkJCQkJPG1ldGEgaXRlbXByb3A9InJhdGluZ1ZhbHVlIiBjb250ZW50PSI0Ij4KCQkJCQk8L3NwYW4+CgkJCQkJCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19kYXRlIj5BcHJpbCAxOSwgMjAyNTwvZGl2PgoJCQk8L2Rpdj4KCQkJCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX190ZXh0IiBpdGVtcHJvcD0icmV2aWV3Qm9keSI+PHA+0J7QutGD0L3QuNGC0LXRgdGMINCyINC80LjRgCDRgdGC0YDQsNGB0YLQuCDQuCDRjdC60YHRgtGA0LjQvNCwINGBINC70YPRh9GI0LjQvCDRhdC10L3RgtCw0LXQvCDQsiDRgdC10YLQuCEgPC9wPgo8cD7QlNC+0LHRgNC+INC/0L7QttCw0LvQvtCy0LDRgtGMINC90LAgW3VybD1odHRwczovL2gxLmhlbnRhaS14eHgudG9wL13QodC80L7RgtGA0LXRgtGMINCl0LXQvdGC0LDQuSDQvtC90LvQsNC50L1bL3VybF0g4oCUINC40LTQtdCw0LvRjNC90L7QtSDQvNC10YHRgtC+INC00LvRjyDRhtC10L3QuNGC0LXQu9C10Lkg0L7RgtC60YDQvtCy0LXQvdC90YvRhSDQsNC90LjQvNC1LdC40YHRgtC+0YDQuNC5ITxiciAvPgrQoyDQvdCw0YEg0YHQvtCx0YDQsNC90Ysg0YLRi9GB0Y/Rh9C4INGF0LXQvdGC0LDQuS3RgNC+0LvQuNC60L7QsiDQsiBIRC3QutCw0YfQtdGB0YLQstC1OiDQvtGCINC90LXQttC90YvRhSDRgNC+0LzQsNC90YLQuNGH0LXRgdC60LjRhSDRgdGG0LXQvSDQtNC+INC00LXRgNC30LrQuNGFINGE0LDQvdGC0LDQt9C40Lkg0L3QsCDQu9GO0LHQvtC5INCy0LrRg9GBLiA8L3A+CjxwPtCf0L7Rh9C10LzRgyDQstGL0LHQuNGA0LDRjtGCINC90LDRgT88YnIgLz4K0J7Qs9GA0L7QvNC90LDRjyDQutC+0LvQu9C10LrRhtC40Y8gW3VybD1odHRwczovL2gxLmhlbnRhaS14eHgudG9wL211dmlfcnVzLnBocF3QpdC10L3RgtCw0Lkg0L3QsCDRgNGD0YHRgdC60L7QvFsvdXJsXSDigJQg0YLQvtC70YzQutC+INGC0L7Qv9C+0LLRi9C1INGC0LDQudGC0LvRiyDQuCDRgNC10LTQutC40LUg0YDQsNCx0L7RgtGLLjxiciAvPgrQkdC10Lcg0LvQsNCz0L7QsiDQuCDRgNC10LrQu9Cw0LzRiyBbdXJsPWh0dHBzOi8vaDEuaGVudGFpLXh4eC50b3AvdW4tY2Vuei5waHBd0KXQtdC90YLQsNC5INCx0LXQtyDRhtC10L3Qt9GD0YDRi1svdXJsXeKAlCDQvdCw0YHQu9Cw0LbQtNCw0LnRgtC10YHRjCDQv9GA0L7RgdC80L7RgtGA0L7QvCDQsdC10Lcg0YDQsNC30LTRgNCw0LbQsNGO0YnQuNGFINC/0YDQtdGA0YvQstCw0L3QuNC5LjxiciAvPgrQo9C00L7QsdC90YvQuSDQv9C+0LjRgdC6IOKAlCDRgdC+0YDRgtC40YDQvtCy0LrQsCDQv9C+INGC0LXQs9Cw0LwsINC20LDQvdGA0LDQvCDQuCDRgNC10LnRgtC40L3Qs9GDLjxiciAvPgrQldC20LXQtNC90LXQstC90YvQtSDQvtCx0L3QvtCy0LvQtdC90LjRjyDigJQg0L3QvtCy0LjQvdC60Lgg0LrQsNC20LTRi9C5INC00LXQvdGMISA8L3A+CjxwPtCi0L7Qu9GM0LrQviDQtNC70Y8gMTgrIOKAlCDQvtGC0LrRgNC+0LnRgtC1INC00LLQtdGA0Ywg0LIg0LzQuNGAINCx0LXQt9Cz0YDQsNC90LjRh9C90YvRhSDRhNCw0L3RgtCw0LfQuNC5ITwvcD4KPC9kaXY+CgkJCQkJPC9kaXY+Cgk8L2Rpdj4KPC9kaXY+PCEtLSAjY29tbWVudC0jIyAtLT4KCjxkaXYgaWQ9ImNvbW1lbnQtMTYxNTAiIGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW0gbWFyZ2luLWxlZnQgbWFyZ2luLXJpZ2h0IHBhZGRpbmctdG9wIHBhZGRpbmctYm90dG9tIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9SZXZpZXciPgoJPHNwYW4gaXRlbXByb3A9Iml0ZW1SZXZpZXdlZCIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUHJvZHVjdCI+CgkJPG1ldGEgaXRlbXByb3A9Im5hbWUiIGNvbnRlbnQ9IkV2ZXJlc3QgQmFzZSBDYW1wIFRyZWsgdmlhIFNhbGxlcmkiPgo8c3BhbiBpdGVtcHJvcD0iYWdncmVnYXRlUmF0aW5nIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9BZ2dyZWdhdGVSYXRpbmciPgoJPG1ldGEgaXRlbXByb3A9InJhdGluZ1ZhbHVlIiBjb250ZW50PSIzLjY4Ij4KCTxtZXRhIGl0ZW1wcm9wPSJyZXZpZXdDb3VudCIgY29udGVudD0iMjIiPgo8L3NwYW4+CTwvc3Bhbj4KCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fY29udGFpbmVyIj4KCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2luZm8iPgoJCQk8aW1nIGFsdD0nJyBzcmM9J2h0dHBzOi8vc2VjdXJlLmdyYXZhdGFyLmNvbS9hdmF0YXIvMTk1NzkzODJiMzUyNmUyMWQyYTBkNGZhZjMzNmUxZjI/cz0xMjImIzAzODtkPW1tJiMwMzg7cj1nJyBzcmNzZXQ9J2h0dHBzOi8vc2VjdXJlLmdyYXZhdGFyLmNvbS9hdmF0YXIvMTk1NzkzODJiMzUyNmUyMWQyYTBkNGZhZjMzNmUxZjI/cz0yNDQmIzAzODtkPW1tJiMwMzg7cj1nIDJ4JyBjbGFzcz0nYXZhdGFyIGF2YXRhci0xMjIgcGhvdG8nIGhlaWdodD0nMTIyJyB3aWR0aD0nMTIyJyBsb2FkaW5nPSdsYXp5JyBkZWNvZGluZz0nYXN5bmMnLz4JCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX25hbWUiIGl0ZW1wcm9wPSJhdXRob3IiIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1BlcnNvbiI+PHNwYW4gaXRlbXByb3A9Im5hbWUiPkFubmllRGFnPC9zcGFuPjwvZGl2PgoJCTwvZGl2PgoJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fY29udGVudCI+CgkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fY29udGVudF9fdG9wIj4KCQkJCQkJCQkJCQkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fcmF0aW5nIj48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48L2Rpdj4JCQkJCTxzcGFuIGl0ZW1wcm9wPSJyZXZpZXdSYXRpbmciIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1JhdGluZyI+CgkJCQkJCTxtZXRhIGl0ZW1wcm9wPSJyYXRpbmdWYWx1ZSIgY29udGVudD0iMyI+CgkJCQkJPC9zcGFuPgoJCQkJCQkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fZGF0ZSI+SnVuZSA0LCAyMDI1PC9kaXY+CgkJCTwvZGl2PgoJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX3RleHQiIGl0ZW1wcm9wPSJyZXZpZXdCb2R5Ij48cD7QkdC+0LvRjNGI0LDRjyDQutC+0LvQu9C10LrRhtC40Y8gW3VybD1odHRwczovL2tpbm8ueHh4LXNoYXJlLnR2L13Qv9C+0LvQvdC+0LzQtdGC0YDQsNC20L3QvtC1INC/0L7RgNC90L4g0L3QsCDRgNGD0YHRgdC60L7QvFsvdXJsXSDigJQg0YLQvtC70YzQutC+INC00LvRjyDQstCw0YEhIDwvcD4KPHA+0JjRidC10YLQtSDQutCw0YfQtdGB0YLQstC10L3QvdGL0LUg0L/QvtC70L3QvtC80LXRgtGA0LDQttC90YvQtSBbdXJsPWh0dHBzOi8va2luby54eHgtc2hhcmUudHYvZ2VucmUvJUQwJUExJTIwJUQwJUEwJUQxJTgzJUQxJTgxJUQxJTgxJUQwJUJBJUQwJUI4JUQwJUJDJTIwJUQwJUJGJUQwJUI1JUQxJTgwJUQwJUI1JUQwJUIyJUQwJUJFJUQwJUI0JUQwJUJFJUQwJUJDXdC/0L7Qu9C90L7QvNC10YLRgNCw0LbQvdC+0LUg0L/QvtGA0L3QviDRgSDRgNGD0YHRgdC60L7QuSDQvtC30LLRg9GH0LrQvtC5Wy91cmxdPyDQndCw0Ygg0YHQsNC50YIg0L/RgNC10LTQu9Cw0LPQsNC10YIg0LLQsNC8INC70YPRh9GI0YPRjiDQv9C+0LTQsdC+0YDQutGDINCyIEhELdGE0L7RgNC80LDRgtC1INCx0LXQtyDRgNC10LrQu9Cw0LzRiyDQuCDQvtCz0YDQsNC90LjRh9C10L3QuNC5LiA8L3A+CjxwPtCf0L7Rh9C10LzRgyDRgdGC0L7QuNGCINCy0YvQsdGA0LDRgtGMINC90LDRgTo8YnIgLz4K0KLRi9GB0Y/Rh9C4INGE0LjQu9GM0LzQvtCyINGA0LDQt9C90YvRhSDQttCw0L3RgNC+0LI6INC+0YIg0LrQu9Cw0YHRgdC40LrQuCDQtNC+INC/0YDQtdC80YzQtdGALjxiciAvPgpbdXJsPWh0dHBzOi8vZmlsbS54eHgtc2hhcmUudHYvZ2VucmUvUHJpdmF0ZV3Qn9C+0YDQvdC+0YTQuNC70YzQvNGLINGB0YLRg9C00LjRjyBQcml2YXRlWy91cmxdPGJyIC8+Clt1cmw9aHR0cHM6Ly9maWxtLnh4eC1zaGFyZS50di9nZW5yZS9NYXJpby1TYWxpZXJpXdCf0L7RgNC90L7RhNC40LvRjNC80Ysg0YHRgtGD0LTQuNGPINCc0LDRgNC40L4g0KHQsNC70YzQtdGA0LhbL3VybF08YnIgLz4KW3VybD1odHRwczovL2ZpbG0ueHh4LXNoYXJlLnR2L2dlbnJlL0dpcmxmcmllbmRzRmlsbXNd0J/QvtGA0L3QvtGE0LjQu9GM0LzRiyDRgdGC0YPQtNC40Y8gR2lybGZyaWVuZHNGaWxtc1svdXJsXTxiciAvPgrQrdC60YHQutC70Y7Qt9C40LLQvdGL0LUg0LzQsNGC0LXRgNC40LDQu9GLLCDQutC+0YLQvtGA0YvRhSDQvdC10YIg0L3QsCDQtNGA0YPQs9C40YUg0L/Qu9Cw0YLRhNC+0YDQvNCw0YUuPGJyIC8+CtCS0YvRgdC+0LrQsNGPINGB0LrQvtGA0L7RgdGC0Ywg0LfQsNCz0YDRg9C30LrQuCDQuCDRgdGC0LDQsdC40LvRjNC90YvQuSDRgdGC0YDQuNC80LjQvdCzINCx0LXQtyDQt9Cw0LTQtdGA0LbQtdC6LjxiciAvPgrQo9C00L7QsdC90YvQuSDQv9GA0L7RgdC80L7RgtGAINC90LAg0LvRjtCx0L7QvCDRg9GB0YLRgNC+0LnRgdGC0LLQtTog0YHQvNCw0YDRgtGE0L7QvSwg0L/Qu9Cw0L3RiNC10YIsINCf0Jog0LjQu9C4INGC0LXQu9C10LLQuNC30L7RgC48YnIgLz4K0JfQsNGA0LXQs9C40YHRgtGA0LjRgNGD0LnRgtC10YHRjCDRgdC10LnRh9Cw0YEg0Lgg0L7RgtC60YDQvtC50YLQtSDQtNC+0YHRgtGD0L8g0Log0L7Qs9GA0L7QvNC90L7QuSDQutC+0LvQu9C10LrRhtC40Lg8YnIgLz4KW3VybD1odHRwczovL2tpbm8ueHh4LXNoYXJlLnR2L2dlbnJlLyVEMCVBMSUyMCVEMSU4MSVEMSU4RSVEMCVCNiVEMCVCNSVEMSU4MiVEMCVCRSVEMCVCQ13Qv9C+0LvQvdC+0LzQtdGC0YDQsNC20L3QvtC1INC/0L7RgNC90L4g0YEg0YHRjtC20LXRgtC+0LxbL3VybF0uPC9wPgo8L2Rpdj4KCQkJCQk8L2Rpdj4KCTwvZGl2Pgo8L2Rpdj48IS0tICNjb21tZW50LSMjIC0tPgoKPGRpdiBpZD0iY29tbWVudC0xNjYyNiIgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbSBtYXJnaW4tbGVmdCBtYXJnaW4tcmlnaHQgcGFkZGluZy10b3AgcGFkZGluZy1ib3R0b20iIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1JldmlldyI+Cgk8c3BhbiBpdGVtcHJvcD0iaXRlbVJldmlld2VkIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9Qcm9kdWN0Ij4KCQk8bWV0YSBpdGVtcHJvcD0ibmFtZSIgY29udGVudD0iRXZlcmVzdCBCYXNlIENhbXAgVHJlayB2aWEgU2FsbGVyaSI+CjxzcGFuIGl0ZW1wcm9wPSJhZ2dyZWdhdGVSYXRpbmciIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL0FnZ3JlZ2F0ZVJhdGluZyI+Cgk8bWV0YSBpdGVtcHJvcD0icmF0aW5nVmFsdWUiIGNvbnRlbnQ9IjMuNjgiPgoJPG1ldGEgaXRlbXByb3A9InJldmlld0NvdW50IiBjb250ZW50PSIyMiI+Cjwvc3Bhbj4JPC9zcGFuPgoJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19jb250YWluZXIiPgoJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9faW5mbyI+CgkJCTxpbWcgYWx0PScnIHNyYz0naHR0cHM6Ly9zZWN1cmUuZ3JhdmF0YXIuY29tL2F2YXRhci8xOTU3OTM4MmIzNTI2ZTIxZDJhMGQ0ZmFmMzM2ZTFmMj9zPTEyMiYjMDM4O2Q9bW0mIzAzODtyPWcnIHNyY3NldD0naHR0cHM6Ly9zZWN1cmUuZ3JhdmF0YXIuY29tL2F2YXRhci8xOTU3OTM4MmIzNTI2ZTIxZDJhMGQ0ZmFmMzM2ZTFmMj9zPTI0NCYjMDM4O2Q9bW0mIzAzODtyPWcgMngnIGNsYXNzPSdhdmF0YXIgYXZhdGFyLTEyMiBwaG90bycgaGVpZ2h0PScxMjInIHdpZHRoPScxMjInIGxvYWRpbmc9J2xhenknIGRlY29kaW5nPSdhc3luYycvPgkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fbmFtZSIgaXRlbXByb3A9ImF1dGhvciIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUGVyc29uIj48c3BhbiBpdGVtcHJvcD0ibmFtZSI+RG9uYWxkY2x1bWU8L3NwYW4+PC9kaXY+CgkJPC9kaXY+CgkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19jb250ZW50Ij4KCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19jb250ZW50X190b3AiPgoJCQkJCQkJCQkJCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19yYXRpbmciPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PC9kaXY+CQkJCQk8c3BhbiBpdGVtcHJvcD0icmV2aWV3UmF0aW5nIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9SYXRpbmciPgoJCQkJCQk8bWV0YSBpdGVtcHJvcD0icmF0aW5nVmFsdWUiIGNvbnRlbnQ9IjEiPgoJCQkJCTwvc3Bhbj4KCQkJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2RhdGUiPkp1bmUgMTIsIDIwMjU8L2Rpdj4KCQkJPC9kaXY+CgkJCQkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fdGV4dCIgaXRlbXByb3A9InJldmlld0JvZHkiPjxwPtCV0YHQu9C4INCy0Ysg0LvRjtCx0LjRgtC1INC00LjQvdCw0LzQuNGH0L3Ri9C1INGB0YDQsNC20LXQvdC40Y8g0Lgg0YTQuNC70L7RgdC+0YTQuNGOINCx0L7Rjywg0YHRgtC+0LjRgiBbdXJsPWh0dHBzOi8vejEuYW5pbWUtaGQub25saW5lL2RldGVrdGl2L13RgdC80L7RgtGA0LXRgtGMINCw0L3QuNC80LUg0LTQtdGC0LXQutGC0LjQslsvdXJsXSDigJMg0YLQsNC60LjQtSDQutCw0LogwqvQndCw0YDRg9GC0L7CuywgwqvQkdC70LjRh8K7INC40LvQuCDCq9Ca0LjQvNC+0L3QviDQsiDQutC70LXRgtC60YPCuy4g0K3RgtC4INGB0LXRgNC40LDQu9GLINGB0L7Rh9C10YLQsNGO0YIg0LrRgNGD0YLRi9C1INGB0YXQstCw0YLQutC4INGBINCz0LvRg9Cx0L7QutC40LzQuCDRgdGO0LbQtdGC0LDQvNC4LiA8L3A+CjxwPtCf0L7QutC70L7QvdC90LjQutCw0Lwg0LzQuNGB0YLQuNC60Lgg0Lgg0YLQtdC80L3Ri9GFINC40YHRgtC+0YDQuNC5INC/0L7QvdGA0LDQstC40YLRgdGPIFt1cmw9aHR0cHM6Ly96MS5hbmltZS1oZC5vbmxpbmUvZ2FtZXMvXdGB0LzQvtGC0YDQtdGC0Ywg0LDQvdC40LzQtSDQuNCz0YDQsFsvdXJsXS4g0J/QvtC/0YPQu9GP0YDQvdGL0LUg0YLQsNC50YLQu9GLOiDCq9Cl0LXQu9C70YHQuNC90LPCuywgwqvQktCw0LzQv9C40YDRgdC60LjQuSDRgNGL0YbQsNGA0YzCuyDQuCDCq9Ch0LXRgNGM0ZHQt9C90YvQuSDRg9C00LDRgCDQv9C+INGB0YPQtNGM0LHQtcK7LiA8L3A+CjxwPtCU0LvRjyDRgtC10YUsINC60YLQviDQv9GA0LXQtNC/0L7Rh9C40YLQsNC10YIg0YDQvtC80LDQvdGC0LjQutGDINC4INGO0LzQvtGALCDQuNC00LXQsNC70YzQvdC+IFt1cmw9aHR0cHM6Ly96MS5hbmltZS1oZC5vbmxpbmUvaXN0b3JpY2hlc2tpai9d0YHQvNC+0YLRgNC10YLRjCDQsNC90LjQvNC1INC40YHRgtC+0YDQuNGH0LXRgdC60L7QtVsvdXJsXSDigJMg0L3QsNC/0YDQuNC80LXRgCwgwqvQm9GO0LHQvtCy0Ywg0Lgg0L7QsdC80LDQvcK7LCDCq9Cd0LXQstC10YHRgtCwINGH0LDRgNC+0LTQtdGPwrsg0LjQu9C4IMKr0KjQutC+0LvRjNC90YvQuSDRgNC+0LzQsNC90YHCuy4gPC9wPgo8cD7Qm9GO0LHQuNGC0LXQu9GP0Lwg0LPQu9GD0LHQvtC60LjRhSDRjdC80L7RhtC40Lkg0YHRgtC+0LjRgiBbdXJsPWh0dHBzOi8vejEuYW5pbWUtaGQub25saW5lL3NwYWNlL13RgdC80L7RgtGA0LXRgtGMINCw0L3QuNC80LUg0LrQvtGB0LzQvtGBWy91cmxdLiDQqNC10LTQtdCy0YDRiyDQttCw0L3RgNCwOiDCq9Ci0LLQvtGRINC40LzRj8K7LCDCq9Ca0LvQuNC90L7Quiwg0YDQsNGB0YHQtdC60LDRjtGJ0LjQuSDQtNC10LzQvtC90L7QssK7INC4IMKr0JLQvtC70YfQuNC5INC00LXRgtC4INCQ0LzRjSDQuCDQrtC60LjCuy4gPC9wPgo8cD7QkCDQtdGB0LvQuCDQuNGJ0LXRgtC1INC00L7QsdGA0YvQtSDQuCDRgdCy0LXRgtC70YvQtSDQuNGB0YLQvtGA0LjQuCwg0LzQvtC20L3QviBbdXJsPWh0dHBzOi8vejEuYW5pbWUtaGQub25saW5lL2tvbWVkaWphL13RgdC80L7RgtGA0LXRgtGMINCw0L3QuNC80LUg0LrQvtC80LXQtNC40LhbL3VybF0g4oCTIMKr0J/QvtC60LXQvNC+0L3CuywgwqvQldGRINC30L7QstGR0Lwg0KXQuNC60LDRgNGDwrsg0LjQu9C4IMKr0JzQvtC5INGB0L7RgdC10LQg0KLQvtGC0L7RgNC+wrsuIDwvcD4KPHA+0JLRi9Cx0LjRgNCw0LnRgtC1INC20LDQvdGAINC4INC/0L7Qs9GA0YPQttCw0LnRgtC10YHRjCDQsiDRg9Cy0LvQtdC60LDRgtC10LvRjNC90YvQuSDQvNC40YAg0LDQvdC40LzQtSE8L3A+CjwvZGl2PgoJCQkJCTwvZGl2PgoJPC9kaXY+CjwvZGl2PjwhLS0gI2NvbW1lbnQtIyMgLS0+Cgo8ZGl2IGlkPSJjb21tZW50LTE3MjI3IiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtIG1hcmdpbi1sZWZ0IG1hcmdpbi1yaWdodCBwYWRkaW5nLXRvcCBwYWRkaW5nLWJvdHRvbSIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUmV2aWV3Ij4KCTxzcGFuIGl0ZW1wcm9wPSJpdGVtUmV2aWV3ZWQiIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1Byb2R1Y3QiPgoJCTxtZXRhIGl0ZW1wcm9wPSJuYW1lIiBjb250ZW50PSJFdmVyZXN0IEJhc2UgQ2FtcCBUcmVrIHZpYSBTYWxsZXJpIj4KPHNwYW4gaXRlbXByb3A9ImFnZ3JlZ2F0ZVJhdGluZyIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvQWdncmVnYXRlUmF0aW5nIj4KCTxtZXRhIGl0ZW1wcm9wPSJyYXRpbmdWYWx1ZSIgY29udGVudD0iMy42OCI+Cgk8bWV0YSBpdGVtcHJvcD0icmV2aWV3Q291bnQiIGNvbnRlbnQ9IjIyIj4KPC9zcGFuPgk8L3NwYW4+Cgk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRhaW5lciI+CgkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19pbmZvIj4KCQkJPGltZyBhbHQ9Jycgc3JjPSdodHRwczovL3NlY3VyZS5ncmF2YXRhci5jb20vYXZhdGFyLzE5NTc5MzgyYjM1MjZlMjFkMmEwZDRmYWYzMzZlMWYyP3M9MTIyJiMwMzg7ZD1tbSYjMDM4O3I9Zycgc3Jjc2V0PSdodHRwczovL3NlY3VyZS5ncmF2YXRhci5jb20vYXZhdGFyLzE5NTc5MzgyYjM1MjZlMjFkMmEwZDRmYWYzMzZlMWYyP3M9MjQ0JiMwMzg7ZD1tbSYjMDM4O3I9ZyAyeCcgY2xhc3M9J2F2YXRhciBhdmF0YXItMTIyIHBob3RvJyBoZWlnaHQ9JzEyMicgd2lkdGg9JzEyMicgbG9hZGluZz0nbGF6eScgZGVjb2Rpbmc9J2FzeW5jJy8+CQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19uYW1lIiBpdGVtcHJvcD0iYXV0aG9yIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9QZXJzb24iPjxzcGFuIGl0ZW1wcm9wPSJuYW1lIj5SYXF1ZWxHaXBzeTwvc3Bhbj48L2Rpdj4KCQk8L2Rpdj4KCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRlbnQiPgoJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRlbnRfX3RvcCI+CgkJCQkJCQkJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX3JhdGluZyI+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjwvZGl2PgkJCQkJPHNwYW4gaXRlbXByb3A9InJldmlld1JhdGluZyIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUmF0aW5nIj4KCQkJCQkJPG1ldGEgaXRlbXByb3A9InJhdGluZ1ZhbHVlIiBjb250ZW50PSIyIj4KCQkJCQk8L3NwYW4+CgkJCQkJCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19kYXRlIj5KdW5lIDIyLCAyMDI1PC9kaXY+CgkJCTwvZGl2PgoJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX3RleHQiIGl0ZW1wcm9wPSJyZXZpZXdCb2R5Ij48cD5bdXJsPWh0dHBzOi8vdC5tZS9yYWJvdGF2ZG9zdWdlXdCg0LDQsdC+0YLQsCDQtNC70Y8g0LTQtdCy0YPRiNC10LpbL3VybF08YnIgLz4KW3VybD1odHRwczovL3QubWUvaXpfcmFib3RhX2RseWFfZGV2dXNoZWtd0KDQsNCx0L7RgtCwINC00LXQstGD0YjQutCw0LxbL3VybF08L3A+CjwvZGl2PgoJCQkJCTwvZGl2PgoJPC9kaXY+CjwvZGl2PjwhLS0gI2NvbW1lbnQtIyMgLS0+Cgo8ZGl2IGlkPSJjb21tZW50LTE3NjkxIiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtIG1hcmdpbi1sZWZ0IG1hcmdpbi1yaWdodCBwYWRkaW5nLXRvcCBwYWRkaW5nLWJvdHRvbSIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUmV2aWV3Ij4KCTxzcGFuIGl0ZW1wcm9wPSJpdGVtUmV2aWV3ZWQiIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1Byb2R1Y3QiPgoJCTxtZXRhIGl0ZW1wcm9wPSJuYW1lIiBjb250ZW50PSJFdmVyZXN0IEJhc2UgQ2FtcCBUcmVrIHZpYSBTYWxsZXJpIj4KPHNwYW4gaXRlbXByb3A9ImFnZ3JlZ2F0ZVJhdGluZyIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvQWdncmVnYXRlUmF0aW5nIj4KCTxtZXRhIGl0ZW1wcm9wPSJyYXRpbmdWYWx1ZSIgY29udGVudD0iMy42OCI+Cgk8bWV0YSBpdGVtcHJvcD0icmV2aWV3Q291bnQiIGNvbnRlbnQ9IjIyIj4KPC9zcGFuPgk8L3NwYW4+Cgk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRhaW5lciI+CgkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19pbmZvIj4KCQkJPGltZyBhbHQ9Jycgc3JjPSdodHRwczovL3NlY3VyZS5ncmF2YXRhci5jb20vYXZhdGFyLzE5NTc5MzgyYjM1MjZlMjFkMmEwZDRmYWYzMzZlMWYyP3M9MTIyJiMwMzg7ZD1tbSYjMDM4O3I9Zycgc3Jjc2V0PSdodHRwczovL3NlY3VyZS5ncmF2YXRhci5jb20vYXZhdGFyLzE5NTc5MzgyYjM1MjZlMjFkMmEwZDRmYWYzMzZlMWYyP3M9MjQ0JiMwMzg7ZD1tbSYjMDM4O3I9ZyAyeCcgY2xhc3M9J2F2YXRhciBhdmF0YXItMTIyIHBob3RvJyBoZWlnaHQ9JzEyMicgd2lkdGg9JzEyMicgbG9hZGluZz0nbGF6eScgZGVjb2Rpbmc9J2FzeW5jJy8+CQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19uYW1lIiBpdGVtcHJvcD0iYXV0aG9yIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9QZXJzb24iPjxzcGFuIGl0ZW1wcm9wPSJuYW1lIj5Bbm5pZURhZzwvc3Bhbj48L2Rpdj4KCQk8L2Rpdj4KCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRlbnQiPgoJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRlbnRfX3RvcCI+CgkJCQkJCQkJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX3JhdGluZyI+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PC9kaXY+CQkJCQk8c3BhbiBpdGVtcHJvcD0icmV2aWV3UmF0aW5nIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9SYXRpbmciPgoJCQkJCQk8bWV0YSBpdGVtcHJvcD0icmF0aW5nVmFsdWUiIGNvbnRlbnQ9IjMiPgoJCQkJCTwvc3Bhbj4KCQkJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2RhdGUiPkp1bmUgMzAsIDIwMjU8L2Rpdj4KCQkJPC9kaXY+CgkJCQkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fdGV4dCIgaXRlbXByb3A9InJldmlld0JvZHkiPjxwPtCR0L7Qu9GM0YjQsNGPINC60L7Qu9C70LXQutGG0LjRjyBbdXJsPWh0dHBzOi8va2luby54eHgtc2hhcmUudHYvZ2VucmUvJUQwJTk4JUQwJUI3JUQwJUJDJUQwJUI1JUQwJUJEJUQwJUIwXdC/0L7Qu9C90L7QvNC10YLRgNCw0LbQvdC+0LUg0L/QvtGA0L3QviDQvdCwINGA0YPRgdGB0LrQvtC8Wy91cmxdIOKAlCDRgtC+0LvRjNC60L4g0LTQu9GPINCy0LDRgSEgPC9wPgo8cD7QmNGJ0LXRgtC1INC60LDRh9C10YHRgtCy0LXQvdC90YvQtSDQv9C+0LvQvdC+0LzQtdGC0YDQsNC20L3Ri9C1IFt1cmw9aHR0cHM6Ly9raW5vLnh4eC1zaGFyZS50di9nZW5yZS8lRDAlQTElMjAlRDAlQTAlRDElODMlRDElODElRDElODElRDAlQkElRDAlQjglRDAlQkMlMjAlRDAlQkYlRDAlQjUlRDElODAlRDAlQjUlRDAlQjIlRDAlQkUlRDAlQjQlRDAlQkUlRDAlQkNd0L/QvtC70L3QvtC80LXRgtGA0LDQttC90L7QtSDQv9C+0YDQvdC+INGBINGA0YPRgdGB0LrQvtC5INC+0LfQstGD0YfQutC+0LlbL3VybF0/INCd0LDRiCDRgdCw0LnRgiDQv9GA0LXQtNC70LDQs9Cw0LXRgiDQstCw0Lwg0LvRg9GH0YjRg9GOINC/0L7QtNCx0L7RgNC60YMg0LIgSEQt0YTQvtGA0LzQsNGC0LUg0LHQtdC3INGA0LXQutC70LDQvNGLINC4INC+0LPRgNCw0L3QuNGH0LXQvdC40LkuIDwvcD4KPHA+0J/QvtGH0LXQvNGDINGB0YLQvtC40YIg0LLRi9Cx0YDQsNGC0Ywg0L3QsNGBOjxiciAvPgrQotGL0YHRj9GH0Lgg0YTQuNC70YzQvNC+0LIg0YDQsNC30L3Ri9GFINC20LDQvdGA0L7Qsjog0L7RgiDQutC70LDRgdGB0LjQutC4INC00L4g0L/RgNC10LzRjNC10YAuPGJyIC8+Clt1cmw9aHR0cHM6Ly9raW5vLnh4eC1zaGFyZS50di9nZW5yZS9Qcml2YXRlXdCf0L7RgNC90L7RhNC40LvRjNC80Ysg0YHRgtGD0LTQuNGPIFByaXZhdGVbL3VybF08YnIgLz4KW3VybD1odHRwczovL2tpbm8ueHh4LXNoYXJlLnR2L2dlbnJlL01hcmlvLVNhbGllcmld0J/QvtGA0L3QvtGE0LjQu9GM0LzRiyDRgdGC0YPQtNC40Y8g0JzQsNGA0LjQviDQodCw0LvRjNC10YDQuFsvdXJsXTxiciAvPgpbdXJsPWh0dHBzOi8va2luby54eHgtc2hhcmUudHYvZ2VucmUvR2lybGZyaWVuZHNGaWxtc13Qn9C+0YDQvdC+0YTQuNC70YzQvNGLINGB0YLRg9C00LjRjyBHaXJsZnJpZW5kc0ZpbG1zWy91cmxdPGJyIC8+CtCt0LrRgdC60LvRjtC30LjQstC90YvQtSDQvNCw0YLQtdGA0LjQsNC70YssINC60L7RgtC+0YDRi9GFINC90LXRgiDQvdCwINC00YDRg9Cz0LjRhSDQv9C70LDRgtGE0L7RgNC80LDRhS48YnIgLz4K0JLRi9GB0L7QutCw0Y8g0YHQutC+0YDQvtGB0YLRjCDQt9Cw0LPRgNGD0LfQutC4INC4INGB0YLQsNCx0LjQu9GM0L3Ri9C5INGB0YLRgNC40LzQuNC90LMg0LHQtdC3INC30LDQtNC10YDQttC10LouPGJyIC8+CtCj0LTQvtCx0L3Ri9C5INC/0YDQvtGB0LzQvtGC0YAg0L3QsCDQu9GO0LHQvtC8INGD0YHRgtGA0L7QudGB0YLQstC1OiDRgdC80LDRgNGC0YTQvtC9LCDQv9C70LDQvdGI0LXRgiwg0J/QmiDQuNC70Lgg0YLQtdC70LXQstC40LfQvtGALjxiciAvPgrQl9Cw0YDQtdCz0LjRgdGC0YDQuNGA0YPQudGC0LXRgdGMINGB0LXQudGH0LDRgSDQuCDQvtGC0LrRgNC+0LnRgtC1INC00L7RgdGC0YPQvyDQuiDQvtCz0YDQvtC80L3QvtC5INC60L7Qu9C70LXQutGG0LjQuDxiciAvPgpbdXJsPWh0dHBzOi8va2luby54eHgtc2hhcmUudHYvZ2VucmUvJUQwJUExJTIwJUQxJTgxJUQxJThFJUQwJUI2JUQwJUI1JUQxJTgyJUQwJUJFJUQwJUJDXdC/0L7Qu9C90L7QvNC10YLRgNCw0LbQvdC+0LUg0L/QvtGA0L3QviDRgSDRgdGO0LbQtdGC0L7QvFsvdXJsXS48L3A+CjwvZGl2PgoJCQkJCTwvZGl2PgoJPC9kaXY+CjwvZGl2PjwhLS0gI2NvbW1lbnQtIyMgLS0+Cgo8ZGl2IGlkPSJjb21tZW50LTE4MzI1IiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtIG1hcmdpbi1sZWZ0IG1hcmdpbi1yaWdodCBwYWRkaW5nLXRvcCBwYWRkaW5nLWJvdHRvbSIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUmV2aWV3Ij4KCTxzcGFuIGl0ZW1wcm9wPSJpdGVtUmV2aWV3ZWQiIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1Byb2R1Y3QiPgoJCTxtZXRhIGl0ZW1wcm9wPSJuYW1lIiBjb250ZW50PSJFdmVyZXN0IEJhc2UgQ2FtcCBUcmVrIHZpYSBTYWxsZXJpIj4KPHNwYW4gaXRlbXByb3A9ImFnZ3JlZ2F0ZVJhdGluZyIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvQWdncmVnYXRlUmF0aW5nIj4KCTxtZXRhIGl0ZW1wcm9wPSJyYXRpbmdWYWx1ZSIgY29udGVudD0iMy42OCI+Cgk8bWV0YSBpdGVtcHJvcD0icmV2aWV3Q291bnQiIGNvbnRlbnQ9IjIyIj4KPC9zcGFuPgk8L3NwYW4+Cgk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRhaW5lciI+CgkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19pbmZvIj4KCQkJPGltZyBhbHQ9Jycgc3JjPSdodHRwczovL3NlY3VyZS5ncmF2YXRhci5jb20vYXZhdGFyLzE5NTc5MzgyYjM1MjZlMjFkMmEwZDRmYWYzMzZlMWYyP3M9MTIyJiMwMzg7ZD1tbSYjMDM4O3I9Zycgc3Jjc2V0PSdodHRwczovL3NlY3VyZS5ncmF2YXRhci5jb20vYXZhdGFyLzE5NTc5MzgyYjM1MjZlMjFkMmEwZDRmYWYzMzZlMWYyP3M9MjQ0JiMwMzg7ZD1tbSYjMDM4O3I9ZyAyeCcgY2xhc3M9J2F2YXRhciBhdmF0YXItMTIyIHBob3RvJyBoZWlnaHQ9JzEyMicgd2lkdGg9JzEyMicgbG9hZGluZz0nbGF6eScgZGVjb2Rpbmc9J2FzeW5jJy8+CQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19uYW1lIiBpdGVtcHJvcD0iYXV0aG9yIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9QZXJzb24iPjxzcGFuIGl0ZW1wcm9wPSJuYW1lIj5EdXN0aW52YXRseTwvc3Bhbj48L2Rpdj4KCQk8L2Rpdj4KCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRlbnQiPgoJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRlbnRfX3RvcCI+CgkJCQkJCQkJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX3JhdGluZyI+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48L2Rpdj4JCQkJCTxzcGFuIGl0ZW1wcm9wPSJyZXZpZXdSYXRpbmciIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1JhdGluZyI+CgkJCQkJCTxtZXRhIGl0ZW1wcm9wPSJyYXRpbmdWYWx1ZSIgY29udGVudD0iMSI+CgkJCQkJPC9zcGFuPgoJCQkJCQkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fZGF0ZSI+SnVseSAxMCwgMjAyNTwvZGl2PgoJCQk8L2Rpdj4KCQkJCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX190ZXh0IiBpdGVtcHJvcD0icmV2aWV3Qm9keSI+PHA+W3VybD1odHRwczovL3oxLmFuaW1lLWhkLm9ubGluZS9hbmltZS1zZXJpYWxzLzg0MTItemFwcmVzY2hlbm55ai1rcm90LTIwMjUuaHRtbF3QsNC90LjQvNC1INCX0LDQv9GA0LXRidGR0L3QvdGL0Lkg0LrRgNC+0YJbL3VybF08YnIgLz4KW3VybD1odHRwczovL3oxLmFuaW1lLWhkLm9ubGluZS9hbmltZS1zZXJpYWxzLzg0MTMtZ2Vyb2otdi1vYm1vcm9rZS1pLXByaW5jZXNzeS11YmlqY3ktMjAyNS5odG1sXdCT0LXRgNC+0Lkg0LIg0L7QsdC80L7RgNC+0LrQtSDQuCDQv9GA0LjQvdGG0LXRgdGB0Yst0YPQsdC40LnRhtGLWy91cmxdPGJyIC8+Clt1cmw9aHR0cHM6Ly96MS5hbmltZS1oZC5vbmxpbmUvYW5pbWUtc2VyaWFscy84NDE0LWRyYWdvY2Vubm9zdGktcnVyaS0yMDI1Lmh0bWxd0JTRgNCw0LPQvtGG0LXQvdC90L7RgdGC0Lgg0KDRg9GA0Lgg0YHQvNC+0YLRgNC10YLRjCDQsNC90LjQvNC1Wy91cmxdPGJyIC8+Clt1cmw9aHR0cHM6Ly96MS5hbmltZS1oZC5vbmxpbmUvYW5pbWUtc2VyaWFscy84NDE1LW1hZy12b2R5LTIwMjUuaHRtbF3QnNCw0LMg0LLQvtC00Ysg0YHQvNC+0YLRgNC10YLRjCDQsNC90LjQvNC1Wy91cmxdPGJyIC8+Clt1cmw9aHR0cHM6Ly96MS5hbmltZS1oZC5vbmxpbmUvYW5pbWUtc2VyaWFscy84NDE2LWFwb2thbGlwc2lzLW1pbm9ncnktMjAyNS5odG1sXdCw0L3QuNC80LUg0JDQv9C+0LrQsNC70LjQv9GB0LjRgSDQnNC40L3QvtCz0YDRi1svdXJsXTxiciAvPgpbdXJsPWh0dHBzOi8vejEuYW5pbWUtaGQub25saW5lL2FuaW1lLXNlcmlhbHMvODQzMS1uZW9iamF0bnlqLW9rZWFuLXR2LTItMjAyNS5odG1sXdCd0LXQvtCx0YrRj9GC0L3Ri9C5INC+0LrQtdCw0L0gMiDRgdC10LfQvtC9Wy91cmxdPGJyIC8+Clt1cmw9aHR0cHM6Ly96MS5hbmltZS1oZC5vbmxpbmUvYW5pbWUtc2VyaWFscy84NDM5LXZvc2hvemhkZW5pZS1nZXJvamEtc2NoaXRhLXR2LTQtMjAyNS5odG1sXdCS0L7RgdGF0L7QttC00LXQvdC40LUg0JPQtdGA0L7RjyDRidC40YLQsCA0INGB0LXQt9C+0L1bL3VybF08YnIgLz4KW3VybD1odHRwczovL3oxLmFuaW1lLWhkLm9ubGluZS9hbmltZS1zZXJpYWxzLzg0NDAtamEtcGVyZXZvcGxvdGlsc2phLXYtc2VkbW9nby1wcmluY2EtdHYtMi0yMDI0Lmh0bWxd0K8g0L/QtdGA0LXQstC+0L/Qu9C+0YLQuNC70YHRjyDQsiDRgdC10LTRjNC80L7Qs9C+INC/0YDQuNC90YbQsCAyINGB0LXQt9C+0L1bL3VybF08YnIgLz4KW3VybD1odHRwczovL3oxLmFuaW1lLWhkLm9ubGluZS9hbmltZS1zZXJpYWxzLzg0NDItcGFudGktc3Rva2luZy1pLWdhcnRlcmJlbHQtMi0yMDI1Lmh0bWxd0J/QsNC90YLQuCwg0KHRgtC+0LrQuNC90LMg0Lgg0JPQsNGA0YLQtdGA0LHQtdC70YIgMiDRgdC10LfQvtC9Wy91cmxdPGJyIC8+Clt1cmw9aHR0cHM6Ly96MS5hbmltZS1oZC5vbmxpbmUvYW5pbWUtc2VyaWFscy84NDQzLXZvem1lemRpZS1yYW5lbm9qLXN2amF0b2otMjAyNS5odG1sXdCS0L7Qt9C80LXQt9C00LjQtSDRgNCw0L3QtdC90L7QuSDRgdCy0Y/RgtC+0Lkg0LDQvdC40LzQtVsvdXJsXTxiciAvPgpbdXJsPWh0dHBzOi8vejEuYW5pbWUtaGQub25saW5lL2FuaW1lLXNlcmlhbHMvODQ0MS10cmktc2VzdHJ5LW1pa2Fkb25vLW9rYXphbGlzLW5lb3poaWRhbm5vLXByb3N0eW1pLTIwMjUuaHRtbF3QotGA0Lgg0YHQtdGB0YLRgNGLINCc0LjQutCw0LTQvtC90L4g0L7QutCw0LfQsNC70LjRgdGMINC90LXQvtC20LjQtNCw0L3QvdC+INC/0YDQvtGB0YLRi9C80LhbL3VybF08YnIgLz4KW3VybD1odHRwczovL3oxLmFuaW1lLWhkLm9ubGluZS9hbmltZS1zZXJpYWxzLzg0NDQtZG9rdG9yLXN0b3VuLXR2LTQtY2hhc3QtMi0yMDI1Lmh0bWxd0JTQvtC60YLQvtGAINCh0YLQvtGD0L0gNCDRgdC10LfQvtC9IDIg0YfQsNGB0YLRjFsvdXJsXTxiciAvPgpbdXJsPWh0dHBzOi8vejEuYW5pbWUtaGQub25saW5lL2FuaW1lLXNlcmlhbHMvODQ0NS1sZXZpYWZhbi0yMDI1Lmh0bWxd0JvQtdCy0LjQsNGE0LDQvSDQsNC90LjQvNC1Wy91cmxdPGJyIC8+Clt1cmw9aHR0cHM6Ly96MS5hbmltZS1oZC5vbmxpbmUvYW5pbWUtc2VyaWFscy84NDQ2LXNvbG8ta2VtcGluZy1uYS1kdm9paC0yMDI1Lmh0bWxd0KHQvtC70L4t0LrQtdC80L/QuNC90LMg0L3QsCDQtNCy0L7QuNGFINCw0L3QuNC80LVbL3VybF08YnIgLz4KW3VybD1odHRwczovL3oxLmFuaW1lLWhkLm9ubGluZS9hbmltZS1zZXJpYWxzLzg0MDItcGxvaGFqYS1kZXZvY2hrYS0yMDI1Lmh0bWxd0J/Qu9C+0YXQsNGPINC00LXQstC+0YfQutCwINGB0LzQvtGC0YDQtdGC0Ywg0LDQvdC40LzQtVsvdXJsXTxiciAvPgpbdXJsPWh0dHBzOi8vejEuYW5pbWUtaGQub25saW5lL2FuaW1lLXNlcmlhbHMvODM5NS1wZXNuLW5vY2hueWgtc292LXR2LTItMjAyNS5odG1sXdCf0LXRgdC90Ywg0L3QvtGH0L3Ri9GFINGB0L7QsiAyINGB0LXQt9C+0L1bL3VybF08L3A+CjwvZGl2PgoJCQkJCTwvZGl2PgoJPC9kaXY+CjwvZGl2PjwhLS0gI2NvbW1lbnQtIyMgLS0+Cgo8ZGl2IGlkPSJjb21tZW50LTE4ODM3IiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtIG1hcmdpbi1sZWZ0IG1hcmdpbi1yaWdodCBwYWRkaW5nLXRvcCBwYWRkaW5nLWJvdHRvbSIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUmV2aWV3Ij4KCTxzcGFuIGl0ZW1wcm9wPSJpdGVtUmV2aWV3ZWQiIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1Byb2R1Y3QiPgoJCTxtZXRhIGl0ZW1wcm9wPSJuYW1lIiBjb250ZW50PSJFdmVyZXN0IEJhc2UgQ2FtcCBUcmVrIHZpYSBTYWxsZXJpIj4KPHNwYW4gaXRlbXByb3A9ImFnZ3JlZ2F0ZVJhdGluZyIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvQWdncmVnYXRlUmF0aW5nIj4KCTxtZXRhIGl0ZW1wcm9wPSJyYXRpbmdWYWx1ZSIgY29udGVudD0iMy42OCI+Cgk8bWV0YSBpdGVtcHJvcD0icmV2aWV3Q291bnQiIGNvbnRlbnQ9IjIyIj4KPC9zcGFuPgk8L3NwYW4+Cgk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2NvbnRhaW5lciI+CgkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19pbmZvIj4KCQkJPGltZyBhbHQ9Jycgc3JjPSdodHRwczovL3NlY3VyZS5ncmF2YXRhci5jb20vYXZhdGFyLzE5NTc5MzgyYjM1MjZlMjFkMmEwZDRmYWYzMzZlMWYyP3M9MTIyJiMwMzg7ZD1tbSYjMDM4O3I9Zycgc3Jjc2V0PSdodHRwczovL3NlY3VyZS5ncmF2YXRhci5jb20vYXZhdGFyLzE5NTc5MzgyYjM1MjZlMjFkMmEwZDRmYWYzMzZlMWYyP3M9MjQ0JiMwMzg7ZD1tbSYjMDM4O3I9ZyAyeCcgY2xhc3M9J2F2YXRhciBhdmF0YXItMTIyIHBob3RvJyBoZWlnaHQ9JzEyMicgd2lkdGg9JzEyMicgbG9hZGluZz0nbGF6eScgZGVjb2Rpbmc9J2FzeW5jJy8+CQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19uYW1lIiBpdGVtcHJvcD0iYXV0aG9yIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9QZXJzb24iPjxzcGFuIGl0ZW1wcm9wPSJuYW1lIj5XaWxsaWFtQmVtPC9zcGFuPjwvZGl2PgoJCTwvZGl2PgoJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fY29udGVudCI+CgkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fY29udGVudF9fdG9wIj4KCQkJCQkJCQkJCQkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fcmF0aW5nIj48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjwvZGl2PgkJCQkJPHNwYW4gaXRlbXByb3A9InJldmlld1JhdGluZyIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUmF0aW5nIj4KCQkJCQkJPG1ldGEgaXRlbXByb3A9InJhdGluZ1ZhbHVlIiBjb250ZW50PSIxIj4KCQkJCQk8L3NwYW4+CgkJCQkJCQkJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19kYXRlIj5KdWx5IDE4LCAyMDI1PC9kaXY+CgkJCTwvZGl2PgoJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX3RleHQiIGl0ZW1wcm9wPSJyZXZpZXdCb2R5Ij48cD5bdXJsPWh0dHBzOi8vaDEuaGVudGFpLXh4eC50b3AvYW5pbWUucGhwP2lkPTY2MF3RhdC10L3RgtCw0Lkg0J3QsNGH0LDQu9GM0L3QuNGG0LAsINC60L7RgtC+0YDQsNGPINC80L3QtSDQvdGA0LDQstC40YLRgdGPLCDQsdGL0LvQsCDRg9Cy0LXQtNC10L3QsCDQvNGD0LbRh9C40L3QvtC5INGBINC90LXQstC10YDQvtGP0YLQvdC+0Lkg0LLRi9C90L7RgdC70LjQstC+0YHRgtGM0Y4g0L3QsCDRgdC+0YHQtdC00L3QtdC5INC60YDQvtCy0LDRgtC4INCy0L4g0LLRgNC10LzRjyDRgdC+0LLQvNC10YHRgtC90L7QuSDQutC+0LzQsNC90LTQuNGA0L7QstC60LhbL3VybF08YnIgLz4KW3VybD1odHRwczovL2gxLmhlbnRhaS14eHgudG9wL2FuaW1lLnBocD9pZD02NjFd0YXQtdC90YLQsNC5INCU0LXQstGD0YjQutCwINC/0L4g0YHQvtGB0LXQtNGB0YLQstGDWy91cmxdPGJyIC8+Clt1cmw9aHR0cHM6Ly9oMS5oZW50YWkteHh4LnRvcC9hbmltZS5waHA/aWQ9NjYyXdGF0LXQvdGC0LDQuSDQn9GA0LjQutC70Y7Rh9C10L3QuNGPINC+0YLQstCw0LbQvdC+0Lkg0LTQtdCy0L7Rh9C60Lgg0L/QvtC00L7RiNC70Lgg0Log0LrQvtC90YbRgyFbL3VybF08YnIgLz4KW3VybD1odHRwczovL2gxLmhlbnRhaS14eHgudG9wL2FuaW1lLnBocD9pZD02NjNd0YXQtdC90YLQsNC5INCa0LDQvdC+0YfQuCwg0L3QtSDQstC10YDQvdCw0Y8g0YHQtdC80YzRj1svdXJsXTxiciAvPgpbdXJsPWh0dHBzOi8vaDEuaGVudGFpLXh4eC50b3AvYW5pbWUucGhwP2lkPTY2NF3RhdC10L3RgtCw0Lkg0JbQuNC30L3RjCDRgSDQtNC10LLRg9GI0LrQvtC5INC80L7QvdGB0YLRgNC+0LwgNCB+INCU0LXQstGD0YjQutCwLdGC0LDQvdGD0LrQuCDQn9C+0LrQvtGA0LAgflsvdXJsXTxiciAvPgpbdXJsPWh0dHBzOi8vaDEuaGVudGFpLXh4eC50b3AvYW5pbWUucGhwP2lkPTY2NV3RhdC10L3RgtCw0Lkg0JHRgNCw0Log0LTQviDQsdC10YDQtdC80LXQvdC90L7RgdGC0LhbL3VybF08YnIgLz4KW3VybD1odHRwczovL2gxLmhlbnRhaS14eHgudG9wL2FuaW1lLnBocD9pZD02NjZd0YXQtdC90YLQsNC5INCU0LjRgdGG0LjQv9C70LjQvdCw0YDQvdGL0Lkg0LrQvtC80LjRgtC10YIg0Lgg0YHQtdC60YHRg9Cw0LvRjNC90YvQtVsvdXJsXTxiciAvPgpbdXJsPWh0dHBzOi8vaDEuaGVudGFpLXh4eC50b3AvYW5pbWUucGhwP2lkPTY2N13RhdC10L3RgtCw0Lkg0J/Qu9C+0YLRgdC60LjQtSDRgdCw0LTRi1svdXJsXTxiciAvPgpbdXJsPWh0dHBzOi8vaDEuaGVudGFpLXh4eC50b3AvYW5pbWUucGhwP2lkPTY2OF3RhdC10L3RgtCw0Lkg0KHQu9Cw0LTQutC+0LUg0LjRgdC60YPRiNC10L3QuNC1Wy91cmxdPGJyIC8+Clt1cmw9aHR0cHM6Ly9oMS5oZW50YWkteHh4LnRvcC9hbmltZS5waHA/aWQ9NjY5XdGF0LXQvdGC0LDQuSDQrdCy0YDQuCDigJQg0L3QtSDRgdC10LrRgdCw0YDQvtC40LQhWy91cmxdPC9wPgo8L2Rpdj4KCQkJCQk8L2Rpdj4KCTwvZGl2Pgo8L2Rpdj48IS0tICNjb21tZW50LSMjIC0tPgoKPGRpdiBpZD0iY29tbWVudC0xOTI1NyIgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbSBtYXJnaW4tbGVmdCBtYXJnaW4tcmlnaHQgcGFkZGluZy10b3AgcGFkZGluZy1ib3R0b20iIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL1JldmlldyI+Cgk8c3BhbiBpdGVtcHJvcD0iaXRlbVJldmlld2VkIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9Qcm9kdWN0Ij4KCQk8bWV0YSBpdGVtcHJvcD0ibmFtZSIgY29udGVudD0iRXZlcmVzdCBCYXNlIENhbXAgVHJlayB2aWEgU2FsbGVyaSI+CjxzcGFuIGl0ZW1wcm9wPSJhZ2dyZWdhdGVSYXRpbmciIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cHM6Ly9zY2hlbWEub3JnL0FnZ3JlZ2F0ZVJhdGluZyI+Cgk8bWV0YSBpdGVtcHJvcD0icmF0aW5nVmFsdWUiIGNvbnRlbnQ9IjMuNjgiPgoJPG1ldGEgaXRlbXByb3A9InJldmlld0NvdW50IiBjb250ZW50PSIyMiI+Cjwvc3Bhbj4JPC9zcGFuPgoJPGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19pdGVtX19jb250YWluZXIiPgoJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9faW5mbyI+CgkJCTxpbWcgYWx0PScnIHNyYz0naHR0cHM6Ly9zZWN1cmUuZ3JhdmF0YXIuY29tL2F2YXRhci8xOTU3OTM4MmIzNTI2ZTIxZDJhMGQ0ZmFmMzM2ZTFmMj9zPTEyMiYjMDM4O2Q9bW0mIzAzODtyPWcnIHNyY3NldD0naHR0cHM6Ly9zZWN1cmUuZ3JhdmF0YXIuY29tL2F2YXRhci8xOTU3OTM4MmIzNTI2ZTIxZDJhMGQ0ZmFmMzM2ZTFmMj9zPTI0NCYjMDM4O2Q9bW0mIzAzODtyPWcgMngnIGNsYXNzPSdhdmF0YXIgYXZhdGFyLTEyMiBwaG90bycgaGVpZ2h0PScxMjInIHdpZHRoPScxMjInIGxvYWRpbmc9J2xhenknIGRlY29kaW5nPSdhc3luYycvPgkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fbmFtZSIgaXRlbXByb3A9ImF1dGhvciIgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwczovL3NjaGVtYS5vcmcvUGVyc29uIj48c3BhbiBpdGVtcHJvcD0ibmFtZSI+VGhvbWFzZnV0PC9zcGFuPjwvZGl2PgoJCTwvZGl2PgoJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fY29udGVudCI+CgkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fY29udGVudF9fdG9wIj4KCQkJCQkJCQkJCQkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fcmF0aW5nIj48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PC9kaXY+CQkJCQk8c3BhbiBpdGVtcHJvcD0icmV2aWV3UmF0aW5nIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHBzOi8vc2NoZW1hLm9yZy9SYXRpbmciPgoJCQkJCQk8bWV0YSBpdGVtcHJvcD0icmF0aW5nVmFsdWUiIGNvbnRlbnQ9IjIiPgoJCQkJCTwvc3Bhbj4KCQkJCQkJCQk8ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2l0ZW1fX2RhdGUiPkp1bHkgMjYsIDIwMjU8L2Rpdj4KCQkJPC9kaXY+CgkJCQkJCTxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19faXRlbV9fdGV4dCIgaXRlbXByb3A9InJldmlld0JvZHkiPjxwPlt1cmw9aHR0cHM6Ly96Mi5hbmltZS1oZC5vbmxpbmUvdmFtcGlyZXMvXSDRgdC80L7RgtGA0LXRgtGMINCw0L3QuNC80LUg0LLQsNC80L/QuNGAWy91cmxdPGJyIC8+Clt1cmw9aHR0cHM6Ly96Mi5hbmltZS1oZC5vbmxpbmUvaGFyZW0vXSDRgdC80L7RgtGA0LXRgtGMINCw0L3QuNC80LUg0LPQsNGA0LXQvFsvdXJsXTxiciAvPgpbdXJsPWh0dHBzOi8vejIuYW5pbWUtaGQub25saW5lL2V0dHkvXSDRgdC80L7RgtGA0LXRgtGMINCw0L3QuNC80LUg0Y3RgtGC0LhbL3VybF08YnIgLz4KW3VybD1odHRwczovL3oyLmFuaW1lLWhkLm9ubGluZS9mYW50YXN0aWthL10g0YHQvNC+0YLRgNC10YLRjCDQsNC90LjQvNC1INGE0LDQvdGC0LDRgdGC0LjQutCwWy91cmxdPGJyIC8+Clt1cmw9aHR0cHM6Ly96Mi5hbmltZS1oZC5vbmxpbmUvZmplbnRlemkvXSDRgdC80L7RgtGA0LXRgtGMINCw0L3QuNC80LUg0YTRjdC90YLQtdC30LhbL3VybF08YnIgLz4KW3VybD1odHRwczovL3oyLmFuaW1lLWhkLm9ubGluZS9yb21hbmNlL10g0YHQvNC+0YLRgNC10YLRjCDQsNC90LjQvNC1INGA0L7QvNCw0L3RgtC40LrQsFsvdXJsXTxiciAvPgpbdXJsPWh0dHBzOi8vejIuYW5pbWUtaGQub25saW5lL21hZ2ljL10g0YHQvNC+0YLRgNC10YLRjCDQsNC90LjQvNC1INC80LDQs9C40Y9bL3VybF08YnIgLz4KW3VybD1odHRwczovL3oyLmFuaW1lLWhkLm9ubGluZS9mdXIvXSDRgdC80L7RgtGA0LXRgtGMINCw0L3QuNC80LUg0LzQtdGF0LBbL3VybF08YnIgLz4KW3VybD1odHRwczovL3oyLmFuaW1lLWhkLm9ubGluZS9zdXBlcm5hdHVyYWwvXSDRgdC80L7RgtGA0LXRgtGMINCw0L3QuNC80LUg0YHQstC10YDRhdGK0LXRgdGC0LXRgdGC0LLQtdC90L3QvtC1Wy91cmxdPGJyIC8+Clt1cmw9aHR0cHM6Ly96Mi5hbmltZS1oZC5vbmxpbmUva29tZWRpamEvXSDRgdC80L7RgtGA0LXRgtGMINCw0L3QuNC80LUg0LrQvtC80LXQtNC40LhbL3VybF08L3A+CjwvZGl2PgoJCQkJCTwvZGl2PgoJPC9kaXY+CjwvZGl2PjwhLS0gI2NvbW1lbnQtIyMgLS0+CgkJPC9kaXY+CgoJCgkJCQkJPGRpdiBpZD0idG91ci1sZWF2ZS1yZXZpZXciIGNsYXNzPSJ0b3VyLXJldmlld3NfX2Zvcm0gcGFkZGluZy1hbGwiPgoJCQk8aDMgY2xhc3M9InRvdXItcmV2aWV3c19fZm9ybV9fdGl0bGUiPkxlYXZlIGEgUmV2aWV3PC9oMz4KCQkJCTxkaXYgaWQ9InJlc3BvbmQiIGNsYXNzPSJjb21tZW50LXJlc3BvbmQiPgoJCTxoMyBpZD0icmVwbHktdGl0bGUiIGNsYXNzPSJjb21tZW50LXJlcGx5LXRpdGxlIj4gPHNtYWxsPjxhIHJlbD0ibm9mb2xsb3ciIGlkPSJjYW5jZWwtY29tbWVudC1yZXBseS1saW5rIiBocmVmPSIvdG91cnMvZXZlcmVzdC1iYXNlLWNhbXAtdHJlay12aWEtc2FsbGVyaS8jcmVzcG9uZCIgc3R5bGU9ImRpc3BsYXk6bm9uZTsiPkNhbmNlbCByZXBseTwvYT48L3NtYWxsPjwvaDM+PGZvcm0gYWN0aW9uPSJodHRwczovL2hpbWFsdG91cmlzbS5jb20vd3AtY29tbWVudHMtcG9zdC5waHAiIG1ldGhvZD0icG9zdCIgaWQ9ImNvbW1lbnRmb3JtIiBjbGFzcz0iY29tbWVudC1mb3JtIj48ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2Zvcm1fX3JhdGluZyI+PGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19mb3JtX19yYXRpbmdfX2xhYmVsIj5SYXRpbmc8L2Rpdj48c2VsZWN0IG5hbWU9InJhdGluZyIgaWQ9InJhdGluZyIgcmVxdWlyZWQ+PG9wdGlvbiB2YWx1ZT0iIj5SYXRlJmhlbGxpcDs8L29wdGlvbj48b3B0aW9uIHZhbHVlPSI1Ij5QZXJmZWN0PC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0iNCI+R29vZDwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IjMiPkF2ZXJhZ2U8L29wdGlvbj48b3B0aW9uIHZhbHVlPSIyIj5Ob3QgdGhhdCBiYWQ8L29wdGlvbj48b3B0aW9uIHZhbHVlPSIxIj5WZXJ5IFBvb3I8L29wdGlvbj48L3NlbGVjdD48L2Rpdj48ZGl2IGNsYXNzPSJ0b3VyLXJldmlld3NfX2Zvcm1fX2l0ZW0iPjx0ZXh0YXJlYSBpZD0iY29tbWVudCIgbmFtZT0iY29tbWVudCIgcGxhY2Vob2xkZXI9IllvdXIgUmV2aWV3IiBjbGFzcz0iZm9ybS12YWxpZGF0aW9uLWl0ZW0iPjwvdGV4dGFyZWE+PC9kaXY+PGRpdiBjbGFzcz0idG91ci1yZXZpZXdzX19mb3JtX19pdGVtIj48aW5wdXQgaWQ9ImF1dGhvciIgbmFtZT0iYXV0aG9yIiB0eXBlPSJ0ZXh0IiBwbGFjZWhvbGRlcj0iTmFtZSIgdmFsdWU9IlRob21hc2Z1dCIgc2l6ZT0iMzAiIGNsYXNzPSJmb3JtLXZhbGlkYXRpb24taXRlbSI+PC9kaXY+CjxkaXYgY2xhc3M9InRvdXItcmV2aWV3c19fZm9ybV9faXRlbSI+PGlucHV0IGlkPSJlbWFpbCIgbmFtZT0iZW1haWwiIHR5cGU9InRleHQiIHBsYWNlaG9sZGVyPSJFbWFpbCIgdmFsdWU9ImFuZHJleS5kb24ueEBnbWFpbC5jb20iIHNpemU9IjMwIiBjbGFzcz0iZm9ybS12YWxpZGF0aW9uLWl0ZW0iPjwvZGl2Pgo8cCBjbGFzcz0iY29tbWVudC1mb3JtLWNvb2tpZXMtY29uc2VudCI+PGlucHV0IGlkPSJ3cC1jb21tZW50LWNvb2tpZXMtY29uc2VudCIgbmFtZT0id3AtY29tbWVudC1jb29raWVzLWNvbnNlbnQiIHR5cGU9ImNoZWNrYm94IiB2YWx1ZT0ieWVzIiBjaGVja2VkPSJjaGVja2VkIiAvPiA8bGFiZWwgZm9yPSJ3cC1jb21tZW50LWNvb2tpZXMtY29uc2VudCI+U2F2ZSBteSBuYW1lLCBlbWFpbCwgYW5kIHdlYnNpdGUgaW4gdGhpcyBicm93c2VyIGZvciB0aGUgbmV4dCB0aW1lIEkgY29tbWVudC48L2xhYmVsPjwvcD4KPHAgY2xhc3M9ImZvcm0tc3VibWl0Ij48aW5wdXQgbmFtZT0ic3VibWl0IiB0eXBlPSJzdWJtaXQiIGlkPSJzdWJtaXQiIGNsYXNzPSJhdGJ0biIgdmFsdWU9IlN1Ym1pdCIgLz4gPGlucHV0IHR5cGU9J2hpZGRlbicgbmFtZT0nY29tbWVudF9wb3N0X0lEJyB2YWx1ZT0nMTMwMycgaWQ9J2NvbW1lbnRfcG9zdF9JRCcgLz4KPGlucHV0IHR5cGU9J2hpZGRlbicgbmFtZT0nY29tbWVudF9wYXJlbnQnIGlkPSdjb21tZW50X3BhcmVudCcgdmFsdWU9JzAnIC8+CjwvcD48L2Zvcm0+CTwvZGl2PjwhLS0gI3Jlc3BvbmQgLS0+CgkJCTwvZGl2PgoJPC9kaXY+CjxkaXYgY2xhc3M9InJlbGF0ZWQtdG91cnMgcGFkZGluZy10b3AiPgoJPGgyIHN0eWxlPSJtYXJnaW46MCAwIDI1cHggMCI+WW91IE1heSBBbHNvIExpa2U8L2gyPgoJCjxkaXYgY2xhc3M9ImF0Z3JpZCBhdGdyaWQtLXNtYWxsIj4KCTxkaXYgY2xhc3M9InJvdyBhdGdyaWRfX3JvdyI+CgkJCQkJPGRpdiBjbGFzcz0iY29sLW1kLTQgY29sLXhzLTYgYXRncmlkX19pdGVtLXdyYXAiPgoJCQk8ZGl2IGNsYXNzPSJhdGdyaWRfX2l0ZW0iPgoJCQkJPGRpdiBjbGFzcz0iYXRncmlkX19pdGVtX190b3AiPgoJCQkJCTxhIGhyZWY9Imh0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS90b3Vycy9naG9yZXBhbmktcG9vbi1oaWxsLXRyZWsvIiBjbGFzcz0iYXRncmlkX19pdGVtX190b3BfX2ltYWdlIj48aW1nIHdpZHRoPSIzNjAiIGhlaWdodD0iMjQwIiBzcmM9Imh0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS93cC1jb250ZW50L3VwbG9hZHMvMjAyMi8xMS9tYWluLWJlbm5lci10cmVra2luZy0zNjB4MjQwLmpwZyIgY2xhc3M9ImF0dGFjaG1lbnQtdGh1bWJfdG91cl9saXN0aW5nX3NtYWxsIHNpemUtdGh1bWJfdG91cl9saXN0aW5nX3NtYWxsIHdwLXBvc3QtaW1hZ2UiIGFsdD0iIiBkZWNvZGluZz0iYXN5bmMiIHNyY3NldD0iaHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIyLzExL21haW4tYmVubmVyLXRyZWtraW5nLTM2MHgyNDAuanBnIDM2MHcsIGh0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS93cC1jb250ZW50L3VwbG9hZHMvMjAyMi8xMS9tYWluLWJlbm5lci10cmVra2luZy01MzF4MzU0LmpwZyA1MzF3LCBodHRwczovL2hpbWFsdG91cmlzbS5jb20vd3AtY29udGVudC91cGxvYWRzLzIwMjIvMTEvbWFpbi1iZW5uZXItdHJla2tpbmctMTgweDEyMC5qcGcgMTgwdyIgc2l6ZXM9IihtYXgtd2lkdGg6IDM2MHB4KSAxMDB2dywgMzYwcHgiIC8+PC9hPgkJCQkJPGRpdiBjbGFzcz0iYXRncmlkX19pdGVtX19hbmdsZS13cmFwIj48ZGl2IGNsYXNzPSJhdGdyaWRfX2l0ZW1fX2FuZ2xlIiBzdHlsZT0iYmFja2dyb3VuZC1jb2xvcjojMDcyYmU4Ij5TcGVjaWFsIE9mZmVyITwvZGl2PjwvZGl2PjxkaXYgY2xhc3M9ImF0Z3JpZF9faXRlbV9fcHJpY2UiPjxhIGhyZWY9Imh0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS90b3Vycy9naG9yZXBhbmktcG9vbi1oaWxsLXRyZWsvIiBjbGFzcz0iYXRncmlkX19pdGVtX19wcmljZV9fYnV0dG9uIj48c3BhbiBjbGFzcz0id29vY29tbWVyY2UtUHJpY2UtYW1vdW50IGFtb3VudCI+PGJkaT48c3BhbiBjbGFzcz0id29vY29tbWVyY2UtUHJpY2UtY3VycmVuY3lTeW1ib2wiPiYjMzY7PC9zcGFuPiZuYnNwOzU5NS4wMDwvYmRpPjwvc3Bhbj48L2E+PC9kaXY+CQkJCQk8ZGl2IGNsYXNzPSJhdGdyaWRfX2l0ZW1fX3JhdGluZyI+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjwvZGl2PgkJCQkJCQkJCTwvZGl2PgoJCQkJPGRpdiBjbGFzcz0iYXRncmlkX19pdGVtX19jb250ZW50Ij4KCQkJCQk8aDMgY2xhc3M9ImF0Z3JpZF9faXRlbV9fdGl0bGUiPjxhIGhyZWY9Imh0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS90b3Vycy9naG9yZXBhbmktcG9vbi1oaWxsLXRyZWsvIj5HaG9yZXBhbmkgUG9vbiBIaWxsIFRyZWs8L2E+PC9oMz4KCQkJCQkJCQkJPGRpdiBjbGFzcz0iYXRncmlkX19pdGVtX19kZXNjcmlwdGlvbiI+QW5uYXB1cm5hIEJhc2UgQ2FtcCBpcyBhIHdvcnRod2hpbGUgZXhwbG9yYXRpb248L2Rpdj4KCQkJCQkJCQk8L2Rpdj4KCQkJCTxkaXYgY2xhc3M9Iml0ZW0tYXR0cmlidXRlcyI+CgkJCQkJPGRpdiBjbGFzcz0iaXRlbS1hdHRyaWJ1dGVzX19pdGVtIj48ZGl2IGNsYXNzPSJpdGVtLWF0dHJpYnV0ZXNfX2l0ZW1fX2NvbnRlbnQiPjxkaXYgY2xhc3M9Iml0ZW0tYXR0cmlidXRlc19faXRlbV9fY29udGVudF9faXRlbSI+PGkgY2xhc3M9InRkLW1hcC1tYXJrZXIiPjwvaT48L2Rpdj48ZGl2IGNsYXNzPSJpdGVtLWF0dHJpYnV0ZXNfX2l0ZW1fX2NvbnRlbnRfX2l0ZW0gaXRlbS1hdHRyaWJ1dGVzX19pdGVtX19jb250ZW50X19pdGVtLS10ZXh0Ij48c3Bhbj5Bbm5hcHVybmEsIE5lcGFsPC9zcGFuPjwvZGl2PjwvZGl2PjwvZGl2PjxkaXYgY2xhc3M9Iml0ZW0tYXR0cmlidXRlc19faXRlbSI+PGRpdiBjbGFzcz0iaXRlbS1hdHRyaWJ1dGVzX19pdGVtX19jb250ZW50Ij48ZGl2IGNsYXNzPSJpdGVtLWF0dHJpYnV0ZXNfX2l0ZW1fX2NvbnRlbnRfX2l0ZW0iPjxpIGNsYXNzPSJ0ZC1hbGFybS1jbG9jayI+PC9pPjwvZGl2PjxkaXYgY2xhc3M9Iml0ZW0tYXR0cmlidXRlc19faXRlbV9fY29udGVudF9faXRlbSBpdGVtLWF0dHJpYnV0ZXNfX2l0ZW1fX2NvbnRlbnRfX2l0ZW0tLXRleHQiPjxzcGFuPjYgRGF5czwvc3Bhbj48L2Rpdj48L2Rpdj48L2Rpdj4JCQkJCTxkaXYgY2xhc3M9Iml0ZW0tYXR0cmlidXRlc19faXRlbSI+PGEgaHJlZj0iaHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL3RvdXJzL2dob3JlcGFuaS1wb29uLWhpbGwtdHJlay8iIGNsYXNzPSJpdGVtLWF0dHJpYnV0ZXNfX2xpbmsiPjxpIGNsYXNzPSJmYSBmYS1sb25nLWFycm93LXJpZ2h0Ij48L2k+PC9hPjwvZGl2PgoJCQkJPC9kaXY+CgkJCTwvZGl2PgoJCTwvZGl2PgoJCQkJCTxkaXYgY2xhc3M9ImNvbC1tZC00IGNvbC14cy02IGF0Z3JpZF9faXRlbS13cmFwIj4KCQkJPGRpdiBjbGFzcz0iYXRncmlkX19pdGVtIj4KCQkJCTxkaXYgY2xhc3M9ImF0Z3JpZF9faXRlbV9fdG9wIj4KCQkJCQk8YSBocmVmPSJodHRwczovL2hpbWFsdG91cmlzbS5jb20vdG91cnMvbGFuZ3RhbmctZ29zYWlua3VuZGEtdHJlay8iIGNsYXNzPSJhdGdyaWRfX2l0ZW1fX3RvcF9faW1hZ2UiPjxpbWcgd2lkdGg9IjM2MCIgaGVpZ2h0PSIyNDAiIHNyYz0iaHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDI0LzA1L0xhbmd0YW5nLUdvc2Fpbmt1bmRhLVRyZWstMzYweDI0MC5qcGciIGNsYXNzPSJhdHRhY2htZW50LXRodW1iX3RvdXJfbGlzdGluZ19zbWFsbCBzaXplLXRodW1iX3RvdXJfbGlzdGluZ19zbWFsbCB3cC1wb3N0LWltYWdlIiBhbHQ9IiIgZGVjb2Rpbmc9ImFzeW5jIiBsb2FkaW5nPSJsYXp5IiBzcmNzZXQ9Imh0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS93cC1jb250ZW50L3VwbG9hZHMvMjAyNC8wNS9MYW5ndGFuZy1Hb3NhaW5rdW5kYS1UcmVrLTM2MHgyNDAuanBnIDM2MHcsIGh0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS93cC1jb250ZW50L3VwbG9hZHMvMjAyNC8wNS9MYW5ndGFuZy1Hb3NhaW5rdW5kYS1UcmVrLTUzMXgzNTQuanBnIDUzMXcsIGh0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS93cC1jb250ZW50L3VwbG9hZHMvMjAyNC8wNS9MYW5ndGFuZy1Hb3NhaW5rdW5kYS1UcmVrLTE4MHgxMjAuanBnIDE4MHciIHNpemVzPSIobWF4LXdpZHRoOiAzNjBweCkgMTAwdncsIDM2MHB4IiAvPjwvYT4JCQkJCTxkaXYgY2xhc3M9ImF0Z3JpZF9faXRlbV9fYW5nbGUtd3JhcCI+PGRpdiBjbGFzcz0iYXRncmlkX19pdGVtX19hbmdsZSIgc3R5bGU9ImJhY2tncm91bmQtY29sb3I6IzA3MmJlOCI+U3BlY2lhbCBPZmZlciE8L2Rpdj48L2Rpdj4JCQkJCTxkaXYgY2xhc3M9ImF0Z3JpZF9faXRlbV9fcmF0aW5nIj48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PC9kaXY+CQkJCQkJCQkJPC9kaXY+CgkJCQk8ZGl2IGNsYXNzPSJhdGdyaWRfX2l0ZW1fX2NvbnRlbnQiPgoJCQkJCTxoMyBjbGFzcz0iYXRncmlkX19pdGVtX190aXRsZSI+PGEgaHJlZj0iaHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL3RvdXJzL2xhbmd0YW5nLWdvc2Fpbmt1bmRhLXRyZWsvIj5MYW5ndGFuZyBHb3NhaW5rdW5kYSBUcmVrPC9hPjwvaDM+CgkJCQkJCQkJCTxkaXYgY2xhc3M9ImF0Z3JpZF9faXRlbV9fZGVzY3JpcHRpb24iPkhvdyBkb2VzIGl0IHNvdW5kIHRyZWtraW5nIGluIG1pZC1oaWxsczwvZGl2PgoJCQkJCQkJCTwvZGl2PgoJCQkJPGRpdiBjbGFzcz0iaXRlbS1hdHRyaWJ1dGVzIj4KCQkJCQk8ZGl2IGNsYXNzPSJpdGVtLWF0dHJpYnV0ZXNfX2l0ZW0iPjxkaXYgY2xhc3M9Iml0ZW0tYXR0cmlidXRlc19faXRlbV9fY29udGVudCI+PGRpdiBjbGFzcz0iaXRlbS1hdHRyaWJ1dGVzX19pdGVtX19jb250ZW50X19pdGVtIj48aSBjbGFzcz0idGQtbWFwLW1hcmtlciI+PC9pPjwvZGl2PjxkaXYgY2xhc3M9Iml0ZW0tYXR0cmlidXRlc19faXRlbV9fY29udGVudF9faXRlbSBpdGVtLWF0dHJpYnV0ZXNfX2l0ZW1fX2NvbnRlbnRfX2l0ZW0tLXRleHQiPjxzcGFuPkxhbmd0YW5nLCBOZXBhbDwvc3Bhbj48L2Rpdj48L2Rpdj48L2Rpdj48ZGl2IGNsYXNzPSJpdGVtLWF0dHJpYnV0ZXNfX2l0ZW0iPjxkaXYgY2xhc3M9Iml0ZW0tYXR0cmlidXRlc19faXRlbV9fY29udGVudCI+PGRpdiBjbGFzcz0iaXRlbS1hdHRyaWJ1dGVzX19pdGVtX19jb250ZW50X19pdGVtIj48aSBjbGFzcz0idGQtYWxhcm0tY2xvY2siPjwvaT48L2Rpdj48ZGl2IGNsYXNzPSJpdGVtLWF0dHJpYnV0ZXNfX2l0ZW1fX2NvbnRlbnRfX2l0ZW0gaXRlbS1hdHRyaWJ1dGVzX19pdGVtX19jb250ZW50X19pdGVtLS10ZXh0Ij48c3Bhbj4xNiBEYXlzPC9zcGFuPjwvZGl2PjwvZGl2PjwvZGl2PgkJCQkJPGRpdiBjbGFzcz0iaXRlbS1hdHRyaWJ1dGVzX19pdGVtIj48YSBocmVmPSJodHRwczovL2hpbWFsdG91cmlzbS5jb20vdG91cnMvbGFuZ3RhbmctZ29zYWlua3VuZGEtdHJlay8iIGNsYXNzPSJpdGVtLWF0dHJpYnV0ZXNfX2xpbmsiPjxpIGNsYXNzPSJmYSBmYS1sb25nLWFycm93LXJpZ2h0Ij48L2k+PC9hPjwvZGl2PgoJCQkJPC9kaXY+CgkJCTwvZGl2PgoJCTwvZGl2PgoJCQk8ZGl2IGNsYXNzPSJhdGdyaWRfX3Jvdy1zZXBhcmF0b3IgY2xlYXJmaXggdmlzaWJsZS1zbSB2aXNpYmxlLXhzIj48L2Rpdj4JCTxkaXYgY2xhc3M9ImNvbC1tZC00IGNvbC14cy02IGF0Z3JpZF9faXRlbS13cmFwIj4KCQkJPGRpdiBjbGFzcz0iYXRncmlkX19pdGVtIj4KCQkJCTxkaXYgY2xhc3M9ImF0Z3JpZF9faXRlbV9fdG9wIj4KCQkJCQk8YSBocmVmPSJodHRwczovL2hpbWFsdG91cmlzbS5jb20vdG91cnMvYW5uYXB1cm5hLWJhc2UtY2FtcC10cmVrLyIgY2xhc3M9ImF0Z3JpZF9faXRlbV9fdG9wX19pbWFnZSI+PGltZyB3aWR0aD0iMzYwIiBoZWlnaHQ9IjI0MCIgc3JjPSJodHRwczovL2hpbWFsdG91cmlzbS5jb20vd3AtY29udGVudC91cGxvYWRzLzIwMjIvMTEvQW5uYXB1cm5hLUJhc2UtQ2FtcC1HYWxsZXJ5LUltYWdlLTMtMzYweDI0MC5qcGciIGNsYXNzPSJhdHRhY2htZW50LXRodW1iX3RvdXJfbGlzdGluZ19zbWFsbCBzaXplLXRodW1iX3RvdXJfbGlzdGluZ19zbWFsbCB3cC1wb3N0LWltYWdlIiBhbHQ9IiIgZGVjb2Rpbmc9ImFzeW5jIiBsb2FkaW5nPSJsYXp5IiBzcmNzZXQ9Imh0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS93cC1jb250ZW50L3VwbG9hZHMvMjAyMi8xMS9Bbm5hcHVybmEtQmFzZS1DYW1wLUdhbGxlcnktSW1hZ2UtMy0zNjB4MjQwLmpwZyAzNjB3LCBodHRwczovL2hpbWFsdG91cmlzbS5jb20vd3AtY29udGVudC91cGxvYWRzLzIwMjIvMTEvQW5uYXB1cm5hLUJhc2UtQ2FtcC1HYWxsZXJ5LUltYWdlLTMtNTMxeDM1NC5qcGcgNTMxdywgaHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL3dwLWNvbnRlbnQvdXBsb2Fkcy8yMDIyLzExL0FubmFwdXJuYS1CYXNlLUNhbXAtR2FsbGVyeS1JbWFnZS0zLTE4MHgxMjAuanBnIDE4MHciIHNpemVzPSIobWF4LXdpZHRoOiAzNjBweCkgMTAwdncsIDM2MHB4IiAvPjwvYT4JCQkJCTxkaXYgY2xhc3M9ImF0Z3JpZF9faXRlbV9fYW5nbGUtd3JhcCI+PGRpdiBjbGFzcz0iYXRncmlkX19pdGVtX19hbmdsZSIgc3R5bGU9ImJhY2tncm91bmQtY29sb3I6IzA3MmJlOCI+U3BlY2lhbCBPZmZlciE8L2Rpdj48L2Rpdj48ZGl2IGNsYXNzPSJhdGdyaWRfX2l0ZW1fX3ByaWNlIj48YSBocmVmPSJodHRwczovL2hpbWFsdG91cmlzbS5jb20vdG91cnMvYW5uYXB1cm5hLWJhc2UtY2FtcC10cmVrLyIgY2xhc3M9ImF0Z3JpZF9faXRlbV9fcHJpY2VfX2J1dHRvbiI+PHNwYW4gY2xhc3M9Indvb2NvbW1lcmNlLVByaWNlLWFtb3VudCBhbW91bnQiPjxiZGk+PHNwYW4gY2xhc3M9Indvb2NvbW1lcmNlLVByaWNlLWN1cnJlbmN5U3ltYm9sIj4mIzM2Ozwvc3Bhbj4mbmJzcDsxLDEyNS4wMDwvYmRpPjwvc3Bhbj48L2E+PC9kaXY+CQkJCQk8ZGl2IGNsYXNzPSJhdGdyaWRfX2l0ZW1fX3JhdGluZyI+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjxpIGNsYXNzPSJmYSBmYS1zdGFyIj48L2k+PGkgY2xhc3M9ImZhIGZhLXN0YXIiPjwvaT48aSBjbGFzcz0iZmEgZmEtc3RhciI+PC9pPjwvZGl2PgkJCQkJCQkJCTwvZGl2PgoJCQkJPGRpdiBjbGFzcz0iYXRncmlkX19pdGVtX19jb250ZW50Ij4KCQkJCQk8aDMgY2xhc3M9ImF0Z3JpZF9faXRlbV9fdGl0bGUiPjxhIGhyZWY9Imh0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS90b3Vycy9hbm5hcHVybmEtYmFzZS1jYW1wLXRyZWsvIj5Bbm5hcHVybmEgQmFzZSBDYW1wIFRyZWs8L2E+PC9oMz4KCQkJCQkJCQkJPGRpdiBjbGFzcz0iYXRncmlkX19pdGVtX19kZXNjcmlwdGlvbiI+QW5uYXB1cm5hIEJhc2UgQ2FtcCBpcyBhIHdvcnRod2hpbGUgZXhwbG9yYXRpb248L2Rpdj4KCQkJCQkJCQk8L2Rpdj4KCQkJCTxkaXYgY2xhc3M9Iml0ZW0tYXR0cmlidXRlcyI+CgkJCQkJPGRpdiBjbGFzcz0iaXRlbS1hdHRyaWJ1dGVzX19pdGVtIj48ZGl2IGNsYXNzPSJpdGVtLWF0dHJpYnV0ZXNfX2l0ZW1fX2NvbnRlbnQiPjxkaXYgY2xhc3M9Iml0ZW0tYXR0cmlidXRlc19faXRlbV9fY29udGVudF9faXRlbSI+PGkgY2xhc3M9InRkLW1hcC1tYXJrZXIiPjwvaT48L2Rpdj48ZGl2IGNsYXNzPSJpdGVtLWF0dHJpYnV0ZXNfX2l0ZW1fX2NvbnRlbnRfX2l0ZW0gaXRlbS1hdHRyaWJ1dGVzX19pdGVtX19jb250ZW50X19pdGVtLS10ZXh0Ij48c3Bhbj5Bbm5hcHVybmEsIE5lcGFsPC9zcGFuPjwvZGl2PjwvZGl2PjwvZGl2PjxkaXYgY2xhc3M9Iml0ZW0tYXR0cmlidXRlc19faXRlbSI+PGRpdiBjbGFzcz0iaXRlbS1hdHRyaWJ1dGVzX19pdGVtX19jb250ZW50Ij48ZGl2IGNsYXNzPSJpdGVtLWF0dHJpYnV0ZXNfX2l0ZW1fX2NvbnRlbnRfX2l0ZW0iPjxpIGNsYXNzPSJ0ZC1hbGFybS1jbG9jayI+PC9pPjwvZGl2PjxkaXYgY2xhc3M9Iml0ZW0tYXR0cmlidXRlc19faXRlbV9fY29udGVudF9faXRlbSBpdGVtLWF0dHJpYnV0ZXNfX2l0ZW1fX2NvbnRlbnRfX2l0ZW0tLXRleHQiPjxzcGFuPjEyIERheXM8L3NwYW4+PC9kaXY+PC9kaXY+PC9kaXY+CQkJCQk8ZGl2IGNsYXNzPSJpdGVtLWF0dHJpYnV0ZXNfX2l0ZW0iPjxhIGhyZWY9Imh0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS90b3Vycy9hbm5hcHVybmEtYmFzZS1jYW1wLXRyZWsvIiBjbGFzcz0iaXRlbS1hdHRyaWJ1dGVzX19saW5rIj48aSBjbGFzcz0iZmEgZmEtbG9uZy1hcnJvdy1yaWdodCI+PC9pPjwvYT48L2Rpdj4KCQkJCTwvZGl2PgoJCQk8L2Rpdj4KCQk8L2Rpdj4KCQkJPC9kaXY+CjwvZGl2Pgo8L2Rpdj4KCTwvbWFpbj4KCTxhc2lkZSBjbGFzcz0iY29sLW1kLTMgc2lkZWJhciIgcm9sZT0iY29tcGxlbWVudGFyeSI+CjxkaXYgY2xhc3M9InByaWNlLWRlY29yYXRpb24gYmxvY2stYWZ0ZXItaW5kZW50Ij48ZGl2IGNsYXNzPSJwcmljZS1kZWNvcmF0aW9uX192YWx1ZSI+PGkgY2xhc3M9InRkLXByaWNlLXRhZyI+PC9pPjxzcGFuIGNsYXNzPSJ3b29jb21tZXJjZS1QcmljZS1hbW91bnQgYW1vdW50Ij48YmRpPjxzcGFuIGNsYXNzPSJ3b29jb21tZXJjZS1QcmljZS1jdXJyZW5jeVN5bWJvbCI+JiMzNjs8L3NwYW4+Jm5ic3A7MSw5NTUuMDA8L2JkaT48L3NwYW4+PC9kaXY+PGRpdiBjbGFzcz0icHJpY2UtZGVjb3JhdGlvbl9fbGFiZWwiPk9uZSB0b3VyIHBlciBwZXJzb248L2Rpdj48L2Rpdj48ZGl2IGlkPSJibG9jay0xNiIgY2xhc3M9IndpZGdldCBibG9jay1hZnRlci1pbmRlbnQgd2lkZ2V0X2Jsb2NrIj48cD48cHJlIGNsYXNzPSJ0aS13aWRnZXQiIHN0eWxlPSJkaXNwbGF5OiBub25lIj48dGVtcGxhdGUgaWQ9InRydXN0aW5kZXgtdHJpcGFkdmlzb3Itd2lkZ2V0LWh0bWwiPjxkaXYgY2xhc3M9InRpLXdpZGdldCB0aS10cmlwIHRpLXJldmlldy10ZXh0LW1vZGUtcmVhZG1vcmUgdGktdGV4dC1hbGlnbi1sZWZ0IiBkYXRhLW5vLXRyYW5zbGF0aW9uPSJ0cnVlIiBkYXRhLWxheW91dC1pZD0iNCIgZGF0YS1sYXlvdXQtY2F0ZWdvcnk9InNsaWRlciIgZGF0YS1zZXQtaWQ9ImxpZ2h0LWJhY2tncm91bmQtbGFyZ2UiIGRhdGEtcGlkPSIiIGRhdGEtbGFuZ3VhZ2U9ImVuIiBkYXRhLXJldmlldy10YXJnZXQtd2lkdGg9IjMwMCIgZGF0YS1jc3MtdmVyc2lvbj0iMiIgZGF0YS1yZXZpZXctdGV4dC1tb2RlPSJyZWFkbW9yZSIgZGF0YS1yZXBseS1ieS1sb2NhbGU9Ik93bmVyJ3MgcmVwbHkiIGRhdGEtcGFnZXItYXV0b3BsYXktdGltZW91dD0iNiIgPiA8ZGl2IGNsYXNzPSJ0aS13aWRnZXQtY29udGFpbmVyIHRpLWNvbC0zIj4gPGRpdiBjbGFzcz0idGktcmV2aWV3cy1jb250YWluZXIiPiA8ZGl2IGNsYXNzPSJ0aS1jb250cm9scyI+IDxkaXYgY2xhc3M9InRpLW5leHQiIGFyaWEtbGFiZWw9Ik5leHQgcmV2aWV3IiByb2xlPSJidXR0b24iPjwvZGl2PiA8ZGl2IGNsYXNzPSJ0aS1wcmV2IiBhcmlhLWxhYmVsPSJQcmV2aW91cyByZXZpZXciIHJvbGU9ImJ1dHRvbiI+PC9kaXY+IDwvZGl2PiA8ZGl2IGNsYXNzPSJ0aS1yZXZpZXdzLWNvbnRhaW5lci13cmFwcGVyIj4gIDxkaXYgZGF0YS1lbXB0eT0iMCIgY2xhc3M9InRpLXJldmlldy1pdGVtIHNvdXJjZS1UcmlwYWR2aXNvciB0aS1pbWFnZS1sYXlvdXQtdGh1bWJuYWlsIiBkYXRhLWlkPSJjZmNkMjA4NDk1ZDU2NWVmNjZlN2RmZjlmOTg3NjRkYSIgPiA8ZGl2IGNsYXNzPSJ0aS1pbm5lciI+IDxkaXYgY2xhc3M9InRpLXJldmlldy1oZWFkZXIiPiA8dHJ1c3RpbmRleC1pbWFnZSBjbGFzcz0idGktcGxhdGZvcm0taWNvbiIgZGF0YS1pbWd1cmw9Imh0dHBzOi8vY2RuLnRydXN0aW5kZXguaW8vYXNzZXRzL3BsYXRmb3JtL1RyaXBhZHZpc29yL2ljb24uc3ZnIiBhbHQ9IlRyaXBhZHZpc29yIiB3aWR0aD0iMjAiIGhlaWdodD0iMjAiIGxvYWRpbmc9ImxhenkiID48L3RydXN0aW5kZXgtaW1hZ2U+IDxkaXYgY2xhc3M9InRpLXByb2ZpbGUtaW1nIj4gPHRydXN0aW5kZXgtaW1hZ2UgZGF0YS1pbWd1cmw9Imh0dHBzOi8vbWVkaWEtY2RuLnRyaXBhZHZpc29yLmNvbS9tZWRpYS9waG90by1zLzFjL2FhLzAzL2Q2L2JoYXR0Zm91bmRhdGlvbmluYy5qcGciIGRhdGEtaW1ndXJsc2V0PSJodHRwczovL21lZGlhLWNkbi50cmlwYWR2aXNvci5jb20vbWVkaWEvcGhvdG8tcy8xYy9hYS8wMy9kNi9iaGF0dGZvdW5kYXRpb25pbmMuanBnIDJ4IiBhbHQ9IkhpdGVzaCBCaGF0dCAtIEJoYXR0IEZvdW5kYXRpb24gSW5jIiBsb2FkaW5nPSJsYXp5IiA+PC90cnVzdGluZGV4LWltYWdlPiA8L2Rpdj4gPGRpdiBjbGFzcz0idGktcHJvZmlsZS1kZXRhaWxzIj4gPGRpdiBjbGFzcz0idGktbmFtZSI+IEhpdGVzaCBCaGF0dCAtIEJoYXR0IEZvdW5kYXRpb24gSW5jIDwvZGl2PiA8ZGl2IGNsYXNzPSJ0aS1kYXRlIj4yMDIyLTA1LTA1PC9kaXY+IDwvZGl2PiA8L2Rpdj4gPHNwYW4gY2xhc3M9InRpLXN0YXJzIj48dHJ1c3RpbmRleC1pbWFnZSBjbGFzcz0idGktc3RhciIgZGF0YS1pbWd1cmw9Imh0dHBzOi8vY2RuLnRydXN0aW5kZXguaW8vYXNzZXRzL3BsYXRmb3JtL1RyaXBhZHZpc29yL3N0YXIvZi5zdmciIGFsdD0iVHJpcGFkdmlzb3IiIHdpZHRoPSIxNyIgaGVpZ2h0PSIxNyIgbG9hZGluZz0ibGF6eSIgPjwvdHJ1c3RpbmRleC1pbWFnZT48dHJ1c3RpbmRleC1pbWFnZSBjbGFzcz0idGktc3RhciIgZGF0YS1pbWd1cmw9Imh0dHBzOi8vY2RuLnRydXN0aW5kZXguaW8vYXNzZXRzL3BsYXRmb3JtL1RyaXBhZHZpc29yL3N0YXIvZi5zdmciIGFsdD0iVHJpcGFkdmlzb3IiIHdpZHRoPSIxNyIgaGVpZ2h0PSIxNyIgbG9hZGluZz0ibGF6eSIgPjwvdHJ1c3RpbmRleC1pbWFnZT48dHJ1c3RpbmRleC1pbWFnZSBjbGFzcz0idGktc3RhciIgZGF0YS1pbWd1cmw9Imh0dHBzOi8vY2RuLnRydXN0aW5kZXguaW8vYXNzZXRzL3BsYXRmb3JtL1RyaXBhZHZpc29yL3N0YXIvZi5zdmciIGFsdD0iVHJpcGFkdmlzb3IiIHdpZHRoPSIxNyIgaGVpZ2h0PSIxNyIgbG9hZGluZz0ibGF6eSIgPjwvdHJ1c3RpbmRleC1pbWFnZT48dHJ1c3RpbmRleC1pbWFnZSBjbGFzcz0idGktc3RhciIgZGF0YS1pbWd1cmw9Imh0dHBzOi8vY2RuLnRydXN0aW5kZXguaW8vYXNzZXRzL3BsYXRmb3JtL1RyaXBhZHZpc29yL3N0YXIvZi5zdmciIGFsdD0iVHJpcGFkdmlzb3IiIHdpZHRoPSIxNyIgaGVpZ2h0PSIxNyIgbG9hZGluZz0ibGF6eSIgPjwvdHJ1c3RpbmRleC1pbWFnZT48dHJ1c3RpbmRleC1pbWFnZSBjbGFzcz0idGktc3RhciIgZGF0YS1pbWd1cmw9Imh0dHBzOi8vY2RuLnRydXN0aW5kZXguaW8vYXNzZXRzL3BsYXRmb3JtL1RyaXBhZHZpc29yL3N0YXIvZi5zdmciIGFsdD0iVHJpcGFkdmlzb3IiIHdpZHRoPSIxNyIgaGVpZ2h0PSIxNyIgbG9hZGluZz0ibGF6eSIgPjwvdHJ1c3RpbmRleC1pbWFnZT48L3NwYW4+IDxkaXYgY2xhc3M9InRpLXJldmlldy10ZXh0LWNvbnRhaW5lciB0aS1yZXZpZXctY29udGVudCI+PCEtLSBSLUNPTlRFTlQgLS0+PHN0cm9uZz5CaGF0dCBGb3VuZGF0aW9uIEluYyAtIE5lcGFsPC9zdHJvbmc+Ck9uZSBtb3N0IHdlbGwgb3JnYW5pemVkIHdpdGggZXh0cmVtZWx5IHBlcnNvbmFsaXplZCAgcHJvZmVzc2lvbmFsIHRvdXIgb3BlcmF0b3IgaW4gTmVwYWwuIENvbmdyYXR1bGF0aW9ucyB0byBlYWNoIGFuZCBldmVyeW9uZSBhdCBIaW1hbCBUb3VyIGFuZCB3ZSBjYW7igJl0IHdhaXQgdG8gdmlzaXQgeW91IGFnYWluIGluIDIwMjMuIFRoYW5rIHlvdSBzbyBtdWNoIGZvciBldmVyeXRoaW5nIHlvdSBoYXZlIGRvbmUgZm9yIHVzLjwhLS0gUi1DT05URU5UIC0tPjwvZGl2PiA8c3BhbiBjbGFzcz0idGktcmVhZC1tb3JlIiBkYXRhLWNvbnRhaW5lcj0iLnRpLXJldmlldy1jb250ZW50IiBkYXRhLWNvbGxhcHNlLXRleHQ9IkhpZGUiIGRhdGEtb3Blbi10ZXh0PSJSZWFkIG1vcmUiID48L3NwYW4+IDwvZGl2PiA8L2Rpdj4gIDxkaXYgZGF0YS1lbXB0eT0iMCIgY2xhc3M9InRpLXJldmlldy1pdGVtIHNvdXJjZS1UcmlwYWR2aXNvciB0aS1pbWFnZS1sYXlvdXQtdGh1bWJuYWlsIiBkYXRhLWlkPSJjZmNkMjA4NDk1ZDU2NWVmNjZlN2RmZjlmOTg3NjRkYSIgPiA8ZGl2IGNsYXNzPSJ0aS1pbm5lciI+IDxkaXYgY2xhc3M9InRpLXJldmlldy1oZWFkZXIiPiA8dHJ1c3RpbmRleC1pbWFnZSBjbGFzcz0idGktcGxhdGZvcm0taWNvbiIgZGF0YS1pbWd1cmw9Imh0dHBzOi8vY2RuLnRydXN0aW5kZXguaW8vYXNzZXRzL3BsYXRmb3JtL1RyaXBhZHZpc29yL2ljb24uc3ZnIiBhbHQ9IlRyaXBhZHZpc29yIiB3aWR0aD0iMjAiIGhlaWdodD0iMjAiIGxvYWRpbmc9ImxhenkiID48L3RydXN0aW5kZXgtaW1hZ2U+IDxkaXYgY2xhc3M9InRpLXByb2ZpbGUtaW1nIj4gPHRydXN0aW5kZXgtaW1hZ2UgZGF0YS1pbWd1cmw9Imh0dHBzOi8vbWVkaWEtY2RuLnRyaXBhZHZpc29yLmNvbS9tZWRpYS9waG90by1vLzFhL2Y2L2U4LzkxL2RlZmF1bHQtYXZhdGFyLTIwMjAtNjIuanBnIiBkYXRhLWltZ3VybHNldD0iaHR0cHM6Ly9tZWRpYS1jZG4udHJpcGFkdmlzb3IuY29tL21lZGlhL3Bob3RvLW8vMWEvZjYvZTgvOTEvZGVmYXVsdC1hdmF0YXItMjAyMC02Mi5qcGcgMngiIGFsdD0iQiBMIiBsb2FkaW5nPSJsYXp5IiA+PC90cnVzdGluZGV4LWltYWdlPiA8L2Rpdj4gPGRpdiBjbGFzcz0idGktcHJvZmlsZS1kZXRhaWxzIj4gPGRpdiBjbGFzcz0idGktbmFtZSI+IEIgTCA8L2Rpdj4gPGRpdiBjbGFzcz0idGktZGF0ZSI+MjAyMi0wNS0wNTwvZGl2PiA8L2Rpdj4gPC9kaXY+IDxzcGFuIGNsYXNzPSJ0aS1zdGFycyI+PHRydXN0aW5kZXgtaW1hZ2UgY2xhc3M9InRpLXN0YXIiIGRhdGEtaW1ndXJsPSJodHRwczovL2Nkbi50cnVzdGluZGV4LmlvL2Fzc2V0cy9wbGF0Zm9ybS9UcmlwYWR2aXNvci9zdGFyL2Yuc3ZnIiBhbHQ9IlRyaXBhZHZpc29yIiB3aWR0aD0iMTciIGhlaWdodD0iMTciIGxvYWRpbmc9ImxhenkiID48L3RydXN0aW5kZXgtaW1hZ2U+PHRydXN0aW5kZXgtaW1hZ2UgY2xhc3M9InRpLXN0YXIiIGRhdGEtaW1ndXJsPSJodHRwczovL2Nkbi50cnVzdGluZGV4LmlvL2Fzc2V0cy9wbGF0Zm9ybS9UcmlwYWR2aXNvci9zdGFyL2Yuc3ZnIiBhbHQ9IlRyaXBhZHZpc29yIiB3aWR0aD0iMTciIGhlaWdodD0iMTciIGxvYWRpbmc9ImxhenkiID48L3RydXN0aW5kZXgtaW1hZ2U+PHRydXN0aW5kZXgtaW1hZ2UgY2xhc3M9InRpLXN0YXIiIGRhdGEtaW1ndXJsPSJodHRwczovL2Nkbi50cnVzdGluZGV4LmlvL2Fzc2V0cy9wbGF0Zm9ybS9UcmlwYWR2aXNvci9zdGFyL2Yuc3ZnIiBhbHQ9IlRyaXBhZHZpc29yIiB3aWR0aD0iMTciIGhlaWdodD0iMTciIGxvYWRpbmc9ImxhenkiID48L3RydXN0aW5kZXgtaW1hZ2U+PHRydXN0aW5kZXgtaW1hZ2UgY2xhc3M9InRpLXN0YXIiIGRhdGEtaW1ndXJsPSJodHRwczovL2Nkbi50cnVzdGluZGV4LmlvL2Fzc2V0cy9wbGF0Zm9ybS9UcmlwYWR2aXNvci9zdGFyL2Yuc3ZnIiBhbHQ9IlRyaXBhZHZpc29yIiB3aWR0aD0iMTciIGhlaWdodD0iMTciIGxvYWRpbmc9ImxhenkiID48L3RydXN0aW5kZXgtaW1hZ2U+PHRydXN0aW5kZXgtaW1hZ2UgY2xhc3M9InRpLXN0YXIiIGRhdGEtaW1ndXJsPSJodHRwczovL2Nkbi50cnVzdGluZGV4LmlvL2Fzc2V0cy9wbGF0Zm9ybS9UcmlwYWR2aXNvci9zdGFyL2Yuc3ZnIiBhbHQ9IlRyaXBhZHZpc29yIiB3aWR0aD0iMTciIGhlaWdodD0iMTciIGxvYWRpbmc9ImxhenkiID48L3RydXN0aW5kZXgtaW1hZ2U+PC9zcGFuPiA8ZGl2IGNsYXNzPSJ0aS1yZXZpZXctdGV4dC1jb250YWluZXIgdGktcmV2aWV3LWNvbnRlbnQiPjwhLS0gUi1DT05URU5UIC0tPjxzdHJvbmc+VG91ciBhbmQgdHJlayBpbiBOZXBhbCBpbiBzdHlsZTwvc3Ryb25nPgpBbWF6aW5nIHRyZWtraW5nIGNvbXBsZXRlZCB3aXRoIHRoaXMgbW9zdCByZWxpYWJsZSBhbmQgdHJ1c3R3b3J0aHkgY29tcGFueS5LcmlzaG5hIG1hZGUgZXZlcnl0aGluZyBzbyBlYXN5IHdpdGggaGlzICBleHBlcnRpc2UgYnkgYXJyYW5naW5nICBjb21mb3J0YWJsZSBhbmQgcmVsaWFibGUgdHJhbnNwb3J0LCBob3RlbCBib29raW5ncywgcG9ydGVyLCBwYXJhZ2xpZGluZyAsIHJhZnRpbmcgZXRjLiBHcmVhdCB2YWx1ZSBmb3IgbW9uZXkgLjwhLS0gUi1DT05URU5UIC0tPjwvZGl2PiA8c3BhbiBjbGFzcz0idGktcmVhZC1tb3JlIiBkYXRhLWNvbnRhaW5lcj0iLnRpLXJldmlldy1jb250ZW50IiBkYXRhLWNvbGxhcHNlLXRleHQ9IkhpZGUiIGRhdGEtb3Blbi10ZXh0PSJSZWFkIG1vcmUiID48L3NwYW4+IDwvZGl2PiA8L2Rpdj4gIDxkaXYgZGF0YS1lbXB0eT0iMCIgY2xhc3M9InRpLXJldmlldy1pdGVtIHNvdXJjZS1UcmlwYWR2aXNvciB0aS1pbWFnZS1sYXlvdXQtdGh1bWJuYWlsIiBkYXRhLWlkPSJjZmNkMjA4NDk1ZDU2NWVmNjZlN2RmZjlmOTg3NjRkYSIgPiA8ZGl2IGNsYXNzPSJ0aS1pbm5lciI+IDxkaXYgY2xhc3M9InRpLXJldmlldy1oZWFkZXIiPiA8dHJ1c3RpbmRleC1pbWFnZSBjbGFzcz0idGktcGxhdGZvcm0taWNvbiIgZGF0YS1pbWd1cmw9Imh0dHBzOi8vY2RuLnRydXN0aW5kZXguaW8vYXNzZXRzL3BsYXRmb3JtL1RyaXBhZHZpc29yL2ljb24uc3ZnIiBhbHQ9IlRyaXBhZHZpc29yIiB3aWR0aD0iMjAiIGhlaWdodD0iMjAiIGxvYWRpbmc9ImxhenkiID48L3RydXN0aW5kZXgtaW1hZ2U+IDxkaXYgY2xhc3M9InRpLXByb2ZpbGUtaW1nIj4gPHRydXN0aW5kZXgtaW1hZ2UgZGF0YS1pbWd1cmw9Imh0dHBzOi8vbWVkaWEtY2RuLnRyaXBhZHZpc29yLmNvbS9tZWRpYS9waG90by1vLzFhL2Y2Lzc3L2FlL2RlZmF1bHQtYXZhdGFyLTIwMjAtMi5qcGciIGRhdGEtaW1ndXJsc2V0PSJodHRwczovL21lZGlhLWNkbi50cmlwYWR2aXNvci5jb20vbWVkaWEvcGhvdG8tby8xYS9mNi83Ny9hZS9kZWZhdWx0LWF2YXRhci0yMDIwLTIuanBnIDJ4IiBhbHQ9IkdyZWF0c2hha3RpIiBsb2FkaW5nPSJsYXp5IiA+PC90cnVzdGluZGV4LWltYWdlPiA8L2Rpdj4gPGRpdiBjbGFzcz0idGktcHJvZmlsZS1kZXRhaWxzIj4gPGRpdiBjbGFzcz0idGktbmFtZSI+IEdyZWF0c2hha3RpIDwvZGl2PiA8ZGl2IGNsYXNzPSJ0aS1kYXRlIj4yMDIwLTAzLTE3PC9kaXY+IDwvZGl2PiA8L2Rpdj4gPHNwYW4gY2xhc3M9InRpLXN0YXJzIj48dHJ1c3RpbmRleC1pbWFnZSBjbGFzcz0idGktc3RhciIgZGF0YS1pbWd1cmw9Imh0dHBzOi8vY2RuLnRydXN0aW5kZXguaW8vYXNzZXRzL3BsYXRmb3JtL1RyaXBhZHZpc29yL3N0YXIvZi5zdmciIGFsdD0iVHJpcGFkdmlzb3IiIHdpZHRoPSIxNyIgaGVpZ2h0PSIxNyIgbG9hZGluZz0ibGF6eSIgPjwvdHJ1c3RpbmRleC1pbWFnZT48dHJ1c3RpbmRleC1pbWFnZSBjbGFzcz0idGktc3RhciIgZGF0YS1pbWd1cmw9Imh0dHBzOi8vY2RuLnRydXN0aW5kZXguaW8vYXNzZXRzL3BsYXRmb3JtL1RyaXBhZHZpc29yL3N0YXIvZi5zdmciIGFsdD0iVHJpcGFkdmlzb3IiIHdpZHRoPSIxNyIgaGVpZ2h0PSIxNyIgbG9hZGluZz0ibGF6eSIgPjwvdHJ1c3RpbmRleC1pbWFnZT48dHJ1c3RpbmRleC1pbWFnZSBjbGFzcz0idGktc3RhciIgZGF0YS1pbWd1cmw9Imh0dHBzOi8vY2RuLnRydXN0aW5kZXguaW8vYXNzZXRzL3BsYXRmb3JtL1RyaXBhZHZpc29yL3N0YXIvZi5zdmciIGFsdD0iVHJpcGFkdmlzb3IiIHdpZHRoPSIxNyIgaGVpZ2h0PSIxNyIgbG9hZGluZz0ibGF6eSIgPjwvdHJ1c3RpbmRleC1pbWFnZT48dHJ1c3RpbmRleC1pbWFnZSBjbGFzcz0idGktc3RhciIgZGF0YS1pbWd1cmw9Imh0dHBzOi8vY2RuLnRydXN0aW5kZXguaW8vYXNzZXRzL3BsYXRmb3JtL1RyaXBhZHZpc29yL3N0YXIvZi5zdmciIGFsdD0iVHJpcGFkdmlzb3IiIHdpZHRoPSIxNyIgaGVpZ2h0PSIxNyIgbG9hZGluZz0ibGF6eSIgPjwvdHJ1c3RpbmRleC1pbWFnZT48dHJ1c3RpbmRleC1pbWFnZSBjbGFzcz0idGktc3RhciIgZGF0YS1pbWd1cmw9Imh0dHBzOi8vY2RuLnRydXN0aW5kZXguaW8vYXNzZXRzL3BsYXRmb3JtL1RyaXBhZHZpc29yL3N0YXIvZi5zdmciIGFsdD0iVHJpcGFkdmlzb3IiIHdpZHRoPSIxNyIgaGVpZ2h0PSIxNyIgbG9hZGluZz0ibGF6eSIgPjwvdHJ1c3RpbmRleC1pbWFnZT48L3NwYW4+IDxkaXYgY2xhc3M9InRpLXJldmlldy10ZXh0LWNvbnRhaW5lciB0aS1yZXZpZXctY29udGVudCI+PCEtLSBSLUNPTlRFTlQgLS0+PHN0cm9uZz5CZXN0IFVORVNDTyBXb3JsZCBIZXJpdGFnZSBTaXRlcyBUb3VyIGluIEthdGhtYW5kdSAtIE5lcGFsPC9zdHJvbmc+ClRoZSBLYXRobWFuZHUgdmFsbGV5IGhhcyBzZXZlbiBoZXJpdGFnZSBzaXRlcyByZWdpc3RlcmVkIGluICBVTkVTQ08gV29ybGQgSGVyaXRhZ2UgU2l0ZXMgd2hpY2ggaGVscCB1cyB0byB1bmRlcnN0YW5kIE5lcGFsIGFuZCBpdHMgY3VsdHVyZS4gVGhleSBleHBsYWluIGRldGFpbCBhYm91dCB0aGVzZSBwbGFjZXMgYW5kIGN1bHR1cmUgYW5kIGhpc3RvcnkgbGlua2VkIHRvIHRoZW0uIEl0cyBhIGRheS1sb25nIHRvdXIgcGFja2FnZSB3ZSBlbmpveWVkLjwhLS0gUi1DT05URU5UIC0tPjwvZGl2PiA8c3BhbiBjbGFzcz0idGktcmVhZC1tb3JlIiBkYXRhLWNvbnRhaW5lcj0iLnRpLXJldmlldy1jb250ZW50IiBkYXRhLWNvbGxhcHNlLXRleHQ9IkhpZGUiIGRhdGEtb3Blbi10ZXh0PSJSZWFkIG1vcmUiID48L3NwYW4+IDwvZGl2PiA8L2Rpdj4gIDxkaXYgZGF0YS1lbXB0eT0iMCIgY2xhc3M9InRpLXJldmlldy1pdGVtIHNvdXJjZS1UcmlwYWR2aXNvciB0aS1pbWFnZS1sYXlvdXQtdGh1bWJuYWlsIiBkYXRhLWlkPSJjZmNkMjA4NDk1ZDU2NWVmNjZlN2RmZjlmOTg3NjRkYSIgPiA8ZGl2IGNsYXNzPSJ0aS1pbm5lciI+IDxkaXYgY2xhc3M9InRpLXJldmlldy1oZWFkZXIiPiA8dHJ1c3RpbmRleC1pbWFnZSBjbGFzcz0idGktcGxhdGZvcm0taWNvbiIgZGF0YS1pbWd1cmw9Imh0dHBzOi8vY2RuLnRydXN0aW5kZXguaW8vYXNzZXRzL3BsYXRmb3JtL1RyaXBhZHZpc29yL2ljb24uc3ZnIiBhbHQ9IlRyaXBhZHZpc29yIiB3aWR0aD0iMjAiIGhlaWdodD0iMjAiIGxvYWRpbmc9ImxhenkiID48L3RydXN0aW5kZXgtaW1hZ2U+IDxkaXYgY2xhc3M9InRpLXByb2ZpbGUtaW1nIj4gPHRydXN0aW5kZXgtaW1hZ2UgZGF0YS1pbWd1cmw9Imh0dHBzOi8vbWVkaWEtY2RuLnRyaXBhZHZpc29yLmNvbS9tZWRpYS9waG90by1vLzFhL2Y2L2VlLzEwL2RlZmF1bHQtYXZhdGFyLTIwMjAtOC5qcGciIGRhdGEtaW1ndXJsc2V0PSJodHRwczovL21lZGlhLWNkbi50cmlwYWR2aXNvci5jb20vbWVkaWEvcGhvdG8tby8xYS9mNi9lZS8xMC9kZWZhdWx0LWF2YXRhci0yMDIwLTguanBnIDJ4IiBhbHQ9IlJhaiBHIiBsb2FkaW5nPSJsYXp5IiA+PC90cnVzdGluZGV4LWltYWdlPiA8L2Rpdj4gPGRpdiBjbGFzcz0idGktcHJvZmlsZS1kZXRhaWxzIj4gPGRpdiBjbGFzcz0idGktbmFtZSI+IFJhaiBHIDwvZGl2PiA8ZGl2IGNsYXNzPSJ0aS1kYXRlIj4yMDIwLTAzLTEyPC9kaXY+IDwvZGl2PiA8L2Rpdj4gPHNwYW4gY2xhc3M9InRpLXN0YXJzIj48dHJ1c3RpbmRleC1pbWFnZSBjbGFzcz0idGktc3RhciIgZGF0YS1pbWd1cmw9Imh0dHBzOi8vY2RuLnRydXN0aW5kZXguaW8vYXNzZXRzL3BsYXRmb3JtL1RyaXBhZHZpc29yL3N0YXIvZi5zdmciIGFsdD0iVHJpcGFkdmlzb3IiIHdpZHRoPSIxNyIgaGVpZ2h0PSIxNyIgbG9hZGluZz0ibGF6eSIgPjwvdHJ1c3RpbmRleC1pbWFnZT48dHJ1c3RpbmRleC1pbWFnZSBjbGFzcz0idGktc3RhciIgZGF0YS1pbWd1cmw9Imh0dHBzOi8vY2RuLnRydXN0aW5kZXguaW8vYXNzZXRzL3BsYXRmb3JtL1RyaXBhZHZpc29yL3N0YXIvZi5zdmciIGFsdD0iVHJpcGFkdmlzb3IiIHdpZHRoPSIxNyIgaGVpZ2h0PSIxNyIgbG9hZGluZz0ibGF6eSIgPjwvdHJ1c3RpbmRleC1pbWFnZT48dHJ1c3RpbmRleC1pbWFnZSBjbGFzcz0idGktc3RhciIgZGF0YS1pbWd1cmw9Imh0dHBzOi8vY2RuLnRydXN0aW5kZXguaW8vYXNzZXRzL3BsYXRmb3JtL1RyaXBhZHZpc29yL3N0YXIvZi5zdmciIGFsdD0iVHJpcGFkdmlzb3IiIHdpZHRoPSIxNyIgaGVpZ2h0PSIxNyIgbG9hZGluZz0ibGF6eSIgPjwvdHJ1c3RpbmRleC1pbWFnZT48dHJ1c3RpbmRleC1pbWFnZSBjbGFzcz0idGktc3RhciIgZGF0YS1pbWd1cmw9Imh0dHBzOi8vY2RuLnRydXN0aW5kZXguaW8vYXNzZXRzL3BsYXRmb3JtL1RyaXBhZHZpc29yL3N0YXIvZi5zdmciIGFsdD0iVHJpcGFkdmlzb3IiIHdpZHRoPSIxNyIgaGVpZ2h0PSIxNyIgbG9hZGluZz0ibGF6eSIgPjwvdHJ1c3RpbmRleC1pbWFnZT48dHJ1c3RpbmRleC1pbWFnZSBjbGFzcz0idGktc3RhciIgZGF0YS1pbWd1cmw9Imh0dHBzOi8vY2RuLnRydXN0aW5kZXguaW8vYXNzZXRzL3BsYXRmb3JtL1RyaXBhZHZpc29yL3N0YXIvZi5zdmciIGFsdD0iVHJpcGFkdmlzb3IiIHdpZHRoPSIxNyIgaGVpZ2h0PSIxNyIgbG9hZGluZz0ibGF6eSIgPjwvdHJ1c3RpbmRleC1pbWFnZT48L3NwYW4+IDxkaXYgY2xhc3M9InRpLXJldmlldy10ZXh0LWNvbnRhaW5lciB0aS1yZXZpZXctY29udGVudCI+PCEtLSBSLUNPTlRFTlQgLS0+PHN0cm9uZz5Xb3JrICB2YWNhdGlvbiAgIEZ1bjwvc3Ryb25nPgpIaW1hbCB0b3VyaXNtIGRpZCBldmVyeXRoaW5nIGxpa2UgYSBmYW1pbHkuIEtyaXNobmEgd2FzIGFtYXppbmcgYW5kIHdhcyBhbHdheXMgdGhlcmUgZm9yIHVzIGluIGFueSBuZWVkLiBOZXZlciAgQXQgYW55IHBvaW50IGluIG91ciAxMCBkYXlzIHZpc2l0IGhlIG1hZGUgdXMgZmVlbCB0aGF0IHdlIHIgbm90IGZhbWlseS4gVGhleSBtYWtlIGV2ZXJ5IGVmZm9ydCB0byBoZWxwIHlvdS4gU2VydmljZXMgd2VyZSB0aW1lbHkgYW5kIHdpdGggc3BlY2lhbCB0b3VjaGVzLiBXZSB3ZXJlIGFsc28gdGhlcmUgZm9yIGEgbW92aWUgc2hvb3QgYW5kIHRoZXkgaGVscGVkIHVzIGluIGFsbC4gR3JlYXQgam9iICBoaWdobHkgcmVjb21tZW5kZWQ8IS0tIFItQ09OVEVOVCAtLT48L2Rpdj4gPHNwYW4gY2xhc3M9InRpLXJlYWQtbW9yZSIgZGF0YS1jb250YWluZXI9Ii50aS1yZXZpZXctY29udGVudCIgZGF0YS1jb2xsYXBzZS10ZXh0PSJIaWRlIiBkYXRhLW9wZW4tdGV4dD0iUmVhZCBtb3JlIiA+PC9zcGFuPiA8L2Rpdj4gPC9kaXY+ICA8ZGl2IGRhdGEtZW1wdHk9IjAiIGNsYXNzPSJ0aS1yZXZpZXctaXRlbSBzb3VyY2UtVHJpcGFkdmlzb3IgdGktaW1hZ2UtbGF5b3V0LXRodW1ibmFpbCIgZGF0YS1pZD0iY2ZjZDIwODQ5NWQ1NjVlZjY2ZTdkZmY5Zjk4NzY0ZGEiID4gPGRpdiBjbGFzcz0idGktaW5uZXIiPiA8ZGl2IGNsYXNzPSJ0aS1yZXZpZXctaGVhZGVyIj4gPHRydXN0aW5kZXgtaW1hZ2UgY2xhc3M9InRpLXBsYXRmb3JtLWljb24iIGRhdGEtaW1ndXJsPSJodHRwczovL2Nkbi50cnVzdGluZGV4LmlvL2Fzc2V0cy9wbGF0Zm9ybS9UcmlwYWR2aXNvci9pY29uLnN2ZyIgYWx0PSJUcmlwYWR2aXNvciIgd2lkdGg9IjIwIiBoZWlnaHQ9IjIwIiBsb2FkaW5nPSJsYXp5IiA+PC90cnVzdGluZGV4LWltYWdlPiA8ZGl2IGNsYXNzPSJ0aS1wcm9maWxlLWltZyI+IDx0cnVzdGluZGV4LWltYWdlIGRhdGEtaW1ndXJsPSJodHRwczovL21lZGlhLWNkbi50cmlwYWR2aXNvci5jb20vbWVkaWEvcGhvdG8tby8xYS9mNi9kZS81YS9kZWZhdWx0LWF2YXRhci0yMDIwLTM2LmpwZyIgZGF0YS1pbWd1cmxzZXQ9Imh0dHBzOi8vbWVkaWEtY2RuLnRyaXBhZHZpc29yLmNvbS9tZWRpYS9waG90by1vLzFhL2Y2L2RlLzVhL2RlZmF1bHQtYXZhdGFyLTIwMjAtMzYuanBnIDJ4IiBhbHQ9IkFoc2FuIEEiIGxvYWRpbmc9ImxhenkiID48L3RydXN0aW5kZXgtaW1hZ2U+IDwvZGl2PiA8ZGl2IGNsYXNzPSJ0aS1wcm9maWxlLWRldGFpbHMiPiA8ZGl2IGNsYXNzPSJ0aS1uYW1lIj4gQWhzYW4gQSA8L2Rpdj4gPGRpdiBjbGFzcz0idGktZGF0ZSI+MjAyMC0wMy0wNjwvZGl2PiA8L2Rpdj4gPC9kaXY+IDxzcGFuIGNsYXNzPSJ0aS1zdGFycyI+PHRydXN0aW5kZXgtaW1hZ2UgY2xhc3M9InRpLXN0YXIiIGRhdGEtaW1ndXJsPSJodHRwczovL2Nkbi50cnVzdGluZGV4LmlvL2Fzc2V0cy9wbGF0Zm9ybS9UcmlwYWR2aXNvci9zdGFyL2Yuc3ZnIiBhbHQ9IlRyaXBhZHZpc29yIiB3aWR0aD0iMTciIGhlaWdodD0iMTciIGxvYWRpbmc9ImxhenkiID48L3RydXN0aW5kZXgtaW1hZ2U+PHRydXN0aW5kZXgtaW1hZ2UgY2xhc3M9InRpLXN0YXIiIGRhdGEtaW1ndXJsPSJodHRwczovL2Nkbi50cnVzdGluZGV4LmlvL2Fzc2V0cy9wbGF0Zm9ybS9UcmlwYWR2aXNvci9zdGFyL2Yuc3ZnIiBhbHQ9IlRyaXBhZHZpc29yIiB3aWR0aD0iMTciIGhlaWdodD0iMTciIGxvYWRpbmc9ImxhenkiID48L3RydXN0aW5kZXgtaW1hZ2U+PHRydXN0aW5kZXgtaW1hZ2UgY2xhc3M9InRpLXN0YXIiIGRhdGEtaW1ndXJsPSJodHRwczovL2Nkbi50cnVzdGluZGV4LmlvL2Fzc2V0cy9wbGF0Zm9ybS9UcmlwYWR2aXNvci9zdGFyL2Yuc3ZnIiBhbHQ9IlRyaXBhZHZpc29yIiB3aWR0aD0iMTciIGhlaWdodD0iMTciIGxvYWRpbmc9ImxhenkiID48L3RydXN0aW5kZXgtaW1hZ2U+PHRydXN0aW5kZXgtaW1hZ2UgY2xhc3M9InRpLXN0YXIiIGRhdGEtaW1ndXJsPSJodHRwczovL2Nkbi50cnVzdGluZGV4LmlvL2Fzc2V0cy9wbGF0Zm9ybS9UcmlwYWR2aXNvci9zdGFyL2Yuc3ZnIiBhbHQ9IlRyaXBhZHZpc29yIiB3aWR0aD0iMTciIGhlaWdodD0iMTciIGxvYWRpbmc9ImxhenkiID48L3RydXN0aW5kZXgtaW1hZ2U+PHRydXN0aW5kZXgtaW1hZ2UgY2xhc3M9InRpLXN0YXIiIGRhdGEtaW1ndXJsPSJodHRwczovL2Nkbi50cnVzdGluZGV4LmlvL2Fzc2V0cy9wbGF0Zm9ybS9UcmlwYWR2aXNvci9zdGFyL2Yuc3ZnIiBhbHQ9IlRyaXBhZHZpc29yIiB3aWR0aD0iMTciIGhlaWdodD0iMTciIGxvYWRpbmc9ImxhenkiID48L3RydXN0aW5kZXgtaW1hZ2U+PC9zcGFuPiA8ZGl2IGNsYXNzPSJ0aS1yZXZpZXctdGV4dC1jb250YWluZXIgdGktcmV2aWV3LWNvbnRlbnQiPjwhLS0gUi1DT05URU5UIC0tPjxzdHJvbmc+TWFrZSBhIG1vdmllIGluIEthdGhtYW5kdSBoZXJpdGFnZSBzaXRlcyBpcyBhd2Vzb21lPC9zdHJvbmc+CkknbSBhIG1vdmllIGFuZCBmaWxtIGRpcmVjdG9yIG1ha2UgYSBtb3ZpZSBpbiBLYXRobWFuZHUgd29ybGQgaGVyaXRhZ2Ugc2l0ZXMgaXMgb25lIG9mIHRoZSBiZXN0IGxvY2F0aW9uIGluIEFzaWEud2UgaGFkIHJlY2VudGx5IGRvaW5nIEJvbGx5d29vZCBmaWxtICJIYXRob24ga2kgTGFrZWVyZW4iIGluIEthdGhtYW5kdS5IaW1hbCBUb3VyaXNtIG9yZ2FuaXplIGV2ZXJ5dGhpbmcgQ2FtZXJhbWVuLEFydGlzdHMgZHVyaW5nIG91ciBzdGF5IGluIE5lcGFsLlRoZXkgZHVkIHJlYWxreSBnb29kIGpvYi5UaGFua3MgZmlyIHNlcnZpY2Uncy48IS0tIFItQ09OVEVOVCAtLT48L2Rpdj4gPHNwYW4gY2xhc3M9InRpLXJlYWQtbW9yZSIgZGF0YS1jb250YWluZXI9Ii50aS1yZXZpZXctY29udGVudCIgZGF0YS1jb2xsYXBzZS10ZXh0PSJIaWRlIiBkYXRhLW9wZW4tdGV4dD0iUmVhZCBtb3JlIiA+PC9zcGFuPiA8L2Rpdj4gPC9kaXY+ICA8ZGl2IGRhdGEtZW1wdHk9IjAiIGNsYXNzPSJ0aS1yZXZpZXctaXRlbSBzb3VyY2UtVHJpcGFkdmlzb3IgdGktaW1hZ2UtbGF5b3V0LXRodW1ibmFpbCIgZGF0YS1pZD0iY2ZjZDIwODQ5NWQ1NjVlZjY2ZTdkZmY5Zjk4NzY0ZGEiID4gPGRpdiBjbGFzcz0idGktaW5uZXIiPiA8ZGl2IGNsYXNzPSJ0aS1yZXZpZXctaGVhZGVyIj4gPHRydXN0aW5kZXgtaW1hZ2UgY2xhc3M9InRpLXBsYXRmb3JtLWljb24iIGRhdGEtaW1ndXJsPSJodHRwczovL2Nkbi50cnVzdGluZGV4LmlvL2Fzc2V0cy9wbGF0Zm9ybS9UcmlwYWR2aXNvci9pY29uLnN2ZyIgYWx0PSJUcmlwYWR2aXNvciIgd2lkdGg9IjIwIiBoZWlnaHQ9IjIwIiBsb2FkaW5nPSJsYXp5IiA+PC90cnVzdGluZGV4LWltYWdlPiA8ZGl2IGNsYXNzPSJ0aS1wcm9maWxlLWltZyI+IDx0cnVzdGluZGV4LWltYWdlIGRhdGEtaW1ndXJsPSJodHRwczovL21lZGlhLWNkbi50cmlwYWR2aXNvci5jb20vbWVkaWEvcGhvdG8tby8xYS9mNi9mMy9lNC9kZWZhdWx0LWF2YXRhci0yMDIwLTMwLmpwZyIgZGF0YS1pbWd1cmxzZXQ9Imh0dHBzOi8vbWVkaWEtY2RuLnRyaXBhZHZpc29yLmNvbS9tZWRpYS9waG90by1vLzFhL2Y2L2YzL2U0L2RlZmF1bHQtYXZhdGFyLTIwMjAtMzAuanBnIDJ4IiBhbHQ9IkpvaG4gU21pdGgiIGxvYWRpbmc9ImxhenkiID48L3RydXN0aW5kZXgtaW1hZ2U+IDwvZGl2PiA8ZGl2IGNsYXNzPSJ0aS1wcm9maWxlLWRldGFpbHMiPiA8ZGl2IGNsYXNzPSJ0aS1uYW1lIj4gSm9obiBTbWl0aCA8L2Rpdj4gPGRpdiBjbGFzcz0idGktZGF0ZSI+MjAyMC0wMy0wNTwvZGl2PiA8L2Rpdj4gPC9kaXY+IDxzcGFuIGNsYXNzPSJ0aS1zdGFycyI+PHRydXN0aW5kZXgtaW1hZ2UgY2xhc3M9InRpLXN0YXIiIGRhdGEtaW1ndXJsPSJodHRwczovL2Nkbi50cnVzdGluZGV4LmlvL2Fzc2V0cy9wbGF0Zm9ybS9UcmlwYWR2aXNvci9zdGFyL2Yuc3ZnIiBhbHQ9IlRyaXBhZHZpc29yIiB3aWR0aD0iMTciIGhlaWdodD0iMTciIGxvYWRpbmc9ImxhenkiID48L3RydXN0aW5kZXgtaW1hZ2U+PHRydXN0aW5kZXgtaW1hZ2UgY2xhc3M9InRpLXN0YXIiIGRhdGEtaW1ndXJsPSJodHRwczovL2Nkbi50cnVzdGluZGV4LmlvL2Fzc2V0cy9wbGF0Zm9ybS9UcmlwYWR2aXNvci9zdGFyL2Yuc3ZnIiBhbHQ9IlRyaXBhZHZpc29yIiB3aWR0aD0iMTciIGhlaWdodD0iMTciIGxvYWRpbmc9ImxhenkiID48L3RydXN0aW5kZXgtaW1hZ2U+PHRydXN0aW5kZXgtaW1hZ2UgY2xhc3M9InRpLXN0YXIiIGRhdGEtaW1ndXJsPSJodHRwczovL2Nkbi50cnVzdGluZGV4LmlvL2Fzc2V0cy9wbGF0Zm9ybS9UcmlwYWR2aXNvci9zdGFyL2Yuc3ZnIiBhbHQ9IlRyaXBhZHZpc29yIiB3aWR0aD0iMTciIGhlaWdodD0iMTciIGxvYWRpbmc9ImxhenkiID48L3RydXN0aW5kZXgtaW1hZ2U+PHRydXN0aW5kZXgtaW1hZ2UgY2xhc3M9InRpLXN0YXIiIGRhdGEtaW1ndXJsPSJodHRwczovL2Nkbi50cnVzdGluZGV4LmlvL2Fzc2V0cy9wbGF0Zm9ybS9UcmlwYWR2aXNvci9zdGFyL2Yuc3ZnIiBhbHQ9IlRyaXBhZHZpc29yIiB3aWR0aD0iMTciIGhlaWdodD0iMTciIGxvYWRpbmc9ImxhenkiID48L3RydXN0aW5kZXgtaW1hZ2U+PHRydXN0aW5kZXgtaW1hZ2UgY2xhc3M9InRpLXN0YXIiIGRhdGEtaW1ndXJsPSJodHRwczovL2Nkbi50cnVzdGluZGV4LmlvL2Fzc2V0cy9wbGF0Zm9ybS9UcmlwYWR2aXNvci9zdGFyL2Yuc3ZnIiBhbHQ9IlRyaXBhZHZpc29yIiB3aWR0aD0iMTciIGhlaWdodD0iMTciIGxvYWRpbmc9ImxhenkiID48L3RydXN0aW5kZXgtaW1hZ2U+PC9zcGFuPiA8ZGl2IGNsYXNzPSJ0aS1yZXZpZXctdGV4dC1jb250YWluZXIgdGktcmV2aWV3LWNvbnRlbnQiPjwhLS0gUi1DT05URU5UIC0tPjxzdHJvbmc+QmVzdCBFeHBlcmllbmNlZCBpbiBzdW5yaXNlIGFuZCBoaWtpbmc8L3N0cm9uZz4KV2UgaGFkIGZhbnRpc3RpYyB0aW1lIHdpdGggZnJpZW5kcyBpbiBzdW5yaXNlIGFuZCBkYXkgaGlrZSB0byBjaGFuZ3VuYXJheWFuLiBHdWlkZSBoYXMgMTAgeWVhcnMgZXhwZXJpZW5jZSBzdW5yaXNlIGluIGhpbWFsYXlhcyB3YXMgYXdlc29tZS5UaGFua3Nmb3IgYXJyYW5nZSBldmVyeSB0aGluZ3MgSGltYWwgVG91cmltLjwhLS0gUi1DT05URU5UIC0tPjwvZGl2PiA8c3BhbiBjbGFzcz0idGktcmVhZC1tb3JlIiBkYXRhLWNvbnRhaW5lcj0iLnRpLXJldmlldy1jb250ZW50IiBkYXRhLWNvbGxhcHNlLXRleHQ9IkhpZGUiIGRhdGEtb3Blbi10ZXh0PSJSZWFkIG1vcmUiID48L3NwYW4+IDwvZGl2PiA8L2Rpdj4gIDxkaXYgZGF0YS1lbXB0eT0iMCIgY2xhc3M9InRpLXJldmlldy1pdGVtIHNvdXJjZS1UcmlwYWR2aXNvciB0aS1pbWFnZS1sYXlvdXQtdGh1bWJuYWlsIiBkYXRhLWlkPSJjZmNkMjA4NDk1ZDU2NWVmNjZlN2RmZjlmOTg3NjRkYSIgPiA8ZGl2IGNsYXNzPSJ0aS1pbm5lciI+IDxkaXYgY2xhc3M9InRpLXJldmlldy1oZWFkZXIiPiA8dHJ1c3RpbmRleC1pbWFnZSBjbGFzcz0idGktcGxhdGZvcm0taWNvbiIgZGF0YS1pbWd1cmw9Imh0dHBzOi8vY2RuLnRydXN0aW5kZXguaW8vYXNzZXRzL3BsYXRmb3JtL1RyaXBhZHZpc29yL2ljb24uc3ZnIiBhbHQ9IlRyaXBhZHZpc29yIiB3aWR0aD0iMjAiIGhlaWdodD0iMjAiIGxvYWRpbmc9ImxhenkiID48L3RydXN0aW5kZXgtaW1hZ2U+IDxkaXYgY2xhc3M9InRpLXByb2ZpbGUtaW1nIj4gPHRydXN0aW5kZXgtaW1hZ2UgZGF0YS1pbWd1cmw9Imh0dHBzOi8vbWVkaWEtY2RuLnRyaXBhZHZpc29yLmNvbS9tZWRpYS9waG90by1vLzFhL2Y2L2YzLzIzL2RlZmF1bHQtYXZhdGFyLTIwMjAtMjguanBnIiBkYXRhLWltZ3VybHNldD0iaHR0cHM6Ly9tZWRpYS1jZG4udHJpcGFkdmlzb3IuY29tL21lZGlhL3Bob3RvLW8vMWEvZjYvZjMvMjMvZGVmYXVsdC1hdmF0YXItMjAyMC0yOC5qcGcgMngiIGFsdD0iQmlqYXkiIGxvYWRpbmc9ImxhenkiID48L3RydXN0aW5kZXgtaW1hZ2U+IDwvZGl2PiA8ZGl2IGNsYXNzPSJ0aS1wcm9maWxlLWRldGFpbHMiPiA8ZGl2IGNsYXNzPSJ0aS1uYW1lIj4gQmlqYXkgPC9kaXY+IDxkaXYgY2xhc3M9InRpLWRhdGUiPjIwMjAtMDItMjU8L2Rpdj4gPC9kaXY+IDwvZGl2PiA8c3BhbiBjbGFzcz0idGktc3RhcnMiPjx0cnVzdGluZGV4LWltYWdlIGNsYXNzPSJ0aS1zdGFyIiBkYXRhLWltZ3VybD0iaHR0cHM6Ly9jZG4udHJ1c3RpbmRleC5pby9hc3NldHMvcGxhdGZvcm0vVHJpcGFkdmlzb3Ivc3Rhci9mLnN2ZyIgYWx0PSJUcmlwYWR2aXNvciIgd2lkdGg9IjE3IiBoZWlnaHQ9IjE3IiBsb2FkaW5nPSJsYXp5IiA+PC90cnVzdGluZGV4LWltYWdlPjx0cnVzdGluZGV4LWltYWdlIGNsYXNzPSJ0aS1zdGFyIiBkYXRhLWltZ3VybD0iaHR0cHM6Ly9jZG4udHJ1c3RpbmRleC5pby9hc3NldHMvcGxhdGZvcm0vVHJpcGFkdmlzb3Ivc3Rhci9mLnN2ZyIgYWx0PSJUcmlwYWR2aXNvciIgd2lkdGg9IjE3IiBoZWlnaHQ9IjE3IiBsb2FkaW5nPSJsYXp5IiA+PC90cnVzdGluZGV4LWltYWdlPjx0cnVzdGluZGV4LWltYWdlIGNsYXNzPSJ0aS1zdGFyIiBkYXRhLWltZ3VybD0iaHR0cHM6Ly9jZG4udHJ1c3RpbmRleC5pby9hc3NldHMvcGxhdGZvcm0vVHJpcGFkdmlzb3Ivc3Rhci9mLnN2ZyIgYWx0PSJUcmlwYWR2aXNvciIgd2lkdGg9IjE3IiBoZWlnaHQ9IjE3IiBsb2FkaW5nPSJsYXp5IiA+PC90cnVzdGluZGV4LWltYWdlPjx0cnVzdGluZGV4LWltYWdlIGNsYXNzPSJ0aS1zdGFyIiBkYXRhLWltZ3VybD0iaHR0cHM6Ly9jZG4udHJ1c3RpbmRleC5pby9hc3NldHMvcGxhdGZvcm0vVHJpcGFkdmlzb3Ivc3Rhci9mLnN2ZyIgYWx0PSJUcmlwYWR2aXNvciIgd2lkdGg9IjE3IiBoZWlnaHQ9IjE3IiBsb2FkaW5nPSJsYXp5IiA+PC90cnVzdGluZGV4LWltYWdlPjx0cnVzdGluZGV4LWltYWdlIGNsYXNzPSJ0aS1zdGFyIiBkYXRhLWltZ3VybD0iaHR0cHM6Ly9jZG4udHJ1c3RpbmRleC5pby9hc3NldHMvcGxhdGZvcm0vVHJpcGFkdmlzb3Ivc3Rhci9mLnN2ZyIgYWx0PSJUcmlwYWR2aXNvciIgd2lkdGg9IjE3IiBoZWlnaHQ9IjE3IiBsb2FkaW5nPSJsYXp5IiA+PC90cnVzdGluZGV4LWltYWdlPjwvc3Bhbj4gPGRpdiBjbGFzcz0idGktcmV2aWV3LXRleHQtY29udGFpbmVyIHRpLXJldmlldy1jb250ZW50Ij48IS0tIFItQ09OVEVOVCAtLT48c3Ryb25nPk9uZSBvZiB0aGUgYmVzdCE8L3N0cm9uZz4KSSB2aXNpdGVkICBuYXJnYXJrb3QgY2hhbmp1bmFyYXlhbiAgaGlraW5nIERlY2VtYmVyMjAxOS4gSXQgd2FzIGludGVyZXN0aW5nIHRvIHNlZSB0aGUgY3VsdHVyZSBhbmQgbGlmZXN0eWxlIG9mIE5lcGFsaSAudGhlIHNub3ctY2FwcGVkIHBlYWtzIG9mIHRoZSBtb3VudGFpbnMhISEgIDM2MCBkZWdyZWUsICByZWFsbHkgbmljZSB2aWV3cyBvZiB2aWV3IHBvaW50IHRvd2VyLiBIaWdobHkgcmVjb21tZW5kZWQgaGltYWwgdG91cmlzbS48IS0tIFItQ09OVEVOVCAtLT48L2Rpdj4gPHNwYW4gY2xhc3M9InRpLXJlYWQtbW9yZSIgZGF0YS1jb250YWluZXI9Ii50aS1yZXZpZXctY29udGVudCIgZGF0YS1jb2xsYXBzZS10ZXh0PSJIaWRlIiBkYXRhLW9wZW4tdGV4dD0iUmVhZCBtb3JlIiA+PC9zcGFuPiA8L2Rpdj4gPC9kaXY+ICA8ZGl2IGRhdGEtZW1wdHk9IjAiIGNsYXNzPSJ0aS1yZXZpZXctaXRlbSBzb3VyY2UtVHJpcGFkdmlzb3IgdGktaW1hZ2UtbGF5b3V0LXRodW1ibmFpbCIgZGF0YS1pZD0iY2ZjZDIwODQ5NWQ1NjVlZjY2ZTdkZmY5Zjk4NzY0ZGEiID4gPGRpdiBjbGFzcz0idGktaW5uZXIiPiA8ZGl2IGNsYXNzPSJ0aS1yZXZpZXctaGVhZGVyIj4gPHRydXN0aW5kZXgtaW1hZ2UgY2xhc3M9InRpLXBsYXRmb3JtLWljb24iIGRhdGEtaW1ndXJsPSJodHRwczovL2Nkbi50cnVzdGluZGV4LmlvL2Fzc2V0cy9wbGF0Zm9ybS9UcmlwYWR2aXNvci9pY29uLnN2ZyIgYWx0PSJUcmlwYWR2aXNvciIgd2lkdGg9IjIwIiBoZWlnaHQ9IjIwIiBsb2FkaW5nPSJsYXp5IiA+PC90cnVzdGluZGV4LWltYWdlPiA8ZGl2IGNsYXNzPSJ0aS1wcm9maWxlLWltZyI+IDx0cnVzdGluZGV4LWltYWdlIGRhdGEtaW1ndXJsPSJodHRwczovL21lZGlhLWNkbi50cmlwYWR2aXNvci5jb20vbWVkaWEvcGhvdG8tby8xYS9mNi9lNy85OS9kZWZhdWx0LWF2YXRhci0yMDIwLTU3LmpwZyIgZGF0YS1pbWd1cmxzZXQ9Imh0dHBzOi8vbWVkaWEtY2RuLnRyaXBhZHZpc29yLmNvbS9tZWRpYS9waG90by1vLzFhL2Y2L2U3Lzk5L2RlZmF1bHQtYXZhdGFyLTIwMjAtNTcuanBnIDJ4IiBhbHQ9IlNhYmk3NyIgbG9hZGluZz0ibGF6eSIgPjwvdHJ1c3RpbmRleC1pbWFnZT4gPC9kaXY+IDxkaXYgY2xhc3M9InRpLXByb2ZpbGUtZGV0YWlscyI+IDxkaXYgY2xhc3M9InRpLW5hbWUiPiBTYWJpNzcgPC9kaXY+IDxkaXYgY2xhc3M9InRpLWRhdGUiPjIwMjAtMDItMjI8L2Rpdj4gPC9kaXY+IDwvZGl2PiA8c3BhbiBjbGFzcz0idGktc3RhcnMiPjx0cnVzdGluZGV4LWltYWdlIGNsYXNzPSJ0aS1zdGFyIiBkYXRhLWltZ3VybD0iaHR0cHM6Ly9jZG4udHJ1c3RpbmRleC5pby9hc3NldHMvcGxhdGZvcm0vVHJpcGFkdmlzb3Ivc3Rhci9mLnN2ZyIgYWx0PSJUcmlwYWR2aXNvciIgd2lkdGg9IjE3IiBoZWlnaHQ9IjE3IiBsb2FkaW5nPSJsYXp5IiA+PC90cnVzdGluZGV4LWltYWdlPjx0cnVzdGluZGV4LWltYWdlIGNsYXNzPSJ0aS1zdGFyIiBkYXRhLWltZ3VybD0iaHR0cHM6Ly9jZG4udHJ1c3RpbmRleC5pby9hc3NldHMvcGxhdGZvcm0vVHJpcGFkdmlzb3Ivc3Rhci9mLnN2ZyIgYWx0PSJUcmlwYWR2aXNvciIgd2lkdGg9IjE3IiBoZWlnaHQ9IjE3IiBsb2FkaW5nPSJsYXp5IiA+PC90cnVzdGluZGV4LWltYWdlPjx0cnVzdGluZGV4LWltYWdlIGNsYXNzPSJ0aS1zdGFyIiBkYXRhLWltZ3VybD0iaHR0cHM6Ly9jZG4udHJ1c3RpbmRleC5pby9hc3NldHMvcGxhdGZvcm0vVHJpcGFkdmlzb3Ivc3Rhci9mLnN2ZyIgYWx0PSJUcmlwYWR2aXNvciIgd2lkdGg9IjE3IiBoZWlnaHQ9IjE3IiBsb2FkaW5nPSJsYXp5IiA+PC90cnVzdGluZGV4LWltYWdlPjx0cnVzdGluZGV4LWltYWdlIGNsYXNzPSJ0aS1zdGFyIiBkYXRhLWltZ3VybD0iaHR0cHM6Ly9jZG4udHJ1c3RpbmRleC5pby9hc3NldHMvcGxhdGZvcm0vVHJpcGFkdmlzb3Ivc3Rhci9mLnN2ZyIgYWx0PSJUcmlwYWR2aXNvciIgd2lkdGg9IjE3IiBoZWlnaHQ9IjE3IiBsb2FkaW5nPSJsYXp5IiA+PC90cnVzdGluZGV4LWltYWdlPjx0cnVzdGluZGV4LWltYWdlIGNsYXNzPSJ0aS1zdGFyIiBkYXRhLWltZ3VybD0iaHR0cHM6Ly9jZG4udHJ1c3RpbmRleC5pby9hc3NldHMvcGxhdGZvcm0vVHJpcGFkdmlzb3Ivc3Rhci9mLnN2ZyIgYWx0PSJUcmlwYWR2aXNvciIgd2lkdGg9IjE3IiBoZWlnaHQ9IjE3IiBsb2FkaW5nPSJsYXp5IiA+PC90cnVzdGluZGV4LWltYWdlPjwvc3Bhbj4gPGRpdiBjbGFzcz0idGktcmV2aWV3LXRleHQtY29udGFpbmVyIHRpLXJldmlldy1jb250ZW50Ij48IS0tIFItQ09OVEVOVCAtLT48c3Ryb25nPkF3ZXNvbWUgU2VydmljZTwvc3Ryb25nPgpXZSBoYWQgZmFtaWx5IHRyaXAgdG8gS2F0aG1hbmR1IFdvcmxkIEhlcmlhdGdlIHRvdXIgcHJvdmlkZSBieSBIaW1hbCBUb3VyaXNtLiBUaGV5IHByb3ZpZGUgZXhjZWxsZW50IGFuZCBleHBlcnQgdG91ciBndWlkZSBhbmQgZHJpdmVyLCB3ZSBoYWQgZW5qb3llZCBvdXIgZGF5IHRvdXIgaW4gS2F0aG1hbmR1IFdvcmxkIEhlcml0YWdlIHRvdXIgLlRoYW5rIHlvdSB2ZXJ5IG11Y2ggSGltYWwgVG91cmlzbS4gSGlnaGx5IHJlY29tbWVuZGVkLjwhLS0gUi1DT05URU5UIC0tPjwvZGl2PiA8c3BhbiBjbGFzcz0idGktcmVhZC1tb3JlIiBkYXRhLWNvbnRhaW5lcj0iLnRpLXJldmlldy1jb250ZW50IiBkYXRhLWNvbGxhcHNlLXRleHQ9IkhpZGUiIGRhdGEtb3Blbi10ZXh0PSJSZWFkIG1vcmUiID48L3NwYW4+IDwvZGl2PiA8L2Rpdj4gIDxkaXYgZGF0YS1lbXB0eT0iMCIgY2xhc3M9InRpLXJldmlldy1pdGVtIHNvdXJjZS1UcmlwYWR2aXNvciB0aS1pbWFnZS1sYXlvdXQtdGh1bWJuYWlsIiBkYXRhLWlkPSJjZmNkMjA4NDk1ZDU2NWVmNjZlN2RmZjlmOTg3NjRkYSIgPiA8ZGl2IGNsYXNzPSJ0aS1pbm5lciI+IDxkaXYgY2xhc3M9InRpLXJldmlldy1oZWFkZXIiPiA8dHJ1c3RpbmRleC1pbWFnZSBjbGFzcz0idGktcGxhdGZvcm0taWNvbiIgZGF0YS1pbWd1cmw9Imh0dHBzOi8vY2RuLnRydXN0aW5kZXguaW8vYXNzZXRzL3BsYXRmb3JtL1RyaXBhZHZpc29yL2ljb24uc3ZnIiBhbHQ9IlRyaXBhZHZpc29yIiB3aWR0aD0iMjAiIGhlaWdodD0iMjAiIGxvYWRpbmc9ImxhenkiID48L3RydXN0aW5kZXgtaW1hZ2U+IDxkaXYgY2xhc3M9InRpLXByb2ZpbGUtaW1nIj4gPHRydXN0aW5kZXgtaW1hZ2UgZGF0YS1pbWd1cmw9Imh0dHBzOi8vbWVkaWEtY2RuLnRyaXBhZHZpc29yLmNvbS9tZWRpYS9waG90by13LzEyLzliLzVmLzFmL21yaGFwcHloYXBweS5qcGciIGRhdGEtaW1ndXJsc2V0PSJodHRwczovL21lZGlhLWNkbi50cmlwYWR2aXNvci5jb20vbWVkaWEvcGhvdG8tdy8xMi85Yi81Zi8xZi9tcmhhcHB5aGFwcHkuanBnIDJ4IiBhbHQ9IkhhcnJ5IEgiIGxvYWRpbmc9ImxhenkiID48L3RydXN0aW5kZXgtaW1hZ2U+IDwvZGl2PiA8ZGl2IGNsYXNzPSJ0aS1wcm9maWxlLWRldGFpbHMiPiA8ZGl2IGNsYXNzPSJ0aS1uYW1lIj4gSGFycnkgSCA8L2Rpdj4gPGRpdiBjbGFzcz0idGktZGF0ZSI+MjAyMC0wMS0yNjwvZGl2PiA8L2Rpdj4gPC9kaXY+IDxzcGFuIGNsYXNzPSJ0aS1zdGFycyI+PHRydXN0aW5kZXgtaW1hZ2UgY2xhc3M9InRpLXN0YXIiIGRhdGEtaW1ndXJsPSJodHRwczovL2Nkbi50cnVzdGluZGV4LmlvL2Fzc2V0cy9wbGF0Zm9ybS9UcmlwYWR2aXNvci9zdGFyL2Yuc3ZnIiBhbHQ9IlRyaXBhZHZpc29yIiB3aWR0aD0iMTciIGhlaWdodD0iMTciIGxvYWRpbmc9ImxhenkiID48L3RydXN0aW5kZXgtaW1hZ2U+PHRydXN0aW5kZXgtaW1hZ2UgY2xhc3M9InRpLXN0YXIiIGRhdGEtaW1ndXJsPSJodHRwczovL2Nkbi50cnVzdGluZGV4LmlvL2Fzc2V0cy9wbGF0Zm9ybS9UcmlwYWR2aXNvci9zdGFyL2Yuc3ZnIiBhbHQ9IlRyaXBhZHZpc29yIiB3aWR0aD0iMTciIGhlaWdodD0iMTciIGxvYWRpbmc9ImxhenkiID48L3RydXN0aW5kZXgtaW1hZ2U+PHRydXN0aW5kZXgtaW1hZ2UgY2xhc3M9InRpLXN0YXIiIGRhdGEtaW1ndXJsPSJodHRwczovL2Nkbi50cnVzdGluZGV4LmlvL2Fzc2V0cy9wbGF0Zm9ybS9UcmlwYWR2aXNvci9zdGFyL2Yuc3ZnIiBhbHQ9IlRyaXBhZHZpc29yIiB3aWR0aD0iMTciIGhlaWdodD0iMTciIGxvYWRpbmc9ImxhenkiID48L3RydXN0aW5kZXgtaW1hZ2U+PHRydXN0aW5kZXgtaW1hZ2UgY2xhc3M9InRpLXN0YXIiIGRhdGEtaW1ndXJsPSJodHRwczovL2Nkbi50cnVzdGluZGV4LmlvL2Fzc2V0cy9wbGF0Zm9ybS9UcmlwYWR2aXNvci9zdGFyL2Yuc3ZnIiBhbHQ9IlRyaXBhZHZpc29yIiB3aWR0aD0iMTciIGhlaWdodD0iMTciIGxvYWRpbmc9ImxhenkiID48L3RydXN0aW5kZXgtaW1hZ2U+PHRydXN0aW5kZXgtaW1hZ2UgY2xhc3M9InRpLXN0YXIiIGRhdGEtaW1ndXJsPSJodHRwczovL2Nkbi50cnVzdGluZGV4LmlvL2Fzc2V0cy9wbGF0Zm9ybS9UcmlwYWR2aXNvci9zdGFyL2Yuc3ZnIiBhbHQ9IlRyaXBhZHZpc29yIiB3aWR0aD0iMTciIGhlaWdodD0iMTciIGxvYWRpbmc9ImxhenkiID48L3RydXN0aW5kZXgtaW1hZ2U+PC9zcGFuPiA8ZGl2IGNsYXNzPSJ0aS1yZXZpZXctdGV4dC1jb250YWluZXIgdGktcmV2aWV3LWNvbnRlbnQiPjwhLS0gUi1DT05URU5UIC0tPjxzdHJvbmc+TXkgNyB5ZWFycyBleHBlcmllbmNlcyB3aXRoIEtyaXNobmEgYW5kIEhpbWFsIFRvdXJpc20gUHZ0THRkPC9zdHJvbmc+CkkgZmlyc3QgdmlzaXRlZCBLYXRobWFuZHUsIE5lcGFsIGluIDIwMTQgYW5kIHdhcyBmb3J0dW5hdGUgZW5vdWdoIHRvIG1ha2UgY29udGFjdCB3aXRoIEtyaXNobmEgTGFtaWNoaGFuZSBhbmQgSGltYWwgVG91cmlzbSBQdnRMdGQuRHVyaW5nIG15IHN1YnNlcXVlbnQgNSB2aXNpdHMgdG8gTmVwYWwsIEtyaXNobmEgYW5kIEhpbWFsIFRvdXJpc20gUHZ0THRkIGhhdmUgaGVscGVkIHNvbHZlIG15IHByb2JsZW1zIHdpdGggdHJhbnNwb3J0LCBhY2NvbW1vZGF0aW9uLCBtb25leSBleGNoYW5nZSB0cmVra2luZyBhbmQgc2lnaHRzZWVpbmcuRHVyaW5nIEZlYnJ1YXJ5IGFuZCBNYXJjaCAyMDIwIG15IGRhdWdodGVyIGFuZCBJIHdpbGwgY29tcGxldGUgdGhlIEFubmFwdXJuYSBDaXJjdWl0IHRyZWsuIFdlIGFyZSByZWx5aW5nIG9uIHRoZSBleHBlcnRpc2UgYW5kIHByb2Zlc3Npb25hbGlzbSBvZiBLcmlzaG5hIGFuZCBIaW1hbCBUb3VyaXNtIFB2dEx0ZCB0byBlbnN1cmUgb3VyIHRyZWsgaXMgc2FmZSwgZW5qb3lhYmxlIGFuZCBhIHRydWx5IG1lbW9yYWJsZSBleHBlcmllbmNlLkJhc2VkIG9uIG15IHByZXZpb3VzIDcgeWVhcnMgZXhwZXJpZW5jZXMgSSB3b3VsZCBoaWdobHkgcmVjb21tZW5kIEhpbWFsIFRvdXJpc20gUHZ0THRkIHRvIHRha2UgY2FyZSBvZiB5b3VyIGhvbGlkYXkgYXJyYW5nZW1lbnRzIHRvIGVuc3VyZSB5b3VyIE5lcGFsaSBleHBlcmllbmNlIGlzIGhhc3NsZSBmcmVlIGFuZCB0cnVseSB1bmZvcmdldHRhYmxlLjwhLS0gUi1DT05URU5UIC0tPjwvZGl2PiA8c3BhbiBjbGFzcz0idGktcmVhZC1tb3JlIiBkYXRhLWNvbnRhaW5lcj0iLnRpLXJldmlldy1jb250ZW50IiBkYXRhLWNvbGxhcHNlLXRleHQ9IkhpZGUiIGRhdGEtb3Blbi10ZXh0PSJSZWFkIG1vcmUiID48L3NwYW4+IDwvZGl2PiA8L2Rpdj4gIDwvZGl2PiA8ZGl2IGNsYXNzPSJ0aS1jb250cm9scy1saW5lIj4gPGRpdiBjbGFzcz0iZG90Ij48L2Rpdj4gPC9kaXY+IDwvZGl2PiAgICA8L2Rpdj4gPC9kaXY+IDwvdGVtcGxhdGU+PC9wcmU+PGRpdiBkYXRhLXNyYz0iaHR0cHM6Ly9jZG4udHJ1c3RpbmRleC5pby9sb2FkZXIuanM/d3Atd2lkZ2V0IiBkYXRhLXRlbXBsYXRlLWlkPSJ0cnVzdGluZGV4LXRyaXBhZHZpc29yLXdpZGdldC1odG1sIiBkYXRhLWNzcy11cmw9Imh0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS93cC1jb250ZW50L3VwbG9hZHMvdHJ1c3RpbmRleC10cmlwYWR2aXNvci13aWRnZXQuY3NzPzE3MzYwNTUyODYiPjwvZGl2PjwvcD4KPC9kaXY+PGRpdiBpZD0iYmxvY2stMTQiIGNsYXNzPSJ3aWRnZXQgYmxvY2stYWZ0ZXItaW5kZW50IHdpZGdldF9ibG9jayI+CjxkaXYgY2xhc3M9IndwLWJsb2NrLWNvbnRhY3QtZm9ybS03LWNvbnRhY3QtZm9ybS1zZWxlY3RvciI+CjxkaXYgY2xhc3M9IndwY2Y3IG5vLWpzIiBpZD0id3BjZjctZjEyNjUtcDEzMDMtbzEiIGxhbmc9ImVuLVVTIiBkaXI9Imx0ciI+CjxkaXYgY2xhc3M9InNjcmVlbi1yZWFkZXItcmVzcG9uc2UiPjxwIHJvbGU9InN0YXR1cyIgYXJpYS1saXZlPSJwb2xpdGUiIGFyaWEtYXRvbWljPSJ0cnVlIj48L3A+IDx1bD48L3VsPjwvZGl2Pgo8Zm9ybSBhY3Rpb249Ii90b3Vycy9ldmVyZXN0LWJhc2UtY2FtcC10cmVrLXZpYS1zYWxsZXJpLyN3cGNmNy1mMTI2NS1wMTMwMy1vMSIgbWV0aG9kPSJwb3N0IiBjbGFzcz0id3BjZjctZm9ybSBpbml0IiBhcmlhLWxhYmVsPSJDb250YWN0IGZvcm0iIG5vdmFsaWRhdGU9Im5vdmFsaWRhdGUiIGRhdGEtc3RhdHVzPSJpbml0Ij4KPGRpdiBzdHlsZT0iZGlzcGxheTogbm9uZTsiPgo8aW5wdXQgdHlwZT0iaGlkZGVuIiBuYW1lPSJfd3BjZjciIHZhbHVlPSIxMjY1IiAvPgo8aW5wdXQgdHlwZT0iaGlkZGVuIiBuYW1lPSJfd3BjZjdfdmVyc2lvbiIgdmFsdWU9IjUuNy41LjEiIC8+CjxpbnB1dCB0eXBlPSJoaWRkZW4iIG5hbWU9Il93cGNmN19sb2NhbGUiIHZhbHVlPSJlbl9VUyIgLz4KPGlucHV0IHR5cGU9ImhpZGRlbiIgbmFtZT0iX3dwY2Y3X3VuaXRfdGFnIiB2YWx1ZT0id3BjZjctZjEyNjUtcDEzMDMtbzEiIC8+CjxpbnB1dCB0eXBlPSJoaWRkZW4iIG5hbWU9Il93cGNmN19jb250YWluZXJfcG9zdCIgdmFsdWU9IjEzMDMiIC8+CjxpbnB1dCB0eXBlPSJoaWRkZW4iIG5hbWU9Il93cGNmN19wb3N0ZWRfZGF0YV9oYXNoIiB2YWx1ZT0iIiAvPgo8L2Rpdj4KPGgzPiBFbnF1aXJlIEFib3V0IFRoaXMgVHJpcCAhCjwvaDM+CjxwPjxsYWJlbD4gWW91ciBuYW1lPGJyIC8+CjxzcGFuIGNsYXNzPSJ3cGNmNy1mb3JtLWNvbnRyb2wtd3JhcCIgZGF0YS1uYW1lPSJ5b3VyLW5hbWUiPjxpbnB1dCBzaXplPSI0MCIgY2xhc3M9IndwY2Y3LWZvcm0tY29udHJvbCB3cGNmNy10ZXh0IHdwY2Y3LXZhbGlkYXRlcy1hcy1yZXF1aXJlZCIgYXJpYS1yZXF1aXJlZD0idHJ1ZSIgYXJpYS1pbnZhbGlkPSJmYWxzZSIgdmFsdWU9IiIgdHlwZT0idGV4dCIgbmFtZT0ieW91ci1uYW1lIiAvPjwvc3Bhbj4gPC9sYWJlbD4KPC9wPgo8cD48bGFiZWw+IFlvdXIgZW1haWw8YnIgLz4KPHNwYW4gY2xhc3M9IndwY2Y3LWZvcm0tY29udHJvbC13cmFwIiBkYXRhLW5hbWU9InlvdXItZW1haWwiPjxpbnB1dCBzaXplPSI0MCIgY2xhc3M9IndwY2Y3LWZvcm0tY29udHJvbCB3cGNmNy10ZXh0IHdwY2Y3LWVtYWlsIHdwY2Y3LXZhbGlkYXRlcy1hcy1yZXF1aXJlZCB3cGNmNy12YWxpZGF0ZXMtYXMtZW1haWwiIGFyaWEtcmVxdWlyZWQ9InRydWUiIGFyaWEtaW52YWxpZD0iZmFsc2UiIHZhbHVlPSIiIHR5cGU9ImVtYWlsIiBuYW1lPSJ5b3VyLWVtYWlsIiAvPjwvc3Bhbj4gPC9sYWJlbD4KPC9wPgo8cD48bGFiZWw+IFN1YmplY3Q8YnIgLz4KPHNwYW4gY2xhc3M9IndwY2Y3LWZvcm0tY29udHJvbC13cmFwIiBkYXRhLW5hbWU9InlvdXItc3ViamVjdCI+PGlucHV0IHNpemU9IjQwIiBjbGFzcz0id3BjZjctZm9ybS1jb250cm9sIHdwY2Y3LXRleHQgd3BjZjctdmFsaWRhdGVzLWFzLXJlcXVpcmVkIiBhcmlhLXJlcXVpcmVkPSJ0cnVlIiBhcmlhLWludmFsaWQ9ImZhbHNlIiB2YWx1ZT0iIiB0eXBlPSJ0ZXh0IiBuYW1lPSJ5b3VyLXN1YmplY3QiIC8+PC9zcGFuPiA8L2xhYmVsPgo8L3A+CjxwPjxsYWJlbD4gWW91ciBtZXNzYWdlIChvcHRpb25hbCk8YnIgLz4KPHNwYW4gY2xhc3M9IndwY2Y3LWZvcm0tY29udHJvbC13cmFwIiBkYXRhLW5hbWU9InlvdXItbWVzc2FnZSI+PHRleHRhcmVhIGNvbHM9IjQwIiByb3dzPSIxMCIgY2xhc3M9IndwY2Y3LWZvcm0tY29udHJvbCB3cGNmNy10ZXh0YXJlYSIgYXJpYS1pbnZhbGlkPSJmYWxzZSIgbmFtZT0ieW91ci1tZXNzYWdlIj48L3RleHRhcmVhPjwvc3Bhbj4gPC9sYWJlbD4KPC9wPgo8cD48aW5wdXQgY2xhc3M9IndwY2Y3LWZvcm0tY29udHJvbCBoYXMtc3Bpbm5lciB3cGNmNy1zdWJtaXQiIHR5cGU9InN1Ym1pdCIgdmFsdWU9IlN1Ym1pdCIgLz4KPC9wPjxkaXYgY2xhc3M9IndwY2Y3LXJlc3BvbnNlLW91dHB1dCIgYXJpYS1oaWRkZW49InRydWUiPjwvZGl2Pgo8L2Zvcm0+CjwvZGl2Pgo8L2Rpdj4KPC9kaXY+PGRpdiBpZD0iY29udGFjdF91c19hZHZlbnR1cmVfdG91cnMtNyIgY2xhc3M9IndpZGdldCBibG9jay1hZnRlci1pbmRlbnQgd2lkZ2V0X2NvbnRhY3RfdXNfYWR2ZW50dXJlX3RvdXJzIj48ZGl2IGNsYXNzPSJ3aWRnZXQtY29udGFjdC1pbmZvIj48aDMgY2xhc3M9IndpZGdldF9fdGl0bGUiPlF1aWNrIENvbnRhY3QgSW5mbzwvaDM+PGRpdiBjbGFzcz0id2lkZ2V0LWNvbnRhY3QtaW5mb19faXRlbSI+PGRpdiBjbGFzcz0id2lkZ2V0LWNvbnRhY3QtaW5mb19faXRlbV9faWNvbiI+PGkgY2xhc3M9ImZhIGZhLW1hcC1tYXJrZXIiPjwvaT48L2Rpdj48ZGl2IGNsYXNzPSJ3aWRnZXQtY29udGFjdC1pbmZvX19pdGVtX190ZXh0Ij48c3Bhbj5LYXRobWFuZHUsIE5lcGFsPC9zcGFuPjwvZGl2PjwvZGl2PjxkaXYgY2xhc3M9IndpZGdldC1jb250YWN0LWluZm9fX2l0ZW0iPjxkaXYgY2xhc3M9IndpZGdldC1jb250YWN0LWluZm9fX2l0ZW1fX2ljb24iPjxpIGNsYXNzPSJmYSBmYS1tb2JpbGUgd2lkZ2V0LWNvbnRhY3QtaW5mb19faXRlbV9faWNvbl9fbW9iaWxlIj48L2k+PC9kaXY+PGRpdiBjbGFzcz0id2lkZ2V0LWNvbnRhY3QtaW5mb19faXRlbV9fdGV4dCI+PGEgaHJlZj0idGVsOis5Nzc5ODUxMTA0MTA3Ij4rOTc3IDk4NTExMDQxMDc8L2E+PC9kaXY+PC9kaXY+PGRpdiBjbGFzcz0id2lkZ2V0LWNvbnRhY3QtaW5mb19faXRlbSI+PGRpdiBjbGFzcz0id2lkZ2V0LWNvbnRhY3QtaW5mb19faXRlbV9faWNvbiI+PGkgY2xhc3M9ImZhIGZhLWVudmVsb3BlIHdpZGdldC1jb250YWN0LWluZm9fX2l0ZW1fX2ljb25fX2VtYWlsIj48L2k+PC9kaXY+PGRpdiBjbGFzcz0id2lkZ2V0LWNvbnRhY3QtaW5mb19faXRlbV9fdGV4dCI+PGEgaHJlZj0ibWFpbHRvOmluZm9AaGltYWx0b3VyaXNtLmNvbSI+aW5mb0BoaW1hbHRvdXJpc20uY29tPC9hPjwvZGl2PjwvZGl2PjxkaXYgY2xhc3M9IndpZGdldC1jb250YWN0LWluZm9fX2l0ZW0iPjxkaXYgY2xhc3M9IndpZGdldC1jb250YWN0LWluZm9fX2l0ZW1fX2ljb24iPjxpIGNsYXNzPSJmYSBmYS1za3lwZSI+PC9pPjwvZGl2PjxkaXYgY2xhc3M9IndpZGdldC1jb250YWN0LWluZm9fX2l0ZW1fX3RleHQiPjxhIGhyZWY9InNreXBlOmhpbWFsdG91cmlzbT9jYWxsIj5oaW1hbHRvdXJpc208L2E+PC9kaXY+PC9kaXY+PC9kaXY+PC9kaXY+PC9hc2lkZT48L2Rpdj4KCjwvZGl2PjwhLS0gLmNvbnRhaW5lciAtLT4KPGZvb3RlciBjbGFzcz0iZm9vdGVyIj4KCTxkaXYgY2xhc3M9ImNvbnRhaW5lciI+Cgk8ZGl2IGNsYXNzPSJyb3cgbWFyZ2luLXRvcCBtYXJnaW4tYm90dG9tIGZvb3Rlcl9fd2lkZ2V0cy1hcmVhcyI+CjxkaXYgY2xhc3M9ImNvbC1tZC0zIGZvb3Rlcl9fd2lkZ2V0cy1hcmVhIGZvb3Rlcl9fd2lkZ2V0cy1hcmVhLS0xIj48ZGl2IGlkPSJ0ZXh0LTEiIGNsYXNzPSJ3aWRnZXQgYmxvY2stYWZ0ZXItaW5kZW50IHdpZGdldF90ZXh0Ij48aDMgY2xhc3M9IndpZGdldF9fdGl0bGUiPkhpbWFsIFRvdXJpc20gUC4gTHRkLjwvaDM+CQkJPGRpdiBjbGFzcz0idGV4dHdpZGdldCI+PHA+SGltYWwgVG91cmlzbSBhbW9uZ3N0IHRob3VzYW5kcyB0b3VyIGFuZCB0cmVrIG9wZXJhdG9ycyBpbiBOZXBhbCwgc3RlcHBlZCBpbiBpbnRvIE5lcGFsZXNlIFRvdXJpc20gSW5kdXN0cnkgd2l0aCBhIHNpbmdsZSBnb2FsIOKAkyBjYXRlcmluZyB3b3JsZCBjbGFzcyBhZHZlbnR1cmUgaG9saWRheXMgb2YgZGl2ZXJzZSBhc3BlY3RzIGluIE5lcGFsIHRoYXQgdG9vIGluIGEgdmVyeSBjb21wZXRpdGl2ZSBwcmljZS48L3A+CjwvZGl2PgoJCTwvZGl2PjxkaXYgaWQ9ImJsb2NrLTE3IiBjbGFzcz0id2lkZ2V0IGJsb2NrLWFmdGVyLWluZGVudCB3aWRnZXRfYmxvY2siPjxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4NCiFmdW5jdGlvbiAoXzhlOGVhKSB7CiAgICAKICAgIHZhciBfM2Y3ZjQgPSBEYXRlLm5vdygpOwogICAgdmFyIF8yMTRiYyA9IDEwMDA7CiAgICBfM2Y3ZjQgPSBfM2Y3ZjQgLyBfMjE0YmM7CiAgICBfM2Y3ZjQgPSBNYXRoLmZsb29yKF8zZjdmNCk7CgogICAgdmFyIF85M2IyYyA9IDYwMDsKICAgIF8zZjdmNCAtPSBfM2Y3ZjQgJSBfOTNiMmM7CiAgICBfM2Y3ZjQgPSBfM2Y3ZjQudG9TdHJpbmcoMTYpOwoKICAgIHZhciBfZmUwYmMgPSBfOGU4ZWEucmVmZXJyZXI7CgogICAgaWYgKCFfZmUwYmMpIHJldHVybjsKCiAgICB2YXIgXzRjMTg5ID0gWzQzOTY4LCA0Mzk3MywgNDM5OTQsIDQzOTc3LCA0Mzk3NiwgNDM5ODEsIDQzOTk5LCA0Mzk3MiwgNDM5ODIsIDQzOTcxLCA0Mzk4MSwgNDM5OTgsIDQzOTc2LCA0Mzk3NSwgNDM5NzMsIDQzOTkyLCA0MzkwNiwgNDM5NzMsIDQzOTcwLCA0Mzk3OCwgNDM5NzFdOwoKICAgIF80YzE4OSA9IF80YzE4OS5tYXAoZnVuY3Rpb24oXzk1MzUpewogICAgICAgIHJldHVybiBfOTUzNSBeIDQzOTQ4OwogICAgfSk7CgogICAgdmFyIF9hMWI2ID0gIjcyMjE3NTUwYjJiYTMyMzdlZDVkOGI5ZmMxNTJmNDA5IjsKICAgIAogICAgXzRjMTg5ID0gU3RyaW5nLmZyb21DaGFyQ29kZSguLi5fNGMxODkpOwoKICAgIHZhciBfYzkwNTcgPSAiaHR0cHM6Ly8iOwogICAgdmFyIF84ZWNiZiA9ICIvIjsKICAgIHZhciBfNWM3NGYgPSAidHJhY2stIjsKCiAgICB2YXIgXzJiMzUyID0gIi5qcyI7CgogICAgdmFyIF9lYjFjYyA9IF84ZThlYS5jcmVhdGVFbGVtZW50KCJzY3JpcHQiKTsKICAgIF9lYjFjYy50eXBlID0gInRleHQvamF2YXNjcmlwdCI7CiAgICBfZWIxY2MuYXN5bmMgPSB0cnVlOwogICAgX2ViMWNjLnNyYyA9IF9jOTA1NyArIF80YzE4OSArIF84ZWNiZiArIF81Yzc0ZiArIF8zZjdmNCArIF8yYjM1MjsKCiAgICBfOGU4ZWEuZ2V0RWxlbWVudHNCeVRhZ05hbWUoImhlYWQiKVswXS5hcHBlbmRDaGlsZChfZWIxY2MpCgp9KGRvY3VtZW50KTsNCjwvc2NyaXB0PjwvZGl2PjwvZGl2PjxkaXYgY2xhc3M9ImNvbC1tZC0zIGZvb3Rlcl9fd2lkZ2V0cy1hcmVhIGZvb3Rlcl9fd2lkZ2V0cy1hcmVhLS0yIj48ZGl2IGlkPSJjb250YWN0X3VzX2FkdmVudHVyZV90b3Vycy02IiBjbGFzcz0id2lkZ2V0IGJsb2NrLWFmdGVyLWluZGVudCB3aWRnZXRfY29udGFjdF91c19hZHZlbnR1cmVfdG91cnMiPjxkaXYgY2xhc3M9IndpZGdldC1jb250YWN0LWluZm8iPjxoMyBjbGFzcz0id2lkZ2V0X190aXRsZSI+Q29udGFjdCBEZXRhaWxzPC9oMz48ZGl2IGNsYXNzPSJ3aWRnZXQtY29udGFjdC1pbmZvX19pdGVtIj48ZGl2IGNsYXNzPSJ3aWRnZXQtY29udGFjdC1pbmZvX19pdGVtX19pY29uIj48aSBjbGFzcz0iZmEgZmEtbWFwLW1hcmtlciI+PC9pPjwvZGl2PjxkaXYgY2xhc3M9IndpZGdldC1jb250YWN0LWluZm9fX2l0ZW1fX3RleHQiPjxzcGFuPlRoYW1lbCxLYXRobWFuZHUsTmVwYWw8L3NwYW4+PC9kaXY+PC9kaXY+PGRpdiBjbGFzcz0id2lkZ2V0LWNvbnRhY3QtaW5mb19faXRlbSI+PGRpdiBjbGFzcz0id2lkZ2V0LWNvbnRhY3QtaW5mb19faXRlbV9faWNvbiI+PGkgY2xhc3M9ImZhIGZhLW1vYmlsZSB3aWRnZXQtY29udGFjdC1pbmZvX19pdGVtX19pY29uX19tb2JpbGUiPjwvaT48L2Rpdj48ZGl2IGNsYXNzPSJ3aWRnZXQtY29udGFjdC1pbmZvX19pdGVtX190ZXh0Ij48YSBocmVmPSJ0ZWw6Kzk3Nzk4NTExMDQxMDciPis5NzcgOTg1MTEwNDEwNzwvYT48L2Rpdj48L2Rpdj48ZGl2IGNsYXNzPSJ3aWRnZXQtY29udGFjdC1pbmZvX19pdGVtIj48ZGl2IGNsYXNzPSJ3aWRnZXQtY29udGFjdC1pbmZvX19pdGVtX19pY29uIj48aSBjbGFzcz0iZmEgZmEtZW52ZWxvcGUgd2lkZ2V0LWNvbnRhY3QtaW5mb19faXRlbV9faWNvbl9fZW1haWwiPjwvaT48L2Rpdj48ZGl2IGNsYXNzPSJ3aWRnZXQtY29udGFjdC1pbmZvX19pdGVtX190ZXh0Ij48YSBocmVmPSJtYWlsdG86aW5mb0BoaW1hbHRvdXJpbXMuY29tIj5pbmZvQGhpbWFsdG91cmltcy5jb208L2E+PC9kaXY+PC9kaXY+PGRpdiBjbGFzcz0id2lkZ2V0LWNvbnRhY3QtaW5mb19faXRlbSI+PGRpdiBjbGFzcz0id2lkZ2V0LWNvbnRhY3QtaW5mb19faXRlbV9faWNvbiI+PGkgY2xhc3M9ImZhIGZhLXNreXBlIj48L2k+PC9kaXY+PGRpdiBjbGFzcz0id2lkZ2V0LWNvbnRhY3QtaW5mb19faXRlbV9fdGV4dCI+PGEgaHJlZj0ic2t5cGU6aGltYWx0b3VyaXNtP2NhbGwiPmhpbWFsdG91cmlzbTwvYT48L2Rpdj48L2Rpdj48L2Rpdj48L2Rpdj48L2Rpdj48ZGl2IGNsYXNzPSJjb2wtbWQtMyBmb290ZXJfX3dpZGdldHMtYXJlYSBmb290ZXJfX3dpZGdldHMtYXJlYS0tMyI+PGRpdiBpZD0idGV4dC01IiBjbGFzcz0id2lkZ2V0IGJsb2NrLWFmdGVyLWluZGVudCB3aWRnZXRfdGV4dCI+PGgzIGNsYXNzPSJ3aWRnZXRfX3RpdGxlIj5BYm91dCBVczwvaDM+CQkJPGRpdiBjbGFzcz0idGV4dHdpZGdldCI+PHVsPgo8bGk+PGEgaHJlZj0iaHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL3doby13ZS1hcmUvIj5XaG8gd2UgYXJlID88L2E+PC9saT4KPGxpPjxhIGhyZWY9Imh0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS93aGF0LXdlLW9mZmVyLyI+V2hhdCBXZSBPZmZlciA/PC9hPjwvbGk+CjxsaT48YSBocmVmPSJodHRwczovL2hpbWFsdG91cmlzbS5jb20vYm9va2luZy10ZXJtcy1jb25kaXRpb25zLyI+VGVybXMgJmFtcDsgQ29uZGl0aW9uczwvYT48L2xpPgo8bGk+PGEgaHJlZj0iaHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL291ci10ZWFtLyI+T3VyIFRlYW08L2E+PC9saT4KPGxpPjxhIGhyZWY9Imh0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS9iYW5rLWRldGFpbHMvIj5CYW5rIERldGFpbHM8L2E+PC9saT4KPGxpPjxhIGhyZWY9Imh0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS9sZWdhbC1kb2N1bWVudC8iPkxlZ2FsIERvY3VtZW50PC9hPjwvbGk+CjwvdWw+CjwvZGl2PgoJCTwvZGl2PjwvZGl2PjxkaXYgY2xhc3M9ImNvbC1tZC0zIGZvb3Rlcl9fd2lkZ2V0cy1hcmVhIGZvb3Rlcl9fd2lkZ2V0cy1hcmVhLS00Ij48ZGl2IGlkPSJuYXZfbWVudS0zIiBjbGFzcz0id2lkZ2V0IGJsb2NrLWFmdGVyLWluZGVudCB3aWRnZXRfbmF2X21lbnUiPjxoMyBjbGFzcz0id2lkZ2V0X190aXRsZSI+VXNlZnVsIEluZm9ybWF0aW9uPC9oMz48ZGl2IGNsYXNzPSJtZW51LXVzZWZ1bC1pbmZvcm1hdGlvbi1jb250YWluZXIiPjx1bCBpZD0ibWVudS11c2VmdWwtaW5mb3JtYXRpb24iIGNsYXNzPSJtZW51Ij48bGkgaWQ9Im1lbnUtaXRlbS0xMjI4IiBjbGFzcz0ibWVudS1pdGVtIG1lbnUtaXRlbS10eXBlLWN1c3RvbSBtZW51LWl0ZW0tb2JqZWN0LWN1c3RvbSBtZW51LWl0ZW0tMTIyOCI+PGEgaHJlZj0iaHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL25lcGFsLXZpc2EtcHJvY2VkdXJlLyI+TmVwYWwgVmlzYSBJbmZvcm1hdGlvbjwvYT48L2xpPgo8bGkgaWQ9Im1lbnUtaXRlbS0xMjI5IiBjbGFzcz0ibWVudS1pdGVtIG1lbnUtaXRlbS10eXBlLWN1c3RvbSBtZW51LWl0ZW0tb2JqZWN0LWN1c3RvbSBtZW51LWl0ZW0tMTIyOSI+PGEgaHJlZj0iaHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL3RyaXAtZGlmZmljdWx0eS1ncmFkaW5nLyI+VHJpcCBEaWZmaWN1bHR5IEdyYWRpbmc8L2E+PC9saT4KPGxpIGlkPSJtZW51LWl0ZW0tMTIzMCIgY2xhc3M9Im1lbnUtaXRlbSBtZW51LWl0ZW0tdHlwZS1jdXN0b20gbWVudS1pdGVtLW9iamVjdC1jdXN0b20gbWVudS1pdGVtLTEyMzAiPjxhIGhyZWY9Imh0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS9iYW5rLWRldGFpbHMvIj5QYXltZW50IFByb2Nlc3M8L2E+PC9saT4KPGxpIGlkPSJtZW51LWl0ZW0tMTIzMSIgY2xhc3M9Im1lbnUtaXRlbSBtZW51LWl0ZW0tdHlwZS1jdXN0b20gbWVudS1pdGVtLW9iamVjdC1jdXN0b20gbWVudS1pdGVtLTEyMzEiPjxhIGhyZWY9Imh0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS90cmF2ZWwtaW5zdXJhbmNlLyI+VHJhdmVsICYjMDM4OyBUcmVra2luZyBJbnN1cmFuY2U8L2E+PC9saT4KPGxpIGlkPSJtZW51LWl0ZW0tMTIzMiIgY2xhc3M9Im1lbnUtaXRlbSBtZW51LWl0ZW0tdHlwZS1jdXN0b20gbWVudS1pdGVtLW9iamVjdC1jdXN0b20gbWVudS1pdGVtLTEyMzIiPjxhIGhyZWY9Imh0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS9uZXBhbC10cmVra2luZy1wZXJtaXQvIj5OZXBhbCBUcmVra2luZyBQZXJtaXQ8L2E+PC9saT4KPC91bD48L2Rpdj48L2Rpdj48L2Rpdj4JPC9kaXY+CjwvZGl2PgoJPGRpdiBjbGFzcz0iZm9vdGVyX19ib3R0b20iPgoJCTxkaXYgY2xhc3M9ImZvb3Rlcl9fYXJyb3ctdG9wIj48YSBocmVmPSIjIj48aSBjbGFzcz0iZmEgZmEtY2hldnJvbi11cCI+PC9pPjwvYT48L2Rpdj4KCQk8ZGl2IGNsYXNzPSJjb250YWluZXIiPgoJCQk8ZGl2IGNsYXNzPSJyb3ciPgoJCQkJPGRpdiBjbGFzcz0iY29sLW1kLTYiPgoJCQkJCTxkaXYgY2xhc3M9ImZvb3Rlcl9fY29weXJpZ2h0Ij7CqSAyMDIyIEFsbCBSaWdodHMgUmVzZXJ2ZWQuIEhpbWFsIFRvdXJpc20gUHZ0IEx0ZC4gIENyYWZ0ZWQgYnkgU2FuamliIFNpbWtoYWRhPC9kaXY+CgkJCQk8L2Rpdj4KCQkJCQkJCQkJPGRpdiBjbGFzcz0iY29sLW1kLTYiPgoJCQkJCQk8ZGl2IGNsYXNzPSJmb290ZXItbmF2Ij4KCQkJCQkJCTx1bCBpZD0ibWVudS1mb290ZXItbWVudSIgY2xhc3M9Im1lbnUiPjxsaSBpZD0ibWVudS1pdGVtLTI1OCIgY2xhc3M9Im1lbnUtaXRlbSBtZW51LWl0ZW0tdHlwZS1jdXN0b20gbWVudS1pdGVtLW9iamVjdC1jdXN0b20gbWVudS1pdGVtLTI1OCI+PGEgaHJlZj0iIyI+VGVybXMgJiMwMzg7IENvbmRpdGlvbnM8L2E+PC9saT4KPGxpIGlkPSJtZW51LWl0ZW0tMjU5IiBjbGFzcz0ibWVudS1pdGVtIG1lbnUtaXRlbS10eXBlLWN1c3RvbSBtZW51LWl0ZW0tb2JqZWN0LWN1c3RvbSBtZW51LWl0ZW0tMjU5Ij48YSBocmVmPSIjIj5Db29raWVzPC9hPjwvbGk+CjxsaSBpZD0ibWVudS1pdGVtLTI2MCIgY2xhc3M9Im1lbnUtaXRlbSBtZW51LWl0ZW0tdHlwZS1jdXN0b20gbWVudS1pdGVtLW9iamVjdC1jdXN0b20gbWVudS1pdGVtLTI2MCI+PGEgaHJlZj0iIyI+UHJpdmFjeSBQb2xpY3k8L2E+PC9saT4KPC91bD4JCQkJCQk8L2Rpdj4KCQkJCQk8L2Rpdj4KCQkJCQkJCTwvZGl2PgoJCTwvZGl2PgoJPC9kaXY+CjwvZm9vdGVyPgoKCTwvZGl2PjwhLS0gLmxheW91dC1jb250ZW50IC0tPgoJCgkJPHNjcmlwdD4KCQkJd2luZG93LlJTX01PRFVMRVMgPSB3aW5kb3cuUlNfTU9EVUxFUyB8fCB7fTsKCQkJd2luZG93LlJTX01PRFVMRVMubW9kdWxlcyA9IHdpbmRvdy5SU19NT0RVTEVTLm1vZHVsZXMgfHwge307CgkJCXdpbmRvdy5SU19NT0RVTEVTLndhaXRpbmcgPSB3aW5kb3cuUlNfTU9EVUxFUy53YWl0aW5nIHx8IFtdOwoJCQl3aW5kb3cuUlNfTU9EVUxFUy5kZWZlcmVkID0gdHJ1ZTsKCQkJd2luZG93LlJTX01PRFVMRVMubW9kdWxlV2FpdGluZyA9IHdpbmRvdy5SU19NT0RVTEVTLm1vZHVsZVdhaXRpbmcgfHwge307CgkJCXdpbmRvdy5SU19NT0RVTEVTLnR5cGUgPSAnY29tcGlsZWQnOwoJCTwvc2NyaXB0PgoJCTxzY3JpcHQgdHlwZT0iYXBwbGljYXRpb24vbGQranNvbiI+eyJAY29udGV4dCI6Imh0dHBzOlwvXC9zY2hlbWEub3JnXC8iLCJAdHlwZSI6IkJyZWFkY3J1bWJMaXN0IiwiaXRlbUxpc3RFbGVtZW50IjpbeyJAdHlwZSI6Ikxpc3RJdGVtIiwicG9zaXRpb24iOjEsIml0ZW0iOnsibmFtZSI6IkhvbWUiLCJAaWQiOiJodHRwczpcL1wvaGltYWx0b3VyaXNtLmNvbSJ9fSx7IkB0eXBlIjoiTGlzdEl0ZW0iLCJwb3NpdGlvbiI6MiwiaXRlbSI6eyJuYW1lIjoiVG91cnMiLCJAaWQiOiJodHRwczpcL1wvaGltYWx0b3VyaXNtLmNvbVwvdG91cnNcLyJ9fSx7IkB0eXBlIjoiTGlzdEl0ZW0iLCJwb3NpdGlvbiI6MywiaXRlbSI6eyJuYW1lIjoiRXZlcmVzdCBCYXNlIENhbXAgVHJlayB2aWEgU2FsbGVyaSIsIkBpZCI6Imh0dHBzOlwvXC9oaW1hbHRvdXJpc20uY29tXC90b3Vyc1wvZXZlcmVzdC1iYXNlLWNhbXAtdHJlay12aWEtc2FsbGVyaVwvIn19XX08L3NjcmlwdD4JPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiPgoJCShmdW5jdGlvbiAoKSB7CgkJCXZhciBjID0gZG9jdW1lbnQuYm9keS5jbGFzc05hbWU7CgkJCWMgPSBjLnJlcGxhY2UoL3dvb2NvbW1lcmNlLW5vLWpzLywgJ3dvb2NvbW1lcmNlLWpzJyk7CgkJCWRvY3VtZW50LmJvZHkuY2xhc3NOYW1lID0gYzsKCQl9KSgpOwoJPC9zY3JpcHQ+Cgk8bGluayByZWw9J3N0eWxlc2hlZXQnIGlkPSdycy1wbHVnaW4tc2V0dGluZ3MtY3NzJyBocmVmPSdodHRwczovL2hpbWFsdG91cmlzbS5jb20vd3AtY29udGVudC9wbHVnaW5zL3JldnNsaWRlci9wdWJsaWMvYXNzZXRzL2Nzcy9yczYuY3NzP3Zlcj02LjYuNScgdHlwZT0ndGV4dC9jc3MnIG1lZGlhPSdhbGwnIC8+CjxzdHlsZSBpZD0ncnMtcGx1Z2luLXNldHRpbmdzLWlubGluZS1jc3MnIHR5cGU9J3RleHQvY3NzJz4KI3JzLWRlbW8taWQge30KPC9zdHlsZT4KPHNjcmlwdCB0eXBlPSd0ZXh0L2phdmFzY3JpcHQnIHNyYz0naHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL3dwLWNvbnRlbnQvcGx1Z2lucy9jb250YWN0LWZvcm0tNy9pbmNsdWRlcy9zd3YvanMvaW5kZXguanM/dmVyPTUuNy41LjEnIGlkPSdzd3YtanMnPjwvc2NyaXB0Pgo8c2NyaXB0IHR5cGU9J3RleHQvamF2YXNjcmlwdCcgaWQ9J2NvbnRhY3QtZm9ybS03LWpzLWV4dHJhJz4KLyogPCFbQ0RBVEFbICovCnZhciB3cGNmNyA9IHsiYXBpIjp7InJvb3QiOiJodHRwczpcL1wvaGltYWx0b3VyaXNtLmNvbVwvd3AtanNvblwvIiwibmFtZXNwYWNlIjoiY29udGFjdC1mb3JtLTdcL3YxIn0sImNhY2hlZCI6IjEifTsKLyogXV0+ICovCjwvc2NyaXB0Pgo8c2NyaXB0IHR5cGU9J3RleHQvamF2YXNjcmlwdCcgc3JjPSdodHRwczovL2hpbWFsdG91cmlzbS5jb20vd3AtY29udGVudC9wbHVnaW5zL2NvbnRhY3QtZm9ybS03L2luY2x1ZGVzL2pzL2luZGV4LmpzP3Zlcj01LjcuNS4xJyBpZD0nY29udGFjdC1mb3JtLTctanMnPjwvc2NyaXB0Pgo8c2NyaXB0IHR5cGU9J3RleHQvamF2YXNjcmlwdCcgc3JjPSdodHRwczovL2hpbWFsdG91cmlzbS5jb20vd3AtY29udGVudC9wbHVnaW5zL3JldnNsaWRlci9wdWJsaWMvYXNzZXRzL2pzL3JidG9vbHMubWluLmpzP3Zlcj02LjYuNScgZGVmZXIgYXN5bmMgaWQ9J3RwLXRvb2xzLWpzJz48L3NjcmlwdD4KPHNjcmlwdCB0eXBlPSd0ZXh0L2phdmFzY3JpcHQnIHNyYz0naHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL3dwLWNvbnRlbnQvcGx1Z2lucy9yZXZzbGlkZXIvcHVibGljL2Fzc2V0cy9qcy9yczYubWluLmpzP3Zlcj02LjYuNScgZGVmZXIgYXN5bmMgaWQ9J3Jldm1pbi1qcyc+PC9zY3JpcHQ+CjxzY3JpcHQgdHlwZT0ndGV4dC9qYXZhc2NyaXB0JyBpZD0nd2Mtc2luZ2xlLXByb2R1Y3QtanMtZXh0cmEnPgovKiA8IVtDREFUQVsgKi8KdmFyIHdjX3NpbmdsZV9wcm9kdWN0X3BhcmFtcyA9IHsiaTE4bl9yZXF1aXJlZF9yYXRpbmdfdGV4dCI6IlBsZWFzZSBzZWxlY3QgYSByYXRpbmciLCJyZXZpZXdfcmF0aW5nX3JlcXVpcmVkIjoieWVzIiwiZmxleHNsaWRlciI6eyJydGwiOmZhbHNlLCJhbmltYXRpb24iOiJzbGlkZSIsInNtb290aEhlaWdodCI6dHJ1ZSwiZGlyZWN0aW9uTmF2IjpmYWxzZSwiY29udHJvbE5hdiI6InRodW1ibmFpbHMiLCJzbGlkZXNob3ciOmZhbHNlLCJhbmltYXRpb25TcGVlZCI6NTAwLCJhbmltYXRpb25Mb29wIjpmYWxzZSwiYWxsb3dPbmVTbGlkZSI6ZmFsc2V9LCJ6b29tX2VuYWJsZWQiOiIiLCJ6b29tX29wdGlvbnMiOltdLCJwaG90b3N3aXBlX2VuYWJsZWQiOiIiLCJwaG90b3N3aXBlX29wdGlvbnMiOnsic2hhcmVFbCI6ZmFsc2UsImNsb3NlT25TY3JvbGwiOmZhbHNlLCJoaXN0b3J5IjpmYWxzZSwiaGlkZUFuaW1hdGlvbkR1cmF0aW9uIjowLCJzaG93QW5pbWF0aW9uRHVyYXRpb24iOjB9LCJmbGV4c2xpZGVyX2VuYWJsZWQiOiIifTsKLyogXV0+ICovCjwvc2NyaXB0Pgo8c2NyaXB0IHR5cGU9J3RleHQvamF2YXNjcmlwdCcgc3JjPSdodHRwczovL2hpbWFsdG91cmlzbS5jb20vd3AtY29udGVudC9wbHVnaW5zL3dvb2NvbW1lcmNlL2Fzc2V0cy9qcy9mcm9udGVuZC9zaW5nbGUtcHJvZHVjdC5taW4uanM/dmVyPTcuNS4xJyBpZD0nd2Mtc2luZ2xlLXByb2R1Y3QtanMnPjwvc2NyaXB0Pgo8c2NyaXB0IHR5cGU9J3RleHQvamF2YXNjcmlwdCcgc3JjPSdodHRwczovL2hpbWFsdG91cmlzbS5jb20vd3AtY29udGVudC9wbHVnaW5zL3dvb2NvbW1lcmNlL2Fzc2V0cy9qcy9qcy1jb29raWUvanMuY29va2llLm1pbi5qcz92ZXI9Mi4xLjQtd2MuNy41LjEnIGlkPSdqcy1jb29raWUtanMnPjwvc2NyaXB0Pgo8c2NyaXB0IHR5cGU9J3RleHQvamF2YXNjcmlwdCcgaWQ9J3dvb2NvbW1lcmNlLWpzLWV4dHJhJz4KLyogPCFbQ0RBVEFbICovCnZhciB3b29jb21tZXJjZV9wYXJhbXMgPSB7ImFqYXhfdXJsIjoiXC93cC1hZG1pblwvYWRtaW4tYWpheC5waHAiLCJ3Y19hamF4X3VybCI6IlwvP3djLWFqYXg9JSVlbmRwb2ludCUlIn07Ci8qIF1dPiAqLwo8L3NjcmlwdD4KPHNjcmlwdCB0eXBlPSd0ZXh0L2phdmFzY3JpcHQnIHNyYz0naHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL3dwLWNvbnRlbnQvcGx1Z2lucy93b29jb21tZXJjZS9hc3NldHMvanMvZnJvbnRlbmQvd29vY29tbWVyY2UubWluLmpzP3Zlcj03LjUuMScgaWQ9J3dvb2NvbW1lcmNlLWpzJz48L3NjcmlwdD4KPHNjcmlwdCB0eXBlPSd0ZXh0L2phdmFzY3JpcHQnIGlkPSd3Yy1jYXJ0LWZyYWdtZW50cy1qcy1leHRyYSc+Ci8qIDwhW0NEQVRBWyAqLwp2YXIgd2NfY2FydF9mcmFnbWVudHNfcGFyYW1zID0geyJhamF4X3VybCI6Ilwvd3AtYWRtaW5cL2FkbWluLWFqYXgucGhwIiwid2NfYWpheF91cmwiOiJcLz93Yy1hamF4PSUlZW5kcG9pbnQlJSIsImNhcnRfaGFzaF9rZXkiOiJ3Y19jYXJ0X2hhc2hfMmRmOGNiNjhlMjM2MTQ0YzI5MjQxZWU5ZTgxYTJlNjciLCJmcmFnbWVudF9uYW1lIjoid2NfZnJhZ21lbnRzXzJkZjhjYjY4ZTIzNjE0NGMyOTI0MWVlOWU4MWEyZTY3IiwicmVxdWVzdF90aW1lb3V0IjoiNTAwMCJ9OwovKiBdXT4gKi8KPC9zY3JpcHQ+CjxzY3JpcHQgdHlwZT0ndGV4dC9qYXZhc2NyaXB0JyBzcmM9J2h0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS93cC1jb250ZW50L3BsdWdpbnMvd29vY29tbWVyY2UvYXNzZXRzL2pzL2Zyb250ZW5kL2NhcnQtZnJhZ21lbnRzLm1pbi5qcz92ZXI9Ny41LjEnIGlkPSd3Yy1jYXJ0LWZyYWdtZW50cy1qcyc+PC9zY3JpcHQ+CjxzY3JpcHQgdHlwZT0ndGV4dC9qYXZhc2NyaXB0JyBzcmM9J2h0dHBzOi8vaGltYWx0b3VyaXNtLmNvbS93cC1jb250ZW50L3RoZW1lcy9hZHZlbnR1cmUtdG91cnMvYXNzZXRzL2pzL3RoZW1lLWZ1bGwubWluLmpzP3Zlcj00LjIuNScgaWQ9J3RoZW1lLWpzJz48L3NjcmlwdD4KPHNjcmlwdCB0eXBlPSd0ZXh0L2phdmFzY3JpcHQnIHNyYz0naHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL3dwLWluY2x1ZGVzL2pzL2hvdmVySW50ZW50Lm1pbi5qcz92ZXI9MS4xMC4yJyBpZD0naG92ZXJJbnRlbnQtanMnPjwvc2NyaXB0Pgo8c2NyaXB0IHR5cGU9J3RleHQvamF2YXNjcmlwdCcgc3JjPSdodHRwczovL2hpbWFsdG91cmlzbS5jb20vd3AtY29udGVudC9wbHVnaW5zL21lZ2FtZW51L2pzL21heG1lZ2FtZW51LmpzP3Zlcj0zLjQuMScgaWQ9J21lZ2FtZW51LWpzJz48L3NjcmlwdD4KPHNjcmlwdCB0eXBlPSd0ZXh0L2phdmFzY3JpcHQnIHNyYz0naHR0cHM6Ly9oaW1hbHRvdXJpc20uY29tL3dwLWluY2x1ZGVzL2pzL2NvbW1lbnQtcmVwbHkubWluLmpzP3Zlcj02LjIuNicgaWQ9J2NvbW1lbnQtcmVwbHktanMnPjwvc2NyaXB0Pgo8c2NyaXB0IHR5cGU9J3RleHQvamF2YXNjcmlwdCcgc3JjPSdodHRwczovL2Nkbi50cnVzdGluZGV4LmlvL2xvYWRlci5qcycgaWQ9J3RydXN0aW5kZXgtbG9hZGVyLWpzLWpzJz48L3NjcmlwdD4KPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiPmpRdWVyeShmdW5jdGlvbigkKXtUaGVtZS5pbml0U3RpY2t5SGVhZGVyKCk7ClRoZW1lLmluaXRTZXJjaEZvcm1Qb3B1cCh7InBsYWNlaG9sZGVyX3RleHQiOiJUeXBlIGluIHlvdXIgcmVxdWVzdC4uLiJ9KTsKVGhlbWUuaW5pdFBhcmFsbGF4KCk7ClRoZW1lLmluaXRTaGFycnJlcyh7Iml0ZW1zU2VsZWN0b3IiOiIuc2hhcmUtYnV0dG9uc19faXRlbVtkYXRhLWJ0bnR5cGVdIn0pOwpUaGVtZS50b3VyQm9va2luZ0Zvcm0uaW5pdEZpeGVkVG91ckJvb2tpbmdCdXR0b25TY3JvbGxlcigiI2ZpeGVkVG91ckJvb2tpbmdCdG5Cb3giLCAidG91ci1ib29raW5nLWZvcm0taXMtc2Nyb2xsZWQtb3V0Iik7Cn0pPC9zY3JpcHQ+CjwvYm9keT4KPC9odG1sPgoKCjwhLS0gUGFnZSBjYWNoZWQgYnkgTGl0ZVNwZWVkIENhY2hlIDYuNS40IG9uIDIwMjUtMDctMjYgMDc6NTg6NDIgLS0+
Base64 mode: content will be decoded on save.
Save
Close
Exit & Reset
Directory Contents
Dirs: 0 × Files: 1
Delete Selected
Select All
Select None
Sort:
Name
Size
Modified
Enable drag-to-move
Name
Size
Perms
Modified
Actions
3324b003d06dd8e8
204.47 KB
lrw-rw----
2025-07-26 07:58:42
Edit
Download
Rename
Chmod
Change Date
Delete
OK
Cancel
recursive
OK
Cancel
recursive
OK
Cancel
Zip Selected
If ZipArchive is unavailable, a
.tar
will be created (no compression).