PGh0bWwgeG1sbnM6dj0idXJuOnNjaGVtYXMtbWljcm9zb2Z0LWNvbTp2bWwiCnhtbG5zOm89InVybjpzY2hlbWFzLW1pY3Jvc29mdC1jb206b2ZmaWNlOm9mZmljZSIKeG1sbnM6cD0idXJuOnNjaGVtYXMtbWljcm9zb2Z0LWNvbTpvZmZpY2U6cG93ZXJwb2ludCIKeG1sbnM6b2E9InVybjpzY2hlbWFzLW1pY3Jvc29mdC1jb206b2ZmaWNlOmFjdGl2YXRpb24iCnhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy9UUi9SRUMtaHRtbDQwIj4KCjxoZWFkPgo8bWV0YSBodHRwLWVxdWl2PUNvbnRlbnQtVHlwZSBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9d2luZG93cy0xMjUyIj4KPG1ldGEgbmFtZT1Qcm9nSWQgY29udGVudD1Qb3dlclBvaW50LlNsaWRlPgo8bWV0YSBuYW1lPUdlbmVyYXRvciBjb250ZW50PSJNaWNyb3NvZnQgUG93ZXJQb2ludCAxMCI+CjxsaW5rIGlkPU1haW4tRmlsZSByZWw9TWFpbi1GaWxlIGhyZWY9Ii4uL0VjbGlwc2VDb24yMDA3X1Nob3J0VGFsay5odG1sIj4KPGxpbmsgcmVsPVByZXZpZXcgaHJlZj1wcmV2aWV3LndtZj4KPG1ldGEgbmFtZT1Sb2JvdHMgY29udGVudD1Ob0luZGV4Pgo8bGluayByZWw9U3R5bGVzaGVldCBocmVmPSJtYXN0ZXIwOF9zdHlsZXNoZWV0LmNzcyI+CjwhW2lmICFwcHRdPjxzY3JpcHQgc3JjPXNjcmlwdC5qcz48L3NjcmlwdD48c2NyaXB0Pgo8IS0tCglwYXJlbnQubG9jYXRpb24uaHJlZj1kb2N1bWVudC5hbGwuaXRlbSgiTWFpbi1GaWxlIikuaHJlZgovLy0tPgo8L3NjcmlwdD4KPCFbZW5kaWZdPgo8L2hlYWQ+Cgo8Ym9keT4KCjxkaXYgdjpzaGFwZT0iX3gwMDAwX20zMjc3NCIgY2xhc3M9VD48c3BhbiBsYW5nPUVOLVVTIHN0eWxlPSdtc28tYW5zaS1sYW5ndWFnZToKRU4tVVMnPkNsaWNrIHRvIGVkaXQgTWFzdGVyIHRpdGxlIHN0eWxlPC9zcGFuPjwvZGl2PgoKPGRpdiB2OnNoYXBlPSJfeDAwMDBfbTMyNzc1Ij4KCjxkaXYgY2xhc3M9Qj48c3BhbiBsYW5nPUVOLVVTIHN0eWxlPSdtc28tYW5zaS1sYW5ndWFnZTpFTi1VUyc+Q2xpY2sgdG8gZWRpdApNYXN0ZXIgdGV4dCBzdHlsZXMmIzEzOzwvc3Bhbj48L2Rpdj4KCjxkaXYgY2xhc3M9QjE+PHNwYW4gbGFuZz1FTi1VUyBzdHlsZT0nbXNvLWFuc2ktbGFuZ3VhZ2U6RU4tVVMnPlNlY29uZApsZXZlbCYjMTM7PC9zcGFuPjwvZGl2PgoKPGRpdiBjbGFzcz1CMj48c3BhbiBsYW5nPUVOLVVTIHN0eWxlPSdtc28tYW5zaS1sYW5ndWFnZTpFTi1VUyc+VGhpcmQgbGV2ZWwmIzEzOzwvc3Bhbj48L2Rpdj4KCjxkaXYgY2xhc3M9QjM+PHNwYW4gbGFuZz1FTi1VUyBzdHlsZT0nbXNvLWFuc2ktbGFuZ3VhZ2U6RU4tVVMnPkZvdXJ0aApsZXZlbCYjMTM7PC9zcGFuPjwvZGl2PgoKPGRpdiBjbGFzcz1CND48c3BhbiBsYW5nPUVOLVVTIHN0eWxlPSdtc28tYW5zaS1sYW5ndWFnZTpFTi1VUyc+RmlmdGggbGV2ZWw8L3NwYW4+PC9kaXY+Cgo8L2Rpdj4KCjxkaXYgdjpzaGFwZT0iX3gwMDAwX3MzMzAyMiIgY2xhc3M9TyBzdHlsZT0nbXNvLWxpbmUtc3BhY2luZzoiMTAwIDUwIDAiJz48c3BhbgpsYW5nPUVOLVVTIHN0eWxlPSdmb250LWZhbWlseTpBcmlhbDttc28taGFuc2ktZm9udC1mYW1pbHk6QXJpYWw7Zm9udC1zaXplOjU2JTsKY29sb3I6YmxhY2s7bXNvLWNvbG9yLWluZGV4OjA7bXNvLWFuc2ktbGFuZ3VhZ2U6RU4tVVM7bXNvLWZpZWxkLWNvZGU6bWV0YTE2Jz48Yj6LI5s8L2I+PC9zcGFuPjxzcGFuCmxhbmc9RU4tVVMgc3R5bGU9J21zby1oYW5zaS1mb250LWZhbWlseTpBcmlhbDtmb250LXNpemU6NTYlO2NvbG9yOmJsYWNrOwptc28tY29sb3ItaW5kZXg6MDttc28tYW5zaS1sYW5ndWFnZTpFTi1VUzttc28tc3BlY2lhbC1mb3JtYXQ6bGFzdENSJz48Yj4mIzEzOzwvYj48L3NwYW4+PC9kaXY+Cgo8ZGl2IHY6c2hhcGU9Il94MDAwMF9zMzMwMjQiIGNsYXNzPU8gc3R5bGU9J21zby1jaGFyLXdyYXA6MDttc28ta2luc29rdS1vdmVyZmxvdzoKMCc+PHNwYW4gbGFuZz1FTi1VUyBzdHlsZT0nZm9udC1zaXplOjU2JTtjb2xvcjpibGFjazttc28tY29sb3ItaW5kZXg6MDsKbXNvLWFuc2ktbGFuZ3VhZ2U6RU4tVVMnPjxzcGFuIHN0eWxlPSdtc28tc3BhY2VydW46eWVzJz6gPC9zcGFuPldoYXQgaXMKTURUPzxzcGFuIHN0eWxlPSdtc28tc3BhY2VydW46eWVzJz6gIDwvc3Bhbj58PHNwYW4gc3R5bGU9J21zby1zcGFjZXJ1bjp5ZXMnPqAKPC9zcGFuPlNob3J0IFRhbGs8c3BhbiBzdHlsZT0nbXNvLXNwYWNlcnVuOnllcyc+oCA8L3NwYW4+fDxzcGFuCnN0eWxlPSdtc28tc3BhY2VydW46eWVzJz6gIDwvc3Bhbj6pIENvcHlyaWdodCAyMDA3IGJ5IElCTSBDb3JwLjsgbWFkZSBhdmFpbGFibGUKdW5kZXIgdGhlIEVQTCB2MS4wPC9zcGFuPjwvZGl2PgoKPC9ib2R5PgoKPC9odG1sPgo=