PCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9JRVRGLy9EVEQgSFRNTCAyLjAvL0VOIj4KPEhUTUw+PEhFQUQ+CjxUSVRMRT5Sb3RhdGluZyBjaHJpc3RtYXMgdHJlZSBzdGFuZCByZXBsYWNlbWVudCBwYXJ0czwvVElUTEU+CjwvSEVBRD48Qk9EWT4KCjxoMT5Sb3RhdGluZyBjaHJpc3RtYXMgdHJlZSBzdGFuZCByZXBsYWNlbWVudCBwYXJ0czwvaDE+Cgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXJvdGF0aW5nLWNocmlzdG1hcy10cmVlLXN0YW5kLXJlcGxhY2VtZW50LXBhcnRzLmh0bS90ZXN0L3dwLWFkbWluL2d1LWNocmlzdG1hcy10cmVlLW5vcndhbGstb2hpby5odG0iPmNocmlzdG1hcyB0cmVlIG5vcndhbGsgb2hpbzwvYT4KPC9zbWFsbD4KPHNtYWxsPkNocmlzdG1hcyB0cmVlIHN0YW5kIHRpcHMsIHJldm9sdmluZyAtIGNocmlzdG1hcyB0cmVlIHRpcHM8L3NtYWxsPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXJvdGF0aW5nLWNocmlzdG1hcy10cmVlLXN0YW5kLXJlcGxhY2VtZW50LXBhcnRzLmh0bS90ZXN0L3dwLWFkbWluL2d1LWNocmlzdG1hcy1pbGx1bWluYXRlZC1naWZ0LWJveGVzLmh0bSI+Y2hyaXN0bWFzIGlsbHVtaW5hdGVkIGdpZnQgYm94ZXM8L2E+CjwvbGk+CjxzdHJpa2U+Q2hyaXN0bWFzIHRyZWUgc3RhbmRzIHwgd2F5ZmFpciBzdXBwbHk8L3N0cmlrZT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3Utcm90YXRpbmctY2hyaXN0bWFzLXRyZWUtc3RhbmQtcmVwbGFjZW1lbnQtcGFydHMuaHRtL3Rlc3Qvd3AtYWRtaW4vZ3UtYS1jaGlsZCdzLWNocmlzdG1hcy1yaWNreS16YWhuZC5odG0iPmEgY2hpbGQncyBjaHJpc3RtYXMgcmlja3kgemFobmQ8L2E+Cjwvc3RyaWtlPgo8bGk+VHJpbSBhIGhvbWWuIC0gcy1wOTA1MTAgLSByb3RhdGluZyBhcnRpZmljaWFsIGNocmlzdG1hcyB0cmVlIHN0YW5kPC9saT4KPHNtYWxsPlByZS1saXQgY2hyaXN0bWFzIHRyZWUgbGlnaHRzIG5vdCB3b3JraW5nIHwgdGhyaWZ0eWZ1bjwvc21hbGw+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXJvdGF0aW5nLWNocmlzdG1hcy10cmVlLXN0YW5kLXJlcGxhY2VtZW50LXBhcnRzLmh0bS90ZXN0L3dwLWFkbWluL2d1LWNocmlzdG1hcy1wb3RhdG9lcy5odG0iPnJldm9sdmluZyBjaHJpc3RtYXMgdHJlZSBzdGFuZC4gZ2VybWFuIG11c2ljYWwgYW5kIHJvdGF0aW5nPC9hPgo8L3N0cmlrZT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3Utcm90YXRpbmctY2hyaXN0bWFzLXRyZWUtc3RhbmQtcmVwbGFjZW1lbnQtcGFydHMuaHRtL3Rlc3Qvd3AtYWRtaW4vZ3UtY2hyaXN0bWFzLWluLW5vcnRoLWFtZXJpY2FuLmh0bSI+Y2hyaXN0bWFzIHRyZWUgc3RhbmRzICZhbXA7IGFjY2Vzc29yaWVzIC0gbHVuYWRhIGJheSBoYXJkd2FyZTwvYT4KPC9zdHJpa2U+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXJvdGF0aW5nLWNocmlzdG1hcy10cmVlLXN0YW5kLXJlcGxhY2VtZW50LXBhcnRzLmh0bS90ZXN0L3dwLWFkbWluL2d1LWNocmlzdG1hcy1zdG9yaWVzLWFuZC1wb2Vtcy1hbmQtaHVtb3IuaHRtIj4yNCZxdW90OyBwb3dlcmZ1bCByb3RhdGluZyBpbmRvb3IgY2hyaXN0bWFzIHRyZWUgc3RhbmQgLSBmb3IgbGlnaHRlZDwvYT4KPC9zdHJpa2U+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXJvdGF0aW5nLWNocmlzdG1hcy10cmVlLXN0YW5kLXJlcGxhY2VtZW50LXBhcnRzLmh0bS90ZXN0L3dwLWFkbWluL2d1LWNocmlzdG1hcy1tdXNpYy1kZW1vLXN1Ym1pc3Npb25zLmh0bSI+NmZ0LiByb3RhdGluZyBjaHJpc3RtYXMgdHJlZSBmb3IgaGFsZiBwcmljZSB8IG90aGVyIGhvbWUgZGVjb3I8L2E+Cjwvc3RyaWtlPgo8bGk+Rm9sZXkgZW5naW5lcyB8IDEwMCB5ZWFycyBvZiBleHBlcnQgYWR2aWNlPC9saT4KPHNtYWxsPlRyZWVzdGFuZHMgJmFtcDsgYmxpbmRzIHwgZGVlciBzdGFuZHMsIGRlZXIgYmxpbmRzLCB0cmlwb2Qgc3RhbmQsIGR1Y2s8L3NtYWxsPgo8c21hbGw+RmVzdGl2ZSBmb2xpYWdlIHNwaW5uZXJzIDogY2hyaXN0bWFzIHRyZWUgYWNjZXNzb3JpZXMgLSB0cmVuZCBodW50ZXI8L3NtYWxsPgo8c21hbGw+SGVpcmxvb20gcm90YXRpbmcgbXVzaWNhbCBjaHJpc3RtYXMgdHJlZSBzdGFuZHMgfCBmYWNlYm9vazwvc21hbGw+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXJvdGF0aW5nLWNocmlzdG1hcy10cmVlLXN0YW5kLXJlcGxhY2VtZW50LXBhcnRzLmh0bS90ZXN0L3dwLWFkbWluL2d1LWNocmlzdG1hcy1nYXJuaXNoLmh0bSI+Y2hyaXN0bWFzIGdhcm5pc2g8L2E+Cjwvc3RyaWtlPgo8c3RyaWtlPkNoZWFwIGFwcGxlIGFjY2Vzc29yaWVzIG9ubGluZSB8IGFwcGxlIGFjY2Vzc29yaWVzIGZvciAyMDE3PC9zdHJpa2U+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXJvdGF0aW5nLWNocmlzdG1hcy10cmVlLXN0YW5kLXJlcGxhY2VtZW50LXBhcnRzLmh0bS90ZXN0L3dwLWFkbWluL2d1LWhhbGxtYXJrLWZyZWUtY2hyaXN0bWFzLWNhcmRzLmh0bSI+aGFsbG1hcmsgZnJlZSBjaHJpc3RtYXMgY2FyZHM8L2E+Cjwvc3RyaWtlPgo8c3RyaWtlPlZpbnRhZ2Ugc3BpbmNyYWZ0IGhlaXJsb29tIHJvdGF0aW5nIG11c2ljYWwgY2hyaXN0bWFzIHRyZWU8L3N0cmlrZT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3Utcm90YXRpbmctY2hyaXN0bWFzLXRyZWUtc3RhbmQtcmVwbGFjZW1lbnQtcGFydHMuaHRtL3Rlc3Qvd3AtYWRtaW4vZ3Utc2liZXJpYW4tY2hyaXN0bWFzLmh0bSI+dmlwZXIgaHN0IDYtMjR4NTAgdm1yLTEgLSB2b3J0ZXggb3B0aWNzPC9hPgo8L3N0cmlrZT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3Utcm90YXRpbmctY2hyaXN0bWFzLXRyZWUtc3RhbmQtcmVwbGFjZW1lbnQtcGFydHMuaHRtL3Rlc3Qvd3AtYWRtaW4vZ3UtY2hyaXN0bWFzLXBvd2VycG9pbnQtamVvcGFyZHktdGVtcGxhdGUuaHRtIj5iYWxzYW0gc3BydWNlIHJvdGF0aW5nIGNocmlzdG1hcyB0cmVlIHwgdHJlZXRvcGlhPC9hPgo8L3N0cmlrZT4KPHNtYWxsPlJvdGF0aW5nIGNocmlzdG1hcyB0cmVlIHN0YW5kIHBhcnRzLiBhcnRpZmljaWFsIHVwc2lkZSBkb3duPC9zbWFsbD4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1yb3RhdGluZy1jaHJpc3RtYXMtdHJlZS1zdGFuZC1yZXBsYWNlbWVudC1wYXJ0cy5odG0vdGVzdC93cC1hZG1pbi9ndS1hLW5pbmUtZG9nLWNocmlzdG1hcy5odG0iPnNjaWVudGlmaWMgYW1lcmljYW4gLSBnb29nbGUgYm9va3MgcmVzdWx0PC9hPgo8L3NtYWxsPgo8c21hbGw+Q2hyaXN0bWFzIHRyZWUgc3RhbmRzIC0gc3RvcmFnZSAmYW1wOyB0cmVlIHN0YW5kcyAtIHRoZSBob21lIGRlcG90PC9zbWFsbD4KPGxpPlJvcmF0ZSBjxmxpPC9saT4KPHN0cmlrZT5Sb3RhdGluZyBhcnRpZmljaWFsIHRyZWUgc3RhbmQgLSBsb3dlcyBob2xpZGF5PC9zdHJpa2U+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXJvdGF0aW5nLWNocmlzdG1hcy10cmVlLXN0YW5kLXJlcGxhY2VtZW50LXBhcnRzLmh0bS90ZXN0L3dwLWFkbWluL2d1LWJlYWQtY2hyaXN0bWFzLWNyYWZ0Lmh0bSI+ZGVsaWNhdGUgNi4waW5jaCBmb3IgYWxjYXRlbCBvbmUgdG91Y2ggcGl4aSA0IG90LTgwNTBkIG90ODA1MDwvYT4KPC9zdHJpa2U+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3Utcm90YXRpbmctY2hyaXN0bWFzLXRyZWUtc3RhbmQtcmVwbGFjZW1lbnQtcGFydHMuaHRtL3Rlc3Qvd3AtYWRtaW4vZ3Utc25vb3B5J3MtY2hyaXN0bWFzLWNkLmh0bSI+c25vb3B5J3MgY2hyaXN0bWFzIGNkPC9hPgo8L3NtYWxsPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXJvdGF0aW5nLWNocmlzdG1hcy10cmVlLXN0YW5kLXJlcGxhY2VtZW50LXBhcnRzLmh0bS90ZXN0L3dwLWFkbWluL2d1LWNocmlzdG1hcy10cmFjZXMuaHRtIj5jcmVhdGl2ZWx5IGNocmlzdG1hczogaW5zcGlyZWQgeXVsZXRpZGUgZOljb3IgLSBnb29nbGUgYm9va3MgcmVzdWx0PC9hPgo8L2xpPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXJvdGF0aW5nLWNocmlzdG1hcy10cmVlLXN0YW5kLXJlcGxhY2VtZW50LXBhcnRzLmh0bS90ZXN0L3dwLWFkbWluL2d1LWNhc2luby10aGVtZWQtY2hyaXN0bWFzLXRyZWUuaHRtIj5jbG90aGVzbGluZXMgYXZhaWxhYmxlIGZyb20gYnVubmluZ3Mgd2FyZWhvdXNlIHwgYnVubmluZ3M8L2E+Cjwvc21hbGw+CjxsaT5sYXN0ciBjaHJpc3RtYXMgd2hhbTwvbGk+CjxsaT5UZWFsaWdodCBob2xkZXIgfCBjYW5kbGUgaG9sZGVycyB8IGpvaG4gbGV3aXM8L2xpPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1yb3RhdGluZy1jaHJpc3RtYXMtdHJlZS1zdGFuZC1yZXBsYWNlbWVudC1wYXJ0cy5odG0vdGVzdC93cC1hZG1pbi9ndS12aWRlby1zdG9yZXMtaW4tY2hyaXN0bWFzLWZsLWZsb3JpZGEuaHRtIj5rcmVza3kga2Fyb3NlbCBtdXNpY2FsIHJvdGF0aW5nIGNocmlzdG1hcyB0cmVlPC9hPgo8L3N0cmlrZT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1yb3RhdGluZy1jaHJpc3RtYXMtdHJlZS1zdGFuZC1yZXBsYWNlbWVudC1wYXJ0cy5odG0vdGVzdC93cC1hZG1pbi9ndS1wcmludGFibGUtbWVycnktY2hyaXN0bWFzLWNhcmRzLmh0bSI+Y2hyaXN0bWFzIHRyZWUgcm90YXRpbmcgc3RhbmRzIC0gbmV3dG9uIHZpZGVvczwvYT4KPC9zbWFsbD4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1yb3RhdGluZy1jaHJpc3RtYXMtdHJlZS1zdGFuZC1yZXBsYWNlbWVudC1wYXJ0cy5odG0vdGVzdC93cC1hZG1pbi9ndS1vYmFtYS1uby1jaHJpc3RtYXMtdHJlZS5odG0iPmNocmlzdG1hcyB0cmVlIHN0YW5kcyAmYW1wOyBhY2Nlc3NvcmllcyAtIGRvbmdoaWEgbHVtYmVyPC9hPgo8L2xpPgo8bGk+Y2hyaXN0bWFzIHRlbXBvcmFyeSBoZWxwIGRldHJvaXQgbWljaGlnYW48L2xpPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1yb3RhdGluZy1jaHJpc3RtYXMtdHJlZS1zdGFuZC1yZXBsYWNlbWVudC1wYXJ0cy5odG0vdGVzdC93cC1hZG1pbi9ndS1jaHJpc3RtYXMtY3JhZnRzLXRyZWUuaHRtIj5taWx3YXVrZWUgZnJlZSBzdHVmZiAtIGNyYWlnc2xpc3Q8L2E+Cjwvc3RyaWtlPgo8bGk+V2VzdGVybiBlbGVjdHJpY2lhbiAtIGdvb2dsZSBib29rcyByZXN1bHQ8L2xpPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXJvdGF0aW5nLWNocmlzdG1hcy10cmVlLXN0YW5kLXJlcGxhY2VtZW50LXBhcnRzLmh0bS90ZXN0L3dwLWFkbWluL2d1LWF1c3RyYWxpYW4tMTItZGF5cy1vZi1jaHJpc3RtYXMtc29uZy5odG0iPnZpbnRhZ2Ugcm90YXRpbmcgY2hyaXN0bWFzIHRyZWUgc3RhbmQgJiM4MjExOyBldHN5PC9hPgo8L3NtYWxsPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXJvdGF0aW5nLWNocmlzdG1hcy10cmVlLXN0YW5kLXJlcGxhY2VtZW50LXBhcnRzLmh0bS90ZXN0L3dwLWFkbWluL2d1LWNocmlzdG1hcy1pbGx1bWluYXRlZC1naWZ0LWJveGVzLmh0bSI+cG93ZXJmdWwgcm90YXRpbmcgaW5kb29yIGNocmlzdG1hcyB0cmVlIHN0YW5kLCBmb3IgbGlnaHRlZCBhcnRpZmljaWFsPC9hPgo8L2xpPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXJvdGF0aW5nLWNocmlzdG1hcy10cmVlLXN0YW5kLXJlcGxhY2VtZW50LXBhcnRzLmh0bS90ZXN0L3dwLWFkbWluL2d1LWZ1bm55LWNocmlzdG1hcy1waXR1cmVzLmh0bSI+ZmluZ2VyaHV0IGNhcnQ8L2E+Cjwvc21hbGw+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3Utcm90YXRpbmctY2hyaXN0bWFzLXRyZWUtc3RhbmQtcmVwbGFjZW1lbnQtcGFydHMuaHRtL3Rlc3Qvd3AtYWRtaW4vZ3UtY2h1cmNoLW9mLWVuZ2xhbmQtY2hyaXN0bWFzLWFkcy5odG0iPnJvdGF0aW5nIGFydGlmaWNpYWwgdHJlZSBzdGFuZCAtIHN0dWR5bGliLm5ldDwvYT4KPC9zbWFsbD4KPHNtYWxsPkppbSBzaG9yZTwvc21hbGw+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3Utcm90YXRpbmctY2hyaXN0bWFzLXRyZWUtc3RhbmQtcmVwbGFjZW1lbnQtcGFydHMuaHRtL3Rlc3Qvd3AtYWRtaW4vZ3UtbG93ZXMtYW5kLWNocmlzdG1hcy10cmVlcy5odG0iPmxvd2VzIGFuZCBjaHJpc3RtYXMgdHJlZXM8L2E+Cjwvc21hbGw+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3Utcm90YXRpbmctY2hyaXN0bWFzLXRyZWUtc3RhbmQtcmVwbGFjZW1lbnQtcGFydHMuaHRtL3Rlc3Qvd3AtYWRtaW4vZ3UtaG93LXRoZS1naW5jaC1zdG9sZS1jaHJpc3RtYXMtdmlkZW8uaHRtIj5ob3cgdGhlIGdpbmNoIHN0b2xlIGNocmlzdG1hcyB2aWRlbzwvYT4KPC9saT4KPHNtYWxsPlJldm9sdmluZyBjaHJpc3RtYXMgdHJlZSBzdGFuZHMgLSBjYXIgZm9ydW1zIGFuZCBhdXRvbW90aXZlIGNoYXQ8L3NtYWxsPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXJvdGF0aW5nLWNocmlzdG1hcy10cmVlLXN0YW5kLXJlcGxhY2VtZW50LXBhcnRzLmh0bS90ZXN0L3dwLWFkbWluL2d1LWJldGgtbW9vcmUtY2hyaXN0bWFzLXN0b3J5Lmh0bSI+YmV0aCBtb29yZSBjaHJpc3RtYXMgc3Rvcnk8L2E+Cjwvc21hbGw+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3Utcm90YXRpbmctY2hyaXN0bWFzLXRyZWUtc3RhbmQtcmVwbGFjZW1lbnQtcGFydHMuaHRtL3Rlc3Qvd3AtYWRtaW4vZ3UtY2hyaXN0bWFzLWNhcmRzLWNhbmFkYS5odG0iPmlyb24gYWdlIC0gZ29vZ2xlIGJvb2tzIHJlc3VsdDwvYT4KPC9saT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3Utcm90YXRpbmctY2hyaXN0bWFzLXRyZWUtc3RhbmQtcmVwbGFjZW1lbnQtcGFydHMuaHRtL3Rlc3Qvd3AtYWRtaW4vZ3UtYmFieXMtZmlyc3QtY2hyaXN0bWFzLXdvb2Qtb3JuYW1lbnQuaHRtIj4obXRzLTgwMSAmIzM2NzE2OyYjMjExNjA7JiMyNjY0MTsmIzMzMDUwOyYjMzU4Mjg7JiMyNjEyNjsmIzIwMDcwOyk8L2E+Cjwvc3RyaWtlPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXJvdGF0aW5nLWNocmlzdG1hcy10cmVlLXN0YW5kLXJlcGxhY2VtZW50LXBhcnRzLmh0bS90ZXN0L3dwLWFkbWluL2d1LWJsYWNrLWFuZC13aGl0ZS1saW5lLWNocmlzdG1hcy1kcmF3aW5ncy5odG0iPnJvdGF0aW5nIGNocmlzdG1hcyB0cmVlIHN0YW5kIC0gdGhlIGNocmlzdG1hcyB6b25lPC9hPgo8L2xpPgo8c21hbGw+VGhlIHJ1cmFsIG5ldy15b3JrZXIgLSBnb29nbGUgYm9va3MgcmVzdWx0PC9zbWFsbD4KPHNtYWxsPlBhdGVudGUgdXM1NjQ3NTY5IC0gcm90YXRpbmcgY2hyaXN0bWFzIHRyZWUgc3RhbmQgLSBnb29nbGUgcGF0ZW50ZXM8L3NtYWxsPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1yb3RhdGluZy1jaHJpc3RtYXMtdHJlZS1zdGFuZC1yZXBsYWNlbWVudC1wYXJ0cy5odG0vdGVzdC93cC1hZG1pbi9ndS1jaHJpc3QtY2hyaXN0bWFzLXBvZW1zLmh0bSI+cm90YXRpbmcgdHJlZSBzdGFuZCAtIGRvaXR5b3Vyc2VsZi5jb20gY29tbXVuaXR5IGZvcnVtczwvYT4KPC9zdHJpa2U+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXJvdGF0aW5nLWNocmlzdG1hcy10cmVlLXN0YW5kLXJlcGxhY2VtZW50LXBhcnRzLmh0bS90ZXN0L3dwLWFkbWluL2d1LWxpdC1jaHJpc3RtYXMtd3JlYXRocy5odG0iPmNocmlzdG1hcyB0cmVlIHN0YW5kcyAmYW1wOyBhY2Nlc3NvcmllcyAtIGRvIGl0IGJlc3Q8L2E+Cjwvc3RyaWtlPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXJvdGF0aW5nLWNocmlzdG1hcy10cmVlLXN0YW5kLXJlcGxhY2VtZW50LXBhcnRzLmh0bS90ZXN0L3dwLWFkbWluL2d1LWNocmlzdG1hcy10ZW1wb3JhcnktaGVscC1kZXRyb2l0LW1pY2hpZ2FuLmh0bSI+cGF0ZW50IHVzMjg0NzE3NSAtIHJldm9sdmluZyBzdGFuZCAtIGdvb2dsZSBwYXRlbnRzPC9hPgo8L3NtYWxsPgo8c3RyaWtlPlNvbHZlZDogd2h5IGlzIHRoZSBjYXJvdXNlbCBub3QgdHVybmluZz8gLSBtci4gY2hyaXN0bWFzIG11c2ljYWw8L3N0cmlrZT4KPHN0cmlrZT5QbGF5bW9iaWwgLSBhd2Vzb21lIHJhbmdlIGZyb20gc215dGhzIHRveXMgdWs8L3N0cmlrZT4KPGxpPlZpY2tlcm1hbiA0LjUmIzM5OyB3aGl0ZSBhcnRpZmljaWFsIGNocmlzdG1hcyB0cmVlIHN0YW5kICZhbXA7IHJldmlld3M8L2xpPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXJvdGF0aW5nLWNocmlzdG1hcy10cmVlLXN0YW5kLXJlcGxhY2VtZW50LXBhcnRzLmh0bS90ZXN0L3dwLWFkbWluL2d1LWNocmlzdG1hcy13ZWVrLWNydWlzZXMuaHRtIj40IHNlY3Rpb24gaGluZ2VkIC5yb3RhdGluZyBzdGFuZC5yZW1vdGUgLSBwb2x5Z3JvdXAgaGVscCBjZW50ZXI8L2E+CjwvbGk+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3Utcm90YXRpbmctY2hyaXN0bWFzLXRyZWUtc3RhbmQtcmVwbGFjZW1lbnQtcGFydHMuaHRtL3Rlc3Qvd3AtYWRtaW4vZ3UtZ2lmdC1ib290cy1jaHJpc3RtYXMtaWRlYS5odG0iPmV6IHJvdGF0aW5nIGNocmlzdG1hcyB0cmVlIHN0YW5kIHwgZWJheTwvYT4KPC9saT4KPHN0cmlrZT4zNjAgZGVncmVlIHJvdGF0aW5nIGNocmlzdG1hcyB0cmVlIHN0YW5kIC0gZm9yIDcuNSYjMzk7IHRyZWVzIGhpZ2gtcXVhbGl0eTwvc3RyaWtlPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1yb3RhdGluZy1jaHJpc3RtYXMtdHJlZS1zdGFuZC1yZXBsYWNlbWVudC1wYXJ0cy5odG0vdGVzdC93cC1hZG1pbi9ndS1ydi1jaHJpc3RtYXMtb3JuYW1lbnQuaHRtIj5zYW50YSYjMzk7cyBzb2x1dGlvbiAtIGJlc3QgY2hyaXN0bWFzIHRyZWUgc3RhbmRzPC9hPgo8L3N0cmlrZT4KPHN0cmlrZT5SZXBhaXIgaW5zdHJ1Y3Rpb25zIGZvciBhIHN0YXIgYmVsbCByb3RhdGluZyB0cmVlIHN0YW5kIHwgZWhvdzwvc3RyaWtlPgo8bGk+U25vdyBqb2UgaG9saWRheSByb3RhdGluZyB0cmVlIHN0YW5kIGZvciBhcnRpZmljaWFsIHRyZWVzIC0gc2FtJiMzOTtzIGNsdWI8L2xpPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXJvdGF0aW5nLWNocmlzdG1hcy10cmVlLXN0YW5kLXJlcGxhY2VtZW50LXBhcnRzLmh0bS90ZXN0L3dwLWFkbWluL2d1LWNocmlzdG1hcy1tdXNpYy1mcmFuY2UuaHRtIj5yb3RhdGluZyBjaHJpc3RtYXMgdHJlZSBzdGFuZHMgJmFtcDsgYWNjZXNzb3JpZXMgfCB3YXlmYWlyLmNvLnVrPC9hPgo8L3NtYWxsPgo8c21hbGw+Q2hyaXN0bWFzIHRyZWUgc3RhbmRzICZhbXA7IGFjY2Vzc29yaWVzPC9zbWFsbD4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1yb3RhdGluZy1jaHJpc3RtYXMtdHJlZS1zdGFuZC1yZXBsYWNlbWVudC1wYXJ0cy5odG0vdGVzdC93cC1hZG1pbi9ndS1vZmZpY2UtY2hyaXN0bWFzLXRyZWVzLmh0bSI+aG9tZSBoZXJpdGFnZSBtZXRhbCByb3RhdGluZyBhbmQgcG93ZXJlZCBjaHJpc3RtYXMgdHJlZSBzdGFuZDwvYT4KPC9zbWFsbD4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1yb3RhdGluZy1jaHJpc3RtYXMtdHJlZS1zdGFuZC1yZXBsYWNlbWVudC1wYXJ0cy5odG0vdGVzdC93cC1hZG1pbi9ndS1jaHJpc3RtYXMtc2FuLWRpZWdvLmh0bSI+cm90YXRpbmcgY2hyaXN0bWFzIHRyZWUgc3RhbmQgMTAgLSBzZWFyczwvYT4KPC9zbWFsbD4KPGxpPkNocmlzdG1hcyB0cmVlIHN0YW5kcyA6IGFtYXpvbi5jby51azwvbGk+CjxzdHJpa2U+b2JhbWEgbm8gY2hyaXN0bWFzIHRyZWU8L3N0cmlrZT4KPHN0cmlrZT42ZnQgNmluIHBlbWJlcnRvbiBwcmUtbGl0IHJvdGF0aW5nIGNocmlzdG1hcyB0cmVlIHwgZGVwYXJ0bWVudHM8L3N0cmlrZT4KPHN0cmlrZT5SZXZpZXc6IDEwMjU0IHdpbnRlciBob2xpZGF5IHRyYWluIHwgYnJpY2tzZXQ6IGxlZ28gc2V0IGd1aWRlIGFuZDwvc3RyaWtlPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1yb3RhdGluZy1jaHJpc3RtYXMtdHJlZS1zdGFuZC1yZXBsYWNlbWVudC1wYXJ0cy5odG0vdGVzdC93cC1hZG1pbi9ndS1yaWNreS12YW4tc2hlbHRvbi1jaHJpc3RtYXMuaHRtIj5yb3RhdGluZyBjaHJpc3RtYXMgdHJlZSBzdGFuZCByZXBsYWNlbWVudCBwYXJ0czwvYT4KPC9zdHJpa2U+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3Utcm90YXRpbmctY2hyaXN0bWFzLXRyZWUtc3RhbmQtcmVwbGFjZW1lbnQtcGFydHMuaHRtL3Rlc3Qvd3AtYWRtaW4vZ3UtbWFkYWdhc2Nhci1raWRzLWNocmlzdG1hcy10di1zcGVjaWFsLmh0bSI+bmF0aW9uYWwgdHJlZSBjby4gaGVhdnktZHV0eSByZXZvbHZpbmcgdHJlZSBzdGFuZCAmYW1wOyByZXZpZXdzPC9hPgo8L2xpPgo8bGk+bWFrZSBhIGNocmlzdG1hcyBzd2VhdHNoaXJ0PC9saT4KPHN0cmlrZT5FeHBsb3JlIGltYWdlcyBhYm91dCBjaHJpc3RtYXMgdHJlZSBzdGFuZCBvbiBiaW5nPC9zdHJpa2U+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3Utcm90YXRpbmctY2hyaXN0bWFzLXRyZWUtc3RhbmQtcmVwbGFjZW1lbnQtcGFydHMuaHRtL3Rlc3Qvd3AtYWRtaW4vZ3Utc3dlZGlzaC1kYXJrLWNocmlzdG1hcy1icmVhZC5odG0iPnJvdGF0aW5nIGNocmlzdG1hcyB0cmVlIHN0YW5kICYjODIxMjsgcXZjLmNvbTwvYT4KPC9saT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1yb3RhdGluZy1jaHJpc3RtYXMtdHJlZS1zdGFuZC1yZXBsYWNlbWVudC1wYXJ0cy5odG0vdGVzdC93cC1hZG1pbi9ndS1iYWJpZXMtY2hyaXN0bWFzLXByZXNlbnRzLmh0bSI+cG9wdWxhciBtZWNoYW5pY3MgLSBnb29nbGUgYm9va3MgcmVzdWx0PC9hPgo8L3NtYWxsPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1yb3RhdGluZy1jaHJpc3RtYXMtdHJlZS1zdGFuZC1yZXBsYWNlbWVudC1wYXJ0cy5odG0vdGVzdC93cC1hZG1pbi9ndS1jaHJpc3RtYXMtcHJpbnRlZC1jcm9zcy1zdGl0Y2guaHRtIj5leiByb3RhdGluZyBjaHJpc3RtYXMgdHJlZSBzdGFuZCByZXBsYWNlbWVudCBwYXJ0cyAtIGJsb2djdTwvYT4KPC9zdHJpa2U+CjxzdHJpa2U+cmlja3kgdmFuIHNoZWx0b24gY2hyaXN0bWFzPC9zdHJpa2U+CjxzbWFsbD5DaHJpc3RtYXMgdHJlZSBzdGFuZHMgfCBjaHJpc3RtYXMgdHJlZSBob2xkZXJzIC0gc2VhcnM8L3NtYWxsPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXJvdGF0aW5nLWNocmlzdG1hcy10cmVlLXN0YW5kLXJlcGxhY2VtZW50LXBhcnRzLmh0bS90ZXN0L3dwLWFkbWluL2d1LW1ldHJvcG9saXRpYW4tbXVzZXVtLWNocmlzdG1hcy1jYXRhbG9nLmh0bSI+bWV0cm9wb2xpdGlhbiBtdXNldW0gY2hyaXN0bWFzIGNhdGFsb2c8L2E+CjwvbGk+CjxsaT5NdXNpYyBib3ggcm90YXRpbmcgYmFzZSBpcyBjaHJpc3RtYXMgdHJlZSBzdGFuZDwvbGk+CjxsaT5Nb3Rvcml6ZWQsIHJvdGF0aW5nIGNocmlzdG1hcyB0cmVlIHN0YW5kcyBhdCBicm9va3N0b25lJiM4MjEyO2J1eSBub3chPC9saT4KPHN0cmlrZT5XYWxrIHlvdXJzZWxmIHdlbGwgLSBnb29nbGUgYm9va3MgcmVzdWx0PC9zdHJpa2U+CjxzdHJpa2U+U2hvcnRicmVhZCBtdXNpY2FsIHRyZWUgdGluIHwgbSZhbXA7czwvc3RyaWtlPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXJvdGF0aW5nLWNocmlzdG1hcy10cmVlLXN0YW5kLXJlcGxhY2VtZW50LXBhcnRzLmh0bS90ZXN0L3dwLWFkbWluL2d1LWRhaXN5LWR1Y2stY2hyaXN0bWFzLW9ybmFtZW50Lmh0bSI+cmVwbGFjZW1lbnQgcGFydHMgLSBwdWxlbyBpbnRlcm5hdGlvbmFsPC9hPgo8L3NtYWxsPgo8c21hbGw+ODAlb2ZmIHJlcGxhY2VtZW50IHBhcnRzIGZvciBnaWJyYWx0YXIgZGplbWJlIHN0YW5kIC0gYXM8L3NtYWxsPgo8bGk+SGVpcmxvb20gY2hyaXN0bWFzIHRyZWUgc3RhbmQgfCByb3RhdGVzIGFuZCBwbGF5cyBtdXNpYyBob2xpZGF5PC9saT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3Utcm90YXRpbmctY2hyaXN0bWFzLXRyZWUtc3RhbmQtcmVwbGFjZW1lbnQtcGFydHMuaHRtL3Rlc3Qvd3AtYWRtaW4vZ3UtZHVjay1saWdodC1jaHJpc3RtYXMtZmFtaWx5LWRvbmFsZC5odG0iPmR1Y2sgbGlnaHQgY2hyaXN0bWFzIGZhbWlseSBkb25hbGQ8L2E+Cjwvc3RyaWtlPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXJvdGF0aW5nLWNocmlzdG1hcy10cmVlLXN0YW5kLXJlcGxhY2VtZW50LXBhcnRzLmh0bS90ZXN0L3dwLWFkbWluL2d1LWNocmlzdG1hcy1kZWNvcmF0aW9uLXdpbi5odG0iPm5ldyBob21lIGRlY29yYXRpb25zIGFuZCBhY2Nlc3NvcmllcyB8IGNiMjwvYT4KPC9saT4KPHN0cmlrZT5Sb3RhdGluZyBjaHJpc3RtYXMgdHJlZSBzdGFuZCBmb3IgOSBmdCB0cmVlIC0gd2Vic2l0ZSBvZiBuaXJpeWFyZCE8L3N0cmlrZT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3Utcm90YXRpbmctY2hyaXN0bWFzLXRyZWUtc3RhbmQtcmVwbGFjZW1lbnQtcGFydHMuaHRtL3Rlc3Qvd3AtYWRtaW4vZ3UtcmVkLW5lY2stY2hyaXN0bWFzLmh0bSI+Y2F0YWxvZyAtIHdvbG8gbWZnLjwvYT4KPC9zdHJpa2U+CjxzbWFsbD5Sb3RhdGluZyB0cmVlIHN0YW5kIC0gc2FudGEmIzM5O3Mgb3duPC9zbWFsbD4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1yb3RhdGluZy1jaHJpc3RtYXMtdHJlZS1zdGFuZC1yZXBsYWNlbWVudC1wYXJ0cy5odG0vdGVzdC93cC1hZG1pbi9ndS1jaHJpc3RtYXMtcG9wLXNvbmdzLmh0bSI+Y2hyaXN0bWFzIHBvcCBzb25nczwvYT4KPC9zbWFsbD4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1yb3RhdGluZy1jaHJpc3RtYXMtdHJlZS1zdGFuZC1yZXBsYWNlbWVudC1wYXJ0cy5odG0vdGVzdC93cC1hZG1pbi9ndS0xMi1kYXlzLW9mLWNocmlzdG1hcy1raWRzLWFjdGl2aXRpZXMuaHRtIj5yZW1vdmVhbmRyZXBsYWNlLmNvbSB8IGRpeSBwcm9qZWN0cyAvIHRpcHMgLyB0cmlja3MgLyBpZGVhcyAvIHJlcGFpcjwvYT4KPC9zbWFsbD4KPHNtYWxsPlZhbml0eSAmYW1wOyBjb3NtZXRpYyBvcmdhbml6ZXJzIC0gYmVkIGJhdGggJmFtcDsgYmV5b25kPC9zbWFsbD4KPGxpPkNocmlzdG1hcyB0cmVlIHN0YW5kcyB8IHJldm9sdmluZyB0cmVlIHN0YW5kcyB8IHRyZWUgc3Bpbm5lcnM8L2xpPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXJvdGF0aW5nLWNocmlzdG1hcy10cmVlLXN0YW5kLXJlcGxhY2VtZW50LXBhcnRzLmh0bS90ZXN0L3dwLWFkbWluL2d1LWNvb2tpbmctZ2FtZXMtZm9yLWNocmlzdG1hcy5odG0iPnJvdGF0aW5nIGNocmlzdG1hcyB0cmVlIHN0YW5kIGZvciBhcnRpZmljaWFsIHRyZWVzPC9hPgo8L2xpPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXJvdGF0aW5nLWNocmlzdG1hcy10cmVlLXN0YW5kLXJlcGxhY2VtZW50LXBhcnRzLmh0bS90ZXN0L3dwLWFkbWluL2d1LWNocmlzdG1hcy1zdG9yZS1vbmxpbmUuaHRtIj5jaGVhcCBrYXJlbiBtaWxsZW4gc2FsZSBkcmVzc2VzLGthcmVuIG1pbGxlbiBibGFjayxrYXJlbiBtaWxsZW48L2E+CjwvbGk+CjxsaT5Sb3RhdGluZyBjaHJpc3RtYXMgdHJlZSBzdGFuZHMuIHZpbnRhZ2UgYW5kIGNsYXNzaWMhPC9saT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3Utcm90YXRpbmctY2hyaXN0bWFzLXRyZWUtc3RhbmQtcmVwbGFjZW1lbnQtcGFydHMuaHRtL3Rlc3Qvd3AtYWRtaW4vZ3UtYXNsLWFuZC1jaHJpc3RtYXMuaHRtIj52aW50YWdlIHNwaW5jcmFmdCBoZWlybG9vbSByb3RhdGluZyBjaHJpc3RtYXMgdHJlZSBzdGFuZCAtIGZvcjwvYT4KPC9zdHJpa2U+CjxzdHJpa2U+VGhlIGhvbGlkYXkgYWlzbGUgcmVwbGFjZW1lbnQgcGFydHMgdHJlZSBzdGFuZCAmYW1wOyByZXZpZXdzIHwgd2F5ZmFpcjwvc3RyaWtlPgo8c3RyaWtlPlZpbnRhZ2Ugc3BpbmNyYWZ0IGhlaXJsb29tIHJvdGF0aW5nIGNocmlzdG1hcyB0cmVlIHN0YW5kIC0gZm9yPC9zdHJpa2U+CjxzbWFsbD5CdXkgNCBib3R0bGUgcmV2b2x2aW5nIG9wdGljIHN0YW5kIGF0IGFyZ29zLmNvLnVrIC0geW91ciBvbmxpbmU8L3NtYWxsPgo8bGk+cHJpbnRhYmxlIG1lcnJ5IGNocmlzdG1hcyBjYXJkczwvbGk+CjxsaT5TaG9wIGFtYXpvbi5jb20gfCB0cmVlIHN0YW5kczwvbGk+CjxsaT5TdGFyIHNob3dlcjogbGVkIG91dGRvb3IvaW5kb29yIGxhc2VyLXByb2plY3RlZCBsaWdodCBzeXN0ZW0gd2l0aDwvbGk+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3Utcm90YXRpbmctY2hyaXN0bWFzLXRyZWUtc3RhbmQtcmVwbGFjZW1lbnQtcGFydHMuaHRtL3Rlc3Qvd3AtYWRtaW4vZ3Utc2FuLW1hdGVvLWNocmlzdG1hcy0xOTcwLmh0bSI+YW5pbWF0ZWQgY2hyaXN0bWFzIHZpbGxhZ2Ugc2NlbmUgd2l0aCByb3RhdGluZyBjaHJpc3RtYXMgdHJlZTwvYT4KPC9zbWFsbD4KPHN0cmlrZT5Sb3RhdGluZyBjaHJpc3RtYXMgdHJlZSBzdGFuZHMuIHZpbnRhZ2UgYW5kIGNsYXNzaWMhIC0gZWxlbWVudHM8L3N0cmlrZT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1yb3RhdGluZy1jaHJpc3RtYXMtdHJlZS1zdGFuZC1yZXBsYWNlbWVudC1wYXJ0cy5odG0vdGVzdC93cC1hZG1pbi9ndS1jb2FzdC1ndWFyZC1jaHJpc3RtYXMtZ2lmdHMuaHRtIj5jb2FzdCBndWFyZCBjaHJpc3RtYXMgZ2lmdHM8L2E+Cjwvc21hbGw+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXJvdGF0aW5nLWNocmlzdG1hcy10cmVlLXN0YW5kLXJlcGxhY2VtZW50LXBhcnRzLmh0bS90ZXN0L3dwLWFkbWluL2d1LW9yZGVyLXBob3RvLWNocmlzdG1hcy1jYXJkcy5odG0iPmggbSBzIC0gMjMtMS80JnF1b3Q7IGJhc2UgZGlhbWV0ZXIgcm90YXRpbmcgdHJlZSBzdGFuZCBlYXN5IHJvdGF0aW5nPC9hPgo8L3N0cmlrZT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1yb3RhdGluZy1jaHJpc3RtYXMtdHJlZS1zdGFuZC1yZXBsYWNlbWVudC1wYXJ0cy5odG0vdGVzdC93cC1hZG1pbi9ndS11a3Jhbmlhbi1jaHJpc3RtYXMtMjAxMC5odG0iPnVrcmFuaWFuIGNocmlzdG1hcyAyMDEwPC9hPgo8L2xpPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1yb3RhdGluZy1jaHJpc3RtYXMtdHJlZS1zdGFuZC1yZXBsYWNlbWVudC1wYXJ0cy5odG0vdGVzdC93cC1hZG1pbi9ndS1sYXN0LWNocmlzdG1hcy1hc2hsZXktdGlsc2RhbGUuaHRtIj5maW5kIGNocmlzdG1hcyB0cmVlIHN0YW5kcyBvbiBob3V6ejwvYT4KPC9zdHJpa2U+CjxsaT5Sb3RhdGluZyBjaHJpc3RtYXMgdHJlZSBzdGFuZCAtIGRlY29yYXRpb25zICZhbXA7IHByb3BzPC9saT4KPGxpPkNocmlzdG1hcyB0cmVlIHN0YW5kcyBpbiB0eXBlOmFydGlmaWNpYWwgdHJlZSBzdGFuZCB8IGViYXk8L2xpPgo8c3RyaWtlPkNocmlzdG1hcyB0cmVlIHN0YW5kIGV6IHJvdGF0ZSAtIGZyaWdodHByb3BzLmNvbTwvc3RyaWtlPgo8c21hbGw+Q2hyaXN0bWFzIHRyZWUgc3RhbmRzICZhbXA7IGFjY2Vzc29yaWVzIC0gY3JhZnR3b29kIGx1bWJlciAmYW1wOyBoYXJkd2FyZTwvc21hbGw+CjxzbWFsbD5DaHJpc3RtYXMgdHJlZSBjaHJpc3RtYXMgdHJlZXMgJmFtcDsgYWNjZXNzb3JpZXMgfCBiaXpyYXRlPC9zbWFsbD4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3Utcm90YXRpbmctY2hyaXN0bWFzLXRyZWUtc3RhbmQtcmVwbGFjZW1lbnQtcGFydHMuaHRtL3Rlc3Qvd3AtYWRtaW4vZ3UtaSdtLWdldHRpbi1udXRpbi1mb3ItY2hyaXN0bWFzLmh0bSI+c2Vhc29uYWwgfCBob2JieSBsb2JieTwvYT4KPC9zdHJpa2U+CjxzdHJpa2U+MzUwIGRlZ3JlZSByb3RhdGluZyB0cmVlIHN0YW5kIHwgazEyOTY4MDwvc3RyaWtlPgo8c21hbGw+Q2hyaXN0bWFzIHRyZWVzIC0gc2hvcCB0aGUgYmVzdCBkZWFscyBmb3IgbWFyIDIwMTcgLSBvdmVyc3RvY2s8L3NtYWxsPgo8c21hbGw+VG95cyAmYW1wOyBnYW1lcyB8IGJhc3MgcHJvIHNob3BzPC9zbWFsbD4KPGxpPkhlYXZ5IGR1dHkgZmFuY3kgZ29sZCBtZXRhbCByb3RhdGluZyBhcnRpZmljaWFsIGNocmlzdG1hcyB0cmVlIHN0YW5kPC9saT4KPHN0cmlrZT5DaHJpc3RtYXMgdHJlZXMgJmFtcDsgYWNjZXNzb3JpZXMgfCBjYW5hZGlhbiB0aXJlPC9zdHJpa2U+CjxzbWFsbD5WaWNrZXJtYW4gLSBpdGVtIGRldGFpbHM8L3NtYWxsPgo8c21hbGw+R2VtbXkgaW5kdXN0cmllcyB8IGlubm92YXRpb24gc3RhcnRzIGhlcmU8L3NtYWxsPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXJvdGF0aW5nLWNocmlzdG1hcy10cmVlLXN0YW5kLXJlcGxhY2VtZW50LXBhcnRzLmh0bS90ZXN0L3dwLWFkbWluL2d1LWlzLWNocmlzdG1hcy1hLXBlZ2FuLWhvbGlkYXkuaHRtIj5wYXRlbnQgdXMzMDczNTU4IC0gY2hyaXN0bWFzIHRyZWUgc3RhbmQgLSBnb29nbGUgcGF0ZW50aTwvYT4KPC9zbWFsbD4KPHN0cmlrZT5QYXRlbnQgdXMxOTg4MzQzIC0gcm90YXRpbmcgY2hyaXN0bWFzLXRyZWUgc3RhbmQgLSBnb29nbGUgcGF0ZW50czwvc3RyaWtlPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXJvdGF0aW5nLWNocmlzdG1hcy10cmVlLXN0YW5kLXJlcGxhY2VtZW50LXBhcnRzLmh0bS90ZXN0L3dwLWFkbWluL2d1LWZpbmQtY2hyaXN0bWFzLWxpZmUtbG92ZS15ZWFyLmh0bSI+ZmluZCBjaHJpc3RtYXMgbGlmZSBsb3ZlIHllYXI8L2E+Cjwvc21hbGw+CjxsaT5CdXkgcmV2b2x2aW5nIGNocmlzdG1hcyB0cmVlIHN0YW5kIGZyb20gb3VyIGFsbCBjaHJpc3RtYXMgcmFuZ2U8L2xpPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXJvdGF0aW5nLWNocmlzdG1hcy10cmVlLXN0YW5kLXJlcGxhY2VtZW50LXBhcnRzLmh0bS90ZXN0L3dwLWFkbWluL2d1LXdpbGwtZGVubnlzLWJlLW9wZW4tb24tY2hyaXN0bWFzLmh0bSI+Y2hyaXN0bWFzIHRyZWUgc3RhbmRzICZhbXA7IGFjY2Vzc29yaWVzIC0gYWwmYW1wO20gYnVpbGRpbmcgc3VwcGx5PC9hPgo8L2xpPgo8c3RyaWtlPkV6IHJvdGF0aW5nIGNocmlzdG1hcyB0cmVlIHN0YW5kIHBhcnRzIHwgaG9tZSBkZXNpZ24gaWRlYXM8L3N0cmlrZT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3Utcm90YXRpbmctY2hyaXN0bWFzLXRyZWUtc3RhbmQtcmVwbGFjZW1lbnQtcGFydHMuaHRtL3Rlc3Qvd3AtYWRtaW4vZ3UtcGVyY2VudGFnZS1vZi1kaXZvcmNlcy1hdC1jaHJpc3RtYXMuaHRtIj5jaHJpc3RtYXMgdHJlZSBzdGFuZHMgJmFtcDsgYWNjZXNzb3JpZXMgLSBjb3VudHkgZG8gaXQgY2VudGVyPC9hPgo8L3N0cmlrZT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3Utcm90YXRpbmctY2hyaXN0bWFzLXRyZWUtc3RhbmQtcmVwbGFjZW1lbnQtcGFydHMuaHRtL3Rlc3Qvd3AtYWRtaW4vZ3UtbGFzdHItY2hyaXN0bWFzLXdoYW0uaHRtIj5yb3RhdGluZyBjaHJpc3RtYXMgdHJlZSBzdGFuZHMgLSB3YWxtYXJ0PC9hPgo8L3N0cmlrZT4KPHN0cmlrZT5TYW50YSBvbiB0cmFpbiByb3RhdGluZyBhcm91bmQgY2hyaXN0bWFzIHRyZWUgb3JuYW1lbnQgLSAxN2NtPC9zdHJpa2U+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3Utcm90YXRpbmctY2hyaXN0bWFzLXRyZWUtc3RhbmQtcmVwbGFjZW1lbnQtcGFydHMuaHRtL3Rlc3Qvd3AtYWRtaW4vZ3UtZmlsbS13aGl0ZS1jaHJpc3RtYXMuaHRtIj5yb3RhdGluZyBjaHJpc3RtYXMgdHJlZSBzdGFuZCAtIHRyZWV0aW1lPC9hPgo8L3NtYWxsPgo8c3RyaWtlPktpZHMgYm9va2Nhc2VzICZhbXA7IGJvb2tzaGVsdmVzIHwgdGhlIGxhbmQgb2Ygbm9kPC9zdHJpa2U+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3Utcm90YXRpbmctY2hyaXN0bWFzLXRyZWUtc3RhbmQtcmVwbGFjZW1lbnQtcGFydHMuaHRtL3Rlc3Qvd3AtYWRtaW4vZ3UtY2F0LWNocmlzdG1hcy1sZXR0ZXIuaHRtIj5yb3RhdGluZyBjaHJpc3RtYXMgdHJlZSBzdGFuZCB8IGViYXk8L2E+CjwvbGk+CjxzbWFsbD43IHRpcHMgdGhhdCBrZWVwIHlvdXIgcmVhbCBjaHJpc3RtYXMgdHJlZSBhbGl2ZSB8IGViYXk8L3NtYWxsPgo8c3RyaWtlPkltYWdlcyBmb3Igcm90YXRpbmcgY2hyaXN0bWFzIHRyZWUgc3RhbmQgcmVwbGFjZW1lbnQgcGFydHM8L3N0cmlrZT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1yb3RhdGluZy1jaHJpc3RtYXMtdHJlZS1zdGFuZC1yZXBsYWNlbWVudC1wYXJ0cy5odG0vdGVzdC93cC1hZG1pbi9ndS1pcm9uLWNocmlzdG1hcy1mcmFtZXMtdG8tbGlnaHQuaHRtIj5ob2xpZGF5IHN1cHBsaWVzIC0gbGl2ZSAmYW1wOyBhcnRpZmljaWFsIGNocmlzdG1hcyB0cmVlIHN0YW5kczwvYT4KPC9saT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1yb3RhdGluZy1jaHJpc3RtYXMtdHJlZS1zdGFuZC1yZXBsYWNlbWVudC1wYXJ0cy5odG0vdGVzdC93cC1hZG1pbi9ndS1jaHJpc3RtYXMtZS1tYWlsLWludml0YXRpb24uaHRtIj5zbXMgbm92ZWx0aXF1ZXMgLSBhbmltYXRlZCBtb3Rpb24gbGFtcHMsIG1vdGlvbiBsYW1wcywgc3Bpbm5lcjwvYT4KPC9saT4KPHNtYWxsPlRoZSBiZXN0IGZsYWcgcG9sZXMgZm9yIHNhbGUsIHUucy4gYW5kIGxhcmdlIGN1c3RvbSBmbGFnczwvc21hbGw+CjxzdHJpa2U+Q2hlYXAgY2FrZSB0aW5zLCBiYWtpbmcgdHJheSwgcm9sbGluZyBwaW5zIGFuZCBtb3JlIGZyb20gYiZhbXA7bTwvc3RyaWtlPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1yb3RhdGluZy1jaHJpc3RtYXMtdHJlZS1zdGFuZC1yZXBsYWNlbWVudC1wYXJ0cy5odG0vdGVzdC93cC1hZG1pbi9ndS1iZWFjaC1jaHJpc3RtYXMtbGlnaHRpbmcuaHRtIj5jaHJpc3RtYXMgdHJlZSAtIHdpa2lwZWRpYTwvYT4KPC9zdHJpa2U+CjxzbWFsbD5CdXkgYSByb3RhdGluZyBjaHJpc3RtYXMgdHJlZSBzdGFuZCBmb3Igc2FsZSAtIHdpdGggbXVzaWMgZm9yPC9zbWFsbD4KPHNtYWxsPjxoMT5Sb3RhdGluZyBDaHJpc3RtYXMgVHJlZSBTdGFuZCBSZXBsYWNlbWVudCBQYXJ0czwvaDE+PC9zbWFsbD4KPGxpPjEwMDArIGlkZWFzIGFib3V0IHJvdGF0aW5nIGNocmlzdG1hcyB0cmVlIHN0YW5kIG9uIHBpbnRlcmVzdDwvbGk+CjxsaT5DaHJpc3RtYXMgdHJlZSBzdGFuZHMgJmFtcDsgYWNjZXNzb3JpZXMgLSBiYXkgaGFyZHdhcmU8L2xpPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXJvdGF0aW5nLWNocmlzdG1hcy10cmVlLXN0YW5kLXJlcGxhY2VtZW50LXBhcnRzLmh0bS90ZXN0L3dwLWFkbWluL2d1LWxha2Utb2tlZWNob2JlZS1jaHJpc3RtYXMtdHJlZXMuaHRtIj5yZXZvbHZpbmcgc3RhbmQgZm9yIGNocmlzdG1hcyB0cmVlcyAtIGFydGlmaWNpYWwgY2hyaXN0bWFzIHRyZWVzPC9hPgo8L3NtYWxsPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1yb3RhdGluZy1jaHJpc3RtYXMtdHJlZS1zdGFuZC1yZXBsYWNlbWVudC1wYXJ0cy5odG0vdGVzdC93cC1hZG1pbi9ndS1jaHJpc3RtYXMtaW4tbWVsYm91cm5lLmh0bSI+Y2hyaXN0bWFzIGluIG1lbGJvdXJuZTwvYT4KPC9zdHJpa2U+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3Utcm90YXRpbmctY2hyaXN0bWFzLXRyZWUtc3RhbmQtcmVwbGFjZW1lbnQtcGFydHMuaHRtL3Rlc3Qvd3AtYWRtaW4vZ3UtYW5kLWNocmlzdG1hc3MtZmFpcnktZmlnaHRzLWJhY2suaHRtIj5ub3J0aGxpZ2h0IDI0IGluLiBwb3dlcmZ1bCByb3RhdGluZyBpbmRvb3IgY2hyaXN0bWFzIHRyZWUgc3RhbmQ8L2E+Cjwvc21hbGw+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXJvdGF0aW5nLWNocmlzdG1hcy10cmVlLXN0YW5kLXJlcGxhY2VtZW50LXBhcnRzLmh0bS90ZXN0L3dwLWFkbWluL2d1LWNhdC1jaHJpc3RtYXMtcGljdHVyZS5odG0iPmNocmlzdG1hcyB0cmVlIHN0YW5kcyAmYW1wOyBjb2xsYXJzIHwgYmFsc2FtIGhpbGw8L2E+Cjwvc3RyaWtlPgo8bGk+SG9tY29tIDdmdCBjaHJpc3RtYXMgaW5mbGF0YWJsZSA2IGxlZCBsaWdodHMgYW5pbWF0ZWQgcm90YXRpbmc8L2xpPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXJvdGF0aW5nLWNocmlzdG1hcy10cmVlLXN0YW5kLXJlcGxhY2VtZW50LXBhcnRzLmh0bS90ZXN0L3dwLWFkbWluL2d1LXVuaXF1ZS1wZXJzb25hbC1jaHJpc3RtYXMtY2FyZHMuaHRtIj5uZXcgc2NpZW50aXN0IC0gZ29vZ2xlIGJvb2tzIHJlc3VsdDwvYT4KPC9zbWFsbD4KPHNtYWxsPk5ldyB5b3JrIG1hZ2F6aW5lIC0gZ29vZ2xlIGJvb2tzIHJlc3VsdDwvc21hbGw+CjxzdHJpa2U+Q2hyaXN0bWFzIHRyZWUgc3RhbmQgcGFydHMgLSBhbGliYWJhPC9zdHJpa2U+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3Utcm90YXRpbmctY2hyaXN0bWFzLXRyZWUtc3RhbmQtcmVwbGFjZW1lbnQtcGFydHMuaHRtL3Rlc3Qvd3AtYWRtaW4vZ3UtY2hyaXN0bWFzLXNvbmctbWVycnktY2hyaXN0bWFzLXRvLXlvdS5odG0iPndoZXJlIGNhbiBpIGZpbmQgYSByb3RhdGluZyBjaHJpc3RtYXMgdHJlZSBzdGFuZCBmb3IgYSAxLjUgaW5jaDwvYT4KPC9zbWFsbD4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1yb3RhdGluZy1jaHJpc3RtYXMtdHJlZS1zdGFuZC1yZXBsYWNlbWVudC1wYXJ0cy5odG0vdGVzdC93cC1hZG1pbi9ndS1jaHJpc3RtYXMtc2hvcC1mbG9yaWRhLmh0bSI+ZXYzIHNlbnNvcnMgJmFtcDsgYWNjZXNzb3JpZXMgLSBtb2Rlcm4gdGVhY2hpbmcgYWlkczwvYT4KPC9saT4KPGxpPkNocmlzdG1hcyB0cmVlcyA6IHRhcmdldDwvbGk+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXJvdGF0aW5nLWNocmlzdG1hcy10cmVlLXN0YW5kLXJlcGxhY2VtZW50LXBhcnRzLmh0bS90ZXN0L3dwLWFkbWluL2d1LTItZnQtd2lkZS1saWdodGVkLWNocmlzdG1hcy10cmVlLmh0bSI+Y2FrZXMgd2l0aCBtb3ZpbmcgcGFydHMgLSBjYWtlIGNlbnRyYWw8L2E+Cjwvc3RyaWtlPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXJvdGF0aW5nLWNocmlzdG1hcy10cmVlLXN0YW5kLXJlcGxhY2VtZW50LXBhcnRzLmh0bS90ZXN0L3dwLWFkbWluL2d1LWVucmljaG1lbnQtY2hyaXN0bWFzLWlkZWFzLmh0bSI+ZW5yaWNobWVudCBjaHJpc3RtYXMgaWRlYXM8L2E+CjwvbGk+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3Utcm90YXRpbmctY2hyaXN0bWFzLXRyZWUtc3RhbmQtcmVwbGFjZW1lbnQtcGFydHMuaHRtL3Rlc3Qvd3AtYWRtaW4vZ3UtbWFrZS1hLWNocmlzdG1hcy1zd2VhdHNoaXJ0Lmh0bSI+aG9tZSBsb2dpYyAxMTEtMiByb3RhdGluZyBhcnRpZmljaWFsIGNocmlzdG1hcyB0cmVlIHN0YW5kLCAyMyZxdW90OyBhdDwvYT4KPC9zbWFsbD4KPHN0cmlrZT5pcm9uIGNocmlzdG1hcyBmcmFtZXMgdG8gbGlnaHQ8L3N0cmlrZT4KPHNtYWxsPjUwJW9mZiBpc2NhciA1NTcwMDQxIHJlcGxhY2VtZW50IHBhcnRzIGZvciBpc2NhciB0dXJuaW5nPC9zbWFsbD4KPHNtYWxsPlZpY2tlcm1hbiBhODAwMDA3IC0gcm90YXRpbmcgY2hyaXN0bWFzIHRyZWUgc3RhbmQgLSAxMDAwYnVsYnMuY29tPC9zbWFsbD4KPHNtYWxsPkFncmljdWx0dXJlIHRheCBndWlkZSAtIHdhc2hpbmd0b24gc3RhdGUgZGVwYXJ0bWVudCBvZiByZXZlbnVlPC9zbWFsbD4KCgo8aHI+CgpSb3RhdGluZyBjaHJpc3RtYXMgdHJlZSBzdGFuZCByZXBsYWNlbWVudCBwYXJ0cwo=