PCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9JRVRGLy9EVEQgSFRNTCAyLjAvL0VOIj4KPEhUTUw+PEhFQUQ+CjxUSVRMRT5NZXJyeSBjaHJpc3RtYXMgaW4gaGF3YWlpIHNvbmc8L1RJVExFPgo8L0hFQUQ+PEJPRFk+Cgo8aDE+TWVycnkgY2hyaXN0bWFzIGluIGhhd2FpaSBzb25nPC9oMT4KCjxzbWFsbD5LdCB0dW5zdGFsbCAtIG1lbGUga2FsaWtpbWFrYSAoY2hyaXN0bWFzIGluIGhhd2FpaSkgbHlyaWNzIC0gbGV0c3NpbmdpdDwvc21hbGw+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNocmlzdG1hcy1kZWNvcmF0aW9ucy1mb3ItYS1wYXJhZGUtZmxvYXQuaHRtIj5jaHJpc3RtYXMgZGVjb3JhdGlvbnMgZm9yIGEgcGFyYWRlIGZsb2F0PC9hPgo8L3NtYWxsPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jaHJpc3RtYXMtdHJlZS1yYWlkLmh0bSI+YW15IGhhbmFpYWxpaSBnaWxsaW9tICYjODIxMTsgaGF3YWlpYW4gbXVzaWMgbGVnZW5kIHwgbXVzaWM8L2E+CjwvbGk+CjxsaT5IYXZlIGEgd2FybSwgc2hha2EgY2hyaXN0bWFzLCBoYXdhaWlhbi1zdHlsZSAmIzgyMTE7IG9rbGFob21hPC9saT4KPGxpPlNvbmcgYm9vayAtIHNhbiBqb3NlIHVrdWxlbGUgY2x1YjwvbGk+CjxsaT5uaWdodG1hcmUgYmVmb3JlIGNocmlzdG1hcyBmcmVlIHB1bXBraW4gcGF0dGVybnM8L2xpPgo8c21hbGw+SGF3YWlpIGZpdmUtMCBtdXNpYyAtIHM0ZTExOiAmcXVvdDtwdWthbmEgKGtlZXBzYWtlKSZxdW90OyAtIHR1bmVmaW5kPC9zbWFsbD4KPHN0cmlrZT5NZWxlIGthbGlraW1ha2EgLSB3aWtpcGVkaWE8L3N0cmlrZT4KPHNtYWxsPkZyaWVuZHMgY2xhc3NpYyByb2NrIDo6IHNvbmcgbGlzdDwvc21hbGw+CjxsaT5UaGUgaGlzdG9yeSBvZiAmIzgyMjA7bWVsZSBrYWxpa2ltYWthJiM4MjIxOyBvciAmIzgyMjA7bWVycnkgY2hyaXN0bWFzJiM4MjIxOyBpbiBoYXdhaWlhbjwvbGk+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1ob3ctaXJlbGFuZC1jZWxlYnJhdGUtY2hyaXN0bWFzLmh0bSI+MjUgZXNzZW50aWFsIHNvbmdzIGZvciB5b3VyIHRyb3BpY2FsIGNocmlzdG1hcyBpbiBqdWx5IHBsYXlsaXN0PC9hPgo8L3N0cmlrZT4KPHN0cmlrZT5DaHJpc3RtYXMgaXNsYW5kIC0gbWFyZ2FyaXRhdmlsbGU8L3N0cmlrZT4KPGxpPk91ciBmYXZvcml0ZXM6IGhhd2FpaWFuIGNocmlzdG1hcyB0dW5lcyB8IGhhd2FpaS5jb208L2xpPgo8c3RyaWtlPk1lbGUga2FsaWtpbWFrYSBvciBtZXJyeSBjaHJpc3RtYXMgZnJvbSBoYXdhaWkguyBsaXZlbXAzbXVzaWM8L3N0cmlrZT4KPHN0cmlrZT5BIG1lcnJ5IGNocmlzdG1hcyB3aXRoIGJpbmcgY3Jvc2J5ICZhbXA7IHRoZSBhbmRyZXdzIHNpc3RlcnM6IGJpbmc8L3N0cmlrZT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNocmlzdG1hcy1mYWlyLXNlYXR0bGUtd2EuaHRtIj50aGUgYW5kcmV3cyBzaXN0ZXJzIGZlYXQuIGJpbmcgY3Jvc2J5IC0gbWVycnkgY2hyaXN0bWFzIGluIGhhd2FpaTwvYT4KPC9zdHJpa2U+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LXNvdWwtY2hyaXN0bWFzLmh0bSI+bWVsZSBrYWxpa2ltYWthITogbWVycnkgY2hyaXN0bWFzIGZyb20ga3VrdWl1bGEgb24ga2F1YWkgOiB0aGU8L2E+CjwvbGk+CjxzbWFsbD5UaGUgYW5kcmV3cyBzaXN0ZXJzIC0gbWVycnkgY2hyaXN0bWFzIGluIGhhd2FpaS4gc29uZyBvbmxpbmUgYW5kPC9zbWFsbD4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtdGhlLWdob3N0LW9mLWNocmlzdG1hcy1wYXN0Lmh0bSI+dGhlIGdob3N0IG9mIGNocmlzdG1hcyBwYXN0PC9hPgo8L2xpPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3Utc25vb3B5LWNocmlzdG1hcy1vcm5hbWVudC1jb2xsZWN0YWJsZS5odG0iPmhhd2FpaSBjaHJpc3RtYXMgLSBjaHJpc3RtYXMgd2l0aCBhbG9oYSwgbWVsZSBrYWxpa2ltYWthISB8IGFsb2hhPC9hPgo8L3N0cmlrZT4KPHNtYWxsPmNocmlzdG1hcyBibHVlIGNlbnRlcnBpZWNlczwvc21hbGw+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LXJlZC1hbmQtZ3JlZW4tY2hyaXN0bWFzLXBlYXJsLWxpZ2h0cy5odG0iPmhpbG8gZm9yIHRoZSBob2xpZGF5cyBib29rbGV0IC0gbW91bnRhaW4gYXBwbGU8L2E+Cjwvc21hbGw+CjxzdHJpa2U+SGF3YWlpYW4gbXVzaWMgLSBjaHJpc3RtYXMgLSBtZWxlLmNvbTwvc3RyaWtlPgo8c3RyaWtlPkEgaGF3YWlpIHN0YXJzIGNocmlzdG1hcyBvIGhvbHkgbmlnaHQgbXAzIGRvd25sb2FkIGZyZWUsIHBsYXk8L3N0cmlrZT4KPHNtYWxsPkNyaXN0bWFzcyBpbiBoYXdhaWkgbXAzIGZyZWUgZG93bmxvYWQgfCBtcDN0YWtlPC9zbWFsbD4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtZ2lybCdzLXRveXMtZm9yLWNocmlzdG1hcy5odG0iPmluc2lkZXRoZWdhdGUgaG9saWRheXM6IGNocmlzdG1hcyBpbiBoYXdhaWk8L2E+Cjwvc21hbGw+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LXRoZS1uaWdodG1hcmUtYmVmb3JlLWNocmlzdG1hcy1zYWxseS5odG0iPnwgNTAgZ3JlYXRlc3Qgc29uZ3Mgb2YgaGF3YWlpIC0gaG9ub2x1bHUgbWFnYXppbmU8L2E+CjwvbGk+CjxzbWFsbD5NZXJyeSBjaHJpc3RtYXMgdG8gYWxsIHRoZSBsYW5kIGx5cmljcyAtIHNvbmcgbHlyaWNzIGF0IGx5cmljcy5jYXQ8L3NtYWxsPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1uZXcteW9yay1jaXR5LWNocmlzdG1hcy1wYXJhZGUuaHRtIj5rb2hhbGFtdXNpYy5jb20guyByZWNvcmRpbmdzPC9hPgo8L2xpPgo8bGk+Q2hyaXN0bWFzIGluIGhhd2FpaSAtIHRoZSBmbG9yaWRhIHN0YW5kYXJkdGhlIGZsb3JpZGEgc3RhbmRhcmQ8L2xpPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jaHJpc3RtYXMtZGVzaWduLXN0YXRpb25hcnkuaHRtIj5jaHJpc3RtYXMgZGVzaWduIHN0YXRpb25hcnk8L2E+Cjwvc21hbGw+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNocmlzdG1hcy10cmVlLXJlY3ljbGUtbW9vcmVzdmlsbGUtaXJlZGVsbC5odG0iPm1lbGUga2FsaWtpbWFrYSAobWVycnkgY2hyaXN0bWFzKSAtIGhhd2FpaSBjYWxscyBvcmNoZXN0cmEgJmFtcDsgY2hvaXI8L2E+Cjwvc21hbGw+CjxzdHJpa2U+UG9wdWxhciBoYXdhaWlhbiB3b3JkcyAmYW1wOyBwaHJhc2VzIC0gYSBmcmllbmQgaW4gdGhlIGlzbGFuZHMhPC9zdHJpa2U+CjxzdHJpa2U+QnJva2VuY2xhdy5uZXQguyBjaHJpc3RtYXMgY2Fyb2xzPC9zdHJpa2U+CjxzbWFsbD5CbHVlIGNocmlzdG1hcyBpbiBoYXdhaWkgLSBpc2xhbmQgY2hyaXN0bWFzIHNvbmcgLSBhbGV4IG11ZGR5IHNtaXRoPC9zbWFsbD4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtamFtYWljYW4tcnVtLXNhdWNlLWZvci1jaHJpc3RtYXMtcHVkZGluZy5odG0iPmNocmlzdG1hcyBpbiBoYXdhaWkgLSBzdXBlcnRlYWNoZXJ3b3Jrc2hlZXRzLmNvbTwvYT4KPC9zbWFsbD4KPGxpPkJpbGxib2FyZCAtIGdvb2dsZSBib29rcyByZXN1bHQ8L2xpPgo8c3RyaWtlPlRoZSBtZXJyeSBodWxhIC0gbHlyaWNzIC0gaW50ZXJuYXRpb25hbCBseXJpY3MgcGxheWdyb3VuZDwvc3RyaWtlPgo8c21hbGw+QSBtZXJyeSBoYXdhaWlhbiBjaHJpc3RtYXMgYnkgaGF3YWlpIGNhbGxzICZhbXA7IHRoZSBoYXdhaWkgY2FsbHM8L3NtYWxsPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jaHJpc3RtYXMtZGVjb3JhdGlvbnMtaW4tZ2VvZ2lhLmh0bSI+c3VuIGNpdHkgYXogdWt1bGVsZSBjbHViIC0gc29uZ3M8L2E+CjwvbGk+CjxzdHJpa2U+Y2hyaXN0bWFzIHRyZWVzIGJhaGFtYXM8L3N0cmlrZT4KPHNtYWxsPjEyIG1vc3QgYW1hemluZyBjaHJpc3RtYXMgc29uZ3Mgb24gc3BvdGlmeSB8IGluc2lnaHRzPC9zbWFsbD4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtZW5yaWNobWVudC1jaHJpc3RtYXMtaWRlYXMuaHRtIj5zbGljZXMgb2YgbGlmZSBpbiBoYXdhaWkgLSBnb29nbGUgYm9va3MgcmVzdWx0PC9hPgo8L2xpPgo8c3RyaWtlPkNocmlzdG1hcyBzb25ncyAtIG1lbGUga2FsaWtpbWFrYSBseXJpY3MgfCBseXJpY3Ntb2RlLmNvbTwvc3RyaWtlPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1kYW5idXJ5LW1pbnQtc25vb3B5LWNocmlzdG1hcy5odG0iPmpha2Ugb3dlbiwgJiMzOTttZWxlIGthbGlraW1ha2EmIzM5OyAmIzgyMTE7IHNvbmcgcmV2aWV3IC0gdGFzdGUgb2YgY291bnRyeTwvYT4KPC9saT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtZXJhc3VyZS1sb25lbHktY2hyaXN0bWFzLmh0bSI+ZXJhc3VyZSBsb25lbHkgY2hyaXN0bWFzPC9hPgo8L3NtYWxsPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLWJ1ZmZldC10YW1wYS1mbG9yaWRhLmh0bSI+eW91ciBzdGF0ZSBoYXMgYSBmYXZvcml0ZSBjaHJpc3RtYXMgc29uZywgc28geW91IG1pZ2h0IGhhdmUgdG88L2E+Cjwvc3RyaWtlPgo8c21hbGw+SGFwcHkgbmV3IHllYXIgYW5kIG1lcnJ5IGNocmlzdG1hcyBpbiBoYXdhaWlhbjwvc21hbGw+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS10ZXN0LWNocmlzdG1hcy1saWdodHMuaHRtIj5tdXNpYyAtIHdpbGxpZSBrIGhhd2FpaWFuIG11c2ljIG1hdWkgbGl2ZSBtdXNpYyBtYXVpIGVudGVydGFpbm1lbnQ8L2E+Cjwvc3RyaWtlPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLWRlY29yYXRpb24taG9tZS1tYWRlLmh0bSI+enVwZSB8IG9mZmljaWFsIHdlYnNpdGUgfCBzb25nIGxpc3Q8L2E+Cjwvc3RyaWtlPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtdG9wLTEwMC1jaHJpc3RtYXMtc29uZ3MuaHRtIj50b3AgMTAwIGNocmlzdG1hcyBzb25nczwvYT4KPC9zdHJpa2U+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNocmlzdG1hcy1zdG9yeS1sZWctbGFtcC1waWN0dXJlLmh0bSI+dWx0aW1hdGUgY2hyaXN0bWFzPC9hPgo8L2xpPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jaHJpc3RtYXMtb3JuYW1lbnQtbWFudWZhY3R1cmVycy5odG0iPmNkIHRpdGxlcyAtIGdyZWcgYW5kIGp1bmtvIG1hY2RvbmFsZCAtIGF3YXJkIHdpbm5pbmcgc3RlZWwgZHJ1bTwvYT4KPC9saT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWp1c3QtY3Jvc3Mtc3RpdGNoLWNocmlzdG1hcy1vcm5hbWVudC1pc3N1ZS5odG0iPmthbmlrYXBpbGEgc3VuZGF5IHwgaGF3YWlpIHB1YmxpYyByYWRpby1ocHIyPC9hPgo8L3N0cmlrZT4KPGxpPlJ1ZG9scGggdGhlIHJlZC1ub3NlZCByZWluZGVlciB3ZSB3aXNoIHlvdSBhIG1lcnJ5IGNocmlzdG1hczwvbGk+CjxzdHJpa2U+V2hhdCBpcyB0aGF0IG9uZSBoYXdhaWlhbiBjaHJpc3RtYXMgc29uZyB0aGF0IHNheXMsICZxdW90O21hbGlraSBsaWtpPC9zdHJpa2U+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LTEyLWRheXMtb2YtY2hyaXN0bWFzLWtpZHMtYWN0aXZpdGllcy5odG0iPjEyIGRheXMgb2YgY2hyaXN0bWFzIGtpZHMgYWN0aXZpdGllczwvYT4KPC9zbWFsbD4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNocmlzdG1hcy1tdXNpYy1ieS1qZWZmLWNvb2suaHRtIj5jaHJpc3RtYXMgbXVzaWMgYnkgamVmZiBjb29rPC9hPgo8L3N0cmlrZT4KPGxpPkhhd2FpaWFuICZxdW90O21lbGUga2FsaWtpbWFrYSwmcXVvdDsgZ3JlZWsgJnF1b3Q7a2hyaXN0b3MsJnF1b3Q7IHhtYXMsIGFuZCB3aHkgbm90PC9saT4KPHN0cmlrZT5ndWFzdGkgbWFuc2lvbiBhbmQgY2hyaXN0bWFzPC9zdHJpa2U+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWxlZC1jaHJpc3RtYXMtbGlnaHRzLmh0bSI+aGF3YWlpYW4gY2hyaXN0bWFzIGFuZCBuZXcgeWVhciYjMzk7cyB3b3JkcyBhbmQgcGhyYXNlczwvYT4KPC9saT4KPGxpPkhhd2FpaWFuIGNocmlzdG1hcyBzb25nLiBmcmVlIG1lcnJ5IGNocmlzdG1hcyBlY2FyZHMsIGdyZWV0aW5nPC9saT4KPGxpPkhvbGlkYXkgZm9vZHMgJmFtcDsgdHJhZGl0aW9ucyBpbiBoYXdhaSYjMzk7aSAtIGhvbHVhbG9hIGlubjwvbGk+CjxzdHJpa2U+TGlzdGVuIHRvIGZyZWUgJnF1b3Q7aGF3YWlpYW4gY2hyaXN0bWFzIHNvbmdzPC9zdHJpa2U+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNocmlzdG1hcy1jYXJkcy1jYW5hZGEuaHRtIj5oYXdhaWlhbiBsYW5ndWFnZSwgaG93IHRvIHNwZWFrIGhhd2FpaWFuPC9hPgo8L2xpPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1zaW1lb24tY2hyaXN0bWFzLXBsYXkuaHRtIj5zaW1lb24gY2hyaXN0bWFzIHBsYXk8L2E+Cjwvc21hbGw+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWEtZG9nLWNocmlzdG1hcy5odG0iPmpha2Ugb3dlbiBicmluZ3MgaGF3YWlpIHRvICYjMzk7Y21hIGNvdW50cnkgY2hyaXN0bWFzJiMzOTsgLSB0aGUgYm9vdDwvYT4KPC9saT4KPHN0cmlrZT5CaW5nIGNyb3NieSBtZXJyeSBjaHJpc3RtYXMgaW4gaGF3YWlpIC0gYmluZzwvc3RyaWtlPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1ndWFzdGktbWFuc2lvbi1hbmQtY2hyaXN0bWFzLmh0bSI+Z3Vhc3RpIG1hbnNpb24gYW5kIGNocmlzdG1hczwvYT4KPC9saT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtbGludXMtaW4tY2hhcmxpZS1icm93bnMtY2hyaXN0bWFzLmh0bSI+aGF3YWlpYW4gbWlkaSBtdXNpYzwvYT4KPC9zbWFsbD4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNocmlzdG1hcy1kZWNvcmF0aW9ucy1mb3ItYS1wYXJhZGUtZmxvYXQuaHRtIj5tZXJyeSBtaXhtYXMgLSBkaiByaWtvIC0gbWFzaHVwcywgbWl4ZXMsIG1pc2hhcHMsIG1heWhlbTwvYT4KPC9zdHJpa2U+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNocmlzdG1hcy10cmVlcy1iYWhhbWFzLmh0bSI+bWVsZSBrYWxpa2ltYWthIGhhd2FpaWFuIGNocmlzdG1hcyBzb25nIC0gZGx0ay1ob2xpZGF5czwvYT4KPC9saT4KPHNtYWxsPkthY2V5IG11c2dyYXZlcyBpbnZpdGVzIHlvdSB0byBzcGVuZCBjaHJpc3RtYXMgb24gYW4gaXNsYW5kPC9zbWFsbD4KPHNtYWxsPk1lbGUga2FsaWtpbWFrYSB8IGNvbnJhZCYjMzk7cyBjaG9yZHM8L3NtYWxsPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS11bmlxdWUtcGVyc29uYWwtY2hyaXN0bWFzLWNhcmRzLmh0bSI+YSBmZXcgaG9saWRheSBzb25ncyBoZWFyZCBkdXJpbmcgY2hyaXN0bWFzIHRpbWUgaW4gaGF3YWlpLi4uIHwga2F0aHk8L2E+Cjwvc21hbGw+CjxsaT5XaGF0JiMzOTtzIHRoZSBoYXdhaWlhbiBzb25nIGZyb20gJiMzOTtuYXRpb25hbCBsYW1wb29uJiMzOTtzIGNocmlzdG1hczwvbGk+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNvbXB1dGVyLWNocmlzdG1hcy1hZHMuaHRtIj5jaHJpc3RtYXMgdGltZSB3aXRoIGVkZGllIGthbWFlICZhbXA7IHRoZSBzb25zIG9mIGhhd2FpaTwvYT4KPC9saT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtcmVkLW5lY2stY2hyaXN0bWFzLmh0bSI+Y2F0YWxvZyBvZiBjb3B5cmlnaHQgZW50cmllczogbXVzaWNhbCBjb21wb3NpdGlvbnMgLSBnb29nbGUgYm9va3MgcmVzdWx0PC9hPgo8L3NtYWxsPgo8c3RyaWtlPlRoZSBiYXJlZm9vdCBoYXdhaWlhbiYjMzk7cyBtZWxlIGthbGlraW1ha2EgY2VsZWJyYXRpb248L3N0cmlrZT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LW1ha2UtYS1jaHJpc3RtYXMtc3dlYXRzaGlydC5odG0iPmppbW15IGJ1ZmZldHQgJiM4MjEyOyBtZWxlIGthbGlraW1ha2EgJiM4MjEyOyBsaXN0ZW4sIHdhdGNoLCBkb3dubG9hZCBhbmQ8L2E+Cjwvc3RyaWtlPgo8c3RyaWtlPjxoMT5NZXJyeSBDaHJpc3RtYXMgSW4gSGF3YWlpIFNvbmc8L2gxPjwvc3RyaWtlPgo8c21hbGw+VGhlIHN0ZWVsIGd1aXRhciBmb3J1bSA6OiB2aWV3IHRvcGljIC0gY2hyaXN0bWFzIHRhYnMgLSBoYXdhaWlhbjwvc21hbGw+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LXRob21hcy1raW5rYWRlLXZpbGxhZ2UtY2hyaXN0bWFzLmh0bSI+dGhvbWFzIGtpbmthZGUgdmlsbGFnZSBjaHJpc3RtYXM8L2E+CjwvbGk+CjxzbWFsbD5QcngguyBwaWVjZSC7IGEgaGF3YWlpYW4gY2hyaXN0bWFzIHdpdGggc2xhY2sga2V5IG1hc3RlciBrYXBvbm88L3NtYWxsPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLWFyb3VuZC10aGUtd29ybGQtZ2VybWFueS5odG0iPmNocmlzdG1hcyBhcm91bmQgdGhlIHdvcmxkIGdlcm1hbnk8L2E+Cjwvc3RyaWtlPgo8bGk+TWVsZSBrYWxpa2ltYWthIC0gdWt1bGVsZSBib29nYWxvbyBwcmVzZW50cyBob2xpZGF5IHNvbmdzPC9saT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3Utb2ZmaWNlLWNocmlzdG1hcy10cmVlcy5odG0iPm1lbGUga2FsaWtpbWFrYSAobWVycnkgY2hyaXN0bWFzIGluIGhhd2FpaSkgfCBzaGVldCBtdXNpYyBkaXJlY3Q8L2E+CjwvbGk+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1mb3J0LW15ZXJzLWNocmlzdG1hcy1icmVhay1jYW1wcy5odG0iPmZvcnQgbXllcnMgY2hyaXN0bWFzIGJyZWFrIGNhbXBzPC9hPgo8L3N0cmlrZT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtdGltZXMtc3F1YXJlLWNocmlzdG1hcy10cmVlLmh0bSI+dGltZXMgc3F1YXJlIGNocmlzdG1hcyB0cmVlPC9hPgo8L2xpPgo8c3RyaWtlPkhhd2FpaSBjaHJpc3RtYXM8L3N0cmlrZT4KPGxpPlRoZSBvZmZpY2lhbCBzaXRlIG9mIGlzcmFlbCBpeiBrYW1ha2F3aXdvYG9sZSB8IHRoaXMgaXMgdGhlIHBsYWNlIGZvcjwvbGk+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNocmlzdG1hcy1zb25nLWNvdXBsZS1iZWVycy5odG0iPmthcmwgcm92ZTogb2JhbWEgd2lzaGluZyBhbWVyaWNhbnMgJiM4MjIwO21lcnJ5IGNocmlzdG1hcyYjODIyMTsgaW4gLSBzYWxvbjwvYT4KPC9saT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LW1leGljYW4tY2hyaXN0bWFzLWVsZW1lbnRhcnktc2Nob29sLWxlc3NvbnMuaHRtIj5tZXhpY2FuIGNocmlzdG1hcyBlbGVtZW50YXJ5IHNjaG9vbCBsZXNzb25zPC9hPgo8L3N0cmlrZT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLWNhcm9scy1zdGFydGluZy13aXRoLXcuaHRtIj5jaHJpc3RtYXMgY2Fyb2xzIHN0YXJ0aW5nIHdpdGggdzwvYT4KPC9saT4KPHN0cmlrZT5jaHJpc3RtYXMgZmFpciBzZWF0dGxlIHdhPC9zdHJpa2U+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWx5cmljcy13ZS1uZWVkLWEtbGl0dGxlLWNocmlzdG1hcy5odG0iPmthY2V5IG11c2dyYXZlcyBvbiBjaHJpc3RtYXMgYWxidW0sIG5ldyB3aWxsaWUgbmVsc29uIGR1ZXQ8L2E+CjwvbGk+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS0xMi0yNS1pbmZpbml0eS1jaHJpc3RtYXMuaHRtIj5iaW5nIGNyb3NieSAmIzgyMTE7IG1lbGUga2FsaWtpbWFrYSBseXJpY3MgfCBnZW5pdXMgbHlyaWNzPC9hPgo8L3N0cmlrZT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LXRoZS1zaW5naW5nLWNocmlzdG1hcy10cmVlLXdhLmh0bSI+dGhlIHNpbmdpbmcgY2hyaXN0bWFzIHRyZWUgd2E8L2E+Cjwvc3RyaWtlPgo8bGk+Q2hyaXN0bWFzIGluIGhhd2FpaSAtIHNlY29uZCBoYW5kIHNvbmdzPC9saT4KPHN0cmlrZT5NZWxlIGthbGlraW1ha2EhIGEgc29uZyBhbmQgYSBzZWFzb24gLSBoYXdhaWkgaW5zaWRlcjwvc3RyaWtlPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jaHJpc3RtYXMtYmFybi1wYXJ0eS1nYW1lLWlkZWFzLmh0bSI+aW4gd2Fpa2lraSwgaXQmIzM5O3MgY2hyaXN0bWFzIHdpdGggYSBkaXN0aW5jdGx5IGhhd2FpaWFuIGZsYXZvciAtIGxhIHRpbWVzPC9hPgo8L2xpPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLXRyZWUtc2hvcC1zYXVndXMtbWFzcy5odG0iPmNocmlzdG1hcyB0cmVlIHNob3Agc2F1Z3VzIG1hc3M8L2E+Cjwvc3RyaWtlPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jaHJpc3RtYXMtc3dlYXRlci1rbml0dGluZy1wYXR0ZXJuLmh0bSI+YSBjaHJpc3RtYXMgeXVsZWJsb2c6IG9sZCBoYXdhaWlhbiBjaHJpc3RtYXMgKHNlYXdlc3QgcmVjb3Jkcyk8L2E+CjwvbGk+CjxzdHJpa2U+TWVsZSBrYWxpa2ltYWthIC0gbWVycnkgY2hyaXN0bWFzIGZyb20gaGF3YWlpIGRpZ2l0YWwgYXJ0IGJ5IGtlcnJpPC9zdHJpa2U+CjxsaT5VbHRpbWF0ZSBjaHJpc3RtYXMgdHJhY2sgbm90ZXMgLSBiZWFjaCBib3lzIGZhbiBjbHViPC9saT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtZ2hhbmEtYW5kLWZhdGhlci1jaHJpc3RtYXMtYW5kLXBpY3R1cmUuaHRtIj5oYXdhaWlhbiBjaHJpc3RtYXMgbWVsZSBrYWxpa2ltYWthIGRvd25sb2FkIGZyZWUgbXAzIHNvbmc8L2E+CjwvbGk+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1zdXBwbGllcy1mb3ItY2hyaXN0bWFzLXBhcnR5cy5odG0iPmxlYXJuIHlvdXIgY2hyaXN0bWFzIGNhcm9sczogbWVsZSBrYWxpa2ltYWthIC0gbHlyaWNzLCB2aWRlbywgbXAzPC9hPgo8L3N0cmlrZT4KPHNtYWxsPjEwMDArIGltYWdlcyBhYm91dCBoYXdhaWlhbiBjaHJpc3RtYXMgb24gcGludGVyZXN0IHwgaGF3YWlpPC9zbWFsbD4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWtpbmctZ2VvcmdlLTZ0aC1jaHJpc3RtYXMtc3BlZWNoLmh0bSI+aGF3YWlpIG1lcnJ5IGNocmlzdG1hcyBzb25nICYjODIxMjsgZnJlZSBtcDMgZG93bmxvYWQ8L2E+Cjwvc3RyaWtlPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jcm9zcy1zdGl0Y2gtY2hyaXN0bWFzLW9ybmFtZW50cy1mcmVlLXBhdHRlcm5zLmh0bSI+Y3Jvc3Mgc3RpdGNoIGNocmlzdG1hcyBvcm5hbWVudHMgZnJlZSBwYXR0ZXJuczwvYT4KPC9saT4KPGxpPkJpbmcgY3Jvc2J5ICZxdW90O21lbGUga2FsaWtpbWFrYSZxdW90OyBzaGVldCBtdXNpYyBpbiBmIG1ham9yPC9saT4KPHNtYWxsPkxpc3RlbiAtIHRlcnJpdG9yaWFsIGFpcndhdmVzPC9zbWFsbD4KPHNtYWxsPkJpbmcgY3Jvc2J5IC0gbWVsZSBrYWxpa2ltYWthIChoYXdhaWlhbiBjaHJpc3RtYXMgc29uZykgLSB5b3V0dWJlPC9zbWFsbD4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtbGFzdHItY2hyaXN0bWFzLXdoYW0uaHRtIj5sYXN0ciBjaHJpc3RtYXMgd2hhbTwvYT4KPC9zbWFsbD4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWl0YWx5LWNocmlzdG1hcy1ob2xpZGF5Lmh0bSI+aXRhbHkgY2hyaXN0bWFzIGhvbGlkYXk8L2E+Cjwvc3RyaWtlPgo8bGk+SGF3YWlpLWNocmlzdG1hcyBmcmVlIG1wMyBkb3dubG9hZDwvbGk+CjxsaT5NZWxlIGthbGlraW1ha2EgbWVycnkgY2hyaXN0bWFzIHdpdGggbHlyaWNzIGJpbmcgY3Jvc2J5IHRoZSB8IGJlZTwvbGk+CjxzdHJpa2U+U2FudGEgY2xhdXMgdGFrZXMgYnJlYWsgZnJvbSBjaHJpc3RtYXMgd2l0aCB2aXNpdCB0byB3YWlraWtpIGJlYWNoPC9zdHJpa2U+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LW5pZ2h0bWFyZS1iZWZvcmUtY2hyaXN0bWFzLWZyZWUtcHVtcGtpbi1wYXR0ZXJucy5odG0iPm5pZ2h0bWFyZSBiZWZvcmUgY2hyaXN0bWFzIGZyZWUgcHVtcGtpbiBwYXR0ZXJuczwvYT4KPC9saT4KPHNtYWxsPk1lbGUga2FsaWtpbWFrYSAtIHVrdWxlbGUgY2hvcmRzIHwgZ290IGEgdWt1bGVsZSAtIHVrdWxlbGU8L3NtYWxsPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtZm9ydC13YWx0b24tYmVhY2gtY2hyaXN0bWFzLXBhcmFkZS5odG0iPmhhcCBwYWxtZXImIzM5O3MgaG9saWRheSBtYWdpYyAtIGx5cmljcyBhbmQgYWN0aXZpdGllczwvYT4KPC9zdHJpa2U+CjxsaT5UaGUgbWVycnkgaHVsYSAtIHNvbmdzIGZvciB0ZWFjaGluZzwvbGk+CjxzbWFsbD5NZWxlIGthbGlraW1ha2EgKGhhd2FpaWFuIGNocmlzdG1hcyBzb25nKSBseXJpY3MgfCB0aW1lIGZvciB0aGU8L3NtYWxsPgo8c3RyaWtlPlRlbGMgLSBjaHJpc3RtYXMgc29uZ3MgaW5zcGlyZWQgYnkgY3VsdHVyZXMgYXJvdW5kIHRoZSB3b3JsZDwvc3RyaWtlPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS11bmlxdWUtcGVyc29uYWwtY2hyaXN0bWFzLWNhcmRzLmh0bSI+YmluZyBjb3NieSAtICggbWVsZSBrYWxpa2ltYWthIGNob3JkcyApIC0gZ3VpdGFyIHRhYnM8L2E+Cjwvc21hbGw+CjxzbWFsbD5NZWxlIGthbGlraW1ha2EgbHlyaWNzIC0gamltbXkgYnVmZmV0dDwvc21hbGw+CjxzdHJpa2U+TWVsZSBrYWxpa2ltYWthIChjaHJpc3RtYXMgaW4gaGF3YWlpKSBieSBrdCB0dW5zdGFsbCAtIGludnVidTwvc3RyaWtlPgo8bGk+S2FyYW9rZSBtZWxlIGthbGlraW1ha2EgLSB2aWRlbyB3aXRoIGx5cmljcyAtIGJpbmcgY3Jvc2J5IC0ga2FyYWZ1bjwvbGk+CjxsaT5DaHJpc3RtYXMgaW4gaG9ub2x1bHUgMjAxNDogdGhlIGJlc3Qgc2Vhc29uYWwgLSBtb3ZlIHRvIGhhd2FpaTwvbGk+CjxsaT5NZWxlIGthbGlraW1ha2EgaXMgdGhlIHRoaW5nIHRvIHNheSwgb24gYSBicmlnaHQgaGF3YWlpYW4gY2hyaXN0bWFzPC9saT4KPHNtYWxsPklkZWFzIGFib3V0IGhhd2FpaSBtZXJyeSBjaHJpc3RtYXMgc29uZywgLSBjaGVhcCBjaHJpc3RtYXM8L3NtYWxsPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtbmlnaHRub2lzZS10aGUtcGFydGluZy10aWRlLWNocmlzdG1hcy5odG0iPmFtYXpvbi5jb206IG1lbGUga2FsaWtpbWFrYSAobWVycnkgY2hyaXN0bWFzKTogYmluZyBjcm9zYnk8L2E+Cjwvc3RyaWtlPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtaWRlYXMtZm9yLWNocmlzdG1hcy1nYWctZ2lmdHMuaHRtIj5tZXJyeSBjaHJpc3RtYXMgaGF3YWlpIHBlcnNvbmFsaXNvbmdzIGx5cmljczwvYT4KPC9zdHJpa2U+CjxzdHJpa2U+QmluZyBjcm9zYnk6bWVsZSBrYWxpa2ltYWthIGx5cmljcyB8IGx5cmljd2lraWEgfCBmYW5kb20gcG93ZXJlZDwvc3RyaWtlPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtZnVubnktY2hyaXN0bWFzLXBpdHVyZXMuaHRtIj5jaHJpc3RtYXMgLSBoaXAgd2F4PC9hPgo8L3N0cmlrZT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNvbnRlbXBvcmFyeS1jaHJpc3RtYXMtcGhvdG8tY2FyZHMuaHRtIj5zb25ndGV4dCB2b24gYmluZyBjcm9zYnkgLSBtZWxlIGthbGlraW1ha2EgbHlyaWNzPC9hPgo8L3N0cmlrZT4KPHNtYWxsPk1lcnJ5IGNocmlzdG1hcyBpbiBoYXdhaWlhbjwvc21hbGw+CjxzdHJpa2U+S29uYSBmZXN0aXZhbGUgY2hvcmFsZSBjZWxlYnJhdHJlcyBjaHJpc3RtYXMgd2l0aCBtdXNpYyB8IHdlc3Q8L3N0cmlrZT4KPHNtYWxsPjkgaGF3YWlpYW4gY2hyaXN0bWFzIHNvbmdzIHRvIGZpbGwgeW91IHdpdGggaG9saWRheSBjaGVlcjwvc21hbGw+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWFuaXNlLWNocmlzdG1hcy1jb29raWUtcmVjaXBlcy5odG0iPmNlbGVicmF0ZSB0aGUgaG9saWRheXMgaGF3YWlpLXN0eWxlIKsgc28gbXVjaCBtb3JlIGhhd2FpaTwvYT4KPC9saT4KPHN0cmlrZT5KYWRvbiBsYXZpayAtIG1lbGUga2FsaWtpbWFrYSBseXJpY3M8L3N0cmlrZT4KPHNtYWxsPk1lbGUga2FsaWtpbWFrYTwvc21hbGw+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1hbnRpcXVlLWNocmlzdG1hcy1zaG93LWdyaW1zYnktb24uaHRtIj53YWlwdW5hIC0gaGF3YWlpYW4gbXVzaWMgYnkga2FsZSBoYW5uYWhzIGFuZCBtYXR0IHNwcm9hdDwvYT4KPC9zdHJpa2U+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWdsb3JpYS1lbi1leGNlbHNpcy1kZW8tY2hyaXN0bWFzLmh0bSI+bWVsZSBrYWxpa2ltYWthIGNob3JkcyBieSBiaW5nIGNvc2J5IEAgdWx0aW1hdGUtZ3VpdGFyLmNvbTwvYT4KPC9zbWFsbD4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLXBseXdvb2QtbGF3bi1vcm5hbWVudC1wYXR0ZXJucy5odG0iPmNocmlzdG1hcyBwbHl3b29kIGxhd24gb3JuYW1lbnQgcGF0dGVybnM8L2E+CjwvbGk+CjxsaT5TYW1wbGUgc29uZyBsaXN0IC0geWVoIG1vbiEgd2VsY29tZSB0byB0aGUgamFtYWljYW4gb25lIG1hbjwvbGk+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNocmlzdG1hcy1zb25nLWd1dGFpci1jaG9yZHMuaHRtIj5tZWxlIGthbGlraW1ha2EgaXMgYSB3aXNlIHdheSB0byBzYXkgbWVycnkgY2hyaXN0bWFzIHRvIHlvdTwvYT4KPC9zbWFsbD4KPGxpPlRoZSB3YWlraWtpcyogLSBtZXJyeSBjaHJpc3RtYXMgaW4gaGF3YWlpICh2aW55bCwgbHAsIGFsYnVtKSBhdDwvbGk+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1ibGVzc2VkLXNhY3JhbWVudC1zaW91eC1jaXR5LWNocmlzdG1hcy5odG0iPmJsZXNzZWQgc2FjcmFtZW50IHNpb3V4IGNpdHkgY2hyaXN0bWFzPC9hPgo8L3N0cmlrZT4KPHNtYWxsPkhlbnJ5IGthcG9ubyAtIG11c2ljaWFuLCBhdXRob3IsIGFjdG9yLCBjb21wb3NlciwgcHJvZHVjZXIsIHdpbGQ8L3NtYWxsPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1jaHJpc3RtYXMtc3dlYXRlci1rbml0dGluZy1wYXR0ZXJuLmh0bSI+bWVycnkgY2hyaXN0bWFzIGluIGhhd2FpaSBtZWxla2VsaWtpbWFrYSAtIGhvdyBkbyBzYXkgbWVycnk8L2E+Cjwvc21hbGw+CjxsaT5NZXJyeSBjaHJpc3RtYXMgYW5kIGhhcHB5IG5ldyB5ZWFyIGluIGhhd2FpaWFuPC9saT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2xvdGhlcy1waW4tY2hyaXN0bWFzLWNyYWZ0cy1mb3Ita2lkcy5odG0iPmNsb3RoZXMgcGluIGNocmlzdG1hcyBjcmFmdHMgZm9yIGtpZHM8L2E+CjwvbGk+CjxsaT5NdXNpYyB0aW1lICYjODIxMTsgY2hyaXN0bWFzIC0gbWlkbGlmZSBjcmlzaXMgaGF3YWlpPC9saT4KPHNtYWxsPklmIGNocmlzdG1hcyBnZXRzIHlvdSBkb3duLCB0aGVyZSYjMzk7cyBhIHNhZCBzb25nIGZvciB5b3UgfCBoYXdhaWk8L3NtYWxsPgo8c21hbGw+TWVycnkgY2hyaXN0bWFzISEhIHwgaW1hZ2VzIG9mIG9sZCBoYXdhaSYjNjk5O2k8L3NtYWxsPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtYS1jaHJpc3RtYXMtY2Fyb2wtd2l0aC1rZWxzeS1ncmFtbWVyLmh0bSI+JnF1b3Q7bWVsZSBrYWxpa2ltYWthJnF1b3Q7IGJ5IGJpbmcgY3Jvc2J5IHVrdWxlbGUgdGFicyBvbiB1a3V0YWJzPC9hPgo8L3N0cmlrZT4KPHNtYWxsPlVsdWthdTogbiYjMjU3OyBtZWxlIG8gaGF3YWkmIzY5OTtpIG5laTogMTAxIGhhd2FpaWFuIHNvbmdzPC9zbWFsbD4KPHN0cmlrZT5IYXdhaWlhbiBkaWN0aW9uYXJ5PC9zdHJpa2U+CjxsaT5DaHJpcyBpc2FhayBseXJpY3MgLSBtZWxlIGthbGlraW1ha2EgLSBhLXogbHlyaWNzPC9saT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LXByaW50YWJsZS1tZXJyeS1jaHJpc3RtYXMtY2FyZHMuaHRtIj5wcmludGFibGUgbWVycnkgY2hyaXN0bWFzIGNhcmRzPC9hPgo8L3N0cmlrZT4KPHNtYWxsPlJvY2sgbHlyaWNzOiBqaW1teSBidWZmZXR0OiBjaHJpc3RtYXMgaXNsYW5kIGx5cmljczwvc21hbGw+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNocmlzdG1hcy1tYWluLWRpc2gtbWVhbHMuaHRtIj5jaHJpc3RtYXMgbWFpbiBkaXNoIG1lYWxzPC9hPgo8L3NtYWxsPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1raW5jYWlkLWNocmlzdG1hcy1mbG9yYWwtYXJyYW5nZW1lbnRzLmh0bSI+Y2hyaXN0bWFzIGx5cmljcyBhbmQgY2hvcmRzIC0gY2FsdmFyeSBieSB0aGUgc2VhPC9hPgo8L3NtYWxsPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLWdpZnQtcGV0Lmh0bSI+MjUgYmVzdCBjaHJpc3RtYXMgc29uZ3MgLSBjbGFzc2ljIGhvbGlkYXkgbXVzaWMgdG8gbGlzdGVuIHRvPC9hPgo8L3N0cmlrZT4KPGxpPkhhd2FpaSBzb25nIG1lcnJ5IGNocmlzdG1hcyAtIGhvbWU8L2xpPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1ob3ctbWFueS13aGl0ZS1jaHJpc3RtYXMtaW4ta2Fuc2FzLmh0bSI+c2luZ2xlIHNvbmcgcHVyY2hhc2VzIC0gdWt1bGVsZSBtZWxlIG9uIG1hdWk8L2E+Cjwvc21hbGw+CjxsaT5BIGhhd2FpaWFuIGNocmlzdG1hcyAtIG11c2ljIGstODwvbGk+CjxzbWFsbD5XaGF0JiMzOTtzIHRoZSB3b3JzdCBjaHJpc3RtYXMgc29uZz8gZXZlcnkgc2luZ2xlIG9uZSBvZiB0aGVtIC0gaGF3YWlpPC9zbWFsbD4KPHNtYWxsPnRoZSBzaW5naW5nIGNocmlzdG1hcyB0cmVlIHdhPC9zbWFsbD4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3Utc3R1ZGlvLWNocmlzdG1hcy1waWN0dXJlcy5odG0iPnN0dWRpbyBjaHJpc3RtYXMgcGljdHVyZXM8L2E+Cjwvc21hbGw+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL21vYmlsZS9ndS1hcnRpZmljaWFsLWNocmlzdG1hcy10cmVlLXdpdGgtYmVycmllcy5odG0iPmJpbmcgY3Jvc2J5IC0gbWVsZSBrYWxpa2ltYWthIChoYXdhaWlhbiBjaHJpc3RtYXMgc29uZykgLSB5b3V0dWJlPC9hPgo8L3N0cmlrZT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9tb2JpbGUvZ3UtY2hyaXN0bWFzLWdpZnQtc3dhcC1nYW1lcy1hY3Rpdml0aWVzLmh0bSI+amVmZiBwZXRlcnNvbiAtIHNsYWNrIGtleSBndWl0YXI8L2E+CjwvbGk+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNocmlzdG1hcy1lbGVjdHJpYy1jb21wYW55LWJ1ZmZhbG8tbnkuaHRtIj5tZXJyeSBjaHJpc3RtYXMgaW4gaGF3YWlpIHNvbmcgLSB2aWRlbyBhbmQgbXAzIGZvciBmcmVlPC9hPgo8L3NtYWxsPgo8bGk+UGVyIGdlc3NsZSYjMzk7cyB0b3A5IGNocmlzdG1hcyBzb25ncyCrIHJveGV0dGVibG9nLmNvbTwvbGk+CjxzbWFsbD4xMSByZWFzb25zIHRvIHNwZW5kIHRoZSBob2xpZGF5cyBpbiBoYXdhaWkgLSBoYXdhaWkgZGlzY291bnQgYmxvZzwvc21hbGw+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LW91ci1iZWF1dGlmdWwtd29ybGQtY2hyaXN0bWFzLWNhcmRzLmh0bSI+dGhlIG1lbG9keSBvZiBtZWxlIGthbGlraW1ha2EgfCBpc2xhbmQgdHJhdmVsIGhhd2FpaTwvYT4KPC9zbWFsbD4KPHN0cmlrZT5NZWxlIGthbGlraW1ha2EgY2hyaXN0bWFzIG11c2ljLCBzb25nIGx5cmljcywgaGF3YWlpYW4gY2hyaXN0bWFzPC9zdHJpa2U+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LXBvZW1zLWZvci1sb3ZlcnMtYXQtY2hyaXN0bWFzLmh0bSI+bWVsZSBrYWxpa2ltYWthIG9uIGJlaGFuY2U8L2E+Cjwvc21hbGw+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNocmlzdG1hcy1naWZ0LXBldC5odG0iPmNocmlzdG1hcyBnaWZ0IHBldDwvYT4KPC9saT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vbW9iaWxlL2d1LWNocmlzdG1hcy1ibHVlLWNlbnRlcnBpZWNlcy5odG0iPmhhd2FpaWFuIGNocmlzdG1hcyBtdXNpYyBvbiByYWRpbyAtIGhvbm9sdWx1IGZvcnVtIC0gdHJpcGFkdmlzb3I8L2E+Cjwvc3RyaWtlPgo8c21hbGw+TWVsZSBrYWxpa2ltYWthIG9yIG1lcnJ5IGNocmlzdG1hcyBmcm9tIGhhd2FpaSB8IDIwMTEgb24gdmltZW88L3NtYWxsPgo8bGk+JnF1b3Q7ZG9ubmEgZG9lcyBlbHZpcyBpbiBoYXdhaWkmcXVvdDsgYXV0b2dyYXBoZWQgZXAgJiM4MjExOyBkb25uYWxvcmVuLmNvbTwvbGk+CgoKPGhyPgoKTWVycnkgY2hyaXN0bWFzIGluIGhhd2FpaSBzb25nCg==