PCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9JRVRGLy9EVEQgSFRNTCAyLjAvL0VOIj4KPEhUTUw+PEhFQUQ+CjxUSVRMRT5NYWRlbGluZS9ndSBlbmFtZWwgY2hyaXN0bWFzIGNoYXJtczwvVElUTEU+CjwvSEVBRD48Qk9EWT4KCjxoMT5NYWRlbGluZS9ndSBlbmFtZWwgY2hyaXN0bWFzIGNoYXJtczwvaDE+Cgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1tYWRlbGluZS9ndS1jaHJpc3RtYXMtc25vdy1taW5uZWFwb2xpcy1tbi5odG0iPmNocmlzdG1hcyBzbm93IG1pbm5lYXBvbGlzIG1uPC9hPgo8L3N0cmlrZT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3Utd2hhdC1pcy1jaHJpc3RtYXMtdGluc2VsLW1hZGUtb2YuaHRtIj50b3Jwb2ludCBhZHZlcnRpc2VyIGphbnVhcnkgMjAxNiBieSBjb3JuZXJzdG9uZSB2aXNpb24gLSBpc3N1dTwvYT4KPC9zdHJpa2U+CjxzbWFsbD5BaGRlYXIuY29tIDogJiMyODAxMDsmIzI4NDU5OyYjODIyMDsmIzI0MDc2OyYjODIyMTsmIzI4MjE2OyYjMzU3NjA7KCYjMjAxMTY7KS0tJiMyMTUwNzsmIzIxOTE3OyYjMzQ4ODA7JiMyNTMwNjsmIzIyMzEyOyYjMzg1OTc7JiMyMDg1Njs8L3NtYWxsPgo8c3RyaWtlPkFycm93c21pdGggLyBzaW5jbGFpciBsZXdpczwvc3RyaWtlPgo8c21hbGw+U2NyYXBrb25zdDogdGlsZGEgd2l0aCBiaWcgYmlnIHJvc2UgY2hyaXN0bWFzIGNhcmQ8L3NtYWxsPgo8bGk+MTggLSByZWQgYmFuayByZWdpc3RlciBhcmNoaXZlPC9saT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1tYWRlbGluZS9ndS1iZXN0LWJ1eS1kYXktYWZ0ZXItY2hyaXN0bWFzLWhvdXJzLmh0bSI+YmVzdCBidXkgZGF5IGFmdGVyIGNocmlzdG1hcyBob3VyczwvYT4KPC9zbWFsbD4KPHN0cmlrZT4zNzMgYmVzdCB2aW50YWdlIGp1bHdlcnkgaW1hZ2VzIG9uIHBpbnRlcmVzdCB8IGpld2VscnkgaWRlYXM8L3N0cmlrZT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtbHlyaWNzLXdlLW5lZWQtYS1saXR0bGUtY2hyaXN0bWFzLmh0bSI+dGhlIGRpc3RyaWJ1dGVkIHByb29mcmVhZGVycyBjYW5hZGEgZWJvb2sgb2YgYXJyb3dzbWl0aCBieTwvYT4KPC9zdHJpa2U+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtaXMtY2hyaXN0bWFzLWEtcGVnYW4taG9saWRheS5odG0iPmh0dHBzOi8vamV0LmNvbS9wcm9kdWN0L3RoZS1kaXNjb3Zlcnktb2YtZ3VpYW5hPC9hPgo8L3NtYWxsPgo8c3RyaWtlPkh0dHBzOi8vd3d3LndhbG1hcnQuY29tL2lwL2dsb2JhbC1nYWxsZXJ5LWxhenktYWZ0ZXJub29uLWJ5LWRpYW5lPC9zdHJpa2U+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtY2hyaXN0bWFzLWFuZ2VsLWNyYWZ0cy1mb3Ita2lkcy5odG0iPnNhZyBoYXJib3IgbnkgZXhwcmVzcyAxOTA2LTE5MDcgZ3JheXNjYWxlIC0gZnVsdG9uIGhpc3Rvcnk8L2E+Cjwvc21hbGw+CjxzdHJpa2U+QmVzdCBwczQgZ2FtZXMgMjAxODogYWxsIHRoZSBtdXN0LWhhdmUgcGxheXN0YXRpb24gNCBnYW1lczwvc3RyaWtlPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LWRvd25sb2FkLWZyZWUtZ29zcGVsLWNocmlzdG1hcy1jYXJvbHMuaHRtIj5jb21wdXRlciBpZGVhcyAtIGxlYXJuaW5nIGJ1c2luZXNzIGVuZ2xpc2ggd2l0aCBodW1hbmVuZ2xpc2g8L2E+Cjwvc21hbGw+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtY2hyaXN0bWFzLWNsb3N1cmVzLXBhbG0tc3ByaW5ncy1jYS5odG0iPm11ZWJsZXMgbXV5IG9yaWdpbmFsZXMgLSBidXNjYXIgY29uIGdvb2dsZSAtIHBpbnRlcmVzdDwvYT4KPC9saT4KPHN0cmlrZT5MdWNlbmUvc3VnZ2VzdC9zcmMvdGVzdC9vcmcvYXBhY2hlL2x1Y2VuZS9zZWFyY2gvc3VnZ2VzdDwvc3RyaWtlPgo8c3RyaWtlPjEwNiBiZXN0IHVuaSBlc3NlbnRpYWxzIGltYWdlcyBvbiBwaW50ZXJlc3QgfCBjaHJpc3RtYXMgMjAxNzwvc3RyaWtlPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LWN1cnQtbWZnLWNocmlzdG1hcy1wYXJ0eS5odG0iPjY2dGggYWNhZGVteSBhd2FyZHMgLSB3aWtpcGVkaWE8L2E+Cjwvc21hbGw+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LW1hcmstcm9iZXJ0cy1hcnRpZmljaWFsLWNocmlzdG1hcy10cmVlcy5odG0iPmFyb3VuZCB0aGUgd29ybGQgLyBydXNzaWEgLSBtYXgga2FzeW1vdjwvYT4KPC9zdHJpa2U+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtaGVhcnQtY2hyaXN0bWFzLmh0bSI+aGVhcnQgY2hyaXN0bWFzPC9hPgo8L3NtYWxsPgo8bGk+NC4zYnNkL3Vzci9kaWN0L3dvcmRzIGEgYWFhIGFhYXMgYWFyaHVzIGFhcm9uIGFiYSBhYmFiYTwvbGk+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LXRvd24tY2hyaXN0bWFzLXRyZWUtbGlnaHRpbmcuaHRtIj5iZSA3NTQ2MzAgdGhlIDYzMDIwMCBpIDQzMDkyNyBhbmQgMzc0MTk2IGEgMzI5MTM0IHRvIDMyNjYxOSBvZjwvYT4KPC9zdHJpa2U+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtY2hyaXN0bWFzLXN0b3JlLW9ubGluZS5odG0iPnZvbHVtZSBpbmZvcm1hdGlvbiAtIGpzdG9yPC9hPgo8L3NtYWxsPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LWphbWFpY2FuLXJ1bS1zYXVjZS1mb3ItY2hyaXN0bWFzLXB1ZGRpbmcuaHRtIj44OCBiZXN0IGpld2Vscnk6IGZpZ3VyYWwgcGllY2VzIGltYWdlcyBvbiBwaW50ZXJlc3QgfCBhbnRpcXVlPC9hPgo8L2xpPgo8bGk+RG5yIHdhcm5zIC0gd2VzdGxhbmQgcHVibGljIGxpYnJhcnk8L2xpPgo8bGk+QnkgYXQgZm0gLSBsb2NhbCBoaXN0b3J5IGFyY2hpdmVzPC9saT4KPGxpPkZlYXR1cmVkIGl0ZW1zIGZyb20gcGFzdCBzYWxlcyAtIHN1c2FuaW5zPC9saT4KPHNtYWxsPjEzIGJlc3QgJiMzMzAxNjsmIzM4MDI0OyBpbWFnZXMgb24gcGludGVyZXN0IHwgamV3ZWxyeSwgYW50aXF1ZSBqZXdlbHJ5IGFuZCBhcnQ8L3NtYWxsPgo8c3RyaWtlPkFuIGFudGlxdWUgdmljdG9yaWFuIHRyYW5zbHVjZW50IGJsdWUgZW5hbWVsIGFuZCBkaWFtb25kIHNldCBoZWFydDwvc3RyaWtlPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1tYWRlbGluZS9ndS1idXktbWNndWlyZS1zaXN0ZXJzLWNocmlzdG1hcy1hbHBoYWJldC5odG0iPjE5IC0gdGhlcmUgYXJlIGEgZmV3IG9mPC9hPgo8L3N0cmlrZT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1tYWRlbGluZS9ndS1jaHJpc3RtYXMtY2Fyb2xzLWNlbGxvLWFuZC12aW9saW4uaHRtIj4yNTY3NzJjbyBtcG8gLSBzdGFuZm9yZCBpbmZvbGFiIHB1YmxpY2F0aW9uIHNlcnZlcjwvYT4KPC9zbWFsbD4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtY2hyaXN0bWFzLXBvaW5zZXR0aWEtY3JvY2hldC1wYXR0ZXJuLWZyZWUuaHRtIj5jaHJpc3RtYXMgcG9pbnNldHRpYSBjcm9jaGV0IHBhdHRlcm4gZnJlZTwvYT4KPC9zdHJpa2U+CjxsaT5Ib3cgdG8gc3VjY2VlZCB3aXRoIHlvdXIgbWFkZWxlaW5lIHwgaGVhZHNwYWNlPC9saT4KPHNtYWxsPk1hZ29vc2ggLSBncmUgY29tbW9uIGZsYXNoY2FyZHMgfCBxdWl6bGV0PC9zbWFsbD4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtY2hyaXN0bWFzLXRocm91Z2gtbmV3LXllYXJzLXZhY2F0aW9uLWRlYWxzLmh0bSI+c2Nhbm5lZCB1c2luZyBib29rIHNjYW5jZW50ZXIgNTEzMSAtIG1lbHJvc2UgcGFyayBtZW1vcmllczwvYT4KPC9zdHJpa2U+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtY2hyaXN0bWFzLWNhcm9sLWZyZWUtZG93bmxhb2Qtdm9pY2FsLmh0bSI+aHR0cHM6Ly93d3cud2FsbWFydC5jb20vaXAvZ2VyYmVyLXJpdmVyLXNob3J0eS1maXhlZC1ibGFkZS1rbmlmZTwvYT4KPC9zbWFsbD4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtZ2lmdC1ib290cy1jaHJpc3RtYXMtaWRlYS5odG0iPmh0dHBzOi8vd3d3LndhbG1hcnQuY2EvZnIvaXAvZm9ydW0tbm92ZWx0aWVzLWZ3MTE2NzIxcy1saWw8L2E+Cjwvc3RyaWtlPgo8c3RyaWtlPlRoZSBjb25jaXNlIG5ldyBtYWtlcnMgb2YgbW9kZXJuIGN1bHR1cmUgLSBwZGYgZnJlZSBkb3dubG9hZDwvc3RyaWtlPgo8c3RyaWtlPlRyYWRlLW1hcmtzIGpvdXJuYWwgdm9sLiA2NCBuby4gMzI1NDwvc3RyaWtlPgo8bGk+VmludGFnZSByZWQgd2hpdGUgY2FuZHkgY2FuZSBwb2xhciBiZWFyIHRlYXBvdCAmIzgyMjY7ICQxMi4xNSAtIHBpY2NsaWNrPC9saT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1tYWRlbGluZS9ndS13b21lbidzLWNocmlzdG1hcy1ob2xpZGF5LXNob2VzLmh0bSI+ZmEgc2lnbGVyIGZvIHRoZSBuZXh0IDJwZGFwLiAtIHZpbGxhZ2Ugb2YgcGluY2tuZXk8L2E+CjwvbGk+CjxzdHJpa2U+PGgxPk1hZGVsaW5lL2d1IEVuYW1lbCBDaHJpc3RtYXMgQ2hhcm1zPC9oMT48L3N0cmlrZT4KPGxpPjggMTAgMTY0IGh0dHBzOi8vaGlzdG9yeS53ZXN0aGFydGZvcmRsaWJyYXJ5Lm9yZy9maWxlcy9vcmlnaW5hbDwvbGk+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtdW5pcXVlLXBlcnNvbmFsLWNocmlzdG1hcy1jYXJkcy5odG0iPnNwZWN0YWN1bGFyLCBhY2Nlc3NpYmxlIGl4aW1jaOkgY3JhZnRpbmcgY2xheSBpbiAtIHJldnVlIG1hZ2F6aW5lPC9hPgo8L3NtYWxsPgo8c21hbGw+VGhlIG5lbGxpZSBsZWFtYW4gdGFmdCBjb2xsZWN0aW9uIGNhcnRpZXIgZm9yIHRoZSBqYXp6IGFnZTwvc21hbGw+CjxzdHJpa2U+Y2hyaXN0bWFzIGFuZ2VsIGNyYWZ0cyBmb3Iga2lkczwvc3RyaWtlPgo8c3RyaWtlPjEwNSBiZXN0IGpld2VscnkgaW1hZ2VzIG9uIHBpbnRlcmVzdCB8IGpld2VscnksIGpld2VsZXJ5IGFuZDwvc3RyaWtlPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1tYWRlbGluZS9ndS1jaHJpc3RtYXMtY3JhZnQtc2hvdy1pbi1tY21pbm52aWxsZS10bi5odG0iPmNocmlzdG1hcyBjcmFmdCBzaG93IGluIG1jbWlubnZpbGxlIHRuPC9hPgo8L3N0cmlrZT4KPHN0cmlrZT5JbWFnZXMgZm9yIG1hZGVsaW5lL2d1IGVuYW1lbCBjaHJpc3RtYXMgY2hhcm1zPC9zdHJpa2U+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtcGhvdG9ncmFwaHMtb2Ytd2lsbGlhbXNidXJnLXZhLWF0LWNocmlzdG1hcy5odG0iPnVudGl0bGVkIC0gbWFyaXBvc2EgZm9sayBmZXN0aXZhbDwvYT4KPC9saT4KPHNtYWxsPlRoZSBwb2Nvbm8gcmVjb3JkIGZyb20gc3Ryb3Vkc2J1cmcsIHBlbm5zeWx2YW5pYSBvbiBzZXB0ZW1iZXI8L3NtYWxsPgo8c3RyaWtlPldhcnRhIGtlcmFqYWFuIHdhcnRhIGtlcmFqYWFuIC0gaW50ZWxsZWN0IHdvcmxkd2lkZSBzZG4uIGJoZC48L3N0cmlrZT4KPHN0cmlrZT5BdWN0aW9uIC0gc3RhY2V5JiMzOTtzIGF1Y3Rpb25lZXJzIGFuZCB2YWx1ZXJzPC9zdHJpa2U+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtbGFzdHItY2hyaXN0bWFzLXdoYW0uaHRtIj5mdWxsIHRleHQgb2YgJnF1b3Q7cGVya2lucyBzY2hvb2wgZm9yIHRoZSBibGluZCBib3VuZCBjbGlwcGluZ3M8L2E+Cjwvc21hbGw+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtY29hc3QtZ3VhcmQtY2hyaXN0bWFzLWdpZnRzLmh0bSI+aHR0cHM6Ly93d3cud2FsbWFydC5jb20vaXAvcGF3LXBhdHJvbC1jaGFzZS1tYXJzaGFsbC10b2RkbGVyPC9hPgo8L2xpPgo8c21hbGw+SyBkIHNtaXRoIGF1Y3Rpb24gLSBjb2luIGRlYWxlciBsaXN0aW5nIG9uIGNvaW56aXAuY29tPC9zbWFsbD4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3Utc2NvdHRpc2gtY2hyaXN0bWFzLWNlbGVicmF0aW9uLWR2ZC5odG0iPnNjb3R0aXNoIGNocmlzdG1hcyBjZWxlYnJhdGlvbiBkdmQ8L2E+Cjwvc3RyaWtlPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LWNhbGxuYW4tZmFtaWx5LWNocmlzdG1hcy10cmVlcy5odG0iPmNhbmFkaWFuIGpld2VsbGVyIG9jdG9iZXIgMjAxMCBpc3N1ZSAtIGRvY3NsaWRlLmNvbS5icjwvYT4KPC9saT4KPHNtYWxsPkJvb2tzIGZvciByZWZlcmVuY2UsIGRlc2lnbiwgJmFtcDsgdGVjaG5pcXVlIC0gc2NoaWZmZXIgcHVibGlzaGluZzwvc21hbGw+CjxsaT5IdHRwczovL3d3dy50YXJnZXQuY29tL3AvbmlnaHQtaHVzaC11bmFicmlkZ2VkLWNkLXNwb2tlbi13b3JkPC9saT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1tYWRlbGluZS9ndS1hbHVtaW51bS1jaHJpc3RtYXMtdHJlZS1waWN0dXJlcy5odG0iPmVwaWsgKGVuZ2xpc2ggcHJvZ3JhbSBpbiBrb3JlYSl8bWlkZGxlIHNjaG9vbCB8bGVzc29uIDMgZ3JhZGUgMTwvYT4KPC9saT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1tYWRlbGluZS9ndS1maXJzdC1jaHJpc3RtYXMtcmVjb3JkLWZvci1jaGlsZGVybi5odG0iPmZpcnN0IGNocmlzdG1hcyByZWNvcmQgZm9yIGNoaWxkZXJuPC9hPgo8L3NtYWxsPgo8bGk+Qm9iYnlhbmRraWRzIC0gbGVvIHRyYXZlcnNhPC9saT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtMTItZGF5cy1vZi1jaHJpc3RtYXMta2lkcy1hY3Rpdml0aWVzLmh0bSI+dGhlIGVuY3ljbG9wZWRpYSBvZiB3aXRjaGVzLCB3aXRjaGNyYWZ0LCBhbmQgd2ljY2EucGRmIC0gc2NyaWJkPC9hPgo8L3N0cmlrZT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1tYWRlbGluZS9ndS1zdGVhbXRvd24tY2hyaXN0bWFzLXNjaGVkdWxlLmh0bSI+YnV5IGNyZXNjZW50IHRveXMgYW5kIGdldCBmcmVlIHNoaXBwaW5nIG9uIGFsaWV4cHJlc3MuY29tPC9hPgo8L3NtYWxsPgo8bGk+UG9ldHMgb2YgdGhlIGZhbGwgLSBjbGVhcnZpZXcgKDIwMTYpIC0gc2x1ZGdlIC0gd2Vyb25pa3VzMjI8L2xpPgoKCjxocj4KCk1hZGVsaW5lL2d1IGVuYW1lbCBjaHJpc3RtYXMgY2hhcm1zCg==