188327 2018-08-03 19:10:28 -0700 innerHTML should not synchronously create a custom element 2018-08-07 00:56:30 -0700 1 1 1 Unclassified WebKit DOM WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=188284 InRadar P2 Normal --- 154907 183586 1 rniwa rniwa cdumez cmarcelo dbates esprehn+autocc ews-watchlist fred.wang gyuyoung.kim kangil.han koivisto sam webkit-bug-importer zalan oldest_to_newest 1447867 0 rniwa 2018-08-03 19:10:28 -0700 The fragment parsing algorithm is supposed to simply enqueue an element to upgrade, not synchronously construct it. 1447868 1 webkit-bug-importer 2018-08-03 19:10:48 -0700 <rdar://problem/42923114> 1447875 2 346578 rniwa 2018-08-03 19:40:31 -0700 Created attachment 346578 Fixes the bug 1447887 3 346578 dbates 2018-08-03 21:30:30 -0700 Comment on attachment 346578 Fixes the bug View in context: https://bugs.webkit.org/attachment.cgi?id=346578&action=review Looks sane to me. > Source/WebCore/ChangeLog:13 > + Namely, when the HTML parser creates an element for a token, *will execute script* will be set to false in > + the fragment parsing algorithm, and creates an element with synchronous custom elements flag *not* set: This sentence does not read well. In particular, the "and creates an element" does not read well. > Source/WebCore/ChangeLog:21 > + enqueued to upgrade is enqueued to upgarde for the second time. In this case, we need to put the element to the upgarde => upgrade "to the" => "into the" > Source/WebCore/ChangeLog:24 > + While the specification simply enqueues another upgarde reaction and bails out immediately in the first step of upgarde => upgrade > Source/WebCore/ChangeLog:46 > + was synchrnously constructing a custom element even for the fragment parsing algorithm. synchrnously => synchronously > Source/WebCore/dom/CustomElementReactionQueue.cpp:126 > + if (alreadyScheduledToUpgrade) { > + ASSERT(queue.m_items.size() == 1); > + ASSERT(queue.m_items[0].type() == CustomElementReactionQueueItem::Type::ElementUpgrade); > + } else > + queue.m_items.append({CustomElementReactionQueueItem::Type::ElementUpgrade}); I wish there was a better way we could design this code such that we wouldn't need to have alreadyScheduledToUpgrade. Putting this aside lets look at this code. Although the compiler is smart enough to optimize out the branch on alreadyScheduledToUpgrade in a release build the existence of alreadyScheduledToUpgrade is only meaningful in a debug build (for the assertion), its unnecessary to write out such a branch in source code. (Disregarding code style, I suspect another reason you wrote it this way was to avoid an unused argument compiler warning when building release). For your consideration, I suggest that we make use of the convenience macro ASSERT_UNUSED() and then simplify this code to read: ASSERT_UNUSED(alreadyScheduledToUpgrade, !alreadyScheduledToUpgrade || queue.m_items.size() == 1); ASSERT_UNUSED(alreadyScheduledToUpgrade, !alreadyScheduledToUpgrade || queue.m_items[0].type() == CustomElementReactionQueueItem::Type::ElementUpgrade); queue.m_items.append({ CustomElementReactionQueueItem::Type::ElementUpgrade }); (Notice that I also took stylistic liberty to put space characters after the '{' and before the '}' in the last line as it's an unwritten convention to put such spaces). On another note, is queue.m_items a public field? If so, it is an unwritten convention to omit the "m_" prefix from the name of public member fields. We do not need to fix this up in this patch. > Source/WebCore/html/parser/HTMLConstructionSite.cpp:681 > + element = HTMLElement::create(QualifiedName(nullAtom(), localName, xhtmlNamespaceURI), ownerDocument); Stylistic nit (code is fine as-is): There is a growing movement of using uniform initialization syntax for new code. > Source/WebCore/html/parser/HTMLConstructionSite.cpp:685 > + QualifiedName qualifiedName(nullAtom(), localName, xhtmlNamespaceURI); Stylistic nit (code is fine as-is): There is a growing movement of using uniform initialization syntax for new code. > LayoutTests/imported/w3c/web-platform-tests/custom-elements/connected-callbacks-html-fragment-parsing-expected.txt:9 > +PASS Inserting a custom element into the document using HTML fragment parsing must enqueue a custom element upgrade reaction, not synchronously invoke its constructor > +PASS Inserting a custom element into the document of the template elements using HTML fragment parsing must enqueue a custom element upgrade reaction, not synchronously invoke its constructor > +PASS Inserting a custom element into a new document using HTML fragment parsing must enqueue a custom element upgrade reaction, not synchronously invoke its constructor > +PASS Inserting a custom element into a cloned document using HTML fragment parsing must enqueue a custom element upgrade reaction, not synchronously invoke its constructor > +PASS Inserting a custom element into a document created by createHTMLDocument using HTML fragment parsing must enqueue a custom element upgrade reaction, not synchronously invoke its constructor > +PASS Inserting a custom element into an HTML document created by createDocument using HTML fragment parsing must enqueue a custom element upgrade reaction, not synchronously invoke its constructor > +PASS Inserting a custom element into the document of an iframe using HTML fragment parsing must enqueue a custom element upgrade reaction, not synchronously invoke its constructor > +PASS Inserting a custom element into an HTML document fetched by XHR using HTML fragment parsing must enqueue a custom element upgrade reaction, not synchronously invoke its constructor Yay! 1447896 4 rniwa 2018-08-03 23:31:44 -0700 Thanks for the review. (In reply to Daniel Bates from comment #3) > Comment on attachment 346578 [details] > Fixes the bug > > View in context: > https://bugs.webkit.org/attachment.cgi?id=346578&action=review > > Looks sane to me. > > > Source/WebCore/ChangeLog:13 > > + Namely, when the HTML parser creates an element for a token, *will execute script* will be set to false in > > + the fragment parsing algorithm, and creates an element with synchronous custom elements flag *not* set: > > This sentence does not read well. In particular, the "and creates an > element" does not read well. Okay, revised to say: The fragment parsing algorithm creates an element for a token with *will execute script* flag set to false: https://html.spec.whatwg.org/multipage/parsing.html#create-an-element-for-the-token which results in creating an element with synchronous custom elements flag *not* set: https://dom.spec.whatwg.org/#concept-create-element > > > Source/WebCore/ChangeLog:21 > > + enqueued to upgrade is enqueued to upgarde for the second time. In this case, we need to put the element to the > > upgarde => upgrade > > "to the" => "into the" Fixed. > > Source/WebCore/ChangeLog:24 > > + While the specification simply enqueues another upgarde reaction and bails out immediately in the first step of > > upgarde => upgrade Fixed. > > Source/WebCore/ChangeLog:46 > > + was synchrnously constructing a custom element even for the fragment parsing algorithm. > > synchrnously => synchronously Fixed. > > Source/WebCore/dom/CustomElementReactionQueue.cpp:126 > > + if (alreadyScheduledToUpgrade) { > > + ASSERT(queue.m_items.size() == 1); > > + ASSERT(queue.m_items[0].type() == CustomElementReactionQueueItem::Type::ElementUpgrade); > > + } else > > + queue.m_items.append({CustomElementReactionQueueItem::Type::ElementUpgrade}); > > I wish there was a better way we could design this code such that we > wouldn't need to have alreadyScheduledToUpgrade. Putting this aside lets > look at this code. Although the compiler is smart enough to optimize out the > branch on alreadyScheduledToUpgrade in a release build the existence of > alreadyScheduledToUpgrade is only meaningful in a debug build (for the > assertion), its unnecessary to write out such a branch in source code. No. The boolean flag is useful in release build as well because we need to avoid inserting a new reaction to queue.m_items.append but we still have to call ensureCurrentQueue. > (Disregarding code style, I suspect another reason you wrote it this way was > to avoid an unused argument compiler warning when building release). For > your consideration, I suggest that we make use of the convenience macro > ASSERT_UNUSED() and then simplify this code to read: > > ASSERT_UNUSED(alreadyScheduledToUpgrade, !alreadyScheduledToUpgrade || > queue.m_items.size() == 1); > ASSERT_UNUSED(alreadyScheduledToUpgrade, !alreadyScheduledToUpgrade || > queue.m_items[0].type() == > CustomElementReactionQueueItem::Type::ElementUpgrade); > queue.m_items.append({ CustomElementReactionQueueItem::Type::ElementUpgrade > }); > > (Notice that I also took stylistic liberty to put space characters after the > '{' and before the '}' in the last line as it's an unwritten convention to > put such spaces). Again, this code is wrong because it inserts a new item to queue.m_items. If we did that, then we'd have to modify JSCustomElementInterface::upgradeElement to exit early as the spec does, which incurs necessary heap allocation and a function call. > On another note, is queue.m_items a public field? If so, it is an unwritten > convention to omit the "m_" prefix from the name of public member fields. We > do not need to fix this up in this patch. It's not. m_items is a private member of CustomElementReactionQueue. > > Source/WebCore/html/parser/HTMLConstructionSite.cpp:681 > > + element = HTMLElement::create(QualifiedName(nullAtom(), localName, xhtmlNamespaceURI), ownerDocument); > > Stylistic nit (code is fine as-is): There is a growing movement of using > uniform initialization syntax for new code. > > > Source/WebCore/html/parser/HTMLConstructionSite.cpp:685 > > + QualifiedName qualifiedName(nullAtom(), localName, xhtmlNamespaceURI); > > Stylistic nit (code is fine as-is): There is a growing movement of using > uniform initialization syntax for new code. Fixed. 1447897 5 rniwa 2018-08-03 23:35:39 -0700 Committed r234577: <https://trac.webkit.org/changeset/234577> 1447913 6 346578 dbates 2018-08-04 06:36:08 -0700 Comment on attachment 346578 Fixes the bug View in context: https://bugs.webkit.org/attachment.cgi?id=346578&action=review >>> Source/WebCore/dom/CustomElementReactionQueue.cpp:126 >>> + queue.m_items.append({CustomElementReactionQueueItem::Type::ElementUpgrade}); >> >> I wish there was a better way we could design this code such that we wouldn't need to have alreadyScheduledToUpgrade. Putting this aside lets look at this code. Although the compiler is smart enough to optimize out the branch on alreadyScheduledToUpgrade in a release build the existence of alreadyScheduledToUpgrade is only meaningful in a debug build (for the assertion), its unnecessary to write out such a branch in source code. (Disregarding code style, I suspect another reason you wrote it this way was to avoid an unused argument compiler warning when building release). For your consideration, I suggest that we make use of the convenience macro ASSERT_UNUSED() and then simplify this code to read: >> >> ASSERT_UNUSED(alreadyScheduledToUpgrade, !alreadyScheduledToUpgrade || queue.m_items.size() == 1); >> ASSERT_UNUSED(alreadyScheduledToUpgrade, !alreadyScheduledToUpgrade || queue.m_items[0].type() == CustomElementReactionQueueItem::Type::ElementUpgrade); >> queue.m_items.append({ CustomElementReactionQueueItem::Type::ElementUpgrade }); >> >> (Notice that I also took stylistic liberty to put space characters after the '{' and before the '}' in the last line as it's an unwritten convention to put such spaces). >> >> On another note, is queue.m_items a public field? If so, it is an unwritten convention to omit the "m_" prefix from the name of public member fields. We do not need to fix this up in this patch. > > No. The boolean flag is useful in release build as well because we need to avoid inserting a new reaction to queue.m_items.append but we still have to call ensureCurrentQueue. You’re right! I’m blind. 346578 2018-08-03 19:40:31 -0700 2018-08-03 21:30:30 -0700 Fixes the bug bug-188327-20180803194031.patch text/plain 14087 rniwa SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDIzNDUzOCkKKysrIFNvdXJjZS9XZWJDb3JlL0NoYW5n ZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDUwIEBACisyMDE4LTA4LTAzICBSeW9zdWtl IE5pd2EgIDxybml3YUB3ZWJraXQub3JnPgorCisgICAgICAgIGlubmVySFRNTCBzaG91bGQgbm90 IHN5bmNocm9ub3VzbHkgY3JlYXRlIGEgY3VzdG9tIGVsZW1lbnQKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE4ODMyNworICAgICAgICA8cmRhcjovL3By b2JsZW0vNDI5MjMxMTQ+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisK KyAgICAgICAgRml4ZWQgdGhlIGJ1ZyB0aGF0IHRoZSBmcmFnbWVudCBwYXJzaW5nIGFsZ29yaXRo bSB3YXMgc3luY2hyb25vdXNseSBjb25zdHJ1Y3RpbmcgYSBjdXN0b20gZWxlbWVudCBpbnN0ZWFk IG9mCisgICAgICAgIGVucXVldWluZyBhbiBlbGVtZW50IHRvIHVwZ3JhZGUuCisKKyAgICAgICAg TmFtZWx5LCB3aGVuIHRoZSBIVE1MIHBhcnNlciBjcmVhdGVzIGFuIGVsZW1lbnQgZm9yIGEgdG9r ZW4sICp3aWxsIGV4ZWN1dGUgc2NyaXB0KiB3aWxsIGJlIHNldCB0byBmYWxzZSBpbgorICAgICAg ICB0aGUgZnJhZ21lbnQgcGFyc2luZyBhbGdvcml0aG0sIGFuZCBjcmVhdGVzIGFuIGVsZW1lbnQg d2l0aCBzeW5jaHJvbm91cyBjdXN0b20gZWxlbWVudHMgZmxhZyAqbm90KiBzZXQ6CisgICAgICAg IGh0dHBzOi8vaHRtbC5zcGVjLndoYXR3Zy5vcmcvbXVsdGlwYWdlL3BhcnNpbmcuaHRtbCNjcmVh dGUtYW4tZWxlbWVudC1mb3ItdGhlLXRva2VuCisgICAgICAgIGh0dHBzOi8vZG9tLnNwZWMud2hh dHdnLm9yZy8jY29uY2VwdC1jcmVhdGUtZWxlbWVudAorCisgICAgICAgIFdoZW4gc3luY2hyb25v dXMgY3VzdG9tIGVsZW1lbnRzIGZsYWcgaXMgZmFsc2UsIHdlJ3JlIHN1cHBvc2VkIHRvIGNyZWF0 ZSBhbiBlbGVtZW50IGFuZCBlbnF1ZXVlIGEgY3VzdG9tIGVsZW1lbnQKKyAgICAgICAgdXBncmFk ZSByZWFjdGlvbi4gY3JlYXRlSFRNTEVsZW1lbnRPckZpbmRDdXN0b21FbGVtZW50SW50ZXJmYWNl IHdhcyBtaXNzaW5nIHRoaXMgbGFzdCBsb2dpYy4gCisKKyAgICAgICAgQWxzbyBmaXhlZCBhIGJ1 ZyB0aGF0IEVsZW1lbnQ6OmVucXVldWVUb1VwZ3JhZGUgd291bGQgaGl0IGEgZGVidWcgYXNzZXJ0 aW9uIHdoZW4gYSBjdXN0b20gZWxlbWVudCB3aGljaCBoYXMgYmVlbgorICAgICAgICBlbnF1ZXVl ZCB0byB1cGdyYWRlIGlzIGVucXVldWVkIHRvIHVwZ2FyZGUgZm9yIHRoZSBzZWNvbmQgdGltZS4g SW4gdGhpcyBjYXNlLCB3ZSBuZWVkIHRvIHB1dCB0aGUgZWxlbWVudCB0byB0aGUKKyAgICAgICAg Y3VycmVudCBlbGVtZW50IHF1ZXVlIChodHRwczovL2h0bWwuc3BlYy53aGF0d2cub3JnL211bHRp cGFnZS9jdXN0b20tZWxlbWVudHMuaHRtbCNjdXJyZW50LWVsZW1lbnQtcXVldWUpIGFnYWluLgor CisgICAgICAgIFdoaWxlIHRoZSBzcGVjaWZpY2F0aW9uIHNpbXBseSBlbnF1ZXVlcyBhbm90aGVy IHVwZ2FyZGUgcmVhY3Rpb24gYW5kIGJhaWxzIG91dCBpbW1lZGlhdGVseSBpbiB0aGUgZmlyc3Qg c3RlcCBvZgorICAgICAgICB0aGUgdXBncmFkZSwgV2ViS2l0J3MgaW1wbGVtZW50YXRpb24gc2lt cGx5IGF2b2lkcyB0aGlzIHJlZHVuZGFuY3kgaW4gdGhlIGZpcnN0IHBsYWNlOgorICAgICAgICBo dHRwczovL2h0bWwuc3BlYy53aGF0d2cub3JnL211bHRpcGFnZS9jdXN0b20tZWxlbWVudHMuaHRt bCNjb25jZXB0LXVwZ3JhZGUtYW4tZWxlbWVudAorCisgICAgICAgIEV4aXN0aW5nIHRlc3RzIHN1 Y2ggYXMgaW1wb3J0ZWQvdzNjL3dlYi1wbGF0Zm9ybS10ZXN0cy9jdXN0b20tZWxlbWVudHMvcmVh Y3Rpb25zL0RvY3VtZW50Lmh0bWwgZXhlcmNpc2VzIHRoaXMKKyAgICAgICAgY29kZSBwYXRoIGFm dGVyIHRoZSBmcmFnbWVudCBwYXJzaW5nIGFsZ29yaXRobSBmaXguCisKKyAgICAgICAgVGVzdHM6 IGltcG9ydGVkL3czYy93ZWItcGxhdGZvcm0tdGVzdHMvY3VzdG9tLWVsZW1lbnRzL2Nvbm5lY3Rl ZC1jYWxsYmFja3MtaHRtbC1mcmFnbWVudC1wYXJzaW5nLmh0bWwKKworICAgICAgICAqIGRvbS9D dXN0b21FbGVtZW50UmVhY3Rpb25RdWV1ZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpDdXN0b21F bGVtZW50UmVhY3Rpb25RdWV1ZUl0ZW06OnR5cGUgY29uc3QpOiBBZGRlZCBmb3IgYW4gYXNzZXJ0 aW9uLgorICAgICAgICAoV2ViQ29yZTo6Q3VzdG9tRWxlbWVudFJlYWN0aW9uUXVldWU6OmVucXVl dWVFbGVtZW50VXBncmFkZSk6IEVucXVldWUgdGhpcyBlbGVtZW50IHRvIHRoZSBjdXJyZW50IGVs ZW1lbnQgcXVldWUKKyAgICAgICAgYnkgY2FsbGluZyBlbnN1cmVDdXJyZW50UXVldWUgYW5kIGF2 b2lkIGluc2VydGluZyBhIHJlZHVuZGFudCB1cGdyYWRlIHJlYWN0aW9uLgorICAgICAgICAqIGRv bS9DdXN0b21FbGVtZW50UmVhY3Rpb25RdWV1ZS5oOgorICAgICAgICAqIGRvbS9FbGVtZW50LmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OkVsZW1lbnQ6OmVucXVldWVUb1VwZ3JhZGUpOiBIYW5kbGUg dGhlIGNhc2Ugd2hlbiBhIGN1c3RvbSBlbGVtZW50IGlzIGVucXVldWVkIHRvIHVwZ3JhZGUgZm9y IHRoZSBzZWNvbmQKKyAgICAgICAgdGltZSB3aGlsZSBpdCBoYWQgYmVlbiB3YWl0aW5nIGluIHNv bWUgZWxlbWVudCBxdWV1ZS4gSW4gdGhpcyBjYXNlLCB0aGUgcmVhY3Rpb24gcXVldWUgZm9yIHRo aXMgZWxlbWVudCBoYXMKKyAgICAgICAgYWxyZWFkeSBiZWVuIGNyZWF0ZWQgYW5kIHdlIHNpbXBs eSBuZWVkIHRvIHB1dCB0aGlzIGVsZW1lbnQgYmFjayBpbnRvIHRoZSBjdXJyZW50IGVsZW1lbnQg cXVldWUgKGkuZS4gdGhpcyBlbGVtZW50CisgICAgICAgIG5vdyBiZWxvbmdzIHRvIGJvdGggZWxl bWVudCBxdWV1ZXMpLgorICAgICAgICAqIGh0bWwvcGFyc2VyL0hUTUxDb25zdHJ1Y3Rpb25TaXRl LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OmZpbmRDdXN0b21FbGVtZW50SW50ZXJmYWNlKTogRXh0 cmFjdGVkIG91dCBvZiBjcmVhdGVIVE1MRWxlbWVudE9yRmluZEN1c3RvbUVsZW1lbnRJbnRlcmZh Y2UuCisgICAgICAgIChXZWJDb3JlOjpIVE1MQ29uc3RydWN0aW9uU2l0ZTo6Y3JlYXRlSFRNTEVs ZW1lbnRPckZpbmRDdXN0b21FbGVtZW50SW50ZXJmYWNlKTogRml4ZWQgdGhlIGJ1ZyB0aGF0IHRo ZSBIVE1MIHBhcnNlcgorICAgICAgICB3YXMgc3luY2hybm91c2x5IGNvbnN0cnVjdGluZyBhIGN1 c3RvbSBlbGVtZW50IGV2ZW4gZm9yIHRoZSBmcmFnbWVudCBwYXJzaW5nIGFsZ29yaXRobS4KKwog MjAxOC0wOC0wMiAgWmFsYW4gQnVqdGFzICA8emFsYW5AYXBwbGUuY29tPgogCiAgICAgICAgIFtM RkNdW0JGQ10gQXBwbHkgdGhlICIxMC42LjYgQ29tcGxpY2F0ZWQgY2FzZXMiIHdoZW4gY29tcHV0 aW5nIGhlaWdodCBhbmQgbWFyZ2luIGZvciB0aGUgZG9jdW1lbnQgcmVuZGVyZXIKSW5kZXg6IFNv dXJjZS9XZWJDb3JlL2RvbS9DdXN0b21FbGVtZW50UmVhY3Rpb25RdWV1ZS5jcHAKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gU291cmNlL1dlYkNvcmUvZG9tL0N1c3RvbUVsZW1lbnRSZWFjdGlvblF1ZXVlLmNwcAko cmV2aXNpb24gMjM0NTM4KQorKysgU291cmNlL1dlYkNvcmUvZG9tL0N1c3RvbUVsZW1lbnRSZWFj dGlvblF1ZXVlLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNjksNiArNjksOCBAQCBwdWJsaWM6CiAg ICAgICAgICwgbV9uZXdWYWx1ZShuZXdWYWx1ZSkKICAgICB7IH0KIAorICAgIFR5cGUgdHlwZSgp IGNvbnN0IHsgcmV0dXJuIG1fdHlwZTsgfQorCiAgICAgdm9pZCBpbnZva2UoRWxlbWVudCYgZWxl bWVudCwgSlNDdXN0b21FbGVtZW50SW50ZXJmYWNlJiBlbGVtZW50SW50ZXJmYWNlKQogICAgIHsK ICAgICAgICAgc3dpdGNoIChtX3R5cGUpIHsKQEAgLTExNCwxMCArMTE2LDE0IEBAIHZvaWQgQ3Vz dG9tRWxlbWVudFJlYWN0aW9uUXVldWU6OmNsZWFyKCkKICAgICBtX2l0ZW1zLmNsZWFyKCk7CiB9 CiAKLXZvaWQgQ3VzdG9tRWxlbWVudFJlYWN0aW9uUXVldWU6OmVucXVldWVFbGVtZW50VXBncmFk ZShFbGVtZW50JiBlbGVtZW50KQordm9pZCBDdXN0b21FbGVtZW50UmVhY3Rpb25RdWV1ZTo6ZW5x dWV1ZUVsZW1lbnRVcGdyYWRlKEVsZW1lbnQmIGVsZW1lbnQsIGJvb2wgYWxyZWFkeVNjaGVkdWxl ZFRvVXBncmFkZSkKIHsKICAgICBhdXRvJiBxdWV1ZSA9IGVuc3VyZUN1cnJlbnRRdWV1ZShlbGVt ZW50KTsKLSAgICBxdWV1ZS5tX2l0ZW1zLmFwcGVuZCh7Q3VzdG9tRWxlbWVudFJlYWN0aW9uUXVl dWVJdGVtOjpUeXBlOjpFbGVtZW50VXBncmFkZX0pOworICAgIGlmIChhbHJlYWR5U2NoZWR1bGVk VG9VcGdyYWRlKSB7CisgICAgICAgIEFTU0VSVChxdWV1ZS5tX2l0ZW1zLnNpemUoKSA9PSAxKTsK KyAgICAgICAgQVNTRVJUKHF1ZXVlLm1faXRlbXNbMF0udHlwZSgpID09IEN1c3RvbUVsZW1lbnRS ZWFjdGlvblF1ZXVlSXRlbTo6VHlwZTo6RWxlbWVudFVwZ3JhZGUpOworICAgIH0gZWxzZQorICAg ICAgICBxdWV1ZS5tX2l0ZW1zLmFwcGVuZCh7Q3VzdG9tRWxlbWVudFJlYWN0aW9uUXVldWVJdGVt OjpUeXBlOjpFbGVtZW50VXBncmFkZX0pOwogfQogCiB2b2lkIEN1c3RvbUVsZW1lbnRSZWFjdGlv blF1ZXVlOjplbnF1ZXVlRWxlbWVudFVwZ3JhZGVJZkRlZmluZWQoRWxlbWVudCYgZWxlbWVudCkK SW5kZXg6IFNvdXJjZS9XZWJDb3JlL2RvbS9DdXN0b21FbGVtZW50UmVhY3Rpb25RdWV1ZS5oCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2RvbS9DdXN0b21FbGVtZW50UmVhY3Rpb25RdWV1 ZS5oCShyZXZpc2lvbiAyMzQ1MzgpCisrKyBTb3VyY2UvV2ViQ29yZS9kb20vQ3VzdG9tRWxlbWVu dFJlYWN0aW9uUXVldWUuaAkod29ya2luZyBjb3B5KQpAQCAtNDMsNyArNDMsNyBAQCBwdWJsaWM6 CiAgICAgQ3VzdG9tRWxlbWVudFJlYWN0aW9uUXVldWUoSlNDdXN0b21FbGVtZW50SW50ZXJmYWNl Jik7CiAgICAgfkN1c3RvbUVsZW1lbnRSZWFjdGlvblF1ZXVlKCk7CiAKLSAgICBzdGF0aWMgdm9p ZCBlbnF1ZXVlRWxlbWVudFVwZ3JhZGUoRWxlbWVudCYpOworICAgIHN0YXRpYyB2b2lkIGVucXVl dWVFbGVtZW50VXBncmFkZShFbGVtZW50JiwgYm9vbCBhbHJlYWR5U2NoZWR1bGVkVG9VcGdyYWRl KTsKICAgICBzdGF0aWMgdm9pZCBlbnF1ZXVlRWxlbWVudFVwZ3JhZGVJZkRlZmluZWQoRWxlbWVu dCYpOwogICAgIHN0YXRpYyB2b2lkIGVucXVldWVDb25uZWN0ZWRDYWxsYmFja0lmTmVlZGVkKEVs ZW1lbnQmKTsKICAgICBzdGF0aWMgdm9pZCBlbnF1ZXVlRGlzY29ubmVjdGVkQ2FsbGJhY2tJZk5l ZWRlZChFbGVtZW50Jik7CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9kb20vRWxlbWVudC5jcHAKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvZG9tL0VsZW1lbnQuY3BwCShyZXZpc2lvbiAyMzQ1 MzgpCisrKyBTb3VyY2UvV2ViQ29yZS9kb20vRWxlbWVudC5jcHAJKHdvcmtpbmcgY29weSkKQEAg LTIwMDksMTAgKzIwMDksMTAgQEAgdm9pZCBFbGVtZW50OjplbnF1ZXVlVG9VcGdyYWRlKEpTQ3Vz dG9tRQogICAgIEluc3BlY3Rvckluc3RydW1lbnRhdGlvbjo6ZGlkQ2hhbmdlQ3VzdG9tRWxlbWVu dFN0YXRlKCp0aGlzKTsKIAogICAgIGF1dG8mIGRhdGEgPSBlbnN1cmVFbGVtZW50UmFyZURhdGEo KTsKLSAgICBBU1NFUlQoIWRhdGEuY3VzdG9tRWxlbWVudFJlYWN0aW9uUXVldWUoKSk7Ci0KLSAg ICBkYXRhLnNldEN1c3RvbUVsZW1lbnRSZWFjdGlvblF1ZXVlKHN0ZDo6bWFrZV91bmlxdWU8Q3Vz dG9tRWxlbWVudFJlYWN0aW9uUXVldWU+KGVsZW1lbnRJbnRlcmZhY2UpKTsKLSAgICBkYXRhLmN1 c3RvbUVsZW1lbnRSZWFjdGlvblF1ZXVlKCktPmVucXVldWVFbGVtZW50VXBncmFkZSgqdGhpcyk7 CisgICAgYm9vbCBhbHJlYWR5U2NoZWR1bGVkVG9VcGdyYWRlID0gZGF0YS5jdXN0b21FbGVtZW50 UmVhY3Rpb25RdWV1ZSgpOworICAgIGlmICghYWxyZWFkeVNjaGVkdWxlZFRvVXBncmFkZSkKKyAg ICAgICAgZGF0YS5zZXRDdXN0b21FbGVtZW50UmVhY3Rpb25RdWV1ZShzdGQ6Om1ha2VfdW5pcXVl PEN1c3RvbUVsZW1lbnRSZWFjdGlvblF1ZXVlPihlbGVtZW50SW50ZXJmYWNlKSk7CisgICAgZGF0 YS5jdXN0b21FbGVtZW50UmVhY3Rpb25RdWV1ZSgpLT5lbnF1ZXVlRWxlbWVudFVwZ3JhZGUoKnRo aXMsIGFscmVhZHlTY2hlZHVsZWRUb1VwZ3JhZGUpOwogfQogCiBDdXN0b21FbGVtZW50UmVhY3Rp b25RdWV1ZSogRWxlbWVudDo6cmVhY3Rpb25RdWV1ZSgpIGNvbnN0CkluZGV4OiBTb3VyY2UvV2Vi Q29yZS9odG1sL3BhcnNlci9IVE1MQ29uc3RydWN0aW9uU2l0ZS5jcHAKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g U291cmNlL1dlYkNvcmUvaHRtbC9wYXJzZXIvSFRNTENvbnN0cnVjdGlvblNpdGUuY3BwCShyZXZp c2lvbiAyMzQ1MzgpCisrKyBTb3VyY2UvV2ViQ29yZS9odG1sL3BhcnNlci9IVE1MQ29uc3RydWN0 aW9uU2l0ZS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTY0OSw2ICs2NDksMTkgQEAgaW5saW5lIERv Y3VtZW50JiBIVE1MQ29uc3RydWN0aW9uU2l0ZTo6bwogICAgIHJldHVybiBjdXJyZW50Tm9kZSgp LmRvY3VtZW50KCk7CiB9CiAKK3N0YXRpYyBpbmxpbmUgSlNDdXN0b21FbGVtZW50SW50ZXJmYWNl KiBmaW5kQ3VzdG9tRWxlbWVudEludGVyZmFjZShEb2N1bWVudCYgb3duZXJEb2N1bWVudCwgY29u c3QgQXRvbWljU3RyaW5nJiBsb2NhbE5hbWUpCit7CisgICAgYXV0byogd2luZG93ID0gb3duZXJE b2N1bWVudC5kb21XaW5kb3coKTsKKyAgICBpZiAoIXdpbmRvdykKKyAgICAgICAgcmV0dXJuIG51 bGxwdHI7CisKKyAgICBhdXRvKiByZWdpc3RyeSA9IHdpbmRvdy0+Y3VzdG9tRWxlbWVudFJlZ2lz dHJ5KCk7CisgICAgaWYgKExJS0VMWSghcmVnaXN0cnkpKQorICAgICAgICByZXR1cm4gbnVsbHB0 cjsKKworICAgIHJldHVybiByZWdpc3RyeS0+ZmluZEludGVyZmFjZShsb2NhbE5hbWUpOworfQor CiBSZWZQdHI8RWxlbWVudD4gSFRNTENvbnN0cnVjdGlvblNpdGU6OmNyZWF0ZUhUTUxFbGVtZW50 T3JGaW5kQ3VzdG9tRWxlbWVudEludGVyZmFjZShBdG9taWNIVE1MVG9rZW4mIHRva2VuLCBKU0N1 c3RvbUVsZW1lbnRJbnRlcmZhY2UqKiBjdXN0b21FbGVtZW50SW50ZXJmYWNlKQogewogICAgIGF1 dG8mIGxvY2FsTmFtZSA9IHRva2VuLm5hbWUoKTsKQEAgLTY2MCwyMyArNjczLDIyIEBAIFJlZlB0 cjxFbGVtZW50PiBIVE1MQ29uc3RydWN0aW9uU2l0ZTo6Y3IKICAgICBib29sIGluc2lkZVRlbXBs YXRlRWxlbWVudCA9ICFvd25lckRvY3VtZW50LmZyYW1lKCk7CiAgICAgUmVmUHRyPEVsZW1lbnQ+ IGVsZW1lbnQgPSBIVE1MRWxlbWVudEZhY3Rvcnk6OmNyZWF0ZUtub3duRWxlbWVudChsb2NhbE5h bWUsIG93bmVyRG9jdW1lbnQsIGluc2lkZVRlbXBsYXRlRWxlbWVudCA/IG51bGxwdHIgOiBmb3Jt KCksIHRydWUpOwogICAgIGlmIChVTkxJS0VMWSghZWxlbWVudCkpIHsKLSAgICAgICAgYXV0byB3 aW5kb3cgPSBtYWtlUmVmUHRyKG93bmVyRG9jdW1lbnQuZG9tV2luZG93KCkpOwotICAgICAgICBp ZiAoY3VzdG9tRWxlbWVudEludGVyZmFjZSAmJiB3aW5kb3cpIHsKLSAgICAgICAgICAgIGF1dG8g cmVnaXN0cnkgPSBtYWtlUmVmUHRyKHdpbmRvdy0+Y3VzdG9tRWxlbWVudFJlZ2lzdHJ5KCkpOwot ICAgICAgICAgICAgaWYgKFVOTElLRUxZKHJlZ2lzdHJ5KSkgewotICAgICAgICAgICAgICAgIGlm IChhdXRvIGVsZW1lbnRJbnRlcmZhY2UgPSBtYWtlUmVmUHRyKHJlZ2lzdHJ5LT5maW5kSW50ZXJm YWNlKGxvY2FsTmFtZSkpKSB7Ci0gICAgICAgICAgICAgICAgICAgICpjdXN0b21FbGVtZW50SW50 ZXJmYWNlID0gZWxlbWVudEludGVyZmFjZS5nZXQoKTsKLSAgICAgICAgICAgICAgICAgICAgcmV0 dXJuIG51bGxwdHI7Ci0gICAgICAgICAgICAgICAgfQorICAgICAgICBpZiAoYXV0byogZWxlbWVu dEludGVyZmFjZSA9IGZpbmRDdXN0b21FbGVtZW50SW50ZXJmYWNlKG93bmVyRG9jdW1lbnQsIGxv Y2FsTmFtZSkpIHsKKyAgICAgICAgICAgIGlmICghbV9pc1BhcnNpbmdGcmFnbWVudCkgeworICAg ICAgICAgICAgICAgICpjdXN0b21FbGVtZW50SW50ZXJmYWNlID0gZWxlbWVudEludGVyZmFjZTsK KyAgICAgICAgICAgICAgICByZXR1cm4gbnVsbHB0cjsKICAgICAgICAgICAgIH0KLSAgICAgICAg fQotCi0gICAgICAgIFF1YWxpZmllZE5hbWUgcXVhbGlmaWVkTmFtZShudWxsQXRvbSgpLCBsb2Nh bE5hbWUsIHhodG1sTmFtZXNwYWNlVVJJKTsKLSAgICAgICAgaWYgKERvY3VtZW50Ojp2YWxpZGF0 ZUN1c3RvbUVsZW1lbnROYW1lKGxvY2FsTmFtZSkgPT0gQ3VzdG9tRWxlbWVudE5hbWVWYWxpZGF0 aW9uU3RhdHVzOjpWYWxpZCkgewotICAgICAgICAgICAgZWxlbWVudCA9IEhUTUxFbGVtZW50Ojpj cmVhdGUocXVhbGlmaWVkTmFtZSwgb3duZXJEb2N1bWVudCk7CisgICAgICAgICAgICBlbGVtZW50 ID0gSFRNTEVsZW1lbnQ6OmNyZWF0ZShRdWFsaWZpZWROYW1lKG51bGxBdG9tKCksIGxvY2FsTmFt ZSwgeGh0bWxOYW1lc3BhY2VVUkkpLCBvd25lckRvY3VtZW50KTsKICAgICAgICAgICAgIGVsZW1l bnQtPnNldElzQ3VzdG9tRWxlbWVudFVwZ3JhZGVDYW5kaWRhdGUoKTsKLSAgICAgICAgfSBlbHNl Ci0gICAgICAgICAgICBlbGVtZW50ID0gSFRNTFVua25vd25FbGVtZW50OjpjcmVhdGUocXVhbGlm aWVkTmFtZSwgb3duZXJEb2N1bWVudCk7CisgICAgICAgICAgICBlbGVtZW50LT5lbnF1ZXVlVG9V cGdyYWRlKCplbGVtZW50SW50ZXJmYWNlKTsKKyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAg IFF1YWxpZmllZE5hbWUgcXVhbGlmaWVkTmFtZShudWxsQXRvbSgpLCBsb2NhbE5hbWUsIHhodG1s TmFtZXNwYWNlVVJJKTsKKyAgICAgICAgICAgIGlmIChEb2N1bWVudDo6dmFsaWRhdGVDdXN0b21F bGVtZW50TmFtZShsb2NhbE5hbWUpID09IEN1c3RvbUVsZW1lbnROYW1lVmFsaWRhdGlvblN0YXR1 czo6VmFsaWQpIHsKKyAgICAgICAgICAgICAgICBlbGVtZW50ID0gSFRNTEVsZW1lbnQ6OmNyZWF0 ZShxdWFsaWZpZWROYW1lLCBvd25lckRvY3VtZW50KTsKKyAgICAgICAgICAgICAgICBlbGVtZW50 LT5zZXRJc0N1c3RvbUVsZW1lbnRVcGdyYWRlQ2FuZGlkYXRlKCk7CisgICAgICAgICAgICB9IGVs c2UKKyAgICAgICAgICAgICAgICBlbGVtZW50ID0gSFRNTFVua25vd25FbGVtZW50OjpjcmVhdGUo cXVhbGlmaWVkTmFtZSwgb3duZXJEb2N1bWVudCk7CisgICAgICAgIH0KICAgICB9CiAgICAgQVNT RVJUKGVsZW1lbnQpOwogCkluZGV4OiBMYXlvdXRUZXN0cy9pbXBvcnRlZC93M2MvQ2hhbmdlTG9n Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2ltcG9ydGVkL3czYy9DaGFuZ2VMb2cJKHJldmlz aW9uIDIzNDU3NSkKKysrIExheW91dFRlc3RzL2ltcG9ydGVkL3czYy9DaGFuZ2VMb2cJKHdvcmtp bmcgY29weSkKQEAgLTEsMyArMSwxNSBAQAorMjAxOC0wOC0wMyAgUnlvc3VrZSBOaXdhICA8cm5p d2FAd2Via2l0Lm9yZz4KKworICAgICAgICBpbm5lckhUTUwgc2hvdWxkIG5vdCBzeW5jaHJvbm91 c2x5IGNyZWF0ZSBhIGN1c3RvbSBlbGVtZW50CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xODgzMjcKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzQyOTIz MTE0PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFJl YmFzZWxpbmVkIHRoZSB0ZXN0IG5vdyB0aGF0IGFsbCB0ZXN0IGNhc2VzIGFyZSBwYXNzaW5nLgor CisgICAgICAgICogd2ViLXBsYXRmb3JtLXRlc3RzL2N1c3RvbS1lbGVtZW50cy9jb25uZWN0ZWQt Y2FsbGJhY2tzLWh0bWwtZnJhZ21lbnQtcGFyc2luZy1leHBlY3RlZC50eHQ6CisKIDIwMTgtMDgt MDIgIFJ5b3N1a2UgTml3YSAgPHJuaXdhQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmVsZWFzZSBh c3NlcnQgd2hlbiB0aHJvd2luZyBleGNlcHRpb25zIGluIGN1c3RvbSBlbGVtZW50IHJlYWN0aW9u cwpJbmRleDogTGF5b3V0VGVzdHMvaW1wb3J0ZWQvdzNjL3dlYi1wbGF0Zm9ybS10ZXN0cy9jdXN0 b20tZWxlbWVudHMvY29ubmVjdGVkLWNhbGxiYWNrcy1odG1sLWZyYWdtZW50LXBhcnNpbmctZXhw ZWN0ZWQudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2ltcG9ydGVkL3czYy93ZWItcGxh dGZvcm0tdGVzdHMvY3VzdG9tLWVsZW1lbnRzL2Nvbm5lY3RlZC1jYWxsYmFja3MtaHRtbC1mcmFn bWVudC1wYXJzaW5nLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMjM0NTM4KQorKysgTGF5b3V0VGVz dHMvaW1wb3J0ZWQvdzNjL3dlYi1wbGF0Zm9ybS10ZXN0cy9jdXN0b20tZWxlbWVudHMvY29ubmVj dGVkLWNhbGxiYWNrcy1odG1sLWZyYWdtZW50LXBhcnNpbmctZXhwZWN0ZWQudHh0CSh3b3JraW5n IGNvcHkpCkBAIC0xLDEwICsxLDEwIEBACiAKLUZBSUwgSW5zZXJ0aW5nIGEgY3VzdG9tIGVsZW1l bnQgaW50byB0aGUgZG9jdW1lbnQgdXNpbmcgSFRNTCBmcmFnbWVudCBwYXJzaW5nIG11c3QgZW5x dWV1ZSBhIGN1c3RvbSBlbGVtZW50IHVwZ3JhZGUgcmVhY3Rpb24sIG5vdCBzeW5jaHJvbm91c2x5 IGludm9rZSBpdHMgY29uc3RydWN0b3IgYXNzZXJ0X2VxdWFsczogZXhwZWN0ZWQgMSBidXQgZ290 IDIKLUZBSUwgSW5zZXJ0aW5nIGEgY3VzdG9tIGVsZW1lbnQgaW50byB0aGUgZG9jdW1lbnQgb2Yg dGhlIHRlbXBsYXRlIGVsZW1lbnRzIHVzaW5nIEhUTUwgZnJhZ21lbnQgcGFyc2luZyBtdXN0IGVu cXVldWUgYSBjdXN0b20gZWxlbWVudCB1cGdyYWRlIHJlYWN0aW9uLCBub3Qgc3luY2hyb25vdXNs eSBpbnZva2UgaXRzIGNvbnN0cnVjdG9yIGFzc2VydF9lcXVhbHM6IGV4cGVjdGVkIDEgYnV0IGdv dCAyCi1GQUlMIEluc2VydGluZyBhIGN1c3RvbSBlbGVtZW50IGludG8gYSBuZXcgZG9jdW1lbnQg dXNpbmcgSFRNTCBmcmFnbWVudCBwYXJzaW5nIG11c3QgZW5xdWV1ZSBhIGN1c3RvbSBlbGVtZW50 IHVwZ3JhZGUgcmVhY3Rpb24sIG5vdCBzeW5jaHJvbm91c2x5IGludm9rZSBpdHMgY29uc3RydWN0 b3IgYXNzZXJ0X2VxdWFsczogZXhwZWN0ZWQgMSBidXQgZ290IDIKLUZBSUwgSW5zZXJ0aW5nIGEg Y3VzdG9tIGVsZW1lbnQgaW50byBhIGNsb25lZCBkb2N1bWVudCB1c2luZyBIVE1MIGZyYWdtZW50 IHBhcnNpbmcgbXVzdCBlbnF1ZXVlIGEgY3VzdG9tIGVsZW1lbnQgdXBncmFkZSByZWFjdGlvbiwg bm90IHN5bmNocm9ub3VzbHkgaW52b2tlIGl0cyBjb25zdHJ1Y3RvciBhc3NlcnRfZXF1YWxzOiBl eHBlY3RlZCAxIGJ1dCBnb3QgMgotRkFJTCBJbnNlcnRpbmcgYSBjdXN0b20gZWxlbWVudCBpbnRv IGEgZG9jdW1lbnQgY3JlYXRlZCBieSBjcmVhdGVIVE1MRG9jdW1lbnQgdXNpbmcgSFRNTCBmcmFn bWVudCBwYXJzaW5nIG11c3QgZW5xdWV1ZSBhIGN1c3RvbSBlbGVtZW50IHVwZ3JhZGUgcmVhY3Rp b24sIG5vdCBzeW5jaHJvbm91c2x5IGludm9rZSBpdHMgY29uc3RydWN0b3IgYXNzZXJ0X2VxdWFs czogZXhwZWN0ZWQgMSBidXQgZ290IDIKLUZBSUwgSW5zZXJ0aW5nIGEgY3VzdG9tIGVsZW1lbnQg aW50byBhbiBIVE1MIGRvY3VtZW50IGNyZWF0ZWQgYnkgY3JlYXRlRG9jdW1lbnQgdXNpbmcgSFRN TCBmcmFnbWVudCBwYXJzaW5nIG11c3QgZW5xdWV1ZSBhIGN1c3RvbSBlbGVtZW50IHVwZ3JhZGUg cmVhY3Rpb24sIG5vdCBzeW5jaHJvbm91c2x5IGludm9rZSBpdHMgY29uc3RydWN0b3IgYXNzZXJ0 X2VxdWFsczogZXhwZWN0ZWQgMSBidXQgZ290IDIKLUZBSUwgSW5zZXJ0aW5nIGEgY3VzdG9tIGVs ZW1lbnQgaW50byB0aGUgZG9jdW1lbnQgb2YgYW4gaWZyYW1lIHVzaW5nIEhUTUwgZnJhZ21lbnQg cGFyc2luZyBtdXN0IGVucXVldWUgYSBjdXN0b20gZWxlbWVudCB1cGdyYWRlIHJlYWN0aW9uLCBu b3Qgc3luY2hyb25vdXNseSBpbnZva2UgaXRzIGNvbnN0cnVjdG9yIGFzc2VydF9lcXVhbHM6IGV4 cGVjdGVkIDEgYnV0IGdvdCAyCi1GQUlMIEluc2VydGluZyBhIGN1c3RvbSBlbGVtZW50IGludG8g YW4gSFRNTCBkb2N1bWVudCBmZXRjaGVkIGJ5IFhIUiB1c2luZyBIVE1MIGZyYWdtZW50IHBhcnNp bmcgbXVzdCBlbnF1ZXVlIGEgY3VzdG9tIGVsZW1lbnQgdXBncmFkZSByZWFjdGlvbiwgbm90IHN5 bmNocm9ub3VzbHkgaW52b2tlIGl0cyBjb25zdHJ1Y3RvciBhc3NlcnRfZXF1YWxzOiBleHBlY3Rl ZCAxIGJ1dCBnb3QgMgorUEFTUyBJbnNlcnRpbmcgYSBjdXN0b20gZWxlbWVudCBpbnRvIHRoZSBk b2N1bWVudCB1c2luZyBIVE1MIGZyYWdtZW50IHBhcnNpbmcgbXVzdCBlbnF1ZXVlIGEgY3VzdG9t IGVsZW1lbnQgdXBncmFkZSByZWFjdGlvbiwgbm90IHN5bmNocm9ub3VzbHkgaW52b2tlIGl0cyBj b25zdHJ1Y3RvciAKK1BBU1MgSW5zZXJ0aW5nIGEgY3VzdG9tIGVsZW1lbnQgaW50byB0aGUgZG9j dW1lbnQgb2YgdGhlIHRlbXBsYXRlIGVsZW1lbnRzIHVzaW5nIEhUTUwgZnJhZ21lbnQgcGFyc2lu ZyBtdXN0IGVucXVldWUgYSBjdXN0b20gZWxlbWVudCB1cGdyYWRlIHJlYWN0aW9uLCBub3Qgc3lu Y2hyb25vdXNseSBpbnZva2UgaXRzIGNvbnN0cnVjdG9yIAorUEFTUyBJbnNlcnRpbmcgYSBjdXN0 b20gZWxlbWVudCBpbnRvIGEgbmV3IGRvY3VtZW50IHVzaW5nIEhUTUwgZnJhZ21lbnQgcGFyc2lu ZyBtdXN0IGVucXVldWUgYSBjdXN0b20gZWxlbWVudCB1cGdyYWRlIHJlYWN0aW9uLCBub3Qgc3lu Y2hyb25vdXNseSBpbnZva2UgaXRzIGNvbnN0cnVjdG9yIAorUEFTUyBJbnNlcnRpbmcgYSBjdXN0 b20gZWxlbWVudCBpbnRvIGEgY2xvbmVkIGRvY3VtZW50IHVzaW5nIEhUTUwgZnJhZ21lbnQgcGFy c2luZyBtdXN0IGVucXVldWUgYSBjdXN0b20gZWxlbWVudCB1cGdyYWRlIHJlYWN0aW9uLCBub3Qg c3luY2hyb25vdXNseSBpbnZva2UgaXRzIGNvbnN0cnVjdG9yIAorUEFTUyBJbnNlcnRpbmcgYSBj dXN0b20gZWxlbWVudCBpbnRvIGEgZG9jdW1lbnQgY3JlYXRlZCBieSBjcmVhdGVIVE1MRG9jdW1l bnQgdXNpbmcgSFRNTCBmcmFnbWVudCBwYXJzaW5nIG11c3QgZW5xdWV1ZSBhIGN1c3RvbSBlbGVt ZW50IHVwZ3JhZGUgcmVhY3Rpb24sIG5vdCBzeW5jaHJvbm91c2x5IGludm9rZSBpdHMgY29uc3Ry dWN0b3IgCitQQVNTIEluc2VydGluZyBhIGN1c3RvbSBlbGVtZW50IGludG8gYW4gSFRNTCBkb2N1 bWVudCBjcmVhdGVkIGJ5IGNyZWF0ZURvY3VtZW50IHVzaW5nIEhUTUwgZnJhZ21lbnQgcGFyc2lu ZyBtdXN0IGVucXVldWUgYSBjdXN0b20gZWxlbWVudCB1cGdyYWRlIHJlYWN0aW9uLCBub3Qgc3lu Y2hyb25vdXNseSBpbnZva2UgaXRzIGNvbnN0cnVjdG9yIAorUEFTUyBJbnNlcnRpbmcgYSBjdXN0 b20gZWxlbWVudCBpbnRvIHRoZSBkb2N1bWVudCBvZiBhbiBpZnJhbWUgdXNpbmcgSFRNTCBmcmFn bWVudCBwYXJzaW5nIG11c3QgZW5xdWV1ZSBhIGN1c3RvbSBlbGVtZW50IHVwZ3JhZGUgcmVhY3Rp b24sIG5vdCBzeW5jaHJvbm91c2x5IGludm9rZSBpdHMgY29uc3RydWN0b3IgCitQQVNTIEluc2Vy dGluZyBhIGN1c3RvbSBlbGVtZW50IGludG8gYW4gSFRNTCBkb2N1bWVudCBmZXRjaGVkIGJ5IFhI UiB1c2luZyBIVE1MIGZyYWdtZW50IHBhcnNpbmcgbXVzdCBlbnF1ZXVlIGEgY3VzdG9tIGVsZW1l bnQgdXBncmFkZSByZWFjdGlvbiwgbm90IHN5bmNocm9ub3VzbHkgaW52b2tlIGl0cyBjb25zdHJ1 Y3RvciAKIAo=