PCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9JRVRGLy9EVEQgSFRNTCAyLjAvL0VOIj4KPEhUTUw+PEhFQUQ+CjxUSVRMRT5NYWRlbGluZS9ndSBibGFuayBjaHJpc3RtYXMgd2lzaCBsaXN0PC9USVRMRT4KPC9IRUFEPjxCT0RZPgoKPGgxPk1hZGVsaW5lL2d1IGJsYW5rIGNocmlzdG1hcyB3aXNoIGxpc3Q8L2gxPgoKPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1tYWRlbGluZS9ndS1jaHJpc3RtYXMtc3Vuc2hpbmUtZG93bmxvYWQtdG9ycmVudC5odG0iPnZvb3JlbWFhPC9hPgo8L3NtYWxsPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LWEtY2hyaXN0bWFzLWNhcm9sLXNpci1qb2huLmh0bSI+Ym9iYnkgcml2ZXJzIHR2OiBub3ZlbWJlciAyMDEyPC9hPgo8L2xpPgo8c21hbGw+SG9ub3Igcm9sbHMgLS0gdXBkYXRlZCBmZWIuIDE5LCAyMDAyIC0gdGhlIGpvdXJuYWwgdGltZXM8L3NtYWxsPgo8c21hbGw+YWx1bWludW0gY2hyaXN0bWFzIHRyZWUgcGljdHVyZXM8L3NtYWxsPgo8bGk+Y2hyaXN0bWFzIGdpZnQgcGV0PC9saT4KPHNtYWxsPm9iYW1hIGdpcmxzIGNocmlzdG1hcyBkcmVzc2VzPC9zbWFsbD4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1tYWRlbGluZS9ndS1jaHJpc3RtYXMtdHJlZS1ub3J3YWxrLW9oaW8uaHRtIj5hYm91dCAtIGhhd2EgJmFtcDsgbWFyY2sgZW5naW5lZXJzPC9hPgo8L3NtYWxsPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1tYWRlbGluZS9ndS1jaHJpc3RtYXMtd29yZHMuaHRtIj5ob2xsb3cgcmlkZ2UgYWNhZGVteSB7b3Blbn0gLSB3YXJyaW9yIGNhdHMgcnBnPC9hPgo8L3N0cmlrZT4KPHN0cmlrZT5Cb29rIG51dDogYXVndXN0IDIwMDk8L3N0cmlrZT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1tYWRlbGluZS9ndS1jaHJpc3RtYXMtaW4tbGViYW5vbi5odG0iPmNocmlzdG1hcyBpbiBsZWJhbm9uPC9hPgo8L2xpPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LWNocmlzdG1hcy1mcmVlLXNoZWV0LW11c2ljLmh0bSI+d2Vsa29tIG9wIGRlIHZlcm5pZXV3ZGUgc2l0ZSB2YW4gbXIyLXBhcnRzLmV1PC9hPgo8L3NtYWxsPgo8c3RyaWtlPlJlY29tbWVuZGVkIC0gYnJvYWR3YXlzdGFycyB8IHVwZGF0ZWQgYnJvYWR3YXkgbmV3cywgZXZlcnk8L3N0cmlrZT4KPHNtYWxsPmNocmlzdG1hcyBhbmdlbHMgY2VudGVycGVpY2VzPC9zbWFsbD4KPHNtYWxsPkdpcmxzIGNvbGxhYiAtIGNsb3NlZCEgYnkgZGlzbmV5LWNsdWIgb24gZGV2aWFudGFydDwvc21hbGw+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtY2VyYW1pYy1jaHJpc3RtYXMtYmFsbHMuaHRtIj5hdWd1c3Qvc2VwdGVtYmVyX3VwLmRhdGVfMTIgLSBzbGlkZXNoYXJlPC9hPgo8L3NtYWxsPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LWNocmlzdG1hcy1hbmQtbmV3LXllYXItZ3JhcGhpY3MuaHRtIj51bmUgYWRtaW5pc3RyYXRyaWNlIC0gYWN0dWFsaXTpcyAtIGNhdXMmIzM5OyB0b3Vqb3VyczwvYT4KPC9zbWFsbD4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1tYWRlbGluZS9ndS1jaHJpc3RtYXMtc25vdy1taW5uZWFwb2xpcy1tbi5odG0iPmNhcmVsZXNzIGxvdmUgZGlnaXRhbCBzaGVldCBtdXNpYyBieSBtYWRlbGVpbmUgcGV5cm91eCAoc2t1OiBoeDwvYT4KPC9zbWFsbD4KPHNtYWxsPkNhbGFt6W8gLSBtb2RlbCBsaWZlIG1hZ2F6aW5lOiBkZWNlbWJlciAyMDEyPC9zbWFsbD4KPHNtYWxsPkZvdG9zIC0gcGZhZGkgZXJkbeRuZGxpIHdhbGxiYWNoPC9zbWFsbD4KPGxpPk1ldGFsIG1pa2V5JiMzOTtzIDEwMC4uLiBvciBob3dldmVyIGxvbmcgaXQmIzM5O2xsIGJlLi4uIHBhZ2Ugc3BlY3RhY3VsYXI8L2xpPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1tYWRlbGluZS9ndS1jaHJpc3RtYXMtbWFpbi1kaXNoLW1lYWxzLmh0bSI+aSBrbm93IGhvdyB0byBjb29rOiBnaW5ldHRlIG1hdGhpb3Q6IDk3ODA3MTQ4NTczNjcgLSBhbWF6b24uY29tPC9hPgo8L3N0cmlrZT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtYmFsbGV0LWNocmlzdG1hcy1zdG9ja2luZy5odG0iPmp1bHkgMjAxNCBuZXdzbGV0dGVyIC0gamFtZXMgbWFkaXNvbiBtZW1vcmlhbCBoaWdoIHNjaG9vbDwvYT4KPC9zdHJpa2U+CjxzdHJpa2U+U2F2b2lyLWZhaXJlIHwgLSAybWF0ZWNoPC9zdHJpa2U+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LWNocmlzdG1hcy1veGZvcmRzaGlyZS5odG0iPmRlYXRoIGJ5IHRoZSBib29rIC0gd2luIGZyZWUgY29waWVzIG9mIGEgbXVyZGVyIG15c3RlcnkhPC9hPgo8L3N0cmlrZT4KPGxpPkpveWZ1bGx5IGJlY2NhOiBqdWx5IDIwMTA8L2xpPgo8bGk+RXYgZ3JpZXZlOiBmcm9tIG1pY2UgdG8gbGVha3MsIGZpcnN0IGhvdXNlcyBhcmUgc2hvd2luZyB0aGVpciBhZ2U8L2xpPgo8c3RyaWtlPmNocmlzdG1hcyBveGZvcmRzaGlyZTwvc3RyaWtlPgo8c3RyaWtlPkJsb2cgLSBrbGV1cmFkdmlzZXVyIC0gaW50ZXJpZXVyIGluc3BpcmF0aWUgfCBtb25hIGNvbG91cnMgLSBnZWVuPC9zdHJpa2U+CjxzbWFsbD5UaGUgbW92aWUgcmVwb3J0IGFyY2hpdmUsIHZvbHVtZSA0MiAtIHRoZW1vdmllcmVwb3J0LmNvbTwvc21hbGw+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LWNocmlzdG1hcy1naWZ0LWZvci1zb21lb25lLXZlcnktc3BlY2lhbC5odG0iPnRoaW5raW5nIG91dCBsb3VkPC9hPgo8L3N0cmlrZT4KPHN0cmlrZT5SYW50cyBmcm9tIG1vbW15bGFuZDogc3dlZXQgdmFsbGV5Li4uIG5vLjwvc3RyaWtlPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LWNocmlzdG1hcy1hZHZlcnRpc2luZy1wYWNrYWdlcy5odG0iPnZvbHVtZSAxMDYgLSB0aGUgcGFjaWZpY2FuPC9hPgo8L3NtYWxsPgo8c21hbGw+SG95YSBsb3ZlIHN0b3JpZXMgLSBnZW9yZ2V0b3duIGFsdW1uaSBvbmxpbmU8L3NtYWxsPgo8c21hbGw+U3RoIGludHJvZHVjdGlvbiCWIHNhaWR1IHRlYWNoaW5nIGhvc3BpdGFsIHN3YXQ8L3NtYWxsPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LXN0ZXBoZW4tY29sYmVydC1jaHJpc3RtYXMtc3BlY2lhbC5odG0iPjkweWVhcnMgb2YgLSB5d2NhIHVzYTwvYT4KPC9zbWFsbD4KPHN0cmlrZT5ScHF1aXogbGlzdCAtIG1vbnRnb21lcnkgY291bnR5IHB1YmxpYyBzY2hvb2xzPC9zdHJpa2U+CjxzdHJpa2U+UmVjb21tZW5kYXRpb25zIHwgbGFkeSBzbXV0PC9zdHJpa2U+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LWEtbmluZS1kb2ctY2hyaXN0bWFzLmh0bSI+c2hhd24gc3BlbmNlciAtIHBzeWNoIHdpa2k8L2E+Cjwvc3RyaWtlPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1tYWRlbGluZS9ndS13aGVuLWlzLWNocmlzdG1hcy1jZWxlYnJhdGVkLWluLWN5cHJ1cy5odG0iPmRvdXggcmV2aWV3czogZGVjZW1iZXIgMjAxMTwvYT4KPC9zdHJpa2U+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LWtpbmNhaWQtY2hyaXN0bWFzLWZsb3JhbC1hcnJhbmdlbWVudHMuaHRtIj5kdWUganVuZSAwODogYSBmZXcgZWdncyBoYXZlIGhhdGNoZWQsIHdlIHdpc2ggdGhlIHJlc3Qgd291bGQgZ2V0PC9hPgo8L3N0cmlrZT4KPHNtYWxsPkZyb20gdGhlIGhlYXJ0Li4uY2hlcnlsIHN0LmpvaG46IGRlY2VtYmVyIDIwMDg8L3NtYWxsPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LWNocmlzdG1hcy1tb3VzZS1ieS1nYXJsYW5kLmh0bSI+Z29pbmcgb24gY2hvcmUgc3RyaWtld3JpdGVyc2RpZ2VzdC5jb20gfCB3cml0ZXJzZGlnZXN0LmNvbTwvYT4KPC9saT4KPHNtYWxsPllhIGhpZ2h3YXk6IG9jdG9iZXIgMjAxMzwvc21hbGw+CjxzbWFsbD5DaHJpczJkL3BhcGVycy9mcmVxMiAtIGNvbXB1dGVyIHNjaWVuY2U8L3NtYWxsPgo8bGk+VGhlcmVnb2VzbW9sbHlyb3NlIHwgdGhlcmUgZ29lcyBtb2xseSByb3NlPC9saT4KPGxpPldlbGxlc2xleSBtYWdhemluZSBzdW1tZXIgMjAxMyAtIHdlbGxlc2xleSBjb2xsZWdlIGRpZ2l0YWw8L2xpPgo8c21hbGw+VGFsZXMgZnJvbSB0aGUgcm93ZSBob3VzZWhvbGQ6IG5vdmVtYmVyIDIwMTQ8L3NtYWxsPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LWNocmlzdG1hcy10cmVlLWZhcm0tY2xlYXZsYW5kLXR4Lmh0bSI+Y2hyaXN0bWFzIHRyZWUgZmFybSBjbGVhdmxhbmQgdHg8L2E+CjwvbGk+CjxzdHJpa2U+VGhlIHdvcmxkIGlzIG15IG95c3RlcjogYXByaWwgMjAxMDwvc3RyaWtlPgo8c3RyaWtlPmNocmlzdG1hcyBzdW5zaGluZSBkb3dubG9hZCB0b3JyZW50PC9zdHJpa2U+CjxzbWFsbD5Qb2UmIzM5O3MgZGVhZGx5IGRhdWdodGVyczogbm92ZW1iZXIgMjAxMDwvc21hbGw+CjxsaT5Db250cm92ZXJzaWFsIGJvb2tzdG9yZSAtIHNhbiBkaWVnbywgY2EgLSBib29rIHN0b3JlIHwgZmFjZWJvb2s8L2xpPgo8bGk+Um9iaW4gaGFzIGFuIGlkZWE6IHNlcHRlbWJlciAyMDEwPC9saT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtZ2lmdC1ib290cy1jaHJpc3RtYXMtaWRlYS5odG0iPmNvbG9yIGRyb3BzIC0gZHJhdyAmYW1wOyBwYWludCAtIGFuZHJvaWQgYXBwcyBvbiBnb29nbGUgcGxheTwvYT4KPC9zdHJpa2U+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtY2hyaXN0bWFzLWVsZWN0cmljLWNvbXBhbnktYnVmZmFsby1ueS5odG0iPmdlbmV2YSB0aGVhdHJlIGd1aWxkIHwgc2RuPC9hPgo8L2xpPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LTMtZnQtcHJlLWxpdC1kZWNvcmF0ZWQtY2hyaXN0bWFzLXRyZWUuaHRtIj5wdXJlIGljZSBoZWFydGJyZWFrZXIgb3ZlciBuaWNvbGUgYnkgb3BpIHRoZSBncmFwZSBkZWJhdGU8L2E+Cjwvc21hbGw+CjxsaT5NYXkgfCAyMDA3IHwgc3R1YXJ0IGJlbmphbWluIGZvcmQ8L2xpPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LXBvbGljZS1jaHJpc3RtYXMtc3RvY2tpbmcuaHRtIj7Ebmdza29sYW5zIGb2cuRsZHJhZvZyZW5pbmcgc2tpY2thciB2eWtvcnQgdGlsbCBwb2xpdGlrZXJuYTwvYT4KPC9saT4KPHNtYWxsPkNvbnRhdHRpIC0gcGFvbG8gbWFsZWRkdSAtIGxpYmVyaWFtbyBsYSBtZW50ZTwvc21hbGw+CjxsaT5Ub3AgYyBvIGQgZXIuIC0gdG9wY29kZXI8L2xpPgo8c3RyaWtlPkZvcndhcmQgcHJvZ3Jlc3MhOiBkZWNlbWJlciAyMDExPC9zdHJpa2U+CjxsaT5DZCBhdWRpb3BoaWxlIGtvcGlhbiBtdXJhaCBtZXJpYWggLSBsYXV0YW4gaW5kb25lc2lhPC9saT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1tYWRlbGluZS9ndS1jaHJpc3RtYXMtaWxsdW1pbmF0ZWQtZ2lmdC1ib3hlcy5odG0iPnRoZSB3b3JraG91c2UgZ3Vlc3Rib29rIDIwMDY8L2E+Cjwvc21hbGw+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtdW5pcXVlLXBlcnNvbmFsLWNocmlzdG1hcy1jYXJkcy5odG0iPnZvbC4geHh4IG5vLiA0IGZlYnJ1YXJ5L21hcmNoLCAyMDEyICQzLjAwIC0gYWxrb3MuY29tPC9hPgo8L3NtYWxsPgo8bGk+U2ltcGxlIHBpY2t1cDwvbGk+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtY2hyaXN0bWFzLWdpZnQtcGV0Lmh0bSI+Y2hyaXN0bWFzIGdpZnQgcGV0PC9hPgo8L3NtYWxsPgo8bGk+SXNzdXUgLSBkZWNlbWJlciA0dGgsIDIwMTQgYnkgMzR0aCBzdHJlZXQgbWFnYXppbmU8L2xpPgo8c3RyaWtlPkJpYmxpb2xhdGhhczoge2J5IG5vIG1lYW5zIGEgcmV2aWV3fSBjaGluYSwgaGV5ZXJpc21zLCAyMDEzPC9zdHJpa2U+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtZWxlZ2FudC1sZWQtY2hyaXN0bWFzLW91dGRvb3ItbGlnaHRzLmh0bSI+aW52ZXN0aWdhdG9yOiBmb3JlaWduZXJzIGJvdWdodCBoYXdhaWkgYmlydGggY2VydGlmaWNhdGVzPC9hPgo8L2xpPgo8c21hbGw+MTk5MC0xMC0wMSAtIGFtZXJpY2FuIGpld2lzaCBhcmNoaXZlczwvc21hbGw+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtZnJlbmNoLWNhbmFkaWFuLWNocmlzdG1hcy1jb2xvcmluZy1wYWdlcy1mcmVlLmh0bSI+cmV2aWV3cyBnZW5lcmFsIHRlc3RpbW9uaWFscyB6enpqbnR5Y2thIDIwMTQtMTItMTgsIDEwOjU5IGNpamZlcjwvYT4KPC9zbWFsbD4KPHNtYWxsPmNocmlzdG1hcyBtdXNpYyByYWRpbyBrZWVuZSBuaDwvc21hbGw+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LWRvbmF0ZS10b3lzLWZvci1jaHJpc3RtYXMtbGV4aW5ndG9uLWt5Lmh0bSI+c2l0ZSBtYXAgfCBiYXJuYWJhcyBoZWFsdGg8L2E+Cjwvc3RyaWtlPgo8c21hbGw+U2ZnaXJsYnliYXk6IDkvMS8wOCAtIDEwLzEvMDg8L3NtYWxsPgo8c21hbGw+TGVnaW9uIG5vaXJlIC0gZ3VpbGRlIGRhcmsgYWdlIG9mIGNhbWVsb3Qgc2VydmV1ciBhbXRlbmFlbDwvc21hbGw+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtY2hyaXN0bWFzLXRyZWUtb2hpby5odG0iPnRoZSB3b3JsZCBvZiBjeWNsaW5nIGFyY2hpdmVzIC0gLSBpbiBzaXR1IHRyYXZlbDwvYT4KPC9saT4KPGxpPkEgbGlnaHQgaW5zaWRlOiBub3ZlbWJlciAyMDEyPC9saT4KPHN0cmlrZT5PcGkgLSBwaW5rIGZyaWRheSB8IHBvbGlzaCBvYnNlc3Npb248L3N0cmlrZT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UteWVzdGVyZGF5J3MtY2hpbGQtY2hyaXN0bWFzLWNhcm9sLmh0bSI+Y2FwaXN0cmFubyB2YWxsZXkgaGlnaCBzY2hvb2w6IG5ld3MgYXJjaGl2ZTwvYT4KPC9zdHJpa2U+CjxzdHJpa2U+V2VsY29tZSB0byBjb25ncmVzc3dvbWFuIG1hZGVsZWluZSBib3JkYWxsbzwvc3RyaWtlPgo8c21hbGw+WW91IGNvb2sgeW91ciBmb29kl3doeSBub3QgeW91ciB0b2JhY2NvPyAtIG55cyBoaXN0b3JpYzwvc21hbGw+CjxsaT5WaXNpdGluZyBsaXR0bGUgbW9yZXRvbiBoYWxsIGluIGNoZXNoaXJlIH4ga2l0dGxpbmc6IGJvb2tzPC9saT4KPHN0cmlrZT5OZXdzbGV0dGVyIC0gdGVtcGxlIGJldGggbWlyaWFtPC9zdHJpa2U+CjxzdHJpa2U+RnVsbCB0ZXh0IG9mICZxdW90O2NhdGFsb2cgb2YgY29weXJpZ2h0IGVudHJpZXMgMTk1MyB1bnB1Ymxpc2hlZCBtdXNpYzwvc3RyaWtlPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1tYWRlbGluZS9ndS1zaXNhbC1jaHJpc3RtYXMtZGVjb3JhdGlvbnMuaHRtIj4xOTcxIHN1cHBsZW1lbnQgdG8gYW1lcmljYW4gZGl2ZXJzaXR5OiBhIGJpYmxpb2dyYXBoeSBvZjwvYT4KPC9zdHJpa2U+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtY2hyaXN0bWFzLWRlY29yYXRpb25zLWRvb3JzLmh0bSI+cnNjIG5ld3MgLSByaW5nd29vZCBzZWNvbmRhcnkgY29sbGVnZTwvYT4KPC9zbWFsbD4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3Utc25vb3B5LXBob3RvLWNocmlzdG1hcy1jYXJkLmh0bSI+c25vb3B5IHBob3RvIGNocmlzdG1hcyBjYXJkPC9hPgo8L3N0cmlrZT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtY2hyaXN0bWFzLWFuZ2Vscy1jZW50ZXJwZWljZXMuaHRtIj5jaHJpc3RtYXMgYW5nZWxzIGNlbnRlcnBlaWNlczwvYT4KPC9zdHJpa2U+CjxsaT5TZWFyY2ggcmVzdWx0cyB8IHd3ZW5kIC0gd29ybGRzIHdpdGhvdXQgZW5kPC9saT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtY2hyaXN0bWFzLXBhZ2VudC1jb3N0dW1lLmh0bSI+Y2hyaXN0bWFzIHBhZ2VudCBjb3N0dW1lPC9hPgo8L3N0cmlrZT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1tYWRlbGluZS9ndS1lbC1zYWx2YWRvci1jaHJpc3RtYXMuaHRtIj5nb29nbGVsaXN0IC0gbWl0PC9hPgo8L2xpPgo8c3RyaWtlPk9jdG9iZXIgLSB0aGUgc2lsdmVyIHNjcmVlbmluZyByb29tPC9zdHJpa2U+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtY2hyaXN0bWFzLWxlaXMuaHRtIj5zYWlyZW40MiAtIHRoZSBvbGQgcmVhZGVyPC9hPgo8L3NtYWxsPgo8bGk+U3RvcmllcyAmYW1wOyBzd2VldGllczogYXByaWwgMjAxMTwvbGk+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtdHJhbnMtc2liZXJpYW4tb3JjaGVzdHJhLXRoaXMtY2hyaXN0bWFzLWRheS5odG0iPmV4cHJpbWVyIHZvdHJlIHBvaW50IGRlIHZ1ZSBzdXIgZGVzIHRo6G1lIC0gdS1seW5rPC9hPgo8L3NtYWxsPgo8bGk+Um9rIGxvayByZWNvcmRzOiBodWdlIHNhbGUgb24gcmVsZWFzZXMvZGlzdHJvIDogY2Fzc2V0dGVjdWx0dXJlPC9saT4KPGxpPlNlcHQuIDE5OTggLSBwaGlsaXBwaW5lIGRlZmVuZGVycyBtYWluPC9saT4KPHN0cmlrZT5MYW1iZXJ0c2xhdGVseS5jb206IGphbnVhcnkgMjAxNTwvc3RyaWtlPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LXRoZS1jaHJpc3RtYXMtbWlyYWNsZS1wZXJzb25hbGl6ZWQtYm9vay5odG0iPmNvbGxlZ2Ugb2YgbG92ZSBtYWtpbmcgLSBlbWJvZGltZW50IG9mIGdvZDwvYT4KPC9saT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtY2hyaXN0bWFzLWZheXJlLW1lbnVzLmh0bSI+ZmFiISBjaGxvZSBmL3cgMjAxMS8yMDEyIGFjY2Vzc29yaWVzLi4uISEhIC0gamVzdGluYSBnZW9yZ2U8L2E+Cjwvc3RyaWtlPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LWNvbXBhbnktY2hyaXN0bWFzLXBhcnR5LW9tYWhhLmh0bSI+Y29tcGFueSBjaHJpc3RtYXMgcGFydHkgb21haGE8L2E+Cjwvc21hbGw+CjxzbWFsbD5EZWNlbWJlciAyMDEzIC0gdGhlIHNjaG9vbCBkaXN0cmljdCBvZiBvbmFsYXNrYTwvc21hbGw+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtY2xvdGhlcy1waW4tY2hyaXN0bWFzLWNyYWZ0cy1mb3Ita2lkcy5odG0iPmRhaXN5IGNoYWluIGJvb2tzICZhbXA7IGJlYXV0eTogYXByaWwgMjAxMTwvYT4KPC9saT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1tYWRlbGluZS9ndS1jaHJpc3RtYXMtcnViYmVyLW1vbGRzLmh0bSI+dGhlIHN3ZWV0IGJvb2tzaGVsZjogamFudWFyeSAyMDEzPC9hPgo8L3NtYWxsPgo8bGk+ZWwgc2FsdmFkb3IgY2hyaXN0bWFzPC9saT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtbHV0aGVyLWNvbGxlZ2UtY2hyaXN0bWFzLWNkLmh0bSI+bGEgcGx1bWUgZGUgbCYjMzk7b3VycyB8IHBoaWxpcHBlIHdhcmQ8L2E+Cjwvc3RyaWtlPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LWNocmlzdG1hcy1jb3VudHktc3BlbGxpbmctYmVlLWNyb3duLWJvb2tzLmh0bSI+YWNjZWxlcmF0ZWQgcmVhZGVyIHRlc3QgbGlzdCByZXBvcnQgdGVzdCBib29rIHJlYWRpbmcgcG9pbnQ8L2E+Cjwvc21hbGw+CjxsaT5SYWRpY2FscyB8IHNlbmlvciBjaXRpemVucyBwdWJsaWMgc3F1YXJlPC9saT4KPHNtYWxsPlN1Y2Nlc3MgaGFiaXRzIHwgc3VjY2VzcyBoYWJpdHMgYXJjaGl2ZXMgLSBsaXZpbmcgc3VjY2Vzc2xpdmluZzwvc21hbGw+CjxzbWFsbD5UaGlzIGNhcmQgaXMgY29vbCAtIG15IGxpZmUgaW4gYmFzZWJhbGwgY2FyZHM6IG9jdG9iZXIgMjAxMTwvc21hbGw+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtZGFpc3ktZHVjay1jaHJpc3RtYXMtb3JuYW1lbnQuaHRtIj5tb250aGx5IGJ1bGxldGluIHN1bmRheSwgbWFyY2ggMTYsIDIwMTQgNTozMCBwbSAtIHNlZWsgYW5kIGZpbmQ8L2E+Cjwvc21hbGw+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtY2Ftb3N1bi1jaHJpc3RtYXMtdG91cm5hbWVudC5odG0iPiYjMTA1ODsmIzEwNzc7JiMxMDg0OyYjMTA3MjsgJiMxMDg5OyYjMTA4NzsmIzEwODY7JiMxMDg4OyYjMTA5MDsgLSAmIzEwNTg7JiMxMDg2OyYjMTA3NDsmIzEwNzI7ICYjMTA4NTsmIzEwNzc7ICYjMTA3NzsgJiMxMDgyOyYjMTA4ODsmIzEwNzI7JiMxMTAzOyYjMTA5MDsgJiMxMDg1OyYjMTA3MjsgJiMxMDQxOyYjMTA3MjsmIzEwODg7JiMxMDg5OyYjMTA3Mjs8L2E+Cjwvc21hbGw+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LWNocmlzdG1hcy1jYWN0dXMtcG9pc29ub3VzLmh0bSI+cGludGVyZXN0IC8gaG9tZSAtIHBhZ2UycnNzPC9hPgo8L3N0cmlrZT4KPHNtYWxsPkFuaW1hdGVkIGZpbG0gcmV2aWV3czogJnF1b3Q7amFjayBhbmQgdGhlIGN1Y2tvby1jbG9jayBoZWFydCZxdW90OyB0cmFpbGVyPC9zbWFsbD4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1tYWRlbGluZS9ndS1nZXJtYW4tY2hyaXN0bWFzLXRyYWRpdGlucy5odG0iPmx1IGJpcmQgYmFieTwvYT4KPC9saT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtaW5kb29yLWFuaW1hdGVkLWNocmlzdG1hcy1maWd1cmluZXMuaHRtIj5hdXRpc20gY2F1Y3VzIG1lbWJlcnNoaXAgfCBjb25ncmVzc21hbiBtaWtlIGRveWxlPC9hPgo8L3N0cmlrZT4KPHNtYWxsPjIwMTItIHdlZWsgMjIgKDMxKSAtIGVuZXdzIHJvb208L3NtYWxsPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LWJlc3QtYWZ0ZXItY2hyaXN0bWFzLXNhbGVzLWluLXNlYXR0bGUuaHRtIj5iZXN0IGFmdGVyIGNocmlzdG1hcyBzYWxlcyBpbiBzZWF0dGxlPC9hPgo8L3NtYWxsPgo8bGk+Q2VkYXIgcG9zdHMgYW5kIGJhcmJlZCB3aXJlIGZlbmNlczogMTIvMS8xMCAtIDEvMS8xMTwvbGk+CjxzdHJpa2U+U2phIGFjY2VsZXJhdGVkIHJlYWRlciB0ZXN0IGxpc3QgLSBzdC4gam9hbiBvZiBhcmMgY2F0aG9saWMgc2Nob29sPC9zdHJpa2U+CjxzbWFsbD5NaXh1cCBtdXNpYyBzdG9yZTwvc21hbGw+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LXdpZXJkZXN0LWNocmlzdG1hcy1naWZ0cy5odG0iPndpZXJkZXN0IGNocmlzdG1hcyBnaWZ0czwvYT4KPC9zdHJpa2U+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3Utcml0ei1jYXJsdG9uLXBlbnRhZ29uLWNpdHktdmlyZ2luaWEtY2hyaXN0bWFzLmh0bSI+Zmlyc3QgYmxvZyBwb3N0IC0gZW5lcmNvbiBlbmdpbmVlcmluZzwvYT4KPC9zbWFsbD4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1tYWRlbGluZS9ndS1jcmVkaXQtdW5pb24tY2hyaXN0bWFzLXBhZWdlbnQuaHRtIj5jcmVkaXQgdW5pb24gY2hyaXN0bWFzIHBhZWdlbnQ8L2E+Cjwvc21hbGw+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtY2hyaXN0bWFzLXRyZWUtcmVjeWNsZS1tb29yZXN2aWxsZS1pcmVkZWxsLmh0bSI+YmVpbmcgYmFpbGV5IGo6IDEwLjEyPC9hPgo8L2xpPgo8c3RyaWtlPm5lb3BldHMgY2hyaXN0bWFzIHBsdXNoaWU8L3N0cmlrZT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1tYWRlbGluZS9ndS1jaHJpc3RtYXMtYW5nZWxzLWNlbnRlcnBlaWNlcy5odG0iPmRlY2VtYmVyIDE4LCAyMDEwIC0gbWFycXVldHRlIHN5bXBob255IG9yY2hlc3RyYTwvYT4KPC9zbWFsbD4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1tYWRlbGluZS9ndS1jaHJpc3RtYXMtYW5pbWF0ZWQtbXVzY2FsLWJvb2tzLmh0bSI+ZG93bmxvYWQgLSB0aGVzZXM8L2E+CjwvbGk+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtY2hyaXN0bWFzLW1vdXNlLWJ5LWdhcmxhbmQuaHRtIj5nYWJpIGNvYXRzd29ydGggfCBsaWZlIG9uIHRoZSBsaWdodGVyIHNpZGUgliB3aXRoIGEgYnJpdGlzaCB0d2lzdDwvYT4KPC9zbWFsbD4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1tYWRlbGluZS9ndS1jaHJpc3RtYXMtYmVyZWF1Lmh0bSI+Y2xhc3NpYyBmaWxtIGFuZCB0diBjYWbpOiBjbGFzc2ljIHR2IHNjaWVuY2UgZmljdGlvbiBhIHRvIHo8L2E+Cjwvc21hbGw+CjxzdHJpa2U+T25lIHRlYXNwb29uIG11c3RhbmcgYm95ZnJpZW5kIGplYW5zIC0gcGludGVyZXN0PC9zdHJpa2U+CjxzbWFsbD5Sb290IHRlc3QgYWRtaW4gb3JhY2xlIHVzZXIgZ3Vlc3QgYSBwb3N0Z3JlcyBuYWdpb3MgbXlzcWwgZnRwPC9zbWFsbD4KPHNtYWxsPkFuc3dlciAtIHVuaXZlcnNpdHkgb2YgaWxsaW5vaXMgYXQgdXJiYW5hLWNoYW1wYWlnbjwvc21hbGw+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtZnVubnktY2hyaXN0bWFzLXBpdHVyZXMuaHRtIj50aGUgdW5pb24ga2l0Y2hlbiAtIGJyYWVzd29vZCBwbGFjZSAtIGhvdXN0b24sIHR4IHwgeWVscDwvYT4KPC9zbWFsbD4KPHNtYWxsPlRoZSBnZWFyIHBvc3QgfCB0aGUgcnVubmVyJiMzOTtzIGtpdGNoZW48L3NtYWxsPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LWNocmlzdG1hcy1saWdodGluZy1kZWNvcmF0aW9ucy5odG0iPnlhIG1pc2ZpdHM8L2E+CjwvbGk+CjxzdHJpa2U+Q29tZW504XJpb3M8L3N0cmlrZT4KPHNtYWxsPlJlcCBib3JkYWxsbywgbWFkZWxlaW5lIHouIC0gYmlsbCBzdW1tYXJ5ICZhbXA7IHN0YXR1cyBzZWFyY2ggcmVzdWx0czwvc21hbGw+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LXRvdGVtaWMtaGFsaWJ1dC1jaHJpc3RtYXMtb3JuYW1lbnQuaHRtIj5tMTkxMSBwaXN0b2wgc2VyaWVzIC0gaW50ZXJuZXQgbW92aWUgZmlyZWFybXMgZGF0YWJhc2UgLSBndW5zIGluPC9hPgo8L3N0cmlrZT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtZ29zcGVsLXRyYWN0LWEtY2hyaXN0bWFzLWNhcm9sLmh0bSI+Y2hpY2sgbGl0IHVuY292ZXJlZDoganVseSAyMDE0PC9hPgo8L3N0cmlrZT4KPHNtYWxsPk5pY2sgZGlhbW9uZHMgLSBicm9va2x5bnZlZ2FuPC9zbWFsbD4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1tYWRlbGluZS9ndS1oZWxsby1raXR0eS1jaHJpc3RtYXMtaW1hZ2VzLmh0bSI+aGVsbG8ga2l0dHkgY2hyaXN0bWFzIGltYWdlczwvYT4KPC9saT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1tYWRlbGluZS9ndS1tZXJyeS1jaHJpc3RtYXMtaW4taGF3YWlpLXNvbmcuaHRtIj4yMDEzIGFubnVhbCBtZWV0aW5nICZhbXA7IGNsZSAtIGNsYXJrIGNvdW50eSBiYXIgYXNzb2NpYXRpb248L2E+Cjwvc21hbGw+CjxzbWFsbD5jb21wYW55IGNocmlzdG1hcyBwYXJ0eSBvbWFoYTwvc21hbGw+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3Uta25pdC1jcm9jaGV0LWNocmlzdG1hcy10cmVlLWRlY29yYXRpb25zLmh0bSI+YnJlYWQgY3VwcyByZXZpZXdzIC0gb25saW5lIHNob3BwaW5nIHJldmlld3Mgb24gYnJlYWQgY3VwczwvYT4KPC9zbWFsbD4KPHNtYWxsPmNocmlzdG1hcyBjYWN0dXMgcG9pc29ub3VzPC9zbWFsbD4KPHN0cmlrZT5MZWFybmluZyBtYXRlcmlhbCAtIGFib29raG91c2UuY29tICYjNjUyOTM7IHlvdXIgZmF2b3JpdGUgb25saW5lPC9zdHJpa2U+CjxsaT5CdXlmdXJuaXR1cmVvbmxpbmUmIzEyMzk4OyYjMTI1MDI7JiMxMjUyNTsmIzEyNDY0OyAtICYjMTI1MjE7JiMxMjQ1MjsmIzEyNTAyOyYjMTI0ODk7JiMxMjQ1MDsmIzEyNTAyOyYjMTI1MjU7JiMxMjQ2NDsgLSBsaXZlZG9vcjwvbGk+CjxzbWFsbD5Ub3RhbCBjb21tYW5kZXIguyBkb3dubG9hZCC7IHdjeCBwbHVnaW5zILsgZ2FtZSBhcmNoaXZlczwvc21hbGw+CjxzdHJpa2U+Q2FsaWJhbiYjMzk7cyByZXZlbmdlOiB0aGUgdGhhbmtzZ2l2aW5nIGJpZyBiYWQtbW92aWUgZXh0cmF2YWdhbnphPC9zdHJpa2U+CjxzdHJpa2U+RnJlZSBuZXcgc2Nob29sIGhvbWUgY291bnR5IG9ubGluZSBseXJpY3MgZG93bmxvYWQ8L3N0cmlrZT4KPHNtYWxsPlRodXJzZGF5LCBzZXB0ZW1iZXIgMzB0aCwgMjAxMCAtIGN5bm9wc2lzIG1lZGlhY3lub3BzaXMgbWVkaWE8L3NtYWxsPgo8bGk+VHdvIHllYXJzIGFmdGVyIHRiZCBsYXVuY2hlZCwgdGhlICN0YmRpYXNwb3JhIGFyZSBkb2luZyBvayB8IHRoZTwvbGk+CjxzbWFsbD5Gb3VyLXllYXItb2xkIGRhbmllbCBwZWxrYSB3YXMgYmVhdGVuIGFuZCBzdGFydmVkIHRvIGRlYXRoIGJ1dDwvc21hbGw+CjxsaT4yMDEzIG1heSBwcmFkYSBwcmVzY3JpcHRpb24gZ2xhc3NlcyAxMTIgc2FuIGZyYW5jaXNjbyAtIGxvZ288L2xpPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LW1lcnJ5LWNocmlzdG1hcy1mcm9tLW9iYW1hLmh0bSI+a3VuZ2Z1LWJsYXppa2VuJiMzOTtzIGRldmlhbnRhcnQgZmF2b3VyaXRlczwvYT4KPC9zbWFsbD4KPHNtYWxsPkkgYW0uLi4gaC4gcmFqdSAtIHdvcmxkbmV3czwvc21hbGw+CjxzbWFsbD5jYW1vc3VuIGNocmlzdG1hcyB0b3VybmFtZW50PC9zbWFsbD4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtY2hyaXN0bWFzLWZyZWUtc2hlZXQtbXVzaWMuaHRtIj5jaHJpc3RtYXMgZnJlZSBzaGVldCBtdXNpYzwvYT4KPC9zdHJpa2U+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LTEyLWRheXMtb2YtY2hyaXN0bWFzLW9yaWdpb25hbC5odG0iPnNjaG9sYXN0aWMgYXJ0ICZhbXA7IHdyaXRpbmcgYXdhcmRzIG9mIDIwMTMuPC9hPgo8L3N0cmlrZT4KPHN0cmlrZT5CdXR0ZXJwYXBlcjogYnVpbGRpbmdzOiBhdXN0cmFsaWE8L3N0cmlrZT4KPHN0cmlrZT5DaGF0dGVyIGJ1c3k6IG5vdmVtYmVyIDIwMTQ8L3N0cmlrZT4KPHNtYWxsPlVzIGVyLyBqcyBsdHRlcnkvIHRoZSBvLTcvcyBhIG5zIC0gc2Nob29sIG9mIGNvbXB1dGVyIHNjaWVuY2U8L3NtYWxsPgo8bGk+TWV0IGluIGVsZXZlbjogZGVjZW1iZXIgMjAxNDwvbGk+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtY2hyaXN0bWFzLWNvbG9yaW5nLXNoZWV0cy5odG0iPmNocmlzdG1hcyBjb2xvcmluZyBzaGVldHM8L2E+CjwvbGk+CjxzdHJpa2U+YmVzdCBjaHJpc3RtYXMgcGFnZWFudCBldmVyIHJlc291cmNlczwvc3RyaWtlPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LW1lcnJ5LWNocmlzdG1hcy1pbi1oYXdhaWktc29uZy5odG0iPmVzcGVjaWFsbHkgYmVuOiA3LzEvMTEgLSA4LzEvMTE8L2E+CjwvbGk+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtMTItZGF5cy1vZi1jaHJpc3RtYXMtY2FuYWRhLWJyb3RoZXJzLmh0bSI+MTIgZGF5cyBvZiBjaHJpc3RtYXMgY2FuYWRhIGJyb3RoZXJzPC9hPgo8L3NtYWxsPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LWJlc3QtY2hyaXN0bWFzLXBhZ2VhbnQtZXZlci1yZXNvdXJjZXMuaHRtIj5ib2FyZHdhbGsgZW1waXJlOiBmYXJld2VsbCBkYWRkeSBibHVlcyB8IGxlYmVhdSYjMzk7cyBsZSBibG9nPC9hPgo8L2xpPgo8bGk+Y2hyaXN0bWFzIGluIGxlYmFub248L2xpPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1tYWRlbGluZS9ndS11c2VzLWZvci11c2VkLWNocmlzdG1hcy1jYXJkcy5odG0iPm9yYW5nZSBzaW5rOiBhdWd1c3QgMjAwOTwvYT4KPC9zdHJpa2U+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtY29va2luZy1nYW1lcy1mb3ItY2hyaXN0bWFzLmh0bSI+YWxpZW4gcm9ib3Qgem9tYmllIGZpbG0gbGlzdCAtIGFsaWVuIHJvYm90IHpvbWJpZXM8L2E+CjwvbGk+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtdGhlLXNpbmdpbmctY2hyaXN0bWFzLXRyZWUtd2EuaHRtIj50aGUgY291bnRyeSBibG9zc29tOiBqdW5lIDIwMTE8L2E+CjwvbGk+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtbmVvcGV0cy1jaHJpc3RtYXMtcGx1c2hpZS5odG0iPnN3b29uPC9hPgo8L2xpPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LW11cHBldHMtY2hyaXN0bWFzLWNhcm9sLmh0bSI+Y29uZ3JhdHVsYXRpb25zIDIwMTMgbmF0aW9uYWwgbWVkYWwgd2lubmVycyEgLSBzY2hvbGFzdGljIG1lZGlhPC9hPgo8L3NtYWxsPgo8c3RyaWtlPkFsZnJlZCBoaXRjaGNvY2sgZ2VlazoganVseSAyMDExPC9zdHJpa2U+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3Utb2JhbWEtZ2lybHMtY2hyaXN0bWFzLWRyZXNzZXMuaHRtIj5vYmFtYSBnaXJscyBjaHJpc3RtYXMgZHJlc3NlczwvYT4KPC9saT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtY2hyaXN0bWFzLXBhcnR5LWlkZWFzLmh0bSI+ZnJlZWRvbSBnYXpldHRlIC0gbG91ZG91biBjb3VudHkgcHVibGljIHNjaG9vbHM8L2E+Cjwvc3RyaWtlPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LWFsdW1pbnVtLWNocmlzdG1hcy10cmVlLXBpY3R1cmVzLmh0bSI+b289PT0gYXJlbmEgY29zcGxheSBsaXN0ID09PW9vIFtjbG9zZWRdIG5ldyB0aHJlYWQgfCBmaXJzdCBwYWdlPC9hPgo8L2xpPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LWNvYXN0LWd1YXJkLWNocmlzdG1hcy1naWZ0cy5odG0iPmZlbHQgaGF0cyB8IGViYXk8L2E+Cjwvc21hbGw+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtZnJlZS1jaHJpc3RtYXMtcGFpbnRpbmctcGF0dGVybnMuaHRtIj5wbGF5c3RhdGlvbiAyIHByaWNlIGxpc3QgaW4gY2hlbm5haSAtIHBsYXlzdGF0aW9uIDQgbmV3IGluZm88L2E+Cjwvc21hbGw+CjxzdHJpa2U+Q29waWVzIG9mIGluY29tZSB0YXggYmxhbmtzIGhhdmUgYmVlbiBzZW50IHRvIC0gZGlnaWZpbmQtaXQuY29tPC9zdHJpa2U+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtZ2FtZXMtZm9yLWNvbXBhbnktY2hyaXN0bWFzLXBhcnRpZXMuaHRtIj50ZW1wbGUgdGlrdmFoIGEgY2VudGVyIGZvciByZWZvcm0ganVkYWlzbTwvYT4KPC9saT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1tYWRlbGluZS9ndS1jaHJpc3RtYXMtcGxheXMtbWlubmVzb3RhLWNvbGxlZ2VzLmh0bSI+cGxlYXNlIHN0YXkgcHJvcGVybHkgaHlkcmF0ZWQgYW5kIG5vdXJpc2hlZCBhcyB5b3UgcGVydXNlIGxpbmtpdHk8L2E+CjwvbGk+CjxzdHJpa2U+NSAvIC0gamFtZXMgbWFkaXNvbiBtZW1vcmlhbCBoaWdoIHNjaG9vbCAtIG1hZGlzb24gbWV0cm9wb2xpdGFuPC9zdHJpa2U+CjxsaT5IZW1pbmd3YXkmIzM5O3MgZWFybHkgbGlmZSCWIGEgY29udmVyc2F0aW9uIHdpdGggaGVtaW5nd2F5JiMzOTtzPC9saT4KPGxpPkhlcmUgLSB0aGUga29vdGVuYXkgc2Nob29sIG9mIHdyaXRpbmc8L2xpPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LXdlc3QtaW5kaWFuLWNocmlzdG1hcy1zb25ncy5odG0iPmNocmlzdG1hcyAyMDEzIHBhZ2UgMyAtIG11bHRpdmVyc2UgY3Jpc2lzIG11c2g8L2E+CjwvbGk+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LXZpcmdpbmlhLWNob29zZS1hbmQtY3V0LWNocmlzdG1hcy10cmVlcy5odG0iPnZpcmdpbmlhIGNob29zZSBhbmQgY3V0IGNocmlzdG1hcyB0cmVlczwvYT4KPC9zdHJpa2U+CjxzbWFsbD5Eb3Rsb2dpY3M8L3NtYWxsPgo8bGk+QSBjYXJkYm9hcmQgcHJvYmxlbTogbm92ZW1iZXIgMjAwODwvbGk+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LWFkYW0tc2FuZGxlci1qZXdpc2gtY2hyaXN0bWFzLWx5cmljcy5odG0iPmNkIGF1ZGlvcGhpbGUgbGlzdCAtIHNjcmliZDwvYT4KPC9zdHJpa2U+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LWNocmlzdG1hcy1tdXNpYy1yYWRpby1rZWVuZS1uaC5odG0iPnBsYXlsaXN0cyB8IHd0bWQ8L2E+Cjwvc3RyaWtlPgo8c3RyaWtlPldoZXJlIHlvdSB3aXNoIHVwb24gYSBzdGFyOiBqdW5lIDIwMTA8L3N0cmlrZT4KPHNtYWxsPkhvcGUmIzM5O3MgYmxvZzwvc21hbGw+CjxzbWFsbD5TaHMgbm92ZW1iZXIgbmV3c2xldHRlciAtIHNvbG9uIGNpdHkgc2Nob29sczwvc21hbGw+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtbWFkZWxpbmUvZ3UtY2hyaXN0bWFzLWluc2lyYXRpb24tcXVvdGVzLmh0bSI+MyAtIGZyb2csIGdvb3NlIGFuZCBiZWFyIJYgcmVjaXBlcywgY3JhZnQgYW5kIHBhcnR5IGlkZWFzPC9hPgo8L3NtYWxsPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW1hZGVsaW5lL2d1LXNvdWwtY2hyaXN0bWFzLmh0bSI+anVzdCBwbGFpbiBmb2xrcyBtdXNpYyBvcmdhbml6YXRpb24gbWVzc2FnZSBib2FyZHM6IGNhbGlmb3JuaWEganBmPC9hPgo8L2xpPgo8c3RyaWtlPlRoZSB0aGlua2VyIGJlbGxlOiBmYW5naXJsIGF0IGhlciBiZXN0OiBhZGRpY3Rpb24gdG8gbm92ZWwgOiBkbyB5b3U/PC9zdHJpa2U+CjxzdHJpa2U+TGl2aW5nIG9mZiBzY3JpcHQ6IGphbnVhcnkgMjAxMzwvc3RyaWtlPgo8c3RyaWtlPkNsYXNpZmljYWRvcyAtIHNlbWFuYXJpbyBtaSBlc3BhY2lvIC0gaW5pY2lvIC0gc2VtYW5hcmlvIG1pIGVzcGFjaW88L3N0cmlrZT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1tYWRlbGluZS9ndS1hcHBhbG9vc2EtY2hyaXN0bWFzLW9ybmFtZW50Lmh0bSI+cnVzaGxlaWdoIH4gdGhlIGF0IGhvbWUgY2hyb25pY2xlOiBjaHJpc3RtYXMgZ2lmdHMgfiB0aHJpZnR5LCBlY288L2E+Cjwvc21hbGw+CjxzbWFsbD48aDE+TWFkZWxpbmUvZ3UgQmxhbmsgQ2hyaXN0bWFzIFdpc2ggTGlzdDwvaDE+PC9zbWFsbD4KCgo8aHI+CgpNYWRlbGluZS9ndSBibGFuayBjaHJpc3RtYXMgd2lzaCBsaXN0Cg==