PCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9JRVRGLy9EVEQgSFRNTCAyLjAvL0VOIj4KPEhUTUw+PEhFQUQ+CjxUSVRMRT5PbGQgd29ybGQgY2hyaXN0bWFzIGxpZ2h0IGNvdmVyIHJvc2U8L1RJVExFPgo8L0hFQUQ+PEJPRFk+Cgo8aDE+T2xkIHdvcmxkIGNocmlzdG1hcyBsaWdodCBjb3ZlciByb3NlPC9oMT4KCjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtY2hyaXN0bWFzLWZ1bi1mYWN0cy1hbmQtdHJpdmlhLmh0bSI+d2hhdCYjMzk7cyBvbiB0diB0b25pZ2h0OiBjYW4gaSBpbXByb3ZlIG15IG1lbW9yeT8sIHRoZSBvYSBhbmQgbW9yZTwvYT4KPC9saT4KPHN0cmlrZT4xMDAgZnJlc2ggY2hyaXN0bWFzIGRlY29yYXRpbmcgaWRlYXMgLSBzb3V0aGVybiBsaXZpbmc8L3N0cmlrZT4KPGxpPlJ1bSByZWNpcGVzIC0gbWluaXN0cnkgb2YgcnVtPC9saT4KPGxpPktyb2dlciBtYXJrZXRwbGFjZTwvbGk+CjxzbWFsbD5Ib3cgdG8gbWFrZSBhbiBvbGQgYW5kcm9pZCBwaG9uZSBmZWVsIG5ldyBhZ2FpbiB8IGNvbXB1dGVyd29ybGQ8L3NtYWxsPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXNpYmVyaWFuLWNocmlzdG1hcy5odG0iPnNpYmVyaWFuIGNocmlzdG1hczwvYT4KPC9saT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1jaHJpc3RtYXMtcGN3YWxscGFwZXIuaHRtIj5yZWQgLSB3aWtpcGVkaWE8L2E+CjwvbGk+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtdG9ybi1wYXBlci1jaHJpc3RtYXMtY2FyZHMuaHRtIj5mZWF0dXJlZCBjb250ZW50IG9uIG15c3BhY2U8L2E+CjwvbGk+CjxzdHJpa2U+TXVycmF5JiMzOTtzIHN0ZWFraG91c2U8L3N0cmlrZT4KPHN0cmlrZT5Sb3NlIGdlcmFuaXVtPC9zdHJpa2U+CjxzbWFsbD5SZWQgY291bnR5IGdvc3BlbCBiYW5kIG1vdmllIC0gcHJlY2ludGw8L3NtYWxsPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1jaHJpc3RtYXMtdHJlZS1sYWR5Lmh0bSI+YmVlciBtZW51IC0gYmVlciB8IHRoZSBpb3dhIHRhcHJvb208L2E+Cjwvc3RyaWtlPgo8c3RyaWtlPkphY2sgcm9zZSBsaWJhdGlvbiBob3VzZTwvc3RyaWtlPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LWppbS1icmlja21hbidzLWNocmlzdG1hcy1pbi1tZW1waGlzLWRvd25sb2FkLmh0bSI+aG9tZXBhZ2UgLSBkZXNjYW5zbyBnYXJkZW5zIGd1aWxkPC9hPgo8L2xpPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LW5vbi1saXQtY2hyaXN0bWFzLXRyZWVzLmh0bSI+bm9uIGxpdCBjaHJpc3RtYXMgdHJlZXM8L2E+CjwvbGk+CjxzdHJpa2U+Q291bGQgaXQgYmU/IGkgdGhpbmsgaXQgaXMsIHRoYXQmIzM5O3MgamltbWVyIG11c2ljISEhISAtIGJhcnN0b29sIHNwb3J0czwvc3RyaWtlPgo8c21hbGw+T2xkIHdvcmxkIGNocmlzdG1hcyBsaWdodCBjb3ZlcnMgLSB0cmFkaXRpb25zPC9zbWFsbD4KPGxpPjUsNTAwIHF1aWx0IGJsb2NrIGRlc2lnbnMgLSBnb29nbGUgYm9va3MgcmVzdWx0PC9saT4KPHN0cmlrZT5Nb2Rlcm4gZnVybml0dXJlLCBob21lIGRlY29yICZhbXA7IGhvbWUgYWNjZXNzb3JpZXMgfCB3ZXN0IGVsbTwvc3RyaWtlPgo8c3RyaWtlPjIwIHBvbGl0aWNhbGx5IGluY29ycmVjdCBzb25ncyB0aGF0JiMzOTtkIGJlIHdpbGRseSBjb250cm92ZXJzaWFsIHRvZGF5PC9zdHJpa2U+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtaGFuLWNocmlzdGlhbi1hbmRlcnNlbidzLXRhbGUtYXQtY2hyaXN0bWFzLmh0bSI+aW1hZ2VzIGZvciBvbGQgd29ybGQgY2hyaXN0bWFzIGxpZ2h0IGNvdmVyIHJvc2U8L2E+CjwvbGk+CjxzbWFsbD5DaHJpc3RtYXMgZGVjb3JhdGlvbnMgLSBtaWNoYWVscyBzdG9yZXM8L3NtYWxsPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1jaHJpc3RtYXMtY29va2llLXJlY2lwZXMtZm9yLWRpYWJldGljcy5odG0iPmNocmlzdG1hcyBjb29raWUgcmVjaXBlcyBmb3IgZGlhYmV0aWNzPC9hPgo8L3N0cmlrZT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtY3VwYm9hcmQtY2hyaXN0bWFzLWRlY29yYXRpb24uaHRtIj5ndWl0YXIgd29ybGQ8L2E+Cjwvc3RyaWtlPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LWFtYXppbmctY2hyaXN0bWFzLXBpY3R1cmUtZ2FsbGVyaWVzLmh0bSI+c3Qgbmlja3MgY2hyaXN0bWFzIHN0b3JlIHwgdHJlZXMgLSBvcm5hbWVudHMgLSBjb2xsZWN0aWJsZXM8L2E+CjwvbGk+CjxsaT5PbGQgd29ybGQgY2hyaXN0bWFzIHJlZCByb3NlIGZsb3dlciBnbGFzcyB0cmVlIG9ybmFtZW50IDM2MjUxPC9saT4KPHN0cmlrZT5Eb2xsYXJ0cmVlLmNvbSB8IGJ1bGsgcGFydHkgc3VwcGxpZXM8L3N0cmlrZT4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1jaHJpc3RtYXMtcmVhZGluZy1sZXNzb24tc2hlZXRzLmh0bSI+Y2hyaXN0bWFzIHJlYWRpbmcgbGVzc29uIHNoZWV0czwvYT4KPC9zbWFsbD4KPHNtYWxsPkNocmlzdG1hcyBkZWNvcmF0aW9ucyAmYW1wOyBnaWZ0cyBjbGVhcmFuY2Ugc2FsZSB8IGJvc2NvdiYjMzk7czwvc21hbGw+CjxzdHJpa2U+TmFzaHZpbGxlIGZhcm1lcnMgbWFya2V0PC9zdHJpa2U+CjxzbWFsbD5CaWxsYm9hcmQgLSBnb29nbGUgYm9va3MgcmVzdWx0PC9zbWFsbD4KPGxpPjxoMT5PbGQgV29ybGQgQ2hyaXN0bWFzIExpZ2h0IENvdmVyIFJvc2U8L2gxPjwvbGk+CjxzdHJpa2U+Q2hyaXN0bWFzIG9ybmFtZW50cyAtIG1hY3kmIzM5O3M8L3N0cmlrZT4KPGxpPk5pZ2h0IGxpZ2h0cyAmIzgyMTE7IG9sZCB3b3JsZCBjaHJpc3RtYXM8L2xpPgo8c3RyaWtlPk5lZmVydGl0aSAoYXVkaW9ib29rKSBieSBtaWNoZWxsZSBtb3JhbiB8IGF1ZGlibGUuY29tPC9zdHJpa2U+CjxsaT5CaWxsaWUgaG9saWRheSAtIHdpa2lwZWRpYTwvbGk+CjxzdHJpa2U+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LWNocmlzdG1hcy1jYXJkLWZ1bmQtcmFpc2VyLmh0bSI+cGFyYWJvbGEgfCB0aGUgc2VhcmNoIGZvciBtZWFuaW5nPC9hPgo8L3N0cmlrZT4KPGxpPlBpeCBub3cgLSBjYnMgc2FuIGZyYW5jaXNjbyAtIG5ld3MsIHNwb3J0cywgd2VhdGhlciwgdHJhZmZpYyBhbmQ8L2xpPgo8bGk+c3Bpcml0IG9mIGNocmlzdG1hcyB0cmVlIGZhcm08L2xpPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1odW5nYXJpYW4tY2hyaXN0bWFzLWZvb2RzLWFuZC10aGVpci1yZWNpcGVzLmh0bSI+Y29uZmVzc2lvbnMgb2YgYSBqYW5lIGF1c3RlbiBhZGRpY3QgKGF1ZGlvYm9vaykgYnkgbGF1cmllIHZpZXJhPC9hPgo8L3N0cmlrZT4KPGxpPk9sZCB3b3JsZCBjaHJpc3RtYXMgbGlnaHQgY292ZXJzIC0gY2hyaXN0bWFzIHRyZWFzdXJlczwvbGk+CjxzdHJpa2U+dHJhbnMgc2liZXJpYW4gb3JjaGVzdHJhIHRoaXMgY2hyaXN0bWFzIGRheTwvc3RyaWtlPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1zcGlyaXQtb2YtY2hyaXN0bWFzLXRyZWUtZmFybS5odG0iPnNwaXJpdCBvZiBjaHJpc3RtYXMgdHJlZSBmYXJtPC9hPgo8L3N0cmlrZT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtY2Fyb2wtZHV2YWwncy1jaHJpc3RtYXMtZGVjb3JhdGlvbnMuaHRtIj5jcm9jaGV0ZWQgc25vd2ZsYWtlcyB8IG1hcnRoYSBzdGV3YXJ0PC9hPgo8L3N0cmlrZT4KPHNtYWxsPlRoZSBiZXN0IGhvbWVtYWRlIGRpbm5lciByb2xscyAmIzgyMTE7IG1vZGVybiBob25leTwvc21hbGw+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtdGhlbi10aGUtdHJ1ZS13b3JrLW9mLWNocmlzdG1hcy5odG0iPmJlZXIsIHdpbmUsICZhbXA7IHNwaXJpdHMgfCBtZWlqZXIuY29tPC9hPgo8L3NtYWxsPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LWNocmlzdG1hcy1zaG9wLWZsb3JpZGEuaHRtIj5vbGQgd29ybGQgY2hyaXN0bWFzJiM4NDgyOyB8IDE1MDArIGJsb3duIGdsYXNzIG9ybmFtZW50cyAtIHdob2xlc2FsZTwvYT4KPC9zbWFsbD4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3Utd2hhdCdzLWNocmlzdG1hcy1saWtlLWluLWVuZ2xhbmQuaHRtIj5kdXZldHMgJmFtcDsgZHV2ZXQgY292ZXIgc2V0cyAtIGgmYW1wO20gaG9tZSB8IGgmYW1wO20gdXM8L2E+Cjwvc3RyaWtlPgo8bGk+aG93IG1hbnkgd2hpdGUgY2hyaXN0bWFzIGluIGthbnNhczwvbGk+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3Utb2JhbWEtbm8tY2hyaXN0bWFzLXRyZWUuaHRtIj4mIzM5O2FtZXJpY2FuIGhvcnJvciBzdG9yeTogYXBvY2FseXBzZSYjMzk7OiBldmVyeXRoaW5nIHdlIGtub3cgYWJvdXQ8L2E+Cjwvc21hbGw+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtY2hyaXN0bWFzLWluLW1lbGJvdXJuZS5odG0iPmJhbmRvbCB3aW5lIHByaWNlIC0gaGlnaC10b3VjaCBsZWFkZXJzaGlwPC9hPgo8L3NtYWxsPgo8c3RyaWtlPkNocmlzdG1hcyBzcHJheXMsIHBpY2tzLCBzdGVtcyB8IHRoZSBqb2xseSBjaHJpc3RtYXMgc2hvcDwvc3RyaWtlPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LWNocmlzdG1hcy1wYWdlbnQtY29zdHVtZS5odG0iPnRoZSBjdXQ6IHN0eWxlLiBzZWxmLiBjdWx0dXJlLiBwb3dlci48L2E+CjwvbGk+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtY2hyaXN0bWFzLXByb2dyYW1zLWluLXNjaG9vbC5odG0iPmNocmlzdG1hcyBwcm9ncmFtcyBpbiBzY2hvb2w8L2E+CjwvbGk+CjxsaT5PbiBhaXIgd2l0aCByeWFuIHNlYWNyZXN0PC9saT4KPHNtYWxsPk1hYyBjb3NtZXRpY3MgfCBiZWF1dHkgYW5kIG1ha2V1cCBwcm9kdWN0cyAtIG9mZmljaWFsIHNpdGU8L3NtYWxsPgo8c21hbGw+MjQgYmVzdCB3aGlza2V5IGNvY2t0YWlscyAtIHdoYXQgdG8gbWl4IHdpdGggd2hpc2tleSBkcmluayByZWNpcGVzPC9zbWFsbD4KPGxpPkRvdWJsZSBsb29wIGNyb2NoZXQgc2FudGEgYmVhcmQgcGF0dGVybiAtIG11bHRpcGxlIHNpemVzIHwgYXNobGVlPC9saT4KPHNtYWxsPlBhcnR5IHN1cHBsaWVzIDogdGFyZ2V0PC9zbWFsbD4KPGxpPlNldCBvZiAxMiBvbGQgd29ybGQgY2hyaXN0bWFzIGxpZ2h0IGNvdmVycyBzYW50YXMgZ2xhc3MgLSAkNDAuMDA8L2xpPgo8c3RyaWtlPkNhdGFsb2cgb2YgY29weXJpZ2h0IGVudHJpZXM6IHRoaXJkIHNlcmllcyAtIGdvb2dsZSBib29rcyByZXN1bHQ8L3N0cmlrZT4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1yaWNrLXdhcnJlbidzLWNocmlzdG1hcy1ldmUtc2VydmljZS5odG0iPnNhdmUgb24gY3JhZnRzIHwgZXZlbnQgZGVjb3IgYW5kIGNhbmRsZSByZXNvdXJjZXM8L2E+CjwvbGk+CjxzbWFsbD5NdXNpYyBuZXdzIHwgYmlsbGJvYXJkPC9zbWFsbD4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1oZWxsby1raXR0eS1jaHJpc3RtYXMtaW1hZ2VzLmh0bSI+dGV4YXMgbW9udGhseSAtIGdvb2dsZSBib29rcyByZXN1bHQ8L2E+Cjwvc21hbGw+CjxzdHJpa2U+UHJpbnQgZWRpdGlvbiAtIHdzai5jb208L3N0cmlrZT4KPHNtYWxsPkxlYXJuaW5nIGhvdyB0byBuZWVkbGUgdGF0dCAtIHRhdHRpbmcgc3VwcGxpZXMgaW5jbHVkaW5nIHNodXR0bGVzPC9zbWFsbD4KPHN0cmlrZT5QYXR0ZXJucyB8IGJlcnJvY288L3N0cmlrZT4KPHN0cmlrZT5jYXJvbCBkdXZhbCdzIGNocmlzdG1hcyBkZWNvcmF0aW9uczwvc3RyaWtlPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXdhbnRlZC1mb3ItY2hyaXN0bWFzLWNyYWlnc2xpc3QuaHRtIj5naWxyb3kgZ2FyZGVucyBmYW1pbHkgdGhlbWUgcGFyazwvYT4KPC9zbWFsbD4KPHNtYWxsPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1zaW1lb24tY2hyaXN0bWFzLXBsYXkuaHRtIj5sZWFybiBhYm91dCBkaWFtb25kcyB8IGJyaWxsaWFudCBlYXJ0aDwvYT4KPC9zbWFsbD4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtcHJpbnRhYmxlLXBpY3R1cmVzLW9mLW5pZ2h0bWFyZS1iZWZvcmUtY2hyaXN0bWFzLmh0bSI+d29ybGQgbWFwIHdhbGxwYXBlciB8IG11cmFscyB3YWxscGFwZXI8L2E+Cjwvc3RyaWtlPgo8c21hbGw+U2hhd24gbWVuZGVzIHwgb2ZmaWNpYWwgc3RvcmU8L3NtYWxsPgo8c21hbGw+QmlsdG1vcmU8L3NtYWxsPgo8c3RyaWtlPndhbnRlZCBmb3IgY2hyaXN0bWFzIGNyYWlnc2xpc3Q8L3N0cmlrZT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtY2hyaXN0bWFzLWNvb2tpZS1yZWNpcGVzLWZvci1kaWFiZXRpY3MuaHRtIj53aWxsaWFtIGdsZW48L2E+Cjwvc3RyaWtlPgo8c3RyaWtlPlJlZCB3aW5lIG9mIHN3IGZyYW5jZSAtIGlrbzwvc3RyaWtlPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LWJyb3RoZXJzLTEyLWRheXMtb2YtY2hyaXN0bWFzLmh0bSI+cm9zZSBwZXRhbCB0ZXh0dXJlPC9hPgo8L3NtYWxsPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1ob3ctbWFueS13aGl0ZS1jaHJpc3RtYXMtaW4ta2Fuc2FzLmh0bSI+dGhlIGludGVybmV0JiMzOTtzIGJlc3QgbGlzdCBvZiBjbGljaGVzIC0gcHJvd3JpdGluZ2FpZDwvYT4KPC9zdHJpa2U+CjxsaT5Mb21iYXJkIGZpcmUgZGVwYXJ0bWVudCByZW1pbmRzIHJlc2lkZW50cyBvZiBidXJuIGFuZCBzY2FsZDwvbGk+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtY2FybC1kdXZhbGwtY2hyaXN0bWFzLWVwaXNvZGVzLmh0bSI+b2xkIHdvcmxkIGl0YWxpYW4gcmVjaXBlcyAtIGdvb2dsZSBib29rcyByZXN1bHQ8L2E+CjwvbGk+CjxzdHJpa2U+Q2hyaXN0bWFzIGNhcm9scyBzb25ncyBjaHJpc3RtYXMgbHlyaWNzIG1vcmUgdGhhbiAxMDAgY2hyaXN0bWFzPC9zdHJpa2U+CjxzbWFsbD48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtZnJlZS1wcmludGFibGUtY2hyaXN0bWFzLWltYWdlcy5odG0iPmNocmlzdG1hcyBsaWdodCBjb3ZlcnMgfCBldHN5PC9hPgo8L3NtYWxsPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS10aGUtY2hyaXN0bWFzLWNyb2NvZGlsZS1ib29rLmh0bSI+dGhlIGNocmlzdG1hcyBjcm9jb2RpbGUgYm9vazwvYT4KPC9zdHJpa2U+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3Utc21pdGhmaWVsZC1uZXctamVyc2V5LWFuZC1jaHJpc3RtYXMtdHJlZXMuaHRtIj4yLWluZ3JlZGllbnQgd2hpdGUgY2xheSBkb3VnaCBvcm5hbWVudHMgLSBoYXBweSBob29saWdhbnM8L2E+CjwvbGk+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtY2hyaXN0bWFzLWNoYXNpbmctbGlnaHRzLmh0bSI+cm9zZSBtY2dvd2FuJiMzOTtzIGJvb2sgJiMzOTticmF2ZSYjMzk7OiB0aGUgYmlnZ2VzdCBib21ic2hlbGxzIHwgcGVvcGxlPC9hPgo8L2xpPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LWVzdG9uaWFuLWNocmlzdG1hcy10cmVlLW9ybmFtZW50cy5odG0iPmVzdG9uaWFuIGNocmlzdG1hcyB0cmVlIG9ybmFtZW50czwvYT4KPC9saT4KPGxpPkhlcml0YWdlIGF1Y3Rpb25zIHwgd29ybGQmIzM5O3MgbGFyZ2VzdCBjb2xsZWN0aWJsZXMgYXVjdGlvbmVlcjwvbGk+CjxsaT5TZXJpb3VzbHkgZ29vZCBvbGQgZmFzaGlvbmVkIHJlY2lwZSAtIGluc3BpcmVkIHRhc3RlPC9saT4KPGxpPkNlbGVicmF0ZSB0aGUgc2Vhc29uIHdpdGggZnVuLCBmZXN0aXZlIGV2ZW50cyAmIzgyMTE7IGJvc3RvbiBoZXJhbGQ8L2xpPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LWNocmlzdG1hcy10cmVlLTEyLWZ0LWViYXkuaHRtIj5jaHJpc3RtYXMgYW5kIGhvbGlkYXkgZGVjb3IgfCB3b3JsZCBtYXJrZXQ8L2E+Cjwvc21hbGw+CjxsaT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtY2hyaXN0bWFzLXBjd2FsbHBhcGVyLmh0bSI+dGhlIGRvY3RvciBvcmRlcnMgY2hyaXN0bWFzOiBjaHJpc3RtYXMgdG93biBib29rIDQgLSBnb29nbGUgYm9va3MgcmVzdWx0PC9hPgo8L2xpPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LWVucmljaG1lbnQtY2hyaXN0bWFzLWlkZWFzLmh0bSI+ZW5yaWNobWVudCBjaHJpc3RtYXMgaWRlYXM8L2E+CjwvbGk+CjxzdHJpa2U+aHVuZ2FyaWFuIGNocmlzdG1hcyBmb29kcyBhbmQgdGhlaXIgcmVjaXBlczwvc3RyaWtlPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LTEyLWRheXMtb2YtY2hyaXN0bWFzLWx5cmljcy1jaG9yZHMuaHRtIj5sb29raW5nIGZvciBhIGNoaWxkaG9vZCBib29rPyBoZXJlJiMzOTtzIGhvdy4gfCBvbGQgY2hpbGRyZW4mIzM5O3MgYm9va3M8L2E+Cjwvc21hbGw+CjxzbWFsbD5FdmVudHMguyBvbGQgcGFzYWRlbmE8L3NtYWxsPgo8bGk+TmV3bHkgcmV0aXJlZCBvbGQgd29ybGQgY2hyaXN0bWFzIG9ybmFtZW50cyAtIHRyZW5keSB0cmVlIGJsb2c8L2xpPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LWNydWlzZS1zaGlwLWRlc2lnbi1jaHJpc3RtYXMtY2FyZHMuaHRtIj5udXRjcmFja2VyIG1hcmtldCBwYXJ0aWNpcGF0aW5nIG1lcmNoYW50cyAtIGhvdXN0b24gYmFsbGV0PC9hPgo8L3NtYWxsPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS13YW50ZWQtZm9yLWNocmlzdG1hcy1jcmFpZ3NsaXN0Lmh0bSI+aG9sbGV5IHBlcmZvcm1hbmNlIHByb2R1Y3RzPC9hPgo8L3N0cmlrZT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3Uta2F0aG1hbmR1LWNocmlzdG1hcy1zYWxlLmh0bSI+Y2hyaXN0bWFzIHRyZWUgZGVjb3JhdGlvbnMgLSBvcm5hbWVudHMgJmFtcDsgbGlnaHRzIHwgam9hbm48L2E+Cjwvc3RyaWtlPgo8bGk+QmVzdCBob21lbWFkZSBtYXJ6aXBhbiBhbmQgYWxtb25kIHBhc3RlIC0gdGhlIGRhcmluZyBnb3VybWV0PC9saT4KPHNtYWxsPkNocmlzdG1hcyBsaWdodCBjb3ZlcnMgfCBlYmF5PC9zbWFsbD4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS10b3RlbWljLWhhbGlidXQtY2hyaXN0bWFzLW9ybmFtZW50Lmh0bSI+Y2hlYXAgZm9yZXZlciByb3NlPC9hPgo8L2xpPgo8c3RyaWtlPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS1pcG9kLXRvdWNoLWF0ZXItY2hyaXN0bWFzLXNhbGUuaHRtIj5ob21lIHwgdmluZHkuY29tPC9hPgo8L3N0cmlrZT4KPHN0cmlrZT48YSBocmVmPSJodHRwOi8vaGFlc3NseWx1bWJlci5jb20vZ3UtcmVkLWdsaXR0ZXItY2hyaXN0bWFzLW9ybmFtZW50cy5odG0iPnJlZCBnbGl0dGVyIGNocmlzdG1hcyBvcm5hbWVudHM8L2E+Cjwvc3RyaWtlPgo8bGk+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LWNocmlzdG1hcy1mYW1pbGllcy5odG0iPnNpbXBsZSBkaXkgYm9va3NoZWxmIHBsYW5zICYjODIxMjsgdGhlIGZhbWlseSBoYW5keW1hbjwvYT4KPC9saT4KPGxpPlNjaG9vbmVyIGZhcmUgfCBob21lIGZvciB0aGUgaG9saWRheXM8L2xpPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LWdlcm1hbi1jaHJpc3RtYXMtc25vd21hbi1zdHVmZi5odG0iPmZhbGwgfCBob2xpZGF5cyAmYW1wOyBzZWFzb25zIHwgYnJvbm5lciYjMzk7cyBjaHJpc3RtYXMgd29uZGVybGFuZDwvYT4KPC9zbWFsbD4KPGxpPjxhIGhyZWY9Imh0dHA6Ly9oYWVzc2x5bHVtYmVyLmNvbS9ndS10cmFucy1zaWJlcmlhbi1vcmNoZXN0cmEtdGhpcy1jaHJpc3RtYXMtZGF5Lmh0bSI+MjE3IGJlc3Qgb2xkIHdvcmxkIGNocmlzdG1hcyBpbWFnZXMgfCB4bWFzLCBjaHJpc3RtYXMgb3JuYW1lbnRzPC9hPgo8L2xpPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LWEtY2hyaXN0bWFzLWNhcm9sLWFsaXN0ZXIuaHRtIj50aG9tYXMga2lua2FkZSAtIG9mZmljaWFsIHNpdGUgb2YgdGhlIHBhaW50ZXIgb2YgbGlnaHQmIzg0ODI7PC9hPgo8L3NtYWxsPgo8c21hbGw+PGEgaHJlZj0iaHR0cDovL2hhZXNzbHlsdW1iZXIuY29tL2d1LXRoYW5rLWdvZC1pdC1zLWNocmlzdG1hcy5odG0iPmNocmlzdG1hcyB0cmVlIGdsYXNzIGxpZ2h0IGNvdmVycyAtIHZpbnRhZ2UtbGlrZSByb3NlcyAtIHNldCBvZiA1PC9hPgo8L3NtYWxsPgo8c3RyaWtlPkNoZWFwIGZvcmV2ZXIgcm9zZTwvc3RyaWtlPgoKCjxocj4KCk9sZCB3b3JsZCBjaHJpc3RtYXMgbGlnaHQgY292ZXIgcm9zZQo=