PCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9JRVRGLy9EVEQgSFRNTCAyLjAvL0VOIj4KPEhUTUw+PEhFQUQ+CjxUSVRMRT5FbnJpY2htZW50IGNocmlzdG1hcyBpZGVhczwvVElUTEU+CjwvSEVBRD48Qk9EWT4KCjxoMT5FbnJpY2htZW50IGNocmlzdG1hcyBpZGVhczwvaDE+Cgo8c3RyaWtlPlByaW1hdGUgZW5yaWNobWVudCAtIGhvdyB0byBlbnJpY2ggdGhlIGxpZmUgb2YgcHJpbWF0ZXM/IC0gcHJpbWF0ZSBjYXJlPC9zdHJpa2U+CjxzbWFsbD5DaHJpc3RtYXMgZm9yYWdpbmcgZ2lmdCBmb3IgeW91ciBiaXJkcyCrIGZvcmFnaW5nIGZvciBwYXJyb3RzPC9zbWFsbD4KPHN0cmlrZT5zY2hvb2wgY2hyaXN0bWFzIHByb2dyYW0gaWRlYXM8L3N0cmlrZT4KPGxpPnsgbW9ybW9uIHNoYXJlIGxlc3NvbiBoZWxwICZhbXA7IGJvb2tzdG9yZSB9IGFjdGl2aXRpZXMgZm9yIHJlbGllZiBzb2NpZXR5PC9saT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtcHVsbC11cC1jb2xsYXBzaWJsZS1jaHJpc3RtYXMtdHJlZS5odG0iPnB1bGwgdXAgY29sbGFwc2libGUgY2hyaXN0bWFzIHRyZWU8L2E+Cjwvc21hbGw+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LXNvdXRoLWFmcmljYW4tdHJlZS1vcm5hbWVudC1jaHJpc3RtYXMuaHRtIj5lbnJpY2htZW50IGFjdGl2aXRpZXMgZ2lmdHMgLSBlbnJpY2htZW50IGFjdGl2aXRpZXMgZ2lmdCBpZGVhcyBvbiB6YXp6bGU8L2E+CjwvbGk+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LTE5Mzktcm9iZXJ0LW1heS1jaHJpc3RtYXMtZmlndXJlLmh0bSI+ZW5yaWNobWVudCBpZGVhcyAtIG1vbSBzYW5pdHk8L2E+CjwvbGk+CjxsaT5FbnJpY2htZW50IGlkZWFzIHdhbnRlZCCrIC0gY2hpbXBhbnplZSBzYW5jdHVhcnkgbm9ydGh3ZXN0PC9saT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNocmlzdG1hcy1mYWlyLXNlYXR0bGUtd2EuaHRtIj5jaHJpc3RtYXMgZmFpciBzZWF0dGxlIHdhPC9hPgo8L3N0cmlrZT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtYXJ0aWZpY2lhbC1jaHJpc3RtYXMtdHJlZXMtYXJpem9uYS5odG0iPmEgdGltZSBmb3IgZW5yaWNobWVudCAtIGxpZ3VvcmlhbiBtYWdhemluZTwvYT4KPC9saT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2F0LWNocmlzdG1hcy1sZXR0ZXIuaHRtIj5tb250aGx5IGVucmljaG1lbnQgYWN0aXZpdGllcyBmb3IgYWxsISEgLSBwb3dlcmVkIGJ5IG9uY291cnNlPC9hPgo8L2xpPgo8c3RyaWtlPkRpeSByYWJiaXQgdG95IGlkZWFzIC0gYnVubnkgYXBwcm92ZWQgLSBob3VzZSByYWJiaXQgdG95czwvc3RyaWtlPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtcG9lbXMtZm9yLWxvdmVycy1hdC1jaHJpc3RtYXMuaHRtIj5zZXB0ZW1iZXJuZXdzIDIwMTUgZGVjZW1iZXIgbmV3c2xldHRlciAtIGVkZW5jcmVzdDwvYT4KPC9zdHJpa2U+CjxzbWFsbD5UZW5uZXNzZWUgYXF1YXJpdW0gd2FudHMgeW91IHRvIGJ1eSB0aGVzZSB3ZWlyZCBjaHJpc3RtYXMgZ2lmdHM8L3NtYWxsPgo8c21hbGw+SG9tZXNjaG9vbCBlbnJpY2htZW50IGlkZWFzIGZvciB0aGUgY2hyaXN0bWFzIHNlYXNvbiArICQ0MDA8L3NtYWxsPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtZG9vcmtub2ItY2hyaXN0bWFzLWRlY29ydGFpb24uaHRtIj5lbnJpY2htZW50IGlkZWFzIGFyY2hpdmVzIC0gZWF0IHByYXkgY3JlYXRlPC9hPgo8L3N0cmlrZT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLXRyZWUtZXZlcmV0dC13YS5odG0iPmNocmlzdG1hcyB0cmVlIGV2ZXJldHQgd2E8L2E+Cjwvc21hbGw+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1sYXN0LWNocmlzdG1hcy1oYXdrLW5lbHNvbi5odG0iPmxhc3QgY2hyaXN0bWFzIGhhd2sgbmVsc29uPC9hPgo8L3N0cmlrZT4KPGxpPkNyYWZ0YWhvbGljcyBhbm9ueW1vdXOuIHwgMzEgc3VwZXIgc2F0dXJkYXkgY3JhZnQgaWRlYXMhPC9saT4KPGxpPmNyb3NzIHN0aXRjaCBjaHJpc3RtYXMgb3JuYW1lbnRzIGZyZWUgcGF0dGVybnM8L2xpPgo8c21hbGw+UmVsaWVmIHNvY2lldHkgZW5yaWNobWVudCBjaHJpc3RtYXMgZ2lmdCBpZGVhcy4uLi4uIC0gYmFieWNlbnRlcjwvc21hbGw+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1idXktbWNndWlyZS1zaXN0ZXJzLWNocmlzdG1hcy1hbHBoYWJldC5odG0iPmJ1eSBtY2d1aXJlIHNpc3RlcnMgY2hyaXN0bWFzIGFscGhhYmV0PC9hPgo8L3N0cmlrZT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtYWR2ZXJ0aXNlbWVudHMtd2l0aG91dC1jaHJpc3RtYXMuaHRtIj5ob21lLCBmYW1pbHkgYW5kIHBlcnNvbmFsIGVucmljaG1lbnQgLSBzdWdhcmRvb2RsZTwvYT4KPC9zbWFsbD4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtZG9vcmtub2ItY2hyaXN0bWFzLWRlY29ydGFpb24uaHRtIj5lbnZpcm9ubWVudGFsIGVucmljaG1lbnQgLSBzYWZlIGhhdmVuIHdpbGRsaWZlIHNhbmN0dWFyeTwvYT4KPC9saT4KPHN0cmlrZT5idXkgbWF4aW5lIGNocmlzdG1hcyBjYXJkczwvc3RyaWtlPgo8c3RyaWtlPkV2ZW50cyAmIzgyMTE7IHJpdmVyc2lkZSBkaXNjb3ZlcnkgY2VudGVyPC9zdHJpa2U+CjxzdHJpa2U+RWNobyYjMzk7cyAyMDE0IGNocmlzdG1hcyBnaWZ0IG5lZWRzIGxpc3QgLSBldmVyZ3JlZW4gY2hyaXN0aWFuPC9zdHJpa2U+CjxzbWFsbD4zNyBob21lbWFkZSBkb2cgdG95cyBtYWRlIGJ5IGRpeSBwZXQgb3duZXJzIC0gYmlnIGRpeSBpZGVhczwvc21hbGw+CjxzdHJpa2U+Q2hyaXN0bWFzIHN0b3JlIKsgcGFya2VyIHN0cmVldCBtaW5pc3RyaWVzPC9zdHJpa2U+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1zZW5pb3ItaGlnaC1jaHJpc3RtYXMtbGVzc29uLmh0bSI+Y2hyaXN0bWFzIGNvbG9yaW5nIHNoZWV0cyAtIGVsZW1lbnRhcnkgc2Nob29sIGVucmljaG1lbnQgYWN0aXZpdGllczwvYT4KPC9zdHJpa2U+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LXVuaXF1ZS1wZXJzb25hbC1jaHJpc3RtYXMtY2FyZHMuaHRtIj5wcmVzY2hvb2wgd2ludGVyIHRoZW1lIGFjdGl2aXRpZXMgZm9yIHRlYWNoZXJzPC9hPgo8L3NtYWxsPgo8bGk+Wm9vIGNocmlzdG1hcyB8IHpvb3MgdmljdG9yaWE8L2xpPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtbmlnaHRtYXJlLWJlZm9yLWNocmlzdG1hcy13aGF0cy10aGlzLmh0bSI+bmlnaHRtYXJlIGJlZm9yIGNocmlzdG1hcyB3aGF0cyB0aGlzPC9hPgo8L3N0cmlrZT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LXNub29weS1jaHJpc3RtYXMtb3JuYW1lbnQtY29sbGVjdGFibGUuaHRtIj5ldmVuIGFuaW1hbHMgZ2V0IHByZXNlbnRzOiB6b28gZW5yaWNobWVudCBhY3Rpdml0aWVzIHwgZXhhbWluZXIuY29tPC9hPgo8L3N0cmlrZT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtaGVsbG8ta2l0dHktY2hyaXN0bWFzLWltYWdlcy5odG0iPm1vc3Qgc3VjY2Vzc2Z1bCBlbnJpY2htZW50IG5pZ2h0IHwgZnVsbCB0aGVtZWQgbmlnaHRzPC9hPgo8L3NtYWxsPgo8bGk+S2lkIGFjdGl2aXRpZXMgfCAxMDAwJiMzOTtzIG9mIGlkZWFzIGZvciBjaGlsZGNhcmUgcHJvZmVzc2lvbmFscyAmYW1wOyB0ZWFjaGVycyE8L2xpPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLWdpZnRzLXVuZGVyLTIwLjAwLmh0bSI+YW5pbWFsIGVucmljaG1lbnQgLSBjaGVldGFoIGV4cGVyaWVuY2U8L2E+Cjwvc3RyaWtlPgo8bGk+WW91JiMzOTtyZSBpbnZpdGVkIHRvIHRoZSBnYXRld2F5IGNocmlzdG1hcyBzb2NpYWwgLSBnYXRld2F5IHdlc3Rlcm48L2xpPgo8bGk+RWR1Y2F0aW9uIHdvcmxkOiBsYW5ndWFnZSBhcnRzOiB3cml0aW5nLCBsaXRlcmF0dXJlLCBhbmQgY3JlYXRpdml0eTwvbGk+CjxzdHJpa2U+Q3VycmljdWx1bSAmYW1wOyBlbnJpY2htZW50IC0gc3RlcHBpbmdzdG9uZSB0aGVhdHJlPC9zdHJpa2U+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jaHJpc3RtYXMtcG9wLXNvbmdzLmh0bSI+Y2hyaXN0bWFzIHBvcCBzb25nczwvYT4KPC9zdHJpa2U+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jaHJpc3RtYXMtdGhyb3VnaC1uZXcteWVhcnMtdmFjYXRpb24tZGVhbHMuaHRtIj5rLTMgY2hyaXN0bWFzIGNvbmNlcnQgaWRlYXMgKCA4MDUwMTYpLCBtLCBiICZhbXA7IHIgbXVzaWMgY2xhc3Nyb29tPC9hPgo8L3N0cmlrZT4KPHNtYWxsPnN0cmljdGx5IGNocmlzdG1hcyBuZWVkbGVwb2ludDwvc21hbGw+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LXRoZS1uaWdodG1hcmUtYmVmb3JlLWNocmlzdG1hcy1zYWxseS5odG0iPnJlYWRpbmcgc2FudGEmIzM5O3MgbmlnaHQgYmVmb3JlIGNocmlzdG1hcyBmb3IgY2xhc3Nyb29tIGVucmljaG1lbnQ8L2E+Cjwvc21hbGw+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWZyZWUtY3JvY2hldC1jaHJpc3RtYXMtaXRlbXMuaHRtIj5sZWFybmluZyBlbnJpY2htZW50IGlkZWFzIGZvciBraW5kZXJnYXJ0ZW4gYW5kIGZpcnN0IGdyYWRlPC9hPgo8L2xpPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY3Jvc3Mtc3RpdGNoLWNocmlzdG1hcy1vcm5hbWVudHMtZnJlZS1wYXR0ZXJucy5odG0iPmNyb3NzIHN0aXRjaCBjaHJpc3RtYXMgb3JuYW1lbnRzIGZyZWUgcGF0dGVybnM8L2E+Cjwvc3RyaWtlPgo8c3RyaWtlPnNlbmlvciBoaWdoIGNocmlzdG1hcyBsZXNzb248L3N0cmlrZT4KPHN0cmlrZT5FbnJpY2htZW50IC0gY3Jvd24gcmlkZ2UgdGlnZXIgc2FuY3R1YXJ5PC9zdHJpa2U+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LW1hbnVmYWN0dXJlLW9mLWNocmlzdG1hcy1kZWNvcmF0aW9uLmh0bSI+bWFudWZhY3R1cmUgb2YgY2hyaXN0bWFzIGRlY29yYXRpb248L2E+Cjwvc21hbGw+CjxzbWFsbD5Ib21lbWFkZSBnaWZ0cyBraWRzIGNhbiBtYWtlIC0gcmVhbCBsaWZlIGF0IGhvbWU8L3NtYWxsPgo8c3RyaWtlPkhpZ2gtaW50ZXJlc3QgYWN0aXZpdGllcyBmb3IgZW5yaWNobWVudCBhbmQgZXh0ZW5zaW9uIGluIGxhbmd1YWdlIC0gZ29vZ2xlIGJvb2tzIHJlc3VsdDwvc3RyaWtlPgo8bGk+SHVuZHJlZHMgb2YgY3JlYXRpdmUgYWZ0ZXItc2Nob29sIGVucmljaG1lbnQgaWRlYXMgZm9yIGtpZHM8L2xpPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jaHJpc3RtYXMtbGlnaHRzLW1hbnVmYWN0dXJpbmctb2hpby1kZWsuaHRtIj5zdXNhbnZvZ3QubmV0XG1vbnRobHkgZW5yaWNobWVudGFjdGl2aXRpZXM8L2E+Cjwvc21hbGw+CjxsaT5DaHJpc3RtYXMgaW4gY29ybndhbGwsIGtpZHMgYW5kIGZhbWlseSBldmVudHM8L2xpPgo8c21hbGw+Q2hyaXN0bWFzIG1hdGggd29ya3NoZWV0cyAoaGFyZGVyKSAtIG1hdGggc2FsYW1hbmRlcnM8L3NtYWxsPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1mdW5ueS1jaHJpc3RtYXMtZnJlZS1lLWNhcmRzLmh0bSI+ZnVubnkgY2hyaXN0bWFzIGZyZWUgZS1jYXJkczwvYT4KPC9saT4KPHNtYWxsPkNoaWxkcmVuJiMzOTtzIGVucmljaG1lbnQgY2VudGVyIC0gZGVhY29uZXNzIGhlYWx0aCBzeXN0ZW08L3NtYWxsPgo8bGk+U3Qtam9zZXBoLXNjaG9vbC1uZyB8IGFjYWRlbWljIGVucmljaG1lbnQ8L2xpPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jaGljYWdvLWdyb2Nlcnktc3RvcmVzLW9wZW4tY2hyaXN0bWFzLWRheS5odG0iPnJhbHBoIHNhZGxlaXIgc2Nob29sILsgZW5yaWNobWVudCBhY3Rpdml0aWVzPC9hPgo8L2xpPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLXBhZ2VudC1jb3N0dW1lLmh0bSI+ZW5yaWNobWVudCBhY3Rpdml0eSBpZGVhcyBmb3IgdGhlIGNyYXlvbiBib3ggdGhhdCB0YWxrZWQgbGVzc29uIHBsYW48L2E+Cjwvc3RyaWtlPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1lcmFzdXJlLWxvbmVseS1jaHJpc3RtYXMuaHRtIj5lbnJpY2htZW50IC8gZW5nYWdlbWVudCAvIGV4dGVuZGVkIHNjaG9vbHMgYWN0aXZpdGllcyB8IGNhbGU8L2E+Cjwvc21hbGw+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWxjYm8tYW5kLWdpZnQtcmV0dXJucy1hdC1jaHJpc3RtYXMuaHRtIj5lbnZpcm9ubWVudGFsIGVucmljaG1lbnQgZm9yIHB1cHBpZXMgYW5kIGRvZ3MgJiM4MjExOyBwdXp6bGUgdG95cyBhbmQ8L2E+Cjwvc21hbGw+CjxsaT5SZWxpZWYgc29jaWV0eSBjaHJpc3RtYXMgZW5yaWNobWVudDwvbGk+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1uYy1mYWlyLWNocmlzdG1hcy5odG0iPm5qIGtpZHMgdm9sdW50ZWVyIG9wcG9ydHVuaXRpZXMgZm9yIGNoaWxkcmVuLCB0ZWVucyAmYW1wOyBmYW1pbGllcyBpbjwvYT4KPC9zdHJpa2U+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LW1hcnktbWNjdXRjaGVvbi1jaHJpc3RtYXMtdHJlZS1jYW5hZGlhbi1saXZpbmcuaHRtIj5tYXJ5IG1jY3V0Y2hlb24gY2hyaXN0bWFzIHRyZWUgY2FuYWRpYW4gbGl2aW5nPC9hPgo8L2xpPgo8bGk+RW5yaWNobWVudCBkYXkgLSB0aGUgYXBwcmVudGljZSBwdyBieSAtIHVrIHRlYWNoaW5nIHJlc291cmNlczwvbGk+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1hLWNoaWxkJ3MtY2hyaXN0bWFzLXJpY2t5LXphaG5kLmh0bSI+bGlmZSBlbnJpY2htZW50IGFjdGl2aXRpZXMgJmFtcDsgcHJvZ3JhbXMgYXQgdGhlIHZpbGxhZ2Ugc2VuaW9yPC9hPgo8L3N0cmlrZT4KPGxpPkFzc3VtcHRpb24gaG9tZSBzY2hvb2wgYXNzb2NpYXRpb24gd2F5cyB0byBnZXQgaW52b2x2ZWQ8L2xpPgo8bGk+MTAwMCsgaWRlYXMgYWJvdXQgcmVsaWVmIHNvY2lldHkgY2hyaXN0bWFzIG9uIHBpbnRlcmVzdCB8IHJlbGllZjwvbGk+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWJpYmxpY2FsLWNocmlzdG1hcy5odG0iPmhvbm9sdWx1IHpvbyYjMzk7cyBhbmltYWwgZW52aXJvbm1lbnRhbCBlbnJpY2htZW50IHByb2dyYW08L2E+CjwvbGk+CjxzdHJpa2U+RWR1Y2F0aW9uIGZvciBjcm9zcy1jdWx0dXJhbCBlbnJpY2htZW50OiBzZWxlY3RlZCBhcnRpY2xlcyBmcm9tIC0gZ29vZ2xlIGJvb2tzIHJlc3VsdDwvc3RyaWtlPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3Utcm9ja2VuLWFyb3VuZC10aGUtY2hyaXN0bWFzLXRyZWUuaHRtIj50aGUgaGFwcHkgZmxvd2VyIGRheSBwcm9qZWN0IHwgYW5kIGxpZmUgZW5yaWNobWVudCBwcm9ncmFtcyBmb3I8L2E+Cjwvc3RyaWtlPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jaHJpc3RtYXMtbGlnaHRzLWRlay5odG0iPmNocmlzdG1hcyBsaWdodHMgZGVrPC9hPgo8L3NtYWxsPgo8bGk+RG93bmxvYWQgZWFzeSBlbnJpY2htZW50IGlkZWFzOiB0aGlua2luZyBvdXRzaWRlIHRoZSBncmVlbjwvbGk+CjxzbWFsbD5SYXQgdG95IGlkZWFzIC0gdGhlIGRhcHBlciByYXQ8L3NtYWxsPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1mbGFtaW5nby1jaHJpc3RtYXMtc3dlYXRlci5odG0iPmNocmlzdG1hcyBnaWZ0IGlkZWFzIGZvciB5b3VyIGRvZyAmIzgyMTE7IGRvZ3MgaW4gdGhlIGNsZTwvYT4KPC9zbWFsbD4KPHN0cmlrZT5QdXJlIGVucmljaG1lbnQgcHVyZXN0ZWFtIGZhYnJpYyBzdGVhbWVyICYjODIxMTsgd2hpdGUgfCBjaHJpc3RtYXM8L3N0cmlrZT4KPGxpPkVucmljaG1lbnQgdGFza3MgfCBkcm94Zm9yZCBqdW5pb3Igc2Nob29sPC9saT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3Utcm9ja2VuLWFyb3VuZC10aGUtY2hyaXN0bWFzLXRyZWUuaHRtIj50cmktY291bnR5IGNvbW11bml0eSBjb2xsZWdlIGNvbW11bml0eSBlbnJpY2htZW50IC0gdHJpLWNvdW50eTwvYT4KPC9saT4KPHN0cmlrZT5FbnJpY2htZW50IGlkZWFzPC9zdHJpa2U+CjxzbWFsbD5UaXBzIGZvciBlbnJpY2htZW50IC0gcmFiYml0IGF3YXJlbmVzcyB3ZWVrPC9zbWFsbD4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWx5cmljcy10by1zaXN0ZXJzLWluLXdoaXRlLWNocmlzdG1hcy5odG0iPnRoZSBhbmltYWwgZW5yaWNobWVudCBwcm9qZWN0PC9hPgo8L3N0cmlrZT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtcGlwZXMtZHJlYW0tb2YtY2hyaXN0bWFzLWJhbmQtc2VhcmNoLmh0bSI+Y2hyaXN0bWFzLyBjaGFudWthaC8ga3dhbnphYSB0ZWFjaGluZyByZXNvdXJjZXMgJmFtcDsgbGVzc29uPC9hPgo8L2xpPgo8c3RyaWtlPlRlbiBmcmVlIGdpZnRzIHRvIGdpdmUgdGhpcyBjaHJpc3RtYXMgfCBnZW4geCBmaW5hbmNlPC9zdHJpa2U+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jb2NvbnV0LXVuZGVyLXRoZS1jaHJpc3RtYXMtdHJlZS5odG0iPmNvY29udXQgdW5kZXIgdGhlIGNocmlzdG1hcyB0cmVlPC9hPgo8L3N0cmlrZT4KPGxpPmFwcGFsb29zYSBjaHJpc3RtYXMgb3JuYW1lbnQ8L2xpPgo8bGk+Y2F0IGNocmlzdG1hcyBsZXR0ZXI8L2xpPgo8bGk+Q2hyaXN0bWFzIG1hdGhzLW5yaWNoIC0gbWlsbGVubml1bSBtYXRoZW1hdGljcyBwcm9qZWN0PC9saT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNocmlzdG1hcy10cmVlLWxhZHkuaHRtIj5jaHJpc3RtYXMgdHJlZSBsYWR5PC9hPgo8L3N0cmlrZT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtaWRlYXMtZm9yLWNocmlzdG1hcy1nYWctZ2lmdHMuaHRtIj5pZGVhcyBmb3IgY2hyaXN0bWFzIGdhZyBnaWZ0czwvYT4KPC9zbWFsbD4KPGxpPldvcmxkIGJpcmQgc2FuY3R1YXJ5OiB0aGUgcm9va2llIGZpbGVzOiBlbnJpY2htZW50PC9saT4KPGxpPmtuaXQgY3JvY2hldCBjaHJpc3RtYXMgdHJlZSBkZWNvcmF0aW9uczwvbGk+CjxsaT5FeHRlbnNpb24gJmFtcDsgZW5yaWNobWVudCBhY3Rpdml0aWVzIGZvciBncmFkZXMgay0xMiAtIHRlYWNoZXJ2aXNpb248L2xpPgo8c3RyaWtlPkhvbWUgc2Nob29sIGVucmljaG1lbnQgLSBob21lc2Nob29sIGN1cnJpY3VsdW0gcmV2aWV3cyAtIGlkZWFzPC9zdHJpa2U+CjxzbWFsbD5QaWcgYmxvZyAtIG1pbmkgcGlnIGluZm88L3NtYWxsPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1teHB4LWNocmlzdG1hcy1kYXkuaHRtIj4yIG1vbnRoIG9sZCBiYWJ5IGRldmVsb3BtZW50IHRveXMgJmFtcDsgYWN0aXZpdGllcyB8IGZpc2hlci1wcmljZTwvYT4KPC9saT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3Utd2VhdGhlci1wcm9mZmluZy1jaHJpc3RtYXMtbGlnaHRzLmh0bSI+dGhlIGJlc3QgY2hyaXN0bWFzIHBhZ2VhbnQgZXZlciBlbnJpY2htZW50IGd1aWRlIC0gZmlyc3Qgc3RhZ2U8L2E+CjwvbGk+CjxsaT5PcGVyYXRpb24gY2hyaXN0bWFzIGNoaWxkIHNob2UgYm94IHBhY2tpbmcgaWRlYXM8L2xpPgo8c3RyaWtlPlJlbGllZiBzb2NpZXR5IC0gc3VnYXJkb29kbGU8L3N0cmlrZT4KPHN0cmlrZT50aGUgbmlnaHRtYXJlIGJlZm9yZSBjaHJpc3RtYXMgc2FsbHk8L3N0cmlrZT4KPHNtYWxsPk1hdGh3aXJlLmNvbSB8IHdpbnRlciBtYXRoIGFjdGl2aXRpZXM8L3NtYWxsPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1iZWFjaC1jaHJpc3RtYXMtbGlnaHRpbmcuaHRtIj5ob21lLCBmYW1pbHksIGFuZCBwZXJzb25hbCBlbnJpY2htZW50IG1lZXRpbmcgLSBtY3BoaWU8L2E+CjwvbGk+CjxsaT5FbnJpY2htZW50IGlkZWFzIC0gYWxiYW55IGtpZDwvbGk+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS10aGUtbmlnaHRtYXJlLWJlZm9yZS1jaHJpc3RtYXMtc2FsbHkuaHRtIj5zdCBpdmVzIGp1bmlvciBzY2hvb2wgfCBlbnJpY2htZW50IHdlZWtzIDIwMTM8L2E+Cjwvc3RyaWtlPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3Utd2hhdC1pcy1jaHJpc3RtYXMtcGxhbnQuaHRtIj5jaHJpc3RtYXMgZ2lmdCBpZGVhcyB8IGJsYWNrcG9vbCB6b288L2E+Cjwvc3RyaWtlPgo8bGk+Q2hyaXN0bWFzIHRlYWNoZXIgZ2lmdCBpZGVhcyAoaG9tZW1hZGUpIC0gc2ltcGxlazEyLmNvbTwvbGk+CjxzdHJpa2U+MTAgZ2lmdHMgdGhhdCBlbnJpY2ggdGhlIHNhY3JhbWVudCBvZiBjb25maXJtYXRpb24gLSBsb3lvbGEgcHJlc3M8L3N0cmlrZT4KPHN0cmlrZT5DYXRhbG9nIG9mIGNvcHlyaWdodCBlbnRyaWVzLiB0aGlyZCBzZXJpZXM6IDE5Njc6IGp1bHktZGVjZW1iZXIgLSBnb29nbGUgYm9va3MgcmVzdWx0PC9zdHJpa2U+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNocmlzdG1hcy10cml2aWEtam9rZXMuaHRtIj53b21lbiYjMzk7cyBjaHJpc3RtYXMgZXZlbnQgfCBjcm9zc2luZ3MgY29tbXVuaXR5IGNodXJjaDwvYT4KPC9zbWFsbD4KPHN0cmlrZT5TdGFmZiBkZXZlbG9wbWVudCBpZGVhcyB0byBpbXByb3ZlIHF1YWxpdHkgb2Ygam9iIHBlcmZvcm1hbmNlIGFuZDwvc3RyaWtlPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jaHJpc3RtYXMtc2FsZXMtb24tYmljeWNsZXMuaHRtIj4xMCBxdWljayBtdXNpYyBlbnJpY2htZW50IGlkZWFzIC0gdGhlIGVuZCBpbiBtaW5kPC9hPgo8L2xpPgo8c3RyaWtlPlJlbGllZiBzb2NpZXR5IGVucmljaG1lbnQgaWRlYXM6IHVwY29taW5nIGNocmlzdG1hcyBwcm9ncmFtPC9zdHJpa2U+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LXRoZS1naG9zdC1mcm9tLWNocmlzdG1hcy1wYXN0Lmh0bSI+ZHdlbGxpbmcgaW4gcG9zc2liaWxpdHk6IHJlbGllZiBzb2NpZXR5IGNocmlzdG1hcyBwYXJ0eTwvYT4KPC9zbWFsbD4KPHNtYWxsPkNvbW11bml0eSAmYW1wOyBmYW1pbHkgZW5yaWNobWVudCAtIGJyaW5rbGV5IGdyb3ZlIHByaW1hcnkgc2Nob29sPC9zbWFsbD4KPGxpPkV2ZW50cyAmYW1wOyBwcm9ncmFtcyAtIHB0byB0b2RheTwvbGk+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWxhc3QtY2hyaXN0bWFzLWppbW15LWVhdC13b3JsZC5odG0iPmZyaWVuZHMgb2Ygd2FzaG9lIDogbGVhcm4gOiBhYm91dCBjaGltcGFuemVlIGVucmljaG1lbnQgOiBmb29kPC9hPgo8L2xpPgo8bGk+RW5yaWNobWVudCBjbHViIGRlc2NyaXB0aW9ucyAtIGZyYW1pbmdoYW0gcHVibGljIHNjaG9vbHM8L2xpPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jaHJpc3RtYXMtY2FyZC1mdW5kLXJhaXNlci5odG0iPiYjODIyMDtjb21tdW5pdHkgZW5yaWNobWVudCB0aHJvdWdoIGZ1biBhbmQgZnVuZHJhaXNpbmcmIzgyMjE7PC9hPgo8L3NtYWxsPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1tZXJyeS1jaHJpc3RtYXMtd2lkZXNjcmVlbi5odG0iPndoeSB3YXMgdGhlIHByb2Zlc3NvciBzbyBhZ3JlZWFibGUgdG8gdGhlIGNoaWxkcmVuJiMzOTtzIGlkZWFzPC9hPgo8L2xpPgo8bGk+TG93IGNvc3QgZW5yaWNobWVudC8gYWN0aXZpdHkgZm9yIHByaSBzY2hvb2wga2lkcz8gKHBhZ2UgMjwvbGk+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jaHJpc3RtYXMtaW4td2luZHktdHJlZS1jaXR5Lmh0bSI+Y2hyaXN0bWFzIGluIHdpbmR5IHRyZWUgY2l0eTwvYT4KPC9zdHJpa2U+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWxhcmdlLXNpemVkLWNocmlzdG1hcy1jb29raWUtY3V0dGVycy5odG0iPmxhcmdlIHNpemVkIGNocmlzdG1hcyBjb29raWUgY3V0dGVyczwvYT4KPC9zbWFsbD4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLWhvc2UuaHRtIj5jaHJpc3RtYXMgaG9zZTwvYT4KPC9saT4KPHNtYWxsPkVudGl0eSBlbnJpY2htZW50IGVuZ2luZSAoZTMpIHwgYm9veiBhbGxlbiBoYW1pbHRvbjwvc21hbGw+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LXBkZi1jaHJpc3RtYXMtb3JpZ2FtaS1kaWFncmFtcy5odG0iPnBoeXNpY2FsIGVkdWNhdGlvbiAtIGVucmljaG1lbnQgLSByc2EgYWNhZGVteSBhcnJvdyB2YWxlPC9hPgo8L3NtYWxsPgo8c21hbGw+V2ludGVyIGVucmljaG1lbnQgYWN0aXZpdGllcyBmb3IgeW91ciBtb250ZXNzb3JpIHNjaG9vbCAtIG5hbWM8L3NtYWxsPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY29tbWVyY2lhbGlzbS1ydWlucy1zcGlyaXQtb2YtY2hyaXN0bWFzLmh0bSI+dW5pdmVyc2l0eSBvZiBtaW5uZXNvdGEsIG1vcnJpcyB8IGFjYWRlbWljIGNlbnRlciBmb3IgZW5yaWNobWVudDwvYT4KPC9zdHJpa2U+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS13aGVuLWEtY2hyaXN0bWFzLWNhcm9sLXdhcy1wdWJsaXNoZWQuaHRtIj5wcm92aWRpbmcgZW5yaWNobWVudCBhdCBubyBjb3N0LCBwYXJ0IGlpPC9hPgo8L3N0cmlrZT4KPGxpPlByaW50YWJsZSBnaW5nZXJicmVhZCBmaWd1cmUgZm9yIHRha2UtaG9tZSBwcm9qZWN0IC0gdGVhY2hlcnMubmV0PC9saT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLXdvbmRlcmxhbmQtc3ByaW5nZmllbGQtbmVicmFza2EuaHRtIj5jaHJpc3RtYXMgd29uZGVybGFuZCBzcHJpbmdmaWVsZCBuZWJyYXNrYTwvYT4KPC9zbWFsbD4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY291bnRkb3duLXRvLWNocmlzdG1hcy13YWxscGFwZXIuaHRtIj5jb3VudGRvd24gdG8gY2hyaXN0bWFzIHdhbGxwYXBlcjwvYT4KPC9saT4KPHN0cmlrZT5UaGlyZCBncmFkZSBzcGFuaXNoIGVucmljaG1lbnQ6PC9zdHJpa2U+CjxsaT5BY3Rpdml0eSBpZGVhcyBmb3IgYWx6aGVpbWVyJiMzOTtzL2RlbWVudGlhIHJlc2lkZW50czwvbGk+CjxsaT5IYW5kcyBmb3IgaHVtYW5pdHkgLSBleHRlbmQgYSBoYW5kLCBlbnJpY2ggYSBsaWZlLiA6IGhhbmRzIGZvcjwvbGk+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNocmlzdG1hcy10cmVlLWxpZ2h0cy12b2x0YWdlcy5odG0iPnJlbGllZiBzb2NpZXR5IChlbnJpY2htZW50LyB2aXNpdGluZyB0ZWFjaGluZy8gc2lzdGVyaG9vZCkgb248L2E+CjwvbGk+CjxsaT5EaXkgY2hyaXN0bWFzIGVucmljaG1lbnQvdG95IGZvciBob3JzZXMgLSB5b3V0dWJlPC9saT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNocmlzdG1hcy1wcmludGVkLWNyb3NzLXN0aXRjaC5odG0iPmxkcyBjaHJpc3RtYXMgcHJvZ3JhbXMgYXJjaGl2ZXMgJiM4MjI2OyBtb3Jtb24gc2hhcmUgbGVzc29uIGhlbHA8L2E+Cjwvc3RyaWtlPgo8c3RyaWtlPkN1dCB3YXN0ZSB3aXRoIG1lYW5pbmdmdWwgZ2lmdHMgZm9yIGxvdmVkIG9uZXMgfCB3YWdnbGUgZGFuY2U8L3N0cmlrZT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLWNvbWljLWpva2UuaHRtIj4xMCBnaWZ0IGlkZWFzIGZvciBob21lc2Nob29sIGZhbWlsaWVzIC0gc291dGhlYXN0IGhvbWVzY2hvb2wgZXhwbzwvYT4KPC9saT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtYnJvdGhlcnMtMTItZGF5cy1vZi1jaHJpc3RtYXMuaHRtIj5sYXRlc3QgbmV3c2xldHRlciB8IHN0LiBqb2huIGJvc2NvIGFjYWRlbXk8L2E+Cjwvc21hbGw+CjxzdHJpa2U+U3VnZ2VzdGVkIGd1aWRlbGluZXMgZm9yIGNhcm5pdm9yZSBlbnJpY2htZW50IC0gYWF6azwvc3RyaWtlPgo8c21hbGw+VmlzaXRpbmcgdGVhY2hpbmcgc3VycHJpc2UhPC9zbWFsbD4KPHN0cmlrZT5PcGVyYXRpb24gY2hyaXN0bWFzIGNoaWxkIHwgZmlyc3QgYmFwdGlzdCBjaHVyY2ggamFja3NvbnZpbGxlPC9zdHJpa2U+CjxsaT5UZXhhcyBob21lc2Nob29sIGNvLW9wcyAmYW1wOyBhY2FkZW1pYyBlbnJpY2htZW50IGNsYXNzZXM8L2xpPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1ob3ctdG8tZGVjb3JhdGUtY2hyaXN0bWFzLXRyZWVzLmh0bSI+dGhlIGVucmljaG1lbnQgdGltZXMgLSB0aGUgc2hhcGUgb2YgZW5yaWNobWVudDwvYT4KPC9zbWFsbD4KPHN0cmlrZT5TZWEgbGlvbiBlbnJpY2htZW50IC0gaG91c3RvbiB6b288L3N0cmlrZT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWFwcGFsb29zYS1jaHJpc3RtYXMtb3JuYW1lbnQuaHRtIj53aHkgbm90IGdpdmUgYSBjcnVpc2UgZm9yIGNocmlzdG1hcz8gLSBjYW1lbHMgJmFtcDsgY2hvY29sYXRlPC9hPgo8L3N0cmlrZT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LXNjYW5kaW5hdmlhbi1jaHJpc3RtYXMtaGF0cy5odG0iPmVucmljaG1lbnQgZm9yIHlvdXIgcGFycm90IC0gbm9ydGhlcm4gcGFycm90czwvYT4KPC9zdHJpa2U+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS13ZSdyZS1leHBlY3RpbmctY2hyaXN0bWFzLWNhcmQuaHRtIj5jb2xsZWdlIGNhbGVuZGFyIGFuZCBlbnJpY2htZW50IC0gZWFzdCBzdXJyZXkgY29sbGVnZTwvYT4KPC9zdHJpa2U+CjxzbWFsbD5Ib21lIGZhbWlseSBhbmQgcGVyc29uYWwgZW5yaWNobWVudCBtZWV0aW5nIGlkZWFzIC0gb2Ytd29ydGguY29tPC9zbWFsbD4KPGxpPkVucmljaG1lbnQgcHJvamVjdHMgc3QgdmluY2VudCYjMzk7cyBzY2hvb2w8L2xpPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1zb3V0aC1hZnJpY2FuLXRyZWUtb3JuYW1lbnQtY2hyaXN0bWFzLmh0bSI+bGl0dGxlIGxkcyBpZGVhcyAtIGEgcGxhY2UgdG8gc2hhcmUgYWxsIG9mIG15IGxpdHRsZSBpZGVhc2xpdHRsZSBsZHM8L2E+CjwvbGk+CjxsaT5Wb2x1bnRlZXIgd2l0aCBjaGlsZHJlbiBsaXZpbmcgaW4gaG9tZWxlc3Mgc2hldGxlcjogaW50ZXJmYWl0aDwvbGk+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LW15c3BhY2Utd293LWNocmlzdG1hcy5odG0iPmNvbW11bml0eSBlbnJpY2htZW50IHNlcmllcyAtIGhpZ2ggcG9pbnQgdW5pdmVyc2l0eTwvYT4KPC9zbWFsbD4KPGxpPkFjdGl2aXRpZXMgZm9yIHJlbGllZiBzb2NpZXR5IHwgamVubnkgc21pdGgmIzM5O3MgbGRzIGlkZWFzICZhbXA7IGJvb2tzdG9yZTwvbGk+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LXJlbGlnaW91cy1jaHJpc3RtYXMtcGxheXMtYW5kLW11c2ljYWxzLmh0bSI+cmVsaWdpb3VzIGNocmlzdG1hcyBwbGF5cyBhbmQgbXVzaWNhbHM8L2E+CjwvbGk+CjxzbWFsbD5JbWFnZXMgZm9yIGVucmljaG1lbnQgY2hyaXN0bWFzIGlkZWFzPC9zbWFsbD4KPHN0cmlrZT53ZSdyZSBleHBlY3RpbmcgY2hyaXN0bWFzIGNhcmQ8L3N0cmlrZT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNvbmNvcmRpYS1jaHJpc3RtYXMuaHRtIj5jb25jb3JkaWEgY2hyaXN0bWFzPC9hPgo8L3N0cmlrZT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LXdvcmxkLWNocmlzdG1hcy1tYXJrZXQtY29yc2ljYW4tdGV4YXMuaHRtIj5jaHJpc3RtYXMgdmlueWwgZm9yIGdsYXNzIGJsb2NrcyAtIGxkcyBlbnJpY2htZW50IG5pZ2h0cywgc3VwZXI8L2E+Cjwvc3RyaWtlPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtaXRhbHktY2hyaXN0bWFzLWhvbGlkYXkuaHRtIj5tZXJyeSBjaHJpc3RtYXMhIHwgZXpla2llbCBtaW5pc3RyaWVzPC9hPgo8L3N0cmlrZT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWEtY2hyaXN0bWFzLWNhcm9sLXBhYnN0LXRoZWF0ZXItbWlsd2F1a2VlLmh0bSI+YWRkaXRpb25hbCByZWxpZWYgc29jaWV0eSBtZWV0aW5nIG5vdCBlbnJpY2htZW50PC9hPgo8L3N0cmlrZT4KPHN0cmlrZT5DcmFmdCBjaHJpc3RtYXMgdHJlZSBkZWNvcmF0aW9ucyBwaWN0dXJlIC0gbW9yZSBkZXRhaWxlZCBwaWN0dXJlPC9zdHJpa2U+CjxzdHJpa2U+RG93bmxvYWQgLSByZW56dWxsaSBsZWFybmluZzwvc3RyaWtlPgo8bGk+Q2hyaXN0bWFzIGlkZWFzIGJ5IHZhbGFyaWUgb24gaW5kdWxneS5jb208L2xpPgo8bGk+PGgxPkVucmljaG1lbnQgQ2hyaXN0bWFzIElkZWFzPC9oMT48L2xpPgo8c3RyaWtlPkVucmljaG1lbnQgbWF0aCB8IHlhbiYjMzk7cyBvbmUgbWludXRlIG1hdGggYmxvZzwvc3RyaWtlPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1pbmRpYW5hcG9saXMtaW5kaWFuYS1vcGVuLW9uLWNocmlzdG1hcy1kYXkuaHRtIj5lbnJpY2htZW50IHllYXIgaWRlYXMgMyAmIzgyMTI7IHNpbXBseSBjaGFybG90dGUgbWFzb248L2E+Cjwvc21hbGw+CjxzbWFsbD5Ib2xpZGF5IGVucmljaG1lbnQ6IGZydWl0IGxvb3AgZnVuIHwgc3RhbGUgY2hlZXJpb3M8L3NtYWxsPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1iaXJkLWNocmlzdG1hcy10cmVlLWx1Y2suaHRtIj5iaXJkIGNocmlzdG1hcyB0cmVlIGx1Y2s8L2E+Cjwvc21hbGw+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jaHJpc3RtYXMtcGFnZW50LWNvc3R1bWUuaHRtIj5hZnRlciB0aGUgc3RvcnkncyBvdmVyOiB5b3VyIGVucmljaG1lbnQgZ3VpZGUgdG8gODggcmVhZC1hbG91ZCAtIGdvb2dsZSBib29rcyByZXN1bHQ8L2E+Cjwvc3RyaWtlPgo8c21hbGw+RG9lcyBhbnlib2R5IG91dCB0aGVyZSBoYXZlIGFueSBpZGVhcyBmb3IgaG9vZnN0b2NrIGVucmljaG1lbnQ8L3NtYWxsPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3Uta25pdC1jcm9jaGV0LWNocmlzdG1hcy10cmVlLWRlY29yYXRpb25zLmh0bSI+dGhlIGVucmljaG1lbnQgcHJvamVjdCAtIGxhcmFqbGEgY3JlYXRlczwvYT4KPC9zdHJpa2U+CjxzbWFsbD5MaXN0IG9mIHJlbGllZiBzb2NpZXR5IG1lZXRpbmcgaWRlYXMgLSBsZHMgd29tZW4gb2YgZ29kPC9zbWFsbD4KPHNtYWxsPkNocmlzdG1hcyBlbnJpY2htZW50IGlkZWFzIC0gZWFzeSBlbnJpY2htZW50IGlkZWFzPC9zbWFsbD4KPHN0cmlrZT5FbnJpY2htZW50IGd1aWRlIC0gdGhpcnRlZW48L3N0cmlrZT4KPGxpPmlkZWFzIGZvciBjaHJpc3RtYXMgZ2FnIGdpZnRzPC9saT4KPGxpPk5ld3MgYW5kIGFydGljbGVzIHwgemVhcmluZyBjaGlsZCBlbnJpY2htZW50IGNlbnRlciAtIHByaW5jZXRvbjwvbGk+CjxzbWFsbD5wb2VtcyBmb3IgbG92ZXJzIGF0IGNocmlzdG1hczwvc21hbGw+CjxzdHJpa2U+Q2hyaXN0bWFzIG0mYW1wO20gcG9lbSArIGdpZnQgaWRlYSAtIGxpbCYjMzk7IGx1bmE8L3N0cmlrZT4KPHN0cmlrZT5DdCBob2xpZGF5IGZ1biBndWlkZSB8IG1vbW15cG9wcGlucyAtIHRoaW5ncyB0byBkbyBpbjwvc3RyaWtlPgo8c3RyaWtlPkZvcmFnaW5nL2VucmljaG1lbnQgaWRlYXMuIHwgY2FnZXMsIGF2aWFyaWVzICZhbXA7IHRveXMgfCByZWFsPC9zdHJpa2U+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LTk2LWhpc3RvcmljYWwtY2hyaXN0bWFzLW9ybmFtZW50Lmh0bSI+OTYgaGlzdG9yaWNhbCBjaHJpc3RtYXMgb3JuYW1lbnQ8L2E+CjwvbGk+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1zY2hvb2wtY2hyaXN0bWFzLXByb2dyYW0taWRlYXMuaHRtIj5jaHJpc3RtYXMgLSBjb25uaWUgbWF4d2VsbCBjaGlsZHJlbiYjMzk7cyBob21lPC9hPgo8L3N0cmlrZT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3Utc3RyaWN0bHktY2hyaXN0bWFzLW5lZWRsZXBvaW50Lmh0bSI+c3RyaWN0bHkgY2hyaXN0bWFzIG5lZWRsZXBvaW50PC9hPgo8L2xpPgo8bGk+QmFycmllciBnYW1lczogZ3JlYXQgZm9yIGxhbmd1YWdlIGVucmljaG1lbnQ8L2xpPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jb2xvcmVkLWNocmlzdG1hcy10cmVlLmh0bSI+Y2hyaXN0bWFzIGdpZnRzIGZvciBkb2dzIDIwMTQ6IDggZnVuIHByZXNlbnQgaWRlYXMgZm9yIHBldHM8L2E+CjwvbGk+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWRlc2lnbmVyLWNocmlzdG1hcy1jZW50ZXJwaWVjZXMuaHRtIj5ob2xpZGF5cyAmYW1wOyBzcGVjaWFsIHRoZW1lcyAtIG1hY29tYiBpbnRlcm1lZGlhdGUgc2Nob29sIGRpc3RyaWN0PC9hPgo8L2xpPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtYnV5LW1heGluZS1jaHJpc3RtYXMtY2FyZHMuaHRtIj5jaGltcGFuemVlcyBlbmpveSBlYXJseSBjaHJpc3RtYXMgaW4gc3lkbmV5LCBhdXN0cmFsaWE8L2E+Cjwvc3RyaWtlPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLXRyYXZlbC1vcHRpb25zLmh0bSI+ZW5yaWNobWVudCBjbHVzdGVycyB8IGhpbmtsZXRvd24gbWVubm9uaXRlIHNjaG9vbDwvYT4KPC9zdHJpa2U+CjxsaT5SZWxpZWYgc29jaWV0eSBvbiBwaW50ZXJlc3QgfCByZWxpZWYgc29jaWV0eSBhY3Rpdml0aWVzLCB2aXNpdGluZzwvbGk+CgoKPGhyPgoKRW5yaWNobWVudCBjaHJpc3RtYXMgaWRlYXMK