PCEtLSBTaW1wbGlmaWVkIFRhYmxlIG9mIENvbnRlbnRzIChvbmx5IG1haW4gaGVhZGluZ3MpIC0tPgo8bmF2IGFyaWEtbGFiZWw9IlRhYmxlIG9mIGNvbnRlbnRzIj4KICA8aDI+VGFibGUgb2YgQ29udGVudHM8L2gyPgogIDxvbD4KICAgIDxsaT48YSBocmVmPSIjaW50cm9kdWN0aW9uIj5JbnRyb2R1Y3Rpb248L2E+PC9saT4KICAgIDxsaT48YSBocmVmPSIjdXNhZ2Utb2YtZm9ybWFsZGVoeWRlLW1lZGljYWwtYXBwbGljYXRpb25zIj5Vc2FnZSBvZiBGb3JtYWxkZWh5ZGU6IE1lZGljYWwgQXBwbGljYXRpb25zPC9hPjwvbGk+CiAgICA8bGk+PGEgaHJlZj0iI2NoZW1pY2FsLXByb3BlcnRpZXMtbW9kZS1vZi1hY3Rpb24iPkNoZW1pY2FsIFByb3BlcnRpZXMgJiBNb2RlIG9mIEFjdGlvbjwvYT48L2xpPgogICAgPGxpPjxhIGhyZWY9IiNzdGVyaWxpemF0aW9uLW9mLW1lZGljYWwtZXF1aXBtZW50Ij5TdGVyaWxpemF0aW9uIG9mIE1lZGljYWwgRXF1aXBtZW50PC9hPjwvbGk+CiAgICA8bGk+PGEgaHJlZj0iI3ByZXNlcnZhdGlvbi1vZi1iaW9sb2dpY2FsLXNwZWNpbWVucy1oaXN0b3BhdGhvbG9neSI+UHJlc2VydmF0aW9uIG9mIEJpb2xvZ2ljYWwgU3BlY2ltZW5zICYgSGlzdG9wYXRob2xvZ3k8L2E+PC9saT4KICAgIDxsaT48YSBocmVmPSIjdmFjY2luZS1wcm9kdWN0aW9uIj5WYWNjaW5lIFByb2R1Y3Rpb248L2E+PC9saT4KICAgIDxsaT48YSBocmVmPSIjcGhhcm1hY2V1dGljYWwtYW5kLXJlc2VhcmNoLWFwcGxpY2F0aW9ucyI+UGhhcm1hY2V1dGljYWwgJiBSZXNlYXJjaCBBcHBsaWNhdGlvbnM8L2E+PC9saT4KICAgIDxsaT48YSBocmVmPSIjb2NjdXBhdGlvbmFsLWV4cG9zdXJlLWFuZC1oZWFsdGgtcmlza3MiPk9jY3VwYXRpb25hbCBFeHBvc3VyZSAmIEhlYWx0aCBSaXNrczwvYT48L2xpPgogICAgPGxpPjxhIGhyZWY9IiNmdXR1cmUtYWx0ZXJuYXRpdmVzLWFuZC1kaXJlY3Rpb25zIj5GdXR1cmUgQWx0ZXJuYXRpdmVzICYgRGlyZWN0aW9uczwvYT48L2xpPgogICAgPGxpPjxhIGhyZWY9IiNjb25jbHVzaW9uIj5Db25jbHVzaW9uPC9hPjwvbGk+CiAgPC9vbD4KPC9uYXY+Cg==PHNlY3Rpb24gaWQ9ImludHJvZHVjdGlvbiI+CiAgPGgyPkludHJvZHVjdGlvbjwvaDI+CiAgPHA+CiAgICBGb3JtYWxkZWh5ZGUsIHdpdGggaXRzIGNoZW1pY2FsIGZvcm11bGEgQ0jigoJPIGFuZCBjbGFzc2lmaWNhdGlvbiBhcyBhIHNpbXBsZSBhbGRlaHlkZSwgaGFzIGJlZW4gdGhlIHBpbGxhciBvZiB2YXJpb3VzIGhlYWx0aCBjYXJlIHVzZXMgZm9yIG1vcmUgdGhhbiBhIGNlbnR1cnkuIEZvcm1hbGRlaHlkZSdzIHN0cm9uZyBhbnRpbWljcm9iaWFsIGFuZCBjcm9zcy1saW5raW5nIGF0dHJpYnV0ZXMgaGF2ZSBtYWRlIGl0IGEgdml0YWwgY29tcG9uZW50IGluIHN0ZXJpbGl6YXRpb24sIG9yZ2FuIHByZXNlcnZhdGlvbiwgdmFjY2luZSBwcmVwYXJhdGlvbiwgYW5kIHBoYXJtYWNldXRpY2FsIHByb2R1Y3Rpb24uIFRoZXNlIHZpcnR1ZXMsIGhvd2V2ZXIsIG5lZWQgdG8gYmUgd2VpZ2hlZCBhZ2FpbnN0IGZvcm1hbGRlaHlkZSdzIGhpZ2gtZG9jdW1lbnRlZCB0b3hpY2l0eSBhbmQgY2FyY2lub2dlbmljaXR5IHdpdGggdXRtb3N0IGNhdXRpb24uIFRoZSBhcnRpY2xlIGRpc2N1c3NlcyB0aGUgdmFyaWVkIGFwcGxpY2F0aW9ucyBvZiBmb3JtYWxkZWh5ZGUgaW4gdGhlIGhlYWx0aCBzZWN0b3IsIHRoZSBjaGVtaWNhbCBtZWNoYW5pc21zIGJlaGluZCB0aGVtLCBzYWZldHkgaW1wbGljYXRpb25zLCBhbmQgdGhlIGFsdGVybmF0aXZlIG9wdGlvbnMgb24gdGhlIGhvcml6b24uCiAgPC9wPgo8L3NlY3Rpb24+Cg==PHNlY3Rpb24gaWQ9InVzYWdlLW9mLWZvcm1hbGRlaHlkZS1tZWRpY2FsLWFwcGxpY2F0aW9ucyI+CiAgPGgxPlVzYWdlIG9mIEZvcm1hbGRlaHlkZTogTWVkaWNhbCBBcHBsaWNhdGlvbnM8L2gxPgogIDxwPgogICAgRm9ybWFsZGVoeWRlIGFuZCBpdHMgZGVyaXZhdGl2ZXMgYXJlIHVzZWQgZWFybHkgaW4gdGhlIHVwc3RyZWFtIHN1cHBseSBjaGFpbiB0byBtYWtlIGNvbXBvdW5kcyB1c2VkIGluIHRoZSBjcmVhdGlvbiBvZiBsaWZlLXNhdmluZyBtZWRpY2FsIGRldmljZXMsIHN1Y2ggYXM6CiAgPC9wPgogIDx1bD4KICAgIDxsaT5QYWNlbWFrZXJzPC9saT4KICAgIDxsaT5BcnRpZmljaWFsIGhlYXJ0IHZhbHZlczwvbGk+CiAgICA8bGk+UHJvc3RoZXNlczwvbGk+CiAgPC91bD4KICA8cD4KICAgIEZvcm1hbGRlaHlkZSBpcyB3ZWxsIGtub3duIGFzIGEgcHJlc2VydmF0aXZlIGluIG1lZGljYWwgbGFib3JhdG9yaWVzIGFuZCBpdHMgdXNlIGFzIGEgc3RlcmlsaXplci4gSXQgaXMgYW4gYWN0aXZlIGluZ3JlZGllbnQgaW4gYW50aS1pbmZlY3RpdmUgZHJ1Z3MgYW5kIGlzIHVzZWQgaW4gZ2VsIGNhcHN1bGVzIHRvIHByb21vdGUgbWF4aW11bSBhYnNvcnB0aW9uLgogIDwvcD4KPC9zZWN0aW9uPgo=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PHNlY3Rpb24gaWQ9InByZXNlcnZhdGlvbi1vZi1iaW9sb2dpY2FsLXNwZWNpbWVucy1oaXN0b3BhdGhvbG9neSI+CiAgPGgyPjMuIFByZXNlcnZhdGlvbiBvZiBCaW9sb2dpY2FsIFNwZWNpbWVucyBhbmQgSGlzdG9wYXRob2xvZ3k8L2gyPgoKICA8aDM+My4xIFRpc3N1ZSBGaXhhdGlvbjwvaDM+CiAgPHA+CiAgICBJbiBhbmF0b21pY2FsIHN0dWR5IGFuZCBoaXN0b3BhdGhvbG9neSwgaW1tb2JpbGl6YXRpb24gb2YgY2VsbCBzdHJ1Y3R1cmVzIGlzIGJyb3VnaHQgYWJvdXQgYnkgZml4YXRpb24gd2l0aCBmb3JtYWxkZWh5ZGUgdGhyb3VnaCBjcm9zcy1saW5raW5nIHByb3RlaW5zIGFuZCBudWNsZWljIGFjaWRzLCBpbmhpYml0aW5nIHB1dHJlZmFjdGlvbiBhbmQgYXV0b2x5c2lzLiAxMCUgbmV1dHJhbCBidWZmZXJlZCBmb3JtYWxpbiAoNCUgZnJlZSBmb3JtYWxkZWh5ZGUpIGlzIHN0YW5kYXJkIHByYWN0aWNlLCB3aXRoIGNvbXBsZXRlIHRpc3N1ZSBwZW5ldHJhdGlvbiB3aXRoaW4gMTjigJMyNCBob3VycyBmb3IgYmxvY2tzIOKJpDIwIG1tIHRoaWNrLgogIDwvcD4KCiAgPGgzPjMuMiBUZWNobmljYWwgQ29uc2lkZXJhdGlvbnM8L2gzPgogIDxwPjxzdHJvbmc+T3Ntb3RpYyBFZmZlY3RzOjwvc3Ryb25nPiBUaGUgNCUgZm9ybWFsZGVoeWRlIHNvbHV0aW9uIGlzIGh5cGVyb3Ntb3RpYyAo4omIMTMwMCBtT3NtKSwgd2l0aCByZWFkeSBkaWZmdXNpb24gaW50byB0aXNzdWUuPC9wPgogIDxwPjxzdHJvbmc+UGVuZXRyYXRpb24tRml4YXRpb24gUGFyYWRveDo8L3N0cm9uZz4gV2hpbGUgcmFwaWQgZGlmZnVzaW9uLCBmdWxsIGNyb3NzLWxpbmtpbmcgaXMgZGVsYXllZCBiZWNhdXNlIG9mIGVxdWlsaWJyaXVtIGR5bmFtaWNzIGJldHdlZW4gZnJlZSBhbmQgcG9seW1lcmljIGZvcm1hbGRlaHlkZTsgbmV3IHNvbHV0aW9ucyByZWR1Y2UgcG9seW1lciBjb250ZW50IGFuZCBlbmhhbmNlIGZpeGF0aW9uLjwvcD4KICA8cD48c3Ryb25nPk5lZ2F0aXZlIEVmZmVjdHM6PC9zdHJvbmc+IE92ZXItZml4YXRpb24gbWF5IHJlc3VsdCBpbiBzaHJpbmthZ2UgKHVwIHRvIDMzJSkgYW5kIGhhcmRlbmluZyBvZiB0aGUgdGlzc3VlLCB3aGljaCBjYW4gaW5mbHVlbmNlIHRoZSBxdWFsaXR5IG9mIHN0YWluaW5nIGFuZCB0aGUgZXh0cmFjdGlvbiBvZiBiaW9tb2xlY3VsZXMuPC9wPgo8L3NlY3Rpb24+Cg==PHNlY3Rpb24gaWQ9InZhY2NpbmUtcHJvZHVjdGlvbiI+CiAgPGgyPjQuIFZhY2NpbmUgUHJvZHVjdGlvbjwvaDI+CgogIDxoMz40LjEgVmlyYWwgYW5kIFRveG9pZCBJbmFjdGl2YXRpb248L2gzPgogIDxwPgogICAgRm9ybWFsZGVoeWRlIGlzIHVzZWQgYXMgYW4gaW5hY3RpdmF0aW5nIGFnZW50IGR1cmluZyB0aGUgcHJvZHVjdGlvbiBvZiB2YWNjaW5lcywgbWFraW5nIHZpcnVzZXMgYW5kIGJhY3RlcmlhbCB0b3hpbnMgbm9uLWluZmVjdGl2ZSBidXQgbGVhdmluZyBhbnRpZ2VuaWMgZXBpdG9wZXMgaW50YWN0LiBNb3N0IGluYWN0aXZhdGVkIHZpcmFsIHZhY2NpbmVz4oCUaW5mbHVlbnphLCBwb2xpbywgY2hvbGVyYSwgYW5kIGhlcGF0aXRpcyBB4oCUdXNlIGZvcm1hbGRlaHlkZSB0byBjcm9zcy1saW5rIHZpcmFsIHByb3RlaW5zLiBUb3hvaWQgdmFjY2luZXMgKGRpcGh0aGVyaWEsIHRldGFudXMpIGFsc28gdXNlIGZvcm1hbGRlaHlkZSB0byBkZXRveGlmeSBwcm90ZWluIHRveGlucy4KICA8L3A+CgogIDxoMz40LjIgUmVzaWR1YWwgRm9ybWFsZGVoeWRlIGFuZCBTYWZldHk8L2gzPgogIDxwPgogICAgTGljZW5zZWQgdmFjY2luZSByZXNpZHVhbCBmb3JtYWxkZWh5ZGUgYW1vdW50cyBmcm9tICZsdDswLjAwNSBtZyB0byAwLjEgbWcgcGVyIGRvc2UsIGZhciBsZXNzIHRoYW4gZW5kb2dlbm91cyBibG9vZCBsZXZlbHMgKH4yLjUgwrVnL21MKSBhbmQgZGFpbHkgZGlldGFyeSBpbnRha2UuIFRveGljb2xvZ2ljYWwgZXZhbHVhdGlvbnMgcmVpbmZvcmNlIHRoYXQgdmFjY2luZSBmb3JtYWxkZWh5ZGUgaXMgNjAw4oCTMSw1MDAgdGltZXMgYmVsb3cgdGhlIGxldmVsIG9mIGFkdmVyc2UgZWZmZWN0cywgcHJlc2VudGluZyBubyBzaWduaWZpY2FudCByaXNrLgogIDwvcD4KCiAgPHRhYmxlIGJvcmRlcj0iMSIgY2VsbHBhZGRpbmc9IjYiIGNlbGxzcGFjaW5nPSIwIj4KICAgIDx0aGVhZD4KICAgICAgPHRyPgogICAgICAgIDx0aD5WYWNjaW5lIFR5cGU8L3RoPgogICAgICAgIDx0aD5Gb3JtYWxkZWh5ZGUgcGVyIERvc2U8L3RoPgogICAgICAgIDx0aD5FbmRvZ2Vub3VzIEJsb29kIExldmVsPC90aD4KICAgICAgICA8dGg+U2FmZXR5IE1hcmdpbjwvdGg+CiAgICAgIDwvdHI+CiAgICA8L3RoZWFkPgogICAgPHRib2R5PgogICAgICA8dHI+CiAgICAgICAgPHRkPkRUYVA8L3RkPgogICAgICAgIDx0ZD7iiaQgMC4wMDXigJMwLjEgbWc8L3RkPgogICAgICAgIDx0ZD5+MS4xIG1nIGluIGluZmFudHM8L3RkPgogICAgICAgIDx0ZD5+MSw1MDDDlzwvdGQ+CiAgICAgIDwvdHI+CiAgICAgIDx0cj4KICAgICAgICA8dGQ+SGVwYXRpdGlzIEE8L3RkPgogICAgICAgIDx0ZD7iiaQgMC4wNeKAkzAuMSBtZzwvdGQ+CiAgICAgICAgPHRkPn4xLjEgbWcgaW4gaW5mYW50czwvdGQ+CiAgICAgICAgPHRkPn4xLDAwMMOXPC90ZD4KICAgICAgPC90cj4KICAgICAgPHRyPgogICAgICAgIDx0ZD5UZC9EVDwvdGQ+CiAgICAgICAgPHRkPuKJpCAwLjAwNeKAkzAuMSBtZzwvdGQ+CiAgICAgICAgPHRkPn4xLjEgbWcgaW4gaW5mYW50czwvdGQ+CiAgICAgICAgPHRkPn4xLDUwMMOXPC90ZD4KICAgICAgPC90cj4KICAgIDwvdGJvZHk+CiAgPC90YWJsZT4KPC9zZWN0aW9uPgo=PHNlY3Rpb24gaWQ9InBoYXJtYWNldXRpY2FsLWFuZC1yZXNlYXJjaC1hcHBsaWNhdGlvbnMiPgogIDxoMj41LiBQaGFybWFjZXV0aWNhbCBhbmQgUmVzZWFyY2ggQXBwbGljYXRpb25zPC9oMj4KCiAgPGgzPjUuMSBBbnRpLWluZmVjdGl2ZSBEcnVncyBhbmQgR2VsIENhcHN1bGVzPC9oMz4KICA8cD4KICAgIEZvcm1hbGRlaHlkZSBhbmQgaXRzIGRlcml2YXRpdmVzIGZpbmQgdXNlIGluIHNvbWUgYW50aS1pbmZlY3RpdmUgbWVkaWNpbmVzIGFuZCBnZWwgY2Fwc3VsZXMsIHRha2luZyBhZHZhbnRhZ2Ugb2YgaXRzIHByZXNlcnZhdGl2ZSBhbmQgYmFjdGVyaW9zdGF0aWMgcHJvcGVydGllcyBpbiBtYWludGFpbmluZyBwcm9kdWN0IHN0YWJpbGl0eSBhbmQgYmlvYXZhaWxhYmlsaXR5LgogIDwvcD4KCiAgPGgzPjUuMiBPbWljcyBSZXNlYXJjaDwvaDM+CiAgPHA+CiAgICBJbiBnZW5vbWljcyBhbmQgcHJvdGVvbWljcywgZm9ybWFsZGVoeWRlIGNyb3NzLWxpbmtpbmcgZmFjaWxpdGF0ZXMgY2hyb21hdGluIGltbXVub3ByZWNpcGl0YXRpb24gYXMgd2VsbCBhcyBvdGhlciBtb2xlY3VsYXIgbWV0aG9kcyB0aGF0IHJlcXVpcmUgY292YWxlbnQgc3RhYmlsaXphdGlvbiBvZiBwcm90ZWluLUROQSBpbnRlcmFjdGlvbnMsIGVzc2VudGlhbCBmb3IgcmVndWxhdG9yeSBuZXR3b3JrIG1hcHBpbmcuCiAgPC9wPgo8L3NlY3Rpb24+Cg==PHNlY3Rpb24gaWQ9Im9jY3VwYXRpb25hbC1leHBvc3VyZS1hbmQtaGVhbHRoLXJpc2tzIj4KICA8aDI+Ni4gT2NjdXBhdGlvbmFsIEV4cG9zdXJlIGFuZCBIZWFsdGggUmlza3M8L2gyPgoKICA8aDM+Ni4xIFRveGljaXR5IFByb2ZpbGU8L2gzPgogIDxwPgogICAgRm9ybWFsZGVoeWRlIGhhcyBiZWVuIGNsYXNzaWZpZWQgYXMgYSBHcm91cCAxIGNhcmNpbm9nZW4gYnkgdGhlIEludGVybmF0aW9uYWwgQWdlbmN5IGZvciBSZXNlYXJjaCBvbiBDYW5jZXIgKElBUkMpIGJhc2VkIG9uIGV2aWRlbmNlIG9mIGFzc29jaWF0aW9ucyB3aXRoIG5hc29waGFyeW5nZWFsIGNhcmNpbm9tYSBhbmQgbGV1a2VtaWEgYWZ0ZXIgcHJvbG9uZ2VkIGV4cG9zdXJlLiBBY3V0ZSBpbmhhbGF0aW9uIGNhbiBjYXVzZSBpcnJpdGF0aW9uIHRvIGV5ZXMsIG5vc2UsIGFuZCB0aHJvYXQ7IGhpZ2hlciBsZXZlbHMgY2FuIGxlYWQgdG8gYXN0aG1hLWxpa2UgcmVhY3Rpb25zIGFuZCBsdW5nIGltcGFpcm1lbnQuCiAgPC9wPgoKICA8aDM+Ni4yIEJpb21vbml0b3JpbmcgU3R1ZGllczwvaDM+CiAgPHA+CiAgICBBIHRyaWFsIG9mIDY4IGhvc3BpdGFsIHN0YWZmIHNob3dlZCB0aGF0IGV2ZW4gbG93IG9jY3VwYXRpb25hbCBleHBvc3VyZSAobWVhbiA1Ny4zIMK1Zy9twrMpIHJhaXNlZCBiaW9tYXJrZXJzIG9mIG94aWRhdGl2ZSBzdHJlc3MgKDE1LUbigoJ0LWlzb3Byb3N0YW5lLCBNREEpIGFuZCBpbmZsYW1tYXRpb24gKFRORs6xKSBpbiBjb21wYXJpc29uIHRvIG5vbi1leHBvc2VkIGNvbnRyb2xzLCBoaWdobGlnaHRpbmcgZm9ybWFsZGVoeWRlJ3MgYWJpbGl0eSB0byBjYXVzZSBtZWFzdXJhYmxlIGJpb2xvZ2ljYWwgZWZmZWN0cyBhdCBleHBvc3VyZSBsZXZlbHMgYWNjZXB0YWJsZSB1bmRlciBleGlzdGluZyByZWd1bGF0aW9ucy4KICA8L3A+CgogIDxoMz42LjMgUHJldmVudGl2ZSBNZWFzdXJlczwvaDM+CiAgPHVsPgogICAgPGxpPkxvY2FsIGV4aGF1c3QgdmVudGlsYXRpb24gYW5kIGNsb3NlZCB2YWN1dW0gc3lzdGVtcyBpbiBwYXRob2xvZ3kgbGFib3JhdG9yaWVzPC9saT4KICAgIDxsaT5FbmdpbmVlcmluZyBjb250cm9scyB0byByZXN0cmljdCBnYXMgbGVha2FnZSBpbiBzdGVyaWxpemF0aW9uIHN1aXRlczwvbGk+CiAgICA8bGk+U3Vic3RpdHV0aW9uIG9mIHBhcmFmb3JtYWxkZWh5ZGUgKFBGQSkgb3Igb3RoZXIgZml4YXRpdmVzIHdoZXJlIHBvc3NpYmxlIHRvIG1pbmltaXplIGdhc2VvdXMgZW1pc3Npb25zPC9saT4KICA8L3VsPgo8L3NlY3Rpb24+Cg==PGgyIGlkPSJmdXR1cmUtYWx0ZXJuYXRpdmVzLWFuZC1kaXJlY3Rpb25zIj43LiBGdXR1cmUgQWx0ZXJuYXRpdmVzIGFuZCBEaXJlY3Rpb25zPC9oMj4KCjxwPk5ldyBkZXZlbG9wbWVudHMgc2VlayB0byBhdm9pZCBmb3JtYWxkZWh5ZGUgdGhyZWF0cyBieTo8L3A+Cgo8aDM+QWx0ZXJuYXRpdmUgRml4YXRpdmVzPC9oMz4KPHA+QWxjb2hvbGljIGFuZCBnbHlveGFsLWJhc2VkIGZpeGF0aXZlcyBhcmUgY29tcGFyYWJsZSB0byBtb3JwaG9sb2dpY2FsIHByZXNlcnZhdGlvbiB3aXRoIGRlY3JlYXNlZCBjcm9zcy1saW5raW5nIGRlbnNpdHksIGVuaGFuY2luZyBudWNsZWljIGFjaWQgcmV0cmlldmFsIGZvciBtb2xlY3VsYXIgZGlhZ25vc3RpY3MuPC9wPgoKPGgzPkxvdy1UZW1wZXJhdHVyZSBTdGVyaWxpemF0aW9uPC9oMz4KPHA+SHlkcm9nZW4gcGVyb3hpZGUgdmFwb3IgYW5kIHBlcmFjZXRpYyBhY2lkIHN5c3RlbXMgc3RlcmlsaXplIHdpdGhvdXQgdG94aWMgcmVzaWR1ZXMsIGFkdmFudGFnZW91cyBmb3IgaGVhdC1zZW5zaXRpdmUgZGV2aWNlIGRpc2luZmVjdGlvbi48L3A+Cgo8aDM+RW56eW1hdGljIGFuZCBQaG90byBjcm9zc2xpbmtpbmcgQXBwcm9hY2hlczwvaDM+CjxwPk5ldyBjaGVtaXN0cmllcyBiYXNlZCBvbiBwaG90b2FjdGl2YXRhYmxlIGNyb3NzLWxpbmtlcnMgZmFjaWxpdGF0ZSB0YXJnZXQgZml4YXRpb24gd2l0aCBtaW5pbWFsIG9mZi10YXJnZXQgY29uc2VxdWVuY2VzLCBvZmZlcmluZyBzYWZlciBwcm90b2NvbHMgaW4gaGlzdG9sb2d5IGFuZCByZXNlYXJjaC48L3A+Cg==PGgyIGlkPSJjb25jbHVzaW9uIj5Db25jbHVzaW9uPC9oMj4KCjxwPkZvcm1hbGRlaHlkZSBjb250aW51ZXMgdG8gYmUgdGhlIGZvdW5kYXRpb24gb2YgbWVkaWNpbmUgYW5kIGJpb21lZGljYWwgc2NpZW5jZSBiZWNhdXNlIG9mIGl0cyB1bnBhcmFsbGVsZWQgZGlzaW5mZWN0YW50IGFuZCBmaXhhdGl2ZSBxdWFsaXRpZXMuIEl0cyB1c2VzIGluY2x1ZGUgbWVkaWNhbCBkZXZpY2Ugc3RlcmlsaXphdGlvbiwgcHJlc2VydmF0aW9uIG9mIHRpc3N1ZXMgZm9yIHBhdGhvbG9neSwgaW5hY3RpdmF0aW9uIG9mIHZhY2NpbmVzLCBhbmQgcGhhcm1hY2V1dGljYWwgcHJvZHVjdGlvbi4gSG93ZXZlciwgdGhlIHRveGljaXR5IG9mIGZvcm1hbGRlaHlkZSByZXF1aXJlcyBzdHJpY3Qgc2FmZXR5IHByb2NlZHVyZXMsIG1vbml0b3Jpbmcgb2YgZXhwb3N1cmUsIGFuZCB0aGUgY3JlYXRpb24gb2Ygc3Vic3RpdHV0ZSBjaGVtaXN0cmllcy4gQ2hhbmdpbmcgcmVndWxhdGlvbnMgYW5kIHRlY2hub2xvZ2ljYWwgYWR2YW5jZW1lbnRzIGFpbSB0byBwcm90ZWN0IHRoZSBiZW5lZml0cyBvZiBmb3JtYWxkZWh5ZGUgd2hpbGUgcmVkdWNpbmcgd29ya2VyIGFuZCBwYXRpZW50IGhlYWx0aCByaXNrcy4gT25nb2luZyByZXNlYXJjaCBpbnRvIHNhZmVyIGFsdGVybmF0aXZlcyBwcm9taXNlcyB0byBkZWZpbmUgdGhlIG5leHQgaGVhbHRoY2FyZSBzdGFuZGFyZHMgZ2VuZXJhdGlvbi48L3A+Cg==
