PCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9JRVRGLy9EVEQgSFRNTCAyLjAvL0VOIj4KPEhUTUw+PEhFQUQ+CjxUSVRMRT5BIHJlY2lwZSBmb3IgY2hyaXN0bWFzIG1vdmllPC9USVRMRT4KPC9IRUFEPjxCT0RZPgoKPGgxPkEgcmVjaXBlIGZvciBjaHJpc3RtYXMgbW92aWU8L2gxPgoKPHN0cmlrZT5SZWNpcGUgZm9yIGEgcGVyZmVjdCBjaHJpc3RtYXMgKHR2IG1vdmllIDIwMDUpIC0gaW1kYjwvc3RyaWtlPgo8c3RyaWtlPnJvbWFudGljIGlkZWFzIGZvciBodXNiYW5kIGF0IGNocmlzdG1hczwvc3RyaWtlPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtZmliZXItb3B0aWMtY2hyaXN0bWFzLXRycmVzLmh0bSI+ZmliZXIgb3B0aWMgY2hyaXN0bWFzIHRycmVzPC9hPgo8L3N0cmlrZT4KPGxpPiYjMzk7cmVjaXBlIGZvciBsb3ZlJiMzOTsgcHJvZHVjdGlvbiBiaW9zIHNoYXduIHdpbGxpYW1zb248L2xpPgo8c3RyaWtlPlRoZSByb2FkIHRvIGNocmlzdG1hcyAvIHJlY2lwZSBmb3IgYSBwZXJmZWN0IGNocmlzdG1hcyAtIHdhbG1hcnQ8L3N0cmlrZT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtaGVyc2hleS1qci1iZWFycy1jaHJpc3RtYXMtdG91cm5hbWVudC5odG0iPnBsb3Qgc3VtbWFyeTwvYT4KPC9saT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtZ2lhbnQtbGlnaHRlZC1jaHJpc3RtYXMtYnVsYnMuaHRtIj5jaHJpc3RtYXMgcmVjaXBlOiBtdWxsZWQgd2luZSxiYWtlZCBoYW0scnVtIHBsdW0gbW92aWUgcmV2aWV3PC9hPgo8L2xpPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS10b3lzLXItdXMtY2hyaXN0bWFzLWFsYnVtLmh0bSI+cGlvbmVlciB3b21hbiBvbiBmb29kIG5ldHdvcmshIHwgdGhlIHBpb25lZXIgd29tYW48L2E+CjwvbGk+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LXB1cml0YW5zLWFuZC1jaHJpc3RtYXMuaHRtIj5jaHJpc3RtYXMgcGFydHkgaWRlYXMgfCB0YXN0ZSBvZiBob21lPC9hPgo8L3NtYWxsPgo8c3RyaWtlPnNvdWwgZm9vZCBjaHJpc3RtYXM8L3N0cmlrZT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtbGlzdC1vZi1jaHJpc3RtYXMtc2F5aW5ncy1hbmQtd2lzaGVzLmh0bSI+Z3JpbmNoIGNvb2tpZXMgcmVjaXBlIHwgaW4ga2F0cmluYSYjMzk7cyBraXRjaGVuPC9hPgo8L3NtYWxsPgo8c3RyaWtlPlJlY2lwZSBmb3IgYSBwZXJmZWN0IGNocmlzdG1hcyAoMjAwNSkgJiM4MjEyOyB0aGUgbW92aWUgZGF0YWJhc2UgKHRtZGIpPC9zdHJpa2U+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWktaGF0ZS1jaHJpc3RtYXMtcXVvdGUuaHRtIj5pIGhhdGUgY2hyaXN0bWFzIHF1b3RlPC9hPgo8L3NtYWxsPgo8bGk+SGFsbG93ZWVuIHJlY2lwZXMgaW5zcGlyZWQgYnkgc2NhcnkgbW92aWVzICYjODIxMTsgaG9uZXN0IGNvb2tpbmc8L2xpPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1kZXMtbW9pbmVzLWNocmlzdG1hcy1saWdodHMuaHRtIj5hbWF6b24uY29tOiByZWNpcGUgZm9yIGEgcGVyZmVjdCBjaHJpc3RtYXM6IGNhcmx5IHBvcGUsIGNocmlzdGluZTwvYT4KPC9saT4KPHN0cmlrZT5WYWwmIzM5O3MgbW92aWUgcm91bmR1cCAjNDogaGFsbG1hcmsgZWRpdGlvbiB8IHRocm91Z2ggdGhlIHNoYXR0ZXJlZDwvc3RyaWtlPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLXN0b2NraW5nLXN0dWZmZWQtZmVsdC1wYXR0ZXJucy5odG0iPm11cmRlciBzaGUgYmFrZWQ6IGEgZGVhZGx5IHJlY2lwZSAtIGl0cyBhIHdvbmRlcmZ1bCBtb3ZpZTwvYT4KPC9zdHJpa2U+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LXBvdWdlcy1jaHJpc3RtYXMtZGF5Lmh0bSI+amV3aXNoIGNocmlzdG1hczogY2hpbmVzZSBmb29kIGFuZCBhIG1vdmllLCBmYW1pbHkgYW5kIGZyaWVuZHM8L2E+Cjwvc21hbGw+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWZyZW5jaC1jYW5hZGlhbi1jaHJpc3RtYXMtY29sb3JpbmctcGFnZXMtZnJlZS5odG0iPmZyZW5jaCBjYW5hZGlhbiBjaHJpc3RtYXMgY29sb3JpbmcgcGFnZXMgZnJlZTwvYT4KPC9saT4KPGxpPkNhcmFtZWwgY3JlbWUgcGllIHJlY2lwZSAtIGxpZmUgd2l0aCBsb3JlbGFpPC9saT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWVjbGVjdHVzLWNocmlzdG1hcy1vcm5hbWVudHMuaHRtIj5mb29kIGx1c3QgcGVvcGxlIGxvdmU6IHJvYXN0ZWQgY2hlc3RudXRzIGZvciAjc3VuZGF5c3VwcGVyPC9hPgo8L3N0cmlrZT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtdGhlLXdpc2UtbWVuLWNocmlzdG1hcy1zb25nLXBhcm9keS5odG0iPmpvc2ggYW5kIGNodWNrJiMzOTtzIDIwMTQgY2hyaXN0bWFzIGV4dHJhdmFnYW56YSEgfCBzdHVmZiB5b3Ugc2hvdWxkPC9hPgo8L2xpPgo8c3RyaWtlPmkgaGF0ZSBjaHJpc3RtYXMgcXVvdGU8L3N0cmlrZT4KPHN0cmlrZT5NaW5pb25zIG1vdmllIG5pZ2h0IGJlc3QgY2hlZXNlIGRpcCByZWNpcGUgLSBraWRzIHZzLiBhZHVsdHM8L3N0cmlrZT4KPHN0cmlrZT5DaHJpc3RtYXMgd2l0aCB0aGUga3JhbmtzIGNhcmFtZWwgY3JlYW0gcGllIHJlY2lwZSAtIHNtYXNoZWQ8L3N0cmlrZT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWhvbGlkYXktY2hyaXN0bWFzLWRpbm5lcndhcmUuaHRtIj5yZWNpcGUgYm94OiBjaHJpc3RtYXMgbW9ybmluZyBwYW5jYWtlcyAmIzgyMTE7IGxhdXJlbiBjb25yYWQ8L2E+Cjwvc3RyaWtlPgo8c3RyaWtlPkNoZWYgZmlsbTogc3RyZWV0IGZvb2QgcmVjaXBlcyBpbnNwaXJlZCBieSB0aGUgbW92aWUgLSB0ZWxlZ3JhcGg8L3N0cmlrZT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtYS1jaHJpc3RtYXMtc3RvcnktY3Jvc3N3b3JkLmh0bSI+YW50aS1jaHJpc3RtYXMgbW92aWU6IHdoaXRlIHJlaW5kZWVyIHwgbW92aWVzIHwgc2V2ZW4gZGF5czwvYT4KPC9saT4KPGxpPlp1enUmIzM5O3MgcGV0YWxzIHdpbnRlciBzYWxhZCB3aXRoIG9yYW5nZSB2aW5haWdyZXR0ZSB8IGdyaW5nYWxpY2lvdXM8L2xpPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hpbGRyZW4tY2hyaXN0bWFzLWdpZnQtaWRlYXMuaHRtIj5yZWNpcGUgcmVjb21tZW5kYXRpb246IHJhbHBoaWUmIzM5O3MgbW9tJiMzOTtzIGJyYWlzZWQgcmVkIGNhYmJhZ2U8L2E+Cjwvc3RyaWtlPgo8bGk+SG9saWRheSBlbnRlcnRhaW5pbmcgMjAxNSA6IHBlb3BsZS5jb208L2xpPgo8bGk+RWxmIHBvcGNvcm4gcmVjaXBlICZhbXA7IG1vdmllIG5pZ2h0IC0gbW9tIGZhdm9yaXRlczwvbGk+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1zdHJpY3RseS1jaHJpc3RtYXMtbmVlZGxlcG9pbnQuaHRtIj5zdHJpY3RseSBjaHJpc3RtYXMgbmVlZGxlcG9pbnQ8L2E+Cjwvc3RyaWtlPgo8c21hbGw+Q3JhbmJlcnJ5IHRhbmdlcmluZSBmaXp6eSBkcmluayByZWNpcGUgLSB0YXN0ZXMgb2YgbGl6enkgdCYjMzk7czwvc21hbGw+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNocmlzdG1hcy10cmVlLXNob3Atc2F1Z3VzLW1hc3MuaHRtIj5ob2xpZGF5IGd1aWRlIHRvIHJlY2lwZXMsIGRlY29yLCBhbmQgZ2lmdCBpZGVhcyAtIGNoYXRlbGFpbmU8L2E+Cjwvc21hbGw+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1hLWNocmlzdG1hcy1zdG9yeS1uZXcteW9yay1jaXR5Lmh0bSI+YSBjaHJpc3RtYXMgc3RvcnkgbmV3IHlvcmsgY2l0eTwvYT4KPC9zdHJpa2U+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWhhbGxtYXJrLWNocmlzdG1hcy1ib3hlZC1jYXJkcy5odG0iPm91ciB0b3AgdGVuIGZhdm9yaXRlIGNocmlzdG1hcyB0cmFkaXRpb25zIC0gZ2VybWFuZm9vZHMub3JnPC9hPgo8L3NtYWxsPgo8bGk+Y2hyaXN0bWFzIHN0b3J5IGxlZyBsYW1wIHBpY3R1cmU8L2xpPgo8c3RyaWtlPlB1ZGRpbmcgaG9tZSBwYWdlIC0gcHVkZGluZzwvc3RyaWtlPgo8c3RyaWtlPkl0IGFpbiYjMzk7dCBtZWF0LCBiYWJlOiBkaW5uZXIgYW5kIGEgKGNocmlzdG1hcykgbW92aWU6IHRoZSBob2xpZGF5PC9zdHJpa2U+CjxzbWFsbD5Nb3J0b24gZmFtaWx5IHN0cmF0YSBmcm9tIHRoZSBmYW1pbHkgc3RvbmUgbW92aWUpIHJlY2lwZSAtIGZvb2QuY29tPC9zbWFsbD4KPGxpPkxhdXJlbiYjMzk7cyBsYXRlc3Q6IGNoZXJyeSBjaGlwIGxvYWY8L2xpPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1oZXJzaGV5LWpyLWJlYXJzLWNocmlzdG1hcy10b3VybmFtZW50Lmh0bSI+aGVyc2hleSBqciBiZWFycyBjaHJpc3RtYXMgdG91cm5hbWVudDwvYT4KPC9saT4KPHN0cmlrZT5UaGUgbGFjZXlzOiBjaHJpc3RtYXMgbW92aWUgYW5kIGEgcmVjaXBlPC9zdHJpa2U+CjxzbWFsbD5Nb21teSYjMzk7cyBraXRjaGVuIC0gcmVjaXBlcyBmcm9tIG15IHRleGFzIGtpdGNoZW4hOiBjaG9jb2xhdGU8L3NtYWxsPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLXRyZWUtbWl4ZWQtY291bnRyeS00LjUuaHRtIj5ydXRoIGluc3RpdHV0ZSBibG9nILsgcmVjaXBlIGZvciBwZWFjZTwvYT4KPC9zdHJpa2U+CjxsaT4mIzM5O2dydW1weSBjYXQmIzM5O3Mgd29yc3QgY2hyaXN0bWFzIGV2ZXImIzM5OyBpcyB0aGUgcGVyZmVjdCByZWNpcGUgZm9yIC0gemFwMml0PC9saT4KPHNtYWxsPk1vcnRvbiBmYW1pbHkgc3RyYXRhIGZyb20gJiM4MjIwO3RoZSBmYW1pbHkgc3RvbmUmIzgyMjE7IC0gbGlmZSBhdCBjbG92ZXJoaWxsPC9zbWFsbD4KPGxpPlJlY2lwZSBmb3IgYSBwZXJmZWN0IGNocmlzdG1hcyAtIGRvd25sb2FkIGhkIG1vdmllPC9saT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LXNvdWwtZm9vZC1jaHJpc3RtYXMuaHRtIj5hbGwgdGhlIGJhcmsgcmVjaXBlcyB5b3UgY291bGQgZXZlciBuZWVkIGZvciB0aGUgaG9saWRheXM8L2E+Cjwvc3RyaWtlPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jaHJpc3RtYXMtY29sb3Jpbmctc2hlZXRzLmh0bSI+Y2FuZGFjZSBjYW1lcm9uIGJ1cmUgb24gaGVyIG5ldyBjaHJpc3RtYXMgbW92aWUgYW5kIGhlcjwvYT4KPC9zbWFsbD4KPGxpPlRoZSBjaHJpc3RtYXMgZ3JhbSBjb2NrdGFpbCByZWNpcGUgfCBhbiBhcHBlYWxpbmcgcGxhbjwvbGk+CjxsaT5hIGNocmlzdG1hcyBzdG9yeSBuZXcgeW9yayBjaXR5PC9saT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWxvd2VzLWFydGlmaWNhbC1jaHJpc3RtYXMtdHJlZXMuaHRtIj5sb3dlcyBhcnRpZmljYWwgY2hyaXN0bWFzIHRyZWVzPC9hPgo8L3N0cmlrZT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtdGhlLXdyaWdodC1mYW1pbHktY2hyaXN0bWFzLXN0b3J5Lmh0bSI+dGhlIHdyaWdodCBmYW1pbHkgY2hyaXN0bWFzIHN0b3J5PC9hPgo8L3NtYWxsPgo8c21hbGw+V2F0Y2ggcmVjaXBlIGZvciBhIHBlcmZlY3QgY2hyaXN0bWFzIG9ubGluZSBmdWxsIG1vdmllIGZyZWU8L3NtYWxsPgo8c3RyaWtlPkhvbGlkYXkgZHJpbmsgcmVjaXBlOiBob3cgdG8gbWFrZSAmIzM5O2EgY2hyaXN0bWFzIHN0b3J5JiMzOTsgY29ja3RhaWwgKHZpZGVvPC9zdHJpa2U+CjxzdHJpa2U+TWFrZSBpdCBhIG1vdmllIG5pZ2h0IHdpdGggYW4gbSZhbXA7bSBwb3Bjb3JuIGJhbGwgcG9wc2ljbGUgcmVjaXBlPC9zdHJpa2U+CjxzdHJpa2U+UmVjaXBlIGZvciBhIHBlcmZlY3QgY2hyaXN0bWFzIHwgdHVtYmxyPC9zdHJpa2U+CjxzdHJpa2U+VGJzIHN1cGVyc3RhdGlvbiAtIGRpbm5lciAmYW1wOyBhIG1vdmllOiByZWNpcGVzPC9zdHJpa2U+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWZ1bm55LWNocmlzdG1hcy1waXR1cmVzLmh0bSI+Y2hyaXN0bWFzIG1vdmllIGhhY2tzOiBhdm9pZGluZyBhIGRpbm5lciBkaXNhc3RlciAtIGF2aXZhPC9hPgo8L3NtYWxsPgo8bGk+VGhlIGdpZnQgb2YgYSBjaHJpc3RtYXMgc2NlbnQgKGhvbWVtYWRlIGhvbGlkYXkgcG90cG91cnJpKS48L2xpPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLWdpZnQtZm9yLXNvbWVvbmUtdmVyeS1zcGVjaWFsLmh0bSI+cmVjaXBlIGZvciBhIHBlcmZlY3QgY2hyaXN0bWFzIHwgd2F0Y2ggZnVsbCBtb3ZpZS4gZG93bmxvYWQgZnVsbDwvYT4KPC9zdHJpa2U+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWZlZWRzYWNrLWNocmlzdG1hcy1zdG9ja2luZy5odG0iPmZlZWRzYWNrIGNocmlzdG1hcyBzdG9ja2luZzwvYT4KPC9zbWFsbD4KPHNtYWxsPlRocm93YmFjayBob2xpZGF5IG1vdmllIG5pZ2h0ICsgY2hlcnJ5IGNob2NvbGF0ZSBjaGVlc2VjYWtlPC9zbWFsbD4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtbGFya2luLWJsdWVncmFzcy1jaHJpc3RtYXMtaW4tdGhlLXNtb2tpZXMuaHRtIj5saWZldGltZSBjaHJpc3RtYXMgbW92aWUgMjAxNSBzY2hlZHVsZTogZGVjZW1iZXIgMS0xMyBsaW5ldXA8L2E+CjwvbGk+CjxzbWFsbD4mIzM5O2Zyb3plbiYjMzk7IHNub3dmbGFrZSBjb29raWUgcmVjaXBlICYjODIxMTsgeXVtISAmIzgyMTE7IGp1c3QgYSBtdW08L3NtYWxsPgo8c3RyaWtlPlF1aWNrICZhbXA7IGVhc3kgLSByZWNpcGUuY29tPC9zdHJpa2U+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LXVuaXF1ZS1wZXJzb25hbC1jaHJpc3RtYXMtY2FyZHMuaHRtIj51bmlxdWUgcGVyc29uYWwgY2hyaXN0bWFzIGNhcmRzPC9hPgo8L3NtYWxsPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1iaXJkLWNocmlzdG1hcy10cmVlLWx1Y2suaHRtIj5iaXJkIGNocmlzdG1hcyB0cmVlIGx1Y2s8L2E+CjwvbGk+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNocmlzdG1hcy1wb2xpY2UtY2VyYW1pYy1ob3VzZS5odG0iPmZ1biBjaHJpc3RtYXMga2lkcyByZWNpcGUgLSBzYW50YSBob3QgZG9nIGNyZXNjZW50IHJvbGxzPC9hPgo8L3NtYWxsPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS03LjUtcHJlbGl0LWNocmlzdG1hcy10cmVlLmh0bSI+Y2VsZWJyYXRlIHlvdXIgZnJpZW5kcyB3aXRoIGEgcmVjaXBlIGZvciBjaHJpc3RtYXMgYmlzY290dGkhPC9hPgo8L2xpPgo8c21hbGw+MTAwKyBjaHJpc3RtYXMgcmVjaXBlcyBvbiBwaW50ZXJlc3QgfCBjaHJpc3RtYXMgZGVzZXJ0cywgYmVzdDwvc21hbGw+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LXRoZS1jaHJpc3RtYXMtcXVpZXQtZmlsbS5odG0iPnB1dGxvY2tlciByZWNpcGUgZm9yIGEgcGVyZmVjdCBjaHJpc3RtYXMgKDIwMDUpIHdhdGNoIG9ubGluZSBmb3I8L2E+CjwvbGk+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LW5pZ2h0bWFyZS1iZWZvcmUtY2hyaXN0bWFzLWZyZWUtcHVtcGtpbi1wYXR0ZXJucy5odG0iPmRpc25leSBpcmwgfCBmYW1pbHkgbW92aWUgbmlnaHQ6IHRoZSBuaWdodG1hcmUgYmVmb3JlIGNocmlzdG1hczwvYT4KPC9zbWFsbD4KPGxpPlBhbGVvIHNuYWNrczogNTEgc2ltcGxlIHJlY2lwZXMgYW55b25lIGNhbiBsb3ZlIHwgZ3JlYXRpc3Q8L2xpPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1odW5nYXJpYW4tY2hyaXN0bWFzLWZvb2RzLWFuZC10aGVpci1yZWNpcGVzLmh0bSI+cmVjaXBlIGZvciBhIHBlcmZlY3QgY2hyaXN0bWFzIDIwMDUgbW92aWUgYWN0b3IgLSB3aWtpbW92aWVzLm5ldDwvYT4KPC9zbWFsbD4KPHN0cmlrZT5CZXN0IG1vdmllLWluc3BpcmVkIHJlY2lwZXMgfCBmb29kICZhbXA7IHdpbmU8L3N0cmlrZT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWJlc3QtZ2lmdC1mb3Itd2lmZS10aGlzLWNocmlzdG1hcy5odG0iPnRoZSBub3Qtc28tc2VjcmV0IHJlY2lwZSBmb3IgdGVsZXZpc2lvbiBjaHJpc3RtYXMgbW92aWVzIC0gd2hhdDwvYT4KPC9zdHJpa2U+CjxzbWFsbD4xOCBjbGFzc2ljIGNocmlzdG1hcyBtb3ZpZXMgLSBiZXN0IGNvbWVkeSBtb3ZpZXMgZm9yIGNocmlzdG1hczwvc21hbGw+CjxzdHJpa2U+TW92aWUgbmlnaHQgc25hY2sgbWl4IHJlY2lwZSB8IGplbGx5IGJlbGx5IGNhbmR5IGNvbXBhbnk8L3N0cmlrZT4KPHN0cmlrZT5DaG9jb2xhdGUgY2FuZHkgY2FuZSBjdXBjYWtlcyByZWNpcGUgJmFtcDsgYXJ0aHVyIGNocmlzdG1hcyByZXZpZXc8L3N0cmlrZT4KPHN0cmlrZT5CYmMgZm9vZCAtIHJlY2lwZXMgLSB0dXJrZXkgcm9sbCB3aXRoIGNocmlzdG1hcyBjcnVtYmxlIHRvcHBpbmc8L3N0cmlrZT4KPHN0cmlrZT5NYWluIGluZ3JlZGllbnRzIHwgYW4gZWxmJiMzOTtzIGd1aWRlIHRvIGVhdGluZyBkdXJpbmcgY2hyaXN0bWFzIHNlYXNvbjwvc3RyaWtlPgo8c3RyaWtlPlR2IGNsYXNzaWNzIGFyZSByZWNpcGUgZm9yIGNocmlzdG1hcyBkYXkgZGVsaWdodCB8IGZyZWV2aWV3PC9zdHJpa2U+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWdpZnQtYm9vdHMtY2hyaXN0bWFzLWlkZWEuaHRtIj5naWZ0IGJvb3RzIGNocmlzdG1hcyBpZGVhPC9hPgo8L3NtYWxsPgo8bGk+Qm9iYnkgY2FubmF2YWxlICZhbXA7IGNocmlzdGluZSBiYXJhbnNraSByZWNpcGUgZm9yIGEgcGVyZmVjdCBjaHJpc3RtYXM8L2xpPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jaHJpc3RtYXMtbW91c2UtYnktZ2FybGFuZC5odG0iPmxpZmV0aW1lJiMzOTtzIDEyIGJlc3Qgcm9tYW50aWMgY2hyaXN0bWFzIG1vdmllcyAtIGRhdGluZyBhZHZpY2U8L2E+Cjwvc21hbGw+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNocmlzdG1hcy1kZWNvcmF0aW9uLWhvbWUtbWFkZS5odG0iPjEwIG1vdmllIHNuYWNrIHJlY2lwZXMge2dsdXRlbi1mcmVlfSBhbmQgYSAmIzM5O3dlIGxvdmUgbW92aWVzPC9hPgo8L3NtYWxsPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLXN0b3JpZXMtYW5kLXBvZW1zLWFuZC1odW1vci5odG0iPndhdGNoIHJlY2lwZSBmb3IgYSBwZXJmZWN0IGNocmlzdG1hcyAoMjAwNSkgLSBvbmxpbmVmcmVlbW92aWU8L2E+Cjwvc3RyaWtlPgo8c3RyaWtlPlRoZSAxMCBiZXN0IGhvbGlkYXkgbW92aWUgZm9vZCBzY2VuZXMgfCBubyByZWNpcGUgcmVxdWlyZWQ8L3N0cmlrZT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtaG93LXRvLWRlY29yYXRlLWNocmlzdG1hcy10cmVlcy5odG0iPmNocmlzdG1hcyBtb3ZpZSBuaWdodCB7YW5kIGhvdCBhcnRpY2hva2UgZGlwfSAtIGxpdHRsZSBlYXJ0aGxpbmcgYmxvZzwvYT4KPC9zbWFsbD4KPHN0cmlrZT5EaXNuZXkgZnJvemVuIGljZSBpbnNwaXJlZCBwZXBwZXJtaW50IHJvY2sgY2FuZHkgKyBjaHJpc3RtYXM8L3N0cmlrZT4KPHNtYWxsPkVhdCBsaWtlIHRoZSBzdGFyczogY29yaW5uZSBncmlmZml0aCYjMzk7cyBjaHJpc3RtYXMgcHVkZGluZzwvc21hbGw+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1hZHZlcnRpc2VtZW50cy13aXRob3V0LWNocmlzdG1hcy5odG0iPmEgYm95IGFuZCBhIGRvZzogYSB3aW5uaW5nIGNocmlzdG1hcyByZWNpcGUgLSBzYW4gYW50b25pbyBleHByZXNzPC9hPgo8L3N0cmlrZT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtbWFkZWEtc3R5bGUtY2hyaXN0bWFzcy1za2l0cy5odG0iPmludG8gdGhlIHdvb2RzOiBob2xpZGF5IGJha2luZyByZWNpcGVzIGZyb20gYmlnIHN1ciBiYWtlcnkgLSB2b2d1ZTwvYT4KPC9saT4KPHNtYWxsPkNhcmx5IHBvcGUgLSB3aWtpcGVkaWEsIHRoZSBmcmVlIGVuY3ljbG9wZWRpYTwvc21hbGw+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWhlcnNoZXktanItYmVhcnMtY2hyaXN0bWFzLXRvdXJuYW1lbnQuaHRtIj5oZXJzaGV5IGpyIGJlYXJzIGNocmlzdG1hcyB0b3VybmFtZW50PC9hPgo8L2xpPgo8c3RyaWtlPkF1c3RyYWxpYW4gY2hyaXN0bWFzIHJlY2lwZXMgQCBub3QgcXVpdGUgbmlnZWxsYTwvc3RyaWtlPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1nZW9yZ2UtY29zdGFuemEtY2hyaXN0bWFzLWNhcmQuaHRtIj5nZW9yZ2UgY29zdGFuemEgY2hyaXN0bWFzIGNhcmQ8L2E+Cjwvc21hbGw+CjxzbWFsbD5BIHJlY2lwZSBmb3IgaGFwcGluZXNzPC9zbWFsbD4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtbmF0aW9uYWwtbGFtcG9vbidzLWNocmlzdG1hcy12YWNhdGlvbi1zdHJlYW1pbmctdmlkZW8uaHRtIj5taXNpeCB8IGV4b2R1cyYjMzk7IHJlY2lwZSBmb3IgZGlzYXN0ZXI8L2E+Cjwvc21hbGw+CjxsaT5RdWl6OiB3aGljaCAmcXVvdDtjaHJpc3RtYXMgdmFjYXRpb24mcXVvdDsgY2hhcmFjdGVyIGFyZSB5b3UgLSBwdXJld293PC9saT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLWRlY29yYXRpb24td2luLmh0bSI+Y2hyaXN0bWFzIGRlY29yYXRpb24gd2luPC9hPgo8L2xpPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1sZWQtY2hyaXN0bWFzLWxpZ2h0cy5odG0iPmNocmlzdG1hcyBtb3ZpZXMgMjAxNiAtIHlvdXIgaG9tZSBmb3IgdGhlIGNocmlzdG1hcyBob2xpZGF5czwvYT4KPC9saT4KPHNtYWxsPk1vdmllIHJldmlldzogYXJ0aHVyIGNocmlzdG1hcyAtIHRoZSByZWNpcGUgc2hlZDwvc21hbGw+CjxzdHJpa2U+RGVuaXNlIHJpY2hhcmRzJiMzOTsgbmV3IGNocmlzdG1hcyBtb3ZpZSBnZXRzIHRoZSBmcmVha3kgZnJpZGF5PC9zdHJpa2U+CjxzbWFsbD5Nb3ZpZSBjYW5keSBjYXJhbWVsIGNvcm4gLSByZWNpcGUgLSBjb29rcy5jb208L3NtYWxsPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jaHJpc3RtYXMtY2Fyb2xzLXN0YXJ0aW5nLXdpdGgtdy5odG0iPnJlY2lwZSBmb3IgYSBwZXJmZWN0IGNocmlzdG1hcyAtIHdhdGNoIG1vdmllcyBvbmxpbmUgYXQgeGZpbml0eSB0djwvYT4KPC9saT4KPHN0cmlrZT5NYXJ5IGJlcnJ5JiMzOTtzIGNocmlzdG1hcyBjYWtlIHJlY2lwZSAtIGdvb2R0b2tub3c8L3N0cmlrZT4KPHN0cmlrZT5Tb2Z0LWJha2VkIGN1dG91dCBzdWdhciBjb29raWVzIHwgYSBsYXR0ZSBmb29kPC9zdHJpa2U+CjxsaT4yNSB1bi1jaHJpc3RtYXMgZ3JpbmNoIHRyZWF0cyAtIHRvdGFsbHkgdGhlIGJvbWIuY29tPC9saT4KPGxpPlBlcHBlcm1pbnQgaG90IGNob2NvbGF0ZSBjb29raWVzIC0gcHVtcGtpbiAmIzM5O24gc3BpY2U8L2xpPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1vbGQtd29ybGQtY2hyaXN0bWFzLWxpZ2h0LWNvdmVyLXJvc2UuaHRtIj5vbGQgd29ybGQgY2hyaXN0bWFzIGxpZ2h0IGNvdmVyIHJvc2U8L2E+Cjwvc21hbGw+CjxzbWFsbD5UaGUgbmlnaHRtYXJlIGJlZm9yZSBjaHJpc3RtYXMgYSAmcXVvdDtoYWxsb3dlZW4gbW92aWUmcXVvdDssIGNvbmZpcm1zPC9zbWFsbD4KPHNtYWxsPldoaXRlIGNocmlzdG1hcyBob2xpZGF5IGJhcmsgLSAtIHNraW5ueSBzb21ldGltZXM8L3NtYWxsPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jaHJpc3RtYXMtbm90ZWJvb2suaHRtIj5yZWNpcGUgZm9yIGEgcGVyZmVjdCBjaHJpc3RtYXMgLSBoZCBtb3ZpZSAtIDIwMDU8L2E+CjwvbGk+CjxsaT5XYXRjaCByZWNpcGUgZm9yIGEgcGVyZmVjdCBjaHJpc3RtYXMgKDIwMDUpIG9ubGluZSBmcmVlIHB1dGxvY2tlcjwvbGk+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LXRyZWUtbWFkZS1mcm9tLWNocmlzdG1hcy1jYXJkcy5odG0iPm1vdmllIHRoZWF0ZXIgYmFyayByZWNpcGUgfCBtYXJ0aGEgc3Rld2FydDwvYT4KPC9saT4KPHNtYWxsPlRoZSBwYXN0IG9uIGEgcGxhdGU6IGRpbm5lciBhbmQgYSBtb3ZpZTogd2hpdGUgY2hyaXN0bWFzLCB2aXNpb25zPC9zbWFsbD4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LXNoYWZ0c2J1cnktd2lsa2lucy1jaHJpc3RtYXMuaHRtIj5yZWNpcGUgY2FyZCAtIHRhYmVybmFjbGUgJiM4MjExOyBleHBlcmllbmNlIGZhbWlseTwvYT4KPC9zdHJpa2U+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LXRvcm4tcGFwZXItY2hyaXN0bWFzLWNhcmRzLmh0bSI+Y2hyaXN0bWFzIGNhcm9sIHJlY2lwZXM6IHRoZSBjcmF0Y2hpdCYjMzk7cyAmIzgyMjA7aG90IHN0dWZmLCYjODIyMTsgYW5kIGRpY2tlbnM8L2E+CjwvbGk+CjxzbWFsbD5NZXJyeSBtb3ZpZSBuaWdodCAmYW1wOyBjaHJpc3RtYXMgY2FrZSBwb3Bjb3JuIC0gc3VnYXIgJmFtcDsgc291bDwvc21hbGw+CjxzdHJpa2U+VGhyZWUgbW92aWUgYW5kIHJlY2lwZSBwYWlyaW5nIGZvciBhIHNub3d5IHdlZWtlbmQ8L3N0cmlrZT4KPHN0cmlrZT43IGNocmlzdG1hcyBtb3ZpZXMgeW91JiMzOTt2ZSBuZXZlciBoZWFyZCBvZiAodGhhdCBhcmUgYWN0dWFsbHkgcXVpdGU8L3N0cmlrZT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtbWVycnktY2hyaXN0bWFzLXRvLWFsbC1zb25nLmh0bSI+Y2hyaXN0bWFzIHRyYWRpdGlvbnM6IGJyaXRhaW4gdnMuIGFtZXJpY2EgfCBhbmdsb3BoZW5pYSB8IGJiYyBhbWVyaWNhPC9hPgo8L3NtYWxsPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jbGF1ZGluZS1sb25nZXQtY2hyaXN0bWFzLmh0bSI+d2UgcmVjcmVhdGVkIDMgZGVlcGx5IGRpc3R1cmJpbmcgdmludGFnZSBjaHJpc3RtYXMgcmVjaXBlcyB8IGZ1c2lvbjwvYT4KPC9saT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LW1vdmllLWEtY2hyaXN0bWFzLXN0b3J5Lmh0bSI+bW92aWUgYSBjaHJpc3RtYXMgc3Rvcnk8L2E+Cjwvc3RyaWtlPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtZnJlZS1jaHJpc3RtYXMtc2xlaWdoLXBsYW5zLmh0bSI+ZnJlZSBjaHJpc3RtYXMgc2xlaWdoIHBsYW5zPC9hPgo8L3N0cmlrZT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtZm9ydC13YWx0b24tYmVhY2gtY2hyaXN0bWFzLXBhcmFkZS5odG0iPnJlY2lwZSBmb3IgYSBwZXJmZWN0IGNocmlzdG1hcyAtIHRyYWlsZXJzICZhbXA7IHZpZGVvcyAtIHJvdHRlbiB0b21hdG9lczwvYT4KPC9saT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNocmlzdG1hcy1kcmVhbS1pdHVuZXMtY29tby5odG0iPjM5IGRpc2hlcyBmcm9tIHRoZSBmaXJzdCBjaHJpc3RtYXMgbWVudSwgcHVibGlzaGVkIGluIDE2NjAgfCBtZW50YWw8L2E+Cjwvc3RyaWtlPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1raWRzLWNocmlzdG1hcy1pbnZpdGF0aW9uLXNheWluZ3MuaHRtIj5yZWNpcGUgZm9yIGEgcGVyZmVjdCBjaHJpc3RtYXMgWzIwMTBdILsgbW92aWUgcmV2aWV3IHdlZWtseTwvYT4KPC9zbWFsbD4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLXdyZWF0aHMtcGljdHVyZS5odG0iPmNhc3Q8L2E+CjwvbGk+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LXRoZS1jaHJpc3RtYXMtb2xkLXBoaWxvc29waGVyLmh0bSI+dGhlIGNocmlzdG1hcyBvbGQgcGhpbG9zb3BoZXI8L2E+Cjwvc21hbGw+CjxzdHJpa2U+RXh0ZXJuYWwgcmV2aWV3czwvc3RyaWtlPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtdG9wLTEwMC1jaHJpc3RtYXMtc29uZ3MuaHRtIj5hIGRpY2tlbiYjMzk7cyBjaHJpc3RtYXMgcmVjaXBlIGZvciBjb2xjYW5ub24gOiB0aGUgcmVsdWN0YW50IGdvdXJtZXQ8L2E+Cjwvc3RyaWtlPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1hbmQtY2hyaXN0bWFzcy1mYWlyeS1maWdodHMtYmFjay5odG0iPnRoZSBuaWdodG1hcmUgYmVmb3JlIGNocmlzdG1hcyB8IGRpc25leSBtb3ZpZXM8L2E+CjwvbGk+CjxsaT5CZXN0IGNob2NvbGF0ZSBjaGlwIGNvb2tpZXMgLSB0aGF0IHNraW5ueSBjaGljayBjYW4gYmFrZTwvbGk+CjxzdHJpa2U+cGhvdG9ncmFwaHMgb2Ygd2lsbGlhbXNidXJnIHZhIGF0IGNocmlzdG1hczwvc3RyaWtlPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS13aGltc2ljYWwtY2hyaXN0bWFzLWVsZi5odG0iPmVsZi1pbnNwaXJlZCBjaHJpc3RtYXMgJnF1b3Q7Z3JhbXMmcXVvdDsjc3VuZGF5c3VwcGVyIC0gbWFyb2NtYW1hPC9hPgo8L2xpPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jaHJpc3RtYXMtY2FyZC1waG90b3MtYWxiYW55LW55Lmh0bSI+Y2hyaXN0bWFzIGdpZnQgYmFza2V0IGlkZWFzIC0gZmxvdXIgb24gbXkgZmFjZTwvYT4KPC9saT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtZmxhbWluZ28tY2hyaXN0bWFzLXN3ZWF0ZXIuaHRtIj5mbGFtaW5nbyBjaHJpc3RtYXMgc3dlYXRlcjwvYT4KPC9zbWFsbD4KPHN0cmlrZT5SYW1hJiMzOTtzIHNjcmVlbjogYSByZWNpcGUgZm9yIHRoZSBwZXJmZWN0IGhvbGlkYXkgbW92aWUgZXhwZXJpZW5jZTwvc3RyaWtlPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtYmVzdC1jaHJpc3RtYXMtdHJhdmVsLWRlc3RpbmF0aW9ucy5odG0iPmJlc3QgY2hyaXN0bWFzIHRyYXZlbCBkZXN0aW5hdGlvbnM8L2E+Cjwvc3RyaWtlPgo8c3RyaWtlPlRoaXMgaXMgY2hyaXN0bWFzO3dpbmUgcGFpcmluZ3MgZm9yIGhvbGlkYXkgI3N1bmRheXN1cHBlciByZWNpcGVzPC9zdHJpa2U+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNocmlzdG1hcy1zdG9yeS1sZWctbGFtcC1waWN0dXJlLmh0bSI+MjYgaG90IHdpbnRlciBkcmlua3MgLSByZWNpcGVzIGZvciBob2xpZGF5IGRyaW5rcyAtIGNvdW50cnkgbGl2aW5nPC9hPgo8L2xpPgo8bGk+Q2hyaXN0bWFzIGZvcnR1bmUgY29va2llczwvbGk+CjxzbWFsbD5SZWNpcGUgZm9yIGRpc2FzdGVyOiBhcGFydG1lbnQgY2hyaXN0bWFzIGNvb2tpZXMgLSB0aGUgYmxhY2sgc2hlZXA8L3NtYWxsPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jb21tZXJjaWFsaXNtLXJ1aW5zLXNwaXJpdC1vZi1jaHJpc3RtYXMuaHRtIj5yZWNpcGUgZm9yIGEgcGVyZmVjdCBjaHJpc3RtYXMgLSBzZWFzb24gMSByZXZpZXdzIC0gbWV0YWNyaXRpYzwvYT4KPC9zbWFsbD4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNocmlzdG1hcy1saWdodHMtbWFudWZhY3R1cmluZy1vaGlvLWRlay5odG0iPmJvdWdocyBvZiBmb2xseTogc2NpZW5jZSBibHVuZGVycyBpbiBuYXRpb25hbCBsYW1wb29uJiMzOTtzICYjMzk7Y2hyaXN0bWFzPC9hPgo8L3N0cmlrZT4KPGxpPk15IGZhdm9yaXRlIGhvbGlkYXkgbW92aWUgcGxheWxpc3QuIHwgaG93IHN3ZWV0IGl0IGlzPC9saT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWJsYWNrLXdoaXRlLWdyYXBoaWNzLWNocmlzdG1hcy10aW4tZ2FybGFuZC5odG0iPnRvYXN0OiBhIG1vdmllIHJldmlldyBhbmQgYSByZWNpcGUgZm9yIGxlbW9uIG1lcmluZ3VlIHBpZSB8IHRoaXM8L2E+Cjwvc3RyaWtlPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtcGhvdG9ncmFwaHMtb2Ytd2lsbGlhbXNidXJnLXZhLWF0LWNocmlzdG1hcy5odG0iPnB1bXBraW4gc3BpY2UgcG9wY29ybiAmYW1wOyBtb3JlIGhvbGlkYXkgbW92aWUtd2F0Y2hpbmcgcmVjaXBlcyE8L2E+Cjwvc3RyaWtlPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1waWN0dXJlcy1vZi1jaHJpc3RtYXMtY2FuZHkuaHRtIj5waWN0dXJlcyBvZiBjaHJpc3RtYXMgY2FuZHk8L2E+CjwvbGk+CjxzbWFsbD5XYXRjaCByZWNpcGUgZm9yIGEgcGVyZmVjdCBjaHJpc3RtYXMgKDIwMDUpIG9ubGluZSBmcmVlPC9zbWFsbD4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtYm9pc2UtaWRhaG8tYmF0dGVyeS1wb3dlcmVkLWNocmlzdG1hcy1saWdodHMuaHRtIj5ib2lzZSBpZGFobyBiYXR0ZXJ5IHBvd2VyZWQgY2hyaXN0bWFzIGxpZ2h0czwvYT4KPC9zbWFsbD4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtYmFyYmllLWNocmlzdG1hcy10cmVldG9wLmh0bSI+YmFyYmllIGNocmlzdG1hcyB0cmVldG9wPC9hPgo8L2xpPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jaGluYS1zcG9kZS1jaHJpc3RtYXMtcGxhdGVzLmh0bSI+Y2hyaXN0bWFzIGNvb2tpZSByZWNpcGVzIHwgaGFsbG1hcms8L2E+CjwvbGk+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LXdoZXJlLWlzLXRoZS13b3JsZHMtYmlnZ2VzdC1jaHJpc3RtYXMuaHRtIj5sb3ZlIGFjdHVhbGx5OiBiYW5vZmZlZSBwaWUgLSBmZWFzdCBvZiBzdGFybGlnaHQ8L2E+CjwvbGk+CjxzbWFsbD5JbWFnZXMgZm9yIGEgcmVjaXBlIGZvciBjaHJpc3RtYXMgbW92aWU8L3NtYWxsPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS13ZWxsc2Jvcm8tcGEtY2hhcmxlcy1kaWNrZW5zLWNocmlzdG1hcy5odG0iPm1lbGlzc2Etam9hbi1oYXJ0cy1pbmdyZWRpZW50cy1mb3ItY29va2luZy11cC1hLWNsYXNzaWMtY2hyaXN0bWFzPC9hPgo8L3NtYWxsPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1nZW9yZ2UtY29zdGFuemEtY2hyaXN0bWFzLWNhcmQuaHRtIj5ncmFudCYjMzk7cyBtb3ZpZSBuaWdodCBicm93bmllcyByZWNpcGUgLSByYWNoYWVsIHJheSBzaG93PC9hPgo8L2xpPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLW94Zm9yZHNoaXJlLmh0bSI+d2hpdGUgY2hvY29sYXRlIHBvcGNvcm4gd2l0aCBtJmFtcDttJiMzOTtzIHJlY2lwZSAtIGNlbnRlcmN1dGNvb2s8L2E+Cjwvc3RyaWtlPgo8c3RyaWtlPk1pbmlvbnMgbW92aWUgc25hY2sgbWl4IHJlY2lwZSAtIGNsb3NlIHRvIGhvbWU8L3N0cmlrZT4KPGxpPkFsbW9zdCBjaHJpc3RtYXMgdHJhaWxlcjogZGFubnkgZ2xvdmVyIGJlZ3MgZm9yIGEgZHJhbWEtZnJlZSBob2xpZGF5PC9saT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNocmlzdG1hcy1odW1vci1wYXJvZHktc29uZ3MtcmFwLmh0bSI+ZnVsbCBjYXN0ICZhbXA7IGNyZXc8L2E+Cjwvc3RyaWtlPgo8bGk+UmF0YXRvdWlsbGUmIzM5O3MgcmF0YXRvdWlsbGUgfCBzbWl0dGVuIGtpdGNoZW48L2xpPgo8c21hbGw+V2F0Y2ggcmVjaXBlIGZvciBhIHBlcmZlY3QgY2hyaXN0bWFzICgyMDA1KSBvbmxpbmUgZnJlZSAtIG1vdmllMjU8L3NtYWxsPgo8c3RyaWtlPkZpbG1pbmcgbG9jYXRpb25zPC9zdHJpa2U+CjxsaT5DaHJpc3RtYXMgdmFjYXRpb24gcGFydHk6IGdyaXN3b2xkIHN0eWxlIC0gZGVzaWduIGRhenpsZTwvbGk+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWZyZW5jaC1jYW5hZGlhbi1jaHJpc3RtYXMtY29sb3JpbmctcGFnZXMtZnJlZS5odG0iPnNob3J0YnJlYWQgY29va2llcyArIHBlcHBlcm1pbnQgaG90IGNob2NvbGF0ZSC7IGZhcmluZyB3ZWxsPC9hPgo8L3NtYWxsPgo8c3RyaWtlPkNocmlzdG1hcyBzaG9ydGJyZWFkIGNvb2tpZXMgfCBidXR0ZXIgYmFraW5nPC9zdHJpa2U+CjxsaT5FbGYgcXVvdGUgY2hyaXN0bWFzIGNvb2tpZXMguyBsb3ZlbHkgaW5kZWVkPC9saT4KPGxpPlJlY2lwZSBmb3IgYSBwZXJmZWN0IGNocmlzdG1hcyAocmVjZWl0YSBwYXJhIHVtIG5hdGFsIHBlcmZlaXRvPC9saT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LXJvbWFudGljLWlkZWFzLWZvci1odXNiYW5kLWF0LWNocmlzdG1hcy5odG0iPnN0YWZmIGNocmlzdG1hcyBtb3ZpZSBwaWNzIHwgb2ZmaWNpYWwgdGhlcm1vbWl4IGZvcnVtICZhbXA7IHJlY2lwZTwvYT4KPC9zdHJpa2U+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNoaWxkcmVuJ3MtY2hyaXN0bWFzLWhhdC5odG0iPnJlY2lwZSBmb3IgYSBwZXJmZWN0IGNocmlzdG1hcyAtIGNocmlzdG1hcyBzcGVjaWFscyB3aWtpIC0gd2lraWE8L2E+CjwvbGk+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNocmlzdG1hcy1naWZ0LXBldC5odG0iPmNocmlzdG1hcyBnaWZ0IHBldDwvYT4KPC9zbWFsbD4KPHN0cmlrZT5NdXNlIGVudGVydGFpbm1lbnQgLSByZWNpcGUgZm9yIGEgcGVyZmVjdCBjaHJpc3RtYXM8L3N0cmlrZT4KPHNtYWxsPk15IDEwIGZhdm9yaXRlIGZvb2QgZmlsbXMgKHdpdGggYWNjb21wYW55aW5nIHJlY2lwZXMhKSAtIGFsd2F5czwvc21hbGw+CjxzbWFsbD5Ib2xpZGF5IG1vdmllIHF1aXogfCBwYnMgZm9vZDwvc21hbGw+CjxzbWFsbD5UaGUgMTAgaGlnaGVzdC1ncm9zc2luZyBjaHJpc3RtYXMgbW92aWVzIG9mIGFsbCB0aW1lIC0gdGhlcmljaGVzdDwvc21hbGw+CjxsaT5SZWNpcGU6IGphY2sgc2tlbGxpbmd0b24gZ2luZ2VyYnJlYWQgY2FrZSBwb3BzICYjODIxMjsgc3VnYXJlZCBuZXJkPC9saT4KPHNtYWxsPkZhbWlseSBtb3ZpZSBuaWdodCAmIzgyMTE7IDE0IGNsYXNzaWMgY2hyaXN0bWFzIGZpbG1zIHlvdSYjMzk7dmUgZ290IHRvIHNlZTwvc21hbGw+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1zdXBwbGllcy1iZWFkZWQtY2hyaXN0bWFzLW9ybmFtZW50cy5odG0iPmRpbm5lciBhbmQgYSBtb3ZpZTogbWFwbGUgc3lydXAgc3BhZ2hldHRpIHJlY2lwZSB3aXRoIGJ1ZGR5IHRoZTwvYT4KPC9zdHJpa2U+CjxsaT5QZWFyIHN0cmV1c2VsIGt1Y2hlbjogaW5zcGlyZWQgYnkgdGhlIG5ldyBob2xpZGF5IGZpbG0sIGxvdmUgdGhlPC9saT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLWNyYWZ0cy10cmVlLmh0bSI+Y2hyaXN0bWFzIGZldHR1Y2NpbmUgJiM4MjEyOyBlcmluIGNvb2tzPC9hPgo8L3NtYWxsPgo8c21hbGw+Q2hyaXN0bWFzIG1vdmllIGZvb2QgLSByZWNpcGVzIGluc3BpcmVkIGJ5IGNocmlzdG1hcyBtb3ZpZXM8L3NtYWxsPgo8bGk+SGFsbG1hcmsgbW92aWVzIGFuZCBteXN0ZXJpZXM6IG9yaWdpbmFsIGRyYW1hcyAmYW1wOyBteXN0ZXJpZXM8L2xpPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtdGhlLXdyaWdodC1mYW1pbHktY2hyaXN0bWFzLXN0b3J5Lmh0bSI+d2hhdCBjaHJpc3RtYXMgZGVzc2VydCByZWNpcGUgc2hvdWxkIHlvdSB0cnkgdGhpcyB5ZWFyPzwvYT4KPC9zdHJpa2U+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jaHJpc3RtYXMtaW4td2lsbGlhbXNidXJnLXN0aXRjaGluZy1yZXRyZWF0Lmh0bSI+JnF1b3Q7cG9wY29ybiZxdW90OyBjdXBjYWtlcyAmYW1wOyBtb3ZpZSBuaWdodCAtIGJldHR5IGNyb2NrZXI8L2E+Cjwvc3RyaWtlPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtYmlnLWJveS1jaHJpc3RtYXMtdG95cy5odG0iPnJlY2lwZSBmb3IgYSBwZXJmZWN0IGNocmlzdG1hcyAoZHZkIHJldmlldykgYXQgd2h5IHNvIGJsdT88L2E+Cjwvc3RyaWtlPgo8bGk+VGhlIGJlc3Qgb2YgdGhlIHdvcnN0IG1hZGUtZm9yLXR2IGNocmlzdG1hcyBtb3ZpZXM8L2xpPgo8c3RyaWtlPlVzZXIgcmV2aWV3czwvc3RyaWtlPgo8bGk+RGFuaWVsbGUgcGFuYWJha2VyIGFzIGxhdXJlbiBvbiByZWNpcGUgZm9yIGxvdmUgfCBoYWxsbWFyayBjaGFubmVsPC9saT4KPHNtYWxsPlBlcHBlcm1pbnQgYmFyayBwb3Bjb3JuIC0geW91ciBjdXAgb2YgY2FrZTwvc21hbGw+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LW9yZGVyaW5nLWNocmlzdG1hcy1naWZ0cy1vbi1saW5lLmh0bSI+d2F0Y2ggcmVjaXBlIGZvciBhIHBlcmZlY3QgY2hyaXN0bWFzICgyMDA1KSBtb3ZpZSBvbmxpbmU8L2E+Cjwvc21hbGw+CjxzdHJpa2U+U25vd2ZsYWtlIHBvcGNvcm4gcmVjaXBlICsgZmFtaWx5IG1vdmllIHBhcnR5IGlkZWFzIC0gY2hpbGQgYXQ8L3N0cmlrZT4KPGxpPkNocmlzdG1hcyBjb29raWUgcmVjaXBlcyB8IHRocmlmdHlmdW48L2xpPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jaHJpc3RtYXMtdG9hc3QtZm9yLWZyaWVuZHMuaHRtIj4mIzM5O2RpcnR5IGdyYW5kcGEmIzM5OyBzdGFyIHphYyBlZnJvbiByZWNlaXZlcyBwZW5pcyBwYXN0YSByZWNpcGUgYm9vazwvYT4KPC9saT4KPHN0cmlrZT5DaHJpc3RtYXMgbW92aWUgbmlnaHQgd2l0aCB3b29kd29yayB3aW5lIHJlY2lwZSBraXQ8L3N0cmlrZT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2Fyb2wtZHV2YWwncy1jaHJpc3RtYXMtZGVjb3JhdGlvbnMuaHRtIj5jYXJvbCBkdXZhbCdzIGNocmlzdG1hcyBkZWNvcmF0aW9uczwvYT4KPC9saT4KPHNtYWxsPjxoMT5BIFJlY2lwZSBGb3IgQ2hyaXN0bWFzIE1vdmllPC9oMT48L3NtYWxsPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1wb2xpY2UtY2hyaXN0bWFzLXN0b2NraW5nLmh0bSI+YSBkaWNrZW5zIG9mIGEgZGlubmVyIGluIG5ld3MgJmFtcDsgb3BpbmlvbiBvbiB0aGUgZm9vZCBjaGFubmVsrjwvYT4KPC9zbWFsbD4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNvYXN0LWd1YXJkLWNocmlzdG1hcy1naWZ0cy5odG0iPmNocmlzdG1hcyBpcyBpbiB0aGUgYWlyLCB5ZXMsIGFscmVhZHksIGFuZCBhIGJ1dHRlcm51dCAtIGp1bHMmIzM5OyBraXRjaGVuPC9hPgo8L3N0cmlrZT4KPGxpPkkmIzM5O20gdHJ5aW5nIGZpbmQgYSBzb25nIGZyb20gdGhlIG1vdmllICZxdW90O3JlY2lwZSBmb3IgYSBwZXJmZWN0PC9saT4KCgo8aHI+CgpBIHJlY2lwZSBmb3IgY2hyaXN0bWFzIG1vdmllCg==