PCFET0NUWVBFIGh0bWw+CjxodG1sIGxhbmc9ImRlIj4KPGhlYWQ+CjxtZXRhIGNoYXJzZXQ9IlVURi04Ij4KPG1ldGEgbmFtZT0idmlld3BvcnQiIGNvbnRlbnQ9IndpZHRoPWRldmljZS13aWR0aCwgaW5pdGlhbC1zY2FsZT0xLjAiPgo8dGl0bGU+V2FuZGVyenViaWT Duc8gZiDDvG4gZGVuIFNvbW1lciAyMDI2IGluIMOc3RlcnJlaWNoIOKAkyBSYXRnZWJlciAmIFRpcHBzIHwgTG9vbWljIEJsb2c8L3RpdGxlPgo8bWV0YSBuYW1lPSJkZXNjcmlwdGlvbiIgY29udGVudD0iV2FuZGVyenViaWT DucOociBSYXRnZWJlciBmw7xyIMOc3RlcnJlaWNoIFNvbW1lciAyMDI2OiBWb24gV2FuZGVyc3TDtmNrZW4gYmlzIFRyaW5rc3lzdGVtLiBBbGxlcyB3YXMgU2llIGbDvHIgaWhyZSBuw6RjaHN0ZSBCZXJndG91ciBicmF1Y2hlbiDigJMgaW5rbHVzaXZlIENoZWNrbGlzdGUuIj4KPG1ldGEgbmFtZT0ia2V5d29yZHMiIGNvbnRlbnQ9IndhbmRlcnp1YmVoc m8iw7ZzdGVycmVpY2gsIHdhbmRlcmF1c3LDvHN0dW5nIHNvbW1lciwgYmVyZ3RvdXJlbiBhdXNydXN0dW5nLCB3YW5kZXJuIGFscGVuLCBvdXRkb29yIHdhbmRlcm4genViaWT DucIsIHdhbmRlcnRpcHBzIMO2c3RlcnJlaWNoIj4KPG1ldGEgbmFtZT0icm9ib3RzIiBjb250ZW50PSJpbmRleCwgZm9sbG93Ij4KPG1ldGEgbmFtZT0iYXV0aG9yIiBjb250ZW50PSJMb29taWMiPgo8bGluayByZWw9ImNhbm9uaWNhbCIgaHJlZj0iaHR0cHM6Ly9sb29taWMuYXQvYmxvZy93YW5kZXJ6dWJlaG9lci1zb21tZXItb2VzdGVycmVpY2gtMjAyNiI+CjxtZXRhIHByb3BlcnR5PSJvZzp0aXRsZSIgY29udGVudD0iV2FuZGVyenViaWT Duc8gZsO8ciBkZW4gU29tbWVyIDIwMjYgaW4gw5xzdGVycmVpY2gg4oCTIFJhdGdlYmVyICYgVGlwcHMiPgo8bWV0YSBwcm9wZXJ0eT0ib2c6ZGVzY3JpcHRpb24iIGNvbnRlbnQ9IldhbmRlcnp1YmVoc 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 DucIsIGRhcyBJcmUgVG91cmVuIHNpY2hlcmVyIHVuZCBhbmdlbmVobWVyIG1hY2h0LjwvcD4KCjxoMj5EaWUgd2ljaHRpZ3N0ZW4gV2FuZGVyLUFjY2Vzc29pcmVzIGltIMOcYmVyYmxpY2s8L2gyPgo8cD5CZXYb3Igd2lyIGluIGRpZSBEZXRhaWxzIGdlaGVuLCBoaWVyIGVpbmUgw5xiZXJzaWNodCBkZXIgd2ljaHRpZ3N0ZW4gS2F0ZWdvcmllbiBmw7xyIFdhbmRlcnp1YmVoc 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 DucIgemFobHQgc2ljaCBkYWJlaSBtZWhyZmFjaCBhdXMgLSBkdXJjaCBtZWhyIFNpY2hlcmhlaXQsIEtvbWZvcnQgdW5kIEZyZXVkZSBpbiBkZXIgTmF0dXIuPC9wPgo8cD5CZWkgTG9vbWljIGZpbmRlbiBTaWUgZWluZSBncm/Dn2UgQXVzd2FobCBhbiBwcmFrdGlzY2hlbSBPdXRkb29yLVp1YmVoc m9yLCBkYXMgSWhyZSBXYW5kZXJ1bmdlbiBiZXJlaWNoZXJ0LiBWb24gVHJpbmtzeXN0ZW1lbiDDvGJlciBQb3dlcmJhbmtzIGJpcyBoaW4genUgT3JnYW5pemVybiB1bmQgQXVmYmV3YWhydW5nc2zDtnN1bmdlbiAtIHN0w7ZiZXJuIFNpZSBkdXJjaCB1bnNlciBTb3J0aW1lbnQgdW5kIHN0YXJ0ZW4gU2llIGJlc3RlbnMgdm9yYmVyZWl0ZXQgaW4gSWhyZSBuw6RjaHN0ZSBUb3VyLjwvcD4KPHA+PHN0cm9uZz5EZW5rZW4gU2llIGRhcmFuOiBFcyBnaWJ0IGtlaW4gc2NobGVjaHRlcyBXZXR0ZXIsIG51ciBmYWxzY2hlIEtsZWlkdW5nIC0gdW5kIG1pdCBkZXIgcmVjaHRpZ2VuIEF1c3LDvHN0dW5nIHdpcmQgamVkZXIgV2V0dGVydGFnIHp1bSBXYW5kZXJ0YWchIPCfj5TigI3igIs8L3N0cm9uZz48L3A+Cgo8L2FydGljbGU+Cjwvc2VjdGlvbj4KCjxzZWN0aW9uIGNsYXNzPSJiZy13aGl0ZSBweS0xMiBib3JkZXItdCBib3JkZXItc2xhdGUtMjAwIj4KPGRpdiBjbGFzcz0ibWF4LXctWzEyODBweF0gbXgtYXV0byBweC00IHNtOnB4LTYgbGc6cHgtOCI+CjxoMiBjbGFzcz0idGV4dC0yeGwgZm9udC1ib2xkIHRleHQtbmF2eSBtYi04IHRleHQtY2VudGVyIj5EYXMgaw29ubnRlIFNpZSBhdWNoIGludGVyZXNzaWVyZW48L2gyPgo8ZGl2IGNsYXNzPSJncmlkIG1kOmdyaWQtY29scy0zIGdhcC02Ij4KPGEgaHJlZj0iL2Jsb2cvb3V0ZG9vci16dWJlaG9lci1jYW1waW5nLW9lc3RlcnJlaWNoLmh0bWwiIGNsYXNzPSJibG9jayBwLTYgYmctbmF2eSByb3VuZGVkLXhsIGhvdmVyOmJnLW5hdnktbGlnaHQgdHJhbnNpdGlvbi1jb2xvcnMiPgo8aDMgY2xhc3M9InRleHQtd2hpdGUgZm9udC1zZW1pYm9sZCBtYi0yIj5PdXRkb29yIFp1YmVoc m8gZsO8ciBDYW1waW5nIGluIMOc3RlcnJlaWNoPC9oMz4KPHAgY2xhc3M9InRleHQtc20gdGV4dC1zbGF0ZS00MDAiPkNhbXBpbmctQ2hlY2tsaXN0ZSAyMDI2IC0gdm9tIFplbHQgYmlzIHp1ciBUYXNjaGVubGFtcGUuPC9wPgo8L2E+CjxhIGhyZWY9Ii9ibG9nL291dGRvb3Item9iZWhvZXItZnVlci1kZW4tc29tbWVyLmh0bWwiIGNsYXNzPSJibG9jayBwLTYgYmctbmF2eSByb3VuZGVkLXhsIGhvdmVyOmJnLW5hdnktbGlnaHQgdHJhbnNpdGlvbi1jb2xvcnMiPgo8aDMgY2xhc3M9InRleHQtd2hpdGUgZm9udC1zZW1pYm9sZCBtYi0yIj5PdXRkb29yLVp1YmVoc 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