PCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9JRVRGLy9EVEQgSFRNTCAyLjAvL0VOIj4KPEhUTUw+PEhFQUQ+CjxUSVRMRT5EZXNpZ25lciBjaHJpc3RtYXMgY2VudGVycGllY2VzPC9USVRMRT4KPC9IRUFEPjxCT0RZPgoKPGgxPkRlc2lnbmVyIGNocmlzdG1hcyBjZW50ZXJwaWVjZXM8L2gxPgoKPGxpPkNocmlzdG1hcyBjZW50ZXJwaWVjZXMgZ2FyZG5lcnZpbGxlLCBuZXZhZGEgODk0MTAgfCBhIHdpbGRmbG93ZXI8L2xpPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1hbmQtY2hyaXN0bWFzcy1mYWlyeS1maWdodHMtYmFjay5odG0iPmFtYXpvbi5jb206IGNocmlzdG1hcyAtIGNlbnRlcnBpZWNlcyAvIGRlY29yYXRpb25zOiBob21lPC9hPgo8L3NtYWxsPgo8c3RyaWtlPlNpbGsgZmxvd2VyIGFycmFuZ2VtZW50cyB8IGZsb3JhbCBkZXNpZ25zIHwgY2VudGVycGllY2VzPC9zdHJpa2U+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LXRoZS1jaHJpc3RtYXMtcXVpZXQtZmlsbS5odG0iPmNocmlzdG1hcyB0YWJsZSBjZW50ZXJwaWVjZSB8IGViYXk8L2E+Cjwvc21hbGw+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1mcmVlLWNocmlzdG1hcy1naWZ0LXRhZy1jbGlwYXJ0Lmh0bSI+bW9udGFnZTogMTggd2ludGVyIHRhYmxlc2NhcGVzIHdpdGggaG9saWRheSBjZW50ZXJwaWVjZXM8L2E+Cjwvc3RyaWtlPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLWFsYnVtLWFtYXpvbi5odG0iPmNocmlzdG1hcyBjZW50ZXJwaWVjZXMgfCBzYW1lIGRheSBmbG93ZXIgZGVsaXZlcnkgfCBmbG93ZXJzIGFuZDwvYT4KPC9zdHJpa2U+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LW11cHBldHMtY2hyaXN0bWFzLWNhcm9sLmh0bSI+bXVwcGV0cyBjaHJpc3RtYXMgY2Fyb2w8L2E+CjwvbGk+CjxzdHJpa2U+Q2hyaXN0bWFzIGNlbnRlcnBpZWNlcyBhbmQgZGVjb3IgfCB0d2lncyAmYW1wOyBwb3NpZXMgfCBjb2xvcmFkbzwvc3RyaWtlPgo8c21hbGw+Q2hyaXN0bWFzIGZsb3dlcnMsIGNocmlzdG1hcyBjZW50ZXJwaWVjZXMgLSBjYWx5eCBmbG93ZXJzPC9zbWFsbD4KPHN0cmlrZT5DaHJpc3RtYXMgY2VudGVycGllY2VzIHN3ZWV0IHBlYSBmbG9yYWwgLSB3YXVuYWtlZSwgd2kgNTM1OTc8L3N0cmlrZT4KPHN0cmlrZT5TaWxrIGZsb3JhbCBjaHJpc3RtYXMgY2VudGVycGllY2UgaWRlYXMgOiBjaHJpc3RtYXMgZGVjb3JhdGluZzwvc3RyaWtlPgo8c3RyaWtlPjQxIGRpeSBjaHJpc3RtYXMgZGVjb3JhdGlvbnMgLSBjaHJpc3RtYXMgZGVjb3JhdGluZyBpZGVhczwvc3RyaWtlPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtNy1jaHJpc3RtYXMtdHJlZS5odG0iPmNyZWF0aXZlIGZsb3dlciBzaG9wcyBhbmQgdGhlaXIgbGF0ZXN0IGNocmlzdG1hcyBmbG9yYWwgZGVzaWduczwvYT4KPC9zdHJpa2U+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jaHJpc3RtYXMtY2Fyb2wtZGlzbmV5LWF0bGFudGEuaHRtIj5kaW5hIG1hbnpvICYjODIxMTsgZGVjb3JhdGl2ZSBob2xpZGF5IGNlbnRlcnBpZWNlczwvYT4KPC9zdHJpa2U+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1oZWFydC1jaHJpc3RtYXMuaHRtIj5oZWFydCBjaHJpc3RtYXM8L2E+Cjwvc3RyaWtlPgo8bGk+RHJlc3MgdXAgeW91ciBjaHJpc3RtYXMgZGVjb3Igd2l0aCBlYXN5LCBjaHJpc3RtYXMgcm9zZSBjZW50ZXJwaWVjZXM8L2xpPgo8c21hbGw+VHV0b3JpYWw6IGZhdXggc3VjY3VsZW50IHNsZWlnaCBob2xpZGF5IGNlbnRlcnBpZWNlcyAtIGRvbGxhciBzdG9yZTwvc21hbGw+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWZ1bm55LWNtcGFueS1jaHJpc3RtYXMtZS1jYXJkLWlkZWFzLmh0bSI+ZGVzaWduZXIgY2hyaXN0bWFzIGRvb3Igc3dhZ3MgfCBlbGVnYW50IGNocmlzdG1hcyB3cmVhdGhzPC9hPgo8L3NtYWxsPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLWNoaWxpLXBlcHBlcnMuaHRtIj5mb2NhbCBwb2ludCBzdHlsaW5nOiBjaHJpc3RtYXMgY2VudGVycGllY2VzIHdpdGggY29uaWZlcnMgJmFtcDsgYTwvYT4KPC9zdHJpa2U+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LW9mZmljZS1jaHJpc3RtYXMtdHJlZXMuaHRtIj5pbWFnZXMgZm9yIGRlc2lnbmVyIGNocmlzdG1hcyBjZW50ZXJwaWVjZXM8L2E+CjwvbGk+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1vbGQtZmFzaGlvbi1jaHJpc3RtYXMtZmVzdGl2YWwuaHRtIj5jaHJpc3RtYXMgY2VudGVycGllY2VzIC0gY2hyaXN0bWFzIGRlY29yYXRpbmcgaWRlYXMgLSBjb2FzdGFsIGxpdmluZzwvYT4KPC9zdHJpa2U+CjxzbWFsbD5DaHJpc3RtYXMgY2VudGVycGllY2VzLCBkb29yIHN3YWdzIC0gZmxvcmFsIHN1cHBseTwvc21hbGw+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LW1hY3kncy1jaHJpc3RtYXMtd2luZG93Lmh0bSI+b3V0ZG9vciBmdXJuaXR1cmUgYXQgbmVpbWFuIG1hcmN1cyBob3JjaG93PC9hPgo8L2xpPgo8c21hbGw+MzEgY2hyaXN0bWFzIHRhYmxlIGRlY29yYXRpb25zICZhbXA7IHBsYWNlIHNldHRpbmdzIC0gaG9saWRheTwvc21hbGw+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWxlc2hlci13YWxudXQtY3JlZWstY2hyaXN0bWFzLWNhcm9sLXRhZ2V0Lmh0bSI+MjkgY2hyaXN0bWFzIHRhYmxlIHNldHRpbmdzIC0gZGVjb3JhdGlvbnMgYW5kIGNlbnRlcnBpZWNlcyBmb3I8L2E+Cjwvc21hbGw+CjxsaT5DZW50ZXJwaWVjZXMgLSBiYWNobWFuJiMzOTtzPC9saT4KPGxpPjEwIGJlc3QsIHNpbXBsZSwgZGl5IGhvbGlkYXkgY2VudGVycGllY2VzIGZvciB5b3VyIGRpbm5lciB0YWJsZTwvbGk+CjxsaT5Ub3AgMTAwIGNocmlzdG1hcyB0YWJsZSBkZWNvcmF0aW9ucyAmIzgyMTI7IHN0eWxlIGVzdGF0ZTwvbGk+CjxsaT4yMiBhd2Vzb21lIGRpeSBiYWxsb29ucyBkZWNvcmF0aW9ucyAtIGFyY2hpdGVjdHVyZSBhcnQgZGVzaWduczwvbGk+CjxzbWFsbD5Ib2xpZGF5Li4ud2l0aCBtYXR0aGV3IG1lYWQ8L3NtYWxsPgo8bGk+U2lsayBmbG9yYWxzIGJ5IHBvbWEgYW5kIGNocmlzdG1hcyBjZW50ZXJwaWVjZXMgfCBpbnRlcmlvciBkZXNpZ248L2xpPgo8c3RyaWtlPjcgY2hyaXN0bWFzIHRyZWU8L3N0cmlrZT4KPGxpPkFtYXppbmcgYmFsbG9vbiBjZW50ZXJwaWVjZSBpZGVhcyBmcm9tIGJhbGxvb24gYXJ0aXN0cnkgLSBzdHlsaXNoIGV2ZTwvbGk+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LW91dGRvb3ItdGV4YXMtYWdnaWUtY2hyaXN0bWFzLWRlY29yYXRpb25zLmh0bSI+ZnJpZGF5IGZhYiBmaW5kIH4gaG9saWRheSBjZW50ZXJwaWVjZXMgLSBhIGdvb2QgYWZmYWlyPC9hPgo8L2xpPgo8bGk+RGVzaWduZXIgZGluaW5nIHRhYmxlcyBjaHJpc3RtYXMgcGFydHkgY2VudGVycGllY2VzIGNlbHRpYzwvbGk+CjxsaT5DZW50ZXJwaWVjZXMgcGhvdG8gZ2FsbGVyeSBieSBtaiBhdCBwYmFzZS5jb208L2xpPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLWNhcm9sLW1vdmllLmh0bSI+c2tvIGRlc2lnbnMgLSBhbiBldmVudCBkZXNpZ24gYm91dGlxdWUgc3BlY2lhbGl6aW5nIGluIGN1c3RvbTwvYT4KPC9zdHJpa2U+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LXdheXMtamFtYWljYS1jZWxlYnJhdGVzLWNocmlzdG1hcy5odG0iPndheXMgamFtYWljYSBjZWxlYnJhdGVzIGNocmlzdG1hczwvYT4KPC9zbWFsbD4KPHNtYWxsPjggd2hpdGUgdW5zY2VudGVkIGRlc2lnbmVyIHRhcGVyIGNhbmRsZXMgJiM4MjExOyAxNCBpbmNoPC9zbWFsbD4KPHNtYWxsPkhvdyBpIGhvbGlkYXk6IGVhc3kgY2hyaXN0bWFzIGdyZWVuZXJ5IGNlbnRlcnBpZWNlcyB8IGp1bGVwIC0gbWludGVkPC9zbWFsbD4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtYmVhZC1jaHJpc3RtYXMtY3JhZnQuaHRtIj5oZWIgZmxvcmFsIGRlcGFydG1lbnQgJiM4MjA5OyBzdG9wIGJ5ITwvYT4KPC9saT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtYmVzdC1naWZ0LWZvci13aWZlLXRoaXMtY2hyaXN0bWFzLmh0bSI+bGFkeWJ1ZyB3cmVhdGhzIHZpZGVvcyAmYW1wOyBkdmRzICZxdW90O2NocmlzdG1hcyBjZW50ZXJwaWVjZXMmcXVvdDsgaG93IHRvPC9hPgo8L3NtYWxsPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3Uta2lkcy1jaHJpc3RtYXMtaW52aXRhdGlvbi1zYXlpbmdzLmh0bSI+Y2hyaXN0bWFzIG1hbnRsZSBjZW50ZXJwaWVjZXMsIGNocmlzdG1hcyBjZW50ZXJwaWVjZXM8L2E+Cjwvc3RyaWtlPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLWRpbmVyLWluLWFybGluZ3Rvbi12YS5odG0iPmNocmlzdG1hcyBkaW5lciBpbiBhcmxpbmd0b24gdmE8L2E+Cjwvc3RyaWtlPgo8c21hbGw+U2hpbm9kYSBkZXNpZ24gY2VudGVyIHwgdGhlIGRlY29yYXRvciYjMzk7cyBzdXBlciB3YXJlaG91c2U8L3NtYWxsPgo8c21hbGw+MzcgY2hyaXN0bWFzIGNlbnRlcnBpZWNlIGlkZWFzIHwgZW50ZXJ0YWluaW5nIGlkZWFzICZhbXA7IHBhcnR5PC9zbWFsbD4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY29jb251dC11bmRlci10aGUtY2hyaXN0bWFzLXRyZWUuaHRtIj5ob2xpZGF5IGNlbnRlcnBpZWNlcyBpbiBib3N0b24sIG1hIC0gc2FtZWRheSBkZWxpdmVyeSAtIGNlbnRyYWw8L2E+Cjwvc21hbGw+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWFkYW0tc2FuZGxlci1qZXdpc2gtY2hyaXN0bWFzLWx5cmljcy5odG0iPnNlYXJjaCByZXN1bHQgeW91dHViZSB2aWRlbyBob2xpZGF5K2NlbnRlcnBpZWNlczwvYT4KPC9zbWFsbD4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY29va2luZy1nYW1lcy1mb3ItY2hyaXN0bWFzLmh0bSI+Y2hyaXN0bWFzIGFycmFuZ2VtZW50cyAtIGNlbnRlcnBpZWNlcyAmYW1wOyBncmVlbmVyeSBhcnJhbmdlbWVudHM8L2E+Cjwvc21hbGw+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNocmlzdG1hcy1wb3RhdG9lcy5odG0iPjI0IGNsZXZlciB0aGluZ3MgdG8gZG8gd2l0aCB3aW5lIGdsYXNzZXMgLSBidXp6ZmVlZDwvYT4KPC9zbWFsbD4KPHN0cmlrZT5DaHJpc3RtYXMgZGlubmVyOiBjZW50ZXJwaWVjZXMgfCBwcmVzdG9uYmFpbGV5LmNvbTwvc3RyaWtlPgo8c3RyaWtlPjUwIGVhc3kgY2hyaXN0bWFzIGNlbnRlcnBpZWNlIGlkZWFzIHwgbWlkd2VzdCBsaXZpbmc8L3N0cmlrZT4KPHN0cmlrZT5DaHJpc3RtYXMgY2VudGVycGllY2VzIHwgZ2FyZGVuLCBob21lICZhbXA7IHBhcnR5PC9zdHJpa2U+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1oYW5kLXBhaW50ZWQtY2hyaXN0bWFzLXN3ZWF0c3VpdHMuaHRtIj5oYW5kIHBhaW50ZWQgY2hyaXN0bWFzIHN3ZWF0c3VpdHM8L2E+Cjwvc3RyaWtlPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLXN0b2NraW5nLXN0dWZmZWQtZmVsdC1wYXR0ZXJucy5odG0iPmNocmlzdG1hcyBzdG9ja2luZyBzdHVmZmVkIGZlbHQgcGF0dGVybnM8L2E+Cjwvc3RyaWtlPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLWNoaWxpLXBlcHBlcnMuaHRtIj5ob3cyaGVyb2VzILsgaG9saWRheSBjZW50ZXJwaWVjZXM8L2E+Cjwvc3RyaWtlPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jaHJpc3RtYXMtdGVtcGxhdGVzLWZvci1sZXR0ZXJzLmh0bSI+Y2hyaXN0bWFzIHRlbXBsYXRlcyBmb3IgbGV0dGVyczwvYT4KPC9saT4KPHNtYWxsPkNocmlzdG1hcyBhY2Nlc3NvcmllcyAtIGTpY29yLCBjcmFmdHMgJmFtcDsgYmFraW5nIHwgam8tYW5uPC9zbWFsbD4KPHN0cmlrZT4xNSBhd2Vzb21lIGNhbmRsZSB0YWJsZSBjZW50ZXIgcGllY2UgaWRlYXMgLSByaWxhbmU8L3N0cmlrZT4KPGxpPkNlbnRlcnBpZWNlcyB8IGxpbmtlZGluPC9saT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LXRpcHMtZm9yLWEtZ3JlZW4tY2hyaXN0bWFzLmh0bSI+Y2hyaXN0bWFzIGRlc2lnbmVycyAtIGNvdmVyaW5nIGFsbCB0aGluZ3MgY2hyaXN0bWFzIGZyb20gbGVkPC9hPgo8L3N0cmlrZT4KPHNtYWxsPkNocmlzdG1hcyBjcmFmdCBkZXNpZ25lcnMgfCBhbGxmcmVlY2hyaXN0bWFzY3JhZnRzLmNvbTwvc21hbGw+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LXRpbWUteWVhci13b3JrLWNocmlzdG1hcy12YS5odG0iPmNocmlzdG1hcyB0YWJsZSBkZWNvcmF0aW9ucyB8IGNocmlzdG1hcyBjZW50ZXJwaWVjZSBpZGVhczwvYT4KPC9saT4KPHNtYWxsPkNocmlzdG1hcyBjZW50ZXJwaWVjZXMgLSBwb3JjaDwvc21hbGw+CjxzbWFsbD5DaHJpc3RtYXMgY2VudGVycGllY2VzIC0gc291dGhlcm4gbGl2aW5nPC9zbWFsbD4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWhvd3JzZS1jaHJpc3RtYXMuaHRtIj5jaHJpc3RtYXMgZGVjb3JhdGlvbnMgLSBjaHJpc3RtYXMgbGlnaHRzLCBldGM8L2E+Cjwvc3RyaWtlPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jaHJpc3RtYXMtaGlzdG9yeS1jb2xsZWN0YWJsZXMuaHRtIj5jaHJpc3RtYXMgaGlzdG9yeSBjb2xsZWN0YWJsZXM8L2E+CjwvbGk+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWFuZC1jaHJpc3RtYXNzLWZhaXJ5LWZpZ2h0cy1iYWNrLmh0bSI+YmlnIGFwcGxlIGZsb3Jpc3QgYmxvZyB8IG1hbmhhdHRhbiYjMzk7cyBhd2FyZC13aW5uaW5nIGZsb3JhbCBkZXNpZ25lcnM8L2E+CjwvbGk+CjxzdHJpa2U+YW5kIGNocmlzdG1hc3MgZmFpcnkgZmlnaHRzIGJhY2s8L3N0cmlrZT4KPGxpPkNocmlzdG1hcyBjZW50ZXJwaWVjZXMgLSBjaHJpc3RtYXMgZGVjb3JhdGlvbnMsIGNocmlzdG1hczwvbGk+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1uZXcteW9yay1jaXR5LWNocmlzdG1hcy1wYXJhZGUuaHRtIj5jaHJpc3RtYXMgfCBmbGlydHkgZmxldXJzIHRoZSBmbG9yaXN0IGJsb2cgLSBpbnNwaXJhdGlvbiBmb3IgZmxvcmFsPC9hPgo8L3N0cmlrZT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtZnJlZS1jaHJpc3RtYXMtZ3JhcGhpY3MtaG9sbHktYmFubmVyLmh0bSI+a+R0aGUgd29obGZhaHJ0IG9mIGFtZXJpY2EgLSBjaHJpc3RtYXMgZnJvbSBnZXJtYW55PC9hPgo8L3NtYWxsPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1rYXRobWFuZHUtY2hyaXN0bWFzLXNhbGUuaHRtIj5rYXRobWFuZHUgY2hyaXN0bWFzIHNhbGU8L2E+Cjwvc21hbGw+CjxsaT5Db3JuZWxsIGZhcm0gfCBob2xpZGF5IHNob3AgJiM4MjEyOyBjb3JuZWxsIGZhcm08L2xpPgo8bGk+ZnJlZSBjaHJpc3RtYXMgZ2lmdCB0YWcgY2xpcGFydDwvbGk+CjxsaT5DaHJpc3RtYXMgYW5kIG90aGVyIGhvbGlkYXkgJmFtcDsgcGFydHkgLSBmb3IgdGhlIGhvbWUgJiM4MjEyOyBxdmMuY29tPC9saT4KPHN0cmlrZT5DaHJpc3RtYXMgY2VudGVycGllY2VzIC0gb3ZlcnN0b2NrLmNvbSBzaG9wcGluZyAtIHRoZSBiZXN0PC9zdHJpa2U+CjxzdHJpa2U+Q29tcGFjdCBjZW50ZXJwaWVjZXMgb24gdGhlIHRhYmxlIGFuZCB3aW5kb3cgc2lkZSAtIGNhbGlmb3JuaWE8L3N0cmlrZT4KPHN0cmlrZT5MdXh1cnkgZGVjb3JhdGl2ZSBhY2Nlc3NvcmllcyB8IGhvbWV3YXJlIGF0IGhhcnJvZHM8L3N0cmlrZT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtamFja3NvbnZpbGxlLWNocmlzdG1hcy1ib2F0LXBhcmFkZS5odG0iPmphY2tzb252aWxsZSBjaHJpc3RtYXMgYm9hdCBwYXJhZGU8L2E+CjwvbGk+CjxsaT5Ib3cgdG8gZGVjb3JhdGUgYSBkZXNpZ25lciBjaHJpc3RtYXMgdHJlZSBmb3IgeW91ciBsdXh1cnkgaG9tZTwvbGk+CjxsaT5QYXVsIGRvdWdsYXMgZmxvcmFsIGRlc2lnbnM6IGNvaGFzc2V0IGZsb3Jpc3Q8L2xpPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS13b21lbi1jaHJpc3RtYXMtZ2FtZXMuaHRtIj5jaHJpc3RtYXMgMjAxNiA6IGdpZnRzICZhbXA7IGhvbGlkYXkgZGVjb3JhdGlvbnMgOiB0YXJnZXQ8L2E+Cjwvc21hbGw+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWEtY2hyaXN0bWFzLXN0b3J5LW5ldy15b3JrLWNpdHkuaHRtIj5hIGNocmlzdG1hcyBzdG9yeSBuZXcgeW9yayBjaXR5PC9hPgo8L3NtYWxsPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jYXJvbGwtcm9iZXJzb24tdHdlbHZlLWRheXMtb2YtY2hyaXN0bWFzLmh0bSI+Y2Fyb2xsIHJvYmVyc29uIHR3ZWx2ZSBkYXlzIG9mIGNocmlzdG1hczwvYT4KPC9zbWFsbD4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLWNyYWZ0cy1mcm9tLXJlY3ljbGVkLWl0ZW1zLmh0bSI+c2ltcGxlIGRpeSBjZW50ZXJwaWVjZXMgZm9yIHRoZSBob2xpZGF5cyAtIHRoZSBpbnRlcmlvciBjb2xsZWN0aXZlPC9hPgo8L2xpPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jYXQtY2hyaXN0bWFzLWxldHRlci5odG0iPmNhdCBjaHJpc3RtYXMgbGV0dGVyPC9hPgo8L3NtYWxsPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtdW5pcXVlLWNocmlzdG1hcy1vcm5hbWVudC5odG0iPnVuaXF1ZSBjaHJpc3RtYXMgb3JuYW1lbnQ8L2E+Cjwvc3RyaWtlPgo8bGk+SG9saWRheSBkZXNpZ25zIC0gZmxvcmFsIGhvbWUgZGVjb3I8L2xpPgo8c3RyaWtlPkRlc2lnbiBhIGxpZmVzdHlsZSB3aXRoIGFuIGV4cGVydCBpbnRlcmlvciBkZXNpZ25lciBmcm9tIG1pbm5lYXBvbGlzPC9zdHJpa2U+CjxzdHJpa2U+RGVzaWducyBieSBnYWlsICZhbXA7IGFyZ3lsZSBmbG9yYWwgYm91dGlxdWUgfCBqdXN0aW4sIGFyZ3lsZSB0eCBmbG9yaXN0PC9zdHJpa2U+CjxzbWFsbD5DaGVhcCBjaHJpc3RtYXMgZGVjb3JhdGlvbnM6IDI0IGhvbWVtYWRlIGRlY29yYXRpbmcgaWRlYXM8L3NtYWxsPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jcm9zcy1zdGl0Y2gtY2hyaXN0bWFzLW9ybmFtZW50cy1mcmVlLXBhdHRlcm5zLmh0bSI+Y291bnRyeSBzdHlsZSBjaHJpc3RtYXMgY2VudGVycGllY2VzIGlkZWFzIGZvciB0YWJsZXMgc2V0czwvYT4KPC9zbWFsbD4KPHN0cmlrZT5BcnRpZmljaWFsIGJ1dHRlcmZsaWVzIC0gZmVhdGhlciBidXR0ZXJmbGllcyAsd2VkZGluZyBidXR0ZXJmbGllczwvc3RyaWtlPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jaHJpc3RtYXMtdHJlZS1zaG9wLXNjYXJib3JvdWdoLW1lLmh0bSI+MjkgYXdlc29tZSB3YXlzIHRvIGdldCBkZXNpZ25lciBkZWNvciBmcm9tIHRoZSBkb2xsYXIgc3RvcmU8L2E+CjwvbGk+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNocmlzdG1hcy1pbi13aW5keS10cmVlLWNpdHkuaHRtIj5ob2xpZGF5IGRlY29yYXRpb25zIG9uIHNhbGUgfCBwb3R0ZXJ5IGJhcm48L2E+CjwvbGk+CjxzdHJpa2U+U2hvcnQgc3RvcCBkZXNpZ25zICYjODIxMTsgZnJlZSBwcmludGFibGVzLCBkaXkgaWRlYXMgJmFtcDsgbW9yZSE8L3N0cmlrZT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLXRyZWVzLWJhaGFtYXMuaHRtIj5jb3BwZXIgY2hyaXN0bWFzIGNlbnRlcnBpZWNlcyAtIHRhYmxlIGlkZWFzIChob3VzZWFuZGdhcmRlbi5jbzwvYT4KPC9zbWFsbD4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLWNsb3N1cmVzLXBhbG0tc3ByaW5ncy1jYS5odG0iPmhvbGlkYXkgY2VudGVycGllY2VzIGFuZCB0YWJsZSBzZXR0aW5ncyB0cmVuZGluZyB0aGlzIHNlYXNvbjwvYT4KPC9saT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLXRvbGUtcGFpbnRpbmctYm9va3MuaHRtIj5uYXphcmV0aCBmbG9yYWwgZGVzaWduczwvYT4KPC9saT4KPGxpPkhvbGlkYXkgY2VudGVycGllY2VzIC0gc2hvcCBmb3IgaG9saWRheSBjZW50ZXJwaWVjZXMgb24gcG9seXZvcmU8L2xpPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS10dXJrZXktY2hyaXN0bWFzLWRpbm5lci1wcmljZXMtbGFzLXZlZ2FzLmh0bSI+dGFsayBhYm91dCBmbG93ZXJzIHwgYSByb2NrY2FzdGxlIGZsb3Jpc3QgYmxvZzwvYT4KPC9zbWFsbD4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLXRyZWUtZmFybXMtdGVubmVzc2VlLmh0bSI+ZmxvcmFsIGRlc2lnbnMgYnkgamVzc2kgfCBkZWxhd2FyZSB3ZWRkaW5nIGZsb3JhbCBkZXNpZ25lciBmb3I8L2E+CjwvbGk+CjxzbWFsbD5GbG93ZXIgY2VudGVycGllY2VzIC0gYWJvdXRmbG93ZXJzLmNvbTwvc21hbGw+CjxzdHJpa2U+RmVzdGl2ZSBob2xpZGF5IGNlbnRlcnBpZWNlcyB8IGJvdWxkZXIgY291bnR5IGhvbWUgJmFtcDsgZ2FyZGVuPC9zdHJpa2U+CjxzbWFsbD5jYXQgY2hyaXN0bWFzIGxldHRlcjwvc21hbGw+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LXNpc2FsLWNocmlzdG1hcy1kZWNvcmF0aW9ucy5odG0iPm1ha2UgY2VudGVycGllY2VzIKsgd29uZGVyIGhvdyB0bzwvYT4KPC9zbWFsbD4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3Utcm90YXRpbmctY2hyaXN0bWFzLXRyZWUtc3RhbmQtcmVwbGFjZW1lbnQtcGFydHMuaHRtIj5jaHJpc3RtYXMgZmxvcmFsIGFycmFuZ2VtZW50cy4gZXZvc29sLmNvPC9hPgo8L2xpPgo8c3RyaWtlPjEwMDArIGlkZWFzIGFib3V0IGNocmlzdG1hcyBjZW50ZXJwaWVjZXMgb24gcGludGVyZXN0IHwgY2hyaXN0bWFzPC9zdHJpa2U+CjxzbWFsbD5DaHJpc3RtYXMgZmxvd2VycyBnaWZ0cywgcG9pbnNldHRpYXMsIGNlbnRlcnBpZWNlcyAtIG5ldyBicmlnaHRvbjwvc21hbGw+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jaHJpc3RtYXMtYmFrZXJ5LWJveGVzLmh0bSI+aG9saWRheSBjZW50ZXJwaWVjZXMgd2hlYXRvbiwgd2VzdCBjaGljYWdvIC0gd2luZmllbGQgZmxvcmlzdDwvYT4KPC9zdHJpa2U+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNocmlzdG1hcy1wcmludGVkLWNyb3NzLXN0aXRjaC5odG0iPnJ1c3RpYyBjaHJpc3RtYXMgZGVjb3JhdGluZyBpZGVhc3wgY2FuYWRpYW4gbG9nIGhvbWVzPC9hPgo8L3NtYWxsPgo8bGk+Q2hyaXN0bWFzIGNlbnRlcnBpZWNlcyB8IGJhbHNhbSBoaWxsPC9saT4KPHNtYWxsPkhvbGlkYXkgY2VudGVycGllY2VzOiB0aGUgcmlnaHQgc2l6ZSBmb3IgdGhlIHBlcmZlY3QgdGFibGU8L3NtYWxsPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1wdWxsLXVwLWNvbGxhcHNpYmxlLWNocmlzdG1hcy10cmVlLmh0bSI+cHVsbCB1cCBjb2xsYXBzaWJsZSBjaHJpc3RtYXMgdHJlZTwvYT4KPC9saT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3Utc3BhbmlzaC1jaHJpc3RtYXMtY2xpcGFydC5odG0iPnNwYW5pc2ggY2hyaXN0bWFzIGNsaXBhcnQ8L2E+CjwvbGk+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jaHJpc3RtYXMtc29uZy1ndXRhaXItY2hvcmRzLmh0bSI+Y2hyaXN0bWFzIGNlbnRlcnBpZWNlcyBmbG9yYWwgYXJ0IC0gamFja3Nvbiwgd3kgODMwMDEgLSB0aGVmbG9yYWxhcnRpc3Q8L2E+Cjwvc3RyaWtlPgo8c21hbGw+V29uZGVyZnVsIHBpbmsgcHVycGxlIGdsYXNzIHdvb2Qgc3RhaW5sZXNzIG1vZGVybiBkZXNpZ248L3NtYWxsPgo8c3RyaWtlPkNyZWF0aW5nIGJlYXV0aWZ1bCAoYW5kIHBldCBmcmllbmRseSkgZnJlc2ggaG9saWRheSBjZW50ZXJwaWVjZXM8L3N0cmlrZT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtbmMtZmFpci1jaHJpc3RtYXMuaHRtIj5ub24tdHJhZGl0aW9uYWwgaG9saWRheSBjZW50ZXJwaWVjZXMgLSBlY28gY2hpYyBibG9zc29tczwvYT4KPC9zbWFsbD4KPGxpPlRpcHMgb24gY2hvb3NpbmcgY2hyaXN0bWFzIHRyZWVzIGRlc2lnbmVyIGRlc2lnbmVyIGNocmlzdG1hcy4uLjwvbGk+CjxsaT5Ib2xpZGF5IC8gY2hyaXN0bWFzIGNlbnRlcnBpZWNlcyBsb3MgYW5nZWxlcywgY2EgLSBmcmVuY2ggZmxvcmlzdDwvbGk+CjxsaT5EZXN0aW4gZmxvcmFsIGRlc2lnbnMgLSBkZXN0aW4sIGZsIDMyNTQxPC9saT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLXNob3BwaW5nLXBvZW0uaHRtIj53aW50ZXIgY29udGFpbmVyIGFycmFuZ2VtZW50cyB8IGRpcnQgc2ltcGxlPC9hPgo8L2xpPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS13aW5kb3dwYW5lLWNocmlzdG1hcy10YWJsZWNsb3RoLmh0bSI+NTUgY2hyaXN0bWFzIGJhbGxzIHRvIGtuaXQ6IGNvbG9yZnVsIGZlc3RpdmUgb3JuYW1lbnRzLCB0cmVlPC9hPgo8L2xpPgo8c21hbGw+RWFzeS10by1tYWtlIGNocmlzdG1hcyBjZW50ZXJwaWVjZXMgLSBiZXR0ZXIgaG9tZXMgYW5kIGdhcmRlbnM8L3NtYWxsPgo8bGk+RWFzeSBjaHJpc3RtYXMgaG9saWRheSBjZW50ZXJwaWVjZTogbWFrZSBpbiAxNSBtaW51dGVzPC9saT4KPHNtYWxsPkhvbWUgZGVjb3IgfCB0LmoubWF4eDwvc21hbGw+CjxzdHJpa2U+Um9iZXJ0c29uJiMzOTtzIGZsb3dlcnMgLSBwaGlsYWRlbHBoaWEmIzM5O3MgcHJlbWllciBmbG9yaXN0LCBmYW1pbHkgb3duZWQ8L3N0cmlrZT4KPHNtYWxsPjIwIHRoYW5rc2dpdmluZyBob2xpZGF5IGNlbnRlcnBpZWNlcyAtIGJhYmJsZTwvc21hbGw+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWhvdy10aGUtZ2luY2gtc3RvbGUtY2hyaXN0bWFzLXZpZGVvLmh0bSI+Y2hyaXN0bWFzIGNhbmRsZSBjZW50ZXJwaWVjZXMgfCBjaHJpc3RtYXNjZW50cmFsPC9hPgo8L2xpPgo8c3RyaWtlPkNocmlzdG1hcyB0cmVlcywgY2VudGVycGllY2VzICZhbXA7IG1vbmEgYiCrIHNldmVuIG1hcGxlcyB8IG1vbnJvZTwvc3RyaWtlPgo8bGk+RGVjb3JhdG9ycyBjcmVhdGUgcXVpY2ssIGFmZm9yZGFibGUgaG9saWRheSBjZW50ZXJwaWVjZXMgfCB3d3c8L2xpPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1naGFuYS1hbmQtZmF0aGVyLWNocmlzdG1hcy1hbmQtcGljdHVyZS5odG0iPmdoYW5hIGFuZCBmYXRoZXIgY2hyaXN0bWFzIGFuZCBwaWN0dXJlPC9hPgo8L2xpPgo8bGk+Q2VudGVycGllY2VzICZhbXA7IGNhbmRsZXNjYXBlcyA6IGNhbmRsZSBob2xkZXJzIHwgcGllciAxIGltcG9ydHM8L2xpPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1zYW0tc25lYWRzLWNocmlzdG1hcy1tZWFscy5odG0iPmhvbGlkYXkgZGlubmVyIHRhYmxlIGRlY29yYXRpbmcgfCBjaHJpc3RtYXMgY2VudGVycGllY2VzIHwgd2ludGVyPC9hPgo8L3NtYWxsPgo8bGk+RGVzaWduZXIgcm91bmQgZGluaW5nIHRhYmxlcyBpbmV4cGVuc2l2ZSBjaHJpc3RtYXMgY2VudGVycGllY2U8L2xpPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jaHJpc3RtYXMtbGVpcy5odG0iPjI0IHN0dW5uaW5nIHdpbmUgYm90dGxlIGNlbnRlcnBpZWNlcyB5b3UgbmV2ZXIgdGhvdWdodCBjb3VsZDwvYT4KPC9saT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtZnJlbmNoLWNhbmFkaWFuLWNocmlzdG1hcy1jb2xvcmluZy1wYWdlcy1mcmVlLmh0bSI+c25vd3kgY2hyaXN0bWFzIGNlbnRlcnBpZWNlcyB8IGVyaW4gdm9sYW50ZSBmbG9yYWw8L2E+Cjwvc21hbGw+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS0xOTUwLXMtY2hyaXN0bWFzLWRlY29yYXRpb25zLmh0bSI+ZGVzaWduZXIgY2hyaXN0bWFzIGNyeXN0YWwgbGlnaHQgLSBhbGliYWJhPC9hPgo8L3N0cmlrZT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNocmlzdG1hcy1naWZ0cy11bmRlci0yMC4wMC5odG0iPmNocmlzdG1hcyBnaWZ0cyB1bmRlciAyMC4wMDwvYT4KPC9zdHJpa2U+CjxsaT5BbGljaWEgcm9kZ2VycyBldmVudCBkZXNpZ25zIHwgZmFjZWJvb2s8L2xpPgo8c21hbGw+QW5hZ3JhbSAtIGNocmlzIGhvcm5lPC9zbWFsbD4KPHN0cmlrZT5DaGFuZ2luZyB0aGUgbW9vZCB3aXRoIGRlc2lnbmVyIHNjZW50ZWQgY2FuZGxlcyAtIGV6aW5lYXJ0aWNsZXM8L3N0cmlrZT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtaG93LXRoZS1ncmludGNoLXN0b2xlLWNocmlzdG1hcy5odG0iPmxhcmdlIHNpbGsgZmxvcmFsIGFycmFuZ2VtZW50cyAtIGZvdGVyPC9hPgo8L3NtYWxsPgo8c3RyaWtlPmNocmlzdG1hcyBoaXN0b3J5IGNvbGxlY3RhYmxlczwvc3RyaWtlPgo8c21hbGw+TWVycnkgYW5kIGJyaWdodCBjaHJpc3RtYXMgY2VudGVycGllY2UgYXQgZnJvbSB5b3UgZmxvd2Vyczwvc21hbGw+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1iYXJiaWUtY2hyaXN0bWFzLXRyZWV0b3AuaHRtIj5mbG93ZXIgYXJyYW5nZW1lbnRzLCB3ZWRkaW5nIGNlbnRlcnBpZWNlcyAtIGNyYWZ0IGZyZWViaWVzPC9hPgo8L3N0cmlrZT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWphbWFpY2EtY2hyaXN0bWFzLXB1ZGRpbmcuaHRtIj5qYW1haWNhIGNocmlzdG1hcyBwdWRkaW5nPC9hPgo8L3N0cmlrZT4KPGxpPkNocmlzdG1hcyBjZW50ZXJwaWVjZXMgLSBjaHJpc3RtYXMgc3dhZyAtIGZyb250Z2F0ZTwvbGk+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWZpbmQtaGFsZi1jaHJpc3RtYXMtdHJlZS5odG0iPnRyZW5keSB0cmVlIGJsb2cgLSBhZGQgZ2xpdHosIHNwYXJrbGUgYW5kIHNoaW5lIHRvIHlvdXIgaG9saWRheTwvYT4KPC9saT4KPHNtYWxsPkRlc2lnbmVyIGRlY29uc3RydWN0cyBjaHJpc3RtYXMgZGVjb3JhdGluZyAtIHN0YXRlc21hbiBqb3VybmFsPC9zbWFsbD4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWhpbHRvbidzLWNocmlzdG1hcy1pbi1qdWx5LXNwZWNpYWwuaHRtIj4zMiBlbGVnYW50IGlkZWFzIGZvciBkaW5pbmcgcm9vbXMgfCByZWFsIHNpbXBsZTwvYT4KPC9zdHJpa2U+CjxsaT5DaHJpc3RtYXMgdGFibGUgY2VudGVycGllY2UgLSBpbnRlcmlvciBkZXNpZ24gLSBsb3ZldG9rbm93PC9saT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNodXJjaC1vZi1lbmdsYW5kLWNocmlzdG1hcy1hZHMuaHRtIj52aWRlbzogbmljaG9sYXMgZGUgc3dlcnQgY3JlYXRlcyBjaHJpc3RtYXMgY2VudGVycGllY2VzIHwgbWFydGhhPC9hPgo8L3N0cmlrZT4KPHNtYWxsPm5vcnRod2VzdCBpbmRpYW5hIGNocmlzdG1hcyBob2xpZGF5IGhvdGVsIHBhY2thZ2VzPC9zbWFsbD4KPGxpPkhvbGlkYXkgZmxvcmFsIGFycmFuZ2VtZW50cyB3aXRoIG1pY2hhZWwgZ2FmZm5leSAtIHZpZGVvIHwgaG9tZTwvbGk+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LXByaW50YWJsZS1tZXJyeS1jaHJpc3RtYXMtY2FyZHMuaHRtIj4zMyBzaGFkZXMgb2YgZ3JlZW46IGVhc3kgaG9saWRheSBjZW50ZXJwaWVjZXM8L2E+CjwvbGk+CjxzdHJpa2U+amFja3NvbnZpbGxlIGNocmlzdG1hcyBib2F0IHBhcmFkZTwvc3RyaWtlPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1lbC1zYWx2YWRvci1jaHJpc3RtYXMuaHRtIj4zNSBhd2Vzb21lIGNocmlzdG1hcyBiYWxscyBhbmQgaWRlYXMgaG93IHRvIHVzZSB0aGVtIGluIGRlY29yPC9hPgo8L3NtYWxsPgo8c3RyaWtlPkNlbGVicmF0ZSB0aGUgc2Vhc29uIGNlbnRlcnBpZWNlIC0gY2hyaXN0bWFzIGNlbnRlcnBpZWNlczwvc3RyaWtlPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtNy41LXByZWxpdC1jaHJpc3RtYXMtdHJlZS5odG0iPnF1YW50aXR5IGxpdmUgMjYmcXVvdDsgc2lsdmVyeSB3aW50ZXIgZmFuY3kgZGVzaWduZXIgY2hyaXN0bWFzIHdyZWF0aDwvYT4KPC9zdHJpa2U+CjxzdHJpa2U+Q2hyaXN0bWFzIGNlbnRlcnBpZWNlIGlkZWFzIG9uIHBpbnRlcmVzdCB8IGNocmlzdG1hcyBjZW50ZXJwaWVjZXM8L3N0cmlrZT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3Utbm9ydGh3ZXN0LWluZGlhbmEtY2hyaXN0bWFzLWhvbGlkYXktaG90ZWwtcGFja2FnZXMuaHRtIj5jaHJpc3RtYXMgY2VudGVycGllY2VzIHNvY29ycm8gbm0gODc4MDEgLSB0aGUgY2hyaXN0bWFzIHN0b3JlPC9hPgo8L2xpPgo8c3RyaWtlPkNocmlzdG1hcyBjZW50ZXJwaWVjZTogc2hvcCBmb3IgYSBjaHJpc3RtYXMgY2VudGVycGllY2UgYXQgbWFjeSYjMzk7czwvc3RyaWtlPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jYWxsbmFuLWZhbWlseS1jaHJpc3RtYXMtdHJlZXMuaHRtIj5jcmFmdGVkIGJ5IGtlaG9lIGRlc2lnbnMgLSBkaXNjb3ZlciBuZXcgaWRlYXMuIG1lZXQgY3JlYXRpdmU8L2E+Cjwvc21hbGw+CjxsaT5TaG9wIGZvciBkZXNpZ25lciBjaHJpc3RtYXMgY2VudGVycGllY2VzIG9uIGdvb2dsZTwvbGk+CjxsaT48aDE+RGVzaWduZXIgQ2hyaXN0bWFzIENlbnRlcnBpZWNlczwvaDE+PC9saT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3Utc3BvZGUtY2hyaXN0bWFzLW9ybmFtZW50cy5odG0iPjExIGZlc3RpdmUgdGhhbmtzZ2l2aW5nIGNlbnRlcnBpZWNlcyBhbmQgZmxvd2VycyAtIHRoYW5rc2dpdmluZzwvYT4KPC9zbWFsbD4KPHN0cmlrZT5EZWNvcmF0aW5nIGluc3BpcmF0aW9uOiA1IGVhc3kgaG9saWRheSBjZW50ZXJwaWVjZXMgfCBwcm9qZWN0IG9mIHRoZTwvc3RyaWtlPgoKCjxocj4KCkRlc2lnbmVyIGNocmlzdG1hcyBjZW50ZXJwaWVjZXMK