UmV0dXJuLVBhdGg6IDx4eEB4eC5kaz4KUmVjZWl2ZWQ6IGZyb20gZmVwRC5wb3N0LnRlbGUuZGsgKDE5NS40MS40Ni4xNDkpIGJ5IG1haWwuZ3JvdXBjYXJlLmRrIChMU01UUCBmb3IgV2luZG93cyBOVCB2MS4xYikgd2l0aCBTTVRQIGlkIDwwLjAwMTRGOEEyQG1haWwuZ3JvdXBjYXJlLmRrPjsgTW9uLCAzMCBBcHIgMjAwMSAxMjoxNzo1MCArMDIwMApVc2VyLUFnZW50OiBNaWNyb3NvZnQtT3V0bG9vay1FeHByZXNzLU1hY2ludG9zaC1FZGl0aW9uLzUuMDIuMjEwNgpTdWJqZWN0OiBYWApGcm9tOiB4eEB4eC5kawpUbzogWFgKTWVzc2FnZS1JRDogPHh4eHg+Ck1pbWUtdmVyc2lvbjogMS4wCkNvbnRlbnQtdHlwZTogbXVsdGlwYXJ0L21peGVkOwogICBib3VuZGFyeT0iTVNfTWFjX09FXzMwNzE0Nzc4NDdfNzIwMjUyX01JTUVfUGFydCIKCj4gRGVubmUgbWVkZGVsZWxzZSBlciBpIE1JTUUtZm9ybWF0LiBEYSBkaXQgcG9zdGy+c25pbmdzcHJvZ3JhbSBpa2tlIGZvcnN0jHIgZGV0dGUgZm9ybWF0LCBrYW4gZGVsIGFmIGVsbGVyIGhlbGUgbWVkZGVsZWxzZW4gdr5yZSB1bL5zZWxpZy4KCi0tTVNfTWFjX09FXzMwNzE0Nzc4NDdfNzIwMjUyX01JTUVfUGFydApDb250ZW50LXR5cGU6IG11bHRpcGFydC9hbHRlcm5hdGl2ZTsKICAgYm91bmRhcnk9Ik1TX01hY19PRV8zMDcxNDc3ODQ3XzcyMDI1Ml9NSU1FX1BhcnQiCgoKLS1NU19NYWNfT0VfMzA3MTQ3Nzg0N183MjAyNTJfTUlNRV9QYXJ0CkNvbnRlbnQtdHlwZTogdGV4dC9wbGFpbjsgY2hhcnNldD0iSVNPLTg4NTktMSIKQ29udGVudC10cmFuc2Zlci1lbmNvZGluZzogcXVvdGVkLXByaW50YWJsZQoKU29tZSByZW1vdmVkIHRlc3QuIAoKLS1NU19NYWNfT0VfMzA3MTQ3Nzg0N183MjAyNTJfTUlNRV9QYXJ0CkNvbnRlbnQtdHlwZTogdGV4dC9odG1sOyBjaGFyc2V0PSJJU08tODg1OS0xIgpDb250ZW50LXRyYW5zZmVyLWVuY29kaW5nOiBxdW90ZWQtcHJpbnRhYmxlCgo8SFRNTD4KPEhFQUQ+CjxUSVRMRT5Tb21lIHJlbW92ZWQgSFRNTDwvVElUTEU+CjwvSEVBRD4KPEJPRFk+ClNvbWUgcmVtb3ZlZCB0ZXh0Lgo8L0JPRFk+CjwvSFRNTD4KCgotLU1TX01hY19PRV8zMDcxNDc3ODQ3XzcyMDI1Ml9NSU1FX1BhcnQtLQoKCi0tTVNfTWFjX09FXzMwNzE0Nzc4NDdfNzIwMjUyX01JTUVfUGFydApDb250ZW50LXR5cGU6IGltYWdlL2dpZjsgbmFtZT0ieHguZ2lmIjsKIHgtbWFjLWNyZWF0b3I9IjZGNjc2QzY1IjsKIHgtbWFjLXR5cGU9IjQ3NDk0NjY2IgpDb250ZW50LWRpc3Bvc2l0aW9uOiBhdHRhY2htZW50CkNvbnRlbnQtdHJhbnNmZXItZW5jb2Rpbmc6IGJhc2U2NAoKU29tZSByZW1vdmVkIGJhc2U2NCBlbmNvZGVkIGNoYXJzLgoKLS1NU19NYWNfT0VfMzA3MTQ3Nzg0N183MjAyNTJfTUlNRV9QYXJ0LS0KCg==