9508 2006-06-19 10:33:22 -0700 Comparing a form element group to itself returns false (form element name getter returns a new NodeList each time) 2022-07-27 17:53:24 -0700 1 1 1 Unclassified WebKit WebCore JavaScript 528+ (Nightly build) All All RESOLVED CONFIGURATION CHANGED P2 Normal --- 1 troyb webkit-unassigned ahmad.saleem792 ap bfulgham darin ggaren ian kling mjs rniwa sanjay12 ysuzuki oldest_to_newest 46282 0 troyb 2006-06-19 10:33:22 -0700 Using this example produces a false result for the button group (theRadio) and a true return for element zero. Expected, both should return true which is what happens in Firefox and Opera. The checked / unchecked state of the buttons is not examined. <html> <head> <script type='text/javascript'> function compareObjects() { var alertText; with (document.theForm) { alertText = "with (document.theForm) {" alertText += "\n\t(theRadio == theRadio) == " if (theRadio == theRadio) { alertText += "true"; } else { alertText += "false"; } alertText += "\n\t(theRadio[0] == theRadio[0]) == " if (theRadio[0] == theRadio[0]) { alertText += "true"; } else { alertText += "false"; } alertText += "\n}"; } alert(alertText); } </script> </head> <body> <p>Clicking the "Compare" button below calls a JavaScript function that compares the <i>theRadio</i> radio button group to itself and compares element zero of the button group to itself, then displays the results of those comparisons in an alert. The checked/unchecked state of the radio buttons is not examined.</p> <form name='theForm'> <input type='button' name='theButton' value='Compare' onclick='compareObjects()' /> <p><input type='radio' name='theRadio' value='0' /> theRadio[0]<br /> <input type='radio' name='theRadio' value='1' /> theRadio[1]</p> </form> </body> </html> 46283 1 8922 troyb 2006-06-19 10:35:08 -0700 Created attachment 8922 example document 33444 2 sanjay12 2007-01-22 09:43:14 -0800 The root issue here is that when comparing objects, the equality check in comparison.cpp does a simple pointer comparison to see whether or not two objects are the same. However, when you access a form group where there's multiple elements with the same name, you get a temporary DOMNamedNodesCollection pointer. So the equality check is checking the addresses of two distinct temporary objects, which of course will always fail. I have an idea for a relatively clean solution, will post the patch this evening. 33156 3 12621 sanjay12 2007-01-23 02:09:06 -0800 Created attachment 12621 proposed fix Weighing the options, the posted patch is probably the best way to solve the issue at hand given all the factors. While it certainly would be possible to cache requests for form groups in the HTMLFormElement, the issue becomes that if we don't cache every single unique request for the life of the HTMLFormElement, then you potentially could have a comparison occur much later that fails when it shouldn't. However, having a cache which only removes elements once the HTMLFormElement gets destroyed would add memory overhead. The comments surrounding DOMNameNodesCollection seemed to imply that it would be too costly to have them persist for long periods of time. We could change how form elements are stored internally, so the group lookup doesn't have to create a temporary object, but it would probably end up touching a great deal of code. With the solution used in the patch, for 99% of the equality comparisons, there'll be no discernable speed effect, and it also gives some flexibility to quickly fix similar problems in other areas, if they pop up. I tested this change with both the LayoutTests and javascriptcore tests, and no regressions are introduced by this patch. Also included is a test case for future regression testing. 33139 4 12621 ddkilzer 2007-01-23 04:09:59 -0800 Comment on attachment 12621 proposed fix A couple random comments on this patch. (Note that I'm not a reviewer, so take these with the proverbial grain of salt! :) - Instead of needsDeepEqual(), how about hasDeepEqual() or useDeepEqual()? - Would it be possible to override operator==() instead? It would be cleaner than adding two functions, but operator overloading is not obvious when looking at source. - You might consider using the LayoutTests/fast/js/resources/js-test-pre.js, js-test-post.js and js-test-style.css files in your layout test so you don't have to reinvent the wheel. Just use relative paths to include these resources. See LayoutTests/fast/js/activation-proto.html for an example of how to use them. 33072 5 12621 darin 2007-01-23 08:03:19 -0800 Comment on attachment 12621 proposed fix There's no need for two virtual functions here. Once we're taking the overhead of a virtual function call there's no reason to not just call it isEqual and do the pointer comparison in the base JSObject implementation. I don't see the need for the word "deep" in the name. Since both objects are known to be ObjectType already, we should be doing a cast to JSObject, not a call to getObject -- the getObject call is much more expensive and does not add any value. In fact, I think the "equal" function would read better if the end part was a switch statement. I don't think the change to strictEqual is correct. That's for the "===" operation, which should almost certainly distinguish two objects with identical contents like these. So I believe that function doesn't need to change. + const DOMNamedNodesCollection* d = reinterpret_cast<const DOMNamedNodesCollection*>(rhs); This should be a static_cast, not a reinterpret_cast. + // For performance, we can assume that two collections which have the same size and start with the + // same nodes are equivalent, as opposed to iterating through the entire vectors. No. That's wrong. We do need to compare the vectors. This code should just say: return rhs->isObject(&DOMNamedNodesCollection::info) && m_nodes == static_cast<const DOMNamedNodesCollection*>(rhs)->m_nodes; 33074 6 darin 2007-01-23 08:08:05 -0800 (In reply to comment #3) > While it certainly would be possible to cache requests for form groups in the > HTMLFormElement, the issue becomes that if we don't cache every single unique > request for the life of the HTMLFormElement, then you potentially could have a > comparison occur much later that fails when it shouldn't. I don't agree with this comment. There's no problem creating a design where the collection is registered with the form; the form points to it and when the collection is destroyed the pointer in the form gets cleared. We don't need to make any change to the collection lifetime at all to do this -- we just need to add a pointer to HTMLFormElement and add the code to the collection class to clear this pointer when the collection is deallocated. I think this change is simple and practical and probably a better choice than adding the ability to do equality comparison to the JavaScript binding. By the way, if we do extend the JavaScript binding in this way, we'll also want it in the C API. 33066 7 darin 2007-01-23 09:01:34 -0800 (In reply to comment #6) > (In reply to comment #3) > > While it certainly would be possible to cache requests for form groups in the > > HTMLFormElement, the issue becomes that if we don't cache every single unique > > request for the life of the HTMLFormElement, then you potentially could have a > > comparison occur much later that fails when it shouldn't. > > I don't agree with this comment. There's no problem creating a design where the > collection is registered with the form; the form points to it and when the > collection is destroyed the pointer in the form gets cleared. > > We don't need to make any change to the collection lifetime at all to do this > -- we just need to add a pointer to HTMLFormElement and add the code to the > collection class to clear this pointer when the collection is deallocated. I > think this change is simple and practical and probably a better choice than > adding the ability to do equality comparison to the JavaScript binding. I studied this more, and I am not sure what I said is right. It's JSHTMLCollection that would need to keep track of DOMNamedNodesCollection objects it creates, not HTMLFormElement, because it's the class that creates the collections. We'd have to add a map of property names to DOMNamedNodesCollection and store both a pointer to the JSHTMLCollection and the property name in the DOMNamedNodesCollection objects. Then when a DOMNamedNodesCollection was destroyed it would call back to the JSHTMLCollection so it could remove it from the map, and when a JSHTMLCollection was destroyed it woud disconnect itself from all the DOMNamedNodesCollection objects still in the map. If we did this, I'd suggest moving DOMNamedNodesCollection closer to JSHTMLCollection, probably renaming it, and making the two classes more-closely-associated to accomplish this. I think it's not all that difficult to make this work. Specifics of this case aside, I think it's a reasonable to consider making equality comparison something that JSObject subclasses can customize. I am sad this came up *after* we defined the C API, because clearly we'd want to be able to do this from C too. 33046 8 sanjay12 2007-01-23 09:44:09 -0800 I think I was concerned that temporarily caching it could create cases where the comparsion would still fail, but I guess really that doesn't make sense, since the lifetime of the object will be however long it is still referenced. Regarding strict equal, are you saying that "strict equal in this case should be false" or "strict equal already works, so we don't need to change it." Well currently, strict equal returns false in this case (for objects it's still doing a pointer comparison), but Firefox says it should be true. So I'm pretty sure strict equal does need to be fixed as well. Making the caching change will fix it at the same time as reguar equal. Good point about getting rid of the second virtual call and having it just do a the pointer comparison first in an isEqual() function to save virtual call overhead, but I guess that's irrelevant anyways with the caching solution. Anyways, I agree the caching solution is a much more elegant way to solve the problem. I was going to do it that way originally, but then I had the lifetime concerns. However it seems like that shouldn't be a problem. I'll rewrite the patch and post something either tonight or tomorrow night. Hey, well at least I already have a test case for it! :) David: While you certainly could overload operator ==, since JSObjects are almost exclusively passed around as pointers, whenever you wanted to call it you'd have to write code like (*v1) == (*v2), which certainly isn't fun :). 32478 9 darin 2007-01-26 11:04:51 -0800 (In reply to comment #8) > Regarding strict equal, are you saying that "strict equal in this case should > be false" or "strict equal already works, so we don't need to change it." Well > currently, strict equal returns false in this case (for objects it's still > doing a pointer comparison), but Firefox says it should be true. So I'm pretty > sure strict equal does need to be fixed as well. Making the caching change will > fix it at the same time as reguar equal. I was saying that === should be false. If === is true in Firefox, that indicates they use the same object, not just an equal one. So that makes me think even more strongly that the best way to do this is by "caching" the object and passing the same one out. > Good point about getting rid of the second virtual call and having it just do a > the pointer comparison first in an isEqual() function to save virtual call > overhead, but I guess that's irrelevant anyways with the caching solution. It's relevant if we ever want to give object classes a way to define what equality means. And if we do that it will be for equal but not strictEqual. It's possible we'll never need that though. 30548 10 12780 sanjay12 2007-01-30 01:52:42 -0800 Created attachment 12780 caching method This patch implements the "caching" method as discussed above. When a new DOMNamedNodesCollection is created, it's stored in a hash map, and subsequent requests for it return a pointer to the same object, instead of creating a new temp object just for themselves. Additionally, I moved DOMNamedNodesCollection closer to JSHTMLCollection, and out of kjs_dom.h. Since it was only ever used internally by JSHTMLCollection, it doesn't even need to be in a header that's included all over the place, but can rather be defined in kjs_html.cpp. One thing that may be a little questionable is the way I mangle the identifier in order to ensure that multiple forms or pages with the same form group identifier don't give false positives. Basically, rather than just using the straight identifier, I take the identifier plus the address of the first node in the collection (since the nodes contained by the collection are never temp copies, but always point to the actual form elements). Then I use the identifier+address as the string key for the hash map. Because the JSHTMLCollection object itself is very short-lived (it immediately goes out of scope after returning what it needs to), this seemed like the least roundabout way to prevent the identifier clashes. But again, I'm definitely open to suggestion if someone has a better idea. I've also updated the test case for this bug slightly from the previous patch. 30114 11 darin 2007-01-30 09:47:25 -0800 (In reply to comment #10) > Basically, rather than just using the > straight identifier, I take the identifier plus the address of the first node > in the collection (since the nodes contained by the collection are never temp > copies, but always point to the actual form elements). Then I use the > identifier+address as the string key for the hash map. I think that's not acceptable. I'll give you a specific suggestion for an alternative way to do it after looking over the patch. 30032 12 12780 darin 2007-01-30 13:52:05 -0800 Comment on attachment 12780 caching method Good work! It looks like you're on the right track. If you're moving the code you should probably clean things up a little bit. Details follow. The patch has a combination of 4-character and 2-character indentation. Better to do 4-character consistently. + DOMNamedNodesCollection(ExecState *exec, const Vector<RefPtr<Node> >& nodes, const AtomicString& name); Just ExecState* here, no space before * and no need for the variable name exec. Also no need to give the Vector the name "nodes". + static JSValue *lengthGetter(ExecState* exec, JSObject *, const Identifier&, const PropertySlot& slot); JSValue* and JSObject*. No need for the name "exec" or "slot". + Vector<RefPtr<WebCore::Node> > m_nodes; No need for the WebCore:: prefix. Probably best to use a typedef for the node vector type. + AtomicString propertyName; Should call this m_propertyName. I'm not sure why this is an AtomicString. The only role for this is to be a key for the hash table, and the hash table uses a StringImpl* rather than an AtomicStringImpl*. We really can go either way -- if the strings are unique each time, then AtomicString doesn't add too much value. To avoid aliasing during the lifetime of the DOMNamedNodesCollection, we have to do something to keep its node alive. Thus I think it needs to hold a RefPtr to the node it was made from, not just the nodes in the collection. Without this, the %p technique we are currently using is not sufficient to prevent collisions. +typedef HashMap<StringImpl*,DOMNamedNodesCollection*> NamedNodesCache; Need a space after the comma. +NamedNodesCache& getNamedNodesCache() Need to mark this static so the function gets internal linkage. + // Mangle the identifier string with the node pointer to the first element. This approach is ugly. If we really need a key that is a string plus a node pointer, we can do that. HashMap allows arbitrary keys and I can help you make a appropriate hash function. But a simpler thing that will also work is to use a hash of hashes -- a primary hash table that uses the node pointer as a key and the values are pointers to hash tables that use a string as a key. + char ptrBuffer[15]; Strange choice of length here. On 64-bit platforms, the hex form of a pointer will typically be 18 bytes long, so you'd need a 19-byte buffer, and on 32-bit it will typically be 10 bytes long and require an 11-byte buffer. So 19 or 20 would make more sense. + getNamedNodesCache().add(tempString.impl(), nodeCollection); This line of code is incorrect. The tempString will go away, and its StringImpl* might be deallocated. What you need to use as the hash key is the pointer to the string that's actually stored inside the DOMNamedNodesCollection object. You'll probably need a member function named propertyName() to get at it. + DOMNamedNodesCollection *thisObj = static_cast<DOMNamedNodesCollection*>(slot.slotBase()); Should move the * next to the type. Ideally we'd move DOMNamedNodesCollection to its own source file. We're trying to phase out these kjs_xxx files. Maybe even use an idl to generate its JavaScript wrapper; we could at least auto-generate length even though we'd still need custom code for getting the array index and by-name properties. review- because of the need to ref the node and the incorrect call to add. I'd really like to see a version that does not use %p. 29463 13 sanjay12 2007-01-31 23:50:17 -0800 I started working on a new patch based on your suggestions. I understood most of what you said, but one thing I'm not completely clear on is that the DOMNamedNodesCollection should hold a refptr to the node which created it. How would I be able to access that in JSHTMLCollection::getNamedItems given that it can be called either via the nameGetter or from JSHTMLFormElement? In the latter case, the JSHTMLCollection created is just a temp object. And even then, I'm not quite sure why that would be needed to prevent aliasing. The individual nodes that make up the form element group won't be destroyed throughout the life of the document, correct? If that's so, and we're hashing the Node pointer to the first node that makes up the group and the identifier, then I don't see how it's a problem. Actually, it just occurred to me if that is the case, then actually we don't need to hash with the Node pointer to the first node PLUS the identifier. The identifier actually doesn't matter at the point where you've already grabbed the named items from that identifier, and are hashing with the node pointer to the first node in the named element group. Or, if that didn't make sense, basically the patch that I submitted on the 30th didn't need to hash with a string at all. It could have hashed just the Node pointer to the first element, and that would be that. 29464 14 darin 2007-01-31 23:56:18 -0800 (In reply to comment #13) > I started working on a new patch based on your suggestions. I understood most > of what you said, but one thing I'm not completely clear on is that the > DOMNamedNodesCollection should hold a refptr to the node which created it. How > would I be able to access that in JSHTMLCollection::getNamedItems given that it > can be called either via the nameGetter or from JSHTMLFormElement? In the > latter case, the JSHTMLCollection created is just a temp object. I see what you mean. I think what I really meant is a RefPtr to the HTMLCollection, and use that as part of the key rather than the first node pointer. > And even then, I'm not quite sure why that would be needed to prevent aliasing. > The individual nodes that make up the form element group won't be destroyed > throughout the life of the document, correct? Someone could change the nodes around with JavaScript DOM operations. For example, the name attribute of an element could be changed or it could be removed from the document or moved into another form. I think we need to test how the other browsers behave in cases like that. Does the collection automatically change to reflect changes to the document? Or what? > It could have hashed just the Node pointer to the first element, > and that would be that. Maybe we can get away with just hashing the node pointer to the first element. I think it depends on the results of the testing I'm suggesting above. 29334 15 sanjay12 2007-02-01 00:38:32 -0800 I'll look into seeing what happens with other browsers in the case of renaming the form element group. But I just realized that due to being able to add/remove members of the form element group, the caching solution is going to have to be a bit more complex than it was in the past solution. The problem is the DOMNamedNodesCollection just has a vector which contains the nodes that existed when the object was created. But suppose you have a DOMNamedNodesCollection cached and then add or remove another form element to that group. Well now whenever you try to access the form element group, you'll still get the DOMNamedNodesCollection that has a vector to the old state of the form group. So...the HTMLCollection pointer, then the identifier string name should be what is used as a key. But then when an HTMLCollection is modified (either a node added or removed), it has to do a lookup to see whether any DOMNamedNodesCollections are cached for that identifier, and if so has to update that DOMNamedNodesCollection to have the correct new state of the form element group. 29101 16 darin 2007-02-01 10:07:26 -0800 Sure, sounds right. But lets not make any assumptions about the behavior when things are changed until we see what the behavior of other browsers is. In all those cases, not just the name change case. 237070 17 ap 2010-06-11 15:24:15 -0700 This is almost the same as bug 33696, but needs to be fixed separately (we we want to fix this). 237071 18 ap 2010-06-11 15:24:40 -0700 _If_ we want to fix this 1887157 19 ahmad.saleem792 2022-07-27 13:48:13 -0700 I am unable to reproduce this bug in Safari 15.6 on macOS 12.5 and all browsers produce same output as below: with (document.theForm) { (theRadio == theRadio) == true (theRadio[0] == theRadio[0]) == true } I think it might have been fixed along the way and can be marked as "RESOLVED CONFIGURATION CHANGED". Thanks! 1887164 20 rniwa 2022-07-27 14:24:35 -0700 Yup, we've fixed this. 1887207 21 darin 2022-07-27 17:53:24 -0700 I think it was fixed with bug 81854. 8922 2006-06-19 10:35:08 -0700 2006-06-26 03:53:36 -0700 example document JavaScriptCompare.html text/html 1139 troyb PGh0bWw+Cgo8aGVhZD4KCjxzY3JpcHQgdHlwZT0ndGV4dC9qYXZhc2NyaXB0Jz4KCmZ1bmN0aW9u IGNvbXBhcmVPYmplY3RzKCkgewoJdmFyIGFsZXJ0VGV4dDsKCQoJd2l0aCAoZG9jdW1lbnQudGhl Rm9ybSkgewoJCQoJCWFsZXJ0VGV4dCA9ICJ3aXRoIChkb2N1bWVudC50aGVGb3JtKSB7IgoJCQoJ CWFsZXJ0VGV4dCArPSAiXG5cdCh0aGVSYWRpbyA9PSB0aGVSYWRpbykgPT0gIgoJCWlmICh0aGVS YWRpbyA9PSB0aGVSYWRpbykgewoJCQlhbGVydFRleHQgKz0gInRydWUiOwoJCX0gZWxzZSB7CgkJ CWFsZXJ0VGV4dCArPSAiZmFsc2UiOwoJCX0KCQkKCQlhbGVydFRleHQgKz0gIlxuXHQodGhlUmFk aW9bMF0gPT0gdGhlUmFkaW9bMF0pID09ICIKCQkKCQlpZiAodGhlUmFkaW9bMF0gPT0gdGhlUmFk aW9bMF0pIHsKCQkJYWxlcnRUZXh0ICs9ICJ0cnVlIjsKCQl9IGVsc2UgewoJCQlhbGVydFRleHQg Kz0gImZhbHNlIjsKCQl9CgkJCgkJYWxlcnRUZXh0ICs9ICJcbn0iOwoJfQoJCglhbGVydChhbGVy dFRleHQpOwp9Cgo8L3NjcmlwdD4KCjwvaGVhZD4KCjxib2R5PgoKPHA+Q2xpY2tpbmcgdGhlICJD b21wYXJlIiBidXR0b24gYmVsb3cgY2FsbHMgYSBKYXZhU2NyaXB0IGZ1bmN0aW9uIHRoYXQgY29t cGFyZXMgdGhlIDxpPnRoZVJhZGlvPC9pPiByYWRpbyBidXR0b24gZ3JvdXAgdG8gaXRzZWxmIGFu ZCBjb21wYXJlcyBlbGVtZW50IHplcm8gb2YgdGhlIGJ1dHRvbiBncm91cCB0byBpdHNlbGYsIHRo ZW4gZGlzcGxheXMgdGhlIHJlc3VsdHMgb2YgdGhvc2UgY29tcGFyaXNvbnMgaW4gYW4gYWxlcnQu IFRoZSBjaGVja2VkL3VuY2hlY2tlZCBzdGF0ZSBvZiB0aGUgcmFkaW8gYnV0dG9ucyBpcyBub3Qg ZXhhbWluZWQuPC9wPgoKPGZvcm0gbmFtZT0ndGhlRm9ybSc+Cgo8aW5wdXQgdHlwZT0nYnV0dG9u JyBuYW1lPSd0aGVCdXR0b24nIHZhbHVlPSdDb21wYXJlJyBvbmNsaWNrPSdjb21wYXJlT2JqZWN0 cygpJyAvPgo8cD48aW5wdXQgdHlwZT0ncmFkaW8nIG5hbWU9J3RoZVJhZGlvJyB2YWx1ZT0nMCcg Lz4gdGhlUmFkaW9bMF08YnIgLz4KPGlucHV0IHR5cGU9J3JhZGlvJyBuYW1lPSd0aGVSYWRpbycg dmFsdWU9JzEnIC8+IHRoZVJhZGlvWzFdPC9wPgoKPC9mb3JtPgoKCjwvYm9keT4KCjwvaHRtbD4= 12621 2007-01-23 02:09:06 -0800 2007-01-25 23:28:27 -0800 proposed fix jsformcomp.diff text/plain 9197 sanjay12 SW5kZXg6IEphdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBKYXZhU2NyaXB0 Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDE5MDM4KQorKysgSmF2YVNjcmlwdENvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTkgQEAKKzIwMDctMDEtMjMgIFNhbmpheSBN YWRoYXYgIDxzYW5qYXkxMkBnbWFpbC5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgRml4IGZvcjogaHR0cDovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9OTUwOAorICAgICAgICBKUyBjb21wYXJpc29ucyBiZXR3ZWVuIHRoZSBzYW1l IGZvcm0gZ3JvdXAgbm93IGFyZSBjb3JyZWN0LgorCisgICAgICAgIFRlc3Q6IExheW91dFRlc3Rz L2Zhc3QvZm9ybS9mb3JtLWNvbXAtdGVzdC5odG1sCisKKyAgICAgICAgKiBranMvb2JqZWN0Lmg6 CisgICAgICAgIChLSlM6OkpTT2JqZWN0OjpuZWVkc0RlZXBFcXVhbCk6CisgICAgICAgIChLSlM6 OkpTT2JqZWN0OjpkZWVwRXF1YWwpOgorICAgICAgICAqIGtqcy9vcGVyYXRpb25zLmNwcDoKKyAg ICAgICAgKEtKUzo6ZXF1YWwpOgorICAgICAgICAoS0pTOjpzdHJpY3RFcXVhbCk6CisKIDIwMDct MDEtMTggIFNhbmpheSBNYWRoYXYgIDxzYW5qYXkxMkBnbWFpbC5jb20+CiAKICAgICAgICAgUmV2 aWV3ZWQgYnkgRGFyaW4uCkluZGV4OiBKYXZhU2NyaXB0Q29yZS9ranMvb2JqZWN0LmgKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gSmF2YVNjcmlwdENvcmUva2pzL29iamVjdC5oCShyZXZpc2lvbiAxOTAzOCkKKysr IEphdmFTY3JpcHRDb3JlL2tqcy9vYmplY3QuaAkod29ya2luZyBjb3B5KQpAQCAtNDU0LDYgKzQ1 NCwxMyBAQCBuYW1lc3BhY2UgS0pTIHsKICAgICB2b2lkIHJlc3RvcmVQcm9wZXJ0aWVzKGNvbnN0 IFNhdmVkUHJvcGVydGllcyAmcCkgeyBfcHJvcC5yZXN0b3JlKHApOyB9CiAKICAgICB2aXJ0dWFs IGJvb2wgaXNBY3RpdmF0aW9uKCkgeyByZXR1cm4gZmFsc2U7IH0KKyAgICAKKyAgICAvLyBEZXJp dmVkIG9iamVjdHMgd2hpY2ggbmVlZCB0byBkbyBkZWVwIGVxdWFsaXR5IGNvbXBhcmlzb25zIGlu IG9wZXJhdGlvbnMuY3BwCisgICAgLy8gc2hvdWxkIG92ZXJsb2FkIHRoZXNlIGZ1bmN0aW9ucy4K KyAgICAvLyBGb3IgdGhlIG1vc3QgcGFydCwgdGhpcyB3b3VsZCBvbmx5IGJlIHVzZWQgZm9yIHNp dHVhdGlvbnMgd2hlcmUgeW91J3JlIGNyZWF0aW5nCisgICAgLy8gdGVtcG9yYXJ5IG9iamVjdHMs IGFuZCB0aGUgZGVmYXVsdCBhZGRyZXNzIGNvbXBhcmlzb24gd291bGQgYmUgaW52YWxpZCAoc3Vj aCBhcyB3aXRoIGZvcm1zKS4KKyAgICB2aXJ0dWFsIGJvb2wgbmVlZHNEZWVwRXF1YWwoKSBjb25z dCB7IHJldHVybiBmYWxzZTsgfQorICAgIHZpcnR1YWwgYm9vbCBkZWVwRXF1YWwoY29uc3QgSlNP YmplY3QqKSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQogICBwcm90ZWN0ZWQ6CiAgICAgUHJvcGVy dHlNYXAgX3Byb3A7CiAgIHByaXZhdGU6CkluZGV4OiBKYXZhU2NyaXB0Q29yZS9ranMvb3BlcmF0 aW9ucy5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gSmF2YVNjcmlwdENvcmUva2pzL29wZXJhdGlvbnMuY3Bw CShyZXZpc2lvbiAxOTAzOCkKKysrIEphdmFTY3JpcHRDb3JlL2tqcy9vcGVyYXRpb25zLmNwcAko d29ya2luZyBjb3B5KQpAQCAtMTU4LDYgKzE1OCwxMCBAQCBib29sIGVxdWFsKEV4ZWNTdGF0ZSAq ZXhlYywgSlNWYWx1ZSAqdjEsCiAgICAgaWYgKHQxID09IEJvb2xlYW5UeXBlKQogICAgICAgICBy ZXR1cm4gdjEtPnRvQm9vbGVhbihleGVjKSA9PSB2Mi0+dG9Cb29sZWFuKGV4ZWMpOwogICAgIAor ICAgIEpTT2JqZWN0KiBvMSA9IHYxLT5nZXRPYmplY3QoKTsKKyAgICBpZiAobzEtPm5lZWRzRGVl cEVxdWFsKCkpCisgICAgICAgIHJldHVybiBvMS0+ZGVlcEVxdWFsKHYyLT5nZXRPYmplY3QoKSk7 CisKICAgICAvLyB0eXBlcyBhcmUgT2JqZWN0CiAgICAgcmV0dXJuIHYxID09IHYyOwogfQpAQCAt MTgyLDYgKzE4NiwxMCBAQCBib29sIHN0cmljdEVxdWFsKEV4ZWNTdGF0ZSAqZXhlYywgSlNWYWx1 CiAgICAgZWxzZSBpZiAodDIgPT0gQm9vbGVhblR5cGUpCiAgICAgICAgIHJldHVybiB2MS0+dG9C b29sZWFuKGV4ZWMpID09IHYyLT50b0Jvb2xlYW4oZXhlYyk7CiAgICAgCisgICAgSlNPYmplY3Qq IG8xID0gdjEtPmdldE9iamVjdCgpOworICAgIGlmIChvMS0+bmVlZHNEZWVwRXF1YWwoKSkKKyAg ICAgICAgcmV0dXJuIG8xLT5kZWVwRXF1YWwodjItPmdldE9iamVjdCgpKTsKKyAgICAKICAgICBp ZiAodjEgPT0gdjIpCiAgICAgICAgIHJldHVybiB0cnVlOwogICAgIC8qIFRPRE86IGpvaW5lZCBv YmplY3RzICovCkluZGV4OiBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5 b3V0VGVzdHMvQ2hhbmdlTG9nCShyZXZpc2lvbiAxOTAzOCkKKysrIExheW91dFRlc3RzL0NoYW5n ZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDEzIEBACisyMDA3LTAxLTIzICBTYW5qYXkg TWFkaGF2ICA8c2FuamF5MTJAZ21haWwuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIFRlc3QgZm9yOiBodHRwOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD05NTA4CisgICAgICAgIEpTIGNvbXBhcmlzb25zIGJldHdlZW4gdGhlIHNh bWUgZm9ybSBncm91cCBub3cgYXJlIGNvcnJlY3QuCisKKyAgICAgICAgKiBmYXN0L2Zvcm1zL2Zv cm0tY29tcC10ZXN0LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9mb3Jtcy9m b3JtLWNvbXAtdGVzdC5odG1sOiBBZGRlZC4KKwogMjAwNy0wMS0yMiAgTWl0eiBQZXR0ZWwgIDxt aXR6QHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4uCkluZGV4OiBMYXlv dXRUZXN0cy9mYXN0L2Zvcm1zL2Zvcm0tY29tcC10ZXN0LWV4cGVjdGVkLnR4dAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBMYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL2Zvcm0tY29tcC10ZXN0LWV4cGVjdGVkLnR4dAko cmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvZm9ybXMvZm9ybS1jb21wLXRlc3QtZXhw ZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDMxIEBACitsYXllciBhdCAoMCwwKSBz aXplIDgwMHg2MDAKKyAgUmVuZGVyVmlldyBhdCAoMCwwKSBzaXplIDgwMHg2MDAKK2xheWVyIGF0 ICgwLDApIHNpemUgODAweDYwMAorICBSZW5kZXJCbG9jayB7SFRNTH0gYXQgKDAsMCkgc2l6ZSA4 MDB4NjAwCisgICAgUmVuZGVyQm9keSB7Qk9EWX0gYXQgKDgsOCkgc2l6ZSA3ODR4NTg0CisgICAg ICBSZW5kZXJCbG9jayB7UH0gYXQgKDAsMCkgc2l6ZSA3ODR4MTgKKyAgICAgICAgUmVuZGVyVGV4 dCB7I3RleHR9IGF0ICgwLDApIHNpemUgNjA2eDE4CisgICAgICAgICAgdGV4dCBydW4gYXQgKDAs MCkgd2lkdGggNjA2OiAiVGhpcyBwYWdlIHRlc3RzIHRvIHNlZSB0aGF0IHRoZSBzZWxmLWNvbXBh cmlzb24gb2YgZm9ybSBlbGVtZW50IGdyb3VwcyBnaXZlcyB0aGUgZXhwZWN0ZWQgcmVzdWx0cy4i CisgICAgICBSZW5kZXJCbG9jayB7UH0gYXQgKDAsMzQpIHNpemUgNzg0eDE4CisgICAgICAgIFJl bmRlclRleHQgeyN0ZXh0fSBhdCAoMCwwKSBzaXplIDQwM3gxOAorICAgICAgICAgIHRleHQgcnVu IGF0ICgwLDApIHdpZHRoIDQwMzogIklmIHRoZSB0ZXN0IHBhc3NlcywgeW91J2xsIHNlZSB0aHJl ZSAnUEFTUycgbWVzc2FnZXMgYmVsb3cgdGhlIGhyLiIKKyAgICAgIFJlbmRlckJsb2NrIHtGT1JN fSBhdCAoMCw2OCkgc2l6ZSA3ODR4MzgKKyAgICAgICAgUmVuZGVyQmxvY2sge1B9IGF0ICgwLDAp IHNpemUgNzg0eDM4CisgICAgICAgICAgUmVuZGVyQmxvY2sge0lOUFVUfSBhdCAoMywzKSBzaXpl IDEyeDEzCisgICAgICAgICAgUmVuZGVyVGV4dCB7I3RleHR9IGF0ICgxOCwwKSBzaXplIDc5eDE4 CisgICAgICAgICAgICB0ZXh0IHJ1biBhdCAoMTgsMCkgd2lkdGggNzk6ICIgdGhlUmFkaW9bMF0i CisgICAgICAgICAgUmVuZGVyQlIge0JSfSBhdCAoOTcsMTQpIHNpemUgMHgwCisgICAgICAgICAg UmVuZGVyQmxvY2sge0lOUFVUfSBhdCAoMywyMikgc2l6ZSAxMngxMworICAgICAgICAgIFJlbmRl clRleHQgeyN0ZXh0fSBhdCAoMTgsMTkpIHNpemUgNzl4MTgKKyAgICAgICAgICAgIHRleHQgcnVu IGF0ICgxOCwxOSkgd2lkdGggNzk6ICIgdGhlUmFkaW9bMV0iCisgICAgICBSZW5kZXJCbG9jayB7 SFJ9IGF0ICgwLDEyMikgc2l6ZSA3ODR4MiBbYm9yZGVyOiAoMXB4IGluc2V0ICMwMDAwMDApXQor ICAgICAgUmVuZGVyQmxvY2sge0RJVn0gYXQgKDAsMTMyKSBzaXplIDc4NHg0NQorICAgICAgICBS ZW5kZXJCbG9jayB7RElWfSBhdCAoMCwwKSBzaXplIDc4NHgxNSBbY29sb3I9IzAwODAwMF0KKyAg ICAgICAgICBSZW5kZXJUZXh0IHsjdGV4dH0gYXQgKDAsMCkgc2l6ZSA2NHgxNQorICAgICAgICAg ICAgdGV4dCBydW4gYXQgKDAsMCkgd2lkdGggNjQ6ICJQQVNTOiA9PSIKKyAgICAgICAgUmVuZGVy QmxvY2sge0RJVn0gYXQgKDAsMTUpIHNpemUgNzg0eDE1IFtjb2xvcj0jMDA4MDAwXQorICAgICAg ICAgIFJlbmRlclRleHQgeyN0ZXh0fSBhdCAoMCwwKSBzaXplIDcyeDE1CisgICAgICAgICAgICB0 ZXh0IHJ1biBhdCAoMCwwKSB3aWR0aCA3MjogIlBBU1M6ID09PSIKKyAgICAgICAgUmVuZGVyQmxv Y2sge0RJVn0gYXQgKDAsMzApIHNpemUgNzg0eDE1IFtjb2xvcj0jMDA4MDAwXQorICAgICAgICAg IFJlbmRlclRleHQgeyN0ZXh0fSBhdCAoMCwwKSBzaXplIDY0eDE1CisgICAgICAgICAgICB0ZXh0 IHJ1biBhdCAoMCwwKSB3aWR0aCA2NDogIlBBU1M6ICE9IgpJbmRleDogTGF5b3V0VGVzdHMvZmFz dC9mb3Jtcy9mb3JtLWNvbXAtdGVzdC5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2Zh c3QvZm9ybXMvZm9ybS1jb21wLXRlc3QuaHRtbAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3Rz L2Zhc3QvZm9ybXMvZm9ybS1jb21wLXRlc3QuaHRtbAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw0 NyBAQAorPGh0bWw+Cis8aGVhZD4KKzx0aXRsZT5Gb3JtIENvbXBhcmlzb24gdGVzdDwvdGl0bGU+ Cis8c2NyaXB0PgorZnVuY3Rpb24gcHJpbnQobWVzc2FnZSwgY29sb3IpIAoreworICAgIHZhciBw YXJhZ3JhcGggPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJkaXYiKTsKKyAgICBwYXJhZ3JhcGgu YXBwZW5kQ2hpbGQoZG9jdW1lbnQuY3JlYXRlVGV4dE5vZGUobWVzc2FnZSkpOworICAgIHBhcmFn cmFwaC5zdHlsZS5mb250RmFtaWx5ID0gIm1vbm9zcGFjZSI7CisgICAgaWYgKGNvbG9yKQorICAg ICAgICBwYXJhZ3JhcGguc3R5bGUuY29sb3IgPSBjb2xvcjsKKyAgICBkb2N1bWVudC5nZXRFbGVt ZW50QnlJZCgiY29uc29sZSIpLmFwcGVuZENoaWxkKHBhcmFncmFwaCk7Cit9CisKK2Z1bmN0aW9u IHRlc3QoKQoreworICAgIGlmIChkb2N1bWVudC50aGVGb3JtLnRoZVJhZGlvID09IGRvY3VtZW50 LnRoZUZvcm0udGhlUmFkaW8pCisgICAgICAgIHByaW50KCJQQVNTOiA9PSIsICJncmVlbiIpOwor ICAgIGVsc2UKKyAgICAgICAgcHJpbnQoIkZBSUw6ID09IiwgInJlZCIpOworICAgIAorICAgIGlm IChkb2N1bWVudC50aGVGb3JtLnRoZVJhZGlvID09PSBkb2N1bWVudC50aGVGb3JtLnRoZVJhZGlv KQorICAgICAgICBwcmludCgiUEFTUzogPT09IiwgImdyZWVuIik7CisgICAgZWxzZQorICAgICAg ICBwcmludCgiRkFJTDogPT09IiwgInJlZCIpOworICAgICAgICAKKyAgICBpZiAoZG9jdW1lbnQu dGhlRm9ybS50aGVSYWRpbyAhPSBkb2N1bWVudC50aGVGb3JtLnRoZVJhZGlvKQorICAgICAgICBw cmludCgiRkFJTDogIT0iLCAicmVkIik7CisgICAgZWxzZQorICAgICAgICBwcmludCgiUEFTUzog IT0iLCAiZ3JlZW4iKTsKK30KKzwvc2NyaXB0PgorPC9oZWFkPgorCis8Ym9keSBzdHlsZT0iY29s b3I6IGJsYWNrIiBvbmxvYWQ9InRlc3QoKSI+Cis8cD5UaGlzIHBhZ2UgdGVzdHMgdG8gc2VlIHRo YXQgdGhlIHNlbGYtY29tcGFyaXNvbiBvZiBmb3JtIGVsZW1lbnQgZ3JvdXBzIGdpdmVzIHRoZSBl eHBlY3RlZCByZXN1bHRzLjwvcD4KKzxwPklmIHRoZSB0ZXN0IHBhc3NlcywgeW91J2xsIHNlZSB0 aHJlZSAnUEFTUycgbWVzc2FnZXMgYmVsb3cgdGhlIGhyLjwvcD4KKzxmb3JtIG5hbWU9J3RoZUZv cm0nPgorPHA+PGlucHV0IHR5cGU9J3JhZGlvJyBuYW1lPSd0aGVSYWRpbycgdmFsdWU9JzAnIC8+ IHRoZVJhZGlvWzBdPGJyIC8+Cis8aW5wdXQgdHlwZT0ncmFkaW8nIG5hbWU9J3RoZVJhZGlvJyB2 YWx1ZT0nMScgLz4gdGhlUmFkaW9bMV08L3A+Cis8L2Zvcm0+Cis8aHI+CisKKzxkaXYgaWQ9J2Nv bnNvbGUnPjwvZGl2PgorCis8L2JvZHk+Cis8L2h0bWw+CkluZGV4OiBXZWJDb3JlL0NoYW5nZUxv Zwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL0NoYW5nZUxvZwkocmV2aXNpb24gMTkwMzgpCisrKyBX ZWJDb3JlL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE3IEBACisyMDA3LTAx LTIzICBTYW5qYXkgTWFkaGF2ICA8c2FuamF5MTJAZ21haWwuY29tPgorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEZpeCBmb3I6IGh0dHA6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTk1MDgKKyAgICAgICAgSlMgY29tcGFyaXNvbnMgYmV0 d2VlbiB0aGUgc2FtZSBmb3JtIGdyb3VwIG5vdyBhcmUgY29ycmVjdC4KKworICAgICAgICBUZXN0 OiBMYXlvdXRUZXN0cy9mYXN0L2Zvcm0vZm9ybS1jb21wLXRlc3QuaHRtbAorCisgICAgICAgICog YmluZGluZ3MvanMva2pzX2RvbS5jcHA6CisgICAgICAgIChLSlM6OkRPTU5hbWVkTm9kZXNDb2xs ZWN0aW9uOjpkZWVwRXF1YWwpOgorICAgICAgICAqIGJpbmRpbmdzL2pzL2tqc19kb20uaDoKKyAg ICAgICAgKEtKUzo6RE9NTmFtZWROb2Rlc0NvbGxlY3Rpb246Om5lZWRzRGVlcEVxdWFsKToKKwog MjAwNy0wMS0yMiAgTWFyayBSb3dlICA8bXJvd2VAYXBwbGUuY29tPgogCiAgICAgICAgIFJldmll d2VkIGJ5IE1hY2llai4KSW5kZXg6IFdlYkNvcmUvYmluZGluZ3MvanMva2pzX2RvbS5jcHAKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gV2ViQ29yZS9iaW5kaW5ncy9qcy9ranNfZG9tLmNwcAkocmV2aXNpb24gMTkw MzgpCisrKyBXZWJDb3JlL2JpbmRpbmdzL2pzL2tqc19kb20uY3BwCSh3b3JraW5nIGNvcHkpCkBA IC0xMTcyLDQgKzExNzIsMjEgQEAgYm9vbCBET01OYW1lZE5vZGVzQ29sbGVjdGlvbjo6Z2V0T3du UHJvcAogICByZXR1cm4gRE9NT2JqZWN0OjpnZXRPd25Qcm9wZXJ0eVNsb3QoZXhlYywgcHJvcGVy dHlOYW1lLCBzbG90KTsKIH0KIAorYm9vbCBET01OYW1lZE5vZGVzQ29sbGVjdGlvbjo6ZGVlcEVx dWFsKGNvbnN0IEpTT2JqZWN0KiByaHMpIGNvbnN0Cit7CisgICAgaWYgKCFyaHMtPmlzT2JqZWN0 KCZET01OYW1lZE5vZGVzQ29sbGVjdGlvbjo6aW5mbykpCisgICAgICAgIHJldHVybiBmYWxzZTsK KyAgICAKKyAgICBjb25zdCBET01OYW1lZE5vZGVzQ29sbGVjdGlvbiogZCA9IHJlaW50ZXJwcmV0 X2Nhc3Q8Y29uc3QgRE9NTmFtZWROb2Rlc0NvbGxlY3Rpb24qPihyaHMpOyAgICAKKyAgICBpZiAo bV9ub2Rlcy5zaXplKCkgIT0gZC0+bV9ub2Rlcy5zaXplKCkpCisgICAgICAgIHJldHVybiBmYWxz ZTsKKyAgICAKKyAgICAvLyBGb3IgcGVyZm9ybWFuY2UsIHdlIGNhbiBhc3N1bWUgdGhhdCB0d28g Y29sbGVjdGlvbnMgd2hpY2ggaGF2ZSB0aGUgc2FtZSBzaXplIGFuZCBzdGFydCB3aXRoIHRoZQor ICAgIC8vIHNhbWUgbm9kZXMgYXJlIGVxdWl2YWxlbnQsIGFzIG9wcG9zZWQgdG8gaXRlcmF0aW5n IHRocm91Z2ggdGhlIGVudGlyZSB2ZWN0b3JzLgorICAgIGlmIChtX25vZGVzLnNpemUoKSA+IDAg JiYgbV9ub2Rlc1swXS5nZXQoKSAhPSBkLT5tX25vZGVzWzBdLmdldCgpKQorICAgICAgICByZXR1 cm4gZmFsc2U7CisgICAgCisgICAgcmV0dXJuIHRydWU7Cit9CisKIH0gLy8gbmFtZXNwYWNlCklu ZGV4OiBXZWJDb3JlL2JpbmRpbmdzL2pzL2tqc19kb20uaAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3Jl L2JpbmRpbmdzL2pzL2tqc19kb20uaAkocmV2aXNpb24gMTkwMzgpCisrKyBXZWJDb3JlL2JpbmRp bmdzL2pzL2tqc19kb20uaAkod29ya2luZyBjb3B5KQpAQCAtMTUxLDYgKzE1MSw4IEBAIG5hbWVz cGFjZSBLSlMgewogICAgIHZpcnR1YWwgYm9vbCBnZXRPd25Qcm9wZXJ0eVNsb3QoRXhlY1N0YXRl ICosIGNvbnN0IElkZW50aWZpZXImLCBQcm9wZXJ0eVNsb3QmKTsKICAgICB2aXJ0dWFsIGNvbnN0 IENsYXNzSW5mbyogY2xhc3NJbmZvKCkgY29uc3QgeyByZXR1cm4gJmluZm87IH0KICAgICBzdGF0 aWMgY29uc3QgQ2xhc3NJbmZvIGluZm87CisgICAgdmlydHVhbCBib29sIG5lZWRzRGVlcEVxdWFs KCkgY29uc3QgeyByZXR1cm4gdHJ1ZTsgfQorICAgIHZpcnR1YWwgYm9vbCBkZWVwRXF1YWwoY29u c3QgSlNPYmplY3QqKSBjb25zdDsKIHByaXZhdGU6CiAgICAgc3RhdGljIEpTVmFsdWUgKmxlbmd0 aEdldHRlcihFeGVjU3RhdGUqIGV4ZWMsIEpTT2JqZWN0ICosIGNvbnN0IElkZW50aWZpZXImLCBj b25zdCBQcm9wZXJ0eVNsb3QmIHNsb3QpOwogICAgIHN0YXRpYyBKU1ZhbHVlICppbmRleEdldHRl cihFeGVjU3RhdGUqIGV4ZWMsIEpTT2JqZWN0ICosIGNvbnN0IElkZW50aWZpZXImLCBjb25zdCBQ cm9wZXJ0eVNsb3QmIHNsb3QpOwo= 12780 2007-01-30 01:52:42 -0800 2010-06-10 14:28:19 -0700 caching method jsformcomp2.diff text/plain 14698 sanjay12 SW5kZXg6IExheW91dFRlc3RzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9D aGFuZ2VMb2cJKHJldmlzaW9uIDE5MjUwKQorKysgTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCSh3b3Jr aW5nIGNvcHkpCkBAIC0xLDMgKzEsMTIgQEAKKzIwMDctMDEtMzAgIFNhbmpheSBNYWRoYXYgIDxz YW5qYXkxMkBnbWFpbC5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgVGVzdCBmb3I6IGh0dHA6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTk1MDgKKworICAgICAgICAqIGZhc3QvZm9ybXMvZm9ybS1jb2xsZWN0aW9uLWNvbXAtZXhw ZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2Zvcm1zL2Zvcm0tY29sbGVjdGlvbi1j b21wLmh0bWw6IEFkZGVkLgorCiAyMDA3LTAxLTI5ICBBbGV4ZXkgUHJvc2t1cnlha292ICA8YXBA d2Via2l0Lm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBEYXJpbi4KSW5kZXg6IExheW91dFRl c3RzL2Zhc3QvZm9ybXMvZm9ybS1jb2xsZWN0aW9uLWNvbXAtZXhwZWN0ZWQudHh0Cj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIExheW91dFRlc3RzL2Zhc3QvZm9ybXMvZm9ybS1jb2xsZWN0aW9uLWNvbXAtZXhwZWN0 ZWQudHh0CShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9mb3JtLWNvbGxl Y3Rpb24tY29tcC1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMzcgQEAKK2xh eWVyIGF0ICgwLDApIHNpemUgODAweDYwMAorICBSZW5kZXJWaWV3IGF0ICgwLDApIHNpemUgODAw eDYwMAorbGF5ZXIgYXQgKDAsMCkgc2l6ZSA4MDB4NjAwCisgIFJlbmRlckJsb2NrIHtIVE1MfSBh dCAoMCwwKSBzaXplIDgwMHg2MDAKKyAgICBSZW5kZXJCb2R5IHtCT0RZfSBhdCAoOCw4KSBzaXpl IDc4NHg1ODQKKyAgICAgIFJlbmRlckJsb2NrIHtQfSBhdCAoMCwwKSBzaXplIDc4NHgxOAorICAg ICAgICBSZW5kZXJUZXh0IHsjdGV4dH0gYXQgKDAsMCkgc2l6ZSA2MDZ4MTgKKyAgICAgICAgICB0 ZXh0IHJ1biBhdCAoMCwwKSB3aWR0aCA2MDY6ICJUaGlzIHBhZ2UgdGVzdHMgdG8gc2VlIHRoYXQg dGhlIHNlbGYtY29tcGFyaXNvbiBvZiBmb3JtIGVsZW1lbnQgZ3JvdXBzIGdpdmVzIHRoZSBleHBl Y3RlZCByZXN1bHRzLiIKKyAgICAgIFJlbmRlckJsb2NrIHtQfSBhdCAoMCwzNCkgc2l6ZSA3ODR4 MTgKKyAgICAgICAgUmVuZGVyVGV4dCB7I3RleHR9IGF0ICgwLDApIHNpemUgMzk2eDE4CisgICAg ICAgICAgdGV4dCBydW4gYXQgKDAsMCkgd2lkdGggMzk2OiAiSWYgdGhlIHRlc3QgcGFzc2VzLCB5 b3UnbGwgc2VlIGZpdmUgJ1BBU1MnIG1lc3NhZ2VzIGJlbG93IHRoZSBoci4iCisgICAgICBSZW5k ZXJCbG9jayB7Rk9STX0gYXQgKDAsNjgpIHNpemUgNzg0eDM4CisgICAgICAgIFJlbmRlckJsb2Nr IHtQfSBhdCAoMCwwKSBzaXplIDc4NHgzOAorICAgICAgICAgIFJlbmRlckJsb2NrIHtJTlBVVH0g YXQgKDMsMykgc2l6ZSAxMngxMworICAgICAgICAgIFJlbmRlclRleHQgeyN0ZXh0fSBhdCAoMTgs MCkgc2l6ZSA3OXgxOAorICAgICAgICAgICAgdGV4dCBydW4gYXQgKDE4LDApIHdpZHRoIDc5OiAi IHRoZVJhZGlvWzBdIgorICAgICAgICAgIFJlbmRlckJSIHtCUn0gYXQgKDk3LDE0KSBzaXplIDB4 MAorICAgICAgICAgIFJlbmRlckJsb2NrIHtJTlBVVH0gYXQgKDMsMjIpIHNpemUgMTJ4MTMKKyAg ICAgICAgICBSZW5kZXJUZXh0IHsjdGV4dH0gYXQgKDE4LDE5KSBzaXplIDc5eDE4CisgICAgICAg ICAgICB0ZXh0IHJ1biBhdCAoMTgsMTkpIHdpZHRoIDc5OiAiIHRoZVJhZGlvWzFdIgorICAgICAg UmVuZGVyQmxvY2sge0hSfSBhdCAoMCwxMjIpIHNpemUgNzg0eDIgW2JvcmRlcjogKDFweCBpbnNl dCAjMDAwMDAwKV0KKyAgICAgIFJlbmRlckJsb2NrIHtESVZ9IGF0ICgwLDEzMikgc2l6ZSA3ODR4 NzUKKyAgICAgICAgUmVuZGVyQmxvY2sge0RJVn0gYXQgKDAsMCkgc2l6ZSA3ODR4MTUgW2NvbG9y PSMwMDgwMDBdCisgICAgICAgICAgUmVuZGVyVGV4dCB7I3RleHR9IGF0ICgwLDApIHNpemUgNjR4 MTUKKyAgICAgICAgICAgIHRleHQgcnVuIGF0ICgwLDApIHdpZHRoIDY0OiAiUEFTUzogPT0iCisg ICAgICAgIFJlbmRlckJsb2NrIHtESVZ9IGF0ICgwLDE1KSBzaXplIDc4NHgxNSBbY29sb3I9IzAw ODAwMF0KKyAgICAgICAgICBSZW5kZXJUZXh0IHsjdGV4dH0gYXQgKDAsMCkgc2l6ZSA3MngxNQor ICAgICAgICAgICAgdGV4dCBydW4gYXQgKDAsMCkgd2lkdGggNzI6ICJQQVNTOiA9PT0iCisgICAg ICAgIFJlbmRlckJsb2NrIHtESVZ9IGF0ICgwLDMwKSBzaXplIDc4NHgxNSBbY29sb3I9IzAwODAw MF0KKyAgICAgICAgICBSZW5kZXJUZXh0IHsjdGV4dH0gYXQgKDAsMCkgc2l6ZSA2NHgxNQorICAg ICAgICAgICAgdGV4dCBydW4gYXQgKDAsMCkgd2lkdGggNjQ6ICJQQVNTOiAhPSIKKyAgICAgICAg UmVuZGVyQmxvY2sge0RJVn0gYXQgKDAsNDUpIHNpemUgNzg0eDE1IFtjb2xvcj0jMDA4MDAwXQor ICAgICAgICAgIFJlbmRlclRleHQgeyN0ZXh0fSBhdCAoMCwwKSBzaXplIDEyMHgxNQorICAgICAg ICAgICAgdGV4dCBydW4gYXQgKDAsMCkgd2lkdGggMTIwOiAiUEFTUzogPT0gdy8gdmFyIgorICAg ICAgICBSZW5kZXJCbG9jayB7RElWfSBhdCAoMCw2MCkgc2l6ZSA3ODR4MTUgW2NvbG9yPSMwMDgw MDBdCisgICAgICAgICAgUmVuZGVyVGV4dCB7I3RleHR9IGF0ICgwLDApIHNpemUgMTEyeDE1Cisg ICAgICAgICAgICB0ZXh0IHJ1biBhdCAoMCwwKSB3aWR0aCAxMTI6ICJQQVNTOiA9PSBtaXhlZCIK SW5kZXg6IExheW91dFRlc3RzL2Zhc3QvZm9ybXMvZm9ybS1jb2xsZWN0aW9uLWNvbXAuaHRtbAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL2Zvcm0tY29sbGVjdGlvbi1jb21w Lmh0bWwJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL2Zvcm0tY29sbGVj dGlvbi1jb21wLmh0bWwJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNTkgQEAKKzxodG1sPgorPGhl YWQ+Cis8dGl0bGU+Rm9ybSBDb21wYXJpc29uIHRlc3Q8L3RpdGxlPgorPHNjcmlwdD4KK2Z1bmN0 aW9uIHByaW50KG1lc3NhZ2UsIGNvbG9yKSAKK3sKKyAgICB2YXIgcGFyYWdyYXBoID0gZG9jdW1l bnQuY3JlYXRlRWxlbWVudCgiZGl2Iik7CisgICAgcGFyYWdyYXBoLmFwcGVuZENoaWxkKGRvY3Vt ZW50LmNyZWF0ZVRleHROb2RlKG1lc3NhZ2UpKTsKKyAgICBwYXJhZ3JhcGguc3R5bGUuZm9udEZh bWlseSA9ICJtb25vc3BhY2UiOworICAgIGlmIChjb2xvcikKKyAgICAgICAgcGFyYWdyYXBoLnN0 eWxlLmNvbG9yID0gY29sb3I7CisgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImNvbnNvbGUi KS5hcHBlbmRDaGlsZChwYXJhZ3JhcGgpOworfQorCitmdW5jdGlvbiB0ZXN0KCkKK3sKKyAgICB2 YXIgbXlSYWRpbyA9IGRvY3VtZW50LnRoZUZvcm0udGhlUmFkaW87CisgICAgCisgICAgaWYgKGRv Y3VtZW50LnRoZUZvcm0udGhlUmFkaW8gPT0gZG9jdW1lbnQudGhlRm9ybS50aGVSYWRpbykKKyAg ICAgICAgcHJpbnQoIlBBU1M6ID09IiwgImdyZWVuIik7CisgICAgZWxzZQorICAgICAgICBwcmlu dCgiRkFJTDogPT0iLCAicmVkIik7CisgICAgCisgICAgaWYgKGRvY3VtZW50LnRoZUZvcm0udGhl UmFkaW8gPT09IGRvY3VtZW50LnRoZUZvcm0udGhlUmFkaW8pCisgICAgICAgIHByaW50KCJQQVNT OiA9PT0iLCAiZ3JlZW4iKTsKKyAgICBlbHNlCisgICAgICAgIHByaW50KCJGQUlMOiA9PT0iLCAi cmVkIik7CisgICAgICAgIAorICAgIGlmIChkb2N1bWVudC50aGVGb3JtLnRoZVJhZGlvICE9IGRv Y3VtZW50LnRoZUZvcm0udGhlUmFkaW8pCisgICAgICAgIHByaW50KCJGQUlMOiAhPSIsICJyZWQi KTsKKyAgICBlbHNlCisgICAgICAgIHByaW50KCJQQVNTOiAhPSIsICJncmVlbiIpOworICAgIAor ICAgIGlmIChteVJhZGlvID09IG15UmFkaW8pCisgICAgICAgIHByaW50KCJQQVNTOiA9PSB3LyB2 YXIiLCAiZ3JlZW4iKTsKKyAgICBlbHNlCisgICAgICAgIHByaW50KCJGQUlMOiA9PSB3LyB2YXIi LCAicmVkIik7CisgICAgICAgIAorICAgIGlmIChteVJhZGlvID09IGRvY3VtZW50LnRoZUZvcm0u dGhlUmFkaW8pCisgICAgICAgIHByaW50KCJQQVNTOiA9PSBtaXhlZCIsICJncmVlbiIpOworICAg IGVsc2UKKyAgICAgICAgcHJpbnQoIkZBSUw6ID09IG1peGVkIiwgInJlZCIpOworfQorPC9zY3Jp cHQ+Cis8L2hlYWQ+CisKKzxib2R5IHN0eWxlPSJjb2xvcjogYmxhY2siIG9ubG9hZD0idGVzdCgp Ij4KKzxwPlRoaXMgcGFnZSB0ZXN0cyB0byBzZWUgdGhhdCB0aGUgc2VsZi1jb21wYXJpc29uIG9m IGZvcm0gZWxlbWVudCBncm91cHMgZ2l2ZXMgdGhlIGV4cGVjdGVkIHJlc3VsdHMuPC9wPgorPHA+ SWYgdGhlIHRlc3QgcGFzc2VzLCB5b3UnbGwgc2VlIGZpdmUgJ1BBU1MnIG1lc3NhZ2VzIGJlbG93 IHRoZSBoci48L3A+Cis8Zm9ybSBuYW1lPSd0aGVGb3JtJz4KKzxwPjxpbnB1dCB0eXBlPSdyYWRp bycgbmFtZT0ndGhlUmFkaW8nIHZhbHVlPScwJyAvPiB0aGVSYWRpb1swXTxiciAvPgorPGlucHV0 IHR5cGU9J3JhZGlvJyBuYW1lPSd0aGVSYWRpbycgdmFsdWU9JzEnIC8+IHRoZVJhZGlvWzFdPC9w PgorPC9mb3JtPgorPGhyPgorCis8ZGl2IGlkPSdjb25zb2xlJz48L2Rpdj4KKworPC9ib2R5Pgor PC9odG1sPgpJbmRleDogV2ViQ29yZS9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9D aGFuZ2VMb2cJKHJldmlzaW9uIDE5MjUwKQorKysgV2ViQ29yZS9DaGFuZ2VMb2cJKHdvcmtpbmcg Y29weSkKQEAgLTEsMyArMSwyMiBAQAorMjAwNy0wMS0zMCAgU2FuamF5IE1hZGhhdiAgPHNhbmph eTEyQGdtYWlsLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBGaXggZm9yOiBodHRwOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD05 NTA4IEpTIGZvcm0gZ3JvdXAgY29tcGFyaXNvbgorCisgICAgICAgICogYmluZGluZ3MvanMva2pz X2RvbS5jcHA6CisgICAgICAgICogYmluZGluZ3MvanMva2pzX2RvbS5oOgorICAgICAgICAqIGJp bmRpbmdzL2pzL2tqc19odG1sLmNwcDoKKyAgICAgICAgKEtKUzo6RE9NTmFtZWROb2Rlc0NvbGxl Y3Rpb246OmNsYXNzSW5mbyk6CisgICAgICAgIChLSlM6OmdldE5hbWVkTm9kZXNDYWNoZSk6Cisg ICAgICAgIChLSlM6OkpTSFRNTENvbGxlY3Rpb246OmdldE5hbWVkSXRlbXMpOgorICAgICAgICAo S0pTOjopOgorICAgICAgICAoS0pTOjpET01OYW1lZE5vZGVzQ29sbGVjdGlvbjo6RE9NTmFtZWRO b2Rlc0NvbGxlY3Rpb24pOgorICAgICAgICAoS0pTOjpET01OYW1lZE5vZGVzQ29sbGVjdGlvbjo6 fkRPTU5hbWVkTm9kZXNDb2xsZWN0aW9uKToKKyAgICAgICAgKEtKUzo6RE9NTmFtZWROb2Rlc0Nv bGxlY3Rpb246Omxlbmd0aEdldHRlcik6CisgICAgICAgIChLSlM6OkRPTU5hbWVkTm9kZXNDb2xs ZWN0aW9uOjppbmRleEdldHRlcik6CisgICAgICAgIChLSlM6OkRPTU5hbWVkTm9kZXNDb2xsZWN0 aW9uOjpnZXRPd25Qcm9wZXJ0eVNsb3QpOgorCiAyMDA3LTAxLTMwICBaYWNrIFJ1c2luICA8emFj a0BrZGUub3JnPgogCiAgICAgICAgIFRoZSBtZXRob2QgaGFzIGJlZW4gcmVtb3ZlZCBmcm9tIHRo ZSBoZWFkZXIKSW5kZXg6IFdlYkNvcmUvYmluZGluZ3MvanMva2pzX2RvbS5jcHAKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gV2ViQ29yZS9iaW5kaW5ncy9qcy9ranNfZG9tLmNwcAkocmV2aXNpb24gMTkyNDcpCisr KyBXZWJDb3JlL2JpbmRpbmdzL2pzL2tqc19kb20uY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xMTE3 LDU5ICsxMTE3LDQgQEAgSlNPYmplY3QqIGdldERPTUV4Y2VwdGlvbkNvbnN0cnVjdG9yKEV4ZQog ICByZXR1cm4gY2FjaGVHbG9iYWxPYmplY3Q8RE9NRXhjZXB0aW9uQ29uc3RydWN0b3I+KGV4ZWMs ICJbW0RPTUV4Y2VwdGlvbi5jb25zdHJ1Y3Rvcl1dIik7CiB9CiAKLS8vIC0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0KLQotY29uc3QgQ2xhc3NJbmZvIERPTU5hbWVkTm9kZXNDb2xsZWN0aW9uOjppbmZvID0geyAi Q29sbGVjdGlvbiIsIDAsIDAsIDAgfTsKLQotLy8gU3VjaCBhIGNvbGxlY3Rpb24gaXMgdXN1YWxs eSB2ZXJ5IHNob3J0LWxpdmVkLCBpdCBvbmx5IGV4aXN0cwotLy8gZm9yIGNvbnN0cnVjdHMgbGlr ZSBkb2N1bWVudC5mb3Jtcy48bmFtZT5bMV0sCi0vLyBzbyBpdCBzaG91bGRuJ3QgYmUgYSBwcm9i bGVtIHRoYXQgaXQncyBzdG9yaW5nIGFsbCB0aGUgbm9kZXMgKHdpdGggdGhlIHNhbWUgbmFtZSku IChEYXZpZCkKLURPTU5hbWVkTm9kZXNDb2xsZWN0aW9uOjpET01OYW1lZE5vZGVzQ29sbGVjdGlv bihFeGVjU3RhdGUqIGV4ZWMsIGNvbnN0IFZlY3RvcjxSZWZQdHI8Tm9kZT4gPiYgbm9kZXMpCi0g IDogbV9ub2Rlcyhub2RlcykKLXsKLSAgICBzZXRQcm90b3R5cGUoZXhlYy0+bGV4aWNhbEludGVy cHJldGVyKCktPmJ1aWx0aW5PYmplY3RQcm90b3R5cGUoKSk7Ci19Ci0KLUpTVmFsdWUqIERPTU5h bWVkTm9kZXNDb2xsZWN0aW9uOjpsZW5ndGhHZXR0ZXIoRXhlY1N0YXRlKiBleGVjLCBKU09iamVj dCogb3JpZ2luYWxPYmplY3QsIGNvbnN0IElkZW50aWZpZXImIHByb3BlcnR5TmFtZSwgY29uc3Qg UHJvcGVydHlTbG90JiBzbG90KQotewotICBET01OYW1lZE5vZGVzQ29sbGVjdGlvbiAqdGhpc09i aiA9IHN0YXRpY19jYXN0PERPTU5hbWVkTm9kZXNDb2xsZWN0aW9uKj4oc2xvdC5zbG90QmFzZSgp KTsKLSAgcmV0dXJuIGpzTnVtYmVyKHRoaXNPYmotPm1fbm9kZXMuc2l6ZSgpKTsKLX0KLQotSlNW YWx1ZSogRE9NTmFtZWROb2Rlc0NvbGxlY3Rpb246OmluZGV4R2V0dGVyKEV4ZWNTdGF0ZSogZXhl YywgSlNPYmplY3QqIG9yaWdpbmFsT2JqZWN0LCBjb25zdCBJZGVudGlmaWVyJiBwcm9wZXJ0eU5h bWUsIGNvbnN0IFByb3BlcnR5U2xvdCYgc2xvdCkKLXsKLSAgRE9NTmFtZWROb2Rlc0NvbGxlY3Rp b24gKnRoaXNPYmogPSBzdGF0aWNfY2FzdDxET01OYW1lZE5vZGVzQ29sbGVjdGlvbio+KHNsb3Qu c2xvdEJhc2UoKSk7Ci0gIHJldHVybiB0b0pTKGV4ZWMsIHRoaXNPYmotPm1fbm9kZXNbc2xvdC5p bmRleCgpXS5nZXQoKSk7Ci19Ci0KLWJvb2wgRE9NTmFtZWROb2Rlc0NvbGxlY3Rpb246OmdldE93 blByb3BlcnR5U2xvdChFeGVjU3RhdGUqIGV4ZWMsIGNvbnN0IElkZW50aWZpZXImIHByb3BlcnR5 TmFtZSwgUHJvcGVydHlTbG90JiBzbG90KQotewotICBpZiAocHJvcGVydHlOYW1lID09IGxlbmd0 aFByb3BlcnR5TmFtZSkgewotICAgIHNsb3Quc2V0Q3VzdG9tKHRoaXMsIGxlbmd0aEdldHRlcik7 Ci0gICAgcmV0dXJuIHRydWU7Ci0gIH0KLQotICAvLyBhcnJheSBpbmRleCA/Ci0gIGJvb2wgb2s7 Ci0gIHVuc2lnbmVkIGlkeCA9IHByb3BlcnR5TmFtZS50b1VJbnQzMigmb2spOwotICBpZiAob2sg JiYgaWR4IDwgbV9ub2Rlcy5zaXplKCkpIHsKLSAgICBzbG90LnNldEN1c3RvbUluZGV4KHRoaXMs IGlkeCwgaW5kZXhHZXR0ZXIpOwotICAgIHJldHVybiB0cnVlOwotICB9Ci0KLSAgLy8gRm9yIElF IGNvbXBhdGliaWxpdHksIHdlIG5lZWQgdG8gYmUgYWJsZSB0byBsb29rIHVwIGVsZW1lbnRzIGlu IGEKLSAgLy8gZG9jdW1lbnQuZm9ybU5hbWUubmFtZSByZXN1bHQgYnkgaWQgYXMgd2VsbCBhcyBi ZSBpbmRleC4KLQotICBBdG9taWNTdHJpbmcgYXRvbWljUHJvcGVydHlOYW1lID0gcHJvcGVydHlO YW1lOwotICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgbV9ub2Rlcy5zaXplKCk7IGkrKykgewot ICAgIE5vZGUqIG5vZGUgPSBtX25vZGVzW2ldLmdldCgpOwotICAgIGlmIChub2RlLT5oYXNBdHRy aWJ1dGVzKCkgJiYgbm9kZS0+YXR0cmlidXRlcygpLT5pZCgpID09IGF0b21pY1Byb3BlcnR5TmFt ZSkgewotICAgICAgc2xvdC5zZXRDdXN0b21JbmRleCh0aGlzLCBpLCBpbmRleEdldHRlcik7Ci0g ICAgICByZXR1cm4gdHJ1ZTsKLSAgICB9Ci0gIH0KLQotICByZXR1cm4gRE9NT2JqZWN0OjpnZXRP d25Qcm9wZXJ0eVNsb3QoZXhlYywgcHJvcGVydHlOYW1lLCBzbG90KTsKLX0KLQogfSAvLyBuYW1l c3BhY2UKSW5kZXg6IFdlYkNvcmUvYmluZGluZ3MvanMva2pzX2RvbS5oCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFdlYkNvcmUvYmluZGluZ3MvanMva2pzX2RvbS5oCShyZXZpc2lvbiAxOTI0NykKKysrIFdlYkNv cmUvYmluZGluZ3MvanMva2pzX2RvbS5oCSh3b3JraW5nIGNvcHkpCkBAIC0xNDIsMjIgKzE0Miw3 IEBAIG5hbWVzcGFjZSBLSlMgewogICBKU1ZhbHVlKiB0b0pTKEV4ZWNTdGF0ZSosIFdlYkNvcmU6 OkV2ZW50VGFyZ2V0Kik7CiAgIEpTT2JqZWN0KiBnZXROb2RlQ29uc3RydWN0b3IoRXhlY1N0YXRl Kik7CiAgIEpTT2JqZWN0KiBnZXRET01FeGNlcHRpb25Db25zdHJ1Y3RvcihFeGVjU3RhdGUqKTsK LQotICAvLyBJbnRlcm5hbCBjbGFzcywgdXNlZCBmb3IgdGhlIGNvbGxlY3Rpb24gcmV0dXJuIGJ5 IGUuZy4gZG9jdW1lbnQuZm9ybXMubXlpbnB1dAotICAvLyB3aGVuIG11bHRpcGxlIG5vZGVzIGhh dmUgdGhlIHNhbWUgbmFtZS4KLSAgY2xhc3MgRE9NTmFtZWROb2Rlc0NvbGxlY3Rpb24gOiBwdWJs aWMgRE9NT2JqZWN0IHsKLSAgcHVibGljOgotICAgIERPTU5hbWVkTm9kZXNDb2xsZWN0aW9uKEV4 ZWNTdGF0ZSAqZXhlYywgY29uc3QgVmVjdG9yPFJlZlB0cjxXZWJDb3JlOjpOb2RlPiA+JiBub2Rl cyk7Ci0gICAgdmlydHVhbCBib29sIGdldE93blByb3BlcnR5U2xvdChFeGVjU3RhdGUgKiwgY29u c3QgSWRlbnRpZmllciYsIFByb3BlcnR5U2xvdCYpOwotICAgIHZpcnR1YWwgY29uc3QgQ2xhc3NJ bmZvKiBjbGFzc0luZm8oKSBjb25zdCB7IHJldHVybiAmaW5mbzsgfQotICAgIHN0YXRpYyBjb25z dCBDbGFzc0luZm8gaW5mbzsKLXByaXZhdGU6Ci0gICAgc3RhdGljIEpTVmFsdWUgKmxlbmd0aEdl dHRlcihFeGVjU3RhdGUqIGV4ZWMsIEpTT2JqZWN0ICosIGNvbnN0IElkZW50aWZpZXImLCBjb25z dCBQcm9wZXJ0eVNsb3QmIHNsb3QpOwotICAgIHN0YXRpYyBKU1ZhbHVlICppbmRleEdldHRlcihF eGVjU3RhdGUqIGV4ZWMsIEpTT2JqZWN0ICosIGNvbnN0IElkZW50aWZpZXImLCBjb25zdCBQcm9w ZXJ0eVNsb3QmIHNsb3QpOwotCi0gICAgVmVjdG9yPFJlZlB0cjxXZWJDb3JlOjpOb2RlPiA+IG1f bm9kZXM7Ci0gIH07Ci0KKyAgCiB9IC8vIG5hbWVzcGFjZQogCiAjZW5kaWYKSW5kZXg6IFdlYkNv cmUvYmluZGluZ3MvanMva2pzX2h0bWwuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvYmluZGlu Z3MvanMva2pzX2h0bWwuY3BwCShyZXZpc2lvbiAxOTI0NykKKysrIFdlYkNvcmUvYmluZGluZ3Mv anMva2pzX2h0bWwuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC01NSw2ICs1NSw3IEBACiAjaW5jbHVk ZSAia2pzX2V2ZW50cy5oIgogI2luY2x1ZGUgImtqc19wcm94eS5oIgogI2luY2x1ZGUgImtqc193 aW5kb3cuaCIKKyNpbmNsdWRlICJTdHJpbmdIYXNoLmgiCiAjaW5jbHVkZSA8bWF0aC5oPgogCiAj aWZkZWYgU1ZHX1NVUFBPUlQKQEAgLTc3LDYgKzc4LDMxIEBAIHByaXZhdGU6CiAgIGludCBpZDsK IH07CiAKKy8vIEludGVybmFsIGNsYXNzLCB1c2VkIGZvciB0aGUgY29sbGVjdGlvbiByZXR1cm4g YnkgZS5nLiBkb2N1bWVudC5mb3Jtcy5teWlucHV0CisvLyB3aGVuIG11bHRpcGxlIG5vZGVzIGhh dmUgdGhlIHNhbWUgbmFtZS4KK2NsYXNzIERPTU5hbWVkTm9kZXNDb2xsZWN0aW9uIDogcHVibGlj IERPTU9iamVjdCB7CitwdWJsaWM6CisgICAgRE9NTmFtZWROb2Rlc0NvbGxlY3Rpb24oRXhlY1N0 YXRlICpleGVjLCBjb25zdCBWZWN0b3I8UmVmUHRyPE5vZGU+ID4mIG5vZGVzLCBjb25zdCBBdG9t aWNTdHJpbmcmIG5hbWUpOworICAgIH5ET01OYW1lZE5vZGVzQ29sbGVjdGlvbigpOworICAgIHZp cnR1YWwgYm9vbCBnZXRPd25Qcm9wZXJ0eVNsb3QoRXhlY1N0YXRlICosIGNvbnN0IElkZW50aWZp ZXImLCBQcm9wZXJ0eVNsb3QmKTsKKyAgICB2aXJ0dWFsIGNvbnN0IENsYXNzSW5mbyogY2xhc3NJ bmZvKCkgY29uc3QgeyByZXR1cm4gJmluZm87IH0KKyAgICBzdGF0aWMgY29uc3QgQ2xhc3NJbmZv IGluZm87Citwcml2YXRlOgorICAgIHN0YXRpYyBKU1ZhbHVlICpsZW5ndGhHZXR0ZXIoRXhlY1N0 YXRlKiBleGVjLCBKU09iamVjdCAqLCBjb25zdCBJZGVudGlmaWVyJiwgY29uc3QgUHJvcGVydHlT bG90JiBzbG90KTsKKyAgICBzdGF0aWMgSlNWYWx1ZSAqaW5kZXhHZXR0ZXIoRXhlY1N0YXRlKiBl eGVjLCBKU09iamVjdCAqLCBjb25zdCBJZGVudGlmaWVyJiwgY29uc3QgUHJvcGVydHlTbG90JiBz bG90KTsKKworICAgIFZlY3RvcjxSZWZQdHI8V2ViQ29yZTo6Tm9kZT4gPiBtX25vZGVzOworICAg IEF0b21pY1N0cmluZyBwcm9wZXJ0eU5hbWU7Cit9OworCit0eXBlZGVmIEhhc2hNYXA8U3RyaW5n SW1wbCosRE9NTmFtZWROb2Rlc0NvbGxlY3Rpb24qPiBOYW1lZE5vZGVzQ2FjaGU7CisKK05hbWVk Tm9kZXNDYWNoZSYgZ2V0TmFtZWROb2Rlc0NhY2hlKCkKK3sKKyAgICBzdGF0aWMgTmFtZWROb2Rl c0NhY2hlIHN0YXRpY05hbWVkTm9kZXNDYWNoZTsKKyAgICByZXR1cm4gc3RhdGljTmFtZWROb2Rl c0NhY2hlOworfQorCiAvKiAKIEBiZWdpbiBKU0hUTUxEb2N1bWVudFByb3RvdHlwZVRhYmxlIDgK IGNsZWFyICAgICAgICAgICAgICAgICBKU0hUTUxEb2N1bWVudDo6Q2xlYXIgICAgICAgICAgICAg RG9udERlbGV0ZXxGdW5jdGlvbiAwCkBAIC0xNTQ1LDcgKzE1NzEsMjIgQEAgSlNWYWx1ZSAqSlNI VE1MQ29sbGVjdGlvbjo6Z2V0TmFtZWRJdGVtcwogICAgIGlmIChuYW1lZEl0ZW1zLnNpemUoKSA9 PSAxKQogICAgICAgICByZXR1cm4gdG9KUyhleGVjLCBuYW1lZEl0ZW1zWzBdLmdldCgpKTsKIAot ICAgIHJldHVybiBuZXcgRE9NTmFtZWROb2Rlc0NvbGxlY3Rpb24oZXhlYywgbmFtZWRJdGVtcyk7 CisgICAgLy8gTWFuZ2xlIHRoZSBpZGVudGlmaWVyIHN0cmluZyB3aXRoIHRoZSBub2RlIHBvaW50 ZXIgdG8gdGhlIGZpcnN0IGVsZW1lbnQuCisgICAgLy8gVGhpcyB3YXksIHdlIG1ha2Ugc3VyZSB0 aGUgc2FtZSBpZGVudGlmaWVyIG9uIG11bHRpcGxlIHBhZ2VzIChvciBmb3JtcykKKyAgICAvLyBk byBub3QgY2F1c2UgYSBjbGFzaC4KKyAgICBTdHJpbmcgdGVtcFN0cmluZyhwcm9wZXJ0eU5hbWUp OworICAgIGNoYXIgcHRyQnVmZmVyWzE1XTsKKyAgICBzbnByaW50ZihwdHJCdWZmZXIsIDE1LCAi JXAiLCBuYW1lZEl0ZW1zWzBdLmdldCgpKTsKKyAgICB0ZW1wU3RyaW5nID0gdGVtcFN0cmluZyAr IHB0ckJ1ZmZlcjsKKyAgICAKKyAgICBOYW1lZE5vZGVzQ2FjaGU6Oml0ZXJhdG9yIGl0ZXIgPSBn ZXROYW1lZE5vZGVzQ2FjaGUoKS5maW5kKHRlbXBTdHJpbmcuaW1wbCgpKTsKKyAgICBpZiAoaXRl ciA9PSBnZXROYW1lZE5vZGVzQ2FjaGUoKS5lbmQoKSkgeworICAgICAgICBET01OYW1lZE5vZGVz Q29sbGVjdGlvbiogbm9kZUNvbGxlY3Rpb24gPSBuZXcgRE9NTmFtZWROb2Rlc0NvbGxlY3Rpb24o ZXhlYywgbmFtZWRJdGVtcywgdGVtcFN0cmluZyk7CisgICAgICAgIGdldE5hbWVkTm9kZXNDYWNo ZSgpLmFkZCh0ZW1wU3RyaW5nLmltcGwoKSwgbm9kZUNvbGxlY3Rpb24pOworICAgICAgICByZXR1 cm4gbm9kZUNvbGxlY3Rpb247CisgICAgfQorICAgIAorICAgIHJldHVybiBpdGVyLT5zZWNvbmQ7 CiB9CiAKIEpTVmFsdWUqIEpTSFRNTENvbGxlY3Rpb25Qcm90b3R5cGVGdW5jdGlvbjo6Y2FsbEFz RnVuY3Rpb24oRXhlY1N0YXRlKiBleGVjLCBKU09iamVjdCogdGhpc09iaiwgY29uc3QgTGlzdCAm YXJncykKQEAgLTE1NzIsNiArMTYxMyw2NyBAQCBKU1ZhbHVlKiBKU0hUTUxDb2xsZWN0aW9uUHJv dG90eXBlRnVuY3RpCiAgIH0KIH0KIAorLy8gLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorCitjb25zdCBDbGFz c0luZm8gRE9NTmFtZWROb2Rlc0NvbGxlY3Rpb246OmluZm8gPSB7ICJDb2xsZWN0aW9uIiwgMCwg MCwgMCB9OworCisvLyBTdWNoIGEgY29sbGVjdGlvbiBpcyB1c3VhbGx5IHZlcnkgc2hvcnQtbGl2 ZWQsIGl0IG9ubHkgZXhpc3RzCisvLyBmb3IgY29uc3RydWN0cyBsaWtlIGRvY3VtZW50LmZvcm1z LjxuYW1lPlsxXSwKKy8vIHNvIGl0IHNob3VsZG4ndCBiZSBhIHByb2JsZW0gdGhhdCBpdCdzIHN0 b3JpbmcgYWxsIHRoZSBub2RlcyAod2l0aCB0aGUgc2FtZSBuYW1lKS4gKERhdmlkKQorRE9NTmFt ZWROb2Rlc0NvbGxlY3Rpb246OkRPTU5hbWVkTm9kZXNDb2xsZWN0aW9uKEV4ZWNTdGF0ZSogZXhl YywgY29uc3QgVmVjdG9yPFJlZlB0cjxOb2RlPiA+JiBub2RlcywgY29uc3QgQXRvbWljU3RyaW5n JiBuYW1lKQorICA6IG1fbm9kZXMobm9kZXMpLAorICAgIHByb3BlcnR5TmFtZShuYW1lKQorewor ICAgIHNldFByb3RvdHlwZShleGVjLT5sZXhpY2FsSW50ZXJwcmV0ZXIoKS0+YnVpbHRpbk9iamVj dFByb3RvdHlwZSgpKTsKK30KKworRE9NTmFtZWROb2Rlc0NvbGxlY3Rpb246On5ET01OYW1lZE5v ZGVzQ29sbGVjdGlvbigpCit7CisgICAgZ2V0TmFtZWROb2Rlc0NhY2hlKCkucmVtb3ZlKHByb3Bl cnR5TmFtZS5pbXBsKCkpOworfQorCitKU1ZhbHVlKiBET01OYW1lZE5vZGVzQ29sbGVjdGlvbjo6 bGVuZ3RoR2V0dGVyKEV4ZWNTdGF0ZSogZXhlYywgSlNPYmplY3QqIG9yaWdpbmFsT2JqZWN0LCBj b25zdCBJZGVudGlmaWVyJiBwcm9wZXJ0eU5hbWUsIGNvbnN0IFByb3BlcnR5U2xvdCYgc2xvdCkK K3sKKyAgRE9NTmFtZWROb2Rlc0NvbGxlY3Rpb24gKnRoaXNPYmogPSBzdGF0aWNfY2FzdDxET01O YW1lZE5vZGVzQ29sbGVjdGlvbio+KHNsb3Quc2xvdEJhc2UoKSk7CisgIHJldHVybiBqc051bWJl cih0aGlzT2JqLT5tX25vZGVzLnNpemUoKSk7Cit9CisKK0pTVmFsdWUqIERPTU5hbWVkTm9kZXND b2xsZWN0aW9uOjppbmRleEdldHRlcihFeGVjU3RhdGUqIGV4ZWMsIEpTT2JqZWN0KiBvcmlnaW5h bE9iamVjdCwgY29uc3QgSWRlbnRpZmllciYgcHJvcGVydHlOYW1lLCBjb25zdCBQcm9wZXJ0eVNs b3QmIHNsb3QpCit7CisgIERPTU5hbWVkTm9kZXNDb2xsZWN0aW9uICp0aGlzT2JqID0gc3RhdGlj X2Nhc3Q8RE9NTmFtZWROb2Rlc0NvbGxlY3Rpb24qPihzbG90LnNsb3RCYXNlKCkpOworICByZXR1 cm4gdG9KUyhleGVjLCB0aGlzT2JqLT5tX25vZGVzW3Nsb3QuaW5kZXgoKV0uZ2V0KCkpOworfQor Citib29sIERPTU5hbWVkTm9kZXNDb2xsZWN0aW9uOjpnZXRPd25Qcm9wZXJ0eVNsb3QoRXhlY1N0 YXRlKiBleGVjLCBjb25zdCBJZGVudGlmaWVyJiBwcm9wZXJ0eU5hbWUsIFByb3BlcnR5U2xvdCYg c2xvdCkKK3sKKyAgaWYgKHByb3BlcnR5TmFtZSA9PSBsZW5ndGhQcm9wZXJ0eU5hbWUpIHsKKyAg ICBzbG90LnNldEN1c3RvbSh0aGlzLCBsZW5ndGhHZXR0ZXIpOworICAgIHJldHVybiB0cnVlOwor ICB9CisKKyAgLy8gYXJyYXkgaW5kZXggPworICBib29sIG9rOworICB1bnNpZ25lZCBpZHggPSBw cm9wZXJ0eU5hbWUudG9VSW50MzIoJm9rKTsKKyAgaWYgKG9rICYmIGlkeCA8IG1fbm9kZXMuc2l6 ZSgpKSB7CisgICAgc2xvdC5zZXRDdXN0b21JbmRleCh0aGlzLCBpZHgsIGluZGV4R2V0dGVyKTsK KyAgICByZXR1cm4gdHJ1ZTsKKyAgfQorCisgIC8vIEZvciBJRSBjb21wYXRpYmlsaXR5LCB3ZSBu ZWVkIHRvIGJlIGFibGUgdG8gbG9vayB1cCBlbGVtZW50cyBpbiBhCisgIC8vIGRvY3VtZW50LmZv cm1OYW1lLm5hbWUgcmVzdWx0IGJ5IGlkIGFzIHdlbGwgYXMgYmUgaW5kZXguCisKKyAgQXRvbWlj U3RyaW5nIGF0b21pY1Byb3BlcnR5TmFtZSA9IHByb3BlcnR5TmFtZTsKKyAgZm9yICh1bnNpZ25l ZCBpID0gMDsgaSA8IG1fbm9kZXMuc2l6ZSgpOyBpKyspIHsKKyAgICBOb2RlKiBub2RlID0gbV9u b2Rlc1tpXS5nZXQoKTsKKyAgICBpZiAobm9kZS0+aGFzQXR0cmlidXRlcygpICYmIG5vZGUtPmF0 dHJpYnV0ZXMoKS0+aWQoKSA9PSBhdG9taWNQcm9wZXJ0eU5hbWUpIHsKKyAgICAgIHNsb3Quc2V0 Q3VzdG9tSW5kZXgodGhpcywgaSwgaW5kZXhHZXR0ZXIpOworICAgICAgcmV0dXJuIHRydWU7Cisg ICAgfQorICB9CisKKyAgcmV0dXJuIERPTU9iamVjdDo6Z2V0T3duUHJvcGVydHlTbG90KGV4ZWMs IHByb3BlcnR5TmFtZSwgc2xvdCk7Cit9CisKIC8vLy8vLy8vLy8vLy8vLy8vLy8vLy8gSW1hZ2Ug T2JqZWN0IC8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLwogCiBJbWFnZUNvbnN0cnVjdG9ySW1wOjpJ bWFnZUNvbnN0cnVjdG9ySW1wKEV4ZWNTdGF0ZSogZXhlYywgRG9jdW1lbnQqIGQpCg==