ZGlmZiAtLWdpdCBhL01hYy9EZW1vL2J1aWxkaW5nLmh0bWwgYi9NYWMvRGVtby9idWlsZGluZy5odG1sCmluZGV4IGRjNmM5YTIuLmMyN2RlMDMgMTAwNjQ0Ci0tLSBhL01hYy9EZW1vL2J1aWxkaW5nLmh0bWwKKysrIGIvTWFjL0RlbW8vYnVpbGRpbmcuaHRtbApAQCAtNDQsNyArNDQsNyBAQAogcmVsYXRlZCBzdHVmZi4KIAogPExJPiBZb3UgbmVlZCBNZXRyb1dlcmtzIENvZGVXYXJyaW9yLiBUaGUgY3VycmVudCBkaXN0cmlidXRpb24gaGFzCi1iZWVuIGJ1aWx0IHdpdGggdmVyc2lvbiAxMSBvZiBDb2RlV2Fycmlvci4gT3JkZXJpbmcgaW5mb3JtYXRpb24gaXMKK2JlZW4gYnVpbHQgd2l0aCBDb2RlV2FycmlvciBQcm8gMS4gT3JkZXJpbmcgaW5mb3JtYXRpb24gaXMKIGF2YWlsYWJsZSBvbiB0aGUgPEEgSFJFRj0iaHR0cDovL3d3dy5tZXRyb3dlcmtzLmNvbS8iPk1ldHJvV2Vya3MKIGhvbWVwYWdlPC9BPi4gWW91IG1pZ2h0IHN0aWxsIGJlIGFibGUgdG8gYnVpbGQgUHl0aG9uIHdpdGggTVBXIG9yCiBUaGluay9TeW1hbnRlYyBDIGJ1dCB5b3UgYXJlIGJhc2ljYWxseSBvbiB5b3VyIG93bi4KQEAgLTU0LDcgKzU0LDcgQEAKIG9idGFpbmFibGUgZnJvbSA8QQogSFJFRj0iZnRwOi8vc3Vuc2l0ZS5jbmxhYi1zd2l0Y2guY2gvc29mdHdhcmUvcGxhdGZvcm0vbWFjb3Mvc3JjIj4KIGZ0cDovL3N1bnNpdGUuY25sYWItc3dpdGNoLmNoL3NvZnR3YXJlL3BsYXRmb3JtL21hY29zL3NyYzwvQT4uCi1BdCB0aGUgbW9tZW50IFB5dGhvbiBpcyBidWlsdCB3aXRoIGEgcmF0aGVyIGhhY2tlZC11cCB2ZXJzaW9uIG9mIEdVU0ksCitBdCB0aGUgbW9tZW50IFB5dGhvbiBpcyBidWlsdCB3aXRoIGEgc2xpZ2h0bHkgbW9kaWZpZWQgdmVyc2lvbiBvZiBHVVNJIDEuOC4xZmMyLAogdGhlc2UgbW9kaWZpY2F0aW9ucyBhcmUgYXZhaWxhYmxlIGluIGZvbGRlciA8Y29kZT5QeXRob246TWFjOkdVU0ktbW9kczwvY29kZT4uCiAKIDwvVUw+CkBAIC0xMjEsNjUgKzEyMSw0MSBAQAogCQl6bGliCiAJCWxpYnBuZwogCWdkYm0KLQlNb3JlRmlsZXMgMS40LjMgKG5vdCBuZWVkZWQgYnkgUHl0aG9uLCBvbmx5IGJ5IHRjbC90aykKIAlQeXRob24KLQlUY2wgNy42Ci0JVGsgNC4yCisJVGNsL1RrIEZvbGRlcgorCQl0Y2w4LjAKKwkJdGs4LjAKKwkJTW9yZUZpbGVzIDEuNC4zCiAJV2FzdGUgMS4yIGRpc3RyaWJ1dGlvbiAoaWYgeW91IHdhbnQgd2FzdGUpCiA8L1BSRT4KIAogRmlyc3QgYnVpbGQgR1VTSS4gSWYgeW91IGRpZG4ndCBnZXQgdGhlIHB5dGhvbi1zcGVjaWZpYyBHVVNJIHlvdSBoYXZlIHRvIAogbW92ZSB0aGUgZmlsZXMgZnJvbSB0aGUgIkNXR1VTSS1tb2RzIiB0byB0aGUgcmlnaHQKLXBsYWNlIGluIHRoZSBDV0dVU0kgZGlzdHJpYnV0aW9uIGZvbGRlci4gQnVpbGQgdGhlCi1wcm9qZWN0cyA8Y29kZT5NU0xHVVNJLjY4Sy61PC9jb2RlPiwgPGNvZGU+TVNMR1VTSS5DRk02OEsutTwvY29kZT4gYW5kCi08Y29kZT5NU0xHVVNJLlBQQy61PC9jb2RlPi4gPHA+CitwbGFjZSBpbiB0aGUgQ1dHVVNJIGRpc3RyaWJ1dGlvbiBmb2xkZXIuIEJ1aWxkIHRoZSBNU0wgdGFyZ2V0IGZvciB5b3VyCitwbGF0Zm9ybSAoTVNMR1VTSSBQUEMsIE1TTEdVU0kgNjhLIG9yIE1TTEdVU0kgQ0ZNNjhLKS4gPHA+CiAKLUlmIHlvdSBoYXZlIGEgQ1dHVVNJIHZlcnNpb24gbW9yZSByZWNlbnQgdGhhbgotMS44IGl0IGNvdWxkIGJlIHRoYXQgdGhlIGZpeGVzIGFyZSBhbHJlYWR5IGluY2x1ZGVkLCBjaGVjayBpdC4gCiBOZXh0LCBpbgogPGNvZGU+TW9yZUZpbGVzPC9jb2RlPiwgPGNvZGU+bGlianBlZzwvY29kZT4sIDxjb2RlPnBibXBsdXM8L2NvZGU+LAogPGNvZGU+emxpYjwvY29kZT4sIDxjb2RlPmxpYnBuZzwvY29kZT4sIDxjb2RlPmdkYm08L2NvZGU+LAotYW5kPGNvZGU+bGlidGlmZjwvY29kZT4geW91IGJ1aWxkIGFsbCBwcm9qZWN0cy4gU29tZXRpbWVzIHRoZSBwcm9qZWN0cyBhcmUgaW4gIm1hYyIKK2FuZDxjb2RlPmxpYnRpZmY8L2NvZGU+IHlvdSBidWlsZCBhbGwgcHJvamVjdHMuIFRoZSBwcm9qZWN0cyBhcmUgaW4gIm1hYyIKIHN1YmZvbGRlcnMsIHNvbWV0aW1lcyB0aGV5IGFyZSBpbiB0aGUgbWFpbiBmb2xkZXIuIFRjbC90ayBpcyBhIHNwZWNpYWwKIGNhc2UsIHNlZSBiZWxvdy4gT2YgY291cnNlLCBpZiB5b3UgYXJlIG9ubHkgaW50ZXJlc3RlZCBpbiBvbmUgb2YKIHN0YXRpYyA2OEssIENGTTY4SyBvciBQUEMgeW91IGNhbiBza2lwIGJ1aWxkaW5nIHRoZSBvdGhlciBsaWJyYXJpZXMuCiAKIDxIMj48QSBOQU1FPSJ0Y2x0ayI+QnVpbGRpbmcgVGNsL1RrPC9IMj4KIAotWW91IG5lZWQgdG8gbWFrZSBzb21lIG1pbm9yIGNoYW5nZXMgdG8gdGhlIFRjbC9UawotZGlzdHJpYnV0aW9uLiBUaGUgY3VycmVudCBpbnN0cnVjdGlvbnMgYXJlIGZvciB0aGUKLTxjb2RlPnRjbDcuNjwvY29kZT4gYW5kIDxjb2RlPnRrNC4yPC9jb2RlPiBkaXN0cmlidXRpb246Ci0KK1lvdSBuZWVkIHRvIG1ha2Ugc29tZSBtaW5vciBjaGFuZ2VzIHRvIHRoZSBUY2wvVGsgOC4wIGJldGEyCitkaXN0cmlidXRpb24uIFlvdSBzaG91bGQgbWFrZSB0aGUgQ1cgUHJvIHByb2plY3RzIFRjbExpYnJhcmllcy65IGFuZAorVGtMaWJyYXJpZXMuuSAoaW4gdGhlIG1hYyBzdWJmb2xkZXJzKS4KIDxVTD4KIAotPExJPiBZb3UgaGF2ZSB0byBjaGFuZ2UgdGhlIGFjY2VzcyBwYXRoIHNldHRpbmcgYW5kIHN1Y2ggdG8gdXNlIHRoZSBNU0wKLWxpYnJhcmllcyAodGhpcyB0Y2wvdGsgZGl0cmlidXRpb24gcHJlZGF0ZXMgTVNMKS4KKzxMST4gVGhlcmUgYXJlIG5vIGNmbTY4ayB0YXJnZXRzLiBZb3UgbWFrZSB0aGVzZSBieSBjb3B5aW5nIHRoZSA2OGsgdGFyZ2V0cywKK3NldHRpbmcgdGhlICI2OGsgdGFyZ2V0IiB0byAiY2ZtNjhrIGxpYnJhcnkiIGFuZCBjaGFuZ2luZyB0aGUgb3V0cHV0IGZpbGVuYW1lLAorYW5kIGNoYW5naW5nIHRoZSBwcmVmaXgKK2hlYWRlciBmaWxlbmFtZSBpbiB0aGUgQy9DKysgc2V0dGluZ3MgcGFuZWwgdG8gIk1XXz8/P0hlYWRlckNGTTY4SyIuCiAKLTxMST4gUmVuYW1lIHRoZSA8Y29kZT5jb21wYXQ8L2NvZGU+IGZvbGRlcnMgdG8gPGNvZGU+KGNvbXBhdCk8L2NvZGU+Ci1pbiBib3RoIHRoZSBUY2wgYW5kIFRrIGZvbGRlcnMuCi0KLTxMST4gSW4gdGhlIFRjbCBmb2xkZXIsIG1vdmUgPGNvZGU+c3RybmNhc2VjbXAuYzwvY29kZT4gYW5kCi08Y29kZT50Y2xFcnJuby5oPC9jb2RlPiBmcm9tIDxjb2RlPihjb21wYXQpPC9jb2RlPiB0byB0aGUgbWFpbiBUY2wKLWZvbGRlci4KLQotPExJPiBGaXggPGNvZGU+ZG5yLmM8L2NvZGU+IGFzIHByb3ZpZGVkIGJ5IE1ldHJvV2Vya3MgYnkgaW5zZXJ0aW5nCi08cHJlPjxjb2RlPiAjcHJhZ21hIEFOU0lfc3RyaWN0IG9mZiA8L2NvZGU+PC9wcmU+IGF0IHRoZQotYmVnaW5uaW5nLiBUaGUgdGNsIGxpYnJhcnkgaXMgYnVpbHQgd2l0aCBzdHJpY3QgQU5TSSBvbiwgYW5kIHRoaXMgZmlsZQotdXNlcyBDKysgc3R5bGUgY29tbWVudHMuCi0KLTxMST4gSWYgeW91IHdhbnQgdG8gYnVpbGQgPGNvZGU+U2ltcGxlVGNsPC9jb2RlPiBhbmQKLTxjb2RlPlNpbXBsZVRrPC9jb2RlPiB5b3UgbWF5ICBoYXZlIHRvIHJlbW92ZSB0aGUgcmVmZXJlbmNlcwotdG8gPGNvZGU+bGlibW90bzwvY29kZT4gZnJvbSB0aGUgcHJvamVjdCwgbm90IGV2ZXJ5b25lIGhhcyB0aGlzIGxpYnJhcnkuCi0KLTxMST4gSWYgeW91IHdhbnQgdG8gYnVpbGQgZm9yIENGTTY4SyB5b3UgaGF2ZSB0byBjcmVhdGUgdGhlIHByb2plY3RzCi1mb3IgdGhlIGxpYnJhcmllcyB5b3Vyc2VsZi4gVGFrZSB0aGUgNjhLIGxpYnJhcnkgcHJvamVjdHMsIHNldCB0aGUgQysrIGhlYWRlcgotZmlsZSB0byAiTVdfVGNsSGVhZGVyQ0ZNNjhLIiwgdGhlIHByb2plY3QgdHlwZSB0byAiY2ZtNjhLIGxpYnJhcnkiIGFuZCB0aGUKLWZpbGVuYW1lIHRvICJUY2wtQ0ZNNjhLLkxpYiIgKGFuZCBzaW1pbGFybHkgZm9yIFRrKS4KLVlvdSBtYXkgYWxzbyBoYXZlIHRvIG1vZGlmeSA8Y29kZT5UY2xNYWNOb3RpZnkuYzwvY29kZT4KLWJlY2F1c2UgdGhlcmUgaXMgYW4gZXJyb3IgaW4gdGhlIEFwcGxlIFVuaXZlcnNhbCBoZWFkZXJzIChzaWMhKS4gUmVhZCB0aGUKLWNvbW1lbnRzIGF0IHRoZSBiZWdpbm5pbmcgb2YgPGNvZGU+TWFjOlB5dGhvbjptYWNnbHVlLmM8L2NvZGU+IGFuZCBjb3B5IHRoZQotY29kZSB0byA8Y29kZT5UY2xNYWNOb3RpZnkuYzwvY29kZT4uIElmIHlvdSBnZXQgbGlua2VyIGVycm9ycyBvbiA8Y29kZT5HZXRFdlFIZHI8L2NvZGU+Ci15b3UgaGF2ZSBub3QgZG9uZSB0aGlzIGNvcnJlY3RseS4gPGVtPlhYWFggSXMgdGhpcyBzdGlsbCBuZWVkZWQ/PC9lbT4KKzxMST4gSSBoYWQgdG8gYWRkIFNlYXJjaC5jIChmcm9tIE1vcmVGaWxlcykgdG8gdGhlIHRjbCBsaWJyYXJ5IHByb2plY3RzLiBJIGRvbid0Cit1bmRlcnN0YW5kIHdoeSB0aGlzIGlzLCBidXQgaXQgc2VlbWVkIHRvIGN1cmUgdGhlIHByb2JsZW1zIEkgaGFkLgogCiA8TEk+IE5vdGUgdGhhdCBpZiB5b3UgdXNlIGEgZGlmZmVyZW50IHJlbGVhc2Ugb2YgVGNsIGFuZCBUayB0aGFuIHRoZSBvbmVzCiBJIGhhdmUgdXNlZCB5b3UgbWF5IGhhdmUgdG8gYWRhcHQgdGhlIFB5dGhvbiA8Y29kZT50a3Jlc291cmNlcy5yc3JjPC9jb2RlPiBmaWxlLgpAQCAtMjE1LDE5ICsxOTEsMTQgQEAKIGZvbGRlcnM6CiAKIDxETD4KLTxEVD4gYnVpbGQubWFjNjhrLnN0YW5kCi08REQ+IFRoaXMgaXMgd2hlcmUgeW91IGJ1aWxkIHN0YXRpYyA2OEsgaW50ZXJwcmV0ZXJzLgorPERUPiBidWlsZC5tYWMKKzxERD4gVGhpcyBpcyB3aGVyZSB5b3UgYnVpbGQgdGhlIFBQQywgQ0ZNNjhLIGFuZCBGYXQgc2hhcmVkIGxpYnJhcmllcywKK2ludGVycHJldGVyIGFuZCBhcHBsZXQgZnJhbWV3b3JrLiBUaGUgRmF0IHZlcnNpb25zLCB3aGljaCBhcmUgZGVyaXZlZAorZnJvbSB0aGUgb3RoZXIgdHdvLCBhcmUgZGVwb3NpdGVkIGluIHRoZSBwYXJlbnQgZm9sZGVyLgogCi08RFQ+IGJ1aWxkLm1hYzY4ay5zaGFyZWQKLTxERD4gVGhpcyBpcyB3aGVyZSB5b3UgYnVpbGQgdGhlIENGTTY4SyBzaGFyZWQgbGlicmFyeSwgaW50ZXJwcmV0ZXIKLWFuZCBhcHBsZXQgZnJhbWV3b3JrLgotCi08RFQ+IGJ1aWxkLm1hY3BwYy5zaGFyZWQKLTxERD4gVGhpcyBpcyB3aGVyZSB5b3UgYnVpbGQgdGhlIFBQQyBzaGFyZWQgbGlicmFyeSwgaW50ZXJwcmV0ZXIgYW5kCi1hcHBsZXQgZnJhbWV3b3JrLiBZb3UgY2FuIGFsc28gYnVpbGQgdGhlIGZhdCBhcHBsZXQgZnJhbWV3b3JrIGhlcmUuCi0KLTxEVD4gYnVpbGQubWFjcHBjLnN0YW5kCi08REQ+IFRoaXMgaXMgd2hlcmUgeW91IGJ1aWxkIGEgbm9uc2hhcmVkIFBQQyBpbnRlcnByZXRlciAob3B0aW9uYWwpLgorPERUPiBidWlsZC5tYWNzdGFuZAorPEREPiBUaGlzIGlzIHdoZXJlIHlvdSBidWlsZCBzdGF0aWMgNjhLIGludGVycHJldGVycywgYW5kIHBvc3NpYmx5IHN0YXRpYworUFBDIGludGVycHJldGVycyAoYnV0IHlvdSBwcm9iYWJseSB3b24ndCBuZWVkIHRob3NlKS4KIAogPERUPiBEZW1vCiA8REQ+IERlbW8gcHJvZ3JhbXMgdGhhdCBhcmUgbm90IE1hYy1zcGVjaWZpYy4gU29tZSBvZiB0aGVzZSBtYXkgbm90Cg==