34679 2010-02-06 04:42:08 -0800 Location and other objects are dysfunctional after a document gets restored from b/f cache 2012-08-16 09:34:41 -0700 1 1 1 Unclassified WebKit Page Loading 528+ (Nightly build) All All RESOLVED FIXED http://benalman.com/code/projects/jquery-hashchange/examples/bug-safari-back-from-diff-domain/ InRadar P2 Normal --- 80903 1 cowboy beidson abarth ap beidson dglazkov gojpeg htengelin japhet kangax mathias michaeln rob ryan sam webkit.review.bot oldest_to_newest 188426 0 cowboy 2010-02-06 04:42:08 -0800 This is somewhat hard to describe... but at least it's reproducible: http://benalman.com/code/projects/jquery-hashchange/examples/bug-safari-back-from-diff-domain/ The gist is, when you navigate to a different domain, and press the back button, accessing 'loc.href' from reference 'var loc = window.location' is sometimes broken. I don't know if this is a "location" thing or a general "reference" thing, but it's totally broken here. I have confirmed this behavior on machines other than mine, and in both Safari 4.0.4 and WebKit nightly r54415. The following is explained at the example page, but I will include it here for posterity. This is the problematic code: (function(window){ // A convenient shortcut. var win_loc = window.location, loc = location, state; (function loopy(){ console.log([ 'win_loc.href: ' + typeof win_loc.href, 'loc.href: ' + typeof loc.href, 'location.href: ' + typeof location.href, 'window.location.href: ' + typeof window.location.href ].join(', ')); timeout_id = setTimeout( loopy, 1000 ); })(); })(this); When you initially navigate to the page, this is logged: win_loc.href: string, loc.href: string, location.href: string, window.location.href: string After visiting another domain, and pressing the back button, this is logged: win_loc.href: undefined, loc.href: undefined, location.href: string, window.location.href: string So, there you go. 188492 1 ap 2010-02-06 23:32:23 -0800 We call Location::disconnectFrame() when a document goes to b/f cache, but we never reconnect the frame when it's restored. This is an issue for many objects - one can easily find a list in DOMWindow::clear(), since that's where we call their disconnectFrame() methods. 217279 2 sam 2010-04-26 14:24:56 -0700 <rdar://problem/7908830> 355682 3 ap 2011-02-22 16:20:46 -0800 *** Bug 54960 has been marked as a duplicate of this bug. *** 480338 4 abarth 2011-10-07 15:08:47 -0700 Yep. I don't know if we'll be able to solve this problem. 549341 5 125471 rob 2012-02-03 20:13:50 -0800 Created attachment 125471 Example of problem with iframes and iOS 5 b/f cache 549343 6 rob 2012-02-03 20:14:34 -0800 We've been hitting this bug pretty hard in mobile Safari since iOS 5 came out. On iOS 4, we could get around this by preventing b/f cache by adding an empty window 'unload' handler, but in iOS 5 Safari this doesn't seem to prevent a page from loading from b/f cache. Basically, load up the attached index.html (which loads inner.html as an iframe) in iOS 5 Safari. On first load / reload of index.html, you can click send ping to iframe and it will correctly use postMessage to increment the ping's received count inside the iframe. When you click back then fwd and this page loads from the b/f cache in iOS 5, a few bugs occur: (a) the iframe listeners are disconnected so pings don't get received by iframe (b) anything dynamic in the iframe doesn't work solely inside the iframe itself This is a huge issue for mobile advertising or anywhere that uses iframes (or any somewhat complex JS). At the very least, is there a known way in iOS 5 / later Webkit versions to prevent a page from loading in b/f cache to work around this bug? (Again, note an empty window unload handler no longer works as workaround in iOS 5 Safari.) It would be awesome to have iframes, event listeners, JS, etc. work in the b/f cache. 572211 7 htengelin 2012-03-06 15:35:25 -0800 It also seems like event handlers added to window object is lost when returning to page using back button. I have tested with scroll, resize, error, all triggered normally when first navigating to page, but none is triggered after navigating to other page and then returning using back button. There are also numerous reports from iOS 5 users getting an "older version" of the page when using back button. Haven't confirmed it, but i suspect page cache to be involved here as well. 572223 8 beidson 2012-03-06 15:47:07 -0800 (In reply to comment #7) > It also seems like event handlers added to window object is lost when returning to page using back button. > I have tested with scroll, resize, error, all triggered normally when first navigating to page, but none is triggered after navigating to other page and then returning using back button. That's all this same bug. I'm working on this right now, btw (Just assigned the bug to myself) > There are also numerous reports from iOS 5 users getting an "older version" of the page when using back button. Haven't confirmed it, but i suspect page cache to be involved here as well. Nope, not at all the same issue. 574394 9 beidson 2012-03-08 17:00:41 -0800 The recent addition of DOMWindowProperty is quite relevant to fixing this bug. All of the things we want to save and restore are DOMWindowProperties, and all of the things that might prevent page-cacheability are already also ActiveDOMProperties. The first problem that comes up is that we need to keep the objects we wish to save/restore alive in the page cache. Right now all of these objects are RefCounted, but with their own base class as the template specialization. My first task as a refactor will be to flip that around so DOMWindowProperty is RefCounted and all the classes derive from that. 574400 10 abarth 2012-03-08 17:08:35 -0800 > The recent addition of DOMWindowProperty is quite relevant to fixing this bug. All of the things we want to save and restore are DOMWindowProperties, and all of the things that might prevent page-cacheability are already also ActiveDOMProperties. Correct. I've been trying to work towards fixing this bug for a while. :) The idea I had in mind was to create a "reconnectFrame" method to parallel disconnectFrame. > The first problem that comes up is that we need to keep the objects we wish to save/restore alive in the page cache. Right now all of these objects are RefCounted, but with their own base class as the template specialization. > > My first task as a refactor will be to flip that around so DOMWindowProperty is RefCounted and all the classes derive from that. Ok. I think you can solve this problem without going that route, but that's a fine route to go as well. Feel free to grab me on #webkit if you'd like to discuss further. 574411 11 beidson 2012-03-08 17:14:41 -0800 (In reply to comment #10) > > The recent addition of DOMWindowProperty is quite relevant to fixing this bug. All of the things we want to save and restore are DOMWindowProperties, and all of the things that might prevent page-cacheability are already also ActiveDOMProperties. > > Correct. I've been trying to work towards fixing this bug for a while. :) > > The idea I had in mind was to create a "reconnectFrame" method to parallel disconnectFrame. I already have that implemented and stashed away as a proof of concept. Exact same name. ;) > > > The first problem that comes up is that we need to keep the objects we wish to save/restore alive in the page cache. Right now all of these objects are RefCounted, but with their own base class as the template specialization. > > > > My first task as a refactor will be to flip that around so DOMWindowProperty is RefCounted and all the classes derive from that. > > Ok. I think you can solve this problem without going that route, but that's a fine route to go as well. Feel free to grab me on #webkit if you'd like to discuss further. I *could* solve it as-is by having the page cache remember a whole bunch of explicit objects like "Location" and "History" and "Navigator" and "StyleMedia", etc. But I'd really like to get away from the little bit of hell that exists in DOMWindow right now where each of them has to be called out explicitly with a special type of RefPtr. Unfortunately It turns out I was wrong about the at-a-glance assumption that all DOMWindowProperties were already RefCounted - DOMWindowIndexedDatabase.h and NavigatorGeolocation.h are the exceptions. Seems like I have two directions I could go: 1 - Refactor those two classes into being RefCounted, then proceed with my original refactor. 2 - Do something else that you might already have in mind. Thoughts? 574430 12 abarth 2012-03-08 17:38:43 -0800 > I *could* solve it as-is by having the page cache remember a whole bunch of explicit objects like "Location" and "History" and "Navigator" and "StyleMedia", etc. That seems undesirable. > But I'd really like to get away from the little bit of hell that exists in DOMWindow right now where each of them has to be called out explicitly with a special type of RefPtr. Why does the PageCache need to know any of this? We get a new DOMWindow object for each Document, so the DOMWindow can be responsible for dealing with its properties. The PageCache just need to signal the DOMWindow that it's time to reconnect everybody. > Unfortunately It turns out I was wrong about the at-a-glance assumption that all DOMWindowProperties were already RefCounted - DOMWindowIndexedDatabase.h and NavigatorGeolocation.h are the exceptions. I don't think either of these need to be DOMWindowProperties anymore. They can just be FrameDestructionObservers. Notice: NavigatorGeolocation doesn't override disconnectFrame anymore and DOMWindowIndexedDatabase just does so to clear out m_idbFactory. > Seems like I have two directions I could go: > 1 - Refactor those two classes into being RefCounted, then proceed with my original refactor. > 2 - Do something else that you might already have in mind. The approach I had in mind was the following: 1) Add the reconnectFrame method to DOMWindowProperty and implement whatever is necessary in each subclass to actually reconnect to the frame. 2) For each property getter (e.g., DOMWindow::screen), change it to always return 0 when isCurrentlyDisplayedInFrame() is false. 3) In DOMWindow::clear(), stop zeroing out the various RefPtrs in DOMWindow. I think that's all that's needed to fix this bug at this point, but I might be missing something in the details. 574483 13 beidson 2012-03-08 18:56:18 -0800 (In reply to comment #12) > > But I'd really like to get away from the little bit of hell that exists in DOMWindow right now where each of them has to be called out explicitly with a special type of RefPtr. > > Why does the PageCache need to know any of this? We get a new DOMWindow object for each Document, so the DOMWindow can be responsible for dealing with its properties. The PageCache just need to signal the DOMWindow that it's time to reconnect everybody. I misunderstood what role DOMWindow played in the split window model: I thought DOMWindow was the object that was reused. Your response here made me go look much closer and realize that it's not and that I've been leading myself on a wild goose chase. > The approach I had in mind was the following: > > 1) Add the reconnectFrame method to DOMWindowProperty and implement whatever is necessary in each subclass to actually reconnect to the frame. > > 2) For each property getter (e.g., DOMWindow::screen), change it to always return 0 when isCurrentlyDisplayedInFrame() is false. > > 3) In DOMWindow::clear(), stop zeroing out the various RefPtrs in DOMWindow. > > I think that's all that's needed to fix this bug at this point, but I might be missing something in the details. With the realization that DOMWindows aren't reused (my bad) this is quite obviously the way to go. Will plow through that tomorrow. 575034 14 beidson 2012-03-09 11:41:38 -0800 Working on this right now and discovered... (In reply to comment #13) > (In reply to comment #12) > > The approach I had in mind was the following: > > ... > > 2) For each property getter (e.g., DOMWindow::screen), change it to always return 0 when isCurrentlyDisplayedInFrame() is false. > > They all already do the right thing. huzzah! 575111 15 abarth 2012-03-09 12:55:08 -0800 > They all already do the right thing. huzzah! DOMWindow::screen doesn't, for example: http://trac.webkit.org/browser/trunk/Source/WebCore/page/DOMWindow.cpp#L552 If m_screen is already non-0, then it will return the object. Otherwise, it will return 0. That seems undesirable because it leaks the fact that we're creating these objects lazily. 575121 16 beidson 2012-03-09 13:02:10 -0800 (In reply to comment #15) > > They all already do the right thing. huzzah! > > DOMWindow::screen doesn't, for example: > > http://trac.webkit.org/browser/trunk/Source/WebCore/page/DOMWindow.cpp#L552 > > If m_screen is already non-0, then it will return the object. Otherwise, it will return 0. That seems undesirable because it leaks the fact that we're creating these objects lazily. This code? Screen* DOMWindow::screen() const { if (!m_screen && isCurrentlyDisplayedInFrame()) m_screen = Screen::create(m_frame); return m_screen.get(); } "If m_screen is NULL *and* this DOMWindow is currently displayed in frame, then lazily create m_screen" If the DOMWindow is in the page cache, isCurrentlyDisplayedInFrame() will be false, and m_screen's 0-pointer will be returned. 575125 17 beidson 2012-03-09 13:02:57 -0800 (In reply to comment #16) > (In reply to comment #15) > > > They all already do the right thing. huzzah! > > > > DOMWindow::screen doesn't, for example: > > > > http://trac.webkit.org/browser/trunk/Source/WebCore/page/DOMWindow.cpp#L552 > > > > If m_screen is already non-0, then it will return the object. Otherwise, it will return 0. That seems undesirable because it leaks the fact that we're creating these objects lazily. > > This code? > > Screen* DOMWindow::screen() const > { > if (!m_screen && isCurrentlyDisplayedInFrame()) > m_screen = Screen::create(m_frame); > return m_screen.get(); > } > > "If m_screen is NULL *and* this DOMWindow is currently displayed in frame, then lazily create m_screen" > > If the DOMWindow is in the page cache, isCurrentlyDisplayedInFrame() will be false, and m_screen's 0-pointer will be returned. Ignore that! I was completely missing the point. I'm on board now. :) 575150 18 abarth 2012-03-09 13:19:33 -0800 > 3) In DOMWindow::clear(), stop zeroing out the various RefPtrs in DOMWindow. Yeah, step (3) is important because you want window.location === window.location both before and after the page has been in the PageCache. (While the page is in the page cache, it's ok for window.location be null---that's a bug for another day.) 576636 19 beidson 2012-03-12 15:43:37 -0700 Finished up a patch, wrote a thorough layout test, and discovered some crashes when restoring Local/SessionStorage objects. The "Storage" object is a wrapper around a StorageArea. DOMWindow creates its own Storage object wrapping its LocalStorage area, which gets registered as one of its DOMWindowProperties. The WebInspector also creates its own Storage object wrapping the same LocalStorage area which also gets registered as one of the DOMWindow's DOMWindowProperties. Then you leave the page and it is cached, and we disconnect all DOMWindowProperties from the frame. Then the WebInspector's wrapper is cleaned up. In the ::~Storage destructor it can't unregister itself from the DOMWindow since it doesn't have its Frame* any long. Then you go back, and the DOMWindow tries to reconnect this invalid Storage object. I'm working on coming up with a clever solution to this without bloating the DOMWindowProperty mechanism that much. 576645 20 beidson 2012-03-12 15:53:44 -0700 (In reply to comment #19) > Finished up a patch, wrote a thorough layout test, and discovered some crashes when restoring Local/SessionStorage objects. > > The "Storage" object is a wrapper around a StorageArea. > DOMWindow creates its own Storage object wrapping its LocalStorage area, which gets registered as one of its DOMWindowProperties. > The WebInspector also creates its own Storage object wrapping the same LocalStorage area which also gets registered as one of the DOMWindow's DOMWindowProperties. > > Then you leave the page and it is cached, and we disconnect all DOMWindowProperties from the frame. > > Then the WebInspector's wrapper is cleaned up. In the ::~Storage destructor it can't unregister itself from the DOMWindow since it doesn't have its Frame* any long. > > Then you go back, and the DOMWindow tries to reconnect this invalid Storage object. > > I'm working on coming up with a clever solution to this without bloating the DOMWindowProperty mechanism that much. This is unique to the Storage objects, and is because of what the Inspector is doing with them. It seems bizarre that the Inspector needs to create a DOMWindowProperty (Storage object) and can't just use the StorageArea directly. Tim Hatcher agrees. Filing a new bugzilla about that. 576647 21 beidson 2012-03-12 15:56:59 -0700 (In reply to comment #20) > Filing a new bugzilla about that. https://bugs.webkit.org/show_bug.cgi?id=80903 576706 22 beidson 2012-03-12 16:35:27 -0700 Okay, that little hiccup is solved. Polishing off a layout test and patch to come shortly. 576894 23 131489 beidson 2012-03-12 19:09:48 -0700 Created attachment 131489 Patch v1 - Fix + layout test I'm still testing the edges, but just wanted to get a patch posted before heading home. 576905 24 131489 abarth 2012-03-12 19:15:54 -0700 Comment on attachment 131489 Patch v1 - Fix + layout test View in context: https://bugs.webkit.org/attachment.cgi?id=131489&action=review This looks great. > Source/WebCore/Modules/indexeddb/DOMWindowIndexedDatabase.cpp:63 > - m_idbFactory = 0; > + m_suspendedIDBFactory = m_idbFactory.release(); That's a nice approach. > Source/WebCore/page/DOMWindow.cpp:537 > +#if ENABLE(NOTIFICATIONS) > + // FIXME: Notifications shouldn't have different disconnection logic than > + // the rest of the DOMWindowProperties. > + // There is currently no way to reconnect them in resumeFromPageCache() so > + // they will be broken after returning to a cached page. > + resetNotifications(); > +#endif This special case will be removed in https://bugs.webkit.org/show_bug.cgi?id=79636 576967 25 131489 webkit.review.bot 2012-03-12 20:27:49 -0700 Comment on attachment 131489 Patch v1 - Fix + layout test Attachment 131489 did not pass chromium-ews (chromium-xvfb): Output: http://queues.webkit.org/results/11947294 576987 26 beidson 2012-03-12 21:09:10 -0700 (In reply to comment #24) > (From update of attachment 131489 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=131489&action=review > > This looks great. > > > Source/WebCore/Modules/indexeddb/DOMWindowIndexedDatabase.cpp:63 > > - m_idbFactory = 0; > > + m_suspendedIDBFactory = m_idbFactory.release(); > > That's a nice approach. > > > Source/WebCore/page/DOMWindow.cpp:537 > > +#if ENABLE(NOTIFICATIONS) > > + // FIXME: Notifications shouldn't have different disconnection logic than > > + // the rest of the DOMWindowProperties. > > + // There is currently no way to reconnect them in resumeFromPageCache() so > > + // they will be broken after returning to a cached page. > > + resetNotifications(); > > +#endif > > This special case will be removed in https://bugs.webkit.org/show_bug.cgi?id=79636 I knew removing it was upcoming work. I'll the bug number to the FIXME before I land this tomorrow. 577386 27 beidson 2012-03-13 09:00:05 -0700 http://trac.webkit.org/changeset/110570 696352 28 rob 2012-08-15 13:55:26 -0700 Thanks guys, is there any way for me to determine when this bug will hit iOS? I'm wondering how we can validate that it is fixed. 696380 29 beidson 2012-08-15 14:28:47 -0700 (In reply to comment #28) > Thanks guys, is there any way for me to determine when this bug will hit iOS? I'm wondering how we can validate that it is fixed. This bug database is for the WebKit open source project. iOS is a product of Apple, and you'd have ask them about timelines for their product releases. 696642 30 rob 2012-08-15 19:22:52 -0700 Understood, just saw a lot of @apple.com email addresses and no amount of web searching led me to a bug database for iOS. Thanks, I'll keep digging. 697207 31 beidson 2012-08-16 09:29:15 -0700 (In reply to comment #30) > Understood, just saw a lot of @apple.com email addresses and no amount of web searching led me to a bug database for iOS. Thanks, I'll keep digging. http://developer.apple.com/ and http://bugreport.apple.com/ 697212 32 beidson 2012-08-16 09:34:41 -0700 *** Bug 94064 has been marked as a duplicate of this bug. *** 125471 2012-02-03 20:13:50 -0800 2012-02-03 20:13:50 -0800 Example of problem with iframes and iOS 5 b/f cache example.webkit.iframe.bug.34679.zip application/zip 2711 rob UEsDBBQACAAIAOCoQ0AAAAAAAAAAAAAAAAAKABAAaW5kZXguaHRtbFVYDABiryxPFNksT/UBFACd VU2v2zYQPFe/YqGL5MaREqC9PEs65OOQoq0LvAA50+TKZkKRAknJEQL/9y4p2XLykqLIRTap4c7s 7HJVnXynmuqETDSVl15hU5XLb4eegWYd1uko8dwb61NIuNEeta/TsxT+VAscJcfncbGVWnrJ1HPH mcL65XZwaOOCHWitzbZjn2U3dFdA2iSV41b2HvzUE4/Hz778yEY279L7dtDcS6NBam6xI+bXZiAF NpdiA18SgJFZQIUd1CAMHwKkOKJ/qyL61fROBOhuQY5MEbBn1uE77fNwsJBao31P1AtKPXsW/nz9 jk7Rm11ySVZNDv2jGSzHfJUi/0NH2k2tJUPTSCQLZzmh08hRhEqk38bX4h+pjz8ZfinVB6mFORe9 cf4vdI4dMc++pCxSpA9pTwTpJdtC9mu2ifzn+QAT4u1I5/+UjsKQ41k3HyfsTWKOARL0EaW3UxQ6 S+3ckcT+8bj/u4h+z9BCMM+IJ8JkCznBilkM1GRGb0jOZgkDT8u+AHbL+7KE9/s3+4foFYRc6Ai8 pCVlLyLoQs8LcOb5KcdF6SW5BA1VOTca9WEZ7wBtHYyYaN03ew2ttM6DMkxACRbjH9OCP0lHPXTE LUxmoNAauJL8050Ibyi5UAxgtCU9nKVSwI21yL2agK4G3FUk4q+pUnyMUTJHpBzliIKOUv6EcVJg BMzhC/hwQj3LiBIOjB4+7LVnEclvamMiDlpruhjhULaknYdYdL/2j/D7Fhi0eIbDcHRgOB/sA+Rs c8cHaukGB8wiCOnIZ005kURnompHDaozD9Sdq/zDdO9HfthA6IYY2KPzd8kHLTNSGHQh0NnYT08z J1Mdqraoyv5arpDDb1s4Y3BLiaiAWTJuMYFE9DZ2YSjRmj7tU7OHPaokdr2fYL4DkA06mJbBiWQr tFuyxt/sgkfWMivn4Fe1DmkWUTkXJnI0eh9dD7ECTVzc+JcUhByb5JeKwcliW6frGHwYjRT5i00K Rsci1+k6GXbksR8slZsph2nzvRbMWyaVW2XfmDdVyZrqYMsGiNn1lL4U9XzFmhd0O2inidFytwnd 7emiBJ3LmVnz/5P85CZnsaWzbzLYpc3aCx+H2BphXodlNDIP7fDDZGDNIoZf0/haeVJdu4iQ17kJ NJDr+3FMH8MZFk7HwUBzInwxk38BUEsHCLCPEHFtAwAAOQcAAFBLAwQKAAAAAAAjkUNAAAAAAAAA AAAAAAAACQAQAF9fTUFDT1NYL1VYDABiryxPYq8sT/UBFABQSwMEFAAIAAgA4KhDQAAAAAAAAAAA AAAAABUAEABfX01BQ09TWC8uX2luZGV4Lmh0bWxVWAwAYq8sTxTZLE/1ARQAY2AVY2dgYmDwTUxW 8A9WiFCAApAYAycQGzEwMGYDaSCfcS4QyzEQBI4hIUHMr42eQnQwnADiq2hKmKDiLQwMqsn5uXqJ BQU5qXq5qSWJKYkliVbZvi6eJam54RmpRaluRfm5xUCljD5AIpCBQRShvrA0sSgxryQzL5UhqSAn s7jEwGAhY7xAaFpJgZW+fkZ+MVAqXbe4oCi/tCSpNDMnJbXIAcLLzEvWA5rjAFWjhyKqX5SfpF+e mpSdWaKfmZeSWqGXUZKbw8EFcTojI5IfkEFSob4BEFibpBklJ6aZWlo7VyalFqWUJmdbW5pbOhs5 GxjpOju7mOuaGJo66zo5ORvpmrm4mbg4mRg5Ghtb1CRn6BWXpuTrJcO0gSyDYjAgIuiHG0D1f0+r AJMEiCXDIPf/PwBQSwcIzfoxDTQBAAC7AgAAUEsDBBQACAAIAOCoQ0AAAAAAAAAAAAAAAAAKABAA aW5uZXIuaHRtbFVYDABiryxPFNksT/UBFACFU8FunDAQvfMVI1+AJoL00MsucEibQ6q2Wyn5Aa89 u+sWbGQbUhTx7x1j2t1oVfWCjf3em/eGoTr5rm2S6oRc0uKEVb0HP/VYM4+/fPmDjzyesiZJDoMW XhkNSguLHWr/0Qzao82UzOE1ARi5BWyxgxqkEUOAFEf0D+2Cvp8eZYBuV+TIWwL23Dp81D4LxEJp jfaZaq+o9uYmbN7eEYtutsl84cmhlt+NPmbRyYvS0rwUJB489Mb5r+gcP2KWvjK+UNiG9URgc3oL 6bs0X/RWHpfyYSTmF+U8UtUsHXRruCTo34qh0lUnWMSxfCYkbx2S7L9Fu+jpjSoGSAhBKbydljSx X507UvLPT7tvxdK0CC0k9zxUCTB1gIxgRUwIdQ2sV5QxX2Xgok/b9eQ6Q6T8uS9LeN592m0WKoQ7 osB7ehVGywU003MGwb04Zbh6n5M5uKrKOEA0X+U6Z3sjJ1r6JmilDiwKVCNK2E8UwPIOITtw1bpQ R+2e4APsywPJixPmG6hcz+lc1tFnc0cl6KSp9rZsID6TisPJ4qFm5xHejEbJ7C5nYLRolfhZs6vo qQgbmgUy5Qer4zfcssaj8+dOLcb+57QqeXPpdpE+26V+rI0o42/4G1BLBwhkgi5g1gEAAI4DAABQ SwMEFAAIAAgA4KhDQAAAAAAAAAAAAAAAABUAEABfX01BQ09TWC8uX2lubmVyLmh0bWxVWAwAYq8s TxTZLE/1ARQAY2AVY2dgYmDwTUxW8A9WiFCAApAYAycQGzEwMGYDaSCfcS4QyzEQBI4hIUHMr41e QHQwnADiq2hKmKDiLQwMqsn5uXqJBQU5qXq5qSWJKYkliVbZvi6eJam54RmpRaluRfm5xUCljD5A IpCBQRShvrA0sSgxryQzL5UhqSAns7jEwGAhY7xAaFpJgZW+fkZ+MVAqXbe4oCi/tCSpNDMnJbXI AcLLzEvWA5rjAFWjhyKqX5SfpF+empSdWaKfmZeXWqSXUZKbw8EFcTojI5IfkEFSob4BEFibpBkl J6aZJlo7VyalFqWUJmdbG7o5G7u5ubrpulkYO+uauJgb6zqaW5rrGjhampsYOJmYObka1CRn6BWX puTrJcO0gSyDYjAgIuiHG0D1f0+rAJM0iCXDIPf/PwBQSwcIf7XvqDQBAAC7AgAAUEsBAhUDFAAI AAgA4KhDQLCPEHFtAwAAOQcAAAoADAAAAAAAAAAAQKSBAAAAAGluZGV4Lmh0bWxVWAgAYq8sTxTZ LE9QSwECFQMKAAAAAAAjkUNAAAAAAAAAAAAAAAAACQAMAAAAAAAAAABA/UG1AwAAX19NQUNPU1gv VVgIAGKvLE9iryxPUEsBAhUDFAAIAAgA4KhDQM36MQ00AQAAuwIAABUADAAAAAAAAAAAQKSB7AMA AF9fTUFDT1NYLy5faW5kZXguaHRtbFVYCABiryxPFNksT1BLAQIVAxQACAAIAOCoQ0Bkgi5g1gEA AI4DAAAKAAwAAAAAAAAAAECkgXMFAABpbm5lci5odG1sVVgIAGKvLE8U2SxPUEsBAhUDFAAIAAgA 4KhDQH+176g0AQAAuwIAABUADAAAAAAAAAAAQKSBkQcAAF9fTUFDT1NYLy5faW5uZXIuaHRtbFVY CABiryxPFNksT1BLBQYAAAAABQAFAGkBAAAYCQAAAAA= 131489 2012-03-12 19:09:48 -0700 2012-03-12 20:27:49 -0700 Patch v1 - Fix + layout test patch.txt text/plain 27675 beidson ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA2YjJiNThmLi4yNmI5M2I3IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTMgQEAKKzIwMTItMDMt MTIgIEJyYWR5IEVpZHNvbiAgPGJlaWRzb25AYXBwbGUuY29tPgorCisgICAgICAgIDxyZGFyOi8v cHJvYmxlbS83OTA4ODMwPiBhbmQgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTM0Njc5CisgICAgICAgIExvY2F0aW9uIGFuZCBvdGhlciBvYmplY3RzIGFyZSBkeXNmdW5j dGlvbmFsIGFmdGVyIGEgZG9jdW1lbnQgZ2V0cyByZXN0b3JlZCBmcm9tIHBhZ2UgY2FjaGUKKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIGZhc3QvbG9h ZGVyL3dpbmRvdy1wcm9wZXJ0aWVzLXJlc3RvcmVkLWZyb20tcGFnZS1jYWNoZS1leHBlY3RlZC50 eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvbG9hZGVyL3dpbmRvdy1wcm9wZXJ0aWVzLXJlc3Rv cmVkLWZyb20tcGFnZS1jYWNoZS5odG1sOiBBZGRlZC4KKwogMjAxMi0wMy0xMiAgQWRhbSBCYXJ0 aCAgPGFiYXJ0aEB3ZWJraXQub3JnPgogCiAgICAgICAgIFVwZGF0ZSBleHBlY3RlZCByZXN1bHRz IGFmdGVyIGh0dHA6Ly90cmFjLndlYmtpdC5vcmcvY2hhbmdlc2V0LzExMDQ4MC4KZGlmZiAtLWdp dCBhL0xheW91dFRlc3RzL2Zhc3QvbG9hZGVyL3dpbmRvdy1wcm9wZXJ0aWVzLXJlc3RvcmVkLWZy b20tcGFnZS1jYWNoZS1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2xvYWRlci93aW5k b3ctcHJvcGVydGllcy1yZXN0b3JlZC1mcm9tLXBhZ2UtY2FjaGUtZXhwZWN0ZWQudHh0Cm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmZjY2JhZWQKLS0tIC9kZXYvbnVsbAorKysg Yi9MYXlvdXRUZXN0cy9mYXN0L2xvYWRlci93aW5kb3ctcHJvcGVydGllcy1yZXN0b3JlZC1mcm9t LXBhZ2UtY2FjaGUtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsMjAgQEAKK1RoaXMgdGVzdCBtYWtl cyBzdXJlIHRoYXQgdmFyaW91cyBwcm9wZXJ0aWVzIG9uIHRoZSB3aW5kb3cgb2JqZWN0IGFyZSBj b3JyZWN0bHkgcmVjb25uZWN0ZWQgYWZ0ZXIgcmVzdG9yaW5nIGEgcGFnZSBmcm9tIHRoZSBwYWdl IGNhY2hlLgorW29iamVjdCBET01BcHBsaWNhdGlvbkNhY2hlXSAKK1tvYmplY3QgQ29uc29sZV0g Citbb2JqZWN0IENyeXB0b10gCitbb2JqZWN0IEhpc3RvcnldIAorW29iamVjdCBTdG9yYWdlXSAK K3RydWUgCitbb2JqZWN0IEJhckluZm9dIAorW29iamVjdCBTdHlsZU1lZGlhXSAKK1tvYmplY3Qg QmFySW5mb10gCitbb2JqZWN0IE5hdmlnYXRvcl0gCitbb2JqZWN0IEJhckluZm9dIAorW29iamVj dCBTY3JlZW5dIAorW29iamVjdCBCYXJJbmZvXSAKK3RydWUgCitbb2JqZWN0IFN0b3JhZ2VdIAor W29iamVjdCBCYXJJbmZvXSAKK1tvYmplY3QgQmFySW5mb10gCisKK0FsbCB0ZXN0cyBwYXNzZWQu CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2xvYWRlci93aW5kb3ctcHJvcGVydGllcy1y ZXN0b3JlZC1mcm9tLXBhZ2UtY2FjaGUuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvbG9hZGVyL3dp bmRvdy1wcm9wZXJ0aWVzLXJlc3RvcmVkLWZyb20tcGFnZS1jYWNoZS5odG1sCm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjU4YmY0N2YKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlv dXRUZXN0cy9mYXN0L2xvYWRlci93aW5kb3ctcHJvcGVydGllcy1yZXN0b3JlZC1mcm9tLXBhZ2Ut Y2FjaGUuaHRtbApAQCAtMCwwICsxLDExMCBAQAorPHNjcmlwdD4KK2lmICh3aW5kb3cubGF5b3V0 VGVzdENvbnRyb2xsZXIpIHsKKwlsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CisJ bGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOworCWxheW91dFRlc3RDb250cm9s bGVyLm92ZXJyaWRlUHJlZmVyZW5jZSgiV2ViS2l0VXNlc1BhZ2VDYWNoZVByZWZlcmVuY2VLZXki LCAxKTsKK30KKwordmFyIGNhY2hlZEFwcGxpY2F0aW9uQ2FjaGUgPSB3aW5kb3cuYXBwbGljYXRp b25DYWNoZTsKK3ZhciBjYWNoZWRDb25zb2xlID0gd2luZG93LmNvbnNvbGU7Cit2YXIgY2FjaGVk Q3J5cHRvID0gd2luZG93LmNyeXB0bzsKK3ZhciBjYWNoZWRIaXN0b3J5ID0gd2luZG93Lmhpc3Rv cnk7Cit2YXIgY2FjaGVkTG9jYWxTdG9yYWdlID0gd2luZG93LmxvY2FsU3RvcmFnZTsKK3ZhciBj YWNoZWRMb2NhdGlvbiA9IHdpbmRvdy5sb2NhdGlvbjsKK3ZhciBjYWNoZWRMb2NhdGlvbmJhciA9 IHdpbmRvdy5sb2NhdGlvbmJhcjsKK3ZhciBjYWNoZWRNZWRpYSA9IHdpbmRvdy5zdHlsZU1lZGlh OwordmFyIGNhY2hlZE1lbnViYXIgPSB3aW5kb3cubWVudWJhcjsKK3ZhciBjYWNoZWROYXZpZ2F0 b3IgPSB3aW5kb3cubmF2aWdhdG9yOwordmFyIGNhY2hlZFBlcnNvbmFsYmFyID0gd2luZG93LnBl cnNvbmFsYmFyOwordmFyIGNhY2hlZFNjcmVlbiA9IHdpbmRvdy5zY3JlZW47Cit2YXIgY2FjaGVk U2Nyb2xsYmFycyA9IHdpbmRvdy5zY3JvbGxiYXJzOwordmFyIGNhY2hlZFNlbGVjdGlvbiA9IHdp bmRvdy5nZXRTZWxlY3Rpb24oKTsKK3ZhciBjYWNoZWRTZXNzaW9uU3RvcmFnZSA9IHdpbmRvdy5z ZXNzaW9uU3RvcmFnZTsKK3ZhciBjYWNoZWRTdGF0dXNiYXIgPSB3aW5kb3cuc3RhdHVzYmFyOwor dmFyIGNhY2hlZFRvb2xiYXIgPSB3aW5kb3cudG9vbGJhcjsKKworZnVuY3Rpb24gbG9nTWVzc2Fn ZShtc2cpCit7CisJZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoIm91dHB1dERpdiIpLmlubmVyVGV4 dCArPSBtc2cgKyAiIFxuIjsKK30KKworZnVuY3Rpb24gbG9nRXJyb3JNZXNzYWdlKG1zZykKK3sK Kwlkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZXJyb3JEaXYiKS5pbm5lclRleHQgKz0gbXNnICsg IiBcbiI7Cit9CisKK3dpbmRvdy5vbnBhZ2VzaG93ID0gZnVuY3Rpb24oZXZ0KSB7CisJaWYgKCFl dnQucGVyc2lzdGVkKSB7CisJCXdpbmRvdy5zZXRUaW1lb3V0KCJ3aW5kb3cubG9jYXRpb24uaHJl ZiA9ICdyZXNvdXJjZXMvZW1wdHktZG9jdW1lbnQtZ29lcy1iYWNrLmh0bWwnIiwgMCk7CisJCXJl dHVybjsKKwl9CisJCisJLy8gRmlyc3QgYWxlcnQgYWxsIG9mIHRoZSBvYmplY3RzIHRvIG1ha2Ug c3VyZSB3ZSBnZXQgYSB2YWxpZCB0b1N0cmluZygpLWlmaWNhdGlvbgorCS8vIGluc3RlYWQgb2Yg InVuZGVmaW5lZCIsICJudWxsIiwgb3IgIk9iamVjdCIKKwlsb2dNZXNzYWdlKHdpbmRvdy5hcHBs aWNhdGlvbkNhY2hlKTsKKwlsb2dNZXNzYWdlKHdpbmRvdy5jb25zb2xlKTsKKwlsb2dNZXNzYWdl KHdpbmRvdy5jcnlwdG8pOworCWxvZ01lc3NhZ2Uod2luZG93Lmhpc3RvcnkpOworCWxvZ01lc3Nh Z2Uod2luZG93LmxvY2FsU3RvcmFnZSk7CisJbG9nTWVzc2FnZSh3aW5kb3cubG9jYXRpb24gIT0g bnVsbCAmJiB3aW5kb3cubG9jYXRpb24gIT0gdW5kZWZpbmVkKTsKKwlsb2dNZXNzYWdlKHdpbmRv dy5sb2NhdGlvbmJhcik7CisJbG9nTWVzc2FnZSh3aW5kb3cuc3R5bGVNZWRpYSk7CisJbG9nTWVz c2FnZSh3aW5kb3cubWVudWJhcik7CisJbG9nTWVzc2FnZSh3aW5kb3cubmF2aWdhdG9yKTsKKwls b2dNZXNzYWdlKHdpbmRvdy5wZXJzb25hbGJhcik7CisJbG9nTWVzc2FnZSh3aW5kb3cuc2NyZWVu KTsKKwlsb2dNZXNzYWdlKHdpbmRvdy5zY3JvbGxiYXJzKTsKKwlsb2dNZXNzYWdlKHdpbmRvdy5n ZXRTZWxlY3Rpb24oKSAhPSBudWxsICYmIHdpbmRvdy5nZXRTZWxlY3Rpb24oKSAhPSB1bmRlZmlu ZWQpOworCWxvZ01lc3NhZ2Uod2luZG93LnNlc3Npb25TdG9yYWdlKTsKKwlsb2dNZXNzYWdlKHdp bmRvdy5zdGF0dXNiYXIpOworCWxvZ01lc3NhZ2Uod2luZG93LnRvb2xiYXIpOworCQorCS8vIFRo ZW4gbWFrZSBzdXJlIHRoZSB3aW5kb3cgcHJvcGVydGllcyBtYXRjaCB0aGUgY2FjaGVkIHJlZmVy ZW5jZXMgZnJvbSB0aGUgaW5pdGlhbCBwYWdlIGxvYWQKKwlpZiAoY2FjaGVkQXBwbGljYXRpb25D YWNoZSAhPSB3aW5kb3cuYXBwbGljYXRpb25DYWNoZSkKKwkJbG9nRXJyb3JNZXNzYWdlKCJhcHBs aWNhdGlvbkNhY2hlIik7CisJaWYgKGNhY2hlZENvbnNvbGUgIT0gd2luZG93LmNvbnNvbGUpCisJ CWxvZ0Vycm9yTWVzc2FnZSgiY29uc29sZSIpOworCWlmIChjYWNoZWRDcnlwdG8gIT0gd2luZG93 LmNyeXB0bykKKwkJbG9nRXJyb3JNZXNzYWdlKCJjcnlwdG8iKTsKKwlpZiAoY2FjaGVkSGlzdG9y eSAhPSB3aW5kb3cuaGlzdG9yeSkKKwkJbG9nRXJyb3JNZXNzYWdlKCJoaXN0b3J5Iik7CisJaWYg KGNhY2hlZExvY2FsU3RvcmFnZSAhPSB3aW5kb3cubG9jYWxTdG9yYWdlKQorCQlsb2dFcnJvck1l c3NhZ2UoImxvY2FsU3RvcmFnZSIpOworCWlmIChjYWNoZWRMb2NhdGlvbiAhPSB3aW5kb3cubG9j YXRpb24pCisJCWxvZ0Vycm9yTWVzc2FnZSgibG9jYXRpb24iKTsKKwlpZiAoY2FjaGVkTG9jYXRp b25iYXIgIT0gd2luZG93LmxvY2F0aW9uYmFyKQorCQlsb2dFcnJvck1lc3NhZ2UoImxvY2F0aW9u YmFyIik7CisJaWYgKGNhY2hlZE1lZGlhICE9IHdpbmRvdy5zdHlsZU1lZGlhKQorCQlsb2dFcnJv ck1lc3NhZ2UoInN0eWxlTWVkaWEiKTsKKwlpZiAoY2FjaGVkTWVudWJhciAhPSB3aW5kb3cubWVu dWJhcikKKwkJbG9nRXJyb3JNZXNzYWdlKCJtZW51YmFyIik7CisJaWYgKGNhY2hlZE5hdmlnYXRv ciAhPSB3aW5kb3cubmF2aWdhdG9yKQorCQlsb2dFcnJvck1lc3NhZ2UoIm5hdmlnYXRvciIpOwor CWlmIChjYWNoZWRQZXJzb25hbGJhciAhPSB3aW5kb3cucGVyc29uYWxiYXIpCisJCWxvZ0Vycm9y TWVzc2FnZSgicGVyc29uYWxiYXIiKTsKKwlpZiAoY2FjaGVkU2NyZWVuICE9IHdpbmRvdy5zY3Jl ZW4pCisJCWxvZ0Vycm9yTWVzc2FnZSgic2NyZWVuIik7CisJaWYgKGNhY2hlZFNjcm9sbGJhcnMg IT0gd2luZG93LnNjcm9sbGJhcnMpCisJCWxvZ0Vycm9yTWVzc2FnZSgic2Nyb2xsYmFycyIpOwor CWlmIChjYWNoZWRTZWxlY3Rpb24gIT0gd2luZG93LmdldFNlbGVjdGlvbigpKQorCQlsb2dFcnJv ck1lc3NhZ2UoImdldFNlbGVjdGlvbiIpOworCWlmIChjYWNoZWRTZXNzaW9uU3RvcmFnZSAhPSB3 aW5kb3cuc2Vzc2lvblN0b3JhZ2UpCisJCWxvZ0Vycm9yTWVzc2FnZSgic2Vzc2lvblN0b3JhZ2Ui KTsKKwlpZiAoY2FjaGVkU3RhdHVzYmFyICE9IHdpbmRvdy5zdGF0dXNiYXIpCisJCWxvZ0Vycm9y TWVzc2FnZSgic3RhdHVzYmFyIik7CisJaWYgKGNhY2hlZFRvb2xiYXIgIT0gd2luZG93LnRvb2xi YXIpCisJCWxvZ0Vycm9yTWVzc2FnZSgidG9vbGJhciIpOworCisJaWYgKGRvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCJlcnJvckRpdiIpLmlubmVyVGV4dCA9PSAiIikKKwkJZG9jdW1lbnQuZ2V0RWxl bWVudEJ5SWQoImVycm9yRGl2IikuaW5uZXJUZXh0ID0gIkFsbCB0ZXN0cyBwYXNzZWQuIjsKKwor CWlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisJCWxheW91dFRlc3RDb250cm9sbGVy Lm5vdGlmeURvbmUoKTsKK30KKworPC9zY3JpcHQ+Cis8Ym9keT4KK1RoaXMgdGVzdCBtYWtlcyBz dXJlIHRoYXQgdmFyaW91cyBwcm9wZXJ0aWVzIG9uIHRoZSB3aW5kb3cgb2JqZWN0IGFyZSBjb3Jy ZWN0bHkgcmVjb25uZWN0ZWQgYWZ0ZXIgcmVzdG9yaW5nIGEgcGFnZSBmcm9tIHRoZSBwYWdlIGNh Y2hlLjxicj4KKzxkaXYgaWQ9Im91dHB1dERpdiI+PC9kaXY+PGJyPgorPGRpdiBpZD0iZXJyb3JE aXYiPjwvZGl2PgorPC9ib2R5PgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpp bmRleCBjZmFjNTM1Li43OWQyNzdmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VM b2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDUgKzEsODAgQEAKIDIwMTIt MDMtMTIgIEJyYWR5IEVpZHNvbiAgPGJlaWRzb25AYXBwbGUuY29tPgogCisgICAgICAgIDxyZGFy Oi8vcHJvYmxlbS83OTA4ODMwPiBhbmQgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTM0Njc5CisgICAgICAgIExvY2F0aW9uIGFuZCBvdGhlciBvYmplY3RzIGFyZSBkeXNm dW5jdGlvbmFsIGFmdGVyIGEgZG9jdW1lbnQgZ2V0cyByZXN0b3JlZCBmcm9tIHBhZ2UgY2FjaGUK KworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBUZXN0OiBm YXN0L2xvYWRlci93aW5kb3ctcHJvcGVydGllcy1yZXN0b3JlZC1mcm9tLXBhZ2UtY2FjaGUuaHRt bAorCisgICAgICAgIEdpdmUgRE9NV2luZG93UHJvcGVydGllcyB0aGUgYWJpbGl0eSB0byByZWNv bm5lY3QgdG8gdGhlaXIgRnJhbWU6CisgICAgICAgICogcGFnZS9ET01XaW5kb3dQcm9wZXJ0eS5j cHA6CisgICAgICAgIChXZWJDb3JlOjpET01XaW5kb3dQcm9wZXJ0eTo6cmVjb25uZWN0RnJhbWUp OgorICAgICAgICAqIHBhZ2UvRE9NV2luZG93UHJvcGVydHkuaDoKKyAgICAgICAgKERPTVdpbmRv d1Byb3BlcnR5KToKKworICAgICAgICBMZXQgQXBwbGljYXRpb25DYWNoZSBkbyBzb21lIGV4dHJh IHdvcmsgd2hlbiByZWNvbm5lY3Rpbmc6CisgICAgICAgICogbG9hZGVyL2FwcGNhY2hlL0RPTUFw cGxpY2F0aW9uQ2FjaGUuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RE9NQXBwbGljYXRpb25DYWNo ZTo6cmVjb25uZWN0RnJhbWUpOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgICogbG9hZGVy L2FwcGNhY2hlL0RPTUFwcGxpY2F0aW9uQ2FjaGUuaDoKKyAgICAgICAgKERPTUFwcGxpY2F0aW9u Q2FjaGUpOgorCisgICAgICAgIExldCBJbmRleERCIGRvIHNvbWUgZXh0cmEgd29yayB3aGVuIHJl Y29ubmVjdGluZzoKKyAgICAgICAgKiBNb2R1bGVzL2luZGV4ZWRkYi9ET01XaW5kb3dJbmRleGVk RGF0YWJhc2UuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RE9NV2luZG93SW5kZXhlZERhdGFiYXNl OjpkaXNjb25uZWN0RnJhbWUpOgorICAgICAgICAoV2ViQ29yZTo6RE9NV2luZG93SW5kZXhlZERh dGFiYXNlOjpyZWNvbm5lY3RGcmFtZSk6CisgICAgICAgIChXZWJDb3JlOjpET01XaW5kb3dJbmRl eGVkRGF0YWJhc2U6OndlYmtpdEluZGV4ZWREQik6CisgICAgICAgICogTW9kdWxlcy9pbmRleGVk ZGIvRE9NV2luZG93SW5kZXhlZERhdGFiYXNlLmg6CisgICAgICAgIChET01XaW5kb3dJbmRleGVk RGF0YWJhc2UpOgorCisgICAgICAgIFRlbGwgdGhlIERPTVdpbmRvdyB0byBzdXNwZW5kIHRvIHRo ZSBwYWdlIGNhY2hlOgorICAgICAgICAqIGhpc3RvcnkvQ2FjaGVkRnJhbWUuY3BwOgorICAgICAg ICAoV2ViQ29yZTo6Q2FjaGVkRnJhbWU6OkNhY2hlZEZyYW1lKToKKworICAgICAgICBUZWxsIHRo ZSBET01XaW5kb3cgdG8gcmVzdW1lIGZyb20gdGhlIHBhZ2UgY2FjaGU6CisgICAgICAgICogbG9h ZGVyL0ZyYW1lTG9hZGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lTG9hZGVyOjpvcGVu KToKKworICAgICAgICAqIHBhZ2UvRE9NV2luZG93LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkRP TVdpbmRvdzo6RE9NV2luZG93KToKKyAgICAgICAgKFdlYkNvcmU6OkRPTVdpbmRvdzo6fkRPTVdp bmRvdyk6IENhbGwgY2xlYXJET01XaW5kb3dQcm9wZXJ0aWVzIGRpcmVjdGx5IGluc3RlYWQgb2Yg Y2xlYXIoKQorICAgICAgICAoV2ViQ29yZTo6RE9NV2luZG93OjpmcmFtZURlc3Ryb3llZCk6IERp dHRvLgorICAgICAgICAoV2ViQ29yZTo6RE9NV2luZG93OjpjbGVhcik6IE9ubHkgY2xlYXIgaWYg dGhlIERPTVdpbmRvdyBpcyBub3Qgc3VzcGVuZGVkIGZvciB0aGUgcGFnZSBjYWNoZS4KKyAgICAg ICAgKFdlYkNvcmU6OkRPTVdpbmRvdzo6c3VzcGVuZEZvclBhZ2VDYWNoZSk6IERpc2Nvbm5lY3Qg cHJvcGVydGllcyBhbmQgc2V0IHRoZSBwYWdlIGNhY2hlIGZsYWcuCisgICAgICAgIChXZWJDb3Jl OjpET01XaW5kb3c6OnJlc3VtZUZyb21QYWdlQ2FjaGUpOiBSZWNvbm5lY3QgcHJvcGVydGllcyBh bmQgcmV2ZXJ0IHRoZSBwYWdlIGNhY2hlIGZsYWcuCisgICAgICAgIChXZWJDb3JlOjpET01XaW5k b3c6OmRpc2Nvbm5lY3RET01XaW5kb3dQcm9wZXJ0aWVzKTogT25seSBkaXNjb25uZWN0IHRoZSBy ZWdpc3RlcmVkIHByb3BlcnRpZXMuCisgICAgICAgIChXZWJDb3JlOjpET01XaW5kb3c6OnJlY29u bmVjdERPTVdpbmRvd1Byb3BlcnRpZXMpOgorICAgICAgICAoV2ViQ29yZTo6RE9NV2luZG93Ojpj bGVhckRPTVdpbmRvd1Byb3BlcnRpZXMpOiBEaXNjb25uZWN0IHRoZSByZWdpc3RlcmVkIHByb3Bl cnRpZXMgdGhlbiBjbGVhciB0aGVtIG91dC4KKworICAgICAgICBGb3IgYWxsIG9mIHRoZSBmb2xs b3dpbmcsIGlmIHRoZSBET01XaW5kb3cgaXMgbm90IGRpc3BsYXllZCBpbiBhIGZyYW1lIChpLmUu LCBpdCBpcyBzdXNwZW5kZWQpLCBkbyBub3RoaW5nOgorICAgICAgICAoV2ViQ29yZTo6RE9NV2lu ZG93OjpzY3JlZW4pOgorICAgICAgICAoV2ViQ29yZTo6RE9NV2luZG93OjpoaXN0b3J5KToKKyAg ICAgICAgKFdlYkNvcmU6OkRPTVdpbmRvdzo6Y3J5cHRvKToKKyAgICAgICAgKFdlYkNvcmU6OkRP TVdpbmRvdzo6bG9jYXRpb25iYXIpOgorICAgICAgICAoV2ViQ29yZTo6RE9NV2luZG93OjptZW51 YmFyKToKKyAgICAgICAgKFdlYkNvcmU6OkRPTVdpbmRvdzo6cGVyc29uYWxiYXIpOgorICAgICAg ICAoV2ViQ29yZTo6RE9NV2luZG93OjpzY3JvbGxiYXJzKToKKyAgICAgICAgKFdlYkNvcmU6OkRP TVdpbmRvdzo6c3RhdHVzYmFyKToKKyAgICAgICAgKFdlYkNvcmU6OkRPTVdpbmRvdzo6dG9vbGJh cik6CisgICAgICAgIChXZWJDb3JlOjpET01XaW5kb3c6OmNvbnNvbGUpOgorICAgICAgICAoV2Vi Q29yZTo6RE9NV2luZG93OjphcHBsaWNhdGlvbkNhY2hlKToKKyAgICAgICAgKFdlYkNvcmU6OkRP TVdpbmRvdzo6bmF2aWdhdG9yKToKKyAgICAgICAgKFdlYkNvcmU6OkRPTVdpbmRvdzo6cGVyZm9y bWFuY2UpOgorICAgICAgICAoV2ViQ29yZTo6RE9NV2luZG93Ojpsb2NhdGlvbik6CisgICAgICAg IChXZWJDb3JlOjpET01XaW5kb3c6OnNlc3Npb25TdG9yYWdlKToKKyAgICAgICAgKFdlYkNvcmU6 OkRPTVdpbmRvdzo6bG9jYWxTdG9yYWdlKToKKyAgICAgICAgKFdlYkNvcmU6OkRPTVdpbmRvdzo6 d2Via2l0Tm90aWZpY2F0aW9ucyk6CisgICAgICAgIChXZWJDb3JlOjpET01XaW5kb3c6OnBvc3RN ZXNzYWdlVGltZXJGaXJlZCk6CisgICAgICAgIChXZWJDb3JlOjpET01XaW5kb3c6OmdldFNlbGVj dGlvbik6CisgICAgICAgIChXZWJDb3JlOjpET01XaW5kb3c6OnN0eWxlTWVkaWEpOgorICAgICAg ICAoV2ViQ29yZTo6RE9NV2luZG93Ojp3ZWJraXRTdG9yYWdlSW5mbyk6CisgICAgICAgICogcGFn ZS9ET01XaW5kb3cuaDoKKworCisKKzIwMTItMDMtMTIgIEJyYWR5IEVpZHNvbiAgPGJlaWRzb25A YXBwbGUuY29tPgorCiAgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD04MDkwMwogICAgICAgICBJbnNwZWN0b3JET01TdG9yYWdlQWdlbnQgY3JlYXRlcyBhIFN0 b3JhZ2Ugb2JqZWN0IHdoaWNoIGlzIGEgRE9NV2luZG93UHJvcGVydHkgLSBTaG91bGQgdXNlIHRo ZSBTdG9yYWdlQXJlYSBkaXJlY3RseQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1 bGVzL2luZGV4ZWRkYi9ET01XaW5kb3dJbmRleGVkRGF0YWJhc2UuY3BwIGIvU291cmNlL1dlYkNv cmUvTW9kdWxlcy9pbmRleGVkZGIvRE9NV2luZG93SW5kZXhlZERhdGFiYXNlLmNwcAppbmRleCA2 ZWMyZGMwLi40YmFkZTcwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4 ZWRkYi9ET01XaW5kb3dJbmRleGVkRGF0YWJhc2UuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL01v ZHVsZXMvaW5kZXhlZGRiL0RPTVdpbmRvd0luZGV4ZWREYXRhYmFzZS5jcHAKQEAgLTYwLDEwICs2 MCwxNiBAQCBET01XaW5kb3dJbmRleGVkRGF0YWJhc2UqIERPTVdpbmRvd0luZGV4ZWREYXRhYmFz ZTo6ZnJvbShET01XaW5kb3cqIHdpbmRvdykKIAogdm9pZCBET01XaW5kb3dJbmRleGVkRGF0YWJh c2U6OmRpc2Nvbm5lY3RGcmFtZSgpCiB7Ci0gICAgbV9pZGJGYWN0b3J5ID0gMDsKKyAgICBtX3N1 c3BlbmRlZElEQkZhY3RvcnkgPSBtX2lkYkZhY3RvcnkucmVsZWFzZSgpOwogICAgIERPTVdpbmRv d1Byb3BlcnR5OjpkaXNjb25uZWN0RnJhbWUoKTsKIH0KIAordm9pZCBET01XaW5kb3dJbmRleGVk RGF0YWJhc2U6OnJlY29ubmVjdEZyYW1lKEZyYW1lKiBmcmFtZSkKK3sKKyAgICBET01XaW5kb3dQ cm9wZXJ0eTo6cmVjb25uZWN0RnJhbWUoZnJhbWUpOworICAgIG1faWRiRmFjdG9yeSA9IG1fc3Vz cGVuZGVkSURCRmFjdG9yeS5yZWxlYXNlKCk7Cit9CisKIElEQkZhY3RvcnkqIERPTVdpbmRvd0lu ZGV4ZWREYXRhYmFzZTo6d2Via2l0SW5kZXhlZERCKERPTVdpbmRvdyogd2luZG93KQogewogICAg IHJldHVybiBmcm9tKHdpbmRvdyktPndlYmtpdEluZGV4ZWREQigpOwpAQCAtODIsNyArODgsMTAg QEAgSURCRmFjdG9yeSogRE9NV2luZG93SW5kZXhlZERhdGFiYXNlOjp3ZWJraXRJbmRleGVkREIo KQogICAgIGlmICghZG9jdW1lbnQtPnNlY3VyaXR5T3JpZ2luKCktPmNhbkFjY2Vzc0RhdGFiYXNl KCkpCiAgICAgICAgIHJldHVybiAwOwogCi0gICAgaWYgKCFtX2lkYkZhY3RvcnkgJiYgbV93aW5k b3ctPmlzQ3VycmVudGx5RGlzcGxheWVkSW5GcmFtZSgpKQorICAgIGlmICghbV93aW5kb3ctPmlz Q3VycmVudGx5RGlzcGxheWVkSW5GcmFtZSgpKQorICAgICAgICByZXR1cm4gMDsKKworICAgIGlm ICghbV9pZGJGYWN0b3J5KQogICAgICAgICBtX2lkYkZhY3RvcnkgPSBJREJGYWN0b3J5OjpjcmVh dGUoUGFnZUdyb3VwSW5kZXhlZERhdGFiYXNlOjpmcm9tKHBhZ2UtPmdyb3VwKCkpLT5mYWN0b3J5 QmFja2VuZCgpKTsKICAgICByZXR1cm4gbV9pZGJGYWN0b3J5LmdldCgpOwogfQpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9pbmRleGVkZGIvRE9NV2luZG93SW5kZXhlZERhdGFi YXNlLmggYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9ET01XaW5kb3dJbmRleGVk RGF0YWJhc2UuaAppbmRleCBkNzFmODJkLi5kMWExMGIxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9ET01XaW5kb3dJbmRleGVkRGF0YWJhc2UuaAorKysgYi9T b3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9ET01XaW5kb3dJbmRleGVkRGF0YWJhc2Uu aApAQCAtNDQsNiArNDQsNyBAQCBwdWJsaWM6CiAgICAgc3RhdGljIElEQkZhY3RvcnkqIHdlYmtp dEluZGV4ZWREQihET01XaW5kb3cqKTsKIAogICAgIHZpcnR1YWwgdm9pZCBkaXNjb25uZWN0RnJh bWUoKSBPVkVSUklERTsKKyAgICB2aXJ0dWFsIHZvaWQgcmVjb25uZWN0RnJhbWUoRnJhbWUqKSBP VkVSUklERTsKIAogcHJpdmF0ZToKICAgICBleHBsaWNpdCBET01XaW5kb3dJbmRleGVkRGF0YWJh c2UoRE9NV2luZG93Kik7CkBAIC01Miw2ICs1Myw3IEBAIHByaXZhdGU6CiAKICAgICBET01XaW5k b3cqIG1fd2luZG93OwogICAgIFJlZlB0cjxJREJGYWN0b3J5PiBtX2lkYkZhY3Rvcnk7CisgICAg UmVmUHRyPElEQkZhY3Rvcnk+IG1fc3VzcGVuZGVkSURCRmFjdG9yeTsKIH07CiAKIH0gLy8gbmFt ZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2hpc3RvcnkvQ2FjaGVk RnJhbWUuY3BwIGIvU291cmNlL1dlYkNvcmUvaGlzdG9yeS9DYWNoZWRGcmFtZS5jcHAKaW5kZXgg OWIwZDJmZS4uMzRmOTEzZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaGlzdG9yeS9DYWNo ZWRGcmFtZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaGlzdG9yeS9DYWNoZWRGcmFtZS5jcHAK QEAgLTE3Miw2ICsxNzIsOSBAQCBDYWNoZWRGcmFtZTo6Q2FjaGVkRnJhbWUoRnJhbWUqIGZyYW1l KQogICAgIG1fZG9jdW1lbnQtPnN1c3BlbmRTY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXJDYWxs YmFja3MoKTsKICAgICBtX2RvY3VtZW50LT5zdXNwZW5kQWN0aXZlRE9NT2JqZWN0cyhBY3RpdmVE T01PYmplY3Q6OkRvY3VtZW50V2lsbEJlY29tZUluYWN0aXZlKTsKICAgICBtX2NhY2hlZEZyYW1l U2NyaXB0RGF0YSA9IGFkb3B0UHRyKG5ldyBTY3JpcHRDYWNoZWRGcmFtZURhdGEoZnJhbWUpKTsK KyAgICAKKyAgICBpZiAoRE9NV2luZG93KiBkb21XaW5kb3cgPSBtX2NhY2hlZEZyYW1lU2NyaXB0 RGF0YS0+ZG9tV2luZG93KCkpCisgICAgICAgIGRvbVdpbmRvdy0+c3VzcGVuZEZvclBhZ2VDYWNo ZSgpOwogCiAgICAgZnJhbWUtPmxvYWRlcigpLT5jbGllbnQoKS0+c2F2ZVBsYXRmb3JtRGF0YVRv Q2FjaGVkRnJhbWUodGhpcyk7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9G cmFtZUxvYWRlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXIuY3BwCmlu ZGV4IDY3NzZhZDcuLjI3ODEwYWEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9G cmFtZUxvYWRlci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyLmNw cApAQCAtMjA1Niw2ICsyMDU2LDcgQEAgdm9pZCBGcmFtZUxvYWRlcjo6b3BlbihDYWNoZWRGcmFt ZUJhc2UmIGNhY2hlZEZyYW1lKQogICAgIAogICAgIG1fZnJhbWUtPnNldERvY3VtZW50KGRvY3Vt ZW50KTsKICAgICBtX2ZyYW1lLT5zZXRET01XaW5kb3coY2FjaGVkRnJhbWUuZG9tV2luZG93KCkp OworICAgIG1fZnJhbWUtPmRvbVdpbmRvdygpLT5yZXN1bWVGcm9tUGFnZUNhY2hlKCk7CiAgICAg bV9mcmFtZS0+ZG9tV2luZG93KCktPnNldFVSTChkb2N1bWVudC0+dXJsKCkpOwogICAgIG1fZnJh bWUtPmRvbVdpbmRvdygpLT5zZXRTZWN1cml0eU9yaWdpbihkb2N1bWVudC0+c2VjdXJpdHlPcmln aW4oKSk7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9hcHBjYWNoZS9ET01B cHBsaWNhdGlvbkNhY2hlLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9hcHBjYWNoZS9ET01B cHBsaWNhdGlvbkNhY2hlLmNwcAppbmRleCAyNDUyOTBiLi4xMWRjYmI4IDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9sb2FkZXIvYXBwY2FjaGUvRE9NQXBwbGljYXRpb25DYWNoZS5jcHAKKysr IGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL2FwcGNhY2hlL0RPTUFwcGxpY2F0aW9uQ2FjaGUuY3Bw CkBAIC01NSw2ICs1NSwxNCBAQCB2b2lkIERPTUFwcGxpY2F0aW9uQ2FjaGU6OmRpc2Nvbm5lY3RG cmFtZSgpCiAgICAgRE9NV2luZG93UHJvcGVydHk6OmRpc2Nvbm5lY3RGcmFtZSgpOwogfQogCit2 b2lkIERPTUFwcGxpY2F0aW9uQ2FjaGU6OnJlY29ubmVjdEZyYW1lKEZyYW1lKiBmcmFtZSkKK3sK KyAgICBET01XaW5kb3dQcm9wZXJ0eTo6cmVjb25uZWN0RnJhbWUoZnJhbWUpOworICAgIEFwcGxp Y2F0aW9uQ2FjaGVIb3N0KiBjYWNoZUhvc3QgPSBhcHBsaWNhdGlvbkNhY2hlSG9zdCgpOworICAg IGlmIChjYWNoZUhvc3QpCisgICAgICAgIGNhY2hlSG9zdC0+c2V0RE9NQXBwbGljYXRpb25DYWNo ZSh0aGlzKTsKK30KKwogQXBwbGljYXRpb25DYWNoZUhvc3QqIERPTUFwcGxpY2F0aW9uQ2FjaGU6 OmFwcGxpY2F0aW9uQ2FjaGVIb3N0KCkgY29uc3QKIHsKICAgICBpZiAoIW1fZnJhbWUgfHwgIW1f ZnJhbWUtPmxvYWRlcigpLT5kb2N1bWVudExvYWRlcigpKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvbG9hZGVyL2FwcGNhY2hlL0RPTUFwcGxpY2F0aW9uQ2FjaGUuaCBiL1NvdXJjZS9XZWJD b3JlL2xvYWRlci9hcHBjYWNoZS9ET01BcHBsaWNhdGlvbkNhY2hlLmgKaW5kZXggZmRiOGRhYi4u ZTNiMmEyZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvbG9hZGVyL2FwcGNhY2hlL0RPTUFw cGxpY2F0aW9uQ2FjaGUuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvYXBwY2FjaGUvRE9N QXBwbGljYXRpb25DYWNoZS5oCkBAIC00OCw2ICs0OCw3IEBAIHB1YmxpYzoKICAgICB+RE9NQXBw bGljYXRpb25DYWNoZSgpIHsgQVNTRVJUKCFtX2ZyYW1lKTsgfQogCiAgICAgdmlydHVhbCB2b2lk IGRpc2Nvbm5lY3RGcmFtZSgpIE9WRVJSSURFOworICAgIHZpcnR1YWwgdm9pZCByZWNvbm5lY3RG cmFtZShGcmFtZSopIE9WRVJSSURFOwogCiAgICAgdW5zaWduZWQgc2hvcnQgc3RhdHVzKCkgY29u c3Q7CiAgICAgdm9pZCB1cGRhdGUoRXhjZXB0aW9uQ29kZSYpOwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuY3BwIGIvU291cmNlL1dlYkNvcmUvcGFnZS9ET01XaW5k b3cuY3BwCmluZGV4IDJiMzBiYmUuLjU4ZTRlY2EgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L3BhZ2UvRE9NV2luZG93LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5j cHAKQEAgLTM5MCw0NCArMzkwLDQ5IEBAIGJvb2wgRE9NV2luZG93OjpjYW5TaG93TW9kYWxEaWFs b2dOb3coY29uc3QgRnJhbWUqIGZyYW1lKQogRE9NV2luZG93OjpET01XaW5kb3coRnJhbWUqIGZy YW1lKQogICAgIDogRnJhbWVEZXN0cnVjdGlvbk9ic2VydmVyKGZyYW1lKQogICAgICwgbV9zaG91 bGRQcmludFdoZW5GaW5pc2hlZExvYWRpbmcoZmFsc2UpCisgICAgLCBtX3N1c3BlbmRlZEZvclBh Z2VDYWNoZShmYWxzZSkKIHsKIH0KIAogRE9NV2luZG93Ojp+RE9NV2luZG93KCkKIHsKLSAgICBB U1NFUlQoIW1fc2NyZWVuKTsKLSAgICBBU1NFUlQoIW1fc2VsZWN0aW9uKTsKLSAgICBBU1NFUlQo IW1faGlzdG9yeSk7Ci0gICAgQVNTRVJUKCFtX2NyeXB0byk7Ci0gICAgQVNTRVJUKCFtX2xvY2F0 aW9uYmFyKTsKLSAgICBBU1NFUlQoIW1fbWVudWJhcik7Ci0gICAgQVNTRVJUKCFtX3BlcnNvbmFs YmFyKTsKLSAgICBBU1NFUlQoIW1fc2Nyb2xsYmFycyk7Ci0gICAgQVNTRVJUKCFtX3N0YXR1c2Jh cik7Ci0gICAgQVNTRVJUKCFtX3Rvb2xiYXIpOwotICAgIEFTU0VSVCghbV9jb25zb2xlKTsKLSAg ICBBU1NFUlQoIW1fbmF2aWdhdG9yKTsKKyNpZm5kZWYgTkRFQlVHCisgICAgaWYgKCFtX3N1c3Bl bmRlZEZvclBhZ2VDYWNoZSkgeworICAgICAgICBBU1NFUlQoIW1fc2NyZWVuKTsKKyAgICAgICAg QVNTRVJUKCFtX3NlbGVjdGlvbik7CisgICAgICAgIEFTU0VSVCghbV9oaXN0b3J5KTsKKyAgICAg ICAgQVNTRVJUKCFtX2NyeXB0byk7CisgICAgICAgIEFTU0VSVCghbV9sb2NhdGlvbmJhcik7Cisg ICAgICAgIEFTU0VSVCghbV9tZW51YmFyKTsKKyAgICAgICAgQVNTRVJUKCFtX3BlcnNvbmFsYmFy KTsKKyAgICAgICAgQVNTRVJUKCFtX3Njcm9sbGJhcnMpOworICAgICAgICBBU1NFUlQoIW1fc3Rh dHVzYmFyKTsKKyAgICAgICAgQVNTRVJUKCFtX3Rvb2xiYXIpOworICAgICAgICBBU1NFUlQoIW1f Y29uc29sZSk7CisgICAgICAgIEFTU0VSVCghbV9uYXZpZ2F0b3IpOwogI2lmIEVOQUJMRShXRUJf VElNSU5HKQotICAgIEFTU0VSVCghbV9wZXJmb3JtYW5jZSk7CisgICAgICAgIEFTU0VSVCghbV9w ZXJmb3JtYW5jZSk7CiAjZW5kaWYKLSAgICBBU1NFUlQoIW1fbG9jYXRpb24pOwotICAgIEFTU0VS VCghbV9tZWRpYSk7Ci0gICAgQVNTRVJUKCFtX3Nlc3Npb25TdG9yYWdlKTsKLSAgICBBU1NFUlQo IW1fbG9jYWxTdG9yYWdlKTsKLSAgICBBU1NFUlQoIW1fYXBwbGljYXRpb25DYWNoZSk7CisgICAg ICAgIEFTU0VSVCghbV9sb2NhdGlvbik7CisgICAgICAgIEFTU0VSVCghbV9tZWRpYSk7CisgICAg ICAgIEFTU0VSVCghbV9zZXNzaW9uU3RvcmFnZSk7CisgICAgICAgIEFTU0VSVCghbV9sb2NhbFN0 b3JhZ2UpOworICAgICAgICBBU1NFUlQoIW1fYXBwbGljYXRpb25DYWNoZSk7CiAjaWYgRU5BQkxF KE5PVElGSUNBVElPTlMpCi0gICAgQVNTRVJUKCFtX25vdGlmaWNhdGlvbnMpOworICAgICAgICBB U1NFUlQoIW1fbm90aWZpY2F0aW9ucyk7CiAjZW5kaWYKICNpZiBFTkFCTEUoQkxPQikKLSAgICBB U1NFUlQoIW1fZG9tVVJMKTsKKyAgICAgICAgQVNTRVJUKCFtX2RvbVVSTCk7CiAjZW5kaWYKICNp ZiBFTkFCTEUoUVVPVEEpCi0gICAgQVNTRVJUKCFtX3N0b3JhZ2VJbmZvKTsKKyAgICAgICAgQVNT RVJUKCFtX3N0b3JhZ2VJbmZvKTsKKyNlbmRpZgorICAgIH0KICNlbmRpZgogCi0gICAgLy8gVGhp cyBjbGVhciBzaG91bGQgYmUgdW5uZXNzYXJ5IGdpdmVuIHRoZSBBU1NFUlRzIGFib3ZlLCBidXQg d2UgZG9uJ3QKLSAgICAvLyB3YW50IGFueSBvZiB0aGVzZSBvYmplY3RzIHRvIGhhbmcgYXJvdW5k IGFmdGVyIHdlJ3ZlIGJlZW4gZGVzdHJveWVkLgotICAgIGNsZWFyKCk7CisgICAgLy8gQXMgdGhl IEFTU0VSVHMgYWJvdmUgaW5kaWNhdGUsIHRoaXMgY2xlYXIgc2hvdWxkIG9ubHkgYmUgbmVjZXNh cnkgaWYgdGhpcyBET01XaW5kb3cgaXMgc3VzcGVuZGVkIGZvciB0aGUgcGFnZSBjYWNoZS4KKyAg ICAvLyBCdXQgd2UgZG9uJ3Qgd2FudCB0byByaXNrIGFueSBvZiB0aGVzZSBvYmplY3RzIGhhbmdp bmcgYXJvdW5kIGFmdGVyIHdlJ3ZlIGJlZW4gZGVzdHJveWVkLgorICAgIGNsZWFyRE9NV2luZG93 UHJvcGVydGllcygpOwogCiAgICAgcmVtb3ZlQWxsVW5sb2FkRXZlbnRMaXN0ZW5lcnModGhpcyk7 CiAgICAgcmVtb3ZlQWxsQmVmb3JlVW5sb2FkRXZlbnRMaXN0ZW5lcnModGhpcyk7CkBAIC00NjYs NyArNDcxLDcgQEAgUGFnZSogRE9NV2luZG93OjpwYWdlKCkKIHZvaWQgRE9NV2luZG93OjpmcmFt ZURlc3Ryb3llZCgpCiB7CiAgICAgRnJhbWVEZXN0cnVjdGlvbk9ic2VydmVyOjpmcmFtZURlc3Ry b3llZCgpOwotICAgIGNsZWFyKCk7CisgICAgY2xlYXJET01XaW5kb3dQcm9wZXJ0aWVzKCk7CiB9 CiAKIHZvaWQgRE9NV2luZG93Ojp3aWxsRGV0YWNoUGFnZSgpCkBAIC00OTYsOSArNTAxLDUzIEBA IHZvaWQgRE9NV2luZG93Ojp1bnJlZ2lzdGVyUHJvcGVydHkoRE9NV2luZG93UHJvcGVydHkqIHBy b3BlcnR5KQogCiB2b2lkIERPTVdpbmRvdzo6Y2xlYXIoKQogeworICAgIC8vIFRoZSBtYWluIGZy YW1lIHdpbGwgYWx3YXlzIHRyeSB0byBjbGVhciBpdHMgRE9NV2luZG93IHdoZW4gYSBuZXcgbG9h ZCBpcyBjb21taXR0ZWQsIGV2ZW4gaWYgdGhhdAorICAgIC8vIERPTVdpbmRvdyBpcyBzdXNwZW5k ZWQgaW4gdGhlIHBhZ2UgY2FjaGUuCisgICAgLy8gSW4gdGhvc2UgY2FzZXMgd2UgbmVlZCB0byBt YWtlIHN1cmUgd2UgZG9uJ3QgYWN0dWFsbHkgY2xlYXIgaXQuCisgICAgaWYgKG1fc3VzcGVuZGVk Rm9yUGFnZUNhY2hlKQorICAgICAgICByZXR1cm47CisgICAgCisgICAgY2xlYXJET01XaW5kb3dQ cm9wZXJ0aWVzKCk7Cit9CisKK3ZvaWQgRE9NV2luZG93OjpzdXNwZW5kRm9yUGFnZUNhY2hlKCkK K3sKKyAgICBkaXNjb25uZWN0RE9NV2luZG93UHJvcGVydGllcygpOworICAgIG1fc3VzcGVuZGVk Rm9yUGFnZUNhY2hlID0gdHJ1ZTsKK30KKwordm9pZCBET01XaW5kb3c6OnJlc3VtZUZyb21QYWdl Q2FjaGUoKQoreworICAgIHJlY29ubmVjdERPTVdpbmRvd1Byb3BlcnRpZXMoKTsKKyAgICBtX3N1 c3BlbmRlZEZvclBhZ2VDYWNoZSA9IGZhbHNlOworfQorCit2b2lkIERPTVdpbmRvdzo6ZGlzY29u bmVjdERPTVdpbmRvd1Byb3BlcnRpZXMoKQorewogICAgIEhhc2hTZXQ8RE9NV2luZG93UHJvcGVy dHkqPjo6aXRlcmF0b3Igc3RvcCA9IG1fcHJvcGVydGllcy5lbmQoKTsKICAgICBmb3IgKEhhc2hT ZXQ8RE9NV2luZG93UHJvcGVydHkqPjo6aXRlcmF0b3IgaXQgPSBtX3Byb3BlcnRpZXMuYmVnaW4o KTsgaXQgIT0gc3RvcDsgKytpdCkKICAgICAgICAgKCppdCktPmRpc2Nvbm5lY3RGcmFtZSgpOwor CisjaWYgRU5BQkxFKE5PVElGSUNBVElPTlMpCisgICAgLy8gRklYTUU6IE5vdGlmaWNhdGlvbnMg c2hvdWxkbid0IGhhdmUgZGlmZmVyZW50IGRpc2Nvbm5lY3Rpb24gbG9naWMgdGhhbgorICAgIC8v IHRoZSByZXN0IG9mIHRoZSBET01XaW5kb3dQcm9wZXJ0aWVzLgorICAgIC8vIFRoZXJlIGlzIGN1 cnJlbnRseSBubyB3YXkgdG8gcmVjb25uZWN0IHRoZW0gaW4gcmVzdW1lRnJvbVBhZ2VDYWNoZSgp IHNvCisgICAgLy8gdGhleSB3aWxsIGJlIGJyb2tlbiBhZnRlciByZXR1cm5pbmcgdG8gYSBjYWNo ZWQgcGFnZS4KKyAgICByZXNldE5vdGlmaWNhdGlvbnMoKTsKKyNlbmRpZgorfQorCit2b2lkIERP TVdpbmRvdzo6cmVjb25uZWN0RE9NV2luZG93UHJvcGVydGllcygpCit7CisgICAgQVNTRVJUKG1f c3VzcGVuZGVkRm9yUGFnZUNhY2hlKTsKKyAgICBIYXNoU2V0PERPTVdpbmRvd1Byb3BlcnR5Kj46 Oml0ZXJhdG9yIHN0b3AgPSBtX3Byb3BlcnRpZXMuZW5kKCk7CisgICAgZm9yIChIYXNoU2V0PERP TVdpbmRvd1Byb3BlcnR5Kj46Oml0ZXJhdG9yIGl0ID0gbV9wcm9wZXJ0aWVzLmJlZ2luKCk7IGl0 ICE9IHN0b3A7ICsraXQpCisgICAgICAgICgqaXQpLT5yZWNvbm5lY3RGcmFtZShtX2ZyYW1lKTsK K30KKwordm9pZCBET01XaW5kb3c6OmNsZWFyRE9NV2luZG93UHJvcGVydGllcygpCit7CisgICAg ZGlzY29ubmVjdERPTVdpbmRvd1Byb3BlcnRpZXMoKTsKICAgICBtX3Byb3BlcnRpZXMuY2xlYXIo KTsKIAogICAgIG1fc2NyZWVuID0gMDsKQEAgLTU1MSw4NCArNjAwLDEwOCBAQCBpbnQgRE9NV2lu ZG93OjpvcmllbnRhdGlvbigpIGNvbnN0CiAKIFNjcmVlbiogRE9NV2luZG93OjpzY3JlZW4oKSBj b25zdAogewotICAgIGlmICghbV9zY3JlZW4gJiYgaXNDdXJyZW50bHlEaXNwbGF5ZWRJbkZyYW1l KCkpCisgICAgaWYgKCFpc0N1cnJlbnRseURpc3BsYXllZEluRnJhbWUoKSkKKyAgICAgICAgcmV0 dXJuIDA7CisgICAgaWYgKCFtX3NjcmVlbikKICAgICAgICAgbV9zY3JlZW4gPSBTY3JlZW46OmNy ZWF0ZShtX2ZyYW1lKTsKICAgICByZXR1cm4gbV9zY3JlZW4uZ2V0KCk7CiB9CiAKIEhpc3Rvcnkq IERPTVdpbmRvdzo6aGlzdG9yeSgpIGNvbnN0CiB7Ci0gICAgaWYgKCFtX2hpc3RvcnkgJiYgaXND dXJyZW50bHlEaXNwbGF5ZWRJbkZyYW1lKCkpCisgICAgaWYgKCFpc0N1cnJlbnRseURpc3BsYXll ZEluRnJhbWUoKSkKKyAgICAgICAgcmV0dXJuIDA7CisgICAgaWYgKCFtX2hpc3RvcnkpCiAgICAg ICAgIG1faGlzdG9yeSA9IEhpc3Rvcnk6OmNyZWF0ZShtX2ZyYW1lKTsKICAgICByZXR1cm4gbV9o aXN0b3J5LmdldCgpOwogfQogCiBDcnlwdG8qIERPTVdpbmRvdzo6Y3J5cHRvKCkgY29uc3QKIHsK LSAgICBpZiAoIW1fY3J5cHRvICYmIGlzQ3VycmVudGx5RGlzcGxheWVkSW5GcmFtZSgpKQorICAg IGlmICghaXNDdXJyZW50bHlEaXNwbGF5ZWRJbkZyYW1lKCkpCisgICAgICAgIHJldHVybiAwOwor ICAgIGlmICghbV9jcnlwdG8pCiAgICAgICAgIG1fY3J5cHRvID0gQ3J5cHRvOjpjcmVhdGUoKTsK ICAgICByZXR1cm4gbV9jcnlwdG8uZ2V0KCk7CiB9CiAKIEJhckluZm8qIERPTVdpbmRvdzo6bG9j YXRpb25iYXIoKSBjb25zdAogewotICAgIGlmICghbV9sb2NhdGlvbmJhciAmJiBpc0N1cnJlbnRs eURpc3BsYXllZEluRnJhbWUoKSkKKyAgICBpZiAoIWlzQ3VycmVudGx5RGlzcGxheWVkSW5GcmFt ZSgpKQorICAgICAgICByZXR1cm4gMDsKKyAgICBpZiAoIW1fbG9jYXRpb25iYXIpCiAgICAgICAg IG1fbG9jYXRpb25iYXIgPSBCYXJJbmZvOjpjcmVhdGUobV9mcmFtZSwgQmFySW5mbzo6TG9jYXRp b25iYXIpOwogICAgIHJldHVybiBtX2xvY2F0aW9uYmFyLmdldCgpOwogfQogCiBCYXJJbmZvKiBE T01XaW5kb3c6Om1lbnViYXIoKSBjb25zdAogewotICAgIGlmICghbV9tZW51YmFyICYmIGlzQ3Vy cmVudGx5RGlzcGxheWVkSW5GcmFtZSgpKQorICAgIGlmICghaXNDdXJyZW50bHlEaXNwbGF5ZWRJ bkZyYW1lKCkpCisgICAgICAgIHJldHVybiAwOworICAgIGlmICghbV9tZW51YmFyKQogICAgICAg ICBtX21lbnViYXIgPSBCYXJJbmZvOjpjcmVhdGUobV9mcmFtZSwgQmFySW5mbzo6TWVudWJhcik7 CiAgICAgcmV0dXJuIG1fbWVudWJhci5nZXQoKTsKIH0KIAogQmFySW5mbyogRE9NV2luZG93Ojpw ZXJzb25hbGJhcigpIGNvbnN0CiB7Ci0gICAgaWYgKCFtX3BlcnNvbmFsYmFyICYmIGlzQ3VycmVu dGx5RGlzcGxheWVkSW5GcmFtZSgpKQorICAgIGlmICghaXNDdXJyZW50bHlEaXNwbGF5ZWRJbkZy YW1lKCkpCisgICAgICAgIHJldHVybiAwOworICAgIGlmICghbV9wZXJzb25hbGJhcikKICAgICAg ICAgbV9wZXJzb25hbGJhciA9IEJhckluZm86OmNyZWF0ZShtX2ZyYW1lLCBCYXJJbmZvOjpQZXJz b25hbGJhcik7CiAgICAgcmV0dXJuIG1fcGVyc29uYWxiYXIuZ2V0KCk7CiB9CiAKIEJhckluZm8q IERPTVdpbmRvdzo6c2Nyb2xsYmFycygpIGNvbnN0CiB7Ci0gICAgaWYgKCFtX3Njcm9sbGJhcnMg JiYgaXNDdXJyZW50bHlEaXNwbGF5ZWRJbkZyYW1lKCkpCisgICAgaWYgKCFpc0N1cnJlbnRseURp c3BsYXllZEluRnJhbWUoKSkKKyAgICAgICAgcmV0dXJuIDA7CisgICAgaWYgKCFtX3Njcm9sbGJh cnMpCiAgICAgICAgIG1fc2Nyb2xsYmFycyA9IEJhckluZm86OmNyZWF0ZShtX2ZyYW1lLCBCYXJJ bmZvOjpTY3JvbGxiYXJzKTsKICAgICByZXR1cm4gbV9zY3JvbGxiYXJzLmdldCgpOwogfQogCiBC YXJJbmZvKiBET01XaW5kb3c6OnN0YXR1c2JhcigpIGNvbnN0CiB7Ci0gICAgaWYgKCFtX3N0YXR1 c2JhciAmJiBpc0N1cnJlbnRseURpc3BsYXllZEluRnJhbWUoKSkKKyAgICBpZiAoIWlzQ3VycmVu dGx5RGlzcGxheWVkSW5GcmFtZSgpKQorICAgICAgICByZXR1cm4gMDsKKyAgICBpZiAoIW1fc3Rh dHVzYmFyKQogICAgICAgICBtX3N0YXR1c2JhciA9IEJhckluZm86OmNyZWF0ZShtX2ZyYW1lLCBC YXJJbmZvOjpTdGF0dXNiYXIpOwogICAgIHJldHVybiBtX3N0YXR1c2Jhci5nZXQoKTsKIH0KIAog QmFySW5mbyogRE9NV2luZG93Ojp0b29sYmFyKCkgY29uc3QKIHsKLSAgICBpZiAoIW1fdG9vbGJh ciAmJiBpc0N1cnJlbnRseURpc3BsYXllZEluRnJhbWUoKSkKKyAgICBpZiAoIWlzQ3VycmVudGx5 RGlzcGxheWVkSW5GcmFtZSgpKQorICAgICAgICByZXR1cm4gMDsKKyAgICBpZiAoIW1fdG9vbGJh cikKICAgICAgICAgbV90b29sYmFyID0gQmFySW5mbzo6Y3JlYXRlKG1fZnJhbWUsIEJhckluZm86 OlRvb2xiYXIpOwogICAgIHJldHVybiBtX3Rvb2xiYXIuZ2V0KCk7CiB9CiAKIENvbnNvbGUqIERP TVdpbmRvdzo6Y29uc29sZSgpIGNvbnN0CiB7Ci0gICAgaWYgKCFtX2NvbnNvbGUgJiYgaXNDdXJy ZW50bHlEaXNwbGF5ZWRJbkZyYW1lKCkpCisgICAgaWYgKCFpc0N1cnJlbnRseURpc3BsYXllZElu RnJhbWUoKSkKKyAgICAgICAgcmV0dXJuIDA7CisgICAgaWYgKCFtX2NvbnNvbGUpCiAgICAgICAg IG1fY29uc29sZSA9IENvbnNvbGU6OmNyZWF0ZShtX2ZyYW1lKTsKICAgICByZXR1cm4gbV9jb25z b2xlLmdldCgpOwogfQogCiBET01BcHBsaWNhdGlvbkNhY2hlKiBET01XaW5kb3c6OmFwcGxpY2F0 aW9uQ2FjaGUoKSBjb25zdAogewotICAgIGlmICghbV9hcHBsaWNhdGlvbkNhY2hlICYmIGlzQ3Vy cmVudGx5RGlzcGxheWVkSW5GcmFtZSgpKQorICAgIGlmICghaXNDdXJyZW50bHlEaXNwbGF5ZWRJ bkZyYW1lKCkpCisgICAgICAgIHJldHVybiAwOworICAgIGlmICghbV9hcHBsaWNhdGlvbkNhY2hl KQogICAgICAgICBtX2FwcGxpY2F0aW9uQ2FjaGUgPSBET01BcHBsaWNhdGlvbkNhY2hlOjpjcmVh dGUobV9mcmFtZSk7CiAgICAgcmV0dXJuIG1fYXBwbGljYXRpb25DYWNoZS5nZXQoKTsKIH0KIAog TmF2aWdhdG9yKiBET01XaW5kb3c6Om5hdmlnYXRvcigpIGNvbnN0CiB7Ci0gICAgaWYgKCFtX25h dmlnYXRvciAmJiBpc0N1cnJlbnRseURpc3BsYXllZEluRnJhbWUoKSkKKyAgICBpZiAoIWlzQ3Vy cmVudGx5RGlzcGxheWVkSW5GcmFtZSgpKQorICAgICAgICByZXR1cm4gMDsKKyAgICBpZiAoIW1f bmF2aWdhdG9yKQogICAgICAgICBtX25hdmlnYXRvciA9IE5hdmlnYXRvcjo6Y3JlYXRlKG1fZnJh bWUpOwogICAgIHJldHVybiBtX25hdmlnYXRvci5nZXQoKTsKIH0KQEAgLTYzNiw3ICs3MDksOSBA QCBOYXZpZ2F0b3IqIERPTVdpbmRvdzo6bmF2aWdhdG9yKCkgY29uc3QKICNpZiBFTkFCTEUoV0VC X1RJTUlORykKIFBlcmZvcm1hbmNlKiBET01XaW5kb3c6OnBlcmZvcm1hbmNlKCkgY29uc3QKIHsK LSAgICBpZiAoIW1fcGVyZm9ybWFuY2UgJiYgaXNDdXJyZW50bHlEaXNwbGF5ZWRJbkZyYW1lKCkp CisgICAgaWYgKCFpc0N1cnJlbnRseURpc3BsYXllZEluRnJhbWUoKSkKKyAgICAgICAgcmV0dXJu IDA7CisgICAgaWYgKCFtX3BlcmZvcm1hbmNlKQogICAgICAgICBtX3BlcmZvcm1hbmNlID0gUGVy Zm9ybWFuY2U6OmNyZWF0ZShtX2ZyYW1lKTsKICAgICByZXR1cm4gbV9wZXJmb3JtYW5jZS5nZXQo KTsKIH0KQEAgLTY0NCwxNCArNzE5LDE4IEBAIFBlcmZvcm1hbmNlKiBET01XaW5kb3c6OnBlcmZv cm1hbmNlKCkgY29uc3QKIAogTG9jYXRpb24qIERPTVdpbmRvdzo6bG9jYXRpb24oKSBjb25zdAog ewotICAgIGlmICghbV9sb2NhdGlvbiAmJiBpc0N1cnJlbnRseURpc3BsYXllZEluRnJhbWUoKSkK KyAgICBpZiAoIWlzQ3VycmVudGx5RGlzcGxheWVkSW5GcmFtZSgpKQorICAgICAgICByZXR1cm4g MDsKKyAgICBpZiAoIW1fbG9jYXRpb24pCiAgICAgICAgIG1fbG9jYXRpb24gPSBMb2NhdGlvbjo6 Y3JlYXRlKG1fZnJhbWUpOwogICAgIHJldHVybiBtX2xvY2F0aW9uLmdldCgpOwogfQogCiBTdG9y YWdlKiBET01XaW5kb3c6OnNlc3Npb25TdG9yYWdlKEV4Y2VwdGlvbkNvZGUmIGVjKSBjb25zdAog ewotICAgIGlmIChtX3Nlc3Npb25TdG9yYWdlIHx8ICFpc0N1cnJlbnRseURpc3BsYXllZEluRnJh bWUoKSkKKyAgICBpZiAoIWlzQ3VycmVudGx5RGlzcGxheWVkSW5GcmFtZSgpKQorICAgICAgICBy ZXR1cm4gMDsKKyAgICBpZiAobV9zZXNzaW9uU3RvcmFnZSkKICAgICAgICAgcmV0dXJuIG1fc2Vz c2lvblN0b3JhZ2UuZ2V0KCk7CiAKICAgICBEb2N1bWVudCogZG9jdW1lbnQgPSB0aGlzLT5kb2N1 bWVudCgpOwpAQCAtNjc2LDcgKzc1NSw5IEBAIFN0b3JhZ2UqIERPTVdpbmRvdzo6c2Vzc2lvblN0 b3JhZ2UoRXhjZXB0aW9uQ29kZSYgZWMpIGNvbnN0CiAKIFN0b3JhZ2UqIERPTVdpbmRvdzo6bG9j YWxTdG9yYWdlKEV4Y2VwdGlvbkNvZGUmIGVjKSBjb25zdAogewotICAgIGlmIChtX2xvY2FsU3Rv cmFnZSB8fCAhaXNDdXJyZW50bHlEaXNwbGF5ZWRJbkZyYW1lKCkpCisgICAgaWYgKCFpc0N1cnJl bnRseURpc3BsYXllZEluRnJhbWUoKSkKKyAgICAgICAgcmV0dXJuIDA7CisgICAgaWYgKG1fbG9j YWxTdG9yYWdlKQogICAgICAgICByZXR1cm4gbV9sb2NhbFN0b3JhZ2UuZ2V0KCk7CiAKICAgICBE b2N1bWVudCogZG9jdW1lbnQgPSB0aGlzLT5kb2N1bWVudCgpOwpAQCAtNzA1LDcgKzc4Niw5IEBA IFN0b3JhZ2UqIERPTVdpbmRvdzo6bG9jYWxTdG9yYWdlKEV4Y2VwdGlvbkNvZGUmIGVjKSBjb25z dAogI2lmIEVOQUJMRShOT1RJRklDQVRJT05TKQogTm90aWZpY2F0aW9uQ2VudGVyKiBET01XaW5k b3c6OndlYmtpdE5vdGlmaWNhdGlvbnMoKSBjb25zdAogewotICAgIGlmIChtX25vdGlmaWNhdGlv bnMgfHwgIWlzQ3VycmVudGx5RGlzcGxheWVkSW5GcmFtZSgpKQorICAgIGlmICghaXNDdXJyZW50 bHlEaXNwbGF5ZWRJbkZyYW1lKCkpCisgICAgICAgIHJldHVybiAwOworICAgIGlmIChtX25vdGlm aWNhdGlvbnMpCiAgICAgICAgIHJldHVybiBtX25vdGlmaWNhdGlvbnMuZ2V0KCk7CiAKICAgICBE b2N1bWVudCogZG9jdW1lbnQgPSB0aGlzLT5kb2N1bWVudCgpOwpAQCAtNzg4LDcgKzg3MSw3IEBA IHZvaWQgRE9NV2luZG93Ojpwb3N0TWVzc2FnZVRpbWVyRmlyZWQoUGFzc093blB0cjxQb3N0TWVz c2FnZVRpbWVyPiB0KQogewogICAgIE93blB0cjxQb3N0TWVzc2FnZVRpbWVyPiB0aW1lcih0KTsK IAotICAgIGlmICghZG9jdW1lbnQoKSkKKyAgICBpZiAoIWRvY3VtZW50KCkgfHwgIWlzQ3VycmVu dGx5RGlzcGxheWVkSW5GcmFtZSgpKQogICAgICAgICByZXR1cm47CiAKICAgICBSZWZQdHI8TWVz c2FnZUV2ZW50PiBldmVudCA9IHRpbWVyLT5ldmVudChkb2N1bWVudCgpKTsKQEAgLTc5Niw3ICs4 NzksNyBAQCB2b2lkIERPTVdpbmRvdzo6cG9zdE1lc3NhZ2VUaW1lckZpcmVkKFBhc3NPd25QdHI8 UG9zdE1lc3NhZ2VUaW1lcj4gdCkKICAgICAvLyBHaXZlIHRoZSBlbWJlZGRlciBhIGNoYW5jZSB0 byBpbnRlcmNlcHQgdGhpcyBwb3N0TWVzc2FnZSBiZWNhdXNlIHRoaXMKICAgICAvLyBET01XaW5k b3cgbWlnaHQgYmUgYSBwcm94eSBmb3IgYW5vdGhlciBpbiBicm93c2VycyB0aGF0IHN1cHBvcnQK ICAgICAvLyBwb3N0TWVzc2FnZSBjYWxscyBhY3Jvc3MgV2ViS2l0IGluc3RhbmNlcy4KLSAgICBp ZiAoaXNDdXJyZW50bHlEaXNwbGF5ZWRJbkZyYW1lKCkgJiYgbV9mcmFtZS0+bG9hZGVyKCktPmNs aWVudCgpLT53aWxsQ2hlY2tBbmREaXNwYXRjaE1lc3NhZ2VFdmVudCh0aW1lci0+dGFyZ2V0T3Jp Z2luKCksIGV2ZW50LmdldCgpKSkKKyAgICBpZiAobV9mcmFtZS0+bG9hZGVyKCktPmNsaWVudCgp LT53aWxsQ2hlY2tBbmREaXNwYXRjaE1lc3NhZ2VFdmVudCh0aW1lci0+dGFyZ2V0T3JpZ2luKCks IGV2ZW50LmdldCgpKSkKICAgICAgICAgcmV0dXJuOwogCiAgICAgaWYgKHRpbWVyLT50YXJnZXRP cmlnaW4oKSkgewpAQCAtODE0LDcgKzg5Nyw5IEBAIHZvaWQgRE9NV2luZG93Ojpwb3N0TWVzc2Fn ZVRpbWVyRmlyZWQoUGFzc093blB0cjxQb3N0TWVzc2FnZVRpbWVyPiB0KQogCiBET01TZWxlY3Rp b24qIERPTVdpbmRvdzo6Z2V0U2VsZWN0aW9uKCkKIHsKLSAgICBpZiAoIW1fc2VsZWN0aW9uICYm IGlzQ3VycmVudGx5RGlzcGxheWVkSW5GcmFtZSgpKQorICAgIGlmICghaXNDdXJyZW50bHlEaXNw bGF5ZWRJbkZyYW1lKCkpCisgICAgICAgIHJldHVybiAwOworICAgIGlmICghbV9zZWxlY3Rpb24p CiAgICAgICAgIG1fc2VsZWN0aW9uID0gRE9NU2VsZWN0aW9uOjpjcmVhdGUobV9mcmFtZSk7CiAg ICAgcmV0dXJuIG1fc2VsZWN0aW9uLmdldCgpOwogfQpAQCAtMTIzMyw3ICsxMzE4LDkgQEAgRG9j dW1lbnQqIERPTVdpbmRvdzo6ZG9jdW1lbnQoKSBjb25zdAogCiBQYXNzUmVmUHRyPFN0eWxlTWVk aWE+IERPTVdpbmRvdzo6c3R5bGVNZWRpYSgpIGNvbnN0CiB7Ci0gICAgaWYgKCFtX21lZGlhICYm IGlzQ3VycmVudGx5RGlzcGxheWVkSW5GcmFtZSgpKQorICAgIGlmICghaXNDdXJyZW50bHlEaXNw bGF5ZWRJbkZyYW1lKCkpCisgICAgICAgIHJldHVybiAwOworICAgIGlmICghbV9tZWRpYSkKICAg ICAgICAgbV9tZWRpYSA9IFN0eWxlTWVkaWE6OmNyZWF0ZShtX2ZyYW1lKTsKICAgICByZXR1cm4g bV9tZWRpYS5nZXQoKTsKIH0KQEAgLTE4MzIsNyArMTkxOSw5IEBAIHZvaWQgRE9NV2luZG93Ojpz aG93TW9kYWxEaWFsb2coY29uc3QgU3RyaW5nJiB1cmxTdHJpbmcsIGNvbnN0IFN0cmluZyYgZGlh bG9nRmVhCiAjaWYgRU5BQkxFKFFVT1RBKQogU3RvcmFnZUluZm8qIERPTVdpbmRvdzo6d2Via2l0 U3RvcmFnZUluZm8oKSBjb25zdAogewotICAgIGlmICghbV9zdG9yYWdlSW5mbyAmJiBpc0N1cnJl bnRseURpc3BsYXllZEluRnJhbWUoKSkKKyAgICBpZiAoIWlzQ3VycmVudGx5RGlzcGxheWVkSW5G cmFtZSgpKQorICAgICAgICByZXR1cm4gMDsKKyAgICBpZiAoIW1fc3RvcmFnZUluZm8pCiAgICAg ICAgIG1fc3RvcmFnZUluZm8gPSBTdG9yYWdlSW5mbzo6Y3JlYXRlKCk7CiAgICAgcmV0dXJuIG1f c3RvcmFnZUluZm8uZ2V0KCk7CiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0RP TVdpbmRvdy5oIGIvU291cmNlL1dlYkNvcmUvcGFnZS9ET01XaW5kb3cuaAppbmRleCBjZGZkMzIy Li42MTM2MjRmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0RPTVdpbmRvdy5oCisr KyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRE9NV2luZG93LmgKQEAgLTk1LDYgKzk1LDggQEAgbmFt ZXNwYWNlIFdlYkNvcmUgewogICAgICAgICB2b2lkIHVucmVnaXN0ZXJQcm9wZXJ0eShET01XaW5k b3dQcm9wZXJ0eSopOwogCiAgICAgICAgIHZvaWQgY2xlYXIoKTsKKyAgICAgICAgdm9pZCBzdXNw ZW5kRm9yUGFnZUNhY2hlKCk7CisgICAgICAgIHZvaWQgcmVzdW1lRnJvbVBhZ2VDYWNoZSgpOwog CiAgICAgICAgIFBhc3NSZWZQdHI8TWVkaWFRdWVyeUxpc3Q+IG1hdGNoTWVkaWEoY29uc3QgU3Ry aW5nJik7CiAKQEAgLTQxMiwxMCArNDE0LDE1IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAg ICAgICAgIFByZXBhcmVEaWFsb2dGdW5jdGlvbiA9IDAsIHZvaWQqIGZ1bmN0aW9uQ29udGV4dCA9 IDApOwogICAgICAgICBib29sIGlzSW5zZWN1cmVTY3JpcHRBY2Nlc3MoRE9NV2luZG93KiBhY3Rp dmVXaW5kb3csIGNvbnN0IFN0cmluZyYgdXJsU3RyaW5nKTsKIAorICAgICAgICB2b2lkIGNsZWFy RE9NV2luZG93UHJvcGVydGllcygpOworICAgICAgICB2b2lkIGRpc2Nvbm5lY3RET01XaW5kb3dQ cm9wZXJ0aWVzKCk7CisgICAgICAgIHZvaWQgcmVjb25uZWN0RE9NV2luZG93UHJvcGVydGllcygp OworCiAgICAgICAgIFJlZlB0cjxTZWN1cml0eU9yaWdpbj4gbV9zZWN1cml0eU9yaWdpbjsKICAg ICAgICAgS1VSTCBtX3VybDsKIAogICAgICAgICBib29sIG1fc2hvdWxkUHJpbnRXaGVuRmluaXNo ZWRMb2FkaW5nOworICAgICAgICBib29sIG1fc3VzcGVuZGVkRm9yUGFnZUNhY2hlOwogCiAgICAg ICAgIEhhc2hTZXQ8RE9NV2luZG93UHJvcGVydHkqPiBtX3Byb3BlcnRpZXM7CiAKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRE9NV2luZG93UHJvcGVydHkuY3BwIGIvU291cmNlL1dl YkNvcmUvcGFnZS9ET01XaW5kb3dQcm9wZXJ0eS5jcHAKaW5kZXggODJmOTMxNi4uMzFlYTQ0ZSAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9ET01XaW5kb3dQcm9wZXJ0eS5jcHAKKysr IGIvU291cmNlL1dlYkNvcmUvcGFnZS9ET01XaW5kb3dQcm9wZXJ0eS5jcHAKQEAgLTQ5LDYgKzQ5 LDEzIEBAIHZvaWQgRE9NV2luZG93UHJvcGVydHk6OmRpc2Nvbm5lY3RGcmFtZSgpCiAgICAgbV9m cmFtZSA9IDA7CiB9CiAKK3ZvaWQgRE9NV2luZG93UHJvcGVydHk6OnJlY29ubmVjdEZyYW1lKEZy YW1lKiBmcmFtZSkKK3sKKyAgICBBU1NFUlQoZnJhbWUpOworICAgIEFTU0VSVCghbV9mcmFtZSk7 CisgICAgbV9mcmFtZSA9IGZyYW1lOworfQorCiB2b2lkIERPTVdpbmRvd1Byb3BlcnR5Ojp3aWxs RGV0YWNoUGFnZSgpCiB7CiAgICAgLy8gU3ViY2xhc3NlcyBzaG91bGQgb3ZlcnJpZGUgdGhpcyBm dW5jdGlvbiB0byBoYW5kbGUgdGhpcyBub3RpZmljYXRpb24uCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9wYWdlL0RPTVdpbmRvd1Byb3BlcnR5LmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0RP TVdpbmRvd1Byb3BlcnR5LmgKaW5kZXggY2QyZDgzNy4uYmM2NjAwZCAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvcGFnZS9ET01XaW5kb3dQcm9wZXJ0eS5oCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3BhZ2UvRE9NV2luZG93UHJvcGVydHkuaApAQCAtMzUsNiArMzUsNyBAQCBwdWJsaWM6CiAgICAg ZXhwbGljaXQgRE9NV2luZG93UHJvcGVydHkoRnJhbWUqKTsKIAogICAgIHZpcnR1YWwgdm9pZCBk aXNjb25uZWN0RnJhbWUoKTsKKyAgICB2aXJ0dWFsIHZvaWQgcmVjb25uZWN0RnJhbWUoRnJhbWUq KTsKICAgICB2aXJ0dWFsIHZvaWQgd2lsbERldGFjaFBhZ2UoKTsKIAogICAgIEZyYW1lKiBmcmFt ZSgpIGNvbnN0IHsgcmV0dXJuIG1fZnJhbWU7IH0K