ZGlmZiAtLWdpdCBhL3J1bnRpbWUvZG9jL2VkaXRpbmcudHh0IGIvcnVudGltZS9kb2MvZWRpdGluZy50eHQKaW5kZXggOTZiY2I5My4uZjZlMzgxMCAxMDA2NDQKLS0tIGEvcnVudGltZS9kb2MvZWRpdGluZy50eHQKKysrIGIvcnVudGltZS9kb2MvZWRpdGluZy50eHQKQEAgLTEsNCArMSw0IEBACi0qZWRpdGluZy50eHQqICAgRm9yIFZpbSB2ZXJzaW9uIDguMi4gIExhc3QgY2hhbmdlOiAyMDE5IERlYyAyMgorKmVkaXRpbmcudHh0KiAgIEZvciBWaW0gdmVyc2lvbiA4LjIuICBMYXN0IGNoYW5nZTogMjAyMCBNYXkgMTIKIAogCiAJCSAgVklNIFJFRkVSRU5DRSBNQU5VQUwgICAgYnkgQnJhbSBNb29sZW5hYXIKQEAgLTQ3NSw2ICs0NzUsOSBAQAogCTp3ICsrZW5jPWxhdGluMSBuZXdmaWxlCiBUaGlzIHdyaXRlcyB0aGUgY3VycmVudCBidWZmZXIgdG8gIm5ld2ZpbGUiIGluIGxhdGluMSBmb3JtYXQuCiAKK1RoZSBtZXNzYWdlIGdpdmVuIHdoZW4gd3JpdGluZyBhIGZpbGUgd2lsbCBzaG93ICJbY29udmVydGVkXSIgd2hlbgorJ2ZpbGVlbmNvZGluZycgb3IgdGhlIHZhbHVlIHNwZWNpZmllZCB3aXRoICsrZW5jIGRpZmZlcnMgZnJvbSAnZW5jb2RpbmcnLgorCiBUaGVyZSBtYXkgYmUgc2V2ZXJhbCArK29wdCBhcmd1bWVudHMsIHNlcGFyYXRlZCBieSB3aGl0ZSBzcGFjZS4gIFRoZXkgbXVzdCBhbGwKIGFwcGVhciBiZWZvcmUgYW55IHwrY21kfCBhcmd1bWVudC4KIApAQCAtMTA3OSw5ICsxMDgyLDkgQEAKIAogCQkJCQkJCSo6cSogKjpxdWl0KgogOnFbdWl0XQkJCVF1aXQgdGhlIGN1cnJlbnQgd2luZG93LiAgUXVpdCBWaW0gaWYgdGhpcyBpcyB0aGUgbGFzdAotCQkJd2luZG93LiAgVGhpcyBmYWlscyB3aGVuIGNoYW5nZXMgaGF2ZSBiZWVuIG1hZGUgYW5kCi0JCQlWaW0gcmVmdXNlcyB0byB8YWJhbmRvbnwgdGhlIGN1cnJlbnQgYnVmZmVyLCBhbmQgd2hlbgotCQkJdGhlIGxhc3QgZmlsZSBpbiB0aGUgYXJndW1lbnQgbGlzdCBoYXMgbm90IGJlZW4KKwkJCXxlZGl0LXdpbmRvd3wuICBUaGlzIGZhaWxzIHdoZW4gY2hhbmdlcyBoYXZlIGJlZW4gbWFkZQorCQkJYW5kIFZpbSByZWZ1c2VzIHRvIHxhYmFuZG9ufCB0aGUgY3VycmVudCBidWZmZXIsIGFuZAorCQkJd2hlbiB0aGUgbGFzdCBmaWxlIGluIHRoZSBhcmd1bWVudCBsaXN0IGhhcyBub3QgYmVlbgogCQkJZWRpdGVkLgogCQkJSWYgdGhlcmUgYXJlIG90aGVyIHRhYiBwYWdlcyBhbmQgcXVpdHRpbmcgdGhlIGxhc3QKIAkJCXdpbmRvdyBpbiB0aGUgY3VycmVudCB0YWIgcGFnZSB0aGUgY3VycmVudCB0YWIgcGFnZSBpcwpAQCAtMTEwNywxOCArMTExMCwyMiBAQAogCQkJfHF1aWNrZml4fCkuCiAKIAkJCQkJCQkqOndxKgotOndxIFsrK29wdF0JCVdyaXRlIHRoZSBjdXJyZW50IGZpbGUgYW5kIHF1aXQuICBXcml0aW5nIGZhaWxzIHdoZW4KLQkJCXRoZSBmaWxlIGlzIHJlYWQtb25seSBvciB0aGUgYnVmZmVyIGRvZXMgbm90IGhhdmUgYQotCQkJbmFtZS4gIFF1aXR0aW5nIGZhaWxzIHdoZW4gdGhlIGxhc3QgZmlsZSBpbiB0aGUKLQkJCWFyZ3VtZW50IGxpc3QgaGFzIG5vdCBiZWVuIGVkaXRlZC4KKzp3cSBbKytvcHRdCQlXcml0ZSB0aGUgY3VycmVudCBmaWxlIGFuZCBjbG9zZSB0aGUgd2luZG93LiAgSWYgdGhpcworCQkJd2FzIHRoZSBsYXN0IHxlZGl0LXdpbmRvd3wgVmltIHF1aXRzLgorCQkJV3JpdGluZyBmYWlscyB3aGVuIHRoZSBmaWxlIGlzIHJlYWQtb25seSBvciB0aGUgYnVmZmVyCisJCQlkb2VzIG5vdCBoYXZlIGEgbmFtZS4gIFF1aXR0aW5nIGZhaWxzIHdoZW4gdGhlIGxhc3QKKwkJCWZpbGUgaW4gdGhlIGFyZ3VtZW50IGxpc3QgaGFzIG5vdCBiZWVuIGVkaXRlZC4KIAotOndxISBbKytvcHRdCQlXcml0ZSB0aGUgY3VycmVudCBmaWxlIGFuZCBxdWl0LiAgV3JpdGluZyBmYWlscyB3aGVuCi0JCQl0aGUgY3VycmVudCBidWZmZXIgZG9lcyBub3QgaGF2ZSBhIG5hbWUuCis6d3EhIFsrK29wdF0JCVdyaXRlIHRoZSBjdXJyZW50IGZpbGUgYW5kIGNsb3NlIHRoZSB3aW5kb3cuICBJZiB0aGlzCisJCQl3YXMgdGhlIGxhc3QgfGVkaXQtd2luZG93fCBWaW0gcXVpdHMuICBXcml0aW5nIGZhaWxzCisJCQl3aGVuIHRoZSBjdXJyZW50IGJ1ZmZlciBkb2VzIG5vdCBoYXZlIGEgbmFtZS4KIAotOndxIFsrK29wdF0ge2ZpbGV9CVdyaXRlIHRvIHtmaWxlfSBhbmQgcXVpdC4gIFF1aXR0aW5nIGZhaWxzIHdoZW4gdGhlCis6d3EgWysrb3B0XSB7ZmlsZX0JV3JpdGUgdG8ge2ZpbGV9IGFuZCBjbG9zZSB0aGUgd2luZG93LiAgSWYgdGhpcyB3YXMgdGhlCisJCQlsYXN0IHxlZGl0LXdpbmRvd3wgVmltIHF1aXRzLiAgUXVpdHRpbmcgZmFpbHMgd2hlbiB0aGUKIAkJCWxhc3QgZmlsZSBpbiB0aGUgYXJndW1lbnQgbGlzdCBoYXMgbm90IGJlZW4gZWRpdGVkLgogCi06d3EhIFsrK29wdF0ge2ZpbGV9CVdyaXRlIHRvIHtmaWxlfSBhbmQgcXVpdC4KKzp3cSEgWysrb3B0XSB7ZmlsZX0JV3JpdGUgdG8ge2ZpbGV9IGFuZCBjbG9zZSB0aGUgY3VycmVudCB3aW5kb3cuICBRdWl0CisJCQlWaW0gaWYgdGhpcyB3YXMgdGhlIGxhc3QgfGVkaXQtd2luZG93fC4KIAogOltyYW5nZV13cVshXSBbKytvcHRdIFtmaWxlXQogCQkJU2FtZSBhcyBhYm92ZSwgYnV0IG9ubHkgd3JpdGUgdGhlIGxpbmVzIGluIFtyYW5nZV0uCkBAIC0xMTM1LDEwICsxMTQyLDEwIEBACiAJCQlTYW1lIGFzIDp4aXQuCiAKIAkJCQkJCQkqWloqCi1aWgkJCVdyaXRlIGN1cnJlbnQgZmlsZSwgaWYgbW9kaWZpZWQsIGFuZCBxdWl0IChzYW1lIGFzCi0JCQkiOngiKS4gIChOb3RlOiBJZiB0aGVyZSBhcmUgc2V2ZXJhbCB3aW5kb3dzIGZvciB0aGUKLQkJCWN1cnJlbnQgZmlsZSwgdGhlIGZpbGUgaXMgd3JpdHRlbiBpZiBpdCB3YXMgbW9kaWZpZWQKLQkJCWFuZCB0aGUgd2luZG93IGlzIGNsb3NlZCkuCitaWgkJCVdyaXRlIGN1cnJlbnQgZmlsZSwgaWYgbW9kaWZpZWQsIGFuZCBjbG9zZSB0aGUgY3VycmVudAorCQkJd2luZG93IChzYW1lIGFzICI6eCIpLgorCQkJSWYgdGhlcmUgYXJlIHNldmVyYWwgd2luZG93cyBmb3IgdGhlIGN1cnJlbnQgZmlsZSwKKwkJCW9ubHkgdGhlIGN1cnJlbnQgd2luZG93IGlzIGNsb3NlZC4KIAogCQkJCQkJCSpaUSoKIFpRCQkJUXVpdCB3aXRob3V0IGNoZWNraW5nIGZvciBjaGFuZ2VzIChzYW1lIGFzICI6cSEiKS4KZGlmZiAtLWdpdCBhL3J1bnRpbWUvZG9jL2luZGV4LnR4dCBiL3J1bnRpbWUvZG9jL2luZGV4LnR4dAppbmRleCAzMTVhNWYzLi43OGQ1NTdmIDEwMDY0NAotLS0gYS9ydW50aW1lL2RvYy9pbmRleC50eHQKKysrIGIvcnVudGltZS9kb2MvaW5kZXgudHh0CkBAIC0xLDQgKzEsNCBAQAotKmluZGV4LnR4dCogICAgIEZvciBWaW0gdmVyc2lvbiA4LjIuICBMYXN0IGNoYW5nZTogMjAyMCBBcHIgMjYKKyppbmRleC50eHQqICAgICBGb3IgVmltIHZlcnNpb24gOC4yLiAgTGFzdCBjaGFuZ2U6IDIwMjAgTWF5IDEwCiAKIAogCQkgIFZJTSBSRUZFUkVOQ0UgTUFOVUFMICAgIGJ5IEJyYW0gTW9vbGVuYWFyCkBAIC0zNjQsOCArMzY0LDggQEAKIAkJCQkgICByZWdpc3RlciB4XQogfFl8CQlbInhdWQkJICAgeWFuayBOIGxpbmVzIFtpbnRvIHJlZ2lzdGVyIHhdOyBzeW5vbnltIGZvcgogCQkJCSAgICJ5eSIKLXxaWnwJCVpaCQkgICBzdG9yZSBjdXJyZW50IGZpbGUgaWYgbW9kaWZpZWQsIGFuZCBleGl0Ci18WlF8CQlaUQkJICAgZXhpdCBjdXJyZW50IGZpbGUgYWx3YXlzCit8Wlp8CQlaWgkJICAgd3JpdGUgaWYgYnVmZmVyIGNoYW5nZWQgYW5kIGNsb3NlIHdpbmRvdworfFpRfAkJWlEJCSAgIGNsb3NlIHdpbmRvdyB3aXRob3V0IHdyaXRpbmcKIHxbfAkJW3tjaGFyfQkJICAgc3F1YXJlIGJyYWNrZXQgY29tbWFuZCAoc2VlIHxbfCBiZWxvdykKIAkJXAkJICAgbm90IHVzZWQKIHxdfAkJXXtjaGFyfQkJICAgc3F1YXJlIGJyYWNrZXQgY29tbWFuZCAoc2VlIHxdfCBiZWxvdykKQEAgLTE3MjEsNyArMTcyMSw3IEBACiB8OndxYWxsfAk6d3FhW2xsXQl3cml0ZSBhbGwgY2hhbmdlZCBidWZmZXJzIGFuZCBxdWl0IFZpbQogfDp3dW5kb3wJOnd1W25kb10Jd3JpdGUgdW5kbyBpbmZvcm1hdGlvbiB0byBhIGZpbGUKIHw6d3ZpbWluZm98CTp3dltpbWluZm9dCXdyaXRlIHRvIHZpbWluZm8gZmlsZQotfDp4aXR8CQk6eFtpdF0JCXdyaXRlIGlmIGJ1ZmZlciBjaGFuZ2VkIGFuZCBxdWl0IHdpbmRvdyBvciBWaW0KK3w6eGl0fAkJOnhbaXRdCQl3cml0ZSBpZiBidWZmZXIgY2hhbmdlZCBhbmQgY2xvc2Ugd2luZG93CiB8OnhhbGx8CQk6eGFbbGxdCQlzYW1lIGFzICI6d3FhbGwiCiB8OnhtYXBjbGVhcnwJOnhtYXBjW2xlYXJdCXJlbW92ZSBhbGwgbWFwcGluZ3MgZm9yIFZpc3VhbCBtb2RlCiB8OnhtYXB8CQk6eG1bYXBdCQlsaWtlICI6bWFwIiBidXQgZm9yIFZpc3VhbCBtb2RlCmRpZmYgLS1naXQgYS9ydW50aW1lL2RvYy9wb3B1cC50eHQgYi9ydW50aW1lL2RvYy9wb3B1cC50eHQKaW5kZXggMjY0MzVkMS4uOTA0MWY4NyAxMDA2NDQKLS0tIGEvcnVudGltZS9kb2MvcG9wdXAudHh0CisrKyBiL3J1bnRpbWUvZG9jL3BvcHVwLnR4dApAQCAtMSw0ICsxLDQgQEAKLSpwb3B1cC50eHQqICBGb3IgVmltIHZlcnNpb24gOC4yLiAgTGFzdCBjaGFuZ2U6IDIwMjAgQXByIDEzCisqcG9wdXAudHh0KiAgRm9yIFZpbSB2ZXJzaW9uIDguMi4gIExhc3QgY2hhbmdlOiAyMDIwIE1heSAxMgogCiAKIAkJICBWSU0gUkVGRVJFTkNFIE1BTlVBTCAgICBieSBCcmFtIE1vb2xlbmFhcgpAQCAtMTUwLDYgKzE1MCw3IEBACiAtIFdoZW4gdGhlIGpvYiBlbmRzLCB0aGUgcG9wdXAgd2luZG93IGNsb3Nlcy4KIC0gVGhlIHBvcHVwIHdpbmRvdyBjYW4gYmUgY2xvc2VkIHdpdGggYHBvcHVwX2Nsb3NlKClgLCB0aGUgdGVybWluYWwgYnVmZmVyCiAgIHRoZW4gYmVjb21lcyBoaWRkZW4uCistIEl0IGlzIG5vdCBwb3NzaWJsZSB0byBlbnRlciBUZXJtaW5hbC1Ob3JtYWwgbW9kZS4KIC0gVGhlIGRlZmF1bHQgUG1lbnUgY29sb3IgaXMgb25seSB1c2VkIGZvciB0aGUgYm9yZGVyIGFuZCBwYWRkaW5nLiAgVG8gY2hhbmdlCiAgIHRoZSBjb2xvciBvZiB0aGUgdGVybWluYWwgaXRzZWxmIHNldCB0aGUgVGVybWluYWwgaGlnaGxpZ2h0IGdyb3VwIGJlZm9yZQogICBjcmVhdGluZyB0aGUgdGVybWluYWwuICBTZXR0aW5nICd3aW5jb2xvcicgbGF0ZXIgY2FuIHdvcmsgYnV0IHJlcXVpcmVzIHRoZQpkaWZmIC0tZ2l0IGEvcnVudGltZS9kb2MvcmVjb3Zlci50eHQgYi9ydW50aW1lL2RvYy9yZWNvdmVyLnR4dAppbmRleCAwYmFiNjRhLi4zNGY3ZjE4IDEwMDY0NAotLS0gYS9ydW50aW1lL2RvYy9yZWNvdmVyLnR4dAorKysgYi9ydW50aW1lL2RvYy9yZWNvdmVyLnR4dApAQCAtMSw0ICsxLDQgQEAKLSpyZWNvdmVyLnR4dCogICBGb3IgVmltIHZlcnNpb24gOC4yLiAgTGFzdCBjaGFuZ2U6IDIwMjAgTWFyIDI0CisqcmVjb3Zlci50eHQqICAgRm9yIFZpbSB2ZXJzaW9uIDguMi4gIExhc3QgY2hhbmdlOiAyMDIwIE1heSAwOQogCiAKIAkJICBWSU0gUkVGRVJFTkNFIE1BTlVBTCAgICBieSBCcmFtIE1vb2xlbmFhcgpAQCAtMTI1LDEyICsxMjUsMTIgQEAKIGNvbW1hbmQ6CiAKIAkJCQkJKjpwcmUqICo6cHJlc2VydmUqICpFMzEzKiAqRTMxNCoKLTpwcmVbc2VydmVdCQlXcml0ZSBhbGwgdGV4dCBmb3IgYWxsIGJ1ZmZlcnMgaW50byBzd2FwIGZpbGVzLiAgVGhlCi0JCQlvcmlnaW5hbCBmaWxlIGlzIG5vIGxvbmdlciBuZWVkZWQgZm9yIHJlY292ZXJ5LgotCQkJVGhpcyBzZXRzIGEgZmxhZyBpbiB0aGUgY3VycmVudCBidWZmZXIuICBXaGVuIHRoZSAnJicKLQkJCWZsYWcgaXMgcHJlc2VudCBpbiAnY3BvcHRpb25zJyB0aGUgc3dhcCBmaWxlIHdpbGwgbm90Ci0JCQliZSBkZWxldGVkIGZvciB0aGlzIGJ1ZmZlciB3aGVuIFZpbSBleGl0cyBhbmQgdGhlCi0JCQlidWZmZXIgaXMgc3RpbGwgbG9hZGVkIHxjcG8tJnwuCis6cHJlW3NlcnZlXQkJV3JpdGUgYWxsIHRleHQgZm9yIHRoZSBjdXJyZW50IGJ1ZmZlciBpbnRvIGl0cyBzd2FwCisJCQlmaWxlLiAgVGhlIG9yaWdpbmFsIGZpbGUgaXMgbm8gbG9uZ2VyIG5lZWRlZCBmb3IKKwkJCXJlY292ZXJ5LiAgVGhpcyBzZXRzIGEgZmxhZyBpbiB0aGUgY3VycmVudCBidWZmZXIuCisJCQlXaGVuIHRoZSAnJicgZmxhZyBpcyBwcmVzZW50IGluICdjcG9wdGlvbnMnIHRoZSBzd2FwCisJCQlmaWxlIHdpbGwgbm90IGJlIGRlbGV0ZWQgZm9yIHRoaXMgYnVmZmVyIHdoZW4gVmltCisJCQlleGl0cyBhbmQgdGhlIGJ1ZmZlciBpcyBzdGlsbCBsb2FkZWQgfGNwby0mfC4KIAogQSBWaW0gc3dhcCBmaWxlIGNhbiBiZSByZWNvZ25pemVkIGJ5IHRoZSBmaXJzdCBzaXggY2hhcmFjdGVyczogImIwVklNICIuCiBBZnRlciB0aGF0IGNvbWVzIHRoZSB2ZXJzaW9uIG51bWJlciwgZS5nLiwgIjMuMCIuCmRpZmYgLS1naXQgYS9ydW50aW1lL2RvYy90YWdzIGIvcnVudGltZS9kb2MvdGFncwppbmRleCBlOGQ3ZDI1Li4xOGU4OGY1IDEwMDY0NAotLS0gYS9ydW50aW1lL2RvYy90YWdzCisrKyBiL3J1bnRpbWUvZG9jL3RhZ3MKQEAgLTYxMjcsNiArNjEyNyw3IEBACiBlZGl0LWludHJvCWVkaXRpbmcudHh0CS8qZWRpdC1pbnRybyoKIGVkaXQtbm8tYnJlYWsJdXNyXzI1LnR4dAkvKmVkaXQtbm8tYnJlYWsqCiBlZGl0LXBhcmFncmFwaC1qb2luCXVzcl8yNS50eHQJLyplZGl0LXBhcmFncmFwaC1qb2luKgorZWRpdC13aW5kb3cJd2luZG93cy50eHQJLyplZGl0LXdpbmRvdyoKIGVkaXRpbmcudHh0CWVkaXRpbmcudHh0CS8qZWRpdGluZy50eHQqCiBlZm0tJT4JcXVpY2tmaXgudHh0CS8qZWZtLSU+KgogZWZtLWVudHJpZXMJcXVpY2tmaXgudHh0CS8qZWZtLWVudHJpZXMqCmRpZmYgLS1naXQgYS9ydW50aW1lL2RvYy90b2RvLnR4dCBiL3J1bnRpbWUvZG9jL3RvZG8udHh0CmluZGV4IDdiYzM5NDUuLmFjYzU1ZmUgMTAwNjQ0Ci0tLSBhL3J1bnRpbWUvZG9jL3RvZG8udHh0CisrKyBiL3J1bnRpbWUvZG9jL3RvZG8udHh0CkBAIC0xLDQgKzEsNCBAQAotKnRvZG8udHh0KiAgICAgIEZvciBWaW0gdmVyc2lvbiA4LjIuICBMYXN0IGNoYW5nZTogMjAyMCBNYXkgMDcKKyp0b2RvLnR4dCogICAgICBGb3IgVmltIHZlcnNpb24gOC4yLiAgTGFzdCBjaGFuZ2U6IDIwMjAgTWF5IDExCiAKIAogCQkgIFZJTSBSRUZFUkVOQ0UgTUFOVUFMCSAgYnkgQnJhbSBNb29sZW5hYXIKQEAgLTM4LDIzICszOCwyMiBAQAogCQkJCQkJCSprbm93bi1idWdzKgogLS0tLS0tLS0tLS0tLS0tLS0tLS0gS25vd24gYnVncyBhbmQgY3VycmVudCB3b3JrIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAKK1BhdGNoIHRvIHRlc3QgVEVSTSBzaWduYWwuIChEb21pbmlxdWUsICM2MDU1KQorCitJbmNsdWRlIHNyYy9wby92aW0ucG90CisKIFZpbTkgc2NyaXB0OgotQmlnIGNoYW5nZXMsIG1heSBuZWVkIGRlc2lnbjoKLS0gTWFrZSBjbG9zdXJlcyB3b3JrOgorTWFrZSBjbG9zdXJlcyB3b3JrOgogICAtIGNhbGwgY2xvc3VyZSBmcm9tIG5vdCBjb21waWxlZCBjb250ZXh0CiAgIC0gQ3JlYXRlIGNsb3N1cmUgaW4gYSBsb29wLiAgTmVlZCB0byBtYWtlIGEgbGlzdCBvZiB0aGVtLgotLSBIYXZpbmcgY29uc3RhbnQgZXhwciBldmFsdWF0aW9uIHNlcGFyYXRlIGRvZXMgbm90IHNjYWxlLgotICBGaXJzdCBwYXJzZSB0aGUgZXhwcmVzc2lvbiwgdGhlbiBzaW1wbGlmeSwgdGhlbiBnZW5lcmF0ZSBjb2RlLgotLSBBdCB0aGUgdmltOSBzY3JpcHQgbGV2ZWw6IEFsbG93IHVzaW5nIGEgZnVuY3Rpb24gdGhhdCBpcyBkZWZpbmVkIGxhdGVyLgotICBSZXF1aXJlcyBjb21waWxpbmcgZnVuY3Rpb25zIG9ubHkgd2hlbiB0aGUgd2hvbGUgc2NyaXB0IGhhcyBiZWVuIHNvdXJjZWQuCi0gIExpa2UgSmF2YXNjcmlwdCAiaG9pc3RpbmciLCBidXQgb25seSBhdCB0aGUgc2NyaXB0IGxldmVsOgotICAwLiBJZiBzY3JpcHQgd2FzIHNvdXJjZWQgYmVmb3JlLCBjbGVhciBhbGwgc2NyaXB0LWxvY2FsIGZ1bmN0aW9ucyBhbmQKLSAgICAgdmFyaWFibGVzLiAodmFyaWFibGVzIHN0aWxsIHRvIGJlIGltcGxlbWVudGVkKQotICAxLiBEaXNjb3ZlcnkgcGhhc2U6IFJlYWQgdGhlIGZpbGUgdG8gZmluZCBhbGwgZnVuY3Rpb25zLCB2YXJpYWJsZQotICAgICBkZWNsYXJhdGlvbnMgYW5kIGltcG9ydHMgSWYgYSB2YXJpYWJsZSBoYXMgYSBjb25zdGFudCBleHByZXNzaW9uIHdlIGdldAotICAgICB0aGUgdHlwZSwgb3RoZXJ3aXNlIGl0IHdpbGwgYmUgImFueSIuICBGb2xsb3cgaW1wb3J0cyByZWN1cnNpdmVseS4KLSAgMi4gQ29tcGlsYXRpb24gcGhhc2U6IGNvbXBpbGUgOmRlZiBmdW5jdGlvbiBib2RpZXMsIHVzaW5nIGRlY2xhcmVkIHR5cGVzCi0gIDMuIEV4ZWN1dGlvbiBwaGFzZTogRXhlY3V0ZSBpbXBvcnRzIHdoZW4gZW5jb3VudGVyZWQuIChza2lwIG92ZXIgZnVuY3Rpb25zKQorRm9yd2FyZCBkZWNsYXJhdGlvbnM6CisgIC0gQ2xlYW51cCB3aGVuIHNvdXJjaW5nIGEgc2NyaXB0IGFnYWluOiBhbGwgc2NyaXB0LWxvY2FsIHZhcmlhYmxlcywgaW1wb3J0cworICAgIGFuZCBmdW5jdGlvbnMgYXJlIGRlbGV0ZWQuCisgIC0gbWFrZSBzdXJlIG9ubHkgY29uc3RhbnRzIGluIGRlY2xhcmF0aW9ucyBhcmUgZXhlY3V0ZWQsIG5vIGZ1bmN0aW9uIGNhbGxzLgorICAtIERlY2xhcmUgYSB2YXJpYWJsZSBhdCBzY3JpcHQgbGV2ZWwgd2l0aG91dCBhbiBhc3NpZ25tZW50LgorCWxldCB2YXI6IHN0cmluZworICAgIEVycm9yIHdpdGhvdXQgYSB0eXBlIG9yIGFzc2lnbm1lbnQKKwlsZXQgdmFyICAjIGVycm9yIQogTWFraW5nIGV2ZXJ5dGhpbmcgd29yazoKIC0gVGVzdCB0aGF0IGEgc2NyaXB0LWxvY2FsIGZ1bmN0aW9uIGluIFZpbTkgc2NyaXB0IGNhbm5vdCBiZSBkZWxldGVkLgogLSBUZXN0IHRoYXQgYSBmdW5jdGlvbiBkZWZpbmVkIGluc2lkZSBhIDpkZWYgZnVuY3Rpb24gaXMgbG9jYWwgdG8gdGhhdApAQCAtNjIsNyArNjEsMTMgQEAKICAgZGVmaW5lZC4KIC0gQ2hlY2sgdGhhdCB3aGVuIHVzaW5nIGEgdXNlciBmdW5jdGlvbiBuYW1lIHdpdGhvdXQgcHJlZml4LCBpdCBkb2VzIG5vdCBmaW5kCiAgIGEgZ2xvYmFsIGZ1bmN0aW9uLiAgUHJlZml4aW5nIGc6IGlzIHJlcXVpcmVkLgotLSBDb21waWxlIGxldCBbdmFyLCB2YXJdID0gZXhwcgorLSBDb21waWxlOiBsZXQgW3ZhciwgdmFyXSA9IGV4cHIKKy0gQ29tcGlsZTogZm9yIFtrZXksIHZhbHVlXSBpbiBpdGVtcyhtYXApCistIEFzc2lnbm1lbnQgdG8gZGljdCBkb2Vzbid0IHdvcms6CisgICAgICBsZXQgcmV0OiBkaWN0PHN0cmluZz4gPSAje30KKyAgICAgIHJldFtpXSA9IHN0cmluZyhpKQorLSBBcHBlbmRpbmcgdG8gZGljdCBpdGVtIGRvZXNuJ3Qgd29yazoKKyAgICBsZXQgZFtpXSAuLj0gdmFsdWUKIC0gQ29tcGlsZSByZXBsYWNlbWVudCBvZiA6cyBjb21tYW5kOiBzL3BhdC9cPWV4cHIvCiAtIENvbXBpbGUgcmVkaXIgdG8gbG9jYWwgdmFyaWFibGU6IHZhcl9yZWRpcl9zdGFydCgpLgogLSBDb21waWxlIGJ1aWx0aW4gZnVuY3Rpb25zIHRoYXQgYWNjZXNzIGxvY2FsIHZhcmlhYmxlczoKQEAgLTc5LDYgKzg0LDcgQEAKIC0gZXhwYW5kY21kKCkgd2l0aCBgPWV4cHJgIGluIGZpbGVuYW1lIHVzZXMgbGVnYWN5IGV4cHJlc3Npb24uCiAtIGV2YWxfZXhwcigpIGluIGV4X2NleHByKCkKIC0gZXZhbF9leHByKCkgY2FsbCBpbiBkYmdfcGFyc2VhcmcoKSBhbmQgZGVidWdneV9maW5kKCkKKy0gTWFrZSAidHJ1ZSIgYW5kICJmYWxzZSIgd29yayBpbiB2aW05c2NyaXB0CiBOZXcgc3ludGF4IGFuZCBmdW5jdGlvbmFsaXR5OgogSW1wcm92ZSBlcnJvciBjaGVja2luZzoKIC0gImVjaG8gRnVuYygpIiBpcyBhbiBlcnJvciBpZiBGdW5jKCkgZG9lcyBub3QgcmV0dXJuIGFueXRoaW5nLgpAQCAtMjU0LDE0ICsyNjAsMTQgQEAKIAogUGF0Y2ggdG8gYWRkIFR1cmtpc2ggbWFudWFsLiAoRW1pciBTYXLEsSwgIzU2NDEpCiAKK1BhdGNoIHRvIGFkZCBsdWEgc2xlZXAgZnVuY3Rpb24uIChQcmFiaXIgU2hyZXN0aGEsICM2MDU3KQorQWx0ZXJuYXRpdmU6IHVzZSB2aW0uY2FsbCBhbmQgdmltLmZuOiAjNjA2MworCiBQYXRjaCB0byBhZGQgZ2V0bWFya2xpc3QoKSAoWWVnYXBwYW4sICM2MDMyKQogCiBQYXRjaCB0byBzdXBwb3J0IGRpZmZlcmVudCBjb2xvciBmb3IgdW5kZXJjdXJsIGluIGN0ZXJtLgogKFRpbXVyIENlbGlrLCAjNjAxMSkKIAotV2hlbiBTSUdUU1RQIGlzIGlnbm9yZWQsIGRvbid0IGxldCBDVFJMLVogc3VzcGVuZCBWaW0/IChLdXJ0aXMgUmFkZXIsICM1OTkwKQotRml4ZWQgYnkgcGF0Y2ggIzYwMjYuICBNYWtlcyB0ZXN0cyBmYWlsLi4uCi0KIFBhdGNoIHRvIHN1cHBvcnQgY2luZGVudCBvcHRpb24gdG8gaGFuZGxlIHByYWdtYXMgZGlmZmVyZW50bHkuCiAoTWF4IFJ1bXBmLCAjNTQ2OCkKIApAQCAtMjk0LDYgKzMwMCwxMCBAQAogV2l0aCBiYXNoICI6bWFrZSIgZG9lcyBub3Qgc2V0IHY6c2hlbGxfZXJyb3IuICBQb3NzaWJsZSBzb2x1dGlvbjogc2V0CiAnc2hlbGxwaXBlJyB0byAiMj4mMXwgdGVlICVzOyBleGl0ICR7UElQRVNUQVRVU1swXX0iICAjNTk5NAogCitXaGVuIGNoYW5naW5nIHRoZSBjcnlwdCBrZXkgdGhlIGJ1ZmZlciBzaG91bGQgYmUgY29uc2lkZXJlZCBtb2RpZmllZC4KK0xpa2Ugd2hlbiBjaGFuZ2luZyAnZmlsZWZvcm1hdCcuICBTYXZlIHRoZSBvbGQga2V5IGluIHNhdmVfZmlsZV9mZigpLgorKE5pbnUtQ2lwcmlhbiBNYXJnaW5lYW4pCisKIFN0cmFuZ2Ugc2VxdWVuY2Ugb2YgQnVmV2lwZW91dCBhbmQgQnVmTmV3IGV2ZW50cyB3aGlsZSBkb2luZyBvbW5pLWNvbXBsZXRlLgogKFBhdWwgSm9sbHksICM1NjU2KQogR2V0IEJ1ZkRlbGV0ZSB3aXRob3V0IHByZWNlZGluZyBCdWZOZXcuIChQYXVsIEpvbGx5LCAjNTY5NCkKZGlmZiAtLWdpdCBhL3J1bnRpbWUvZG9jL3ZpbTkudHh0IGIvcnVudGltZS9kb2MvdmltOS50eHQKaW5kZXggY2I4ODBjMS4uM2VlYzI4MCAxMDA2NDQKLS0tIGEvcnVudGltZS9kb2MvdmltOS50eHQKKysrIGIvcnVudGltZS9kb2MvdmltOS50eHQKQEAgLTEsNCArMSw0IEBACi0qdmltOS50eHQqCUZvciBWaW0gdmVyc2lvbiA4LjIuICBMYXN0IGNoYW5nZTogMjAyMCBNYXkgMDYKKyp2aW05LnR4dCoJRm9yIFZpbSB2ZXJzaW9uIDguMi4gIExhc3QgY2hhbmdlOiAyMDIwIE1heSAwOQogCiAKIAkJICBWSU0gUkVGRVJFTkNFIE1BTlVBTAkgIGJ5IEJyYW0gTW9vbGVuYWFyCkBAIC0xMzQsNyArMTM0LDcgQEAKIAogSW4gbGVnYWN5IHNjcmlwdCB0aGUgZnVuY3Rpb25zIGFyZSBjcmVhdGVkIHdoZW4gZW5jb3VudGVyZWQsIGJ1dCBwYXJzZWQgb25seQogd2hlbiB1c2VkLiAgVGhpcyBhbGxvd3MgZm9yIGRlZmluaW5nIGZ1bmN0aW9ucyBpbiBhbnkgb3JkZXIgYW5kIGhhdmluZyB0aGVtCi1jYWxsIGVhY2ggb3RoZXI6ID4KK2NhbGwgZWFjaCBvdGhlciwgc28gbG9uZyBhcyB0aGUgZnVuY3Rpb24gaXMgZGVmaW5lZCB3aGVuIGl0IGlzIGNhbGxlZDogPgogCWZ1bmMgT25lKCkKIAkgICBjYWxsIFR3bygpCiAJZW5kZnVuYwpAQCAtMTQ1LDIyICsxNDUsMjUgQEAKIAllbmRmdW5jCiAJY2FsbCBPbmUoKQogCi1JbiBWaW05IHNjcmlwdCB0aGUgZnVuY3Rpb25zIGFyZSBjb21waWxlZC4gIElmIHVzaW5nIHRoZSBzYW1lIGZ1bmN0aW9ucyBhcyB0aGUKLWFib3ZlIGV4YW1wbGUgaXQgaXMgbm90IHBvc3NpYmxlIHRvIGNvbXBpbGUgZnVuY3Rpb24gT25lIHdpdGhvdXQga25vd2luZyB0aGF0Ci1mdW5jdGlvbiBUd28gZXhpc3RzLiBPciB0aGlzIHdvdWxkIHJlcXVpcmUgYSBydW50aW1lIGNoZWNrLCB3aGljaCBpcyBzbG93IGFuZAotZG9lcyBub3QgYWxsb3cgZm9yIGNvbXBpbGUgdGltZSB0eXBlIGNoZWNraW5nLgorSW4gVmltOSBzY3JpcHQgdGhlIGZ1bmN0aW9ucyBhcmUgY29tcGlsZWQuICBXaGVuIHVzaW5nIHRoZSBzYW1lIGZ1bmN0aW9ucyBhcwordGhlIGFib3ZlIGV4YW1wbGUgaXQgaXMgbm90IHBvc3NpYmxlIHRvIGNvbXBpbGUgZnVuY3Rpb24gT25lIHdpdGhvdXQga25vd2luZwordGhhdCBmdW5jdGlvbiBUd28gZXhpc3RzLiBPciB0aGlzIHdvdWxkIHJlcXVpcmUgYSBydW50aW1lIGNoZWNrLCB3aGljaCBpcyBzbG93CithbmQgZG9lcyBub3QgYWxsb3cgZm9yIGNvbXBpbGUgdGltZSB0eXBlIGNoZWNraW5nLgogCiBXaGVuIHNvdXJjaW5nIGEgVmltOSBzY3JpcHQgdGhpcyBoYXBwZW5zIGluIGZvdXIgcGhhc2VzOgogMS4gQ2xlYW51cDogSWYgdGhlIHNjcmlwdCB3YXMgc291cmNlZCBiZWZvcmUgYWxsIHNjcmlwdC1sb2NhbCB2YXJpYWJsZXMsCiAgICBpbXBvcnRzIGFuZCBmdW5jdGlvbnMgYXJlIGRlbGV0ZWQuCi0yLiBEaXNjb3Zlcnk6IFRoZSBzY3JpcHQgaXMgcmVhZCBhbmQgZW5jb3VudGVyZWQgZnVuY3Rpb25zLCBpbXBvcnRzIGFuZAotICAgdmFyaWFibGVzIGFyZSByZWNvZ25pemVkLiAgVGhlIHR5cGUgaXMgcGFyc2VkLiAgVmFyaWFibGUgaW5pdGlhbGl6ZXJzIHRoYXQKLSAgIGFyZSBhIGNvbnN0YW50IGFyZSBldmFsdWF0ZWQsIHRoaXMgY2FuIGdpdmUgdGhlIHR5cGUgb2YgdGhlIHZhcmlhYmxlLgorMi4gRGlzY292ZXJ5OiBUaGUgc2NyaXB0IGlzIHJlYWQgYW5kIGRlY2xhcmF0aW9ucyBvZiBmdW5jdGlvbnMsIGltcG9ydHMgYW5kCisgICB2YXJpYWJsZXMgYXJlIHJlY29nbml6ZWQgYW5kIHRoZSB0eXBlIGlzIHBhcnNlZC4gIFZhcmlhYmxlIGluaXRpYWxpemVycworICAgdGhhdCBhcmUgYSBjb25zdGFudCBhcmUgZXZhbHVhdGVkLCB0aGlzIGNhbiBhbHNvIGdpdmUgdGhlIHR5cGUgb2YgdGhlCisgICB2YXJpYWJsZS4KIDMuIENvbXBpbGF0aW9uOiBGdW5jdGlvbnMgYXJlIGNvbXBpbGVkLiAgVGhlIHNjcmlwdC1sb2NhbCBmdW5jdGlvbnMsIGltcG9ydHMKLSAgIGFuZCB2YXJpYWJsZXMgZnJvbSB0aGUgZGlzY292ZXJ5IHBoYXNlIGFyZSByZWNvZ25pemVkIGFuZCB0eXBlcyBhcmUKLSAgIGNoZWNrZWQuCi00LiBFeGVjdXRpb246IHRoZSBjb21tYW5kcyBpbiB0aGUgc2NyaXB0IGFyZSBleGVjdXRlZC4gRnVuY3Rpb25zIGFyZSBza2lwcGVkCi0gICBvdmVyLiAgVmFyaWFibGUgaW5pdGlhbGl6ZXJzIGFyZSBldmFsdWF0ZWQsIHVubGVzcyB0aGV5IGFyZSBhIGNvbnN0YW50LgorICAgYW5kIHZhcmlhYmxlcyBmcm9tIHRoZSBkaXNjb3ZlcnkgcGhhc2UgYXJlIGZvdW5kIGFuZCB0eXBlcyBhcmUgY2hlY2tlZC4KKzQuIEV4ZWN1dGlvbjogdGhlIGNvbW1hbmRzIGluIHRoZSBzY3JpcHQgYXJlIGV4ZWN1dGVkLCB0b3AgdG8gYm90dG9tLgorICAgRnVuY3Rpb25zIGFyZSBza2lwcGVkIG92ZXIsIHRoZXkgZG8gZG8gbm90IG5lZWQgdG8gYmUgcHJvY2Vzc2VkIGFnYWluLgorICAgVmFyaWFibGUgaW5pdGlhbGl6ZXJzIGFyZSBldmFsdWF0ZWQgd2hlbiBlbmNvdW50ZXJlZC4gIE5vdGUgdGhhdCBpZiBhCisgICBmdW5jdGlvbiBjYWxsZWQgZWFybGllciBoYXMgc2V0IHRoZSB2YWx1ZSB0aGlzIHdpbGwgYmUgb3Zlci13cml0dGVuLiBJdCBpcworICAgYmVzdCB0byBkZWNsYXJlIHZhcmlhYmxlcyBiZWZvcmUgd2hlcmUgdGhleSBhcmUgdXNlZCB0byBhdm9pZCBjb25mdXNpb24uCiAKIFRoZSByZXN1bHQgaXMgdGhhdCBpdGVtcyBkZWZpbmVkIGF0IHRoZSBzY3JpcHQgbGV2ZWwgY2FuIGJlIHVzZWQgYW55d2hlcmUgaW4KIHRoZSBzY3JpcHQuIFRoaXMgYWxsb3dzIGZvciBwdXR0aW5nIHRoZSBtYWluIGZ1bmN0aW9uIGF0IHRoZSB0b3A6ID4KZGlmZiAtLWdpdCBhL3J1bnRpbWUvZG9jL3dpbmRvd3MudHh0IGIvcnVudGltZS9kb2Mvd2luZG93cy50eHQKaW5kZXggNjEyOWI4ZC4uMmIwMWZiMyAxMDA2NDQKLS0tIGEvcnVudGltZS9kb2Mvd2luZG93cy50eHQKKysrIGIvcnVudGltZS9kb2Mvd2luZG93cy50eHQKQEAgLTEsNCArMSw0IEBACi0qd2luZG93cy50eHQqICAgRm9yIFZpbSB2ZXJzaW9uIDguMi4gIExhc3QgY2hhbmdlOiAyMDIwIE1hciAxOQorKndpbmRvd3MudHh0KiAgIEZvciBWaW0gdmVyc2lvbiA4LjIuICBMYXN0IGNoYW5nZTogMjAyMCBNYXkgMTAKIAogCiAJCSAgVklNIFJFRkVSRU5DRSBNQU5VQUwgICAgYnkgQnJhbSBNb29sZW5hYXIKQEAgLTI5MSw5ICsyOTEsOSBAQAogQ1RSTC1XIENUUkwtUQkJCQkJCSpDVFJMLVdfQ1RSTC1RKgogCQlXaXRob3V0IHtjb3VudH06IFF1aXQgdGhlIGN1cnJlbnQgd2luZG93LiAgSWYge2NvdW50fSBpcwogCQlnaXZlbiBxdWl0IHRoZSB7Y291bnR9IHdpbmRvdy4KLQotCQlXaGVuIHF1aXR0aW5nIHRoZSBsYXN0IHdpbmRvdyAobm90IGNvdW50aW5nIGEgaGVscCB3aW5kb3cpLAotCQlleGl0IFZpbS4KKwkJCQkJCQkqZWRpdC13aW5kb3cqCisJCVdoZW4gcXVpdHRpbmcgdGhlIGxhc3QgZWRpdCB3aW5kb3cgKG5vdCBjb3VudGluZyBoZWxwIG9yCisJCXByZXZpZXcgd2luZG93cyksIGV4aXQgVmltLgogCiAJCVdoZW4gJ2hpZGRlbicgaXMgc2V0LCBhbmQgdGhlcmUgaXMgb25seSBvbmUgd2luZG93IGZvciB0aGUKIAkJY3VycmVudCBidWZmZXIsIGl0IGJlY29tZXMgaGlkZGVuLiAgV2hlbiAnaGlkZGVuJyBpcyBub3Qgc2V0LApAQCAtMzEyLDggKzMxMiw5IEBACiAJCSAgICA6K3F1aXQgICIgcXVpdCB0aGUgbmV4dCB3aW5kb3cKIAkJICAgIDorMnF1aXQgIiBxdWl0IHRoZSBzZWNvbmQgbmV4dCB3aW5kb3cKIDwKLQkJV2hlbiBjbG9zaW5nIGEgaGVscCB3aW5kb3csIFZpbSB3aWxsIHRyeSB0byByZXN0b3JlIHRoZQotCQlwcmV2aW91cyB3aW5kb3cgbGF5b3V0IHw6aGVscGNsb3NlfC4KKwkJV2hlbiBjbG9zaW5nIGEgaGVscCB3aW5kb3csIGFuZCB0aGlzIGlzIG5vdCB0aGUgb25seSB3aW5kb3csCisJCVZpbSB3aWxsIHRyeSB0byByZXN0b3JlIHRoZSBwcmV2aW91cyB3aW5kb3cgbGF5b3V0LCBzZWUKKwkJfDpoZWxwY2xvc2V8LgogCiA6cVt1aXRdIQogOntjb3VudH1xW3VpdF0hCkBAIC0zMzUsOSArMzM2LDkgQEAKIAkJY2hhbmdlZCBhbmQgdGhlIFshXSBpcyB1c2VkLCB0aGUgYnVmZmVyIGJlY29tZXMgaGlkZGVuICh1bmxlc3MKIAkJdGhlcmUgaXMgYW5vdGhlciB3aW5kb3cgZWRpdGluZyBpdCkuCiAKLQkJV2hlbiB0aGVyZSBpcyBvbmx5IG9uZSB3aW5kb3cgaW4gdGhlIGN1cnJlbnQgdGFiIHBhZ2UgYW5kCi0JCXRoZXJlIGlzIGFub3RoZXIgdGFiIHBhZ2UsIHRoaXMgY2xvc2VzIHRoZSBjdXJyZW50IHRhYiBwYWdlLgotCQl8dGFiLXBhZ2V8LgorCQlXaGVuIHRoZXJlIGlzIG9ubHkgb25lIHxlZGl0LXdpbmRvd3wgaW4gdGhlIGN1cnJlbnQgdGFiIHBhZ2UKKwkJYW5kIHRoZXJlIGlzIGFub3RoZXIgdGFiIHBhZ2UsIHRoaXMgY2xvc2VzIHRoZSBjdXJyZW50IHRhYgorCQlwYWdlLiAgfHRhYi1wYWdlfC4KIAogCQlUaGlzIGNvbW1hbmQgZmFpbHMgd2hlbjoJCQkqRTQ0NCoKIAkJLSBUaGVyZSBpcyBvbmx5IG9uZSB3aW5kb3cgb24gdGhlIHNjcmVlbi4KZGlmZiAtLWdpdCBhL3J1bnRpbWUvZnRwbHVnaW4vbWFzbS52aW0gYi9ydW50aW1lL2Z0cGx1Z2luL21hc20udmltCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjIzNTQ2OWEKLS0tIC9kZXYvbnVsbAorKysgYi9ydW50aW1lL2Z0cGx1Z2luL21hc20udmltCkBAIC0wLDAgKzEsMTkgQEAKKyIgVmltIGZpbGV0eXBlIHBsdWdpbiBmaWxlCisiIExhbmd1YWdlOglNaWNyb3NvZnQgTWFjcm8gQXNzZW1ibGVyICg4MHg4NikKKyIgTWFpbnRhaW5lcjoJV3UgWW9uZ3dlaSA8d3V5b25nd2VpQGdtYWlsLmNvbT4KKyIgTGFzdCBDaGFuZ2U6CTIwMjAtMDUtMDkgMjM6MDI6MDUgKzA4MDAKKworaWYgZXhpc3RzKCJiOmRpZF9mdHBsdWdpbiIpCisgIGZpbmlzaAorZW5kaWYKK2xldCBiOmRpZF9mdHBsdWdpbiA9IDEKKworbGV0IHM6Y3BvX3NhdmUgPSAmY3BvCitzZXQgY3BvJnZpbQorCitsZXQgYjp1bmRvX2Z0cGx1Z2luID0gInNldGwgaXNrZXl3b3JkPCIKKworc2V0bG9jYWwgaXNrZXl3b3JkPUAsNDgtNTcsXywzNiw2MCw2Miw2MyxALUAKKworbGV0ICZjcG8gPSBzOmNwb19zYXZlCit1bmxldCBzOmNwb19zYXZlCmRpZmYgLS1naXQgYS9ydW50aW1lL2luZGVudC9weXRob24udmltIGIvcnVudGltZS9pbmRlbnQvcHl0aG9uLnZpbQppbmRleCBlNTM5ODdhLi5mOTIzNmU2IDEwMDY0NAotLS0gYS9ydW50aW1lL2luZGVudC9weXRob24udmltCisrKyBiL3J1bnRpbWUvaW5kZW50L3B5dGhvbi52aW0KQEAgLTI4LDYgKzI4LDExIEBACiAKIGxldCBzOm1heG9mZiA9IDUwCSIgbWF4aW11bSBudW1iZXIgb2YgbGluZXMgdG8gbG9vayBiYWNrd2FyZHMgZm9yICgpCiAKKyIgU2VlIGlmIHRoZSBzcGVjaWZpZWQgbGluZSBpcyBhbHJlYWR5IHVzZXItZGVkZW50ZWQgZnJvbSB0aGUgZXhwZWN0ZWQgdmFsdWUuCitmdW5jdGlvbiBzOkRlZGVudGVkKGxudW0sIGV4cGVjdGVkKQorICByZXR1cm4gaW5kZW50KGE6bG51bSkgPD0gYTpleHBlY3RlZCAtIHNoaWZ0d2lkdGgoKQorZW5kZnVuY3Rpb24KKwogZnVuY3Rpb24gR2V0UHl0aG9uSW5kZW50KGxudW0pCiAKICAgIiBJZiB0aGlzIGxpbmUgaXMgZXhwbGljaXRseSBqb2luZWQ6IElmIHRoZSBwcmV2aW91cyBsaW5lIHdhcyBhbHNvIGpvaW5lZCwKQEAgLTE1OCwxMiArMTYzLDEyIEBACiAgICIgSWYgdGhlIHByZXZpb3VzIGxpbmUgd2FzIGEgc3RvcC1leGVjdXRpb24gc3RhdGVtZW50Li4uCiAgIGlmIGdldGxpbmUocGxudW0pID1+ICdeXHMqXChicmVha1x8Y29udGludWVcfHJhaXNlXHxyZXR1cm5cfHBhc3NcKVw+JwogICAgICIgU2VlIGlmIHRoZSB1c2VyIGhhcyBhbHJlYWR5IGRlZGVudGVkCi0gICAgaWYgaW5kZW50KGE6bG51bSkgPiBpbmRlbnQocGxudW0pIC0gc2hpZnR3aWR0aCgpCi0gICAgICAiIElmIG5vdCwgcmVjb21tZW5kIG9uZSBkZWRlbnQKLSAgICAgIHJldHVybiBpbmRlbnQocGxudW0pIC0gc2hpZnR3aWR0aCgpCisgICAgaWYgczpEZWRlbnRlZChhOmxudW0sIGluZGVudChwbG51bSkpCisgICAgICAiIElmIHNvLCB0cnVzdCB0aGUgdXNlcgorICAgICAgcmV0dXJuIC0xCiAgICAgZW5kaWYKLSAgICAiIE90aGVyd2lzZSwgdHJ1c3QgdGhlIHVzZXIKLSAgICByZXR1cm4gLTEKKyAgICAiIElmIG5vdCwgcmVjb21tZW5kIG9uZSBkZWRlbnQKKyAgICByZXR1cm4gaW5kZW50KHBsbnVtKSAtIHNoaWZ0d2lkdGgoKQogICBlbmRpZgogCiAgICIgSWYgdGhlIGN1cnJlbnQgbGluZSBiZWdpbnMgd2l0aCBhIGtleXdvcmQgdGhhdCBsaW5lcyB1cCB3aXRoICJ0cnkiCkBAIC0xOTEsNyArMTk2LDcgQEAKICAgICBlbmRpZgogCiAgICAgIiBPciB0aGUgdXNlciBoYXMgYWxyZWFkeSBkZWRlbnRlZAotICAgIGlmIGluZGVudChhOmxudW0pIDw9IHBsaW5kZW50IC0gc2hpZnR3aWR0aCgpCisgICAgaWYgczpEZWRlbnRlZChhOmxudW0sIHBsaW5kZW50KQogICAgICAgcmV0dXJuIC0xCiAgICAgZW5kaWYKIApAQCAtMjAzLDcgKzIwOCwxMiBAQAogICAiICAgICAgICsgYykKICAgIiBoZXJlCiAgIGlmIHBhcmxudW0gPiAwCi0gICAgcmV0dXJuIHBsaW5kZW50CisgICAgIiAuLi51bmxlc3MgdGhlIHVzZXIgaGFzIGFscmVhZHkgZGVkZW50ZWQKKyAgICBpZiBzOkRlZGVudGVkKGE6bG51bSwgcGxpbmRlbnQpCisgICAgICAgIHJldHVybiAtMQorICAgIGVsc2UKKyAgICAgICAgcmV0dXJuIHBsaW5kZW50CisgICAgZW5kaWYKICAgZW5kaWYKIAogICByZXR1cm4gLTEKZGlmZiAtLWdpdCBhL3J1bnRpbWUvcGx1Z2luL2d6aXAudmltIGIvcnVudGltZS9wbHVnaW4vZ3ppcC52aW0KaW5kZXggZmZjMDBmNi4uNzIxNDQ4OCAxMDA2NDQKLS0tIGEvcnVudGltZS9wbHVnaW4vZ3ppcC52aW0KKysrIGIvcnVudGltZS9wbHVnaW4vZ3ppcC52aW0KQEAgLTIwLDcgKzIwLDcgQEAKICAgIgogICAiIFNldCBiaW5hcnkgbW9kZSBiZWZvcmUgcmVhZGluZyB0aGUgZmlsZS4KICAgIiBVc2UgImd6aXAgLWQiLCBndW56aXAgaXNuJ3QgYWx3YXlzIGF2YWlsYWJsZS4KLSAgYXV0b2NtZCBCdWZSZWFkUHJlLEZpbGVSZWFkUHJlCSouZ3osKi5iejIsKi5aLCoubHptYSwqLnh6LCoubHosKi56c3QsKi5iciBzZXRsb2NhbCBiaW4KKyAgYXV0b2NtZCBCdWZSZWFkUHJlLEZpbGVSZWFkUHJlCSouZ3osKi5iejIsKi5aLCoubHptYSwqLnh6LCoubHosKi56c3QsKi5iciwqLmx6byBzZXRsb2NhbCBiaW4KICAgYXV0b2NtZCBCdWZSZWFkUG9zdCxGaWxlUmVhZFBvc3QJKi5neiAgY2FsbCBnemlwI3JlYWQoImd6aXAgLWRuIikKICAgYXV0b2NtZCBCdWZSZWFkUG9zdCxGaWxlUmVhZFBvc3QJKi5iejIgY2FsbCBnemlwI3JlYWQoImJ6aXAyIC1kIikKICAgYXV0b2NtZCBCdWZSZWFkUG9zdCxGaWxlUmVhZFBvc3QJKi5aICAgY2FsbCBnemlwI3JlYWQoInVuY29tcHJlc3MiKQpAQCAtMjksNiArMjksNyBAQAogICBhdXRvY21kIEJ1ZlJlYWRQb3N0LEZpbGVSZWFkUG9zdAkqLmx6ICBjYWxsIGd6aXAjcmVhZCgibHppcCAtZCIpCiAgIGF1dG9jbWQgQnVmUmVhZFBvc3QsRmlsZVJlYWRQb3N0CSouenN0IGNhbGwgZ3ppcCNyZWFkKCJ6c3RkIC1kIC0tcm0iKQogICBhdXRvY21kIEJ1ZlJlYWRQb3N0LEZpbGVSZWFkUG9zdAkqLmJyIGNhbGwgZ3ppcCNyZWFkKCJicm90bGkgLWQgLS1ybSIpCisgIGF1dG9jbWQgQnVmUmVhZFBvc3QsRmlsZVJlYWRQb3N0CSoubHpvIGNhbGwgZ3ppcCNyZWFkKCJsem9wIC1kIC1VIikKICAgYXV0b2NtZCBCdWZXcml0ZVBvc3QsRmlsZVdyaXRlUG9zdAkqLmd6ICBjYWxsIGd6aXAjd3JpdGUoImd6aXAiKQogICBhdXRvY21kIEJ1ZldyaXRlUG9zdCxGaWxlV3JpdGVQb3N0CSouYnoyIGNhbGwgZ3ppcCN3cml0ZSgiYnppcDIiKQogICBhdXRvY21kIEJ1ZldyaXRlUG9zdCxGaWxlV3JpdGVQb3N0CSouWiAgIGNhbGwgZ3ppcCN3cml0ZSgiY29tcHJlc3MgLWYiKQpAQCAtMzcsNiArMzgsNyBAQAogICBhdXRvY21kIEJ1ZldyaXRlUG9zdCxGaWxlV3JpdGVQb3N0CSoubHogIGNhbGwgZ3ppcCN3cml0ZSgibHppcCIpCiAgIGF1dG9jbWQgQnVmV3JpdGVQb3N0LEZpbGVXcml0ZVBvc3QJKi56c3QgIGNhbGwgZ3ppcCN3cml0ZSgienN0ZCAtLXJtIikKICAgYXV0b2NtZCBCdWZXcml0ZVBvc3QsRmlsZVdyaXRlUG9zdAkqLmJyICBjYWxsIGd6aXAjd3JpdGUoImJyb3RsaSAtLXJtIikKKyAgYXV0b2NtZCBCdWZXcml0ZVBvc3QsRmlsZVdyaXRlUG9zdAkqLmx6byAgY2FsbCBnemlwI3dyaXRlKCJsem9wIC1VIikKICAgYXV0b2NtZCBGaWxlQXBwZW5kUHJlCQkJKi5neiAgY2FsbCBnemlwI2FwcHJlKCJnemlwIC1kbiIpCiAgIGF1dG9jbWQgRmlsZUFwcGVuZFByZQkJCSouYnoyIGNhbGwgZ3ppcCNhcHByZSgiYnppcDIgLWQiKQogICBhdXRvY21kIEZpbGVBcHBlbmRQcmUJCQkqLlogICBjYWxsIGd6aXAjYXBwcmUoInVuY29tcHJlc3MiKQpAQCAtNDUsNiArNDcsNyBAQAogICBhdXRvY21kIEZpbGVBcHBlbmRQcmUJCQkqLmx6ICAgY2FsbCBnemlwI2FwcHJlKCJsemlwIC1kIikKICAgYXV0b2NtZCBGaWxlQXBwZW5kUHJlCQkJKi56c3QgY2FsbCBnemlwI2FwcHJlKCJ6c3RkIC1kIC0tcm0iKQogICBhdXRvY21kIEZpbGVBcHBlbmRQcmUJCQkqLmJyIGNhbGwgZ3ppcCNhcHByZSgiYnJvdGxpIC1kIC0tcm0iKQorICBhdXRvY21kIEZpbGVBcHBlbmRQcmUJCQkqLmx6byBjYWxsIGd6aXAjYXBwcmUoImx6b3AgLWQgLVUiKQogICBhdXRvY21kIEZpbGVBcHBlbmRQb3N0CQkqLmd6ICBjYWxsIGd6aXAjd3JpdGUoImd6aXAiKQogICBhdXRvY21kIEZpbGVBcHBlbmRQb3N0CQkqLmJ6MiBjYWxsIGd6aXAjd3JpdGUoImJ6aXAyIikKICAgYXV0b2NtZCBGaWxlQXBwZW5kUG9zdAkJKi5aICAgY2FsbCBnemlwI3dyaXRlKCJjb21wcmVzcyAtZiIpCkBAIC01Myw0ICs1Niw1IEBACiAgIGF1dG9jbWQgRmlsZUFwcGVuZFBvc3QJCSoubHogY2FsbCBnemlwI3dyaXRlKCJsemlwIikKICAgYXV0b2NtZCBGaWxlQXBwZW5kUG9zdAkJKi56c3QgY2FsbCBnemlwI3dyaXRlKCJ6c3RkIC0tcm0iKQogICBhdXRvY21kIEZpbGVBcHBlbmRQb3N0CQkqLmJyIGNhbGwgZ3ppcCN3cml0ZSgiYnJvdGxpIC0tcm0iKQorICBhdXRvY21kIEZpbGVBcHBlbmRQb3N0CQkqLmx6byBjYWxsIGd6aXAjd3JpdGUoImx6b3AgLVUiKQogYXVncm91cCBFTkQKZGlmZiAtLWdpdCBhL3J1bnRpbWUvc3ludGF4L2dudXBsb3QudmltIGIvcnVudGltZS9zeW50YXgvZ251cGxvdC52aW0KaW5kZXggNzc3N2NjOS4uOWM5OGU2NyAxMDA2NDQKLS0tIGEvcnVudGltZS9zeW50YXgvZ251cGxvdC52aW0KKysrIGIvcnVudGltZS9zeW50YXgvZ251cGxvdC52aW0KQEAgLTMsNyArMyw3IEBACiAiIE1haW50YWluZXI6CUpvc2ggV2FpbndyaWdodCA8d2FpbndyaWdodCBET1QgamEgQVQgZ21haWwgRE9UIGNvbT4KICIgTGFzdCBNYWludGFpbmVyOglBbmRyZXcgUmFzbXVzc2VuIGFuZHlyYXNAdXNlcnMuc291cmNlZm9yZ2UubmV0CiAiIE9yaWdpbmFsIE1haW50YWluZXI6CUpvaG4gSG9lbHplbCBqb2huaDUxQHVzZXJzLnNvdXJjZWZvcmdlLm5ldAotIiBMYXN0IENoYW5nZToJMjAxNS0wOC0yNQorIiBMYXN0IENoYW5nZToJMjAyMCBNYXkgMTIKICIgRmlsZW5hbWVzOgkqLmdudSAqLnBsdCAqLmdwaSAqLmdpaCAqLmdwICouZ251cGxvdCBzY3JpcHRzOiAjISpnbnVwbG90CiAiIFVSTDoJCWh0dHA6Ly93d3cudmltLm9yZy9zY3JpcHRzL3NjcmlwdC5waHA/c2NyaXB0X2lkPTQ4NzMKICIgT3JpZ2luYWwgVVJMOglodHRwOi8vam9obmg1MS5nZXQudG8vdmltL3N5bnRheC9nbnVwbG90LnZpbQpAQCAtNDc5LDcgKzQ3OSw3IEBACiAKICIgLS0tLSBNYWNyb3MgLS0tLSAiCiAKLXN5biByZWdpb24gZ251cGxvdE1hY3JvCQlzdGFydD0iQCIgZW5kPSIgIgorc3luIG1hdGNoIGdudXBsb3RNYWNybwkJIkBbYS16QS1aMC05X10qIgogCiAiIC0tLS0gVG9kb3MgLS0tLSAiCiAKZGlmZiAtLWdpdCBhL3J1bnRpbWUvc3ludGF4L21hc20udmltIGIvcnVudGltZS9zeW50YXgvbWFzbS52aW0KaW5kZXggYWJlZTc4Yi4uYzNiMmE5YiAxMDA2NDQKLS0tIGEvcnVudGltZS9zeW50YXgvbWFzbS52aW0KKysrIGIvcnVudGltZS9zeW50YXgvbWFzbS52aW0KQEAgLTIsNyArMiw3IEBACiAiIExhbmd1YWdlOglNaWNyb3NvZnQgTWFjcm8gQXNzZW1ibGVyICg4MHg4NikKICIgT3JpZyBBdXRob3I6CVJvYiBCcmFkeSA8cm9iYkBkYXRhdG9uZS5jb20+CiAiIE1haW50YWluZXI6CVd1IFlvbmd3ZWkgPHd1eW9uZ3dlaUBnbWFpbC5jb20+Ci0iIExhc3QgQ2hhbmdlOgkyMDIwLTA1LTA3IDE3OjA0OjEwICswODAwCisiIExhc3QgQ2hhbmdlOgkyMDIwLTA1LTA5IDIyOjU1OjM4ICswODAwCiAKICIgUXVpdCB3aGVuIGEgc3ludGF4IGZpbGUgd2FzIGFscmVhZHkgbG9hZGVkCiBpZiBleGlzdHMoImI6Y3VycmVudF9zeW50YXgiKQpAQCAtMTIsNyArMTIsNyBAQAogbGV0IHM6Y3BvX3NhdmUgPSAmY3BvCiBzZXQgY3BvJnZpbQogCi1zZXRsb2NhbCBpc2tleXdvcmQ9QCw0OC01NyxfLDM2LDYwLDYyLDYzLEAtQAorc3luIGlza2V5d29yZCBALDQ4LTU3LF8sMzYsNjAsNjIsNjMsQC1ACiAKIHN5biBjYXNlIGlnbm9yZQogCmRpZmYgLS1naXQgYS9ydW50aW1lL3N5bnRheC9wYW1lbnYudmltIGIvcnVudGltZS9zeW50YXgvcGFtZW52LnZpbQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi45MDM1OWRhCi0tLSAvZGV2L251bGwKKysrIGIvcnVudGltZS9zeW50YXgvcGFtZW52LnZpbQpAQCAtMCwwICsxLDI4IEBACisiIFZpbSBzeW50YXggZmlsZQorIiBMYW5ndWFnZTogICAgICAgICAgICAgcGFtX2Vudi5jb25mKDUpIGNvbmZpZ3VyYXRpb24gZmlsZQorIiBMYXRlc3QgUmV2aXNpb246ICAgICAgMjAyMC0wNS0xMAorCitpZiBleGlzdHMoImI6Y3VycmVudF9zeW50YXgiKQorICBmaW5pc2gKK2VuZGlmCisKK3N5biBrZXl3b3JkICAgICBwYW1lbnZUb2RvICAgICAgICAgICAgICBjb250YWluZWQgVE9ETyBGSVhNRSBYWFggTk9URQorc3luIHJlZ2lvbiAgICAgIHBhbWVudkNvbW1lbnQgICAgICAgICAgIHN0YXJ0PSdeIycgZW5kPSckJyBkaXNwbGF5IG9uZWxpbmUgY29udGFpbnM9cGFtZW52VG9kbyxAU3BlbGxzCisKK3N5biBtYXRjaCAgICAgICBwYW1lbnZWYXJzICAgICAgICAgICAgICAnXltBLVpfXVtBLVpfMC05XSonIG5leHRncm91cD1wYW1lbnZLZXl3b3JkcyBza2lwd2hpdGUKKworc3luIGtleXdvcmQgICAgIHBhbWVudktleXdvcmRzICAgICAgICAgIGNvbnRhaW5lZCBERUZBVUxUIE9WRVJSSURFIG5leHRncm91cD1wYW1lbnZWYXJFcQorCitzeW4gbWF0Y2ggICAgICAgcGFtZW52VmFyRXEgICAgICAgICAgICAgY29udGFpbmVkICc9JyBuZXh0Z3JvdXA9cGFtZW52VmFsdWUscGFtZW52VmFsdWVXaXRoUXVvdGUKKworc3luIG1hdGNoICAgICAgIHBhbWVudlZhbHVlICAgICAgICAgICAgIGNvbnRhaW5lZCAnW14gXHRdKicgc2tpcHdoaXRlIG5leHRncm91cD1wYW1lbnZLZXl3b3Jkcworc3luIHJlZ2lvbiAgICAgIHBhbWVudlZhbHVlV2l0aFF1b3RlICAgIGNvbnRhaW5lZCBzdGFydD0nIicgZW5kPSciJyBza2lwd2hpdGUgbmV4dGdyb3VwPXBhbWVudktleXdvcmRzCisKK2hpIGRlZiBsaW5rICAgICBwYW1lbnZUb2RvICAgICAgICAgICAgICBUb2RvCitoaSBkZWYgbGluayAgICAgcGFtZW52Q29tbWVudCAgICAgICAgICAgQ29tbWVudAoraGkgZGVmIGxpbmsgICAgIHBhbWVudktleXdvcmRzICAgICAgICAgIEtleXdvcmQKK2hpIGRlZiBsaW5rICAgICBwYW1lbnZWYXJzICAgICAgICAgICAgICBJZGVudGlmaWVyCitoaSBkZWYgbGluayAgICAgcGFtZW52VmFsdWUgICAgICAgICAgICAgU3RyaW5nCitoaSBkZWYgbGluayAgICAgcGFtZW52VmFsdWVXaXRoUXVvdGUgICAgU3RyaW5nCisKK2xldCBiOmN1cnJlbnRfc3ludGF4ID0gInBhbWVudiIKZGlmZiAtLWdpdCBhL3J1bnRpbWUvc3ludGF4L3BocC52aW0gYi9ydW50aW1lL3N5bnRheC9waHAudmltCmluZGV4IDA0MDM2ZmQuLjcyMGQ3MWUgMTAwNjQ0Ci0tLSBhL3J1bnRpbWUvc3ludGF4L3BocC52aW0KKysrIGIvcnVudGltZS9zeW50YXgvcGhwLnZpbQpAQCAtMSw5ICsxLDExIEBACiAiIFZpbSBzeW50YXggZmlsZQogIiBMYW5ndWFnZTogcGhwIFBIUCAzLzQvNS83Ci0iIE1haW50YWluZXI6IEphc29uIFdvb2ZlbmRlbiA8amFzb25AamFzb253b29mLmNvbT4KLSIgTGFzdCBDaGFuZ2U6IE9jdCAxOSwgMjAxOQotIiBVUkw6IGh0dHBzOi8vamFzb253b29mLmNvbS9naXR3ZWIvP3A9dmltLXN5bnRheC5naXQ7YT1ibG9iO2Y9cGhwLnZpbTtoYj1IRUFECi0iIEZvcm1lciBNYWludGFpbmVyczogUGV0ZXIgSG9kZ2UgPHRvb211Y2hwaHAtdmltQHlhaG9vLmNvbT4KKyIgTWFpbnRhaW5lcjogVHlzb24gQW5kcmUgPHR5c29uYW5kcmU3NzVAaG90bWFpbC5jb20+CisiIExhc3QgQ2hhbmdlOiBNYXkgMTEsIDIwMjAKKyIgVVJMOiBodHRwczovL2dpdGh1Yi5jb20vVHlzb25BbmRyZS92aW0tc3ludGF4CisiIEZvcm1lciBNYWludGFpbmVyczogCisiICAgICAgICAgSmFzb24gV29vZmVuZGVuIDxqYXNvbkBqYXNvbndvb2YuY29tPgorIiAgICAgICAgIFBldGVyIEhvZGdlIDx0b29tdWNocGhwLXZpbUB5YWhvby5jb20+CiAiICAgICAgICAgRGViaWFuIFZJTSBNYWludGFpbmVycyA8cGtnLXZpbS1tYWludGFpbmVyc0BsaXN0cy5hbGlvdGguZGViaWFuLm9yZz4KICIKICIgTm90ZTogSWYgeW91IGFyZSB1c2luZyBhIGNvbG91ciB0ZXJtaW5hbCB3aXRoIGRhcmsgYmFja2dyb3VuZCwgeW91IHdpbGwKQEAgLTkxLDcgKzkzLDcgQEAKICAgc3luIGNsdXN0ZXIgcGhwQWRkU3RyaW5ncyBhZGQ9QGh0bWxUb3AKIGVuZGlmCiAKLSIgbWFrZSBzdXJlIHdlIGNhbiB1c2UgXCBhdCB0aGUgYmVnaW5pbmcgb2YgdGhlIGxpbmUgdG8gZG8gYSBjb250aW51YXRpb24KKyIgbWFrZSBzdXJlIHdlIGNhbiB1c2UgXCBhdCB0aGUgYmVnaW5uaW5nIG9mIHRoZSBsaW5lIHRvIGRvIGEgY29udGludWF0aW9uCiBsZXQgczpjcG9fc2F2ZSA9ICZjcG8KIHNldCBjcG8mdmltCiAKQEAgLTMxNCw3ICszMTYsNyBAQAogICAiIGRlZmluZSBhIGNsdXN0ZXIgdG8gZ2V0IGFsbCBpbnRlcnBvbGF0aW9uIHN5bnRheGVzIGZvciBkb3VibGUtcXVvdGVkIHN0cmluZ3MKICAgc3luIGNsdXN0ZXIgcGhwSW50ZXJwRG91YmxlIGNvbnRhaW5zPXBocEludGVycFNpbXBsZSxwaHBJbnRlcnBTaW1wbGVDdXJseSxwaHBJbnRlcnBEb2xsYXJDdXJseTEscGhwSW50ZXJwRG9sbGFyQ3VybHkyLHBocEludGVycEJvZ3VzRG9sbGFyQ3VybGV5LHBocEludGVycENvbXBsZXgKIAotIiBNZXRob2RlbgorIiBNZXRob2RzCiBzeW4gbWF0Y2ggcGhwTWV0aG9kc1ZhciAiLT5caFx3KiIgY29udGFpbmVkIGNvbnRhaW5zPXBocE1ldGhvZHMscGhwTWVtYmVyU2VsZWN0b3IgZGlzcGxheQogCiAiIEluY2x1ZGUKQEAgLTMyOCwxNCArMzMwLDE0IEBACiAKICIgRmxvYXQKICIgUmVmZXIgdG86IGh0dHBzOi8vd3d3LnBocC5uZXQvbWFudWFsL2VuL2xhbmd1YWdlLnR5cGVzLmZsb2F0LnBocAotc3luIG1hdGNoIHBocEZsb2F0ICJcJShcd1x8XC5cKVxAPCFcJShcZFx8XC5cKSpcZFwlKFxkXHxcLlwpKlwlKFtlRV1bKy1dXD1cJShcZFx8XC5cKVwrXClcPVwlKFx3XHxcLlwpXEAhIiBjb250YWluZWQgY29udGFpbnM9cGhwRmxvYXRFcnJvciBkaXNwbGF5Ci1zeW4gbWF0Y2ggcGhwRmxvYXRFcnJvciAiW2VFLl0uKlwuIiBjb250YWluZWQgZGlzcGxheQorc3luIG1hdGNoIHBocEZsb2F0ICJcJShcd1x8XC5cKVxAPCFcJShcZF9cP1x8XC5cKSpcZFwlKFxkXHxfXHxcLlwpKlwlKFtlRV1bKy1dXD1cJShcZFx8X1x8XC5cKVwrXClcPVwlKFx3XHxcLlwpXEAhIiBjb250YWluZWQgY29udGFpbnM9cGhwRmxvYXRFcnJvciBkaXNwbGF5CitzeW4gbWF0Y2ggcGhwRmxvYXRFcnJvciAiXCUoW2VFLl1bMC05Ll8rLV0qXC5cfF9fXHxfXChcPlx8W2VFXVwpXHxcKFw+XHxbZUVdXClfXCkiIGNvbnRhaW5lZCBkaXNwbGF5CiAKICIgTnVtYmVyCi1zeW4gbWF0Y2ggcGhwTnVtYmVyICJcJShcLlwpXEA8IVw8XCUoWzEtOV1cZCpcfDBcfDBbeFhdXHhcK1wpXD5cJShcLlwpXEAhIiBjb250YWluZWQgZGlzcGxheQorc3luIG1hdGNoIHBocE51bWJlciAiXCUoXC5cKVxAPCFcPFwlKFsxLTldXGQqXHwwXHwwW3hYXVwoXHhfXD9cKSpceFwpXD5cJShcLlwpXEAhIiBjb250YWluZWQgZGlzcGxheQogc3luIG1hdGNoIHBocE51bWJlciAiXCUoXC5cKVxAPCFcPDBcZFwrXD5cJShcLlwpXEAhIiBjb250YWluZWQgY29udGFpbnM9cGhwT2N0YWxFcnJvciBkaXNwbGF5CiBzeW4gbWF0Y2ggcGhwQmluYXJ5RXJyb3IgIlsyLTldIiBjb250YWluZWQgZGlzcGxheQotc3luIG1hdGNoIHBocE51bWJlciAiXCUoXC5cKVxAPCFcPDBbYkJdXGRcK1w+XCUoXC5cKVxAISIgY29udGFpbmVkIGNvbnRhaW5zPXBocEJpbmFyeUVycm9yIGRpc3BsYXkKK3N5biBtYXRjaCBwaHBOdW1iZXIgIlwlKFwuXClcQDwhXDwwW2JCXVwoXGRfXD9cKSpcZFw+XCUoXC5cKVxAISIgY29udGFpbmVkIGNvbnRhaW5zPXBocEJpbmFyeUVycm9yIGRpc3BsYXkKIAogIiBCYWNrc2xhc2ggZXNjYXBlcwogc3luIGNhc2UgbWF0Y2gKQEAgLTQ0Miw2ICs0NDQsNyBAQAogIiBtYXRjaCBvbmUgbGluZSBjb25zdHJ1Y3RzIGhlcmUgYW5kIHNraXAgdGhlbSBhdCBmb2xkaW5nCiAgIHN5biBrZXl3b3JkIHBocFNDS2V5d29yZCBhYnN0cmFjdCBmaW5hbCBwcml2YXRlIHByb3RlY3RlZCBwdWJsaWMgc3RhdGljIGNvbnRhaW5lZAogICBzeW4ga2V5d29yZCBwaHBGQ0tleXdvcmQgZnVuY3Rpb24gY29udGFpbmVkCisgIHN5biBrZXl3b3JkIHBocERlZmluZSBmbiBjb250YWluZWQKICAgc3luIGtleXdvcmQgcGhwU3RvcmFnZUNsYXNzIGdsb2JhbCBjb250YWluZWQKICAgc3luIG1hdGNoIHBocERlZmluZSAiXChcc1x8XlwpXChhYnN0cmFjdFxzXCtcfGZpbmFsXHNcK1x8cHJpdmF0ZVxzXCtcfHByb3RlY3RlZFxzXCtcfHB1YmxpY1xzXCtcfHN0YXRpY1xzXCtcKSpmdW5jdGlvblwoXHNcKy4qWzt9XVwpXEA9IiBjb250YWluZWQgY29udGFpbnM9cGhwU0NLZXl3b3JkCiAgIHN5biBtYXRjaCBwaHBTdHJ1Y3R1cmUgIlwoXHNcfF5cKVwoYWJzdHJhY3Rcc1wrXHxmaW5hbFxzXCtcKSpcKHRyYWl0XHxjbGFzc1wpXChcc1wrLip9XClcQD0iIGNvbnRhaW5lZApAQCAtNDU5LDcgKzQ2Miw3IEBACiAgIHN5biByZWdpb24gcGhwRm9sZENhdGNoIG1hdGNoZ3JvdXA9RXhjZXB0aW9uIHN0YXJ0PSJeXHooXHMqXCljYXRjaFxzXCtcKFtefV0qJFwpXEA9IiBtYXRjaGdyb3VwPURlbGltaXRlciBlbmQ9Il5cejF9IiBjb250YWlucz1AcGhwQ2xGdW5jdGlvbixwaHBGb2xkRnVuY3Rpb24gY29udGFpbmVkIHRyYW5zcGFyZW50IGZvbGQgZXh0ZW5kCiAgIHN5biByZWdpb24gcGhwRm9sZFRyeSBtYXRjaGdyb3VwPUV4Y2VwdGlvbiBzdGFydD0iXlx6KFxzKlwpdHJ5XHNcK1woW159XSokXClcQD0iIG1hdGNoZ3JvdXA9RGVsaW1pdGVyIGVuZD0iXlx6MX0iIGNvbnRhaW5zPUBwaHBDbEZ1bmN0aW9uLHBocEZvbGRGdW5jdGlvbiBjb250YWluZWQgdHJhbnNwYXJlbnQgZm9sZCBleHRlbmQKIGVsc2UKLSAgc3luIGtleXdvcmQgcGhwRGVmaW5lIGZ1bmN0aW9uIGNvbnRhaW5lZAorICBzeW4ga2V5d29yZCBwaHBEZWZpbmUgZnVuY3Rpb24gZm4gY29udGFpbmVkCiAgIHN5biBrZXl3b3JkIHBocFN0cnVjdHVyZSBhYnN0cmFjdCBjbGFzcyB0cmFpdCBpbnRlcmZhY2UgY29udGFpbmVkCiAgIHN5biBrZXl3b3JkIHBocEV4Y2VwdGlvbiBjYXRjaCB0aHJvdyB0cnkgZmluYWxseSBjb250YWluZWQKICAgc3luIGtleXdvcmQgcGhwU3RvcmFnZUNsYXNzIGZpbmFsIGdsb2JhbCBwcml2YXRlIHByb3RlY3RlZCBwdWJsaWMgc3RhdGljIGNvbnRhaW5lZApkaWZmIC0tZ2l0IGEvcnVudGltZS9zeW50YXgvc2gudmltIGIvcnVudGltZS9zeW50YXgvc2gudmltCmluZGV4IDBmNDQwNmQuLjNhMmE2ZTcgMTAwNjQ0Ci0tLSBhL3J1bnRpbWUvc3ludGF4L3NoLnZpbQorKysgYi9ydW50aW1lL3N5bnRheC9zaC52aW0KQEAgLTIsOCArMiw4IEBACiAiIExhbmd1YWdlOgkJc2hlbGwgKHNoKSBLb3JuIHNoZWxsIChrc2gpIGJhc2ggKHNoKQogIiBNYWludGFpbmVyOgkJQ2hhcmxlcyBFLiBDYW1wYmVsbCA8TmNhbXBPYmVsbEBTZHJQY2hpcC5Bb3JnTS1OT1NQQU0+CiAiIFByZXZpb3VzIE1haW50YWluZXI6CUxlbm5hcnQgU2NodWx0eiA8TGVubmFydC5TY2h1bHR6QGVjbXdmLmludD4KLSIgTGFzdCBDaGFuZ2U6CQlPY3QgMTYsIDIwMTkKLSIgVmVyc2lvbjoJCTE4OQorIiBMYXN0IENoYW5nZToJCUFwciAxNCwgMjAyMAorIiBWZXJzaW9uOgkJMTkwCiAiIFVSTDoJCWh0dHA6Ly93d3cuZHJjaGlwLm9yZy9hc3Ryb25hdXQvdmltL2luZGV4Lmh0bWwjU1lOVEFYX1NICiAiIEZvciBvcHRpb25zIGFuZCBzZXR0aW5ncywgcGxlYXNlIHVzZTogICAgICA6aGVscCBmdC1zaC1zeW50YXgKICIgVGhpcyBmaWxlIGluY2x1ZGVzIG1hbnkgaWRlYXMgZnJvbSBFcmljIEJydW5ldCAoZXJpYy5icnVuZXRAZW5zLmZyKQpAQCAtMzU3LDE5ICszNTcsMTggQEAKICBzeW4gcmVnaW9uICBzaEV4RG91YmxlUXVvdGUJbWF0Y2hHcm91cD1FcnJvciBzdGFydD0rXCQiKyBza2lwPStcXFxcXHxcXC4rIGVuZD0rIisJY29udGFpbnM9c2hTdHJpbmdTcGVjaWFsCiBlbmRpZgogc3luIHJlZ2lvbiAgc2hTaW5nbGVRdW90ZQltYXRjaGdyb3VwPXNoUXVvdGUgc3RhcnQ9KycrIGVuZD0rJysJCWNvbnRhaW5zPUBTcGVsbAluZXh0Z3JvdXA9c2hTcGVjaWFsU3RhcnQsc2hTcGVjaWFsU1EKLXN5biByZWdpb24gIHNoRG91YmxlUXVvdGUJbWF0Y2hncm91cD1zaFF1b3RlIHN0YXJ0PStcJShcJShcXFxcXCkqXFxcKVxAPCEiKyBza2lwPStcXCIrIGVuZD0rIisJY29udGFpbnM9QHNoRGJsUXVvdGVMaXN0LHNoU3RyaW5nU3BlY2lhbCxAU3BlbGwJbmV4dGdyb3VwPXNoU3BlY2lhbFN0YXJ0Ci1zeW4gcmVnaW9uICBzaERvdWJsZVF1b3RlCW1hdGNoZ3JvdXA9c2hRdW90ZSBzdGFydD0rIisgc2tpcD0rXFwiKyBlbmQ9KyIrCQljb250YWluZWQgY29udGFpbnM9QHNoRGJsUXVvdGVMaXN0LHNoU3RyaW5nU3BlY2lhbCxAU3BlbGwJbmV4dGdyb3VwPXNoU3BlY2lhbFN0YXJ0CitzeW4gcmVnaW9uICBzaERvdWJsZVF1b3RlCW1hdGNoZ3JvdXA9c2hRdW90ZSBzdGFydD0rXCUoXCUoXFxcXFwpKlxcXClcQDwhIisgc2tpcD0rXFwuKyBlbmQ9KyIrCWNvbnRhaW5zPUBzaERibFF1b3RlTGlzdCxzaFN0cmluZ1NwZWNpYWwsQFNwZWxsCW5leHRncm91cD1zaFNwZWNpYWxTdGFydAorc3luIHJlZ2lvbiAgc2hEb3VibGVRdW90ZQltYXRjaGdyb3VwPXNoUXVvdGUgc3RhcnQ9KyIrIG1hdGNoZ3JvdXA9c2hTcGVjaWFsIHNraXA9K1xcIisgZW5kPSsiKwkJY29udGFpbmVkCWNvbnRhaW5zPUBzaERibFF1b3RlTGlzdCxzaFN0cmluZ1NwZWNpYWwsQFNwZWxsCW5leHRncm91cD1zaFNwZWNpYWxTdGFydAogc3luIG1hdGNoICAgc2hTdHJpbmdTcGVjaWFsCSJbXls6cHJpbnQ6XSBcdF0iCQkJY29udGFpbmVkCiBzeW4gbWF0Y2ggICBzaFN0cmluZ1NwZWNpYWwJIlteXFxdXHpzXCUoXFxcXFwpKlxcW1xcIidgJCgpI10iCQkJbmV4dGdyb3VwPXNoQ29tbWVudAotc3luIG1hdGNoICAgc2hTdHJpbmdTcGVjaWFsCSJbXlxcXVx6c1wlKFxcXFxcKSpcXFtcXCInYCQoKSNdIgogc3luIG1hdGNoICAgc2hTcGVjaWFsU1EJIlteXFxdXHpzXCUoXFxcXFwpKlxcW1xcIidgJCgpI10iCQljb250YWluZWQJbmV4dGdyb3VwPXNoQmtzbHNoU25nbFF1b3RlLEBzaE5vWlNMaXN0CiBzeW4gbWF0Y2ggICBzaFNwZWNpYWxEUQkiW15cXF1cenNcJShcXFxcXCkqXFxbXFwiJ2AkKCkjXSIJCWNvbnRhaW5lZAluZXh0Z3JvdXA9c2hCa3Nsc2hEYmxRdW90ZSxAc2hOb1pTTGlzdAogc3luIG1hdGNoICAgc2hTcGVjaWFsU3RhcnQJIlwlKFxcXFxcKSpcXFtcXCInYCQoKSNdIgkJCWNvbnRhaW5lZAluZXh0Z3JvdXA9c2hCa3Nsc2hTbmdsUXVvdGUsc2hCa3Nsc2hEYmxRdW90ZSxAc2hOb1pTTGlzdAogc3luIG1hdGNoICAgc2hTcGVjaWFsCSJeXCUoXFxcXFwpKlxcW1xcIidgJCgpI10iCiBzeW4gbWF0Y2ggICBzaFNwZWNpYWxOb1pTCWNvbnRhaW5lZAkiXCUoXFxcXFwpKlxcW1xcIidgJCgpI10iCiBzeW4gbWF0Y2ggICBzaFNwZWNpYWxOeHQJY29udGFpbmVkCSJcXFtcXCInYCQoKSNdIgotc3luIHJlZ2lvbiAgc2hCa3Nsc2hTbmdsUXVvdGUJY29udGFpbmVkCW1hdGNoZ3JvdXA9c2hRdW90ZSBzdGFydD0rJysgZW5kPSsnKwljb250YWlucz1AU3BlbGwJbmV4dGdyb3VwPXNoU3BlY2lhbFN0YXJ0Ci1zeW4gcmVnaW9uICBzaEJrc2xzaERibFF1b3RlCWNvbnRhaW5lZAltYXRjaGdyb3VwPXNoUXVvdGUgc3RhcnQ9KyIrIHNraXA9K1xcIisgZW5kPSsiKwljb250YWlucz1Ac2hEYmxRdW90ZUxpc3Qsc2hTdHJpbmdTcGVjaWFsLEBTcGVsbAluZXh0Z3JvdXA9c2hTcGVjaWFsU3RhcnQKKyJzeW4gcmVnaW9uICBzaEJrc2xzaFNuZ2xRdW90ZQljb250YWluZWQJbWF0Y2hncm91cD1zaFF1b3RlIHN0YXJ0PSsnKyBlbmQ9KycrCWNvbnRhaW5zPUBTcGVsbAluZXh0Z3JvdXA9c2hTcGVjaWFsU3RhcnQKKyJzeW4gcmVnaW9uICBzaEJrc2xzaERibFF1b3RlCWNvbnRhaW5lZAltYXRjaGdyb3VwPXNoUXVvdGUgc3RhcnQ9KyIrIHNraXA9K1xcIisgZW5kPSsiKwljb250YWlucz1Ac2hEYmxRdW90ZUxpc3Qsc2hTdHJpbmdTcGVjaWFsLEBTcGVsbAluZXh0Z3JvdXA9c2hTcGVjaWFsU3RhcnQKIAogIiBDb21tZW50czoge3t7MQogIj09PT09PT09PT0KQEAgLTQ1NCwxMyArNDUzLDEzIEBACiAgc3luIG1hdGNoICBzaERlcmVmV29yZEVycm9yCSJbXn0kW35dIgljb250YWluZWQKIGVuZGlmCiBzeW4gbWF0Y2ggIHNoRGVyZWZTaW1wbGUJIlwkXCUoXGhcdypcfFxkXCkiCW5leHRncm91cD1Ac2hOb1pTTGlzdAotc3luIHJlZ2lvbiBzaERlcmVmCW1hdGNoZ3JvdXA9UHJlUHJvYyBzdGFydD0iXCR7IiBlbmQ9In0iCWNvbnRhaW5zPUBzaERlcmVmTGlzdCxzaERlcmVmVmFyQXJyYXkKK3N5biByZWdpb24gc2hEZXJlZgltYXRjaGdyb3VwPVByZVByb2Mgc3RhcnQ9IlwkeyIgZW5kPSJ9Igljb250YWlucz1Ac2hEZXJlZkxpc3Qsc2hEZXJlZlZhckFycmF5IG5leHRncm91cD1zaFNwZWNpYWxTdGFydAogc3luIG1hdGNoICBzaERlcmVmU2ltcGxlCSJcJFstIypAIT9dIgluZXh0Z3JvdXA9QHNoTm9aU0xpc3QKIHN5biBtYXRjaCAgc2hEZXJlZlNpbXBsZQkiXCRcJCIJbmV4dGdyb3VwPUBzaE5vWlNMaXN0Ci1zeW4gbWF0Y2ggIHNoRGVyZWZTaW1wbGUJIlwke1xkfSIJbmV4dGdyb3VwPUBzaE5vWlNMaXN0CitzeW4gbWF0Y2ggIHNoRGVyZWZTaW1wbGUJIlwke1xkfSIJbmV4dGdyb3VwPUBzaE5vWlNMaXN0CW5leHRncm91cD1zaFNwZWNpYWxTdGFydAogaWYgZXhpc3RzKCJiOmlzX2Jhc2giKSB8fCBleGlzdHMoImI6aXNfa29ybnNoZWxsIikgfHwgZXhpc3RzKCJiOmlzX3Bvc2l4IikKLSBzeW4gcmVnaW9uIHNoRGVyZWYJbWF0Y2hncm91cD1QcmVQcm9jIHN0YXJ0PSJcJHsjI1w9IiBlbmQ9In0iCWNvbnRhaW5zPUBzaERlcmVmTGlzdAluZXh0Z3JvdXA9QHNoU3BlY2lhbE5vWlMKLSBzeW4gcmVnaW9uIHNoRGVyZWYJbWF0Y2hncm91cD1QcmVQcm9jIHN0YXJ0PSJcJHtcJFwkIiBlbmQ9In0iCWNvbnRhaW5zPUBzaERlcmVmTGlzdAluZXh0Z3JvdXA9QHNoU3BlY2lhbE5vWlMKKyBzeW4gcmVnaW9uIHNoRGVyZWYJbWF0Y2hncm91cD1QcmVQcm9jIHN0YXJ0PSJcJHsjI1w9IiBlbmQ9In0iCWNvbnRhaW5zPUBzaERlcmVmTGlzdAluZXh0Z3JvdXA9QHNoU3BlY2lhbE5vWlMsc2hTcGVjaWFsU3RhcnQKKyBzeW4gcmVnaW9uIHNoRGVyZWYJbWF0Y2hncm91cD1QcmVQcm9jIHN0YXJ0PSJcJHtcJFwkIiBlbmQ9In0iCWNvbnRhaW5zPUBzaERlcmVmTGlzdAluZXh0Z3JvdXA9QHNoU3BlY2lhbE5vWlMsc2hTcGVjaWFsU3RhcnQKIGVuZGlmCiAKICIga3NoOiAkeyF2YXJbKl19IGFycmF5IGluZGV4IGxpc3Qgc3ludGF4OiB7e3sxCmRpZmYgLS1naXQgYS9zcmMvcG8vYWYucG8gYi9zcmMvcG8vYWYucG8KaW5kZXggMGIwNDdmYy4uZTE5YzJjNCAxMDA2NDQKLS0tIGEvc3JjL3BvL2FmLnBvCisrKyBiL3NyYy9wby9hZi5wbwpAQCAtMjE1MSw3ICsyMTUxLDcgQEAKIG1zZ2lkICJrZXlib2FyZCBpbnRlcnJ1cHQiCiBtc2dzdHIgInNsZXV0ZWxib3Jkb25kZXJicmVraW5nIgogCi1tc2dpZCAidmltIGVycm9yIgorbXNnaWQgIlZpbSBlcnJvciIKIG1zZ3N0ciAidmltIGZvdXQiCiAKIG1zZ2lkICJjYW5ub3QgY3JlYXRlIGJ1ZmZlci93aW5kb3cgY29tbWFuZDogb2JqZWN0IGlzIGJlaW5nIGRlbGV0ZWQiCkBAIC0yNDMyLDggKzI0MzIsOCBAQAogbXNnaWQgIi14XHRcdFx0RWRpdCBlbmNyeXB0ZWQgZmlsZXMiCiBtc2dzdHIgIi14XHRcdFx0QmV3ZXJrIGdl625rcmlwdGVlcmRlIGzqZXJzIgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRDb25uZWN0IHZpbSB0byB0aGlzIHBhcnRpY3VsYXIgWC1zZXJ2ZXIiCi1tc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0S29wcGVsIHZpbSBhYW4gaGllcmRpZSBYLWJlZGllbmVyIgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0Q29ubmVjdCBWaW0gdG8gdGhpcyBwYXJ0aWN1bGFyIFgtc2VydmVyIgorbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdEtvcHBlbCBWaW0gYWFuIGhpZXJkaWUgWC1iZWRpZW5lciIKIAogbXNnaWQgIi1YXHRcdFx0RG8gbm90IGNvbm5lY3QgdG8gWCBzZXJ2ZXIiCiBtc2dzdHIgIi1YXHRcdFx0TW9ldCBuaWUgdmVyYmluZGluZyBtZXQgWC1iZWRpZW5lciBtYWFrIG5pZSIKQEAgLTI0OTgsMTAgKzI0OTgsMTAgQEAKICJcbiIKICJQYXJhbWV0ZXJzIGRldXIgZ3ZpbSBoZXJrZW4gKEF0aGVuYSB3ZWVyZ2F3ZSk6XG4iCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biB2aW0gb24gPGRpc3BsYXk+IgotbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdFZvZXIgdmltIG9wIDxkaXNwbGF5PiB1aXQiCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gVmltIG9uIDxkaXNwbGF5PiIKK21zZ3N0ciAiLWRpc3BsYXkgPGRpc3BsYXk+XHRWb2VyIFZpbSBvcCA8ZGlzcGxheT4gdWl0IgogCi1tc2dpZCAiLWljb25pY1x0XHRTdGFydCB2aW0gaWNvbmlmaWVkIgorbXNnaWQgIi1pY29uaWNcdFx0U3RhcnQgVmltIGljb25pZmllZCIKIG1zZ3N0ciAiLWljb25pY1x0XHRCZWdpbiB2aW0gYXMgaWtvb24iCiAKIG1zZ2lkICItbmFtZSA8bmFtZT5cdFx0VXNlIHJlc291cmNlIGFzIGlmIHZpbSB3YXMgPG5hbWU+IgpAQCAtMjU2OCw4ICsyNTY4LDggQEAKICJcbiIKICJQYXJhbWV0ZXJzIHdhdCBndmltIHZlcnN0YWFuIChHVEsrIHdlZXJnYXdlKTpcbiIKIAotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIHZpbSBvbiA8ZGlzcGxheT4gKGFsc286IC0tZGlzcGxheSkiCi1tc2dzdHIgIi1kaXNwbGF5IDxza2VybT5cdFZvZXIgdmltIG9wIDxza2VybT4gdWl0OiAob29rIC0tZGlzcGxheSkiCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gVmltIG9uIDxkaXNwbGF5PiAoYWxzbzogLS1kaXNwbGF5KSIKK21zZ3N0ciAiLWRpc3BsYXkgPHNrZXJtPlx0Vm9lciBWaW0gb3AgPHNrZXJtPiB1aXQ6IChvb2sgLS1kaXNwbGF5KSIKIAogbXNnaWQgIi0tcm9sZSA8cm9sZT5cdFNldCBhIHVuaXF1ZSByb2xlIHRvIGlkZW50aWZ5IHRoZSBtYWluIHdpbmRvdyIKIG1zZ3N0ciAiLS1yb2xlIDxyb2w+XHRTdGVsICduIHVuaWVrZSByb2wgb20gZGllIGhvb2Z2ZW5zdGVyIHRlIGlkZW50aWZpc2VlciIKZGlmZiAtLWdpdCBhL3NyYy9wby9jYS5wbyBiL3NyYy9wby9jYS5wbwppbmRleCA2NWJlOGY2Li41ZmI1ZWRlIDEwMDY0NAotLS0gYS9zcmMvcG8vY2EucG8KKysrIGIvc3JjL3BvL2NhLnBvCkBAIC0yNzYwLDkgKzI3NjAsNiBAQAogbXNnaWQgImtleWJvYXJkIGludGVycnVwdCIKIG1zZ3N0ciAiaW50ZXJydXBjafMgZGUgdGVjbGF0IgogCi1tc2dpZCAidmltIGVycm9yIgotbXNnc3RyICJlcnJvciBkZSB2aW0iCi0KIG1zZ2lkICJjYW5ub3QgY3JlYXRlIGJ1ZmZlci93aW5kb3cgY29tbWFuZDogb2JqZWN0IGlzIGJlaW5nIGRlbGV0ZWQiCiBtc2dzdHIgIm5vIGVzIHBvdCBjcmVhciBsJ29yZHJlIFRjbDogbCdvYmplY3RlIGVzdOAgc2VudCBlbGltaW5hbnQiCiAKQEAgLTMwODAsNyArMzA3Nyw3IEBACiBtc2dpZCAiLXhcdFx0XHRFZGl0IGVuY3J5cHRlZCBmaWxlcyIKIG1zZ3N0ciAiLXhcdFx0XHRFZGl0YSBmaXR4ZXJzIGFtYiB4aWZyYXQiCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdENvbm5lY3QgdmltIHRvIHRoaXMgcGFydGljdWxhciBYLXNlcnZlciIKK21zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdENvbm5lY3QgVmltIHRvIHRoaXMgcGFydGljdWxhciBYLXNlcnZlciIKIG1zZ3N0ciAiLWRpc3BsYXkgPHBhbnRhbGxhPlx0Q29ubmVjdGEgZWwgVmltIGEgdW4gc2Vydmlkb3IgWCBwYXJ0aWN1bGFyIgogCiBtc2dpZCAiLVhcdFx0XHREbyBub3QgY29ubmVjdCB0byBYIHNlcnZlciIKQEAgLTMxNTEsMTAgKzMxNDgsMTAgQEAKICJcbiIKICJBcmd1bWVudHMgcmVjb25lZ3V0cyBwZWwgZ3ZpbSAodmVyc2nzIEF0aGVuYSk6XG4iCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biB2aW0gb24gPGRpc3BsYXk+IgotbXNnc3RyICItZGlzcGxheSA8cGFudGFsbGE+XHRFeGVjdXRhIHZpbSBhIDxwYW50YWxsYT4iCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gVmltIG9uIDxkaXNwbGF5PiIKK21zZ3N0ciAiLWRpc3BsYXkgPHBhbnRhbGxhPlx0RXhlY3V0YSBWaW0gYSA8cGFudGFsbGE+IgogCi1tc2dpZCAiLWljb25pY1x0XHRTdGFydCB2aW0gaWNvbmlmaWVkIgorbXNnaWQgIi1pY29uaWNcdFx0U3RhcnQgVmltIGljb25pZmllZCIKIG1zZ3N0ciAiLWljb25pY1x0XHRDb21lbudhIGljb25pZmljYXQiCiAKIG1zZ2lkICItYmFja2dyb3VuZCA8Y29sb3I+XHRVc2UgPGNvbG9yPiBmb3IgdGhlIGJhY2tncm91bmQgKGFsc286IC1iZykiCkBAIC0zMjAwLDE0ICszMTk3LDE0IEBACiAiXG4iCiAiQXJndW1lbnRzIHJlY29uZWd1dHMgcGVsIGd2aW0gKHZlcnNp8yBHVEsrKTpcbiIKIAotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIHZpbSBvbiA8ZGlzcGxheT4gKGFsc286IC0tZGlzcGxheSkiCi1tc2dzdHIgIi1kaXNwbGF5IDxwYW50YWxsYT5cdEV4ZWN1dGEgdmltIGEgPHBhbnRhbGxhPiAodGFtYuk6IC0tZGlzcGxheSkiCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gVmltIG9uIDxkaXNwbGF5PiAoYWxzbzogLS1kaXNwbGF5KSIKK21zZ3N0ciAiLWRpc3BsYXkgPHBhbnRhbGxhPlx0RXhlY3V0YSBWaW0gYSA8cGFudGFsbGE+ICh0YW1i6TogLS1kaXNwbGF5KSIKIAogbXNnaWQgIi0tcm9sZSA8cm9sZT5cdFNldCBhIHVuaXF1ZSByb2xlIHRvIGlkZW50aWZ5IHRoZSBtYWluIHdpbmRvdyIKIG1zZ3N0ciAiLS1yb2xlIDxyb2w+XHRcdFVzYSB1biD6bmljIHJvbCBwZXIgYSBpZGVudGlmaWNhciBsYSBmaW5lc3RyYSBwcmluY2lwYWwiCiAKIG1zZ2lkICItLXNvY2tldGlkIDx4aWQ+XHRPcGVuIFZpbSBpbnNpZGUgYW5vdGhlciBHVEsgd2lkZ2V0IgotbXNnc3RyICItLXNvY2tldGlkIDx4aWQ+XHRPYnJlIGVsIHZpbSBkaW5zIGQndW4gYWx0cmUgZ2lueSBHVEsiCittc2dzdHIgIi0tc29ja2V0aWQgPHhpZD5cdE9icmUgZWwgVmltIGRpbnMgZCd1biBhbHRyZSBnaW55IEdUSyIKIAogbXNnaWQgIi0tZWNoby13aWRcdFx0TWFrZSBndmltIGVjaG8gdGhlIFdpbmRvdyBJRCBvbiBzdGRvdXQiCiBtc2dzdHIgIi0tZWNoby13aWRcdFx0RXNjcml1IGVsIFdpbmRvdyBJRCBhIGxhIHNvcnRpZGEgZXN04G5kYXJkIgpAQCAtNjc3NCw4ICs2NzcxLDggQEAKIG1zZ3N0ciAi7W5kZXggZGUgbGxpc3RhIGZvcmEgZGUgbCdpbnRlcnZhbCIKIAogIywgYy1mb3JtYXQKLW1zZ2lkICJpbnRlcm5hbCBlcnJvcjogZmFpbGVkIHRvIGdldCB2aW0gbGlzdCBpdGVtICVkIgotbXNnc3RyICJlcnJvciBpbnRlcm46IGVycm9yIGVuIG9idGVuaXIgbCdlbGVtZW50ICVkIGRlIGxhIGxsaXN0YSB2aW0iCittc2dpZCAiaW50ZXJuYWwgZXJyb3I6IGZhaWxlZCB0byBnZXQgVmltIGxpc3QgaXRlbSAlZCIKK21zZ3N0ciAiZXJyb3IgaW50ZXJuOiBlcnJvciBlbiBvYnRlbmlyIGwnZWxlbWVudCAlZCBkZSBsYSBsbGlzdGEgVmltIgogCiBtc2dpZCAic2xpY2Ugc3RlcCBjYW5ub3QgYmUgemVybyIKIG1zZ3N0ciAibCdpbmNyZW1lbnQgZGUgbCdpbnRlcnZhbCBubyBwb3Qgc2VyIHplcm8iCkBAIC02Nzg1LDggKzY3ODIsOCBAQAogbXNnc3RyICJpbnRlbnQgZCdhc3NpZ25hciB1bmEgc2Vx/OhuY2lhIGRlIG3pcyBkZSAlZCBlbGVtZW50cyBhIHVuIGludGVydmFsIGVzdOhzIgogCiAjLCBjLWZvcm1hdAotbXNnaWQgImludGVybmFsIGVycm9yOiBubyB2aW0gbGlzdCBpdGVtICVkIgotbXNnc3RyICJlcnJvciBpbnRlcm46IG5vIGV4aXN0ZWl4IGwnZWxlbWVudCAlZCBhIGxhIGxsaXN0YSB2aW0iCittc2dpZCAiaW50ZXJuYWwgZXJyb3I6IG5vIFZpbSBsaXN0IGl0ZW0gJWQiCittc2dzdHIgImVycm9yIGludGVybjogbm8gZXhpc3RlaXggbCdlbGVtZW50ICVkIGEgbGEgbGxpc3RhIFZpbSIKIAogbXNnaWQgImludGVybmFsIGVycm9yOiBub3QgZW5vdWdoIGxpc3QgaXRlbXMiCiBtc2dzdHIgImVycm9yIGludGVybjogbm8gaGkgaGEgcHJvdSBlbGVtZW50cyBhIGxhIGxsaXN0YSIKQEAgLTY4OTQsMTkgKzY4OTEsMTkgQEAKIG1zZ2lkICJFODU4OiBFdmFsIGRpZCBub3QgcmV0dXJuIGEgdmFsaWQgcHl0aG9uIG9iamVjdCIKIG1zZ3N0ciAiRTg1ODogRXZhbCBubyBoYSByZXRvcm5hdCB1biBvYmplY3RlIFB5dGhvbiB24GxpZCIKIAotbXNnaWQgIkU4NTk6IEZhaWxlZCB0byBjb252ZXJ0IHJldHVybmVkIHB5dGhvbiBvYmplY3QgdG8gdmltIHZhbHVlIgorbXNnaWQgIkU4NTk6IEZhaWxlZCB0byBjb252ZXJ0IHJldHVybmVkIHB5dGhvbiBvYmplY3QgdG8gYSBWaW0gdmFsdWUiCiBtc2dzdHIgIkU4NTk6IEVycm9yIGVuIGNvbnZlcnRpciBsJ29iamVjdGUgUHl0aG9uIHJldG9ybmF0IGEgdW4gdmFsb3IgVmltIgogCiAjLCBjLWZvcm1hdAotbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIHZpbSBkaWN0aW9uYXJ5IgorbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIGEgVmltIGRpY3Rpb25hcnkiCiBtc2dzdHIgImVycm9yIGVuIGNvbnZlcnRpciAlcyBlbiB1biBkaWNjaW9uYXJpIFZpbSIKIAogIywgYy1mb3JtYXQKLW1zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byB2aW0gbGlzdCIKK21zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byBhIFZpbSBsaXN0IgogbXNnc3RyICJlcnJvciBlbiBjb252ZXJ0aXIgJXMgZW4gdW5hIGxsaXN0YSBWaW0iCiAKICMsIGMtZm9ybWF0Ci1tc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gdmltIHN0cnVjdHVyZSIKK21zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byBhIFZpbSBzdHJ1Y3R1cmUiCiBtc2dzdHIgImVycm9yIGVuIGNvbnZlcnRpciAlcyBlbiB1bmEgZXN0cnVjdHVyYSBWaW0iCiAKIG1zZ2lkICJpbnRlcm5hbCBlcnJvcjogTlVMTCByZWZlcmVuY2UgcGFzc2VkIgpkaWZmIC0tZ2l0IGEvc3JjL3BvL2NzLmNwMTI1MC5wbyBiL3NyYy9wby9jcy5jcDEyNTAucG8KaW5kZXggNDAxZjYwZC4uODA5Y2VkMSAxMDA2NDQKLS0tIGEvc3JjL3BvL2NzLmNwMTI1MC5wbworKysgYi9zcmMvcG8vY3MuY3AxMjUwLnBvCkBAIC0xOTYyLDcgKzE5NjIsNyBAQAogbXNnaWQgImtleWJvYXJkIGludGVycnVwdCIKIG1zZ3N0ciAicPhlcnWaZW7tIHoga2zhdmVzbmljZSIKIAotbXNnaWQgInZpbSBlcnJvciIKK21zZ2lkICJWaW0gZXJyb3IiCiBtc2dzdHIgImNoeWJhIHZpbSIKIAogbXNnaWQgImNhbm5vdCBjcmVhdGUgYnVmZmVyL3dpbmRvdyBjb21tYW5kOiBvYmplY3QgaXMgYmVpbmcgZGVsZXRlZCIKQEAgLTIyNDcsOCArMjI0Nyw4IEBACiBtc2dpZCAiLXhcdFx0XHRFZGl0IGVuY3J5cHRlZCBmaWxlcyIKIG1zZ3N0ciAiLXhcdFx0XHRFZGl0YWNlIHphmmlmcm92YW79Y2ggc291Ym9y+SIKIAotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0Q29ubmVjdCB2aW0gdG8gdGhpcyBwYXJ0aWN1bGFyIFgtc2VydmVyIgotbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdFNwdXN07SB2aW0gbmEgZGFu/SBYLXNlcnZlciIKK21zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdENvbm5lY3QgVmltIHRvIHRoaXMgcGFydGljdWxhciBYLXNlcnZlciIKK21zZ3N0ciAiLWRpc3BsYXkgPGRpc3BsYXk+XHRTcHVzdO0gVmltIG5hIGRhbv0gWC1zZXJ2ZXIiCiAKIG1zZ2lkICItWFx0XHRcdERvIG5vdCBjb25uZWN0IHRvIFggc2VydmVyIgogbXNnc3RyICItWFx0XHRcdE5lcPhpcG9q7SBzZSBrIFggc2VydmVydSIKQEAgLTIzMDAsMTEgKzIzMDAsMTEgQEAKICJcbiIKICJQ+GVw7W5h6GUgcHJvIGd2aW0gKEF0aGVuYSB2ZXJ6aSk6XG4iCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biB2aW0gb24gPGRpc3BsYXk+IgotbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdFNwdXN07SB2aW0gbmEgPGRpc3BsYXk+IgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIFZpbSBvbiA8ZGlzcGxheT4iCittc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0U3B1c3TtIFZpbSBuYSA8ZGlzcGxheT4iCiAKLW1zZ2lkICItaWNvbmljXHRcdFN0YXJ0IHZpbSBpY29uaWZpZWQiCi1tc2dzdHIgIi1pY29uaWNcdFx0U3B1c3TtIHZpbSBtaW5pbWFsaXpvdmFu6SIKK21zZ2lkICItaWNvbmljXHRcdFN0YXJ0IFZpbSBpY29uaWZpZWQiCittc2dzdHIgIi1pY29uaWNcdFx0U3B1c3TtIFZpbSBtaW5pbWFsaXpvdmFu6SIKIAogbXNnaWQgIi1uYW1lIDxuYW1lPlx0XHRVc2UgcmVzb3VyY2UgYXMgaWYgdmltIHdhcyA8bmFtZT4iCiBtc2dzdHIgIi1uYW1lIDxu4Xpldj5cdFx0UG91nmlqZSByZXNvdXJjZSBqYWtvIGJ5IHZpbSBt7GwgPG7hemV2PiIKQEAgLTIzNjgsOCArMjM2OCw4IEBACiAiXG4iCiAiUPhlcO1uYehlIHBybyBndmltIChHVEsrIHZlcnppKTpcbiIKIAotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIHZpbSBvbiA8ZGlzcGxheT4gKGFsc286IC0tZGlzcGxheSkiCi1tc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0U3B1c3TtIHZpbSBuYSA8ZGlzcGxheT4gKHRha+kgLS1kaXNwbGF5KSIKK21zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biBWaW0gb24gPGRpc3BsYXk+IChhbHNvOiAtLWRpc3BsYXkpIgorbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdFNwdXN07SBWaW0gbmEgPGRpc3BsYXk+ICh0YWvpIC0tZGlzcGxheSkiCiAKIG1zZ2lkICItLWhlbHBcdFx0U2hvdyBHbm9tZSBhcmd1bWVudHMiCiBtc2dzdHIgIi0taGVscFx0XHRWeXDtmmUgR25vbWUgcPhlcO1uYehlIgpkaWZmIC0tZ2l0IGEvc3JjL3BvL2NzLnBvIGIvc3JjL3BvL2NzLnBvCmluZGV4IDE3ZDk0YjMuLjZlNmNjM2IgMTAwNjQ0Ci0tLSBhL3NyYy9wby9jcy5wbworKysgYi9zcmMvcG8vY3MucG8KQEAgLTE5NjIsNyArMTk2Miw3IEBACiBtc2dpZCAia2V5Ym9hcmQgaW50ZXJydXB0IgogbXNnc3RyICJw+GVydbllbu0geiBrbOF2ZXNuaWNlIgogCi1tc2dpZCAidmltIGVycm9yIgorbXNnaWQgIlZpbSBlcnJvciIKIG1zZ3N0ciAiY2h5YmEgdmltIgogCiBtc2dpZCAiY2Fubm90IGNyZWF0ZSBidWZmZXIvd2luZG93IGNvbW1hbmQ6IG9iamVjdCBpcyBiZWluZyBkZWxldGVkIgpAQCAtMjI0Nyw4ICsyMjQ3LDggQEAKIG1zZ2lkICIteFx0XHRcdEVkaXQgZW5jcnlwdGVkIGZpbGVzIgogbXNnc3RyICIteFx0XHRcdEVkaXRhY2UgemG5aWZyb3Zhbv1jaCBzb3Vib3L5IgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRDb25uZWN0IHZpbSB0byB0aGlzIHBhcnRpY3VsYXIgWC1zZXJ2ZXIiCi1tc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0U3B1c3TtIHZpbSBuYSBkYW79IFgtc2VydmVyIgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0Q29ubmVjdCBWaW0gdG8gdGhpcyBwYXJ0aWN1bGFyIFgtc2VydmVyIgorbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdFNwdXN07SBWaW0gbmEgZGFu/SBYLXNlcnZlciIKIAogbXNnaWQgIi1YXHRcdFx0RG8gbm90IGNvbm5lY3QgdG8gWCBzZXJ2ZXIiCiBtc2dzdHIgIi1YXHRcdFx0TmVw+Glwb2rtIHNlIGsgWCBzZXJ2ZXJ1IgpAQCAtMjMwMCwxMSArMjMwMCwxMSBAQAogIlxuIgogIlD4ZXDtbmHoZSBwcm8gZ3ZpbSAoQXRoZW5hIHZlcnppKTpcbiIKIAotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIHZpbSBvbiA8ZGlzcGxheT4iCi1tc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0U3B1c3TtIHZpbSBuYSA8ZGlzcGxheT4iCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gVmltIG9uIDxkaXNwbGF5PiIKK21zZ3N0ciAiLWRpc3BsYXkgPGRpc3BsYXk+XHRTcHVzdO0gVmltIG5hIDxkaXNwbGF5PiIKIAotbXNnaWQgIi1pY29uaWNcdFx0U3RhcnQgdmltIGljb25pZmllZCIKLW1zZ3N0ciAiLWljb25pY1x0XHRTcHVzdO0gdmltIG1pbmltYWxpem92YW7pIgorbXNnaWQgIi1pY29uaWNcdFx0U3RhcnQgVmltIGljb25pZmllZCIKK21zZ3N0ciAiLWljb25pY1x0XHRTcHVzdO0gVmltIG1pbmltYWxpem92YW7pIgogCiBtc2dpZCAiLW5hbWUgPG5hbWU+XHRcdFVzZSByZXNvdXJjZSBhcyBpZiB2aW0gd2FzIDxuYW1lPiIKIG1zZ3N0ciAiLW5hbWUgPG7hemV2Plx0XHRQb3W+aWplIHJlc291cmNlIGpha28gYnkgdmltIG3sbCA8buF6ZXY+IgpAQCAtMjM2OCw4ICsyMzY4LDggQEAKICJcbiIKICJQ+GVw7W5h6GUgcHJvIGd2aW0gKEdUSysgdmVyemkpOlxuIgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gdmltIG9uIDxkaXNwbGF5PiAoYWxzbzogLS1kaXNwbGF5KSIKLW1zZ3N0ciAiLWRpc3BsYXkgPGRpc3BsYXk+XHRTcHVzdO0gdmltIG5hIDxkaXNwbGF5PiAodGFr6SAtLWRpc3BsYXkpIgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIFZpbSBvbiA8ZGlzcGxheT4gKGFsc286IC0tZGlzcGxheSkiCittc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0U3B1c3TtIFZpbSBuYSA8ZGlzcGxheT4gKHRha+kgLS1kaXNwbGF5KSIKIAogbXNnaWQgIi0taGVscFx0XHRTaG93IEdub21lIGFyZ3VtZW50cyIKIG1zZ3N0ciAiLS1oZWxwXHRcdFZ5cO25ZSBHbm9tZSBw+GVw7W5h6GUiCmRpZmYgLS1naXQgYS9zcmMvcG8vZGEucG8gYi9zcmMvcG8vZGEucG8KaW5kZXggNjkyYjNiZi4uYTVlOWMyNiAxMDA2NDQKLS0tIGEvc3JjL3BvL2RhLnBvCisrKyBiL3NyYy9wby9kYS5wbwpAQCAtMjgwNyw5ICsyODA3LDYgQEAKIG1zZ2lkICJrZXlib2FyZCBpbnRlcnJ1cHQiCiBtc2dzdHIgInRhc3RhdHVyYWZicnlkIgogCi1tc2dpZCAidmltIGVycm9yIgotbXNnc3RyICJmZWpsIHZlZCB2aW0iCi0KIG1zZ2lkICJjYW5ub3QgY3JlYXRlIGJ1ZmZlci93aW5kb3cgY29tbWFuZDogb2JqZWN0IGlzIGJlaW5nIGRlbGV0ZWQiCiBtc2dzdHIgImthbiBpa2tlIG9wcmV0dGUgYnVmZmVyLS92aW5kdWUta29tbWFuZG86IG9iamVrdCBzbGV0dGVzIgogCkBAIC0zMTM2LDggKzMxMzMsOCBAQAogbXNnaWQgIi14XHRcdFx0RWRpdCBlbmNyeXB0ZWQgZmlsZXMiCiBtc2dzdHIgIi14XHRcdFx0UmVkaWdlciBrcnlwdGVyZWRlIGZpbGVyIgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRDb25uZWN0IHZpbSB0byB0aGlzIHBhcnRpY3VsYXIgWC1zZXJ2ZXIiCi1tc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0Rm9yYmluZCB2aW0gdGlsIGRlbm5lIFgtc2VydmVyIgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0Q29ubmVjdCBWaW0gdG8gdGhpcyBwYXJ0aWN1bGFyIFgtc2VydmVyIgorbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdEZvcmJpbmQgVmltIHRpbCBkZW5uZSBYLXNlcnZlciIKIAogbXNnaWQgIi1YXHRcdFx0RG8gbm90IGNvbm5lY3QgdG8gWCBzZXJ2ZXIiCiBtc2dzdHIgIi1YXHRcdFx0T3ByZXQgaWtrZSBmb3JiaW5kZWxzZSB0aWwgWC1zZXJ2ZXIiCkBAIC0zMjE3LDExICszMjE0LDExIEBACiAiXG4iCiAiQXJndW1lbnRlciBzb20gZ2Vua2VuZGVzIGFmIGd2aW0gKEF0aGVuYS12ZXJzaW9uKTpcbiIKIAotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIHZpbSBvbiA8ZGlzcGxheT4iCi1tc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0S8O4ciB2aW0gcMOlIDxkaXNwbGF5PiIKK21zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biBWaW0gb24gPGRpc3BsYXk+IgorbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdEvDuHIgVmltIHDDpSA8ZGlzcGxheT4iCiAKLW1zZ2lkICItaWNvbmljXHRcdFN0YXJ0IHZpbSBpY29uaWZpZWQiCi1tc2dzdHIgIi1pY29uaWNcdFx0U3RhcnQgdmltIHNvbSBpa29uIgorbXNnaWQgIi1pY29uaWNcdFx0U3RhcnQgVmltIGljb25pZmllZCIKK21zZ3N0ciAiLWljb25pY1x0XHRTdGFydCBWaW0gc29tIGlrb24iCiAKIG1zZ2lkICItYmFja2dyb3VuZCA8Y29sb3I+XHRVc2UgPGNvbG9yPiBmb3IgdGhlIGJhY2tncm91bmQgKGFsc286IC1iZykiCiBtc2dzdHIgIi1iYWNrZ3JvdW5kIDxmYXJ2ZT5cdEJydWcgPGZhcnZlPiB0aWwgYmFnZ3J1bmRlbiAob2dzw6U6IC1iZykiCkBAIC0zMjY3LDggKzMyNjQsOCBAQAogIlxuIgogIkFyZ3VtZW50ZXIgZ2Vua2VuZHQgYWYgZ3ZpbSAoR1RLKy12ZXJzaW9uKTpcbiIKIAotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIHZpbSBvbiA8ZGlzcGxheT4gKGFsc286IC0tZGlzcGxheSkiCi1tc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0S8O4ciB2aW0gcMOlIDxkaXNwbGF5PiAob2dzw6U6IC0tZGlzcGxheSkiCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gVmltIG9uIDxkaXNwbGF5PiAoYWxzbzogLS1kaXNwbGF5KSIKK21zZ3N0ciAiLWRpc3BsYXkgPGRpc3BsYXk+XHRLw7hyIFZpbSBww6UgPGRpc3BsYXk+IChvZ3PDpTogLS1kaXNwbGF5KSIKIAogbXNnaWQgIi0tcm9sZSA8cm9sZT5cdFNldCBhIHVuaXF1ZSByb2xlIHRvIGlkZW50aWZ5IHRoZSBtYWluIHdpbmRvdyIKIG1zZ3N0ciAiLS1yb2xlIDxyb2xsZT5cdFPDpnQgZW4gdW5payByb2xsZSB0aWwgYXQgaWRlbnRpZmljZXJlIGhvdmVkdmluZHVldCIKQEAgLTY4OTEsNyArNjg4OCw3IEBACiBtc2dzdHIgImxpc3RlaW5kZWtzIHVkZW5mb3Igb21yw6VkZSIKIAogIywgYy1mb3JtYXQKLW1zZ2lkICJpbnRlcm5hbCBlcnJvcjogZmFpbGVkIHRvIGdldCB2aW0gbGlzdCBpdGVtICVkIgorbXNnaWQgImludGVybmFsIGVycm9yOiBmYWlsZWQgdG8gZ2V0IFZpbSBsaXN0IGl0ZW0gJWQiCiBtc2dzdHIgImludGVybiBmZWpsOiBrdW5uZSBpa2tlIGhlbnRlIHZpbS1saXN0ZXB1bmt0ICVkIgogCiBtc2dpZCAic2xpY2Ugc3RlcCBjYW5ub3QgYmUgemVybyIKQEAgLTY5MDIsNyArNjg5OSw3IEBACiBtc2dzdHIgImZvcnPDuGcgcMOlIGF0IHRpbGRlbGUgc2VrdmVucyBzb20gZXIgc3TDuHJyZSBlbmQgJWQgdGlsIHVkdmlkZXQgc2xpY2UiCiAKICMsIGMtZm9ybWF0Ci1tc2dpZCAiaW50ZXJuYWwgZXJyb3I6IG5vIHZpbSBsaXN0IGl0ZW0gJWQiCittc2dpZCAiaW50ZXJuYWwgZXJyb3I6IG5vIFZpbSBsaXN0IGl0ZW0gJWQiCiBtc2dzdHIgImludGVybiBmZWpsOiBpbnRldCB2aW0tbGlzdGVwdW5rdCAlZCIKIAogbXNnaWQgImludGVybmFsIGVycm9yOiBub3QgZW5vdWdoIGxpc3QgaXRlbXMiCkBAIC03MDEzLDE5ICs3MDEwLDE5IEBACiBtc2dpZCAiRTg1ODogRXZhbCBkaWQgbm90IHJldHVybiBhIHZhbGlkIHB5dGhvbiBvYmplY3QiCiBtc2dzdHIgIkU4NTg6IEV2YWwgcmV0dXJuZXJlZGUgaWtrZSBldCBneWxkaWd0IHB5dGhvbi1vYmpla3QiCiAKLW1zZ2lkICJFODU5OiBGYWlsZWQgdG8gY29udmVydCByZXR1cm5lZCBweXRob24gb2JqZWN0IHRvIHZpbSB2YWx1ZSIKK21zZ2lkICJFODU5OiBGYWlsZWQgdG8gY29udmVydCByZXR1cm5lZCBweXRob24gb2JqZWN0IHRvIGEgVmltIHZhbHVlIgogbXNnc3RyICJFODU5OiBLdW5uZSBpa2tlIGtvbnZlcnRlcmUgcmV0dXJuZXJlZGUgcHl0aG9uLW9iamVrdCB0aWwgdmltLXbDpnJkaSIKIAogIywgYy1mb3JtYXQKLW1zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byB2aW0gZGljdGlvbmFyeSIKK21zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byBhIFZpbSBkaWN0aW9uYXJ5IgogbXNnc3RyICJrYW4gaWtrZSBrb252ZXJ0ZXJlICVzIHRpbCB2aW0tb3JkYm9nIgogCiAjLCBjLWZvcm1hdAotbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIHZpbSBsaXN0IgorbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIGEgVmltIGxpc3QiCiBtc2dzdHIgImthbiBpa2tlIGtvbnZlcnRlcmUgJXMgdGlsIHZpbS1saXN0ZSIKIAogIywgYy1mb3JtYXQKLW1zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byB2aW0gc3RydWN0dXJlIgorbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIGEgVmltIHN0cnVjdHVyZSIKIG1zZ3N0ciAia2FuIGlra2Uga29udmVydGVyZSAlcyB0aWwgdmltLXN0cnVrdHVyIgogCiBtc2dpZCAiaW50ZXJuYWwgZXJyb3I6IE5VTEwgcmVmZXJlbmNlIHBhc3NlZCIKZGlmZiAtLWdpdCBhL3NyYy9wby9kZS5wbyBiL3NyYy9wby9kZS5wbwppbmRleCBmZTQyM2NiLi43MjBmY2JhIDEwMDY0NAotLS0gYS9zcmMvcG8vZGUucG8KKysrIGIvc3JjL3BvL2RlLnBvCkBAIC0yNTY0LDkgKzI1NjQsNiBAQAogbXNnaWQgImtleWJvYXJkIGludGVycnVwdCIKIG1zZ3N0ciAiVGFzdGF0dXItSW50ZXJydXB0IgogCi1tc2dpZCAidmltIGVycm9yIgotbXNnc3RyICJ2aW0gRmVobGVyIgotCiBtc2dpZCAiY2Fubm90IGNyZWF0ZSBidWZmZXIvd2luZG93IGNvbW1hbmQ6IG9iamVjdCBpcyBiZWluZyBkZWxldGVkIgogbXNnc3RyICIiCiAiUHVmZmVyL0ZlbnN0ZXItQmVmZWhsIGthbm4gbmljaHQgYXVzZ2Vm/GhydCB3ZXJkZW46IGRhcyBPYmpla3Qgd2lyZCBnZWz2c2NodCIKQEAgLTMwNDIsOCArMzAzOSw4IEBACiBtc2dpZCAiLXhcdFx0XHRFZGl0IGVuY3J5cHRlZCBmaWxlcyIKIG1zZ3N0ciAiLXhcdFx0XHRFZGl0aWVyZSB2ZXJzY2hs/HNzZWx0ZSBEYXRlaWVuIgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRDb25uZWN0IHZpbSB0byB0aGlzIHBhcnRpY3VsYXIgWC1zZXJ2ZXIiCi1tc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0U3RhcnRlIHZpbSA8ZGlzcGxheT4iCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRDb25uZWN0IFZpbSB0byB0aGlzIHBhcnRpY3VsYXIgWC1zZXJ2ZXIiCittc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0U3RhcnRlIFZpbSA8ZGlzcGxheT4iCiAKIG1zZ2lkICItWFx0XHRcdERvIG5vdCBjb25uZWN0IHRvIFggc2VydmVyIgogbXNnc3RyICItWFx0XHRcdFN0ZWxsZSBrZWluZSBWZXJiaW5kdW5nIHp1bSBYLXNlcnZlciBoZXIiCkBAIC0zMTI2LDExICszMTIzLDExIEBACiAiXG4iCiAiQXJndW1lbnRlIGb8ciBkZW4gZ3ZpbSAoQXRoZW5hIFZlcnNpb24pOlxuIgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gdmltIG9uIDxkaXNwbGF5PiIKLW1zZ3N0ciAiLWRpc3BsYXkgPGRpc3BsYXk+XHRTdGFydGUgdmltIGF1ZiA8ZGlzcGxheT4iCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gVmltIG9uIDxkaXNwbGF5PiIKK21zZ3N0ciAiLWRpc3BsYXkgPGRpc3BsYXk+XHRTdGFydGUgVmltIGF1ZiA8ZGlzcGxheT4iCiAKLW1zZ2lkICItaWNvbmljXHRcdFN0YXJ0IHZpbSBpY29uaWZpZWQiCi1tc2dzdHIgIi1pY29uaWNcdFx0U3RhcnRlIHZpbSBhbHMgSWNvbiIKK21zZ2lkICItaWNvbmljXHRcdFN0YXJ0IFZpbSBpY29uaWZpZWQiCittc2dzdHIgIi1pY29uaWNcdFx0U3RhcnRlIFZpbSBhbHMgSWNvbiIKIAogbXNnaWQgIi1iYWNrZ3JvdW5kIDxjb2xvcj5cdFVzZSA8Y29sb3I+IGZvciB0aGUgYmFja2dyb3VuZCAoYWxzbzogLWJnKSIKIG1zZ3N0ciAiIgpAQCAtMzE4NSw4ICszMTgyLDggQEAKICJcbiIKICJBcmd1bWVudGUgZvxyIGd2aW0gR1RLKyBWZXJzaW9uOlxuIgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gdmltIG9uIDxkaXNwbGF5PiAoYWxzbzogLS1kaXNwbGF5KSIKLW1zZ3N0ciAiLWRpc3BsYXkgPGRpc3BsYXk+XHRTdGFydGUgdmltIGF1ZiA8ZGlzcGxheT4gKGF1Y2ggbWl0OiAtLWRpc3BsYXkpIgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIFZpbSBvbiA8ZGlzcGxheT4gKGFsc286IC0tZGlzcGxheSkiCittc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0U3RhcnRlIFZpbSBhdWYgPGRpc3BsYXk+IChhdWNoIG1pdDogLS1kaXNwbGF5KSIKIAogbXNnaWQgIi0tcm9sZSA8cm9sZT5cdFNldCBhIHVuaXF1ZSByb2xlIHRvIGlkZW50aWZ5IHRoZSBtYWluIHdpbmRvdyIKIG1zZ3N0ciAiIgpAQCAtNzU2Myw3ICs3NTYwLDcgQEAKIG1zZ3N0ciAiTGlzdGVuIEluZGV4IGF132VyaGFsYiBkZXMgZ/xsdGlnZW4gQmVyZWljaHMiCiAKICMsIGMtZm9ybWF0Ci1tc2dpZCAiaW50ZXJuYWwgZXJyb3I6IGZhaWxlZCB0byBnZXQgdmltIGxpc3QgaXRlbSAlZCIKK21zZ2lkICJpbnRlcm5hbCBlcnJvcjogZmFpbGVkIHRvIGdldCBWaW0gbGlzdCBpdGVtICVkIgogbXNnc3RyICJpbnRlcm5lciBGZWhsZXI6IFp1Z3JpZmYgYXVmIFZpbSBMaXN0b2JqZWt0ICVkIGZlaGxnZXNjaGxhZ2VuIgogCiBtc2dpZCAic2xpY2Ugc3RlcCBjYW5ub3QgYmUgemVybyIKQEAgLTc1NzUsNyArNzU3Miw3IEBACiAiVmVyc3VjaCBkZXIgWnV3ZWlzdW5nIHZvbiBTZXF1ZW56Z3L232UgZ3L232VyIGFscyAlZCB6dSBlcndlaXRlcnRlbiBTbGljZSIKIAogIywgYy1mb3JtYXQKLW1zZ2lkICJpbnRlcm5hbCBlcnJvcjogbm8gdmltIGxpc3QgaXRlbSAlZCIKK21zZ2lkICJpbnRlcm5hbCBlcnJvcjogbm8gVmltIGxpc3QgaXRlbSAlZCIKIG1zZ3N0ciAiaW50ZXJuZXIgRmVobGVyOiBLZWluIFZpbSBMaXN0b2JqZWt0ICVkIgogCiBtc2dpZCAiaW50ZXJuYWwgZXJyb3I6IG5vdCBlbm91Z2ggbGlzdCBpdGVtcyIKQEAgLTc2ODUsMjEgKzc2ODIsMjEgQEAKIG1zZ2lkICJFODU4OiBFdmFsIGRpZCBub3QgcmV0dXJuIGEgdmFsaWQgcHl0aG9uIG9iamVjdCIKIG1zZ3N0ciAiRTg1ODogRXZhbCBoYXQga2VpbiBn/Gx0aWdlcyBQeXRob25vYmpla3QgenVy/GNrZ2VnZWJlbiIKIAotbXNnaWQgIkU4NTk6IEZhaWxlZCB0byBjb252ZXJ0IHJldHVybmVkIHB5dGhvbiBvYmplY3QgdG8gdmltIHZhbHVlIgorbXNnaWQgIkU4NTk6IEZhaWxlZCB0byBjb252ZXJ0IHJldHVybmVkIHB5dGhvbiBvYmplY3QgdG8gYSBWaW0gdmFsdWUiCiBtc2dzdHIgIiIKICJFODU5OiBLb252ZXJ0aWVydW5nIHZvbiB6dXL8Y2tnZWdlYmVuZW4gUHl0aG9ub2JqZWt0IHp1IFZpbSBXZXJ0ICIKICJmZWhsZ2VzY2hsYWdlbiIKIAogIywgYy1mb3JtYXQKLW1zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byB2aW0gZGljdGlvbmFyeSIKK21zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byBhIFZpbSBkaWN0aW9uYXJ5IgogbXNnc3RyICJrb25udGUgbmljaHQgJXMgenUgVmltIERpY3Rpb25hcnkga29udmVydGllcmVuIgogCiAjLCBjLWZvcm1hdAotbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIHZpbSBsaXN0IgorbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIGEgVmltIGxpc3QiCiBtc2dzdHIgImtvbm50ZSAlcyBuaWNodCB6dSBWaW0gTGlzdGUga29udmVydGllcmVuIgogCiAjLCBjLWZvcm1hdAotbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIHZpbSBzdHJ1Y3R1cmUiCittc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gYSBWaW0gc3RydWN0dXJlIgogbXNnc3RyICJrb25udGUgJXMgbmljaHQgenUgVmltIFN0cnVrdHVyIGtvbnZlcnRpZXJlbiIKIAogbXNnaWQgImludGVybmFsIGVycm9yOiBOVUxMIHJlZmVyZW5jZSBwYXNzZWQiCmRpZmYgLS1naXQgYS9zcmMvcG8vZW8ucG8gYi9zcmMvcG8vZW8ucG8KaW5kZXggMDE3MzJjMy4uNTIxNTIyYiAxMDA2NDQKLS0tIGEvc3JjL3BvL2VvLnBvCisrKyBiL3NyYy9wby9lby5wbwpAQCAtMjUzOSw5ICsyNTM5LDYgQEAKIG1zZ2lkICJrZXlib2FyZCBpbnRlcnJ1cHQiCiBtc2dzdHIgImtsYXZhcmEgaW50ZXJyb21wbyIKIAotbXNnaWQgInZpbSBlcnJvciIKLW1zZ3N0ciAiZXJhcm8gZGUgVmltIgotCiBtc2dpZCAiY2Fubm90IGNyZWF0ZSBidWZmZXIvd2luZG93IGNvbW1hbmQ6IG9iamVjdCBpcyBiZWluZyBkZWxldGVkIgogbXNnc3RyICJuZSBlYmxhcyBrcmVpIGtvbWFuZG9uIGRlIGJ1ZnJvL2ZlbmVzdHJvOiBvYmpla3RvIGVzdGFzIGZvcnZpxZ1pxJ1hbnRhIgogCkBAIC0zMDE0LDcgKzMwMTEsNyBAQAogbXNnaWQgIi14XHRcdFx0RWRpdCBlbmNyeXB0ZWQgZmlsZXMiCiBtc2dzdHIgIi14XHRcdFx0UmVkYWt0aSDEiWlmcmFkYW4gZG9zaWVyb24iCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdENvbm5lY3QgdmltIHRvIHRoaXMgcGFydGljdWxhciBYLXNlcnZlciIKK21zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdENvbm5lY3QgVmltIHRvIHRoaXMgcGFydGljdWxhciBYLXNlcnZlciIKIG1zZ3N0ciAiLWRpc3BsYXkgPGVrcmFubz5cdEtvbmVrdGkgVmltIGFsIHRpdSBYLXNlcnZpbG8iCiAKIG1zZ2lkICItWFx0XHRcdERvIG5vdCBjb25uZWN0IHRvIFggc2VydmVyIgpAQCAtMzA5MywxMSArMzA5MCwxMSBAQAogIlxuIgogIkFyZ3VtZW50b2ogYWdub3NraXRhaiBkZSBndmltICh2ZXJzaW8gQXRoZW5hKTpcbiIKIAotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIHZpbSBvbiA8ZGlzcGxheT4iCi1tc2dzdHIgIi1kaXNwbGF5IDxla3Jhbm8+XHRMYW7EiWkgdmltIHN1ciA8ZWtyYW5vPiIKK21zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biBWaW0gb24gPGRpc3BsYXk+IgorbXNnc3RyICItZGlzcGxheSA8ZWtyYW5vPlx0TGFuxIlpIFZpbSBzdXIgPGVrcmFubz4iCiAKLW1zZ2lkICItaWNvbmljXHRcdFN0YXJ0IHZpbSBpY29uaWZpZWQiCi1tc2dzdHIgIi1pY29uaWNcdFx0TGFuxIlpIHZpbSBwaWt0b2dyYW1lIgorbXNnaWQgIi1pY29uaWNcdFx0U3RhcnQgVmltIGljb25pZmllZCIKK21zZ3N0ciAiLWljb25pY1x0XHRMYW7EiWkgVmltIHBpa3RvZ3JhbWUiCiAKIG1zZ2lkICItYmFja2dyb3VuZCA8Y29sb3I+XHRVc2UgPGNvbG9yPiBmb3IgdGhlIGJhY2tncm91bmQgKGFsc286IC1iZykiCiBtc2dzdHIgIi1iYWNrZ3JvdW5kIDxrb2xvcm8+XHRVemkgPGtvbG9ybz4tbiBwb3IgbGEgZm9uYSBrb2xvcm8gKGFua2HFrTogLWJnKSIKQEAgLTMxNDUsNyArMzE0Miw3IEBACiAiXG4iCiAiQXJndW1lbnRvaiBhZ25vc2tpdGFqIGRlIGd2aW0gKHZlcnNpbyBHVEsrKTpcbiIKIAotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIHZpbSBvbiA8ZGlzcGxheT4gKGFsc286IC0tZGlzcGxheSkiCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gVmltIG9uIDxkaXNwbGF5PiAoYWxzbzogLS1kaXNwbGF5KSIKIG1zZ3N0ciAiLWRpc3BsYXkgPGVrcmFubz5cdExhbsSJaSBWaW0gc3VyIHRpdSA8ZWtyYW5vPiAoYW5rYcWtOiAtLWRpc3BsYXkpIgogCiBtc2dpZCAiLS1yb2xlIDxyb2xlPlx0U2V0IGEgdW5pcXVlIHJvbGUgdG8gaWRlbnRpZnkgdGhlIG1haW4gd2luZG93IgpAQCAtNzQ1OSw3ICs3NDU2LDcgQEAKIG1zZ3N0ciAiaW5kZWtzbyBkZSBsaXN0byBla3N0ZXIgbGltb2oiCiAKICMsIGMtZm9ybWF0Ci1tc2dpZCAiaW50ZXJuYWwgZXJyb3I6IGZhaWxlZCB0byBnZXQgdmltIGxpc3QgaXRlbSAlZCIKK21zZ2lkICJpbnRlcm5hbCBlcnJvcjogZmFpbGVkIHRvIGdldCBWaW0gbGlzdCBpdGVtICVkIgogbXNnc3RyICJpbnRlcm5hIGVyYXJvOiBvYnRlbm8gZGUgdmltLWEgbGlzdGVybyAlZCBtYWxzdWtjZXNpcyIKIAogbXNnaWQgInNsaWNlIHN0ZXAgY2Fubm90IGJlIHplcm8iCkBAIC03NDcwLDcgKzc0NjcsNyBAQAogbXNnc3RyICJwcm92aXMgdmFsb3Jpemkgc2VrdmVuY29uIGt1biBwbGkgb2wgJWQgZXJvaiBlbiBldGVuZGl0YSBzZWtjbyIKIAogIywgYy1mb3JtYXQKLW1zZ2lkICJpbnRlcm5hbCBlcnJvcjogbm8gdmltIGxpc3QgaXRlbSAlZCIKK21zZ2lkICJpbnRlcm5hbCBlcnJvcjogbm8gVmltIGxpc3QgaXRlbSAlZCIKIG1zZ3N0ciAiaW50ZXJuYSBlcmFybzogbmVuaXUgdmltLWEgbGlzdGVybyAlZCIKIAogbXNnaWQgImludGVybmFsIGVycm9yOiBub3QgZW5vdWdoIGxpc3QgaXRlbXMiCkBAIC03NTc5LDE5ICs3NTc2LDE5IEBACiBtc2dpZCAiRTg1ODogRXZhbCBkaWQgbm90IHJldHVybiBhIHZhbGlkIHB5dGhvbiBvYmplY3QiCiBtc2dzdHIgIkU4NTg6IEV2YWwgbmUgcmV2ZW5pcyBrdW4gdmFsaWRhIHB5dGhvbi1vYmpla3RvIgogCi1tc2dpZCAiRTg1OTogRmFpbGVkIHRvIGNvbnZlcnQgcmV0dXJuZWQgcHl0aG9uIG9iamVjdCB0byB2aW0gdmFsdWUiCittc2dpZCAiRTg1OTogRmFpbGVkIHRvIGNvbnZlcnQgcmV0dXJuZWQgcHl0aG9uIG9iamVjdCB0byBhIFZpbSB2YWx1ZSIKIG1zZ3N0ciAiRTg1OTogS29udmVydG8gZGUgcmV2ZW5hIHB5dGhvbi1vYmpla3RvIGFsIHZpbS12YWxvcm8gbWFsc3VrY2VzaXMiCiAKICMsIGMtZm9ybWF0Ci1tc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gdmltIGRpY3Rpb25hcnkiCittc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gYSBWaW0gZGljdGlvbmFyeSIKIG1zZ3N0ciAibmUgcG92aXMga29udmVydGkgJXMgYWwgdmltLXZvcnRhcm8iCiAKICMsIGMtZm9ybWF0Ci1tc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gdmltIGxpc3QiCittc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gYSBWaW0gbGlzdCIKIG1zZ3N0ciAibmUgcG92aXMga29udmVydGkgJXMgYWwgdmltLWxpc3RvIgogCiAjLCBjLWZvcm1hdAotbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIHZpbSBzdHJ1Y3R1cmUiCittc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gYSBWaW0gc3RydWN0dXJlIgogbXNnc3RyICJuZSBwb3ZpcyBrb252ZXJ0aSAlcyBhbCB2aW0tc3RydWt0dXJvIgogCiBtc2dpZCAiaW50ZXJuYWwgZXJyb3I6IE5VTEwgcmVmZXJlbmNlIHBhc3NlZCIKZGlmZiAtLWdpdCBhL3NyYy9wby9lcy5wbyBiL3NyYy9wby9lcy5wbwppbmRleCA4Zjg5MzVjLi42YzZkMTQ3IDEwMDY0NAotLS0gYS9zcmMvcG8vZXMucG8KKysrIGIvc3JjL3BvL2VzLnBvCkBAIC0xOSwxODEgKzE5LDEzOSBAQAogIkNvbnRlbnQtVHlwZTogdGV4dC9wbGFpbjsgY2hhcnNldD11dGYtOFxuIgogIkNvbnRlbnQtVHJhbnNmZXItRW5jb2Rpbmc6IG9jdGVjdC1zdHJlYW1cbiIKIAotIzogYnVmZmVyLmM6MTAyCiBtc2dpZCAiRTgyOiBDYW5ub3QgYWxsb2NhdGUgYW55IGJ1ZmZlciwgZXhpdGluZy4uLiIKIG1zZ3N0ciAiRTgyOiBObyBzZSBwdWRvIGFzaWduYXIgbWVtb3JpYSBwYXJhIG5pbmfDum4gYsO6ZmVyLCBzYWxpZW5kby4uLiIKIAotIzogYnVmZmVyLmM6MTA1CiBtc2dpZCAiRTgzOiBDYW5ub3QgYWxsb2NhdGUgYnVmZmVyLCB1c2luZyBvdGhlciBvbmUuLi4iCiBtc2dzdHIgIkU4MzogTm8gc2UgcHVkbyBhc2lnbmFyIG1lbW9yaWEgcGFyYSBlbCBiw7pmZXIsIHVzYW5kbyBvdHJvLi4uIgogCi0jOiBidWZmZXIuYzo4NzkKIG1zZ2lkICJFNTE1OiBObyBidWZmZXJzIHdlcmUgdW5sb2FkZWQiCiBtc2dzdHIgIkU1MTU6IE5vIHNlIGRlc2NhcmfDsyBuaW5nw7puIGLDumZlciIKIAotIzogYnVmZmVyLmM6ODgxCiBtc2dpZCAiRTUxNjogTm8gYnVmZmVycyB3ZXJlIGRlbGV0ZWQiCiBtc2dzdHIgIkU1MTY6IE5vIHNlIGJvcnLDsyBuaW5nw7puIGLDumZlciIKIAotIzogYnVmZmVyLmM6ODgzCiBtc2dpZCAiRTUxNzogTm8gYnVmZmVycyB3ZXJlIHdpcGVkIG91dCIKIG1zZ3N0ciAiRTUxNzogTm8gc2UgZWxpbWluw7MgbmluZ8O6biBiw7pmZXIiCiAKLSM6IGJ1ZmZlci5jOjg5MQogbXNnaWQgIjEgYnVmZmVyIHVubG9hZGVkIgogbXNnc3RyICJTZSBkZXNjYXJnw7MgdW4gKDEpIGLDumZlciIKIAotIzogYnVmZmVyLmM6ODkzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVkIGJ1ZmZlcnMgdW5sb2FkZWQiCiBtc2dzdHIgIlNlIGRlc2Nhcmdhcm9uICVkIGLDumZlcnMiCiAKLSM6IGJ1ZmZlci5jOjg5OAogbXNnaWQgIjEgYnVmZmVyIGRlbGV0ZWQiCiBtc2dzdHIgIlNlIHN1cHJpbWnDsyB1biAoMSkgYsO6ZmVyIgogCi0jOiBidWZmZXIuYzo5MDAKICMsIGMtZm9ybWF0CiBtc2dpZCAiJWQgYnVmZmVycyBkZWxldGVkIgogbXNnc3RyICJTZSBzdXByaW1pZXJvbiAlZCBiw7pmZXJzIgogCi0jOiBidWZmZXIuYzo5MDUKIG1zZ2lkICIxIGJ1ZmZlciB3aXBlZCBvdXQiCiBtc2dzdHIgIlNlIGVsaW1pbsOzIHVuICgxKSBiw7pmZXIiCiAKLSM6IGJ1ZmZlci5jOjkwNwogIywgYy1mb3JtYXQKIG1zZ2lkICIlZCBidWZmZXJzIHdpcGVkIG91dCIKIG1zZ3N0ciAiU2UgZWxpbWluYXJvbiAlZCBiw7pmZXJzIgogCi0jOiBidWZmZXIuYzo5NjUKIG1zZ2lkICJFODQ6IE5vIG1vZGlmaWVkIGJ1ZmZlciBmb3VuZCIKIG1zZ3N0ciAiRTg0OiBObyBzZSBlbmNvbnRyw7MgbmluZ8O6biBiw7pmZXIgbW9kaWZpY2FkbyIKIAogIyBiYWNrIHdoZXJlIHdlIHN0YXJ0ZWQsIGRpZG4ndCBmaW5kIGFueXRoaW5nLgotIy4gYmFjayB3aGVyZSB3ZSBzdGFydGVkLCBkaWRuJ3QgZmluZCBhbnl0aGluZy4KLSM6IGJ1ZmZlci5jOjEwMDQKIG1zZ2lkICJFODU6IFRoZXJlIGlzIG5vIGxpc3RlZCBidWZmZXIiCiBtc2dzdHIgIkU4NTogTm8gaGF5IGLDumZlcnMgZW4gbGEgbGlzdGEiCiAKLSM6IGJ1ZmZlci5jOjEwMTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTg2OiBCdWZmZXIgJWxkIGRvZXMgbm90IGV4aXN0IgogbXNnc3RyICJFODY6IEVsIGLDumZlciAlbGQgbm8gZXhpc3RlIgogCi0jOiBidWZmZXIuYzoxMDE5CiBtc2dpZCAiRTg3OiBDYW5ub3QgZ28gYmV5b25kIGxhc3QgYnVmZmVyIgogbXNnc3RyICJFODc6IE5vIHNlIHB1ZG8gaXIgbcOhcyBhbGzDoSBkZWwgw7psdGltbyBiw7pmZXIiCiAKLSM6IGJ1ZmZlci5jOjEwMjEKIG1zZ2lkICJFODg6IENhbm5vdCBnbyBiZWZvcmUgZmlyc3QgYnVmZmVyIgogbXNnc3RyICJFODg6IE5vIHNlIHB1ZG8gcmVncmVzYXIgYW50ZXMgZGVsIHByaW1lciBiw7pmZXIiCiAKLSM6IGJ1ZmZlci5jOjEwNjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTg5OiBObyB3cml0ZSBzaW5jZSBsYXN0IGNoYW5nZSBmb3IgYnVmZmVyICVsZCAoYWRkICEgdG8gb3ZlcnJpZGUpIgogbXNnc3RyICIiCiAiRTg5OiBObyBzZSBndWFyZMOzIGVsIGFyY2hpdm8gZGVzZGUgZWwgw7psdGltbyBjYW1iaW8gZGVsIGLDumZlciAlbGQgKGHDsWFkYSBcIiEiCiAiXCIgcGFyYSBmb3J6YXIpIgogCi0jOiBidWZmZXIuYzoxMDgwCiBtc2dpZCAiRTkwOiBDYW5ub3QgdW5sb2FkIGxhc3QgYnVmZmVyIgogbXNnc3RyICJFOTA6IE5vIHNlIHB1ZG8gZGVzY2FyZ2FyIGVsIMO6bHRpbW8gYsO6ZmVyIgogCi0jOiBidWZmZXIuYzoxNjUxCiBtc2dpZCAiVzE0OiBXYXJuaW5nOiBMaXN0IG9mIGZpbGUgbmFtZXMgb3ZlcmZsb3ciCiBtc2dzdHIgIlcxNDogQWR2ZXJ0ZW5jaWE6IExhIGxpc3RhIGRlIG5vbWJyZXMgZGUgYXJjaGl2b3MgZXMgbXV5IGxhcmdhIgogCi0jOiBidWZmZXIuYzoxODUwIHF1aWNrZml4LmM6MzYzMgogIywgYy1mb3JtYXQKIG1zZ2lkICJFOTI6IEJ1ZmZlciAlbGQgbm90IGZvdW5kIgogbXNnc3RyICJFOTI6IE5vIHNlIGVuY29udHLDsyBlbCBiw7pmZXIgJWxkIgogCi0jOiBidWZmZXIuYzoyMTI1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkU5MzogTW9yZSB0aGFuIG9uZSBtYXRjaCBmb3IgJXMiCiBtc2dzdHIgIkU5MzogSGF5IG3DoXMgZGUgdW5hIGNvaW5jaWRlbmNpYSBjb24gJXMiCiAKLSM6IGJ1ZmZlci5jOjIxMjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTk0OiBObyBtYXRjaGluZyBidWZmZXIgZm9yICVzIgogbXNnc3RyICJFOTQ6IE5vIGhheSB1biBiw7pmZXIgcXVlIGNvaW5jaWRhIGNvbiAlcyIKIAotIzogYnVmZmVyLmM6MjU3OQogIywgYy1mb3JtYXQKIG1zZ2lkICJsaW5lICVsZCIKIG1zZ3N0ciAibMOtbmVhICVsZCIKIAotIzogYnVmZmVyLmM6MjY2NgogbXNnaWQgIkU5NTogQnVmZmVyIHdpdGggdGhpcyBuYW1lIGFscmVhZHkgZXhpc3RzIgogbXNnc3RyICJFOTU6IFlhIGV4aXN0ZSB1biBiw7pmZXIgY29uIGVzdGUgbm9tYnJlIgogCi0jOiBidWZmZXIuYzoyOTkzCiBtc2dpZCAiIFtNb2RpZmllZF0iCiBtc2dzdHIgIiBbTW9kaWZpY2Fkb10iCiAKLSM6IGJ1ZmZlci5jOjI5OTgKIG1zZ2lkICJbTm90IGVkaXRlZF0iCiBtc2dzdHIgIltTaW4gZWRpdGFyXSIKIAotIzogYnVmZmVyLmM6MzAwMwogbXNnaWQgIltOZXcgZmlsZV0iCiBtc2dzdHIgIltBcmNoaXZvIG51ZXZvXSIKIAotIzogYnVmZmVyLmM6MzAwNAogbXNnaWQgIltSZWFkIGVycm9yc10iCiBtc2dzdHIgIltFcnJvcmVzIGRlIGxlY3R1cmFdIgogCi0jOiBidWZmZXIuYzozMDA2IGZpbGVpby5jOjIzOTEgbmV0YmVhbnMuYzozNjMyCiBtc2dpZCAiW3JlYWRvbmx5XSIKIG1zZ3N0ciAiW1PDs2xvIGxlY3R1cmFdIgogCi0jOiBidWZmZXIuYzozMDI5CiAjLCBjLWZvcm1hdAogbXNnaWQgIjEgbGluZSAtLSVkJSUtLSIKIG1zZ3N0ciAiMSBsw61uZWEgLS0lZCUlLS0iCiAKLSM6IGJ1ZmZlci5jOjMwMzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiJWxkIGxpbmVzIC0tJWQlJS0tIgogbXNnc3RyICIlbGQgbMOtbmVhcyAtLSVkJSUtLSIKIAotIzogYnVmZmVyLmM6MzAzOQogIywgYy1mb3JtYXQKIG1zZ2lkICJsaW5lICVsZCBvZiAlbGQgLS0lZCUlLS0gY29sICIKIG1zZ3N0ciAibMOtbmVhICVsZCBkZSAlbGQgLS0lZCUlLS0gY29sICIKIAotIzogYnVmZmVyLmM6MzE2MCBidWZmZXIuYzo1MTI2IG1lbWxpbmUuYzoxNzI3CiBtc2dpZCAiW05vIE5hbWVdIgogbXNnc3RyICJbU2luIG5vbWJyZV0iCiAKICMgbXVzdCBiZSBhIGhlbHAgYnVmZmVyCi0jLiBtdXN0IGJlIGEgaGVscCBidWZmZXIKLSM6IGJ1ZmZlci5jOjMxOTgKIG1zZ2lkICJoZWxwIgogbXNnc3RyICJheXVkYSIKIAotIzogYnVmZmVyLmM6MzgyNiBzY3JlZW4uYzo1ODE3CiBtc2dpZCAiW0hlbHBdIgogbXNnc3RyICJbQXl1ZGFdIgogCi0jOiBidWZmZXIuYzozODYwIHNjcmVlbi5jOjU4MjMKIG1zZ2lkICJbUHJldmlld10iCiBtc2dzdHIgIltWaXN0YSBwcmV2aWFdIgogCi0jOiBidWZmZXIuYzo0MTgyCiBtc2dpZCAiQWxsIgogbXNnc3RyICJUb2RvIgogCi0jOiBidWZmZXIuYzo0MTgyCiBtc2dpZCAiQm90IgogbXNnc3RyICJGaW5hbCIKIAotIzogYnVmZmVyLmM6NDE4NQogbXNnaWQgIlRvcCIKIG1zZ3N0ciAiQ29taWVuem8iCiAKLSM6IGJ1ZmZlci5jOjUwNjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlxuIgpAQCAtMjAyLDE5ICsxNjAsMTUgQEAKICJcbiIKICIjIExpc3RhIGRlIGLDumZlcnM6XG4iCiAKLSM6IGJ1ZmZlci5jOjUxMTAKIG1zZ2lkICJbTG9jYXRpb24gTGlzdF0iCiBtc2dzdHIgIltMaXN0YSBkZSB1YmljYWNpb25lc10iCiAKLSM6IGJ1ZmZlci5jOjUxMTIKIG1zZ2lkICJbUXVpY2tmaXggTGlzdF0iCiBtc2dzdHIgIltMaXN0YSBkZSBjYW1iaW9zIHLDoXBpZG9zXSIKIAotIzogYnVmZmVyLmM6NTEyMgogbXNnaWQgIltTY3JhdGNoXSIKIG1zZ3N0ciAiW0RlIGNlcm9dIgogCi0jOiBidWZmZXIuYzo1NDM5CiBtc2dpZCAiIgogIlxuIgogIi0tLSBTaWducyAtLS0iCkBAIC0yMjIsMTgyICsxNzYsMTM5IEBACiAiXG4iCiAiLS0tIFNpZ25vcyAtLS0iCiAKLSM6IGJ1ZmZlci5jOjU0NDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiU2lnbnMgZm9yICVzOiIKIG1zZ3N0ciAiU2lnbm9zIHBhcmEgJXM6IgogCi0jOiBidWZmZXIuYzo1NDU1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiAgICBsaW5lPSVsZCAgaWQ9JWQgIG5hbWU9JXMiCiBtc2dzdHIgIiAgICBsw61uZWE9JWxkIGlkPSVkIG5vbWJyZT0lcyIKIAotIzogZGlmZi5jOjE0MQogIywgYy1mb3JtYXQKIG1zZ2lkICJFOTY6IENhbiBub3QgZGlmZiBtb3JlIHRoYW4gJWxkIGJ1ZmZlcnMiCiBtc2dzdHIgIkU5NjogTm8gc2UgcHVlZGUgdXNhciBcImRpZmZcIiBjb24gbcOhcyBkZSAlbGQgYsO6ZmVycyIKIAotIzogZGlmZi5jOjc3NwogbXNnaWQgIkU4MTA6IENhbm5vdCByZWFkIG9yIHdyaXRlIHRlbXAgZmlsZXMiCiBtc2dzdHIgIkU4MTA6IE5vIHNlIHB1ZWRlIGxlZXIgbyBlc2NyaWJpciBlbiBhcmNoaXZvcyB0ZW1wb3JhbGVzIgogCi0jOiBkaWZmLmM6Nzc4CiBtc2dpZCAiRTk3OiBDYW5ub3QgY3JlYXRlIGRpZmZzIgogbXNnc3RyICJFOTc6IE5vIHNlIHB1ZGllcm9uIGNyZWFyIGxhcyBcImRpZmZzXCIgKGRpZmVyZW5jaWFzKSIKIAotIzogZGlmZi5jOjkwMQogbXNnaWQgIlBhdGNoIGZpbGUiCiBtc2dzdHIgIkFyY2hpdm8gZGUgcGFyY2hlcyIKIAotIzogZGlmZi5jOjEwMDUKIG1zZ2lkICJFODE2OiBDYW5ub3QgcmVhZCBwYXRjaCBvdXRwdXQiCiBtc2dzdHIgIkU4MTY6IE5vIHNlIHB1ZG8gbGVlciBsYSBzYWxpZGEgZGVsIHBhcmNoZSIKIAotIzogZGlmZi5jOjEyMjcKIG1zZ2lkICJFOTg6IENhbm5vdCByZWFkIGRpZmYgb3V0cHV0IgogbXNnc3RyICJFOTg6IE5vIHNlIHB1ZG8gbGVlciBsYSBzYWxpZGEgZGUgXCJkaWZmXCIiCiAKLSM6IGRpZmYuYzoyMDg2CiBtc2dpZCAiRTk5OiBDdXJyZW50IGJ1ZmZlciBpcyBub3QgaW4gZGlmZiBtb2RlIgogbXNnc3RyICJFOTk6IEVsIGLDumZlciBhY3R1YWwgbm8gZXN0w6EgZW4gbW9kbyBkZSBkaWZlcmVuY2lhcyIKIAotIzogZGlmZi5jOjIxMDUKIG1zZ2lkICJFNzkzOiBObyBvdGhlciBidWZmZXIgaW4gZGlmZiBtb2RlIGlzIG1vZGlmaWFibGUiCiBtc2dzdHIgIkU3OTM6IE5pbmfDum4gb3RybyBiw7pmZXIgZXN0w6EgZW4gbW9kbyBkZSBkaWZlcmVuY2lhcyIKIAotIzogZGlmZi5jOjIxMDcKIG1zZ2lkICJFMTAwOiBObyBvdGhlciBidWZmZXIgaW4gZGlmZiBtb2RlIgogbXNnc3RyICJFMTAwOiBOaW5nw7puIG90cm8gYsO6ZmVyIGVzdMOhIGVuIG1vZG8gZGUgZGlmZXJlbmNpYXMiCiAKLSM6IGRpZmYuYzoyMTE3CiBtc2dpZCAiRTEwMTogTW9yZSB0aGFuIHR3byBidWZmZXJzIGluIGRpZmYgbW9kZSwgZG9uJ3Qga25vdyB3aGljaCBvbmUgdG8gdXNlIgogbXNnc3RyICJFMTAxOiBNw6FzIGRlIGRvcyBiw7pmZXJzIGVuIG1vZG8gZGUgZGlmZXJlbmNpYXMsIG5vIHNlIGN1YWwgdXNhciIKIAotIzogZGlmZi5jOjIxNDAKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTEwMjogQ2FuJ3QgZmluZCBidWZmZXIgXCIlc1wiIgogbXNnc3RyICJFMTAyOiBObyBzZSBwdWRvIGVuY29udHJhciBlbCBiw7pmZXIgJXMiCiAKLSM6IGRpZmYuYzoyMTQ4CiAjLCBjLWZvcm1hdAogbXNnaWQgIkUxMDM6IEJ1ZmZlciBcIiVzXCIgaXMgbm90IGluIGRpZmYgbW9kZSIKIG1zZ3N0ciAiRTEwMzogRWwgYsO6ZmVyIFwiJXNcIiBubyBlc3TDoSBlbiBtb2RvIGRlIGRpZmVyZW5jaWFzIgogCi0jOiBkaWZmLmM6MjE5MgogbXNnaWQgIkU3ODc6IEJ1ZmZlciBjaGFuZ2VkIHVuZXhwZWN0ZWRseSIKIG1zZ3N0ciAiRTc4NzogRWwgYsO6ZmVyIGNhbWJpw7MgaW5lc3BlcmFkYW1lbnRlIgogCi0jOiBkaWdyYXBoLmM6MjI1MQogbXNnaWQgIkUxMDQ6IEVzY2FwZSBub3QgYWxsb3dlZCBpbiBkaWdyYXBoIgogbXNnc3RyICJFMTA0OiBFbCBjw7NkaWdvIGRlIGVzY2FwZSBubyBzZSBwZXJtaXRlIGVuIHVuIGTDrWdyYWZvIgogCi0jOiBkaWdyYXBoLmM6MjQ0NAogbXNnaWQgIkU1NDQ6IEtleW1hcCBmaWxlIG5vdCBmb3VuZCIKIG1zZ3N0ciAiRTU0NDogTm8gc2UgZW5jb250csOzIGVsIGFyY2hpdm8gXCJrZXltYXBcIiIKIAotIzogZGlncmFwaC5jOjI0NzEKIG1zZ2lkICJFMTA1OiBVc2luZyA6bG9hZGtleW1hcCBub3QgaW4gYSBzb3VyY2VkIGZpbGUiCiBtc2dzdHIgIkUxMDU6IFVzYW5kbyBcIjpsb2Fka2V5bWFwXCIgZW4gZWwgYXJjaGl2byBzdW1pbmlzdHJhZG8iCiAKLSM6IGRpZ3JhcGguYzoyNTEwCiBtc2dpZCAiRTc5MTogRW1wdHkga2V5bWFwIGVudHJ5IgogbXNnc3RyICJFNzkxOiBEZWZpbmljacOzbiBkZSBcImtleW1hcFwiIHZhY8OtYSIKIAotIzogZWRpdC5jOjQyCiBtc2dpZCAiIEtleXdvcmQgY29tcGxldGlvbiAoXk5eUCkiCiBtc2dzdHIgIiBDb21wbGV0YXIgcGFsYWJyYSBjbGF2ZSAoXk5eUCkiCiAKICMgY3RybF94X21vZGUgPT0gMCwgXlAvXk4gY29tcGwuCi0jLiBjdHJsX3hfbW9kZSA9PSAwLCBeUC9eTiBjb21wbC4KLSM6IGVkaXQuYzo0MwogbXNnaWQgIiBeWCBtb2RlICheXV5EXkVeRl5JXkteTF5OXk9eUHNeVV5WXlkpIgogbXNnc3RyICIgTW9kbyBeWCAoXl1eRF5FXkZeSV5LXkxeTl5PXlBzXlVeVl5ZKSIKIAotIzogZWRpdC5jOjQ1CiBtc2dpZCAiIFdob2xlIGxpbmUgY29tcGxldGlvbiAoXkxeTl5QKSIKIG1zZ3N0ciAiIENvbXBsZXRhciB0b2RhIGxhIGzDrW5lYSAoXkxeTl5QKSIKIAotIzogZWRpdC5jOjQ2CiBtc2dpZCAiIEZpbGUgbmFtZSBjb21wbGV0aW9uICheRl5OXlApIgogbXNnc3RyICIgQ29tcGxldGFyIG5vbWJyZSBkZSBhcmNoaXZvICheRl5OXlApIgogCi0jOiBlZGl0LmM6NDcKIG1zZ2lkICIgVGFnIGNvbXBsZXRpb24gKF5dXk5eUCkiCiBtc2dzdHIgIiBDb21wbGV0YXIgZXRpcXVldGFzICheXV5OXlApIgogCi0jOiBlZGl0LmM6NDgKIG1zZ2lkICIgUGF0aCBwYXR0ZXJuIGNvbXBsZXRpb24gKF5OXlApIgogbXNnc3RyICIgQ29tcGxldGFyIHBhdHLDs24gZGUgcnV0YSAoXk5eUCkiCiAKLSM6IGVkaXQuYzo0OQogbXNnaWQgIiBEZWZpbml0aW9uIGNvbXBsZXRpb24gKF5EXk5eUCkiCiBtc2dzdHIgIiBDb21wbGV0YXIgZGVmaW5pY2nDs24gKF5EXk5eUCkiCiAKLSM6IGVkaXQuYzo1MQogbXNnaWQgIiBEaWN0aW9uYXJ5IGNvbXBsZXRpb24gKF5LXk5eUCkiCiBtc2dzdHIgIiBDb21wbGV0YXIgZGljY2lvbmFyaW8gKF5LXk5eUCkiCiAKLSM6IGVkaXQuYzo1MgogbXNnaWQgIiBUaGVzYXVydXMgY29tcGxldGlvbiAoXlReTl5QKSIKIG1zZ3N0ciAiIENvbXBsZXRhciBwYWxhYnJhcyBjb24gdGVzYXVybyAoXlReTl5QKSIKIAotIzogZWRpdC5jOjUzCiBtc2dpZCAiIENvbW1hbmQtbGluZSBjb21wbGV0aW9uICheVl5OXlApIgogbXNnc3RyICIgQ29tcGxlY2nDs24gZGUgbMOtbmVhIGRlIMOzcmRlbmVzICheVl5OXlApIgogCi0jOiBlZGl0LmM6NTQKIG1zZ2lkICIgVXNlciBkZWZpbmVkIGNvbXBsZXRpb24gKF5VXk5eUCkiCiBtc2dzdHIgIiBDb21wbGV0YXIgZGVmaW5pZG8gcG9yIHVzdWFyaW8gKF5VXk5eUCkiCiAKLSM6IGVkaXQuYzo1NQogbXNnaWQgIiBPbW5pIGNvbXBsZXRpb24gKF5PXk5eUCkiCiBtc2dzdHIgIiBDb21wbGV0YXIgY29uIG3DqXRvZG8gT21uaSAoXk9eTl5QKSIKIAotIzogZWRpdC5jOjU2CiBtc2dpZCAiIFNwZWxsaW5nIHN1Z2dlc3Rpb24gKHNeTl5QKSIKIG1zZ3N0ciAiIFN1Z2VyZW5jaWEgZGUgb3J0b2dyYWbDrWEgKHNeTl5QKSIKIAogIyBTY3JvbGwgaGFzIGl0cyBvd24gbXNncywgaW4gaXRzIHBsYWNlIHRoZXJlIGlzIHRoZSBtc2cgZm9yIGxvY2FsCiAjICogY3RybF94X21vZGUgPSAwIChlZyBjb250aW51ZV9zdGF0dXMgJiBDT05UX0xPQ0FMKSAgLS0gQWNldmVkbwotIzogZWRpdC5jOjU3CiBtc2dpZCAiIEtleXdvcmQgTG9jYWwgY29tcGxldGlvbiAoXk5eUCkiCiBtc2dzdHIgIiBDb21wbGV0YXIgcGFsYWJyYSBjbGF2ZSBsb2NhbCAoXk5eUCkiCiAKLSM6IGVkaXQuYzo2MAogbXNnaWQgIkhpdCBlbmQgb2YgcGFyYWdyYXBoIgogbXNnc3RyICJTZSBsbGVnw7MgYWwgZmluYWwgZGVsIHDDoXJyYWZvIgogCi0jOiBlZGl0LmM6MjAzOAogbXNnaWQgIidkaWN0aW9uYXJ5JyBvcHRpb24gaXMgZW1wdHkiCiBtc2dzdHIgIkxhIG9wY2nDs24gJ2RpY3Rpb25hcnknIGVzdMOhIHZhY8OtYSIKIAotIzogZWRpdC5jOjIwMzkKIG1zZ2lkICIndGhlc2F1cnVzJyBvcHRpb24gaXMgZW1wdHkiCiBtc2dzdHIgIkxhIG9wY2nDs24gJ3RoZXNhdXJ1cycgKHRlc2F1cm8pIGVzdMOhIHZhY8OtYSIKIAotIzogZWRpdC5jOjI5OTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiU2Nhbm5pbmcgZGljdGlvbmFyeTogJXMiCiBtc2dzdHIgIkJ1c2NhbmRvIGVuIGVsIGRpY2Npb25hcmlvOiAlcyIKIAotIzogZWRpdC5jOjM0ODQKIG1zZ2lkICIgKGluc2VydCkgU2Nyb2xsICheRS9eWSkiCiBtc2dzdHIgIiAoaW5zZXJ0YXIpIERlc3BsYXphbWllbnRvICheRS9eWSkiCiAKLSM6IGVkaXQuYzozNDg2CiBtc2dpZCAiIChyZXBsYWNlKSBTY3JvbGwgKF5FL15ZKSIKIG1zZ3N0ciAiIChyZWVtcGxhemFyKSBEZXNwbGF6YW1pZW50byAoXkUvXlkpIgogCi0jOiBlZGl0LmM6Mzk2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJTY2FubmluZzogJXMiCiBtc2dzdHIgIkJ1c2NhbmRvOiAlcyIKIAotIzogZWRpdC5jOjM5OTgKIG1zZ2lkICJTY2FubmluZyB0YWdzLiIKIG1zZ3N0ciAiQnVzY2FuZG8gZXRpcXVldGFzLiIKIAotIzogZWRpdC5jOjUwMTAKIG1zZ2lkICIgQWRkaW5nIgogbXNnc3RyICJBw7FhZGllbmRvIgogCkBAIC00MDUsMzM2ICszMTYsMjU1IEBACiAjICogYmUgY2FsbGVkIGJlZm9yZSBsaW5lID0gbWxfZ2V0KCksIG9yIHdoZW4gdGhpcyBhZGRyZXNzIGlzIG5vCiAjICogbG9uZ2VyIG5lZWRlZC4gIC0tIEFjZXZlZG8uCiAjCi0jLiBzaG93bW9kZSBtaWdodCByZXNldCB0aGUgaW50ZXJuYWwgbGluZSBwb2ludGVycywgc28gaXQgbXVzdAotIy4gKiBiZSBjYWxsZWQgYmVmb3JlIGxpbmUgPSBtbF9nZXQoKSwgb3Igd2hlbiB0aGlzIGFkZHJlc3MgaXMgbm8KLSMuICogbG9uZ2VyIG5lZWRlZC4gIC0tIEFjZXZlZG8uCi0jLgotIzogZWRpdC5jOjUwNTcKIG1zZ2lkICItLSBTZWFyY2hpbmcuLi4iCiBtc2dzdHIgIi0tIEJ1c2NhbmRvLi4uIgogCi0jOiBlZGl0LmM6NTExNgogbXNnaWQgIkJhY2sgYXQgb3JpZ2luYWwiCiBtc2dzdHIgIkRlIHZ1ZWx0YSBhbCBvcmlnaW5hbCIKIAotIzogZWRpdC5jOjUxMjEKIG1zZ2lkICJXb3JkIGZyb20gb3RoZXIgbGluZSIKIG1zZ3N0ciAiUGFsYWJyYSBwcm92ZW5pZW50ZSBkZSBvdHJhIGzDrW5lYSIKIAotIzogZWRpdC5jOjUxMjYKIG1zZ2lkICJUaGUgb25seSBtYXRjaCIKIG1zZ3N0ciAiTGEgw7puaWNhIGNvaW5jaWRlbmNpYSIKIAotIzogZWRpdC5jOjUxOTEKICMsIGMtZm9ybWF0CiBtc2dpZCAibWF0Y2ggJWQgb2YgJWQiCiBtc2dzdHIgImNvaW5jaWRlbmNpYSAlZCBkZSAlZCIKIAotIzogZWRpdC5jOjUxOTUKICMsIGMtZm9ybWF0CiBtc2dpZCAibWF0Y2ggJWQiCiBtc2dzdHIgImNvaW5jaWRlbmNpYSAlZCIKIAotIzogZXZhbC5jOjk2CiBtc2dpZCAiRTE4OiBVbmV4cGVjdGVkIGNoYXJhY3RlcnMgaW4gOmxldCIKIG1zZ3N0ciAiRTE4OiBDYXJhY3RlcmVzIGluZXNwZXJhZG9zIGVuIDpsZXQiCiAKLSM6IGV2YWwuYzo5NwogIywgYy1mb3JtYXQKIG1zZ2lkICJFNjg0OiBsaXN0IGluZGV4IG91dCBvZiByYW5nZTogJWxkIgogbXNnc3RyICJFNjg0OiDDrW5kaWNlIGRlIGxpc3RhIGZ1ZXJhIGRlIHJhbmdvOiAlbGQiCiAKLSM6IGV2YWwuYzo5OAogIywgYy1mb3JtYXQKIG1zZ2lkICJFMTIxOiBVbmRlZmluZWQgdmFyaWFibGU6ICVzIgogbXNnc3RyICJFMTIxOiBWYXJpYWJsZSBzaW4gZGVmaW5pcjogJXMiCiAKLSM6IGV2YWwuYzo5OQogbXNnaWQgIkUxMTE6IE1pc3NpbmcgJ10nIgogbXNnc3RyICJFMTExOiBGYWx0YSB1biBcIl1cIiIKIAotIzogZXZhbC5jOjEwMAogIywgYy1mb3JtYXQKIG1zZ2lkICJFNjg2OiBBcmd1bWVudCBvZiAlcyBtdXN0IGJlIGEgTGlzdCIKIG1zZ3N0ciAiRTY4NjogRWwgYXJndW1lbnRvIGRlICVzIGRlYmUgc2VyIHVuYSBsaXN0YSIKIAotIzogZXZhbC5jOjEwMQogIywgYy1mb3JtYXQKIG1zZ2lkICJFNzEyOiBBcmd1bWVudCBvZiAlcyBtdXN0IGJlIGEgTGlzdCBvciBEaWN0aW9uYXJ5IgogbXNnc3RyICJFNzEyOiBFbCBhcmd1bWVudG8gZGUgJXMgZGViZSBzZXIgdW5hIGxpc3RhIG8gdW4gZGljY2lvbmFyaW8iCiAKLSM6IGV2YWwuYzoxMDIKIG1zZ2lkICJFNzEzOiBDYW5ub3QgdXNlIGVtcHR5IGtleSBmb3IgRGljdGlvbmFyeSIKIG1zZ3N0ciAiRTcxMzogTm8gc2UgcHVlZGUgdXNhciB1bmEgbGxhdmUgdmFjw61hIHBhcmEgZWwgZGljY2lvbmFyaW8iCiAKLSM6IGV2YWwuYzoxMDMKIG1zZ2lkICJFNzE0OiBMaXN0IHJlcXVpcmVkIgogbXNnc3RyICJFNzE0OiBTZSByZXF1aWVyZSB1bmEgbGlzdGEiCiAKLSM6IGV2YWwuYzoxMDQKIG1zZ2lkICJFNzE1OiBEaWN0aW9uYXJ5IHJlcXVpcmVkIgogbXNnc3RyICJFNzE1OiBTZSByZXF1aWVyZSBkZSB1biBkaWNjaW9uYXJpbyIKIAotIzogZXZhbC5jOjEwNQogIywgYy1mb3JtYXQKIG1zZ2lkICJFMTE4OiBUb28gbWFueSBhcmd1bWVudHMgZm9yIGZ1bmN0aW9uOiAlcyIKIG1zZ3N0ciAiRTExODogRGVtYXNpYWRvcyBhcmd1bWVudG9zIHBhcmEgbGEgZnVuY2nDs246ICVzIgogCi0jOiBldmFsLmM6MTA2CiAjLCBjLWZvcm1hdAogbXNnaWQgIkU3MTY6IEtleSBub3QgcHJlc2VudCBpbiBEaWN0aW9uYXJ5OiAlcyIKIG1zZ3N0ciAiRTcxNjogTm8gc2UgZW5jdWVudHJhIGxhIGxsYXZlIGVuIGVsIGRpY2Npb25hcmlvLiAlcyIKIAotIzogZXZhbC5jOjEwNwogIywgYy1mb3JtYXQKIG1zZ2lkICJFMTIyOiBGdW5jdGlvbiAlcyBhbHJlYWR5IGV4aXN0cywgYWRkICEgdG8gcmVwbGFjZSBpdCIKIG1zZ3N0ciAiRTEyMjogTGEgZnVuY2nDs24gJXMgeWEgZXhpc3RlLCBhw7FhZGEgXCIhXCIgcGFyYSByZWVtcGxhemFybGEiCiAKLSM6IGV2YWwuYzoxMDgKIG1zZ2lkICJFNzE3OiBEaWN0aW9uYXJ5IGVudHJ5IGFscmVhZHkgZXhpc3RzIgogbXNnc3RyICJFNzE3OiBFc3RhIGVudHJhZGEgeWEgZXhpc3RlIGVuIGVsIGRpY2Npb25hcmlvIgogCi0jOiBldmFsLmM6MTA5CiBtc2dpZCAiRTcxODogRnVuY3JlZiByZXF1aXJlZCIKIG1zZ3N0ciAiRTcxODogU2UgcmVxdWllcmUgdW5hIHJlZmVyZW5jaWEgZGUgZnVuY2nDs24iCiAKICMgaWYgVmltIG9wZW5lZCBhIHdpbmRvdzogRXhlY3V0aW5nIGEgc2hlbGwgbWF5IGNhdXNlIGNyYXNoZXMKLSM6IGV2YWwuYzoxMTAKIG1zZ2lkICJFNzE5OiBDYW5ub3QgdXNlIFs6XSB3aXRoIGEgRGljdGlvbmFyeSIKIG1zZ3N0ciAiRTcxOTogTm8gcHVlZGUgdXNhciBbOl0gY29uIHVuIGRpY2Npb25hcmlvIgogCi0jOiBldmFsLmM6MTExCiAjLCBjLWZvcm1hdAogbXNnaWQgIkU3MzQ6IFdyb25nIHZhcmlhYmxlIHR5cGUgZm9yICVzPSIKIG1zZ3N0ciAiRTczNDogVGlwbyBkZSB2YXJpYWJsZSBpbmNvcnJlY3RhIHBhcmEgJXM9IgogCi0jOiBldmFsLmM6MTEyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkUxMzA6IFVua25vd24gZnVuY3Rpb246ICVzIgogbXNnc3RyICJFMTMwOiBGdW5jacOzbiBkZXNjb25vY2lkYTogJXMiCiAKLSM6IGV2YWwuYzoxMTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTQ2MTogSWxsZWdhbCB2YXJpYWJsZSBuYW1lOiAlcyIKIG1zZ3N0ciAiRTQ2MTogTm9tYnJlIGlsZWdhbCBwYXJhIHVuYSB2YXJpYWJsZTogJXMiCiAKLSM6IGV2YWwuYzoxODk4CiBtc2dpZCAiRTY4NzogTGVzcyB0YXJnZXRzIHRoYW4gTGlzdCBpdGVtcyIKIG1zZ3N0ciAiRTY4NzogTWVub3MgYmxhbmNvcyBxdWUgZWxlbWVudG9zIGVuIGxhIGxpc3RhIgogCi0jOiBldmFsLmM6MTkwMwogbXNnaWQgIkU2ODg6IE1vcmUgdGFyZ2V0cyB0aGFuIExpc3QgaXRlbXMiCiBtc2dzdHIgIkU2ODg6IE3DoXMgYmxhbmNvcyBxdWUgZWxlbWVudG9zIGVuIGxhIGxpc3RhIgogCi0jOiBldmFsLmM6MTk4OQogbXNnaWQgIkRvdWJsZSA7IGluIGxpc3Qgb2YgdmFyaWFibGVzIgogbXNnc3RyICJEdXBsaWNhZG8gOyBlbiBsYSBsaXN0YSBkZSB2YXJpYWJsZXMiCiAKLSM6IGV2YWwuYzoyMjA4CiAjLCBjLWZvcm1hdAogbXNnaWQgIkU3Mzg6IENhbid0IGxpc3QgdmFyaWFibGVzIGZvciAlcyIKIG1zZ3N0ciAiRTczODogTm8gc2UgcHVkbyBlbnVtZXJhciBsYXMgdmFyaWFibGVzIGRlICVzIgogCi0jOiBldmFsLmM6MjU1NAogbXNnaWQgIkU2ODk6IENhbiBvbmx5IGluZGV4IGEgTGlzdCBvciBEaWN0aW9uYXJ5IgogbXNnc3RyICJFNjg5OiBTb2xvIHB1ZWRvIGluZGV4YXIgdW5hIGxpc3RhIG8gdW4gZGljY2lvbmFyaW8iCiAKLSM6IGV2YWwuYzoyNTYwCiBtc2dpZCAiRTcwODogWzpdIG11c3QgY29tZSBsYXN0IgogbXNnc3RyICJFNzA4OiBbOl0gZGViZSBpciBhbCBmaW5hbCIKIAotIzogZXZhbC5jOjI2MTIKIG1zZ2lkICJFNzA5OiBbOl0gcmVxdWlyZXMgYSBMaXN0IHZhbHVlIgogbXNnc3RyICJFNzA5OiBbOl0gcmVxdWllcmUgdW4gdmFsb3IgZGUgbGEgbGlzdGEiCiAKLSM6IGV2YWwuYzoyODQ4CiBtc2dpZCAiRTcxMDogTGlzdCB2YWx1ZSBoYXMgbW9yZSBpdGVtcyB0aGFuIHRhcmdldCIKIG1zZ3N0ciAiRTcxMDogTGEgbGlzdGEgZGUgdmFsb3JlcyB0aWVuZSBtw6FzIGVsZW1lbnRvcyBxdWUgYmxhbmNvcyIKIAotIzogZXZhbC5jOjI4NTIKIG1zZ2lkICJFNzExOiBMaXN0IHZhbHVlIGhhcyBub3QgZW5vdWdoIGl0ZW1zIgogbXNnc3RyICJFNzExOiBMYSBsaXN0YSBkZSB2YWxvcmVzIG5vIHRpZW5lIHN1ZmljaWVudGVzIGVsZW1lbnRvcyIKIAotIzogZXZhbC5jOjMwODcKIG1zZ2lkICJFNjkwOiBNaXNzaW5nIFwiaW5cIiBhZnRlciA6Zm9yIgogbXNnc3RyICJFNjkwOiBGYWx0YSBcImluXCIgZGVzcHXDqXMgZGUgOmZvciIKIAotIzogZXZhbC5jOjMzMjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTEwNzogTWlzc2luZyBwYXJlbnRoZXNlczogJXMiCiBtc2dzdHIgIkUxMDc6IEZhbHRhbiBwYXLDqW50ZXNpczogJXMiCiAKLSM6IGV2YWwuYzozNTU5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkUxMDg6IE5vIHN1Y2ggdmFyaWFibGU6IFwiJXNcIiIKIG1zZ3N0ciAiRTEwODogTm8gZXhpc3RlIGxhIHZhcmlhYmxlOiBcIiVzXCIiCiAKLSM6IGV2YWwuYzozNjQ2CiBtc2dpZCAiRTc0MzogdmFyaWFibGUgbmVzdGVkIHRvbyBkZWVwIGZvciAodW4pbG9jayIKIG1zZ3N0ciAiRTc0MzogTGEgdmFyaWFibGUgZXN0w6EgYW5pZGFkYSBtdXkgcHJvZnVuZGFtZW50ZSBwYXJhIChkZXMpYmxvcXVlYXIiCiAKLSM6IGV2YWwuYzozOTk0CiBtc2dpZCAiRTEwOTogTWlzc2luZyAnOicgYWZ0ZXIgJz8nIgogbXNnc3RyICJFMTA5OiBGYWx0YSB1biBcIjpcIiBkZXNwdcOpcyBkZSBcIj9cIiIKIAotIzogZXZhbC5jOjQyOTYKIG1zZ2lkICJFNjkxOiBDYW4gb25seSBjb21wYXJlIExpc3Qgd2l0aCBMaXN0IgogbXNnc3RyICJFNjkxOiBTb2xvIHNlIHB1ZWRlIGNvbXBhcmFyIHVuYSBsaXN0YSBjb24gb3RyYSBsaXN0YSIKIAotIzogZXZhbC5jOjQyOTgKIG1zZ2lkICJFNjkyOiBJbnZhbGlkIG9wZXJhdGlvbiBmb3IgTGlzdCIKIG1zZ3N0ciAiRTY5MjogT3BlcmFjacOzbiBpbnbDoWxpZGEgcGFyYSBsaXN0YSIKIAotIzogZXZhbC5jOjQzMjUKIG1zZ2lkICJFNzM1OiBDYW4gb25seSBjb21wYXJlIERpY3Rpb25hcnkgd2l0aCBEaWN0aW9uYXJ5IgogbXNnc3RyICJFNzM1OiBTb2xvIHNlIHB1ZWRlIGNvbXBhcmFyIHVuIGRpY2Npb25hcmlvIGNvbiBvdHJvIGRpY2Npb25hcmlvIgogCi0jOiBldmFsLmM6NDMyNwogbXNnaWQgIkU3MzY6IEludmFsaWQgb3BlcmF0aW9uIGZvciBEaWN0aW9uYXJ5IgogbXNnc3RyICJFNzM2OiBPcGVyYWNpw7NuIGludsOhbGlkYSBwYXJhIGRpY2Npb25hcmlvIgogCi0jOiBldmFsLmM6NDM0NwogbXNnaWQgIkU2OTM6IENhbiBvbmx5IGNvbXBhcmUgRnVuY3JlZiB3aXRoIEZ1bmNyZWYiCiBtc2dzdHIgIkU2OTM6IFNvbG8gc2UgcHVlZGUgY29tcGFyYXIgdW4gXCJGdW5yZWZcIiBjb24gb3RybyBcIkZ1bmNyZWZcIiIKIAotIzogZXZhbC5jOjQzNDkKIG1zZ2lkICJFNjk0OiBJbnZhbGlkIG9wZXJhdGlvbiBmb3IgRnVuY3JlZnMiCiBtc2dzdHIgIkU2OTQ6IE9wZXJhY2nDs24gaW52w6FsaWRhIHBhcmEgXCJGdW5jcmVmc1wiIgogCiAjIGlmIFZpbSBvcGVuZWQgYSB3aW5kb3c6IEV4ZWN1dGluZyBhIHNoZWxsIG1heSBjYXVzZSBjcmFzaGVzCi0jOiBldmFsLmM6NDc2OQogbXNnaWQgIkU4MDQ6IENhbm5vdCB1c2UgJyUnIHdpdGggRmxvYXQiCiBtc2dzdHIgIkU4MDQ6IE5vIHNlIHB1ZWRlIHVzYXIgJyUnIGNvbiBcIkZsb2F0XCIiCiAKLSM6IGV2YWwuYzo0OTg5CiBtc2dpZCAiRTExMDogTWlzc2luZyAnKSciCiBtc2dzdHIgIkUxMTA6IEZhbHRhIHVuIFwiKVwiIgogCi0jOiBldmFsLmM6NTE0MQogbXNnaWQgIkU2OTU6IENhbm5vdCBpbmRleCBhIEZ1bmNyZWYiCiBtc2dzdHIgIkU2OTU6IE5vIHNlIHB1ZWRlIGNyZWFyIHVuIMOtbmRpY2UgZGUgdW4gXCJGdW5jcmVmXCIiCiAKLSM6IGV2YWwuYzo1Mzk4CiAjLCBjLWZvcm1hdAogbXNnaWQgIkUxMTI6IE9wdGlvbiBuYW1lIG1pc3Npbmc6ICVzIgogbXNnc3RyICJFMTEyOiBGYWx0YSBlbCBub21icmUgZGUgbGEgb3BjacOzbjogJXMiCiAKLSM6IGV2YWwuYzo1NDE2CiAjLCBjLWZvcm1hdAogbXNnaWQgIkUxMTM6IFVua25vd24gb3B0aW9uOiAlcyIKIG1zZ3N0ciAiRTExMzogT3BjacOzbiBkZXNjb25vY2lkYTogJXMiCiAKLSM6IGV2YWwuYzo1NDgyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkUxMTQ6IE1pc3NpbmcgcXVvdGU6ICVzIgogbXNnc3RyICJFMTE0OiBGYWx0YW4gbGFzIGNvbWlsbGFzOiAlcyIKIAotIzogZXZhbC5jOjU2MTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTExNTogTWlzc2luZyBxdW90ZTogJXMiCiBtc2dzdHIgIkUxMTU6IEZhbHRhbiBsYXMgY29taWxsYXM6ICVzIgogCi0jOiBldmFsLmM6NTY5NwogIywgYy1mb3JtYXQKIG1zZ2lkICJFNjk2OiBNaXNzaW5nIGNvbW1hIGluIExpc3Q6ICVzIgogbXNnc3RyICJFNjk2OiBGYWx0YSB1bmEgY29tYSBlbiBsYSBsaXN0YTogJXMiCiAKLSM6IGV2YWwuYzo1NzA1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkU2OTc6IE1pc3NpbmcgZW5kIG9mIExpc3QgJ10nOiAlcyIKIG1zZ3N0ciAiRTY5NzogRmFsdGEgdW5hIG1hcmNhIGRlIGZpbmFsIGRlIGxpc3RhICddJzogJXMiCiAKLSM6IGV2YWwuYzo3MTk1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkU3MjA6IE1pc3NpbmcgY29sb24gaW4gRGljdGlvbmFyeTogJXMiCiBtc2dzdHIgIkU3MjA6IEZhbHRhIHVuYSBtYXJjYSBkZSBkb3MgcHVudG9zIGVuIGVsIGRpY2Npb25hcmlvOiAlcyIKIAotIzogZXZhbC5jOjcyMjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTcyMTogRHVwbGljYXRlIGtleSBpbiBEaWN0aW9uYXJ5OiBcIiVzXCIiCiBtc2dzdHIgIkU3MjE6IExsYXZlIGR1cGxpY2FkYSBlbiBlbCBkaWNjaW9uYXJpbzogJXMiCiAKLSM6IGV2YWwuYzo3MjQ0CiAjLCBjLWZvcm1hdAogbXNnaWQgIkU3MjI6IE1pc3NpbmcgY29tbWEgaW4gRGljdGlvbmFyeTogJXMiCiBtc2dzdHIgIkU3MjI6IEZhbHRhIHVuYSBjb21hIGVuIGVsIGRpY2Npb25hcmlvOiAlcyIKIAotIzogZXZhbC5jOjcyNTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTcyMzogTWlzc2luZyBlbmQgb2YgRGljdGlvbmFyeSAnfSc6ICVzIgogbXNnc3RyICJFNzIzOiBGYWx0YSB1bmEgbWFyY2EgZGUgY2llcnJlICd9JyBlbiBlbCBkaWNjaW9uYXJpbzogJXMiCiAKLSM6IGV2YWwuYzo3MjkwCiBtc2dpZCAiRTcyNDogdmFyaWFibGUgbmVzdGVkIHRvbyBkZWVwIGZvciBkaXNwbGF5aW5nIgogbXNnc3RyICJFNzI0OiBMYSB2YXJpYWJsZSBlc3TDoSBhbmlkYWRhIGRlbWFzaWFkbyBwcm9mdW5kYW1lbnRlIHBhcmEgbW9zdHJhcmxhIgogCi0jOiBldmFsLmM6Nzk3NAogIywgYy1mb3JtYXQKIG1zZ2lkICJFNzQwOiBUb28gbWFueSBhcmd1bWVudHMgZm9yIGZ1bmN0aW9uICVzIgogbXNnc3RyICJFNzQwOiBEZW1hc2lhZG9zIGFyZ3VtZW50b3MgcGFyYSBsYSBmdW5jacOzbjogJXMiCiAKLSM6IGV2YWwuYzo3OTc2CiAjLCBjLWZvcm1hdAogbXNnaWQgIkUxMTY6IEludmFsaWQgYXJndW1lbnRzIGZvciBmdW5jdGlvbiAlcyIKIG1zZ3N0ciAiRTExNjogQXJndW1lbnRvcyBpbnbDoWxpZG9zIHBhcmEgbGEgZnVuY2nDs246ICVzIgogCi0jOiBldmFsLmM6ODE4MQogIywgYy1mb3JtYXQKIG1zZ2lkICJFMTE3OiBVbmtub3duIGZ1bmN0aW9uOiAlcyIKIG1zZ3N0ciAiRTExNzogRnVuY2nDs24gZGVzY29ub2NpZGE6ICVzIgogCi0jOiBldmFsLmM6ODE4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJFMTE5OiBOb3QgZW5vdWdoIGFyZ3VtZW50cyBmb3IgZnVuY3Rpb246ICVzIgogbXNnc3RyICJFMTE5OiBObyBoYXkgc3VmaWNpZW50ZXMgYXJndW1lbnRvcyBwYXJhIGxhIGZ1bmNpw7NuOiAlcyIKIAotIzogZXZhbC5jOjgxOTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTEyMDogVXNpbmcgPFNJRD4gbm90IGluIGEgc2NyaXB0IGNvbnRleHQ6ICVzIgogbXNnc3RyICJFMTIwOiBVc2FuZG8gPFNJRD4gZW4gdW4gY29udGV4dG8gcXVlIG5vIGVzIGRlIFwic2NyaXB0XCI6ICVzIgogCi0jOiBldmFsLmM6ODE5NQogIywgYy1mb3JtYXQKIG1zZ2lkICJFNzI1OiBDYWxsaW5nIGRpY3QgZnVuY3Rpb24gd2l0aG91dCBEaWN0aW9uYXJ5OiAlcyIKIG1zZ3N0ciAiRTcyNTogTGxhbWFuZG8gdW5hIGZ1bmNpw7NuIFwiZGljdFwiIHNpbiB1biBkaWNjaW9uYXJpbzogJXMiCiAKLSM6IGV2YWwuYzo4NDIzCiBtc2dpZCAiRTgwODogTnVtYmVyIG9yIEZsb2F0IHJlcXVpcmVkIgogbXNnc3RyICJFODA4OiBTZSByZXF1aWVyZSBcIk51bWJlclwiIG8gXCJGbG9hdFwiIgogCi0jOiBldmFsLmM6ODgwOAogbXNnaWQgIkU2OTk6IFRvbyBtYW55IGFyZ3VtZW50cyIKIG1zZ3N0ciAiRTY5OTogRGVtYXNpYWRvcyBhcmd1bWVudG9zIgogCi0jOiBldmFsLmM6ODk3NwogbXNnaWQgIkU3ODU6IGNvbXBsZXRlKCkgY2FuIG9ubHkgYmUgdXNlZCBpbiBJbnNlcnQgbW9kZSIKIG1zZ3N0ciAiRTc4NTogY29tcGxldGUoKSBzb2xvIHNlIHB1ZWRlIHVzYXIgZW4gbW9kbyBcIkluc2VydFwiIgogCi0jLgotIy4gKiBZZXMgdGhpcyBpcyB1Z2x5LCBJIGRvbid0IHBhcnRpY3VsYXJseSBsaWtlIGl0IGVpdGhlci4gIEJ1dCBkb2luZyBpdAotIy4gKiB0aGlzIHdheSBoYXMgdGhlIGNvbXBlbGxpbmcgYWR2YW50YWdlIHRoYXQgdHJhbnNsYXRpb25zIG5lZWQgbm90IHRvCi0jLiAqIGJlIHRvdWNoZWQgYXQgYWxsLiAgU2VlIGJlbG93IHdoYXQgJ29rJyBhbmQgJ3luYycgYXJlIHVzZWQgZm9yLgotIy4KLSM6IGV2YWwuYzo5MDc3IGd1aS5jOjQ4NzEgZ3VpX2d0ay5jOjIxNDQgb3NfbXN3aW4uYzo1OTgKIG1zZ2lkICImT2siCiBtc2dzdHIgIiZPayIKIAotIzogZXZhbC5jOjk3MjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTczNzogS2V5IGFscmVhZHkgZXhpc3RzOiAlcyIKIG1zZ3N0ciAiRTczNzogWWEgZXhpc3RlIHVuYSBsbGF2ZTogJXMiCiAKLSM6IGV2YWwuYzoxMDMwMQogIywgYy1mb3JtYXQKIG1zZ2lkICIrLSVzJTNsZCBsaW5lczogIgogbXNnc3RyICIrLSVzJTNsZCBsw61uZWFzOiAiCiAKLSM6IGV2YWwuYzoxMDM4OQogIywgYy1mb3JtYXQKIG1zZ2lkICJFNzAwOiBVbmtub3duIGZ1bmN0aW9uOiAlcyIKIG1zZ3N0ciAiRTcwMDogRnVuY2nDs24gZGVzY29ub2NpZGE6ICVzIgogCi0jOiBldmFsLmM6MTIzNzkKIG1zZ2lkICIiCiAiJk9LXG4iCiAiJkNhbmNlbCIKQEAgLTc0MiwyMjIgKzU3MiwxNzQgQEAKICImQWNlcHRhclxuIgogIiZDYW5jZWxhciIKIAotIzogZXZhbC5jOjEyNDYxCiBtc2dpZCAiY2FsbGVkIGlucHV0cmVzdG9yZSgpIG1vcmUgb2Z0ZW4gdGhhbiBpbnB1dHNhdmUoKSIKIG1zZ3N0ciAiU2UgaW52b2PDsyBcImlucHV0cmVzdG9yZSgpXCIgbcOhcyB2ZWNlcyBxdWUgXCJpbnB1dHNhdmUoKVwiIgogCi0jOiBldmFsLmM6MTI1OTUKIG1zZ2lkICJFNzg2OiBSYW5nZSBub3QgYWxsb3dlZCIKIG1zZ3N0ciAiRTc4NjogRWwgcmFuZ28gbm8gZXN0w6EgcGVybWl0aWRvIgogCi0jOiBldmFsLmM6MTI3OTUKIG1zZ2lkICJFNzAxOiBJbnZhbGlkIHR5cGUgZm9yIGxlbigpIgogbXNnc3RyICJFNzAxOiBObyBlcyB1biB0aXBvIHbDoWxpZG8gcGFyYSBsZW4oKSIKIAotIzogZXZhbC5jOjEzNzg4CiBtc2dpZCAiRTcyNjogU3RyaWRlIGlzIHplcm8iCiBtc2dzdHIgIkU3MjY6IEVsIGxhcmdvIGVzIGNlcm8iCiAKLSM6IGV2YWwuYzoxMzc5MAogbXNnaWQgIkU3Mjc6IFN0YXJ0IHBhc3QgZW5kIgogbXNnc3RyICJFNzI3OiBFbCBpbmljaW8gZXN0w6EgbcOhcyBhbGzDoSBkZWwgZmluYWwiCiAKLSM6IGV2YWwuYzoxMzg0MyBldmFsLmM6MTc1NzYKIG1zZ2lkICI8ZW1wdHk+IgogbXNnc3RyICI8dmFjaW8+IgogCi0jOiBldmFsLmM6MTQwNzcKIG1zZ2lkICJFMjQwOiBObyBjb25uZWN0aW9uIHRvIFZpbSBzZXJ2ZXIiCiBtc2dzdHIgIkUyNDA6IE5vIGhheSBjb25leGnDs24gYWwgc2Vydmlkb3IgVmltIgogCi0jOiBldmFsLmM6MTQxMjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTI0MTogVW5hYmxlIHRvIHNlbmQgdG8gJXMiCiBtc2dzdHIgIkUyNDE6IEluY2FwYXogZGUgZW52aWFyIGEgJXMiCiAKLSM6IGV2YWwuYzoxNDI3MgogbXNnaWQgIkUyNzc6IFVuYWJsZSB0byByZWFkIGEgc2VydmVyIHJlcGx5IgogbXNnc3RyICJFMjc3OiBJbmNhcGF6IGRlIGxlZXIgdW5hIHJlc3B1ZXN0YSBkZWwgc2Vydmlkb3IiCiAKLSM6IGV2YWwuYzoxNDUyMgogbXNnaWQgIkU2NTU6IFRvbyBtYW55IHN5bWJvbGljIGxpbmtzIChjeWNsZT8pIgogbXNnc3RyICJFNjU1OiBEZW1hc2lhZG9zIGVubGFjZXMgc2ltYsOzbGljb3MgKMK/cmVmZXJlbmNpYSBjaXJjdWxhcj8pIgogCi0jOiBldmFsLmM6MTUyNDMKIG1zZ2lkICJFMjU4OiBVbmFibGUgdG8gc2VuZCB0byBjbGllbnQiCiBtc2dzdHIgIkUyNTg6IEluY2FwYXogZGUgZW52aWFyIGFsIGNsaWVudGUiCiAKLSM6IGV2YWwuYzoxNTk1MAogbXNnaWQgIkU3MDI6IFNvcnQgY29tcGFyZSBmdW5jdGlvbiBmYWlsZWQiCiBtc2dzdHIgIkU3MDI6IEZhbGxvIGFsIG9yZGVuYXIgZnVuY2lvbmVzIGNvbXBhcmFkYXMiCiAKLSM6IGV2YWwuYzoxNjI3NQogbXNnaWQgIihJbnZhbGlkKSIKIG1zZ3N0ciAiKE5vIGVzIHbDoWxpZG8pIgogCi0jOiBldmFsLmM6MTY3NjAKIG1zZ2lkICJFNjc3OiBFcnJvciB3cml0aW5nIHRlbXAgZmlsZSIKIG1zZ3N0ciAiRTY3NzogRXJyb3IgYWwgZXNjcmliaXIgZWwgYXJjaGl2byB0ZW1wb3JhbCIKIAotIzogZXZhbC5jOjE4NjAyCiBtc2dpZCAiRTgwNTogVXNpbmcgYSBGbG9hdCBhcyBhIE51bWJlciIKIG1zZ3N0ciAiRTgwNTogVXNhbmRvIFwiRmxvYXRcIiBjb21vIHVuIFwiTnVtYmVyXCIiCiAKLSM6IGV2YWwuYzoxODYwNgogbXNnaWQgIkU3MDM6IFVzaW5nIGEgRnVuY3JlZiBhcyBhIE51bWJlciIKIG1zZ3N0ciAiRTcwMzogVXNhbmRvIHVuYSBmdW5jacOzbiBkZSByZWZlcmVuY2lhIGNvbW8gXCJOdW1iZXJcIiIKIAotIzogZXZhbC5jOjE4NjE0CiBtc2dpZCAiRTc0NTogVXNpbmcgYSBMaXN0IGFzIGEgTnVtYmVyIgogbXNnc3RyICJFNzQ1OiBVc2FuZG8gdW5hIFwiTGlzdGFcIiBjb21vIFwiTnVtYmVyXCIiCiAKLSM6IGV2YWwuYzoxODYxNwogbXNnaWQgIkU3Mjg6IFVzaW5nIGEgRGljdGlvbmFyeSBhcyBhIE51bWJlciIKIG1zZ3N0ciAiRTcyODogVXNhbmRvIHVuIERpY2Npb25hcmlvIGNvbW8gXCJOdW1iZXJcIiIKIAotIzogZXZhbC5jOjE4NzIwCiBtc2dpZCAiRTcyOTogdXNpbmcgRnVuY3JlZiBhcyBhIFN0cmluZyIKIG1zZ3N0ciAiRTcyOTogVXNhbmRvIHVuYSBGdW5jacOzbiBkZSByZWZlcmVuY2lhIGNvbW8gXCJTdHJpbmdcIiIKIAotIzogZXZhbC5jOjE4NzIzCiBtc2dpZCAiRTczMDogdXNpbmcgTGlzdCBhcyBhIFN0cmluZyIKIG1zZ3N0ciAiRTczMDogVXNhbmRvIHVuYSBcIkxpc3RcIiBjb21vIFwiU3RyaW5nXCIiCiAKLSM6IGV2YWwuYzoxODcyNgogbXNnaWQgIkU3MzE6IHVzaW5nIERpY3Rpb25hcnkgYXMgYSBTdHJpbmciCiBtc2dzdHIgIkU3MzE6IFVzYW5kbyB1biBEaWNjaW9uYXJpbyBjb21vIFwiU3RyaW5nXCIiCiAKLSM6IGV2YWwuYzoxODczMAogbXNnaWQgIkU4MDY6IHVzaW5nIEZsb2F0IGFzIGEgU3RyaW5nIgogbXNnc3RyICJFODA2OiBVc2FuZG8gXCJGbG9hdFwiIGNvbW8gXCJTdHJpbmdcIiIKIAotIzogZXZhbC5jOjE5MDkwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkU3MDQ6IEZ1bmNyZWYgdmFyaWFibGUgbmFtZSBtdXN0IHN0YXJ0IHdpdGggYSBjYXBpdGFsOiAlcyIKIG1zZ3N0ciAiIgogIkU3MDQ6IEVsIG5vbWJyZSBkZSB1bmEgdmFyaWFibGUgZGUgRnVuY2nDs24gZGUgcmVmZXJlbmNpYSBkZWJlIGVtcGV6YXIgY29uICIKICJtYXnDunNjdWxhOiAlcyIKIAotIzogZXZhbC5jOjE5MDk1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkU3MDU6IFZhcmlhYmxlIG5hbWUgY29uZmxpY3RzIHdpdGggZXhpc3RpbmcgZnVuY3Rpb246ICVzIgogbXNnc3RyICJFNzA1OiBOb21icmUgZGUgdmFyaWFibGUgZW4gY29uZmxpY3RvIGNvbiB1bmEgZnVuY2nDs24gZXhpc3RlbnRlOiAlcyIKIAotIzogZXZhbC5jOjE5MTI4CiAjLCBjLWZvcm1hdAogbXNnaWQgIkU3MDY6IFZhcmlhYmxlIHR5cGUgbWlzbWF0Y2ggZm9yOiAlcyIKIG1zZ3N0ciAiRTcwNjogVGlwbyBkZSB2YXJpYWJsZSBubyBjb25jdWVyZGEgY29uIDogJXMiCiAKLSM6IGV2YWwuYzoxOTIzNwogIywgYy1mb3JtYXQKIG1zZ2lkICJFNzk1OiBDYW5ub3QgZGVsZXRlIHZhcmlhYmxlICVzIgogbXNnc3RyICJFNzk1OiBObyBzZSBwdWRvIGJvcnJhciBsYSB2YXJpYWJsZSAlcyIKIAotIzogZXZhbC5jOjE5MjU0CiAjLCBjLWZvcm1hdAogbXNnaWQgIkU3NDE6IFZhbHVlIGlzIGxvY2tlZDogJXMiCiBtc2dzdHIgIkU3NDE6IEVsIHZhbG9yIGVzdMOhIGJsb3F1ZWFkbzogJXMiCiAKLSM6IGV2YWwuYzoxOTI1NSBldmFsLmM6MTkyNjEgbWVzc2FnZS5jOjIxMzIgb3NfbXN3aW4uYzoyMjU4CiBtc2dpZCAiVW5rbm93biIKIG1zZ3N0ciAiRGVzY29ub2NpZG8iCiAKLSM6IGV2YWwuYzoxOTI2MAogIywgYy1mb3JtYXQKIG1zZ2lkICJFNzQyOiBDYW5ub3QgY2hhbmdlIHZhbHVlIG9mICVzIgogbXNnc3RyICJFNzQyOiBObyBzZSBwdWRvIGNhbWJpYXIgZWwgdmFsb3IgZGUgJXMiCiAKLSM6IGV2YWwuYzoxOTM0NQogbXNnaWQgIkU2OTg6IHZhcmlhYmxlIG5lc3RlZCB0b28gZGVlcCBmb3IgbWFraW5nIGEgY29weSIKIG1zZ3N0ciAiRTY5ODogTGEgdmFyaWFibGUgZXN0w6EgYW5pZGFkYSBtdXkgcHJvZnVuZGFtZW50ZSBwYXJhIGhhY2VyIHVuYSBjb3BpYSIKIAotIzogZXZhbC5jOjE5ODE4CiAjLCBjLWZvcm1hdAogbXNnaWQgIkUxMjM6IFVuZGVmaW5lZCBmdW5jdGlvbjogJXMiCiBtc2dzdHIgIkUxMjM6IEZ1bmNpw7NuIGluZGVmaW5pZGE6ICVzIgogCi0jOiBldmFsLmM6MTk4MzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTEyNDogTWlzc2luZyAnKCc6ICVzIgogbXNnc3RyICJFMTI0OiBGYWx0YSB1biBcIihcIjogJXMiCiAKLSM6IGV2YWwuYzoxOTg4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJFMTI1OiBJbGxlZ2FsIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAiRTEyNTogQXJndW1lbnRvIGlsZWdhbDogJXMiCiAKLSM6IGV2YWwuYzoxOTk5NwogbXNnaWQgIkUxMjY6IE1pc3NpbmcgOmVuZGZ1bmN0aW9uIgogbXNnc3RyICJFMTI2OiBGYWx0YSB1biBcIjplbmRmdW5jdGlvblwiIgogCi0jOiBldmFsLmM6MjAxMzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTcwNzogRnVuY3Rpb24gbmFtZSBjb25mbGljdHMgd2l0aCB2YXJpYWJsZTogJXMiCiBtc2dzdHIgIkU3MDc6IEVsIG5vbWJyZSBkZSBsYSBmdW5jacOzbiBlbnRyYW4gZW4gY29uZmxpY3RvIGNvbiBsYSB2YXJpYWJsZTogJXMiCiAKLSM6IGV2YWwuYzoyMDE0OQogIywgYy1mb3JtYXQKIG1zZ2lkICJFMTI3OiBDYW5ub3QgcmVkZWZpbmUgZnVuY3Rpb24gJXM6IEl0IGlzIGluIHVzZSIKIG1zZ3N0ciAiRTEyNzogTm8gc2UgcHVlZGUgcmVkZWZpbmlyIGxhIGZ1bmNpw7NuICVzOiBFc3TDoSBlbiB1c28iCiAKLSM6IGV2YWwuYzoyMDIxNAogIywgYy1mb3JtYXQKIG1zZ2lkICJFNzQ2OiBGdW5jdGlvbiBuYW1lIGRvZXMgbm90IG1hdGNoIHNjcmlwdCBmaWxlIG5hbWU6ICVzIgogbXNnc3RyICJFNzQ2OiBOb21icmUgZGUgZnVuY2nDs24gbm8gY29uY3VlcmRhIGNvbiBlbCBub21icmUgZGUgYXJjaGl2bzogJXMiCiAKLSM6IGV2YWwuYzoyMDMzMgogbXNnaWQgIkUxMjk6IEZ1bmN0aW9uIG5hbWUgcmVxdWlyZWQiCiBtc2dzdHIgIkUxMjk6IFNlIHJlcXVpZXJlIGVsIG5vbWJyZSBkZSBsYSBmdW5jacOzbiIKIAotIzogZXZhbC5jOjIwNDUyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkUxMjg6IEZ1bmN0aW9uIG5hbWUgbXVzdCBzdGFydCB3aXRoIGEgY2FwaXRhbCBvciBjb250YWluIGEgY29sb246ICVzIgogbXNnc3RyICIiCiAiRTEyODogRWwgbm9tYnJlIGRlIHVuYSBmdW5jacOzbiBkZWJlIGVtcGV6YXIgY29uIG1hecO6c2N1bGEgbyBjb250ZW5lciBlbCAiCiAic2lnbm8gZGUgZG9zIHB1bnRvczogJXMiCiAKLSM6IGV2YWwuYzoyMDk4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJFMTMxOiBDYW5ub3QgZGVsZXRlIGZ1bmN0aW9uICVzOiBJdCBpcyBpbiB1c2UiCiBtc2dzdHIgIkUxMzE6IE5vIHNlIHB1ZG8gZWxpbWluYXIgbGEgZnVuY2nDs24gJXM6IEVzdMOhIGVuIHVzbyIKIAotIzogZXZhbC5jOjIxMTA0CiBtc2dpZCAiRTEzMjogRnVuY3Rpb24gY2FsbCBkZXB0aCBpcyBoaWdoZXIgdGhhbiAnbWF4ZnVuY2RlcHRoJyIKIG1zZ3N0ciAiIgogIkUxMzI6IExhIHJlY3Vyc2nDs24gZGUgbGxhbWFkYSBkZSBsYSBmdW5jacOzbiBlcyBtYXlvciBxdWUgXCJtYXhmdW5jZGVwdGhcIiIKIAogIyBhbHdheXMgc2Nyb2xsIHVwLCBkb24ndCBvdmVyd3JpdGUKLSM6IGV2YWwuYzoyMTI0MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjYWxsaW5nICVzIgogbXNnc3RyICJJbnZvY2FuZG8gJXMiCiAKLSM6IGV2YWwuYzoyMTMzNQogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBhYm9ydGVkIgogbXNnc3RyICJBYm9ydGFkYSBsYSBlamVjdWNpw7NuIGRlICVzIgogCi0jOiBldmFsLmM6MjEzMzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgcmV0dXJuaW5nICMlbGQiCiBtc2dzdHIgIiVzIGRldnVlbHZlICMlbGQiCiAKLSM6IGV2YWwuYzoyMTM1MwogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyByZXR1cm5pbmcgJXMiCiBtc2dzdHIgIiVzIGRldnVlbHZlICVzIgogCiAjIGFsd2F5cyBzY3JvbGwgdXAsIGRvbid0IG92ZXJ3cml0ZQotIzogZXZhbC5jOjIxMzc3IGV4X2NtZHMyLmM6MzE0NQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb250aW51aW5nIGluICVzIgogbXNnc3RyICJjb250aW51YW5kbyBlbiAlcyIKIAotIzogZXZhbC5jOjIxNDk2CiBtc2dpZCAiRTEzMzogOnJldHVybiBub3QgaW5zaWRlIGEgZnVuY3Rpb24iCiBtc2dzdHIgIkUxMzM6IFwiOnJldHVyblwiIG5vIGVzdMOhIGRlbnRybyBkZSB1bmEgZnVuY2nDs24iCiAKLSM6IGV2YWwuYzoyMTkwOQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiXG4iCkBAIC05NjYsNyArNzQ4LDYgQEAKICJcbiIKICIjIHZhcmlhYmxlcyBnbG9iYWxlczpcbiIKIAotIzogZXZhbC5jOjIyMDI2CiBtc2dpZCAiIgogIlxuIgogIlx0TGFzdCBzZXQgZnJvbSAiCkBAIC05NzQsMTA1ICs3NTUsODEgQEAKICJcbiIKICJcdFNlIGRlZmluacOzIHBvciDDumx0aW1hIHZleiBlbiAiCiAKLSM6IGV2YWwuYzoyMjA0NgogbXNnaWQgIk5vIG9sZCBmaWxlcyIKIG1zZ3N0ciAiTm8gaGF5IGFyY2hpdm9zIGFudGlndW9zIgogCi0jOiBleF9jbWRzLmM6MTAxCiAjLCBjLWZvcm1hdAogbXNnaWQgIjwlcz4lcyVzICAlZCwgIEhleCAlMDJ4LCAgT2N0YWwgJTAzbyIKIG1zZ3N0ciAiPCVzPiVzJXMgICVkLCAgSGV4ICUwMngsICBPY3RhbCAlMDNvIgogCi0jOiBleF9jbWRzLmM6MTI4CiAjLCBjLWZvcm1hdAogbXNnaWQgIj4gJWQsIEhleCAlMDR4LCBPY3RhbCAlbyIKIG1zZ3N0ciAiPiAlZCwgSGV4ICUwNHgsIE9jdGFsICVvIgogCi0jOiBleF9jbWRzLmM6MTI5CiAjLCBjLWZvcm1hdAogbXNnaWQgIj4gJWQsIEhleCAlMDh4LCBPY3RhbCAlbyIKIG1zZ3N0ciAiPiAlZCwgSGV4ICUwOHgsIE9jdGFsICVvIgogCi0jOiBleF9jbWRzLmM6NzM5CiBtc2dpZCAiRTEzNDogTW92ZSBsaW5lcyBpbnRvIHRoZW1zZWx2ZXMiCiBtc2dzdHIgIkUxMzQ6IE1vdmllbmRvIGzDrW5lYXMgc29icmUgc8OtIG1pc21hcyIKIAotIzogZXhfY21kcy5jOjgwOAogbXNnaWQgIjEgbGluZSBtb3ZlZCIKIG1zZ3N0ciAiMSBsw61uZWEgbW92aWRhIgogCi0jOiBleF9jbWRzLmM6ODEwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVsZCBsaW5lcyBtb3ZlZCIKIG1zZ3N0ciAiJWxkIGzDrW5lYXMgbW92aWRhcyIKIAotIzogZXhfY21kcy5jOjEzMDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJWxkIGxpbmVzIGZpbHRlcmVkIgogbXNnc3RyICIlbGQgbMOtbmVhcyBmaWx0cmFkYXMiCiAKLSM6IGV4X2NtZHMuYzoxMzI5CiBtc2dpZCAiRTEzNTogKkZpbHRlciogQXV0b2NvbW1hbmRzIG11c3Qgbm90IGNoYW5nZSBjdXJyZW50IGJ1ZmZlciIKIG1zZ3N0ciAiRTEzNTogKkZpbHRybyogTGFzIGF1dG8tw7NyZGVuZXMgbm8gZGViZW4gY2FtYmlhciBlbCBiw7pmZXIgZW4gdXNvIgogCi0jOiBleF9jbWRzLmM6MTQxNAogbXNnaWQgIltObyB3cml0ZSBzaW5jZSBsYXN0IGNoYW5nZV1cbiIKIG1zZ3N0ciAiW05vIHNlIGhhIGVzY3JpdG8gbmFkYSBhbCBkaXNjbyBkZXNkZSBlbCDDumx0aW1vIGNhbWJpb11cbiIKIAotIzogZXhfY21kcy5jOjE2NzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXN2aW1pbmZvOiAlcyBpbiBsaW5lOiAiCiBtc2dzdHIgIiVzdmltaW5mbzogJXMgZW4gbGEgbMOtbmVhOiAiCiAKLSM6IGV4X2NtZHMuYzoxNjgwCiBtc2dpZCAiRTEzNjogdmltaW5mbzogVG9vIG1hbnkgZXJyb3JzLCBza2lwcGluZyByZXN0IG9mIGZpbGUiCiBtc2dzdHIgIkUxMzY6IHZpbWluZm86IERlbWFzaWFkb3MgZXJyb3Jlcywgb21pdGllbmRvIGVsIHJlc3RvIGRlbCBhcmNoaXZvIgogCi0jOiBleF9jbWRzLmM6MTcwOQogIywgYy1mb3JtYXQKIG1zZ2lkICJSZWFkaW5nIHZpbWluZm8gZmlsZSBcIiVzXCIlcyVzJXMiCiBtc2dzdHIgIkxleWVuZG8gZWwgYXJjaGl2byBcInZpbWluZm9cIiBcIiVzXCIlcyVzJXMiCiAKLSM6IGV4X2NtZHMuYzoxNzExCiBtc2dpZCAiIGluZm8iCiBtc2dzdHIgIiBpbmZvIgogCi0jOiBleF9jbWRzLmM6MTcxMgogbXNnaWQgIiBtYXJrcyIKIG1zZ3N0ciAiIG1hcmNhcyIKIAotIzogZXhfY21kcy5jOjE3MTMKIG1zZ2lkICIgb2xkZmlsZXMiCiBtc2dzdHIgIiBhcmNoaXZvcyBhbnRpZ3VvcyIKIAotIzogZXhfY21kcy5jOjE3MTQKIG1zZ2lkICIgRkFJTEVEIgogbXNnc3RyICIgRkFMTMOTIgogCi0jLiBhdm9pZCBhIHdhaXRfcmV0dXJuIGZvciB0aGlzIG1lc3NhZ2UsIGl0J3MgYW5ub3lpbmcKLSM6IGV4X2NtZHMuYzoxODEwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkUxMzc6IFZpbWluZm8gZmlsZSBpcyBub3Qgd3JpdGFibGU6ICVzIgogbXNnc3RyICJFMTM3OiBObyBoYXkgcGVybWlzb3MgZGUgZXNjcml0dXJhIHBhcmEgZWwgYXJjaGl2byBcInZpbWluZm9cIjogJXMiCiAKLSM6IGV4X2NtZHMuYzoxOTYzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkUxMzg6IENhbid0IHdyaXRlIHZpbWluZm8gZmlsZSAlcyEiCiBtc2dzdHIgIkUxMzg6IMKhTm8gc2UgcHVkbyBlc2NyaWJpciBlbCBhcmNoaXZvIFwidmltaW5mb1wiICVzISIKIAotIzogZXhfY21kcy5jOjE5NzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiV3JpdGluZyB2aW1pbmZvIGZpbGUgXCIlc1wiIgogbXNnc3RyICJFc2NyaWJpZW5kbyBhcmNoaXZvIFwidmltaW5mb1wiIFwiJXNcIiIKIAogIyBXcml0ZSB0aGUgaW5mbzoKLSMuIFdyaXRlIHRoZSBpbmZvOgotIzogZXhfY21kcy5jOjIwODEKICMsIGMtZm9ybWF0CiBtc2dpZCAiIyBUaGlzIHZpbWluZm8gZmlsZSB3YXMgZ2VuZXJhdGVkIGJ5IFZpbSAlcy5cbiIKIG1zZ3N0ciAiIyBWaW0gJXMgZ2VuZXLDsyBlc3RlIGFyY2hpdm8gXCJ2aW1pbmZvXCIuXG4iCiAKLSM6IGV4X2NtZHMuYzoyMDgzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICIjIFlvdSBtYXkgZWRpdCBpdCBpZiB5b3UncmUgY2FyZWZ1bCFcbiIKQEAgLTEwODEsNTUgKzgzOCw0NCBAQAogIiMgUHVlZGUgZWRpdGFybG8sIMKhc8OzbG8gc2kgdGllbmUgY3VpZGFkbyFcbiIKICJcbiIKIAotIzogZXhfY21kcy5jOjIwODUKICMsIGMtZm9ybWF0CiBtc2dpZCAiIyBWYWx1ZSBvZiAnZW5jb2RpbmcnIHdoZW4gdGhpcyBmaWxlIHdhcyB3cml0dGVuXG4iCiBtc2dzdHIgIiMgVmFsb3IgZGUgJ2VuY29kaW5nJyBjdWFuZG8gc2UgZXNjcmliacOzIGVzdGUgYXJjaGl2b1xuIgogCi0jOiBleF9jbWRzLmM6MjE4NQogbXNnaWQgIklsbGVnYWwgc3RhcnRpbmcgY2hhciIKIG1zZ3N0ciAiQ2Fyw6FjdGVyIGRlIGNvbWllbnpvIGlsZWdhbCIKIAotIzogZXhfY21kcy5jOjI1NTEgZXhfY21kczIuYzoxNDA3CiBtc2dpZCAiU2F2ZSBBcyIKIG1zZ3N0ciAiR3VhcmRhciBjb21vIgogCi0jOiBleF9jbWRzLmM6MjYyOAogbXNnaWQgIldyaXRlIHBhcnRpYWwgZmlsZT8iCiBtc2dzdHIgIsK/RXNjcmliaXIgdW4gYXJjaGl2byBwYXJjaWFsPyIKIAotIzogZXhfY21kcy5jOjI2MzUKIG1zZ2lkICJFMTQwOiBVc2UgISB0byB3cml0ZSBwYXJ0aWFsIGJ1ZmZlciIKIG1zZ3N0ciAiRTE0MDogVXNlIFwiIVwiIHBhcmEgZXNjcmliaXIgdW4gYsO6ZmVyIHBhcmNpYWwiCiAKLSM6IGV4X2NtZHMuYzoyNzc3CiAjLCBjLWZvcm1hdAogbXNnaWQgIk92ZXJ3cml0ZSBleGlzdGluZyBmaWxlIFwiJXNcIj8iCiBtc2dzdHIgIsK/RXNjcmliaXIgc29icmUgZWwgYXJjaGl2byBleGlzdGVudGUgXCIlc1wiPyIKIAotIzogZXhfY21kcy5jOjI4MjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiU3dhcCBmaWxlIFwiJXNcIiBleGlzdHMsIG92ZXJ3cml0ZSBhbnl3YXk/IgogbXNnc3RyICJZYSBleGlzdGUgdW4gYXJjaGl2byBkZSBpbnRlcmNhbWJpbyBcIiVzXCIsIGRlc2VhIHNvYnJlZXNjcmliaXJsbz8gIgogCi0jOiBleF9jbWRzLmM6MjgzMwogIywgYy1mb3JtYXQKIG1zZ2lkICJFNzY4OiBTd2FwIGZpbGUgZXhpc3RzOiAlcyAoOnNpbGVudCEgb3ZlcnJpZGVzKSIKIG1zZ3N0ciAiIgogIkU3Njg6IEVsIGFyY2hpdm8gZGUgaW50ZXJjYW1iaW8geWEgZXhpc3RlOiAlcyAodXNlICEgcGFyYSBzb2JyZWVzY3JpYmlyKSIKIAotIzogZXhfY21kcy5jOjI5MDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTE0MTogTm8gZmlsZSBuYW1lIGZvciBidWZmZXIgJWxkIgogbXNnc3RyICJFMTQxOiBObyBleGlzdGUgdW4gbm9tYnJlIGRlIGFyY2hpdm8gcGFyYSBlbCBiw7pmZXIgJWxkIgogCi0jOiBleF9jbWRzLmM6Mjk0MAogbXNnaWQgIkUxNDI6IEZpbGUgbm90IHdyaXR0ZW46IFdyaXRpbmcgaXMgZGlzYWJsZWQgYnkgJ3dyaXRlJyBvcHRpb24iCiBtc2dzdHIgIiIKICJFMTQyOiBObyBzZSBoYSBlc2NyaXRvIGVsIGFyY2hpdm86IGVzY3JpdHVyYSBkZXNhY3RpdmFkYSBwb3IgIgogImxhIG9wY2nDs24gJ3dyaXRlJyIKIAotIzogZXhfY21kcy5jOjI5NzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIidyZWFkb25seScgb3B0aW9uIGlzIHNldCBmb3IgXCIlc1wiLlxuIgpAQCAtMTEzOCw3ICs4ODQsNiBAQAogIlNlIGhhIGFjdGl2YWRvIGxhIG9wY2nDs24gZGUgc29sbyBsZWN0dXJhICgncmVhZG9ubHknKSBwYXJhICVzLlxuIgogIsK/RGVzZWEgZXNjcmliaXIgZGUgdG9kYXMgZm9ybWFzPyIKIAotIzogZXhfY21kcy5jOjI5NzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkZpbGUgcGVybWlzc2lvbnMgb2YgXCIlc1wiIGFyZSByZWFkLW9ubHkuXG4iCkBAIC0xMTQ5LDgyICs4OTQsNjQgQEAKICJzw7NsbyBsZWN0dXJhLiBDYWJlIGxhIHBvc2liaWxpZGFkIGRlIGVzY3JpYmlyXG4iCiAiZW4gw6lsLiDCv0Rlc2VhIGludGVudGFybG8/IgogCi0jOiBleF9jbWRzLmM6Mjk5MAogIywgYy1mb3JtYXQKIG1zZ2lkICJFNTA1OiBcIiVzXCIgaXMgcmVhZC1vbmx5IChhZGQgISB0byBvdmVycmlkZSkiCiBtc2dzdHIgIkU1MDU6IFwiJXNcIiBlcyBkZSBzb2xvIGxlY3R1cmEgKGHDsWFkYSAhIHBhcmEgc29icmVlc2NyaWJpcikiCiAKLSM6IGV4X2NtZHMuYzozMTc3CiBtc2dpZCAiRWRpdCBGaWxlIgogbXNnc3RyICJFZGl0YXIgYXJjaGl2byIKIAotIzogZXhfY21kcy5jOjM4NDcKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTE0MzogQXV0b2NvbW1hbmRzIHVuZXhwZWN0ZWRseSBkZWxldGVkIG5ldyBidWZmZXIgJXMiCiBtc2dzdHIgIkUxNDM6IExhcyBhdXRvLcOzcmRlbmVzIGhhbiBlbGltaW5hZG8gYWwgbnVldm8gYsO6ZmVyICVzIgogCi0jOiBleF9jbWRzLmM6NDA2MwogbXNnaWQgIkUxNDQ6IG5vbi1udW1lcmljIGFyZ3VtZW50IHRvIDp6IgogbXNnc3RyICJFMTQ0OiBBcmd1bWVudG8gbm8gbnVtw6lyaWNvIHBhcmEgXCI6elwiIgogCi0jOiBleF9jbWRzLmM6NDE2MgogbXNnaWQgIkUxNDU6IFNoZWxsIGNvbW1hbmRzIG5vdCBhbGxvd2VkIGluIHJ2aW0iCiBtc2dzdHIgIkUxNDU6IE5vIHNlIHBlcm1pdGVuIMOzcmRlbmVzIGRlIGNvbnNvbGEgZW4gcnZpbSIKIAotIzogZXhfY21kcy5jOjQyNjEKIG1zZ2lkICJFMTQ2OiBSZWd1bGFyIGV4cHJlc3Npb25zIGNhbid0IGJlIGRlbGltaXRlZCBieSBsZXR0ZXJzIgogbXNnc3RyICJFMTQ2OiBMYXMgZXhwcmVzaW9uZXMgcmVndWxhcmVzIG5vIHNlIHB1ZWRlbiBkZWxpbWl0YXIgY29uIGxldHJhcyIKIAotIzogZXhfY21kcy5jOjQ3MjEKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVwbGFjZSB3aXRoICVzICh5L24vYS9xL2wvXkUvXlkpPyIKIG1zZ3N0ciAiwr9SZWVtcGxhemFyIGNvbiAlcyAoeS9uL2EvcS9sL15FL15ZKT8iCiAKLSM6IGV4X2NtZHMuYzo1MTY2CiBtc2dpZCAiKEludGVycnVwdGVkKSAiCiBtc2dzdHIgIihJbnRlcnJ1bXBpZG8pIgogCi0jOiBleF9jbWRzLmM6NTE3MQogbXNnaWQgIjEgbWF0Y2giCiBtc2dzdHIgIlVuYSAoMSkgY29pbmNpZGVuY2lhIgogCi0jOiBleF9jbWRzLmM6NTE3MQogbXNnaWQgIjEgc3Vic3RpdHV0aW9uIgogbXNnc3RyICJVbmEgKDEpIHN1c3RpdHVjacOzbiIKIAotIzogZXhfY21kcy5jOjUxNzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJWxkIG1hdGNoZXMiCiBtc2dzdHIgIiVsZCBjb2luY2lkZW5jaWFzIgogCi0jOiBleF9jbWRzLmM6NTE3NAogIywgYy1mb3JtYXQKIG1zZ2lkICIlbGQgc3Vic3RpdHV0aW9ucyIKIG1zZ3N0ciAiJWxkIHN1c3RpdHVjaW9uZXMiCiAKLSM6IGV4X2NtZHMuYzo1MTc5CiBtc2dpZCAiIG9uIDEgbGluZSIKIG1zZ3N0ciAiIGVuIHVuYSAoMSkgbMOtbmVhIgogCi0jOiBleF9jbWRzLmM6NTE4MgogIywgYy1mb3JtYXQKIG1zZ2lkICIgb24gJWxkIGxpbmVzIgogbXNnc3RyICIgZW4gJWxkIGzDrW5lYXMiCiAKLSM6IGV4X2NtZHMuYzo1MjI5CiBtc2dpZCAiRTE0NzogQ2Fubm90IGRvIDpnbG9iYWwgcmVjdXJzaXZlIgogbXNnc3RyICJFMTQ3OiBcIjpnbG9iYWxcIiBubyBwdWVkZSBzZXIgcmVjdXJzaXZvIgogCi0jOiBleF9jbWRzLmM6NTI2NAogbXNnaWQgIkUxNDg6IFJlZ3VsYXIgZXhwcmVzc2lvbiBtaXNzaW5nIGZyb20gZ2xvYmFsIgogbXNnc3RyICJFMTQ4OiBGYWx0YSB1bmEgZXhwcmVzacOzbiByZWd1bGFyIGVuIFwiOmdsb2JhbFwiIgogCi0jOiBleF9jbWRzLmM6NTMxMwogIywgYy1mb3JtYXQKIG1zZ2lkICJQYXR0ZXJuIGZvdW5kIGluIGV2ZXJ5IGxpbmU6ICVzIgogbXNnc3RyICJQYXRyw7NuIGVuY29udHJhZG8gZW4gY2FkYSBsw61uZWE6ICVzIgogCi0jOiBleF9jbWRzLmM6NTM5OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiXG4iCkBAIC0xMjM1LDM0NSArOTYyLDI3MCBAQAogIiMgw5psdGltYSBjYWRlbmEgZGUgc3VzdGl0dWNpw7NuOlxuIgogIiQiCiAKLSM6IGV4X2NtZHMuYzo1NTExCiBtc2dpZCAiRTQ3ODogRG9uJ3QgcGFuaWMhIgogbXNnc3RyICJFNDc4OiDCoU5vIGVudHJlIGVuIHDDoW5pY28hIgogCi0jOiBleF9jbWRzLmM6NTU1NwogIywgYy1mb3JtYXQKIG1zZ2lkICJFNjYxOiBTb3JyeSwgbm8gJyVzJyBoZWxwIGZvciAlcyIKIG1zZ3N0ciAiRTY2MTogTG8gc2llbnRvLCBubyBoYXkgYXl1ZGEgJyVzJyBwYXJhIFwiJXNcIiIKIAotIzogZXhfY21kcy5jOjU1NjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTE0OTogU29ycnksIG5vIGhlbHAgZm9yICVzIgogbXNnc3RyICJFMTQ5OiBMbyBzaWVudG8sIG5vIGhheSBheXVkYSBwYXJhIFwiJXNcIiIKIAotIzogZXhfY21kcy5jOjU2MDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiU29ycnksIGhlbHAgZmlsZSBcIiVzXCIgbm90IGZvdW5kIgogbXNnc3RyICJMbyBzaWVudG8sIG5vIGVuY3VlbnRybyBlbCBhcmNoaXZvIGRlIGF5dWRhIFwiJXNcIiIKIAotIzogZXhfY21kcy5jOjYxODAKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTE1MDogTm90IGEgZGlyZWN0b3J5OiAlcyIKIG1zZ3N0ciAiRTE1MDogTm8gZXMgdW4gZGlyZWN0b3JpbzogJXMiCiAKLSM6IGV4X2NtZHMuYzo2MzIzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkUxNTI6IENhbm5vdCBvcGVuICVzIGZvciB3cml0aW5nIgogbXNnc3RyICJFMTUyOiBObyBzZSBwdWRvIGFicmlyICVzIHBhcmEgZXNjcml0dXJhIgogCi0jOiBleF9jbWRzLmM6NjM2MAogIywgYy1mb3JtYXQKIG1zZ2lkICJFMTUzOiBVbmFibGUgdG8gb3BlbiAlcyBmb3IgcmVhZGluZyIKIG1zZ3N0ciAiRTE1MzogSW5jYXBheiBkZSBhYnJpciAlcyBwYXJhIGxlY3R1cmEiCiAKLSM6IGV4X2NtZHMuYzo2Mzk2CiAjLCBjLWZvcm1hdAogbXNnaWQgIkU2NzA6IE1peCBvZiBoZWxwIGZpbGUgZW5jb2RpbmdzIHdpdGhpbiBhIGxhbmd1YWdlOiAlcyIKIG1zZ3N0ciAiIgogIkU2NzA6IE1lemNsYSBkZSBjb2RpZmljYWNpb25lcyBlbiBhcmNoaXZvcyBkZSBheXVkYSBkZW50cm8gZGUgdW4gbGVuZ3VhamU6ICVzIgogCi0jOiBleF9jbWRzLmM6NjQ3NAogIywgYy1mb3JtYXQKIG1zZ2lkICJFMTU0OiBEdXBsaWNhdGUgdGFnIFwiJXNcIiBpbiBmaWxlICVzLyVzIgogbXNnc3RyICJFMTU0OiBFdGlxdWV0YSBcIiVzXCIgZHVwbGljYWRhIGVuIGVsIGFyY2hpdm8gJXMvJXMiCiAKLSM6IGV4X2NtZHMuYzo2NjEwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkUxNjA6IFVua25vd24gc2lnbiBjb21tYW5kOiAlcyIKIG1zZ3N0ciAiRTE2MDogT3JkZW4gZGUgc2lnbm8gZGVzY29ub2NpZGE6ICVzIgogCi0jOiBleF9jbWRzLmM6NjYyNwogbXNnaWQgIkUxNTY6IE1pc3Npbmcgc2lnbiBuYW1lIgogbXNnc3RyICJFMTU2OiBGYWx0YSBlbCBub21icmUgZGVsIHNpZ25vIgogCi0jOiBleF9jbWRzLmM6NjY3MwogbXNnaWQgIkU2MTI6IFRvbyBtYW55IHNpZ25zIGRlZmluZWQiCiBtc2dzdHIgIkU2MTI6IERlbWFzaWFkb3Mgc2lnbm9zIGRlZmluaWRvcyIKIAotIzogZXhfY21kcy5jOjY3NDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTIzOTogSW52YWxpZCBzaWduIHRleHQ6ICVzIgogbXNnc3RyICJFMjM5OiBFbCB0ZXh0byBkZSBzaWdubyBubyBlcyB2w6FsaWRvOiAlcyIKIAotIzogZXhfY21kcy5jOjY3NzIgZXhfY21kcy5jOjY5NDcKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTE1NTogVW5rbm93biBzaWduOiAlcyIKIG1zZ3N0ciAiRTE1NTogU2lnbm8gZGVzY29ub2NpZG86ICVzIgogCi0jOiBleF9jbWRzLmM6NjgwNQogbXNnaWQgIkUxNTk6IE1pc3Npbmcgc2lnbiBudW1iZXIiCiBtc2dzdHIgIkUxNTk6IEZhbHRhIGVsIG7Dum1lcm8gZGVsIHNpZ25vIgogCi0jOiBleF9jbWRzLmM6Njg4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJFMTU4OiBJbnZhbGlkIGJ1ZmZlciBuYW1lOiAlcyIKIG1zZ3N0ciAiRTE1ODogRWwgbm9tYnJlIGRlbCBiw7pmZXIgbm8gZXMgdsOhbGlkbzogJXMiCiAKLSM6IGV4X2NtZHMuYzo2OTI2CiAjLCBjLWZvcm1hdAogbXNnaWQgIkUxNTc6IEludmFsaWQgc2lnbiBJRDogJWxkIgogbXNnc3RyICJFMTU3OiBMYSBpZGVudGlmaWNhY2nDs24gZGVsIHNpZ25vIG5vIGVzIHbDoWxpZGE6ICVsZCIKIAotIzogZXhfY21kcy5jOjY5OTYKIG1zZ2lkICIgKE5PVCBGT1VORCkiCiBtc2dzdHIgIiAoTk8gRU5DT05UUkFETykiCiAKLSM6IGV4X2NtZHMuYzo2OTk4CiBtc2dpZCAiIChub3Qgc3VwcG9ydGVkKSIKIG1zZ3N0ciAiIChubyBoYXkgYXBveW8gcGFyYSBsYSBmdW5jacOzbiBwZWRpZGEpIgogCi0jOiBleF9jbWRzLmM6NzEyMgogbXNnaWQgIltEZWxldGVkXSIKIG1zZ3N0ciAiW1N1cHJpbWlkb10iCiAKLSM6IGV4X2NtZHMyLmM6MTM4CiBtc2dpZCAiRW50ZXJpbmcgRGVidWcgbW9kZS4gIFR5cGUgXCJjb250XCIgdG8gY29udGludWUuIgogbXNnc3RyICJJbmljaWFuZG8gbW9kbyBkZSBkZXB1cmFjacOzbi4gRXNjcmliYSBcImNvbnRcIiBwYXJhIGNvbnRpbnVhci4iCiAKLSM6IGV4X2NtZHMyLmM6MTQyIGV4X2RvY21kLmM6MTA4MQogIywgYy1mb3JtYXQKIG1zZ2lkICJsaW5lICVsZDogJXMiCiBtc2dzdHIgImzDrW5lYSAlbGQ6ICVzIgogCi0jOiBleF9jbWRzMi5jOjE0NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjbWQ6ICVzIgogbXNnc3RyICJjbWQ6ICVzIgogCi0jOiBleF9jbWRzMi5jOjM0NAogIywgYy1mb3JtYXQKIG1zZ2lkICJCcmVha3BvaW50IGluIFwiJXMlc1wiIGxpbmUgJWxkIgogbXNnc3RyICJcIkJyZWFrcG9pbnRcIiBlbiBcIiVzJXNcIiBsw61uZWEgJWxkIgogCi0jOiBleF9jbWRzMi5jOjY1NgogIywgYy1mb3JtYXQKIG1zZ2lkICJFMTYxOiBCcmVha3BvaW50IG5vdCBmb3VuZDogJXMiCiBtc2dzdHIgIkUxNjE6IE5vIHNlIGhhIGVuY29udHJhZG8gZWwgXCJicmVha3BvaW50XCI6ICVzIgogCi0jOiBleF9jbWRzMi5jOjY5MgogbXNnaWQgIk5vIGJyZWFrcG9pbnRzIGRlZmluZWQiCiBtc2dzdHIgIk5vIHNlIGhhbiBkZWZpbmlkbyBcImJyZWFrcG9pbnRzXCIiCiAKLSM6IGV4X2NtZHMyLmM6Njk3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiUzZCAgJXMgJXMgIGxpbmUgJWxkIgogbXNnc3RyICIlM2QgICVzICVzICBsw61uZWEgJWxkIgogCi0jOiBleF9jbWRzMi5jOjEwOTUKIG1zZ2lkICJFNzUwOiBGaXJzdCB1c2UgOnByb2ZpbGUgc3RhcnQgPGZuYW1lPiIKIG1zZ3N0ciAiRTc1MDogUHJpbWVybyB1c2UgXCI6cHJvZmlsZSBzdGFydCA8bm9tYnJlX2RlX2FyY2hpdm8+XCIiCiAKLSM6IGV4X2NtZHMyLmM6MTQzMgogIywgYy1mb3JtYXQKIG1zZ2lkICJTYXZlIGNoYW5nZXMgdG8gXCIlc1wiPyIKIG1zZ3N0ciAiwr9HdWFyZGFyIGxvcyBjYW1iaW9zIGVuIFwiJXNcIj8iCiAKLSM6IGV4X2NtZHMyLmM6MTQzNCBleF9kb2NtZC5jOjEwODE0CiBtc2dpZCAiVW50aXRsZWQiCiBtc2dzdHIgIlNpbiB0w610dWxvIgogCi0jOiBleF9jbWRzMi5jOjE1NjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTE2MjogTm8gd3JpdGUgc2luY2UgbGFzdCBjaGFuZ2UgZm9yIGJ1ZmZlciBcIiVzXCIiCiBtc2dzdHIgIkUxNjI6IE5vIHNlIGhhIGdyYWJhZG8gbmFkYSBkZXNkZSBlbCDDumx0aW1vIGNhbWJpbyBlbiBlbCBiw7pmZXIgXCIlc1wiIgogCi0jOiBleF9jbWRzMi5jOjE2MzQKIG1zZ2lkICJXYXJuaW5nOiBFbnRlcmVkIG90aGVyIGJ1ZmZlciB1bmV4cGVjdGVkbHkgKGNoZWNrIGF1dG9jb21tYW5kcykiCiBtc2dzdHIgIiIKICJBZHZlcnRlbmNpYTogc2UgaGEgZW50cmFkbyBlbiBvdHJvIGLDumZlciBkZSBmb3JtYSBpbmVzcGVyYWRhICh2ZXJpZmlxdWUgbGFzICIKICJhdXRvLcOzcmRlbmVzKSIKIAotIzogZXhfY21kczIuYzoyMDc4CiBtc2dpZCAiRTE2MzogVGhlcmUgaXMgb25seSBvbmUgZmlsZSB0byBlZGl0IgogbXNnc3RyICJFMTYzOiBIYXkgc8OzbG8gdW4gYXJjaGl2byBwYXJhIGVkaXRhciIKIAotIzogZXhfY21kczIuYzoyMDgwCiBtc2dpZCAiRTE2NDogQ2Fubm90IGdvIGJlZm9yZSBmaXJzdCBmaWxlIgogbXNnc3RyICJFMTY0OiBObyBzZSBwdWRvIHJlZ3Jlc2FyIGFudGVzIGRlbCBwcmltZXIgYXJjaGl2byIKIAotIzogZXhfY21kczIuYzoyMDgyCiBtc2dpZCAiRTE2NTogQ2Fubm90IGdvIGJleW9uZCBsYXN0IGZpbGUiCiBtc2dzdHIgIkUxNjU6IE5vIHNlIHB1ZG8gaXIgbcOhcyBhbGzDoSBkZWwgw7psdGltbyBhcmNoaXZvIgogCi0jOiBleF9jbWRzMi5jOjI1MTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTY2NjogY29tcGlsZXIgbm90IHN1cHBvcnRlZDogJXMiCiBtc2dzdHIgIkU2NjY6IEVsIGNvbXBpbGFkb3Igbm8gZXMgY29tcGF0aWJsZSBlbiBlc3RhIHZlcnNpw7NuOiAlcyIKIAotIzogZXhfY21kczIuYzoyNjEyCiAjLCBjLWZvcm1hdAogbXNnaWQgIlNlYXJjaGluZyBmb3IgXCIlc1wiIGluIFwiJXNcIiIKIG1zZ3N0ciAiQnVzY2FuZG8gXCIlc1wiIGVuIFwiJXNcIiIKIAotIzogZXhfY21kczIuYzoyNjM5CiAjLCBjLWZvcm1hdAogbXNnaWQgIlNlYXJjaGluZyBmb3IgXCIlc1wiIgogbXNnc3RyICJCdXNjYW5kbyBcIiVzXCIiCiAKLSM6IGV4X2NtZHMyLmM6MjY2NQogIywgYy1mb3JtYXQKIG1zZ2lkICJub3QgZm91bmQgaW4gJ3J1bnRpbWVwYXRoJzogXCIlc1wiIgogbXNnc3RyICJObyBzZSBoYSBlbmNvbnRyYWRvIGVuICdydW50aW1lcGF0aCc6ICVzIgogCi0jOiBleF9jbWRzMi5jOjI3MDAKIG1zZ2lkICJTb3VyY2UgVmltIHNjcmlwdCIKIG1zZ3N0ciAiRWplY3V0ZSBhcmNoaXZvIGRlIMOzcmRlbmVzIGRlIFZpbSIKIAotIzogZXhfY21kczIuYzoyODc1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNhbm5vdCBzb3VyY2UgYSBkaXJlY3Rvcnk6IFwiJXNcIiIKIG1zZ3N0ciAiTm8gc2UgcHVkbyBlamVjdXRhciB1biBkaXJlY3RvcmlvOiAlcyIKIAotIzogZXhfY21kczIuYzoyOTMyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBzb3VyY2UgXCIlc1wiIgogbXNnc3RyICJObyBwdWRlIGVqZWN1dGFyICVzIgogCi0jOiBleF9jbWRzMi5jOjI5MzQKICMsIGMtZm9ybWF0CiBtc2dpZCAibGluZSAlbGQ6IGNvdWxkIG5vdCBzb3VyY2UgXCIlc1wiIgogbXNnc3RyICJsw61uZWEgJWxkOiBubyBzZSBwdWRvIGVqZWN1dGFyICVzIgogCi0jOiBleF9jbWRzMi5jOjI5NTAKICMsIGMtZm9ybWF0CiBtc2dpZCAic291cmNpbmcgXCIlc1wiIgogbXNnc3RyICJlamVjdXRhbmRvICVzIgogCi0jOiBleF9jbWRzMi5jOjI5NTIKICMsIGMtZm9ybWF0CiBtc2dpZCAibGluZSAlbGQ6IHNvdXJjaW5nIFwiJXNcIiIKIG1zZ3N0ciAibMOtbmVhICVsZDogZWplY3V0YW5kbyAlcyIKIAotIzogZXhfY21kczIuYzozMTQzCiAjLCBjLWZvcm1hdAogbXNnaWQgImZpbmlzaGVkIHNvdXJjaW5nICVzIgogbXNnc3RyICJMYSBlamVjdWNpw7NuIGRlICVzIGhhIHRlcm1pbmFkbyIKIAotIzogZXhfY21kczIuYzozMjI0CiBtc2dpZCAibW9kZWxpbmUiCiBtc2dzdHIgIm1vZGVsaW5lIgogCi0jOiBleF9jbWRzMi5jOjMyMjYKIG1zZ2lkICItLWNtZCBhcmd1bWVudCIKIG1zZ3N0ciAiLS1jbWQgW2FyZ3VtZW50b3NdIgogCi0jOiBleF9jbWRzMi5jOjMyMjgKIG1zZ2lkICItYyBhcmd1bWVudCIKIG1zZ3N0ciAiLWMgW2FyZ3VtZW50b3NdIgogCi0jOiBleF9jbWRzMi5jOjMyMzAKIG1zZ2lkICJlbnZpcm9ubWVudCB2YXJpYWJsZSIKIG1zZ3N0ciAidmFyaWFibGUgZGUgZW50b3JubyIKIAotIzogZXhfY21kczIuYzozMjMyCiBtc2dpZCAiZXJyb3IgaGFuZGxlciIKIG1zZ3N0ciAiYWRtaW5pc3RyYWRvciBkZSBlcnJvcmVzIgogCi0jOiBleF9jbWRzMi5jOjM1MjQKIG1zZ2lkICJXMTU6IFdhcm5pbmc6IFdyb25nIGxpbmUgc2VwYXJhdG9yLCBeTSBtYXkgYmUgbWlzc2luZyIKIG1zZ3N0ciAiVzE1OiBBZHZlcnRlbmNpYTogc2VwYXJhZG9yIGRlIGzDrW5lYSBpbmNvcnJlY3RvLCBwdWVkZSBxdWUgZmFsdGUgXk0iCiAKLSM6IGV4X2NtZHMyLmM6MzY1NwogbXNnaWQgIkUxNjc6IDpzY3JpcHRlbmNvZGluZyB1c2VkIG91dHNpZGUgb2YgYSBzb3VyY2VkIGZpbGUiCiBtc2dzdHIgIiIKICJFMTY3OiBIYSB1c2FkbyBcIjpzY3JpcHRlbmNvZGluZ1wiIGZ1ZXJhIGRlIHVuIGFyY2hpdm8gZGUgaW5zdHJ1Y2Npb25lcyAiCiAiZWplY3V0YWJsZXMiCiAKLSM6IGV4X2NtZHMyLmM6MzY5MAogbXNnaWQgIkUxNjg6IDpmaW5pc2ggdXNlZCBvdXRzaWRlIG9mIGEgc291cmNlZCBmaWxlIgogbXNnc3RyICIiCiAiRTE2ODogSGEgdXNhZG8gXCI6ZmluaXNoXCIgZnVlcmEgZGUgdW4gYXJjaGl2byBkZSBpbnN0cnVjY2lvbmVzIGVqZWN1dGFibGVzIgogCi0jOiBleF9jbWRzMi5jOjQwMTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ3VycmVudCAlc2xhbmd1YWdlOiBcIiVzXCIiCiBtc2dzdHIgIklkaW9tYSBhY3R1YWwgJXM6IFwiJXNcIiIKIAotIzogZXhfY21kczIuYzo0MDI5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkUxOTc6IENhbm5vdCBzZXQgbGFuZ3VhZ2UgdG8gXCIlc1wiIgogbXNnc3RyICJFMTk3OiBObyBzZSBwdWRvIGVzdGFibGVjZXIgbGEgb3BjacOzbiBkZWwgaWRpb21hIGEgXCIlc1wiIgogCi0jOiBleF9kb2NtZC5jOjYyNgogbXNnaWQgIkVudGVyaW5nIEV4IG1vZGUuICBUeXBlIFwidmlzdWFsXCIgdG8gZ28gdG8gTm9ybWFsIG1vZGUuIgogbXNnc3RyICJFbnRyYW5kbyBhbCBtb2RvIEV4LiBFc2NyaWJhIFwidmlzdWFsXCIgcGFyYSBpciBhbCBtb2RvIE5vcm1hbCIKIAogIyBtdXN0IGJlIGF0IEVPRgotIzogZXhfZG9jbWQuYzo2ODEKIG1zZ2lkICJFNTAxOiBBdCBlbmQtb2YtZmlsZSIKIG1zZ3N0ciAiRTUwMTogRXN0b3kgYWwgZmluYWwgZGVsIGFyY2hpdm8iCiAKLSM6IGV4X2RvY21kLmM6NzgwCiBtc2dpZCAiRTE2OTogQ29tbWFuZCB0b28gcmVjdXJzaXZlIgogbXNnc3RyICJFMTY5OiBPcmRlbiBkZW1hc2lhZG8gcmVjdXJzaXZhIgogCi0jOiBleF9kb2NtZC5jOjEzNTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTYwNTogRXhjZXB0aW9uIG5vdCBjYXVnaHQ6ICVzIgogbXNnc3RyICJFNjA1OiBMYSBleGNlcGNpw7NuICVzIG5vIHNlIGF0cmFww7MiCiAKLSM6IGV4X2RvY21kLmM6MTQ0NwogbXNnaWQgIkVuZCBvZiBzb3VyY2VkIGZpbGUiCiBtc2dzdHIgIkZpbiBkZWwgYXJjaGl2byBkZSBpbnN0cnVjY2lvbmVzIGVqZWN1dGFibGVzIgogCi0jOiBleF9kb2NtZC5jOjE0NDgKIG1zZ2lkICJFbmQgb2YgZnVuY3Rpb24iCiBtc2dzdHIgIkZpbiBkZSBsYSBmdW5jacOzbiIKIAotIzogZXhfZG9jbWQuYzoyMDk2CiBtc2dpZCAiRTQ2NDogQW1iaWd1b3VzIHVzZSBvZiB1c2VyLWRlZmluZWQgY29tbWFuZCIKIG1zZ3N0ciAiRTQ2NDogVXNvIGFtYmlndW8gZGUgdW5hIG9yZGVuIGRlZmluaWRhIHBvciBlbCB1c3VhcmlvIgogCi0jOiBleF9kb2NtZC5jOjIxMTAKIG1zZ2lkICJFNDkyOiBOb3QgYW4gZWRpdG9yIGNvbW1hbmQiCiBtc2dzdHIgIkU0OTI6IE5vIGVzIHVuYSBvcmRlbiBkZWwgZWRpdG9yIgogCi0jOiBleF9kb2NtZC5jOjIyNDIKIG1zZ2lkICJFNDkzOiBCYWNrd2FyZHMgcmFuZ2UgZ2l2ZW4iCiBtc2dzdHIgIkU0OTM6IE1lIGhhIGRhZG8gdW4gcmFuZ28gaW52ZXJ0aWRvIgogCi0jOiBleF9kb2NtZC5jOjIyNDYKIG1zZ2lkICJCYWNrd2FyZHMgcmFuZ2UgZ2l2ZW4sIE9LIHRvIHN3YXAiCiBtc2dzdHIgIlNlIGRldm9sdmnDsyB1biByYW5nbyBpbnZlcnRpZG8sIMK/cHVlZG8gaW50ZXJjYW1iaWFybG8/IgogCi0jOiBleF9kb2NtZC5jOjIzMDkKIG1zZ2lkICJFNDk0OiBVc2UgdyBvciB3Pj4iCiBtc2dzdHIgIkU0OTQ6IFVzZSBcIndcIiBvIFwidz4+XCIiCiAKLSM6IGV4X2RvY21kLmM6NDA3NgogbXNnaWQgIkUzMTk6IFNvcnJ5LCB0aGUgY29tbWFuZCBpcyBub3QgYXZhaWxhYmxlIGluIHRoaXMgdmVyc2lvbiIKIG1zZ3N0ciAiRTMxOTogTG8gc2llbnRvLCBlc2Egb3JkZW4gbm8gZXN0w6EgZGlzcG9uaWJsZSBlbiBlc3RhIHZlcnNpw7NuIgogCi0jOiBleF9kb2NtZC5jOjQ0MjUKIG1zZ2lkICJFMTcyOiBPbmx5IG9uZSBmaWxlIG5hbWUgYWxsb3dlZCIKIG1zZ3N0ciAiRTE3MjogU29sbyBzZSBwZXJtaXRlIHVuIG5vbWJyZSBkZSBhcmNoaXZvIgogCi0jOiBleF9kb2NtZC5jOjUwMzYKIG1zZ2lkICIxIG1vcmUgZmlsZSB0byBlZGl0LiAgUXVpdCBhbnl3YXk/IgogbXNnc3RyICJVbiAoMSkgYXJjaGl2byBtw6FzIHBhcmEgZWRpdGFyLiDCv0NlcnJhciBkZSB0b2RhcyBmb3JtYXM/IgogCi0jOiBleF9kb2NtZC5jOjUwMzkKICMsIGMtZm9ybWF0CiBtc2dpZCAiJWQgbW9yZSBmaWxlcyB0byBlZGl0LiAgUXVpdCBhbnl3YXk/IgogbXNnc3RyICJIYXkgJWQgYXJjaGl2b3MgbcOhcyBlbiBlZGljacOzbi4gwr9DZXJyYXIgZGUgdG9kYXMgZm9ybWFzPyIKIAotIzogZXhfZG9jbWQuYzo1MDQ2CiBtc2dpZCAiRTE3MzogMSBtb3JlIGZpbGUgdG8gZWRpdCIKIG1zZ3N0ciAiRTE3MzogVW4gKDEpIGFyY2hpdm8gbcOhcyBwYXJhIGVkaXRhciIKIAotIzogZXhfZG9jbWQuYzo1MDQ4CiAjLCBjLWZvcm1hdAogbXNnaWQgIkUxNzM6ICVsZCBtb3JlIGZpbGVzIHRvIGVkaXQiCiBtc2dzdHIgIkUxNzM6IEhheSAlbGQgYXJjaGl2b3MgZW4gZWRpY2nDs24iCiAKLSM6IGV4X2RvY21kLmM6NTE0MgogbXNnaWQgIkUxNzQ6IENvbW1hbmQgYWxyZWFkeSBleGlzdHM6IGFkZCAhIHRvIHJlcGxhY2UgaXQiCiBtc2dzdHIgIkUxNzQ6IFlhIGV4aXN0ZSBlc2Egb3JkZW4uIEHDsWFkYSBcIiFcIiBwYXJhIHJlZW1wbGF6YXJsYSIKIAotIzogZXhfZG9jbWQuYzo1MjY0CiBtc2dpZCAiIgogIlxuIgogIiAgICBOYW1lICAgICAgICBBcmdzIFJhbmdlIENvbXBsZXRlICBEZWZpbml0aW9uIgpAQCAtMTU4MSwzODkgKzEyMzMsMjk4IEBACiAiXG4iCiAiICAgIE5vbWJyZSAgICAgIEFyZ3MgUmFuZ28gQ29tcGxldGFyICBEZWZpbmljacOzbiIKIAotIzogZXhfZG9jbWQuYzo1MzU3CiBtc2dpZCAiTm8gdXNlci1kZWZpbmVkIGNvbW1hbmRzIGZvdW5kIgogbXNnc3RyICJObyBzZSBoYW4gZW5jb250cmFkbyDDs3JkZW5lcyBkZWZpbmlkb3MgcG9yIGVsIHVzdWFyaW8iCiAKLSM6IGV4X2RvY21kLmM6NTM4OQogbXNnaWQgIkUxNzU6IE5vIGF0dHJpYnV0ZSBzcGVjaWZpZWQiCiBtc2dzdHIgIkUxNzU6IE5vIHNlIGhhIGVzcGVjaWZpY2FkbyBlbCBhdHJpYnV0byIKIAotIzogZXhfZG9jbWQuYzo1NDQxCiBtc2dpZCAiRTE3NjogSW52YWxpZCBudW1iZXIgb2YgYXJndW1lbnRzIgogbXNnc3RyICJFMTc2OiBFbCBuw7ptZXJvIGRlIGFyZ3VtZW50b3Mgbm8gZXMgdsOhbGlkbyIKIAotIzogZXhfZG9jbWQuYzo1NDU2CiBtc2dpZCAiRTE3NzogQ291bnQgY2Fubm90IGJlIHNwZWNpZmllZCB0d2ljZSIKIG1zZ3N0ciAiRTE3NzogRWwgcmVjdWVudG8gbm8gc2UgcHVlZGUgZXNwZWNpZmljYXIgZG9zIHZlY2VzIgogCi0jOiBleF9kb2NtZC5jOjU0NjYKIG1zZ2lkICJFMTc4OiBJbnZhbGlkIGRlZmF1bHQgdmFsdWUgZm9yIGNvdW50IgogbXNnc3RyICJFMTc4OiBFbCB2YWxvciBwcmVkZXRlcm1pbmFkbyBwYXJhIGVsIHJlY3VlbnRvIG5vIGVzIHbDoWxpZG8iCiAKLSM6IGV4X2RvY21kLmM6NTQ5NAogbXNnaWQgIkUxNzk6IGFyZ3VtZW50IHJlcXVpcmVkIGZvciAtY29tcGxldGUiCiBtc2dzdHIgIkUxNzk6IHNlIG5lY2VzaXRhIHVuIGFyZ3VtZW50byBwYXJhIFwiLWNvbXBsZXRlXCIiCiAKLSM6IGV4X2RvY21kLmM6NTUwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJFMTgxOiBJbnZhbGlkIGF0dHJpYnV0ZTogJXMiCiBtc2dzdHIgIkUxODE6IEVsIGF0cmlidXRvIG5vIGVzIHbDoWxpZG86ICVzIgogCi0jOiBleF9kb2NtZC5jOjU1NTIKIG1zZ2lkICJFMTgyOiBJbnZhbGlkIGNvbW1hbmQgbmFtZSIKIG1zZ3N0ciAiRTE4MjogRWwgbm9tYnJlIGRlIGxhIG9yZGVuIG5vIGVzIHbDoWxpZG8iCiAKLSM6IGV4X2RvY21kLmM6NTU2NwogbXNnaWQgIkUxODM6IFVzZXIgZGVmaW5lZCBjb21tYW5kcyBtdXN0IHN0YXJ0IHdpdGggYW4gdXBwZXJjYXNlIGxldHRlciIKIG1zZ3N0ciAiIgogIkUxODM6IExhcyDDs3JkZW5lcyBkZWZpbmlkYXMgcG9yIGVsIHVzdWFyaW8gZGViZW4gY29tZW56YXIgY29uIG1hecO6c2N1bGEiCiAKLSM6IGV4X2RvY21kLmM6NTYzNQogIywgYy1mb3JtYXQKIG1zZ2lkICJFMTg0OiBObyBzdWNoIHVzZXItZGVmaW5lZCBjb21tYW5kOiAlcyIKIG1zZ3N0ciAiRTE4NDogTm8gZXhpc3RlIGVzYSBvcmRlbiBkZWZpbmlkYSBwb3IgZWwgdXN1YXJpbzogJXMiCiAKLSM6IGV4X2RvY21kLmM6NjE4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJFMTgwOiBJbnZhbGlkIGNvbXBsZXRlIHZhbHVlOiAlcyIKIG1zZ3N0ciAiRTE4MDogRWwgdmFsb3IgcGFyYSBjb21wbGV0YXIgbm8gZXMgdsOhbGlkbzogJXMiCiAKLSM6IGV4X2RvY21kLmM6NjE5OAogbXNnaWQgIkU0Njg6IENvbXBsZXRpb24gYXJndW1lbnQgb25seSBhbGxvd2VkIGZvciBjdXN0b20gY29tcGxldGlvbiIKIG1zZ3N0ciAiIgogIkU0Njg6IEVsIGFyZ3VtZW50byBkZSBmaW5hbGl6YWNpw7NuIHNvbG8gc2UgcGVybWl0ZSBlbiBmaW5hbGl6YWNpb25lcyAiCiAiZGVmaW5pZGFzIHBvciBlbCB1c3VhcmlvIgogCi0jOiBleF9kb2NtZC5jOjYyMDYKIG1zZ2lkICJFNDY3OiBDdXN0b20gY29tcGxldGlvbiByZXF1aXJlcyBhIGZ1bmN0aW9uIGFyZ3VtZW50IgogbXNnc3RyICIiCiAiRTQ2NzogTGFzIGZpbmFsaXphY2lvbmVzIGRlZmluaWRhcyBwb3IgZWwgdXN1YXJpbyByZXF1aWVyZW4gZGUgdW4gYXJndW1lbnRvICIKICJkZSBmdW5jacOzbiIKIAotIzogZXhfZG9jbWQuYzo2MjIyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkUxODU6IENhbm5vdCBmaW5kIGNvbG9yIHNjaGVtZSAlcyIKIG1zZ3N0ciAiRTE4NTogTm8gc2UgcHVkbyBlbmNvbnRyYXIgZWwgZXNxdWVtYSBkZSBjb2xvcmVzICVzIgogCi0jOiBleF9kb2NtZC5jOjYyMzAKIG1zZ2lkICJHcmVldGluZ3MsIFZpbSB1c2VyISIKIG1zZ3N0ciAiwqFTYWx1ZG9zLCB1c3VhcmlvIGRlIFZpbSEiCiAKLSM6IGV4X2RvY21kLmM6NjQ0OAogbXNnaWQgIkU3ODQ6IENhbm5vdCBjbG9zZSBsYXN0IHRhYiBwYWdlIgogbXNnc3RyICJFNzg0OiBObyBzZSBwdWRvIGNlcnJhciBsYSDDumx0aW1hIHZlbnRhbmEiCiAKLSM6IGV4X2RvY21kLmM6NjQ5MAogbXNnaWQgIkFscmVhZHkgb25seSBvbmUgdGFiIHBhZ2UiCiBtc2dzdHIgIlNvbG8gaGF5IHVuYSB2ZW50YW5hIgogCi0jOiBleF9kb2NtZC5jOjcxNzcKIG1zZ2lkICJFZGl0IEZpbGUgaW4gbmV3IHdpbmRvdyIKIG1zZ3N0ciAiRWRpdGFyIGFyY2hpdm8gZW4gdW5hIHZlbnRhbmEgbnVldmEiCiAKLSM6IGV4X2RvY21kLmM6NzMwMwogIywgYy1mb3JtYXQKIG1zZ2lkICJUYWIgcGFnZSAlZCIKIG1zZ3N0ciAiUMOhZ2luYSAlZCIKIAotIzogZXhfZG9jbWQuYzo3Njk1CiBtc2dpZCAiTm8gc3dhcCBmaWxlIgogbXNnc3RyICJObyBoYXkgYXJjaGl2byBkZSBpbnRlcmNhbWJpbyIKIAotIzogZXhfZG9jbWQuYzo3ODAwCiBtc2dpZCAiQXBwZW5kIEZpbGUiCiBtc2dzdHIgIkHDsWFkaXIgYXJjaGl2byIKIAotIzogZXhfZG9jbWQuYzo3ODk5CiBtc2dpZCAiRTc0NzogQ2Fubm90IGNoYW5nZSBkaXJlY3RvcnksIGJ1ZmZlciBpcyBtb2RpZmllZCAoYWRkICEgdG8gb3ZlcnJpZGUpIgogbXNnc3RyICIiCiAiRTc0NzogTm8gc2UgcHVkbyBjYW1iaWFyIGRlIGRpcmVjdG9yaW8sIGVsIGLDumZlciBmdWUgbW9kaWZpY2FkbyAoYcOxYWRhICEgIgogInBhcmEgZm9yemFyIGxhIG9yZGVuKSIKIAotIzogZXhfZG9jbWQuYzo3OTA4CiBtc2dpZCAiRTE4NjogTm8gcHJldmlvdXMgZGlyZWN0b3J5IgogbXNnc3RyICJFMTg2OiBObyBoYXkgdW4gZGlyZWN0b3JpbyBwcmV2aW8iCiAKLSM6IGV4X2RvY21kLmM6Nzk4OQogbXNnaWQgIkUxODc6IFVua25vd24iCiBtc2dzdHIgIkUxODc6IERlc2Nvbm9jaWRvIgogCi0jOiBleF9kb2NtZC5jOjgwODQKIG1zZ2lkICJFNDY1OiA6d2luc2l6ZSByZXF1aXJlcyB0d28gbnVtYmVyIGFyZ3VtZW50cyIKIG1zZ3N0ciAiRTQ2NTogXCI6d2luc2l6ZVwiIHJlcXVpZXJlIGRlIGRvcyBhcmd1bWVudG9zIG51bcOpcmljb3MiCiAKLSM6IGV4X2RvY21kLmM6ODE0NgogIywgYy1mb3JtYXQKIG1zZ2lkICJXaW5kb3cgcG9zaXRpb246IFggJWQsIFkgJWQiCiBtc2dzdHIgIlBvc2ljacOzbiBkZSBsYSB2ZW50YW5hOiBYICVkLCBZICVkIgogCi0jOiBleF9kb2NtZC5jOjgxNTEKIG1zZ2lkICJFMTg4OiBPYnRhaW5pbmcgd2luZG93IHBvc2l0aW9uIG5vdCBpbXBsZW1lbnRlZCBmb3IgdGhpcyBwbGF0Zm9ybSIKIG1zZ3N0ciAiIgogIkUxODg6IE9idGVuZXIgbGEgcG9zaWNpw7NuIGRlIGxhIHZlbnRhbmEgbm8gZXN0w6EgaW1wbGVtZW50YWRvIGVuIGVzdGEgIgogInBsYXRhZm9ybWEiCiAKLSM6IGV4X2RvY21kLmM6ODE2MQogbXNnaWQgIkU0NjY6IDp3aW5wb3MgcmVxdWlyZXMgdHdvIG51bWJlciBhcmd1bWVudHMiCiBtc2dzdHIgIkU0NjY6IFwiOndpbnBvc1wiIHJlcXVpZXJlIGRlIGRvcyBhcmd1bWVudG9zIG51bcOpcmljb3MiCiAKLSM6IGV4X2RvY21kLmM6ODQ5OQogbXNnaWQgIlNhdmUgUmVkaXJlY3Rpb24iCiBtc2dzdHIgIkd1YXJkYXIgcmVkaXJlY2Npw7NuIgogCi0jOiBleF9kb2NtZC5jOjg3MzAKIG1zZ2lkICJTYXZlIFZpZXciCiBtc2dzdHIgIkd1YXJkYXIgdmlzdGEiCiAKLSM6IGV4X2RvY21kLmM6ODczMQogbXNnaWQgIlNhdmUgU2Vzc2lvbiIKIG1zZ3N0ciAiR3VhcmRhciBzZXNpw7NuIgogCi0jOiBleF9kb2NtZC5jOjg3MzMKIG1zZ2lkICJTYXZlIFNldHVwIgogbXNnc3RyICJHdWFyZGFyIGNvbmZpZ3VyYWNpw7NuIgogCi0jOiBleF9kb2NtZC5jOjg4ODkKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTczOTogQ2Fubm90IGNyZWF0ZSBkaXJlY3Rvcnk6ICVzIgogbXNnc3RyICJFNzM5OiBObyBzZSBwdWRvIGNyZWFyIGRpcmVjdG9yaW86ICVzIgogCi0jOiBleF9kb2NtZC5jOjg5MTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTE4OTogXCIlc1wiIGV4aXN0cyAoYWRkICEgdG8gb3ZlcnJpZGUpIgogbXNnc3RyICJFMTg5OiBcIiVzXCIgeWEgZXhpc3RlIChhw7FhZGEgISBwYXJhIHNvYnJlZXNjcmliaXIuKSIKIAotIzogZXhfZG9jbWQuYzo4OTIzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkUxOTA6IENhbm5vdCBvcGVuIFwiJXNcIiBmb3Igd3JpdGluZyIKIG1zZ3N0ciAiRTE5MDogTm8gc2UgcHVkbyBhYnJpciBcIiVzXCIgcGFyYSBlc2NyYmlyIgogCiAjIHNldCBtYXJrCi0jLiBzZXQgbWFyawotIzogZXhfZG9jbWQuYzo4OTQ3CiBtc2dpZCAiRTE5MTogQXJndW1lbnQgbXVzdCBiZSBhIGxldHRlciBvciBmb3J3YXJkL2JhY2t3YXJkIHF1b3RlIgogbXNnc3RyICIiCiAiRTE5MTogRWwgYXJndW1lbnRvIGRlYmUgc2VyIHVuYSBsZXRyYSBvIHVuYSBjb21pbGxhIHNpbXBsZS9jb21pbGxhIHNpbXBsZSAiCiAiaW52ZXJ0aWRhIgogCi0jOiBleF9kb2NtZC5jOjg5OTQKIG1zZ2lkICJFMTkyOiBSZWN1cnNpdmUgdXNlIG9mIDpub3JtYWwgdG9vIGRlZXAiCiBtc2dzdHIgIkUxOTI6IEV4Y2VzaXZvIHVzbyByZWN1cnNpdm8gZGUgXCI6bm9ybWFsXCIiCiAKLSM6IGV4X2RvY21kLmM6OTU5MwogbXNnaWQgIkU4MDk6ICM8IGlzIG5vdCBhdmFpbGFibGUgd2l0aG91dCB0aGUgK2V2YWwgZmVhdHVyZSIKIG1zZ3N0ciAiRTgwOTogIzwgbm8gZXN0w6EgZGlzcG9uaWJsZSBzaW4gbGEgY2FyYWN0ZXLDrXN0aWNhIFwiK2V2YWxcIiIKIAotIzogZXhfZG9jbWQuYzo5NjAyCiBtc2dpZCAiRTE5NDogTm8gYWx0ZXJuYXRlIGZpbGUgbmFtZSB0byBzdWJzdGl0dXRlIGZvciAnIyciCiBtc2dzdHIgIkUxOTQ6IE5vIGhheSB1biBub21icmUgZGUgYXJjaGl2byBhbHRlcm5vIHF1ZSBzdXN0aXR1eWEgYSAnIyciCiAKLSM6IGV4X2RvY21kLmM6OTY0MwogbXNnaWQgIkU0OTU6IG5vIGF1dG9jb21tYW5kIGZpbGUgbmFtZSB0byBzdWJzdGl0dXRlIGZvciBcIjxhZmlsZT5cIiIKIG1zZ3N0ciAiIgogIkU0OTU6IE5vIHNlIGhhIGRhZG8gdW4gbm9tYnJlIGRlIGFyY2hpdm8gZGUgYXV0by3Ds3JkZW5lcyBwYXJhIHN1c3RpdHVpciBhICAiCiAiXCI8YWZpbGU+XCIiCiAKLSM6IGV4X2RvY21kLmM6OTY1MgogbXNnaWQgIkU0OTY6IG5vIGF1dG9jb21tYW5kIGJ1ZmZlciBudW1iZXIgdG8gc3Vic3RpdHV0ZSBmb3IgXCI8YWJ1Zj5cIiIKIG1zZ3N0ciAiRTQ5NjogTm8gZXhpc3RlIHVuIGLDumZlciBkZSBhdXRvLcOzcmRlbmVzIHBhcmEgc3VzdGl0dWlyIHBvciBcIjxhYnVmPlwiIgogCi0jOiBleF9kb2NtZC5jOjk2NjMKIG1zZ2lkICJFNDk3OiBubyBhdXRvY29tbWFuZCBtYXRjaCBuYW1lIHRvIHN1YnN0aXR1dGUgZm9yIFwiPGFtYXRjaD5cIiIKIG1zZ3N0ciAiIgogIkU0OTc6IE5pbmfDum4gbm9tYnJlIGRlIGF1dG8tb3JkZW4gY29uY3VlcmRhIHBhcmEgc3VzdGl0dWlyIFwiPGFtYXRjaD5cIiIKIAotIzogZXhfZG9jbWQuYzo5NjczCiBtc2dpZCAiRTQ5ODogbm8gOnNvdXJjZSBmaWxlIG5hbWUgdG8gc3Vic3RpdHV0ZSBmb3IgXCI8c2ZpbGU+XCIiCiBtc2dzdHIgIiIKICJFNDk4OiBObyBoYXkgdW4gbm9tYnJlIGRlIGFyY2hpdm8gXCI6c291cmNlXCIgcXVlIHN1c3RpdHV5YSBhIFwiPHNmaWxlPlwiIgogCi0jOiBleF9kb2NtZC5jOjk3MTUKICMsIG5vLWMtZm9ybWF0CiBtc2dpZCAiRTQ5OTogRW1wdHkgZmlsZSBuYW1lIGZvciAnJScgb3IgJyMnLCBvbmx5IHdvcmtzIHdpdGggXCI6cDpoXCIiCiBtc2dzdHIgIiIKICJFNDk5OiBVbiBub21icmUgZGUgYXJjaGl2byB2YWPDrW8gcGFyYSBcIiVcIiBvIFwiI1wiIHNvbG8gZnVuY2lvbmEgY29uIFwiOnA6aCIKICJcIiIKIAotIzogZXhfZG9jbWQuYzo5NzE3CiBtc2dpZCAiRTUwMDogRXZhbHVhdGVzIHRvIGFuIGVtcHR5IHN0cmluZyIKIG1zZ3N0ciAiRTUwMDogTGEgZXhwcmVzacOzbiBldmFsw7phIGEgdW5hIGNhZGVuYSB2YWPDrWEiCiAKLSM6IGV4X2RvY21kLmM6MTA3OTQKIG1zZ2lkICJFMTk1OiBDYW5ub3Qgb3BlbiB2aW1pbmZvIGZpbGUgZm9yIHJlYWRpbmciCiBtc2dzdHIgIkUxOTU6IE5vIHNlIHB1ZG8gYWJyaXIgZWwgYXJjaGl2byBcInZpbWluZm9cIiBwYXJhIGxlY3R1cmEiCiAKLSM6IGV4X2RvY21kLmM6MTA5NjQKIG1zZ2lkICJFMTk2OiBObyBkaWdyYXBocyBpbiB0aGlzIHZlcnNpb24iCiBtc2dzdHIgIkUxOTY6IE5vIGhheSBkw61ncmFmb3MgZW4gZXN0YSB2ZXJzacOzbiIKIAotIzogZXhfZXZhbC5jOjQ0MQogbXNnaWQgIkU2MDg6IENhbm5vdCA6dGhyb3cgZXhjZXB0aW9ucyB3aXRoICdWaW0nIHByZWZpeCIKIG1zZ3N0ciAiIgogIkU2MDg6IE5vIHNlIHB1ZG8gbGFuemFyICgnOnRocm93JykgZXhjZXBjaW9uZXMgc2kgdGllbmVuIGVsIHByZWZpam8gJ1ZpbSciCiAKICMgYWx3YXlzIHNjcm9sbCB1cCwgZG9uJ3Qgb3ZlcndyaXRlCi0jLiBhbHdheXMgc2Nyb2xsIHVwLCBkb24ndCBvdmVyd3JpdGUKLSM6IGV4X2V2YWwuYzo1MzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiRXhjZXB0aW9uIHRocm93bjogJXMiCiBtc2dzdHIgIkV4Y2VwY2nDs24gbGFuemFkYTogJXMiCiAKLSM6IGV4X2V2YWwuYzo1ODgKICMsIGMtZm9ybWF0CiBtc2dpZCAiRXhjZXB0aW9uIGZpbmlzaGVkOiAlcyIKIG1zZ3N0ciAiRXhjZXBjacOzbiB0ZXJtaW5hZGE6ICVzIgogCi0jOiBleF9ldmFsLmM6NTg5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkV4Y2VwdGlvbiBkaXNjYXJkZWQ6ICVzIgogbXNnc3RyICJFeGNlcGNpw7NuIGRlc2NhcnRhZGE6ICVzIgogCi0jOiBleF9ldmFsLmM6NjM1IGV4X2V2YWwuYzo2ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMsIGxpbmUgJWxkIgogbXNnc3RyICIlcywgZW4gbGEgbMOtbmVhICVsZCIKIAogIyBhbHdheXMgc2Nyb2xsIHVwLCBkb24ndCBvdmVyd3JpdGUKLSMuIGFsd2F5cyBzY3JvbGwgdXAsIGRvbid0IG92ZXJ3cml0ZQotIzogZXhfZXZhbC5jOjY1NwogIywgYy1mb3JtYXQKIG1zZ2lkICJFeGNlcHRpb24gY2F1Z2h0OiAlcyIKIG1zZ3N0ciAiRXhjZXBjacOzbiBhdHJhcGFkYTogJXMiCiAKLSM6IGV4X2V2YWwuYzo3MzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgbWFkZSBwZW5kaW5nIgogbXNnc3RyICIlcyBoYSBwYXNhZG8gYSBsYSBsaXN0YSBkZSBwZW5kaWVudGVzIgogCi0jOiBleF9ldmFsLmM6NzQwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIHJlc3VtZWQiCiBtc2dzdHIgIiVzIGNvbnRpbnVhZG8iCiAKLSM6IGV4X2V2YWwuYzo3NDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgZGlzY2FyZGVkIgogbXNnc3RyICIlcyBkZXNjYXJ0YWRvIgogCi0jOiBleF9ldmFsLmM6NzcxCiBtc2dpZCAiRXhjZXB0aW9uIgogbXNnc3RyICJFeGNlcGNpw7NuIgogCi0jOiBleF9ldmFsLmM6Nzc3CiBtc2dpZCAiRXJyb3IgYW5kIGludGVycnVwdCIKIG1zZ3N0ciAiRXJyb3IgZSBpbnRlcnJ1cGNpw7NuIgogCi0jOiBleF9ldmFsLmM6Nzc5IGd1aS5jOjQ4NzAgZ3VpX3htZGxnLmM6Njg5IGd1aV94bWRsZy5jOjgwOCBvc19tc3dpbi5jOjU5NwogbXNnaWQgIkVycm9yIgogbXNnc3RyICJFcnJvciIKIAogIyBpZiAocGVuZGluZyAmIENTVFBfSU5URVJSVVBUKQotIy4gaWYgKHBlbmRpbmcgJiBDU1RQX0lOVEVSUlVQVCkKLSM6IGV4X2V2YWwuYzo3ODEKIG1zZ2lkICJJbnRlcnJ1cHQiCiBtc2dzdHIgIkludGVycnVwY2nDs24iCiAKLSM6IGV4X2V2YWwuYzo4NzMKIG1zZ2lkICJFNTc5OiA6aWYgbmVzdGluZyB0b28gZGVlcCIKIG1zZ3N0ciAiRTU3OTogwqFcIjppZlwiIGFuaWRhZG8gZW4gZXhjZXNvISIKIAotIzogZXhfZXZhbC5jOjkxMAogbXNnaWQgIkU1ODA6IDplbmRpZiB3aXRob3V0IDppZiIKIG1zZ3N0ciAiRTU4MDogwqFcIjplbmRpZlwiIHNpbiB1biBcIjppZlwiISIKIAotIzogZXhfZXZhbC5jOjk1NQogbXNnaWQgIkU1ODE6IDplbHNlIHdpdGhvdXQgOmlmIgogbXNnc3RyICJFNTgxOiDCoVwiOmVsc2VcIiBzaW4gdW4gXCI6aWZcIiEiCiAKLSM6IGV4X2V2YWwuYzo5NTgKIG1zZ2lkICJFNTgyOiA6ZWxzZWlmIHdpdGhvdXQgOmlmIgogbXNnc3RyICJFNTgyOiDCoVwiOmVsc2VpZlwiIHNpbiB1biBcIjppZlwiISIKIAotIzogZXhfZXZhbC5jOjk2NQogbXNnaWQgIkU1ODM6IG11bHRpcGxlIDplbHNlIgogbXNnc3RyICJFNTgzOiDCoVwiOmVsc2VcIiBtw7psdGlwbGUhIgogCi0jOiBleF9ldmFsLmM6OTY4CiBtc2dpZCAiRTU4NDogOmVsc2VpZiBhZnRlciA6ZWxzZSIKIG1zZ3N0ciAiRTU4NDogwqFcIjplbHNlaWZcIiBkZXNwdcOpcyBkZSBcIjplbHNlXCIhIgogCi0jOiBleF9ldmFsLmM6MTAzNQogbXNnaWQgIkU1ODU6IDp3aGlsZS86Zm9yIG5lc3RpbmcgdG9vIGRlZXAiCiBtc2dzdHIgIkU1ODU6IMKhXCI6d2hpbGVcIiBhbmlkYWRvIGVuIGV4Y2VzbyEiCiAKLSM6IGV4X2V2YWwuYzoxMTMzCiBtc2dpZCAiRTU4NjogOmNvbnRpbnVlIHdpdGhvdXQgOndoaWxlIG9yIDpmb3IiCiBtc2dzdHIgIkU1ODY6IMKhXCI6Y29udGludWVcIiBzaW4gdW4gXCI6d2hpbGVcIiBvIFwiOmZvclwiISIKIAotIzogZXhfZXZhbC5jOjExNzIKIG1zZ2lkICJFNTg3OiA6YnJlYWsgd2l0aG91dCA6d2hpbGUgb3IgOmZvciIKIG1zZ3N0ciAiRTU4NzogwqFcIjpicmVha1wiIHNpbiBcIjp3aGlsZVwiIG8gXCI6Zm9yXCIhIgogCi0jOiBleF9ldmFsLmM6MTIyMgogbXNnaWQgIkU3MzI6IFVzaW5nIDplbmRmb3Igd2l0aCA6d2hpbGUiCiBtc2dzdHIgIkU3MzI6IFVzYW5kbyBcIjplbmRmb3JcIiBjb24gXCI6d2hpbGVcIiIKIAotIzogZXhfZXZhbC5jOjEyMjQKIG1zZ2lkICJFNzMzOiBVc2luZyA6ZW5kd2hpbGUgd2l0aCA6Zm9yIgogbXNnc3RyICJFNzMzOiBVc2FuZG8gXCI6ZW5kd2hpbGVcIiBjb24gXCI6Zm9yXCIiCiAKLSM6IGV4X2V2YWwuYzoxMzk5CiBtc2dpZCAiRTYwMTogOnRyeSBuZXN0aW5nIHRvbyBkZWVwIgogbXNnc3RyICJFNjAxOiDCoVwiOnRyeVwiIGFuaWRhZG8gZW4gZXhjZXNvISIKIAotIzogZXhfZXZhbC5jOjE0NzkKIG1zZ2lkICJFNjAzOiA6Y2F0Y2ggd2l0aG91dCA6dHJ5IgogbXNnc3RyICJFNjAzOiDCoVwiOmNhdGNoXCIgc2luIHVuIFwiOnRyeVwiISIKIAogIyBHaXZlIHVwIGZvciBhICI6Y2F0Y2giIGFmdGVyICI6ZmluYWxseSIgYW5kIGlnbm9yZSBpdC4KICMgKiBKdXN0IHBhcnNlLgotIy4gR2l2ZSB1cCBmb3IgYSAiOmNhdGNoIiBhZnRlciAiOmZpbmFsbHkiIGFuZCBpZ25vcmUgaXQuCi0jLiAqIEp1c3QgcGFyc2UuCi0jOiBleF9ldmFsLmM6MTQ5OAogbXNnaWQgIkU2MDQ6IDpjYXRjaCBhZnRlciA6ZmluYWxseSIKIG1zZ3N0ciAiRTYwNDogwqFcIjpjYXRjaFwiIGRlc3B1w6lzIGRlIFwiOmZpbmFsbHlcIiEiCiAKLSM6IGV4X2V2YWwuYzoxNjMyCiBtc2dpZCAiRTYwNjogOmZpbmFsbHkgd2l0aG91dCA6dHJ5IgogbXNnc3RyICJFNjA2OiDCoVwiOmZpbmFsbHlcIiBzaW4gdW4gXCI6dHJ5XCIhIgogCiAjIEdpdmUgdXAgZm9yIGEgbXVsdGlwbGUgIjpmaW5hbGx5IiBhbmQgaWdub3JlIGl0LgotIy4gR2l2ZSB1cCBmb3IgYSBtdWx0aXBsZSAiOmZpbmFsbHkiIGFuZCBpZ25vcmUgaXQuCi0jOiBleF9ldmFsLmM6MTY1MgogbXNnaWQgIkU2MDc6IG11bHRpcGxlIDpmaW5hbGx5IgogbXNnc3RyICJFNjA3OiDCoVwiOmZpbmFsbHlcIiBtw7psdGlwbGUhIgogCi0jOiBleF9ldmFsLmM6MTc2MgogbXNnaWQgIkU2MDI6IDplbmR0cnkgd2l0aG91dCA6dHJ5IgogbXNnc3RyICJFNjAyOiDCoVwiOmVuZHRyeVwiIHNpbiB1biBcIjp0cnlcIiEiCiAKLSM6IGV4X2V2YWwuYzoyMjY3CiBtc2dpZCAiRTE5MzogOmVuZGZ1bmN0aW9uIG5vdCBpbnNpZGUgYSBmdW5jdGlvbiIKIG1zZ3N0ciAiRTE5MzogwqFcIjplbmRmdW5jdGlvblwiIG5vIGVzdMOhIGRlbnRybyBkZSB1bmEgZnVuY2nDs24hIgogCi0jOiBleF9nZXRsbi5jOjIwMTAKIG1zZ2lkICJFNzg4OiBOb3QgYWxsb3dlZCB0byBlZGl0IGFub3RoZXIgYnVmZmVyIG5vdyIKIG1zZ3N0ciAiRTc4ODogTm8gc2UgcGVybWl0ZSBlZGl0YXIgb3RybyBiw7pmZXIgZW4gZXN0ZSBtb21lbnRvIgogCi0jOiBleF9nZXRsbi5jOjIwMjUKIG1zZ2lkICJFODExOiBOb3QgYWxsb3dlZCB0byBjaGFuZ2UgYnVmZmVyIGluZm9ybWF0aW9uIG5vdyIKIG1zZ3N0ciAiRTgxMTogTm8gc2UgcGVybWl0ZSBjYW1iaWFyIGxhIGluZm9ybWFjacOzbiBkZWwgYsO6ZmVyIGVuIGVzdGUgbW9tZW50byIKIAotIzogZXhfZ2V0bG4uYzozOTI0CiBtc2dpZCAidGFnbmFtZSIKIG1zZ3N0ciAiTm9tYnJlIGRlIGxhIGV0aXF1ZXRhIChcInRhZ25hbWVcIikiCiAKLSM6IGV4X2dldGxuLmM6MzkyNwogbXNnaWQgIiBraW5kIGZpbGVcbiIKIG1zZ3N0ciAiIHRpcG8gZGUgYXJjaGl2b1xuIgogCi0jOiBleF9nZXRsbi5jOjU2NzYKIG1zZ2lkICInaGlzdG9yeScgb3B0aW9uIGlzIHplcm8iCiBtc2dzdHIgIkxhIG9wY2nDs24gJ2hpc3RvcnknIChoaXN0b3JpYSkgZXMgY2VybyIKIAotIzogZXhfZ2V0bG4uYzo1OTQ3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJcbiIKQEAgLTE5NzIsMjUyICsxNTMzLDE5NCBAQAogIlxuIgogIiMgSGlzdG9yaWEgZGUgJXMgKGRlIGxvIG3DoXMgbnVldm8gYSBsbyBtw6FzIGFudGlndW8pOlxuIgogCi0jOiBleF9nZXRsbi5jOjU5NDgKIG1zZ2lkICJDb21tYW5kIExpbmUiCiBtc2dzdHIgIkzDrW5lYSBkZSDDs3JkZW5lcyIKIAotIzogZXhfZ2V0bG4uYzo1OTQ5CiBtc2dpZCAiU2VhcmNoIFN0cmluZyIKIG1zZ3N0ciAiQ2FkZW5hIGRlIGLDunNxdWVkYSIKIAotIzogZXhfZ2V0bG4uYzo1OTUwCiBtc2dpZCAiRXhwcmVzc2lvbiIKIG1zZ3N0ciAiRXhwcmVzacOzbiIKIAotIzogZXhfZ2V0bG4uYzo1OTUxCiBtc2dpZCAiSW5wdXQgTGluZSIKIG1zZ3N0ciAiTMOtbmVhIGRlIGVudHJhZGEiCiAKLSM6IGV4X2dldGxuLmM6NTk4OQogbXNnaWQgIkUxOTg6IGNtZF9wY2hhciBiZXlvbmQgdGhlIGNvbW1hbmQgbGVuZ3RoIgogbXNnc3RyICJFMTk4OiBcImNtZF9wY2hhclwiIG3DoXMgYWxsw6EgZGUgbGEgbG9uZ2l0dWQgZGUgbGEgb3JkZW4iCiAKLSM6IGV4X2dldGxuLmM6NjE5MAogbXNnaWQgIkUxOTk6IEFjdGl2ZSB3aW5kb3cgb3IgYnVmZmVyIGRlbGV0ZWQiCiBtc2dzdHIgIkUxOTk6IFNlIGJvcnLDsyBsYSB2ZW50YW5hIG8gZWwgYsO6ZmVyIGFjdGl2byIKIAotIzogZmlsZWlvLmM6MTUzCiBtc2dpZCAiRTgxMjogQXV0b2NvbW1hbmRzIGNoYW5nZWQgYnVmZmVyIG9yIGJ1ZmZlciBuYW1lIgogbXNnc3RyICJFODEyOiAqRmlsdHJvKiBMYXMgYXV0by3Ds3JkZW5lcyBubyBkZWJlbiBjYW1iaWFyIGVsIGLDumZlciBlbiB1c28iCiAKLSM6IGZpbGVpby5jOjQwOAogbXNnaWQgIklsbGVnYWwgZmlsZSBuYW1lIgogbXNnc3RyICJOb21icmUgZGUgYXJjaGl2byBpbGVnYWwiCiAKLSM6IGZpbGVpby5jOjQzNyBmaWxlaW8uYzo1OTEgZmlsZWlvLmM6MzMyMCBmaWxlaW8uYzozMzcxCiBtc2dpZCAiaXMgYSBkaXJlY3RvcnkiCiBtc2dzdHIgImVzIHVuIGRpcmVjdG9yaW8iCiAKLSM6IGZpbGVpby5jOjQzOQogbXNnaWQgImlzIG5vdCBhIGZpbGUiCiBtc2dzdHIgIm5vIGVzIHVuIGFyY2hpdm8iCiAKLSM6IGZpbGVpby5jOjQ1MgogbXNnaWQgImlzIGEgZGV2aWNlIChkaXNhYmxlZCB3aXRoICdvcGVuZGV2aWNlJyBvcHRpb24pIgogbXNnc3RyICJlcyB1biBkaXNwb3NpdGl2byAoZGVzYWN0aXZhZG8gY29uIGxhIG9wY2nDs24gJ29wZW5kZXZpY2UnKSIKIAotIzogZmlsZWlvLmM6NjI4IGZpbGVpby5jOjQ2MDUKIG1zZ2lkICJbTmV3IEZpbGVdIgogbXNnc3RyICJbQXJjaGl2byBudWV2b10iCiAKLSM6IGZpbGVpby5jOjYzMQogbXNnaWQgIltOZXcgRElSRUNUT1JZXSIKIG1zZ3N0ciAiW0RpcmVjdG9yaW8gbnVldm9dIgogCi0jOiBmaWxlaW8uYzo2NjUKIG1zZ2lkICJbRmlsZSB0b28gYmlnXSIKIG1zZ3N0ciAiW0VsIGFyY2hpdm8gZXMgZGVtYXNpYWRvIGdyYW5kZV0iCiAKLSM6IGZpbGVpby5jOjY2NwogbXNnaWQgIltQZXJtaXNzaW9uIERlbmllZF0iCiBtc2dzdHIgIltQZXJtaXNvIGRlbmVnYWRvXSIKIAotIzogZmlsZWlvLmM6ODAwCiBtc2dpZCAiRTIwMDogKlJlYWRQcmUgYXV0b2NvbW1hbmRzIG1hZGUgdGhlIGZpbGUgdW5yZWFkYWJsZSIKIG1zZ3N0ciAiRTIwMDogTGFzIGF1dG8tw7NyZGVuZXMgXCIqUmVhZFByZVwiIGhpY2llcm9uIGlsZWdpYmxlIGVsIGFyY2hpdm8iCiAKLSM6IGZpbGVpby5jOjgwMgogbXNnaWQgIkUyMDE6ICpSZWFkUHJlIGF1dG9jb21tYW5kcyBtdXN0IG5vdCBjaGFuZ2UgY3VycmVudCBidWZmZXIiCiBtc2dzdHIgIkUyMDE6IExhcyBhdXRvLcOzcmRlbmVzIFwiKlJlYWRQcmVcIiBubyBkZWJlbiBjYW1iaWFyIGVsIGLDumZlciBlbiB1c28iCiAKLSM6IGZpbGVpby5jOjgyMwogbXNnaWQgIlZpbTogUmVhZGluZyBmcm9tIHN0ZGluLi4uXG4iCiBtc2dzdHIgIlZpbTogTGV5ZW5kbyBsYSBlbnRyYWRhIGVzdMOhbmRhci4uLlxuIgogCi0jOiBmaWxlaW8uYzo4MjkKIG1zZ2lkICJSZWFkaW5nIGZyb20gc3RkaW4uLi4iCiBtc2dzdHIgIkxleWVuZG8gbGEgZW50cmFkYSBlc3TDoW5kYXIuLi4iCiAKICMgUmUtb3BlbmluZyB0aGUgb3JpZ2luYWwgZmlsZSBmYWlsZWQhCi0jLiBSZS1vcGVuaW5nIHRoZSBvcmlnaW5hbCBmaWxlIGZhaWxlZCEKLSM6IGZpbGVpby5jOjExMjgKIG1zZ2lkICJFMjAyOiBDb252ZXJzaW9uIG1hZGUgZmlsZSB1bnJlYWRhYmxlISIKIG1zZ3N0ciAiRTIwMjogwqFMYSBjb252ZXJzacOzbiBoYSBoZWNobyBpbGVnaWJsZSBlbCBhcmNoaXZvISIKIAotIzogZmlsZWlvLmM6MjM2MgogbXNnaWQgIltmaWZvL3NvY2tldF0iCiBtc2dzdHIgIltmaWZvL3NvY2tldF0iCiAKLSM6IGZpbGVpby5jOjIzNjkKIG1zZ2lkICJbZmlmb10iCiBtc2dzdHIgIltmaWZvXSIKIAotIzogZmlsZWlvLmM6MjM3NgogbXNnaWQgIltzb2NrZXRdIgogbXNnc3RyICJbc29ja2V0XSIKIAotIzogZmlsZWlvLmM6MjM4NAogbXNnaWQgIltjaGFyYWN0ZXIgc3BlY2lhbF0iCiBtc2dzdHIgIltjYXLDoWN0ZXIgZXNwZWNpYWxdIgogCi0jOiBmaWxlaW8uYzoyMzkxIG5ldGJlYW5zLmM6MzYzMgogbXNnaWQgIltST10iCiBtc2dzdHIgIltST10iCiAKLSM6IGZpbGVpby5jOjI0MDEKIG1zZ2lkICJbQ1IgbWlzc2luZ10iCiBtc2dzdHIgIltGYWx0YSB1biBDUl0iCiAKLSM6IGZpbGVpby5jOjI0MDYKIG1zZ2lkICJbbG9uZyBsaW5lcyBzcGxpdF0iCiBtc2dzdHIgIltzZSBoYW4gZGl2aWRpZG8gbGFzIGzDrW5lYXMgbGFyZ2FzXSIKIAotIzogZmlsZWlvLmM6MjQxMiBmaWxlaW8uYzo0NTg5CiBtc2dpZCAiW05PVCBjb252ZXJ0ZWRdIgogbXNnc3RyICJbTk8gc2UgaGEgY29udmVydGlkb10iCiAKLSM6IGZpbGVpby5jOjI0MTcgZmlsZWlvLmM6NDU5NAogbXNnaWQgIltjb252ZXJ0ZWRdIgogbXNnc3RyICJbY29udmVydGlkb10iCiAKLSM6IGZpbGVpby5jOjI0MjQgZmlsZWlvLmM6NDYxOQogbXNnaWQgIltjcnlwdGVkXSIKIG1zZ3N0ciAiW2NpZnJhZG9dIgogCi0jOiBmaWxlaW8uYzoyNDMyCiAjLCBjLWZvcm1hdAogbXNnaWQgIltDT05WRVJTSU9OIEVSUk9SIGluIGxpbmUgJWxkXSIKIG1zZ3N0ciAiW0VSUk9SIERFIENPTlZFUlNJw5NOIGVuIGzDrW5lYSAlbGRdIgogCi0jOiBmaWxlaW8uYzoyNDM4CiAjLCBjLWZvcm1hdAogbXNnaWQgIltJTExFR0FMIEJZVEUgaW4gbGluZSAlbGRdIgogbXNnc3RyICJbQllURSBJTEVHQUwgZW4gbGEgbMOtbmVhICVsZF0iCiAKLSM6IGZpbGVpby5jOjI0NDUKIG1zZ2lkICJbUkVBRCBFUlJPUlNdIgogbXNnc3RyICJbRVJST1JFUyBERSBMRUNUVVJBXSIKIAotIzogZmlsZWlvLmM6MjcyMwogbXNnaWQgIkNhbid0IGZpbmQgdGVtcCBmaWxlIGZvciBjb252ZXJzaW9uIgogbXNnc3RyICJObyBzZSBwdWRvIGVuY29udHJhciBlbCBhcmNoaXZvIHRlbXBvcmFsIHBhcmEgbGEgY29udmVyc2nDs24iCiAKLSM6IGZpbGVpby5jOjI3MzAKIG1zZ2lkICJDb252ZXJzaW9uIHdpdGggJ2NoYXJjb252ZXJ0JyBmYWlsZWQiCiBtc2dzdHIgIkZhbGzDsyBsYSBjb252ZXJzacOzbiBjb24gJ2NoYXJjb252ZXJ0JyIKIAotIzogZmlsZWlvLmM6MjczMwogbXNnaWQgImNhbid0IHJlYWQgb3V0cHV0IG9mICdjaGFyY29udmVydCciCiBtc2dzdHIgIk5vIHNlIHB1ZG8gbGVlciBlbCByZXN1bHRhZG8gZGUgJ2NoYXJjb252ZXJ0JyIKIAotIzogZmlsZWlvLmM6MzE2NQogbXNnaWQgIkU2NzY6IE5vIG1hdGNoaW5nIGF1dG9jb21tYW5kcyBmb3IgYWN3cml0ZSBidWZmZXIiCiBtc2dzdHIgIkU2NzY6IE5vIGNvaW5jaWRlIG5pbmd1bmEgYXV0by1vcmRlbiBwYXJhIFwiYWN3cml0ZVwiZW4gZWwgYsO6ZmVyIgogCi0jOiBmaWxlaW8uYzozMjAwCiBtc2dpZCAiRTIwMzogQXV0b2NvbW1hbmRzIGRlbGV0ZWQgb3IgdW5sb2FkZWQgYnVmZmVyIHRvIGJlIHdyaXR0ZW4iCiBtc2dzdHIgIiIKICJFMjAzOiBMYXMgYXV0by3Ds3JkZW5lcyBmdWVyb24gc3VwcmltaWRhcyBvIGVsIGLDumZlciBzZSBkZXNjYXJnw7MgcGFyYSBzZXIgIgogImdyYWJhZG8gZW4gZGlzY28iCiAKLSM6IGZpbGVpby5jOjMyMjMKIG1zZ2lkICJFMjA0OiBBdXRvY29tbWFuZCBjaGFuZ2VkIG51bWJlciBvZiBsaW5lcyBpbiB1bmV4cGVjdGVkIHdheSIKIG1zZ3N0ciAiIgogIkUyMDQ6IExhIGF1dG8tb3JkZW4gaGEgY2FtYmlhZG8gZWwgbsO6bWVybyBkZSBsw61uZWFzIGVuIGZvcm1hIGluZXNwZXJhZGEiCiAKLSM6IGZpbGVpby5jOjMyNjMKIG1zZ2lkICJOZXRCZWFucyBkaXNhbGxvd3Mgd3JpdGVzIG9mIHVubW9kaWZpZWQgYnVmZmVycyIKIG1zZ3N0ciAiTmV0QmVhbnMgbm8gcGVybWl0ZSBxdWUgc2UgZXNjcmliYSBzb2JyZSBiw7pmZXJzIHNpbiBtb2RpZmljYXIiCiAKLSM6IGZpbGVpby5jOjMyNzEKIG1zZ2lkICJQYXJ0aWFsIHdyaXRlcyBkaXNhbGxvd2VkIGZvciBOZXRCZWFucyBidWZmZXJzIgogbXNnc3RyICJObyBzZSBwZXJtaXRlIGxhIGVzY3JpdHVyYSBwYXJjaWFsIGRlIGxvcyBiw7pmZXJzIGRlIE5ldEJlYW5zIgogCi0jOiBmaWxlaW8uYzozMzI2IGZpbGVpby5jOjMzNDQKIG1zZ2lkICJpcyBub3QgYSBmaWxlIG9yIHdyaXRhYmxlIGRldmljZSIKIG1zZ3N0ciAibm8gZXMgdW4gYXJjaGl2byBvIGRpc3Bvc2l0aXZvIGVuIGVsIHF1ZSBzZSBwdWVkYSBlc2NyaWJpciIKIAotIzogZmlsZWlvLmM6MzM1NQogbXNnaWQgIndyaXRpbmcgdG8gZGV2aWNlIGRpc2FibGVkIHdpdGggJ29wZW5kZXZpY2UnIG9wdGlvbiIKIG1zZ3N0ciAiIgogInNlIGhhIGRlc2FjdGl2YWRvIGxhIGVzY3JpdHVyYSBlbiBkaXNwb3NpdGl2byBjb24gbGEgb3BjacOzbiAnb3BlbmRldmljZSciCiAKLSM6IGZpbGVpby5jOjMzOTcgbmV0YmVhbnMuYzozNjk0CiBtc2dpZCAiaXMgcmVhZC1vbmx5IChhZGQgISB0byBvdmVycmlkZSkiCiBtc2dzdHIgImVzIGRlIHNvbG8gbGVjdHVyYSAoYcOxYWRhICEgcGFyYSBzb2JyZWVzY3JpYmlyKSIKIAotIzogZmlsZWlvLmM6Mzc2MQogbXNnaWQgIkU1MDY6IENhbid0IHdyaXRlIHRvIGJhY2t1cCBmaWxlIChhZGQgISB0byBvdmVycmlkZSkiCiBtc2dzdHIgIiIKICJFNTA2OiBObyBzZSBwdWRvIGVzY3JpYmlyIGVuIGVsIGFyY2hpdm8gZGUgcmVjdXBlcmFjacOzbiAiCiAiKGHDsWFkYSAhIHBhcmEgZm9yemFyIGxhIG9yZGVuKSIKIAotIzogZmlsZWlvLmM6Mzc3MwogbXNnaWQgIkU1MDc6IENsb3NlIGVycm9yIGZvciBiYWNrdXAgZmlsZSAoYWRkICEgdG8gb3ZlcnJpZGUpIgogbXNnc3RyICIiCiAiRTUwNzogRXJyb3IgYWwgY2VycmFyIGVsIGFyY2hpdm8gZGUgbGEgY29waWEgZGUgc2VndXJpZGFkIChhw7FhZGEgISBwYXJhICIKICJmb3J6YXIgbGEgb3JkZW4pIgogCi0jOiBmaWxlaW8uYzozNzc1CiBtc2dpZCAiRTUwODogQ2FuJ3QgcmVhZCBmaWxlIGZvciBiYWNrdXAgKGFkZCAhIHRvIG92ZXJyaWRlKSIKIG1zZ3N0ciAiIgogIkU1MDg6IE5vIHNlIHB1ZG8gbGVlciBlbCBhcmNoaXZvIHBhcmEgY3JlYXIgbGEgY29waWEgZGUgc2VndXJpZGFkIChhw7FhZGEgISAiCiAicGFyYSBmb3J6YXIgbGEgb3JkZW4pIgogCi0jOiBmaWxlaW8uYzozNzk0CiBtc2dpZCAiRTUwOTogQ2Fubm90IGNyZWF0ZSBiYWNrdXAgZmlsZSAoYWRkICEgdG8gb3ZlcnJpZGUpIgogbXNnc3RyICIiCiAiRTUwOTogTm8gc2UgcHVkbyBjcmVhciBlbCBhcmNoaXZvIHBhcmEgbGEgY29waWEgZGUgc2VndXJpZGFkIChhw7FhZGEgISBwYXJhICIKICJmb3J6YXIgbGEgb3JkZW4pIgogCi0jOiBmaWxlaW8uYzozODk2CiBtc2dpZCAiRTUxMDogQ2FuJ3QgbWFrZSBiYWNrdXAgZmlsZSAoYWRkICEgdG8gb3ZlcnJpZGUpIgogbXNnc3RyICIiCiAiRTUxMDogTm8gc2UgcHVkbyBoYWNlciB1biBhcmNoaXZvIGRlIGNvcGlhIGRlIHNlZ3VyaWRhZCAoYcOxYWRhICEgcGFyYSBmb3J6YXIgIgogImxhIG9yZGVuKSIKIAotIzogZmlsZWlvLmM6NDA2NwogbXNnaWQgIkUyMTQ6IENhbid0IGZpbmQgdGVtcCBmaWxlIGZvciB3cml0aW5nIgogbXNnc3RyICJFMjE0OiBObyBzZSBwdWRvIGVuY29udHJhciBlbCBhcmNoaXZvIHRlbXBvcmFsIHBhcmEgZXNjcmliaXIgZW4gw6lsIgogCi0jOiBmaWxlaW8uYzo0MDg1CiBtc2dpZCAiRTIxMzogQ2Fubm90IGNvbnZlcnQgKGFkZCAhIHRvIHdyaXRlIHdpdGhvdXQgY29udmVyc2lvbikiCiBtc2dzdHIgIiIKICJFMjEzOiBObyBzZSBwdWRvIGNvbnZlcnRpciAoYcOxYWRhIFwiIVwiIHBhcmEgZXNjcmliaXIgZWwgYXJjaGl2byBzaW4gIgogImNvbnZlcnNpw7NuKSIKIAotIzogZmlsZWlvLmM6NDEyMAogbXNnaWQgIkUxNjY6IENhbid0IG9wZW4gbGlua2VkIGZpbGUgZm9yIHdyaXRpbmciCiBtc2dzdHIgIkUxNjY6IE5vIHNlIHB1ZG8gYWJyaXIgZWwgYXJjaGl2byBlbmxhemFkbyBwYXJhIGVzY3JpYmlyIgogCi0jOiBmaWxlaW8uYzo0MTI0CiBtc2dpZCAiRTIxMjogQ2FuJ3Qgb3BlbiBmaWxlIGZvciB3cml0aW5nIgogbXNnc3RyICJFMjEyOiBObyBzZSBwdWRvIGFicmlyIGVsIGFyY2hpdm8gcGFyYSBlc2NyaWJpciBlbiDDqWwiCiAKLSM6IGZpbGVpby5jOjQ0MDUKIG1zZ2lkICJFNjY3OiBGc3luYyBmYWlsZWQiCiBtc2dzdHIgIkU2Njc6IEZhbGzDsyBcImZzeW5jXCIgKHNpbmNyb25pemFjacOzbiBkZSBhcmNoaXZvKSIKIAotIzogZmlsZWlvLmM6NDQ0NAogbXNnaWQgIkU1MTI6IENsb3NlIGZhaWxlZCIKIG1zZ3N0ciAiRTUxMjogRmFsbMOzIGVsIGNpZXJyZSBkZWwgYXJjaGl2byIKIAotIzogZmlsZWlvLmM6NDQ5NgogbXNnaWQgIkU1MTM6IHdyaXRlIGVycm9yLCBjb252ZXJzaW9uIGZhaWxlZCAobWFrZSAnZmVuYycgZW1wdHkgdG8gb3ZlcnJpZGUpIgogbXNnc3RyICIiCiAiRTUxMzogRXJyb3IgZGUgZXNjcml0dXJhLCBsYSBjb252ZXJzacOzbiBmYWxsw7MgKHZhY8OtZSAnZmVuYycgcGFyYSBmb3J6YXIpLiIKIAotIzogZmlsZWlvLmM6NDUwMQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiRTUxMzogd3JpdGUgZXJyb3IsIGNvbnZlcnNpb24gZmFpbGVkIGluIGxpbmUgJWxkIChtYWtlICdmZW5jJyBlbXB0eSB0byAiCkBAIC0yMjI2LDU2ICsxNzI5LDQzIEBACiAiRTUxMzogRXJyb3IgZGUgZXNjcml0dXJhLCBsYSBjb252ZXJzacOzbiBmYWxsw7MgZW4gbGEgbMOtbmVhICVsZCh2YWPDrWUgJ2ZlbmMnICIKICJwYXJhIGZvcnphcikiCiAKLSM6IGZpbGVpby5jOjQ1MTAKIG1zZ2lkICJFNTE0OiB3cml0ZSBlcnJvciAoZmlsZSBzeXN0ZW0gZnVsbD8pIgogbXNnc3RyICJFNTE0OiBFcnJvciBkZSBlc2NyaXR1cmEgKMK/U2lzdGVtYSBkZSBhcmNoaXZvcyBsbGVubz8pIgogCi0jOiBmaWxlaW8uYzo0NTc4CiBtc2dpZCAiIENPTlZFUlNJT04gRVJST1IiCiBtc2dzdHIgIiBFUlJPUiBERSBDT05WRVJTScOTTiIKIAotIzogZmlsZWlvLmM6NDU4MwogIywgYy1mb3JtYXQKIG1zZ2lkICIgaW4gbGluZSAlbGQ7IgogbXNnc3RyICJlbiBsYSBsw61uZWEgJWxkIgogCi0jOiBmaWxlaW8uYzo0NjAwCiBtc2dpZCAiW0RldmljZV0iCiBtc2dzdHIgIltEaXNwb3NpdGl2b10iCiAKLSM6IGZpbGVpby5jOjQ2MDUKIG1zZ2lkICJbTmV3XSIKIG1zZ3N0ciAiW051ZXZvXSIKIAotIzogZmlsZWlvLmM6NDYyNwogbXNnaWQgIiBbYV0iCiBtc2dzdHIgIiBbYV0iCiAKLSM6IGZpbGVpby5jOjQ2MjcKIG1zZ2lkICIgYXBwZW5kZWQiCiBtc2dzdHIgIiBhw7FhZGlkbyIKIAotIzogZmlsZWlvLmM6NDYyOQogbXNnaWQgIiBbd10iCiBtc2dzdHIgIiBbd10iCiAKLSM6IGZpbGVpby5jOjQ2MjkKIG1zZ2lkICIgd3JpdHRlbiIKIG1zZ3N0ciAiIGVzY3JpdG9zIgogCi0jOiBmaWxlaW8uYzo0Njg0CiBtc2dpZCAiRTIwNTogUGF0Y2htb2RlOiBjYW4ndCBzYXZlIG9yaWdpbmFsIGZpbGUiCiBtc2dzdHIgIkUyMDU6IE1vZG8gZGUgcGFyY2hlbzogbm8gc2UgcHVlZGUgZ3VhcmRhciBlbCBhcmNoaXZvIG9yaWdpbmFsIgogCi0jOiBmaWxlaW8uYzo0NzA3CiBtc2dpZCAiRTIwNjogcGF0Y2htb2RlOiBjYW4ndCB0b3VjaCBlbXB0eSBvcmlnaW5hbCBmaWxlIgogbXNnc3RyICJFMjA2OiBNb2RvIGRlIHBhcmNoZW86IG5vIHNlIHB1ZWRlIHRvY2FyIGVsIGFyY2hpdm8gb3JpZ2luYWwgdmFjw61vIgogCi0jOiBmaWxlaW8uYzo0NzIyCiBtc2dpZCAiRTIwNzogQ2FuJ3QgZGVsZXRlIGJhY2t1cCBmaWxlIgogbXNnc3RyICJFMjA3OiBObyBzZSBwdWRvIGJvcnJhciBlbCBhcmNoaXZvIGRlIHJlc3BhbGRvIgogCi0jOiBmaWxlaW8uYzo0Nzg4CiBtc2dpZCAiIgogIlxuIgogIldBUk5JTkc6IE9yaWdpbmFsIGZpbGUgbWF5IGJlIGxvc3Qgb3IgZGFtYWdlZFxuIgpAQCAtMjI4Myw5OSArMTc3Myw3NSBAQAogIlxuIgogIkFEVkVSVEVOQ0lBOiBlbCBhcmNoaXZvIG9yaWdpbmFsIHB1ZWRlIGhhYmVyc2UgcGVyZGlkbyBvIGRhw7FhZG9cbiIKIAotIzogZmlsZWlvLmM6NDc5MAogbXNnaWQgImRvbid0IHF1aXQgdGhlIGVkaXRvciB1bnRpbCB0aGUgZmlsZSBpcyBzdWNjZXNzZnVsbHkgd3JpdHRlbiEiCiBtc2dzdHIgIsKhbm8gc2FsZ2EgZGVsIGVkaXRvciBoYXN0YSBxdWUgZWwgYXJjaGl2byBzZSBoYXlhIGVzY3JpdG8hIgogCi0jOiBmaWxlaW8uYzo0OTMyCiBtc2dpZCAiW2Rvc10iCiBtc2dzdHIgIltET1NdIgogCi0jOiBmaWxlaW8uYzo0OTMyCiBtc2dpZCAiW2RvcyBmb3JtYXRdIgogbXNnc3RyICJbZm9ybWF0byBET1NdIgogCi0jOiBmaWxlaW8uYzo0OTM5CiBtc2dpZCAiW21hY10iCiBtc2dzdHIgIltNYWNdIgogCi0jOiBmaWxlaW8uYzo0OTM5CiBtc2dpZCAiW21hYyBmb3JtYXRdIgogbXNnc3RyICJbZm9ybWF0byBNYWNdIgogCi0jOiBmaWxlaW8uYzo0OTQ2CiBtc2dpZCAiW3VuaXhdIgogbXNnc3RyICJbVU5JWF0iCiAKLSM6IGZpbGVpby5jOjQ5NDYKIG1zZ2lkICJbdW5peCBmb3JtYXRdIgogbXNnc3RyICJbZm9ybWF0byBVTklYXSIKIAotIzogZmlsZWlvLmM6NDk3MwogbXNnaWQgIjEgbGluZSwgIgogbXNnc3RyICIxIGzDrW5lYSwgIgogCi0jOiBmaWxlaW8uYzo0OTc1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVsZCBsaW5lcywgIgogbXNnc3RyICIlbGQgbMOtbmVhcywgIgogCi0jOiBmaWxlaW8uYzo0OTc4CiBtc2dpZCAiMSBjaGFyYWN0ZXIiCiBtc2dzdHIgIjEgY2Fyw6FjdGVyIgogCi0jOiBmaWxlaW8uYzo0OTgwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVsZCBjaGFyYWN0ZXJzIgogbXNnc3RyICIlbGQgY2FyYWN0ZXJlcyIKIAotIzogZmlsZWlvLmM6NDk5MCBuZXRiZWFucy5jOjM2MzcKIG1zZ2lkICJbbm9lb2xdIgogbXNnc3RyICJbbm8gaGF5IGZpbiBkZSBsw61uZWFdIgogCi0jOiBmaWxlaW8uYzo0OTkwIG5ldGJlYW5zLmM6MzYzNwogbXNnaWQgIltJbmNvbXBsZXRlIGxhc3QgbGluZV0iCiBtc2dzdHIgIlvDmmx0aW1hIGzDrW5lYSBpbmNvbXBsZXRhXSIKIAogIyBkb24ndCBvdmVyd3JpdGUgbWVzc2FnZXMgaGVyZQogIyBtdXN0IGdpdmUgdGhpcyBwcm9tcHQKICMgZG9uJ3QgdXNlIGVtc2coKSBoZXJlLCBkb24ndCB3YW50IHRvIGZsdXNoIHRoZSBidWZmZXJzCi0jLiBkb24ndCBvdmVyd3JpdGUgbWVzc2FnZXMgaGVyZQotIy4gbXVzdCBnaXZlIHRoaXMgcHJvbXB0Ci0jLiBkb24ndCB1c2UgZW1zZygpIGhlcmUsIGRvbid0IHdhbnQgdG8gZmx1c2ggdGhlIGJ1ZmZlcnMKLSM6IGZpbGVpby5jOjUwMDkKIG1zZ2lkICJXQVJOSU5HOiBUaGUgZmlsZSBoYXMgYmVlbiBjaGFuZ2VkIHNpbmNlIHJlYWRpbmcgaXQhISEiCiBtc2dzdHIgIkFEVkVSVEVOQ0lBOiDCocKhwqFFbCBhcmNoaXZvIGhhIGNhbWJpYWRvIGRlc2RlIHF1ZSBzZSBsZXnDsyEhISIKIAotIzogZmlsZWlvLmM6NTAxMQogbXNnaWQgIkRvIHlvdSByZWFsbHkgd2FudCB0byB3cml0ZSB0byBpdCIKIG1zZ3N0ciAiwr9EZXNlYSByZWFsbWVudGUgZXNjcmliaXIgYWwgYXJjaGl2bz8iCiAKLSM6IGZpbGVpby5jOjYzNzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTIwODogRXJyb3Igd3JpdGluZyB0byBcIiVzXCIiCiBtc2dzdHIgIkUyMDg6IEVycm9yIGFsIGVzY3JpYmlyIGEgXCIlc1wiIgogCi0jOiBmaWxlaW8uYzo2MzgyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkUyMDk6IEVycm9yIGNsb3NpbmcgXCIlc1wiIgogbXNnc3RyICJFMjA5OiBFcnJvciBhbCBjZXJyYXIgXCIlc1wiIgogCi0jOiBmaWxlaW8uYzo2Mzg1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkUyMTA6IEVycm9yIHJlYWRpbmcgXCIlc1wiIgogbXNnc3RyICJFMjEwOiBFcnJvciBhbCBsZWVyIFwiJXNcIiIKIAotIzogZmlsZWlvLmM6NjY0NwogbXNnaWQgIkUyNDY6IEZpbGVDaGFuZ2VkU2hlbGwgYXV0b2NvbW1hbmQgZGVsZXRlZCBidWZmZXIiCiBtc2dzdHIgIkUyNDY6IExhIGF1dG8tb3JkZW4gXCJGaWxlQ2hhbmdlZFNoZWxsXCIgaGEgYm9ycmFkbyBlbCBiw7pmZXIiCiAKLSM6IGZpbGVpby5jOjY2NjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTIxMTogRmlsZSBcIiVzXCIgbm8gbG9uZ2VyIGF2YWlsYWJsZSIKIG1zZ3N0ciAiRTIxMTogRWwgYXJjaGl2byBcIiVzXCIgeWEgbm8gZXN0w6EgZGlzcG9uaWJsZSIKIAotIzogZmlsZWlvLmM6NjY3NwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVzEyOiBXYXJuaW5nOiBGaWxlIFwiJXNcIiBoYXMgY2hhbmdlZCBhbmQgdGhlIGJ1ZmZlciB3YXMgY2hhbmdlZCBpbiBWaW0gYXMgIgpAQCAtMjM4NCw0MyArMTg1MCwzNSBAQAogIlcxMjogQWR2ZXJ0ZW5jaWE6IGVsIGFyY2hpdm8gXCIlc1wiIGhhIGNhbWJpYWRvIHkgZWwgYsO6ZmVyIHNlIG1vZGlmaWPDsyAiCiAidGFtYmnDqW4gZW4gVmltIgogCi0jOiBmaWxlaW8uYzo2Njc4CiBtc2dpZCAiU2VlIFwiOmhlbHAgVzEyXCIgZm9yIG1vcmUgaW5mby4iCiBtc2dzdHIgIlbDqWFzZSBcIjpoZWxwIFcxMlwiIHBhcmEgbcOhcyBpbmZvcm1hY2nDs24iCiAKLSM6IGZpbGVpby5jOjY2ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAiVzExOiBXYXJuaW5nOiBGaWxlIFwiJXNcIiBoYXMgY2hhbmdlZCBzaW5jZSBlZGl0aW5nIHN0YXJ0ZWQiCiBtc2dzdHIgIiIKICJXMTE6IEFkdmVydGVuY2lhOiBlbCBhcmNoaXZvIFwiJXNcIiBoYSBjYW1iaWFkbyBkZXNkZSBxdWUgY29tZW56w7MgbGEgZWRpY2nDs24iCiAKLSM6IGZpbGVpby5jOjY2ODMKIG1zZ2lkICJTZWUgXCI6aGVscCBXMTFcIiBmb3IgbW9yZSBpbmZvLiIKIG1zZ3N0ciAiVsOpYXNlIFwiOmhlbHAgVzExXCIgcGFyYSBtw6FzIGluZm9ybWFjacOzbi4iCiAKLSM6IGZpbGVpby5jOjY2ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiVzE2OiBXYXJuaW5nOiBNb2RlIG9mIGZpbGUgXCIlc1wiIGhhcyBjaGFuZ2VkIHNpbmNlIGVkaXRpbmcgc3RhcnRlZCIKIG1zZ3N0ciAiIgogIlcxNjogQWR2ZXJ0ZW5jaWE6IGVsIG1vZG8gZGVsIGFyY2hpdm8gXCIlc1wiIGhhIGNhbWJpYWRvIGRlc2RlIHF1ZSBjb21lbnrDsyAiCiAibGEgZWRpY2nDs24iCiAKLSM6IGZpbGVpby5jOjY2ODgKIG1zZ2lkICJTZWUgXCI6aGVscCBXMTZcIiBmb3IgbW9yZSBpbmZvLiIKIG1zZ3N0ciAiVsOpYXNlIFwiOmhlbHAgVzE2XCIgcGFyYSBtw6FzIGluZm9ybWFjacOzbi4iCiAKLSM6IGZpbGVpby5jOjY3MDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiVzEzOiBXYXJuaW5nOiBGaWxlIFwiJXNcIiBoYXMgYmVlbiBjcmVhdGVkIGFmdGVyIGVkaXRpbmcgc3RhcnRlZCIKIG1zZ3N0ciAiIgogIlcxMzogQWR2ZXJ0ZW5jaWE6IGxhIGNyZWFjacOzbiBkZWwgYXJjaGl2byBcIiVzXCIgZXMgcG9zdGVyaW9yIGFsIGluaWNpbyBkZSAiCiAibGEgZWRpY2nDs24iCiAKLSM6IGZpbGVpby5jOjY3MzMKIG1zZ2lkICJXYXJuaW5nIgogbXNnc3RyICJBZHZlcnRlbmNpYSIKIAotIzogZmlsZWlvLmM6NjczNAogbXNnaWQgIiIKICImT0tcbiIKICImTG9hZCBGaWxlIgpAQCAtMjQyOCw1MCArMTg4NiwzOSBAQAogIiZPS1xuIgogIiZDYXJnYXIgYXJjaGl2byIKIAotIzogZmlsZWlvLmM6Njg1NwogIywgYy1mb3JtYXQKIG1zZ2lkICJFNDYyOiBDb3VsZCBub3QgcHJlcGFyZSBmb3IgcmVsb2FkaW5nIFwiJXNcIiIKIG1zZ3N0ciAiRTQ2MjogTm8gcHVkZSBwcmVwYXJhcm1lIHBhcmEgcmVjYXJnYXIgXCIlc1wiIgogCi0jOiBmaWxlaW8uYzo2ODc2CiAjLCBjLWZvcm1hdAogbXNnaWQgIkUzMjE6IENvdWxkIG5vdCByZWxvYWQgXCIlc1wiIgogbXNnc3RyICJFMzIxOiBObyBwdWRlIHJlY2FyZ2FyIFwiJXNcIiIKIAotIzogZmlsZWlvLmM6NzQ5MAogbXNnaWQgIi0tRGVsZXRlZC0tIgogbXNnc3RyICItLVN1cHJpbWlkby0tIgogCi0jOiBmaWxlaW8uYzo3NjQzCiAjLCBjLWZvcm1hdAogbXNnaWQgImF1dG8tcmVtb3ZpbmcgYXV0b2NvbW1hbmQ6ICVzIDxidWZmZXI9JWQ+IgogbXNnc3RyICJBdXRvLXJlbW92aWVuZG8gYXV0b2NvbWFuZG86ICVzIDxiw7pmZXI9JWQ+IgogCiAjIHRoZSBncm91cCBkb2Vzbid0IGV4aXN0Ci0jLiB0aGUgZ3JvdXAgZG9lc24ndCBleGlzdAotIzogZmlsZWlvLmM6NzY4OQogIywgYy1mb3JtYXQKIG1zZ2lkICJFMzY3OiBObyBzdWNoIGdyb3VwOiBcIiVzXCIiCiBtc2dzdHIgIkUzNjc6IE5vIGV4aXN0ZSBlbCBncnVwbzogJXMiCiAKLSM6IGZpbGVpby5jOjc4MzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTIxNTogSWxsZWdhbCBjaGFyYWN0ZXIgYWZ0ZXIgKjogJXMiCiBtc2dzdHIgIkUyMTU6IENhcsOhY3RlciBpbGVnYWwgZGVzcHXDqXMgZGUgKjogJXMiCiAKLSM6IGZpbGVpby5jOjc4NDgKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTIxNjogTm8gc3VjaCBldmVudDogJXMiCiBtc2dzdHIgIkUyMTY6IE5vIGV4aXN0ZSB0YWwgZXZlbnRvOiAlcyIKIAotIzogZmlsZWlvLmM6Nzg1MAogIywgYy1mb3JtYXQKIG1zZ2lkICJFMjE2OiBObyBzdWNoIGdyb3VwIG9yIGV2ZW50OiAlcyIKIG1zZ3N0ciAiRTIxNjogTm8gZXhpc3RlIHRhbCBncnVwbyBvIGV2ZW50bzogJXMiCiAKICMgSGlnaGxpZ2h0IHRpdGxlCi0jLiBIaWdobGlnaHQgdGl0bGUKLSM6IGZpbGVpby5jOjgwNTgKIG1zZ2lkICIiCiAiXG4iCiAiLS0tIEF1dG9jb21tYW5kcyAtLS0iCkBAIC0yNDc5LDE4OCArMTkyNiwxNDcgQEAKICJcbiIKICItLS0gQXV0by3Ds3JkZW5lcyAtLS0iCiAKLSM6IGZpbGVpby5jOjgyOTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTY4MDogPGJ1ZmZlcj0lZD46IGludmFsaWQgYnVmZmVyIG51bWJlciAiCiBtc2dzdHIgIkU2ODA6IG7Dum1lcm8gZGUgPGLDumZlcj0lZD4gbm8gdsOhbGlkbyIKIAotIzogZmlsZWlvLmM6ODM5MQogbXNnaWQgIkUyMTc6IENhbid0IGV4ZWN1dGUgYXV0b2NvbW1hbmRzIGZvciBBTEwgZXZlbnRzIgogbXNnc3RyICJFMjE3OiBObyBzZSBwdWVkZW4gZWplY3V0YXIgbGFzIGF1dG8tw7NyZGVuZXMgcGFyYSBUT0RPUyBsb3MgZXZlbnRvcyIKIAotIzogZmlsZWlvLmM6ODQxNAogbXNnaWQgIk5vIG1hdGNoaW5nIGF1dG9jb21tYW5kcyIKIG1zZ3N0ciAiTm8gY29pbmNpZGUgbmluZ3VuYSBhdXRvLW9yZGVuIgogCi0jOiBmaWxlaW8uYzo4ODYyCiBtc2dpZCAiRTIxODogYXV0b2NvbW1hbmQgbmVzdGluZyB0b28gZGVlcCIKIG1zZ3N0ciAiRTIxODogTGEgYXV0by1vcmRlbiBzZSBhbmlkYSBlbiBleGNlc28iCiAKLSM6IGZpbGVpby5jOjkyMTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgQXV0b2NvbW1hbmRzIGZvciBcIiVzXCIiCiBtc2dzdHIgIiVzIEF1dG8tw7NyZGVuZXMgcGFyYSBcIiVzXCIiCiAKLSM6IGZpbGVpby5jOjkyMjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiRXhlY3V0aW5nICVzIgogbXNnc3RyICJFamVjdXRhbmRvICVzIgogCiAjIGFsd2F5cyBzY3JvbGwgdXAsIGRvbid0IG92ZXJ3cml0ZQotIzogZmlsZWlvLmM6OTI5NAogIywgYy1mb3JtYXQKIG1zZ2lkICJhdXRvY29tbWFuZCAlcyIKIG1zZ3N0ciAiYXV0by1vcmRlbiAlcyIKIAotIzogZmlsZWlvLmM6OTk3NwogbXNnaWQgIkUyMTk6IE1pc3Npbmcgey4iCiBtc2dzdHIgIkUyMTk6IEZhbHRhIHVuIHsuIgogCi0jOiBmaWxlaW8uYzo5OTc5CiBtc2dpZCAiRTIyMDogTWlzc2luZyB9LiIKIG1zZ3N0ciAiRTIyMDogRmFsdGEgdW4gfS4iCiAKLSM6IGZvbGQuYzo2OAogbXNnaWQgIkU0OTA6IE5vIGZvbGQgZm91bmQiCiBtc2dzdHIgIkU0OTA6IE5vIHNlIGVuY29udHLDsyBuaW5nw7puIHBsaWVndWUiCiAKLSM6IGZvbGQuYzo1OTMKIG1zZ2lkICJFMzUwOiBDYW5ub3QgY3JlYXRlIGZvbGQgd2l0aCBjdXJyZW50ICdmb2xkbWV0aG9kJyIKIG1zZ3N0ciAiRTM1MDogTm8gc2UgcHVlZGUgY3JlYXIgZWwgcGxpZWd1ZSBjb24gZWwgJ2ZvbGRtZXRob2QnIGFjdHVhbCBhY3Rpdm8iCiAKLSM6IGZvbGQuYzo1OTUKIG1zZ2lkICJFMzUxOiBDYW5ub3QgZGVsZXRlIGZvbGQgd2l0aCBjdXJyZW50ICdmb2xkbWV0aG9kJyIKIG1zZ3N0ciAiRTM1MTogTm8gc2UgcHVlZGUgYm9ycmFyIGVsIHBsaWVndWUgY29uIGVsICdmb2xkbWV0aG9kJyBhY3Rpdm8iCiAKLSM6IGZvbGQuYzoxOTk5CiAjLCBjLWZvcm1hdAogbXNnaWQgIistLSUzbGQgbGluZXMgZm9sZGVkICIKIG1zZ3N0ciAiKy0tJTNsZCBsw61uZWFzIHBsZWdhZGFzIgogCi0jOiBnZXRjaGFyLmM6MjUyCiBtc2dpZCAiRTIyMjogQWRkIHRvIHJlYWQgYnVmZmVyIgogbXNnc3RyICJFMjIyOiBBw7FhZGlyIGFsIGLDumZlciBkZSBsZWN0dXJhIgogCi0jOiBnZXRjaGFyLmM6MjQwNwogbXNnaWQgIkUyMjM6IHJlY3Vyc2l2ZSBtYXBwaW5nIgogbXNnc3RyICJFMjIzOiBBc29jaWFjacOzbiByZWN1cnNpdmEiCiAKLSM6IGdldGNoYXIuYzozMzY2CiAjLCBjLWZvcm1hdAogbXNnaWQgIkUyMjQ6IGdsb2JhbCBhYmJyZXZpYXRpb24gYWxyZWFkeSBleGlzdHMgZm9yICVzIgogbXNnc3RyICJFMjI0OiBZYSBleGlzdGUgdW5hIGFicmV2aWF0dXJhIGdsb2JhbCBwYXJhICVzIgogCi0jOiBnZXRjaGFyLmM6MzM2OQogIywgYy1mb3JtYXQKIG1zZ2lkICJFMjI1OiBnbG9iYWwgbWFwcGluZyBhbHJlYWR5IGV4aXN0cyBmb3IgJXMiCiBtc2dzdHIgIkUyMjU6IFlhIGV4aXN0ZSB1bmEgYXNvY2lhY2nDs24gZ2xvYmFsIHBhcmEgJXMiCiAKLSM6IGdldGNoYXIuYzozNTAxCiAjLCBjLWZvcm1hdAogbXNnaWQgIkUyMjY6IGFiYnJldmlhdGlvbiBhbHJlYWR5IGV4aXN0cyBmb3IgJXMiCiBtc2dzdHIgIkUyMjY6IFlhIGV4aXN0ZSB1bmEgYWJyZXZpYXR1cmEgcGFyYSAlcyIKIAotIzogZ2V0Y2hhci5jOjM1MDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTIyNzogbWFwcGluZyBhbHJlYWR5IGV4aXN0cyBmb3IgJXMiCiBtc2dzdHIgIkUyMjc6IFlhIGV4aXN0ZSB1bmEgYXNvY2lhY2nDs24gcGFyYSAlcyIKIAotIzogZ2V0Y2hhci5jOjM1NzIKIG1zZ2lkICJObyBhYmJyZXZpYXRpb24gZm91bmQiCiBtc2dzdHIgIk5vIHNlIGVuY29udHLDsyBuaW5ndW5hIGFicmV2aWF0dXJhIgogCi0jOiBnZXRjaGFyLmM6MzU3NAogbXNnaWQgIk5vIG1hcHBpbmcgZm91bmQiCiBtc2dzdHIgIk5vIHNlIGVuY29udHLDsyBuaW5ndW5hIGFzb2NpYWNpw7NuIGRlIHRlY2xhZG8iCiAKLSM6IGdldGNoYXIuYzo0Njg3CiBtc2dpZCAiRTIyODogbWFrZW1hcDogSWxsZWdhbCBtb2RlIgogbXNnc3RyICJFMjI4OiBcIm1ha2VtYXBcIjogbW9kbyBpbGVnYWwiCiAKLSM6IGd1aS5jOjIyNgogbXNnaWQgIkUyMjk6IENhbm5vdCBzdGFydCB0aGUgR1VJIgogbXNnc3RyICJFMjI5OiBObyBzZSBwdWRvIGluaWNpYXIgbGEgaW50ZXJmYXogZ3LDoWZpY2EiCiAKLSM6IGd1aS5jOjM2MQogIywgYy1mb3JtYXQKIG1zZ2lkICJFMjMwOiBDYW5ub3QgcmVhZCBmcm9tIFwiJXNcIiIKIG1zZ3N0ciAiRTIzMDogTm8gc2UgcHVkbyBsZWVyIGRlc2RlIFwiJXNcIiIKIAotIzogZ3VpLmM6NDg3CiBtc2dpZCAiRTY2NTogQ2Fubm90IHN0YXJ0IEdVSSwgbm8gdmFsaWQgZm9udCBmb3VuZCIKIG1zZ3N0ciAiIgogIkU2NjU6IE5vIHNlIHB1ZG8gaW5pY2lhciBsYSBpbnRlcmZheiBncsOhZmljYSAoR1VJKSwgbm8gc2UgZW5jb250csOzIG5pbmd1bmEgIgogInRpcG9ncmFmw61hIGRlIGltcHJlc2nDs24gdsOhbGlkYSIKIAotIzogZ3VpLmM6NDkyCiBtc2dpZCAiRTIzMTogJ2d1aWZvbnR3aWRlJyBpbnZhbGlkIgogbXNnc3RyICJFMjMxOiBFbCB2YWxvciBkZSAnZ3VpZm9udHdpZGUnIG5vIGVzIHbDoWxpZG8iCiAKLSM6IGd1aS5jOjYwMwogbXNnaWQgIkU1OTk6IFZhbHVlIG9mICdpbWFjdGl2YXRla2V5JyBpcyBpbnZhbGlkIgogbXNnc3RyICJFNTk5OiBFbCB2YWxvciBkZSAnaW1hY3RpdmF0ZWtleScgbm8gZXMgdsOhbGlkbyIKIAotIzogZ3VpLmM6NDUyNgogIywgYy1mb3JtYXQKIG1zZ2lkICJFMjU0OiBDYW5ub3QgYWxsb2NhdGUgY29sb3IgJXMiCiBtc2dzdHIgIkUyNTQ6IE5vIHNlIHB1ZG8gYXNpZ25hciBlbCBjb2xvciAlcyIKIAotIzogZ3VpLmM6NTEwNwogbXNnaWQgIk5vIG1hdGNoIGF0IGN1cnNvciwgZmluZGluZyBuZXh0IgogbXNnc3RyICIiCiAiTm8gaGF5IGNvcnJlc3BvbmRlbmNpYSBlbiBsYSBwb3NpY2nDs24gZGVsIGN1cnNvciwgYnVzY2FuZG8gbGEgc2lndWllbnRlIgogCi0jOiBndWlfYXRfZnMuYzozMDAKIG1zZ2lkICI8Y2Fubm90IG9wZW4+ICIKIG1zZ3N0ciAiPG5vIHNlIHB1ZWRlIGFicmlyPiAiCiAKLSM6IGd1aV9hdF9mcy5jOjExMzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTYxNjogdmltX1NlbEZpbGU6IGNhbid0IGdldCBmb250ICVzIgogbXNnc3RyICIiCiAiRTYxNjogXCJ2aW1fU2VsRmlsZVwiOiBObyBzZSBwdWVkZSBoYWxsYXIgbGEgdGlwb2dyYWbDrWEgZGUgaW1wcmVzacOzbiAlcyIKIAotIzogZ3VpX2F0X2ZzLmM6Mjc2NAogbXNnaWQgIkU2MTQ6IHZpbV9TZWxGaWxlOiBjYW4ndCByZXR1cm4gdG8gY3VycmVudCBkaXJlY3RvcnkiCiBtc2dzdHIgIkU2MTQ6IFwidmltX1NlbEZpbGVcIjogbm8gcHVlZG8gcmVncmVzYXIgYWwgZGlyZWN0b3JpbyBhY3R1YWwiCiAKLSM6IGd1aV9hdF9mcy5jOjI3ODQKIG1zZ2lkICJQYXRobmFtZToiCiBtc2dzdHIgIk5vbWJyZSBkZSBsYSBydXRhOiIKIAotIzogZ3VpX2F0X2ZzLmM6Mjc5MAogbXNnaWQgIkU2MTU6IHZpbV9TZWxGaWxlOiBjYW4ndCBnZXQgY3VycmVudCBkaXJlY3RvcnkiCiBtc2dzdHIgIiIKICJFNjE1OiBcInZpbV9TZWxGaWxlXCI6IE5vIHNlIHB1ZG8gb2J0ZW5lciBsYSB1YmljYWNpw7NuIGRlbCBkaXJlY3RvcmlvIGFjdHVhbCIKIAotIzogZ3VpX2F0X2ZzLmM6Mjc5OCBndWlfeG1kbGcuYzo5MzEKIG1zZ2lkICJPSyIKIG1zZ3N0ciAiT0siCiAKLSM6IGd1aV9hdF9mcy5jOjI3OTggZ3VpX2d0ay5jOjI4MzEgZ3VpX3htZGxnLmM6OTQwCiBtc2dpZCAiQ2FuY2VsIgogbXNnc3RyICJDYW5jZWxhciIKIAotIzogZ3VpX2F0X3NiLmM6NDkwCiBtc2dpZCAiU2Nyb2xsYmFyIFdpZGdldDogQ291bGQgbm90IGdldCBnZW9tZXRyeSBvZiB0aHVtYiBwaXhtYXAuIgogbXNnc3RyICIiCiAiU2Nyb2xsYmFyIFdpZGdldDogTm8gcHVkZSBvYnRlbmVyIGxhIGdlb21ldHLDrWEgZGUgbGEgbWluaWF0dXJhIFwicGl4bWFwXCIiCiAKLSM6IGd1aV9hdGhlbmEuYzoyMTYwIGd1aV9tb3RpZi5jOjI1ODgKIG1zZ2lkICJWaW0gZGlhbG9nIgogbXNnc3RyICJEacOhbG9nbyBkZSBWaW0iCiAKLSM6IGd1aV9iZXZhbC5jOjIwMCBndWlfdzMyLmM6NDcyOAogbXNnaWQgIkUyMzI6IENhbm5vdCBjcmVhdGUgQmFsbG9vbkV2YWwgd2l0aCBib3RoIG1lc3NhZ2UgYW5kIGNhbGxiYWNrIgogbXNnc3RyICIiCiAiRTIzMjogTm8gc2UgcHVkbyBjcmVhciB1biBcIkJhbGxvb25FdmFsXCIgcXVlIGNvbnRlbmdhIHRhbnRvIGVsIG1lbnNhamUgY29tbyAiCiAibGEgbGxhbWFkYSBkZSByZXRvcm5vIgogCi0jOiBndWlfZ3RrLmM6MTY5NAogbXNnaWQgIlZpbSBkaWFsb2cuLi4iCiBtc2dzdHIgIkRpw6Fsb2dvIGRlIFZpbS4uLiIKIAotIzogZ3VpX2d0ay5jOjIxNDUgbWVzc2FnZS5jOjM2NTQKIG1zZ2lkICIiCiAiJlllc1xuIgogIiZOb1xuIgpAQCAtMjY3MCwyMjcgKzIwNzYsMTcyIEBACiAiJk5vXG4iCiAiJkNhbmNlbGFyIgogCi0jOiBndWlfZ3RrLmM6MjM1NgogbXNnaWQgIklucHV0IF9NZXRob2RzIgogbXNnc3RyICJNw6l0b2RvcyBkZSBFbnRyYWRhIChcIklucHV0IE1ldGhvZHNcIikiCiAKLSM6IGd1aV9ndGsuYzoyNjM0IGd1aV9tb3RpZi5jOjM3NjAKIG1zZ2lkICJWSU0gLSBTZWFyY2ggYW5kIFJlcGxhY2UuLi4iCiBtc2dzdHIgIlZJTSAtIEJ1c2NhciB5IHJlZW1wbGF6YXIuLi4iCiAKLSM6IGd1aV9ndGsuYzoyNjQyIGd1aV9tb3RpZi5jOjM3NjIKIG1zZ2lkICJWSU0gLSBTZWFyY2guLi4iCiBtc2dzdHIgIlZJTSAtIEJ1c2Nhci4uLiIKIAotIzogZ3VpX2d0ay5jOjI2NzQgZ3VpX21vdGlmLmM6Mzg3MQogbXNnaWQgIkZpbmQgd2hhdDoiCiBtc2dzdHIgIsK/RW5jb250cmFyIHF1w6k/OiIKIAotIzogZ3VpX2d0ay5jOjI2OTIgZ3VpX21vdGlmLmM6MzkwNAogbXNnaWQgIlJlcGxhY2Ugd2l0aDoiCiBtc2dzdHIgIlJlZW1wbGF6YXIgY29uOiIKIAogIyB3aG9sZSB3b3JkIG9ubHkgYnV0dG9uCi0jLiB3aG9sZSB3b3JkIG9ubHkgYnV0dG9uCi0jOiBndWlfZ3RrLmM6MjcyNCBndWlfbW90aWYuYzo0MDI1CiBtc2dpZCAiTWF0Y2ggd2hvbGUgd29yZCBvbmx5IgogbXNnc3RyICJFbmNvbnRyYXIgc29sbyBwYWxhYnJhcyBjb21wbGV0YXMiCiAKICMgbWF0Y2ggY2FzZSBidXR0b24KLSMuIG1hdGNoIGNhc2UgYnV0dG9uCi0jOiBndWlfZ3RrLmM6MjczNSBndWlfbW90aWYuYzo0MDM3CiBtc2dpZCAiTWF0Y2ggY2FzZSIKIG1zZ3N0ciAiTGEgw7puaWNhIGNvaW5jaWRlbmNpYSIKIAotIzogZ3VpX2d0ay5jOjI3NDUgZ3VpX21vdGlmLmM6Mzk3NgogbXNnaWQgIkRpcmVjdGlvbiIKIG1zZ3N0ciAiRGlyZWNjacOzbiIKIAogIyAnVXAnIGFuZCAnRG93bicgYnV0dG9ucwotIy4gJ1VwJyBhbmQgJ0Rvd24nIGJ1dHRvbnMKLSM6IGd1aV9ndGsuYzoyNzU3IGd1aV9tb3RpZi5jOjM5ODkKIG1zZ2lkICJVcCIKIG1zZ3N0ciAiSGFjaWEgYXJyaWJhIgogCi0jOiBndWlfZ3RrLmM6Mjc2MSBndWlfbW90aWYuYzozOTk4CiBtc2dpZCAiRG93biIKIG1zZ3N0ciAiSGFjaWEgYWJham8iCiAKLSM6IGd1aV9ndGsuYzoyNzgzIGd1aV9ndGsuYzoyNzg1CiBtc2dpZCAiRmluZCBOZXh0IgogbXNnc3RyICJFbmNvbnRyYXIgc2lndWllbnRlIgogCi0jOiBndWlfZ3RrLmM6MjgwMiBndWlfZ3RrLmM6MjgwNAogbXNnaWQgIlJlcGxhY2UiCiBtc2dzdHIgIlJlZW1wbGF6YXIiCiAKLSM6IGd1aV9ndGsuYzoyODE1IGd1aV9ndGsuYzoyODE3CiBtc2dpZCAiUmVwbGFjZSBBbGwiCiBtc2dzdHIgIlJlZW1wbGF6YXIgdG9kb3MiCiAKLSM6IGd1aV9ndGtfeDExLmM6MjQxNwogbXNnaWQgIlZpbTogUmVjZWl2ZWQgXCJkaWVcIiByZXF1ZXN0IGZyb20gc2Vzc2lvbiBtYW5hZ2VyXG4iCiBtc2dzdHIgIlZpbTogUmVjaWLDrSB1bmEgc29saWNpdHVkIFwiZGllXCIgZGVsIGFkbWluaXN0cmFkb3IgZGUgc2VzaW9uZXMuXG4iCiAKLSM6IGd1aV9ndGtfeDExLmM6MzI0NAogbXNnaWQgIkNsb3NlIgogbXNnc3RyICJDZXJyYXIiCiAKLSM6IGd1aV9ndGtfeDExLmM6MzI0NSBndWlfdzQ4LmM6MjM3NQogbXNnaWQgIk5ldyB0YWIiCiBtc2dzdHIgIlBlc3Rhw7FhIG51ZXZhIgogCi0jOiBndWlfZ3RrX3gxMS5jOjMyNDYKIG1zZ2lkICJPcGVuIFRhYi4uLiIKIG1zZ3N0ciAiQWJyaXIgcGVzdGHDsWEuLi4iCiAKLSM6IGd1aV9ndGtfeDExLmM6NDAyNQogbXNnaWQgIlZpbTogTWFpbiB3aW5kb3cgdW5leHBlY3RlZGx5IGRlc3Ryb3llZFxuIgogbXNnc3RyICJWaW06IExhIHZlbnRhbmEgcHJpbmNpcGFsIGZ1ZSBkZXN0cnVpZGEgaW5lc3BlcmFkYW1lbnRlLlxuIgogCi0jOiBndWlfZ3RrX3gxMS5jOjQ3NDYKIG1zZ2lkICJGb250IFNlbGVjdGlvbiIKIG1zZ3N0ciAiU2VsZWNjacOzbiBkZSB0aXBvcyBkZSBsZXRyYSIKIAotIzogZ3VpX21vdGlmLmM6MjM1NQogbXNnaWQgIiZGaWx0ZXIiCiBtc2dzdHIgIiZGaWx0cm8iCiAKLSM6IGd1aV9tb3RpZi5jOjIzNTYgZ3VpX21vdGlmLmM6MzgzOQogbXNnaWQgIiZDYW5jZWwiCiBtc2dzdHIgIiZDYW5jZWxhciIKIAotIzogZ3VpX21vdGlmLmM6MjM1NwogbXNnaWQgIkRpcmVjdG9yaWVzIgogbXNnc3RyICJEaXJlY3RvcmlvcyIKIAotIzogZ3VpX21vdGlmLmM6MjM1OAogbXNnaWQgIkZpbHRlciIKIG1zZ3N0ciAiRmlsdHJvIgogCi0jOiBndWlfbW90aWYuYzoyMzU5CiBtc2dpZCAiJkhlbHAiCiBtc2dzdHIgIiZBeXVkYSIKIAotIzogZ3VpX21vdGlmLmM6MjM2MAogbXNnaWQgIkZpbGVzIgogbXNnc3RyICJBcmNoaXZvcyIKIAotIzogZ3VpX21vdGlmLmM6MjM2MQogbXNnaWQgIiZPSyIKIG1zZ3N0ciAiJk9LIgogCi0jOiBndWlfbW90aWYuYzoyMzYyCiBtc2dpZCAiU2VsZWN0aW9uIgogbXNnc3RyICJTZWxlY2Npw7NuIgogCi0jOiBndWlfbW90aWYuYzozNzkxCiBtc2dpZCAiRmluZCAmTmV4dCIKIG1zZ3N0ciAiRW5jb250cmFyICZTaWd1aWVudGUiCiAKLSM6IGd1aV9tb3RpZi5jOjM4MDYKIG1zZ2lkICImUmVwbGFjZSIKIG1zZ3N0ciAiJlJlZW1wbGF6YXIiCiAKLSM6IGd1aV9tb3RpZi5jOjM4MTcKIG1zZ2lkICJSZXBsYWNlICZBbGwiCiBtc2dzdHIgIlJlZW1wbGF6YXIgJlRvZG9zIgogCi0jOiBndWlfbW90aWYuYzozODI4CiBtc2dpZCAiJlVuZG8iCiBtc2dzdHIgIiZEZXNoYWNlciIKIAotIzogZ3VpX3czMi5jOjExNzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTY3MTogQ2Fubm90IGZpbmQgd2luZG93IHRpdGxlIFwiJXNcIiIKIG1zZ3N0ciAiRTY3MTogTm8gc2UgcHVkbyBlbmNvbnRyYXIgZWwgdMOtdHVsbyBkZSBsYSB2ZW50YW5hIFwiJXNcIiIKIAotIzogZ3VpX3czMi5jOjExOTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTI0MzogQXJndW1lbnQgbm90IHN1cHBvcnRlZDogXCItJXNcIjsgVXNlIHRoZSBPTEUgdmVyc2lvbi4iCiBtc2dzdHIgIkUyNDM6IEFyZ3VtZW50byBubyBhZG1pdGlkbzogXCItJXNcIjsgdXNlIGxhIHZlcnNpw7NuIE9MRS4iCiAKLSM6IGd1aV93MzIuYzoxNDQyCiBtc2dpZCAiRTY3MjogVW5hYmxlIHRvIG9wZW4gd2luZG93IGluc2lkZSBNREkgYXBwbGljYXRpb24iCiBtc2dzdHIgIkU2NzI6IEluY2FwYXogZGUgYWJyaXIgdmVudGFuYSBkZW50cm8gZGUgbGEgYXBsaWNhY2nDs24gTURJIgogCi0jOiBndWlfdzQ4LmM6MjM3NAogbXNnaWQgIkNsb3NlIHRhYiIKIG1zZ3N0ciAiQ2VycmFyIFZlbnRhbmEiCiAKLSM6IGd1aV93NDguYzoyMzc3CiBtc2dpZCAiT3BlbiB0YWIuLi4iCiBtc2dzdHIgIkFicmlyIHBlc3Rhw7FhLi4uIgogCi0jOiBndWlfdzQ4LmM6MjYzMwogbXNnaWQgIkZpbmQgc3RyaW5nICh1c2UgJ1xcXFwnIHRvIGZpbmQgIGEgJ1xcJykiCiBtc2dzdHIgIkJ1c2NhciBjYWRlbmEgKHVzZSAnXFxcXCcgcGFyYSBlbmNvbnRyYXIgdW4gJ1xcJykiCiAKLSM6IGd1aV93NDguYzoyNjY5CiBtc2dpZCAiRmluZCAmIFJlcGxhY2UgKHVzZSAnXFxcXCcgdG8gZmluZCAgYSAnXFwnKSIKIG1zZ3N0ciAiQnVzY2FyIHkgcmVlbXBsYXphciAodXNlICdcXFxcJyBwYXJhIGVuY29udHJhciB1biAnXFwnKSIKIAotIy4gV2UgZmFrZSB0aGlzOiBVc2UgYSBmaWx0ZXIgdGhhdCBkb2Vzbid0IHNlbGVjdCBhbnl0aGluZyBhbmQgYSBkZWZhdWx0Ci0jLiAqIGZpbGUgbmFtZSB0aGF0IHdvbid0IGJlIHVzZWQuCi0jOiBndWlfdzQ4LmM6MzQ2MwogbXNnaWQgIk5vdCBVc2VkIgogbXNnc3RyICJTaW4gdXNhciIKIAotIzogZ3VpX3c0OC5jOjM0NjQKIG1zZ2lkICJEaXJlY3RvcnlcdCoubm90aGluZ1xuIgogbXNnc3RyICJEaXJlY3RvcmlvXHQqLm5hZGFcbiIKIAotIzogZ3VpX3gxMS5jOjE1NDYKIG1zZ2lkICJWaW0gRTQ1ODogQ2Fubm90IGFsbG9jYXRlIGNvbG9ybWFwIGVudHJ5LCBzb21lIGNvbG9ycyBtYXkgYmUgaW5jb3JyZWN0IgogbXNnc3RyICIiCiAiVmltIEU0NTg6IG5vIHNlIHB1ZWRlIGFzaWduYXIgdW5hIGVudHJhZGEgYWwgbWFwYSBkZSBjb2xvcmVzOyBhbGd1bm9zICIKICJjb2xvcmVzIHRhbCB2ZXogbm8gc2VhbiBjb3JyZWN0b3MiCiAKLSM6IGd1aV94MTEuYzoyMTM4CiAjLCBjLWZvcm1hdAogbXNnaWQgIkUyNTA6IEZvbnRzIGZvciB0aGUgZm9sbG93aW5nIGNoYXJzZXRzIGFyZSBtaXNzaW5nIGluIGZvbnRzZXQgJXM6IgogbXNnc3RyICIiCiAiRTI1MDogRmFsdGFuIGxvcyB0aXBvcyBkZSBsZXRyYXMgcGFyYSBsb3Mgc2lndWllbnRlcyBjb25qdW50b3MgZGUgY2FyYWN0ZXJlcyAiCiAiZW4gZWwgY29uanVudG8gZGUgZnVlbnRlcyAlczoiCiAKLSM6IGd1aV94MTEuYzoyMTgxCiAjLCBjLWZvcm1hdAogbXNnaWQgIkUyNTI6IEZvbnRzZXQgbmFtZTogJXMiCiBtc2dzdHIgIkUyNTI6IE5vbWJyZSBkZWwgY29uanVudG8gZGUgdGlwb3MgZGUgbGV0cmE6ICVzIgogCi0jOiBndWlfeDExLmM6MjE4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJGb250ICclcycgaXMgbm90IGZpeGVkLXdpZHRoIgogbXNnc3RyICJMYSB0aXBvZ3JhZsOtYSBkZSBpbXByZXNpw7NuICclcycgbm8gZXMgZGUgYW5jaG8gZmlqbyIKIAotIzogZ3VpX3gxMS5jOjIyMDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTI1MzogRm9udHNldCBuYW1lOiAlc1xuIgogbXNnc3RyICJFMjUzOiBOb21icmUgZGVsIGNvbmp1bnRvIGRlIHRpcG9ncmFmw61hcyBkZSBpbXByZXNpw7NuOiAlc1xuIgogCi0jOiBndWlfeDExLmM6MjIwMgogIywgYy1mb3JtYXQKIG1zZ2lkICJGb250MDogJXNcbiIKIG1zZ3N0ciAiVGlwbyBkZSBsZXRyYSBkZSBpbXByZXNpw7NuIDA6ICVzXG4iCiAKLSM6IGd1aV94MTEuYzoyMjAzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkZvbnQxOiAlc1xuIgogbXNnc3RyICJUaXBvIGRlIGxldHJhIGRlIGltcHJlc2nDs24gMTogJXNcbiIKIAotIzogZ3VpX3gxMS5jOjIyMDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiRm9udCVsZCB3aWR0aCBpcyBub3QgdHdpY2UgdGhhdCBvZiBmb250MFxuIgogbXNnc3RyICIiCiAiTGEgYW5jaHVyYSBkZWwgdGlwbyBkZSBsZXRyYSBkZSBpbXByZXNpw7NuICVsZCBubyBlcyBlbCBkb2JsZSBkZSBsYSAiCiAiZGUgbGEgdGlwb2dyYWbDrWEgZGUgaW1wcmVzacOzbiAwXG4iCiAKLSM6IGd1aV94MTEuYzoyMjA1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkZvbnQwIHdpZHRoOiAlbGRcbiIKIG1zZ3N0ciAiQW5jaHVyYSBkZWwgdGlwbyBkZSBsZXRyYSBkZSBpbXByZXNpw7NuIDA6ICVsZFxuIgogCi0jOiBndWlfeDExLmM6MjIwNgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiRm9udDEgd2lkdGg6ICVsZFxuIgpAQCAtMjg5OSwyOTMgKzIyNTAsMjI2IEBACiAiQW5jaHVyYSBkZWwgdGlwbyBkZSBsZXRyYSBkZSBpbXByZXNpw7NuIDE6ICVsZFxuIgogIlxuIgogCi0jOiBndWlfeG1kbGcuYzo2OTAgZ3VpX3htZGxnLmM6ODA5CiBtc2dpZCAiSW52YWxpZCBmb250IHNwZWNpZmljYXRpb24iCiBtc2dzdHIgIkxhIGVzcGVjaWZpY2FjacOzbiBkZSB0aXBvIGRlIGxldHJhIG5vIGVzIHbDoWxpZGEiCiAKLSM6IGd1aV94bWRsZy5jOjY5MSBndWlfeG1kbGcuYzo4MTAKIG1zZ2lkICImRGlzbWlzcyIKIG1zZ3N0ciAiJkNlcnJhciIKIAotIzogZ3VpX3htZGxnLmM6NzAwCiBtc2dpZCAibm8gc3BlY2lmaWMgbWF0Y2giCiBtc2dzdHIgIm5vIGhheSB1bmEgY29pbmNpZGVuY2lhIGVzcGVjaWZpY2EiCiAKLSM6IGd1aV94bWRsZy5jOjkwOQogbXNnaWQgIlZpbSAtIEZvbnQgU2VsZWN0b3IiCiBtc2dzdHIgIlZpbSAtIFNlbGVjdG9yIGRlIHRpcG9zIGRlIGxldHJhIgogCi0jOiBndWlfeG1kbGcuYzo5NzgKIG1zZ2lkICJOYW1lOiIKIG1zZ3N0ciAiTm9tYnJlOiIKIAotIy4gY3JlYXRlIHRvZ2dsZSBidXR0b24KLSM6IGd1aV94bWRsZy5jOjEwMTgKIG1zZ2lkICJTaG93IHNpemUgaW4gUG9pbnRzIgogbXNnc3RyICJNb3N0cmFyIHRhbWHDsW8gZW4gcHVudG9zIgogCi0jOiBndWlfeG1kbGcuYzoxMDM3CiBtc2dpZCAiRW5jb2Rpbmc6IgogbXNnc3RyICJDb2RpZmljYW5kbzoiCiAKLSM6IGd1aV94bWRsZy5jOjEwODMKIG1zZ2lkICJGb250OiIKIG1zZ3N0ciAiVGlwbyBkZSBsZXRyYToiCiAKLSM6IGd1aV94bWRsZy5jOjExMTYKIG1zZ2lkICJTdHlsZToiCiBtc2dzdHIgIkVzdGlsbzoiCiAKLSM6IGd1aV94bWRsZy5jOjExNDgKIG1zZ2lkICJTaXplOiIKIG1zZ3N0ciAiVGFtYcOxbzoiCiAKLSM6IGhhbmd1bGluLmM6NjEwCiBtc2dpZCAiRTI1NjogSGFuZ3VsIGF1dG9tYXRhIEVSUk9SIgogbXNnc3RyICJFMjU2OiBFUlJPUiBkZWwgYXV0w7NtYXRhIEhhbmd1bCIKIAotIzogaGFyZGNvcHkuYzoyMTAKIG1zZ2lkICJFNTUwOiBNaXNzaW5nIGNvbG9uIgogbXNnc3RyICJFNTUwOiBGYWx0YSB1biBzw61tYm9sbyBkZSBkb3MgcHVudG9zIgogCi0jOiBoYXJkY29weS5jOjIyMgogbXNnaWQgIkU1NTE6IElsbGVnYWwgY29tcG9uZW50IgogbXNnc3RyICJFNTUxOiBDb21wb25lbnRlIGlsZWdhbCIKIAotIzogaGFyZGNvcHkuYzoyMzAKIG1zZ2lkICJFNTUyOiBkaWdpdCBleHBlY3RlZCIKIG1zZ3N0ciAiRTU1MjogU2UgZXNwZXJhYmEgdW4gZMOtZ2l0byIKIAotIzogaGFyZGNvcHkuYzo1MDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiUGFnZSAlZCIKIG1zZ3N0ciAiUMOhZ2luYSAlZCIKIAotIzogaGFyZGNvcHkuYzo2NTgKIG1zZ2lkICJObyB0ZXh0IHRvIGJlIHByaW50ZWQiCiBtc2dzdHIgIk5vIGhheSB0ZXh0byBxdWUgaW1wcmltaXIiCiAKLSM6IGhhcmRjb3B5LmM6NzM2CiAjLCBjLWZvcm1hdAogbXNnaWQgIlByaW50aW5nIHBhZ2UgJWQgKCVkJSUpIgogbXNnc3RyICJJbXByaW1pZW5kbyBsYSBww6FnaW5hICVkICglZCUlKSIKIAotIzogaGFyZGNvcHkuYzo3NDgKICMsIGMtZm9ybWF0CiBtc2dpZCAiIENvcHkgJWQgb2YgJWQiCiBtc2dzdHIgIkNvcGlhICVkIGRlICVkIgogCi0jOiBoYXJkY29weS5jOjgwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJQcmludGVkOiAlcyIKIG1zZ3N0ciAiSW1wcmVzbzogJXMiCiAKLSM6IGhhcmRjb3B5LmM6ODE0CiBtc2dpZCAiUHJpbnRpbmcgYWJvcnRlZCIKIG1zZ3N0ciAiSW1wcmVzacOzbiBpbnRlcnJ1bXBpZGEiCiAKLSM6IGhhcmRjb3B5LmM6MTQ2OQogbXNnaWQgIkU0NTU6IEVycm9yIHdyaXRpbmcgdG8gUG9zdFNjcmlwdCBvdXRwdXQgZmlsZSIKIG1zZ3N0ciAiRTQ1NTogRXJyb3IgZXNjcmliaWVuZG8gYWwgYXJjaGl2byBQb3N0U2NyaXB0IGRlIHNhbGlkYSIKIAotIzogaGFyZGNvcHkuYzoxOTMxCiAjLCBjLWZvcm1hdAogbXNnaWQgIkU2MjQ6IENhbid0IG9wZW4gZmlsZSBcIiVzXCIiCiBtc2dzdHIgIkU2MjQ6IE5vIHNlIHB1ZG8gYWJyaXIgZWwgYXJjaGl2byBcIiVzXCIiCiAKLSM6IGhhcmRjb3B5LmM6MTk0MSBoYXJkY29weS5jOjI4MjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTQ1NzogQ2FuJ3QgcmVhZCBQb3N0U2NyaXB0IHJlc291cmNlIGZpbGUgXCIlc1wiIgogbXNnc3RyICJFNDU3OiBObyBzZSBwdWRvIGxlZXIgZWwgYXJjaGl2byBkZSByZWN1cnNvcyBkZSBQb3N0U2NyaXB0IFwiJXNcIiIKIAotIzogaGFyZGNvcHkuYzoxOTU3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkU2MTg6IGZpbGUgXCIlc1wiIGlzIG5vdCBhIFBvc3RTY3JpcHQgcmVzb3VyY2UgZmlsZSIKIG1zZ3N0ciAiRTYxODogRWwgYXJjaGl2byBcIiVzXCIgbm8gZXMgdW4gYXJjaGl2byBkZSByZWN1cnNvcyBQb3N0U2NyaXB0IgogCi0jOiBoYXJkY29weS5jOjE5NzUgaGFyZGNvcHkuYzoxOTk0IGhhcmRjb3B5LmM6MjAzNwogIywgYy1mb3JtYXQKIG1zZ2lkICJFNjE5OiBmaWxlIFwiJXNcIiBpcyBub3QgYSBzdXBwb3J0ZWQgUG9zdFNjcmlwdCByZXNvdXJjZSBmaWxlIgogbXNnc3RyICJFNjE5OiBFbCBhcmNoaXZvIFwiJXNcIiBubyBlcyB1biByZWN1cnNvIFBvc3RTY3JpcHQgcXVlIHB1ZWRhIHVzYXIiCiAKLSM6IGhhcmRjb3B5LmM6MjA1NgogIywgYy1mb3JtYXQKIG1zZ2lkICJFNjIxOiBcIiVzXCIgcmVzb3VyY2UgZmlsZSBoYXMgd3JvbmcgdmVyc2lvbiIKIG1zZ3N0ciAiRTYyMTogTGEgdmVyc2nDs24gZGVsIGFyY2hpdm8gZGUgcmVjdXJzb3MgXCIlc1wiIGVzIGluY29ycmVjdGEiCiAKLSM6IGhhcmRjb3B5LmM6MjU0MwogbXNnaWQgIkU2NzM6IEluY29tcGF0aWJsZSBtdWx0aS1ieXRlIGVuY29kaW5nIGFuZCBjaGFyYWN0ZXIgc2V0LiIKIG1zZ3N0ciAiRTY3MzogQ29kaWZpY2FjacOzbiB5IHNldCBkZSBjYXJhY3RlcmVzIG11bHRpLWJ5dGUgaW5jb21wYXRpYmxlcyIKIAotIzogaGFyZGNvcHkuYzoyNTYwCiBtc2dpZCAiRTY3NDogcHJpbnRtYmNoYXJzZXQgY2Fubm90IGJlIGVtcHR5IHdpdGggbXVsdGktYnl0ZSBlbmNvZGluZy4iCiBtc2dzdHIgIiIKICJFNjc0OiBcInByaW50bWJjaGFyc2V0XCIgbm8gcHVlZGUgZXN0YXIgdmFjw61vIGVuIHVuYSBjb2RpZmljYWNpw7NuIG11bHRpLWJ5dGUiCiAKLSM6IGhhcmRjb3B5LmM6MjU3OAogbXNnaWQgIkU2NzU6IE5vIGRlZmF1bHQgZm9udCBzcGVjaWZpZWQgZm9yIG11bHRpLWJ5dGUgcHJpbnRpbmcuIgogbXNnc3RyICIiCiAiRTY3NTogTm8gc2UgaGEgZGVmaW5pZG8gdW4gdGlwbyBkZSBsZXRyYSBwcmVkZXRlcm1pbmFkbyBwYXJhIGltcHJlc2nDs24gIgogIm11bHRpLWJ5dGUiCiAKLSM6IGhhcmRjb3B5LmM6Mjc3MQogbXNnaWQgIkUzMjQ6IENhbid0IG9wZW4gUG9zdFNjcmlwdCBvdXRwdXQgZmlsZSIKIG1zZ3N0ciAiRTMyNDogTm8gc2UgcHVkbyBhYnJpciBlbCBhcmNoaXZvIFBvc3RTY3JpcHQgZGUgc2FsaWRhIgogCi0jOiBoYXJkY29weS5jOjI4MDgKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTQ1NjogQ2FuJ3Qgb3BlbiBmaWxlIFwiJXNcIiIKIG1zZ3N0ciAiRTQ1NjogTm8gc2UgcHVkbyBhYnJpciBlbCBhcmNoaXZvICVzIgogCi0jOiBoYXJkY29weS5jOjI5NDIKIG1zZ2lkICJFNDU2OiBDYW4ndCBmaW5kIFBvc3RTY3JpcHQgcmVzb3VyY2UgZmlsZSBcInByb2xvZy5wc1wiIgogbXNnc3RyICJFNDU2OiBObyBzZSBlbmNvbnRyw7MgZWwgYXJjaGl2byBkZSByZWN1cnNvcyBQb3N0U2NyaXB0IFwicHJvbG9nLnBzXCIiCiAKLSM6IGhhcmRjb3B5LmM6Mjk1NQogbXNnaWQgIkU0NTY6IENhbid0IGZpbmQgUG9zdFNjcmlwdCByZXNvdXJjZSBmaWxlIFwiY2lkZm9udC5wc1wiIgogbXNnc3RyICJFNDU2OiBObyBzZSBlbmNvbnRyw7MgZWwgYXJjaGl2byBkZSByZWN1cnNvcyBQb3N0U2NyaXB0IFwiY2lkZm9udC5wc1wiIgogCi0jOiBoYXJkY29weS5jOjI5OTMgaGFyZGNvcHkuYzozMDE1IGhhcmRjb3B5LmM6MzA0NAogIywgYy1mb3JtYXQKIG1zZ2lkICJFNDU2OiBDYW4ndCBmaW5kIFBvc3RTY3JpcHQgcmVzb3VyY2UgZmlsZSBcIiVzLnBzXCIiCiBtc2dzdHIgIkU0NTY6IE5vIHNlIGVuY29udHLDsyBlbCBhcmNoaXZvIGRlIHJlY3Vyc29zIFBvc3RTY3JpcHQgXCIlcy5wc1wiIgogCi0jOiBoYXJkY29weS5jOjMwMzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTYyMDogVW5hYmxlIHRvIGNvbnZlcnQgdG8gcHJpbnQgZW5jb2RpbmcgXCIlc1wiIgogbXNnc3RyICJFNjIwOiBObyBzZSBwdWRvIGNvbnZlcnRpciBhIGxhIGNvZGlmaWNhY2nDs24gZGUgaW1wcmVzacOzbiBcIiVzXCIiCiAKLSM6IGhhcmRjb3B5LmM6MzI4NQogbXNnaWQgIlNlbmRpbmcgdG8gcHJpbnRlci4uLiIKIG1zZ3N0ciAiRW52aWFuZG8gYSBsYSBpbXByZXNvcmEuLi4iCiAKLSM6IGhhcmRjb3B5LmM6MzI4OQogbXNnaWQgIkUzNjU6IEZhaWxlZCB0byBwcmludCBQb3N0U2NyaXB0IGZpbGUiCiBtc2dzdHIgIkUzNjU6IEZhbGzDsyBsYSBpbXByZXNpw7NuIGRlbCBhcmNoaXZvIFBvc3RTY3JpcHQiCiAKLSM6IGhhcmRjb3B5LmM6MzI5MQogbXNnaWQgIlByaW50IGpvYiBzZW50LiIKIG1zZ3N0ciAiU2UgaGEgZW52aWFkbyBsYSB0YXJlYSBkZSBpbXByZXNpw7NuLiIKIAotIzogaWZfY3Njb3BlLmM6NzcKIG1zZ2lkICJBZGQgYSBuZXcgZGF0YWJhc2UiCiBtc2dzdHIgIkHDsWFkaXIgdW5hIG51ZXZhIGJhc2UgZGUgZGF0b3MiCiAKLSM6IGlmX2NzY29wZS5jOjc5CiBtc2dpZCAiUXVlcnkgZm9yIGEgcGF0dGVybiIKIG1zZ3N0ciAiUGV0aWNpw7NuIGRlIHVuIHBhdHLDs24iCiAKLSM6IGlmX2NzY29wZS5jOjgxCiBtc2dpZCAiU2hvdyB0aGlzIG1lc3NhZ2UiCiBtc2dzdHIgIk1vc3RyYXIgZXN0ZSBtZW5zYWplIgogCi0jOiBpZl9jc2NvcGUuYzo4MwogbXNnaWQgIktpbGwgYSBjb25uZWN0aW9uIgogbXNnc3RyICJNYXRhciB1bmEgY29uZXhpw7NuIgogCi0jOiBpZl9jc2NvcGUuYzo4NQogbXNnaWQgIlJlaW5pdCBhbGwgY29ubmVjdGlvbnMiCiBtc2dzdHIgIlJlaW5pY2lhciB0b2RhcyBsYXMgY29uZXhpb25lcyIKIAotIzogaWZfY3Njb3BlLmM6ODcKIG1zZ2lkICJTaG93IGNvbm5lY3Rpb25zIgogbXNnc3RyICJNb3N0cmFyIGxhcyBjb25leGlvbmVzIgogCi0jOiBpZl9jc2NvcGUuYzo5NQogIywgYy1mb3JtYXQKIG1zZ2lkICJFNTYwOiBVc2FnZTogY3NbY29wZV0gJXMiCiBtc2dzdHIgIkU1NjA6IEZvcm1hIGRlIHVzbzogY3NbY29wZV0gJXMiCiAKLSM6IGlmX2NzY29wZS5jOjIzNgogbXNnaWQgIlRoaXMgY3Njb3BlIGNvbW1hbmQgZG9lcyBub3Qgc3VwcG9ydCBzcGxpdHRpbmcgdGhlIHdpbmRvdy5cbiIKIG1zZ3N0ciAiRXN0YSBvcmRlbiBcImNzY29wZVwiIG5vIGFkbWl0ZSBsYSBkaXZpc2nDs24gZGUgbGEgdmVudGFuYS5cbiIKIAotIzogaWZfY3Njb3BlLmM6Mjg3CiBtc2dpZCAiRTU2MjogVXNhZ2U6IGNzdGFnIDxpZGVudD4iCiBtc2dzdHIgIkU1NjI6IEZvcm1hIGRlIHVzbzogY3N0YWcgPGlkZW50aWZpY2Fkb3I+IgogCi0jOiBpZl9jc2NvcGUuYzozNDUKIG1zZ2lkICJFMjU3OiBjc3RhZzogdGFnIG5vdCBmb3VuZCIKIG1zZ3N0ciAiRTI1NzogY3N0YWc6IG5vIHNlIGVuY29udHLDsyBsYSBldGlxdWV0YSIKIAotIzogaWZfY3Njb3BlLmM6NTE1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkU1NjM6IHN0YXQoJXMpIGVycm9yOiAlZCIKIG1zZ3N0ciAiRTU2MzogRXJyb3IgZW4gc3RhdCglcyk6ICVkIgogCi0jOiBpZl9jc2NvcGUuYzo1MjUKIG1zZ2lkICJFNTYzOiBzdGF0IGVycm9yIgogbXNnc3RyICJFNTYzOiBlcnJvciBlbiBsYSBmdW5jacOzbiBcInN0YXRcIiIKIAotIzogaWZfY3Njb3BlLmM6NjIyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkU1NjQ6ICVzIGlzIG5vdCBhIGRpcmVjdG9yeSBvciBhIHZhbGlkIGNzY29wZSBkYXRhYmFzZSIKIG1zZ3N0ciAiRTU2NDogXCIlc1wiIG5vIGVzIHVuIGRpcmVjdG9yaW8gbmkgdW5hIGJhc2UgZGUgZGF0b3MgdsOhbGlkYSBkZSBjc2NvcGUiCiAKLSM6IGlmX2NzY29wZS5jOjY0MAogIywgYy1mb3JtYXQKIG1zZ2lkICJBZGRlZCBjc2NvcGUgZGF0YWJhc2UgJXMiCiBtc2dzdHIgIlNlIGhhIGHDsWFkaWRvIGxhIGJhc2UgZGUgZGF0b3MgXCJjc2NvcGVcIiAlcyIKIAotIzogaWZfY3Njb3BlLmM6Njk1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkUyNjI6IGVycm9yIHJlYWRpbmcgY3Njb3BlIGNvbm5lY3Rpb24gJWxkIgogbXNnc3RyICJFMjYyOiBFcnJvciBhbCBsZWVyIGxhIGNvbmV4acOzbiAlbGQgY29uIFwiY3Njb3BlXCIiCiAKLSM6IGlmX2NzY29wZS5jOjgwMgogbXNnaWQgIkU1NjE6IHVua25vd24gY3Njb3BlIHNlYXJjaCB0eXBlIgogbXNnc3RyICJFNTYxOiBUaXBvIGRlIGLDunNxdWVkYSBkZXNjb25vY2lkbyBwYXJhIFwiY3Njb3BlXCIiCiAKLSM6IGlmX2NzY29wZS5jOjg2NiBpZl9jc2NvcGUuYzo5MDUKIG1zZ2lkICJFNTY2OiBDb3VsZCBub3QgY3JlYXRlIGNzY29wZSBwaXBlcyIKIG1zZ3N0ciAiRTU2NjogRmFsbMOzIGxhIGNvbmV4acOzbiBcInBpcGVcIiBwYXJhIGNvbXVuaWNhcnNlIGNvbiBcImNzY29wZVwiIgogCi0jOiBpZl9jc2NvcGUuYzo4ODIKIG1zZ2lkICJFNjIyOiBDb3VsZCBub3QgZm9yayBmb3IgY3Njb3BlIgogbXNnc3RyICIiCiAiRTYyMjogTm8gc2UgcHVkbyBjcmVhciB1biBudWV2byBwcm9jZXNvIChcImZvcmtcIikgcGFyYSB1c2FyIFwiY3Njb3BlXCIiCiAKLSM6IGlmX2NzY29wZS5jOjk5MiBpZl9jc2NvcGUuYzoxMDI5CiBtc2dpZCAiY3NfY3JlYXRlX2Nvbm5lY3Rpb24gZXhlYyBmYWlsZWQiCiBtc2dzdHIgIkZhbGzDsyBsYSBlamVjdWNpw7NuIGRlIFwiY3NfY3JlYXRlX2Nvbm5lY3Rpb25cIiIKIAotIzogaWZfY3Njb3BlLmM6MTAwMiBpZl9jc2NvcGUuYzoxMDQyCiBtc2dpZCAiY3NfY3JlYXRlX2Nvbm5lY3Rpb246IGZkb3BlbiBmb3IgdG9fZnAgZmFpbGVkIgogbXNnc3RyICJcImNzX2NyZWF0ZV9jb25uZWN0aW9uXCI6IEZhbGzDsyBcImZkb3BlblwiIHBhcmEgXCJ0b19mcFwiIgogCi0jOiBpZl9jc2NvcGUuYzoxMDA0IGlmX2NzY29wZS5jOjEwNDYKIG1zZ2lkICJjc19jcmVhdGVfY29ubmVjdGlvbjogZmRvcGVuIGZvciBmcl9mcCBmYWlsZWQiCiBtc2dzdHIgIlwiY3NfY3JlYXRlX2Nvbm5lY3Rpb25cIjogRmFsbMOzIFwiZmRvcGVuXCIgcGFyYSBcImZyX2ZwXCIiCiAKLSM6IGlmX2NzY29wZS5jOjEwMzAKIG1zZ2lkICJFNjIzOiBDb3VsZCBub3Qgc3Bhd24gY3Njb3BlIHByb2Nlc3MiCiBtc2dzdHIgIkU2MjM6IE5vIHNlIHB1ZG8gY3JlYXIgdW4gbnVldm8gcHJvY2VzbyAoXCJzcGF3blwiKSBkZSBcImNzY29wZVwiIgogCi0jOiBpZl9jc2NvcGUuYzoxMDc0CiBtc2dpZCAiRTU2Nzogbm8gY3Njb3BlIGNvbm5lY3Rpb25zIgogbXNnc3RyICJFNTY3OiBObyBoYXkgY29uZXhpb25lcyBjb24gXCJjc2NvcGVcIiIKIAotIzogaWZfY3Njb3BlLmM6MTE1NAogIywgYy1mb3JtYXQKIG1zZ2lkICJFMjU5OiBubyBtYXRjaGVzIGZvdW5kIGZvciBjc2NvcGUgcXVlcnkgJXMgb2YgJXMiCiBtc2dzdHIgIiIKICJFMjU5OiBObyBzZSBlbmNvbnRyYXJvbiBjb2luY2lkZW5jaWFzIHBhcmEgbGEgYsO6c3F1ZWRhIFwiY3Njb3BlXCIgJXMgZGUgJXMiCiAKLSM6IGlmX2NzY29wZS5jOjEyMTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTQ2OTogaW52YWxpZCBjc2NvcGVxdWlja2ZpeCBmbGFnICVjIGZvciAlYyIKIG1zZ3N0ciAiRTQ2OTogTGEgbWFyY2EgXCJjc2NvcGVxdWlja2ZpeFwiICVjIHBhcmEgJWMgbm8gZXMgdsOhbGlkYSIKIAotIzogaWZfY3Njb3BlLmM6MTMwNwogbXNnaWQgImNzY29wZSBjb21tYW5kczpcbiIKIG1zZ3N0ciAiw7NyZGVuZXMgZGUgXCJjc2NvcGVcIjpcbiIKIAotIzogaWZfY3Njb3BlLmM6MTMxNgogIywgYy1mb3JtYXQKIG1zZ2lkICIlLTVzOiAlcyUqcyAoVXNhZ2U6ICVzKSIKIG1zZ3N0ciAiJS01czogJXMlKnMgKE1vZG8gZGUgdXNvOiAlcykiCiAKLSM6IGlmX2NzY29wZS5jOjEzMjEKIG1zZ2lkICIiCiAiXG4iCiAiICAgICAgIGM6IEZpbmQgZnVuY3Rpb25zIGNhbGxpbmcgdGhpcyBmdW5jdGlvblxuIgpAQCAtMzIwNyw0MiArMjQ5MSwzMyBAQAogIiAgICAgICBzOiBFbmNvbnRyYXIgZXN0ZSBzw61tYm9sbyBkZSBDXG4iCiAiICAgICAgIHQ6IEVuY29udHJhciBhc2lnbmFjaW9uZXMgYVxuIgogCi0jOiBpZl9jc2NvcGUuYzoxNDA5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkU2MjU6IGNhbm5vdCBvcGVuIGNzY29wZSBkYXRhYmFzZTogJXMiCiBtc2dzdHIgIkU2MjU6IE5vIHNlIHB1ZG8gYWJyaXIgbGEgYmFzZSBkZSBkYXRvcyBcImNzY29wZVwiOiAlcyIKIAotIzogaWZfY3Njb3BlLmM6MTQyNwogbXNnaWQgIkU2MjY6IGNhbm5vdCBnZXQgY3Njb3BlIGRhdGFiYXNlIGluZm9ybWF0aW9uIgogbXNnc3RyICIiCiAiRTYyNjogTm8gc2UgcHVkbyBvYnRlbmVyIGluZm9ybWFjacOzbiBhY2VyY2EgZGUgbGEgYmFzZSBkZSBkYXRvcyBcImNzY29wZVwiIgogCi0jOiBpZl9jc2NvcGUuYzoxNDUyCiBtc2dpZCAiRTU2ODogZHVwbGljYXRlIGNzY29wZSBkYXRhYmFzZSBub3QgYWRkZWQiCiBtc2dzdHIgIkU1Njg6IEludGVudMOzIGHDsWFkaXIgdW5hIGJhc2UgZGUgZGF0b3MgZGUgXCJjc2NvcGVcIiBkdXBsaWNhZGEiCiAKLSM6IGlmX2NzY29wZS5jOjE1OTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTI2MTogY3Njb3BlIGNvbm5lY3Rpb24gJXMgbm90IGZvdW5kIgogbXNnc3RyICJFMjYxOiBObyBzZSBoYSBlbmNvbnRyYWRvIGxhIGNvbmV4acOzbiBcImNzY29wZVwiICVzIgogCi0jOiBpZl9jc2NvcGUuYzoxNjMxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNzY29wZSBjb25uZWN0aW9uICVzIGNsb3NlZCIKIG1zZ3N0ciAiQ29uZXhpw7NuIFwiY3Njb3BlXCIgJXMgY2VycmFkYSIKIAogIyBzaG91bGQgbm90IHJlYWNoIGhlcmUKLSMuIHNob3VsZCBub3QgcmVhY2ggaGVyZQotIzogaWZfY3Njb3BlLmM6MTc3MQogbXNnaWQgIkU1NzA6IGZhdGFsIGVycm9yIGluIGNzX21hbmFnZV9tYXRjaGVzIgogbXNnc3RyICJFNTcwOiBFcnJvciBmYXRhbCBlbiBcImNzX21hbmFnZV9tYXRjaGVzXCIiCiAKLSM6IGlmX2NzY29wZS5jOjIwMzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ3Njb3BlIHRhZzogJXMiCiBtc2dzdHIgIkV0aXF1ZXRhIGRlIFwiY3Njb3BlXCI6ICVzIgogCi0jOiBpZl9jc2NvcGUuYzoyMDU1CiBtc2dpZCAiIgogIlxuIgogIiAgICMgICBsaW5lIgpAQCAtMzI1MCwyOCArMjUyNSwyMiBAQAogIlxuIgogIiAgICMgICBsw61uZWEiCiAKLSM6IGlmX2NzY29wZS5jOjIwNTcKIG1zZ2lkICJmaWxlbmFtZSAvIGNvbnRleHQgLyBsaW5lXG4iCiBtc2dzdHIgIm5vbWJyZSBkZWwgYXJjaGl2byAvIGNvbnRleHRvIC8gbMOtbmVhXG4iCiAKLSM6IGlmX2NzY29wZS5jOjIxNjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTYwOTogQ3Njb3BlIGVycm9yOiAlcyIKIG1zZ3N0ciAiRTYwOTogRXJyb3IgZGUgXCJjc2NvcGVcIjogJXMiCiAKLSM6IGlmX2NzY29wZS5jOjI0MzgKIG1zZ2lkICJBbGwgY3Njb3BlIGRhdGFiYXNlcyByZXNldCIKIG1zZ3N0ciAiU2UgaGFuIHZhY2lhZG8gdG9kYXMgbGFzIGJhc2VzIGRlIGRhdG9zIGRlIFwiY3Njb3BlXCIiCiAKLSM6IGlmX2NzY29wZS5jOjI1MDUKIG1zZ2lkICJubyBjc2NvcGUgY29ubmVjdGlvbnNcbiIKIG1zZ3N0ciAibm8gaGF5IGNvbmV4aW9uZXMgXCJjc2NvcGVcIlxuIgogCi0jOiBpZl9jc2NvcGUuYzoyNTA5CiBtc2dpZCAiICMgcGlkICAgIGRhdGFiYXNlIG5hbWUgICAgICAgICAgICAgICAgICAgICAgIHByZXBlbmQgcGF0aFxuIgogbXNnc3RyICIgbsK6IHBpZCAgICBiYXNlIGRlIGRhdG9zICAgICAgICAgICAgICAgICAgICAgICBwcmVmaWpvIHJ1dGFcbiIKIAotIzogaWZfbXpzY2guYzoxMDQ1CiBtc2dpZCAiIgogIkU4MTU6IFNvcnJ5LCB0aGlzIGNvbW1hbmQgaXMgZGlzYWJsZWQsIHRoZSBNelNjaGVtZSBsaWJyYXJpZXMgY291bGQgbm90IGJlICIKICJsb2FkZWQuIgpAQCAtMzI3OSw4MSArMjU0OCw1NyBAQAogIkU4MTU6IExvIHNpZW50bywgZXN0YSBvcmRlbiBlc3TDoSBkZXNhY3RpdmFkYSwgbm8gc2UgcHVkbyBjYXJnYXIgbGFzICIKICJiaWJsaW90ZWNhcyBkZSBNelNjaGVtZSIKIAotIzogaWZfbXpzY2guYzoxNDY5IGlmX3B5dGhvbi5jOjEyNzEgaWZfdGNsLmM6MTQwNAogbXNnaWQgImludmFsaWQgZXhwcmVzc2lvbiIKIG1zZ3N0ciAiZXhwcmVzacOzbiBubyB2w6FsaWRhIgogCi0jOiBpZl9tenNjaC5jOjE0NzcgaWZfcHl0aG9uLmM6MTI5MCBpZl90Y2wuYzoxNDA5CiBtc2dpZCAiZXhwcmVzc2lvbnMgZGlzYWJsZWQgYXQgY29tcGlsZSB0aW1lIgogbXNnc3RyICJleHByZXNpb25lcyBkZXNhY3RpdmFkYXMgYWwgY29tcGlsYXIiCiAKLSM6IGlmX216c2NoLmM6MTU2NgogbXNnaWQgImhpZGRlbiBvcHRpb24iCiBtc2dzdHIgIm9wY2nDs24gb2N1bHRhIgogCi0jOiBpZl9tenNjaC5jOjE1NjggaWZfdGNsLmM6NTAxCiBtc2dpZCAidW5rbm93biBvcHRpb24iCiBtc2dzdHIgIm9wY2nDs24gZGVzY29ub2NpZGEiCiAKLSM6IGlmX216c2NoLmM6MTcyNwogbXNnaWQgIndpbmRvdyBpbmRleCBpcyBvdXQgb2YgcmFuZ2UiCiBtc2dzdHIgImluZGljZSBkZSB2ZW50YW5hIGZ1ZXJhIGRlbCByYW5nbyIKIAotIzogaWZfbXpzY2guYzoxODg3CiBtc2dpZCAiY291bGRuJ3Qgb3BlbiBidWZmZXIiCiBtc2dzdHIgIk5vIHNlIHB1ZG8gYWJyaXIgZWwgYsO6ZmVyIgogCi0jOiBpZl9tenNjaC5jOjIxNjcgaWZfbXpzY2guYzoyMTk3IGlmX216c2NoLmM6MjI5NCBpZl9tenNjaC5jOjIzNTgKLSM6IGlmX216c2NoLmM6MjQ3OSBpZl9tenNjaC5jOjI1MzYgaWZfcHl0aG9uLmM6MjUwOCBpZl9weXRob24uYzoyNTQyCi0jOiBpZl9weXRob24uYzoyNjAxIGlmX3B5dGhvbi5jOjI2NjggaWZfcHl0aG9uLmM6Mjc5MCBpZl9weXRob24uYzoyODQyCi0jOiBpZl90Y2wuYzo2ODQgaWZfdGNsLmM6NzI5IGlmX3RjbC5jOjgwMyBpZl90Y2wuYzo4NzUgaWZfdGNsLmM6MjAxNwogbXNnaWQgImNhbm5vdCBzYXZlIHVuZG8gaW5mb3JtYXRpb24iCiBtc2dzdHIgIk5vIHNlIHB1ZG8gZ3VhcmRhciBsYSBpbmZvcm1hY2nDs24gcGFyYSBkZXNoYWNlciIKIAotIzogaWZfbXpzY2guYzoyMTcyIGlmX216c2NoLmM6MjMwMiBpZl9tenNjaC5jOjIzNzIgaWZfcHl0aG9uLmM6MjUxMAotIzogaWZfcHl0aG9uLmM6MjYwOCBpZl9weXRob24uYzoyNjc5CiBtc2dpZCAiY2Fubm90IGRlbGV0ZSBsaW5lIgogbXNnc3RyICJubyBwdWVkbyBzdXByaW1pciBsYSBsw61uZWEiCiAKLSM6IGlmX216c2NoLmM6MjIwMyBpZl9tenNjaC5jOjIzODcgaWZfcHl0aG9uLmM6MjU0NyBpZl9weXRob24uYzoyNjk1Ci0jOiBpZl90Y2wuYzo2OTAgaWZfdGNsLmM6MjAzOQogbXNnaWQgImNhbm5vdCByZXBsYWNlIGxpbmUiCiBtc2dzdHIgIm5vIHNlIHB1ZG8gcmVlbXBsYXphciBsYSBsw61uZWEiCiAKLSM6IGlmX216c2NoLmM6MjQwMiBpZl9tenNjaC5jOjI0ODUgaWZfbXpzY2guYzoyNTQ2IGlmX3B5dGhvbi5jOjI3MTMKLSM6IGlmX3B5dGhvbi5jOjI3OTIgaWZfcHl0aG9uLmM6Mjg1MAogbXNnaWQgImNhbm5vdCBpbnNlcnQgbGluZSIKIG1zZ3N0ciAibm8gc2UgcHVkbyBpbnNlcnRhciBsYSBsw61uZWEiCiAKLSM6IGlmX216c2NoLmM6MjYzNyBpZl9weXRob24uYzoyOTYyCiBtc2dpZCAic3RyaW5nIGNhbm5vdCBjb250YWluIG5ld2xpbmVzIgogbXNnc3RyICJMYSBjYWRlbmEgbm8gcHVlZGUgY29udGVuZXIgcXVpZWJyZXMgZGUgbMOtbmVhIgogCi0jOiBpZl9tenNjaC5jOjI4NTkKIG1zZ2lkICJWaW0gZXJyb3I6IH5hIgogbXNnc3RyICJFcnJvciBkZSBWaW06IH5hIgogCi0jOiBpZl9tenNjaC5jOjI4OTIKIG1zZ2lkICJWaW0gZXJyb3IiCiBtc2dzdHIgIkVycm9yIGRlIFZpbSIKIAotIzogaWZfbXpzY2guYzoyOTU4CiBtc2dpZCAiYnVmZmVyIGlzIGludmFsaWQiCiBtc2dzdHIgIkVsIGLDumZlciBubyBlcyB2YWxpZG8iCiAKLSM6IGlmX216c2NoLmM6Mjk2NwogbXNnaWQgIndpbmRvdyBpcyBpbnZhbGlkIgogbXNnc3RyICJMYSB2ZW50YW5hIG5vIGVzIHbDoWxpZGEiCiAKLSM6IGlmX216c2NoLmM6Mjk4NwogbXNnaWQgImxpbmVuciBvdXQgb2YgcmFuZ2UiCiBtc2dzdHIgIkVsIG7Dum1lcm8gZGUgbGEgbMOtbmVhIGVzdMOhIGZ1ZXJhIGRlbCByYW5nbyIKIAotIzogaWZfbXpzY2guYzozMTM4IGlmX216c2NoLmM6MzE4MAogbXNnaWQgIm5vdCBhbGxvd2VkIGluIHRoZSBWaW0gc2FuZGJveCIKIG1zZ3N0ciAiTm8gcGVybWl0aWRvIGVuIGxhIFwic2FuZGJveFwiIGRlIHZpbSIKIAotIzogaWZfcHl0aG9uLmM6NTE3CiBtc2dpZCAiIgogIkUyNjM6IFNvcnJ5LCB0aGlzIGNvbW1hbmQgaXMgZGlzYWJsZWQsIHRoZSBQeXRob24gbGlicmFyeSBjb3VsZCBub3QgYmUgIgogImxvYWRlZC4iCkBAIC0zMzYxLDE3MSArMjYwNiwxMjggQEAKICJFMjYzOiBMbyBzaWVudG8sIGVzdGEgb3JkZW4gZXN0w6EgZGVzYWN0aXZhZGEsIG5vIHNlIHB1ZG8gY2FyZ2FyIGxhICIKICJiaWJsaW90ZWNhIGRlIFB5dGhvbiIKIAotIzogaWZfcHl0aG9uLmM6NTgzCiBtc2dpZCAiRTY1OTogQ2Fubm90IGludm9rZSBQeXRob24gcmVjdXJzaXZlbHkiCiBtc2dzdHIgIkU2NTk6IE5vIHNlIHB1ZG8gaW52b2NhciBhIFB5dGhvbiByZWN1cnNpdmFtZW50ZSIKIAotIzogaWZfcHl0aG9uLmM6Nzc2CiBtc2dpZCAiY2FuJ3QgZGVsZXRlIE91dHB1dE9iamVjdCBhdHRyaWJ1dGVzIgogbXNnc3RyICJObyBzZSBwdWVkZW4gYm9ycmFyIGxvcyBhdHJpYnV0b3MgZGUgXCJPdXRwdXRPYmplY3RcIiIKIAotIzogaWZfcHl0aG9uLmM6NzgzCiBtc2dpZCAic29mdHNwYWNlIG11c3QgYmUgYW4gaW50ZWdlciIKIG1zZ3N0ciAiXCJzb2Z0c3BhY2VcIiBkZWJlIHNlciB1biBlbnRlcm8iCiAKLSM6IGlmX3B5dGhvbi5jOjc5MQogbXNnaWQgImludmFsaWQgYXR0cmlidXRlIgogbXNnc3RyICJBdHJpYnV0byBubyB2w6FsaWRvIgogCi0jOiBpZl9weXRob24uYzo4MzAgaWZfcHl0aG9uLmM6ODQ0CiBtc2dpZCAid3JpdGVsaW5lcygpIHJlcXVpcmVzIGxpc3Qgb2Ygc3RyaW5ncyIKIG1zZ3N0ciAiXCJ3cml0ZWxpbmVzKClcIiByZXF1aWVyZSB1bmEgbGlzdGEgZGUgY2FkZW5hcyIKIAotIzogaWZfcHl0aG9uLmM6OTcwCiBtc2dpZCAiRTI2NDogUHl0aG9uOiBFcnJvciBpbml0aWFsaXNpbmcgSS9PIG9iamVjdHMiCiBtc2dzdHIgIkUyNjQ6IFB5dGhvbjogZXJyb3IgZGUgaW5pY2lhY2nDs24gZGUgbG9zIG9iamV0b3MgZGUgSS9PIgogCi0jOiBpZl9weXRob24uYzoxMzAzCiBtc2dpZCAiYXR0ZW1wdCB0byByZWZlciB0byBkZWxldGVkIGJ1ZmZlciIKIG1zZ3N0ciAiSW50ZW50byBkZSByZWZlcmlyc2UgYSB1biBiw7pmZXIgc3VwcmltaWRvIgogCi0jOiBpZl9weXRob24uYzoxMzE4IGlmX3B5dGhvbi5jOjEzNTkgaWZfcHl0aG9uLmM6MTQyMyBpZl90Y2wuYzoxMjE2CiBtc2dpZCAibGluZSBudW1iZXIgb3V0IG9mIHJhbmdlIgogbXNnc3RyICJFbCBuw7ptZXJvIGRlIGxhIGzDrW5lYSBlc3TDoSBmdWVyYSBkZWwgcmFuZ28iCiAKLSM6IGlmX3B5dGhvbi5jOjE1NTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiPGJ1ZmZlciBvYmplY3QgKGRlbGV0ZWQpIGF0ICVwPiIKIG1zZ3N0ciAiPG9iamV0byBkZSBiw7pmZXIgKHN1cHJpbWlkbykgZW4gJXA+IgogCi0jOiBpZl9weXRob24uYzoxNjQ5IGlmX3RjbC5jOjgzNgogbXNnaWQgImludmFsaWQgbWFyayBuYW1lIgogbXNnc3RyICJOb21icmUgZGUgbWFyY2Egbm8gdsOhbGlkbyIKIAotIzogaWZfcHl0aG9uLmM6MTkyNwogbXNnaWQgIm5vIHN1Y2ggYnVmZmVyIgogbXNnc3RyICJObyBleGlzdGUgdGFsIGLDumZlciIKIAotIzogaWZfcHl0aG9uLmM6MjAxNQogbXNnaWQgImF0dGVtcHQgdG8gcmVmZXIgdG8gZGVsZXRlZCB3aW5kb3ciCiBtc2dzdHIgIkludGVudG8gZGUgcmVmZXJpcnNlIGEgdW5hIHZlbnRhbmEgc3VwcmltaWRhIgogCi0jOiBpZl9weXRob24uYzoyMDYwCiBtc2dpZCAicmVhZG9ubHkgYXR0cmlidXRlIgogbXNnc3RyICJBdHJpYnV0byBkZSBzb2xvIGxlY3R1cmEiCiAKLSM6IGlmX3B5dGhvbi5jOjIwNzQKIG1zZ2lkICJjdXJzb3IgcG9zaXRpb24gb3V0c2lkZSBidWZmZXIiCiBtc2dzdHIgIlBvc2ljacOzbiBkZWwgY3Vyc29yIGZ1ZXJhIGRlbCBiw7pmZXIiCiAKLSM6IGlmX3B5dGhvbi5jOjIxNTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiPHdpbmRvdyBvYmplY3QgKGRlbGV0ZWQpIGF0ICVwPiIKIG1zZ3N0ciAiPG9iamV0byB2ZW50YW5hIChzdXByaW1pZG8pIGVuICVwPiIKIAotIzogaWZfcHl0aG9uLmM6MjE2OQogIywgYy1mb3JtYXQKIG1zZ2lkICI8d2luZG93IG9iamVjdCAodW5rbm93bikgYXQgJXA+IgogbXNnc3RyICI8b2JqZXRvIHZlbnRhbmEgKGRlc2Nvbm9jaWRvKSBlbiAlcD4iCiAKLSM6IGlmX3B5dGhvbi5jOjIxNzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiPHdpbmRvdyAlZD4iCiBtc2dzdHIgIjx2ZW50YW5hICVkPiIKIAotIzogaWZfcHl0aG9uLmM6MjI0NgogbXNnaWQgIm5vIHN1Y2ggd2luZG93IgogbXNnc3RyICJObyBleGlzdGUgdGFsIHZlbnRhbmEiCiAKLSM6IGlmX3J1YnkuYzozNjUKIG1zZ2lkICJFMjY1OiAkXyBtdXN0IGJlIGFuIGluc3RhbmNlIG9mIFN0cmluZyIKIG1zZ3N0ciAiRTI2NTogJF8gZGViZSBzZXIgdW5hIGluc3RhbmNpYSBkZSBcIlN0cmluZ1wiIgogCi0jOiBpZl9ydWJ5LmM6NDI2CiBtc2dpZCAiIgogIkUyNjY6IFNvcnJ5LCB0aGlzIGNvbW1hbmQgaXMgZGlzYWJsZWQsIHRoZSBSdWJ5IGxpYnJhcnkgY291bGQgbm90IGJlIGxvYWRlZC4iCiBtc2dzdHIgIiIKICJFMjY2OiBMbyBzaWVudG8sIGVzdGEgb3JkZW4gZXN0w6EgZGVzYWN0aXZhZGEsIG5vIHNlIHB1ZG8gY2FyZ2FyICIKICJsYSBiaWJsaW90ZWNhIGRlIFJ1YnkiCiAKLSM6IGlmX3J1YnkuYzo0NTUKIG1zZ2lkICJFMjY3OiB1bmV4cGVjdGVkIHJldHVybiIKIG1zZ3N0ciAiRTI2NzogXCJyZXR1cm5cIiBpbmVzcGVyYWRvIgogCi0jOiBpZl9ydWJ5LmM6NDU4CiBtc2dpZCAiRTI2ODogdW5leHBlY3RlZCBuZXh0IgogbXNnc3RyICJFMjY4OiBcIm5leHRcIiBpbmVzcGVyYWRvIgogCi0jOiBpZl9ydWJ5LmM6NDYxCiBtc2dpZCAiRTI2OTogdW5leHBlY3RlZCBicmVhayIKIG1zZ3N0ciAiRTI2OTogXCJicmVha1wiIGluZXNwZXJhZG8iCiAKLSM6IGlmX3J1YnkuYzo0NjQKIG1zZ2lkICJFMjcwOiB1bmV4cGVjdGVkIHJlZG8iCiBtc2dzdHIgIkUyNzA6IFwicmVkb1wiIGluZXNwZXJhZG8iCiAKLSM6IGlmX3J1YnkuYzo0NjcKIG1zZ2lkICJFMjcxOiByZXRyeSBvdXRzaWRlIG9mIHJlc2N1ZSBjbGF1c2UiCiBtc2dzdHIgIkUyNzE6IFwicmV0cnlcIiBmdWVyYSBkZSB1bmEgY2zDoXVzdWxhIFwicmVzY3VlXCIiCiAKLSM6IGlmX3J1YnkuYzo0NzQKIG1zZ2lkICJFMjcyOiB1bmhhbmRsZWQgZXhjZXB0aW9uIgogbXNnc3RyICJFMjcyOiBleGNlcGNpw7NuIHNpbiBtYW5lamFyIgogCi0jOiBpZl9ydWJ5LmM6NDg5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkUyNzM6IHVua25vd24gbG9uZ2ptcCBzdGF0dXMgJWQiCiBtc2dzdHIgIkUyNzM6IEVsIGVzdGFkbyAlZCBkZSBcImxvbmdqbXBcIiBlcyBkZXNjb25vY2lkbyIKIAogCi0jOiBpZl90Y2wuYzo0MTkKIG1zZ2lkICJpbnZhbGlkIGJ1ZmZlciBudW1iZXIiCiBtc2dzdHIgIk7Dum1lcm8gZGUgYsO6ZmVyIG5vIHbDoWxpZG8iCiAKLSM6IGlmX3RjbC5jOjQ2NSBpZl90Y2wuYzo5MzUgaWZfdGNsLmM6MTExNQogbXNnaWQgIm5vdCBpbXBsZW1lbnRlZCB5ZXQiCiBtc2dzdHIgIkHDum4gbm8gaW1wbGVtZW50YWRvIgogCiAjID8/PwotIy4gPz8/Ci0jOiBpZl90Y2wuYzo3NzQKIG1zZ2lkICJjYW5ub3Qgc2V0IGxpbmUocykiCiBtc2dzdHIgIk5vIHNlIHB1ZWRlKG4pIGRlZmluaXIgbGEvcyBsw61uZWEvcyIKIAotIzogaWZfdGNsLmM6ODQ1CiBtc2dpZCAibWFyayBub3Qgc2V0IgogbXNnc3RyICJNYXJjYSBzaW4gZGVmaW5pciIKIAotIzogaWZfdGNsLmM6ODUyIGlmX3RjbC5jOjEwNzEKICMsIGMtZm9ybWF0CiBtc2dpZCAicm93ICVkIGNvbHVtbiAlZCIKIG1zZ3N0ciAiZmlsYSAlZCBjb2x1bW5hICVkIgogCi0jOiBpZl90Y2wuYzo4ODQKIG1zZ2lkICJjYW5ub3QgaW5zZXJ0L2FwcGVuZCBsaW5lIgogbXNnc3RyICJObyBzZSBwdWVkZSBpbnNlcnRhci9hw7FhZGlyIGzDrW5lYSIKIAotIzogaWZfdGNsLmM6MTI3MAogbXNnaWQgInVua25vd24gZmxhZzogIgogbXNnc3RyICJJbmRpY2Fkb3IgZGVzY29ub2NpZG86ICIKIAotIzogaWZfdGNsLmM6MTM0MAogbXNnaWQgInVua25vd24gdmltT3B0aW9uIgogbXNnc3RyICJcInZpbU9wdGlvblwiIGRlc2Nvbm9jaWRhIgogCi0jOiBpZl90Y2wuYzoxNDI1CiBtc2dpZCAia2V5Ym9hcmQgaW50ZXJydXB0IgogbXNnc3RyICJJbnRlcnJ1cGNpw7NuIGRlc2RlIGVsIHRlY2xhZG8iCiAKLSM6IGlmX3RjbC5jOjE0MzAKLW1zZ2lkICJ2aW0gZXJyb3IiCi1tc2dzdHIgIkVycm9yIGRlIFZpbSIKLQotIzogaWZfdGNsLmM6MTQ3NAogbXNnaWQgImNhbm5vdCBjcmVhdGUgYnVmZmVyL3dpbmRvdyBjb21tYW5kOiBvYmplY3QgaXMgYmVpbmcgZGVsZXRlZCIKIG1zZ3N0ciAiTm8gc2UgcHVkbyBjcmVhciBsYSBvcmRlbiBkZSBiw7pmZXIvdmVudGFuYTogZWwgb2JqZXRvIHNlIHN1cHJpbWlyw6EiCiAKLSM6IGlmX3RjbC5jOjE1NTAKIG1zZ2lkICIiCiAiY2Fubm90IHJlZ2lzdGVyIGNhbGxiYWNrIGNvbW1hbmQ6IGJ1ZmZlci93aW5kb3cgaXMgYWxyZWFkeSBiZWluZyBkZWxldGVkIgogbXNnc3RyICIiCkBAIC0zNTMzLDggKzI3MzUsNiBAQAogImVsaW1pbsOzIgogCiAjIFRoaXMgc2hvdWxkIG5ldmVyIGhhcHBlbi4gIEZhbW91cyBsYXN0IHdvcmQ/Ci0jLiBUaGlzIHNob3VsZCBuZXZlciBoYXBwZW4uICBGYW1vdXMgbGFzdCB3b3JkPwotIzogaWZfdGNsLmM6MTU2OQogbXNnaWQgIiIKICJFMjgwOiBUQ0wgRkFUQUwgRVJST1I6IHJlZmxpc3QgY29ycnVwdCE/IFBsZWFzZSByZXBvcnQgdGhpcyB0byB2aW0tZGV2QHZpbS4iCiAib3JnIgpAQCAtMzU0MiwxMjcgKzI3NDIsOTkgQEAKICJFMjgwOiBFUlJPUiBGQVRBTCBERSBUQ0w6IMK/wqFcInJlZmxpc3RcIiBkYcOxYWRhIT8gUG9yIGZhdm9yLCBpbmZvcm1lIGRlICIKICJlc3RvIGEgdmltLWRldkB2aW0ub3JnIgogCi0jOiBpZl90Y2wuYzoxNTcwCiBtc2dpZCAiY2Fubm90IHJlZ2lzdGVyIGNhbGxiYWNrIGNvbW1hbmQ6IGJ1ZmZlci93aW5kb3cgcmVmZXJlbmNlIG5vdCBmb3VuZCIKIG1zZ3N0ciAiIgogIk5vIHNlIHB1ZG8gcmVnaXN0cmFyIGxhIG9yZGVuIGRlIHJldG9ybm8gZGUgbGxhbWFkYTogTm8gc2UgcHVkbyBlbmNvbnRyYXIgIgogImxhIHJlZmVyZW5jaWEgYWwgYsO6ZmVyIG8gbGEgdmVudGFuYSIKIAotIzogaWZfdGNsLmM6MTc0MgogbXNnaWQgIiIKICJFNTcxOiBTb3JyeSwgdGhpcyBjb21tYW5kIGlzIGRpc2FibGVkOiB0aGUgVGNsIGxpYnJhcnkgY291bGQgbm90IGJlIGxvYWRlZC4iCiBtc2dzdHIgIiIKICJFNTcxOiBMbyBzaWVudG8sIGVzdGEgb3JkZW4gZXN0w6EgZGVzYWN0aXZhZGEgcHVlcyBubyBzZSBwdWRvICIKICJjYXJnYXIgbGEgYmlibGlvdGVjYSBkZSBUY2wiCiAKLSM6IGlmX3RjbC5jOjE5MDQKIG1zZ2lkICIiCiAiRTI4MTogVENMIEVSUk9SOiBleGl0IGNvZGUgaXMgbm90IGludCE/IFBsZWFzZSByZXBvcnQgdGhpcyB0byB2aW0tZGV2QHZpbS5vcmciCiBtc2dzdHIgIiIKICJFMjgxOiBFUlJPUiBERSBUQ0w6IMK/wqFlbCBjw7NkaWdvIGRlIHNhbGlkYSBubyBlcyBcImludFwiIT8gUG9yIGZhdm9yICIKICJpbmZvcm1lIGEgdmltLWRldkB2aW0ub3JnIgogCi0jOiBpZl90Y2wuYzoxOTA5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkU1NzI6IGV4aXQgY29kZSAlZCIKIG1zZ3N0ciAiRTU3MjogY8OzZGlnbyBkZSBzYWxpZGEgJWQiCiAKLSM6IGlmX3RjbC5jOjIwMjUKIG1zZ2lkICJjYW5ub3QgZ2V0IGxpbmUiCiBtc2dzdHIgIk5vIHB1ZWRvIG9idGVuZXIgbGEgbMOtbmVhIgogCi0jOiBpZl94Y21kc3J2LmM6MjMzCiBtc2dpZCAiVW5hYmxlIHRvIHJlZ2lzdGVyIGEgY29tbWFuZCBzZXJ2ZXIgbmFtZSIKIG1zZ3N0ciAiSW5jYXBheiBkZSByZWdpc3RyYXIgdW4gbm9tYnJlIGRlIHNlcnZpZG9yIGRlIMOzcmRlbmVzIgogCi0jOiBpZl94Y21kc3J2LmM6NDkyCiBtc2dpZCAiRTI0ODogRmFpbGVkIHRvIHNlbmQgY29tbWFuZCB0byB0aGUgZGVzdGluYXRpb24gcHJvZ3JhbSIKIG1zZ3N0ciAiRTI0ODogTm8gcHVkZSBlbnZpYXIgbGEgb3JkZW4gYWwgcHJvZ3JhbWEgZGUgZGVzdGlubyIKIAotIzogaWZfeGNtZHNydi5jOjc2NQogIywgYy1mb3JtYXQKIG1zZ2lkICJFNTczOiBJbnZhbGlkIHNlcnZlciBpZCB1c2VkOiAlcyIKIG1zZ3N0ciAiRTU3MzogRWwgSUQgZGUgdXN1YXJpbyBubyBlcyB2w6FsaWRvIGVuIGVsIHNlcnZpZG9yOiAlcyIKIAotIzogaWZfeGNtZHNydi5jOjExNDYKIG1zZ2lkICJFMjUxOiBWSU0gaW5zdGFuY2UgcmVnaXN0cnkgcHJvcGVydHkgaXMgYmFkbHkgZm9ybWVkLiAgRGVsZXRlZCEiCiBtc2dzdHIgIkUyNTE6IExhIHByb3BpZWRhZCBkZSByZWdpc3RybyBkZSBWSU0gZXMgaW5jb3JyZWN0YS4gwqFFbGltaW5hZGEhIgogCi0jOiBtYWluLmM6MTM4CiBtc2dpZCAiVW5rbm93biBvcHRpb24gYXJndW1lbnQiCiBtc2dzdHIgIk9wY2nDs24gZGUgYXJndW1lbnRvIGRlc2Nvbm9jaWRhIgogCi0jOiBtYWluLmM6MTQwCiBtc2dpZCAiVG9vIG1hbnkgZWRpdCBhcmd1bWVudHMiCiBtc2dzdHIgIkRlbWFzaWFkb3MgYXJndW1lbnRvcyBkZSBlZGljacOzbiIKIAotIzogbWFpbi5jOjE0MgogbXNnaWQgIkFyZ3VtZW50IG1pc3NpbmcgYWZ0ZXIiCiBtc2dzdHIgIkZhbHRhIGVsIGFyZ3VtZW50byBkZXNwdcOpcyBkZSIKIAotIzogbWFpbi5jOjE0NAogbXNnaWQgIkdhcmJhZ2UgYWZ0ZXIgb3B0aW9uIGFyZ3VtZW50IgogbXNnc3RyICJCYXN1cmEgZGVzcHXDqXMgZGUgbGEgb3BjacOzbiIKIAotIzogbWFpbi5jOjE0NgogbXNnaWQgIlRvbyBtYW55IFwiK2NvbW1hbmRcIiwgXCItYyBjb21tYW5kXCIgb3IgXCItLWNtZCBjb21tYW5kXCIgYXJndW1lbnRzIgogbXNnc3RyICIiCiAiRGVtYXNpYWRvcyBhcmd1bWVudG9zIHRhbGVzIGNvbW86IFwiK29yZGVuXCIsIFwiLWMgb3JkZW5cIiAiCiAibyBcIi0tY21kIG9yZGVuXCIiCiAKLSM6IG1haW4uYzoxNDgKIG1zZ2lkICJJbnZhbGlkIGFyZ3VtZW50IGZvciIKIG1zZ3N0ciAiQXJndW1lbnRvIG5vIHbDoWxpZG8gcGFyYSIKIAotIzogbWFpbi5jOjUxNAogIywgYy1mb3JtYXQKIG1zZ2lkICIlZCBmaWxlcyB0byBlZGl0XG4iCiBtc2dzdHIgIiVkIGFyY2hpdm9zIHF1ZSBlZGl0YXJcbiIKIAotIzogbWFpbi5jOjE1MTAKIG1zZ2lkICJUaGlzIFZpbSB3YXMgbm90IGNvbXBpbGVkIHdpdGggdGhlIGRpZmYgZmVhdHVyZS4iCiBtc2dzdHIgIkVzdGUgVmltIG5vIHNlIGhhIGNvbXBpbGFkbyBjb24gbGEgb3BjacOzbiBcImRpZmZcIiIKIAotIzogbWFpbi5jOjE2MTIKIG1zZ2lkICInLW5iJyBjYW5ub3QgYmUgdXNlZDogbm90IGVuYWJsZWQgYXQgY29tcGlsZSB0aW1lXG4iCiBtc2dzdHIgIictbmInIG5vIHNlIHB1ZWRlIHVzYXI6IG5vIHNlIGhhIGFjdGl2YWRvIGFsIGNvbXBpbGFyXG4iCiAKLSM6IG1haW4uYzoyMTM1CiBtc2dpZCAiQXR0ZW1wdCB0byBvcGVuIHNjcmlwdCBmaWxlIGFnYWluOiBcIiIKIG1zZ3N0ciAiSW50ZW50byBkZSBhYnJpciBkZSBudWV2byBlbCBhcmNoaXZvIGRlIMOzcmRlbmVzOiBcIiIKIAotIzogbWFpbi5jOjIxNDQKIG1zZ2lkICJDYW5ub3Qgb3BlbiBmb3IgcmVhZGluZzogXCIiCiBtc2dzdHIgIk5vIHNlIHB1ZG8gYWJyaXIgcGFyYSBsZWVyOiBcIiIKIAotIzogbWFpbi5jOjIxOTgKIG1zZ2lkICJDYW5ub3Qgb3BlbiBmb3Igc2NyaXB0IG91dHB1dDogXCIiCiBtc2dzdHIgIk5vIHNlIHB1ZG8gYWJyaXIgcGFyYSBlc2NyaWJpciBsYSBzYWxpZGEgZGVsIGFyY2hpdm8gZGUgw7NyZGVuZXM6IFwiIgogCi0jOiBtYWluLmM6MjM2NAogbXNnaWQgIlZpbTogRXJyb3I6IEZhaWx1cmUgdG8gc3RhcnQgZ3ZpbSBmcm9tIE5ldEJlYW5zXG4iCiBtc2dzdHIgIlZpbTogRXJyb3I6IEltcG9zaWJsZSBpbmljaWFyIGd2aW0gcGFyYSBOZXRCZWFuc1xuIgogCi0jOiBtYWluLmM6MjM2OQogbXNnaWQgIlZpbTogV2FybmluZzogT3V0cHV0IGlzIG5vdCB0byBhIHRlcm1pbmFsXG4iCiBtc2dzdHIgIlZpbTogQWR2ZXJ0ZW5jaWE6IGxhIHNhbGlkYSBubyBlcyB1biB0ZXJtaW5hbFxuIgogCi0jOiBtYWluLmM6MjM3MQogbXNnaWQgIlZpbTogV2FybmluZzogSW5wdXQgaXMgbm90IGZyb20gYSB0ZXJtaW5hbFxuIgogbXNnc3RyICJWaW06IEFkdmVydGVuY2lhOiBsYSBlbnRyYWRhIG5vIGVzIGRlc2RlIHVuIHRlcm1pbmFsXG4iCiAKICMganVzdCBpbiBjYXNlLi4KLSMuIGp1c3QgaW4gY2FzZS4uCi0jOiBtYWluLmM6MjY4OAogbXNnaWQgInByZS12aW1yYyBjb21tYW5kIGxpbmUiCiBtc2dzdHIgIkzDrW5lYSBkZSDDs3JkZW5lcyBwcmV2aWEgYSBcInZpbXJjXCIiCiAKLSM6IG1haW4uYzoyNzg1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkUyODI6IENhbm5vdCByZWFkIGZyb20gXCIlc1wiIgogbXNnc3RyICJFMjgyOiBObyBzZSBwdWRvIGxlZXIgZGVzZGUgXCIlc1wiIgogCi0jOiBtYWluLmM6MzAwMgogbXNnaWQgIiIKICJcbiIKICJNb3JlIGluZm8gd2l0aDogXCJ2aW0gLWhcIlxuIgpAQCAtMzY3MCwyMyArMjg0MiwxOCBAQAogIlxuIgogIk3DoXMgaW5mb3JtYWNpw7NuIGNvbjogXCJ2aW0gLWhcIlxuIgogCi0jOiBtYWluLmM6MzAzNQogbXNnaWQgIltmaWxlIC4uXSAgICAgICBlZGl0IHNwZWNpZmllZCBmaWxlKHMpIgogbXNnc3RyICJbYXJjaGl2byAuLl0gICBFZGl0YXIgZWwvbG9zIGFyY2hpdm9zL3MgZXNwZWNpZmljYWRvL3MiCiAKLSM6IG1haW4uYzozMDM2CiBtc2dpZCAiLSAgICAgICAgICAgICAgIHJlYWQgdGV4dCBmcm9tIHN0ZGluIgogbXNnc3RyICItICAgICAgICAgICAgICAgTGVlciB0ZXh0byBkZSBsYSBlbnRyYWRhIGVzdMOhbmRhciIKIAotIzogbWFpbi5jOjMwMzcKIG1zZ2lkICItdCB0YWcgICAgICAgICAgZWRpdCBmaWxlIHdoZXJlIHRhZyBpcyBkZWZpbmVkIgogbXNnc3RyICItdCBldGlxdWV0YSAgICBFZGl0YXIgZWwgYXJjaGl2byBkb25kZSBlc3TDoSBkZWZpbmlkYSBsYSBldGlxdWV0YSIKIAotIzogbWFpbi5jOjMwMzkKIG1zZ2lkICItcSBbZXJyb3JmaWxlXSAgZWRpdCBmaWxlIHdpdGggZmlyc3QgZXJyb3IiCiBtc2dzdHIgIi1xIFtmaWNoLiBlcnIuXSBFZGl0YXIgZWwgYXJjaGl2byBjb24gZWwgcHJpbWVyIGVycm9yIgogCi0jOiBtYWluLmM6MzA0OAogbXNnaWQgIiIKICJcbiIKICJcbiIKQEAgLTM2OTYsMTEgKzI4NjMsOSBAQAogIlxuIgogIlVzbzoiCiAKLSM6IG1haW4uYzozMDUxCiBtc2dpZCAiIHZpbSBbYXJndW1lbnRzXSAiCiBtc2dzdHIgIiB2aW0gW2FyZ3VtZW50b3NdIgogCi0jOiBtYWluLmM6MzA1NQogbXNnaWQgIiIKICJcbiIKICIgICBvcjoiCkBAIC0zNzA4LDcgKzI4NzMsNiBAQAogIlxuIgogIiAgbzoiCiAKLSM6IG1haW4uYzozMDU4CiBtc2dpZCAiIgogIlxuIgogIldoZXJlIGNhc2UgaXMgaWdub3JlZCBwcmVwZW5kIC8gdG8gbWFrZSBmbGFnIHVwcGVyIGNhc2UiCkBAIC0zNzE3LDcgKzI4ODEsNiBAQAogIkN1YW5kbyBtYXnDunNjdWxhIHkgbWluw7pzY3VsYSBzb24gaWdub3JhZGFzIGHDsWFkYSBcIi9cIiBwYXJhICIKICJjYW1iaWFyIGxhIG1hcmNhIChcImZsYWdcIikgYSBtYXnDunNjdWxhIgogCi0jOiBtYWluLmM6MzA2MQogbXNnaWQgIiIKICJcbiIKICJcbiIKQEAgLTM3MjcsMjgwICsyODkwLDIxOCBAQAogIlxuIgogIkFyZ3VtZW50b3M6XG4iCiAKLSM6IG1haW4uYzozMDYyCiBtc2dpZCAiLS1cdFx0XHRPbmx5IGZpbGUgbmFtZXMgYWZ0ZXIgdGhpcyIKIG1zZ3N0ciAiLS1cdFx0XHRTb2xvIG5vbWJyZXMgZGUgYXJjaGl2b3MgYSBwYXJ0aXIgZGUgYXF1w60iCiAKLSM6IG1haW4uYzozMDY0CiBtc2dpZCAiLS1saXRlcmFsXHRcdERvbid0IGV4cGFuZCB3aWxkY2FyZHMiCiBtc2dzdHIgIi0tbGl0ZXJhbFx0XHRObyBleHBhbmRpciBjb21vZGluZXMiCiAKLSM6IG1haW4uYzozMDY3CiBtc2dpZCAiLXJlZ2lzdGVyXHRcdFJlZ2lzdGVyIHRoaXMgZ3ZpbSBmb3IgT0xFIgogbXNnc3RyICItcmVnaXN0ZXJcdFx0UmVnaXN0cmFyIGVzdGUgXCJndmltXCIgcGFyYSBcIk9MRVwiIgogCi0jOiBtYWluLmM6MzA2OAogbXNnaWQgIi11bnJlZ2lzdGVyXHRcdFVucmVnaXN0ZXIgZ3ZpbSBmb3IgT0xFIgogbXNnc3RyICItdW5yZWdpc3Rlclx0XHRTdXByaW1pciBlbCByZWdpc3RybyBkZSBcImd2aW1cIiBwYXJhIFwiT0xFXCIiCiAKLSM6IG1haW4uYzozMDcxCiBtc2dpZCAiLWdcdFx0XHRSdW4gdXNpbmcgR1VJIChsaWtlIFwiZ3ZpbVwiKSIKIG1zZ3N0ciAiLWdcdFx0XHRFamVjdXRhciB1c2FuZG8gZWwgR1VJIChjb21vIFwiZ3ZpbVwiKSIKIAotIzogbWFpbi5jOjMwNzIKIG1zZ2lkICItZiAgb3IgIC0tbm9mb3JrXHRGb3JlZ3JvdW5kOiBEb24ndCBmb3JrIHdoZW4gc3RhcnRpbmcgR1VJIgogbXNnc3RyICIiCiAiLWYgIG8gIC0tbm9mb3JrXHRQcmltZXIgcGxhbm86IE5vIHNlcGFyYXJzZSAoXCJmb3JrXCIpIGN1YW5kbyBzZSAiCiAiaW5pY2lhIGxhIGludGVyZmF6IGdyw6FmaWNhIChHVUkpIgogCi0jOiBtYWluLmM6MzA3NAogbXNnaWQgIi12XHRcdFx0VmkgbW9kZSAobGlrZSBcInZpXCIpIgogbXNnc3RyICItdlx0XHRcdE1vZG8gdmkiCiAKLSM6IG1haW4uYzozMDc1CiBtc2dpZCAiLWVcdFx0XHRFeCBtb2RlIChsaWtlIFwiZXhcIikiCiBtc2dzdHIgIi1lXHRcdFx0TW9kbyBleCIKIAotIzogbWFpbi5jOjMwNzYKIG1zZ2lkICItc1x0XHRcdFNpbGVudCAoYmF0Y2gpIG1vZGUgKG9ubHkgZm9yIFwiZXhcIikiCiBtc2dzdHIgIi1zXHRcdFx0TW9kbyBzaWxlbmNpb3NvIGRlIGVqZWN1Y2nDs24gcG9yIGxvdGVzIChcImV4XCIpIgogCi0jOiBtYWluLmM6MzA3OAogbXNnaWQgIi1kXHRcdFx0RGlmZiBtb2RlIChsaWtlIFwidmltZGlmZlwiKSIKIG1zZ3N0ciAiLWRcdFx0XHRNb2RvIGRlIGRpZmVyZW5jaWFzIChjb21vIFwidmltZGlmZlwiKSIKIAotIzogbWFpbi5jOjMwODAKIG1zZ2lkICIteVx0XHRcdEVhc3kgbW9kZSAobGlrZSBcImV2aW1cIiwgbW9kZWxlc3MpIgogbXNnc3RyICIteVx0XHRcdE1vZG8gZsOhY2lsIChjb21vIFwiZXZpbVwiLCBzaW4gbW9kbykiCiAKLSM6IG1haW4uYzozMDgxCiBtc2dpZCAiLVJcdFx0XHRSZWFkb25seSBtb2RlIChsaWtlIFwidmlld1wiKSIKIG1zZ3N0ciAiLVJcdFx0XHRNb2RvIGRlIHNvbG8gbGVjdHVyYSAoY29tbyBcInZpZXdcIikiCiAKLSM6IG1haW4uYzozMDgyCiBtc2dpZCAiLVpcdFx0XHRSZXN0cmljdGVkIG1vZGUgKGxpa2UgXCJydmltXCIpIgogbXNnc3RyICItWlx0XHRcdE1vZG8gcmVzdHJpbmdpZG8gKGNvbW8gXCJydmltXCIpIgogCi0jOiBtYWluLmM6MzA4MwogbXNnaWQgIi1tXHRcdFx0TW9kaWZpY2F0aW9ucyAod3JpdGluZyBmaWxlcykgbm90IGFsbG93ZWQiCiBtc2dzdHIgIi1tXHRcdFx0TW9kaWZpY2FjacOzbiBkZSBhcmNoaXZvcyBkZXNhY3RpdmFkYSIKIAotIzogbWFpbi5jOjMwODQKIG1zZ2lkICItTVx0XHRcdE1vZGlmaWNhdGlvbnMgaW4gdGV4dCBub3QgYWxsb3dlZCIKIG1zZ3N0ciAiLU1cdFx0XHRNb2RpZmljYWNpw7NuIGRlIHRleHRvIGRlc2FjdGl2YWRhIgogCi0jOiBtYWluLmM6MzA4NQogbXNnaWQgIi1iXHRcdFx0QmluYXJ5IG1vZGUiCiBtc2dzdHIgIi1iXHRcdFx0TW9kbyBiaW5hcmlvIgogCi0jOiBtYWluLmM6MzA4NwogbXNnaWQgIi1sXHRcdFx0TGlzcCBtb2RlIgogbXNnc3RyICItbFx0XHRcdE1vZG8gTElTUCIKIAotIzogbWFpbi5jOjMwODkKIG1zZ2lkICItQ1x0XHRcdENvbXBhdGlibGUgd2l0aCBWaTogJ2NvbXBhdGlibGUnIgogbXNnc3RyICItQ1x0XHRcdENvbXBhdGlibGUgY29uIHZpOiBcImNvbXBhdGlibGVcIiIKIAotIzogbWFpbi5jOjMwOTAKIG1zZ2lkICItTlx0XHRcdE5vdCBmdWxseSBWaSBjb21wYXRpYmxlOiAnbm9jb21wYXRpYmxlJyIKIG1zZ3N0ciAiLU5cdFx0XHRQYXJjaWFsbWVudGUgY29tcGF0aWJsZSBjb24gdmk6IFwibm9jb21wYXRpYmxlXCIiCiAKLSM6IG1haW4uYzozMDkxCiBtc2dpZCAiLVZbTl1bZm5hbWVdXHRcdEJlIHZlcmJvc2UgW2xldmVsIE5dIFtsb2cgbWVzc2FnZXMgdG8gZm5hbWVdIgogbXNnc3RyICIiCiAiLVZbTl1bbm9tYnJlX2FyY2hpdm9dXHRcdENvbiB2ZXJib3NpZGFkIFtuaXZlbCBOXSBbZ3VhcmRhciBtZW5zYWplcyBlbiAiCiAibm9tYnJlX2FyY2hpdm9dIgogCi0jOiBtYWluLmM6MzA5MwogbXNnaWQgIi1EXHRcdFx0RGVidWdnaW5nIG1vZGUiCiBtc2dzdHIgIi1EXHRcdFx0TW9kbyBkZSBkZXB1cmFjacOzbiIKIAotIzogbWFpbi5jOjMwOTUKIG1zZ2lkICItblx0XHRcdE5vIHN3YXAgZmlsZSwgdXNlIG1lbW9yeSBvbmx5IgogbXNnc3RyICItblx0XHRcdFNpbiBhcmNoaXZvIGRlIGludGVyY2FtYmlvLCBzb2xvIHVzYSBSQU0iCiAKLSM6IG1haW4uYzozMDk2CiBtc2dpZCAiLXJcdFx0XHRMaXN0IHN3YXAgZmlsZXMgYW5kIGV4aXQiCiBtc2dzdHIgIi1yXHRcdFx0RGFyIHVuYSBsaXN0YSBkZSBsb3MgYXJjaGl2byBkZSBpbnRlcmNhbWJpbyB5IHNhbGlyIgogCi0jOiBtYWluLmM6MzA5NwogbXNnaWQgIi1yICh3aXRoIGZpbGUgbmFtZSlcdFJlY292ZXIgY3Jhc2hlZCBzZXNzaW9uIgogbXNnc3RyICItciBcImFyY2hpdm9cIlx0UmVjdXBlcmFyIHNlc2nDs24gZmFsbGlkYSIKIAotIzogbWFpbi5jOjMwOTgKIG1zZ2lkICItTFx0XHRcdFNhbWUgYXMgLXIiCiBtc2dzdHIgIi1MXHRcdFx0SWd1YWwgcXVlIFwiLXJcIiIKIAotIzogbWFpbi5jOjMxMDAKIG1zZ2lkICItZlx0XHRcdERvbid0IHVzZSBuZXdjbGkgdG8gb3BlbiB3aW5kb3ciCiBtc2dzdHIgIi1mXHRcdFx0Tm8gdXNhciBcIm5ld2NsaVwiIHBhcmEgYWJyaXIgdmVudGFuYXMiCiAKLSM6IG1haW4uYzozMTAxCiBtc2dpZCAiLWRldiA8ZGV2aWNlPlx0XHRVc2UgPGRldmljZT4gZm9yIEkvTyIKIG1zZ3N0ciAiLWRldiA8ZGlzcG9zaXRpdm8+XHRcdFVzYXIgPGRpc3Bvc2l0aXZvPiBwYXJhIEkvTyIKIAotIzogbWFpbi5jOjMxMDQKIG1zZ2lkICItQVx0XHRcdFN0YXJ0IGluIEFyYWJpYyBtb2RlIgogbXNnc3RyICItQVx0XHRcdEluaWNpYXIgZW4gbW9kbyDDoXJhYmUiCiAKLSM6IG1haW4uYzozMTA3CiBtc2dpZCAiLUhcdFx0XHRTdGFydCBpbiBIZWJyZXcgbW9kZSIKIG1zZ3N0ciAiLUhcdFx0XHRJbmljaWFyIGVuIG1vZG8gaGVicmVvIgogCi0jOiBtYWluLmM6MzExMAogbXNnaWQgIi1GXHRcdFx0U3RhcnQgaW4gRmFyc2kgbW9kZSIKIG1zZ3N0ciAiLUZcdFx0XHRJbmljaWFyIGVuIG1vZG8gcGVyc2EgKGZhcnNpKSIKIAotIzogbWFpbi5jOjMxMTIKIG1zZ2lkICItVCA8dGVybWluYWw+XHRTZXQgdGVybWluYWwgdHlwZSB0byA8dGVybWluYWw+IgogbXNnc3RyICItVCA8dGVybWluYWw+XHRFc3RhYmxlY2VyIGVsIHRpcG8gZGUgc2FsaWRhIHZpc3VhbCBhIDx0ZXJtaW5hbD4iCiAKLSM6IG1haW4uYzozMTEzCiBtc2dpZCAiLXUgPHZpbXJjPlx0XHRVc2UgPHZpbXJjPiBpbnN0ZWFkIG9mIGFueSAudmltcmMiCiBtc2dzdHIgIi11IDx2aW1yYz5cdFx0VXNhciA8dmltcmM+IGVuIGx1Z2FyIGRlIGN1YWxxdWllciBcIi52aW1yY1wiIgogCi0jOiBtYWluLmM6MzExNQogbXNnaWQgIi1VIDxndmltcmM+XHRcdFVzZSA8Z3ZpbXJjPiBpbnN0ZWFkIG9mIGFueSAuZ3ZpbXJjIgogbXNnc3RyICItVSA8Z3ZpbXJjPlx0XHRVc2FyIDxndmltcmM+IGVuIGx1Z2FyIGRlIG90cm8gXCIuZ3ZpbXJjXCIiCiAKLSM6IG1haW4uYzozMTE3CiBtc2dpZCAiLS1ub3BsdWdpblx0XHREb24ndCBsb2FkIHBsdWdpbiBzY3JpcHRzIgogbXNnc3RyICItLW5vcGx1Z2luXHRcdE5vIGNhcmdhciBsb3MgbcOzZHVsb3MgZGUgZXhwYW5zacOzbiIKIAotIzogbWFpbi5jOjMxMTkKIG1zZ2lkICItcFtOXVx0XHRPcGVuIE4gdGFiIHBhZ2VzIChkZWZhdWx0OiBvbmUgZm9yIGVhY2ggZmlsZSkiCiBtc2dzdHIgIi1wW05dXHRcdEFicmlyIE4gdmVudGFuYXMgKHZhbG9yIHByZWRldGVybWluYWRvOiB1bmEgcG9yIGFyY2hpdm8pIgogCi0jOiBtYWluLmM6MzEyMAogbXNnaWQgIi1vW05dXHRcdE9wZW4gTiB3aW5kb3dzIChkZWZhdWx0OiBvbmUgZm9yIGVhY2ggZmlsZSkiCiBtc2dzdHIgIi1vW05dXHRcdEFicmlyIE4gdmVudGFuYXMgKHZhbG9yIHByZWRldGVybWluYWRvOiB1bmEgcG9yIGFyY2hpdm8pIgogCi0jOiBtYWluLmM6MzEyMQogbXNnaWQgIi1PW05dXHRcdExpa2UgLW8gYnV0IHNwbGl0IHZlcnRpY2FsbHkiCiBtc2dzdHIgIi1PW05dXHRcdENvbW8gXCItb1wiIHBlcm8gZGl2aWRlIGxhcyB2ZW50YW5hcyB2ZXJ0aWNhbG1lbnRlIgogCi0jOiBtYWluLmM6MzEyMwogbXNnaWQgIitcdFx0XHRTdGFydCBhdCBlbmQgb2YgZmlsZSIKIG1zZ3N0ciAiK1x0XHRcdENvbWVuemFyIGFsIGZpbmFsIGRlbCBhcmNoaXZvIgogCi0jOiBtYWluLmM6MzEyNAogbXNnaWQgIis8bG51bT5cdFx0U3RhcnQgYXQgbGluZSA8bG51bT4iCiBtc2dzdHIgIis8bsO6bWVyb19kZV9sw61uZWE+XHRDb21pZW56YSBlbiBsYSBsw61uZWEgPG7Dum1lcm9fZGVfbMOtbmVhPiIKIAotIzogbWFpbi5jOjMxMjUKIG1zZ2lkICItLWNtZCA8Y29tbWFuZD5cdEV4ZWN1dGUgPGNvbW1hbmQ+IGJlZm9yZSBsb2FkaW5nIGFueSB2aW1yYyBmaWxlIgogbXNnc3RyICItLWNtZCA8b3JkZW4+XHRFamVjdXRhciBsYSA8b3JkZW4+IGFudGVzIGRlIGNhcmdhciBhbGfDum4gYXJjaGl2byB2aW1yYyIKIAotIzogbWFpbi5jOjMxMjYKIG1zZ2lkICItYyA8Y29tbWFuZD5cdFx0RXhlY3V0ZSA8Y29tbWFuZD4gYWZ0ZXIgbG9hZGluZyB0aGUgZmlyc3QgZmlsZSIKIG1zZ3N0ciAiLWMgPG9yZGVuPlx0XHRFamVjdXRhciA8b3JkZW4+IGRlc3B1w6lzIGRlIGNhcmdhciBlbCBwcmltZXIgYXJjaGl2byIKIAotIzogbWFpbi5jOjMxMjcKIG1zZ2lkICItUyA8c2Vzc2lvbj5cdFx0U291cmNlIGZpbGUgPHNlc3Npb24+IGFmdGVyIGxvYWRpbmcgdGhlIGZpcnN0IGZpbGUiCiBtc2dzdHIgIiIKICItUyA8c2VzacOzbj5cdFx0RWplY3V0YXIgbGFzIMOzcmRlbmVzIGRlbCBhcmNoaXZvIDxzZXNpw7NuPiBkZXNwdcOpcyAiCiAiZGUgY2FyZ2FyIGVsIHByaW1lciBhcmNoaXZvIgogCi0jOiBtYWluLmM6MzEyOAogbXNnaWQgIi1zIDxzY3JpcHRpbj5cdFJlYWQgTm9ybWFsIG1vZGUgY29tbWFuZHMgZnJvbSBmaWxlIDxzY3JpcHRpbj4iCiBtc2dzdHIgIiIKICItcyA8c2NyaXB0aW4+XHRMZWVyIGxhcyDDs3JkZW5lcyBlbiBtb2RvIE5vcm1hbCBkZWwgYXJjaGl2byAiCiAiXCJtw7NkdWxvIGRlIGV4cGFuc2nDs25cIiBkZSBlbnRyYWRhPiIKIAotIzogbWFpbi5jOjMxMjkKIG1zZ2lkICItdyA8c2NyaXB0b3V0Plx0QXBwZW5kIGFsbCB0eXBlZCBjb21tYW5kcyB0byBmaWxlIDxzY3JpcHRvdXQ+IgogbXNnc3RyICIiCiAiLXcgPHNjcmlwdG91dD5cdEHDsWFkaXIgdG9kYXMgbGFzIMOzcmRlbmVzIGVzY3JpdGFzIGFsIGFyY2hpdm8gIgogIlwibcOzZHVsbyBkZSBleHBhbnNpw7NuXCIgZGUgc2FsaWRhIgogCi0jOiBtYWluLmM6MzEzMAogbXNnaWQgIi1XIDxzY3JpcHRvdXQ+XHRXcml0ZSBhbGwgdHlwZWQgY29tbWFuZHMgdG8gZmlsZSA8c2NyaXB0b3V0PiIKIG1zZ3N0ciAiIgogIi1XIDxzY3JpcHRvdXQ+XHRHcmFiYXIgdG9kYXMgbGFzIMOzcmRlbmVzIGVzY3JpdGFzIGFsIGFyY2hpdm8gIgogIlwibcOzZHVsbyBkZSBleHBhbnNpw7NuXCIgZGUgc2FsaWRhIgogCi0jOiBtYWluLmM6MzEzMgogbXNnaWQgIi14XHRcdFx0RWRpdCBlbmNyeXB0ZWQgZmlsZXMiCiBtc2dzdHIgIi14XHRcdFx0RWRpdGFyIGFyY2hpdm9zIGNpZnJhZG9zIgogCi0jOiBtYWluLmM6MzEzNgotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0Q29ubmVjdCB2aW0gdG8gdGhpcyBwYXJ0aWN1bGFyIFgtc2VydmVyIgotbXNnc3RyICItZGlzcGxheSA8cGFudGFsbGE+XHRDb25lY3RhciB2aW0gYSBlc3RlIHNlcnZpZG9yIFggZW4gcGFydGljdWxhciIKK21zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdENvbm5lY3QgVmltIHRvIHRoaXMgcGFydGljdWxhciBYLXNlcnZlciIKK21zZ3N0ciAiLWRpc3BsYXkgPHBhbnRhbGxhPlx0Q29uZWN0YXIgVmltIGEgZXN0ZSBzZXJ2aWRvciBYIGVuIHBhcnRpY3VsYXIiCiAKLSM6IG1haW4uYzozMTM4CiBtc2dpZCAiLVhcdFx0XHREbyBub3QgY29ubmVjdCB0byBYIHNlcnZlciIKIG1zZ3N0ciAiLVhcdFx0XHRFdml0YXIgbGEgY29uZXhpw7NuIGFsIHNlcnZpZG9yIFgiCiAKLSM6IG1haW4uYzozMTQxCiBtc2dpZCAiLS1yZW1vdGUgPGZpbGVzPlx0RWRpdCA8ZmlsZXM+IGluIGEgVmltIHNlcnZlciBpZiBwb3NzaWJsZSIKIG1zZ3N0ciAiIgogIi0tcmVtb3RlIDxhcmNoaXZvcz5cdEVkaXRhciA8YXJjaGl2b3M+IGVuIHVuIHNlcnZpZG9yIFZpbSBzaSBlcyBwb3NpYmxlIgogCi0jOiBtYWluLmM6MzE0MgogbXNnaWQgIi0tcmVtb3RlLXNpbGVudCA8ZmlsZXM+ICBTYW1lLCBkb24ndCBjb21wbGFpbiBpZiB0aGVyZSBpcyBubyBzZXJ2ZXIiCiBtc2dzdHIgIiIKICItLXJlbW90ZS1zaWxlbnQgXCJhcmNoaXZvc1wiXHRMbyBtaXNtbyBwZXJvIG5vIHNlIHF1ZWphIHNpIG5vIGV4aXN0ZSB1biAiCiAic2Vydmlkb3IgZGlzcG9uaWJsZSIKIAotIzogbWFpbi5jOjMxNDMKIG1zZ2lkICIiCiAiLS1yZW1vdGUtd2FpdCA8ZmlsZXM+ICBBcyAtLXJlbW90ZSBidXQgd2FpdCBmb3IgZmlsZXMgdG8gaGF2ZSBiZWVuIGVkaXRlZCIKIG1zZ3N0ciAiIgogIi0tcmVtb3RlLXdhaXQgXCJhcmNoaXZvc1wiXHRDb21vIC0tcmVtb3RlIHBlcm8gZXNwZXJhIGEgcXVlIGxvcyBhcmNoaXZvcyAiCiAidGVybWluZW4gZGUgZWRpdGFyc2UiCiAKLSM6IG1haW4uYzozMTQ0CiBtc2dpZCAiIgogIi0tcmVtb3RlLXdhaXQtc2lsZW50IDxmaWxlcz4gIFNhbWUsIGRvbid0IGNvbXBsYWluIGlmIHRoZXJlIGlzIG5vIHNlcnZlciIKIG1zZ3N0ciAiIgogIi0tcmVtb3RlLXdhaXQtc2lsZW50IFwiYXJjaGl2b3NcIlx0TG8gbWlzbW8gcGVybyBubyBzZSBxdWVqYSBzaSBubyBoYXkgdW4gIgogInNlcnZpZG9yIGRpc3BvbmlibGUiCiAKLSM6IG1haW4uYzozMTQ2CiBtc2dpZCAiIgogIi0tcmVtb3RlLXRhYlstd2FpdF1bLXNpbGVudF0gPGZpbGVzPiAgQXMgLS1yZW1vdGUgYnV0IHVzZSB0YWIgcGFnZSBwZXIgZmlsZSIKIG1zZ3N0ciAiIgogIi0tcmVtb3RlLXRhYlstd2FpdF1bLXNpbGVudF0gPGFyY2hpdm9zPiAgQ29tbyBcIi0tcmVtb3RlXCIgcGVybyB1c2EgdW5hICIKICJwZXN0YcOxYSBwb3IgcMOhZ2luYSIKIAotIzogbWFpbi5jOjMxNDgKIG1zZ2lkICItLXJlbW90ZS1zZW5kIDxrZXlzPlx0U2VuZCA8a2V5cz4gdG8gYSBWaW0gc2VydmVyIGFuZCBleGl0IgogbXNnc3RyICItLXJlbW90ZS1zZW5kIDx0ZWNsYXM+XHRFbnbDrWFyIDx0ZWNsYXM+IGEgdW4gc2Vydmlkb3IgVmltIHkgY2VycmFyIgogCi0jOiBtYWluLmM6MzE0OQogbXNnaWQgIi0tcmVtb3RlLWV4cHIgPGV4cHI+XHRFdmFsdWF0ZSA8ZXhwcj4gaW4gYSBWaW0gc2VydmVyIGFuZCBwcmludCByZXN1bHQiCiBtc2dzdHIgIiIKICItLXJlbW90ZS1leHByIDxleHByPlx0RXZhbHVhciA8ZXhwcj4gZW4gdW4gc2Vydmlkb3IgVmltIGUgaW1wcmltaXIgZWwgIgogInJlc3VsdGFkbyIKIAotIzogbWFpbi5jOjMxNTAKIG1zZ2lkICItLXNlcnZlcmxpc3RcdFx0TGlzdCBhdmFpbGFibGUgVmltIHNlcnZlciBuYW1lcyBhbmQgZXhpdCIKIG1zZ3N0ciAiIgogIi0tc2VydmVybGlzdFx0XHRFbWl0aXIgdW5hIGxpc3RhIGRlIGxvcyBzZXJ2aWRvcmVzIFZpbSBkaXNwb25pYmxlcyB5IGNlcnJhciIKIAotIzogbWFpbi5jOjMxNTEKIG1zZ2lkICItLXNlcnZlcm5hbWUgPG5hbWU+XHRTZW5kIHRvL2JlY29tZSB0aGUgVmltIHNlcnZlciA8bmFtZT4iCiBtc2dzdHIgIiIKICItLXNlcnZlcm5hbWUgXCJub21icmVcIlx0RW52w61hciBhL3NlIGNvbnZpZXJ0ZSBlbiBlbCBzZXJ2aWRvciBWaW0gY29uIDxub21icmU+IgogCi0jOiBtYWluLmM6MzE1NAogbXNnaWQgIi0tc3RhcnR1cHRpbWUgPGZpbGU+XHRXcml0ZSBzdGFydHVwIHRpbWluZyBtZXNzYWdlcyB0byA8ZmlsZT4iCiBtc2dzdHIgIi0tIHN0YXJ0dXB0aW1lIDxhcmNoaXZvPlx0R3VhcmRhciBsb3MgbWVuc2FqZXMgZGUgdGllbXBvIGRlIGluaWNpbyAiCiAiYSA8YXJjaGl2bz4uIgogCi0jOiBtYWluLmM6MzE1NwogbXNnaWQgIi1pIDx2aW1pbmZvPlx0XHRVc2UgPHZpbWluZm8+IGluc3RlYWQgb2YgLnZpbWluZm8iCiBtc2dzdHIgIi1pIDx2aW1pbmZvPlx0XHRVc2FyIDx2aW1pbmZvPiBlbiBsdWdhciBkZSBcIi52aW1pbmZvXCIiCiAKLSM6IG1haW4uYzozMTU5CiBtc2dpZCAiLWggIG9yICAtLWhlbHBcdFByaW50IEhlbHAgKHRoaXMgbWVzc2FnZSkgYW5kIGV4aXQiCiBtc2dzdHIgIi1oICBvciAgLS1oZWxwXHRJbXByZXNpw7NuIGRlIGxhIGF5dWRhIChlc3RlIG1lbnNhamUpIHkgY2VycmFyIgogCi0jOiBtYWluLmM6MzE2MAogbXNnaWQgIi0tdmVyc2lvblx0XHRQcmludCB2ZXJzaW9uIGluZm9ybWF0aW9uIGFuZCBleGl0IgogbXNnc3RyICItLXZlcnNpb25cdFx0SW1wcmVzacOzbiBkZSBsYSBpbmZvcm1hY2nDs24gZGUgdmVyc2nDs24geSBjZXJyYXIiCiAKLSM6IG1haW4uYzozMTY0CiBtc2dpZCAiIgogIlxuIgogIkFyZ3VtZW50cyByZWNvZ25pc2VkIGJ5IGd2aW0gKE1vdGlmIHZlcnNpb24pOlxuIgpAQCAtNDAwOCw3ICszMTA5LDYgQEAKICJcbiIKICJBcmd1bWVudG9zIHJlY29ub2NpZG9zIHBvciBndmltICh2ZXJzacOzbiBNb3RpZik6XG4iCiAKLSM6IG1haW4uYzozMTY4CiBtc2dpZCAiIgogIlxuIgogIkFyZ3VtZW50cyByZWNvZ25pc2VkIGJ5IGd2aW0gKG5lWHRhdyB2ZXJzaW9uKTpcbiIKQEAgLTQwMTYsNyArMzExNiw2IEBACiAiXG4iCiAiQXJndW1lbnRvcyByZWNvbm9jaWRvcyBwb3IgZ3ZpbSAodmVyc2nDs24gbmVYdGF3KTpcbiIKIAotIzogbWFpbi5jOjMxNzAKIG1zZ2lkICIiCiAiXG4iCiAiQXJndW1lbnRzIHJlY29nbmlzZWQgYnkgZ3ZpbSAoQXRoZW5hIHZlcnNpb24pOlxuIgpAQCAtNDAyNCw4MSArMzEyMyw2NCBAQAogIlxuIgogIkFyZ3VtZW50b3MgcmVjb25vY2lkb3MgcG9yIGd2aW0gKHZlcnNpw7NuIEF0aGVuYSk6XG4iCiAKLSM6IG1haW4uYzozMTc0Ci1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gdmltIG9uIDxkaXNwbGF5PiIKLW1zZ3N0ciAiLWRpc3BsYXkgPHBhbnRhbGxhPlx0RWplY3V0YSB2aW0gZW4gPHBhbnRhbGxhPiIKK21zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biBWaW0gb24gPGRpc3BsYXk+IgorbXNnc3RyICItZGlzcGxheSA8cGFudGFsbGE+XHRFamVjdXRhIFZpbSBlbiA8cGFudGFsbGE+IgogCi0jOiBtYWluLmM6MzE3NQotbXNnaWQgIi1pY29uaWNcdFx0U3RhcnQgdmltIGljb25pZmllZCIKLW1zZ3N0ciAiLWljb25pY1x0XHRBcnJhbmNhIHZpbSBcImljb25pemFkb1wiIgorbXNnaWQgIi1pY29uaWNcdFx0U3RhcnQgVmltIGljb25pZmllZCIKK21zZ3N0ciAiLWljb25pY1x0XHRBcnJhbmNhIFZpbSBcImljb25pemFkb1wiIgogCi0jOiBtYWluLmM6MzE3NwogbXNnaWQgIi1uYW1lIDxuYW1lPlx0XHRVc2UgcmVzb3VyY2UgYXMgaWYgdmltIHdhcyA8bmFtZT4iCiBtc2dzdHIgIi1uYW1lIDxub21icmU+XHRcdFVzYSB1biByZWN1cnNvIGNvbW8gc2kgdmltIGZ1ZXNlIDxub21icmU+IgogCi0jOiBtYWluLmM6MzE3OAogbXNnaWQgIlx0XHRcdCAgKFVuaW1wbGVtZW50ZWQpXG4iCiBtc2dzdHIgIlx0XHRcdCAgKFNpbiBpbXBsZW1lbnRhcilcbiIKIAotIzogbWFpbi5jOjMxODAKIG1zZ2lkICItYmFja2dyb3VuZCA8Y29sb3I+XHRVc2UgPGNvbG9yPiBmb3IgdGhlIGJhY2tncm91bmQgKGFsc286IC1iZykiCiBtc2dzdHIgIi1iYWNrZ3JvdW5kIDxjb2xvcj5cdFVzYSA8Y29sb3I+IHBhcmEgZWwgZm9uZG8gKHRhbWJpw6luOiAtYmcpIgogCi0jOiBtYWluLmM6MzE4MQogbXNnaWQgIi1mb3JlZ3JvdW5kIDxjb2xvcj5cdFVzZSA8Y29sb3I+IGZvciBub3JtYWwgdGV4dCAoYWxzbzogLWZnKSIKIG1zZ3N0ciAiLWZvcmVncm91bmQgPGNvbG9yPlx0VXNhIDxjb2xvcj4gcGFyYSBlbCB0ZXh0byBub3JtYWwgKHRhbWJpw6luOiAtZmcpIgogCi0jOiBtYWluLmM6MzE4MiBtYWluLmM6MzIwMgogbXNnaWQgIi1mb250IDxmb250Plx0XHRVc2UgPGZvbnQ+IGZvciBub3JtYWwgdGV4dCAoYWxzbzogLWZuKSIKIG1zZ3N0ciAiIgogIi1mb250IDx0aXBvPlx0XHRVc2UgPHRpcG8gZGUgbGV0cmEgZGUgaW1wcmVzacOzbj4gcGFyYSBlbCB0ZXh0byBub3JtYWwgIgogIih0YW1iacOpbjogLWZuKSIKIAotIzogbWFpbi5jOjMxODMKIG1zZ2lkICItYm9sZGZvbnQgPGZvbnQ+XHRVc2UgPGZvbnQ+IGZvciBib2xkIHRleHQiCiBtc2dzdHIgIiIKICItYm9sZGZvbnQgPHRpcG8+XHRVc2EgPHRpcG8gZGUgbGV0cmEgZGUgaW1wcmVzacOzbj4gcGFyYSB0ZXh0byBlbiAiCiAibmVncml0YSIKIAotIzogbWFpbi5jOjMxODQKIG1zZ2lkICItaXRhbGljZm9udCA8Zm9udD5cdFVzZSA8Zm9udD4gZm9yIGl0YWxpYyB0ZXh0IgogbXNnc3RyICIiCiAiLWl0YWxpY2ZvbnQgPHRpcG8+XHRVc2UgPHRpcG8gZGUgbGV0cmEgZGUgaW1wcmVzacOzbj4gcGFyYSB0ZXh0byAiCiAiZW4gY3Vyc2l2YSIKIAotIzogbWFpbi5jOjMxODUgbWFpbi5jOjMyMDMKIG1zZ2lkICItZ2VvbWV0cnkgPGdlb20+XHRVc2UgPGdlb20+IGZvciBpbml0aWFsIGdlb21ldHJ5IChhbHNvOiAtZ2VvbSkiCiBtc2dzdHIgIiIKICItZ2VvbWV0cnkgPGdlb20+XHRVc2UgPGdlb20+IHBhcmEgbGEgZ2VvbWV0csOtYSBpbmljaWFsICh0YW1iacOpbjogLWdlb20pIgogCi0jOiBtYWluLmM6MzE4NgogbXNnaWQgIi1ib3JkZXJ3aWR0aCA8d2lkdGg+XHRVc2UgYSBib3JkZXIgd2lkdGggb2YgPHdpZHRoPiAoYWxzbzogLWJ3KSIKIG1zZ3N0ciAiLWJvcmRlcndpZHRoIDxhbmNobz5cdFVzYSB1biBhbmNobyBkZSBib3JkZSBkZSA8YW5jaG8+ICh0YW1iacOpbjogLWJ3KSIKIAotIzogbWFpbi5jOjMxODcKIG1zZ2lkICItc2Nyb2xsYmFyd2lkdGggPHdpZHRoPiAgVXNlIGEgc2Nyb2xsYmFyIHdpZHRoIG9mIDx3aWR0aD4gKGFsc286IC1zdykiCiBtc2dzdHIgIiIKICItc2Nyb2xsYmFyd2lkdGggPGFuY2hvPlx0VXNhIHVuYSBiYXJyYSBkZSBkZXNwbGF6YW1pZW50byBkZSBhbmNobyA8YW5jaG8+ICIKICIodGFtYmnDqW46IC1zdykiCiAKLSM6IG1haW4uYzozMTg5CiBtc2dpZCAiLW1lbnVoZWlnaHQgPGhlaWdodD5cdFVzZSBhIG1lbnUgYmFyIGhlaWdodCBvZiA8aGVpZ2h0PiAoYWxzbzogLW1oKSIKIG1zZ3N0ciAiIgogIi1tZW51aGVpZ2h0IDxhbHQ+XHRVc2EgdW5hIGJhcnJhIGRlIG1lbsO6IGRlIGFsdHVyYSA8YWx0PiAodGFtYmnDqW46IC1taCkiCiAKLSM6IG1haW4uYzozMTkxIG1haW4uYzozMjA0CiBtc2dpZCAiLXJldmVyc2VcdFx0VXNlIHJldmVyc2UgdmlkZW8gKGFsc286IC1ydikiCiBtc2dzdHIgIi1yZXZlcnNlXHRcdFVzYXIgdsOtZGVvIGludmVyc28gKHRhbWJpw6luOiAtcnYpIgogCi0jOiBtYWluLmM6MzE5MgogbXNnaWQgIityZXZlcnNlXHRcdERvbid0IHVzZSByZXZlcnNlIHZpZGVvIChhbHNvOiArcnYpIgogbXNnc3RyICIrcmV2ZXJzZVx0XHRObyB1c2FyIHbDrWRlbyBpbnZlcnNvICh0YW1iacOpbjogK3J2KSIKIAotIzogbWFpbi5jOjMxOTMKIG1zZ2lkICIteHJtIDxyZXNvdXJjZT5cdFNldCB0aGUgc3BlY2lmaWVkIHJlc291cmNlIgogbXNnc3RyICIteHJtIDxyZWN1cnNvPlx0RXN0YWJsZWNlIGVsIHJlY3Vyc28gZXNwZWNpZmljYWRvIgogCi0jOiBtYWluLmM6MzE5NgogbXNnaWQgIiIKICJcbiIKICJBcmd1bWVudHMgcmVjb2duaXNlZCBieSBndmltIChSSVNDIE9TIHZlcnNpb24pOlxuIgpAQCAtNDEwNiwxNSArMzE4OCwxMiBAQAogIlxuIgogIkFyZ3VtZW50b3MgcmVjb25vY2lkb3MgcG9yIGd2aW0gKHZlcnNpw7NuIHBhcmEgUklTQyBPUyk6XG4iCiAKLSM6IG1haW4uYzozMTk3CiBtc2dpZCAiLS1jb2x1bW5zIDxudW1iZXI+XHRJbml0aWFsIHdpZHRoIG9mIHdpbmRvdyBpbiBjb2x1bW5zIgogbXNnc3RyICItLWNvbHVtbnMgPG7Dum1lcm8+XHRBbmNodXJhIGluaWNpYWwgZGUgbGEgdmVudGFuYSwgZW4gY29sdW1uYXMiCiAKLSM6IG1haW4uYzozMTk4CiBtc2dpZCAiLS1yb3dzIDxudW1iZXI+XHRJbml0aWFsIGhlaWdodCBvZiB3aW5kb3cgaW4gcm93cyIKIG1zZ3N0ciAiLS1yb3dzIDxuw7ptZXJvPlx0QWx0dXJhIGluaWNpYWwgZGUgbGEgdmVudGFuYSwgZW4gZmlsYXMiCiAKLSM6IG1haW4uYzozMjAxCiBtc2dpZCAiIgogIlxuIgogIkFyZ3VtZW50cyByZWNvZ25pc2VkIGJ5IGd2aW0gKEdUSysgdmVyc2lvbik6XG4iCkBAIC00MTIyLDcwICszMjAxLDUzIEBACiAiXG4iCiAiQXJndW1lbnRvcyByZWNvbm9jaWRvcyBwb3IgZ3ZpbSAodmVyc2nDs24gR1RLKyk6XG4iCiAKLSM6IG1haW4uYzozMjA1Ci1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gdmltIG9uIDxkaXNwbGF5PiAoYWxzbzogLS1kaXNwbGF5KSIKLW1zZ3N0ciAiLWRpc3BsYXkgPHBhbnRhbGxhPlx0RWplY3V0YSB2aW0gZW4gPHBhbnRhbGxhPiAodGFtYmnDqW46IC0tZGlzcGxheSkiCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gVmltIG9uIDxkaXNwbGF5PiAoYWxzbzogLS1kaXNwbGF5KSIKK21zZ3N0ciAiLWRpc3BsYXkgPHBhbnRhbGxhPlx0RWplY3V0YSBWaW0gZW4gPHBhbnRhbGxhPiAodGFtYmnDqW46IC0tZGlzcGxheSkiCiAKLSM6IG1haW4uYzozMjA3CiBtc2dpZCAiLS1yb2xlIDxyb2xlPlx0U2V0IGEgdW5pcXVlIHJvbGUgdG8gaWRlbnRpZnkgdGhlIG1haW4gd2luZG93IgogbXNnc3RyICIiCiAiLS1yb2xlIDxyb2xlPlx0RGVmaW5lIHVuIHJvbCDDum5pY28gcGFyYSBpZGVudGlmaWNhciBsYSB2ZW50YW5hIHByaW5jaXBhbCIKIAotIzogbWFpbi5jOjMyMDkKIG1zZ2lkICItLXNvY2tldGlkIDx4aWQ+XHRPcGVuIFZpbSBpbnNpZGUgYW5vdGhlciBHVEsgd2lkZ2V0IgogbXNnc3RyICItLXNvY2tldGlkIDx4aWQ+XHRBYnJlIGEgVmltIGRlbnRybyBkZSBvdHJvIFwid2lkZ2V0XCIgR1RLIgogCi0jOiBtYWluLmM6MzIxMgogbXNnaWQgIi1QIDxwYXJlbnQgdGl0bGU+XHRPcGVuIFZpbSBpbnNpZGUgcGFyZW50IGFwcGxpY2F0aW9uIgogbXNnc3RyICItUCA8dMOtdHVsbyB2ZW50YW5hIHBhZHJlPlx0QWJyaXIgYSBWaW0gZGVudHJvIGRlIGxhIGFwbGljYWNpw7NuIHBhZHJlIgogCi0jOiBtYWluLmM6MzIxMwogbXNnaWQgIi0td2luZG93aWQgPEhXTkQ+XHRPcGVuIFZpbSBpbnNpZGUgYW5vdGhlciB3aW4zMiB3aWRnZXQiCiBtc2dzdHIgIi0td2luZG93aWQgPEhXTkQ+XHRBYnJpciBWaW0gZGVudHJvIGRlIG90cm8gb2JqZXRvIGRlIHdpbjMyIgogCi0jOiBtYWluLmM6MzU1NwogbXNnaWQgIk5vIGRpc3BsYXkiCiBtc2dzdHIgIk5vIGhheSB1bmEgdmVudGFuYSIKIAogIyBGYWlsZWQgdG8gc2VuZCwgYWJvcnQuCi0jLiBGYWlsZWQgdG8gc2VuZCwgYWJvcnQuCi0jOiBtYWluLmM6MzU3MgogbXNnaWQgIjogU2VuZCBmYWlsZWQuXG4iCiBtc2dzdHIgIjogRmFsbMOzIGVsIGVudsOtby5cbiIKIAogIyBMZXQgdmltIHN0YXJ0IG5vcm1hbGx5LgotIy4gTGV0IHZpbSBzdGFydCBub3JtYWxseS4KLSM6IG1haW4uYzozNTc4CiBtc2dpZCAiOiBTZW5kIGZhaWxlZC4gVHJ5aW5nIHRvIGV4ZWN1dGUgbG9jYWxseVxuIgogbXNnc3RyICIiCiAiOiBGYWxsw7MgZWwgaW5pY2lvIGRlIHNlc2nDs24gcmVtb3RhIChcInNlbmRcIikuIEludGVudGFkbyB1bmEgIgogImVqZWN1Y2nDs24gbG9jYWxcbiIKIAotIzogbWFpbi5jOjM2MTYgbWFpbi5jOjM2MzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiJWQgb2YgJWQgZWRpdGVkIgogbXNnc3RyICIlZCBkZSAlZCBlZGl0YWRvcyIKIAotIzogbWFpbi5jOjM2NTkKIG1zZ2lkICJObyBkaXNwbGF5OiBTZW5kIGV4cHJlc3Npb24gZmFpbGVkLlxuIgogbXNnc3RyICJObyBoYXkgdW5hIHZlbnRhbmEgZW4gZWwgZGVzdGlubzogRWwgZW52w61vIGRlIGxhIGV4cHJlc2nDs24gZmFsbMOzLlxuIgogCi0jOiBtYWluLmM6MzY3MQogbXNnaWQgIjogU2VuZCBleHByZXNzaW9uIGZhaWxlZC5cbiIKIG1zZ3N0ciAiOiBGYWxsw7MgZWwgZW52w61vIGRlIGxhIGV4cHJlc2nDs24uXG4iCiAKLSM6IG1hcmsuYzo3NjEKIG1zZ2lkICJObyBtYXJrcyBzZXQiCiBtc2dzdHIgIk5vIHNlIGhhbiBmaWphZG8gbWFyY2FzIgogCi0jOiBtYXJrLmM6NzYzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkUyODM6IE5vIG1hcmtzIG1hdGNoaW5nIFwiJXNcIiIKIG1zZ3N0ciAiRTI4MzogTm8gaGF5IG1hcmNhcyBxdWUgY29pbmNpZGFuIGNvbiAlcyIKIAogIyBIaWdobGlnaHQgdGl0bGUKLSMuIEhpZ2hsaWdodCB0aXRsZQotIzogbWFyay5jOjc3NAogbXNnaWQgIiIKICJcbiIKICJtYXJrIGxpbmUgIGNvbCBmaWxlL3RleHQiCkBAIC00MTk0LDggKzMyNTYsNiBAQAogIm1hcmNhIGzDrW5lYSAgY29sIGFyY2hpdm8vdGV4dG8iCiAKICMgSGlnaGxpZ2h0IHRpdGxlCi0jLiBIaWdobGlnaHQgdGl0bGUKLSM6IG1hcmsuYzo4OTYKIG1zZ2lkICIiCiAiXG4iCiAiIGp1bXAgbGluZSAgY29sIGZpbGUvdGV4dCIKQEAgLTQyMDQsOCArMzI2NCw2IEBACiAiIHNhbHRvIGzDrW5lYSAgY29sIGFyY2hpdm8vdGV4dG8iCiAKICMgSGlnaGxpZ2h0IHRpdGxlCi0jLiBIaWdobGlnaHQgdGl0bGUKLSM6IG1hcmsuYzo5NDMKIG1zZ2lkICIiCiAiXG4iCiAiY2hhbmdlIGxpbmUgIGNvbCB0ZXh0IgpAQCAtNDIxMyw3ICszMjcxLDYgQEAKICJcbiIKICJjYW1iaW8gbMOtbmVhICBjb2wgYXJjaGl2by90ZXh0byIKIAotIzogbWFyay5jOjE0MzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlxuIgpAQCAtNDIyMyw4ICszMjgwLDYgQEAKICIjIE1hcmNhcyBlbiBlbCBhcmNoaXZvOlxuIgogCiAjIFdyaXRlIHRoZSBqdW1wbGlzdCB3aXRoIC0nCi0jLiBXcml0ZSB0aGUganVtcGxpc3Qgd2l0aCAtJwotIzogbWFyay5jOjE0NzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlxuIgpAQCAtNDIzMyw3ICszMjg4LDYgQEAKICJcbiIKICIjIExpc3RhIGRlIHNhbHRvcyAoZWwgbcOhcyByZWNpZW50ZSB2YSBwcmltZXJvKTpcbiIKIAotIzogbWFyay5jOjE1NzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlxuIgpAQCAtNDI0MywxMjQgKzMyOTcsOTYgQEAKICIjIEhpc3RvcmlhIGRlIGxhcyBtYXJjYXMgZW4gbG9zIGFyY2hpdm9zIChkZSBsYSBtw6FzIHJlY2llbnRlIGEgbGEgbcOhcyAiCiAiYW50aWd1YSk6XG4iCiAKLSM6IG1hcmsuYzoxNjc3CiBtc2dpZCAiTWlzc2luZyAnPiciCiBtc2dzdHIgIkZhbHRhIFwiPlwiIgogCi0jOiBtYnl0ZS5jOjUzMgogbXNnaWQgIkU1NDM6IE5vdCBhIHZhbGlkIGNvZGVwYWdlIgogbXNnc3RyICJFNTQzOiBObyBlcyB1bmEgcMOhZ2luYSBkZSBjw7NkaWdvIHbDoWxpZGEiCiAKLSM6IG1ieXRlLmM6NDg1MgogbXNnaWQgIkUyODQ6IENhbm5vdCBzZXQgSUMgdmFsdWVzIgogbXNnc3RyICJFMjg0OiBObyBzZSBwdWRvIGZpamFyIGxvcyB2YWxvcmVzIElDIgogCi0jOiBtYnl0ZS5jOjUwMDQKIG1zZ2lkICJFMjg1OiBGYWlsZWQgdG8gY3JlYXRlIGlucHV0IGNvbnRleHQiCiBtc2dzdHIgIkUyODU6IEZhbGzDsyBsYSBjcmVhY2nDs24gZGVsIGNvbnRleHRvIGRlIGVudHJhZGEiCiAKLSM6IG1ieXRlLmM6NTE2MgogbXNnaWQgIkUyODY6IEZhaWxlZCB0byBvcGVuIGlucHV0IG1ldGhvZCIKIG1zZ3N0ciAiRTI4NjogRmFsbMOzIGxhIGFwZXJ0dXJhIGRlbCBtw6l0b2RvIGRlIGVudHJhZGEiCiAKLSM6IG1ieXRlLmM6NTE3NQogbXNnaWQgIkUyODc6IFdhcm5pbmc6IENvdWxkIG5vdCBzZXQgZGVzdHJveSBjYWxsYmFjayB0byBJTSIKIG1zZ3N0ciAiIgogIkUyODc6IEFkdmVydGVuY2lhOiBObyBwdWRlIGNyZWFyIHVuYSBsbGFtYWRhIGRlIHJldG9ybm8gIgogImRlIGRlc3RydWNjacOzbiBhbCBJTSIKIAotIzogbWJ5dGUuYzo1MTgxCiBtc2dpZCAiRTI4ODogaW5wdXQgbWV0aG9kIGRvZXNuJ3Qgc3VwcG9ydCBhbnkgc3R5bGUiCiBtc2dzdHIgIkUyODg6IGVsIG3DqXRvZG8gZGUgZW50cmFkYSBubyBhZG1pdGUgbmluZ8O6biBlc3RpbG8iCiAKLSM6IG1ieXRlLmM6NTI0MAogbXNnaWQgIkUyODk6IGlucHV0IG1ldGhvZCBkb2Vzbid0IHN1cHBvcnQgbXkgcHJlZWRpdCB0eXBlIgogbXNnc3RyICJFMjg5OiBFbCBtw6l0b2RvIGRlIGVudHJhZGEgbm8gc29wb3J0YSBtaSB0aXBvIGRlIHByZS1lZGljacOzbiIKIAotIzogbWJ5dGUuYzo1MzUyCiBtc2dpZCAiRTI5MTogWW91ciBHVEsrIGlzIG9sZGVyIHRoYW4gMS4yLjMuIFN0YXR1cyBhcmVhIGRpc2FibGVkIgogbXNnc3RyICIiCiAiRTI5MTogU3UgdmVyc2nDs24gZGUgR1RLKyBlcyBhbnRlcmlvciBhIDEuMi4zLiDDgXJlYSBkZSBlc3RhZG8gIgogImRlc2FjdGl2YWRhIgogCi0jOiBtZW1maWxlLmM6NTAxCiBtc2dpZCAiRTI5MzogYmxvY2sgd2FzIG5vdCBsb2NrZWQiCiBtc2dzdHIgIkUyOTM6IEVsIGJsb3F1ZSBubyBlc3RhYmEgYXNlZ3VyYWRvIgogCi0jOiBtZW1maWxlLmM6MTA0NAogbXNnaWQgIkUyOTQ6IFNlZWsgZXJyb3IgaW4gc3dhcCBmaWxlIHJlYWQiCiBtc2dzdHIgIkUyOTQ6IEVycm9yIGRlIGLDunNxdWVkYSBhbCBsZWVyIGVsIGFyY2hpdm8gZGUgaW50ZXJjYW1iaW8iCiAKLSM6IG1lbWZpbGUuYzoxMDQ5CiBtc2dpZCAiRTI5NTogUmVhZCBlcnJvciBpbiBzd2FwIGZpbGUiCiBtc2dzdHIgIkUyOTU6IEVycm9yIGRlIGxlY3R1cmEgZW4gZWwgYXJjaGl2byBkZSBpbnRlcmNhbWJpbyIKIAotIzogbWVtZmlsZS5jOjExMDEKIG1zZ2lkICJFMjk2OiBTZWVrIGVycm9yIGluIHN3YXAgZmlsZSB3cml0ZSIKIG1zZ3N0ciAiRTI5NjogRXJyb3IgZGUgYsO6c3F1ZWRhIGFsIGVzY3JpYmlyIGVuIGVsIGFyY2hpdm8gZGUgaW50ZXJjYW1iaW8iCiAKLSM6IG1lbWZpbGUuYzoxMTE5CiBtc2dpZCAiRTI5NzogV3JpdGUgZXJyb3IgaW4gc3dhcCBmaWxlIgogbXNnc3RyICJFMjk3OiBFcnJvciBkZSBlc2NyaXR1cmEgZW4gZWwgYXJjaGl2byBkZSBpbnRlcmNhbWJpbyIKIAotIzogbWVtZmlsZS5jOjEzMTYKIG1zZ2lkICJFMzAwOiBTd2FwIGZpbGUgYWxyZWFkeSBleGlzdHMgKHN5bWxpbmsgYXR0YWNrPykiCiBtc2dzdHIgIiIKICJFMzAwOiBZYSBleGlzdGUgdW4gYXJjaGl2byBkZSBpbnRlcmNhbWJpbyAowr9hdGFxdWUgZGUgZW5sYWNlIHNpbWLDs2xpY28/KSIKIAotIzogbWVtbGluZS5jOjMxMgogbXNnaWQgIkUyOTg6IERpZG4ndCBnZXQgYmxvY2sgbnIgMD8iCiBtc2dzdHIgIkUyOTg6IMK/Tm8gc2Ugb2J0dXZvIGVsIGJsb3F1ZSBOwrogMD8iCiAKLSM6IG1lbWxpbmUuYzozNTkKIG1zZ2lkICJFMjk4OiBEaWRuJ3QgZ2V0IGJsb2NrIG5yIDE/IgogbXNnc3RyICJFMjk4OiDCv05vIHNlIG9idHV2byBlbCBibG9xdWUgTsK6IDE/IgogCi0jOiBtZW1saW5lLmM6Mzc3CiBtc2dpZCAiRTI5ODogRGlkbid0IGdldCBibG9jayBuciAyPyIKIG1zZ3N0ciAiRTI5ODogwr9ObyBzZSBvYnR1dm8gZWwgYmxvcXVlIE7CuiAyPyIKIAogIyBjb3VsZCBub3QgKHJlKW9wZW4gdGhlIHN3YXAgZmlsZSwgd2hhdCBjYW4gd2UgZG8/Pz8/Ci0jLiBjb3VsZCBub3QgKHJlKW9wZW4gdGhlIHN3YXAgZmlsZSwgd2hhdCBjYW4gd2UgZG8/Pz8/Ci0jOiBtZW1saW5lLmM6NDkwCiBtc2dpZCAiRTMwMTogT29wcywgbG9zdCB0aGUgc3dhcCBmaWxlISEhIgogbXNnc3RyICJFMzAxOiDCocKhwqFQZXJkw60gZWwgYXJjaGl2byBkZSBpbnRlcmNhbWJpbyEhISIKIAotIzogbWVtbGluZS5jOjUwMgogbXNnaWQgIkUzMDI6IENvdWxkIG5vdCByZW5hbWUgc3dhcCBmaWxlIgogbXNnc3RyICJFMzAyOiBObyBwdWRlIGNhbWJpYXIgZWwgbm9tYnJlIGRlbCBhcmNoaXZvIGRlIGludGVyY2FtYmlvIgogCi0jOiBtZW1saW5lLmM6NTkyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkUzMDM6IFVuYWJsZSB0byBvcGVuIHN3YXAgZmlsZSBmb3IgXCIlc1wiLCByZWNvdmVyeSBpbXBvc3NpYmxlIgogbXNnc3RyICIiCiAiRTMwMzogSW5jYXBheiBkZSBhYnJpciBlbCBhcmNoaXZvIGRlIGludGVyY2FtYmlvIHBhcmEgJXMsICIKICJyZWN1cGVyYWNpw7NuIGltcG9zaWJsZSIKIAotIzogbWVtbGluZS5jOjcwMwogbXNnaWQgIkUzMDQ6IG1sX3VwZF9ibG9jazAoKTogRGlkbid0IGdldCBibG9jayAwPz8iCiBtc2dzdHIgIkUzMDQ6IFwibWxfdXBkX2Jsb2NrMCgpXCI6IMK/Tm8gc2Ugb2J0dXZvIGVsIGJsb3F1ZSAwPyIKIAotIzogbWVtbGluZS5jOjkwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJFMzA1OiBObyBzd2FwIGZpbGUgZm91bmQgZm9yICVzIgogbXNnc3RyICJFMzA1OiBObyBzZSBlbmNvbnRyw7MgZWwgYXJjaGl2byBkZSBpbnRlcmNhbWJpbyBwYXJhICVzIgogCi0jOiBtZW1saW5lLmM6OTE0CiBtc2dpZCAiRW50ZXIgbnVtYmVyIG9mIHN3YXAgZmlsZSB0byB1c2UgKDAgdG8gcXVpdCk6ICIKIG1zZ3N0ciAiIgogIkludHJvZHV6Y2EgZWwgbsO6bWVybyBkZWwgYXJjaGl2byBkZSBpbnRlcmNhbWJpbyBhIHVzYXIgKDAgcGFyYSBzYWxpcik6ICIKIAotIzogbWVtbGluZS5jOjk1OQogIywgYy1mb3JtYXQKIG1zZ2lkICJFMzA2OiBDYW5ub3Qgb3BlbiAlcyIKIG1zZ3N0ciAiRTMwNjogTm8gc2UgcHVkbyBhYnJpciAlcyIKIAotIzogbWVtbGluZS5jOjk4MQogbXNnaWQgIlVuYWJsZSB0byByZWFkIGJsb2NrIDAgZnJvbSAiCiBtc2dzdHIgIkluY2FwYXogZGUgbGVlciBlbCBibG9xdWUgMCBkZSAiCiAKLSM6IG1lbWxpbmUuYzo5ODQKIG1zZ2lkICIiCiAiXG4iCiAiTWF5YmUgbm8gY2hhbmdlcyB3ZXJlIG1hZGUgb3IgVmltIGRpZCBub3QgdXBkYXRlIHRoZSBzd2FwIGZpbGUuIgpAQCAtNDM2OCwyOCArMzM5NCwyMiBAQAogIlxuIgogIlRhbCB2ZXogbm8gaGF5IGNhbWJpb3MgbyBWaW0gbm8gYWN0dWFsaXrDsyBlbCBhcmNoaXZvIGRlIGludGVyY2FtYmlvLiIKIAotIzogbWVtbGluZS5jOjk5NCBtZW1saW5lLmM6MTAxMQogbXNnaWQgIiBjYW5ub3QgYmUgdXNlZCB3aXRoIHRoaXMgdmVyc2lvbiBvZiBWaW0uXG4iCiBtc2dzdHIgIiBubyBwdWVkZSB1c2Fyc2UgY29uIGVzdGEgdmVyc2nDs24gZGUgVmltLlxuIgogCi0jOiBtZW1saW5lLmM6OTk2CiBtc2dpZCAiVXNlIFZpbSB2ZXJzaW9uIDMuMC5cbiIKIG1zZ3N0ciAiVXNlIGxhIHZlcnNpw7NuIDMuMCBkZSBWaW0uXG4iCiAKLSM6IG1lbWxpbmUuYzoxMDAyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkUzMDc6ICVzIGRvZXMgbm90IGxvb2sgbGlrZSBhIFZpbSBzd2FwIGZpbGUiCiBtc2dzdHIgIkUzMDc6ICVzIG5vIHBhcmVjZSB1biBhcmNoaXZvIGRlIGludGVyY2FtYmlvIGRlIFZpbSIKIAotIzogbWVtbGluZS5jOjEwMTUKIG1zZ2lkICIgY2Fubm90IGJlIHVzZWQgb24gdGhpcyBjb21wdXRlci5cbiIKIG1zZ3N0ciAibm8gcHVlZGUgdXNhcnNlIGVuIGVzdGUgb3JkZW5hZG9yLlxuIgogCi0jOiBtZW1saW5lLmM6MTAxNwogbXNnaWQgIlRoZSBmaWxlIHdhcyBjcmVhdGVkIG9uICIKIG1zZ3N0ciAiRWwgYXJjaGl2byBzZSBjcmXDsyBlbCAiCiAKLSM6IG1lbWxpbmUuYzoxMDIxCiBtc2dpZCAiIgogIixcbiIKICJvciB0aGUgZmlsZSBoYXMgYmVlbiBkYW1hZ2VkLiIKQEAgLTQzOTcsODggKzM0MTcsNjkgQEAKICIsXG4iCiAibyBlbCBhcmNoaXZvIHNlIGhhIGRhw7FhZG8iCiAKLSM6IG1lbWxpbmUuYzoxMDM5CiBtc2dpZCAiIGhhcyBiZWVuIGRhbWFnZWQgKHBhZ2Ugc2l6ZSBpcyBzbWFsbGVyIHRoYW4gbWluaW11bSB2YWx1ZSkuXG4iCiBtc2dzdHIgIiBzZSBoYSBkYcOxYWRvIChlbCB0YW1hw7FvIGRlIGxhIHDDoWdpbmEgZXMgbWVub3IgYWwgdmFsb3IgbWluaW1vKS5cbiIKIAotIzogbWVtbGluZS5jOjEwNzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiVXNpbmcgc3dhcCBmaWxlIFwiJXNcIiIKIG1zZ3N0ciAiVXNhbmRvIGVsIGFyY2hpdm8gZGUgaW50ZXJjYW1iaW8gXCIlc1wiIgogCi0jOiBtZW1saW5lLmM6MTA3NwogIywgYy1mb3JtYXQKIG1zZ2lkICJPcmlnaW5hbCBmaWxlIFwiJXNcIiIKIG1zZ3N0ciAiQXJjaGl2byBvcmlnaW5hbCAlcyIKIAotIzogbWVtbGluZS5jOjEwOTAKIG1zZ2lkICJFMzA4OiBXYXJuaW5nOiBPcmlnaW5hbCBmaWxlIG1heSBoYXZlIGJlZW4gY2hhbmdlZCIKIG1zZ3N0ciAiRTMwODogQWR2ZXJ0ZW5jaWE6IGVsIGFyY2hpdm8gb3JpZ2luYWwgcHVlZGUgaGFiZXIgY2FtYmlhZG8iCiAKLSM6IG1lbWxpbmUuYzoxMTY0CiAjLCBjLWZvcm1hdAogbXNnaWQgIkUzMDk6IFVuYWJsZSB0byByZWFkIGJsb2NrIDEgZnJvbSAlcyIKIG1zZ3N0ciAiRTMwOTogSW5jYXBheiBkZSBsZWVyIGVsIGJsb3F1ZSAxIGRlICVzIgogCi0jOiBtZW1saW5lLmM6MTE2OAogbXNnaWQgIj8/P01BTlkgTElORVMgTUlTU0lORyIKIG1zZ3N0ciAiPz8/RkFMVEFOIE1VQ0hBUyBMw41ORUFTIgogCi0jOiBtZW1saW5lLmM6MTE4NAogbXNnaWQgIj8/P0xJTkUgQ09VTlQgV1JPTkciCiBtc2dzdHIgIj8/P1JFQ1VFTlRPIERFIEzDjU5FQVMgRVFVSVZPQ0FETyIKIAotIzogbWVtbGluZS5jOjExOTEKIG1zZ2lkICI/Pz9FTVBUWSBCTE9DSyIKIG1zZ3N0ciAiPz8/QkxPUVVFIFZBQ8ONTyIKIAotIzogbWVtbGluZS5jOjEyMTcKIG1zZ2lkICI/Pz9MSU5FUyBNSVNTSU5HIgogbXNnc3RyICI/Pz9GQUxUQU4gTMONTkVBUyIKIAotIzogbWVtbGluZS5jOjEyNDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTMxMDogQmxvY2sgMSBJRCB3cm9uZyAoJXMgbm90IGEgLnN3cCBmaWxlPykiCiBtc2dzdHIgIkUzMTA6IEVsIElEIGRlbCBibG9xdWUgMSBlcyBpbmNvcnJlY3RvICjCv05vIGVzICVzIHVuIGFyY2hpdm8gLnN3cD8pIgogCi0jOiBtZW1saW5lLmM6MTI1NAogbXNnaWQgIj8/P0JMT0NLIE1JU1NJTkciCiBtc2dzdHIgIj8/P0ZBTFRBIFVOIEJMT1FVRSIKIAotIzogbWVtbGluZS5jOjEyNzAKIG1zZ2lkICI/Pz8gZnJvbSBoZXJlIHVudGlsID8/P0VORCBsaW5lcyBtYXkgYmUgbWVzc2VkIHVwIgogbXNnc3RyICI/Pz8gZGVzZGUgYXF1w60gaGFzdGEgPz8/RklOIGxhcyBsw61uZWFzIHB1ZWRlbiBlc3RhciBkZXNvcmRlbmFkYXMiCiAKLSM6IG1lbWxpbmUuYzoxMjg2CiBtc2dpZCAiPz8/IGZyb20gaGVyZSB1bnRpbCA/Pz9FTkQgbGluZXMgbWF5IGhhdmUgYmVlbiBpbnNlcnRlZC9kZWxldGVkIgogbXNnc3RyICIiCiAiPz8/IGRlc2RlIGFxdcOtIGhhc3RhID8/P0ZJTiBsYXMgbMOtbmVhcyBwdWVkZW4gaGFiZXIgc2lkbyAiCiAiaW5zZXJ0YWRhcy9ib3JyYWRhcyIKIAotIzogbWVtbGluZS5jOjEzMDYKIG1zZ2lkICI/Pz9FTkQiCiBtc2dzdHIgIj8/P0ZJTiIKIAotIzogbWVtbGluZS5jOjEzMzMKIG1zZ2lkICJFMzExOiBSZWNvdmVyeSBJbnRlcnJ1cHRlZCIKIG1zZ3N0ciAiRTMxMTogUmVjdXBlcmFjacOzbiBpbnRlcnJ1bXBpZGEiCiAKLSM6IG1lbWxpbmUuYzoxMzM4CiBtc2dpZCAiIgogIkUzMTI6IEVycm9ycyBkZXRlY3RlZCB3aGlsZSByZWNvdmVyaW5nOyBsb29rIGZvciBsaW5lcyBzdGFydGluZyB3aXRoID8/PyIKIG1zZ3N0ciAiIgogIkUzMTI6IFNlIGhhbiBkZXRlY3RhZG8gZXJyb3JlcyBhbCByZWN1cGVyYXI7IGJ1c3F1ZSBsw61uZWFzIHF1ZSAiCiAiZW1waWVjZW4gY29uID8/PyIKIAotIzogbWVtbGluZS5jOjEzNDAKIG1zZ2lkICJTZWUgXCI6aGVscCBFMzEyXCIgZm9yIG1vcmUgaW5mb3JtYXRpb24uIgogbXNnc3RyICJWZWEgXCI6aGVscCBFMzEyXCIgcGFyYSBtw6FzIGluZm9ybWFjacOzbi4iCiAKLSM6IG1lbWxpbmUuYzoxMzQ1CiBtc2dpZCAiUmVjb3ZlcnkgY29tcGxldGVkLiBZb3Ugc2hvdWxkIGNoZWNrIGlmIGV2ZXJ5dGhpbmcgaXMgT0suIgogbXNnc3RyICJSZWN1cGVyYWNpw7NuIGNvbXBsZXRhLiBVZC4gZGViZXLDrWEgY29tcHJvYmFyIHF1ZSB0b2RvIGVzdMOhIGJpZW4iCiAKLSM6IG1lbWxpbmUuYzoxMzQ2CiBtc2dpZCAiIgogIlxuIgogIihZb3UgbWlnaHQgd2FudCB0byB3cml0ZSBvdXQgdGhpcyBmaWxlIHVuZGVyIGFub3RoZXIgbmFtZVxuIgpAQCAtNDQ4NiwxMiArMzQ4NywxMCBAQAogIlxuIgogIihQb2Ryw61hIHF1ZXJlciBndWFyZGFyIGVzdGUgYXJjaGl2byBjb24gb3RybyBub21icmVcbiIKIAotIzogbWVtbGluZS5jOjEzNDcKIG1zZ2lkICJhbmQgcnVuIGRpZmYgd2l0aCB0aGUgb3JpZ2luYWwgZmlsZSB0byBjaGVjayBmb3IgY2hhbmdlcylcbiIKIG1zZ3N0ciAiIgogInkgZWplY3V0YXIgXCJkaWZmXCIgY29uIGVsIGFyY2hpdm8gb3JpZ2luYWwgcGFyYSBjb21wcm9iYXIgbG9zIGNhbWJpb3MpXG4iCiAKLSM6IG1lbWxpbmUuYzoxMzQ4CiBtc2dpZCAiIgogIkRlbGV0ZSB0aGUgLnN3cCBmaWxlIGFmdGVyd2FyZHMuXG4iCiAiXG4iCkBAIC00NTAwLDUyICszNDk5LDM5IEBACiAiXG4iCiAKICMgdXNlIG1zZygpIHRvIHN0YXJ0IHRoZSBzY3JvbGxpbmcgcHJvcGVybHkKLSMuIHVzZSBtc2coKSB0byBzdGFydCB0aGUgc2Nyb2xsaW5nIHByb3Blcmx5Ci0jOiBtZW1saW5lLmM6MTQwOAogbXNnaWQgIlN3YXAgZmlsZXMgZm91bmQ6IgogbXNnc3RyICJTZSBoYW4gZW5jb250cmFkbyBsb3Mgc2lndWllbnRlcyBhcmNoaXZvcyBkZSBpbnRlcmNhbWJpbzoiCiAKLSM6IG1lbWxpbmUuYzoxNTkzCiBtc2dpZCAiICAgSW4gY3VycmVudCBkaXJlY3Rvcnk6XG4iCiBtc2dzdHIgIiAgIEVuIGVsIGRpcmVjdG9yaW8gYWN0dWFsOlxuIgogCi0jOiBtZW1saW5lLmM6MTU5NQogbXNnaWQgIiAgIFVzaW5nIHNwZWNpZmllZCBuYW1lOlxuIgogbXNnc3RyICIgICBVc2FuZG8gZWwgbm9tYnJlIGVzcGVjaWZpY2FkbzpcbiIKIAotIzogbWVtbGluZS5jOjE1OTkKIG1zZ2lkICIgICBJbiBkaXJlY3RvcnkgIgogbXNnc3RyICIgICBFbiBlbCBkaXJlY3RvcmlvICIKIAotIzogbWVtbGluZS5jOjE2MTcKIG1zZ2lkICIgICAgICAtLSBub25lIC0tXG4iCiBtc2dzdHIgIiAgICAgIC0tIG5pbmd1bm8gLS1cbiIKIAotIzogbWVtbGluZS5jOjE2OTIKIG1zZ2lkICIgICAgICAgICAgb3duZWQgYnk6ICIKIG1zZ3N0ciAiICAgICAgICAgIHByb3BpZWRhZCBkZTogIgogCi0jOiBtZW1saW5lLmM6MTY5NAogbXNnaWQgIiAgIGRhdGVkOiAiCiBtc2dzdHIgIiAgIGRlIGZlY2hhOiAiCiAKLSM6IG1lbWxpbmUuYzoxNjk4IG1lbWxpbmUuYzozNzM2CiBtc2dpZCAiICAgICAgICAgICAgIGRhdGVkOiAiCiBtc2dzdHIgIiAgICAgICAgICAgICBkZSBmZWNoYTogIgogCi0jOiBtZW1saW5lLmM6MTcxNwogbXNnaWQgIiAgICAgICAgIFtmcm9tIFZpbSB2ZXJzaW9uIDMuMF0iCiBtc2dzdHIgIiAgICAgIFtkZXNkZSBsYSB2ZXJzacOzbiAzLjAgZGUgVmltXSIKIAotIzogbWVtbGluZS5jOjE3MjEKIG1zZ2lkICIgICAgICAgICBbZG9lcyBub3QgbG9vayBsaWtlIGEgVmltIHN3YXAgZmlsZV0iCiBtc2dzdHIgIiAgICAgICAgIFtubyBwYXJlY2UgdW4gYXJjaGl2byBkZSBpbnRlcmNhbWJpbyBkZSBWaW1dIgogCi0jOiBtZW1saW5lLmM6MTcyNQogbXNnaWQgIiAgICAgICAgIGZpbGUgbmFtZTogIgogbXNnc3RyICIgICAgICAgICBub21icmUgZGVsIGFyY2hpdm86ICIKIAotIzogbWVtbGluZS5jOjE3MzEKIG1zZ2lkICIiCiAiXG4iCiAiICAgICAgICAgIG1vZGlmaWVkOiAiCkBAIC00NTUzLDE1ICszNTM5LDEyIEBACiAiXG4iCiAiICAgICAgICAgbW9kaWZpY2FkbzogIgogCi0jOiBtZW1saW5lLmM6MTczMgogbXNnaWQgIllFUyIKIG1zZ3N0ciAiU0kiCiAKLSM6IG1lbWxpbmUuYzoxNzMyCiBtc2dpZCAibm8iCiBtc2dzdHIgIm5vIgogCi0jOiBtZW1saW5lLmM6MTczNgogbXNnaWQgIiIKICJcbiIKICIgICAgICAgICB1c2VyIG5hbWU6ICIKQEAgLTQ1NjksMTEgKzM1NTIsOSBAQAogIlxuIgogIiBub21icmUgZGVsIHVzdWFyaW86ICIKIAotIzogbWVtbGluZS5jOjE3NDMKIG1zZ2lkICIgICBob3N0IG5hbWU6ICIKIG1zZ3N0ciAiICBub21icmUgZGVsIHNlcnZpZG9yOiAiCiAKLSM6IG1lbWxpbmUuYzoxNzQ1CiBtc2dpZCAiIgogIlxuIgogIiAgICAgICAgIGhvc3QgbmFtZTogIgpAQCAtNDU4MSw3ICszNTYyLDYgQEAKICJcbiIKICIgICAgICAgbm9tYnJlIGRlbCBzZXJ2aWRvcjogIgogCi0jOiBtZW1saW5lLmM6MTc1MQogbXNnaWQgIiIKICJcbiIKICIgICAgICAgIHByb2Nlc3MgSUQ6ICIKQEAgLTQ1ODksMTEgKzM1NjksOSBAQAogIlxuIgogIiAgICAgIElEIGRlbCBwcm9jZXNvOiAiCiAKLSM6IG1lbWxpbmUuYzoxNzU3CiBtc2dpZCAiIChzdGlsbCBydW5uaW5nKSIKIG1zZ3N0ciAiIChhw7puIGVuIGVqZWN1Y2nDs24pIgogCi0jOiBtZW1saW5lLmM6MTc2OQogbXNnaWQgIiIKICJcbiIKICIgICAgICAgICBbbm90IHVzYWJsZSB3aXRoIHRoaXMgdmVyc2lvbiBvZiBWaW1dIgpAQCAtNDYwMSw3ICszNTc5LDYgQEAKICJcbiIKICIgICAgICAgICBbbm8gc2UgcHVlZGUgdXNhciBjb24gZXN0YSB2ZXJzacOzbiBkZSBWaW1dIgogCi0jOiBtZW1saW5lLmM6MTc3MgogbXNnaWQgIiIKICJcbiIKICIgICAgICAgICBbbm90IHVzYWJsZSBvbiB0aGlzIGNvbXB1dGVyXSIKQEAgLTQ2MDksOTcgKzM1ODYsNzUgQEAKICJcbiIKICIgICAgICAgICBbbm8gc2UgcHVlZGUgdXNhciBlbiBlc3RlIG9yZGVuYWRvcl0iCiAKLSM6IG1lbWxpbmUuYzoxNzc3CiBtc2dpZCAiICAgICAgICAgW2Nhbm5vdCBiZSByZWFkXSIKIG1zZ3N0ciAiICAgICAgICAgW25vIHNlIHB1ZWRlIGxlZXJdIgogCi0jOiBtZW1saW5lLmM6MTc4MQogbXNnaWQgIiAgICAgICAgIFtjYW5ub3QgYmUgb3BlbmVkXSIKIG1zZ3N0ciAiICAgICAgICAgW25vIHNlIHB1ZWRlIGFicmlyXSIKIAotIzogbWVtbGluZS5jOjE5NzEKIG1zZ2lkICJFMzEzOiBDYW5ub3QgcHJlc2VydmUsIHRoZXJlIGlzIG5vIHN3YXAgZmlsZSIKIG1zZ3N0ciAiRTMxMzogTm8gc2UgcHVkbyBwcmVzZXJ2YXIsIG5vIGV4aXN0ZSB1biBhcmNoaXZvIGRlIGludGVyY2FtYmlvIgogCi0jOiBtZW1saW5lLmM6MjAyNAogbXNnaWQgIkZpbGUgcHJlc2VydmVkIgogbXNnc3RyICJBcmNoaXZvIHByZXNlcnZhZG8iCiAKLSM6IG1lbWxpbmUuYzoyMDI2CiBtc2dpZCAiRTMxNDogUHJlc2VydmUgZmFpbGVkIgogbXNnc3RyICJFMzE0OiBGYWxsw7MgbGEgcHJlc2VydmFjacOzbiBkZWwgYXJjaGl2byIKIAotIzogbWVtbGluZS5jOjIxMDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTMxNTogbWxfZ2V0OiBpbnZhbGlkIGxudW06ICVsZCIKIG1zZ3N0ciAiRTMxNTogXCJtbF9nZXRcIjogbsO6bWVybyBkZSBsw61uZWEgbm8gdsOhbGlkbzogJWxkIgogCi0jOiBtZW1saW5lLmM6MjEzOAogIywgYy1mb3JtYXQKIG1zZ2lkICJFMzE2OiBtbF9nZXQ6IGNhbm5vdCBmaW5kIGxpbmUgJWxkIgogbXNnc3RyICJFMzE2OiBcIm1sX2dldFwiOiBubyBzZSBwdWRvIGVuY29udHJhciBsYSBsw61uZWEgJWxkIgogCi0jOiBtZW1saW5lLmM6MjU1MgogbXNnaWQgIkUzMTc6IHBvaW50ZXIgYmxvY2sgaWQgd3JvbmcgMyIKIG1zZ3N0ciAiRTMxNzogRWwgaWQgZGVsIGJsb3F1ZSBkZSBwdW50ZXJvcyBlcyBpbmNvcnJlY3RvLiAzIgogCi0jOiBtZW1saW5lLmM6MjYzMgogbXNnaWQgInN0YWNrX2lkeCBzaG91bGQgYmUgMCIKIG1zZ3N0ciAiXCJzdGFja19pZHhcIiBkZWJlcsOtYSBzZXIgMCIKIAotIzogbWVtbGluZS5jOjI2OTQKIG1zZ2lkICJFMzE4OiBVcGRhdGVkIHRvbyBtYW55IGJsb2Nrcz8iCiBtc2dzdHIgIkUzMTg6IMK/RGVtYXNpYWRvcyBibG9xdWVzIGFjdHVhbGl6YWRvcz8iCiAKLSM6IG1lbWxpbmUuYzoyODc0CiBtc2dpZCAiRTMxNzogcG9pbnRlciBibG9jayBpZCB3cm9uZyA0IgogbXNnc3RyICJFMzE3OiBFbCBpZCBkZWwgYmxvcXVlIGRlIHB1bnRlcm9zIGVzIGluY29ycmVjdG8uIDQiCiAKLSM6IG1lbWxpbmUuYzoyOTAxCiBtc2dpZCAiZGVsZXRlZCBibG9jayAxPyIKIG1zZ3N0ciAiwr9ibG9xdWUgMSBzdXByaW1pZG8/IgogCi0jOiBtZW1saW5lLmM6MzEwMQogIywgYy1mb3JtYXQKIG1zZ2lkICJFMzIwOiBDYW5ub3QgZmluZCBsaW5lICVsZCIKIG1zZ3N0ciAiRTMyMDogTm8gc2UgcHVkbyBlbmNvbnRyYXIgbGEgbMOtbmVhICVsZCIKIAotIzogbWVtbGluZS5jOjMzNDcKIG1zZ2lkICJFMzE3OiBwb2ludGVyIGJsb2NrIGlkIHdyb25nIgogbXNnc3RyICJFMzE3OiBFbCBpZCBkZWwgYmxvcXVlIGRlIHB1bnRlcm9zIGVzIGluY29ycmVjdG8iCiAKLSM6IG1lbWxpbmUuYzozMzYzCiBtc2dpZCAicGVfbGluZV9jb3VudCBpcyB6ZXJvIgogbXNnc3RyICJcInBlX2xpbmVfY291bnRcIiBlcyBjZXJvIgogCi0jOiBtZW1saW5lLmM6MzM5MgogIywgYy1mb3JtYXQKIG1zZ2lkICJFMzIyOiBsaW5lIG51bWJlciBvdXQgb2YgcmFuZ2U6ICVsZCBwYXN0IHRoZSBlbmQiCiBtc2dzdHIgIkUzMjI6IG7Dum1lcm8gZGUgbMOtbmVhIGZ1ZXJhIGRlIHJhbmdvOiAlbGQgbcOhcyBhbGzDoSBkZWwgZmluYWwiCiAKLSM6IG1lbWxpbmUuYzozMzk2CiAjLCBjLWZvcm1hdAogbXNnaWQgIkUzMjM6IGxpbmUgY291bnQgd3JvbmcgaW4gYmxvY2sgJWxkIgogbXNnc3RyICJFMzIzOiByZWN1ZW50byBkZSBsw61uZWFzIGVycsOzbmVvIGVuIGVsIGJsb3F1ZSAlbGQiCiAKLSM6IG1lbWxpbmUuYzozNDQ1CiBtc2dpZCAiU3RhY2sgc2l6ZSBpbmNyZWFzZXMiCiBtc2dzdHIgIkVsIHRhbWHDsW8gZGUgbGEgcGlsYSBhdW1lbnRhIgogCi0jOiBtZW1saW5lLmM6MzQ5MgogbXNnaWQgIkUzMTc6IHBvaW50ZXIgYmxvY2sgaWQgd3JvbmcgMiIKIG1zZ3N0ciAiRTMxNzogRWwgaWQgZGVsIGJsb3F1ZSBkZSBwdW50ZXJvcyBlcyBpbmNvcnJlY3RvLiAyIgogCi0jOiBtZW1saW5lLmM6MzUzMQogIywgYy1mb3JtYXQKIG1zZ2lkICJFNzczOiBTeW1saW5rIGxvb3AgZm9yIFwiJXNcIiIKIG1zZ3N0ciAiRTc3MzogQnVjbGUgZGUgc3ltbGlua3MgcGFyYSBcIiVzXCIiCiAKLSM6IG1lbWxpbmUuYzozNzI2CiBtc2dpZCAiRTMyNTogQVRURU5USU9OIgogbXNnc3RyICJFMzI1OiBBVEVOQ0nDk04iCiAKLSM6IG1lbWxpbmUuYzozNzI3CiBtc2dpZCAiIgogIlxuIgogIkZvdW5kIGEgc3dhcCBmaWxlIGJ5IHRoZSBuYW1lIFwiIgpAQCAtNDcwNywxOSArMzY2MiwxNCBAQAogIlxuIgogIlNlIGhhIGVuY29udHJhZG8gdW4gYXJjaGl2byBkZSBpbnRlcmNhbWJpbyBjb24gZWwgbm9tYnJlIFwiIgogCi0jOiBtZW1saW5lLmM6MzczMQogbXNnaWQgIldoaWxlIG9wZW5pbmcgZmlsZSBcIiIKIG1zZ3N0ciAiYWwgYWJyaXIgZWwgYXJjaGl2byBcIiIKIAotIzogbWVtbGluZS5jOjM3NDQKIG1zZ2lkICIgICAgICBORVdFUiB0aGFuIHN3YXAgZmlsZSFcbiIKIG1zZ3N0ciAiICAgICBNw4FTIE5VRVZPIHF1ZSBlbCBhcmNoaXZvIGRlIGludGVyY2FtYmlvIVxuIgogCiAjIFNvbWUgb2YgdGhlc2UgbWVzc2FnZXMgYXJlIGxvbmcgdG8gYWxsb3cgdHJhbnNsYXRpb24gdG8KICMgKiBvdGhlciBsYW5ndWFnZXMuCi0jLiBTb21lIG9mIHRoZXNlIG1lc3NhZ2VzIGFyZSBsb25nIHRvIGFsbG93IHRyYW5zbGF0aW9uIHRvCi0jLiAqIG90aGVyIGxhbmd1YWdlcy4KLSM6IG1lbWxpbmUuYzozNzQ4CiBtc2dpZCAiIgogIlxuIgogIigxKSBBbm90aGVyIHByb2dyYW0gbWF5IGJlIGVkaXRpbmcgdGhlIHNhbWUgZmlsZS5cbiIKQEAgLTQ3MzEsMTEgKzM2ODEsOSBAQAogIiAgICBEZSBzZXIgYXPDrSwgdGVuZ2EgY3VpZGFkbyBkZSBubyBhY2FiYXIgY29uIGRvc1xuIgogIiAgICBlamVtcGxhcmVzIGRpZmVyZW50ZXMgZGVsIG1pc21vIGFyY2hpdm8gYWwgaGFjZXIgY2FtYmlvcy5cbiIKIAotIzogbWVtbGluZS5jOjM3NDkKIG1zZ2lkICIgICAgUXVpdCwgb3IgY29udGludWUgd2l0aCBjYXV0aW9uLlxuIgogbXNnc3RyICIgICAgU2FsZ2EgZGVsIHByb2dyYW1hIG8gY29udGluw7plIGNvbiBwcmVjYXVjacOzbi5cbiIKIAotIzogbWVtbGluZS5jOjM3NTAKIG1zZ2lkICIiCiAiXG4iCiAiKDIpIEFuIGVkaXQgc2Vzc2lvbiBmb3IgdGhpcyBmaWxlIGNyYXNoZWQuXG4iCkBAIC00NzQzLDExICszNjkxLDkgQEAKICJcbiIKICIoMikgRmFsbMOzIHVuYSBzZXNpw7NuIGRlIGVkaWNpw7NuIGRlIGVzdGUgYXJjaGl2by5cbiIKIAotIzogbWVtbGluZS5jOjM3NTEKIG1zZ2lkICIgICAgSWYgdGhpcyBpcyB0aGUgY2FzZSwgdXNlIFwiOnJlY292ZXJcIiBvciBcInZpbSAtciAiCiBtc2dzdHIgIiAgICBTaSBlcyBhc8OtLCB1c2UgXCI6cmVjb3ZlclwiIG8gXCJ2aW0gLXIgIgogCi0jOiBtZW1saW5lLmM6Mzc1MwogbXNnaWQgIiIKICJcIlxuIgogIiAgICB0byByZWNvdmVyIHRoZSBjaGFuZ2VzIChzZWUgXCI6aGVscCByZWNvdmVyeVwiKS5cbiIKQEAgLTQ3NTUsMTEgKzM3MDEsOSBAQAogIlwiXG4iCiAiICAgIHBhcmEgcmVjdXBlcmFyIGxvcyBjYW1iaW9zICh2w6lhIFwiOmhlbHAgcmVjb3ZlcnlcIikuXG4iCiAKLSM6IG1lbWxpbmUuYzozNzU0CiBtc2dpZCAiICAgIElmIHlvdSBkaWQgdGhpcyBhbHJlYWR5LCBkZWxldGUgdGhlIHN3YXAgZmlsZSBcIiIKIG1zZ3N0ciAiICAgIFNpIFVkLiB5YSBoYSBoZWNobyBlc3RvLCBib3JyZSBlbCBhcmNoaXZvIGRlIGludGVyY2FtYmlvIFwiIgogCi0jOiBtZW1saW5lLmM6Mzc1NgogbXNnaWQgIiIKICJcIlxuIgogIiAgICB0byBhdm9pZCB0aGlzIG1lc3NhZ2UuXG4iCkBAIC00NzY3LDIzICszNzExLDE4IEBACiAiXCJcbiIKICIgICAgcGFyYSBldml0YXIgZXN0ZSBtZW5zYWplLlxuIgogCi0jOiBtZW1saW5lLmM6NDE3NSBtZW1saW5lLmM6NDE3OQogbXNnaWQgIlN3YXAgZmlsZSBcIiIKIG1zZ3N0ciAiwqFFbCBhcmNoaXZvIGRlIGludGVyY2FtYmlvIFwiIgogCi0jOiBtZW1saW5lLmM6NDE3NiBtZW1saW5lLmM6NDE4MgogbXNnaWQgIlwiIGFscmVhZHkgZXhpc3RzISIKIG1zZ3N0ciAiXCIgeWEgZXhpc3RlISIKIAotIzogbWVtbGluZS5jOjQxODUKIG1zZ2lkICJWSU0gLSBBVFRFTlRJT04iCiBtc2dzdHIgIlZJTSAtIEFURU5DScOTTiIKIAotIzogbWVtbGluZS5jOjQxODcKIG1zZ2lkICJTd2FwIGZpbGUgYWxyZWFkeSBleGlzdHMhIgogbXNnc3RyICLCoVlhIGV4aXN0ZSB1biBhcmNoaXZvIGRlIGludGVyY2FtYmlvISIKIAotIzogbWVtbGluZS5jOjQxOTEKIG1zZ2lkICIiCiAiJk9wZW4gUmVhZC1Pbmx5XG4iCiAiJkVkaXQgYW55d2F5XG4iCkBAIC00Nzk3LDcgKzM3MzYsNiBAQAogIiZTYWxpclxuIgogIkEmYm9ydGFyIgogCi0jOiBtZW1saW5lLmM6NDE5MwogbXNnaWQgIiIKICImT3BlbiBSZWFkLU9ubHlcbiIKICImRWRpdCBhbnl3YXlcbiIKQEAgLTQ4MTMsNDYgKzM3NTEsMzQgQEAKICImU2FsaXJcbiIKICImQWJvcnRhciIKIAotIzogbWVtbGluZS5jOjQyNjQKIG1zZ2lkICJFMzI2OiBUb28gbWFueSBzd2FwIGZpbGVzIGZvdW5kIgogbXNnc3RyICJFMzI2OiBTZSBoYW4gZW5jb250cmFkbyBkZW1hc2lhZG9zIGFyY2hpdm9zIGRlIGludGVyY2FtYmlvIgogCi0jOiBtZW51LmM6NjQKIG1zZ2lkICJFMzI3OiBQYXJ0IG9mIG1lbnUtaXRlbSBwYXRoIGlzIG5vdCBzdWItbWVudSIKIG1zZ3N0ciAiRTMyNzogUGFydGUgZGUgbGEgcnV0YSBkZWwgaXRlbSBkZWwgbWVuw7ogbm8gZXMgdW4gc3ViLW1lbsO6IgogCi0jOiBtZW51LmM6NjUKIG1zZ2lkICJFMzI4OiBNZW51IG9ubHkgZXhpc3RzIGluIGFub3RoZXIgbW9kZSIKIG1zZ3N0ciAiRTMyODogRWwgbWVuw7ogc29sbyBleGlzdGUgZW4gb3RybyBtb2RvIGRlIG9wZXJhY2nDs24iCiAKLSM6IG1lbnUuYzo2NgogIywgYy1mb3JtYXQKIG1zZ2lkICJFMzI5OiBObyBtZW51IFwiJXNcIiIKIG1zZ3N0ciAiRTMyOTogTm8gZXhpc3RlIGVsIG1lbsO6IFwiJXNcIiIKIAotIy4gT25seSBhIG1uZW1vbmljIG9yIGFjY2VsZXJhdG9yIGlzIG5vdCB2YWxpZC4KLSM6IG1lbnUuYzo1MTkKIG1zZ2lkICJFNzkyOiBFbXB0eSBtZW51IG5hbWUiCiBtc2dzdHIgIkU3OTI6IE5vbWJyZSBkZSBtZW7DuiB2YWPDrW8iCiAKLSM6IG1lbnUuYzo1MzcKIG1zZ2lkICJFMzMwOiBNZW51IHBhdGggbXVzdCBub3QgbGVhZCB0byBhIHN1Yi1tZW51IgogbXNnc3RyICJFMzMwOiBMYSBydXRhIGRlbCBtZW7DuiBubyBkZWJlIGNvbmR1Y2lyIGEgdW4gc3ViLW1lbsO6IgogCi0jOiBtZW51LmM6NTc2CiBtc2dpZCAiRTMzMTogTXVzdCBub3QgYWRkIG1lbnUgaXRlbXMgZGlyZWN0bHkgdG8gbWVudSBiYXIiCiBtc2dzdHIgIiIKICJFMzMxOiBObyBzZSBkZWJlbiBhw7FhZGlyIGVsZW1lbnRvcyBkZWwgbWVuw7ogZGlyZWN0YW1lbnRlIGEgbGEgYmFycmEgZGVsIG1lbsO6IgogCi0jOiBtZW51LmM6NTgyCiBtc2dpZCAiRTMzMjogU2VwYXJhdG9yIGNhbm5vdCBiZSBwYXJ0IG9mIGEgbWVudSBwYXRoIgogbXNnc3RyICJFMzMyOiBFbCBzZXBhcmFkb3Igbm8gcHVlZGUgc2VyIHBhcnRlIGRlIHVuYSBydXRhIGRlIG1lbsO6IgogCiAjIE5vdyB3ZSBoYXZlIGZvdW5kIHRoZSBtYXRjaGluZyBtZW51LCBhbmQgd2UgbGlzdCB0aGUgbWFwcGluZ3MKICMgSGlnaGxpZ2h0IHRpdGxlCi0jLiBOb3cgd2UgaGF2ZSBmb3VuZCB0aGUgbWF0Y2hpbmcgbWVudSwgYW5kIHdlIGxpc3QgdGhlIG1hcHBpbmdzCi0jLiBIaWdobGlnaHQgdGl0bGUKLSM6IG1lbnUuYzoxMTI3CiBtc2dpZCAiIgogIlxuIgogIi0tLSBNZW51cyAtLS0iCkBAIC00ODYwLDc4ICszNzg2LDYxIEBACiAiXG4iCiAiLS0tIE1lbsO6cyAtLS0iCiAKLSM6IG1lbnUuYzoyMDkwCiBtc2dpZCAiVGVhciBvZmYgdGhpcyBtZW51IgogbXNnc3RyICJEZXNwcmVuZGVyIHkgZmxvdGFyIGVzdGUgbWVuw7oiCiAKLSM6IG1lbnUuYzoyMTU1CiBtc2dpZCAiRTMzMzogTWVudSBwYXRoIG11c3QgbGVhZCB0byBhIG1lbnUgaXRlbSIKIG1zZ3N0ciAiRTMzMzogTGEgcnV0YSBkZWwgbWVuw7ogZGViZSBjb25kdWNpciBhIHVuIGl0ZW0gZGVsIG1lbsO6IgogCi0jOiBtZW51LmM6MjE3NQogIywgYy1mb3JtYXQKIG1zZ2lkICJFMzM0OiBNZW51IG5vdCBmb3VuZDogJXMiCiBtc2dzdHIgIkUzMzQ6IE5vIHNlIGhhIGVuY29udHJhZG8gZWwgbWVuw7o6ICVzIgogCi0jOiBtZW51LmM6MjI1NwogIywgYy1mb3JtYXQKIG1zZ2lkICJFMzM1OiBNZW51IG5vdCBkZWZpbmVkIGZvciAlcyBtb2RlIgogbXNnc3RyICJFMzM1OiBFbCBtZW7DuiBubyBlc3TDoSBkZWZpbmlkbyBwYXJhIGVsIG1vZG8gJXMiCiAKLSM6IG1lbnUuYzoyMjk1CiBtc2dpZCAiRTMzNjogTWVudSBwYXRoIG11c3QgbGVhZCB0byBhIHN1Yi1tZW51IgogbXNnc3RyICJFMzM2OiBMYSBydXRhIGRlbCBtZW7DuiBkZWJlIGNvbmR1Y2lyIGEgdW4gc3ViLW1lbsO6IgogCi0jOiBtZW51LmM6MjMxNgogbXNnaWQgIkUzMzc6IE1lbnUgbm90IGZvdW5kIC0gY2hlY2sgbWVudSBuYW1lcyIKIG1zZ3N0ciAiRTMzNzogTm8gc2UgaGEgZW5jb250cmFkbyBlbCBtZW7DuiAtIHZlcmlmaXF1ZSBsb3Mgbm9tYnJlcyBkZSBsb3MgbWVuw7pzIgogCi0jOiBtZXNzYWdlLmM6NDYyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkVycm9yIGRldGVjdGVkIHdoaWxlIHByb2Nlc3NpbmcgJXM6IgogbXNnc3RyICJTZSBoYSBkZXRlY3RhZG8gdW4gZXJyb3IgYWwgcHJvY2VzYXIgJXM6IgogCi0jOiBtZXNzYWdlLmM6NDg3CiAjLCBjLWZvcm1hdAogbXNnaWQgImxpbmUgJTRsZDoiCiBtc2dzdHIgImzDrW5lYSAlNGxkIgogCi0jOiBtZXNzYWdlLmM6Njg1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkUzNTQ6IEludmFsaWQgcmVnaXN0ZXIgbmFtZTogJyVzJyIKIG1zZ3N0ciAiRTM1NDogTm9tYnJlIGRlIHJlZ2lzdHJvIG5vIHbDoWxpZG86ICclcyciCiAKLSM6IG1lc3NhZ2UuYzo4MzMKIG1zZ2lkICJNZXNzYWdlcyBtYWludGFpbmVyOiBCcmFtIE1vb2xlbmFhciA8QnJhbUB2aW0ub3JnPiIKIG1zZ3N0ciAiIgogIlRyYWR1Y2Npw7NuOiBQcm95ZWN0byB2aW0tZG9jLWVzIDxodHRwOi8vd3d3LmFzc2VtYmxhLmNvbS93aWtpL3Nob3cvdmltLWRvYy1lcz4iCiAKLSM6IG1lc3NhZ2UuYzoxMDkwCiBtc2dpZCAiSW50ZXJydXB0OiAiCiBtc2dzdHIgIkludGVycnVwY2nDs246ICIKIAotIzogbWVzc2FnZS5jOjEwOTIKIG1zZ2lkICJQcmVzcyBFTlRFUiBvciB0eXBlIGNvbW1hbmQgdG8gY29udGludWUiCiBtc2dzdHIgIlB1bHNlIElOVFJPIG8gZXNjcmliYSB1bmEgb3JkZW4gcGFyYSBjb250aW51YXIiCiAKLSM6IG1lc3NhZ2UuYzoyMTM5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGxpbmUgJWxkIgogbXNnc3RyICIlcywgZW4gbGEgbMOtbmVhICVsZCIKIAotIzogbWVzc2FnZS5jOjI4MzkKIG1zZ2lkICItLSBNb3JlIC0tIgogbXNnc3RyICItLSBNw6FzIC0tIgogCi0jOiBtZXNzYWdlLmM6Mjg0NQogbXNnaWQgIiBTUEFDRS9kL2o6IHNjcmVlbi9wYWdlL2xpbmUgZG93biwgYi91L2s6IHVwLCBxOiBxdWl0ICIKIG1zZ3N0ciAiIEVTUEFDSU8vZC9qOiBwYW50YWxsYS9ww6FnaW5hL2zDrW5lYSBhYmFqbywgYi91L2s6IGFycmliYSwgcTogc2FsaXIgIgogCi0jOiBtZXNzYWdlLmM6MzYzNyBtZXNzYWdlLmM6MzY1MgogbXNnaWQgIlF1ZXN0aW9uIgogbXNnc3RyICJQcmVndW50YSIKIAotIzogbWVzc2FnZS5jOjM2MzkKIG1zZ2lkICIiCiAiJlllc1xuIgogIiZObyIKQEAgLTQ5MzksNyArMzg0OCw2IEBACiAiJlNpXG4iCiAiJk5vIgogCi0jOiBtZXNzYWdlLmM6MzY3MgogbXNnaWQgIiIKICImWWVzXG4iCiAiJk5vXG4iCkBAIC00OTUzLDkwICszODYxLDY4IEBACiAiJkRlc2NhcnRhciB0b2RvXG4iCiAiJkNhbmNlbGFyIgogCi0jOiBtZXNzYWdlLmM6MzcxMwogbXNnaWQgIlNlbGVjdCBEaXJlY3RvcnkgZGlhbG9nIgogbXNnc3RyICJEacOhbG9nbzogU2VsZWNjacOzbiBkZSBkaXJlY3RvcmlvIgogCi0jOiBtZXNzYWdlLmM6MzcxNQogbXNnaWQgIlNhdmUgRmlsZSBkaWFsb2ciCiBtc2dzdHIgIkRpw6Fsb2dvOiBHdWFyZGFyIEFyY2hpdm9zIgogCi0jOiBtZXNzYWdlLmM6MzcxNwogbXNnaWQgIk9wZW4gRmlsZSBkaWFsb2ciCiBtc2dzdHIgIkRpw6Fsb2dvOiBBYnJpciBBcmNoaXZvcyIKIAogIyBUT0RPOiBub24tR1VJIGZpbGUgc2VsZWN0b3IgaGVyZQotIy4gVE9ETzogbm9uLUdVSSBmaWxlIHNlbGVjdG9yIGhlcmUKLSM6IG1lc3NhZ2UuYzozODE3CiBtc2dpZCAiRTMzODogU29ycnksIG5vIGZpbGUgYnJvd3NlciBpbiBjb25zb2xlIG1vZGUiCiBtc2dzdHIgIkUzMzg6IExvIHNpZW50bywgbm8gaGF5IG5hdmVnYWRvciBkZSBhcmNoaXZvcyBlbiBlbCBtb2RvIGRlIGNvbnNvbGEiCiAKLSM6IG1lc3NhZ2UuYzozODQ4CiBtc2dpZCAiRTc2NjogSW5zdWZmaWNpZW50IGFyZ3VtZW50cyBmb3IgcHJpbnRmKCkiCiBtc2dzdHIgIkU3NjY6IEFyZ3VtZW50b3MgaW5zdWZpY2llbnRlcyBwYXJhIHByaW50ZigpIgogCi0jOiBtZXNzYWdlLmM6MzkyNAogbXNnaWQgIkU4MDc6IEV4cGVjdGVkIEZsb2F0IGFyZ3VtZW50IGZvciBwcmludGYoKSIKIG1zZ3N0ciAiRTgwNzogU2UgZXNwZXJhYmEgdW4gYXJndW1lbnRvIFwiRmxvYXRcIiBwYXJhIHByaW50ZigpIgogCi0jOiBtZXNzYWdlLmM6NDgxMgogbXNnaWQgIkU3Njc6IFRvbyBtYW55IGFyZ3VtZW50cyB0byBwcmludGYoKSIKIG1zZ3N0ciAiRTc2NzogRGVtYXNpYWRvcyBhcmd1bWVudG9zIHBhcmEgcHJpbnRmKCkiCiAKLSM6IG1pc2MxLmM6Mjk3NQogbXNnaWQgIlcxMDogV2FybmluZzogQ2hhbmdpbmcgYSByZWFkb25seSBmaWxlIgogbXNnc3RyICJXMTA6IEFkdmVydGVuY2lhOiBjYW1iaWFuZG8gdW4gYXJjaGl2byBkZSBzw7NsbyBsZWN0dXJhIgogCi0jOiBtaXNjMS5jOjMyNjkKIG1zZ2lkICJUeXBlIG51bWJlciBhbmQgPEVudGVyPiBvciBjbGljayB3aXRoIG1vdXNlIChlbXB0eSBjYW5jZWxzKTogIgogbXNnc3RyICJFc2NyaWJhIHVuIG7Dum1lcm8gZSA8SW50cm8+IG8gcHVsc2UgY29uIGVsIHJhdMOzbiAobGEgb21pc2nDs24gY2FuY2VsYSkgIgogCi0jOiBtaXNjMS5jOjMyNzEKIG1zZ2lkICJUeXBlIG51bWJlciBhbmQgPEVudGVyPiAoZW1wdHkgY2FuY2Vscyk6ICIKIG1zZ3N0ciAiRXNjb2phIHVuIG7Dum1lcm8gZSA8SW50cm8+IChsYSBvbWlzacOzbiBjYW5jZWxhIGxhIGFjY2nDs24pOiAiCiAKLSM6IG1pc2MxLmM6MzMyMwogbXNnaWQgIjEgbW9yZSBsaW5lIgogbXNnc3RyICIxIGzDrW5lYSBtw6FzIgogCi0jOiBtaXNjMS5jOjMzMjUKIG1zZ2lkICIxIGxpbmUgbGVzcyIKIG1zZ3N0ciAiMSBsw61uZWEgbWVub3MiCiAKLSM6IG1pc2MxLmM6MzMzMAogIywgYy1mb3JtYXQKIG1zZ2lkICIlbGQgbW9yZSBsaW5lcyIKIG1zZ3N0ciAiJWxkIGzDrW5lYXMgbcOhcyIKIAotIzogbWlzYzEuYzozMzMyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVsZCBmZXdlciBsaW5lcyIKIG1zZ3N0ciAiJWxkIGzDrW5lYXMgbWVub3MiCiAKLSM6IG1pc2MxLmM6MzMzNQogbXNnaWQgIiAoSW50ZXJydXB0ZWQpIgogbXNnc3RyICIgKEludGVycnVtcGlkbykiCiAKLSM6IG1pc2MxLmM6MzQwMAogbXNnaWQgIkJlZXAhIgogbXNnc3RyICLCoUJpcCEiCiAKLSM6IG1pc2MxLmM6ODM4MAogbXNnaWQgIlZpbTogcHJlc2VydmluZyBmaWxlcy4uLlxuIgogbXNnc3RyICJWaW06IHByZXNlcnZhbmRvIGFyY2hpdm9zLi4uXG4iCiAKICMgY2xvc2UgYWxsIG1lbWZpbGVzLCB3aXRob3V0IGRlbGV0aW5nCi0jLiBjbG9zZSBhbGwgbWVtZmlsZXMsIHdpdGhvdXQgZGVsZXRpbmcKLSM6IG1pc2MxLmM6ODM5MAogbXNnaWQgIlZpbTogRmluaXNoZWQuXG4iCiBtc2dzdHIgIlZpbTogRmluYWxpemFkby5cbiIKIAotIzogbWlzYzIuYzo3MTggbWlzYzIuYzo3MzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiRVJST1I6ICIKIG1zZ3N0ciAiRVJST1I6ICIKIAotIzogbWlzYzIuYzo3MzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlxuIgpAQCAtNTA0NSw3ICszOTMxLDYgQEAKICJcbiIKICJbYnl0ZXNdIHRvdGFsIGxpYmVyYWRvcyBwb3IgYWxsb2M6ICVsdS0lbHUsIGVuIHVzbzogJWx1LCB1c28gbcOheGltbzogJWx1XG4iCiAKLSM6IG1pc2MyLmM6NzQwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJbY2FsbHNdIHRvdGFsIHJlL21hbGxvYygpJ3MgJWx1LCB0b3RhbCBmcmVlKCkncyAlbHVcbiIKQEAgLTUwNTQsNTggKzM5MzksNDUgQEAKICJbbGxhbWFkYXNdIHRvdGFsIHJlL21hbGxvYygpOiAlbHUsIHRvdGFsIGZyZWUoKTogJWx1XG4iCiAiXG4iCiAKLSM6IG1pc2MyLmM6Nzk1CiBtc2dpZCAiRTM0MDogTGluZSBpcyBiZWNvbWluZyB0b28gbG9uZyIKIG1zZ3N0ciAiRTM0MDogTGEgbMOtbmVhIHNlIGVzdMOhIGhhY2llbmRvIGRlbWFzaWFkbyBsYXJnYSIKIAotIzogbWlzYzIuYzo4MzkKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTM0MTogSW50ZXJuYWwgZXJyb3I6IGxhbGxvYyglbGQsICkiCiBtc2dzdHIgIkUzNDE6IEVycm9yIGludGVybm86IGxhbGxvYyglbGQsICkiCiAKLSM6IG1pc2MyLmM6OTUzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkUzNDI6IE91dCBvZiBtZW1vcnkhICAoYWxsb2NhdGluZyAlbHUgYnl0ZXMpIgogbXNnc3RyICJFMzQyOiDCoU1lbW9yaWEgYWdvdGFkYSEgKGFsIGFzaWduYXIgJWx1IGJ5dGVzKSIKIAotIzogbWlzYzIuYzozMDMzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNhbGxpbmcgc2hlbGwgdG8gZXhlY3V0ZTogXCIlc1wiIgogbXNnc3RyICJJbnZvY2FuZG8gYWwgaW50w6lycHJldGUgZGUgw7NyZGVuZXMgcGFyYSBlamVjdXRhcjogJXMiCiAKLSM6IG1pc2MyLmM6MzMwMgogbXNnaWQgIkU1NDU6IE1pc3NpbmcgY29sb24iCiBtc2dzdHIgIkU1NDU6IEZhbHRhIHVuIHPDrW1ib2xvIGRlIGRvcyBwdW50b3MiCiAKLSM6IG1pc2MyLmM6MzMwNCBtaXNjMi5jOjMzMzEKIG1zZ2lkICJFNTQ2OiBJbGxlZ2FsIG1vZGUiCiBtc2dzdHIgIkU1NDY6IE1vZG8gZGUgb3BlcmFjacOzbiBpbGVnYWwiCiAKLSM6IG1pc2MyLmM6MzM3MAogbXNnaWQgIkU1NDc6IElsbGVnYWwgbW91c2VzaGFwZSIKIG1zZ3N0ciAiRTU0NzogRWwgXCJtb3VzZXNoYXBlXCIgbm8gZXMgdsOhbGlkbyIKIAotIzogbWlzYzIuYzozNDEwCiBtc2dpZCAiRTU0ODogZGlnaXQgZXhwZWN0ZWQiCiBtc2dzdHIgIkU1NDg6IFNlIGVzcGVyYWJhIHVuIGTDrWdpdG8iCiAKLSM6IG1pc2MyLmM6MzQxNQogbXNnaWQgIkU1NDk6IElsbGVnYWwgcGVyY2VudGFnZSIKIG1zZ3N0ciAiRTU0OTogUG9yY2VudGFqZSBpbGVnYWwiCiAKLSM6IG1pc2MyLmM6MzczNwogbXNnaWQgIkVudGVyIGVuY3J5cHRpb24ga2V5OiAiCiBtc2dzdHIgIkludHJvZHV6Y2EgbGEgY2xhdmUgZGUgY2lmcmFkbzogIgogCi0jOiBtaXNjMi5jOjM3MzgKIG1zZ2lkICJFbnRlciBzYW1lIGtleSBhZ2FpbjogIgogbXNnc3RyICJJbnRyb2R1emNhIGxhIG1pc21hIGNsYXZlIGRlIGNpZnJhZG8gb3RyYSB2ZXo6ICIKIAotIzogbWlzYzIuYzozNzQ5CiBtc2dpZCAiS2V5cyBkb24ndCBtYXRjaCEiCiBtc2dzdHIgIsKhTGFzIGNsYXZlcyBkZSBjaWZyYWRvIG5vIGNvaW5jaWRlbiEiCiAKLSM6IG1pc2MyLmM6NDI5MAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiRTM0MzogSW52YWxpZCBwYXRoOiAnKipbbnVtYmVyXScgbXVzdCBiZSBhdCB0aGUgZW5kIG9mIHRoZSBwYXRoIG9yIGJlICIKQEAgLTUxMTQsMTc4ICszOTg2LDEzOCBAQAogIkUzNDM6IFJ1dGEgbm8gdsOhbGlkYTogJyoqW27Dum1lcm9dJyBkZWJlIGVzdGFyIGFsIGZpbmFsIGRlIGxhIHJ1dGEgIgogIm8gc2VndWlkbyBkZSAlcy4iCiAKLSM6IG1pc2MyLmM6NTU4NQogIywgYy1mb3JtYXQKIG1zZ2lkICJFMzQ0OiBDYW4ndCBmaW5kIGRpcmVjdG9yeSBcIiVzXCIgaW4gY2RwYXRoIgogbXNnc3RyICJFMzQ0OiBObyBzZSBwdWRvIGVuY29udHJhciBlbCBkaXJlY3RvcmlvIFwiJXNcIiBlbiBcImNkcGF0aFwiIgogCi0jOiBtaXNjMi5jOjU1ODgKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTM0NTogQ2FuJ3QgZmluZCBmaWxlIFwiJXNcIiBpbiBwYXRoIgogbXNnc3RyICJFMzQ1OiBObyBzZSBwdWRvIGVuY29udHJhciBlbCBhcmNoaXZvICVzIGVuIGxhIHJ1dGEiCiAKLSM6IG1pc2MyLmM6NTU5NAogIywgYy1mb3JtYXQKIG1zZ2lkICJFMzQ2OiBObyBtb3JlIGRpcmVjdG9yeSBcIiVzXCIgZm91bmQgaW4gY2RwYXRoIgogbXNnc3RyICJFMzQ2OiBObyBzZSBoYW4gZW5jb250cmFkbyBtYXMgZGlyZWN0b3Jpb3MgXCIlc1wiIGVuIFwiY2RwYXRoXCIiCiAKLSM6IG1pc2MyLmM6NTU5NwogIywgYy1mb3JtYXQKIG1zZ2lkICJFMzQ3OiBObyBtb3JlIGZpbGUgXCIlc1wiIGZvdW5kIGluIHBhdGgiCiBtc2dzdHIgIkUzNDc6IE5vIHNlIGhhbiBlbmNvbnRyYWRvIG1hcyBhcmNoaXZvcyBcIiVzXCIgZW4gbGEgcnV0YSIKIAogIyBHZXQgaGVyZSB3aGVuIHRoZSBzZXJ2ZXIgY2FuJ3QgYmUgZm91bmQuCi0jOiBuZXRiZWFucy5jOjQwNgogbXNnaWQgIkNhbm5vdCBjb25uZWN0IHRvIE5ldGJlYW5zICMyIgogbXNnc3RyICJObyBzZSBwdWRvIGNvbmVjdGFyIGEgTmV0QmVhbnMgIzIiCiAKLSM6IG5ldGJlYW5zLmM6NDE1CiBtc2dpZCAiQ2Fubm90IGNvbm5lY3QgdG8gTmV0YmVhbnMiCiBtc2dzdHIgIk5vIHNlIHB1ZG8gY29uZWN0YXIgYSBOZXRCZWFucyIKIAogIyBjLWZvcm1hdAotIzogbmV0YmVhbnMuYzo0NjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTY2ODogV3JvbmcgYWNjZXNzIG1vZGUgZm9yIE5ldEJlYW5zIGNvbm5lY3Rpb24gaW5mbyBmaWxlOiBcIiVzXCIiCiBtc2dzdHIgIkU2Njg6IEVsIGR1ZcOxby9hIGRlbCBhcmNoaXZvIGRlIGNvbmV4acOzbiBOZXRCZWFucyBubyBlcyB2w6FsaWRvOiAlcyIKIAotIzogbmV0YmVhbnMuYzo3NzAKIG1zZ2lkICJyZWFkIGZyb20gTmV0YmVhbnMgc29ja2V0IgogbXNnc3RyICJsZcOtZG8gZGVsIHNvY2tldCBOZXRCZWFucyIKIAotIzogbmV0YmVhbnMuYzoxODcyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkU2NTg6IE5ldEJlYW5zIGNvbm5lY3Rpb24gbG9zdCBmb3IgYnVmZmVyICVsZCIKIG1zZ3N0ciAiRTY1ODogU2UgcGVyZGnDsyBsYSBjb25leGnDs24gTmV0QmVhbnMgcGFyYSBlbCBiw7pmZXIgJWxkIgogCi0jOiBuZXRiZWFucy5jOjM2OTIKIG1zZ2lkICJFNTA1OiAiCiBtc2dzdHIgIkU1MDU6ICIKIAotIzogbm9ybWFsLmM6MTg2CiBtc2dpZCAiRTM0OTogTm8gaWRlbnRpZmllciB1bmRlciBjdXJzb3IiCiBtc2dzdHIgIkUzNDk6IE5vIGhheSBuaW5nw7puIGlkZW50aWZpY2Fkb3IgYmFqbyBlbCBjdXJzb3IiCiAKLSM6IG5vcm1hbC5jOjIxOTgKIG1zZ2lkICJFNzc0OiAnb3BlcmF0b3JmdW5jJyBpcyBlbXB0eSIKIG1zZ3N0ciAiRTc3NDogJ29wZXJhdG9yZnVuYycgZXN0w6EgdmFjw61vIgogCi0jOiBub3JtYWwuYzoyMjE3CiBtc2dpZCAiRTc3NTogRXZhbCBmZWF0dXJlIG5vdCBhdmFpbGFibGUiCiBtc2dzdHIgIkU3NzU6IExhIGNhcmFjdGVyw61zdGljYSBcImV2YWxcIiBubyBlc3TDoSBkaXNwb25pYmxlIgogCi0jOiBub3JtYWwuYzozMjIxCiBtc2dpZCAiV2FybmluZzogdGVybWluYWwgY2Fubm90IGhpZ2hsaWdodCIKIG1zZ3N0ciAiQWR2ZXJ0ZW5jaWE6IGxhIHRlcm1pbmFsIG5vIHB1ZWRlIHJlc2FsdGFyIGVsIHRleHRvIgogCi0jOiBub3JtYWwuYzozNTE2CiBtc2dpZCAiRTM0ODogTm8gc3RyaW5nIHVuZGVyIGN1cnNvciIKIG1zZ3N0ciAiRTM0ODogTm8gaGF5IG5pbmd1bmEgY2FkZW5hIGJham8gZWwgY3Vyc29yIgogCi0jOiBub3JtYWwuYzo0ODY4CiBtc2dpZCAiRTM1MjogQ2Fubm90IGVyYXNlIGZvbGRzIHdpdGggY3VycmVudCAnZm9sZG1ldGhvZCciCiBtc2dzdHIgIkUzNTI6IE5vIHNlIHB1ZG8gYm9ycmFyIHBsaWVndWVzIGNvbiBlbCAnZm9sbWV0aG9kJyBhY3R1YWwiCiAKLSM6IG5vcm1hbC5jOjczNjUKIG1zZ2lkICJFNjY0OiBjaGFuZ2VsaXN0IGlzIGVtcHR5IgogbXNnc3RyICJFNjY0OiBMYSBsaXN0YSBkZSBjYW1iaW9zIGVzdMOhIHZhY8OtYSIKIAotIzogbm9ybWFsLmM6NzM2NwogbXNnaWQgIkU2NjI6IEF0IHN0YXJ0IG9mIGNoYW5nZWxpc3QiCiBtc2dzdHIgIkU2NjI6IEFsIGNvbWllbnpvIGRlIGxhIGxpc3RhIGRlIGNhbWJpb3MiCiAKLSM6IG5vcm1hbC5jOjczNjkKIG1zZ2lkICJFNjYzOiBBdCBlbmQgb2YgY2hhbmdlbGlzdCIKIG1zZ3N0ciAiRTY2MzogQWwgZmluYWwgZGUgbGEgbGlzdGEgZGUgY2FtYmlvcyIKIAotIzogbm9ybWFsLmM6ODczNAogbXNnaWQgIlR5cGUgIDpxdWl0PEVudGVyPiAgdG8gZXhpdCBWaW0iCiBtc2dzdHIgIkVzY3JpYmEgXCI6cXVpdDxpbnRybz5cIiBwYXJhIHNhbGlyIGRlIFZpbSIKIAotIzogb3BzLmM6MjkzCiAjLCBjLWZvcm1hdAogbXNnaWQgIjEgbGluZSAlc2VkIDEgdGltZSIKIG1zZ3N0ciAiMSBsw61uZWEgJXNlZCAxIHZleiIKIAotIzogb3BzLmM6Mjk1CiAjLCBjLWZvcm1hdAogbXNnaWQgIjEgbGluZSAlc2VkICVkIHRpbWVzIgogbXNnc3RyICIxIGzDrW5lYSAlc2VkICVkIHZlY2VzIgogCi0jOiBvcHMuYzozMDAKICMsIGMtZm9ybWF0CiBtc2dpZCAiJWxkIGxpbmVzICVzZWQgMSB0aW1lIgogbXNnc3RyICIlbGQgbMOtbmVhcyAlc2VkIDEgdmV6IgogCi0jOiBvcHMuYzozMDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJWxkIGxpbmVzICVzZWQgJWQgdGltZXMiCiBtc2dzdHIgIiVsZCBsw61uZWFzICVzZWQgJWQgdmVjZXMiCiAKLSM6IG9wcy5jOjY5MQogIywgYy1mb3JtYXQKIG1zZ2lkICIlbGQgbGluZXMgdG8gaW5kZW50Li4uICIKIG1zZ3N0ciAiJWxkIGzDrW5lYXMgcG9yIHNhbmdyYXIuLi4iCiAKLSM6IG9wcy5jOjc0MgogbXNnaWQgIjEgbGluZSBpbmRlbnRlZCAiCiBtc2dzdHIgIjEgbMOtbmVhIHNhbmdyYWRhIgogCi0jOiBvcHMuYzo3NDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJWxkIGxpbmVzIGluZGVudGVkICIKIG1zZ3N0ciAiJWxkIGzDrW5lYXMgc2FuZ3JhZGFzIgogCi0jOiBvcHMuYzoxMTcwCiBtc2dpZCAiRTc0ODogTm8gcHJldmlvdXNseSB1c2VkIHJlZ2lzdGVyIgogbXNnc3RyICJFNzQ4OiBObyBoYXkgcmVnaXN0cm8gcHJldmlhbWVudGUgZW4gdXNvIgogCiAjIG11c3QgZGlzcGxheSB0aGUgcHJvbXB0Ci0jLiBtdXN0IGRpc3BsYXkgdGhlIHByb21wdAotIzogb3BzLmM6MTczNAogbXNnaWQgImNhbm5vdCB5YW5rOyBkZWxldGUgYW55d2F5IgogbXNnc3RyICJObyBzZSBwdWRvIGNvcGlhciBcInlhbmtcIjsgwr9MbyBib3JybyBkZSB0b2RhcyBmb3JtYXM/IgogCi0jOiBvcHMuYzoyMzMxCiBtc2dpZCAiMSBsaW5lIGNoYW5nZWQiCiBtc2dzdHIgIjEgbMOtbmVhIGNhbWJpYWRhIgogCi0jOiBvcHMuYzoyMzMzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVsZCBsaW5lcyBjaGFuZ2VkIgogbXNnc3RyICIlbGQgbMOtbmVhcyBjYW1iaWFkYXMiCiAKLSM6IG9wcy5jOjI3ODgKICMsIGMtZm9ybWF0CiBtc2dpZCAiZnJlZWluZyAlbGQgbGluZXMiCiBtc2dzdHIgImxpYmVyYW5kbyAlbGQgbMOtbmVhcyIKIAotIzogb3BzLmM6MzA3MwogbXNnaWQgImJsb2NrIG9mIDEgbGluZSB5YW5rZWQiCiBtc2dzdHIgImJsb3F1ZSBkZSAxIGzDrW5lYSBjb3BpYWRhIgogCi0jOiBvcHMuYzozMDc2CiBtc2dpZCAiMSBsaW5lIHlhbmtlZCIKIG1zZ3N0ciAiMSBsw61uZWEgY29waWFkYSIKIAotIzogb3BzLmM6MzA4MAogIywgYy1mb3JtYXQKIG1zZ2lkICJibG9jayBvZiAlbGQgbGluZXMgeWFua2VkIgogbXNnc3RyICJibG9xdWUgZGUgJWxkIGzDrW5lYXMgY29waWFkYXMiCiAKLSM6IG9wcy5jOjMwODMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJWxkIGxpbmVzIHlhbmtlZCIKIG1zZ3N0ciAiJWxkIGzDrW5lYXMgY29waWFkYXMiCiAKLSM6IG9wcy5jOjMzNzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTM1MzogTm90aGluZyBpbiByZWdpc3RlciAlcyIKIG1zZ3N0ciAiRTM1MzogTm8gaGF5IG5hZGEgZW4gZWwgcmVnaXN0cm8gJXMiCiAKICMgSGlnaGxpZ2h0IHRpdGxlCi0jLiBIaWdobGlnaHQgdGl0bGUKLSM6IG9wcy5jOjM5NzAKIG1zZ2lkICIiCiAiXG4iCiAiLS0tIFJlZ2lzdGVycyAtLS0iCkBAIC01MjkzLDExICs0MTI1LDkgQEAKICJcbiIKICItLS0gUmVnaXN0cm9zIC0tLSIKIAotIzogb3BzLmM6NTM0NAogbXNnaWQgIklsbGVnYWwgcmVnaXN0ZXIgbmFtZSIKIG1zZ3N0ciAiTm9tYnJlIGRlIHJlZ2lzdHJvIGlsZWdhbCIKIAotIzogb3BzLmM6NTQ0MAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiXG4iCkBAIC01MzA2LDIzICs0MTM2LDE5IEBACiAiXG4iCiAiIyBSZWdpc3Ryb3M6XG4iCiAKLSM6IG9wcy5jOjU0OTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTU3NDogVW5rbm93biByZWdpc3RlciB0eXBlICVkIgogbXNnc3RyICJFNTc0OiBSZWdpc3RybyBkZXNjb25vY2lkbyBkZSB0aXBvICVkIgogCi0jOiBvcHMuYzo2NDM1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVsZCBDb2xzOyAiCiBtc2dzdHIgIiVsZCBDb2xzOyAiCiAKLSM6IG9wcy5jOjY0NDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiU2VsZWN0ZWQgJXMlbGQgb2YgJWxkIExpbmVzOyAlbGQgb2YgJWxkIFdvcmRzOyAlbGQgb2YgJWxkIEJ5dGVzIgogbXNnc3RyICIiCiAiU2VsZWNjacOzbiAlcyVsZCBkZSAlbGQgTMOtbmVhczsgJWxkIGRlICVsZCBQYWxhYnJhczsgJWxkIGRlICVsZCBDYXJhY3RlcmVzIgogCi0jOiBvcHMuYzo2NDUxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJTZWxlY3RlZCAlcyVsZCBvZiAlbGQgTGluZXM7ICVsZCBvZiAlbGQgV29yZHM7ICVsZCBvZiAlbGQgQ2hhcnM7ICVsZCBvZiAlbGQgIgpAQCAtNTMzMSwxMiArNDE1NywxMCBAQAogIlNlbGVjY2nDs24gJXMlbGQgZGUgJWxkIEzDrW5lYXM7ICVsZCBkZSAlbGQgUGFsYWJyYXM7ICVsZCBkZSAlbGQgQ2FyYWN0ZXJlczsgJSIKICJsZCBkZSAlbGQgQnl0ZXMiCiAKLSM6IG9wcy5jOjY0NzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ29sICVzIG9mICVzOyBMaW5lICVsZCBvZiAlbGQ7IFdvcmQgJWxkIG9mICVsZDsgQnl0ZSAlbGQgb2YgJWxkIgogbXNnc3RyICJDb2wgJXMgZGUgJXM7IEzDrW5lYSAlbGQgZGUgJWxkOyBQYWxhYnJhICVsZCBkZSAlbGQ7IEJ5dGUgJWxkIGRlICVsZCIKIAotIzogb3BzLmM6NjQ3OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ29sICVzIG9mICVzOyBMaW5lICVsZCBvZiAlbGQ7IFdvcmQgJWxkIG9mICVsZDsgQ2hhciAlbGQgb2YgJWxkOyBCeXRlICVsZCBvZiAiCkBAIC01MzQ1LDE3MyArNDE2OSwxMzEgQEAKICJDb2wgJXMgZGUgJXM7IEzDrW5lYSAlbGQgZGUgJWxkOyBQYWxhYnJhICVsZCBkZSAlbGQ7IENhcsOhY3RlciAlbGQgZGUgJWxkIEJ5dGUgIgogIiVsZCBkZSAlbGQiCiAKLSM6IG9wcy5jOjY0OTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiKCslbGQgZm9yIEJPTSkiCiBtc2dzdHIgIigrJWxkIHBhcmEgQk9NKSIKIAotIzogb3B0aW9uLmM6MTk1MwogbXNnaWQgIiU8JWYlaCVtJT1QYWdlICVOIgogbXNnc3RyICIlPCVmJWglbSU9UMOhZ2luYSAlTiIKIAotIzogb3B0aW9uLmM6MjUyNAogbXNnaWQgIlRoYW5rcyBmb3IgZmx5aW5nIFZpbSIKIG1zZ3N0ciAiR3JhY2lhcyBwb3Igdm9sYXIgY29uIFZpbSIKIAotIzogb3B0aW9uLmM6NDA5OSBvcHRpb24uYzo0MjQyCiBtc2dpZCAiRTUxODogVW5rbm93biBvcHRpb24iCiBtc2dzdHIgIkU1MTg6IE9wY2nDs24gZGVzY29ub2NpZGEiCiAKLSM6IG9wdGlvbi5jOjQxMTIKIG1zZ2lkICJFNTE5OiBPcHRpb24gbm90IHN1cHBvcnRlZCIKIG1zZ3N0ciAiRTUxOTogT3BjacOzbiBubyBhZG1pdGlkYSIKIAotIzogb3B0aW9uLmM6NDE1MAogbXNnaWQgIkU1MjA6IE5vdCBhbGxvd2VkIGluIGEgbW9kZWxpbmUiCiBtc2dzdHIgIkU1MjA6IE5vIHBlcm1pdGlkbyBlbiB1bmEgXCJtb2RlbGluZVwiIgogCi0jOiBvcHRpb24uYzo0MzY4CiBtc2dpZCAiRTUyMTogTnVtYmVyIHJlcXVpcmVkIGFmdGVyID0iCiBtc2dzdHIgIkU1MjE6IERlYmUgaW50cm9kdWNpciB1biBuw7ptZXJvIGRlc3B1w6lzIGRlIFwiPVwiIgogCi0jOiBvcHRpb24uYzo0NjkzIG9wdGlvbi5jOjU0OTkKIG1zZ2lkICJFNTIyOiBOb3QgZm91bmQgaW4gdGVybWNhcCIKIG1zZ3N0ciAiRTUyMjogTm8gbG8gZW5jb250csOpIGVuIGVsIFwidGVybWNhcFwiIgogCi0jOiBvcHRpb24uYzo0ODEwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkU1Mzk6IElsbGVnYWwgY2hhcmFjdGVyIDwlcz4iCiBtc2dzdHIgIkU1Mzk6IENhcsOhY3RlciBpbGVnYWwgPCVzPiIKIAotIzogb3B0aW9uLmM6NTQ5MQogbXNnaWQgIkU1Mjk6IENhbm5vdCBzZXQgJ3Rlcm0nIHRvIGVtcHR5IHN0cmluZyIKIG1zZ3N0ciAiRTUyOTogTm8gc2UgcHVkbyBkZWZpbmlyIFwidGVybVwiIGNvbW8gdW5hIGNhZGVuYSBkZSBjYXJhY3RlcmVzIHZhY8OtYSIKIAotIzogb3B0aW9uLmM6NTQ5NAogbXNnaWQgIkU1MzA6IENhbm5vdCBjaGFuZ2UgdGVybSBpbiBHVUkiCiBtc2dzdHIgIkU1MzA6IE5vIHNlIHB1ZG8gY2FtYmlhciBcInRlcm1cIiBlbiBsYSBpbnRlcmZheiBncsOhZmljYSIKIAotIzogb3B0aW9uLmM6NTQ5NgogbXNnaWQgIkU1MzE6IFVzZSBcIjpndWlcIiB0byBzdGFydCB0aGUgR1VJIgogbXNnc3RyICJFNTMxOiBVc2UgXCI6Z3VpXCIgcGFyYSBpbmljaWFyIGxhIGludGVyZmF6IGdyw6FmaWNhIgogCi0jOiBvcHRpb24uYzo1NTI1CiBtc2dpZCAiRTU4OTogJ2JhY2t1cGV4dCcgYW5kICdwYXRjaG1vZGUnIGFyZSBlcXVhbCIKIG1zZ3N0ciAiRTU4OTogXCJiYWNrdXBleHRcIiB5IFwicGF0Y2htb2RlXCIgc29uIGlndWFsZXMiCiAKLSM6IG9wdGlvbi5jOjU3NTMKIG1zZ2lkICJFNjE3OiBDYW5ub3QgYmUgY2hhbmdlZCBpbiB0aGUgR1RLKyAyIEdVSSIKIG1zZ3N0ciAiRTYxNzogTm8gcHVlZGUgY2FtYmlhcnNlIGVuIGxhIGludGVyZmF6IGdyw6FmaWNhIGRlIEdUSysgMiIKIAotIzogb3B0aW9uLmM6NTkzMQogbXNnaWQgIkU1MjQ6IE1pc3NpbmcgY29sb24iCiBtc2dzdHIgIkU1MjQ6IEZhbHRhIHVuIHPDrW1ib2xvIGRlIGRvcyBwdW50b3MiCiAKLSM6IG9wdGlvbi5jOjU5MzMKIG1zZ2lkICJFNTI1OiBaZXJvIGxlbmd0aCBzdHJpbmciCiBtc2dzdHIgIkU1MjU6IENhZGVuYSBkZSBjYXJhY3RlcmVzIGRlIGxhcmdvIGNlcm8iCiAKLSM6IG9wdGlvbi5jOjYwMTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTUyNjogTWlzc2luZyBudW1iZXIgYWZ0ZXIgPCVzPiIKIG1zZ3N0ciAiRTUyNjogRmFsdGEgZWwgbsO6bWVybyBkZXNwdcOpcyBkZSA8JXM+IgogCi0jOiBvcHRpb24uYzo2MDMwCiBtc2dpZCAiRTUyNzogTWlzc2luZyBjb21tYSIKIG1zZ3N0ciAiRTUyNzogRmFsdGEgdW5hIGNvbWEiCiAKLSM6IG9wdGlvbi5jOjYwMzcKIG1zZ2lkICJFNTI4OiBNdXN0IHNwZWNpZnkgYSAnIHZhbHVlIgogbXNnc3RyICJFNTI4OiBEZWJlIGVzcGVjaWZpY2FyIHVuIHZhbG9yICIKIAotIzogb3B0aW9uLmM6NjA4NgogbXNnaWQgIkU1OTU6IGNvbnRhaW5zIHVucHJpbnRhYmxlIG9yIHdpZGUgY2hhcmFjdGVyIgogbXNnc3RyICJFNTk1OiBDb250aWVuZSB1biBjYXLDoWN0ZXIgbm8gaW1wcmltaWJsZSBvIGRlIG3DoXMgZGUgdW4gYnl0ZSIKIAotIzogb3B0aW9uLmM6NjEzMAogbXNnaWQgIkU1OTY6IEludmFsaWQgZm9udChzKSIKIG1zZ3N0ciAiRTU5NjogTGFzIGZ1ZW50ZS9zIGRlIGltcHJlc2nDs24gbm8gc29uIHbDoWxpZGFzIgogCi0jOiBvcHRpb24uYzo2MTM5CiBtc2dpZCAiRTU5NzogY2FuJ3Qgc2VsZWN0IGZvbnRzZXQiCiBtc2dzdHIgIkU1OTc6IE5vIHNlIHB1ZG8gc2VsZWNjaW9uYXIgZXNlIFwiZm9udHNldFwiIgogCi0jOiBvcHRpb24uYzo2MTQxCiBtc2dpZCAiRTU5ODogSW52YWxpZCBmb250c2V0IgogbXNnc3RyICJFNTk4OiBFbCBjb25qdW50byBkZSB0aXBvcyBkZSBsZXRyYSBkZSBpbXByZXNpw7NuIG5vIGVzIHbDoWxpZG8iCiAKLSM6IG9wdGlvbi5jOjYxNDkKIG1zZ2lkICJFNTMzOiBjYW4ndCBzZWxlY3Qgd2lkZSBmb250IgogbXNnc3RyICIiCiAiRTUzMzogTm8gc2UgcHVkbyBzZWxlY2Npb25hciBlbCB0aXBvIGRlIGxldHJhIGRlIGltcHJlc2nDs24gXCJhbmNob1wiIChkZSAiCiAiXCJieXRlXCIgZG9ibGUpIgogCi0jOiBvcHRpb24uYzo2MTUxCiBtc2dpZCAiRTUzNDogSW52YWxpZCB3aWRlIGZvbnQiCiBtc2dzdHIgIkU1MzQ6IFRpcG8gZGUgbGV0cmEgZGUgaW1wcmVzacOzbiBcImFuY2hvXCIgaW52w6FsaWRhIgogCi0jOiBvcHRpb24uYzo2NDc3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkU1MzU6IElsbGVnYWwgY2hhcmFjdGVyIGFmdGVyIDwlYz4iCiBtc2dzdHIgIkU1MzU6IENhcsOhY3RlciBpbGVnYWwgZGVzcHXDqXMgZGUgPCVjPiIKIAotIzogb3B0aW9uLmM6NjU5NwogbXNnaWQgIkU1MzY6IGNvbW1hIHJlcXVpcmVkIgogbXNnc3RyICJFNTM2OiBuZWNlc2l0YSB1bmEgY29tYSIKIAotIzogb3B0aW9uLmM6NjYwNwogIywgYy1mb3JtYXQKIG1zZ2lkICJFNTM3OiAnY29tbWVudHN0cmluZycgbXVzdCBiZSBlbXB0eSBvciBjb250YWluICVzIgogbXNnc3RyICJFNTM3OiAnY29tbWVudHN0cmluZycgZGViZSBlc3RhciB2YWPDrW8gbyBjb250ZW5lciAlcyIKIAotIzogb3B0aW9uLmM6NjY4OAogbXNnaWQgIkU1Mzg6IE5vIG1vdXNlIHN1cHBvcnQiCiBtc2dzdHIgIkU1Mzg6IE5vIGhheSBzb3BvcnRlIHBhcmEgZWwgcmF0w7NuIgogCi0jOiBvcHRpb24uYzo3MDA3CiBtc2dpZCAiRTU0MDogVW5jbG9zZWQgZXhwcmVzc2lvbiBzZXF1ZW5jZSIKIG1zZ3N0ciAiRTU0MDogU2VjdWVuY2lhIGRlIGV4cHJlc2nDs24gc2luIGNlcnJhciIKIAotIzogb3B0aW9uLmM6NzAxMQogbXNnaWQgIkU1NDE6IHRvbyBtYW55IGl0ZW1zIgogbXNnc3RyICJFNTQxOiBEZW1hc2lhZG9zIGVsZW1lbnRvcyIKIAotIzogb3B0aW9uLmM6NzAxMwogbXNnaWQgIkU1NDI6IHVuYmFsYW5jZWQgZ3JvdXBzIgogbXNnc3RyICJFNTQyOiBHcnVwb3Mgc2luIGVxdWlsaWJyYXIiCiAKLSM6IG9wdGlvbi5jOjczNDkKIG1zZ2lkICJFNTkwOiBBIHByZXZpZXcgd2luZG93IGFscmVhZHkgZXhpc3RzIgogbXNnc3RyICJFNTkwOiBZYSBleGlzdGUgdW5hIHZlbnRhbmEgZGUgdmlzdWFsaXphY2nDs24gcHJldmlhIgogCi0jOiBvcHRpb24uYzo3NjA1CiBtc2dpZCAiVzE3OiBBcmFiaWMgcmVxdWlyZXMgVVRGLTgsIGRvICc6c2V0IGVuY29kaW5nPXV0Zi04JyIKIG1zZ3N0ciAiVzE3OiBMYSBvcGNpw7NuIMOhcmFiZSBuZWNlc2l0YSBkZSBVVEYtOCwgdXNlIFwiOnNldCBlbmNvZGluZz11dGYtOFwiIgogCi0jOiBvcHRpb24uYzo4MDI4CiAjLCBjLWZvcm1hdAogbXNnaWQgIkU1OTM6IE5lZWQgYXQgbGVhc3QgJWQgbGluZXMiCiBtc2dzdHIgIkU1OTM6IE5lY2VzaXRhIGFsIG1lbm9zICVkIGzDrW5lYXMiCiAKLSM6IG9wdGlvbi5jOjgwMzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTU5NDogTmVlZCBhdCBsZWFzdCAlZCBjb2x1bW5zIgogbXNnc3RyICJFNTk0OiBOZWNlc2l0YSBhbCBtZW5vcyAlZCBjb2x1bW5hcyIKIAotIzogb3B0aW9uLmM6ODM1NwogIywgYy1mb3JtYXQKIG1zZ2lkICJFMzU1OiBVbmtub3duIG9wdGlvbjogJXMiCiBtc2dzdHIgIkUzNTU6IE9wY2nDs24gZGVzY29ub2NpZGE6ICVzIgogCi0jLiBUaGVyZSdzIGFub3RoZXIgY2hhcmFjdGVyIGFmdGVyIHplcm9zIG9yIHRoZSBzdHJpbmcKLSMuICogaXMgZW1wdHkuICBJbiBib3RoIGNhc2VzLCB3ZSBhcmUgdHJ5aW5nIHRvIHNldCBhCi0jLiAqIG51bSBvcHRpb24gdXNpbmcgYSBzdHJpbmcuCi0jOiBvcHRpb24uYzo4Mzg5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkU1MjE6IE51bWJlciByZXF1aXJlZDogJiVzID0gJyVzJyIKIG1zZ3N0ciAiRTUyMTogRGViZSBpbnRyb2R1Y2lyIHVuIG7Dum1lcm86ICYlcyA9ICclcyciCiAKLSM6IG9wdGlvbi5jOjg1MTMKIG1zZ2lkICIiCiAiXG4iCiAiLS0tIFRlcm1pbmFsIGNvZGVzIC0tLSIKQEAgLTU1MTksNyArNDMwMSw2IEBACiAiXG4iCiAiLS0tIEPDs2RpZ29zIGRlIHRlcm1pbmFsIC0tLSIKIAotIzogb3B0aW9uLmM6ODUxNQogbXNnaWQgIiIKICJcbiIKICItLS0gR2xvYmFsIG9wdGlvbiB2YWx1ZXMgLS0tIgpAQCAtNTUyNyw3ICs0MzA4LDYgQEAKICJcbiIKICItLS0gVmFsb3JlcyBkZSBsYXMgb3BjaW9uZXMgZ2xvYmFsZXMgLS0tIgogCi0jOiBvcHRpb24uYzo4NTE3CiBtc2dpZCAiIgogIlxuIgogIi0tLSBMb2NhbCBvcHRpb24gdmFsdWVzIC0tLSIKQEAgLTU1MzUsNyArNDMxNSw2IEBACiAiXG4iCiAiLS0tIFZhbG9yZXMgZGUgbGFzIG9wY2lvbmVzIGxvY2FsZXMgLS0tIgogCi0jOiBvcHRpb24uYzo4NTE5CiBtc2dpZCAiIgogIlxuIgogIi0tLSBPcHRpb25zIC0tLSIKQEAgLTU1NDMsMTUwICs0MzIyLDExNyBAQAogIlxuIgogIi0tLSBPcGNpb25lcyAtLS0iCiAKLSM6IG9wdGlvbi5jOjkzMzIKIG1zZ2lkICJFMzU2OiBnZXRfdmFycCBFUlJPUiIKIG1zZ3N0ciAiRTM1NjogRVJST1IgZW4gXCJnZXRfdmFycFwiIgogCi0jOiBvcHRpb24uYzoxMDQzMQogIywgYy1mb3JtYXQKIG1zZ2lkICJFMzU3OiAnbGFuZ21hcCc6IE1hdGNoaW5nIGNoYXJhY3RlciBtaXNzaW5nIGZvciAlcyIKIG1zZ3N0ciAiRTM1NzogXCJsYW5nbWFwXCI6IGZhbHRhIGNhcsOhY3RlciBjb2luY2lkZW50ZSBwYXJhICVzIgogCi0jOiBvcHRpb24uYzoxMDQ2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJFMzU4OiAnbGFuZ21hcCc6IEV4dHJhIGNoYXJhY3RlcnMgYWZ0ZXIgc2VtaWNvbG9uOiAlcyIKIG1zZ3N0ciAiRTM1ODogXCJsYW5nbWFwXCI6IGNhcmFjdGVyZXMgZXh0cmEgZGVzcHXDqXMgZGVsIHB1bnRvIHkgY29tYTogJXMiCiAKLSM6IG9zX2FtaWdhLmM6Mjc4CiBtc2dpZCAiY2Fubm90IG9wZW4gIgogbXNnc3RyICJObyBzZSBwdWRvIGFicmlyIgogCi0jOiBvc19hbWlnYS5jOjMxMwogbXNnaWQgIlZJTTogQ2FuJ3Qgb3BlbiB3aW5kb3chXG4iCiBtc2dzdHIgIlZJTTogwqFObyBzZSBwdWRvIGFicmlyIGxhIHZlbnRhbmEhXG4iCiAKLSM6IG9zX2FtaWdhLmM6MzQwCiBtc2dpZCAiTmVlZCBBbWlnYWRvcyB2ZXJzaW9uIDIuMDQgb3IgbGF0ZXJcbiIKIG1zZ3N0ciAiTmVjZXNpdG8gQW1pZ2Fkb3MgMi4wNCBvIHVuYSB2ZXJzacOzbiBwb3N0ZXJpb3JcbiIKIAotIzogb3NfYW1pZ2EuYzozNDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiTmVlZCAlcyB2ZXJzaW9uICVsZFxuIgogbXNnc3RyICJOZWNlc2l0byAlcyB2ZXJzacOzbiAlbGRcbiIKIAotIzogb3NfYW1pZ2EuYzo0MTkKIG1zZ2lkICJDYW5ub3Qgb3BlbiBOSUw6XG4iCiBtc2dzdHIgIk5vIHNlIHB1ZG8gYWJyaXIgTklMOlxuIgogCi0jOiBvc19hbWlnYS5jOjQzNwogbXNnaWQgIkNhbm5vdCBjcmVhdGUgIgogbXNnc3RyICJObyBzZSBwdWRvIGNyZWFyICIKIAotIzogb3NfYW1pZ2EuYzo5NDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiVmltIGV4aXRpbmcgd2l0aCAlZFxuIgogbXNnc3RyICJTYWxpZW5kbyBkZSBWaW0gY29uICVkXG4iCiAKLSM6IG9zX2FtaWdhLmM6OTc5CiBtc2dpZCAiY2Fubm90IGNoYW5nZSBjb25zb2xlIG1vZGUgPyFcbiIKIG1zZ3N0ciAiwqHCv05vIHNlIHB1ZG8gY2FtYmlhciBlbCBtb2RvIGRlIGxhIGNvbnNvbGE/IVxuIgogCi0jOiBvc19hbWlnYS5jOjEwNTcKIG1zZ2lkICJtY2hfZ2V0X3NoZWxsc2l6ZTogbm90IGEgY29uc29sZT8/XG4iCiBtc2dzdHIgIlwibWNoX2dldF9zaGVsbHNpemVcIjogwr9ObyBlcyB1bmEgY29uc29sYT9cbiIKIAogIyBpZiBWaW0gb3BlbmVkIGEgd2luZG93OiBFeGVjdXRpbmcgYSBzaGVsbCBtYXkgY2F1c2UgY3Jhc2hlcwotIy4gaWYgVmltIG9wZW5lZCBhIHdpbmRvdzogRXhlY3V0aW5nIGEgc2hlbGwgbWF5IGNhdXNlIGNyYXNoZXMKLSM6IG9zX2FtaWdhLmM6MTIxMgogbXNnaWQgIkUzNjA6IENhbm5vdCBleGVjdXRlIHNoZWxsIHdpdGggLWYgb3B0aW9uIgogbXNnc3RyICJFMzYwOiBObyBzZSBwdWRvIGVqZWN1dGFyIGVsIGludMOpcnByZXRlIGRlIMOzcmRlbmVzIGNvbiBsYSBvcGNpw7NuIC1mIgogCi0jOiBvc19hbWlnYS5jOjEyNTMgb3NfYW1pZ2EuYzoxMzQzCiBtc2dpZCAiQ2Fubm90IGV4ZWN1dGUgIgogbXNnc3RyICJObyBzZSBwdWVkZSBlamVjdXRhciAiCiAKLSM6IG9zX2FtaWdhLmM6MTI1NiBvc19hbWlnYS5jOjEzNTMKIG1zZ2lkICJzaGVsbCAiCiBtc2dzdHIgInNoZWxsICIKIAotIzogb3NfYW1pZ2EuYzoxMjc2IG9zX2FtaWdhLmM6MTM3OAogbXNnaWQgIiByZXR1cm5lZFxuIgogbXNnc3RyICIgZGV2b2x2acOzXG4iCiAKLSM6IG9zX2FtaWdhLmM6MTU0MAogbXNnaWQgIkFOQ0hPUl9CVUZfU0laRSB0b28gc21hbGwuIgogbXNnc3RyICJcIkFOQ0hPUl9CVUZfU0laRVwiIGRlbWFzaWFkbyBwZXF1ZcOxby4iCiAKLSM6IG9zX2FtaWdhLmM6MTU0NAogbXNnaWQgIkkvTyBFUlJPUiIKIG1zZ3N0ciAiRVJST1IgSS9PIgogCi0jOiBvc19tc3dpbi5jOjU5NQogbXNnaWQgIk1lc3NhZ2UiCiBtc2dzdHIgIk1lbnNhamUiCiAKLSM6IG9zX21zd2luLmM6NzEwCiBtc2dpZCAiJ2NvbHVtbnMnIGlzIG5vdCA4MCwgY2Fubm90IGV4ZWN1dGUgZXh0ZXJuYWwgY29tbWFuZHMiCiBtc2dzdHIgIlwiY29sdW1uc1wiIG5vIGVzIDgwLCBubyBwdWVkZSBlamVjdXRhciDDs3JkZW5lcyBleHRlcm5hcyIKIAotIzogb3NfbXN3aW4uYzoyMTQzCiBtc2dpZCAiRTIzNzogUHJpbnRlciBzZWxlY3Rpb24gZmFpbGVkIgogbXNnc3RyICJFMjM3OiBGYWxsw7MgbGEgc2VsZWNjacOzbiBkZSBpbXByZXNvcmEiCiAKLSM6IG9zX21zd2luLmM6MjE4MwogIywgYy1mb3JtYXQKIG1zZ2lkICJ0byAlcyBvbiAlcyIKIG1zZ3N0ciAicGFyYSAlcyBlbiAlcyIKIAotIzogb3NfbXN3aW4uYzoyMTk4CiAjLCBjLWZvcm1hdAogbXNnaWQgIkU2MTM6IFVua25vd24gcHJpbnRlciBmb250OiAlcyIKIG1zZ3N0ciAiRTYxMzogVGlwbyBkZSBsZXRyYSBkZSBpbXByZXNpw7NuIGRlc2Nvbm9jaWRhIGVuIGxhIGltcHJlc29yYTogJXMiCiAKLSM6IG9zX21zd2luLmM6MjI0NyBvc19tc3dpbi5jOjIyNTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTIzODogUHJpbnQgZXJyb3I6ICVzIgogbXNnc3RyICJFMjM4OiBFcnJvciBkZSBpbXByZXNpw7NuOiAlcyIKIAotIzogb3NfbXN3aW4uYzoyMjg1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlByaW50aW5nICclcyciCiBtc2dzdHIgIkltcHJpbWllbmRvICVzIgogCi0jOiBvc19tc3dpbi5jOjM0NjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTI0NDogSWxsZWdhbCBjaGFyc2V0IG5hbWUgXCIlc1wiIGluIGZvbnQgbmFtZSBcIiVzXCIiCiBtc2dzdHIgIiIKICJFMjQ0OiBFbCBub21icmUgZGVsIGNvbmp1bnRvIGRlIGNhcmFjdGVyZXMgXCIlc1wiIG5vIGVzIHbDoWxpZG8gZW4gZWwgIgogIm5vbWJyZSBkZWwgdGlwbyBkZSBsZXRyYSBkZSBpbXByZXNpw7NuIFwiJXNcIiIKIAotIzogb3NfbXN3aW4uYzozNDcxCiAjLCBjLWZvcm1hdAogbXNnaWQgIkUyNDU6IElsbGVnYWwgY2hhciAnJWMnIGluIGZvbnQgbmFtZSBcIiVzXCIiCiBtc2dzdHIgIiIKICJFMjQ1OiBDYXLDoWN0ZXIgJyVjJyBpbGVnYWwgZW4gZWwgbm9tYnJlIGRlbCB0aXBvIGRlIGxldHJhIGRlICIKICJpbXByZXNpw7NuICVzIgogCi0jOiBvc191bml4LmM6MTA2NQogbXNnaWQgIlZpbTogRG91YmxlIHNpZ25hbCwgZXhpdGluZ1xuIgogbXNnc3RyICJWaW06IFNlw7FhbCBkb2JsZSwgc2FsaWVuZG9cbiIKIAotIzogb3NfdW5peC5jOjEwNzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiVmltOiBDYXVnaHQgZGVhZGx5IHNpZ25hbCAlc1xuIgogbXNnc3RyICJWaW06IENhcHTDqSB1bmEgc2XDsWFsIG1vcnRhbCAlc1xuIgogCi0jOiBvc191bml4LmM6MTA3NAogIywgYy1mb3JtYXQKIG1zZ2lkICJWaW06IENhdWdodCBkZWFkbHkgc2lnbmFsXG4iCiBtc2dzdHIgIlZpbTogQ2FwdMOpIHVuYSBzZcOxYWwgbW9ydGFsXG4iCiAKLSM6IG9zX3VuaXguYzoxNDEyCiAjLCBjLWZvcm1hdAogbXNnaWQgIk9wZW5pbmcgdGhlIFggZGlzcGxheSB0b29rICVsZCBtc2VjIgogbXNnc3RyICJBYnJpciBsYSBwYW50YWxsYSBYIHRvbcOzICVsZCBtc2VnIgogCi0jOiBvc191bml4LmM6MTQzOQogbXNnaWQgIiIKICJcbiIKICJWaW06IEdvdCBYIGVycm9yXG4iCkBAIC01Njk0LDE1ICs0NDQwLDEyIEBACiAiXG4iCiAiVmltOiBIYXkgdW4gZXJyb3IgZGUgWFxuIgogCi0jOiBvc191bml4LmM6MTU0NAogbXNnaWQgIlRlc3RpbmcgdGhlIFggZGlzcGxheSBmYWlsZWQiCiBtc2dzdHIgIkZhbGzDsyBsYSBwcnVlYmEgZGVsIHNpc3RlbWEgWCIKIAotIzogb3NfdW5peC5jOjE2ODQKIG1zZ2lkICJPcGVuaW5nIHRoZSBYIGRpc3BsYXkgdGltZWQgb3V0IgogbXNnc3RyICJFbCBcImRpc3BsYXlcIiBkZSBYIHRhcmTDsyBkZW1hc2lhZG8gZW4gYWJyaXJzZSIKIAotIzogb3NfdW5peC5jOjI2NTggb3NfdW5peC5jOjI2NjUKIG1zZ2lkICIiCiAiXG4iCiAiQ291bGQgbm90IGdldCBzZWN1cml0eSBjb250ZXh0IGZvciAiCkBAIC01NzEwLDcgKzQ0NTMsNiBAQAogIlxuIgogIk5vIHNlIHB1ZG8gb2J0ZW5lciBlbCBjb250ZXh0byBkZSBzZWd1cmlkYWQgcGFyYSAiCiAKLSM6IG9zX3VuaXguYzoyNjc1CiBtc2dpZCAiIgogIlxuIgogIkNvdWxkIG5vdCBzZXQgc2VjdXJpdHkgY29udGV4dCBmb3IgIgpAQCAtNTcxOCw3ICs0NDYwLDYgQEAKICJcbiIKICJObyBzZSBwdWRvIGRlZmluaXIgZWwgY29udGV4dG8gZGUgc2VndXJpZGFkIHBhcmEgIgogCi0jOiBvc191bml4LmM6MzY5NSBvc191bml4LmM6NDYyMAogbXNnaWQgIiIKICJcbiIKICJDYW5ub3QgZXhlY3V0ZSBzaGVsbCAiCkBAIC01NzI2LDcgKzQ0NjcsNiBAQAogIlxuIgogIk5vIHNlIHB1ZG8gZWplY3V0YXIgZWwgaW50w6lycHJldGUgZGUgw7NyZGVuZXMgIgogCi0jOiBvc191bml4LmM6Mzc0MwogbXNnaWQgIiIKICJcbiIKICJDYW5ub3QgZXhlY3V0ZSBzaGVsbCBzaFxuIgpAQCAtNTczNCw3ICs0NDc0LDYgQEAKICJcbiIKICJObyBzZSBwdWRvIGVqZWN1dGFyIGVsIGludMOpcnByZXRlIGRlIMOzcmRlbmVzIFwic2hcIlxuIgogCi0jOiBvc191bml4LmM6Mzc0NyBvc191bml4LmM6NDYyNgogbXNnaWQgIiIKICJcbiIKICJzaGVsbCByZXR1cm5lZCAiCkBAIC01NzQyLDcgKzQ0ODEsNiBAQAogIlxuIgogIkVsIGludMOpcnByZXRlIGRlIMOzcmRlbmVzIGRldm9sdmnDsyAiCiAKLSM6IG9zX3VuaXguYzozODkxCiBtc2dpZCAiIgogIlxuIgogIkNhbm5vdCBjcmVhdGUgcGlwZXNcbiIKQEAgLTU3NTAsNyArNDQ4OCw2IEBACiAiXG4iCiAiTm8gc2UgcHVkbyBjcmVhciBcInBpcGVzXCJcbiIKIAotIzogb3NfdW5peC5jOjM5MDUgb3NfdW5peC5jOjQxNjkKIG1zZ2lkICIiCiAiXG4iCiAiQ2Fubm90IGZvcmtcbiIKQEAgLTU3NTgsNyArNDQ5NSw2IEBACiAiXG4iCiAiTm8gc2UgcHVkbyBjcmVhciBwcm9jZXNvIHNlY3VuZGFyaW8gXCJmb3JrXCJcbiIKIAotIzogb3NfdW5peC5jOjQ2MzMKIG1zZ2lkICIiCiAiXG4iCiAiQ29tbWFuZCB0ZXJtaW5hdGVkXG4iCkBAIC01NzY2LDc5ICs0NTAyLDYxIEBACiAiXG4iCiAiTGEgb3JkZW4gZnVlIHRlcm1pbmFkYVxuIgogCi0jOiBvc191bml4LmM6NDkxOSBvc191bml4LmM6NTA2OSBvc191bml4LmM6Njc5MgogbXNnaWQgIlhTTVAgbG9zdCBJQ0UgY29ubmVjdGlvbiIKIG1zZ3N0ciAiWFNNUCBwZXJkacOzIGxhIGNvbmV4acOzbiBJQ0UiCiAKLSM6IG9zX3VuaXguYzo2MTkyIG9zX3VuaXguYzo2Mjk1CiAjLCBjLWZvcm1hdAogbXNnaWQgImRsZXJyb3IgPSBcIiVzXCIiCiBtc2dzdHIgImRsZXJyb3IgPSBcIiVzXCIiCiAKLSM6IG9zX3VuaXguYzo2Mzc3CiBtc2dpZCAiT3BlbmluZyB0aGUgWCBkaXNwbGF5IGZhaWxlZCIKIG1zZ3N0ciAiRmFsbMOzIGxhIGFwZXJ0dXJhIGRlIGxhIHBhbnRhbGxhIGRlIFgiCiAKLSM6IG9zX3VuaXguYzo2NzAxCiBtc2dpZCAiWFNNUCBoYW5kbGluZyBzYXZlLXlvdXJzZWxmIHJlcXVlc3QiCiBtc2dzdHIgIlhTTVAgZXN0w6EgbWFuZWphbmRvIHVuYSBzb2xpY2l0dWQgZGUgXCJndWFyZGVsbyB1c3RlZCBtaXNtb1wiIgogCi0jOiBvc191bml4LmM6NjgxNQogbXNnaWQgIlhTTVAgb3BlbmluZyBjb25uZWN0aW9uIgogbXNnc3RyICJYU01QIGVzdMOhIGFicmllbmRvIHVuYSBjb25leGnDs24iCiAKLSM6IG9zX3VuaXguYzo2ODM0CiBtc2dpZCAiWFNNUCBJQ0UgY29ubmVjdGlvbiB3YXRjaCBmYWlsZWQiCiBtc2dzdHIgIlhTTVAgRmFsbMOzIGVsIHN1cGVydmlzacOzbiBkZSBsYSBjb25leGnDs24gSUNFIgogCi0jOiBvc191bml4LmM6Njg1OAogIywgYy1mb3JtYXQKIG1zZ2lkICJYU01QIFNtY09wZW5Db25uZWN0aW9uIGZhaWxlZDogJXMiCiBtc2dzdHIgIlhTTVAgU21jT3BlbkNvbm5lY3Rpb24gZmFsbMOzOiAlcyIKIAotIzogb3Nfdm1zX21tcy5jOjYwCiBtc2dpZCAiQXQgbGluZSIKIG1zZ3N0ciAiRW4gbGEgbMOtbmVhIgogCi0jOiBvc193MzJleGUuYzo4OQogbXNnaWQgIkNvdWxkIG5vdCBsb2FkIHZpbTMyLmRsbCEiCiBtc2dzdHIgIsKhTm8gc2UgcHVkbyBjYXJnYXIgXCJ2aW0zMi5kbGxcIiEiCiAKLSM6IG9zX3czMmV4ZS5jOjg5IG9zX3czMmV4ZS5jOjEwMAogbXNnaWQgIlZJTSBFcnJvciIKIG1zZ3N0ciAiRXJyb3IgZGUgVmltIgogCi0jOiBvc193MzJleGUuYzo5OQogbXNnaWQgIkNvdWxkIG5vdCBmaXggdXAgZnVuY3Rpb24gcG9pbnRlcnMgdG8gdGhlIERMTCEiCiBtc2dzdHIgIsKhTm8gc2UgcHVkbyBjb25lY3RhciBsb3MgcHVudGVyb3MgZGUgbGEgZnVuY2nDs24gYSBsYSBETEwhIgogCi0jOiBvc193aW4xNi5jOjM0MiBvc193aW4zMi5jOjMzOTkKICMsIGMtZm9ybWF0CiBtc2dpZCAic2hlbGwgcmV0dXJuZWQgJWQiCiBtc2dzdHIgIkVsIGludMOpcnByZXRlIGRlIMOzcmRlbmVzIGhhIGRldnVlbHRvICVkIgogCi0jOiBvc193aW4zMi5jOjI4NTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiVmltOiBDYXVnaHQgJXMgZXZlbnRcbiIKIG1zZ3N0ciAiVmltOiBDYXB0w6kgZWwgZXZlbnRvICVzXG4iCiAKLSM6IG9zX3dpbjMyLmM6Mjg1OAogbXNnaWQgImNsb3NlIgogbXNnc3RyICJjZXJyYXIiCiAKLSM6IG9zX3dpbjMyLmM6Mjg2MAogbXNnaWQgImxvZ29mZiIKIG1zZ3N0ciAiY2VycmFyIGxhIHNlc2nDs24iCiAKLSM6IG9zX3dpbjMyLmM6Mjg2MQogbXNnaWQgInNodXRkb3duIgogbXNnc3RyICJhcGFnYXIiCiAKLSM6IG9zX3dpbjMyLmM6MzM1MQogbXNnaWQgIkUzNzE6IENvbW1hbmQgbm90IGZvdW5kIgogbXNnc3RyICJFMzcxOiBObyBzZSBlbmNvbnRyw7MgbGEgb3JkZW4iCiAKLSM6IG9zX3dpbjMyLmM6MzM2NAogbXNnaWQgIiIKICJWSU1SVU4uRVhFIG5vdCBmb3VuZCBpbiB5b3VyICRQQVRILlxuIgogIkV4dGVybmFsIGNvbW1hbmRzIHdpbGwgbm90IHBhdXNlIGFmdGVyIGNvbXBsZXRpb24uXG4iCkBAIC01ODQ4LDM2MyArNDU2NiwyODAgQEAKICJMYXMgw7NyZGVuZXMgZXh0ZXJuYXMgbm8gaGFyw6FuIHVuYSBwYXVzYSBhbCBmaW5hbGl6YXIuXG4iCiAiVsOpYXNlIFwiOmhlbHAgd2luMzItdmltcnVuXCIgIHBhcmEgbcOhcyBpbmZvcm1hY2nDs24iCiAKLSM6IG9zX3dpbjMyLmM6MzM2NwogbXNnaWQgIlZpbSBXYXJuaW5nIgogbXNnc3RyICJBZHZlcnRlbmNpYSBkZSBWaW0iCiAKLSM6IHF1aWNrZml4LmM6MzMwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkUzNzI6IFRvbyBtYW55ICUlJWMgaW4gZm9ybWF0IHN0cmluZyIKIG1zZ3N0ciAiRTM3MjogRGVtYXNpYWRvcyAlJSVjIGVuIGxhIGNhZGVuYSBkZSBmb3JtYXRvIgogCi0jOiBxdWlja2ZpeC5jOjM0MwogIywgYy1mb3JtYXQKIG1zZ2lkICJFMzczOiBVbmV4cGVjdGVkICUlJWMgaW4gZm9ybWF0IHN0cmluZyIKIG1zZ3N0ciAiRTM3MzogJSUlYyBpbmVzcGVyYWRvIGVuIGxhIGNhZGVuYSBkZSBmb3JtYXRvIgogCi0jOiBxdWlja2ZpeC5jOjQwNQogbXNnaWQgIkUzNzQ6IE1pc3NpbmcgXSBpbiBmb3JtYXQgc3RyaW5nIgogbXNnc3RyICJFMzc0OiBGYWx0YSBdIGVuIGxhIGNhZGVuYSBkZSBmb3JtYXRvIgogCi0jOiBxdWlja2ZpeC5jOjQxOQogIywgYy1mb3JtYXQKIG1zZ2lkICJFMzc1OiBVbnN1cHBvcnRlZCAlJSVjIGluIGZvcm1hdCBzdHJpbmciCiBtc2dzdHIgIkUzNzU6ICUlJWMgbm8gYWRtaXRpZG8gZW4gY2FkZW5hIGRlIGZvcm1hdG8iCiAKLSM6IHF1aWNrZml4LmM6NDM5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkUzNzY6IEludmFsaWQgJSUlYyBpbiBmb3JtYXQgc3RyaW5nIHByZWZpeCIKIG1zZ3N0ciAiRTM3NjogJSUlYyBubyBlcyB2w6FsaWRvIGVuIGVsIHByZWZpam8gZGUgdW5hIGNhZGVuYSBkZSBmb3JtYXRvIgogCi0jOiBxdWlja2ZpeC5jOjQ0NwogIywgYy1mb3JtYXQKIG1zZ2lkICJFMzc3OiBJbnZhbGlkICUlJWMgaW4gZm9ybWF0IHN0cmluZyIKIG1zZ3N0ciAiRTM3NzogJSUlYyBubyBlcyB2w6FsaWRvIGVuIHVuYSBjYWRlbmEgZGUgZm9ybWF0byIKIAotIzogcXVpY2tmaXguYzo0NzMKIG1zZ2lkICJFMzc4OiAnZXJyb3Jmb3JtYXQnIGNvbnRhaW5zIG5vIHBhdHRlcm4iCiBtc2dzdHIgIkUzNzg6ICdlcnJvcmZvcm1hdCcgbm8gY29udGllbmUgdW4gcGF0csOzbiIKIAotIzogcXVpY2tmaXguYzo3MDYKIG1zZ2lkICJFMzc5OiBNaXNzaW5nIG9yIGVtcHR5IGRpcmVjdG9yeSBuYW1lIgogbXNnc3RyICJFMzc5OiBIYWNlIGZhbHRhIGVsIG5vbWJyZSBkZWwgZGlyZWN0b3JpbyIKIAotIzogcXVpY2tmaXguYzoxNDA4CiBtc2dpZCAiRTU1MzogTm8gbW9yZSBpdGVtcyIKIG1zZ3N0ciAiRTU1MzogTm8gaGF5IG3DoXMgZWxlbWVudG9zIgogCi0jOiBxdWlja2ZpeC5jOjE4MzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiKCVkIG9mICVkKSVzJXM6ICIKIG1zZ3N0ciAiKCVkIGRlICVkKSVzJXM6ICIKIAotIzogcXVpY2tmaXguYzoxODMyCiBtc2dpZCAiIChsaW5lIGRlbGV0ZWQpIgogbXNnc3RyICIgKGzDrW5lYSBib3JyYWRhKSIKIAotIzogcXVpY2tmaXguYzoyMDYxCiBtc2dpZCAiRTM4MDogQXQgYm90dG9tIG9mIHF1aWNrZml4IHN0YWNrIgogbXNnc3RyICJFMzgwOiBBbCBmaW5hbCBkZSBsYSBwaWxhIGRlIGNvcnJlY2Npw7NuIHLDoXBpZGEiCiAKLSM6IHF1aWNrZml4LmM6MjA3MAogbXNnaWQgIkUzODE6IEF0IHRvcCBvZiBxdWlja2ZpeCBzdGFjayIKIG1zZ3N0ciAiRTM4MTogQWwgcHJpbmNpcGlvIGRlIGxhIHBpbGEgZGUgY29ycmVjY2nDs24gcsOhcGlkYSIKIAotIzogcXVpY2tmaXguYzoyMDg0CiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIGxpc3QgJWQgb2YgJWQ7ICVkIGVycm9ycyIKIG1zZ3N0ciAibGlzdGEgZGUgZXJyb3JlcyAlZCBkZSAlZDogJWQgZXJyb3JlcyIKIAotIzogcXVpY2tmaXguYzoyNjcwCiBtc2dpZCAiRTM4MjogQ2Fubm90IHdyaXRlLCAnYnVmdHlwZScgb3B0aW9uIGlzIHNldCIKIG1zZ3N0ciAiRTM4MjogTm8gc2UgcHVkbyBlc2NyaWJpciwgbGEgb3BjacOzbiBcImJ1ZnR5cGVcIiBlc3TDoSBhY3RpdmEiCiAKLSM6IHF1aWNrZml4LmM6MzA3NAogbXNnaWQgIkU2ODM6IEZpbGUgbmFtZSBtaXNzaW5nIG9yIGludmFsaWQgcGF0dGVybiIKIG1zZ3N0ciAiRTY4MzogRmFsdGEgZWwgbm9tYnJlIGRlbCBhcmNoaXZvIG8gZWwgcGF0csOzbiBubyBlcyB2w6FsaWRvIgogCi0jOiBxdWlja2ZpeC5jOjMxNzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ2Fubm90IG9wZW4gZmlsZSBcIiVzXCIiCiBtc2dzdHIgIk5vIHNlIHB1ZG8gYWJyaXIgZWwgYXJjaGl2byAlcyIKIAotIzogcXVpY2tmaXguYzozNzA1CiBtc2dpZCAiRTY4MTogQnVmZmVyIGlzIG5vdCBsb2FkZWQiCiBtc2dzdHIgIkU2ODE6IEVsIGLDumZlciBubyBlc3TDoSBjYXJnYWRvIgogCi0jOiBxdWlja2ZpeC5jOjM3NjYKIG1zZ2lkICJFNzc3OiBTdHJpbmcgb3IgTGlzdCBleHBlY3RlZCIKIG1zZ3N0ciAiRTc3NzogU2UgZXNwZXJhYmEgdW5hIGxpc3RhIG8gdW5hIGNhZGVuYSBkZSBjYXJhY3RlcmVzIgogCi0jOiByZWdleHAuYzozMzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTM2OTogaW52YWxpZCBpdGVtIGluICVzJSVbXSIKIG1zZ3N0ciAiRTM2OTogRWwgZWxlbWVudG8gZW4gJXMlJVtdIG5vIGVzIHbDoWxpZG8iCiAKLSM6IHJlZ2V4cC5jOjEwMTcKIG1zZ2lkICJFMzM5OiBQYXR0ZXJuIHRvbyBsb25nIgogbXNnc3RyICJFMzM5OiBQYXRyw7NuIGRlbWFzaWFkbyBsYXJnbyIKIAotIzogcmVnZXhwLmM6MTE4OQogbXNnaWQgIkU1MDogVG9vIG1hbnkgXFx6KCIKIG1zZ3N0ciAiRTUwOiBEZW1hc2lhZG9zIFxceigiCiAKLSM6IHJlZ2V4cC5jOjEyMDAKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTUxOiBUb28gbWFueSAlcygiCiBtc2dzdHIgIkU1MTogSGF5IGRlbWFzaWFkb3MgJXMoIgogCi0jOiByZWdleHAuYzoxMjU3CiBtc2dpZCAiRTUyOiBVbm1hdGNoZWQgXFx6KCIKIG1zZ3N0ciAiRTUyOiBcXHooIHNpbiBjb21wbGVtZW50byIKIAotIzogcmVnZXhwLmM6MTI2MQogIywgYy1mb3JtYXQKIG1zZ2lkICJFNTM6IFVubWF0Y2hlZCAlcyUlKCIKIG1zZ3N0ciAiRTUzOiAlcyUlKCBzaW4gY29tcGxlbWVudG8iCiAKLSM6IHJlZ2V4cC5jOjEyNjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTU0OiBVbm1hdGNoZWQgJXMoIgogbXNnc3RyICJFNTQ6ICVzKCBzaW4gY29tcGxlbWVudG8iCiAKLSM6IHJlZ2V4cC5jOjEyNjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTU1OiBVbm1hdGNoZWQgJXMpIgogbXNnc3RyICJFNTU6ICVzKSBzaW4gY29tcGxlbWVudG8iCiAKLSM6IHJlZ2V4cC5jOjE0ODQKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTU5OiBpbnZhbGlkIGNoYXJhY3RlciBhZnRlciAlc0AiCiBtc2dzdHIgIkU1OTogQ2Fyw6FjdGVyIGludsOhbGlkbyBkZXNwdcOpcyBkZSAlc0AiCiAKLSM6IHJlZ2V4cC5jOjE1MTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTYwOiBUb28gbWFueSBjb21wbGV4ICVzey4uLn1zIgogbXNnc3RyICJFNjA6IEhheSBkZW1hc2lhZG9zICVzey4uLn1zIGNvbXBsZWpvcyIKIAotIzogcmVnZXhwLmM6MTUzNAogIywgYy1mb3JtYXQKIG1zZ2lkICJFNjE6IE5lc3RlZCAlcyoiCiBtc2dzdHIgIkU2MTogQW5pZGFkbyAlcyoiCiAKLSM6IHJlZ2V4cC5jOjE1MzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTYyOiBOZXN0ZWQgJXMlYyIKIG1zZ3N0ciAiRTYyOiBBbmlkYWRvICVzJWMiCiAKLSM6IHJlZ2V4cC5jOjE2NTcKIG1zZ2lkICJFNjM6IGludmFsaWQgdXNlIG9mIFxcXyIKIG1zZ3N0ciAiRTYzOiBVc28gaW52w6FsaWRvIGRlIFxcXyIKIAotIzogcmVnZXhwLmM6MTcxMwogIywgYy1mb3JtYXQKIG1zZ2lkICJFNjQ6ICVzJWMgZm9sbG93cyBub3RoaW5nIgogbXNnc3RyICJFNjQ6ICVzJWMgbm8gc2lndWUgYSBuYWRhIgogCi0jOiByZWdleHAuYzoxNzY5CiBtc2dpZCAiRTY1OiBJbGxlZ2FsIGJhY2sgcmVmZXJlbmNlIgogbXNnc3RyICJFNjU6IFJlZmVyZW5jaWEgaW52ZXJzYSBpbGVnYWwiCiAKLSM6IHJlZ2V4cC5jOjE3ODIKIG1zZ2lkICJFNjY6IFxceiggbm90IGFsbG93ZWQgaGVyZSIKIG1zZ3N0ciAiRTY2OiBObyBzZSBwZXJtaXRlIFxceiggYXF1w60iCiAKLSM6IHJlZ2V4cC5jOjE4MDEKIG1zZ2lkICJFNjc6IFxcejEgLSBcXHo5IG5vdCBhbGxvd2VkIGhlcmUiCiBtc2dzdHIgIkU2NzogXFx6MSAtIFxcejkgbm8gc2UgcGVybWl0ZW4gYXF1w60iCiAKICMgRXMgcHJlZmVyaWJsZSB0cmFkdWNpciAiaW52YWxpZCIgcG9yICJubyBbZXNdIHbDoWxpZG8iIHB1ZXMgImludsOhbGlkbyIgbm8gZXMgbG8gc3VmaWNpZW50ZW1lbnRlIGNsYXJvLiBBZGVtw6FzLCBubyBlcyBwb2zDrXRpY2FtZW50ZSBjb3JyZWN0byA6LSkgQUxWCi0jOiByZWdleHAuYzoxODEzCiBtc2dpZCAiRTY4OiBJbnZhbGlkIGNoYXJhY3RlciBhZnRlciBcXHoiCiBtc2dzdHIgIkU2ODogSGF5IHVuIGNhcsOhY3RlciBubyB2w6FsaWRvIGRlc3B1w6lzIGRlIFxceiIKIAotIzogcmVnZXhwLmM6MTg2NQogIywgYy1mb3JtYXQKIG1zZ2lkICJFNjk6IE1pc3NpbmcgXSBhZnRlciAlcyUlWyIKIG1zZ3N0ciAiRTY5OiBGYWx0YSBdIGRlc3B1w6lzIGRlICVzJSVbIgogCi0jOiByZWdleHAuYzoxODgxCiAjLCBjLWZvcm1hdAogbXNnaWQgIkU3MDogRW1wdHkgJXMlJVtdIgogbXNnc3RyICJFNzA6ICVzJSVbXSB2YWPDrW8iCiAKLSM6IHJlZ2V4cC5jOjE5MjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTY3ODogSW52YWxpZCBjaGFyYWN0ZXIgYWZ0ZXIgJXMlJVtkeG91VV0iCiBtc2dzdHIgIkU2Nzg6IENhcsOhY3RlciBubyB2w6FsaWRvIGRlc3B1w6lzIGRlICVzJSVbZHhvdVVdIgogCi0jOiByZWdleHAuYzoxOTk3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkU3MTogSW52YWxpZCBjaGFyYWN0ZXIgYWZ0ZXIgJXMlJSIKIG1zZ3N0ciAiRTcxOiBDYXLDoWN0ZXIgaWxlZ2FsIGRlc3B1w6lzIGRlICVzJSUiCiAKLSM6IHJlZ2V4cC5jOjIyOTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTc2OTogTWlzc2luZyBdIGFmdGVyICVzWyIKIG1zZ3N0ciAiRTc2OTogRmFsdGEgXSBkZXNwdcOpcyBkZSAlc1siCiAKLSM6IHJlZ2V4cC5jOjI5NzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTU1NDogU3ludGF4IGVycm9yIGluICVzey4uLn0iCiBtc2dzdHIgIkU1NTQ6IEVycm9yIGRlIHNpbnRheGlzIGVuICVzey4uLn0iCiAKLSM6IHJlZ2V4cC5jOjM4MjEKIG1zZ2lkICJFeHRlcm5hbCBzdWJtYXRjaGVzOlxuIgogbXNnc3RyICJTdWItY29pbmNpZGVuY2lhcyBleHRlcm5hczpcbiIKIAotIzogc2NyZWVuLmM6OTA3MgogbXNnaWQgIiBWUkVQTEFDRSIKIG1zZ3N0ciAiIFJFRU1QTEFaTyBWSVJUVUFMIgogCi0jOiBzY3JlZW4uYzo5MDc2CiBtc2dpZCAiIFJFUExBQ0UiCiBtc2dzdHIgIiBSRUVNUExBWkFSIgogCi0jOiBzY3JlZW4uYzo5MDgxCiBtc2dpZCAiIFJFVkVSU0UiCiBtc2dzdHIgIiBJTlZFUlRJUiIKIAotIzogc2NyZWVuLmM6OTA4MwogbXNnaWQgIiBJTlNFUlQiCiBtc2dzdHIgIiBJTlNFUlRBUiIKIAotIzogc2NyZWVuLmM6OTA4NgogbXNnaWQgIiAoaW5zZXJ0KSIKIG1zZ3N0ciAiIChpbnNlcnRhcikiCiAKLSM6IHNjcmVlbi5jOjkwODgKIG1zZ2lkICIgKHJlcGxhY2UpIgogbXNnc3RyICIgKHJlZW1wbGF6YXIpIgogCi0jOiBzY3JlZW4uYzo5MDkwCiBtc2dpZCAiICh2cmVwbGFjZSkiCiBtc2dzdHIgIiAocmVlbXBsYXpvIHZpcnR1YWwpIgogCi0jOiBzY3JlZW4uYzo5MDkzCiBtc2dpZCAiIEhlYnJldyIKIG1zZ3N0ciAiIGhlYnJlbyIKIAotIzogc2NyZWVuLmM6OTEwNAogbXNnaWQgIiBBcmFiaWMiCiBtc2dzdHIgIiDDoXJhYmUiCiAKLSM6IHNjcmVlbi5jOjkxMDcKIG1zZ2lkICIgKGxhbmcpIgogbXNnc3RyICIgKGlkaW9tYSkiCiAKLSM6IHNjcmVlbi5jOjkxMTEKIG1zZ2lkICIgKHBhc3RlKSIKIG1zZ3N0ciAiIChwZWdhcikiCiAKLSM6IHNjcmVlbi5jOjkxMjQKIG1zZ2lkICIgVklTVUFMIgogbXNnc3RyICIgVklTVUFMIgogCi0jOiBzY3JlZW4uYzo5MTI1CiBtc2dpZCAiIFZJU1VBTCBMSU5FIgogbXNnc3RyICIgTMONTkVBIFZJU1VBTCIKIAotIzogc2NyZWVuLmM6OTEyNgogbXNnaWQgIiBWSVNVQUwgQkxPQ0siCiBtc2dzdHIgIiBCTE9RVUUgVklTVUFMIgogCi0jOiBzY3JlZW4uYzo5MTI3CiBtc2dpZCAiIFNFTEVDVCIKIG1zZ3N0ciAiIFNFTEVDQ0lPTkFSIgogCi0jOiBzY3JlZW4uYzo5MTI4CiBtc2dpZCAiIFNFTEVDVCBMSU5FIgogbXNnc3RyICIgU0VMRUNDSU9OQVIgTMONTkVBIgogCi0jOiBzY3JlZW4uYzo5MTI5CiBtc2dpZCAiIFNFTEVDVCBCTE9DSyIKIG1zZ3N0ciAiIFNFTEVDQ0lPTkFSIEJMT1FVRSIKIAotIzogc2NyZWVuLmM6OTE0NSBzY3JlZW4uYzo5MjExCiBtc2dpZCAicmVjb3JkaW5nIgogbXNnc3RyICJncmFiYW5kbyIKIAotIzogc2VhcmNoLmM6NTYyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkUzODM6IEludmFsaWQgc2VhcmNoIHN0cmluZzogJXMiCiBtc2dzdHIgIkUzODM6IExhIGNhZGVuYSBkZSBiw7pzcXVlZGEgbm8gZXMgdsOhbGlkYTogJXMiCiAKLSM6IHNlYXJjaC5jOjk4MwogIywgYy1mb3JtYXQKIG1zZ2lkICJFMzg0OiBzZWFyY2ggaGl0IFRPUCB3aXRob3V0IG1hdGNoIGZvcjogJXMiCiBtc2dzdHIgIkUzODQ6IExhIGLDunNxdWVkYSBoYSBsbGVnYWRvIGFsIFBSSU5DSVBJTyBzaW4gY29pbmNpZGlyIGNvbjogJXMiCiAKLSM6IHNlYXJjaC5jOjk4NgogIywgYy1mb3JtYXQKIG1zZ2lkICJFMzg1OiBzZWFyY2ggaGl0IEJPVFRPTSB3aXRob3V0IG1hdGNoIGZvcjogJXMiCiBtc2dzdHIgIkUzODU6IExhIGLDunNxdWVkYSBoYSBsbGVnYWRvIGFsIEZJTkFMIHNpbiBjb2luY2lkaXIgY29uOiAlcyIKIAotIzogc2VhcmNoLmM6MTQxNQogbXNnaWQgIkUzODY6IEV4cGVjdGVkICc/JyBvciAnLycgIGFmdGVyICc7JyIKIG1zZ3N0ciAiRTM4NjogRXNwZXJhYmEgXCI/XCIgbyBcIi9cIiBkZXNwdcOpcyBkZSBcIjtcIiIKIAotIzogc2VhcmNoLmM6NDY4MQogbXNnaWQgIiAoaW5jbHVkZXMgcHJldmlvdXNseSBsaXN0ZWQgbWF0Y2gpIgogbXNnc3RyICIgKGluY2x1eWUgbGEgY29pbmNpZGVuY2lhIG1vc3RyYWRhIHByZXZpYW1lbnRlKSIKIAogIyBjdXJzb3IgYXQgc3RhdHVzIGxpbmUKLSMuIGN1cnNvciBhdCBzdGF0dXMgbGluZQotIzogc2VhcmNoLmM6NDcwMQogbXNnaWQgIi0tLSBJbmNsdWRlZCBmaWxlcyAiCiBtc2dzdHIgIi0tLSBBcmNoaXZvcyBpbmNsdWlkb3MgIgogCi0jOiBzZWFyY2guYzo0NzAzCiBtc2dpZCAibm90IGZvdW5kICIKIG1zZ3N0ciAibm8gc2UgZW5jb250cuG5lSIKIAotIzogc2VhcmNoLmM6NDcwNAogbXNnaWQgImluIHBhdGggLS0tXG4iCiBtc2dzdHIgImVuIGxhIHJ1dGEgLS0tXG4iCiAKLSM6IHNlYXJjaC5jOjQ3NjEKIG1zZ2lkICIgIChBbHJlYWR5IGxpc3RlZCkiCiBtc2dzdHIgIiAgKFlhIGVzdMOhIGxpc3RhZG8pIgogCi0jOiBzZWFyY2guYzo0NzYzCiBtc2dpZCAiICBOT1QgRk9VTkQiCiBtc2dzdHIgIiAgTk8gU0UgRU5DT05UUsOTIgogCi0jOiBzZWFyY2guYzo0ODE3CiAjLCBjLWZvcm1hdAogbXNnaWQgIlNjYW5uaW5nIGluY2x1ZGVkIGZpbGU6ICVzIgogbXNnc3RyICJFeHBsb3JhbmRvIGVsIGFyY2hpdm8gaW5jbHVpZG86ICVzIgogCi0jOiBzZWFyY2guYzo0ODI2CiAjLCBjLWZvcm1hdAogbXNnaWQgIlNlYXJjaGluZyBpbmNsdWRlZCBmaWxlICVzIgogbXNnc3RyICJCdXNjYW5kbyBlbiBlbCBhcmNoaXZvIGluY2x1aWRvOiAlcyIKIAotIzogc2VhcmNoLmM6NTA0OQogbXNnaWQgIkUzODc6IE1hdGNoIGlzIG9uIGN1cnJlbnQgbGluZSIKIG1zZ3N0ciAiRTM4NzogTGEgY29pbmNpZGVuY2lhIGVzdMOhIGVuIGxhIGzDrW5lYSBiYWpvIGVsIGN1cnNvciIKIAotIzogc2VhcmNoLmM6NTE5MwogbXNnaWQgIkFsbCBpbmNsdWRlZCBmaWxlcyB3ZXJlIGZvdW5kIgogbXNnc3RyICJTZSBoYW4gZW5jb250cmFkbyB0b2RvcyBsb3MgYXJjaGl2b3MgaW5jbHVpZG9zIgogCi0jOiBzZWFyY2guYzo1MTk1CiBtc2dpZCAiTm8gaW5jbHVkZWQgZmlsZXMiCiBtc2dzdHIgIk5vIGhheSBhcmNoaXZvcyBpbmNsdWlkb3MiCiAKLSM6IHNlYXJjaC5jOjUyMTEKIG1zZ2lkICJFMzg4OiBDb3VsZG4ndCBmaW5kIGRlZmluaXRpb24iCiBtc2dzdHIgIkUzODg6IExhIGRlZmluaWNpw7NuIG5vIHNlIGVuY29udHLDsyIKIAotIzogc2VhcmNoLmM6NTIxMwogbXNnaWQgIkUzODk6IENvdWxkbid0IGZpbmQgcGF0dGVybiIKIG1zZ3N0ciAiRTM4OTogRWwgcGF0csOzbiBubyBzZSBlbmNvbnRyw7MiCiAKLSM6IHNlYXJjaC5jOjUzOTEKIG1zZ2lkICJTdWJzdGl0dXRlICIKIG1zZ3N0ciAiU3VzdGl0dWNpw7NuIgogCi0jOiBzZWFyY2guYzo1NDA0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJcbiIKQEAgLTYyMTUsMTA0ICs0ODUwLDgyIEBACiAiIyDDmmx0aW1vICVzUGF0csOzbiBkZSBiw7pzcXVlZGE6XG4iCiAifiIKIAotIzogc3BlbGwuYzo5ODkKIG1zZ2lkICJFNzU5OiBGb3JtYXQgZXJyb3IgaW4gc3BlbGwgZmlsZSIKIG1zZ3N0ciAiRTc1OTogRXJyb3IgZGUgZm9ybWF0byBlbiBlbCBhcmNoaXZvIGRlIG9ydG9ncmFmw61hIgogCi0jOiBzcGVsbC5jOjk5MAogbXNnaWQgIkU3NTg6IFRydW5jYXRlZCBzcGVsbCBmaWxlIgogbXNnc3RyICJFNzU4OiBBcmNoaXZvIGRlIG9ydG9ncmFmw61hIHRydW5jYWRvIgogCi0jOiBzcGVsbC5jOjk5MQogIywgYy1mb3JtYXQKIG1zZ2lkICJUcmFpbGluZyB0ZXh0IGluICVzIGxpbmUgJWQ6ICVzIgogbXNnc3RyICJUZXh0byBzb2JyYW50ZSBlbiAlcyBsw61uZWEgJWQ6ICVzIgogCi0jOiBzcGVsbC5jOjk5MgogIywgYy1mb3JtYXQKIG1zZ2lkICJBZmZpeCBuYW1lIHRvbyBsb25nIGluICVzIGxpbmUgJWQ6ICVzIgogbXNnc3RyICJOb21icmUgZGUgYWZpam8gZGVtYXNpYWRvIGxhcmdvIGVuICVzIGzDrW5lYSAlZDogJXMiCiAKLSM6IHNwZWxsLmM6OTkzCiBtc2dpZCAiRTc2MTogRm9ybWF0IGVycm9yIGluIGFmZml4IGZpbGUgRk9MLCBMT1cgb3IgVVBQIgogbXNnc3RyICJFNzYxOiBFcnJvciBkZSBmb3JtYXRvIGVuIGVsIGFyY2hpdm8gZGUgYWZpam9zIEZPTCwgTE9XIG8gVVBQIgogCi0jOiBzcGVsbC5jOjk5NAogbXNnaWQgIkU3NjI6IENoYXJhY3RlciBpbiBGT0wsIExPVyBvciBVUFAgaXMgb3V0IG9mIHJhbmdlIgogbXNnc3RyICJFNzYyOiBFbCBjYXLDoWN0ZXIgZW4gRk9MLCBMT1cgbyBVUFAgZXN0w6EgZnVlcmEgZGUgcmFuZ28iCiAKLSM6IHNwZWxsLmM6OTk1CiBtc2dpZCAiQ29tcHJlc3Npbmcgd29yZCB0cmVlLi4uIgogbXNnc3RyICJDb21wcmltaWVuZG8gZWwgw6FyYm9sIGRlIHBhbGFicmFzLi4uIgogCi0jOiBzcGVsbC5jOjIxNDkKIG1zZ2lkICJFNzU2OiBTcGVsbCBjaGVja2luZyBpcyBub3QgZW5hYmxlZCIKIG1zZ3N0ciAiRTc1NjogTGEgY29ycmVjY2nDs24gb3J0b2dyw6FmaWNhIGVzdMOhIGRlc2FjdGl2YWRhIgogCi0jOiBzcGVsbC5jOjI1MDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiV2FybmluZzogQ2Fubm90IGZpbmQgd29yZCBsaXN0IFwiJXMuJXMuc3BsXCIgb3IgXCIlcy5hc2NpaS5zcGxcIiIKIG1zZ3N0ciAiIgogIkFkdmVydGVuY2lhOiBObyBzZSBwdWRvIGhhbGxhciBsYSBsaXN0YSBkZSBwYWxhYnJhcyBcIiVzLiVzLnNwbFwiICIKICJvciBcIiVzLmFzY2lpLnNwbFwiIgogCi0jOiBzcGVsbC5jOjI3NzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVhZGluZyBzcGVsbCBmaWxlIFwiJXNcIiIKIG1zZ3N0ciAiTGV5ZW5kbyBhcmNoaXZvIGRlIG9ydG9ncmFmw61hIFwiJXNcIiIKIAotIzogc3BlbGwuYzoyODA4CiBtc2dpZCAiRTc1NzogVGhpcyBkb2VzIG5vdCBsb29rIGxpa2UgYSBzcGVsbCBmaWxlIgogbXNnc3RyICJFNzU3OiBFc3RvIG5vIHBhcmVjZSB1biBhcmNoaXZvIGRlIG9ydG9ncmFmw61hIgogCi0jOiBzcGVsbC5jOjI4MTQKIG1zZ2lkICJFNzcxOiBPbGQgc3BlbGwgZmlsZSwgbmVlZHMgdG8gYmUgdXBkYXRlZCIKIG1zZ3N0ciAiRTc3MTogQXJjaGl2byBkZSBvcnRvZ3JhZsOtYSBvYnNvbGV0bywgZGViZSBhY3R1YWxpemFybG8iCiAKLSM6IHNwZWxsLmM6MjgxOQogbXNnaWQgIkU3NzI6IFNwZWxsIGZpbGUgaXMgZm9yIG5ld2VyIHZlcnNpb24gb2YgVmltIgogbXNnc3RyICJFNzcyOiBFbCBhcmNoaXZvIGRlIG9ydG9ncmFmw61hIGVzIHBhcmEgdW5hIHZlcnNpw7NuIGRlIFZpbSBtw6FzIHJlY2llbnRlIgogCi0jOiBzcGVsbC5jOjI5MjIKIG1zZ2lkICJFNzcwOiBVbnN1cHBvcnRlZCBzZWN0aW9uIGluIHNwZWxsIGZpbGUiCiBtc2dzdHIgIkU3NzA6IFNlY2Npw7NuIG5vIGNvbXBhdGlibGUgZW4gZWwgYXJjaGl2byBkZSBvcnRvZ3JhZsOtYSIKIAotIzogc3BlbGwuYzo0NDE3CiAjLCBjLWZvcm1hdAogbXNnaWQgIldhcm5pbmc6IHJlZ2lvbiAlcyBub3Qgc3VwcG9ydGVkIgogbXNnc3RyICJBZHZlcnRlbmNpYTogbGEgcmVnacOzbiAlcyBubyBlcyBjb21wYXRpYmxlIgogCi0jOiBzcGVsbC5jOjUzMDcKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVhZGluZyBhZmZpeCBmaWxlICVzLi4uIgogbXNnc3RyICJMZXllbmRvIGVsIGFyY2hpdm8gZGUgYWZpam9zIFwiJXNcIi4uLiIKIAotIzogc3BlbGwuYzo1MzU1IHNwZWxsLmM6NjY5OSBzcGVsbC5jOjcyNzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ29udmVyc2lvbiBmYWlsdXJlIGZvciB3b3JkIGluICVzIGxpbmUgJWQ6ICVzIgogbXNnc3RyICJMYSBjb252ZXJzacOzbiBmYWxsw7MgcGFyYSBsYSBwYWxhYnJhIGVuICVzIGzDrW5lYSAlZDogJXMiCiAKLSM6IHNwZWxsLmM6NTQwMyBzcGVsbC5jOjczMTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ29udmVyc2lvbiBpbiAlcyBub3Qgc3VwcG9ydGVkOiBmcm9tICVzIHRvICVzIgogbXNnc3RyICJMYSBjb252ZXJzacOzbiBlbiAlcyBubyBlcyBwb3NpYmxlOiBkZSAlcyBhICVzIgogCi0jOiBzcGVsbC5jOjU0MDcgc3BlbGwuYzo3MzE4CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvbnZlcnNpb24gaW4gJXMgbm90IHN1cHBvcnRlZCIKIG1zZ3N0ciAiTGEgY29udmVyc2nDs24gYSAlcyBubyBlcyBwb3NpYmxlIGVuIGVzdGEgdmVyc2nDs24iCiAKLSM6IHNwZWxsLmM6NTQyMAogIywgYy1mb3JtYXQKIG1zZ2lkICJJbnZhbGlkIHZhbHVlIGZvciBGTEFHIGluICVzIGxpbmUgJWQ6ICVzIgogbXNnc3RyICJFbCB2YWxvciBwYXJhIFwiRkxBR1wiIG5vIGVzIHbDoWxpZG8gZW4gbGEgJXMgbMOtbmVhICVkOiAlcyIKIAotIzogc3BlbGwuYzo1NDMzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkZMQUcgYWZ0ZXIgdXNpbmcgZmxhZ3MgaW4gJXMgbGluZSAlZDogJXMiCiBtc2dzdHIgIlwiRkxBR1wiIGRlc3B1w6lzIGRlIHVzYXIgcGFyw6FtZXRyb3MgZW4gJXMgbMOtbmVhICVkOiAlcyIKIAotIzogc3BlbGwuYzo1NTI0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJEZWZpbmluZyBDT01QT1VOREZPUkJJREZMQUcgYWZ0ZXIgUEZYIGl0ZW0gbWF5IGdpdmUgd3JvbmcgcmVzdWx0cyBpbiAlcyBsaW5lICIKQEAgLTYzMjEsNyArNDkzNCw2IEBACiAiRGVmaW5pciBDT01QT1VOREZPUkJJREZMQUcgZGVzcHXDqXMgZGUgdW4gZWxlbWVudG8gUEZYIHB1ZWRlIGRhciByZXN1bHRhZG9zICIKICJlcnLDs25lb3MgZW4gJXMgbMOtbmVhICVkIgogCi0jOiBzcGVsbC5jOjU1MzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkRlZmluaW5nIENPTVBPVU5EUEVSTUlURkxBRyBhZnRlciBQRlggaXRlbSBtYXkgZ2l2ZSB3cm9uZyByZXN1bHRzIGluICVzIGxpbmUgIgpAQCAtNjMzMCw0NCArNDk0MiwzNiBAQAogIkRlZmluaXIgQ09NUE9VTkRQRVJNSVRGTEFHIGRlc3B1w6lzIGRlIHVuIMOtdGVtIFBGWCBwdWVkZSBkYXIgcmVzdWx0YWRvcyAiCiAiZXJyw7NuZW9zIGVuICVzIGzDrW5lYSAlZCIKIAotIzogc3BlbGwuYzo1NTU0CiAjLCBjLWZvcm1hdAogbXNnaWQgIldyb25nIENPTVBPVU5EUlVMRVMgdmFsdWUgaW4gJXMgbGluZSAlZDogJXMiCiBtc2dzdHIgIlZhbG9yIGVxdWl2b2NhZG8gZGUgQ09NUE9VTkRSVUxFUyAlcyBsw61uZWEgJWQ6ICVzIgogCi0jOiBzcGVsbC5jOjU1ODEKICMsIGMtZm9ybWF0CiBtc2dpZCAiV3JvbmcgQ09NUE9VTkRXT1JETUFYIHZhbHVlIGluICVzIGxpbmUgJWQ6ICVzIgogbXNnc3RyICJWYWxvciBlcXVpdm9jYWRvIGRlIENPTVBPVU5EV09SRE1BWCBlbiAlcyBsw61uZWEgJWQ6ICVzIgogCi0jOiBzcGVsbC5jOjU1ODkKICMsIGMtZm9ybWF0CiBtc2dpZCAiV3JvbmcgQ09NUE9VTkRNSU4gdmFsdWUgaW4gJXMgbGluZSAlZDogJXMiCiBtc2dzdHIgIlZhbG9yIGVxdWl2b2NhZG8gZGUgQ09NUE9VTkRNSU4gZW4gJXMgbMOtbmVhICVkOiAlcyIKIAotIzogc3BlbGwuYzo1NTk3CiAjLCBjLWZvcm1hdAogbXNnaWQgIldyb25nIENPTVBPVU5EU1lMTUFYIHZhbHVlIGluICVzIGxpbmUgJWQ6ICVzIgogbXNnc3RyICJWYWxvciBlcXVpdm9jYWRvIGRlIENPTVBPVU5EU1lMTUFYIGVuICVzIGzDrW5lYSAlZDogJXMiCiAKLSM6IHNwZWxsLmM6NTYxOQogIywgYy1mb3JtYXQKIG1zZ2lkICJXcm9uZyBDSEVDS0NPTVBPVU5EUEFUVEVSTiB2YWx1ZSBpbiAlcyBsaW5lICVkOiAlcyIKIG1zZ3N0ciAiVmFsb3IgZXF1aXZvY2FkbyBkZSBDSEVDS0NPTVBPVU5EUEFUVEVSTiBlbiAlcyBsw61uZWEgJWQ6ICVzIgogCi0jOiBzcGVsbC5jOjU2ODUKICMsIGMtZm9ybWF0CiBtc2dpZCAiRGlmZmVyZW50IGNvbWJpbmluZyBmbGFnIGluIGNvbnRpbnVlZCBhZmZpeCBibG9jayBpbiAlcyBsaW5lICVkOiAlcyIKIG1zZ3N0ciAiIgogIk1hcmNhIGRlIGNvbWJpbmFjacOzbiBkaWZlcmVudGUgZW4gZWwgYmxvcXVlIGRlIGFmaWpvcyBjb250aW51byAiCiAiZW4gJXMgbMOtbmVhICVkOiAlcyIKIAotIzogc3BlbGwuYzo1Njg4CiAjLCBjLWZvcm1hdAogbXNnaWQgIkR1cGxpY2F0ZSBhZmZpeCBpbiAlcyBsaW5lICVkOiAlcyIKIG1zZ3N0ciAiQWZpam8gZHVwbGljYWRvIGVuICVzIGzDrW5lYSAlZDogJXMiCiAKLSM6IHNwZWxsLmM6NTcxMAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQWZmaXggYWxzbyB1c2VkIGZvciBCQUQvUkFSRS9LRUVQQ0FTRS9ORUVEQUZGSVgvTkVFRENPTVBPVU5EL05PU1VHR0VTVCBpbiAlcyAiCkBAIC02Mzc2LDMzOCArNDk4MCwyNjEgQEAKICJBZmlqbyB1c2FkbyB0YW1iacOpbiBwYXJhIEJBRC9SQVJFL0tFRVBDQVNFL05FRURBRkZJWC9ORUVEQ09NUE9VTkQvTk9TVUdHRVNUICIKICJlbiAlcyBsw61uZWEgJWQ6ICVzIgogCi0jOiBzcGVsbC5jOjU3MzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiRXhwZWN0ZWQgWSBvciBOIGluICVzIGxpbmUgJWQ6ICVzIgogbXNnc3RyICJFc3BlcmFiYSBZIG8gTiBlbiAlcyBsw61uZWEgJWQ6ICVzIgogCi0jOiBzcGVsbC5jOjU4MTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiQnJva2VuIGNvbmRpdGlvbiBpbiAlcyBsaW5lICVkOiAlcyIKIG1zZ3N0ciAiQ29uZGljacOzbiBpbnbDoWxpZGEgZW4gJXMgbMOtbmVhICVkOiAlcyIKIAotIzogc3BlbGwuYzo1OTY2CiAjLCBjLWZvcm1hdAogbXNnaWQgIkV4cGVjdGVkIFJFUChTQUwpIGNvdW50IGluICVzIGxpbmUgJWQiCiBtc2dzdHIgIkVzcGVyYWJhIGNvbnRlbyBSRVAoU0FMKSBlbiAlcyBsw61uZWEgJWQiCiAKLSM6IHNwZWxsLmM6NjAwMQogIywgYy1mb3JtYXQKIG1zZ2lkICJFeHBlY3RlZCBNQVAgY291bnQgaW4gJXMgbGluZSAlZCIKIG1zZ3N0ciAiRXNwZXJhYmEgY29udGVvIE1BUCBlbiAlcyBsw61uZWEgJWQiCiAKLSM6IHNwZWxsLmM6NjAyMAogIywgYy1mb3JtYXQKIG1zZ2lkICJEdXBsaWNhdGUgY2hhcmFjdGVyIGluIE1BUCBpbiAlcyBsaW5lICVkIgogbXNnc3RyICJDYXLDoWN0ZXIgZHVwbGljYWRvIGVuIE1BUCBlbiAlcyBsw61uZWEgJWQiCiAKLSM6IHNwZWxsLmM6NjA3NwogIywgYy1mb3JtYXQKIG1zZ2lkICJVbnJlY29nbml6ZWQgb3IgZHVwbGljYXRlIGl0ZW0gaW4gJXMgbGluZSAlZDogJXMiCiBtc2dzdHIgIkVsZW1lbnRvIG5vIHJlY29ub2NpZG8gbyBkdXBsaWNhZG8gZW4gJXMgbMOtbmVhICVkOiAlcyIKIAotIzogc3BlbGwuYzo2MTA1CiAjLCBjLWZvcm1hdAogbXNnaWQgIk1pc3NpbmcgRk9ML0xPVy9VUFAgbGluZSBpbiAlcyIKIG1zZ3N0ciAiRmFsdGEgdW5hIGzDrW5lYSBGT0wvTE9XL1VQUCBlbiAlcyIKIAotIzogc3BlbGwuYzo2MTMxCiBtc2dpZCAiQ09NUE9VTkRTWUxNQVggdXNlZCB3aXRob3V0IFNZTExBQkxFIgogbXNnc3RyICJDT01QT1VORFNZTE1BWCB1c2FkbyBzaW4gU1lMTEFCTEUiCiAKLSM6IHNwZWxsLmM6NjE0OQogbXNnaWQgIlRvbyBtYW55IHBvc3Rwb25lZCBwcmVmaXhlcyIKIG1zZ3N0ciAiSGF5IGRlbWFzaWFkb3MgcHJlZmlqb3MgcG9zdHB1ZXN0b3MiCiAKLSM6IHNwZWxsLmM6NjE1MQogbXNnaWQgIlRvbyBtYW55IGNvbXBvdW5kIGZsYWdzIgogbXNnc3RyICJEZW1hc2lhZG9zIHBhcsOhbWV0cm9zIGNvbXB1ZXN0b3MiCiAKLSM6IHNwZWxsLmM6NjE1MwogbXNnaWQgIlRvbyBtYW55IHBvc3Rwb25lZCBwcmVmaXhlcyBhbmQvb3IgY29tcG91bmQgZmxhZ3MiCiBtc2dzdHIgIkRlbWFzaWFkb3MgcHJlZmlqb3MgcG9zdHB1ZXN0b3MgeS9vIFwiZmxhZ3NcIiBjb21wdWVzdG9zIgogCi0jOiBzcGVsbC5jOjYxNjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiTWlzc2luZyBTT0ZPJXMgbGluZSBpbiAlcyIKIG1zZ3N0ciAiRmFsdGEgdW5hIGzDrW5lYSBTT0ZPJXMgZW4gJXMiCiAKLSM6IHNwZWxsLmM6NjE2OAogIywgYy1mb3JtYXQKIG1zZ2lkICJCb3RoIFNBTCBhbmQgU09GTyBsaW5lcyBpbiAlcyIKIG1zZ3N0ciAiTMOtbmVhcyBTQUwgeSBTT0ZPIGVuICVzIgogCi0jOiBzcGVsbC5jOjYyNzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmxhZyBpcyBub3QgYSBudW1iZXIgaW4gJXMgbGluZSAlZDogJXMiCiBtc2dzdHIgIkxhIG1hcmNhIG5vIGVzIHVuIG7Dum1lcm8gZW4gJXMgbMOtbmVhICVkOiAlcyIKIAotIzogc3BlbGwuYzo2Mjc4CiAjLCBjLWZvcm1hdAogbXNnaWQgIklsbGVnYWwgZmxhZyBpbiAlcyBsaW5lICVkOiAlcyIKIG1zZ3N0ciAiTWFyY2EgaWxlZ2FsIGVuICVzIGxpbmUgJWQ6ICVzIgogCi0jOiBzcGVsbC5jOjY0OTUgc3BlbGwuYzo2NTA4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIHZhbHVlIGRpZmZlcnMgZnJvbSB3aGF0IGlzIHVzZWQgaW4gYW5vdGhlciAuYWZmIGZpbGUiCiBtc2dzdHIgIkVsIHZhbG9yICVzIGRpZmllcmUgZGUgbG9zIHF1ZSBzZSB1c2EgZW4gb3RybyBhcmNoaXZvIC5hZmYiCiAKLSM6IHNwZWxsLmM6NjY2MAogIywgYy1mb3JtYXQKIG1zZ2lkICJSZWFkaW5nIGRpY3Rpb25hcnkgZmlsZSAlcy4uLiIKIG1zZ3N0ciAiTGV5ZW5kbyBlbCBhcmNoaXZvIGRlIGRpY2Npb25hcmlvICVzLi4uIgogCi0jOiBzcGVsbC5jOjY2NjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTc2MDogTm8gd29yZCBjb3VudCBpbiAlcyIKIG1zZ3N0ciAiRTc2MDogTm8gaGF5IGN1ZW50YSBkZSBwYWxhYnJhcyBlbiAlcyIKIAotIzogc3BlbGwuYzo2NzQwCiAjLCBjLWZvcm1hdAogbXNnaWQgImxpbmUgJTZkLCB3b3JkICU2ZCAtICVzIgogbXNnc3RyICJsw61uZWEgJTZkLCBwYWxhYnJhICU2ZCAtICVzIgogCi0jOiBzcGVsbC5jOjY3NjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiRHVwbGljYXRlIHdvcmQgaW4gJXMgbGluZSAlZDogJXMiCiBtc2dzdHIgIlBhbGFicmEgZHVwbGljYWRhIGVuICVzIGzDrW5lYSAlZDogJXMiCiAKLSM6IHNwZWxsLmM6Njc2NwogIywgYy1mb3JtYXQKIG1zZ2lkICJGaXJzdCBkdXBsaWNhdGUgd29yZCBpbiAlcyBsaW5lICVkOiAlcyIKIG1zZ3N0ciAiUHJpbWVyYSBwYWxhYnJhIGR1cGxpY2FkYSBlbiAlcyBsaW5lICVkOiAlcyIKIAotIzogc3BlbGwuYzo2ODIyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVkIGR1cGxpY2F0ZSB3b3JkKHMpIGluICVzIgogbXNnc3RyICIlZCBwYWxhYnJhKHMpIGR1cGxpY2FkYShzKSBlbiAlcyIKIAotIzogc3BlbGwuYzo2ODI0CiAjLCBjLWZvcm1hdAogbXNnaWQgIklnbm9yZWQgJWQgd29yZChzKSB3aXRoIG5vbi1BU0NJSSBjaGFyYWN0ZXJzIGluICVzIgogbXNnc3RyICJJZ25vcmFuZG8gJWQgcGFsYWJyYShzKSBjb24gY2FyYWN0ZXJlcyBuby1BU0NJSSBlbiAlcyIKIAotIzogc3BlbGwuYzo3MjQ3CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlYWRpbmcgd29yZCBmaWxlICVzLi4uIgogbXNnc3RyICJMZXllbmRvIGFyY2hpdm8gZGUgcGFsYWJyYXMgXCIlc1wiLi4uIgogCi0jOiBzcGVsbC5jOjcyOTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiRHVwbGljYXRlIC9lbmNvZGluZz0gbGluZSBpZ25vcmVkIGluICVzIGxpbmUgJWQ6ICVzIgogbXNnc3RyICJJZ25vcmFuZG8gbMOtbmVhIC9lbmNvZGluZz0gZHVwbGljYWRhIGVuICVzIGxpbmUgJWQ6ICVzIgogCi0jOiBzcGVsbC5jOjczMDAKICMsIGMtZm9ybWF0CiBtc2dpZCAiL2VuY29kaW5nPSBsaW5lIGFmdGVyIHdvcmQgaWdub3JlZCBpbiAlcyBsaW5lICVkOiAlcyIKIG1zZ3N0ciAiSWdub3JhbmRvIGzDrW5lYSAvZW5jb2Rpbmc9IGRlc3B1w6lzIGRlIHBhbGFicmEgZW4gJXMgbMOtbmVhICVkOiAlcyIKIAotIzogc3BlbGwuYzo3MzI3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkR1cGxpY2F0ZSAvcmVnaW9ucz0gbGluZSBpZ25vcmVkIGluICVzIGxpbmUgJWQ6ICVzIgogbXNnc3RyICJJZ25vcmFuZG8gbMOtbmVhIC9yZWdpb25zPSBlbiAlcyBsw61uZWEgJWQ6ICVzIgogCi0jOiBzcGVsbC5jOjczMzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiVG9vIG1hbnkgcmVnaW9ucyBpbiAlcyBsaW5lICVkOiAlcyIKIG1zZ3N0ciAiRGVtYXNpYWRhcyByZWdpb25lcyBlbiAlcyBsw61uZWEgJWQ6ICVzIgogCi0jOiBzcGVsbC5jOjczNDcKICMsIGMtZm9ybWF0CiBtc2dpZCAiLyBsaW5lIGlnbm9yZWQgaW4gJXMgbGluZSAlZDogJXMiCiBtc2dzdHIgIklnbm9yYW5kbyBsw61uZWEgLyBlbiAlcyBsw61uZWEgJWQ6ICVzIgogCi0jOiBzcGVsbC5jOjczNzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiSW52YWxpZCByZWdpb24gbnIgaW4gJXMgbGluZSAlZDogJXMiCiBtc2dzdHIgIlJlZ2nDs24gbnIgbm8gdsOhbGlkYSBlbiAlcyBsw61uZWEgJWQ6ICVzIgogCi0jOiBzcGVsbC5jOjczODUKICMsIGMtZm9ybWF0CiBtc2dpZCAiVW5yZWNvZ25pemVkIGZsYWdzIGluICVzIGxpbmUgJWQ6ICVzIgogbXNnc3RyICJQYXLDoW1ldHJvcyBubyByZWNvbm9jaWRvcyBlbiAlcyBsw61uZWEgJWQ6ICVzIgogCi0jOiBzcGVsbC5jOjc0MTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiSWdub3JlZCAlZCB3b3JkcyB3aXRoIG5vbi1BU0NJSSBjaGFyYWN0ZXJzIgogbXNnc3RyICJJZ25vcmFuZG8gJWQgcGFsYWJyYXMgY29uIGNhcmFjdGVyZXMgbm8tQVNDSUkiCiAKLSM6IHNwZWxsLmM6Nzg3NgogIywgYy1mb3JtYXQKIG1zZ2lkICJDb21wcmVzc2VkICVkIG9mICVkIG5vZGVzOyAlZCAoJWQlJSkgcmVtYWluaW5nIgogbXNnc3RyICJDb21wcmltaWVuZG8gJWQgZGUgJWQgbm9kb3M7IGZhbHRhbiAlZCAoJWQlJSkiCiAKLSM6IHNwZWxsLmM6ODcyMAogbXNnaWQgIlJlYWRpbmcgYmFjayBzcGVsbCBmaWxlLi4uIgogbXNnc3RyICJSZWxleWVuZG8gZWwgYXJjaGl2byBkZSBvcnRvZ3JhZsOtYSAuLi4iCiAKLSMuCi0jLiAqIEdvIHRocm91Z2ggdGhlIHRyaWUgb2YgZ29vZCB3b3Jkcywgc291bmRmb2xkIGVhY2ggd29yZCBhbmQgYWRkIGl0IHRvCi0jLiAqIHRoZSBzb3VuZGZvbGQgdHJpZS4KLSMuCi0jOiBzcGVsbC5jOjg3NDEKIG1zZ2lkICJQZXJmb3JtaW5nIHNvdW5kZm9sZGluZy4uLiIKIG1zZ3N0ciAiRWplY3V0YW5kbyBjb21wcmVzacOzbiBmb27DqXRpY2EiCiAKLSM6IHNwZWxsLmM6ODc1NAogIywgYy1mb3JtYXQKIG1zZ2lkICJOdW1iZXIgb2Ygd29yZHMgYWZ0ZXIgc291bmRmb2xkaW5nOiAlbGQiCiBtc2dzdHIgIk7Dum1lcm8gZGUgcGFsYWJyYXMgZGVzcHXDqXMgZGUgbGEgY29tcHJlc2nDs24gZm9uw6l0aWNhOiAlbGQiCiAKLSM6IHNwZWxsLmM6ODg3OQogIywgYy1mb3JtYXQKIG1zZ2lkICJUb3RhbCBudW1iZXIgb2Ygd29yZHM6ICVkIgogbXNnc3RyICJOw7ptZXJvIHRvdGFsIGRlIHBhbGFicmFzOiAlZCIKIAotIzogc3BlbGwuYzo5MDk2CiAjLCBjLWZvcm1hdAogbXNnaWQgIldyaXRpbmcgc3VnZ2VzdGlvbiBmaWxlICVzLi4uIgogbXNnc3RyICJFc2NyaWJpZW5kbyBlbCBhcmNoaXZvIGRlIHN1Z2VyZW5jaWFzICVzLi4uIgogCi0jOiBzcGVsbC5jOjkxNTcgc3BlbGwuYzo5NDE4CiAjLCBjLWZvcm1hdAogbXNnaWQgIkVzdGltYXRlZCBydW50aW1lIG1lbW9yeSB1c2U6ICVkIGJ5dGVzIgogbXNnc3RyICJVc28gZGUgbWVtb3JpYSBlc3RpbWFkbyBhbCB1c2FyOiAlZCBieXRlcyIKIAotIzogc3BlbGwuYzo5Mjg5CiBtc2dpZCAiRTc1MTogT3V0cHV0IGZpbGUgbmFtZSBtdXN0IG5vdCBoYXZlIHJlZ2lvbiBuYW1lIgogbXNnc3RyICIiCiAiRTc1MTogRWwgbm9tYnJlIGRlbCBhcmNoaXZvIGRlIHNhbGlkYSBubyBkZWJlIGNvbnRlbmVyIHVuIG5vbWJyZSBkZSByZWdpw7NuIgogCi0jOiBzcGVsbC5jOjkyOTEKIG1zZ2lkICJFNzU0OiBPbmx5IHVwIHRvIDggcmVnaW9ucyBzdXBwb3J0ZWQiCiBtc2dzdHIgIkU3NTQ6IFNvbG8gc2UgcHVlZGVuIHVzYXIgaGFzdGEgOCByZWdpb25lcyIKIAotIzogc3BlbGwuYzo5MzIxCiAjLCBjLWZvcm1hdAogbXNnaWQgIkU3NTU6IEludmFsaWQgcmVnaW9uIGluICVzIgogbXNnc3RyICJFNzU1OiBSZWdpw7NuIG5vIHbDoWxpZGEgZW4gJXMiCiAKLSM6IHNwZWxsLmM6OTM5MgogbXNnaWQgIldhcm5pbmc6IGJvdGggY29tcG91bmRpbmcgYW5kIE5PQlJFQUsgc3BlY2lmaWVkIgogbXNnc3RyICJBZHZlcnRlbmNpYTogU2UgZXNwZWNpZmljw7MgXCJjb21wb3VuZGluZ1wiIHkgTk9CUkVBSyIKIAotIzogc3BlbGwuYzo5NDExCiAjLCBjLWZvcm1hdAogbXNnaWQgIldyaXRpbmcgc3BlbGwgZmlsZSAlcy4uLiIKIG1zZ3N0ciAiRXNjcmliaWVuZG8gYXJjaGl2byBkZSBvcnRvZ3JhZsOtYSBcIiVzXCIuLi4iCiAKLSM6IHNwZWxsLmM6OTQxNgogbXNnaWQgIkRvbmUhIgogbXNnc3RyICLCoUxpc3RvISIKIAotIzogc3BlbGwuYzo5NTQzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkU3NjU6ICdzcGVsbGZpbGUnIGRvZXMgbm90IGhhdmUgJWxkIGVudHJpZXMiCiBtc2dzdHIgIkU3NjU6ICdzcGVsbGZpbGUnIG5vIHRpZW5lIGVudHJhZGFzICVsZCIKIAotIzogc3BlbGwuYzo5NTg4CiAjLCBjLWZvcm1hdAogbXNnaWQgIldvcmQgcmVtb3ZlZCBmcm9tICVzIgogbXNnc3RyICJFbGltaW5hbmRvIHBhbGFicmEgZGUgJXMiCiAKLSM6IHNwZWxsLmM6OTYzMwogIywgYy1mb3JtYXQKIG1zZ2lkICJXb3JkIGFkZGVkIHRvICVzIgogbXNnc3RyICJBw7FhZGllbmRvIHBhbGFicmEgZW4gXCIlc1wiIgogCi0jOiBzcGVsbC5jOjk5NDYKIG1zZ2lkICJFNzYzOiBXb3JkIGNoYXJhY3RlcnMgZGlmZmVyIGJldHdlZW4gc3BlbGwgZmlsZXMiCiBtc2dzdHIgIiIKICJFNzYzOiBMb3MgY2FyYWN0ZXJlcyBkZSBsYSBwYWxhYnJhIGRpZmllcmVuIGVudHJlIGFyY2hpdm9zIGRlIG9ydG9ncmFmw61hIgogCi0jOiBzcGVsbC5jOjEwMzIxCiBtc2dpZCAiU29ycnksIG5vIHN1Z2dlc3Rpb25zIgogbXNnc3RyICJMbyBzaWVudG8sIG5vIGhheSBzdWdlcmVuY2lhcyIKIAotIzogc3BlbGwuYzoxMDMyNQogIywgYy1mb3JtYXQKIG1zZ2lkICJTb3JyeSwgb25seSAlbGQgc3VnZ2VzdGlvbnMiCiBtc2dzdHIgIkxvIHNpZW50bywgc29sbyBoYXkgJWxkIHN1Z2VyZW5jaWFzIgogCi0jLiBmb3Igd2hlbiAnY21kaGVpZ2h0JyA+IDEKLSMuIGF2b2lkIG1vcmUgcHJvbXB0Ci0jOiBzcGVsbC5jOjEwMzQ2CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNoYW5nZSBcIiUuKnNcIiB0bzoiCiBtc2dzdHIgIlwiJS4qc1wiIGNhbWJpw7MgYToiCiAKLSM6IHNwZWxsLmM6MTAzODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiIDwgXCIlLipzXCIiCiBtc2dzdHIgIiA8IFwiJS4qc1wiIgogCi0jOiBzcGVsbC5jOjEwNTYyCiBtc2dpZCAiRTc1MjogTm8gcHJldmlvdXMgc3BlbGwgcmVwbGFjZW1lbnQiCiBtc2dzdHIgIkU3NTI6IE5vIGhheSB1biByZWVtcGxhem8gZGUgb3J0b2dyYWbDrWEgcHJldmlvIgogCi0jOiBzcGVsbC5jOjEwNjEyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkU3NTM6IE5vdCBmb3VuZDogJXMiCiBtc2dzdHIgIkU3NTM6IE5vIHNlIGVuY29udHLDszogJXMiCiAKLSM6IHNwZWxsLmM6MTEwMzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTc3ODogVGhpcyBkb2VzIG5vdCBsb29rIGxpa2UgYSAuc3VnIGZpbGU6ICVzIgogbXNnc3RyICJFNzc4OiBFc3RvIG5vIHNlIHBhcmVjZSBhIHVuIGFyY2hpdm8gLnN1ZzogJXMiCiAKLSM6IHNwZWxsLmM6MTEwMzkKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTc3OTogT2xkIC5zdWcgZmlsZSwgbmVlZHMgdG8gYmUgdXBkYXRlZDogJXMiCiBtc2dzdHIgIkU3Nzk6IEFyY2hpdm8gLnN1ZyBvYnNvbGV0bywgbmVjZXNpdGEgdW5hIGFjdHVhbGl6YWNpw7NuOiAlcyIKIAotIzogc3BlbGwuYzoxMTA0NQogIywgYy1mb3JtYXQKIG1zZ2lkICJFNzgwOiAuc3VnIGZpbGUgaXMgZm9yIG5ld2VyIHZlcnNpb24gb2YgVmltOiAlcyIKIG1zZ3N0ciAiRTc4MDogRWwgYXJjaGl2byAuc3VnIGVzIHBhcmEgdW5hIHZlcnNpw7NuIG3DoXMgcmVjaWVudGUgZGUgVmltOiAlcyIKIAotIzogc3BlbGwuYzoxMTA1NQogIywgYy1mb3JtYXQKIG1zZ2lkICJFNzgxOiAuc3VnIGZpbGUgZG9lc24ndCBtYXRjaCAuc3BsIGZpbGU6ICVzIgogbXNnc3RyICJFNzgxOiBFbCBhcmNoaXZvIC5zdWcgbm8gY29ycmVzcG9uZGUgYWwgYXJjaGl2byAuc3BsOiAlcyIKIAotIzogc3BlbGwuYzoxMTA2OAogIywgYy1mb3JtYXQKIG1zZ2lkICJFNzgyOiBlcnJvciB3aGlsZSByZWFkaW5nIC5zdWcgZmlsZTogJXMiCiBtc2dzdHIgIkU3ODI6IEVycm9yIGFsIGxlZXIgYXJjaGl2byAuc2lnOiAlcyIKIAotIy4gVGhpcyBzaG91bGQgaGF2ZSBiZWVuIGNoZWNrZWQgd2hlbiBnZW5lcmF0aW5nIHRoZSAuc3BsCi0jLiAqIGZpbGUuCi0jOiBzcGVsbC5jOjEzNzY1CiBtc2dpZCAiRTc4MzogZHVwbGljYXRlIGNoYXIgaW4gTUFQIGVudHJ5IgogbXNnc3RyICJFNzgzOiBjYXLDoWN0ZXIgZHVwbGljYWRvIGVuIGVudHJhZGEgTUFQIgogCi0jOiBzeW50YXguYzozMjQ1IHN5bnRheC5jOjMyNzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTM5MDogSWxsZWdhbCBhcmd1bWVudDogJXMiCiBtc2dzdHIgIkUzOTA6IEFyZ3VtZW50byBpbGVnYWw6ICVzIgogCi0jOiBzeW50YXguYzozNDUzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkUzOTE6IE5vIHN1Y2ggc3ludGF4IGNsdXN0ZXI6ICVzIgogbXNnc3RyICJFMzkxOiBObyBleGlzdGUgdGFsIGFncnVwYW1pZW50byBzaW50w6FjdGljbzogJXMiCiAKLSM6IHN5bnRheC5jOjM2MTIKIG1zZ2lkICJObyBTeW50YXggaXRlbXMgZGVmaW5lZCBmb3IgdGhpcyBidWZmZXIiCiBtc2dzdHIgIk5vIGhheSBlbGVtZW50b3Mgc2ludMOhY3RpY29zIGRlZmluaWRvcyBwYXJhIGVzdGUgYsO6ZmVyIgogCi0jOiBzeW50YXguYzozNjIwCiBtc2dpZCAic3luY2luZyBvbiBDLXN0eWxlIGNvbW1lbnRzIgogbXNnc3RyICJTaW5jcm9uaXphbmRvIGNvbiBsb3MgY29tZW50YXJpb3MgZGUgZXN0aWxvIFwiQ1wiIgogCi0jOiBzeW50YXguYzozNjI4CiBtc2dpZCAibm8gc3luY2luZyIKIG1zZ3N0ciAibm8gaGF5IHNpbmNyb25pemFjacOzbiIKIAotIzogc3ludGF4LmM6MzYzMQogbXNnaWQgInN5bmNpbmcgc3RhcnRzICIKIG1zZ3N0ciAiQ29tZW56YW5kbyBzaW5jcm9uaXphY2nDs24iCiAKLSM6IHN5bnRheC5jOjM2MzMgc3ludGF4LmM6MzcwOAogbXNnaWQgIiBsaW5lcyBiZWZvcmUgdG9wIGxpbmUiCiBtc2dzdHIgIiBsw61uZWFzIGFudGVzIGRlIGxhIGzDrW5lYSBzdXBlcmlvciIKIAotIzogc3ludGF4LmM6MzYzOAogbXNnaWQgIiIKICJcbiIKICItLS0gU3ludGF4IHN5bmMgaXRlbXMgLS0tIgpAQCAtNjcxNSw3ICs1MjQyLDYgQEAKICJcbiIKICItLS0gRWxlbWVudG9zIGRlIHNpbmNyb25pemFjacOzbiBkZSBzaW50YXhpcyAtLS0iCiAKLSM6IHN5bnRheC5jOjM2NDMKIG1zZ2lkICIiCiAiXG4iCiAic3luY2luZyBvbiBpdGVtcyIKQEAgLTY3MjMsNyArNTI0OSw2IEBACiAiXG4iCiAic2luY3Jvbml6YW5kbyBjb24gbG9zIGVsZW1lbnRvcyIKIAotIzogc3ludGF4LmM6MzY0OQogbXNnaWQgIiIKICJcbiIKICItLS0gU3ludGF4IGl0ZW1zIC0tLSIKQEAgLTY3MzEsMjYwICs1MjU2LDIwMyBAQAogIlxuIgogIi0tLSBFbGVtZW50b3Mgc2ludMOhY3RpY29zIC0tLSIKIAotIzogc3ludGF4LmM6MzY3MgogIywgYy1mb3JtYXQKIG1zZ2lkICJFMzkyOiBObyBzdWNoIHN5bnRheCBjbHVzdGVyOiAlcyIKIG1zZ3N0ciAiRTM5MjogTm8gZXhpc3RlIHRhbCBhZ3J1cGFtaWVudG8gc2ludMOhY3RpY286ICVzIgogCi0jOiBzeW50YXguYzozNjk4CiBtc2dpZCAibWluaW1hbCAiCiBtc2dzdHIgIm3DrW5pbW8iCiAKLSM6IHN5bnRheC5jOjM3MDUKIG1zZ2lkICJtYXhpbWFsICIKIG1zZ3N0ciAibcOheGltbyIKIAotIzogc3ludGF4LmM6MzcxNwogbXNnaWQgIjsgbWF0Y2ggIgogbXNnc3RyICI7IGNvaW5jaWRlIgogCi0jOiBzeW50YXguYzozNzE5CiBtc2dpZCAiIGxpbmUgYnJlYWtzIgogbXNnc3RyICIgbMOtbmVhcyBkZSBxdWllYnJlIgogCi0jOiBzeW50YXguYzo0MzQ3CiBtc2dpZCAiRTM5NTogY29udGFpbnMgYXJndW1lbnQgbm90IGFjY2VwdGVkIGhlcmUiCiBtc2dzdHIgIkUzOTU6IGVsIGNvbnRlbmlkbyBkZWwgYXJndW1lbnRvIG5vIHNlIGFjZXB0YSBhcXXDrSIKIAotIzogc3ludGF4LmM6NDM1OAogbXNnaWQgIkUzOTY6IGNvbnRhaW5lZGluIGFyZ3VtZW50IG5vdCBhY2NlcHRlZCBoZXJlIgogbXNnc3RyICJFMzk2OiBlbCBhcmd1bWVudG8gXCJjb250YWluZWRpblwiIG5vIHNlIGFjZXB0YSBhcXXDrSIKIAotIzogc3ludGF4LmM6NDM4MAogbXNnaWQgIkUzOTM6IGdyb3VwW3RdaGVyZSBub3QgYWNjZXB0ZWQgaGVyZSIKIG1zZ3N0ciAiRTM5MzogXCJncm91cGhlcmVcIiB5IFwiZ3JvdXB0aGVyZVwiIG5vIHNvbiB2w6FsaWRvcyBhcXXDrSIKIAotIzogc3ludGF4LmM6NDQwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJFMzk0OiBEaWRuJ3QgZmluZCByZWdpb24gaXRlbSBmb3IgJXMiCiBtc2dzdHIgIkUzOTQ6IE5vIHNlIGVuY3VlbnRyYSBlbCBlbGVtZW50byBkZSBsYSByZWdpw7NuIHBhcmEgJXMiCiAKLSM6IHN5bnRheC5jOjQ0ODEKIG1zZ2lkICJFMzk3OiBGaWxlbmFtZSByZXF1aXJlZCIKIG1zZ3N0ciAiRTM5NzogRGViZSBwcm9wb3JjaW9uYXIgdW4gbm9tYnJlIGRlIGFyY2hpdm8iCiAKLSM6IHN5bnRheC5jOjQ2MDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTc4OTogTWlzc2luZyAnXSc6ICVzIgogbXNnc3RyICJFNzg5OiBGYWx0YSB1biAnXSc6ICVzIgogCi0jOiBzeW50YXguYzo0ODQzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkUzOTg6IE1pc3NpbmcgJz0nOiAlcyIKIG1zZ3N0ciAiRTM5ODogRmFsdGEgdW4gJz0nOiAlcyIKIAotIzogc3ludGF4LmM6NTAwMgogIywgYy1mb3JtYXQKIG1zZ2lkICJFMzk5OiBOb3QgZW5vdWdoIGFyZ3VtZW50czogc3ludGF4IHJlZ2lvbiAlcyIKIG1zZ3N0ciAiRTM5OTogQXJndW1lbnRvcyBpbnN1ZmljaWVudGVzOiByZWdpw7NuIGRlIHNpbnRheGlzICVzIgogCi0jOiBzeW50YXguYzo1MzM2CiBtc2dpZCAiRTQwMDogTm8gY2x1c3RlciBzcGVjaWZpZWQiCiBtc2dzdHIgIkU0MDA6IE5vIHNlIGhhIGVzcGVjaWZpY2FkbyB1bmEgYWdydXBhY2nDs24iCiAKLSM6IHN5bnRheC5jOjUzNzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTQwMTogUGF0dGVybiBkZWxpbWl0ZXIgbm90IGZvdW5kOiAlcyIKIG1zZ3N0ciAiRTQwMTogTm8gaGF5IHVuIGRlbGltaXRhZG9yIGRlIHBhdHLDs246ICVzIgogCi0jOiBzeW50YXguYzo1NDQ4CiAjLCBjLWZvcm1hdAogbXNnaWQgIkU0MDI6IEdhcmJhZ2UgYWZ0ZXIgcGF0dGVybjogJXMiCiBtc2dzdHIgIkU0MDI6IEJhc3VyYSBkZXNwdcOpcyBkZWwgcGF0csOzbjogJXMiCiAKLSM6IHN5bnRheC5jOjU1MzcKIG1zZ2lkICJFNDAzOiBzeW50YXggc3luYzogbGluZSBjb250aW51YXRpb25zIHBhdHRlcm4gc3BlY2lmaWVkIHR3aWNlIgogbXNnc3RyICIiCiAiRTQwMzogU2luY3Jvbml6YWNpw7NuIGRlIHNpbnRheGlzOiBTZSBlc3BlY2lmaWPDsyBkb3MgdmVjZXMgdW4gIgogInBhdHLDs24gZGUgY29udGludWFjacOzbiBkZSBsw61uZWEiCiAKLSM6IHN5bnRheC5jOjU1OTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTQwNDogSWxsZWdhbCBhcmd1bWVudHM6ICVzIgogbXNnc3RyICJFNDA0OiBBcmd1bWVudG9zIGlsZWdhbGVzOiAlcyIKIAotIzogc3ludGF4LmM6NTY0NAogIywgYy1mb3JtYXQKIG1zZ2lkICJFNDA1OiBNaXNzaW5nIGVxdWFsIHNpZ246ICVzIgogbXNnc3RyICJFNDA1OiBGYWx0YSBlbCBzaWdubyBpZ3VhbDogJXMiCiAKLSM6IHN5bnRheC5jOjU2NTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTQwNjogRW1wdHkgYXJndW1lbnQ6ICVzIgogbXNnc3RyICJFNDA2OiBBcmd1bWVudG8gdmFjw61vOiAlcyIKIAotIzogc3ludGF4LmM6NTY3NgogIywgYy1mb3JtYXQKIG1zZ2lkICJFNDA3OiAlcyBub3QgYWxsb3dlZCBoZXJlIgogbXNnc3RyICJFNDA3OiAlcyBubyBzZSBwZXJtaXRlIGFxdcOtIgogCi0jOiBzeW50YXguYzo1NjgzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkU0MDg6ICVzIG11c3QgYmUgZmlyc3QgaW4gY29udGFpbnMgbGlzdCIKIG1zZ3N0ciAiRTQwODogJXMgZGViZSBzZXIgZWwgcHJpbWVybyBlbiBsYSBsaXN0YSBkZSBjb250ZW5pZG8iCiAKLSM6IHN5bnRheC5jOjU3NTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTQwOTogVW5rbm93biBncm91cCBuYW1lOiAlcyIKIG1zZ3N0ciAiRTQwOTogTm9tYnJlIGRlIGdydXBvIGRlc2Nvbm9jaWRvOiAlcyIKIAotIzogc3ludGF4LmM6NTk4OAogIywgYy1mb3JtYXQKIG1zZ2lkICJFNDEwOiBJbnZhbGlkIDpzeW50YXggc3ViY29tbWFuZDogJXMiCiBtc2dzdHIgIkU0MTA6IFN1Ym9yZGVuIFwiOnN5bnRheFwiIG5vIHbDoWxpZG86ICVzIgogCi0jOiBzeW50YXguYzo2NDc1CiBtc2dpZCAiRTY3OTogcmVjdXJzaXZlIGxvb3AgbG9hZGluZyBzeW5jb2xvci52aW0iCiBtc2dzdHIgIkU2Nzk6IGJ1Y2xlIHJlY3Vyc2l2byBhbCBjYXJnYXIgXCJzeW5jb2xvci52aW1cIiIKIAotIzogc3ludGF4LmM6NjYwMgogIywgYy1mb3JtYXQKIG1zZ2lkICJFNDExOiBoaWdobGlnaHQgZ3JvdXAgbm90IGZvdW5kOiAlcyIKIG1zZ3N0ciAiRTQxMTogZ3J1cG8gZGUgcmVzYWx0YWRvIG5vIGVuY29udHJhZG86ICVzIgogCi0jOiBzeW50YXguYzo2NjI2CiAjLCBjLWZvcm1hdAogbXNnaWQgIkU0MTI6IE5vdCBlbm91Z2ggYXJndW1lbnRzOiBcIjpoaWdobGlnaHQgbGluayAlc1wiIgogbXNnc3RyICJFNDEyOiBBcmd1bWVudG9zIGluc3VmaWNpZW50ZXM6IFwiOmhpZ2hsaWdodCBsaW5rICVzXCIiCiAKLSM6IHN5bnRheC5jOjY2MzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTQxMzogVG9vIG1hbnkgYXJndW1lbnRzOiBcIjpoaWdobGlnaHQgbGluayAlc1wiIgogbXNnc3RyICJFNDEzOiBEZW1hc2lhZG9zIGFyZ3VtZW50b3M6IFwiOmhpZ2hsaWdodCBsaW5rICVzXCIiCiAKLSM6IHN5bnRheC5jOjY2NTMKIG1zZ2lkICJFNDE0OiBncm91cCBoYXMgc2V0dGluZ3MsIGhpZ2hsaWdodCBsaW5rIGlnbm9yZWQiCiBtc2dzdHIgIkU0MTQ6IEVzdGEgZ3J1cG8gZXN0w6EgY29uZmlndXJhZG8sIHNlIGlnbm9yYSBlbCBlbmxhY2UgcmVzYWx0YWRvIgogCi0jOiBzeW50YXguYzo2Nzg1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkU0MTU6IHVuZXhwZWN0ZWQgZXF1YWwgc2lnbjogJXMiCiBtc2dzdHIgIkU0MTU6IFNpZ25vIFwiPVwiIGluZXNwZXJhZG86ICVzIgogCi0jOiBzeW50YXguYzo2ODIxCiAjLCBjLWZvcm1hdAogbXNnaWQgIkU0MTY6IG1pc3NpbmcgZXF1YWwgc2lnbjogJXMiCiBtc2dzdHIgIkU0MTY6IEZhbHRhIGVsIHNpZ25vIFwiPVwiOiAlcyIKIAotIzogc3ludGF4LmM6Njg0OQogIywgYy1mb3JtYXQKIG1zZ2lkICJFNDE3OiBtaXNzaW5nIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAiRTQxNzogRmFsdGEgZWwgYXJndW1lbnRvOiAlcyIKIAotIzogc3ludGF4LmM6Njg4NgogIywgYy1mb3JtYXQKIG1zZ2lkICJFNDE4OiBJbGxlZ2FsIHZhbHVlOiAlcyIKIG1zZ3N0ciAiRTQxODogVmFsb3IgaWxlZ2FsOiAlcyIKIAotIzogc3ludGF4LmM6NzAwNQogbXNnaWQgIkU0MTk6IEZHIGNvbG9yIHVua25vd24iCiBtc2dzdHIgIkU0MTk6IENvbG9yIGVuIHByaW1lciBwbGFubyBkZXNjb25vY2lkbyIKIAotIzogc3ludGF4LmM6NzAxNgogbXNnaWQgIkU0MjA6IEJHIGNvbG9yIHVua25vd24iCiBtc2dzdHIgIkU0MjA6IENvbG9yIGRlIGZvbmRvIGRlc2Nvbm9jaWRvIgogCi0jOiBzeW50YXguYzo3MDc3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkU0MjE6IENvbG9yIG5hbWUgb3IgbnVtYmVyIG5vdCByZWNvZ25pemVkOiAlcyIKIG1zZ3N0ciAiRTQyMTogTm9tYnJlIG8gbsO6bWVybyBkZSBjb2xvciBkZXNjb25vY2lkbzogJXMiCiAKLSM6IHN5bnRheC5jOjczMDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTQyMjogdGVybWluYWwgY29kZSB0b28gbG9uZzogJXMiCiBtc2dzdHIgIkU0MjI6IEPDs2RpZ28gZGUgdGVybWluYWwgZGVtYXNpYWRvIGxhcmdvOiAlcyIKIAotIzogc3ludGF4LmM6NzM1MQogIywgYy1mb3JtYXQKIG1zZ2lkICJFNDIzOiBJbGxlZ2FsIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAiRTQyMzogQXJndW1lbnRvIGlsZWdhbDogJXMiCiAKLSM6IHN5bnRheC5jOjc5MTIKIG1zZ2lkICJFNDI0OiBUb28gbWFueSBkaWZmZXJlbnQgaGlnaGxpZ2h0aW5nIGF0dHJpYnV0ZXMgaW4gdXNlIgogbXNnc3RyICJFNDI0OiBIYXkgZGVtYXNpYWRvcyBhdHJpYnV0b3MgZGUgcmVzYWx0YWRvIHNpbnTDoWN0aWNvIGVuIHVzbyIKIAotIzogc3ludGF4LmM6ODY0OQogbXNnaWQgIkU2Njk6IFVucHJpbnRhYmxlIGNoYXJhY3RlciBpbiBncm91cCBuYW1lIgogbXNnc3RyICJFNjY5OiBDYXLDoWN0ZXIgbm8gaW1wcmltaWJsZSBlbiBlbCBub21icmUgZGVsIGdydXBvIgogCiAjIFRoaXMgaXMgYW4gZXJyb3IsIGJ1dCBzaW5jZSB0aGVyZSBwcmV2aW91c2x5IHdhcyBubyBjaGVjayBvbmx5CiAjICogZ2l2ZSBhIHdhcm5pbmcuCi0jOiBzeW50YXguYzo4NjU3CiBtc2dpZCAiVzE4OiBJbnZhbGlkIGNoYXJhY3RlciBpbiBncm91cCBuYW1lIgogbXNnc3RyICJXMTg6IEhheSB1biBjYXLDoWN0ZXIgbm8gdsOhbGlkbyBlbiBlbCBub21icmUgZGVsIGdydXBvIgogCi0jOiB0YWcuYzo4NQogbXNnaWQgIkU1NTU6IGF0IGJvdHRvbSBvZiB0YWcgc3RhY2siCiBtc2dzdHIgIkU1NTU6IEVuIGVsIGZpbmFsIGRlIGxhIHBpbGEgZGUgZXRpcXVldGFzIgogCi0jOiB0YWcuYzo4NgogbXNnaWQgIkU1NTY6IGF0IHRvcCBvZiB0YWcgc3RhY2siCiBtc2dzdHIgIkU1NTY6IEVuIGVsIHByaW5jaXBpbyBkZSBsYSBwaWxhIGRlIGV0aXF1ZXRhcyIKIAotIzogdGFnLmM6NDM0CiBtc2dpZCAiRTQyNTogQ2Fubm90IGdvIGJlZm9yZSBmaXJzdCBtYXRjaGluZyB0YWciCiBtc2dzdHIgIkU0MjU6IE5vIHNlIHB1ZG8gaXIgYW50ZXMgZGUgbGEgcHJpbWVyIGV0aXF1ZXRhIGNvaW5jaWRlbnRlIgogCi0jOiB0YWcuYzo1ODMKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTQyNjogdGFnIG5vdCBmb3VuZDogJXMiCiBtc2dzdHIgIkU0MjY6IE5vIHNlIGVuY29udHLDsyBsYSBldGlxdWV0YTogJXMiCiAKLSM6IHRhZy5jOjYxNgogbXNnaWQgIiAgIyBwcmkga2luZCB0YWciCiBtc2dzdHIgIiAgIyBldGlxdWV0YSB0aXBvIFwicHJpXCIiCiAKLSM6IHRhZy5jOjYxOQogbXNnaWQgImZpbGVcbiIKIG1zZ3N0ciAiYXJjaGl2b1xuIgogCi0jOiB0YWcuYzo5NTMKIG1zZ2lkICJFNDI3OiBUaGVyZSBpcyBvbmx5IG9uZSBtYXRjaGluZyB0YWciCiBtc2dzdHIgIkU0Mjc6IFPDs2xvIGNvaW5jaWRlIHVuYSBldGlxdWV0YSIKIAotIzogdGFnLmM6OTU1CiBtc2dpZCAiRTQyODogQ2Fubm90IGdvIGJleW9uZCBsYXN0IG1hdGNoaW5nIHRhZyIKIG1zZ3N0ciAiRTQyODogTm8gc2UgcHVkbyBpciBtw6FzIGFsbMOhIGRlIGxhIMO6bHRpbWEgZXRpcXVldGEgY29pbmNpZGVudGUiCiAKLSM6IHRhZy5jOjk3OQogIywgYy1mb3JtYXQKIG1zZ2lkICJGaWxlIFwiJXNcIiBkb2VzIG5vdCBleGlzdCIKIG1zZ3N0ciAiTm8gZXhpc3RlIGVsIGFyY2hpdm8gXCIlc1wiIgogCiAjIEdpdmUgYW4gaW5kaWNhdGlvbiBvZiB0aGUgbnVtYmVyIG9mIG1hdGNoaW5nIHRhZ3MKLSMuIEdpdmUgYW4gaW5kaWNhdGlvbiBvZiB0aGUgbnVtYmVyIG9mIG1hdGNoaW5nIHRhZ3MKLSM6IHRhZy5jOjk5MQogIywgYy1mb3JtYXQKIG1zZ2lkICJ0YWcgJWQgb2YgJWQlcyIKIG1zZ3N0ciAiZXRpcXVldGEgJWQgZGUgJWQlcyIKIAotIzogdGFnLmM6OTk0CiBtc2dpZCAiIG9yIG1vcmUiCiBtc2dzdHIgIiBvIG3DoXMiCiAKLSM6IHRhZy5jOjk5NgogbXNnaWQgIiAgVXNpbmcgdGFnIHdpdGggZGlmZmVyZW50IGNhc2UhIgogbXNnc3RyICIiCiAiICDCoUVzdMOhIHVzYW5kbyB1bmEgZXRpcXVldGEgY29uIG1hecO6c2N1bGFzIHkgbWluw7pzY3VsYXMgcXVlIG5vIGNvaW5jaWRlbiEiCiAKLSM6IHRhZy5jOjEwNTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTQyOTogRmlsZSBcIiVzXCIgZG9lcyBub3QgZXhpc3QiCiBtc2dzdHIgIkU0Mjk6IEVsIGFyY2hpdm8gXCIlc1wiIG5vIGV4aXN0ZSIKIAogIyBIaWdobGlnaHQgdGl0bGUKLSMuIEhpZ2hsaWdodCB0aXRsZQotIzogdGFnLmM6MTExOQogbXNnaWQgIiIKICJcbiIKICIgICMgVE8gdGFnICAgICAgICAgRlJPTSBsaW5lICBpbiBmaWxlL3RleHQiCkBAIC02OTkyLDgxICs1NDYwLDYyIEBACiAiXG4iCiAiICAjIEEgZXRpcXVldGEgICAgICAgIERFU0RFIGxhIGzDrW5lYSAgIGVuIGVsIGFyY2hpdm8vdGV4dG8iCiAKLSM6IHRhZy5jOjE1NDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiU2VhcmNoaW5nIHRhZ3MgZmlsZSAlcyIKIG1zZ3N0ciAiQnVzY2FuZG8gZWwgYXJjaGl2byBkZSBldGlxdWV0YXMgJXMiCiAKLSM6IHRhZy5jOjE3MzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTQzMDogVGFnIGZpbGUgcGF0aCB0cnVuY2F0ZWQgZm9yICVzXG4iCiBtc2dzdHIgIkU0MzA6IExhIHJ1dGEgZGVsIGFyY2hpdm8gZGUgZXRpcXVldGFzICVzIGVzdMOhIHRydW5jYWRhXG4iCiAKLSM6IHRhZy5jOjIzODgKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTQzMTogRm9ybWF0IGVycm9yIGluIHRhZ3MgZmlsZSBcIiVzXCIiCiBtc2dzdHIgIkU0MzE6IEVycm9yIGRlIGZvcm1hdG8gZW4gZWwgYXJjaGl2byBkZSBldGlxdWV0YXMgXCIlc1wiIgogCi0jOiB0YWcuYzoyMzkyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkJlZm9yZSBieXRlICVsZCIKIG1zZ3N0ciAiQWRlbGFudGUgZGVsIGJ5dGUgJWxkIgogCi0jOiB0YWcuYzoyNDI1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkU0MzI6IFRhZ3MgZmlsZSBub3Qgc29ydGVkOiAlcyIKIG1zZ3N0ciAiRTQzMjogQXJjaGl2byBkZSBldGlxdWV0YXMgc2luIG9yZGVuYXI6ICVzIgogCiAjIG5ldmVyIG9wZW5lZCBhbnkgdGFncyBmaWxlCi0jLiBuZXZlciBvcGVuZWQgYW55IHRhZ3MgZmlsZQotIzogdGFnLmM6MjQ2OQogbXNnaWQgIkU0MzM6IE5vIHRhZ3MgZmlsZSIKIG1zZ3N0ciAiRTQzMzogTm8gaGF5IGFyY2hpdm8gZGUgZXRpcXVldGFzIgogCi0jOiB0YWcuYzoyNzQ4CiBtc2dpZCAiSWdub3JpbmcgbG9uZyBsaW5lIGluIHRhZ3MgZmlsZSIKIG1zZ3N0ciAiSWdub3JhbmRvIGxhIGzDrW5lYSBsYXJnYSBlbiBlbCBhcmNoaXZvIGRlIGV0aXF1ZXRhcyIKIAotIzogdGFnLmM6MzI1NwogbXNnaWQgIkU0MzQ6IENhbid0IGZpbmQgdGFnIHBhdHRlcm4iCiBtc2dzdHIgIkU0MzQ6IE5vIHNlIHB1ZG8gZW5jb250cmFyIGVsIHBhdHLDs24gZGUgbGEgZXRpcXVldGEiCiAKLSM6IHRhZy5jOjMyNjgKIG1zZ2lkICJFNDM1OiBDb3VsZG4ndCBmaW5kIHRhZywganVzdCBndWVzc2luZyEiCiBtc2dzdHIgIkU0MzU6IE5vIHNlIHB1ZG8gZW5jb250cmFyIGxhIGV0aXF1ZXRhLiDCoUVzdG95IGFkaXZpbmFuZG8hIgogCi0jOiB0ZXJtLmM6MTc5MwogbXNnaWQgIicgbm90IGtub3duLiBBdmFpbGFibGUgYnVpbHRpbiB0ZXJtaW5hbHMgYXJlOiIKIG1zZ3N0ciAiJyBkZXNjb25vY2lkby4gTG9zIHRlcm1pbmFsZXMgaW5jb3Jwb3JhZG9zIGRpc3BvbmlibGVzIHNvbjoiCiAKLSM6IHRlcm0uYzoxODE3CiBtc2dpZCAiZGVmYXVsdGluZyB0byAnIgogbXNnc3RyICJVc2FuZG8gJyBwb3IgZGVmZWN0byIKIAotIzogdGVybS5jOjIxNzIKIG1zZ2lkICJFNTU3OiBDYW5ub3Qgb3BlbiB0ZXJtY2FwIGZpbGUiCiBtc2dzdHIgIkU1NTc6IE5vIHNlIHB1ZG8gYWJyaXIgZWwgYXJjaGl2byBcInRlcm1jYXBcIiIKIAotIzogdGVybS5jOjIxNzYKIG1zZ2lkICJFNTU4OiBUZXJtaW5hbCBlbnRyeSBub3QgZm91bmQgaW4gdGVybWluZm8iCiBtc2dzdHIgIkU1NTg6IE5vIGhlIGVuY29udHJhZG8gbGEgZGVmaW5pY2nDs24gZGVsIHRlcm1pbmFsIGVuIFwidGVybWluZm9cIiIKIAotIzogdGVybS5jOjIxNzgKIG1zZ2lkICJFNTU5OiBUZXJtaW5hbCBlbnRyeSBub3QgZm91bmQgaW4gdGVybWNhcCIKIG1zZ3N0ciAiRTU1OTogTm8gaGUgZW5jb250cmFkbyBsYSBkZWZpbmljacOzbiBkZWwgdGVybWluYWwgZW4gXCJ0ZXJtY2FwXCIiCiAKLSM6IHRlcm0uYzoyMzM3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkU0MzY6IE5vIFwiJXNcIiBlbnRyeSBpbiB0ZXJtY2FwIgogbXNnc3RyICJFNDM2OiBsYSBlbnRyYWRhICVzIG5vIGV4aXN0ZSBlbiBlbCBhcmNoaXZvIFwidGVybWNhcFwiIgogCi0jOiB0ZXJtLmM6MjgxMQogbXNnaWQgIkU0Mzc6IHRlcm1pbmFsIGNhcGFiaWxpdHkgXCJjbVwiIHJlcXVpcmVkIgogbXNnc3RyICJFNDM3OiBTZSBuZWNlc2l0YSBsYSBjYXBhY2lkYWQgXCJjbVwiIGVuIGVsIHRlcm1pbmFsIgogCiAjIEhpZ2hsaWdodCB0aXRsZQotIy4gSGlnaGxpZ2h0IHRpdGxlCi0jOiB0ZXJtLmM6NTI4MAogbXNnaWQgIiIKICJcbiIKICItLS0gVGVybWluYWwga2V5cyAtLS0iCkBAIC03MDc0LDEwNiArNTUyMyw4MCBAQAogIlxuIgogIi0tLSBUZWNsYXMgZGUgbGEgdGVybWluYWwgLS0tIgogCi0jOiB1aS5jOjI4NAogbXNnaWQgIm5ldyBzaGVsbCBzdGFydGVkXG4iCiBtc2dzdHIgIkluaWNpYWRvIG51ZXZvIGludMOpcnByZXRlIGRlIMOzcmRlbmVzXG4iCiAKLSM6IHVpLmM6MTg4NgogbXNnaWQgIlZpbTogRXJyb3IgcmVhZGluZyBpbnB1dCwgZXhpdGluZy4uLlxuIgogbXNnc3RyICJWaW06IGVycm9yIGFsIGxlZXIgbGEgZW50cmFkYSwgc2FsaWVuZG8uLi5cbiIKIAotIzogdWkuYzoyNDA5CiBtc2dpZCAiVXNlZCBDVVRfQlVGRkVSMCBpbnN0ZWFkIG9mIGVtcHR5IHNlbGVjdGlvbiIKIG1zZ3N0ciAiU2UgaGEgdXNhZG8gXCJDVVRfQlVGRkVSMFwiIGVuIHZleiBkZSB1bmEgc2VsZWNjacOzbiB2YWPDrWEiCiAKICMgbXVzdCBkaXNwbGF5IHRoZSBwcm9tcHQKLSMuIG11c3QgZGlzcGxheSB0aGUgcHJvbXB0Ci0jOiB1bmRvLmM6NjQ1CiBtc2dpZCAiTm8gdW5kbyBwb3NzaWJsZTsgY29udGludWUgYW55d2F5IgogbXNnc3RyICJObyBlcyBwb3NpYmxlIGRlc2hhY2VyOyBjb250aW51YW5kbyBkZSB0b2RvcyBtb2RvcyIKIAotIzogdW5kby5jOjcyNyB1bmRvLmM6OTM3CiBtc2dpZCAiQWxyZWFkeSBhdCBvbGRlc3QgY2hhbmdlIgogbXNnc3RyICJFc3RlIGVzIGVsIGNhbWJpbyBtw6FzIGFudGlndW8iCiAKLSM6IHVuZG8uYzo3NDIgdW5kby5jOjkzOQogbXNnaWQgIkFscmVhZHkgYXQgbmV3ZXN0IGNoYW5nZSIKIG1zZ3N0ciAiRXN0ZSBlcyBlbCBjYW1iaW8gbcOhcyBudWV2byIKIAotIzogdW5kby5jOjkzMAogIywgYy1mb3JtYXQKIG1zZ2lkICJVbmRvIG51bWJlciAlbGQgbm90IGZvdW5kIgogbXNnc3RyICJObyBzZSBlbmNvbnRyw7MgZWwgbsO6bWVybyBkZSBcImRlc2hhY2VyXCIgJWxkIgogCi0jOiB1bmRvLmM6MTEwMAogbXNnaWQgIkU0Mzg6IHVfdW5kbzogbGluZSBudW1iZXJzIHdyb25nIgogbXNnc3RyICJFNDM4OiBcInVfdW5kb1wiOiBuw7ptZXJvcyBkZSBsw61uZWEgZXJyw7NuZW9zIgogCi0jOiB1bmRvLmM6MTMzOAogbXNnaWQgIm1vcmUgbGluZSIKIG1zZ3N0ciAiVW5hIGzDrW5lYSBtw6FzIgogCi0jOiB1bmRvLmM6MTM0MAogbXNnaWQgIm1vcmUgbGluZXMiCiBtc2dzdHIgImzDrW5lYXMgbcOhcyIKIAotIzogdW5kby5jOjEzNDIKIG1zZ2lkICJsaW5lIGxlc3MiCiBtc2dzdHIgInVuYSBsw61uZWEgbWVub3MiCiAKLSM6IHVuZG8uYzoxMzQ0CiBtc2dpZCAiZmV3ZXIgbGluZXMiCiBtc2dzdHIgImzDrW5lYXMgbWVub3MiCiAKLSM6IHVuZG8uYzoxMzQ5CiBtc2dpZCAiY2hhbmdlIgogbXNnc3RyICJjYW1iaW8iCiAKLSM6IHVuZG8uYzoxMzUxCiBtc2dpZCAiY2hhbmdlcyIKIG1zZ3N0ciAiY2FtYmlvcyIKIAotIzogdW5kby5jOjEzNzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJWxkICVzOyAlcyAjJWxkICAlcyIKIG1zZ3N0ciAiJWxkICVzOyAlcyAjJWxkICAlcyIKIAotIzogdW5kby5jOjEzNzgKIG1zZ2lkICJiZWZvcmUiCiBtc2dzdHIgImFudGVzIgogCi0jOiB1bmRvLmM6MTM3OAogbXNnaWQgImFmdGVyIgogbXNnc3RyICJkZXNwdcOpcyIKIAotIzogdW5kby5jOjE0ODYKIG1zZ2lkICJOb3RoaW5nIHRvIHVuZG8iCiBtc2dzdHIgIk5hZGEgcXVlIGhhY2VyIgogCi0jOiB1bmRvLmM6MTQ5MgogbXNnaWQgIm51bWJlciBjaGFuZ2VzICB0aW1lIgogbXNnc3RyICJlbCBuw7ptZXJvIG1vZGlmaWNhIGVsIHRpZW1wbyIKIAotIzogdW5kby5jOjE1MjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJWxkIHNlY29uZHMgYWdvIgogbXNnc3RyICJoYWNlICVsZCBzZWd1bmRvcyIKIAotIzogdW5kby5jOjE1NDEKIG1zZ2lkICJFNzkwOiB1bmRvam9pbiBpcyBub3QgYWxsb3dlZCBhZnRlciB1bmRvIgogbXNnc3RyICJFNzkwOiBcInVuZG9qb2luXCIgbm8gZXN0w6EgcGVybWl0aWRvIGRlc3B1w6lzIGRlIFwidW5kb1wiIgogCi0jOiB1bmRvLmM6MTU5MQogbXNnaWQgIkU0Mzk6IHVuZG8gbGlzdCBjb3JydXB0IgogbXNnc3RyICJFNDM5OiBsYSBsaXN0YSBkZSBkZXNoYWNlciBzZSBoYSBkYcOxYWRvIgogCi0jOiB1bmRvLmM6MTYyMwogbXNnaWQgIkU0NDA6IHVuZG8gbGluZSBtaXNzaW5nIgogbXNnc3RyICJFNDQwOiBmYWx0YSBsYSBsw61uZWEgZGVzaGFjZXIiCiAKICMgT25seSBNUyBWQyA0LjEgYW5kIGVhcmxpZXIgY2FuIGRvIFdpbjMycwotIy4gT25seSBNUyBWQyA0LjEgYW5kIGVhcmxpZXIgY2FuIGRvIFdpbjMycwotIzogdmVyc2lvbi5jOjEzNjYKIG1zZ2lkICIiCiAiXG4iCiAiTVMtV2luZG93cyAxNi8zMi1iaXQgR1VJIHZlcnNpb24iCkBAIC03MTgxLDcgKzU2MDQsNiBAQAogIlxuIgogIlZlcnNpw7NuIGRlIGludGVyZmF6IGdyw6FmaWNhIGRlIDE2LzMyIGJpdHMgcGFyYSBNUy1XaW5kb3dzIgogCi0jOiB2ZXJzaW9uLmM6MTM2OQogbXNnaWQgIiIKICJcbiIKICJNUy1XaW5kb3dzIDY0LWJpdCBHVUkgdmVyc2lvbiIKQEAgLTcxODksNyArNTYxMSw2IEBACiAiXG4iCiAiVmVyc2nDs24gZGUgaW50ZXJmYXogZ3LDoWZpY2EgZGUgNjQgYml0cyBwYXJhIE1TLVdpbmRvd3MiCiAKLSM6IHZlcnNpb24uYzoxMzcxCiBtc2dpZCAiIgogIlxuIgogIk1TLVdpbmRvd3MgMzItYml0IEdVSSB2ZXJzaW9uIgpAQCAtNzE5NywxNSArNTYxOCwxMiBAQAogIlxuIgogIlZlcnNpw7NuIGRlIGludGVyZmF6IGdyw6FmaWNhIGRlIDMyIGJpdHMgcGFyYSBNUy1XaW5kb3dzIgogCi0jOiB2ZXJzaW9uLmM6MTM3NQogbXNnaWQgIiBpbiBXaW4zMnMgbW9kZSIKIG1zZ3N0ciAiIGVuIG1vZG8gV2luMzJzIgogCi0jOiB2ZXJzaW9uLmM6MTM3NwogbXNnaWQgIiB3aXRoIE9MRSBzdXBwb3J0IgogbXNnc3RyICIgY29uIGNvbXBhdGliaWxpZGFkIGNvbiBPTEUiCiAKLSM6IHZlcnNpb24uYzoxMzgxCiBtc2dpZCAiIgogIlxuIgogIk1TLVdpbmRvd3MgNjQtYml0IGNvbnNvbGUgdmVyc2lvbiIKQEAgLTcyMTMsNyArNTYzMSw2IEBACiAiXG4iCiAiVmVyc2nDs24gZGUgNjQgYml0cyBwYXJhIGNvbnNvbGEgZGUgTVMtV2luZG93cyIKIAotIzogdmVyc2lvbi5jOjEzODMKIG1zZ2lkICIiCiAiXG4iCiAiTVMtV2luZG93cyAzMi1iaXQgY29uc29sZSB2ZXJzaW9uIgpAQCAtNzIyMSw3ICs1NjM4LDYgQEAKICJcbiIKICJWZXJzacOzbiBkZSAzMiBiaXRzIHBhcmEgY29uc29sYSBkZSBNUy1XaW5kb3dzIgogCi0jOiB2ZXJzaW9uLmM6MTM4OAogbXNnaWQgIiIKICJcbiIKICJNUy1XaW5kb3dzIDE2LWJpdCB2ZXJzaW9uIgpAQCAtNzIyOSw3ICs1NjQ1LDYgQEAKICJcbiIKICJWZXJzacOzbiBkZSAxNiBiaXRzIHBhcmEgTVMtV2luZG93cyIKIAotIzogdmVyc2lvbi5jOjEzOTIKIG1zZ2lkICIiCiAiXG4iCiAiMzItYml0IE1TLURPUyB2ZXJzaW9uIgpAQCAtNzIzNyw3ICs1NjUyLDYgQEAKICJcbiIKICJWZXJzacOzbiBkZSAzMiBiaXRzIHBhcmEgTVMtRE9TIgogCi0jOiB2ZXJzaW9uLmM6MTM5NAogbXNnaWQgIiIKICJcbiIKICIxNi1iaXQgTVMtRE9TIHZlcnNpb24iCkBAIC03MjQ1LDcgKzU2NTksNiBAQAogIlxuIgogIlZlcnNpw7NuIGRlIDE2IGJpdHMgcGFyYSBNUy1ET1MiCiAKLSM6IHZlcnNpb24uYzoxNDAwCiBtc2dpZCAiIgogIlxuIgogIk1hY09TIFggKHVuaXgpIHZlcnNpb24iCkBAIC03MjUzLDcgKzU2NjYsNiBAQAogIlxuIgogIlZlcnNpw7NuIHBhcmEgWCAoVW5peCkgcGFyYSBNYWNPUyIKIAotIzogdmVyc2lvbi5jOjE0MDIKIG1zZ2lkICIiCiAiXG4iCiAiTWFjT1MgWCB2ZXJzaW9uIgpAQCAtNzI2MSw3ICs1NjczLDYgQEAKICJcbiIKICJWZXJzacOzbiBwYXJhIE1hY09TIFgiCiAKLSM6IHZlcnNpb24uYzoxNDA1CiBtc2dpZCAiIgogIlxuIgogIk1hY09TIHZlcnNpb24iCkBAIC03MjY5LDcgKzU2ODAsNiBAQAogIlxuIgogIlZlcnNpw7NuIHBhcmEgTWFjT1MiCiAKLSM6IHZlcnNpb24uYzoxNDEwCiBtc2dpZCAiIgogIlxuIgogIlJJU0MgT1MgdmVyc2lvbiIKQEAgLTcyNzcsNyArNTY4Nyw2IEBACiAiXG4iCiAiVmVyc2nDs24gcGFyYSBSSVNDIE9TIgogCi0jOiB2ZXJzaW9uLmM6MTQxMwogbXNnaWQgIiIKICJcbiIKICJPcGVuVk1TIHZlcnNpb24iCkBAIC03Mjg1LDcgKzU2OTQsNiBAQAogIlxuIgogIlZlcnNpw7NuIHBhcmEgT3BlblZNUyIKIAotIzogdmVyc2lvbi5jOjE0MjgKIG1zZ2lkICIiCiAiXG4iCiAiSW5jbHVkZWQgcGF0Y2hlczogIgpAQCAtNzI5Myw3ICs1NzAxLDYgQEAKICJcbiIKICJQYXJjaGVzIGluY2x1aWRvczogIgogCi0jOiB2ZXJzaW9uLmM6MTQ1NQogbXNnaWQgIiIKICJcbiIKICJFeHRyYSBwYXRjaGVzOiAiCkBAIC03MzAxLDExICs1NzA4LDkgQEAKICJcbiIKICJQYXJjaGVzIGFkaWNpb25hbGVzOiAiCiAKLSM6IHZlcnNpb24uYzoxNDY3IHZlcnNpb24uYzoxODMxCiBtc2dpZCAiTW9kaWZpZWQgYnkgIgogbXNnc3RyICJNb2RpZmljYWRvIHBvciAiCiAKLSM6IHZlcnNpb24uYzoxNDc0CiBtc2dpZCAiIgogIlxuIgogIkNvbXBpbGVkICIKQEAgLTczMTMsMTEgKzU3MTgsOSBAQAogIlxuIgogIkNvbXBpbGFkbyAiCiAKLSM6IHZlcnNpb24uYzoxNDc3CiBtc2dpZCAiYnkgIgogbXNnc3RyICJwb3IgIgogCi0jOiB2ZXJzaW9uLmM6MTQ4OQogbXNnaWQgIiIKICJcbiIKICJIdWdlIHZlcnNpb24gIgpAQCAtNzMyNSw3ICs1NzI4LDYgQEAKICJcbiIKICJWZXJzacOzbiBcImVub3JtZVwiICIKIAotIzogdmVyc2lvbi5jOjE0OTIKIG1zZ2lkICIiCiAiXG4iCiAiQmlnIHZlcnNpb24gIgpAQCAtNzMzMyw3ICs1NzM1LDYgQEAKICJcbiIKICJWZXJzacOzbiBcImdyYW5kZVwiICIKIAotIzogdmVyc2lvbi5jOjE0OTUKIG1zZ2lkICIiCiAiXG4iCiAiTm9ybWFsIHZlcnNpb24gIgpAQCAtNzM0MSw3ICs1NzQyLDYgQEAKICJcbiIKICJWZXJzacOzbiBcIm5vcm1hbFwiICIKIAotIzogdmVyc2lvbi5jOjE0OTgKIG1zZ2lkICIiCiAiXG4iCiAiU21hbGwgdmVyc2lvbiAiCkBAIC03MzQ5LDcgKzU3NDksNiBAQAogIlxuIgogIlZlcnNpw7NuIFwicGVxdWXDsWFcIiAiCiAKLSM6IHZlcnNpb24uYzoxNTAwCiBtc2dpZCAiIgogIlxuIgogIlRpbnkgdmVyc2lvbiAiCkBAIC03MzU3LDMzMCArNTc1NiwyNTAgQEAKICJcbiIKICJWZXJzacOzbiBcImRpbWludXRhXCIgIgogCi0jOiB2ZXJzaW9uLmM6MTUwNgogbXNnaWQgIndpdGhvdXQgR1VJLiIKIG1zZ3N0ciAic2luIGludGVyZmF6IGdyw6FmaWNhIChHVUkpLiIKIAotIzogdmVyc2lvbi5jOjE1MTEKIG1zZ2lkICJ3aXRoIEdUSzItR05PTUUgR1VJLiIKIG1zZ3N0ciAiY29uIGludGVyZmF6IGdyw6FmaWNhIHBhcmEgR1RLMi1HTk9NRS4iCiAKLSM6IHZlcnNpb24uYzoxNTEzCiBtc2dpZCAid2l0aCBHVEstR05PTUUgR1VJLiIKIG1zZ3N0ciAiY29uIGludGVyZmF6IGdyw6FmaWNhIHBhcmEgR1RLLUdOT01FLiIKIAotIzogdmVyc2lvbi5jOjE1MTcKIG1zZ2lkICJ3aXRoIEdUSzIgR1VJLiIKIG1zZ3N0ciAiY29uIGludGVyZmF6IGdyw6FmaWNhIGRlIEdUSzIuIgogCi0jOiB2ZXJzaW9uLmM6MTUxOQogbXNnaWQgIndpdGggR1RLIEdVSS4iCiBtc2dzdHIgImNvbiBpbnRlcmZheiBncsOhZmljYSBkZSBHVEsuIgogCi0jOiB2ZXJzaW9uLmM6MTUyNAogbXNnaWQgIndpdGggWDExLU1vdGlmIEdVSS4iCiBtc2dzdHIgImNvbiBpbnRlcmZheiBncsOhZmljYSBwYXJhIFgxMS1Nb3RpZi4iCiAKLSM6IHZlcnNpb24uYzoxNTI4CiBtc2dpZCAid2l0aCBYMTEtbmVYdGF3IEdVSS4iCiBtc2dzdHIgImNvbiBpbnRlcmZheiBncsOhZmljYSBkZSBYMTEtbmVYdGF3LiIKIAotIzogdmVyc2lvbi5jOjE1MzAKIG1zZ2lkICJ3aXRoIFgxMS1BdGhlbmEgR1VJLiIKIG1zZ3N0ciAiY29uIGludGVyZmF6IGdyw6FmaWNhIGRlIFgxMS1BdGhlbmEuIgogCi0jOiB2ZXJzaW9uLmM6MTUzNAogbXNnaWQgIndpdGggUGhvdG9uIEdVSS4iCiBtc2dzdHIgImNvbiBpbnRlcmZheiBncsOhZmljYSBwYXJhIFBob3Rvbi4iCiAKLSM6IHZlcnNpb24uYzoxNTM3CiBtc2dpZCAid2l0aCBHVUkuIgogbXNnc3RyICJjb24gaW50ZXJmYXogZ3LDoWZpY2EgZGUgdXN1YXJpby4iCiAKLSM6IHZlcnNpb24uYzoxNTQwCiBtc2dpZCAid2l0aCBDYXJib24gR1VJLiIKIG1zZ3N0ciAiY29uIEdVSSBDYXJib24uIgogCi0jOiB2ZXJzaW9uLmM6MTU0MwogbXNnaWQgIndpdGggQ29jb2EgR1VJLiIKIG1zZ3N0ciAiY29uIGludGVyZmF6IGdyw6FmaWNhIHBhcmEgQ29jb2EuIgogCi0jOiB2ZXJzaW9uLmM6MTU0NgogbXNnaWQgIndpdGggKGNsYXNzaWMpIEdVSS4iCiBtc2dzdHIgImNvbiBpbnRlcmZheiBncsOhZmljYSAoY2zDoXNpY2EpLiIKIAotIzogdmVyc2lvbi5jOjE1NTYKIG1zZ2lkICIgIEZlYXR1cmVzIGluY2x1ZGVkICgrKSBvciBub3QgKC0pOlxuIgogbXNnc3RyICIgIEFzcGVjdG9zIGluY2x1aWRvcyAoKykgbyBubyAoLSk6XG4iCiAKLSM6IHZlcnNpb24uYzoxNTY4CiBtc2dpZCAiICAgc3lzdGVtIHZpbXJjIGZpbGU6IFwiIgogbXNnc3RyICIgICAgIGFyY2hpdm8gXCJ2aW1yY1wiIGRlbCBzaXN0ZW1hOiBcIiIKIAotIzogdmVyc2lvbi5jOjE1NzMKIG1zZ2lkICIgICAgIHVzZXIgdmltcmMgZmlsZTogXCIiCiBtc2dzdHIgIiAgICAgYXJjaGl2byBcInZpbXJjXCIgZGVsIHVzdWFyaW86IFwiIgogCi0jOiB2ZXJzaW9uLmM6MTU3OAogbXNnaWQgIiAybmQgdXNlciB2aW1yYyBmaWxlOiBcIiIKIG1zZ3N0ciAiICAywrogYXJjaGl2byBcInZpbXJjXCIgZGVsIHVzdWFyaW86IFwiIgogCi0jOiB2ZXJzaW9uLmM6MTU4MwogbXNnaWQgIiAzcmQgdXNlciB2aW1yYyBmaWxlOiBcIiIKIG1zZ3N0ciAiIDNlciBhcmNoaXZvIFwidmltcmNcIiBkZWwgdXN1YXJpbzogXCIiCiAKLSM6IHZlcnNpb24uYzoxNTg4CiBtc2dpZCAiICAgICAgdXNlciBleHJjIGZpbGU6IFwiIgogbXNnc3RyICIgICAgICBhcmNoaXZvIFwiZXhyY1wiIGRlbCB1c3VhcmlvOiBcIiIKIAotIzogdmVyc2lvbi5jOjE1OTMKIG1zZ2lkICIgIDJuZCB1c2VyIGV4cmMgZmlsZTogXCIiCiBtc2dzdHIgIiAgIDLCuiBhcmNoaXZvIFwiZXhyY1wiIGRlbCB1c3VhcmlvOiBcIiIKIAotIzogdmVyc2lvbi5jOjE1OTkKIG1zZ2lkICIgIHN5c3RlbSBndmltcmMgZmlsZTogXCIiCiBtc2dzdHIgIiAgICBhcmNoaXZvIFwiZ3ZpbXJjXCIgZGVsIHNpc3RlbWE6IFwiIgogCi0jOiB2ZXJzaW9uLmM6MTYwMwogbXNnaWQgIiAgICB1c2VyIGd2aW1yYyBmaWxlOiBcIiIKIG1zZ3N0ciAiICAgIGFyY2hpdm8gXCJndmltcmNcIiBkZWwgdXN1YXJpbzogXCIiCiAKLSM6IHZlcnNpb24uYzoxNjA3CiBtc2dpZCAiMm5kIHVzZXIgZ3ZpbXJjIGZpbGU6IFwiIgogbXNnc3RyICIgMsK6IGFyY2hpdm8gXCJndmltcmNcIiBkZWwgdXN1YXJpbzogXCIiCiAKLSM6IHZlcnNpb24uYzoxNjEyCiBtc2dpZCAiM3JkIHVzZXIgZ3ZpbXJjIGZpbGU6IFwiIgogbXNnc3RyICIzZXIgYXJjaGl2byBcImd2aW1yY1wiIGRlbCB1c3VhcmlvOiBcIiIKIAotIzogdmVyc2lvbi5jOjE2MTkKIG1zZ2lkICIgICAgc3lzdGVtIG1lbnUgZmlsZTogXCIiCiBtc2dzdHIgIiAgICAgYXJjaGl2byBkZSBtZW7DuiBkZWwgc2lzdGVtYTogXCIiCiAKLSM6IHZlcnNpb24uYzoxNjI3CiBtc2dpZCAiICBmYWxsLWJhY2sgZm9yICRWSU06IFwiIgogbXNnc3RyICIgICAgICAgICAgICBwcmVkZWZpbmlkbyBwYXJhICRWSU06IFwiIgogCi0jOiB2ZXJzaW9uLmM6MTYzMwogbXNnaWQgIiBmLWIgZm9yICRWSU1SVU5USU1FOiBcIiIKIG1zZ3N0ciAiICAgICBwcmVkZWZpbmlkbyBwYXJhICRWSU1SVU5USU1FOiBcIiIKIAotIzogdmVyc2lvbi5jOjE2MzcKIG1zZ2lkICJDb21waWxhdGlvbjogIgogbXNnc3RyICJDb21waWxhY2nDs246ICIKIAotIzogdmVyc2lvbi5jOjE2NDMKIG1zZ2lkICJDb21waWxlcjogIgogbXNnc3RyICJDb21waWxhZG9yOiAiCiAKLSM6IHZlcnNpb24uYzoxNjQ4CiBtc2dpZCAiTGlua2luZzogIgogbXNnc3RyICJFbmxhemFkbzogIgogCi0jOiB2ZXJzaW9uLmM6MTY1MwogbXNnaWQgIiAgREVCVUcgQlVJTEQiCiBtc2dzdHIgIiAgQ09NUElMQUNJw5NOIENPTiBTw41NQk9MT1MgREUgREVQVVJBQ0nDk04iCiAKLSM6IHZlcnNpb24uYzoxNjkyCiBtc2dpZCAiVklNIC0gVmkgSU1wcm92ZWQiCiBtc2dzdHIgIlZJTSAtIFZJIE1lam9yYWRvIgogCi0jOiB2ZXJzaW9uLmM6MTY5NAogbXNnaWQgInZlcnNpb24gIgogbXNnc3RyICJ2ZXJzacOzbiAiCiAKLSM6IHZlcnNpb24uYzoxNjk1CiBtc2dpZCAiYnkgQnJhbSBNb29sZW5hYXIgZXQgYWwuIgogbXNnc3RyICJwb3IgQnJhbSBNb29sZW5hYXIgZXQgYWwuIgogCi0jOiB2ZXJzaW9uLmM6MTY5OQogbXNnaWQgIlZpbSBpcyBvcGVuIHNvdXJjZSBhbmQgZnJlZWx5IGRpc3RyaWJ1dGFibGUiCiBtc2dzdHIgIlZpbSBlcyBjw7NkaWdvIGFiaWVydG8geSBzZSBwdWVkZSBkaXN0cmlidWlyIGxpYnJlbWVudGUiCiAKLSM6IHZlcnNpb24uYzoxNzAxCiBtc2dpZCAiSGVscCBwb29yIGNoaWxkcmVuIGluIFVnYW5kYSEiCiBtc2dzdHIgIsKhQXl1ZGUgYSBsb3MgbmnDsW9zIHBvYnJlcyBkZSBVZ2FuZGEhIgogCi0jOiB2ZXJzaW9uLmM6MTcwMgogbXNnaWQgInR5cGUgIDpoZWxwIGljY2Y8RW50ZXI+ICAgICAgIGZvciBpbmZvcm1hdGlvbiAiCiBtc2dzdHIgImVzY3JpYmEgIMKrOmhlbHAgaWNjZjxJbnRybz7CuyAgICBwYXJhIG3DoXMgaW5mb3JtYWNpw7NuICAiCiAKLSM6IHZlcnNpb24uYzoxNzA0CiBtc2dpZCAidHlwZSAgOnE8RW50ZXI+ICAgICAgICAgICAgICAgdG8gZXhpdCAgICAgICAgICIKIG1zZ3N0ciAiZXNjcmliYSAgwqs6cTxJbnRybz7CuyAgICAgICAgICAgIHBhcmEgc2FsaXIgICAgICAgICAgICAgIgogCi0jOiB2ZXJzaW9uLmM6MTcwNQogbXNnaWQgInR5cGUgIDpoZWxwPEVudGVyPiAgb3IgIDxGMT4gIGZvciBvbi1saW5lIGhlbHAiCiBtc2dzdHIgImVzY3JpYmEgIMKrOmhlbHA8SW50cm8+wrsgbyA8RjE+ICBwYXJhIG9idGVuZXIgYXl1ZGEgICAgICIKIAotIzogdmVyc2lvbi5jOjE3MDYKIG1zZ2lkICJ0eXBlICA6aGVscCB2ZXJzaW9uODxFbnRlcj4gICBmb3IgdmVyc2lvbiBpbmZvIgogbXNnc3RyICJlc2NyaWJhIMKrOmhlbHAgdmVyc2lvbjg8SW50cm8+wrsgcGFyYSBpbmZvcm1hY2nDs24gZGUgbGEgdmVyc2nDs24iCiAKLSM6IHZlcnNpb24uYzoxNzA5CiBtc2dpZCAiUnVubmluZyBpbiBWaSBjb21wYXRpYmxlIG1vZGUiCiBtc2dzdHIgIkVqZWN1dGFuZG8gZW4gbW9kbyBjb21wYXRpYmxlIGNvbiBWaSIKIAotIzogdmVyc2lvbi5jOjE3MTAKIG1zZ2lkICJ0eXBlICA6c2V0IG5vY3A8RW50ZXI+ICAgICAgICBmb3IgVmltIGRlZmF1bHRzIgogbXNnc3RyICJlc2NyaWJhICDCqzpzZXQgbm9jcDxJbnRybz7CuyAgcGFyYSBsb3MgdmFsb3JlcyBwcmVkZWZpbmlkb3MgZGUgVmltIgogCi0jOiB2ZXJzaW9uLmM6MTcxMQogbXNnaWQgInR5cGUgIDpoZWxwIGNwLWRlZmF1bHQ8RW50ZXI+IGZvciBpbmZvIG9uIHRoaXMiCiBtc2dzdHIgImVzY3JpYmEgwqs6aGVscCBjcC1kZWZhdWx0PEludHJvPsK7ICAgICAgICBwYXJhIG3DoXMgaW5mb3JtYWNpw7NuIgogCi0jOiB2ZXJzaW9uLmM6MTcyNgogbXNnaWQgIm1lbnUgIEhlbHAtPk9ycGhhbnMgICAgICAgICAgIGZvciBpbmZvcm1hdGlvbiAgICAiCiBtc2dzdHIgIm1lbsO6ICBBeXVkYS0+QXl1ZGUgYSBsb3MgbmnDsW9zIGh1w6lyZmFub3MgICAgICBwYXJhIG3DoXMgaW5mb3JtYWNpw7NuICIKIAotIzogdmVyc2lvbi5jOjE3MjgKIG1zZ2lkICJSdW5uaW5nIG1vZGVsZXNzLCB0eXBlZCB0ZXh0IGlzIGluc2VydGVkIgogbXNnc3RyICJFamVjdWNpw7NuIG5vIG1vZGFsLCBlbCB0ZXh0byBlc2NyaXRvIHNlIGluc2VydGEgZGlyZWN0YW1lbnRlIgogCi0jOiB2ZXJzaW9uLmM6MTcyOQogbXNnaWQgIm1lbnUgIEVkaXQtPkdsb2JhbCBTZXR0aW5ncy0+VG9nZ2xlIEluc2VydCBNb2RlICAiCiBtc2dzdHIgIm1lbsO6IEVkaXRhci0+T3BjaW9uZXMgZ2xvYmFsZXMtPkFjdGl2YXIvRGVzYWN0aXZhciBtb2RvIGRlIGluc2VyY2nDs24iCiAKLSM6IHZlcnNpb24uYzoxNzMwCiBtc2dpZCAiICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZm9yIHR3byBtb2RlcyAgICAgICIKIG1zZ3N0ciAiICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHBhcmEgZG9zIG1vZG9zICAgICAiCiAKLSM6IHZlcnNpb24uYzoxNzM0CiBtc2dpZCAibWVudSAgRWRpdC0+R2xvYmFsIFNldHRpbmdzLT5Ub2dnbGUgVmkgQ29tcGF0aWJsZSIKIG1zZ3N0ciAiIgogIm1lbsO6IEVkaXRhci0+T3BjaW9uZXMgZ2xvYmFsZXMtPkFjdGl2YXIvRGVzYWN0aXZhciBjb21wYXRpYmlsaWRhZCBjb24gVmkiCiAKLSM6IHZlcnNpb24uYzoxNzM1CiBtc2dpZCAiICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZm9yIFZpbSBkZWZhdWx0cyAgICIKIG1zZ3N0ciAiIgogIiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHBhcmEgbG9zIHZhbG9yZXMgcHJlZGV0ZXJtaW5hZG9zIGRlIFZpbSIKIAotIzogdmVyc2lvbi5jOjE3ODIKIG1zZ2lkICJTcG9uc29yIFZpbSBkZXZlbG9wbWVudCEiCiBtc2dzdHIgIsKhUGF0cm9jaW5lIGVsIGRlc2Fycm9sbG8gZGUgVmltISIKIAotIzogdmVyc2lvbi5jOjE3ODMKIG1zZ2lkICJCZWNvbWUgYSByZWdpc3RlcmVkIFZpbSB1c2VyISIKIG1zZ3N0ciAiwqFDb252acOpcnRhc2UgZW4gdW4gdXN1YXJpbyByZWdpc3RyYWRvIGRlIFZpbSEiCiAKLSM6IHZlcnNpb24uYzoxNzg2CiBtc2dpZCAidHlwZSAgOmhlbHAgc3BvbnNvcjxFbnRlcj4gICAgZm9yIGluZm9ybWF0aW9uICIKIG1zZ3N0ciAiZXNjcmliYSAgwqs6aGVscCBzcG9uc29yPEludHJvPsK7ICAgICBwYXJhIG3DoXMgaW5mb3JtYWNpw7NuICAiCiAKLSM6IHZlcnNpb24uYzoxNzg3CiBtc2dpZCAidHlwZSAgOmhlbHAgcmVnaXN0ZXI8RW50ZXI+ICAgZm9yIGluZm9ybWF0aW9uICIKIG1zZ3N0ciAiZXNjcmliYSDCqzpoZWxwIHJlZ2lzdGVyPEludHJvPsK7ICAgIHBhcmEgbcOhcyBpbmZvcm1hY2nDs24gICIKIAotIzogdmVyc2lvbi5jOjE3ODkKIG1zZ2lkICJtZW51ICBIZWxwLT5TcG9uc29yL1JlZ2lzdGVyICBmb3IgaW5mb3JtYXRpb24gICAgIgogbXNnc3RyICJtZW7DuiAgQXl1ZGEtPkJlbmVmYWN0b3IvUmVnw61zdHJlc2UgIHBhcmEgbcOhcyBpbmZvcm1hY2nDs24iCiAKLSM6IHZlcnNpb24uYzoxNzk5CiBtc2dpZCAiV0FSTklORzogV2luZG93cyA5NS85OC9NRSBkZXRlY3RlZCIKIG1zZ3N0ciAiQURWRVJURU5DSUE6IHNlIGhhIGRldGVjdGFkbyBXaW5kb3dzIDk1Lzk4L01FIgogCi0jOiB2ZXJzaW9uLmM6MTgwMgogbXNnaWQgInR5cGUgIDpoZWxwIHdpbmRvd3M5NTxFbnRlcj4gIGZvciBpbmZvIG9uIHRoaXMiCiBtc2dzdHIgImVzY3JpYmEgwqs6aGVscCB3aW5kb3dzOTU8SW50cm8+wrsgcGFyYSBtw6FzIGluZm9ybWFjacOzbiIKIAotIzogd2luZG93LmM6ODgKIG1zZ2lkICJBbHJlYWR5IG9ubHkgb25lIHdpbmRvdyIKIG1zZ3N0ciAiU29sbyBoYXkgdW5hIHZlbnRhbmEiCiAKLSM6IHdpbmRvdy5jOjIzNwogbXNnaWQgIkU0NDE6IFRoZXJlIGlzIG5vIHByZXZpZXcgd2luZG93IgogbXNnc3RyICJFNDQxOiBObyBoYXkgdW5hIHZlbnRhbmEgZGUgdmlzdGEgcHJldmlhIgogCi0jOiB3aW5kb3cuYzo2NzIKIG1zZ2lkICJFNDQyOiBDYW4ndCBzcGxpdCB0b3BsZWZ0IGFuZCBib3RyaWdodCBhdCB0aGUgc2FtZSB0aW1lIgogbXNnc3RyICJFNDQyOiBObyBzZSBwdWVkZSBkaXZpZGlyIGFycmliYSBpenEuIHkgYWJham8gZGVyLiBhbCBtaXNtbyB0aWVtcG8iCiAKLSM6IHdpbmRvdy5jOjE0ODQKIG1zZ2lkICJFNDQzOiBDYW5ub3Qgcm90YXRlIHdoZW4gYW5vdGhlciB3aW5kb3cgaXMgc3BsaXQiCiBtc2dzdHIgIkU0NDM6IE5vIHNlIHB1ZWRlIHJvdGFyIGN1YW5kbyBvdHJhIHZlbnRhbmEgZXN0w6EgZGl2aWRpZGEiCiAKLSM6IHdpbmRvdy5jOjIxMTMKIG1zZ2lkICJFNDQ0OiBDYW5ub3QgY2xvc2UgbGFzdCB3aW5kb3ciCiBtc2dzdHIgIkU0NDQ6IE5vIHNlIHB1ZWRlIGNlcnJhciBsYSDDumx0aW1hIHZlbnRhbmEiCiAKLSM6IHdpbmRvdy5jOjIxMjAKIG1zZ2lkICJFODEzOiBDYW5ub3QgY2xvc2UgYXV0b2NtZCB3aW5kb3ciCiBtc2dzdHIgIkU4MTM6IE5vIHNlIHB1ZWRlIGNlcnJhciBsYSB2ZW50YW5hIGRlIGF1dG9jbWQiCiAKLSM6IHdpbmRvdy5jOjIxMjUKIG1zZ2lkICJFODE0OiBDYW5ub3QgY2xvc2Ugd2luZG93LCBvbmx5IGF1dG9jbWQgd2luZG93IHdvdWxkIHJlbWFpbiIKIG1zZ3N0ciAiIgogIkU4MTQ6IE5vIHNlIHB1ZG8gY2VycmFyIGxhIMO6bHRpbWEgdmVudGFuYSwgc29sbyBxdWVkYXLDoSAiCiAibGEgdmVudGFuYSBkZSBhdXRvY21kIgogCi0jOiB3aW5kb3cuYzozMTg4CiBtc2dpZCAiRTQ0NTogT3RoZXIgd2luZG93IGNvbnRhaW5zIGNoYW5nZXMiCiBtc2dzdHIgIkU0NDU6IE90cmEgdmVudGFuYSBjb250aWVuZSBjYW1iaW9zIgogCi0jOiB3aW5kb3cuYzo1ODY4CiBtc2dpZCAiRTQ0NjogTm8gZmlsZSBuYW1lIHVuZGVyIGN1cnNvciIKIG1zZ3N0ciAiRTQ0NjogTm8gaGF5IHVuIG5vbWJyZSBkZSBhcmNoaXZvIGJham8gZWwgY3Vyc29yIgogCi0jOiB3aW5kb3cuYzo2MDA1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkU0NDc6IENhbid0IGZpbmQgZmlsZSBcIiVzXCIgaW4gcGF0aCIKIG1zZ3N0ciAiRTQ0NzogTm8gc2UgcHVkbyBlbmNvbnRyYXIgZWwgYXJjaGl2byBcIiVzXCIgZW4gbGEgcnV0YSIKIAotIzogaWZfcGVybC54czo0MjAgZ2xvYmFscy5oOjE0MjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTM3MDogQ291bGQgbm90IGxvYWQgbGlicmFyeSAlcyIKIG1zZ3N0ciAiRTM3MDogTm8gc2UgcHVkbyBjYXJnYXIgbGEgYmlibGlvdGVjYSBkaW7DoW1pY2EgJXMiCiAKLSM6IGlmX3BlcmwueHM6NjcxCiBtc2dpZCAiU29ycnksIHRoaXMgY29tbWFuZCBpcyBkaXNhYmxlZDogdGhlIFBlcmwgbGlicmFyeSBjb3VsZCBub3QgYmUgbG9hZGVkLiIKIG1zZ3N0ciAiRXN0YSBvcmRlbiBlc3TDoSBkZXNhY3RpdmFkYSwgbm8gc2UgcHVkbyBjYXJnYXIgbGEgYmlibGlvdGVjYSBkZSBQZXJsIgogCi0jOiBpZl9wZXJsLnhzOjcyNgogbXNnaWQgIkUyOTk6IFBlcmwgZXZhbHVhdGlvbiBmb3JiaWRkZW4gaW4gc2FuZGJveCB3aXRob3V0IHRoZSBTYWZlIG1vZHVsZSIKIG1zZ3N0ciAiIgogIkUyOTk6IE5vIHNlIHBlcm1pdGUgbGEgZXZhbHVhY2nDs24gZGUgY8OzZGlnbyBQZXJsIGVuIGxhIGNhamEgZGUgIgogImFyZW5hIHNpbiBlbCB1c28gZGVsIG3Ds2R1bG8gXCJTYWZlXCIiCiAKLSM6IEd2aW1FeHQvZ3ZpbWV4dC5jcHA6NTg3CiBtc2dpZCAiRWRpdCB3aXRoICZtdWx0aXBsZSBWaW1zIgogbXNnc3RyICJFZGl0YXIgY29uICZtw7psdGlwbGVzIFZpbXMiCiAKLSM6IEd2aW1FeHQvZ3ZpbWV4dC5jcHA6NTkzCiBtc2dpZCAiRWRpdCB3aXRoIHNpbmdsZSAmVmltIgogbXNnc3RyICJFZGl0YXIgY29uIHVuIHNvbG8gJlZpbSIKIAotIzogR3ZpbUV4dC9ndmltZXh0LmNwcDo2MDIKIG1zZ2lkICJEaWZmIHdpdGggVmltIgogbXNnc3RyICJEaWZmIGNvbiBWaW0iCiAKLSM6IEd2aW1FeHQvZ3ZpbWV4dC5jcHA6NjE1CiBtc2dpZCAiRWRpdCB3aXRoICZWaW0iCiBtc2dzdHIgIkVkaXRhciBjb24gJlZpbSIKIAogIyBOb3cgY29uY2F0ZW5hdGUKLSMuIE5vdyBjb25jYXRlbmF0ZQotIzogR3ZpbUV4dC9ndmltZXh0LmNwcDo2MzcKIG1zZ2lkICJFZGl0IHdpdGggZXhpc3RpbmcgVmltIC0gIgogbXNnc3RyICJFZGl0YXIgY29uIHVuIFZpbSBlbiBlamVjdWNpw7NuIC0iCiAKLSM6IEd2aW1FeHQvZ3ZpbWV4dC5jcHA6NzUyCiBtc2dpZCAiRWRpdHMgdGhlIHNlbGVjdGVkIGZpbGUocykgd2l0aCBWaW0iCiBtc2dzdHIgIkVkaXRhciBlbChsb3MpIGFyY2hpdm9zIHNlbGVjY2lvbmFkby9zIGNvbiBWaW0iCiAKLSM6IEd2aW1FeHQvZ3ZpbWV4dC5jcHA6ODkxIEd2aW1FeHQvZ3ZpbWV4dC5jcHA6OTcyCiBtc2dpZCAiRXJyb3IgY3JlYXRpbmcgcHJvY2VzczogQ2hlY2sgaWYgZ3ZpbSBpcyBpbiB5b3VyIHBhdGghIgogbXNnc3RyICIiCiAiRXJyb3IgYWwgY3JlYXIgZWwgcHJvY2VzbzogwqFBc2Vnw7pyZXNlIGRlIHF1ZSBndmltIGVzdGEgZW4gc3UgcnV0YSBkZSBhY2Nlc28hIgogCi0jOiBHdmltRXh0L2d2aW1leHQuY3BwOjg5MiBHdmltRXh0L2d2aW1leHQuY3BwOjkwNiBHdmltRXh0L2d2aW1leHQuY3BwOjk3MwogbXNnaWQgImd2aW1leHQuZGxsIGVycm9yIgogbXNnc3RyICJlcnJvciBkZSBcImd2aW1leHQuZGxsXCIiCiAKLSM6IEd2aW1FeHQvZ3ZpbWV4dC5jcHA6OTA1CiBtc2dpZCAiUGF0aCBsZW5ndGggdG9vIGxvbmchIgogbXNnc3RyICLCoUxhIHJ1dGEgZGUgYWNjZXNvIGVzIGRlbWFzaWFkbyBsYXJnYSEiCiAKLSM6IGdsb2JhbHMuaDoxMTc0CiBtc2dpZCAiLS1ObyBsaW5lcyBpbiBidWZmZXItLSIKIG1zZ3N0ciAiLS1ObyBoYXkgbMOtbmVhcyBlbiBlbCBiw7pmZXItLSIKIApAQCAtNzY4OCw0NjAgKzYwMDcsMzQ1IEBACiAjICogVGhlIGVycm9yIG1lc3NhZ2VzIHRoYXQgY2FuIGJlIHNoYXJlZCBhcmUgaW5jbHVkZWQgaGVyZS4KICMgKiBFeGNsdWRlZCBhcmUgZXJyb3JzIHRoYXQgYXJlIG9ubHkgdXNlZCBvbmNlIGFuZCBkZWJ1Z2dpbmcgbWVzc2FnZXMuCiAjCi0jLgotIy4gKiBUaGUgZXJyb3IgbWVzc2FnZXMgdGhhdCBjYW4gYmUgc2hhcmVkIGFyZSBpbmNsdWRlZCBoZXJlLgotIy4gKiBFeGNsdWRlZCBhcmUgZXJyb3JzIHRoYXQgYXJlIG9ubHkgdXNlZCBvbmNlIGFuZCBkZWJ1Z2dpbmcgbWVzc2FnZXMuCi0jLgotIzogZ2xvYmFscy5oOjEzNzQKIG1zZ2lkICJFNDcwOiBDb21tYW5kIGFib3J0ZWQiCiBtc2dzdHIgIkU0NzA6IExhIG9yZGVuIHNlIGhhIGludGVycnVtcGlkbyIKIAotIzogZ2xvYmFscy5oOjEzNzUKIG1zZ2lkICJFNDcxOiBBcmd1bWVudCByZXF1aXJlZCIKIG1zZ3N0ciAiRTQ3MTogRXMgbmVjZXNhcmlvIHVuIGFyZ3VtZW50byIKIAotIzogZ2xvYmFscy5oOjEzNzYKIG1zZ2lkICJFMTA6IFxcIHNob3VsZCBiZSBmb2xsb3dlZCBieSAvLCA/IG9yICYiCiBtc2dzdHIgIkUxMDogXFwgZGViZXLDrWEgaXIgc2VndWlkbyBkZSBcIi9cIiwgXCI/XCIgbyBcIiZcIiIKIAotIzogZ2xvYmFscy5oOjEzNzgKIG1zZ2lkICJFMTE6IEludmFsaWQgaW4gY29tbWFuZC1saW5lIHdpbmRvdzsgPENSPiBleGVjdXRlcywgQ1RSTC1DIHF1aXRzIgogbXNnc3RyICIiCiAiRTExOiBJbnbDoWxpZG8gZW4gbGEgdmVudGFuYSBkZSBsYSBsw61uZWEgZGUgw7NyZGVuZXM6IDxDUj4gZWplY3V0YSwgQ1RSTC1DICIKICJjaWVycmEiCiAKLSM6IGdsb2JhbHMuaDoxMzgwCiBtc2dpZCAiRTEyOiBDb21tYW5kIG5vdCBhbGxvd2VkIGZyb20gZXhyYy92aW1yYyBpbiBjdXJyZW50IGRpciBvciB0YWcgc2VhcmNoIgogbXNnc3RyICIiCiAiRTEyOiBPcmRlbiBubyBwZXJtaXRpZGEgZGVzZGUgZXhyYy92aW1yYyBlbiBlbCBkaXJlY3RvcmlvICIKICJlbiB1c28gbyBhbCBidXNjYXIgZXRpcXVldGFzIgogCi0jOiBnbG9iYWxzLmg6MTM4MgogbXNnaWQgIkUxNzE6IE1pc3NpbmcgOmVuZGlmIgogbXNnc3RyICJFMTcxOiBGYWx0YSBcIjplbmRpZlwiIgogCi0jOiBnbG9iYWxzLmg6MTM4MwogbXNnaWQgIkU2MDA6IE1pc3NpbmcgOmVuZHRyeSIKIG1zZ3N0ciAiRTYwMDogRmFsdGEgXCI6ZW5kdHJ5XCIiCiAKLSM6IGdsb2JhbHMuaDoxMzg0CiBtc2dpZCAiRTE3MDogTWlzc2luZyA6ZW5kd2hpbGUiCiBtc2dzdHIgIkUxNzA6IEZhbHRhIFwiOmVuZHdoaWxlXCIiCiAKLSM6IGdsb2JhbHMuaDoxMzg1CiBtc2dpZCAiRTE3MDogTWlzc2luZyA6ZW5kZm9yIgogbXNnc3RyICJFMTcwOiBGYWx0YSBcIjplbmRmb3JcIiIKIAotIzogZ2xvYmFscy5oOjEzODYKIG1zZ2lkICJFNTg4OiA6ZW5kd2hpbGUgd2l0aG91dCA6d2hpbGUiCiBtc2dzdHIgIkU1ODg6IFwiOmVuZHdoaWxlXCIgc2luIFwiOndoaWxlXCIiCiAKLSM6IGdsb2JhbHMuaDoxMzg3CiBtc2dpZCAiRTU4ODogOmVuZGZvciB3aXRob3V0IDpmb3IiCiBtc2dzdHIgIkU1ODg6IFwiOmVuZGZvclwiIHNpbiB1biBcIjpmb3JcIiIKIAotIzogZ2xvYmFscy5oOjEzODkKIG1zZ2lkICJFMTM6IEZpbGUgZXhpc3RzIChhZGQgISB0byBvdmVycmlkZSkiCiBtc2dzdHIgIkUxMzogRWwgYXJjaGl2byB5YSBleGlzdGUgKHVzZSBcIiFcIiBwYXJhIHNvYnJlZXNjcmliaXIpIgogCi0jOiBnbG9iYWxzLmg6MTM5MAogbXNnaWQgIkU0NzI6IENvbW1hbmQgZmFpbGVkIgogbXNnc3RyICJFNDcyOiBMYSBvcmRlbiBmYWxsw7MiCiAKLSM6IGdsb2JhbHMuaDoxMzkyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkUyMzQ6IFVua25vd24gZm9udHNldDogJXMiCiBtc2dzdHIgIkUyMzQ6IENvbmp1bnRvIGRlIHRpcG9zIGRlIGxldHJhIGRlIGltcHJlc2nDs24gZGVzY29ub2NpZG86ICVzIgogCi0jOiBnbG9iYWxzLmg6MTM5NgogIywgYy1mb3JtYXQKIG1zZ2lkICJFMjM1OiBVbmtub3duIGZvbnQ6ICVzIgogbXNnc3RyICJFMjM1OiBUaXBvIGRlIGxldHJhIGRlIGltcHJlc2nDs24gZGVzY29ub2NpZGE6ICVzIgogCi0jOiBnbG9iYWxzLmg6MTM5OQogIywgYy1mb3JtYXQKIG1zZ2lkICJFMjM2OiBGb250IFwiJXNcIiBpcyBub3QgZml4ZWQtd2lkdGgiCiBtc2dzdHIgIkUyMzY6IEVsIHRpcG8gZGUgbGV0cmEgZGUgaW1wcmVzacOzbiBcIiVzXCIgbm8gZXMgZGUgYW5jaG8gZmlqbyIKIAotIzogZ2xvYmFscy5oOjE0MDEKIG1zZ2lkICJFNDczOiBJbnRlcm5hbCBlcnJvciIKIG1zZ3N0ciAiRTQ3MzogRXJyb3IgaW50ZXJubyIKIAotIzogZ2xvYmFscy5oOjE0MDIKIG1zZ2lkICJJbnRlcnJ1cHRlZCIKIG1zZ3N0ciAiSW50ZXJydW1waWRvIgogCi0jOiBnbG9iYWxzLmg6MTQwMwogbXNnaWQgIkUxNDogSW52YWxpZCBhZGRyZXNzIgogbXNnc3RyICJFMTQ6IExhIGRpcmVjY2nDs24gbm8gZXMgdsOhbGlkYSIKIAotIzogZ2xvYmFscy5oOjE0MDQKIG1zZ2lkICJFNDc0OiBJbnZhbGlkIGFyZ3VtZW50IgogbXNnc3RyICJFNDc0OiBFbCBhcmd1bWVudG8gbm8gZXMgdsOhbGlkbyIKIAotIzogZ2xvYmFscy5oOjE0MDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTQ3NTogSW52YWxpZCBhcmd1bWVudDogJXMiCiBtc2dzdHIgIkU0NzU6IEVsIGFyZ3VtZW50byBubyBlcyB2w6FsaWRvOiAlcyIKIAotIzogZ2xvYmFscy5oOjE0MDcKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTE1OiBJbnZhbGlkIGV4cHJlc3Npb246ICVzIgogbXNnc3RyICJFMTU6IExhIGV4cHJlc2nDs24gbm8gZXMgdsOhbGlkYTogJXMiCiAKLSM6IGdsb2JhbHMuaDoxNDA5CiBtc2dpZCAiRTE2OiBJbnZhbGlkIHJhbmdlIgogbXNnc3RyICJFMTY6IEVsIHJhbmdvIG5vIGVzIHbDoWxpZG8iCiAKLSM6IGdsb2JhbHMuaDoxNDEwCiBtc2dpZCAiRTQ3NjogSW52YWxpZCBjb21tYW5kIgogbXNnc3RyICJFNDc2OiBMYSBvcmRlbiBubyBlcyB2w6FsaWRhIgogCi0jOiBnbG9iYWxzLmg6MTQxMgogIywgYy1mb3JtYXQKIG1zZ2lkICJFMTc6IFwiJXNcIiBpcyBhIGRpcmVjdG9yeSIKIG1zZ3N0ciAiRTE3OiBcIiVzXCIgZXMgdW4gZGlyZWN0b3JpbyIKIAotIzogZ2xvYmFscy5oOjE0MTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTM2NDogTGlicmFyeSBjYWxsIGZhaWxlZCBmb3IgXCIlcygpXCIiCiBtc2dzdHIgIkUzNjQ6IEZhbGzDsyBsYSBsbGFtYWRhIGEgbGEgYmlibGlvdGVjYSBwYXJhIFwiJXMoKVwiIgogCi0jOiBnbG9iYWxzLmg6MTQyMQogIywgYy1mb3JtYXQKIG1zZ2lkICJFNDQ4OiBDb3VsZCBub3QgbG9hZCBsaWJyYXJ5IGZ1bmN0aW9uICVzIgogbXNnc3RyICJFNDQ4OiBObyBwdWRlIGNhcmdhciBsYSBiaWJsaW90ZWNhIGRlIGZ1bmNpb25lcyAlcyIKIAotIzogZ2xvYmFscy5oOjE0MjMKIG1zZ2lkICJFMTk6IE1hcmsgaGFzIGludmFsaWQgbGluZSBudW1iZXIiCiBtc2dzdHIgIkUxOTogRWwgbsO6bWVybyBkZSBsw61uZWEgZGUgbGEgbWFyY2Egbm8gZXMgdsOhbGlkbyIKIAotIzogZ2xvYmFscy5oOjE0MjQKIG1zZ2lkICJFMjA6IE1hcmsgbm90IHNldCIKIG1zZ3N0ciAiRTIwOiBObyBzZSBoYSBjb2xvY2FkbyB1bmEgbWFyY2EiCiAKLSM6IGdsb2JhbHMuaDoxNDI1CiBtc2dpZCAiRTIxOiBDYW5ub3QgbWFrZSBjaGFuZ2VzLCAnbW9kaWZpYWJsZScgaXMgb2ZmIgogbXNnc3RyICJFMjE6IE5vIHNlIHB1ZG8gbW9kaWZpY2FyLCAnbW9kaWZpYWJsZScgZXN0w6EgZGVzYWN0aXZhZG8iCiAKLSM6IGdsb2JhbHMuaDoxNDI2CiBtc2dpZCAiRTIyOiBTY3JpcHRzIG5lc3RlZCB0b28gZGVlcCIKIG1zZ3N0ciAiRTIyOiBEZW1hc2lhZG9zIGFyY2hpdm9zIGRlIMOzcmRlbmVzIGFuaWRhZG9zIgogCi0jOiBnbG9iYWxzLmg6MTQyNwogbXNnaWQgIkUyMzogTm8gYWx0ZXJuYXRlIGZpbGUiCiBtc2dzdHIgIkUyMzogTm8gaGF5IHVuIGFyY2hpdm8gYWx0ZXJubyIKIAotIzogZ2xvYmFscy5oOjE0MjgKIG1zZ2lkICJFMjQ6IE5vIHN1Y2ggYWJicmV2aWF0aW9uIgogbXNnc3RyICJFMjQ6IE5vIGV4aXN0ZSBlc2EgYWJyZXZpYXR1cmEiCiAKLSM6IGdsb2JhbHMuaDoxNDI5CiBtc2dpZCAiRTQ3NzogTm8gISBhbGxvd2VkIgogbXNnc3RyICJFNDc3OiBcIiFcIiBubyBlc3TDoSBwZXJtaXRpZG8iCiAKLSM6IGdsb2JhbHMuaDoxNDMxCiBtc2dpZCAiRTI1OiBHVUkgY2Fubm90IGJlIHVzZWQ6IE5vdCBlbmFibGVkIGF0IGNvbXBpbGUgdGltZSIKIG1zZ3N0ciAiIgogIkUyNTogTm8gc2UgcHVlZGUgdXNhciBsYSBpbnRlcmZheiBncsOhZmljYSBkZSB1c3VhcmlvOiBObyBzZSBhY3RpdsOzIGFsICIKICJjb21waWxhciIKIAotIzogZ2xvYmFscy5oOjE0MzQKIG1zZ2lkICJFMjY6IEhlYnJldyBjYW5ub3QgYmUgdXNlZDogTm90IGVuYWJsZWQgYXQgY29tcGlsZSB0aW1lXG4iCiBtc2dzdHIgIkUyNjogTm8gc2UgcHVkbyB1c2FyIGVsIGhlYnJlbzogbm8gc2UgYWN0aXbDsyBhbCBjb21waWxhclxuIgogCi0jOiBnbG9iYWxzLmg6MTQzNwogbXNnaWQgIkUyNzogRmFyc2kgY2Fubm90IGJlIHVzZWQ6IE5vdCBlbmFibGVkIGF0IGNvbXBpbGUgdGltZVxuIgogbXNnc3RyICJFMjc6IE5vIHNlIHB1ZG8gdXNhciBlbCBwZXJzYSAoZmFyc2kpOiBubyBzZSBhY3RpdsOzIGFsIGNvbXBpbGFyXG4iCiAKLSM6IGdsb2JhbHMuaDoxNDQwCiBtc2dpZCAiRTgwMDogQXJhYmljIGNhbm5vdCBiZSB1c2VkOiBOb3QgZW5hYmxlZCBhdCBjb21waWxlIHRpbWVcbiIKIG1zZ3N0ciAiRTgwMDogTm8gc2UgcHVkbyB1c2FyIGVsIMOhcmFiZTogbm8gc2UgYWN0aXbDsyBhbCBjb21waWxhclxuIgogCi0jOiBnbG9iYWxzLmg6MTQ0MwogIywgYy1mb3JtYXQKIG1zZ2lkICJFMjg6IE5vIHN1Y2ggaGlnaGxpZ2h0IGdyb3VwIG5hbWU6ICVzIgogbXNnc3RyICJFMjg6IE5vIGV4aXN0ZSB1biBncnVwbyBkZSByZXNhbHRhZG8gZGUgbm9tYnJlOiAlcyIKIAotIzogZ2xvYmFscy5oOjE0NDUKIG1zZ2lkICJFMjk6IE5vIGluc2VydGVkIHRleHQgeWV0IgogbXNnc3RyICJFMjk6IEHDum4gbm8gaGEgaW5zZXJ0YWRvIHRleHRvIgogCi0jOiBnbG9iYWxzLmg6MTQ0NgogbXNnaWQgIkUzMDogTm8gcHJldmlvdXMgY29tbWFuZCBsaW5lIgogbXNnc3RyICJFMzA6IE5vIGhheSB1bmEgbMOtbmVhIGRlIMOzcmRlbmVzIHByZXZpYSIKIAotIzogZ2xvYmFscy5oOjE0NDcKIG1zZ2lkICJFMzE6IE5vIHN1Y2ggbWFwcGluZyIKIG1zZ3N0ciAiRTMxOiBObyBleGlzdGUgdGFsIGFzb2NpYWNpw7NuIgogCi0jOiBnbG9iYWxzLmg6MTQ0OAogbXNnaWQgIkU0Nzk6IE5vIG1hdGNoIgogbXNnc3RyICJFNDc5OiBObyBoYXkgY29pbmNpZGVuY2lhIgogCi0jOiBnbG9iYWxzLmg6MTQ0OQogIywgYy1mb3JtYXQKIG1zZ2lkICJFNDgwOiBObyBtYXRjaDogJXMiCiBtc2dzdHIgIkU0ODA6IE5vIGNvaW5jaWRlOiAlcyIKIAotIzogZ2xvYmFscy5oOjE0NTAKIG1zZ2lkICJFMzI6IE5vIGZpbGUgbmFtZSIKIG1zZ3N0ciAiRTMyOiBObyBoYXkgdW4gbm9tYnJlIGRlIGFyY2hpdm8iCiAKLSM6IGdsb2JhbHMuaDoxNDUxCiBtc2dpZCAiRTMzOiBObyBwcmV2aW91cyBzdWJzdGl0dXRlIHJlZ3VsYXIgZXhwcmVzc2lvbiIKIG1zZ3N0ciAiRTMzOiBObyBleGlzdGUgdW5hIGV4cHJlc2nDs24gcmVndWxhciBkZSBzdXN0aXR1Y2nDs24gcHJldmlhIgogCi0jOiBnbG9iYWxzLmg6MTQ1MgogbXNnaWQgIkUzNDogTm8gcHJldmlvdXMgY29tbWFuZCIKIG1zZ3N0ciAiRTM0OiBObyBleGlzdGUgdW5hIG9yZGVuIHByZXZpYSIKIAotIzogZ2xvYmFscy5oOjE0NTMKIG1zZ2lkICJFMzU6IE5vIHByZXZpb3VzIHJlZ3VsYXIgZXhwcmVzc2lvbiIKIG1zZ3N0ciAiRTM1OiBObyBleGlzdGUgdW5hIGV4cHJlc2nDs24gcmVndWxhciBwcmV2aWEiCiAKLSM6IGdsb2JhbHMuaDoxNDU0CiBtc2dpZCAiRTQ4MTogTm8gcmFuZ2UgYWxsb3dlZCIKIG1zZ3N0ciAiRTQ4MTogRWwgcmFuZ28gbm8gZXN0w6EgcGVybWl0aWRvIgogCi0jOiBnbG9iYWxzLmg6MTQ1NgogbXNnaWQgIkUzNjogTm90IGVub3VnaCByb29tIgogbXNnc3RyICJFMzY6IE5vIGhheSBlc3BhY2lvIHN1ZmljaWVudGUiCiAKLSM6IGdsb2JhbHMuaDoxNDU5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkUyNDc6IG5vIHJlZ2lzdGVyZWQgc2VydmVyIG5hbWVkIFwiJXNcIiIKIG1zZ3N0ciAiRTI0NzogRWwgc2Vydmlkb3IgbGxhbWFkbyBcIiVzXCIgbm8gZXN0w6EgcmVnaXN0cmFkbyIKIAotIzogZ2xvYmFscy5oOjE0NjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiRTQ4MjogQ2FuJ3QgY3JlYXRlIGZpbGUgJXMiCiBtc2dzdHIgIkU0ODI6IE5vIHNlIHB1ZG8gY3JlYXIgZWwgYXJjaGl2byBcIiVzXCIiCiAKLSM6IGdsb2JhbHMuaDoxNDYyCiBtc2dpZCAiRTQ4MzogQ2FuJ3QgZ2V0IHRlbXAgZmlsZSBuYW1lIgogbXNnc3RyICJFNDgzOiBObyBzZSBwdWRvIG9idGVuZXIgZWwgbm9tYnJlIGRlbCBhcmNoaXZvIHRlbXBvcmFsIgogCi0jOiBnbG9iYWxzLmg6MTQ2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJFNDg0OiBDYW4ndCBvcGVuIGZpbGUgJXMiCiBtc2dzdHIgIkU0ODQ6IE5vIHNlIHB1ZG8gYWJyaXIgZWwgYXJjaGl2byBcIiVzXCIiCiAKLSM6IGdsb2JhbHMuaDoxNDY0CiAjLCBjLWZvcm1hdAogbXNnaWQgIkU0ODU6IENhbid0IHJlYWQgZmlsZSAlcyIKIG1zZ3N0ciAiRTQ4NTogTm8gc2UgcHVkbyBsZWVyIGVsIGFyY2hpdm8gXCIlc1wiIgogCi0jOiBnbG9iYWxzLmg6MTQ2NQogbXNnaWQgIkUzNzogTm8gd3JpdGUgc2luY2UgbGFzdCBjaGFuZ2UgKGFkZCAhIHRvIG92ZXJyaWRlKSIKIG1zZ3N0ciAiIgogIkUzNzogTm8gZ3VhcmTDsyBlbCBhcmNoaXZvIGRlc2RlIGVsIMO6bHRpbW8gY2FtYmlvIChhw7FhZGEgXCIhXCIgcGFyYSBmb3J6YXIpIgogCi0jOiBnbG9iYWxzLmg6MTQ2NgogbXNnaWQgIkUzODogTnVsbCBhcmd1bWVudCIKIG1zZ3N0ciAiRTM4OiBBcmd1bWVudG8gbnVsbyIKIAotIzogZ2xvYmFscy5oOjE0NjgKIG1zZ2lkICJFMzk6IE51bWJlciBleHBlY3RlZCIKIG1zZ3N0ciAiRTM5OiBTZSBlc3BlcmFiYSB1biBuw7ptZXJvIgogCi0jOiBnbG9iYWxzLmg6MTQ3MQogIywgYy1mb3JtYXQKIG1zZ2lkICJFNDA6IENhbid0IG9wZW4gZXJyb3JmaWxlICVzIgogbXNnc3RyICJFNDA6IE5vIHNlIHB1ZG8gYWJyaXIgZWwgYXJjaGl2byBkZSBlcnJvcmVzIFwiJXNcIiIKIAotIzogZ2xvYmFscy5oOjE0NzQKIG1zZ2lkICJFMjMzOiBjYW5ub3Qgb3BlbiBkaXNwbGF5IgogbXNnc3RyICJFMjMzOiBObyBzZSBwdWRvIGFicmlyIGxhIHBhbnRhbGxhIgogCi0jOiBnbG9iYWxzLmg6MTQ3NgogbXNnaWQgIkU0MTogT3V0IG9mIG1lbW9yeSEiCiBtc2dzdHIgIkU0MTogwqFNZW1vcmlhIGFnb3RhZGEhIgogCi0jOiBnbG9iYWxzLmg6MTQ3OAogbXNnaWQgIlBhdHRlcm4gbm90IGZvdW5kIgogbXNnc3RyICJObyBzZSBlbmNvbnRyw7MgZWwgcGF0csOzbiBkZSBiw7pzcXVlZGEiCiAKLSM6IGdsb2JhbHMuaDoxNDgwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkU0ODY6IFBhdHRlcm4gbm90IGZvdW5kOiAlcyIKIG1zZ3N0ciAiRTQ4NjogTm8gc2UgZW5jb250csOzIGVsIHBhdHLDs24gZGUgYsO6c3F1ZWRhOiAlcyIKIAotIzogZ2xvYmFscy5oOjE0ODEKIG1zZ2lkICJFNDg3OiBBcmd1bWVudCBtdXN0IGJlIHBvc2l0aXZlIgogbXNnc3RyICJFNDg3OiBFbCBhcmd1bWVudG8gZGViZSBzZXIgcG9zaXRpdm8iCiAKLSM6IGdsb2JhbHMuaDoxNDgzCiBtc2dpZCAiRTQ1OTogQ2Fubm90IGdvIGJhY2sgdG8gcHJldmlvdXMgZGlyZWN0b3J5IgogbXNnc3RyICJFNDU5OiBObyBzZSBwdWRvIHJlZ3Jlc2FyIGFsIGRpcmVjdG9yaW8gcHJldmlvIgogCi0jOiBnbG9iYWxzLmg6MTQ4NwogbXNnaWQgIkU0MjogTm8gRXJyb3JzIgogbXNnc3RyICJFNDI6IE5vIGhheSBlcnJvcmVzIgogCi0jOiBnbG9iYWxzLmg6MTQ4OAogbXNnaWQgIkU3NzY6IE5vIGxvY2F0aW9uIGxpc3QiCiBtc2dzdHIgIkU3NzY6IE5vIGhheSB1bmEgbGlzdGEgZGUgcG9zaWNpb25lcyIKIAotIzogZ2xvYmFscy5oOjE0OTAKIG1zZ2lkICJFNDM6IERhbWFnZWQgbWF0Y2ggc3RyaW5nIgogbXNnc3RyICJFNDM6IENhZGVuYSBkZSBjb2luY2lkZW5jaWEgZGHDsWFkYSIKIAotIzogZ2xvYmFscy5oOjE0OTEKIG1zZ2lkICJFNDQ6IENvcnJ1cHRlZCByZWdleHAgcHJvZ3JhbSIKIG1zZ3N0ciAiRTQ0OiBFbCBwcm9ncmFtYSBcInJlZ2V4cFwiIGVzdMOhIGNvcnJ1cHRvIgogCi0jOiBnbG9iYWxzLmg6MTQ5MgogbXNnaWQgIkU0NTogJ3JlYWRvbmx5JyBvcHRpb24gaXMgc2V0IChhZGQgISB0byBvdmVycmlkZSkiCiBtc2dzdHIgIkU0NTogTGEgb3BjacOzbiAncmVhZG9ubHknIGVzdMOhIGFjdGl2YWRhIChhw7FhZGEgXCIhXCIgcGFyYSBmb3J6YXIpIgogCi0jOiBnbG9iYWxzLmg6MTQ5NAogIywgYy1mb3JtYXQKIG1zZ2lkICJFNDY6IENhbm5vdCBjaGFuZ2UgcmVhZC1vbmx5IHZhcmlhYmxlIFwiJXNcIiIKIG1zZ3N0ciAiRTQ2OiBObyBwdWVkZSBjYW1iaWFyIGxhIHZhcmlhYmxlIGRlIHNvbG8gbGVjdHVyYSBcIiVzXCIiCiAKLSM6IGdsb2JhbHMuaDoxNDk1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkU3OTQ6IENhbm5vdCBzZXQgdmFyaWFibGUgaW4gdGhlIHNhbmRib3g6IFwiJXNcIiIKIG1zZ3N0ciAiRTc5NDogTm8gc2UgcHVlZGUgZGVmaW5pciBsYSB2YXJpYWJsZSBlbiBlbCBcInNhbmRib3hcIjogXCIlc1wiIgogCi0jOiBnbG9iYWxzLmg6MTQ5OAogbXNnaWQgIkU0NzogRXJyb3Igd2hpbGUgcmVhZGluZyBlcnJvcmZpbGUiCiBtc2dzdHIgIkU0NzogRXJyb3IgYWwgbGVlciBlbCBhcmNoaXZvIGRlIGVycm9yZXMiCiAKLSM6IGdsb2JhbHMuaDoxNTAxCiBtc2dpZCAiRTQ4OiBOb3QgYWxsb3dlZCBpbiBzYW5kYm94IgogbXNnc3RyICJFNDg6IE5vIHNlIHBlcm1pdGUgZW4gZWwgYW1iaWVudGUgcHJvdGVnaWRvIgogCi0jOiBnbG9iYWxzLmg6MTUwMwogbXNnaWQgIkU1MjM6IE5vdCBhbGxvd2VkIGhlcmUiCiBtc2dzdHIgIkU1MjM6IE5vIHNlIHBlcm1pdGUgYXF1w60iCiAKLSM6IGdsb2JhbHMuaDoxNTA2CiBtc2dpZCAiRTM1OTogU2NyZWVuIG1vZGUgc2V0dGluZyBub3Qgc3VwcG9ydGVkIgogbXNnc3RyICJFMzU5OiBMYSBjb25maWd1cmFjacOzbiBkZSBsYSBwYW50YWxsYSBubyBlcyB2w6FsaWRhIgogCi0jOiBnbG9iYWxzLmg6MTUwOAogbXNnaWQgIkU0OTogSW52YWxpZCBzY3JvbGwgc2l6ZSIKIG1zZ3N0ciAiRTQ5OiBMYSBsb25naXR1ZCBkZSBkZXNwbGF6YW1pZW50byBubyBlcyB2w6FsaWRhIgogCi0jOiBnbG9iYWxzLmg6MTUwOQogbXNnaWQgIkU5MTogJ3NoZWxsJyBvcHRpb24gaXMgZW1wdHkiCiBtc2dzdHIgIkU5MTogTGEgb3BjacOzbiAnc2hlbGwnIChpbnTDqXJwcmV0ZSBkZSDDs3JkZW5lcykgZXN0w6EgdmFjw61hIgogCi0jOiBnbG9iYWxzLmg6MTUxMQogbXNnaWQgIkUyNTU6IENvdWxkbid0IHJlYWQgaW4gc2lnbiBkYXRhISIKIG1zZ3N0ciAiRTI1NTogwqFObyBzZSBwdWRvIGNhcmdhciBsb3Mgc2lnbm9zISIKIAotIzogZ2xvYmFscy5oOjE1MTMKIG1zZ2lkICJFNzI6IENsb3NlIGVycm9yIG9uIHN3YXAgZmlsZSIKIG1zZ3N0ciAiRTcyOiBFcnJvciBkZSBjaWVycmUgZW4gZWwgYXJjaGl2byBkZSBpbnRlcmNhbWJpbyIKIAotIzogZ2xvYmFscy5oOjE1MTQKIG1zZ2lkICJFNzM6IHRhZyBzdGFjayBlbXB0eSIKIG1zZ3N0ciAiRTczOiBMYSBwaWxhIGRlIGV0aXF1ZXRhcyAoJ3RhZ3N0YWNrJykgZXN0w6EgdmFjw61hIgogCi0jOiBnbG9iYWxzLmg6MTUxNQogbXNnaWQgIkU3NDogQ29tbWFuZCB0b28gY29tcGxleCIKIG1zZ3N0ciAiRTc0OiBMYSBvcmRlbiBlcyBkZW1hc2lhZG8gY29tcGxlamEiCiAKLSM6IGdsb2JhbHMuaDoxNTE2CiBtc2dpZCAiRTc1OiBOYW1lIHRvbyBsb25nIgogbXNnc3RyICJFNzU6IEVsIG5vbWJyZSBlcyBkZW1hc2lhZG8gbGFyZ28iCiAKLSM6IGdsb2JhbHMuaDoxNTE3CiBtc2dpZCAiRTc2OiBUb28gbWFueSBbIgogbXNnc3RyICJFNzY6IEhheSBkZW1hc2lhZG9zIFsiCiAKLSM6IGdsb2JhbHMuaDoxNTE4CiBtc2dpZCAiRTc3OiBUb28gbWFueSBmaWxlIG5hbWVzIgogbXNnc3RyICJFNzc6IEhheSBkZW1hc2lhZG9zIG5vbWJyZXMgZGUgYXJjaGl2b3MiCiAKLSM6IGdsb2JhbHMuaDoxNTE5CiBtc2dpZCAiRTQ4ODogVHJhaWxpbmcgY2hhcmFjdGVycyIKIG1zZ3N0ciAiRTQ4ODogQ2FyYWN0ZXJlcyBlbiBleGNlc28gYWwgZmluYWwgZGUgbGEgbMOtbmVhIgogCi0jOiBnbG9iYWxzLmg6MTUyMAogbXNnaWQgIkU3ODogVW5rbm93biBtYXJrIgogbXNnc3RyICJFNzg6IE1hcmNhIGRlc2Nvbm9jaWRhIgogCi0jOiBnbG9iYWxzLmg6MTUyMQogbXNnaWQgIkU3OTogQ2Fubm90IGV4cGFuZCB3aWxkY2FyZHMiCiBtc2dzdHIgIkU3OTogTm8gc2UgcHVkbyBleHBhbmRpciBsb3MgY29tb2RpbmVzIgogCi0jOiBnbG9iYWxzLmg6MTUyMwogbXNnaWQgIkU1OTE6ICd3aW5oZWlnaHQnIGNhbm5vdCBiZSBzbWFsbGVyIHRoYW4gJ3dpbm1pbmhlaWdodCciCiBtc2dzdHIgIkU1OTE6IFwid2luaGVpZ2h0XCIgbm8gcHVlZGUgc2VyIG3DoXMgcGVxdWXDsW8gcXVlIFwid2lubWluaGVpZ2h0XCIiCiAKLSM6IGdsb2JhbHMuaDoxNTI1CiBtc2dpZCAiRTU5MjogJ3dpbndpZHRoJyBjYW5ub3QgYmUgc21hbGxlciB0aGFuICd3aW5taW53aWR0aCciCiBtc2dzdHIgIkU1OTI6IFwid2lud2lkdGhcIiBubyBwdWVkZSBzZXIgbcOhcyBwZXF1ZcOxbyBxdWUgXCJ3aW5taW53aWR0aFwiIgogCi0jOiBnbG9iYWxzLmg6MTUyOAogbXNnaWQgIkU4MDogRXJyb3Igd2hpbGUgd3JpdGluZyIKIG1zZ3N0ciAiRTgwOiBFcnJvciBhbCBlc2NyaWJpciBlbCBhcmNoaXZvIgogCi0jOiBnbG9iYWxzLmg6MTUyOQogbXNnaWQgIlplcm8gY291bnQiCiBtc2dzdHIgIkVsIHJlY3VlbnRvIGVzIGNlcm8iCiAKLSM6IGdsb2JhbHMuaDoxNTMxCiBtc2dpZCAiRTgxOiBVc2luZyA8U0lEPiBub3QgaW4gYSBzY3JpcHQgY29udGV4dCIKIG1zZ3N0ciAiRTgxOiBVc2FuZG8gPFNJRD4gZW4gdW4gY29udGV4dG8gcXVlIG5vIGVzIGRlIGFyY2hpdm8gZGUgw7NyZGVuZXMiCiAKLSM6IGdsb2JhbHMuaDoxNTM0CiBtc2dpZCAiRTQ0OTogSW52YWxpZCBleHByZXNzaW9uIHJlY2VpdmVkIgogbXNnc3RyICJFNDQ5OiBTZSByZWNpYmnDsyB1bmEgZXhwcmVzacOzbiBpbnbDoWxpZGEiCiAKLSM6IGdsb2JhbHMuaDoxNTM3CiBtc2dpZCAiRTQ2MzogUmVnaW9uIGlzIGd1YXJkZWQsIGNhbm5vdCBtb2RpZnkiCiBtc2dzdHIgIkU0NjM6IExhIHJlZ2nDs24gZXN0w6EgcHJvdGVnaWRhLCBubyBzZSBwdWVkZSBtb2RpZmljYXIiCiAKLSM6IGdsb2JhbHMuaDoxNTM4CiBtc2dpZCAiRTc0NDogTmV0QmVhbnMgZG9lcyBub3QgYWxsb3cgY2hhbmdlcyBpbiByZWFkLW9ubHkgZmlsZXMiCiBtc2dzdHIgIkU3NDQ6IE5ldEJlYW5zIG5vIHBlcm1pdGUgY2FtYmlvcyBhIGFyY2hpdm9zIGRlIHPDs2xvIGxlY3R1cmEiCiAKLSM6IGdsb2JhbHMuaDoxNTQwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkU2ODU6IEludGVybmFsIGVycm9yOiAlcyIKIG1zZ3N0ciAiRTY4NTogRXJyb3IgaW50ZXJubzogJXMiCiAKLSM6IGdsb2JhbHMuaDoxNTQxCiBtc2dpZCAiRTM2MzogcGF0dGVybiB1c2VzIG1vcmUgbWVtb3J5IHRoYW4gJ21heG1lbXBhdHRlcm4nIgogbXNnc3RyICJFMzYzOiBFbCBwYXRyw7NuIHVzYSBtw6FzIG1lbW9yaWEgcXVlICdtYXhtZW1wYXR0ZXJuJyIKIAotIzogZ2xvYmFscy5oOjE1NDIKIG1zZ2lkICJFNzQ5OiBlbXB0eSBidWZmZXIiCiBtc2dzdHIgIkU3NDk6IELDumZlciB2YWPDrW8iCiAKLSM6IGdsb2JhbHMuaDoxNTQ1CiBtc2dpZCAiRTY4MjogSW52YWxpZCBzZWFyY2ggcGF0dGVybiBvciBkZWxpbWl0ZXIiCiBtc2dzdHIgIkU2ODI6IFBhdHLDs24gZGUgYsO6c3F1ZWRhIG8gZGVsaW1pdGFkb3Igbm8gdsOhbGlkbyIKIAogIyBPdmVyd3JpdGluZyBhIGZpbGUgdGhhdCBpcyBsb2FkZWQgaW4gYW5vdGhlciBidWZmZXIgaXMgbm90IGEKICMgKiBnb29kIGlkZWEuCi0jOiBnbG9iYWxzLmg6MTU0NwogbXNnaWQgIkUxMzk6IEZpbGUgaXMgbG9hZGVkIGluIGFub3RoZXIgYnVmZmVyIgogbXNnc3RyICJFMTM5OiBFbCBhcmNoaXZvIHlhIHNlIGhhIGNhcmdhZG8gZW4gb3RybyBiw7pmZXIiCiAKLSM6IGdsb2JhbHMuaDoxNTUwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkU3NjQ6IE9wdGlvbiAnJXMnIGlzIG5vdCBzZXQiCiBtc2dzdHIgIkU3NjQ6IE5vIHNlIGhhIGRlZmluaWRvIGxhIG9wY2nDs24gJyVzJyIKIAotIzogZ2xvYmFscy5oOjE1NTcKIG1zZ2lkICJzZWFyY2ggaGl0IFRPUCwgY29udGludWluZyBhdCBCT1RUT00iCiBtc2dzdHIgIkxhIGLDunNxdWVkYSBoYSBsbGVnYWRvIGFsIFBSSU5DSVBJTywgY29udGludWFuZG8gZGVzZGUgZWwgRklOQUwiCiAKLSM6IGdsb2JhbHMuaDoxNTU4CiBtc2dpZCAic2VhcmNoIGhpdCBCT1RUT00sIGNvbnRpbnVpbmcgYXQgVE9QIgogbXNnc3RyICJMYSBiw7pzcXVlZGEgaGEgbGxlZ2FkbyBhbCBGSU5BTCwgY29udGludWFuZG8gZGVzZGUgZWwgUFJJTkNJUElPIgogCi0jfiBtc2dpZCAiW05MIGZvdW5kXSIKLSN+IG1zZ3N0ciAiW05MIGVuY29udHJhZG9dIgogCi0jfiBtc2dpZCAiRTU2OTogbWF4aW11bSBudW1iZXIgb2YgY3Njb3BlIGNvbm5lY3Rpb25zIHJlYWNoZWQiCi0jfiBtc2dzdHIgIkU1Njk6IFNlIGhhIGFsY2FuemFkbyBlbCBuw7ptZXJvIG3DoXhpbW8gZGUgY29uZXhpb25lcyBjb24gXCJjc2NvcGVcIiIKLQotI34gbXNnaWQgIi1WW05dXHRcdFZlcmJvc2UgbGV2ZWwiCi0jfiBtc2dzdHIgIi1WW05dXHRcdE5pdmVsIGRlIHZlcmJvc2lkYWQgKHRyYXphIGRlIGVqZWN1Y2nDs24pIgpkaWZmIC0tZ2l0IGEvc3JjL3BvL2ZpLnBvIGIvc3JjL3BvL2ZpLnBvCmluZGV4IDY4NGM2NzYuLjE2NjQ3MmMgMTAwNjQ0Ci0tLSBhL3NyYy9wby9maS5wbworKysgYi9zcmMvcG8vZmkucG8KQEAgLTI3NzQsOSArMjc3NCw2IEBACiBtc2dpZCAia2V5Ym9hcmQgaW50ZXJydXB0IgogbXNnc3RyICJuw6RwcMOkaW1pc3TDtmtlc2tleXR5cyIKIAotbXNnaWQgInZpbSBlcnJvciIKLW1zZ3N0ciAidmltLXZpcmhlIgotCiBtc2dpZCAiY2Fubm90IGNyZWF0ZSBidWZmZXIvd2luZG93IGNvbW1hbmQ6IG9iamVjdCBpcyBiZWluZyBkZWxldGVkIgogbXNnc3RyICJlaSB2b2kgbHVvZGEgcHVza3VyaS0gdGFpIGlra3VuYWtvbWVudG9hLCBvbGlvIG9uIHBvaXN0dW1hc3NhIgogCkBAIC0zMDkzLDggKzMwOTAsOCBAQAogbXNnaWQgIi14XHRcdFx0RWRpdCBlbmNyeXB0ZWQgZmlsZXMiCiBtc2dzdHIgIi14XHRcdFx0TXVva2thYSBzYWxhdHR1YSB0aWVkb3N0b2EiCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdENvbm5lY3QgdmltIHRvIHRoaXMgcGFydGljdWxhciBYLXNlcnZlciIKLW1zZ3N0ciAiLWRpc3BsYXkgPG7DpHl0dMO2Plx0WWhkaXN0w6QgdmltIHRpZXR0eXluIFgtcGFsdmVsaW1lZW4iCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRDb25uZWN0IFZpbSB0byB0aGlzIHBhcnRpY3VsYXIgWC1zZXJ2ZXIiCittc2dzdHIgIi1kaXNwbGF5IDxuw6R5dHTDtj5cdFloZGlzdMOkIFZpbSB0aWV0dHl5biBYLXBhbHZlbGltZWVuIgogCiBtc2dpZCAiLVhcdFx0XHREbyBub3QgY29ubmVjdCB0byBYIHNlcnZlciIKIG1zZ3N0ciAiLVhcdFx0XHTDhGzDpCB5aGRpc3TDpCBYLXBhbHZlbGltZWVuIgpAQCAtMzE3NywxMCArMzE3NCwxMCBAQAogIlxuIgogIkd2aW1pbiAoQXRoZW5hLXZlcnNpb24pIHR1bnRlbWF0IGFyZ3VtZW50aXQ6XG4iCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biB2aW0gb24gPGRpc3BsYXk+IgotbXNnc3RyICItZGlzcGxheSA8bsOkeXR0w7Y+XHRTdW9yaXRhIHZpbSA8bsOkeXTDtnNzw6Q+IgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIFZpbSBvbiA8ZGlzcGxheT4iCittc2dzdHIgIi1kaXNwbGF5IDxuw6R5dHTDtj5cdFN1b3JpdGEgVmltIDxuw6R5dMO2c3PDpD4iCiAKLW1zZ2lkICItaWNvbmljXHRcdFN0YXJ0IHZpbSBpY29uaWZpZWQiCittc2dpZCAiLWljb25pY1x0XHRTdGFydCBWaW0gaWNvbmlmaWVkIgogbXNnc3RyICItaWNvbmljXHRcdEvDpHlubmlzdMOkIHBpZW5lbm5ldHR5bsOkIgogCiBtc2dpZCAiLWJhY2tncm91bmQgPGNvbG9yPlx0VXNlIDxjb2xvcj4gZm9yIHRoZSBiYWNrZ3JvdW5kIChhbHNvOiAtYmcpIgpAQCAtMzIyOCw4ICszMjI1LDggQEAKICJcbiIKICJHdmltaW4gKEdUSystdmVyc2lvbikgdHVudGVtYXQgYXJndW1lbnRpdDpcbiIKIAotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIHZpbSBvbiA8ZGlzcGxheT4gKGFsc286IC0tZGlzcGxheSkiCi1tc2dzdHIgIi1kaXNwbGF5IDxuw6R5dHTDtj5cdFN1b3JpdGEgdmltIG7DpHl0w7ZsbMOkIDxuw6R5dHTDtj4gKG15w7ZzOiAtLWRpc3BsYXkpIgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIFZpbSBvbiA8ZGlzcGxheT4gKGFsc286IC0tZGlzcGxheSkiCittc2dzdHIgIi1kaXNwbGF5IDxuw6R5dHTDtj5cdFN1b3JpdGEgVmltIG7DpHl0w7ZsbMOkIDxuw6R5dHTDtj4gKG15w7ZzOiAtLWRpc3BsYXkpIgogCiAjIFgtaWtrdW5vaW50aWrDpHJqZXN0ZWxtw6Rzc8OkIHNhbWFuIHNvdmVsbHVrc2VuIHNhbWFuIGx1b2thbiBpa2t1bmF0CiAjIHR1bm5pc3RldGFhbiByb29saXJlc3Vyc3NlaXN0YQpAQCAtNjgyOCw3ICs2ODI1LDcgQEAKIG1zZ3N0ciAibGlzdGFpbmRla3NpIGFydm9hbHVlZW4gdWxrb3B1b2xlbHRhIgogCiAjLCBjLWZvcm1hdAotbXNnaWQgImludGVybmFsIGVycm9yOiBmYWlsZWQgdG8gZ2V0IHZpbSBsaXN0IGl0ZW0gJWQiCittc2dpZCAiaW50ZXJuYWwgZXJyb3I6IGZhaWxlZCB0byBnZXQgVmltIGxpc3QgaXRlbSAlZCIKIG1zZ3N0ciAic2lzw6RpbmVuIHZpcmhlOiBlaSBweXN0eXR0eSBoYWtlYSB2aW1pbiBsaXN0YW4gaW5kZWtzacOkICVkIgogCiBtc2dpZCAic2xpY2Ugc3RlcCBjYW5ub3QgYmUgemVybyIKQEAgLTY4MzksNyArNjgzNiw3IEBACiBtc2dzdHIgInlyaXRldHRpaW4gc2lqb2l0dGFhIHNla3ZlbnNzacOkIGpvbmthIGtva28gb24gZW5lbW3DpG4ga3VpbiAlZCBzbGljZWVuIgogCiAjLCBjLWZvcm1hdAotbXNnaWQgImludGVybmFsIGVycm9yOiBubyB2aW0gbGlzdCBpdGVtICVkIgorbXNnaWQgImludGVybmFsIGVycm9yOiBubyBWaW0gbGlzdCBpdGVtICVkIgogbXNnc3RyICJzaXPDpGluZW4gdmlyaGU6IGVpIHZpbS1saXN0YW4gaW5kZWtzacOkICVkIgogCiBtc2dpZCAiaW50ZXJuYWwgZXJyb3I6IG5vdCBlbm91Z2ggbGlzdCBpdGVtcyIKQEAgLTY5NDksMTkgKzY5NDYsMTkgQEAKIG1zZ2lkICJFODU4OiBFdmFsIGRpZCBub3QgcmV0dXJuIGEgdmFsaWQgcHl0aG9uIG9iamVjdCIKIG1zZ3N0ciAiRTg1ODogRXZhbCBlaSBwYWxhdXR0YW51dCBweXRob24tb2xpb3RhIgogCi1tc2dpZCAiRTg1OTogRmFpbGVkIHRvIGNvbnZlcnQgcmV0dXJuZWQgcHl0aG9uIG9iamVjdCB0byB2aW0gdmFsdWUiCittc2dpZCAiRTg1OTogRmFpbGVkIHRvIGNvbnZlcnQgcmV0dXJuZWQgcHl0aG9uIG9iamVjdCB0byBhIFZpbSB2YWx1ZSIKIG1zZ3N0ciAiRTg1OTogRWkgdm9pdHUga29udmVydG9pZGEgcHl0aG9uLW9saW90YSB2aW0tYXJ2b2tzaSIKIAogIywgYy1mb3JtYXQKLW1zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byB2aW0gZGljdGlvbmFyeSIKK21zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byBhIFZpbSBkaWN0aW9uYXJ5IgogbXNnc3RyICJlaSB2b2l0dSBrb252ZXJ0b2lkYSBvbGlvdGEgJXMgdmltLXNhbmFraXJqYWtzaSIKIAogIywgYy1mb3JtYXQKLW1zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byB2aW0gbGlzdCIKK21zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byBhIFZpbSBsaXN0IgogbXNnc3RyICJlaSB2b2l0dSBrb252ZXJ0b2lkYSB0eXlwaXN0w6QgJXMgdmltLWxpc3Rha3NpIgogCiAjLCBjLWZvcm1hdAotbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIHZpbSBzdHJ1Y3R1cmUiCittc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gYSBWaW0gc3RydWN0dXJlIgogbXNnc3RyICJlaSB2b2kga29udmVydG9pZGEgb2xpb3RhICVzIHZpbS10aWV0b3Jha2VudGVla3NpIgogCiBtc2dpZCAiaW50ZXJuYWwgZXJyb3I6IE5VTEwgcmVmZXJlbmNlIHBhc3NlZCIKZGlmZiAtLWdpdCBhL3NyYy9wby9mci5wbyBiL3NyYy9wby9mci5wbwppbmRleCBlOTAyZjYzLi5iYjY5NDkzIDEwMDY0NAotLS0gYS9zcmMvcG8vZnIucG8KKysrIGIvc3JjL3BvL2ZyLnBvCkBAIC0yNzUxLDkgKzI3NTEsNiBAQAogbXNnaWQgImtleWJvYXJkIGludGVycnVwdCIKIG1zZ3N0ciAiaW50ZXJydXB0aW9uIGNsYXZpZXIiCiAKLW1zZ2lkICJ2aW0gZXJyb3IiCi1tc2dzdHIgImVycmV1ciBWaW0iCi0KIG1zZ2lkICJjYW5ub3QgY3JlYXRlIGJ1ZmZlci93aW5kb3cgY29tbWFuZDogb2JqZWN0IGlzIGJlaW5nIGRlbGV0ZWQiCiBtc2dzdHIgIiIKICJJbXBvc3NpYmxlIGRlIGNy6WVyIGNvbW1hbmRlIGRlIHRhbXBvbi9mZW7qdHJlIDogb2JqZXQgZW4gY291cnMgZCdlZmZhY2VtZW50IgpAQCAtMzI1Myw3ICszMjUwLDcgQEAKIG1zZ2lkICIteFx0XHRcdEVkaXQgZW5jcnlwdGVkIGZpbGVzIgogbXNnc3RyICIteFx0XHRcdMlkaXRlciBkZXMgZmljaGllcnMgY2hpZmZy6XMiCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdENvbm5lY3QgdmltIHRvIHRoaXMgcGFydGljdWxhciBYLXNlcnZlciIKK21zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdENvbm5lY3QgVmltIHRvIHRoaXMgcGFydGljdWxhciBYLXNlcnZlciIKIG1zZ3N0ciAiLWRpc3BsYXkgPGRpc3BsYXk+XHRDb25uZWN0ZXIgVmltIGF1IHNlcnZldXIgWCBzcOljaWZp6SIKIAogbXNnaWQgIi1YXHRcdFx0RG8gbm90IGNvbm5lY3QgdG8gWCBzZXJ2ZXIiCkBAIC0zMzM2LDEwICszMzMzLDEwIEBACiAiXG4iCiAiQXJndW1lbnRzIHJlY29ubnVzIHBhciBndmltICh2ZXJzaW9uIEF0aGVuYSkgOlxuIgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gdmltIG9uIDxkaXNwbGF5PiIKK21zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biBWaW0gb24gPGRpc3BsYXk+IgogbXNnc3RyICItZGlzcGxheSA86WNyYW4+XHRMYW5jZXIgVmltIHN1ciBjZSA8ZGlzcGxheT4iCiAKLW1zZ2lkICItaWNvbmljXHRcdFN0YXJ0IHZpbSBpY29uaWZpZWQiCittc2dpZCAiLWljb25pY1x0XHRTdGFydCBWaW0gaWNvbmlmaWVkIgogbXNnc3RyICItaWNvbmljXHRcdEljb25pZmllciBWaW0gYXUgZOltYXJyYWdlIgogCiBtc2dpZCAiLWJhY2tncm91bmQgPGNvbG9yPlx0VXNlIDxjb2xvcj4gZm9yIHRoZSBiYWNrZ3JvdW5kIChhbHNvOiAtYmcpIgpAQCAtMzM4OSw3ICszMzg2LDcgQEAKICJcbiIKICJBcmd1bWVudHMgcmVjb25udXMgcGFyIGd2aW0gKHZlcnNpb24gR1RLKykgOlxuIgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gdmltIG9uIDxkaXNwbGF5PiAoYWxzbzogLS1kaXNwbGF5KSIKK21zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biBWaW0gb24gPGRpc3BsYXk+IChhbHNvOiAtLWRpc3BsYXkpIgogbXNnc3RyICIiCiAiLWRpc3BsYXkgPGRpc3BsYXk+XHRMYW5jZXIgVmltIHN1ciBjZSA8ZGlzcGxheT5cdCjpZ2FsZW1lbnQgOiAtLWRpc3BsYXkpIgogCkBAIC03NDg5LDcgKzc0ODYsNyBAQAogbXNnc3RyICJpbmRleCBkZSBsaXN0ZSBob3JzIGxpbWl0ZXMiCiAKICMsIGMtZm9ybWF0Ci1tc2dpZCAiaW50ZXJuYWwgZXJyb3I6IGZhaWxlZCB0byBnZXQgdmltIGxpc3QgaXRlbSAlZCIKK21zZ2lkICJpbnRlcm5hbCBlcnJvcjogZmFpbGVkIHRvIGdldCBWaW0gbGlzdCBpdGVtICVkIgogbXNnc3RyICJlcnJldXIgaW50ZXJuZSA6IGFjY+hzIOAgdW4g6WzpbWVudCAlZCBkZSBsaXN0ZSBhIOljaG916SIKIAogbXNnaWQgInNsaWNlIHN0ZXAgY2Fubm90IGJlIHplcm8iCkBAIC03NTAyLDcgKzc0OTksNyBAQAogImTpY291cGFnZSBlbiB0cmFuY2hlIOl0ZW5kdSAiCiAKICMsIGMtZm9ybWF0Ci1tc2dpZCAiaW50ZXJuYWwgZXJyb3I6IG5vIHZpbSBsaXN0IGl0ZW0gJWQiCittc2dpZCAiaW50ZXJuYWwgZXJyb3I6IG5vIFZpbSBsaXN0IGl0ZW0gJWQiCiBtc2dzdHIgImVycmV1ciBpbnRlcm5lIDogcGFzIGQn6WzpbWVudCAlZCBkZSBsaXN0ZSB2aW0iCiAKIG1zZ2lkICJpbnRlcm5hbCBlcnJvcjogbm90IGVub3VnaCBsaXN0IGl0ZW1zIgpAQCAtNzYxMywxOSArNzYxMCwxOSBAQAogbXNnaWQgIkU4NTg6IEV2YWwgZGlkIG5vdCByZXR1cm4gYSB2YWxpZCBweXRob24gb2JqZWN0IgogbXNnc3RyICJFODU4OiBFdmFsIG4nYSBwYXMgcmV0b3VybukgdW4gb2JqZXQgcHl0aG9uIHZhbGlkZSIKIAotbXNnaWQgIkU4NTk6IEZhaWxlZCB0byBjb252ZXJ0IHJldHVybmVkIHB5dGhvbiBvYmplY3QgdG8gdmltIHZhbHVlIgorbXNnaWQgIkU4NTk6IEZhaWxlZCB0byBjb252ZXJ0IHJldHVybmVkIHB5dGhvbiBvYmplY3QgdG8gYSBWaW0gdmFsdWUiCiBtc2dzdHIgIkU4NTk6IENvbnZlcnNpb24gZCdvYmpldCBweXRob24g4CB1bmUgdmFsZXVyIGRlIHZpbSBhIOljaG916SIKIAogIywgYy1mb3JtYXQKLW1zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byB2aW0gZGljdGlvbmFyeSIKK21zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byBhIFZpbSBkaWN0aW9uYXJ5IgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIGNvbnZlcnRpciAlcyDgIHVuIGRpY3Rpb25uYWlyZSB2aW0iCiAKICMsIGMtZm9ybWF0Ci1tc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gdmltIGxpc3QiCittc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gYSBWaW0gbGlzdCIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBjb252ZXJ0aXIgJXMg4CB1bmUgbGlzdGUgZGUgdmltIgogCiAjLCBjLWZvcm1hdAotbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIHZpbSBzdHJ1Y3R1cmUiCittc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gYSBWaW0gc3RydWN0dXJlIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIGNvbnZlcnRpciAlcyDgIHVuZSBzdHJ1Y3R1cmUgZGUgdmltIgogCiBtc2dpZCAiaW50ZXJuYWwgZXJyb3I6IE5VTEwgcmVmZXJlbmNlIHBhc3NlZCIKZGlmZiAtLWdpdCBhL3NyYy9wby9nYS5wbyBiL3NyYy9wby9nYS5wbwppbmRleCAyOTMzZmYzLi4zZWYwMmI0IDEwMDY0NAotLS0gYS9zcmMvcG8vZ2EucG8KKysrIGIvc3JjL3BvL2dhLnBvCkBAIC0yODA2LDkgKzI4MDYsNiBAQAogbXNnaWQgImtleWJvYXJkIGludGVycnVwdCIKIG1zZ3N0ciAiaWRpcmJocmlzZWFkaCBt6WFyY2hs4WlyIgogCi1tc2dpZCAidmltIGVycm9yIgotbXNnc3RyICJlYXJy4WlkIHZpbSIKLQogbXNnaWQgImNhbm5vdCBjcmVhdGUgYnVmZmVyL3dpbmRvdyBjb21tYW5kOiBvYmplY3QgaXMgYmVpbmcgZGVsZXRlZCIKIG1zZ3N0ciAibu0gZulpZGlyIG9yZPogbWFvbOFpbi9mdWlubmVvaWdlIGEgY2hydXRo+jogculhZCDhIHNjcmlvc2FkaCIKIApAQCAtMzEzNSw4ICszMTMyLDggQEAKIG1zZ2lkICIteFx0XHRcdEVkaXQgZW5jcnlwdGVkIGZpbGVzIgogbXNnc3RyICIteFx0XHRcdEN1aXIgY29taGFpZCBjaHJpcHRpdGhlIGluIGVhZ2FyIgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRDb25uZWN0IHZpbSB0byB0aGlzIHBhcnRpY3VsYXIgWC1zZXJ2ZXIiCi1tc2dzdHIgIi1kaXNwbGF5IDxmcmVhc3RhbGHtPlx0TmFzYyB2aW0gbGVpcyBhbiBiaGZyZWFzdGFsYe0tWCBzZW8iCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRDb25uZWN0IFZpbSB0byB0aGlzIHBhcnRpY3VsYXIgWC1zZXJ2ZXIiCittc2dzdHIgIi1kaXNwbGF5IDxmcmVhc3RhbGHtPlx0TmFzYyBWaW0gbGVpcyBhbiBiaGZyZWFzdGFsYe0tWCBzZW8iCiAKIG1zZ2lkICItWFx0XHRcdERvIG5vdCBjb25uZWN0IHRvIFggc2VydmVyIgogbXNnc3RyICItWFx0XHRcdE7hIG5haXNjIGxlaXMgYW4gYmhmcmVhc3RhbGHtIFgiCkBAIC0zMjE4LDExICszMjE1LDExIEBACiAiXG4iCiAiQXJn82ludO0gYXIgZW9sYXMgZG8gZ3ZpbSAobGVhZ2FuIEF0aGVuYSk6XG4iCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biB2aW0gb24gPGRpc3BsYXk+IgotbXNnc3RyICItZGlzcGxheSA8c2PhaWxl4W4+XHRSaXRoIHZpbSBhciA8c2PhaWxl4W4+IgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIFZpbSBvbiA8ZGlzcGxheT4iCittc2dzdHIgIi1kaXNwbGF5IDxzY+FpbGXhbj5cdFJpdGggVmltIGFyIDxzY+FpbGXhbj4iCiAKLW1zZ2lkICItaWNvbmljXHRcdFN0YXJ0IHZpbSBpY29uaWZpZWQiCi1tc2dzdHIgIi1pY29uaWNcdFx0VG9zYWlnaCB2aW0gc2EgbWjzZCDtb3NsYWdoZGFpdGhlIgorbXNnaWQgIi1pY29uaWNcdFx0U3RhcnQgVmltIGljb25pZmllZCIKK21zZ3N0ciAiLWljb25pY1x0XHRUb3NhaWdoIFZpbSBzYSBtaPNkIO1vc2xhZ2hkYWl0aGUiCiAKIG1zZ2lkICItYmFja2dyb3VuZCA8Y29sb3I+XHRVc2UgPGNvbG9yPiBmb3IgdGhlIGJhY2tncm91bmQgKGFsc286IC1iZykiCiBtc2dzdHIgIi1iYWNrZ3JvdW5kIDxkYXRoPlx0QmFpbiD6c+FpZCBhcyA8ZGF0aD4gZG9uIGNo+mxyYSAoLWJnIGZvc3RhKSIKQEAgLTMyNzMsOCArMzI3MCw4IEBACiAiXG4iCiAiQXJn82ludO0gYXIgZW9sYXMgZG8gZ3ZpbSAobGVhZ2FuIEdUSyspOlxuIgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gdmltIG9uIDxkaXNwbGF5PiAoYWxzbzogLS1kaXNwbGF5KSIKLW1zZ3N0ciAiLWRpc3BsYXkgPHNj4WlsZeFuPlx0Uml0aCB2aW0gYXIgPHNj4WlsZeFuPiAoZm9zdGE6IC0tZGlzcGxheSkiCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gVmltIG9uIDxkaXNwbGF5PiAoYWxzbzogLS1kaXNwbGF5KSIKK21zZ3N0ciAiLWRpc3BsYXkgPHNj4WlsZeFuPlx0Uml0aCBWaW0gYXIgPHNj4WlsZeFuPiAoZm9zdGE6IC0tZGlzcGxheSkiCiAKIG1zZ2lkICItLXJvbGUgPHJvbGU+XHRTZXQgYSB1bmlxdWUgcm9sZSB0byBpZGVudGlmeSB0aGUgbWFpbiB3aW5kb3ciCiBtc2dzdHIgIi0tcm9sZSA8cvNsPlx0U29jcmFpZ2ggcvNsIHNhaW5p+mlsIGNodW4gYW4gcGhy7W9taGZodWlubmVvZyBhIGFpdGhpbnQiCkBAIC02OTU1LDcgKzY5NTIsNyBAQAogCiAjLiBObyBtb3JlIHN1aXRhYmxlIGZvcm1hdCBzcGVjaWZpY2F0aW9ucyBpbiBweXRob24tMi4zCiAjLCBjLWZvcm1hdAotbXNnaWQgImludGVybmFsIGVycm9yOiBmYWlsZWQgdG8gZ2V0IHZpbSBsaXN0IGl0ZW0gJWQiCittc2dpZCAiaW50ZXJuYWwgZXJyb3I6IGZhaWxlZCB0byBnZXQgVmltIGxpc3QgaXRlbSAlZCIKIG1zZ3N0ciAiZWFycuFpZCBpbm1oZeFuYWNoOiBu7WwgYW9uIGZo4WlsIGFyIG1o7XIgJWQgc2EgbGlvc3RhIHZpbSIKIAogbXNnaWQgInNsaWNlIHN0ZXAgY2Fubm90IGJlIHplcm8iCkBAIC02OTY2LDcgKzY5NjMsNyBAQAogbXNnc3RyICJpYXJyYWNodCBhciBzaGVpY2hlYW1oIG7tb3MgbfMgbuEgJWQgYSBzaGFubmFkaCBkbyBzaGxpc25lIGZhZGFpdGhlIgogCiAjLCBjLWZvcm1hdAotbXNnaWQgImludGVybmFsIGVycm9yOiBubyB2aW0gbGlzdCBpdGVtICVkIgorbXNnaWQgImludGVybmFsIGVycm9yOiBubyBWaW0gbGlzdCBpdGVtICVkIgogbXNnc3RyICJlYXJy4WlkIGlubWhl4W5hY2g6IG7tbCBhb24gbWjtciAlZCBzYSBsaW9zdGEgdmltIgogCiBtc2dpZCAiaW50ZXJuYWwgZXJyb3I6IG5vdCBlbm91Z2ggbGlzdCBpdGVtcyIKQEAgLTcwNzUsMTkgKzcwNzIsMTkgQEAKIG1zZ2lkICJFODU4OiBFdmFsIGRpZCBub3QgcmV0dXJuIGEgdmFsaWQgcHl0aG9uIG9iamVjdCIKIG1zZ3N0ciAiRTg1ODogTu0gYmhmdWFydGhhcyBy6WFkIGJhaWztIHB5dGhvbiBhciBhaXMg8yBFdmFsIgogCi1tc2dpZCAiRTg1OTogRmFpbGVkIHRvIGNvbnZlcnQgcmV0dXJuZWQgcHl0aG9uIG9iamVjdCB0byB2aW0gdmFsdWUiCittc2dpZCAiRTg1OTogRmFpbGVkIHRvIGNvbnZlcnQgcmV0dXJuZWQgcHl0aG9uIG9iamVjdCB0byBhIFZpbSB2YWx1ZSIKIG1zZ3N0ciAiRTg1OTogTu1vcmJoIGZo6WlkaXIgbHVhY2ggdmltIGEgZGjpYW5hbWggYXMgYW4gculhZCBweXRob24iCiAKICMsIGMtZm9ybWF0Ci1tc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gdmltIGRpY3Rpb25hcnkiCittc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gYSBWaW0gZGljdGlvbmFyeSIKIG1zZ3N0ciAibu0gZulpZGlyIGZvY2zzaXIgdmltIGEgZGjpYW5hbWggYXMgJXMiCiAKICMsIGMtZm9ybWF0Ci1tc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gdmltIGxpc3QiCittc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gYSBWaW0gbGlzdCIKIG1zZ3N0ciAibu0gZulpZGlyIGxpb3N0YSB2aW0gYSBkaOlhbmFtaCBhcyAlcyIKIAogIywgYy1mb3JtYXQKLW1zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byB2aW0gc3RydWN0dXJlIgorbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIGEgVmltIHN0cnVjdHVyZSIKIG1zZ3N0ciAibu0gZulpZGlyIHN0cnVjaHT6ciB2aW0gYSBkaOlhbmFtaCBhcyAlcyIKIAogbXNnaWQgImludGVybmFsIGVycm9yOiBOVUxMIHJlZmVyZW5jZSBwYXNzZWQiCmRpZmYgLS1naXQgYS9zcmMvcG8vaXQucG8gYi9zcmMvcG8vaXQucG8KaW5kZXggZDlmYzNjOS4uNzdlNGVmMCAxMDA2NDQKLS0tIGEvc3JjL3BvL2l0LnBvCisrKyBiL3NyYy9wby9pdC5wbwpAQCAtMjYwNyw5ICsyNjA3LDYgQEAKIG1zZ2lkICJrZXlib2FyZCBpbnRlcnJ1cHQiCiBtc2dzdHIgImludGVycnV6aW9uZSBkYWxsYSB0YXN0aWVyYSIKIAotbXNnaWQgInZpbSBlcnJvciIKLW1zZ3N0ciAiZXJyb3JlIHZpbSIKLQogbXNnaWQgImNhbm5vdCBjcmVhdGUgYnVmZmVyL3dpbmRvdyBjb21tYW5kOiBvYmplY3QgaXMgYmVpbmcgZGVsZXRlZCIKIG1zZ3N0ciAiIgogIm5vbiByaWVzY28gYSBjcmVhcmUgY29tYW5kbyBidWZmZXIvZmluZXN0cmE6IG9nZ2V0dG8gaW4gdmlhIGRpIGNhbmNlbGxhemlvbmUiCkBAIC0zMDE4LDggKzMwMTUsOCBAQAogbXNnaWQgIi14XHRcdFx0RWRpdCBlbmNyeXB0ZWQgZmlsZXMiCiBtc2dzdHIgIi14XHRcdFx0QXByaSB1biBmaWxlIGNpZnJhdG8iCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdENvbm5lY3QgdmltIHRvIHRoaXMgcGFydGljdWxhciBYLXNlcnZlciIKLW1zZ3N0ciAiLWRpc3BsYXkgPHNjaGVybW8+XHRFc2VndWkgdmltIGEgcXVlc3RvIHBhcnRpY29sYXJlIHNlcnZlciBYIgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0Q29ubmVjdCBWaW0gdG8gdGhpcyBwYXJ0aWN1bGFyIFgtc2VydmVyIgorbXNnc3RyICItZGlzcGxheSA8c2NoZXJtbz5cdEVzZWd1aSBWaW0gYSBxdWVzdG8gcGFydGljb2xhcmUgc2VydmVyIFgiCiAKIG1zZ2lkICItWFx0XHRcdERvIG5vdCBjb25uZWN0IHRvIFggc2VydmVyIgogbXNnc3RyICItWFx0XHRcdE5vbiBjb25uZXR0ZXJ0aSBhIHNlcnZlciBYIgpAQCAtMzA5NiwxMSArMzA5MywxMSBAQAogIlxuIgogIk9wemlvbmkgYWNjZXR0YXRlIGRhIGd2aW0gKHZlcnNpb25lIEF0aGVuYSk6XG4iCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biB2aW0gb24gPGRpc3BsYXk+IgotbXNnc3RyICItZGlzcGxheSA8c2NoZXJtbz5cdEVzZWd1aSB2aW0gc3UgPHNjaGVybW8+IgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIFZpbSBvbiA8ZGlzcGxheT4iCittc2dzdHIgIi1kaXNwbGF5IDxzY2hlcm1vPlx0RXNlZ3VpIFZpbSBzdSA8c2NoZXJtbz4iCiAKLW1zZ2lkICItaWNvbmljXHRcdFN0YXJ0IHZpbSBpY29uaWZpZWQiCi1tc2dzdHIgIi1pY29uaWNcdFx0SW5pemlhIHZpbSByaWR1Y2VuZG9sbyBhZCBpY29uYSIKK21zZ2lkICItaWNvbmljXHRcdFN0YXJ0IFZpbSBpY29uaWZpZWQiCittc2dzdHIgIi1pY29uaWNcdFx0SW5pemlhIFZpbSByaWR1Y2VuZG9sbyBhZCBpY29uYSIKIAogbXNnaWQgIi1iYWNrZ3JvdW5kIDxjb2xvcj5cdFVzZSA8Y29sb3I+IGZvciB0aGUgYmFja2dyb3VuZCAoYWxzbzogLWJnKSIKIG1zZ3N0ciAiLWJhY2tncm91bmQgPGNvbG9yZT5cdFVzYSA8Y29sb3JlPiBjb21lIHNmb25kbyAoYW5jaGU6IC1iZykiCkBAIC0zMTQ2LDggKzMxNDMsOCBAQAogIlxuIgogIkFyZ29tZW50aSBhY2NldHRhdGkgZGEgZ3ZpbSAodmVyc2lvbmUgR1RLKyk6XG4iCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biB2aW0gb24gPGRpc3BsYXk+IChhbHNvOiAtLWRpc3BsYXkpIgotbXNnc3RyICItZGlzcGxheSA8c2NoZXJtbz5cdEVzZWd1aSB2aW0gc3UgPHNjaGVybW8+IChhbmNoZTogLS1kaXNwbGF5KSIKK21zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biBWaW0gb24gPGRpc3BsYXk+IChhbHNvOiAtLWRpc3BsYXkpIgorbXNnc3RyICItZGlzcGxheSA8c2NoZXJtbz5cdEVzZWd1aSBWaW0gc3UgPHNjaGVybW8+IChhbmNoZTogLS1kaXNwbGF5KSIKIAogbXNnaWQgIi0tcm9sZSA8cm9sZT5cdFNldCBhIHVuaXF1ZSByb2xlIHRvIGlkZW50aWZ5IHRoZSBtYWluIHdpbmRvdyIKIG1zZ3N0ciAiIgpAQCAtNjUzMCw4ICs2NTI3LDggQEAKIG1zZ2lkICJsaXN0IGluZGV4IG91dCBvZiByYW5nZSIKIG1zZ3N0ciAiSW5kaWNlIGRpIExpc3RhIGZ1b3JpIGludGVydmFsbG8iCiAKLW1zZ2lkICJpbnRlcm5hbCBlcnJvcjogZmFpbGVkIHRvIGdldCB2aW0gbGlzdCBpdGVtICVkIgotbXNnc3RyICJlcnJvcmUgaW50ZXJubzogbm9uIGhvIHBvdHV0byBvdHRlbmVyZSBsJ2VsZW1lbnRvIGRpIHZpbSBsaXN0ICVkIgorbXNnaWQgImludGVybmFsIGVycm9yOiBmYWlsZWQgdG8gZ2V0IFZpbSBsaXN0IGl0ZW0gJWQiCittc2dzdHIgImVycm9yZSBpbnRlcm5vOiBub24gaG8gcG90dXRvIG90dGVuZXJlIGwnZWxlbWVudG8gZGkgVmltIGxpc3QgJWQiCiAKIG1zZ2lkICJzbGljZSBzdGVwIGNhbm5vdCBiZSB6ZXJvIgogbXNnc3RyICJpbCBwYXNzbyBzY29ycmVuZG8gdW4gaW50ZXJ2YWxsbyBub24gcHXyIGVzc2VyZSB6ZXJvIgpAQCAtNjU0MCw3ICs2NTM3LDcgQEAKIG1zZ3N0ciAiIgogInRlbnRhdGl2byBkaSBhc3NlZ25hcmUgdW5hIHNlcXVlbnphIG1hZ2dpb3JlIGRpICVkIGEgdW4gaW50ZXJ2YWxsbyBlc3Rlc28iCiAKLW1zZ2lkICJpbnRlcm5hbCBlcnJvcjogbm8gdmltIGxpc3QgaXRlbSAlZCIKK21zZ2lkICJpbnRlcm5hbCBlcnJvcjogbm8gVmltIGxpc3QgaXRlbSAlZCIKIG1zZ3N0ciAiZXJyb3JlIGludGVybm86IG5vbiBjJ+ggdW4gZWxlbWVudG8gZGkgdmltIGxpc3QgJWQiCiAKIG1zZ2lkICJpbnRlcm5hbCBlcnJvcjogbm90IGVub3VnaCBsaXN0IGl0ZW1zIgpAQCAtNjY0MiwxNyArNjYzOSwxNyBAQAogbXNnaWQgIkU4NTg6IEV2YWwgZGlkIG5vdCByZXR1cm4gYSB2YWxpZCBweXRob24gb2JqZWN0IgogbXNnc3RyICJFODU4OiBFdmFsIG5vbiBoYSByZXN0aXR1aXRvIHVuIG9nZ2V0dG8gcHl0aG9uIHZhbGlkbyIKIAotbXNnaWQgIkU4NTk6IEZhaWxlZCB0byBjb252ZXJ0IHJldHVybmVkIHB5dGhvbiBvYmplY3QgdG8gdmltIHZhbHVlIgorbXNnaWQgIkU4NTk6IEZhaWxlZCB0byBjb252ZXJ0IHJldHVybmVkIHB5dGhvbiBvYmplY3QgdG8gYSBWaW0gdmFsdWUiCiBtc2dzdHIgIiIKICJFODU5OiBDb252ZXJzaW9uZSBub24gcml1c2NpdGEgZGVsbCdvZ2dldHRvIHB5dGhvbiByaXN1bHRhdG8gYSB1biB2YWxvcmUgdmltIgogCi1tc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gdmltIGRpY3Rpb25hcnkiCittc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gYSBWaW0gZGljdGlvbmFyeSIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgY29udmVydGlyZSAlcyBhIGRpemlvbmFyaW8gdmltIgogCi1tc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gdmltIGxpc3QiCittc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gYSBWaW0gbGlzdCIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgY29udmVydGlyZSAlcyBhIExpc3RhIHZpbSIKIAotbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIHZpbSBzdHJ1Y3R1cmUiCittc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gYSBWaW0gc3RydWN0dXJlIgogbXNnc3RyICJpbXBvc3NpYmlsZSBjb252ZXJ0aXJlICVzIGEgc3RydXR0dXJhIHZpbSIKIAogbXNnaWQgImludGVybmFsIGVycm9yOiBOVUxMIHJlZmVyZW5jZSBwYXNzZWQiCmRpZmYgLS1naXQgYS9zcmMvcG8vamEuZXVjLWpwLnBvIGIvc3JjL3BvL2phLmV1Yy1qcC5wbwppbmRleCA3MWE0NmQ4Li45MzU4NzRiIDEwMDY0NAotLS0gYS9zcmMvcG8vamEuZXVjLWpwLnBvCisrKyBiL3NyYy9wby9qYS5ldWMtanAucG8KQEAgLTI1OTAsOSArMjU5MCw2IEBACiBtc2dpZCAia2V5Ym9hcmQgaW50ZXJydXB0IgogbXNnc3RyICKlraG8pdyhvKXJs+S5/qTfIgogCi1tc2dpZCAidmltIGVycm9yIgotbXNnc3RyICJ2aW0gpail6aG8IgotCiBtc2dpZCAiY2Fubm90IGNyZWF0ZSBidWZmZXIvd2luZG93IGNvbW1hbmQ6IG9iamVjdCBpcyBiZWluZyBkZWxldGVkIgogbXNnc3RyICIiCiAipdClw6XVpaEvpaalo6XzpcmlprruwK6ls6XepfOlyaTyuu7ArqTHpK2k3qS7pPM6IKWqpdaluKWnpa+lyKSsvsO17qS1pOykxqSkpN4iCkBAIC0zMDU1LDcgKzMwNTIsNyBAQAogbXNnaWQgIi14XHRcdFx0RWRpdCBlbmNyeXB0ZWQgZmlsZXMiCiBtc2dzdHIgIi14XHRcdFx0sMW55rK9pLWk7KS/pdWloaWkpeuk8srUvbikuaTrIgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRDb25uZWN0IHZpbSB0byB0aGlzIHBhcnRpY3VsYXIgWC1zZXJ2ZXIiCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRDb25uZWN0IFZpbSB0byB0aGlzIHBhcnRpY3VsYXIgWC1zZXJ2ZXIiCiBtc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0dmltpPK72MTqpLekvyBYIKW1obyl0KG8pMvA3MKzpLmk6yIKIAogbXNnaWQgIi1YXHRcdFx0RG8gbm90IGNvbm5lY3QgdG8gWCBzZXJ2ZXIiCkBAIC0zMTMwLDEwICszMTI3LDEwIEBACiAiXG4iCiAiZ3ZpbaTLpOikw6TGsvK84aS1pOyk67D6v/QoQXRoZW5hpdChvKW4peel8yk6XG4iCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biB2aW0gb24gPGRpc3BsYXk+IgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIFZpbSBvbiA8ZGlzcGxheT4iCiBtc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0PGRpc3BsYXk+IKTHdmltpPK8wrnUpLmk6yIKIAotbXNnaWQgIi1pY29uaWNcdFx0U3RhcnQgdmltIGljb25pZmllZCIKK21zZ2lkICItaWNvbmljXHRcdFN0YXJ0IFZpbSBpY29uaWZpZWQiCiBtc2dzdHIgIi1pY29uaWNcdFx0use+rrK9pLekv771wtakx3ZpbaTyta/GsKS5pOsiCiAKIG1zZ2lkICItYmFja2dyb3VuZCA8Y29sb3I+XHRVc2UgPGNvbG9yPiBmb3IgdGhlIGJhY2tncm91bmQgKGFsc286IC1iZykiCkBAIC0zMTgwLDggKzMxNzcsOCBAQAogIlxuIgogImd2aW2ky6TopMOkxrLyvOGktaTspOuw+r/0KEdUSyul0KG8pbil56XzKTpcbiIKIAotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIHZpbSBvbiA8ZGlzcGxheT4gKGFsc286IC0tZGlzcGxheSkiCi1tc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0PGRpc3BsYXk+IKTHdmltpPK8wrnUpLmk6yjGsbXBOiAtLWRpc3BsYXkpIgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIFZpbSBvbiA8ZGlzcGxheT4gKGFsc286IC0tZGlzcGxheSkiCittc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0PGRpc3BsYXk+IKTHVmltpPK8wrnUpLmk6yjGsbXBOiAtLWRpc3BsYXkpIgogCiBtc2dpZCAiLS1yb2xlIDxyb2xlPlx0U2V0IGEgdW5pcXVlIHJvbGUgdG8gaWRlbnRpZnkgdGhlIG1haW4gd2luZG93IgogbXNnc3RyICItLXJvbGUgPHJvbGU+XHSl4aWkpfOlpqWjpfOlyaWmpPK8scrMpLmk67DssNWkyszys+Qocm9sZSmk8sDfxOqkuaTrIgpAQCAtNzEzNSw3ICs3MTMyLDcgQEAKIG1zZ3N0ciAipeqluaXIyM+wz7OwpM6lpKXzpcelw6Wvpbmkx6S5IgogCiAjLCBjLWZvcm1hdAotbXNnaWQgImludGVybmFsIGVycm9yOiBmYWlsZWQgdG8gZ2V0IHZpbSBsaXN0IGl0ZW0gJWQiCittc2dpZCAiaW50ZXJuYWwgZXJyb3I6IGZhaWxlZCB0byBnZXQgVmltIGxpc3QgaXRlbSAlZCIKIG1zZ3N0ciAixuLJ9KWopemhvDogdmltpM6l6qW5pcjN18HHICVkIKTOvOjGwKTLvLrH1KS3pN6kt6S/IgogCiBtc2dpZCAic2xpY2Ugc3RlcCBjYW5ub3QgYmUgemVybyIKQEAgLTcxNDYsNyArNzE0Myw3IEBACiBtc2dzdHIgIsS5pLUgJWQgpM6zyMSlpbml6aWkpbmky6GipOik6sS5pKSluaXppaSluaTys+Sk6sX2pMak6KSmpMikt6TepLekvyIKIAogIywgYy1mb3JtYXQKLW1zZ2lkICJpbnRlcm5hbCBlcnJvcjogbm8gdmltIGxpc3QgaXRlbSAlZCIKK21zZ2lkICJpbnRlcm5hbCBlcnJvcjogbm8gVmltIGxpc3QgaXRlbSAlZCIKIG1zZ3N0ciAixuLJ9KWopemhvDogdmltpM6l6qW5pcjN18HHICVkIKTPpKKk6qTepLuk8yIKIAogbXNnaWQgImludGVybmFsIGVycm9yOiBub3QgZW5vdWdoIGxpc3QgaXRlbXMiCkBAIC03MjU1LDE5ICs3MjUyLDE5IEBACiBtc2dpZCAiRTg1ODogRXZhbCBkaWQgbm90IHJldHVybiBhIHZhbGlkIHB5dGhvbiBvYmplY3QiCiBtc2dzdHIgIkU4NTg6ILywyb6ywaTPza24+qTKcHl0aG9upaql1qW4paelr6XIpPLK1qS3pN6ku6TzpMekt6S/IgogCi1tc2dpZCAiRTg1OTogRmFpbGVkIHRvIGNvbnZlcnQgcmV0dXJuZWQgcHl0aG9uIG9iamVjdCB0byB2aW0gdmFsdWUiCittc2dpZCAiRTg1OTogRmFpbGVkIHRvIGNvbnZlcnQgcmV0dXJuZWQgcHl0aG9uIG9iamVjdCB0byBhIFZpbSB2YWx1ZSIKIG1zZ3N0ciAiRTg1OTogytaktaTspL9weXRob26lqqXWpbilp6Wvpcik8nZpbaTOw82ky8rRtLmkx6StpN6ku6TzpMekt6S/IgogCiAjLCBjLWZvcm1hdAotbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIHZpbSBkaWN0aW9uYXJ5IgorbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIGEgVmltIGRpY3Rpb25hcnkiCiBtc2dzdHIgIiVzIHZpbaTOvK298be/pMvK0bS5pMekraTepLuk8yIKIAogIywgYy1mb3JtYXQKLW1zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byB2aW0gbGlzdCIKK21zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byBhIFZpbSBsaXN0IgogbXNnc3RyICIlcyCk8nZpbaTOpeqluaXIpMvK0bS5pMekraTepLuk8yIKIAogIywgYy1mb3JtYXQKLW1zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byB2aW0gc3RydWN0dXJlIgorbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIGEgVmltIHN0cnVjdHVyZSIKIG1zZ3N0ciAiJXMgpPJ2aW2kzrm9wqTCzqTLytG0uaTHpK2k3qS7pPMiCiAKIG1zZ2lkICJpbnRlcm5hbCBlcnJvcjogTlVMTCByZWZlcmVuY2UgcGFzc2VkIgpkaWZmIC0tZ2l0IGEvc3JjL3BvL2phLnBvIGIvc3JjL3BvL2phLnBvCmluZGV4IDI4MjZjMzUuLmFjYzE1MmUgMTAwNjQ0Ci0tLSBhL3NyYy9wby9qYS5wbworKysgYi9zcmMvcG8vamEucG8KQEAgLTI1OTAsOSArMjU5MCw2IEBACiBtc2dpZCAia2V5Ym9hcmQgaW50ZXJydXB0IgogbXNnc3RyICLjgq3jg7zjg5zjg7zjg4nlibLovrzjgb8iCiAKLW1zZ2lkICJ2aW0gZXJyb3IiCi1tc2dzdHIgInZpbSDjgqjjg6njg7wiCi0KIG1zZ2lkICJjYW5ub3QgY3JlYXRlIGJ1ZmZlci93aW5kb3cgY29tbWFuZDogb2JqZWN0IGlzIGJlaW5nIGRlbGV0ZWQiCiBtc2dzdHIgIiIKICLjg5Djg4Pjg5XjgqEv44Km44Kj44Oz44OJ44Km5L2c5oiQ44Kz44Oe44Oz44OJ44KS5L2c5oiQ44Gn44GN44G+44Gb44KTOiDjgqrjg5bjgrjjgqfjgq/jg4jjgYzmtojljrvjgZXjgozjgabjgYTjgb4iCkBAIC0zMDU1LDcgKzMwNTIsNyBAQAogbXNnaWQgIi14XHRcdFx0RWRpdCBlbmNyeXB0ZWQgZmlsZXMiCiBtc2dzdHIgIi14XHRcdFx05pqX5Y+35YyW44GV44KM44Gf44OV44Kh44Kk44Or44KS57eo6ZuG44GZ44KLIgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRDb25uZWN0IHZpbSB0byB0aGlzIHBhcnRpY3VsYXIgWC1zZXJ2ZXIiCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRDb25uZWN0IFZpbSB0byB0aGlzIHBhcnRpY3VsYXIgWC1zZXJ2ZXIiCiBtc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0dmlt44KS5oyH5a6a44GX44GfIFgg44K144O844OQ44O844Gr5o6l57aa44GZ44KLIgogCiBtc2dpZCAiLVhcdFx0XHREbyBub3QgY29ubmVjdCB0byBYIHNlcnZlciIKQEAgLTMxMzAsMTAgKzMxMjcsMTAgQEAKICJcbiIKICJndmlt44Gr44KI44Gj44Gm6Kej6YeI44GV44KM44KL5byV5pWwKEF0aGVuYeODkOODvOOCuOODp+ODsyk6XG4iCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biB2aW0gb24gPGRpc3BsYXk+IgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIFZpbSBvbiA8ZGlzcGxheT4iCiBtc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0PGRpc3BsYXk+IOOBp3ZpbeOCkuWun+ihjOOBmeOCiyIKIAotbXNnaWQgIi1pY29uaWNcdFx0U3RhcnQgdmltIGljb25pZmllZCIKK21zZ2lkICItaWNvbmljXHRcdFN0YXJ0IFZpbSBpY29uaWZpZWQiCiBtc2dzdHIgIi1pY29uaWNcdFx05pyA5bCP5YyW44GX44Gf54q25oWL44Gndmlt44KS6LW35YuV44GZ44KLIgogCiBtc2dpZCAiLWJhY2tncm91bmQgPGNvbG9yPlx0VXNlIDxjb2xvcj4gZm9yIHRoZSBiYWNrZ3JvdW5kIChhbHNvOiAtYmcpIgpAQCAtMzE4MCw4ICszMTc3LDggQEAKICJcbiIKICJndmlt44Gr44KI44Gj44Gm6Kej6YeI44GV44KM44KL5byV5pWwKEdUSyvjg5Djg7zjgrjjg6fjg7MpOlxuIgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gdmltIG9uIDxkaXNwbGF5PiAoYWxzbzogLS1kaXNwbGF5KSIKLW1zZ3N0ciAiLWRpc3BsYXkgPGRpc3BsYXk+XHQ8ZGlzcGxheT4g44Gndmlt44KS5a6f6KGM44GZ44KLKOWQjOe+qTogLS1kaXNwbGF5KSIKK21zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biBWaW0gb24gPGRpc3BsYXk+IChhbHNvOiAtLWRpc3BsYXkpIgorbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdDxkaXNwbGF5PiDjgadWaW3jgpLlrp/ooYzjgZnjgoso5ZCM576pOiAtLWRpc3BsYXkpIgogCiBtc2dpZCAiLS1yb2xlIDxyb2xlPlx0U2V0IGEgdW5pcXVlIHJvbGUgdG8gaWRlbnRpZnkgdGhlIG1haW4gd2luZG93IgogbXNnc3RyICItLXJvbGUgPHJvbGU+XHTjg6HjgqTjg7PjgqbjgqPjg7Pjg4njgqbjgpLorZjliKXjgZnjgovkuIDmhI/jgarlvbnlibIocm9sZSnjgpLoqK3lrprjgZnjgosiCkBAIC03MTM1LDcgKzcxMzIsNyBAQAogbXNnc3RyICLjg6rjgrnjg4jnr4Tlm7LlpJbjga7jgqTjg7Pjg4fjg4Pjgq/jgrnjgafjgZkiCiAKICMsIGMtZm9ybWF0Ci1tc2dpZCAiaW50ZXJuYWwgZXJyb3I6IGZhaWxlZCB0byBnZXQgdmltIGxpc3QgaXRlbSAlZCIKK21zZ2lkICJpbnRlcm5hbCBlcnJvcjogZmFpbGVkIHRvIGdldCBWaW0gbGlzdCBpdGVtICVkIgogbXNnc3RyICLlhoXpg6jjgqjjg6njg7w6IHZpbeOBruODquOCueODiOimgee0oCAlZCDjga7lj5blvpfjgavlpLHmlZfjgZfjgb7jgZfjgZ8iCiAKIG1zZ2lkICJzbGljZSBzdGVwIGNhbm5vdCBiZSB6ZXJvIgpAQCAtNzE0Niw3ICs3MTQzLDcgQEAKIG1zZ3N0ciAi6ZW344GVICVkIOOBruaLoeW8teOCueODqeOCpOOCueOBq+OAgeOCiOOCiumVt+OBhOOCueODqeOCpOOCueOCkuWJsuOCiuW9k+OBpuOCiOOBhuOBqOOBl+OBvuOBl+OBnyIKIAogIywgYy1mb3JtYXQKLW1zZ2lkICJpbnRlcm5hbCBlcnJvcjogbm8gdmltIGxpc3QgaXRlbSAlZCIKK21zZ2lkICJpbnRlcm5hbCBlcnJvcjogbm8gVmltIGxpc3QgaXRlbSAlZCIKIG1zZ3N0ciAi5YaF6YOo44Ko44Op44O8OiB2aW3jga7jg6rjgrnjg4jopoHntKAgJWQg44Gv44GC44KK44G+44Gb44KTIgogCiBtc2dpZCAiaW50ZXJuYWwgZXJyb3I6IG5vdCBlbm91Z2ggbGlzdCBpdGVtcyIKQEAgLTcyNTUsMTkgKzcyNTIsMTkgQEAKIG1zZ2lkICJFODU4OiBFdmFsIGRpZCBub3QgcmV0dXJuIGEgdmFsaWQgcHl0aG9uIG9iamVjdCIKIG1zZ3N0ciAiRTg1ODog5byP6KmV5L6h44Gv5pyJ5Yq544GqcHl0aG9u44Kq44OW44K444Kn44Kv44OI44KS6L+U44GX44G+44Gb44KT44Gn44GX44GfIgogCi1tc2dpZCAiRTg1OTogRmFpbGVkIHRvIGNvbnZlcnQgcmV0dXJuZWQgcHl0aG9uIG9iamVjdCB0byB2aW0gdmFsdWUiCittc2dpZCAiRTg1OTogRmFpbGVkIHRvIGNvbnZlcnQgcmV0dXJuZWQgcHl0aG9uIG9iamVjdCB0byBhIFZpbSB2YWx1ZSIKIG1zZ3N0ciAiRTg1OTog6L+U44GV44KM44GfcHl0aG9u44Kq44OW44K444Kn44Kv44OI44KSdmlt44Gu5YCk44Gr5aSJ5o+b44Gn44GN44G+44Gb44KT44Gn44GX44GfIgogCiAjLCBjLWZvcm1hdAotbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIHZpbSBkaWN0aW9uYXJ5IgorbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIGEgVmltIGRpY3Rpb25hcnkiCiBtc2dzdHIgIiVzIHZpbeOBrui+nuabuOWei+OBq+WkieaPm+OBp+OBjeOBvuOBm+OCkyIKIAogIywgYy1mb3JtYXQKLW1zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byB2aW0gbGlzdCIKK21zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byBhIFZpbSBsaXN0IgogbXNnc3RyICIlcyDjgpJ2aW3jga7jg6rjgrnjg4jjgavlpInmj5vjgafjgY3jgb7jgZvjgpMiCiAKICMsIGMtZm9ybWF0Ci1tc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gdmltIHN0cnVjdHVyZSIKK21zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byBhIFZpbSBzdHJ1Y3R1cmUiCiBtc2dzdHIgIiVzIOOCknZpbeOBruani+mAoOS9k+OBq+WkieaPm+OBp+OBjeOBvuOBm+OCkyIKIAogbXNnaWQgImludGVybmFsIGVycm9yOiBOVUxMIHJlZmVyZW5jZSBwYXNzZWQiCmRpZmYgLS1naXQgYS9zcmMvcG8vamEuc2ppcy5wbyBiL3NyYy9wby9qYS5zamlzLnBvCmluZGV4IDk2NzY0NzUuLjkyN2Y0ZjQgMTAwNjQ0Ci0tLSBhL3NyYy9wby9qYS5zamlzLnBvCisrKyBiL3NyYy9wby9qYS5zamlzLnBvCkBAIC0yNTkwLDkgKzI1OTAsNiBAQAogbXNnaWQgImtleWJvYXJkIGludGVycnVwdCIKIG1zZ3N0ciAig0yBW4N7gVuDaIqEjZ6C3SIKIAotbXNnaWQgInZpbSBlcnJvciIKLW1zZ3N0ciAidmltIINHg4mBWyIKLQogbXNnaWQgImNhbm5vdCBjcmVhdGUgYnVmZmVyL3dpbmRvdyBjb21tYW5kOiBvYmplY3QgaXMgYmVpbmcgZGVsZXRlZCIKIG1zZ3N0ciAiIgogIoNvg2KDdINAL4NFg0KDk4Nog0WN7JCsg1KDfYOTg2iC8I3skKyCxYKrgtyCuYLxOiCDSYN1g1eDRoNOg2eCqo/Bi46Cs4LqgsSCooLcIgpAQCAtMzA1NSw3ICszMDUyLDcgQEAKIG1zZ2lkICIteFx0XHRcdEVkaXQgZW5jcnlwdGVkIGZpbGVzIgogbXNnc3RyICIteFx0XHRcdIjDjYaJu4KzguqCvYN0g0CDQ4OLgvCV0o9XgreC6SIKIAotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0Q29ubmVjdCB2aW0gdG8gdGhpcyBwYXJ0aWN1bGFyIFgtc2VydmVyIgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0Q29ubmVjdCBWaW0gdG8gdGhpcyBwYXJ0aWN1bGFyIFgtc2VydmVyIgogbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdHZpbYLwjneS6IK1gr0gWCCDVIFbg2+BW4LJkNqRsYK3gukiCiAKIG1zZ2lkICItWFx0XHRcdERvIG5vdCBjb25uZWN0IHRvIFggc2VydmVyIgpAQCAtMzEzMCwxMCArMzEyNywxMCBAQAogIlxuIgogImd2aW2CyYLmgsGCxInwjt+Cs4LqgumI+JCUKEF0aGVuYYNvgVuDV4OHg5MpOlxuIgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gdmltIG9uIDxkaXNwbGF5PiIKK21zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biBWaW0gb24gPGRpc3BsYXk+IgogbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdDxkaXNwbGF5PiCCxXZpbYLwjsCNc4K3gukiCiAKLW1zZ2lkICItaWNvbmljXHRcdFN0YXJ0IHZpbSBpY29uaWZpZWQiCittc2dpZCAiLWljb25pY1x0XHRTdGFydCBWaW0gaWNvbmlmaWVkIgogbXNnc3RyICItaWNvbmljXHRcdI3Fj6yJu4K1gr2P85HUgsV2aW2C8ItOk66Ct4LpIgogCiBtc2dpZCAiLWJhY2tncm91bmQgPGNvbG9yPlx0VXNlIDxjb2xvcj4gZm9yIHRoZSBiYWNrZ3JvdW5kIChhbHNvOiAtYmcpIgpAQCAtMzE4MCw3ICszMTc3LDcgQEAKICJcbiIKICJndmltgsmC5oLBgsSJ8I7fgrOC6oLpiPiQlChHVEsrg2+BW4NXg4eDkyk6XG4iCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biB2aW0gb24gPGRpc3BsYXk+IChhbHNvOiAtLWRpc3BsYXkpIgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIFZpbSBvbiA8ZGlzcGxheT4gKGFsc286IC0tZGlzcGxheSkiCiBtc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0PGRpc3BsYXk+IILFdmltgvCOwI1zgreC6SiTr4tgOiAtLWRpc3BsYXkpIgogCiBtc2dpZCAiLS1yb2xlIDxyb2xlPlx0U2V0IGEgdW5pcXVlIHJvbGUgdG8gaWRlbnRpZnkgdGhlIG1haW4gd2luZG93IgpAQCAtNzEzNSw3ICs3MTMyLDcgQEAKIG1zZ3N0ciAig4qDWINnlM2IzYpPgsyDQ4OTg2aDYoNOg1iCxYK3IgogCiAjLCBjLWZvcm1hdAotbXNnaWQgImludGVybmFsIGVycm9yOiBmYWlsZWQgdG8gZ2V0IHZpbSBsaXN0IGl0ZW0gJWQiCittc2dpZCAiaW50ZXJuYWwgZXJyb3I6IGZhaWxlZCB0byBnZXQgVmltIGxpc3QgaXRlbSAlZCIKIG1zZ3N0ciAik+CVlINHg4mBWzogdmltgsyDioNYg2eXdpFmICVkIILMjuaTvoLJjriUc4K1gtyCtYK9IgogCiBtc2dpZCAic2xpY2Ugc3RlcCBjYW5ub3QgYmUgemVybyIKQEAgLTcxNDYsNyArNzE0Myw3IEBACiBtc2dzdHIgIpK3grMgJWQggsyKZ5Kjg1iDiYNDg1iCyYFBguaC6JK3gqKDWIOJg0ODWILwioSC6JOWgsSC5oKkgsaCtYLcgrWCvSIKIAogIywgYy1mb3JtYXQKLW1zZ2lkICJpbnRlcm5hbCBlcnJvcjogbm8gdmltIGxpc3QgaXRlbSAlZCIKK21zZ2lkICJpbnRlcm5hbCBlcnJvcjogbm8gVmltIGxpc3QgaXRlbSAlZCIKIG1zZ3N0ciAik+CVlINHg4mBWzogdmltgsyDioNYg2eXdpFmICVkIILNgqCC6ILcgrmC8SIKIAogbXNnaWQgImludGVybmFsIGVycm9yOiBub3QgZW5vdWdoIGxpc3QgaXRlbXMiCkBAIC03MjU1LDE5ICs3MjUyLDE5IEBACiBtc2dpZCAiRTg1ODogRXZhbCBkaWQgbm90IHJldHVybiBhIHZhbGlkIHB5dGhvbiBvYmplY3QiCiBtc2dzdHIgIkU4NTg6II6ulV2Jv4LNl0yM+ILIcHl0aG9ug0mDdYNXg0aDToNngvCV1IK1gtyCuYLxgsWCtYK9IgogCi1tc2dpZCAiRTg1OTogRmFpbGVkIHRvIGNvbnZlcnQgcmV0dXJuZWQgcHl0aG9uIG9iamVjdCB0byB2aW0gdmFsdWUiCittc2dpZCAiRTg1OTogRmFpbGVkIHRvIGNvbnZlcnQgcmV0dXJuZWQgcHl0aG9uIG9iamVjdCB0byBhIFZpbSB2YWx1ZSIKIG1zZ3N0ciAiRTg1OTogldSCs4Lqgr1weXRob26DSYN1g1eDRoNOg2eC8HZpbYLMkmyCyZXPireCxYKrgtyCuYLxgsWCtYK9IgogCiAjLCBjLWZvcm1hdAotbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIHZpbSBkaWN0aW9uYXJ5IgorbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIGEgVmltIGRpY3Rpb25hcnkiCiBtc2dzdHIgIiVzIHZpbYLMjquPkYxegsmVz4q3gsWCq4LcgrmC8SIKIAogIywgYy1mb3JtYXQKLW1zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byB2aW0gbGlzdCIKK21zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byBhIFZpbSBsaXN0IgogbXNnc3RyICIlcyCC8HZpbYLMg4qDWINngsmVz4q3gsWCq4LcgrmC8SIKIAogIywgYy1mb3JtYXQKLW1zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byB2aW0gc3RydWN0dXJlIgorbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIGEgVmltIHN0cnVjdHVyZSIKIG1zZ3N0ciAiJXMggvB2aW2CzI1cXJGikcyCyZXPireCxYKrgtyCuYLxIgogCiBtc2dpZCAiaW50ZXJuYWwgZXJyb3I6IE5VTEwgcmVmZXJlbmNlIHBhc3NlZCIKZGlmZiAtLWdpdCBhL3NyYy9wby9rby5VVEYtOC5wbyBiL3NyYy9wby9rby5VVEYtOC5wbwppbmRleCA4YWNiY2M5Li5hNDg2NGU3IDEwMDY0NAotLS0gYS9zcmMvcG8va28uVVRGLTgucG8KKysrIGIvc3JjL3BvL2tvLlVURi04LnBvCkBAIC0yNzgwLDkgKzI3ODAsNiBAQAogbXNnaWQgImtleWJvYXJkIGludGVycnVwdCIKIG1zZ3N0ciAi7YKk67O065OcIOyduO2EsOufve2KuCIKIAotbXNnaWQgInZpbSBlcnJvciIKLW1zZ3N0ciAi67mUIOyXkOufrCIKLQogbXNnaWQgImNhbm5vdCBjcmVhdGUgYnVmZmVyL3dpbmRvdyBjb21tYW5kOiBvYmplY3QgaXMgYmVpbmcgZGVsZXRlZCIKIG1zZ3N0ciAi67KE7Y28L+ywvSDrqoXroLnsnYQg66eM65OkIOyImCDsl4bsirXri4jri6Q6IOqwneyytOqwgCDsp4Dsm4zsp5Hri4jri6QiCiAKQEAgLTMwOTYsNyArMzA5Myw3IEBACiBtc2dpZCAiLXhcdFx0XHRFZGl0IGVuY3J5cHRlZCBmaWxlcyIKIG1zZ3N0ciAiLXhcdFx0XHTslZTtmLjtmZTrkJwg7YyM7J28IOqzoOy5mOq4sCIKIAotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0Q29ubmVjdCB2aW0gdG8gdGhpcyBwYXJ0aWN1bGFyIFgtc2VydmVyIgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0Q29ubmVjdCBWaW0gdG8gdGhpcyBwYXJ0aWN1bGFyIFgtc2VydmVyIgogbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdOu5lOydhCDtirnsoJUgWC3shJzrsoTsmYAg7Jew6rKwIgogCiBtc2dpZCAiLVhcdFx0XHREbyBub3QgY29ubmVjdCB0byBYIHNlcnZlciIKQEAgLTMxNzAsMTAgKzMxNjcsMTAgQEAKICJcbiIKICJndmlt7J20IOyVjOqzoCDsnojripQg7J247J6QICjslYTthYzrgpgg7YyQKTpcbiIKIAotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIHZpbSBvbiA8ZGlzcGxheT4iCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gVmltIG9uIDxkaXNwbGF5PiIKIG1zZ3N0ciAiLWRpc3BsYXkgPGRpc3BsYXk+XHTruZTsnYQgPGRpc3BsYXk+7JeQ7IScIOyLpO2WiSIKIAotbXNnaWQgIi1pY29uaWNcdFx0U3RhcnQgdmltIGljb25pZmllZCIKK21zZ2lkICItaWNvbmljXHRcdFN0YXJ0IFZpbSBpY29uaWZpZWQiCiBtc2dzdHIgIi1pY29uaWNcdFx07JWE7J207L2YIOyDge2DnOuhnCDruZQg7Iuc7J6RIgogCiBtc2dpZCAiLWJhY2tncm91bmQgPGNvbG9yPlx0VXNlIDxjb2xvcj4gZm9yIHRoZSBiYWNrZ3JvdW5kIChhbHNvOiAtYmcpIgpAQCAtMzIxOSw3ICszMjE2LDcgQEAKICJcbiIKICJndmlt7J20IOyVjOqzoOyeiOuKlCDsnbjsnpAgKEdUSysg7YyQKTpcbiIKIAotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIHZpbSBvbiA8ZGlzcGxheT4gKGFsc286IC0tZGlzcGxheSkiCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gVmltIG9uIDxkaXNwbGF5PiAoYWxzbzogLS1kaXNwbGF5KSIKIG1zZ3N0ciAiLWRpc3BsYXkgPGRpc3BsYXk+XHTruZTsnYQgPGRpc3BsYXk+7JeQ7IScIOyLpO2WiSAoYWxzbzogLS1kaXNwbGF5KSIKIAogbXNnaWQgIi0tcm9sZSA8cm9sZT5cdFNldCBhIHVuaXF1ZSByb2xlIHRvIGlkZW50aWZ5IHRoZSBtYWluIHdpbmRvdyIKQEAgLTY4MTEsNyArNjgwOCw3IEBACiBtc2dzdHIgImxpc3Qg7IOJ7J247J20IOuylOychOulvCDrspfslrTrgqzsirXri4jri6QiCiAKICMsIGMtZm9ybWF0Ci0jfiBtc2dpZCAiaW50ZXJuYWwgZXJyb3I6IGZhaWxlZCB0byBnZXQgdmltIGxpc3QgaXRlbSAlZCIKKyN+IG1zZ2lkICJpbnRlcm5hbCBlcnJvcjogZmFpbGVkIHRvIGdldCBWaW0gbGlzdCBpdGVtICVkIgogI34gbXNnc3RyICIiCiAKICN+IG1zZ2lkICJzbGljZSBzdGVwIGNhbm5vdCBiZSB6ZXJvIgpAQCAtNjgyMiw3ICs2ODE5LDcgQEAKICN+IG1zZ3N0ciAiIgogCiAjLCBjLWZvcm1hdAotI34gbXNnaWQgImludGVybmFsIGVycm9yOiBubyB2aW0gbGlzdCBpdGVtICVkIgorI34gbXNnaWQgImludGVybmFsIGVycm9yOiBubyBWaW0gbGlzdCBpdGVtICVkIgogI34gbXNnc3RyICIiCiAKICN+IG1zZ2lkICJpbnRlcm5hbCBlcnJvcjogbm90IGVub3VnaCBsaXN0IGl0ZW1zIgpAQCAtNjkzMSwxOSArNjkyOCwxOSBAQAogI34gbXNnaWQgIkU4NTg6IEV2YWwgZGlkIG5vdCByZXR1cm4gYSB2YWxpZCBweXRob24gb2JqZWN0IgogI34gbXNnc3RyICIiCiAKLSN+IG1zZ2lkICJFODU5OiBGYWlsZWQgdG8gY29udmVydCByZXR1cm5lZCBweXRob24gb2JqZWN0IHRvIHZpbSB2YWx1ZSIKKyN+IG1zZ2lkICJFODU5OiBGYWlsZWQgdG8gY29udmVydCByZXR1cm5lZCBweXRob24gb2JqZWN0IHRvIGEgVmltIHZhbHVlIgogI34gbXNnc3RyICIiCiAKICMsIGMtZm9ybWF0Ci0jfiBtc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gdmltIGRpY3Rpb25hcnkiCisjfiBtc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gYSBWaW0gZGljdGlvbmFyeSIKICN+IG1zZ3N0ciAiIgogCiAjLCBjLWZvcm1hdAotbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIHZpbSBsaXN0IgorbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIGEgVmltIGxpc3QiCiBtc2dzdHIgIiVz7J2EKOulvCkgdmltIGxpc3TroZwg67OA6rK97ZWgIOyImCDsl4bsirXri4jri6QiCiAKICMsIGMtZm9ybWF0Ci0jfiBtc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gdmltIHN0cnVjdHVyZSIKKyN+IG1zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byBhIFZpbSBzdHJ1Y3R1cmUiCiAjfiBtc2dzdHIgIiIKIAogI34gbXNnaWQgImludGVybmFsIGVycm9yOiBOVUxMIHJlZmVyZW5jZSBwYXNzZWQiCmRpZmYgLS1naXQgYS9zcmMvcG8va28ucG8gYi9zcmMvcG8va28ucG8KaW5kZXggYzZiMDk5Ny4uOWYyZmY3MCAxMDA2NDQKLS0tIGEvc3JjL3BvL2tvLnBvCisrKyBiL3NyYy9wby9rby5wbwpAQCAtMjc4MCw5ICsyNzgwLDYgQEAKIG1zZ2lkICJrZXlib2FyZCBpbnRlcnJ1cHQiCiBtc2dzdHIgIsWwuri15SDAzsXNt7TGriIKIAotbXNnaWQgInZpbSBlcnJvciIKLW1zZ3N0ciAiuvYgv6G3ryIKLQogbXNnaWQgImNhbm5vdCBjcmVhdGUgYnVmZmVyL3dpbmRvdyBjb21tYW5kOiBvYmplY3QgaXMgYmVpbmcgZGVsZXRlZCIKIG1zZ3N0ciAiufbG2y/DoiC47bfJwLsguLi16SC89iC++L3AtM+02TogsLTDvLChIMH2v/bB/bTPtNkiCiAKQEAgLTMwOTYsNyArMzA5Myw3IEBACiBtc2dpZCAiLXhcdFx0XHRFZGl0IGVuY3J5cHRlZCBmaWxlcyIKIG1zZ3N0ciAiLXhcdFx0XHS+z8ijyK21yCDGxMDPILDtxKGx4iIKIAotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0Q29ubmVjdCB2aW0gdG8gdGhpcyBwYXJ0aWN1bGFyIFgtc2VydmVyIgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0Q29ubmVjdCBWaW0gdG8gdGhpcyBwYXJ0aWN1bGFyIFgtc2VydmVyIgogbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdLr2wLsgxq/BpCBYLbytufa/zSC/rLDhIgogCiBtc2dpZCAiLVhcdFx0XHREbyBub3QgY29ubmVjdCB0byBYIHNlcnZlciIKQEAgLTMxNzAsMTAgKzMxNjcsMTAgQEAKICJcbiIKICJndmltwMwgvsuw7SDA1rTCIMDOwNogKL7GxdezqiDGxyk6XG4iCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biB2aW0gb24gPGRpc3BsYXk+IgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIFZpbSBvbiA8ZGlzcGxheT4iCiBtc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0uvbAuyA8ZGlzcGxheT6/obytIL3Hx+AiCiAKLW1zZ2lkICItaWNvbmljXHRcdFN0YXJ0IHZpbSBpY29uaWZpZWQiCittc2dpZCAiLWljb25pY1x0XHRTdGFydCBWaW0gaWNvbmlmaWVkIgogbXNnc3RyICItaWNvbmljXHRcdL7GwMzE3CC788XCt84guvYgvcPA2yIKIAogbXNnaWQgIi1iYWNrZ3JvdW5kIDxjb2xvcj5cdFVzZSA8Y29sb3I+IGZvciB0aGUgYmFja2dyb3VuZCAoYWxzbzogLWJnKSIKQEAgLTMyMTksNyArMzIxNiw3IEBACiAiXG4iCiAiZ3ZpbcDMIL7LsO3A1rTCIMDOwNogKEdUSysgxscpOlxuIgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gdmltIG9uIDxkaXNwbGF5PiAoYWxzbzogLS1kaXNwbGF5KSIKK21zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biBWaW0gb24gPGRpc3BsYXk+IChhbHNvOiAtLWRpc3BsYXkpIgogbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdLr2wLsgPGRpc3BsYXk+v6G8rSC9x8fgIChhbHNvOiAtLWRpc3BsYXkpIgogCiBtc2dpZCAiLS1yb2xlIDxyb2xlPlx0U2V0IGEgdW5pcXVlIHJvbGUgdG8gaWRlbnRpZnkgdGhlIG1haW4gd2luZG93IgpAQCAtNjgxMSw3ICs2ODA4LDcgQEAKIG1zZ3N0ciAibGlzdCC79sDOwMwgufzAp7imILn+vu6ztb3AtM+02SIKIAogIywgYy1mb3JtYXQKLSN+IG1zZ2lkICJpbnRlcm5hbCBlcnJvcjogZmFpbGVkIHRvIGdldCB2aW0gbGlzdCBpdGVtICVkIgorI34gbXNnaWQgImludGVybmFsIGVycm9yOiBmYWlsZWQgdG8gZ2V0IFZpbSBsaXN0IGl0ZW0gJWQiCiAjfiBtc2dzdHIgIiIKIAogI34gbXNnaWQgInNsaWNlIHN0ZXAgY2Fubm90IGJlIHplcm8iCkBAIC02ODIyLDcgKzY4MTksNyBAQAogI34gbXNnc3RyICIiCiAKICMsIGMtZm9ybWF0Ci0jfiBtc2dpZCAiaW50ZXJuYWwgZXJyb3I6IG5vIHZpbSBsaXN0IGl0ZW0gJWQiCisjfiBtc2dpZCAiaW50ZXJuYWwgZXJyb3I6IG5vIFZpbSBsaXN0IGl0ZW0gJWQiCiAjfiBtc2dzdHIgIiIKIAogI34gbXNnaWQgImludGVybmFsIGVycm9yOiBub3QgZW5vdWdoIGxpc3QgaXRlbXMiCkBAIC02OTMxLDE5ICs2OTI4LDE5IEBACiAjfiBtc2dpZCAiRTg1ODogRXZhbCBkaWQgbm90IHJldHVybiBhIHZhbGlkIHB5dGhvbiBvYmplY3QiCiAjfiBtc2dzdHIgIiIKIAotI34gbXNnaWQgIkU4NTk6IEZhaWxlZCB0byBjb252ZXJ0IHJldHVybmVkIHB5dGhvbiBvYmplY3QgdG8gdmltIHZhbHVlIgorI34gbXNnaWQgIkU4NTk6IEZhaWxlZCB0byBjb252ZXJ0IHJldHVybmVkIHB5dGhvbiBvYmplY3QgdG8gYSBWaW0gdmFsdWUiCiAjfiBtc2dzdHIgIiIKIAogIywgYy1mb3JtYXQKLSN+IG1zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byB2aW0gZGljdGlvbmFyeSIKKyN+IG1zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byBhIFZpbSBkaWN0aW9uYXJ5IgogI34gbXNnc3RyICIiCiAKICMsIGMtZm9ybWF0Ci1tc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gdmltIGxpc3QiCittc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gYSBWaW0gbGlzdCIKIG1zZ3N0ciAiJXPAuyi4pikgdmltIGxpc3S3ziC6r7Dmx9IgvPYgvvi9wLTPtNkiCiAKICMsIGMtZm9ybWF0Ci0jfiBtc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gdmltIHN0cnVjdHVyZSIKKyN+IG1zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byBhIFZpbSBzdHJ1Y3R1cmUiCiAjfiBtc2dzdHIgIiIKIAogI34gbXNnaWQgImludGVybmFsIGVycm9yOiBOVUxMIHJlZmVyZW5jZSBwYXNzZWQiCmRpZmYgLS1naXQgYS9zcmMvcG8vbmIucG8gYi9zcmMvcG8vbmIucG8KaW5kZXggYTU4MjRlYi4uN2U5OWRlYiAxMDA2NDQKLS0tIGEvc3JjL3BvL25iLnBvCisrKyBiL3NyYy9wby9uYi5wbwpAQCAtMjY0OCw5ICsyNjQ4LDYgQEAKIG1zZ2lkICJrZXlib2FyZCBpbnRlcnJ1cHQiCiBtc2dzdHIgInRhc3RhdHVyYXZicnVkZCIKIAotbXNnaWQgInZpbSBlcnJvciIKLW1zZ3N0ciAidmltLWZlaWwiCi0KIG1zZ2lkICJjYW5ub3QgY3JlYXRlIGJ1ZmZlci93aW5kb3cgY29tbWFuZDogb2JqZWN0IGlzIGJlaW5nIGRlbGV0ZWQiCiBtc2dzdHIgImthbiBpa2tlIG9wcHJldHRlIGJ1ZmZlci92aW5kdWtvbW1hbmRvOiBPYmpla3RldCBzbGV0dGVzIgogCkBAIC0yOTQ2LDggKzI5NDMsOCBAQAogbXNnaWQgIi14XHRcdFx0RWRpdCBlbmNyeXB0ZWQgZmlsZXMiCiBtc2dzdHIgIi14XHRcdFx0UmVkaWdlciBrcnlwdGVydGUgZmlsZXIiCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdENvbm5lY3QgdmltIHRvIHRoaXMgcGFydGljdWxhciBYLXNlcnZlciIKLW1zZ3N0ciAiLWRpc3BsYXkgPGRpc3BsYXk+XHRLb2JsZSB2aW0gdGlsIGRlbm5lIHNwZXNpZWxsZSBYLXRqZW5lcmVuIgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0Q29ubmVjdCBWaW0gdG8gdGhpcyBwYXJ0aWN1bGFyIFgtc2VydmVyIgorbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdEtvYmxlIFZpbSB0aWwgZGVubmUgc3Blc2llbGxlIFgtdGplbmVyZW4iCiAKIG1zZ2lkICItWFx0XHRcdERvIG5vdCBjb25uZWN0IHRvIFggc2VydmVyIgogbXNnc3RyICItWFx0XHRcdFVubmflIG9wcGtvYmxpbmcgdGlsIFgtdGplbmVyIgpAQCAtMzAxNiwxMSArMzAxMywxMSBAQAogIlxuIgogIlBhcmFtZXRlcmUgZ2plbmtqZW50IGF2IGd2aW0gKEF0aGVuYS12ZXJzam9uKTpcbiIKIAotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIHZpbSBvbiA8ZGlzcGxheT4iCi1tc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0S2r4ciB2aW0gcOUgPGRpc3BsYXk+IgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIFZpbSBvbiA8ZGlzcGxheT4iCittc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0S2r4ciBWaW0gcOUgPGRpc3BsYXk+IgogCi1tc2dpZCAiLWljb25pY1x0XHRTdGFydCB2aW0gaWNvbmlmaWVkIgotbXNnc3RyICItaWNvbmljXHRcdFN0YXJ0IHZpbSBzb20gaWtvbiIKK21zZ2lkICItaWNvbmljXHRcdFN0YXJ0IFZpbSBpY29uaWZpZWQiCittc2dzdHIgIi1pY29uaWNcdFx0U3RhcnQgVmltIHNvbSBpa29uIgogCiBtc2dpZCAiLW5hbWUgPG5hbWU+XHRcdFVzZSByZXNvdXJjZSBhcyBpZiB2aW0gd2FzIDxuYW1lPiIKIG1zZ3N0ciAiLW5hbWUgPG5hdm4+XHRcdEJydWsgcmVzc3VycyBzb20gb20gVmltIHZhciA8bmF2bj4iCkBAIC0zMDg5LDggKzMwODYsOCBAQAogIlxuIgogIlBhcmFtZXRlcmUgZ2plbmtqZW50IGF2IGd2aW0gKEdUSystdmVyc2pvbik6XG4iCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biB2aW0gb24gPGRpc3BsYXk+IChhbHNvOiAtLWRpc3BsYXkpIgotbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdEtq+HIgdmltIHDlIDxkaXNwbGF5PiAob2dz5TogLS1kaXNwbGF5KSIKK21zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biBWaW0gb24gPGRpc3BsYXk+IChhbHNvOiAtLWRpc3BsYXkpIgorbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdEtq+HIgVmltIHDlIDxkaXNwbGF5PiAob2dz5TogLS1kaXNwbGF5KSIKIAogbXNnaWQgIi0tcm9sZSA8cm9sZT5cdFNldCBhIHVuaXF1ZSByb2xlIHRvIGlkZW50aWZ5IHRoZSBtYWluIHdpbmRvdyIKIG1zZ3N0ciAiLS1yb2xlIDxyb2xlPlx0U2V0dCBlbiB1bmlrIFwicm9sZVwiIGZvciDlIGlkZW50aWZpc2VyZSBob3ZlZHZpbmR1ZXQiCmRpZmYgLS1naXQgYS9zcmMvcG8vbmwucG8gYi9zcmMvcG8vbmwucG8KaW5kZXggZTVlYjlmNC4uYjRkMGE0NCAxMDA2NDQKLS0tIGEvc3JjL3BvL25sLnBvCisrKyBiL3NyYy9wby9ubC5wbwpAQCAtMjcyMCw5ICsyNzIwLDYgQEAKIG1zZ2lkICJrZXlib2FyZCBpbnRlcnJ1cHQiCiBtc2dzdHIgInRvZXRzZW5ib3JkLWludGVycnVwdCIKIAotbXNnaWQgInZpbSBlcnJvciIKLW1zZ3N0ciAidmltLWZvdXQiCi0KIG1zZ2lkICJjYW5ub3QgY3JlYXRlIGJ1ZmZlci93aW5kb3cgY29tbWFuZDogb2JqZWN0IGlzIGJlaW5nIGRlbGV0ZWQiCiBtc2dzdHIgImFhbm1ha2VuIGJ1ZmZlci0vdmVuc3Rlcm9wZHJhY2h0IGlzIG1pc2x1a3Q6IG9iamVjdCB3b3JkdCB2ZXJ3aWpkZXJkIgogCmRpZmYgLS1naXQgYS9zcmMvcG8vbm8ucG8gYi9zcmMvcG8vbm8ucG8KaW5kZXggYTU4MjRlYi4uN2U5OWRlYiAxMDA2NDQKLS0tIGEvc3JjL3BvL25vLnBvCisrKyBiL3NyYy9wby9uby5wbwpAQCAtMjY0OCw5ICsyNjQ4LDYgQEAKIG1zZ2lkICJrZXlib2FyZCBpbnRlcnJ1cHQiCiBtc2dzdHIgInRhc3RhdHVyYXZicnVkZCIKIAotbXNnaWQgInZpbSBlcnJvciIKLW1zZ3N0ciAidmltLWZlaWwiCi0KIG1zZ2lkICJjYW5ub3QgY3JlYXRlIGJ1ZmZlci93aW5kb3cgY29tbWFuZDogb2JqZWN0IGlzIGJlaW5nIGRlbGV0ZWQiCiBtc2dzdHIgImthbiBpa2tlIG9wcHJldHRlIGJ1ZmZlci92aW5kdWtvbW1hbmRvOiBPYmpla3RldCBzbGV0dGVzIgogCkBAIC0yOTQ2LDggKzI5NDMsOCBAQAogbXNnaWQgIi14XHRcdFx0RWRpdCBlbmNyeXB0ZWQgZmlsZXMiCiBtc2dzdHIgIi14XHRcdFx0UmVkaWdlciBrcnlwdGVydGUgZmlsZXIiCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdENvbm5lY3QgdmltIHRvIHRoaXMgcGFydGljdWxhciBYLXNlcnZlciIKLW1zZ3N0ciAiLWRpc3BsYXkgPGRpc3BsYXk+XHRLb2JsZSB2aW0gdGlsIGRlbm5lIHNwZXNpZWxsZSBYLXRqZW5lcmVuIgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0Q29ubmVjdCBWaW0gdG8gdGhpcyBwYXJ0aWN1bGFyIFgtc2VydmVyIgorbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdEtvYmxlIFZpbSB0aWwgZGVubmUgc3Blc2llbGxlIFgtdGplbmVyZW4iCiAKIG1zZ2lkICItWFx0XHRcdERvIG5vdCBjb25uZWN0IHRvIFggc2VydmVyIgogbXNnc3RyICItWFx0XHRcdFVubmflIG9wcGtvYmxpbmcgdGlsIFgtdGplbmVyIgpAQCAtMzAxNiwxMSArMzAxMywxMSBAQAogIlxuIgogIlBhcmFtZXRlcmUgZ2plbmtqZW50IGF2IGd2aW0gKEF0aGVuYS12ZXJzam9uKTpcbiIKIAotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIHZpbSBvbiA8ZGlzcGxheT4iCi1tc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0S2r4ciB2aW0gcOUgPGRpc3BsYXk+IgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIFZpbSBvbiA8ZGlzcGxheT4iCittc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0S2r4ciBWaW0gcOUgPGRpc3BsYXk+IgogCi1tc2dpZCAiLWljb25pY1x0XHRTdGFydCB2aW0gaWNvbmlmaWVkIgotbXNnc3RyICItaWNvbmljXHRcdFN0YXJ0IHZpbSBzb20gaWtvbiIKK21zZ2lkICItaWNvbmljXHRcdFN0YXJ0IFZpbSBpY29uaWZpZWQiCittc2dzdHIgIi1pY29uaWNcdFx0U3RhcnQgVmltIHNvbSBpa29uIgogCiBtc2dpZCAiLW5hbWUgPG5hbWU+XHRcdFVzZSByZXNvdXJjZSBhcyBpZiB2aW0gd2FzIDxuYW1lPiIKIG1zZ3N0ciAiLW5hbWUgPG5hdm4+XHRcdEJydWsgcmVzc3VycyBzb20gb20gVmltIHZhciA8bmF2bj4iCkBAIC0zMDg5LDggKzMwODYsOCBAQAogIlxuIgogIlBhcmFtZXRlcmUgZ2plbmtqZW50IGF2IGd2aW0gKEdUSystdmVyc2pvbik6XG4iCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biB2aW0gb24gPGRpc3BsYXk+IChhbHNvOiAtLWRpc3BsYXkpIgotbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdEtq+HIgdmltIHDlIDxkaXNwbGF5PiAob2dz5TogLS1kaXNwbGF5KSIKK21zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biBWaW0gb24gPGRpc3BsYXk+IChhbHNvOiAtLWRpc3BsYXkpIgorbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdEtq+HIgVmltIHDlIDxkaXNwbGF5PiAob2dz5TogLS1kaXNwbGF5KSIKIAogbXNnaWQgIi0tcm9sZSA8cm9sZT5cdFNldCBhIHVuaXF1ZSByb2xlIHRvIGlkZW50aWZ5IHRoZSBtYWluIHdpbmRvdyIKIG1zZ3N0ciAiLS1yb2xlIDxyb2xlPlx0U2V0dCBlbiB1bmlrIFwicm9sZVwiIGZvciDlIGlkZW50aWZpc2VyZSBob3ZlZHZpbmR1ZXQiCmRpZmYgLS1naXQgYS9zcmMvcG8vcGwuVVRGLTgucG8gYi9zcmMvcG8vcGwuVVRGLTgucG8KaW5kZXggMGQxNzNmNi4uODg2ZDQzYSAxMDA2NDQKLS0tIGEvc3JjL3BvL3BsLlVURi04LnBvCisrKyBiL3NyYy9wby9wbC5VVEYtOC5wbwpAQCAtMjc2Nyw4ICsyNzY3LDYgQEAKIG1zZ2lkICJrZXlib2FyZCBpbnRlcnJ1cHQiCiBtc2dzdHIgInByemVyd2FuaWUga2xhd2lhdHVyeSIKIAotbXNnaWQgInZpbSBlcnJvciIKLW1zZ3N0ciAiYsWCxIVkIHZpbWEiCiAKIG1zZ2lkICJjYW5ub3QgY3JlYXRlIGJ1ZmZlci93aW5kb3cgY29tbWFuZDogb2JqZWN0IGlzIGJlaW5nIGRlbGV0ZWQiCiBtc2dzdHIgIm5pZSBtb2fEmSBzdHdvcnp5xIcgYnVmb3JhL29rbmEga29tZW5keTogb2JpZWt0IGplc3Qga2Fzb3dhbnkiCkBAIC0zMDc4LDcgKzMwNzYsNyBAQAogbXNnaWQgIi14XHRcdFx0RWRpdCBlbmNyeXB0ZWQgZmlsZXMiCiBtc2dzdHIgIi14XHRcdFx0RWR5dHVqIHpha29kb3dhbmUgcGxpa2kiCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdENvbm5lY3QgdmltIHRvIHRoaXMgcGFydGljdWxhciBYLXNlcnZlciIKK21zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdENvbm5lY3QgVmltIHRvIHRoaXMgcGFydGljdWxhciBYLXNlcnZlciIKIG1zZ3N0ciAiLWRpc3BsYXkgPGRpc3BsYXk+XHRQb2TFgsSFY3ogdmltYSB0byBkYW5lZ28gWC1zZXJ3ZXJhIgogCiBtc2dpZCAiLVhcdFx0XHREbyBub3QgY29ubmVjdCB0byBYIHNlcnZlciIKQEAgLTMxNTMsMTAgKzMxNTEsMTAgQEAKICJcbiIKICJBcmd1bWVudHkgcm96cG96bmF3YW5lIHByemV6IGd2aW0gKHdlcnNqYSBBdGhlbmEpOlxuIgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gdmltIG9uIDxkaXNwbGF5PiIKLW1zZ3N0ciAiLWRpc3BsYXkgPGRpc3BsYXk+XHRaYcWCYWR1aiB2aW0gbmEgPGRpc3BsYXk+IgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIFZpbSBvbiA8ZGlzcGxheT4iCittc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0WmHFgmFkdWogVmltIG5hIDxkaXNwbGF5PiIKIAotbXNnaWQgIi1pY29uaWNcdFx0U3RhcnQgdmltIGljb25pZmllZCIKK21zZ2lkICItaWNvbmljXHRcdFN0YXJ0IFZpbSBpY29uaWZpZWQiCiBtc2dzdHIgIi1pY29uaWNcdFx0WmFjem5paiBWaW0gamFrbyBpa29uxJkiCiAKIG1zZ2lkICItYmFja2dyb3VuZCA8Y29sb3I+XHRVc2UgPGNvbG9yPiBmb3IgdGhlIGJhY2tncm91bmQgKGFsc286IC1iZykiCkBAIC0zMjA2LDggKzMyMDQsOCBAQAogIlxuIgogIkFyZ3VtZW50eSByb3pwb3puYXdhbmUgcHJ6ZXogZ3ZpbSAod2Vyc2phIEdUSyspOlxuIgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gdmltIG9uIDxkaXNwbGF5PiAoYWxzbzogLS1kaXNwbGF5KSIKLW1zZ3N0ciAiLWRpc3BsYXkgPGRpc3BsYXk+XHRaYXN0YXJ0dWogdmltIG5hIDxkaXNwbGF5PiAocsOzd25pZcW8OiAtLWRpc3BsYXkpIgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIFZpbSBvbiA8ZGlzcGxheT4gKGFsc286IC0tZGlzcGxheSkiCittc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0WmFzdGFydHVqIFZpbSBuYSA8ZGlzcGxheT4gKHLDs3duaWXFvDogLS1kaXNwbGF5KSIKIAogbXNnaWQgIi0tcm9sZSA8cm9sZT5cdFNldCBhIHVuaXF1ZSByb2xlIHRvIGlkZW50aWZ5IHRoZSBtYWluIHdpbmRvdyIKIG1zZ3N0ciAiLS1yb2xlIDxyb2xlPlx0VXN0YXcgdW5pa2F0b3fEhSByb2zEmSBkbyBpZGVudHlmaWthY2ppIGfFgsOzd25lZ28gb2tuYSIKQEAgLTY2NDMsMTQgKzY2NDEsMTQgQEAKIAogIy4gTm8gbW9yZSBzdWl0YWJsZSBmb3JtYXQgc3BlY2lmaWNhdGlvbnMgaW4gcHl0aG9uLTIuMwogIywgYy1mb3JtYXQKLW1zZ2lkICJpbnRlcm5hbCBlcnJvcjogZmFpbGVkIHRvIGdldCB2aW0gbGlzdCBpdGVtICVkIgorbXNnaWQgImludGVybmFsIGVycm9yOiBmYWlsZWQgdG8gZ2V0IFZpbSBsaXN0IGl0ZW0gJWQiCiBtc2dzdHIgImLFgsSFZCB3ZXduxJl0cnpueTogbmllIHBvd2lvZMWCbyBzacSZIHBvYnJhbmllIHogbGlzdHkgVmltYSBlbGVtZW50dSAlZCIKIAogbXNnaWQgImZhaWxlZCB0byBhZGQgaXRlbSB0byBsaXN0IgogbXNnc3RyICJuaWUgcG93aW9kxYJvIHNpxJkgZG9kYW5pZSBlbGVtZW50dSBkbyBsaXN0eSIKIAogIywgYy1mb3JtYXQKLW1zZ2lkICJpbnRlcm5hbCBlcnJvcjogbm8gdmltIGxpc3QgaXRlbSAlZCIKK21zZ2lkICJpbnRlcm5hbCBlcnJvcjogbm8gVmltIGxpc3QgaXRlbSAlZCIKIG1zZ3N0ciAiYsWCxIVkIHdld27EmXRyem55OiB3IGxpxZtjaWUgVmltYSBicmFrIGVsZW1lbnR1ICVkIgogCiBtc2dpZCAiaW50ZXJuYWwgZXJyb3I6IGZhaWxlZCB0byBhZGQgaXRlbSB0byBsaXN0IgpAQCAtNjc1Miw3ICs2NzUwLDcgQEAKIG1zZ2lkICJFODU4OiBFdmFsIGRpZCBub3QgcmV0dXJuIGEgdmFsaWQgcHl0aG9uIG9iamVjdCIKIG1zZ3N0ciAiRTg1ODogZXZhbCBuaWUgendyw7NjacWCbyBvZHBvd2llZG5pZWdvIG9iaWVrdHUgcHl0aG9uYSIKIAotbXNnaWQgIkU4NTk6IEZhaWxlZCB0byBjb252ZXJ0IHJldHVybmVkIHB5dGhvbiBvYmplY3QgdG8gdmltIHZhbHVlIgorbXNnaWQgIkU4NTk6IEZhaWxlZCB0byBjb252ZXJ0IHJldHVybmVkIHB5dGhvbiBvYmplY3QgdG8gYSBWaW0gdmFsdWUiCiBtc2dzdHIgIkU4NTk6IE5pZSBwb3dpb2TFgmEgc2nEmSBrb253ZXJzamEgb2JpZWt0dSBweXRob25hIGRvIHdhcnRvxZtjaSBWaW1hIgogCiAjLCBjLWZvcm1hdApkaWZmIC0tZ2l0IGEvc3JjL3BvL3BsLmNwMTI1MC5wbyBiL3NyYy9wby9wbC5jcDEyNTAucG8KaW5kZXggYTFlNWE0NS4uMDA3YzhkMyAxMDA2NDQKLS0tIGEvc3JjL3BvL3BsLmNwMTI1MC5wbworKysgYi9zcmMvcG8vcGwuY3AxMjUwLnBvCkBAIC0yNzY3LDggKzI3NjcsNiBAQAogbXNnaWQgImtleWJvYXJkIGludGVycnVwdCIKIG1zZ3N0ciAicHJ6ZXJ3YW5pZSBrbGF3aWF0dXJ5IgogCi1tc2dpZCAidmltIGVycm9yIgotbXNnc3RyICJis7lkIHZpbWEiCiAKIG1zZ2lkICJjYW5ub3QgY3JlYXRlIGJ1ZmZlci93aW5kb3cgY29tbWFuZDogb2JqZWN0IGlzIGJlaW5nIGRlbGV0ZWQiCiBtc2dzdHIgIm5pZSBtb2fqIHN0d29yennmIGJ1Zm9yYS9va25hIGtvbWVuZHk6IG9iaWVrdCBqZXN0IGthc293YW55IgpAQCAtMzA3OCw3ICszMDc2LDcgQEAKIG1zZ2lkICIteFx0XHRcdEVkaXQgZW5jcnlwdGVkIGZpbGVzIgogbXNnc3RyICIteFx0XHRcdEVkeXR1aiB6YWtvZG93YW5lIHBsaWtpIgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRDb25uZWN0IHZpbSB0byB0aGlzIHBhcnRpY3VsYXIgWC1zZXJ2ZXIiCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRDb25uZWN0IFZpbSB0byB0aGlzIHBhcnRpY3VsYXIgWC1zZXJ2ZXIiCiBtc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UG9ks7ljeiB2aW1hIHRvIGRhbmVnbyBYLXNlcndlcmEiCiAKIG1zZ2lkICItWFx0XHRcdERvIG5vdCBjb25uZWN0IHRvIFggc2VydmVyIgpAQCAtMzE1MywxMCArMzE1MSwxMCBAQAogIlxuIgogIkFyZ3VtZW50eSByb3pwb3puYXdhbmUgcHJ6ZXogZ3ZpbSAod2Vyc2phIEF0aGVuYSk6XG4iCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biB2aW0gb24gPGRpc3BsYXk+IgotbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdFphs2FkdWogdmltIG5hIDxkaXNwbGF5PiIKK21zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biBWaW0gb24gPGRpc3BsYXk+IgorbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdFphs2FkdWogVmltIG5hIDxkaXNwbGF5PiIKIAotbXNnaWQgIi1pY29uaWNcdFx0U3RhcnQgdmltIGljb25pZmllZCIKK21zZ2lkICItaWNvbmljXHRcdFN0YXJ0IFZpbSBpY29uaWZpZWQiCiBtc2dzdHIgIi1pY29uaWNcdFx0WmFjem5paiBWaW0gamFrbyBpa29u6iIKIAogbXNnaWQgIi1iYWNrZ3JvdW5kIDxjb2xvcj5cdFVzZSA8Y29sb3I+IGZvciB0aGUgYmFja2dyb3VuZCAoYWxzbzogLWJnKSIKQEAgLTMyMDYsOCArMzIwNCw4IEBACiAiXG4iCiAiQXJndW1lbnR5IHJvenBvem5hd2FuZSBwcnpleiBndmltICh3ZXJzamEgR1RLKyk6XG4iCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biB2aW0gb24gPGRpc3BsYXk+IChhbHNvOiAtLWRpc3BsYXkpIgotbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdFphc3RhcnR1aiB2aW0gbmEgPGRpc3BsYXk+IChy83duaWW/OiAtLWRpc3BsYXkpIgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIFZpbSBvbiA8ZGlzcGxheT4gKGFsc286IC0tZGlzcGxheSkiCittc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0WmFzdGFydHVqIFZpbSBuYSA8ZGlzcGxheT4gKHLzd25pZb86IC0tZGlzcGxheSkiCiAKIG1zZ2lkICItLXJvbGUgPHJvbGU+XHRTZXQgYSB1bmlxdWUgcm9sZSB0byBpZGVudGlmeSB0aGUgbWFpbiB3aW5kb3ciCiBtc2dzdHIgIi0tcm9sZSA8cm9sZT5cdFVzdGF3IHVuaWthdG93uSByb2zqIGRvIGlkZW50eWZpa2FjamkgZ7Pzd25lZ28gb2tuYSIKQEAgLTY2NDMsMTQgKzY2NDEsMTQgQEAKIAogIy4gTm8gbW9yZSBzdWl0YWJsZSBmb3JtYXQgc3BlY2lmaWNhdGlvbnMgaW4gcHl0aG9uLTIuMwogIywgYy1mb3JtYXQKLW1zZ2lkICJpbnRlcm5hbCBlcnJvcjogZmFpbGVkIHRvIGdldCB2aW0gbGlzdCBpdGVtICVkIgorbXNnaWQgImludGVybmFsIGVycm9yOiBmYWlsZWQgdG8gZ2V0IFZpbSBsaXN0IGl0ZW0gJWQiCiBtc2dzdHIgImKzuWQgd2V3bup0cnpueTogbmllIHBvd2lvZLNvIHNp6iBwb2JyYW5pZSB6IGxpc3R5IFZpbWEgZWxlbWVudHUgJWQiCiAKIG1zZ2lkICJmYWlsZWQgdG8gYWRkIGl0ZW0gdG8gbGlzdCIKIG1zZ3N0ciAibmllIHBvd2lvZLNvIHNp6iBkb2RhbmllIGVsZW1lbnR1IGRvIGxpc3R5IgogCiAjLCBjLWZvcm1hdAotbXNnaWQgImludGVybmFsIGVycm9yOiBubyB2aW0gbGlzdCBpdGVtICVkIgorbXNnaWQgImludGVybmFsIGVycm9yOiBubyBWaW0gbGlzdCBpdGVtICVkIgogbXNnc3RyICJis7lkIHdld27qdHJ6bnk6IHcgbGmcY2llIFZpbWEgYnJhayBlbGVtZW50dSAlZCIKIAogbXNnaWQgImludGVybmFsIGVycm9yOiBmYWlsZWQgdG8gYWRkIGl0ZW0gdG8gbGlzdCIKQEAgLTY3NTIsNyArNjc1MCw3IEBACiBtc2dpZCAiRTg1ODogRXZhbCBkaWQgbm90IHJldHVybiBhIHZhbGlkIHB5dGhvbiBvYmplY3QiCiBtc2dzdHIgIkU4NTg6IGV2YWwgbmllIHp3cvNjabNvIG9kcG93aWVkbmllZ28gb2JpZWt0dSBweXRob25hIgogCi1tc2dpZCAiRTg1OTogRmFpbGVkIHRvIGNvbnZlcnQgcmV0dXJuZWQgcHl0aG9uIG9iamVjdCB0byB2aW0gdmFsdWUiCittc2dpZCAiRTg1OTogRmFpbGVkIHRvIGNvbnZlcnQgcmV0dXJuZWQgcHl0aG9uIG9iamVjdCB0byBhIFZpbSB2YWx1ZSIKIG1zZ3N0ciAiRTg1OTogTmllIHBvd2lvZLNhIHNp6iBrb253ZXJzamEgb2JpZWt0dSBweXRob25hIGRvIHdhcnRvnGNpIFZpbWEiCiAKICMsIGMtZm9ybWF0CmRpZmYgLS1naXQgYS9zcmMvcG8vcGwucG8gYi9zcmMvcG8vcGwucG8KaW5kZXggMGQyYmEzNC4uZWI5NWJkNSAxMDA2NDQKLS0tIGEvc3JjL3BvL3BsLnBvCisrKyBiL3NyYy9wby9wbC5wbwpAQCAtMjc2Nyw4ICsyNzY3LDYgQEAKIG1zZ2lkICJrZXlib2FyZCBpbnRlcnJ1cHQiCiBtc2dzdHIgInByemVyd2FuaWUga2xhd2lhdHVyeSIKIAotbXNnaWQgInZpbSBlcnJvciIKLW1zZ3N0ciAiYrOxZCB2aW1hIgogCiBtc2dpZCAiY2Fubm90IGNyZWF0ZSBidWZmZXIvd2luZG93IGNvbW1hbmQ6IG9iamVjdCBpcyBiZWluZyBkZWxldGVkIgogbXNnc3RyICJuaWUgbW9n6iBzdHdvcnp55iBidWZvcmEvb2tuYSBrb21lbmR5OiBvYmlla3QgamVzdCBrYXNvd2FueSIKQEAgLTMwNzgsNyArMzA3Niw3IEBACiBtc2dpZCAiLXhcdFx0XHRFZGl0IGVuY3J5cHRlZCBmaWxlcyIKIG1zZ3N0ciAiLXhcdFx0XHRFZHl0dWogemFrb2Rvd2FuZSBwbGlraSIKIAotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0Q29ubmVjdCB2aW0gdG8gdGhpcyBwYXJ0aWN1bGFyIFgtc2VydmVyIgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0Q29ubmVjdCBWaW0gdG8gdGhpcyBwYXJ0aWN1bGFyIFgtc2VydmVyIgogbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdFBvZLOxY3ogdmltYSB0byBkYW5lZ28gWC1zZXJ3ZXJhIgogCiBtc2dpZCAiLVhcdFx0XHREbyBub3QgY29ubmVjdCB0byBYIHNlcnZlciIKQEAgLTMxNTMsMTAgKzMxNTEsMTAgQEAKICJcbiIKICJBcmd1bWVudHkgcm96cG96bmF3YW5lIHByemV6IGd2aW0gKHdlcnNqYSBBdGhlbmEpOlxuIgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gdmltIG9uIDxkaXNwbGF5PiIKLW1zZ3N0ciAiLWRpc3BsYXkgPGRpc3BsYXk+XHRaYbNhZHVqIHZpbSBuYSA8ZGlzcGxheT4iCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gVmltIG9uIDxkaXNwbGF5PiIKK21zZ3N0ciAiLWRpc3BsYXkgPGRpc3BsYXk+XHRaYbNhZHVqIFZpbSBuYSA8ZGlzcGxheT4iCiAKLW1zZ2lkICItaWNvbmljXHRcdFN0YXJ0IHZpbSBpY29uaWZpZWQiCittc2dpZCAiLWljb25pY1x0XHRTdGFydCBWaW0gaWNvbmlmaWVkIgogbXNnc3RyICItaWNvbmljXHRcdFphY3puaWogVmltIGpha28gaWtvbuoiCiAKIG1zZ2lkICItYmFja2dyb3VuZCA8Y29sb3I+XHRVc2UgPGNvbG9yPiBmb3IgdGhlIGJhY2tncm91bmQgKGFsc286IC1iZykiCkBAIC0zMjA2LDggKzMyMDQsOCBAQAogIlxuIgogIkFyZ3VtZW50eSByb3pwb3puYXdhbmUgcHJ6ZXogZ3ZpbSAod2Vyc2phIEdUSyspOlxuIgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gdmltIG9uIDxkaXNwbGF5PiAoYWxzbzogLS1kaXNwbGF5KSIKLW1zZ3N0ciAiLWRpc3BsYXkgPGRpc3BsYXk+XHRaYXN0YXJ0dWogdmltIG5hIDxkaXNwbGF5PiAocvN3bmllvzogLS1kaXNwbGF5KSIKK21zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biBWaW0gb24gPGRpc3BsYXk+IChhbHNvOiAtLWRpc3BsYXkpIgorbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdFphc3RhcnR1aiBWaW0gbmEgPGRpc3BsYXk+IChy83duaWW/OiAtLWRpc3BsYXkpIgogCiBtc2dpZCAiLS1yb2xlIDxyb2xlPlx0U2V0IGEgdW5pcXVlIHJvbGUgdG8gaWRlbnRpZnkgdGhlIG1haW4gd2luZG93IgogbXNnc3RyICItLXJvbGUgPHJvbGU+XHRVc3RhdyB1bmlrYXRvd7Egcm9s6iBkbyBpZGVudHlmaWthY2ppIGez83duZWdvIG9rbmEiCkBAIC02NjQzLDE0ICs2NjQxLDE0IEBACiAKICMuIE5vIG1vcmUgc3VpdGFibGUgZm9ybWF0IHNwZWNpZmljYXRpb25zIGluIHB5dGhvbi0yLjMKICMsIGMtZm9ybWF0Ci1tc2dpZCAiaW50ZXJuYWwgZXJyb3I6IGZhaWxlZCB0byBnZXQgdmltIGxpc3QgaXRlbSAlZCIKK21zZ2lkICJpbnRlcm5hbCBlcnJvcjogZmFpbGVkIHRvIGdldCBWaW0gbGlzdCBpdGVtICVkIgogbXNnc3RyICJis7FkIHdld27qdHJ6bnk6IG5pZSBwb3dpb2SzbyBzaeogcG9icmFuaWUgeiBsaXN0eSBWaW1hIGVsZW1lbnR1ICVkIgogCiBtc2dpZCAiZmFpbGVkIHRvIGFkZCBpdGVtIHRvIGxpc3QiCiBtc2dzdHIgIm5pZSBwb3dpb2SzbyBzaeogZG9kYW5pZSBlbGVtZW50dSBkbyBsaXN0eSIKIAogIywgYy1mb3JtYXQKLW1zZ2lkICJpbnRlcm5hbCBlcnJvcjogbm8gdmltIGxpc3QgaXRlbSAlZCIKK21zZ2lkICJpbnRlcm5hbCBlcnJvcjogbm8gVmltIGxpc3QgaXRlbSAlZCIKIG1zZ3N0ciAiYrOxZCB3ZXdu6nRyem55OiB3IGxptmNpZSBWaW1hIGJyYWsgZWxlbWVudHUgJWQiCiAKIG1zZ2lkICJpbnRlcm5hbCBlcnJvcjogZmFpbGVkIHRvIGFkZCBpdGVtIHRvIGxpc3QiCkBAIC02NzUyLDcgKzY3NTAsNyBAQAogbXNnaWQgIkU4NTg6IEV2YWwgZGlkIG5vdCByZXR1cm4gYSB2YWxpZCBweXRob24gb2JqZWN0IgogbXNnc3RyICJFODU4OiBldmFsIG5pZSB6d3LzY2mzbyBvZHBvd2llZG5pZWdvIG9iaWVrdHUgcHl0aG9uYSIKIAotbXNnaWQgIkU4NTk6IEZhaWxlZCB0byBjb252ZXJ0IHJldHVybmVkIHB5dGhvbiBvYmplY3QgdG8gdmltIHZhbHVlIgorbXNnaWQgIkU4NTk6IEZhaWxlZCB0byBjb252ZXJ0IHJldHVybmVkIHB5dGhvbiBvYmplY3QgdG8gYSBWaW0gdmFsdWUiCiBtc2dzdHIgIkU4NTk6IE5pZSBwb3dpb2SzYSBzaeoga29ud2Vyc2phIG9iaWVrdHUgcHl0aG9uYSBkbyB3YXJ0b7ZjaSBWaW1hIgogCiAjLCBjLWZvcm1hdApkaWZmIC0tZ2l0IGEvc3JjL3BvL3B0X0JSLnBvIGIvc3JjL3BvL3B0X0JSLnBvCmluZGV4IDhhY2VmMGUuLjY1ZGNmMzcgMTAwNjQ0Ci0tLSBhL3NyYy9wby9wdF9CUi5wbworKysgYi9zcmMvcG8vcHRfQlIucG8KQEAgLTI3NjUsOSArMjc2NSw2IEBACiBtc2dpZCAia2V5Ym9hcmQgaW50ZXJydXB0IgogbXNnc3RyICJpbnRlcnJvbXBpZG8gcGVsbyB0ZWNsYWRvIgogCi1tc2dpZCAidmltIGVycm9yIgotbXNnc3RyICJlcnJvIGRvIHZpbSIKLQogbXNnaWQgImNhbm5vdCBjcmVhdGUgYnVmZmVyL3dpbmRvdyBjb21tYW5kOiBvYmplY3QgaXMgYmVpbmcgZGVsZXRlZCIKIG1zZ3N0ciAiIgogImltcG9zc8OtdmVsIGNyaWFyIGNvbWFuZG8gZGUgYnVmZmVyL2phbmVsYTogbyBvYmpldG8gZXN0w6Egc2VuZG8gZXhjbHXDrWRvIgpAQCAtMzA5Niw4ICszMDkzLDggQEAKIG1zZ2lkICIteFx0XHRcdEVkaXQgZW5jcnlwdGVkIGZpbGVzIgogbXNnc3RyICIteFx0XHRcdEVkaXRhciBhcnF1aXZvcyBjcmlwdG9ncmFmYWRvcyIKIAotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0Q29ubmVjdCB2aW0gdG8gdGhpcyBwYXJ0aWN1bGFyIFgtc2VydmVyIgotbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdENvbmVjdGFyIG8gdmltIGEgZXN0ZSBzZXJ2aWRvciBYIGVzcGVjw61maWNvIgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0Q29ubmVjdCBWaW0gdG8gdGhpcyBwYXJ0aWN1bGFyIFgtc2VydmVyIgorbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdENvbmVjdGFyIG8gVmltIGEgZXN0ZSBzZXJ2aWRvciBYIGVzcGVjw61maWNvIgogCiBtc2dpZCAiLVhcdFx0XHREbyBub3QgY29ubmVjdCB0byBYIHNlcnZlciIKIG1zZ3N0ciAiLVhcdFx0XHROw6NvIGNvbmVjdGFyIGFvIHNlcnZpZG9yIFgiCkBAIC0zMTc1LDExICszMTcyLDExIEBACiAiXG4iCiAiQXJndW1lbnRvcyByZWNvbmhlY2lkb3MgcGVsbyBndmltICh2ZXJzw6NvIEF0aGVuYSk6XG4iCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biB2aW0gb24gPGRpc3BsYXk+IgotbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdEV4ZWN1dGFyIHZpbSBlbSA8ZGlzcGxheT4iCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gVmltIG9uIDxkaXNwbGF5PiIKK21zZ3N0ciAiLWRpc3BsYXkgPGRpc3BsYXk+XHRFeGVjdXRhciBWaW0gZW0gPGRpc3BsYXk+IgogCi1tc2dpZCAiLWljb25pY1x0XHRTdGFydCB2aW0gaWNvbmlmaWVkIgotbXNnc3RyICItaWNvbmljXHRcdEluaWNpYXIgdmltIGljb25pemFkbyIKK21zZ2lkICItaWNvbmljXHRcdFN0YXJ0IFZpbSBpY29uaWZpZWQiCittc2dzdHIgIi1pY29uaWNcdFx0SW5pY2lhciBWaW0gaWNvbml6YWRvIgogCiBtc2dpZCAiLWJhY2tncm91bmQgPGNvbG9yPlx0VXNlIDxjb2xvcj4gZm9yIHRoZSBiYWNrZ3JvdW5kIChhbHNvOiAtYmcpIgogbXNnc3RyICItYmFja2dyb3VuZCA8Y29yPlx0VXNhciA8Y29yPiBwYXJhIG8gZnVuZG8gKGFicmV2LjogLWJnKSIKQEAgLTMyMjcsOCArMzIyNCw4IEBACiAiXG4iCiAiQXJndW1lbnRvcyByZWNvbmhlY2lkb3MgcGVsbyBndmltICh2ZXJzw6NvIEdUSyspOlxuIgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gdmltIG9uIDxkaXNwbGF5PiAoYWxzbzogLS1kaXNwbGF5KSIKLW1zZ3N0ciAiLWRpc3BsYXkgPGRpc3BsYXk+XHRFeGVjdXRhciB2aW0gbm8gPGRpc3BsYXk+IChhbHQuOiAtLWRpc3BsYXkpIgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIFZpbSBvbiA8ZGlzcGxheT4gKGFsc286IC0tZGlzcGxheSkiCittc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0RXhlY3V0YXIgVmltIG5vIDxkaXNwbGF5PiAoYWx0LjogLS1kaXNwbGF5KSIKIAogbXNnaWQgIi0tcm9sZSA8cm9sZT5cdFNldCBhIHVuaXF1ZSByb2xlIHRvIGlkZW50aWZ5IHRoZSBtYWluIHdpbmRvdyIKIG1zZ3N0ciAiIgpAQCAtNjg0OSw3ICs2ODQ2LDcgQEAKIG1zZ3N0ciAiw61uZGljZSBkZSBsaXN0YSBmb3JhIGRvcyBsaW1pdGVzIgogCiAjLCBjLWZvcm1hdAotbXNnaWQgImludGVybmFsIGVycm9yOiBmYWlsZWQgdG8gZ2V0IHZpbSBsaXN0IGl0ZW0gJWQiCittc2dpZCAiaW50ZXJuYWwgZXJyb3I6IGZhaWxlZCB0byBnZXQgVmltIGxpc3QgaXRlbSAlZCIKIG1zZ3N0ciAiZXJybyBpbnRlcm5vOiBuw6NvIGNvbnNlZ3VpIG9idGVyIGl0ZW0gJWQgZGUgbGlzdGEgZG8gVmltIgogCiBtc2dpZCAic2xpY2Ugc3RlcCBjYW5ub3QgYmUgemVybyIKQEAgLTY4NjEsNyArNjg1OCw3IEBACiAidGVudGF0aXZhIGRlIGF0cmlidWlyIHNlcXXDqm5jaWEgZGUgdGFtYW5obyBtYWlvciBxdWUgJWQgYSBzbGljZSBlc3RlbmRpZGEiCiAKICMsIGMtZm9ybWF0Ci1tc2dpZCAiaW50ZXJuYWwgZXJyb3I6IG5vIHZpbSBsaXN0IGl0ZW0gJWQiCittc2dpZCAiaW50ZXJuYWwgZXJyb3I6IG5vIFZpbSBsaXN0IGl0ZW0gJWQiCiBtc2dzdHIgImVycm8gaW50ZXJubzogbsOjbyBleGlzdGUgbyBpdGVtICVkIG5hIGxpc3RhIGRvIHZpbSIKIAogbXNnaWQgImludGVybmFsIGVycm9yOiBub3QgZW5vdWdoIGxpc3QgaXRlbXMiCkBAIC02OTcxLDIwICs2OTY4LDIwIEBACiBtc2dpZCAiRTg1ODogRXZhbCBkaWQgbm90IHJldHVybiBhIHZhbGlkIHB5dGhvbiBvYmplY3QiCiBtc2dzdHIgIkU4NTg6IEV2YWwgbsOjbyBkZXZvbHZldSB1bSBvYmpldG8gcHl0aG9uIHbDoWxpZG8iCiAKLW1zZ2lkICJFODU5OiBGYWlsZWQgdG8gY29udmVydCByZXR1cm5lZCBweXRob24gb2JqZWN0IHRvIHZpbSB2YWx1ZSIKK21zZ2lkICJFODU5OiBGYWlsZWQgdG8gY29udmVydCByZXR1cm5lZCBweXRob24gb2JqZWN0IHRvIGEgVmltIHZhbHVlIgogbXNnc3RyICIiCiAiRTg1OTogRmFsaGEgYW8gY29udmVydGVyIG8gb2JqZXRvIGRldm9sdmlkbyBwZWxvIHB5dGhvbiBwYXJhIHVtIHZhbG9yIGRvIHZpbSIKIAogIywgYy1mb3JtYXQKLW1zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byB2aW0gZGljdGlvbmFyeSIKK21zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byBhIFZpbSBkaWN0aW9uYXJ5IgogbXNnc3RyICJpbXBvc3PDrXZlbCBjb252ZXJ0ZXIgJXMgcGFyYSBkaWNpb27DoXJpbyBkbyB2aW0iCiAKICMsIGMtZm9ybWF0Ci1tc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gdmltIGxpc3QiCittc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gYSBWaW0gbGlzdCIKIG1zZ3N0ciAiaW1wb3Nzw612ZWwgY29udmVydGVyICVzIHBhcmEgbGlzdGEgZG8gdmltIgogCiAjLCBjLWZvcm1hdAotbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIHZpbSBzdHJ1Y3R1cmUiCittc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gYSBWaW0gc3RydWN0dXJlIgogbXNnc3RyICJpbXBvc3PDrXZlbCBjb252ZXJ0ZXIgJXMgcGFyYSBlc3RydXR1cmEgZG8gdmltIgogCiBtc2dpZCAiaW50ZXJuYWwgZXJyb3I6IE5VTEwgcmVmZXJlbmNlIHBhc3NlZCIKZGlmZiAtLWdpdCBhL3NyYy9wby9ydS5jcDEyNTEucG8gYi9zcmMvcG8vcnUuY3AxMjUxLnBvCmluZGV4IDUwYzFkYTIuLmJkOWM5ZGMgMTAwNjQ0Ci0tLSBhL3NyYy9wby9ydS5jcDEyNTEucG8KKysrIGIvc3JjL3BvL3J1LmNwMTI1MS5wbwpAQCAtMjY0Miw5ICsyNjQyLDYgQEAKIG1zZ2lkICJrZXlib2FyZCBpbnRlcnJ1cHQiCiBtc2dzdHIgIurr4OLo4PLz8O3u5SDv8OXw++Lg7ejlIgogCi1tc2dpZCAidmltIGVycm9yIgotbXNnc3RyICLu+Ojh6uAgVklNIgotCiBtc2dpZCAiY2Fubm90IGNyZWF0ZSBidWZmZXIvd2luZG93IGNvbW1hbmQ6IG9iamVjdCBpcyBiZWluZyBkZWxldGVkIgogbXNnc3RyICLt5eLu5+zu5u3uIPHu5+Tg8vwg6u7s4O3k8yDh8/Tl8OAg6OvoIO7q7eA6IO7h+uXq8iDiIO/w7vbl8fHlIPPk4Ovl7ej/IgogCkBAIC0zMTMyLDcgKzMxMjksNyBAQAogbXNnaWQgIi14XHRcdFx0RWRpdCBlbmNyeXB0ZWQgZmlsZXMiCiBtc2dzdHIgIi14XHRcdFx00OXk4Ory6PDu4uDt6OUg5+D46PTw7uLg7e379SD04Onr7uIiCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdENvbm5lY3QgdmltIHRvIHRoaXMgcGFydGljdWxhciBYLXNlcnZlciIKK21zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdENvbm5lY3QgVmltIHRvIHRoaXMgcGFydGljdWxhciBYLXNlcnZlciIKIG1zZ3N0ciAiLWRpc3BsYXkgPP3q8ODtPlx0z+7k8e7l5Ojt6PL8IFZpbSDqIPPq4Ofg7e3u7PMgWC3x5fDi5fDzIgogCiBtc2dpZCAiLVhcdFx0XHREbyBub3QgY29ubmVjdCB0byBYIHNlcnZlciIKQEAgLTMyMTAsMTAgKzMyMDcsMTAgQEAKICJcbiIKICLP4PDg7OXy8Psg5Ov/IGd2aW0gKOLl8PHo/yBBdGhlbmEpOlxuIgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gdmltIG9uIDxkaXNwbGF5PiIKK21zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biBWaW0gb24gPGRpc3BsYXk+IgogbXNnc3RyICItZGlzcGxheSA85Ojx7+vl6T5cdMfg7/Px8ujy/CBWaW0g7eAg8+rg5+Dt7e7sIDzk6PHv6+XlPiIKIAotbXNnaWQgIi1pY29uaWNcdFx0U3RhcnQgdmltIGljb25pZmllZCIKK21zZ2lkICItaWNvbmljXHRcdFN0YXJ0IFZpbSBpY29uaWZpZWQiCiBtc2dzdHIgIi1pY29uaWNcdFx0x+Dv8/Hy6PL8IFZpbSDiIPHiuPDt8/Lu7CDi6OTlIgogCiBtc2dpZCAiLWJhY2tncm91bmQgPGNvbG9yPlx0VXNlIDxjb2xvcj4gZm9yIHRoZSBiYWNrZ3JvdW5kIChhbHNvOiAtYmcpIgpAQCAtMzI2MCw3ICszMjU3LDcgQEAKICJcbiIKICLP4PDg7OXy8Psg5Ov/IGd2aW0gKOLl8PHo/yBHVEsrKTpcbiIKIAotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIHZpbSBvbiA8ZGlzcGxheT4gKGFsc286IC0tZGlzcGxheSkiCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gVmltIG9uIDxkaXNwbGF5PiAoYWxzbzogLS1kaXNwbGF5KSIKIG1zZ3N0ciAiIgogIi1kaXNwbGF5IDzk6PHv6+XpPlx0x+Dv8/Hy6PL8IFZpbSDt4CDz6uDn4O3t7uwgPOTo8e/r5eU+ICjo6+ggLS1kaXNwbGF5KSIKIApAQCAtNzI2Miw3ICs3MjU5LDcgQEAKIG1zZ3N0ciAiyO3k5erxIPHv6PHq4CDn4CDv8OXk5evg7Ogg5Ojg7+Dn7u3gIgogCiAjLCBjLWZvcm1hdAotbXNnaWQgImludGVybmFsIGVycm9yOiBmYWlsZWQgdG8gZ2V0IHZpbSBsaXN0IGl0ZW0gJWQiCittc2dpZCAiaW50ZXJuYWwgZXJyb3I6IGZhaWxlZCB0byBnZXQgVmltIGxpc3QgaXRlbSAlZCIKIG1zZ3N0ciAiwu3z8vDl7e3//yDu+Ojh6uA6IO3lIPPk4Ovu8fwg7+7r8/fo8vwg/evl7OXt8iBWSU0t8e/o8ergICVkIgogCiBtc2dpZCAic2xpY2Ugc3RlcCBjYW5ub3QgYmUgemVybyIKQEAgLTcyNzUsNyArNzI3Miw3IEBACiAi4vvh7vDq5SIKIAogIywgYy1mb3JtYXQKLW1zZ2lkICJpbnRlcm5hbCBlcnJvcjogbm8gdmltIGxpc3QgaXRlbSAlZCIKK21zZ2lkICJpbnRlcm5hbCBlcnJvcjogbm8gVmltIGxpc3QgaXRlbSAlZCIKIG1zZ3N0ciAiwu3z8vDl7e3//yDu+Ojh6uA6IO3l8iD96+Xs5e3y4CBWSU0t8e/o8ergICVkIgogCiBtc2dpZCAiaW50ZXJuYWwgZXJyb3I6IG5vdCBlbm91Z2ggbGlzdCBpdGVtcyIKQEAgLTczODYsMjAgKzczODMsMjAgQEAKIG1zZ2lkICJFODU4OiBFdmFsIGRpZCBub3QgcmV0dXJuIGEgdmFsaWQgcHl0aG9uIG9iamVjdCIKIG1zZ3N0ciAiRTg1ODogRXZhbCDt5SDi7ufi8ODy6Osg5O7v8/Hy6Ozu4+4g7uH65ery4CBQeXRob24iCiAKLW1zZ2lkICJFODU5OiBGYWlsZWQgdG8gY29udmVydCByZXR1cm5lZCBweXRob24gb2JqZWN0IHRvIHZpbSB2YWx1ZSIKK21zZ2lkICJFODU5OiBGYWlsZWQgdG8gY29udmVydCByZXR1cm5lZCBweXRob24gb2JqZWN0IHRvIGEgVmltIHZhbHVlIgogbXNnc3RyICIiCiAiRTg1OTogzeUg8+Tg6+7x/CDv8OXu4fDg5+7i4PL8IOLu5+Lw4Pm47e376SDu4frl6vIgUHl0aG9uIOIg5+3g9+Xt6OUgVklNIgogCiAjLCBjLWZvcm1hdAotbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIHZpbSBkaWN0aW9uYXJ5IgorbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIGEgVmltIGRpY3Rpb25hcnkiCiBtc2dzdHIgIs3l4u7n7O7m7e4g7/Dl7uHw4Ofu4uDy/CAlcyDiIPHr7uLg8PwgVklNIgogCiAjLCBjLWZvcm1hdAotbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIHZpbSBsaXN0IgorbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIGEgVmltIGxpc3QiCiBtc2dzdHIgIs3l4u7n7O7m7e4g7/Dl7uHw4Ofu4uDy/CAlcyDiIPHv6PHu6iBWSU0iCiAKICMsIGMtZm9ybWF0Ci1tc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gdmltIHN0cnVjdHVyZSIKK21zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byBhIFZpbSBzdHJ1Y3R1cmUiCiBtc2dzdHIgIs3l4u7n7O7m7e4g7/Dl7uHw4Ofu4uDy/CAlcyDiIPHy8PPq8vPw8yBWSU0iCiAKIG1zZ2lkICJpbnRlcm5hbCBlcnJvcjogTlVMTCByZWZlcmVuY2UgcGFzc2VkIgpkaWZmIC0tZ2l0IGEvc3JjL3BvL3J1LnBvIGIvc3JjL3BvL3J1LnBvCmluZGV4IDljMmM3ODguLmQyYjcwYTMgMTAwNjQ0Ci0tLSBhL3NyYy9wby9ydS5wbworKysgYi9zcmMvcG8vcnUucG8KQEAgLTI2NDIsOSArMjY0Miw2IEBACiBtc2dpZCAia2V5Ym9hcmQgaW50ZXJydXB0IgogbXNnc3RyICLQutC70LDQstC40LDRgtGD0YDQvdC+0LUg0L/RgNC10YDRi9Cy0LDQvdC40LUiCiAKLW1zZ2lkICJ2aW0gZXJyb3IiCi1tc2dzdHIgItC+0YjQuNCx0LrQsCBWSU0iCi0KIG1zZ2lkICJjYW5ub3QgY3JlYXRlIGJ1ZmZlci93aW5kb3cgY29tbWFuZDogb2JqZWN0IGlzIGJlaW5nIGRlbGV0ZWQiCiBtc2dzdHIgItC90LXQstC+0LfQvNC+0LbQvdC+INGB0L7Qt9C00LDRgtGMINC60L7QvNCw0L3QtNGDINCx0YPRhNC10YDQsCDQuNC70Lgg0L7QutC90LA6INC+0LHRitC10LrRgiDQsiDQv9GA0L7RhtC10YHRgdC1INGD0LTQsNC70LXQvdC40Y8iCiAKQEAgLTMxMzIsNyArMzEyOSw3IEBACiBtc2dpZCAiLXhcdFx0XHRFZGl0IGVuY3J5cHRlZCBmaWxlcyIKIG1zZ3N0ciAiLXhcdFx0XHTQoNC10LTQsNC60YLQuNGA0L7QstCw0L3QuNC1INC30LDRiNC40YTRgNC+0LLQsNC90L3Ri9GFINGE0LDQudC70L7QsiIKIAotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0Q29ubmVjdCB2aW0gdG8gdGhpcyBwYXJ0aWN1bGFyIFgtc2VydmVyIgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0Q29ubmVjdCBWaW0gdG8gdGhpcyBwYXJ0aWN1bGFyIFgtc2VydmVyIgogbXNnc3RyICItZGlzcGxheSA80Y3QutGA0LDQvT5cdNCf0L7QtNGB0L7QtdC00LjQvdC40YLRjCBWaW0g0Log0YPQutCw0LfQsNC90L3QvtC80YMgWC3RgdC10YDQstC10YDRgyIKIAogbXNnaWQgIi1YXHRcdFx0RG8gbm90IGNvbm5lY3QgdG8gWCBzZXJ2ZXIiCkBAIC0zMjEwLDEwICszMjA3LDEwIEBACiAiXG4iCiAi0J/QsNGA0LDQvNC10YLRgNGLINC00LvRjyBndmltICjQstC10YDRgdC40Y8gQXRoZW5hKTpcbiIKIAotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIHZpbSBvbiA8ZGlzcGxheT4iCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gVmltIG9uIDxkaXNwbGF5PiIKIG1zZ3N0ciAiLWRpc3BsYXkgPNC00LjRgdC/0LvQtdC5Plx00JfQsNC/0YPRgdGC0LjRgtGMIFZpbSDQvdCwINGD0LrQsNC30LDQvdC90L7QvCA80LTQuNGB0L/Qu9C10LU+IgogCi1tc2dpZCAiLWljb25pY1x0XHRTdGFydCB2aW0gaWNvbmlmaWVkIgorbXNnaWQgIi1pY29uaWNcdFx0U3RhcnQgVmltIGljb25pZmllZCIKIG1zZ3N0ciAiLWljb25pY1x0XHTQl9Cw0L/Rg9GB0YLQuNGC0YwgVmltINCyINGB0LLRkdGA0L3Rg9GC0L7QvCDQstC40LTQtSIKIAogbXNnaWQgIi1iYWNrZ3JvdW5kIDxjb2xvcj5cdFVzZSA8Y29sb3I+IGZvciB0aGUgYmFja2dyb3VuZCAoYWxzbzogLWJnKSIKQEAgLTMyNjAsNyArMzI1Nyw3IEBACiAiXG4iCiAi0J/QsNGA0LDQvNC10YLRgNGLINC00LvRjyBndmltICjQstC10YDRgdC40Y8gR1RLKyk6XG4iCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biB2aW0gb24gPGRpc3BsYXk+IChhbHNvOiAtLWRpc3BsYXkpIgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIFZpbSBvbiA8ZGlzcGxheT4gKGFsc286IC0tZGlzcGxheSkiCiBtc2dzdHIgIiIKICItZGlzcGxheSA80LTQuNGB0L/Qu9C10Lk+XHTQl9Cw0L/Rg9GB0YLQuNGC0YwgVmltINC90LAg0YPQutCw0LfQsNC90L3QvtC8IDzQtNC40YHQv9C70LXQtT4gKNC40LvQuCAtLWRpc3BsYXkpIgogCkBAIC03MjYyLDcgKzcyNTksNyBAQAogbXNnc3RyICLQmNC90LTQtdC60YEg0YHQv9C40YHQutCwINC30LAg0L/RgNC10LTQtdC70LDQvNC4INC00LjQsNC/0LDQt9C+0L3QsCIKIAogIywgYy1mb3JtYXQKLW1zZ2lkICJpbnRlcm5hbCBlcnJvcjogZmFpbGVkIHRvIGdldCB2aW0gbGlzdCBpdGVtICVkIgorbXNnaWQgImludGVybmFsIGVycm9yOiBmYWlsZWQgdG8gZ2V0IFZpbSBsaXN0IGl0ZW0gJWQiCiBtc2dzdHIgItCS0L3Rg9GC0YDQtdC90L3Rj9GPINC+0YjQuNCx0LrQsDog0L3QtSDRg9C00LDQu9C+0YHRjCDQv9C+0LvRg9GH0LjRgtGMINGN0LvQtdC80LXQvdGCIFZJTS3RgdC/0LjRgdC60LAgJWQiCiAKIG1zZ2lkICJzbGljZSBzdGVwIGNhbm5vdCBiZSB6ZXJvIgpAQCAtNzI3NSw3ICs3MjcyLDcgQEAKICLQstGL0LHQvtGA0LrQtSIKIAogIywgYy1mb3JtYXQKLW1zZ2lkICJpbnRlcm5hbCBlcnJvcjogbm8gdmltIGxpc3QgaXRlbSAlZCIKK21zZ2lkICJpbnRlcm5hbCBlcnJvcjogbm8gVmltIGxpc3QgaXRlbSAlZCIKIG1zZ3N0ciAi0JLQvdGD0YLRgNC10L3QvdGP0Y8g0L7RiNC40LHQutCwOiDQvdC10YIg0Y3Qu9C10LzQtdC90YLQsCBWSU0t0YHQv9C40YHQutCwICVkIgogCiBtc2dpZCAiaW50ZXJuYWwgZXJyb3I6IG5vdCBlbm91Z2ggbGlzdCBpdGVtcyIKQEAgLTczODYsMjAgKzczODMsMjAgQEAKIG1zZ2lkICJFODU4OiBFdmFsIGRpZCBub3QgcmV0dXJuIGEgdmFsaWQgcHl0aG9uIG9iamVjdCIKIG1zZ3N0ciAiRTg1ODogRXZhbCDQvdC1INCy0L7Qt9Cy0YDQsNGC0LjQuyDQtNC+0L/Rg9GB0YLQuNC80L7Qs9C+INC+0LHRitC10LrRgtCwIFB5dGhvbiIKIAotbXNnaWQgIkU4NTk6IEZhaWxlZCB0byBjb252ZXJ0IHJldHVybmVkIHB5dGhvbiBvYmplY3QgdG8gdmltIHZhbHVlIgorbXNnaWQgIkU4NTk6IEZhaWxlZCB0byBjb252ZXJ0IHJldHVybmVkIHB5dGhvbiBvYmplY3QgdG8gYSBWaW0gdmFsdWUiCiBtc2dzdHIgIiIKICJFODU5OiDQndC1INGD0LTQsNC70L7RgdGMINC/0YDQtdC+0LHRgNCw0LfQvtCy0LDRgtGMINCy0L7Qt9Cy0YDQsNGJ0ZHQvdC90YvQuSDQvtCx0YrQtdC60YIgUHl0aG9uINCyINC30L3QsNGH0LXQvdC40LUgVklNIgogCiAjLCBjLWZvcm1hdAotbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIHZpbSBkaWN0aW9uYXJ5IgorbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIGEgVmltIGRpY3Rpb25hcnkiCiBtc2dzdHIgItCd0LXQstC+0LfQvNC+0LbQvdC+INC/0YDQtdC+0LHRgNCw0LfQvtCy0LDRgtGMICVzINCyINGB0LvQvtCy0LDRgNGMIFZJTSIKIAogIywgYy1mb3JtYXQKLW1zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byB2aW0gbGlzdCIKK21zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byBhIFZpbSBsaXN0IgogbXNnc3RyICLQndC10LLQvtC30LzQvtC20L3QviDQv9GA0LXQvtCx0YDQsNC30L7QstCw0YLRjCAlcyDQsiDRgdC/0LjRgdC+0LogVklNIgogCiAjLCBjLWZvcm1hdAotbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIHZpbSBzdHJ1Y3R1cmUiCittc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gYSBWaW0gc3RydWN0dXJlIgogbXNnc3RyICLQndC10LLQvtC30LzQvtC20L3QviDQv9GA0LXQvtCx0YDQsNC30L7QstCw0YLRjCAlcyDQsiDRgdGC0YDRg9C60YLRg9GA0YMgVklNIgogCiBtc2dpZCAiaW50ZXJuYWwgZXJyb3I6IE5VTEwgcmVmZXJlbmNlIHBhc3NlZCIKZGlmZiAtLWdpdCBhL3NyYy9wby9zay5jcDEyNTAucG8gYi9zcmMvcG8vc2suY3AxMjUwLnBvCmluZGV4IGFmNDEzZTkuLmM0OTJmMmEgMTAwNjQ0Ci0tLSBhL3NyYy9wby9zay5jcDEyNTAucG8KKysrIGIvc3JjL3BvL3NrLmNwMTI1MC5wbwpAQCAtMjQ0OCw5ICsyNDQ4LDYgQEAKIG1zZ2lkICJrZXlib2FyZCBpbnRlcnJ1cHQiCiBtc2dzdHIgInByZXJ1mmVuaWUgeiBrbOF2ZXNuaWNlIgogCi1tc2dpZCAidmltIGVycm9yIgotbXNnc3RyICJjaHliYSBWaW0iCi0KIG1zZ2lkICJjYW5ub3QgY3JlYXRlIGJ1ZmZlci93aW5kb3cgY29tbWFuZDogb2JqZWN0IGlzIGJlaW5nIGRlbGV0ZWQiCiBtc2dzdHIgIm5lZOEgc2Egdnl0dm9yaZ0gcHLta2F6IGJ1ZmZlcnUvb2tuYTogb2JqZWt0IGJ1ZGUgdnltYXphbv0iCiAKQEAgLTI3NDAsOCArMjczNyw4IEBACiBtc2dpZCAiLXhcdFx0XHRFZGl0IGVuY3J5cHRlZCBmaWxlcyIKIG1zZ3N0ciAiLXhcdFx0XHTacHJhdmEgemGaaWZyb3Zhbv1jaCBz+mJvcm92IgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRDb25uZWN0IHZpbSB0byB0aGlzIHBhcnRpY3VsYXIgWC1zZXJ2ZXIiCi1tc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGVqPlx0UHJpcG9q7SB2aW0gbmEgcHLtc2x1mm79IFgtc2VydmVyIgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0Q29ubmVjdCBWaW0gdG8gdGhpcyBwYXJ0aWN1bGFyIFgtc2VydmVyIgorbXNnc3RyICItZGlzcGxheSA8ZGlzcGxlaj5cdFByaXBvau0gVmltIG5hIHBy7XNsdZpu/SBYLXNlcnZlciIKIAogbXNnaWQgIi1YXHRcdFx0RG8gbm90IGNvbm5lY3QgdG8gWCBzZXJ2ZXIiCiBtc2dzdHIgIi1YXHRcdFx0TmVwcmlwb2rtIHNhIGsgWCBzZXJ2ZXJ1IgpAQCAtMjgwMywxMSArMjgwMCwxMSBAQAogIlxuIgogIkFyZ3VtZW50eSBkb3N0dXBu6SBwcmUgZ3ZpbSAoQXRoZW5hIHZlcnppYSk6XG4iCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biB2aW0gb24gPGRpc3BsYXk+IgotbXNnc3RyICItZGlzcGxheSA8ZGlzcGxlaj5cdFNwdXN07SB2aW0gbmEgPGRpc3BsZWo+IgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIFZpbSBvbiA8ZGlzcGxheT4iCittc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGVqPlx0U3B1c3TtIFZpbSBuYSA8ZGlzcGxlaj4iCiAKLW1zZ2lkICItaWNvbmljXHRcdFN0YXJ0IHZpbSBpY29uaWZpZWQiCi1tc2dzdHIgIi1pY29uaWNcdFx0U3B1c3TtIHZpbSBtaW5pbWFsaXpvdmFu6SIKK21zZ2lkICItaWNvbmljXHRcdFN0YXJ0IFZpbSBpY29uaWZpZWQiCittc2dzdHIgIi1pY29uaWNcdFx0U3B1c3TtIFZpbSBtaW5pbWFsaXpvdmFu6SIKIAogbXNnaWQgIi1uYW1lIDxuYW1lPlx0XHRVc2UgcmVzb3VyY2UgYXMgaWYgdmltIHdhcyA8bmFtZT4iCiBtc2dzdHIgIi1uYW1lIDxu4Xpvdj5cdFx0UG91nmlqZSByZXNvdXJjZSBha28gYnkgdmltIG1hbCA8buF6b3Y+IgpAQCAtMjg3Miw4ICsyODY5LDggQEAKICJcbiIKICJBcmd1bWVudHkgZG9zdHVwbukgcHJlIGd2aW0gKEdUSysgdmVyemlhKTpcbiIKIAotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIHZpbSBvbiA8ZGlzcGxheT4gKGFsc286IC0tZGlzcGxheSkiCi1tc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGVqPlx0U3B1c3TtIHZpbSBuYSA8ZGlzcGxlaj4gKHRpZZ4gLS1kaXNwbGF5KSIKK21zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biBWaW0gb24gPGRpc3BsYXk+IChhbHNvOiAtLWRpc3BsYXkpIgorbXNnc3RyICItZGlzcGxheSA8ZGlzcGxlaj5cdFNwdXN07SBWaW0gbmEgPGRpc3BsZWo+ICh0aWWeIC0tZGlzcGxheSkiCiAKIG1zZ2lkICItLXJvbGUgPHJvbGU+XHRTZXQgYSB1bmlxdWUgcm9sZSB0byBpZGVudGlmeSB0aGUgbWFpbiB3aW5kb3ciCiBtc2dzdHIgIi1yb2xlIDxyb2xhPlx0TmFzdGF27SB1bmlr4XRudSByb2x1IHByZSBpZGVudGlmaWvhY2l1IGhsYXZu6WhvIG9rbmEiCkBAIC0yODk3LDggKzI4OTQsOCBAQAogbXNnaWQgIi1ub3RpcFx0XHREaXNhYmxlIHRoZSB0aXAgZGlhbG9nIgogbXNnc3RyICItbm90aXBcdFx0TmV6b2JyYXp1aiB0aXAgcHJpIJp0YXJ0ZSIKIAotbXNnaWQgIi0tZGlzcGxheSA8ZGlzcGxheT5cdFJ1biB2aW0gb24gPGRpc3BsYXk+IgotbXNnc3RyICItZGlzcGxheSA8ZGlzcGxlaj5cdFNwdXN07SB2aW0gbmEgPGRpc3BsZWo+IgorbXNnaWQgIi0tZGlzcGxheSA8ZGlzcGxheT5cdFJ1biBWaW0gb24gPGRpc3BsYXk+IgorbXNnc3RyICItZGlzcGxheSA8ZGlzcGxlaj5cdFNwdXN07SBWaW0gbmEgPGRpc3BsZWo+IgogCiBtc2dpZCAiLVAgPHBhcmVudCB0aXRsZT5cdE9wZW4gVmltIGluc2lkZSBwYXJlbnQgYXBwbGljYXRpb24iCiBtc2dzdHIgIi1QIDx0aXR1bG9rIHJvZGnoYT5cdE90dm9yIFZpbSB2bvp0cmkgbWF0ZXJza2VqIGFwbGlr4WNpZSIKZGlmZiAtLWdpdCBhL3NyYy9wby9zay5wbyBiL3NyYy9wby9zay5wbwppbmRleCBhYjEzMjc3Li4zODBhOTI5IDEwMDY0NAotLS0gYS9zcmMvcG8vc2sucG8KKysrIGIvc3JjL3BvL3NrLnBvCkBAIC0yNDQ4LDkgKzI0NDgsNiBAQAogbXNnaWQgImtleWJvYXJkIGludGVycnVwdCIKIG1zZ3N0ciAicHJlcnW5ZW5pZSB6IGts4XZlc25pY2UiCiAKLW1zZ2lkICJ2aW0gZXJyb3IiCi1tc2dzdHIgImNoeWJhIFZpbSIKLQogbXNnaWQgImNhbm5vdCBjcmVhdGUgYnVmZmVyL3dpbmRvdyBjb21tYW5kOiBvYmplY3QgaXMgYmVpbmcgZGVsZXRlZCIKIG1zZ3N0ciAibmVk4SBzYSB2eXR2b3JpuyBwcu1rYXogYnVmZmVydS9va25hOiBvYmpla3QgYnVkZSB2eW1hemFu/SIKIApAQCAtMjc0MCw4ICsyNzM3LDggQEAKIG1zZ2lkICIteFx0XHRcdEVkaXQgZW5jcnlwdGVkIGZpbGVzIgogbXNnc3RyICIteFx0XHRcdNpwcmF2YSB6YblpZnJvdmFu/WNoIHP6Ym9yb3YiCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdENvbm5lY3QgdmltIHRvIHRoaXMgcGFydGljdWxhciBYLXNlcnZlciIKLW1zZ3N0ciAiLWRpc3BsYXkgPGRpc3BsZWo+XHRQcmlwb2rtIHZpbSBuYSBwcu1zbHW5bv0gWC1zZXJ2ZXIiCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRDb25uZWN0IFZpbSB0byB0aGlzIHBhcnRpY3VsYXIgWC1zZXJ2ZXIiCittc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGVqPlx0UHJpcG9q7SBWaW0gbmEgcHLtc2x1uW79IFgtc2VydmVyIgogCiBtc2dpZCAiLVhcdFx0XHREbyBub3QgY29ubmVjdCB0byBYIHNlcnZlciIKIG1zZ3N0ciAiLVhcdFx0XHROZXByaXBvau0gc2EgayBYIHNlcnZlcnUiCkBAIC0yODAzLDExICsyODAwLDExIEBACiAiXG4iCiAiQXJndW1lbnR5IGRvc3R1cG7pIHByZSBndmltIChBdGhlbmEgdmVyemlhKTpcbiIKIAotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIHZpbSBvbiA8ZGlzcGxheT4iCi1tc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGVqPlx0U3B1c3TtIHZpbSBuYSA8ZGlzcGxlaj4iCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gVmltIG9uIDxkaXNwbGF5PiIKK21zZ3N0ciAiLWRpc3BsYXkgPGRpc3BsZWo+XHRTcHVzdO0gVmltIG5hIDxkaXNwbGVqPiIKIAotbXNnaWQgIi1pY29uaWNcdFx0U3RhcnQgdmltIGljb25pZmllZCIKLW1zZ3N0ciAiLWljb25pY1x0XHRTcHVzdO0gdmltIG1pbmltYWxpem92YW7pIgorbXNnaWQgIi1pY29uaWNcdFx0U3RhcnQgVmltIGljb25pZmllZCIKK21zZ3N0ciAiLWljb25pY1x0XHRTcHVzdO0gVmltIG1pbmltYWxpem92YW7pIgogCiBtc2dpZCAiLW5hbWUgPG5hbWU+XHRcdFVzZSByZXNvdXJjZSBhcyBpZiB2aW0gd2FzIDxuYW1lPiIKIG1zZ3N0ciAiLW5hbWUgPG7hem92Plx0XHRQb3W+aWplIHJlc291cmNlIGFrbyBieSB2aW0gbWFsIDxu4Xpvdj4iCkBAIC0yODcyLDggKzI4NjksOCBAQAogIlxuIgogIkFyZ3VtZW50eSBkb3N0dXBu6SBwcmUgZ3ZpbSAoR1RLKyB2ZXJ6aWEpOlxuIgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gdmltIG9uIDxkaXNwbGF5PiAoYWxzbzogLS1kaXNwbGF5KSIKLW1zZ3N0ciAiLWRpc3BsYXkgPGRpc3BsZWo+XHRTcHVzdO0gdmltIG5hIDxkaXNwbGVqPiAodGllviAtLWRpc3BsYXkpIgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIFZpbSBvbiA8ZGlzcGxheT4gKGFsc286IC0tZGlzcGxheSkiCittc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGVqPlx0U3B1c3TtIFZpbSBuYSA8ZGlzcGxlaj4gKHRpZb4gLS1kaXNwbGF5KSIKIAogbXNnaWQgIi0tcm9sZSA8cm9sZT5cdFNldCBhIHVuaXF1ZSByb2xlIHRvIGlkZW50aWZ5IHRoZSBtYWluIHdpbmRvdyIKIG1zZ3N0ciAiLXJvbGUgPHJvbGE+XHROYXN0YXbtIHVuaWvhdG51IHJvbHUgcHJlIGlkZW50aWZpa+FjaXUgaGxhdm7paG8gb2tuYSIKQEAgLTI4OTcsOCArMjg5NCw4IEBACiBtc2dpZCAiLW5vdGlwXHRcdERpc2FibGUgdGhlIHRpcCBkaWFsb2ciCiBtc2dzdHIgIi1ub3RpcFx0XHROZXpvYnJhenVqIHRpcCBwcmkguXRhcnRlIgogCi1tc2dpZCAiLS1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIHZpbSBvbiA8ZGlzcGxheT4iCi1tc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGVqPlx0U3B1c3TtIHZpbSBuYSA8ZGlzcGxlaj4iCittc2dpZCAiLS1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIFZpbSBvbiA8ZGlzcGxheT4iCittc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGVqPlx0U3B1c3TtIFZpbSBuYSA8ZGlzcGxlaj4iCiAKIG1zZ2lkICItUCA8cGFyZW50IHRpdGxlPlx0T3BlbiBWaW0gaW5zaWRlIHBhcmVudCBhcHBsaWNhdGlvbiIKIG1zZ3N0ciAiLVAgPHRpdHVsb2sgcm9kaehhPlx0T3R2b3IgVmltIHZu+nRyaSBtYXRlcnNrZWogYXBsaWvhY2llIgpkaWZmIC0tZ2l0IGEvc3JjL3BvL3NyLnBvIGIvc3JjL3BvL3NyLnBvCmluZGV4IDAyZDY5N2MuLjg3ZWM0MTYgMTAwNjQ0Ci0tLSBhL3NyYy9wby9zci5wbworKysgYi9zcmMvcG8vc3IucG8KQEAgLTI2MzAsOSArMjYzMCw2IEBACiBtc2dpZCAia2V5Ym9hcmQgaW50ZXJydXB0IgogbXNnc3RyICLQv9GA0LXQutC40LQg0YLQsNGB0YLQsNGC0YPRgNC1IgogCi1tc2dpZCAidmltIGVycm9yIgotbXNnc3RyICJ2aW0g0LPRgNC10YjQutCwIgotCiBtc2dpZCAiY2Fubm90IGNyZWF0ZSBidWZmZXIvd2luZG93IGNvbW1hbmQ6IG9iamVjdCBpcyBiZWluZyBkZWxldGVkIgogbXNnc3RyICLQsdCw0YTQtdGAL9C/0YDQvtC30L7RgCDQutC+0LzQsNC90LTQsCDQvdC1INC80L7QttC1INC00LAg0YHQtSDQutGA0LXQuNGA0LA6INC+0LHRmNC10LrQsNGCINGB0LUg0LHRgNC40YjQtSIKIApAQCAtMzEwMCw4ICszMDk3LDggQEAKIG1zZ2lkICIteFx0XHRcdEVkaXQgZW5jcnlwdGVkIGZpbGVzIgogbXNnc3RyICIteFx0XHRcdNCj0YDQtdGS0YPRmCDRiNC40YTRgNC+0LLQsNC90LUg0YTQsNGY0LvQvtCy0LUiCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdENvbm5lY3QgdmltIHRvIHRoaXMgcGFydGljdWxhciBYLXNlcnZlciIKLW1zZ3N0ciAiLWRpc3BsYXkgPNC00LjRgdC/0LvQtdGYPlx00J/QvtCy0LXQttC4IHZpbSDQvdCwINC+0LLQsNGYIFgt0YHQtdGA0LLQtdGAIgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0Q29ubmVjdCBWaW0gdG8gdGhpcyBwYXJ0aWN1bGFyIFgtc2VydmVyIgorbXNnc3RyICItZGlzcGxheSA80LTQuNGB0L/Qu9C10Zg+XHTQn9C+0LLQtdC20LggVmltINC90LAg0L7QstCw0ZggWC3RgdC10YDQstC10YAiCiAKIG1zZ2lkICItWFx0XHRcdERvIG5vdCBjb25uZWN0IHRvIFggc2VydmVyIgogbXNnc3RyICItWFx0XHRcdNCd0LUg0L/QvtCy0LXQt9GD0Zgg0YHQtSDQvdCwIFgg0YHQtdGA0LLQtdGAIgpAQCAtMzE3OCwxMSArMzE3NSwxMSBAQAogIlxuIgogItCQ0YDQs9GD0LzQtdC90YLQuCDQutC+0ZjQtSDQv9GA0LXQv9C+0LfQvdCw0ZjQtSBndmltIChBdGhlbmEg0LLQtdGA0LfQuNGY0LApOlxuIgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gdmltIG9uIDxkaXNwbGF5PiIKLW1zZ3N0ciAiLWRpc3BsYXkgPNC00LjRgdC/0LvQtdGYPlx00J/QvtC60YDQtdC90LggdmltINC90LAgPNC00LjRgdC/0LvQtdGYPiIKK21zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biBWaW0gb24gPGRpc3BsYXk+IgorbXNnc3RyICItZGlzcGxheSA80LTQuNGB0L/Qu9C10Zg+XHTQn9C+0LrRgNC10L3QuCBWaW0g0L3QsCA80LTQuNGB0L/Qu9C10Zg+IgogCi1tc2dpZCAiLWljb25pY1x0XHRTdGFydCB2aW0gaWNvbmlmaWVkIgotbXNnc3RyICItaWNvbmljXHRcdNCf0L7QutGA0LXQvdC4IHZpbSDQutCw0L4g0LjQutC+0L3RgyIKK21zZ2lkICItaWNvbmljXHRcdFN0YXJ0IFZpbSBpY29uaWZpZWQiCittc2dzdHIgIi1pY29uaWNcdFx00J/QvtC60YDQtdC90LggVmltINC60LDQviDQuNC60L7QvdGDIgogCiBtc2dpZCAiLWJhY2tncm91bmQgPGNvbG9yPlx0VXNlIDxjb2xvcj4gZm9yIHRoZSBiYWNrZ3JvdW5kIChhbHNvOiAtYmcpIgogbXNnc3RyICItYmFja2dyb3VuZCA80LHQvtGY0LA+XHTQmtC+0YDQuNGB0YLQuCA80LHQvtGY0LA+INC30LAg0L/QvtC30LDQtNC40L3RgyAo0YLQsNC60L7RktC1OiAtYmcpIgpAQCAtMzIzMCw4ICszMjI3LDggQEAKICJcbiIKICLQkNGA0LPRg9C80LXQvdGC0Lgg0LrQvtGY0LUg0L/RgNC10L/QvtC30L3QsNGY0LUgZ3ZpbSAoR1RLKyDQstC10YDQt9C40ZjQsCk6XG4iCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biB2aW0gb24gPGRpc3BsYXk+IChhbHNvOiAtLWRpc3BsYXkpIgotbXNnc3RyICItZGlzcGxheSA80LTQuNGB0L/Qu9C10Zg+XHTQn9C+0LrRgNC10L3QuCB2aW0g0L3QsCA80LTQuNGB0L/Qu9C10Zg+ICjRgtCw0LrQvtGS0LU6IC0tZGlzcGxheSkiCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gVmltIG9uIDxkaXNwbGF5PiAoYWxzbzogLS1kaXNwbGF5KSIKK21zZ3N0ciAiLWRpc3BsYXkgPNC00LjRgdC/0LvQtdGYPlx00J/QvtC60YDQtdC90LggVmltINC90LAgPNC00LjRgdC/0LvQtdGYPiAo0YLQsNC60L7RktC1OiAtLWRpc3BsYXkpIgogCiBtc2dpZCAiLS1yb2xlIDxyb2xlPlx0U2V0IGEgdW5pcXVlIHJvbGUgdG8gaWRlbnRpZnkgdGhlIG1haW4gd2luZG93IgogbXNnc3RyICIiCkBAIC03MjEwLDcgKzcyMDcsNyBAQAogbXNnc3RyICLQuNC90LTQtdC60YEg0LvQuNGB0YLQtSDRmNC1INCy0LDQvSDQvtC/0YHQtdCz0LAiCiAKICMsIGMtZm9ybWF0Ci1tc2dpZCAiaW50ZXJuYWwgZXJyb3I6IGZhaWxlZCB0byBnZXQgdmltIGxpc3QgaXRlbSAlZCIKK21zZ2lkICJpbnRlcm5hbCBlcnJvcjogZmFpbGVkIHRvIGdldCBWaW0gbGlzdCBpdGVtICVkIgogbXNnc3RyICLQuNC90YLQtdGA0L3QsCDQs9GA0LXRiNC60LA6INGB0YLQsNCy0LrQsCAlZCB2aW0g0LvQuNGB0YLQtSDQvdC40ZjQtSDQvNC+0LPQu9CwINC00LAg0YHQtSDQtNC+0LHQuNGY0LUiCiAKIG1zZ2lkICJzbGljZSBzdGVwIGNhbm5vdCBiZSB6ZXJvIgpAQCAtNzIyMSw3ICs3MjE4LDcgQEAKIG1zZ3N0ciAi0L/QvtC60YPRiNCw0Zgg0LTQvtC00LXQu9C1INGB0LXQutCy0LXQvdGG0LUg0LLQtdC70LjRh9C40L3QtSDQstC10ZvQtSDQvtC0ICVkINC60LDQutC+INCx0Lgg0YHQtSDQv9GA0L7QtNGD0LbQuNC+IHNsaWNlIgogCiAjLCBjLWZvcm1hdAotbXNnaWQgImludGVybmFsIGVycm9yOiBubyB2aW0gbGlzdCBpdGVtICVkIgorbXNnaWQgImludGVybmFsIGVycm9yOiBubyBWaW0gbGlzdCBpdGVtICVkIgogbXNnc3RyICLQuNC90YLQtdGA0L3QsCDQs9GA0LXRiNC60LA6INC90LXQvNCwINGB0YLQsNCy0LrQtSAlZCDRgyB2aW0g0LvQuNGB0YLQuCIKIAogbXNnaWQgImludGVybmFsIGVycm9yOiBub3QgZW5vdWdoIGxpc3QgaXRlbXMiCkBAIC03MzMxLDE5ICs3MzI4LDE5IEBACiBtc2dpZCAiRTg1ODogRXZhbCBkaWQgbm90IHJldHVybiBhIHZhbGlkIHB5dGhvbiBvYmplY3QiCiBtc2dzdHIgIkU4NTg6IEV2YWwg0L3QuNGY0LUg0LLRgNCw0YLQuNC+INCy0LDQttC10ZvQuCBweXRob24g0L7QsdGY0LXQutCw0YIiCiAKLW1zZ2lkICJFODU5OiBGYWlsZWQgdG8gY29udmVydCByZXR1cm5lZCBweXRob24gb2JqZWN0IHRvIHZpbSB2YWx1ZSIKK21zZ2lkICJFODU5OiBGYWlsZWQgdG8gY29udmVydCByZXR1cm5lZCBweXRob24gb2JqZWN0IHRvIGEgVmltIHZhbHVlIgogbXNnc3RyICJFODU5OiDQmtC+0L3QstC10YDQt9C40ZjQsCDQstGA0LDRm9C10L3QvtCzIHB5dGhvbiDQvtCx0ZjQtdC60YLQsCDRgyB2aW0g0LLRgNC10LTQvdC+0YHRgiDQvdC40ZjQtSDRg9GB0L/QtdC70LAiCiAKICMsIGMtZm9ybWF0Ci1tc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gdmltIGRpY3Rpb25hcnkiCittc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gYSBWaW0gZGljdGlvbmFyeSIKIG1zZ3N0ciAiJXMg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0LrQvtC90LLQtdGA0YLRg9GY0LUg0YMgdmltINGA0LXRh9C90LjQuiIKIAogIywgYy1mb3JtYXQKLW1zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byB2aW0gbGlzdCIKK21zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byBhIFZpbSBsaXN0IgogbXNnc3RyICIlcyDQvdC1INC80L7QttC1INC00LAg0YHQtSDQutC+0L3QstC10YDRgtGD0ZjQtSDRgyB2aW0g0LvQuNGB0YLRgyIKIAogIywgYy1mb3JtYXQKLW1zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byB2aW0gc3RydWN0dXJlIgorbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIGEgVmltIHN0cnVjdHVyZSIKIG1zZ3N0ciAiJXMg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0LrQvtC90LLQtdGA0YLRg9GY0LUg0YMgdmltINGB0YLRgNGD0LrRgtGD0YDRgyIKIAogbXNnaWQgImludGVybmFsIGVycm9yOiBOVUxMIHJlZmVyZW5jZSBwYXNzZWQiCmRpZmYgLS1naXQgYS9zcmMvcG8vc3YucG8gYi9zcmMvcG8vc3YucG8KaW5kZXggOGJlYWU4Mi4uMzViOWE2MiAxMDA2NDQKLS0tIGEvc3JjL3BvL3N2LnBvCisrKyBiL3NyYy9wby9zdi5wbwpAQCAtMjYyMSw5ICsyNjIxLDYgQEAKIG1zZ2lkICJrZXlib2FyZCBpbnRlcnJ1cHQiCiBtc2dzdHIgInRhbmdlbnRib3Jkc2F2YnJvdHQiCiAKLW1zZ2lkICJ2aW0gZXJyb3IiCi1tc2dzdHIgInZpbS1mZWwiCi0KIG1zZ2lkICJjYW5ub3QgY3JlYXRlIGJ1ZmZlci93aW5kb3cgY29tbWFuZDogb2JqZWN0IGlzIGJlaW5nIGRlbGV0ZWQiCiBtc2dzdHIgImthbiBpbnRlIHNrYXBhIGJ1ZmZlcnQvZvZuc3Rlci1rb21tYW5kbzogb2JqZWt0IGjlbGxlciBw5SBhdHQgdGFzIGJvcnQiCiAKQEAgLTI5MjIsOCArMjkxOSw4IEBACiBtc2dpZCAiLXhcdFx0XHRFZGl0IGVuY3J5cHRlZCBmaWxlcyIKIG1zZ3N0ciAiLXhcdFx0XHRSZWRpZ2VyYSBrcnlwdGVyYWRlIGZpbGVyIgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRDb25uZWN0IHZpbSB0byB0aGlzIHBhcnRpY3VsYXIgWC1zZXJ2ZXIiCi1tc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0QW5zbHV0IHZpbSB0aWxsIGp1c3QgZGVubmEgWC1zZXJ2ZXIiCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRDb25uZWN0IFZpbSB0byB0aGlzIHBhcnRpY3VsYXIgWC1zZXJ2ZXIiCittc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0QW5zbHV0IFZpbSB0aWxsIGp1c3QgZGVubmEgWC1zZXJ2ZXIiCiAKIG1zZ2lkICItWFx0XHRcdERvIG5vdCBjb25uZWN0IHRvIFggc2VydmVyIgogbXNnc3RyICItWFx0XHRcdEFuc2x1dCBpbnRlIHRpbGwgWCBzZXJ2ZXIiCkBAIC0yOTk1LDExICsyOTkyLDExIEBACiAiXG4iCiAiQXJndW1lbnQgc29tIHN09mRzIGF2IGd2aW0gKEF0aGVuYS12ZXJzaW9uKTpcbiIKIAotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIHZpbSBvbiA8ZGlzcGxheT4iCi1tc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0S/ZyIHZpbSBw5SA8ZGlzcGxheT4iCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gVmltIG9uIDxkaXNwbGF5PiIKK21zZ3N0ciAiLWRpc3BsYXkgPGRpc3BsYXk+XHRL9nIgVmltIHDlIDxkaXNwbGF5PiIKIAotbXNnaWQgIi1pY29uaWNcdFx0U3RhcnQgdmltIGljb25pZmllZCIKLW1zZ3N0ciAiLWljb25pY1x0XHRTdGFydGEgdmltIHNvbSBpa29uIgorbXNnaWQgIi1pY29uaWNcdFx0U3RhcnQgVmltIGljb25pZmllZCIKK21zZ3N0ciAiLWljb25pY1x0XHRTdGFydGEgVmltIHNvbSBpa29uIgogCiBtc2dpZCAiLW5hbWUgPG5hbWU+XHRcdFVzZSByZXNvdXJjZSBhcyBpZiB2aW0gd2FzIDxuYW1lPiIKIG1zZ3N0ciAiLW5hbWUgPG5hbW4+XHRcdEFuduRuZCByZXN1cnMgc29tIG9tIHZpbSB2YXIgPG5hbW4+IgpAQCAtMzA2NSw4ICszMDYyLDggQEAKICJcbiIKICJBcmd1bWVudCBpZ2Vua+RuZGEgYXYgZ3ZpbSAoR1RLKy12ZXJzaW9uKTpcbiIKIAotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIHZpbSBvbiA8ZGlzcGxheT4gKGFsc286IC0tZGlzcGxheSkiCi1tc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0S/ZyIHZpbSBw5SA8ZGlzcGxheT4gKOR2ZW46IC0tZGlzcGxheSkiCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gVmltIG9uIDxkaXNwbGF5PiAoYWxzbzogLS1kaXNwbGF5KSIKK21zZ3N0ciAiLWRpc3BsYXkgPGRpc3BsYXk+XHRL9nIgVmltIHDlIDxkaXNwbGF5PiAo5HZlbjogLS1kaXNwbGF5KSIKIAogbXNnaWQgIi0tcm9sZSA8cm9sZT5cdFNldCBhIHVuaXF1ZSByb2xlIHRvIGlkZW50aWZ5IHRoZSBtYWluIHdpbmRvdyIKIG1zZ3N0ciAiLS1yb2xlIDxyb2xsPlx0U3TkbGwgaW4gZW4gdW5payByb2xsIGb2ciBhdHQgaWRlbnRpZmllcmEgaHV2dWRm9m5zdHJldCIKZGlmZiAtLWdpdCBhL3NyYy9wby90ci5wbyBiL3NyYy9wby90ci5wbwppbmRleCAzZjk4OGIxLi4wNDQyMmZiIDEwMDY0NAotLS0gYS9zcmMvcG8vdHIucG8KKysrIGIvc3JjL3BvL3RyLnBvCkBAIC0yNTI5LDkgKzI1MjksNiBAQAogbXNnaWQgImtleWJvYXJkIGludGVycnVwdCIKIG1zZ3N0ciAia2xhdnllIGFyYXlhIGdpcmRpIgogCi1tc2dpZCAidmltIGVycm9yIgotbXNnc3RyICJ2aW0gaGF0YXPEsSIKLQogbXNnaWQgImNhbm5vdCBjcmVhdGUgYnVmZmVyL3dpbmRvdyBjb21tYW5kOiBvYmplY3QgaXMgYmVpbmcgZGVsZXRlZCIKIG1zZ3N0ciAiYXJhYmVsbGVrL3BlbmNlcmUga29tdXR1IG9sdcWfdHVydWxhbWFkxLE6IMO2Z2UgxZ91IGFuZGEgc2lsaW5peW9yIgogCkBAIC0yOTkxLDcgKzI5ODgsNyBAQAogbXNnaWQgIi14XHRcdFx0RWRpdCBlbmNyeXB0ZWQgZmlsZXMiCiBtc2dzdHIgIi14XHRcdFx0xZ5pZnJlbGVubWnFnyBkb3N5YWxhcsSxIGTDvHplbmxlIgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRDb25uZWN0IHZpbSB0byB0aGlzIHBhcnRpY3VsYXIgWC1zZXJ2ZXIiCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRDb25uZWN0IFZpbSB0byB0aGlzIHBhcnRpY3VsYXIgWC1zZXJ2ZXIiCiBtc2dzdHIgIi1kaXNwbGF5IDxla3Jhbj5cdFZpbSdpIGJ1IGJlbGlydGlsZW4gWCBzdW51Y3VzdW5hIGJhxJ9sYSIKIAogbXNnaWQgIi1YXHRcdFx0RG8gbm90IGNvbm5lY3QgdG8gWCBzZXJ2ZXIiCkBAIC0zMDY5LDEwICszMDY2LDEwIEBACiAiXG4iCiAiZ3ZpbSB0YXJhZsSxbmRhbiB0YW7EsW5hbiBkZcSfacWfa2VubGVyIChBdGhlbmEgc8O8csO8bcO8KTpcbiIKIAotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIHZpbSBvbiA8ZGlzcGxheT4iCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gVmltIG9uIDxkaXNwbGF5PiIKIG1zZ3N0ciAiLWRpc3BsYXkgPGVrcmFuPlx0VmltJ2kgPGVrcmFuPidkYSDDp2FsxLHFn3TEsXIiCiAKLW1zZ2lkICItaWNvbmljXHRcdFN0YXJ0IHZpbSBpY29uaWZpZWQiCittc2dpZCAiLWljb25pY1x0XHRTdGFydCBWaW0gaWNvbmlmaWVkIgogbXNnc3RyICItaWNvbmljXHRcdFZpbSdpIHNpbWdlIGR1cnVtdW5kYSBiYcWfbGF0IgogCiBtc2dpZCAiLWJhY2tncm91bmQgPGNvbG9yPlx0VXNlIDxjb2xvcj4gZm9yIHRoZSBiYWNrZ3JvdW5kIChhbHNvOiAtYmcpIgpAQCAtMzEyMCw3ICszMTE3LDcgQEAKICJcbiIKICJndmltIHRhcmFmxLFuZGFuIHRhbsSxbmFuIGRlxJ9pxZ9rZW5sZXIgKEdUSysgc8O8csO8bcO8KTpcbiIKIAotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIHZpbSBvbiA8ZGlzcGxheT4gKGFsc286IC0tZGlzcGxheSkiCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gVmltIG9uIDxkaXNwbGF5PiAoYWxzbzogLS1kaXNwbGF5KSIKIG1zZ3N0ciAiLWRpc3BsYXkgPGVrcmFuPlx0VmltJ2kgPGVrcmFuPidkYSDDp2FsxLHFn3TEsXIgKHZleWE6IC0tZGlzcGxheSkiCiAKIG1zZ2lkICItLXJvbGUgPHJvbGU+XHRTZXQgYSB1bmlxdWUgcm9sZSB0byBpZGVudGlmeSB0aGUgbWFpbiB3aW5kb3ciCkBAIC03NDM3LDcgKzc0MzQsNyBAQAogbXNnc3RyICJsaXN0ZSBkaXppbmkgZXJpbWluIGTEscWfxLFuZGEiCiAKICMsIGMtZm9ybWF0Ci1tc2dpZCAiaW50ZXJuYWwgZXJyb3I6IGZhaWxlZCB0byBnZXQgdmltIGxpc3QgaXRlbSAlZCIKK21zZ2lkICJpbnRlcm5hbCBlcnJvcjogZmFpbGVkIHRvIGdldCBWaW0gbGlzdCBpdGVtICVkIgogbXNnc3RyICJpw6cgaGF0YTogJWQgdmltIGxpc3RlIMO2Z2VzaSBhbMSxbmFtYWTEsSIKIAogbXNnaWQgInNsaWNlIHN0ZXAgY2Fubm90IGJlIHplcm8iCkBAIC03NDQ4LDcgKzc0NDUsNyBAQAogbXNnc3RyICJnZW5pxZ9sZXRpbG1pxZ8gZGlsaW1lICVkIGJveXV0dGFuIGLDvHnDvGsgYmlyIHPEsXJhbGFtYXnEsSBhdGFtYSBkZW5lbWVzaSIKIAogIywgYy1mb3JtYXQKLW1zZ2lkICJpbnRlcm5hbCBlcnJvcjogbm8gdmltIGxpc3QgaXRlbSAlZCIKK21zZ2lkICJpbnRlcm5hbCBlcnJvcjogbm8gVmltIGxpc3QgaXRlbSAlZCIKIG1zZ3N0ciAiacOnIGhhdGE6ICVkIHZpbSBsaXN0ZSDDtmdlc2kgeW9rIgogCiBtc2dpZCAiaW50ZXJuYWwgZXJyb3I6IG5vdCBlbm91Z2ggbGlzdCBpdGVtcyIKQEAgLTc1NTcsMTkgKzc1NTQsMTkgQEAKIG1zZ2lkICJFODU4OiBFdmFsIGRpZCBub3QgcmV0dXJuIGEgdmFsaWQgcHl0aG9uIG9iamVjdCIKIG1zZ3N0ciAiRTg1ODogRXZhbCBnZcOnZXJsaSBiaXIgcHl0aG9uIG5lc25lc2kgZMO2bmTDvHJtZWRpIgogCi1tc2dpZCAiRTg1OTogRmFpbGVkIHRvIGNvbnZlcnQgcmV0dXJuZWQgcHl0aG9uIG9iamVjdCB0byB2aW0gdmFsdWUiCittc2dpZCAiRTg1OTogRmFpbGVkIHRvIGNvbnZlcnQgcmV0dXJuZWQgcHl0aG9uIG9iamVjdCB0byBhIFZpbSB2YWx1ZSIKIG1zZ3N0ciAiRTg1OTogRMO2bmTDvHLDvGxlbiBweXRob24gbmVzbmVzaSB2aW0gZGXEn2VyaW5lIGTDtm7DvMWfdMO8csO8bGVtZWRpIgogCiAjLCBjLWZvcm1hdAotbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIHZpbSBkaWN0aW9uYXJ5IgorbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIGEgVmltIGRpY3Rpb25hcnkiCiBtc2dzdHIgIiVzIHZpbSBzw7Z6bMO8xJ/DvG5lIGTDtm7DvMWfdMO8csO8bGVtZWRpIgogCiAjLCBjLWZvcm1hdAotbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIHZpbSBsaXN0IgorbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIGEgVmltIGxpc3QiCiBtc2dzdHIgIiVzIHZpbSBsaXN0ZXNpbmUgZMO2bsO8xZ90w7xyw7xsZW1lZGkiCiAKICMsIGMtZm9ybWF0Ci1tc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gdmltIHN0cnVjdHVyZSIKK21zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byBhIFZpbSBzdHJ1Y3R1cmUiCiBtc2dzdHIgIiVzIHZpbSB5YXDEsXPEsW5hIGTDtm7DvMWfdMO8csO8bGVtZWRpIgogCiBtc2dpZCAiaW50ZXJuYWwgZXJyb3I6IE5VTEwgcmVmZXJlbmNlIHBhc3NlZCIKZGlmZiAtLWdpdCBhL3NyYy9wby91ay5jcDEyNTEucG8gYi9zcmMvcG8vdWsuY3AxMjUxLnBvCmluZGV4IDliN2RlNDAuLjc4NTkzYWEgMTAwNjQ0Ci0tLSBhL3NyYy9wby91ay5jcDEyNTEucG8KKysrIGIvc3JjL3BvL3VrLmNwMTI1MS5wbwpAQCAtMjg3OSw5ICsyODc5LDYgQEAKIG1zZ2lkICJrZXlib2FyZCBpbnRlcnJ1cHQiCiBtc2dzdHIgIu/l8OXw4uDt7iDnIOrr4OKz4PLz8OgiCiAKLW1zZ2lkICJ2aW0gZXJyb3IiCi1tc2dzdHIgIu/u7Ojr6uAgVmltIgotCiBtc2dpZCAiY2Fubm90IGNyZWF0ZSBidWZmZXIvd2luZG93IGNvbW1hbmQ6IG9iamVjdCBpcyBiZWluZyBkZWxldGVkIgogbXNnc3RyICLt5SDi5ODr7vH/IPHy4u7w6PLoIOru7ODt5PMg4rPq7eAv4fP05fDgOiDu4Se66vIg5+3o+fO68vzx/yIKIApAQCAtMzIwMSw4ICszMTk4LDggQEAKIG1zZ2lkICIteFx0XHRcdEVkaXQgZW5jcnlwdGVkIGZpbGVzIgogbXNnc3RyICIteFx0XHRcdNDl5ODj8+Lg8ugg5+D46PTw7uLg7bMg9ODp6+giCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdENvbm5lY3QgdmltIHRvIHRoaXMgcGFydGljdWxhciBYLXNlcnZlciIKLW1zZ3N0ciAiLWRpc3BsYXkgPOTo8e/r5ek+XHTPs+QnuuTt4PLoIHZpbSDk7iDn4OTg7e7j7iDk6PHv6+X+IPHl8OLl8OAgWCIKK21zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdENvbm5lY3QgVmltIHRvIHRoaXMgcGFydGljdWxhciBYLXNlcnZlciIKK21zZ3N0ciAiLWRpc3BsYXkgPOTo8e/r5ek+XHTPs+QnuuTt4PLoIFZpbSDk7iDn4OTg7e7j7iDk6PHv6+X+IPHl8OLl8OAgWCIKIAogbXNnaWQgIi1YXHRcdFx0RG8gbm90IGNvbm5lY3QgdG8gWCBzZXJ2ZXIiCiBtc2dzdHIgIi1YXHRcdFx0zeUg5ye65O3z4uDy6PH/IOcgWCDx5fDi5fDu7CIKQEAgLTMyODMsMTAgKzMyODAsMTAgQEAKICJcbiIKICLA8OPz7OXt8ugg5Ov/IGd2aW0gKOLl8PGz/yBBdGhlbmEpXG4iCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biB2aW0gb24gPGRpc3BsYXk+IgotbXNnc3RyICItZGlzcGxheSA85Ojx7+vl6T5cdMLo6u7t4PLoIHZpbSDt4CDn4OTg7e7s8yA85Ojx7+vlvz4iCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gVmltIG9uIDxkaXNwbGF5PiIKK21zZ3N0ciAiLWRpc3BsYXkgPOTo8e/r5ek+XHTC6Oru7eDy6CBWaW0g7eAg5+Dk4O3u7PMgPOTo8e/r5b8+IgogCi1tc2dpZCAiLWljb25pY1x0XHRTdGFydCB2aW0gaWNvbmlmaWVkIgorbXNnaWQgIi1pY29uaWNcdFx0U3RhcnQgVmltIGljb25pZmllZCIKIG1zZ3N0ciAiLWljb25pY1x0XHTH4O/z8fLo8uggVmltILMg5+Pu8O3z8ugg6e7j7iDis+rt7iIKIAogbXNnaWQgIi1iYWNrZ3JvdW5kIDxjb2xvcj5cdFVzZSA8Y29sb3I+IGZvciB0aGUgYmFja2dyb3VuZCAoYWxzbzogLWJnKSIKQEAgLTMzMzMsOCArMzMzMCw4IEBACiAiXG4iCiAiwPDj8+zl7fLoIGd2aW0gKOLl8PGz/yBHVEsrKVxuIgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gdmltIG9uIDxkaXNwbGF5PiAoYWxzbzogLS1kaXNwbGF5KSIKLW1zZ3N0ciAiLWRpc3BsYXkgPOTo8e/r5ek+XHTC6Oru7eDy6CB2aW0g7eAgPOTo8e/r5b8+ICjy4Oru5jogLS1kaXNwbGF5KSIKK21zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biBWaW0gb24gPGRpc3BsYXk+IChhbHNvOiAtLWRpc3BsYXkpIgorbXNnc3RyICItZGlzcGxheSA85Ojx7+vl6T5cdMLo6u7t4PLoIFZpbSDt4CA85Ojx7+vlvz4gKPLg6u7mOiAtLWRpc3BsYXkpIgogCiBtc2dpZCAiLS1yb2xlIDxyb2xlPlx0U2V0IGEgdW5pcXVlIHJvbGUgdG8gaWRlbnRpZnkgdGhlIG1haW4gd2luZG93IgogbXNnc3RyICIiCkBAIC03MTIzLDcgKzcxMjAsNyBAQAogbXNnc3RyICKz7eTl6vEg8e/o8erzIOfgIOzl5uDs6CIKIAogIywgYy1mb3JtYXQKLW1zZ2lkICJpbnRlcm5hbCBlcnJvcjogZmFpbGVkIHRvIGdldCB2aW0gbGlzdCBpdGVtICVkIgorbXNnaWQgImludGVybmFsIGVycm9yOiBmYWlsZWQgdG8gZ2V0IFZpbSBsaXN0IGl0ZW0gJWQiCiBtc2dzdHIgIuLt8/Lws/jt/yDv7uzo6+rgOiDt5SDi5ODr7vH/IO7y8Ojs4PLoIOXr5ezl7fIg8e/o8erzIHZpbSAlZCIKIAogbXNnaWQgInNsaWNlIHN0ZXAgY2Fubm90IGJlIHplcm8iCkBAIC03MTM1LDcgKzcxMzIsNyBAQAogIvHv8O7h4CDv8Ojn7eD36PLoIO/u8euz5O7i7bPx8vwg8O7n7LPw8yDhs+v8+OUsIO2z5iAlZCwg8yDw7uf46PDl7ejpIOfws+ciCiAKICMsIGMtZm9ybWF0Ci1tc2dpZCAiaW50ZXJuYWwgZXJyb3I6IG5vIHZpbSBsaXN0IGl0ZW0gJWQiCittc2dpZCAiaW50ZXJuYWwgZXJyb3I6IG5vIFZpbSBsaXN0IGl0ZW0gJWQiCiBtc2dzdHIgIuLt8/Lws/jt/yDv7uzo6+rgOiDt5ezguiDl6+Xs5e3y4CDx7+jx6vMgdmltICVkIgogCiBtc2dpZCAiaW50ZXJuYWwgZXJyb3I6IG5vdCBlbm91Z2ggbGlzdCBpdGVtcyIKQEAgLTcyNDcsMTkgKzcyNDQsMTkgQEAKIG1zZ2lkICJFODU4OiBFdmFsIGRpZCBub3QgcmV0dXJuIGEgdmFsaWQgcHl0aG9uIG9iamVjdCIKIG1zZ3N0ciAiRTg1ODogRXZhbCDt5SDv7uLl8O3z4iDks+nx7ejpIO7hkrrq8iBweXRob24iCiAKLW1zZ2lkICJFODU5OiBGYWlsZWQgdG8gY29udmVydCByZXR1cm5lZCBweXRob24gb2JqZWN0IHRvIHZpbSB2YWx1ZSIKK21zZ2lkICJFODU5OiBGYWlsZWQgdG8gY29udmVydCByZXR1cm5lZCBweXRob24gb2JqZWN0IHRvIGEgVmltIHZhbHVlIgogbXNnc3RyICJFODU5OiDN5SDi5ODr7vH/IO/l8OXy4u7w6PLoIO7hkrrq8iBweXRob24g8yDn7eD35e3t/yB2aW0iCiAKICMsIGMtZm9ybWF0Ci1tc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gdmltIGRpY3Rpb25hcnkiCittc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gYSBWaW0gZGljdGlvbmFyeSIKIG1zZ3N0ciAi7eUg4uTg6+7x/yDv5fDl8uLu8Ojy6CAlcyDzIPHr7uLt6OogdmltIgogCiAjLCBjLWZvcm1hdAotbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIHZpbSBsaXN0IgorbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIGEgVmltIGxpc3QiCiBtc2dzdHIgIu3lIOLk4Ovu8f8g7+Xw5fLi7vDo8uggJXMg8yDx7+jx7uogdmltIgogCiAjLCBjLWZvcm1hdAotbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIHZpbSBzdHJ1Y3R1cmUiCittc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gYSBWaW0gc3RydWN0dXJlIgogbXNnc3RyICLt5SDi5ODr7vH/IO/l8OXy4u7w6PLoICVzIPMg8fLw8+ry8/DzIHZpbSIKIAogbXNnaWQgImludGVybmFsIGVycm9yOiBOVUxMIHJlZmVyZW5jZSBwYXNzZWQiCmRpZmYgLS1naXQgYS9zcmMvcG8vdWsucG8gYi9zcmMvcG8vdWsucG8KaW5kZXggOGVjMmNkZS4uYmIwMjBhZiAxMDA2NDQKLS0tIGEvc3JjL3BvL3VrLnBvCisrKyBiL3NyYy9wby91ay5wbwpAQCAtMjg3OSw5ICsyODc5LDYgQEAKIG1zZ2lkICJrZXlib2FyZCBpbnRlcnJ1cHQiCiBtc2dzdHIgItC/0LXRgNC10YDQstCw0L3QviDQtyDQutC70LDQstGW0LDRgtGD0YDQuCIKIAotbXNnaWQgInZpbSBlcnJvciIKLW1zZ3N0ciAi0L/QvtC80LjQu9C60LAgVmltIgotCiBtc2dpZCAiY2Fubm90IGNyZWF0ZSBidWZmZXIvd2luZG93IGNvbW1hbmQ6IG9iamVjdCBpcyBiZWluZyBkZWxldGVkIgogbXNnc3RyICLQvdC1INCy0LTQsNC70L7RgdGPINGB0YLQstC+0YDQuNGC0Lgg0LrQvtC80LDQvdC00YMg0LLRltC60L3QsC/QsdGD0YTQtdGA0LA6INC+0LEn0ZTQutGCINC30L3QuNGJ0YPRlNGC0YzRgdGPIgogCkBAIC0zMjAxLDggKzMxOTgsOCBAQAogbXNnaWQgIi14XHRcdFx0RWRpdCBlbmNyeXB0ZWQgZmlsZXMiCiBtc2dzdHIgIi14XHRcdFx00KDQtdC00LDQs9GD0LLQsNGC0Lgg0LfQsNGI0LjRhNGA0L7QstCw0L3RliDRhNCw0LnQu9C4IgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRDb25uZWN0IHZpbSB0byB0aGlzIHBhcnRpY3VsYXIgWC1zZXJ2ZXIiCi1tc2dzdHIgIi1kaXNwbGF5IDzQtNC40YHQv9C70LXQuT5cdNCf0ZbQtCfRlNC00L3QsNGC0LggdmltINC00L4g0LfQsNC00LDQvdC+0LPQviDQtNC40YHQv9C70LXRjiDRgdC10YDQstC10YDQsCBYIgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0Q29ubmVjdCBWaW0gdG8gdGhpcyBwYXJ0aWN1bGFyIFgtc2VydmVyIgorbXNnc3RyICItZGlzcGxheSA80LTQuNGB0L/Qu9C10Lk+XHTQn9GW0LQn0ZTQtNC90LDRgtC4IFZpbSDQtNC+INC30LDQtNCw0L3QvtCz0L4g0LTQuNGB0L/Qu9C10Y4g0YHQtdGA0LLQtdGA0LAgWCIKIAogbXNnaWQgIi1YXHRcdFx0RG8gbm90IGNvbm5lY3QgdG8gWCBzZXJ2ZXIiCiBtc2dzdHIgIi1YXHRcdFx00J3QtSDQtyfRlNC00L3Rg9Cy0LDRgtC40YHRjyDQtyBYINGB0LXRgNCy0LXRgNC+0LwiCkBAIC0zMjgzLDEwICszMjgwLDEwIEBACiAiXG4iCiAi0JDRgNCz0YPQvNC10L3RgtC4INC00LvRjyBndmltICjQstC10YDRgdGW0Y8gQXRoZW5hKVxuIgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gdmltIG9uIDxkaXNwbGF5PiIKLW1zZ3N0ciAiLWRpc3BsYXkgPNC00LjRgdC/0LvQtdC5Plx00JLQuNC60L7QvdCw0YLQuCB2aW0g0L3QsCDQt9Cw0LTQsNC90L7QvNGDIDzQtNC40YHQv9C70LXRlz4iCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gVmltIG9uIDxkaXNwbGF5PiIKK21zZ3N0ciAiLWRpc3BsYXkgPNC00LjRgdC/0LvQtdC5Plx00JLQuNC60L7QvdCw0YLQuCBWaW0g0L3QsCDQt9Cw0LTQsNC90L7QvNGDIDzQtNC40YHQv9C70LXRlz4iCiAKLW1zZ2lkICItaWNvbmljXHRcdFN0YXJ0IHZpbSBpY29uaWZpZWQiCittc2dpZCAiLWljb25pY1x0XHRTdGFydCBWaW0gaWNvbmlmaWVkIgogbXNnc3RyICItaWNvbmljXHRcdNCX0LDQv9GD0YHRgtC40YLQuCBWaW0g0ZYg0LfQs9C+0YDQvdGD0YLQuCDQudC+0LPQviDQstGW0LrQvdC+IgogCiBtc2dpZCAiLWJhY2tncm91bmQgPGNvbG9yPlx0VXNlIDxjb2xvcj4gZm9yIHRoZSBiYWNrZ3JvdW5kIChhbHNvOiAtYmcpIgpAQCAtMzMzMyw4ICszMzMwLDggQEAKICJcbiIKICLQkNGA0LPRg9C80LXQvdGC0LggZ3ZpbSAo0LLQtdGA0YHRltGPIEdUSyspXG4iCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biB2aW0gb24gPGRpc3BsYXk+IChhbHNvOiAtLWRpc3BsYXkpIgotbXNnc3RyICItZGlzcGxheSA80LTQuNGB0L/Qu9C10Lk+XHTQktC40LrQvtC90LDRgtC4IHZpbSDQvdCwIDzQtNC40YHQv9C70LXRlz4gKNGC0LDQutC+0LY6IC0tZGlzcGxheSkiCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gVmltIG9uIDxkaXNwbGF5PiAoYWxzbzogLS1kaXNwbGF5KSIKK21zZ3N0ciAiLWRpc3BsYXkgPNC00LjRgdC/0LvQtdC5Plx00JLQuNC60L7QvdCw0YLQuCBWaW0g0L3QsCA80LTQuNGB0L/Qu9C10Zc+ICjRgtCw0LrQvtC2OiAtLWRpc3BsYXkpIgogCiBtc2dpZCAiLS1yb2xlIDxyb2xlPlx0U2V0IGEgdW5pcXVlIHJvbGUgdG8gaWRlbnRpZnkgdGhlIG1haW4gd2luZG93IgogbXNnc3RyICIiCkBAIC03MTIzLDcgKzcxMjAsNyBAQAogbXNnc3RyICLRltC90LTQtdC60YEg0YHQv9C40YHQutGDINC30LAg0LzQtdC20LDQvNC4IgogCiAjLCBjLWZvcm1hdAotbXNnaWQgImludGVybmFsIGVycm9yOiBmYWlsZWQgdG8gZ2V0IHZpbSBsaXN0IGl0ZW0gJWQiCittc2dpZCAiaW50ZXJuYWwgZXJyb3I6IGZhaWxlZCB0byBnZXQgVmltIGxpc3QgaXRlbSAlZCIKIG1zZ3N0ciAi0LLQvdGD0YLRgNGW0YjQvdGPINC/0L7QvNC40LvQutCwOiDQvdC1INCy0LTQsNC70L7RgdGPINC+0YLRgNC40LzQsNGC0Lgg0LXQu9C10LzQtdC90YIg0YHQv9C40YHQutGDIHZpbSAlZCIKIAogbXNnaWQgInNsaWNlIHN0ZXAgY2Fubm90IGJlIHplcm8iCkBAIC03MTM1LDcgKzcxMzIsNyBAQAogItGB0L/RgNC+0LHQsCDQv9GA0LjQt9C90LDRh9C40YLQuCDQv9C+0YHQu9GW0LTQvtCy0L3RltGB0YLRjCDRgNC+0LfQvNGW0YDRgyDQsdGW0LvRjNGI0LUsINC90ZbQtiAlZCwg0YMg0YDQvtC30YjQuNGA0LXQvdC40Lkg0LfRgNGW0LciCiAKICMsIGMtZm9ybWF0Ci1tc2dpZCAiaW50ZXJuYWwgZXJyb3I6IG5vIHZpbSBsaXN0IGl0ZW0gJWQiCittc2dpZCAiaW50ZXJuYWwgZXJyb3I6IG5vIFZpbSBsaXN0IGl0ZW0gJWQiCiBtc2dzdHIgItCy0L3Rg9GC0YDRltGI0L3RjyDQv9C+0LzQuNC70LrQsDog0L3QtdC80LDRlCDQtdC70LXQvNC10L3RgtCwINGB0L/QuNGB0LrRgyB2aW0gJWQiCiAKIG1zZ2lkICJpbnRlcm5hbCBlcnJvcjogbm90IGVub3VnaCBsaXN0IGl0ZW1zIgpAQCAtNzI0NywxOSArNzI0NCwxOSBAQAogbXNnaWQgIkU4NTg6IEV2YWwgZGlkIG5vdCByZXR1cm4gYSB2YWxpZCBweXRob24gb2JqZWN0IgogbXNnc3RyICJFODU4OiBFdmFsINC90LUg0L/QvtCy0LXRgNC90YPQsiDQtNGW0LnRgdC90LjQuSDQvtCx4oCZ0ZTQutGCIHB5dGhvbiIKIAotbXNnaWQgIkU4NTk6IEZhaWxlZCB0byBjb252ZXJ0IHJldHVybmVkIHB5dGhvbiBvYmplY3QgdG8gdmltIHZhbHVlIgorbXNnaWQgIkU4NTk6IEZhaWxlZCB0byBjb252ZXJ0IHJldHVybmVkIHB5dGhvbiBvYmplY3QgdG8gYSBWaW0gdmFsdWUiCiBtc2dzdHIgIkU4NTk6INCd0LUg0LLQtNCw0LvQvtGB0Y8g0L/QtdGA0LXRgtCy0L7RgNC40YLQuCDQvtCx4oCZ0ZTQutGCIHB5dGhvbiDRgyDQt9C90LDRh9C10L3QvdGPIHZpbSIKIAogIywgYy1mb3JtYXQKLW1zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byB2aW0gZGljdGlvbmFyeSIKK21zZ2lkICJ1bmFibGUgdG8gY29udmVydCAlcyB0byBhIFZpbSBkaWN0aW9uYXJ5IgogbXNnc3RyICLQvdC1INCy0LTQsNC70L7RgdGPINC/0LXRgNC10YLQstC+0YDQuNGC0LggJXMg0YMg0YHQu9C+0LLQvdC40LogdmltIgogCiAjLCBjLWZvcm1hdAotbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIHZpbSBsaXN0IgorbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIGEgVmltIGxpc3QiCiBtc2dzdHIgItC90LUg0LLQtNCw0LvQvtGB0Y8g0L/QtdGA0LXRgtCy0L7RgNC40YLQuCAlcyDRgyDRgdC/0LjRgdC+0LogdmltIgogCiAjLCBjLWZvcm1hdAotbXNnaWQgInVuYWJsZSB0byBjb252ZXJ0ICVzIHRvIHZpbSBzdHJ1Y3R1cmUiCittc2dpZCAidW5hYmxlIHRvIGNvbnZlcnQgJXMgdG8gYSBWaW0gc3RydWN0dXJlIgogbXNnc3RyICLQvdC1INCy0LTQsNC70L7RgdGPINC/0LXRgNC10YLQstC+0YDQuNGC0LggJXMg0YMg0YHRgtGA0YPQutGC0YPRgNGDIHZpbSIKIAogbXNnaWQgImludGVybmFsIGVycm9yOiBOVUxMIHJlZmVyZW5jZSBwYXNzZWQiCmRpZmYgLS1naXQgYS9zcmMvcG8vdmkucG8gYi9zcmMvcG8vdmkucG8KaW5kZXggOTFlNTU2Mi4uMjRiNzAwMSAxMDA2NDQKLS0tIGEvc3JjL3BvL3ZpLnBvCisrKyBiL3NyYy9wby92aS5wbwpAQCAtMjE3Niw3ICsyMTc2LDcgQEAKIG1zZ2lkICJrZXlib2FyZCBpbnRlcnJ1cHQiCiBtc2dzdHIgInPhu7EgZ2nDoW4gxJFv4bqhbiBj4bunYSBiw6BuIHBow61tIgogCi1tc2dpZCAidmltIGVycm9yIgorbXNnaWQgIlZpbSBlcnJvciIKIG1zZ3N0ciAibOG7l2kgY+G7p2EgdmltIgogCiBtc2dpZCAiY2Fubm90IGNyZWF0ZSBidWZmZXIvd2luZG93IGNvbW1hbmQ6IG9iamVjdCBpcyBiZWluZyBkZWxldGVkIgpAQCAtMjQ2MCw4ICsyNDYwLDggQEAKIG1zZ2lkICIteFx0XHRcdEVkaXQgZW5jcnlwdGVkIGZpbGVzIgogbXNnc3RyICIteFx0XHRcdFNv4bqhbiB0aOG6o28gdOG6rXAgdGluIMSRw6MgbcOjIGjDs2EiCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdENvbm5lY3QgdmltIHRvIHRoaXMgcGFydGljdWxhciBYLXNlcnZlciIKLW1zZ3N0ciAiLWRpc3BsYXkgPG3DoG4gaMOsbmg+XHRL4bq/dCBu4buRaSB2aW0gdOG7m2kgbcOheSBjaOG7pyBYIMSRw6MgY2jhu4kgcmEiCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRDb25uZWN0IFZpbSB0byB0aGlzIHBhcnRpY3VsYXIgWC1zZXJ2ZXIiCittc2dzdHIgIi1kaXNwbGF5IDxtw6BuIGjDrG5oPlx0S+G6v3QgbuG7kWkgVmltIHThu5tpIG3DoXkgY2jhu6cgWCDEkcOjIGNo4buJIHJhIgogCiBtc2dpZCAiLVhcdFx0XHREbyBub3QgY29ubmVjdCB0byBYIHNlcnZlciIKIG1zZ3N0ciAiLVhcdFx0XHRLaMO0bmcgdGjhu7FjIGhp4buHbiB2aeG7h2Mga+G6v3QgbuG7kWkgdOG7m2kgbcOheSBjaOG7pyBYIgpAQCAtMjUyNiwxMSArMjUyNiwxMSBAQAogIlxuIgogIlRoYW0gc+G7kSBjaG8gZ3ZpbSAocGhpw6puIGLhuqNuIEF0aGVuYSk6XG4iCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biB2aW0gb24gPGRpc3BsYXk+IgotbXNnc3RyICItZGlzcGxheSA8bcOgbiBow6xuaD5cdENo4bqheSB2aW0gdHJvbmcgPG3DoG4gaMOsbmg+IMSRw6MgY2jhu4kgcmEiCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gVmltIG9uIDxkaXNwbGF5PiIKK21zZ3N0ciAiLWRpc3BsYXkgPG3DoG4gaMOsbmg+XHRDaOG6oXkgVmltIHRyb25nIDxtw6BuIGjDrG5oPiDEkcOjIGNo4buJIHJhIgogCi1tc2dpZCAiLWljb25pY1x0XHRTdGFydCB2aW0gaWNvbmlmaWVkIgotbXNnc3RyICItaWNvbmljXHRcdENo4bqheSB2aW0g4bufIGThuqFuZyB0aHUgbmjhu48iCittc2dpZCAiLWljb25pY1x0XHRTdGFydCBWaW0gaWNvbmlmaWVkIgorbXNnc3RyICItaWNvbmljXHRcdENo4bqheSBWaW0g4bufIGThuqFuZyB0aHUgbmjhu48iCiAKIG1zZ2lkICItbmFtZSA8bmFtZT5cdFx0VXNlIHJlc291cmNlIGFzIGlmIHZpbSB3YXMgPG5hbWU+IgogbXNnc3RyICItbmFtZSA8dMOqbj5cdFx0U+G7rSBk4bulbmcgdMOgaSBuZ3V5w6puIGdp4buRbmcgbmjGsCBraGkgdmltIGPDsyA8dMOqbj4iCkBAIC0yNTk5LDkgKzI1OTksOSBAQAogIlxuIgogIlRoYW0gc+G7kSBjaG8gZ3ZpbSAocGhpw6puIGLhuqNuIEdUSyspOlxuIgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gdmltIG9uIDxkaXNwbGF5PiAoYWxzbzogLS1kaXNwbGF5KSIKK21zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biBWaW0gb24gPGRpc3BsYXk+IChhbHNvOiAtLWRpc3BsYXkpIgogbXNnc3RyICIiCi0iLWRpc3BsYXkgPG3DoG4gaMOsbmg+XHRDaOG6oXkgdmltIHRyw6puIDxtw6BuIGjDrG5oPiBjaOG7iSByYSAoY8WpbmcgbmjGsDogLS1kaXNwbGF5KSIKKyItZGlzcGxheSA8bcOgbiBow6xuaD5cdENo4bqheSBWaW0gdHLDqm4gPG3DoG4gaMOsbmg+IGNo4buJIHJhIChjxaluZyBuaMawOiAtLWRpc3BsYXkpIgogCiBtc2dpZCAiLS1yb2xlIDxyb2xlPlx0U2V0IGEgdW5pcXVlIHJvbGUgdG8gaWRlbnRpZnkgdGhlIG1haW4gd2luZG93IgogbXNnc3RyICItLXJvbGUgPHZhaSB0csOyPlx0xJDhurd0IDx2YWkgdHLDsj4gZHV5IG5o4bqldCDEkeG7gyBuaOG6rW4gZGnhu4duIGPhu61hIHPhu5UgY2jDrW5oIgpkaWZmIC0tZ2l0IGEvc3JjL3BvL3poX0NOLlVURi04LnBvIGIvc3JjL3BvL3poX0NOLlVURi04LnBvCmluZGV4IGJiODhjYzkuLjgzZWQwMWUgMTAwNjQ0Ci0tLSBhL3NyYy9wby96aF9DTi5VVEYtOC5wbworKysgYi9zcmMvcG8vemhfQ04uVVRGLTgucG8KQEAgLTI1NjksOSArMjU2OSw2IEBACiBtc2dpZCAia2V5Ym9hcmQgaW50ZXJydXB0IgogbXNnc3RyICLplK7nm5jkuK3mlq0iCiAKLW1zZ2lkICJ2aW0gZXJyb3IiCi1tc2dzdHIgInZpbSDplJnor68iCi0KIG1zZ2lkICJjYW5ub3QgY3JlYXRlIGJ1ZmZlci93aW5kb3cgY29tbWFuZDogb2JqZWN0IGlzIGJlaW5nIGRlbGV0ZWQiCiBtc2dzdHIgIuaXoOazleWIm+W7uue8k+WGsuWMui/nqpflj6Plkb3ku6Q6IOWvueixoeWwhuiiq+WIoOmZpCIKIApAQCAtMjg1NSw4ICsyODUyLDggQEAKIG1zZ2lkICIteFx0XHRcdEVkaXQgZW5jcnlwdGVkIGZpbGVzIgogbXNnc3RyICIteFx0XHRcdOe8lui+keWKoOWvhueahOaWh+S7tiIKIAotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0Q29ubmVjdCB2aW0gdG8gdGhpcyBwYXJ0aWN1bGFyIFgtc2VydmVyIgotbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdOWwhiB2aW0g5LiO5oyH5a6a55qEIFgtc2VydmVyIOi/nuaOpSIKK21zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdENvbm5lY3QgVmltIHRvIHRoaXMgcGFydGljdWxhciBYLXNlcnZlciIKK21zZ3N0ciAiLWRpc3BsYXkgPGRpc3BsYXk+XHTlsIYgVmltIOS4juaMh+WumueahCBYLXNlcnZlciDov57mjqUiCiAKIG1zZ2lkICItWFx0XHRcdERvIG5vdCBjb25uZWN0IHRvIFggc2VydmVyIgogbXNnc3RyICItWFx0XHRcdOS4jei/nuaOpeWIsCBYIFNlcnZlciIKQEAgLTI5MjEsMTAgKzI5MTgsMTAgQEAKICJcbiIKICJndmltIChBdGhlbmEg54mI5pysKSDlj6/or4bliKvnmoTlj4LmlbA6XG4iCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biB2aW0gb24gPGRpc3BsYXk+IgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIFZpbSBvbiA8ZGlzcGxheT4iCiBtc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx05ZyoIDxkaXNwbGF5PiDkuIrov5DooYwgdmltIgogCi1tc2dpZCAiLWljb25pY1x0XHRTdGFydCB2aW0gaWNvbmlmaWVkIgorbXNnaWQgIi1pY29uaWNcdFx0U3RhcnQgVmltIGljb25pZmllZCIKIG1zZ3N0ciAiLWljb25pY1x0XHTlkK/liqjlkI7mnIDlsI/ljJYiCiAKIG1zZ2lkICItbmFtZSA8bmFtZT5cdFx0VXNlIHJlc291cmNlIGFzIGlmIHZpbSB3YXMgPG5hbWU+IgpAQCAtMjk4OSw4ICsyOTg2LDggQEAKICJcbiIKICJndmltIChHVEsrIOeJiOacrCkg5Y+v6K+G5Yir55qE5Y+C5pWwOlxuIgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gdmltIG9uIDxkaXNwbGF5PiAoYWxzbzogLS1kaXNwbGF5KSIKLW1zZ3N0ciAiLWRpc3BsYXkgPGRpc3BsYXk+XHTlnKggPGRpc3BsYXk+IOS4iui/kOihjCB2aW0gKOS5n+WPr+eUqCAtLWRpc3BsYXkpIgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIFZpbSBvbiA8ZGlzcGxheT4gKGFsc286IC0tZGlzcGxheSkiCittc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx05ZyoIDxkaXNwbGF5PiDkuIrov5DooYwgVmltICjkuZ/lj6/nlKggLS1kaXNwbGF5KSIKIAogbXNnaWQgIi0tcm9sZSA8cm9sZT5cdFNldCBhIHVuaXF1ZSByb2xlIHRvIGlkZW50aWZ5IHRoZSBtYWluIHdpbmRvdyIKIG1zZ3N0ciAiLS1yb2xlIDxyb2xlPlx06K6+572u55So5LqO5Yy65YiG5Li756qX5Y+j55qE56qX5Y+j6KeS6Imy5ZCNIgpkaWZmIC0tZ2l0IGEvc3JjL3BvL3poX0NOLmNwOTM2LnBvIGIvc3JjL3BvL3poX0NOLmNwOTM2LnBvCmluZGV4IGI2ZTJiZDkuLjNmZWVkOWQgMTAwNjQ0Ci0tLSBhL3NyYy9wby96aF9DTi5jcDkzNi5wbworKysgYi9zcmMvcG8vemhfQ04uY3A5MzYucG8KQEAgLTI1NjksOSArMjU2OSw2IEBACiBtc2dpZCAia2V5Ym9hcmQgaW50ZXJydXB0IgogbXNnc3RyICK8/MXM1tC2zyIKIAotbXNnaWQgInZpbSBlcnJvciIKLW1zZ3N0ciAidmltILTtzvMiCi0KIG1zZ2lkICJjYW5ub3QgY3JlYXRlIGJ1ZmZlci93aW5kb3cgY29tbWFuZDogb2JqZWN0IGlzIGJlaW5nIGRlbGV0ZWQiCiBtc2dzdHIgIs7et6i0tL2ou7qz5cf4L7Swv9rD/MHuOiC21M/zvauxu8m+s/0iCiAKQEAgLTI4NTUsOCArMjg1Miw4IEBACiBtc2dpZCAiLXhcdFx0XHRFZGl0IGVuY3J5cHRlZCBmaWxlcyIKIG1zZ3N0ciAiLXhcdFx0XHSx4LytvNPD3LXEzsS8/iIKIAotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0Q29ubmVjdCB2aW0gdG8gdGhpcyBwYXJ0aWN1bGFyIFgtc2VydmVyIgotbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdL2rIHZpbSDT69a4tqi1xCBYLXNlcnZlciDBrL3TIgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0Q29ubmVjdCBWaW0gdG8gdGhpcyBwYXJ0aWN1bGFyIFgtc2VydmVyIgorbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdL2rIFZpbSDT69a4tqi1xCBYLXNlcnZlciDBrL3TIgogCiBtc2dpZCAiLVhcdFx0XHREbyBub3QgY29ubmVjdCB0byBYIHNlcnZlciIKIG1zZ3N0ciAiLVhcdFx0XHSyu8GsvdO1vSBYIFNlcnZlciIKQEAgLTI5MjEsMTAgKzI5MTgsMTAgQEAKICJcbiIKICJndmltIChBdGhlbmEgsOaxvikgv8nKtrHwtcSyzsr9OlxuIgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gdmltIG9uIDxkaXNwbGF5PiIKK21zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biBWaW0gb24gPGRpc3BsYXk+IgogbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdNTaIDxkaXNwbGF5PiDJz9TL0NAgdmltIgogCi1tc2dpZCAiLWljb25pY1x0XHRTdGFydCB2aW0gaWNvbmlmaWVkIgorbXNnaWQgIi1pY29uaWNcdFx0U3RhcnQgVmltIGljb25pZmllZCIKIG1zZ3N0ciAiLWljb25pY1x0XHTG9LavuvPX7tChu68iCiAKIG1zZ2lkICItbmFtZSA8bmFtZT5cdFx0VXNlIHJlc291cmNlIGFzIGlmIHZpbSB3YXMgPG5hbWU+IgpAQCAtMjk4OSw4ICsyOTg2LDggQEAKICJcbiIKICJndmltIChHVEsrILDmsb4pIL/Jyrax8LXEss7K/TpcbiIKIAotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIHZpbSBvbiA8ZGlzcGxheT4gKGFsc286IC0tZGlzcGxheSkiCi1tc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx01NogPGRpc3BsYXk+IMnP1MvQ0CB2aW0gKNKyv8nTwyAtLWRpc3BsYXkpIgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIFZpbSBvbiA8ZGlzcGxheT4gKGFsc286IC0tZGlzcGxheSkiCittc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx01NogPGRpc3BsYXk+IMnP1MvQ0CBWaW0gKNKyv8nTwyAtLWRpc3BsYXkpIgogCiBtc2dpZCAiLS1yb2xlIDxyb2xlPlx0U2V0IGEgdW5pcXVlIHJvbGUgdG8gaWRlbnRpZnkgdGhlIG1haW4gd2luZG93IgogbXNnc3RyICItLXJvbGUgPHJvbGU+XHTJ6NbD08PT2sf4t9bW97Swv9q1xLSwv9q9x8mrw/siCmRpZmYgLS1naXQgYS9zcmMvcG8vemhfQ04ucG8gYi9zcmMvcG8vemhfQ04ucG8KaW5kZXggYmRkYWQwZC4uNjA2Yjc1YyAxMDA2NDQKLS0tIGEvc3JjL3BvL3poX0NOLnBvCisrKyBiL3NyYy9wby96aF9DTi5wbwpAQCAtMjU3MCw5ICsyNTcwLDYgQEAKIG1zZ2lkICJrZXlib2FyZCBpbnRlcnJ1cHQiCiBtc2dzdHIgIrz8xczW0LbPIgogCi1tc2dpZCAidmltIGVycm9yIgotbXNnc3RyICJ2aW0gtO3O8yIKLQogbXNnaWQgImNhbm5vdCBjcmVhdGUgYnVmZmVyL3dpbmRvdyBjb21tYW5kOiBvYmplY3QgaXMgYmVpbmcgZGVsZXRlZCIKIG1zZ3N0ciAizt63qLS0vai7urPlx/gvtLC/2sP8we46ILbUz/O9q7G7yb6z/SIKIApAQCAtMjg1Niw4ICsyODUzLDggQEAKIG1zZ2lkICIteFx0XHRcdEVkaXQgZW5jcnlwdGVkIGZpbGVzIgogbXNnc3RyICIteFx0XHRcdLHgvK2808PctcTOxLz+IgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRDb25uZWN0IHZpbSB0byB0aGlzIHBhcnRpY3VsYXIgWC1zZXJ2ZXIiCi1tc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0vasgdmltINPr1ri2qLXEIFgtc2VydmVyIMGsvdMiCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRDb25uZWN0IFZpbSB0byB0aGlzIHBhcnRpY3VsYXIgWC1zZXJ2ZXIiCittc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx0vasgVmltINPr1ri2qLXEIFgtc2VydmVyIMGsvdMiCiAKIG1zZ2lkICItWFx0XHRcdERvIG5vdCBjb25uZWN0IHRvIFggc2VydmVyIgogbXNnc3RyICItWFx0XHRcdLK7way907W9IFggU2VydmVyIgpAQCAtMjkyMSwxMCArMjkxOCwxMCBAQAogIlxuIgogImd2aW0gKEF0aGVuYSCw5rG+KSC/ycq2sfC1xLLOyv06XG4iCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biB2aW0gb24gPGRpc3BsYXk+IgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIFZpbSBvbiA8ZGlzcGxheT4iCiBtc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx01NogPGRpc3BsYXk+IMnP1MvQ0CB2aW0iCiAKLW1zZ2lkICItaWNvbmljXHRcdFN0YXJ0IHZpbSBpY29uaWZpZWQiCittc2dpZCAiLWljb25pY1x0XHRTdGFydCBWaW0gaWNvbmlmaWVkIgogbXNnc3RyICItaWNvbmljXHRcdMb0tq+689fu0KG7ryIKIAogbXNnaWQgIi1uYW1lIDxuYW1lPlx0XHRVc2UgcmVzb3VyY2UgYXMgaWYgdmltIHdhcyA8bmFtZT4iCkBAIC0yOTg5LDggKzI5ODYsOCBAQAogIlxuIgogImd2aW0gKEdUSysgsOaxvikgv8nKtrHwtcSyzsr9OlxuIgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gdmltIG9uIDxkaXNwbGF5PiAoYWxzbzogLS1kaXNwbGF5KSIKLW1zZ3N0ciAiLWRpc3BsYXkgPGRpc3BsYXk+XHTU2iA8ZGlzcGxheT4gyc/Uy9DQIHZpbSAo0rK/ydPDIC0tZGlzcGxheSkiCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gVmltIG9uIDxkaXNwbGF5PiAoYWxzbzogLS1kaXNwbGF5KSIKK21zZ3N0ciAiLWRpc3BsYXkgPGRpc3BsYXk+XHTU2iA8ZGlzcGxheT4gyc/Uy9DQIFZpbSAo0rK/ydPDIC0tZGlzcGxheSkiCiAKIG1zZ2lkICItLXJvbGUgPHJvbGU+XHRTZXQgYSB1bmlxdWUgcm9sZSB0byBpZGVudGlmeSB0aGUgbWFpbiB3aW5kb3ciCiBtc2dzdHIgIi0tcm9sZSA8cm9sZT5cdMno1sPTw9Pax/i31tb3tLC/2rXEtLC/2r3HyavD+yIKZGlmZiAtLWdpdCBhL3NyYy9wby96aF9UVy5VVEYtOC5wbyBiL3NyYy9wby96aF9UVy5VVEYtOC5wbwppbmRleCA4NmUyY2UxLi5lOTkxYjdhIDEwMDY0NAotLS0gYS9zcmMvcG8vemhfVFcuVVRGLTgucG8KKysrIGIvc3JjL3BvL3poX1RXLlVURi04LnBvCkBAIC0yMTkwLDcgKzIxOTAsNyBAQAogbXNnaWQgImtleWJvYXJkIGludGVycnVwdCIKIG1zZ3N0ciAi6Y2155uk5Lit5pa3IgogCi1tc2dpZCAidmltIGVycm9yIgorbXNnaWQgIlZpbSBlcnJvciIKIG1zZ3N0ciAidmltIOmMr+iqpCIKIAogbXNnaWQgImNhbm5vdCBjcmVhdGUgYnVmZmVyL3dpbmRvdyBjb21tYW5kOiBvYmplY3QgaXMgYmVpbmcgZGVsZXRlZCIKQEAgLTI0NjMsOCArMjQ2Myw4IEBACiBtc2dpZCAiLXhcdFx0XHRFZGl0IGVuY3J5cHRlZCBmaWxlcyIKIG1zZ3N0ciAiLXhcdFx0XHTnt6jovK/nt6jnorzpgY7nmoTmqpTmoYgiCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdENvbm5lY3QgdmltIHRvIHRoaXMgcGFydGljdWxhciBYLXNlcnZlciIKLW1zZ3N0ciAiLWRpc3BsYXkgPGRpc3BsYXk+XHTlsIcgdmltIOiIh+aMh+WumueahCBYLXNlcnZlciDpgKPnt5oiCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRDb25uZWN0IFZpbSB0byB0aGlzIHBhcnRpY3VsYXIgWC1zZXJ2ZXIiCittc2dzdHIgIi1kaXNwbGF5IDxkaXNwbGF5Plx05bCHIFZpbSDoiIfmjIflrprnmoQgWC1zZXJ2ZXIg6YCj57eaIgogCiBtc2dpZCAiLVhcdFx0XHREbyBub3QgY29ubmVjdCB0byBYIHNlcnZlciIKIG1zZ3N0ciAiLVhcdFx0XHTkuI3opoHpgKPnt5rliLAgWCBTZXJ2ZXIiCkBAIC0yNTI1LDEwICsyNTI1LDEwIEBACiAiXG4iCiAiZ3ZpbSDoqo3lvpfnmoTlj4PmlbggKEF0aGVuYSDniYgpOlxuIgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gdmltIG9uIDxkaXNwbGF5PiIKK21zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biBWaW0gb24gPGRpc3BsYXk+IgogbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdOWcqOimlueqlyA8ZGlzcGxheT4g5Z+36KGMIHZpbSIKIAotbXNnaWQgIi1pY29uaWNcdFx0U3RhcnQgdmltIGljb25pZmllZCIKK21zZ2lkICItaWNvbmljXHRcdFN0YXJ0IFZpbSBpY29uaWZpZWQiCiBtc2dzdHIgIi1pY29uaWNcdFx05ZWf5YuV5b6M5ZyW56S65YyWKGljb25pZmllZCkiCiAKIG1zZ2lkICItbmFtZSA8bmFtZT5cdFx0VXNlIHJlc291cmNlIGFzIGlmIHZpbSB3YXMgPG5hbWU+IgpAQCAtMjU5Myw3ICsyNTkzLDcgQEAKICJcbiIKICJndmltIOiqjeW+l+eahOWPg+aVuCAoR1RLKyDniYgpOlxuIgogCi1tc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gdmltIG9uIDxkaXNwbGF5PiAoYWxzbzogLS1kaXNwbGF5KSIKK21zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biBWaW0gb24gPGRpc3BsYXk+IChhbHNvOiAtLWRpc3BsYXkpIgogbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdOWcqCA8ZGlzcGxheT4g5Z+36KGMIHZpbSAo5Lmf5Y+v55SoIC0tZGlzcGxheSkiCiAKIG1zZ2lkICItLXJvbGUgPHJvbGU+XHRTZXQgYSB1bmlxdWUgcm9sZSB0byBpZGVudGlmeSB0aGUgbWFpbiB3aW5kb3ciCmRpZmYgLS1naXQgYS9zcmMvcG8vemhfVFcucG8gYi9zcmMvcG8vemhfVFcucG8KaW5kZXggNzBlMDQ2Yy4uNjU3ZDYwNCAxMDA2NDQKLS0tIGEvc3JjL3BvL3poX1RXLnBvCisrKyBiL3NyYy9wby96aF9UVy5wbwpAQCAtMjE4Myw3ICsyMTgzLDcgQEAKIG1zZ2lkICJrZXlib2FyZCBpbnRlcnJ1cHQiCiBtc2dzdHIgIsHkvUykpMJfIgogCi1tc2dpZCAidmltIGVycm9yIgorbXNnaWQgIlZpbSBlcnJvciIKIG1zZ3N0ciAidmltIL/5u34iCiAKIG1zZ2lkICJjYW5ub3QgY3JlYXRlIGJ1ZmZlci93aW5kb3cgY29tbWFuZDogb2JqZWN0IGlzIGJlaW5nIGRlbGV0ZWQiCkBAIC0yNDU2LDggKzI0NTYsOCBAQAogbXNnaWQgIi14XHRcdFx0RWRpdCBlbmNyeXB0ZWQgZmlsZXMiCiBtc2dzdHIgIi14XHRcdFx0vXO/6L1zvVi5TKq6wMmu1yIKIAotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0Q29ubmVjdCB2aW0gdG8gdGhpcyBwYXJ0aWN1bGFyIFgtc2VydmVyIgotbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdLFOIHZpbSC7UKv8qXequiBYLXNlcnZlciCzc711IgorbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0Q29ubmVjdCBWaW0gdG8gdGhpcyBwYXJ0aWN1bGFyIFgtc2VydmVyIgorbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdLFOIFZpbSC7UKv8qXequiBYLXNlcnZlciCzc711IgogCiBtc2dpZCAiLVhcdFx0XHREbyBub3QgY29ubmVjdCB0byBYIHNlcnZlciIKIG1zZ3N0ciAiLVhcdFx0XHSko61us3O9dajsIFggU2VydmVyIgpAQCAtMjUxOCwxMCArMjUxOCwxMCBAQAogIlxuIgogImd2aW0gu3uxb6q6sNG8xiAoQXRoZW5hIKqpKTpcbiIKIAotbXNnaWQgIi1kaXNwbGF5IDxkaXNwbGF5Plx0UnVuIHZpbSBvbiA8ZGlzcGxheT4iCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gVmltIG9uIDxkaXNwbGF5PiIKIG1zZ3N0ciAiLWRpc3BsYXkgPGRpc3BsYXk+XHSmYrX4taEgPGRpc3BsYXk+ILD1puYgdmltIgogCi1tc2dpZCAiLWljb25pY1x0XHRTdGFydCB2aW0gaWNvbmlmaWVkIgorbXNnaWQgIi1pY29uaWNcdFx0U3RhcnQgVmltIGljb25pZmllZCIKIG1zZ3N0ciAiLWljb25pY1x0XHSx0rDKq+G5z6XcpMYoaWNvbmlmaWVkKSIKIAogbXNnaWQgIi1uYW1lIDxuYW1lPlx0XHRVc2UgcmVzb3VyY2UgYXMgaWYgdmltIHdhcyA8bmFtZT4iCkBAIC0yNTg2LDggKzI1ODYsOCBAQAogIlxuIgogImd2aW0gu3uxb6q6sNG8xiAoR1RLKyCqqSk6XG4iCiAKLW1zZ2lkICItZGlzcGxheSA8ZGlzcGxheT5cdFJ1biB2aW0gb24gPGRpc3BsYXk+IChhbHNvOiAtLWRpc3BsYXkpIgotbXNnc3RyICItZGlzcGxheSA8ZGlzcGxheT5cdKZiIDxkaXNwbGF5PiCw9abmIHZpbSAopF2laaXOIC0tZGlzcGxheSkiCittc2dpZCAiLWRpc3BsYXkgPGRpc3BsYXk+XHRSdW4gVmltIG9uIDxkaXNwbGF5PiAoYWxzbzogLS1kaXNwbGF5KSIKK21zZ3N0ciAiLWRpc3BsYXkgPGRpc3BsYXk+XHSmYiA8ZGlzcGxheT4gsPWm5iBWaW0gKKRdpWmlziAtLWRpc3BsYXkpIgogCiBtc2dpZCAiLS1yb2xlIDxyb2xlPlx0U2V0IGEgdW5pcXVlIHJvbGUgdG8gaWRlbnRpZnkgdGhlIG1haW4gd2luZG93IgogbXNnc3RyICItLXJvbGUgPHJvbGU+XHSzXal3v1evU6q6qKSm4ihyb2xlKaVIsM+kwKVEtfi1oSIK