27980 2009-08-04 04:38:04 -0700 Give an ability to WebKit to free statically allocated pointers before quit 2010-06-10 19:43:26 -0700 1 1 1 Unclassified WebKit WebKit Misc. 528+ (Nightly build) All All REOPENED P2 Enhancement --- 1 zherczeg webkit-unassigned ap carol commit-queue darin ddkilzer eric gyuyoung kbalazs laszlo.gombos manyoso tonikitoo xan.lopez yong.li.webkit oldest_to_newest 136966 0 zherczeg 2009-08-04 04:38:04 -0700 For this enhancement we should keep in mind, that freeing statically allocated pointers takes time, which may delay the quit process. This may not be desired in standalone web browsers. However, sometimes it is good to free statically allocated pointers but this method should not have a performance impact when it is disabled. 136967 1 34058 zherczeg 2009-08-04 04:39:13 -0700 Created attachment 34058 First draft patch 136968 2 zherczeg 2009-08-04 04:57:04 -0700 (In reply to comment #1) > Created an attachment (id=34058) [details] > First draft patch This patch is intended to be a draft. I would like to hear your opinion about this solution: - two new files are added to wtf directory: StaticPtr.h and StaticPtr.cpp - enabling FREE_STATIC_PTRS allows to free the pointers in a reversed creation order - Although c++ supports automatic destructors, I think it would not be wise to free the pointers in random order. - StdLibExtras.h is overwritten to support these pointers - Since heap.destroy() must be called for JSGlobalData before delete, I created a new derived class, because template specialization created multiple definitions for StaticPtr<JSGlobalData>::free() (See JSDOMWindowBase.cpp -> commonJSGlobalData()) - I am sure this patch should be cut to multiple parts. Do you have any suggestions for this? - Some destructors are only defined, but never implemented. Why? (~ImageLoadEventSender(), ~FontCache()) - And an iteresting observation: some AtomicStrings are defined as const, and some are not, but all of them seems like fixed strings. Should we change all of their type to "const AtomicString"? This patch works with Qt port nicely (after some fixes). 136991 3 manyoso 2009-08-04 08:20:52 -0700 I have grave doubts about the ability of this to work for all static pointers. In particular I think the global static AtomicStrings in HTMLNames will cause problems. Before seeing something like this go in I'd want to see it work for all the global statics and know that it wouldn't be a maintenance burden to keep it working when new ones are added or the order of them changed, etc. 137008 4 ddkilzer 2009-08-04 08:59:33 -0700 I think enabling/disabling static pointer destruction should also be controllable by a runtime option as well (once enabled with the compile-time option). 137012 5 eric 2009-08-04 09:06:36 -0700 if I remember correctly, Mac OS X's "leaks" tool, correctly ignores static pointer leaks. Can't valgrind do the same? with DEFINE_STATIC_LOCAL we even put them all into a custom section, which should make them super-easy to ignore. ;) 137025 6 zherczeg 2009-08-04 09:31:39 -0700 (In reply to comment #4) I think this would be an easy feature since WTF::StaticPtrBase::freeStaticPtrs() must be called from the code itself. With a runtime option we can easly prevent the call of this function. 137027 7 zherczeg 2009-08-04 09:38:44 -0700 (In reply to comment #5) The problem is with the transitive allocations. Valgrind does not track the use of 'this' pointers. Let A be a static object, and it allocates a B object, which also allocates a C object. A()->B()->C() In this case valgrind cannot see that B and C are belongs to the A object, and report them as memory errors. Perhaps it would be too time consuming to detect these situations. 137073 8 34058 darin 2009-08-04 11:40:01 -0700 Comment on attachment 34058 First draft patch I think it's a good idea to make our globals more consistent. But probably not such a great idea to start what could be a massive project without a good idea how we'll keep test this and keep it working as each global is added. Is the goal here to make memory leak debugging tools work better? Or is there value beyond that? Could you write a document about how to use StaticPtr correctly? I'd like to review that to get an idea how we would make sure we were using it properly on various platforms. Would we consider it a coding style violation to make a global that doesn't use StaticPtr? As part of this are you proposing that DEFINE_STATIC_LOCAL be the only legal way to make global variables? I do not want to sign up everyone on the project to write a lot of code to deallocate every last object if this code isn't actually useful to someone on one of the ports. I need to hear more justification about why to take on all this additional complexity. Making all the global data structures practical to delete is an enormous task that this patch barely scratches the surface of. An excellent economy in the project at the moment is that we don't try to write all the deallocation code for all the global objects. > wtf/RefCountedLeakCounter.cpp \ > wtf/TypeTraits.cpp \ > + wtf/StaticPtr.cpp \ > wtf/unicode/CollatorDefault.cpp \ I believe this is supposed to be in alphabetic order, so it should come before TypeTraits.cpp. > +#include "config.h" > + > +#include "StaticPtr.h" Extra blank line here. > + StaticPtrBase() { > +#if ENABLE(FREE_STATIC_PTRS) > + m_next = head(); > + m_head = this; > +#endif > + }; Extra semicolon here. I think this would might read better if the inline implementation was outside the class definition since it has an #if in it. There's no reason we have to have the ifdef in here. But a better alternative would be to just leave out the constructor definition entirely when FREE_STATIC_PTRS is not enabled. If there are no constructor definitions then the class automatically will have an empty default constructor which is what we want. > + StaticPtr(PtrType ptr) : StaticPtrBase(), m_ptr(ptr) { }; > + StaticPtr() : StaticPtrBase(), m_ptr(0) { }; > + ~StaticPtr() { }; No need to explicitly initialize StaticPtrBase since there are no constructor arguments. Extra semicolons here. No need to explicitly declare the destructor -- this is the same as the compiler-generated constructor and it's much better style to not declare it. > + PtrType operator=(PtrType); This seems like bad style. Since values stored in this pointer will be freed, I think we want this to use some explicit style like OwnPtr rather than plain assignment. > + ValueType& operator=(ValueType&); This seems quite strange. Why do we need to allow assignment to the pointer of a non-const pointer of value type? This seems very dangerous, since the value type will later be destroyed. > + PtrType operator&(); > + PtrType operator&() const; Do we need this operator? What coding style is going to require this? > + // Condition operators > + bool operator!(); Should be const. Please look at OwnPtr for some ideas on how to make this class work. This should be much closer to OwnPtr which has exactly the same semantic. > +protected: I believe these members should be private, not protected. > +#if !PLATFORM(QT) > delete data; > +#endif This seems clearly wrong. Did you mean this to be a FREE_STATIC_PTRS ifdef? > + StaticGlobalData() : WTF::StaticPtr<JSGlobalData>() { }; This constructor is entirely unnecessary. > +protected: Should be private, not protected. > +#if ENABLE(FREE_STATIC_PTRS) > + virtual void free() { > + m_ptr->heap.destroy(); > + delete m_ptr; > + } > +#endif Incorrect brace style here. > +ALWAYS_INLINE JSGlobalData* StaticGlobalData::operator=(JSGlobalData* value) > +{ > + m_ptr = value; > +} Seems poor to use plain assignment of a raw pointer for an operation that transfers ownership. > - return globalData; > + return &globalData; This line of code seems wrong. You want a JSGlobalData*, not a StaticGlobalData*. This is a poor use of operator overloading. review- for now based on the specific problems with the patch, but I do also have project-direction concerns here, although I am not using reviewer power to try to enforce those. 137089 9 zherczeg 2009-08-04 12:22:29 -0700 (In reply to comment #8) > (From update of attachment 34058 [details]) > I think it's a good idea to make our globals more consistent. Thank you! > But probably not such a great idea to start what could be a massive project > without a good idea how we'll keep test this and keep it working as each global > is added. Totally agree. It is not my custom to submit a patch in such draft phase, but I feel this project is more about finding a way to define globals which everyone _likes_, than the actual code itself. I know this is risky, may never be a successful project, but it is worth a try, isn't it? :) I will fix typos and answer to all your questions tomorrow. Once again, thank you for your detailed feedback! 137099 10 ddkilzer 2009-08-04 13:02:51 -0700 (In reply to comment #8) > (From update of attachment 34058 [details]) > I do not want to sign up everyone on the project to write a lot of code to > deallocate every last object if this code isn't actually useful to someone on > one of the ports. I need to hear more justification about why to take on all > this additional complexity. Making all the global data structures practical to > delete is an enormous task that this patch barely scratches the surface of. Being able to "reset" WebCore to its pre-cached-local-statics state would be useful for the iPhone OS port. We don't care about tearing down objects when exiting a process, but being able to clear out the cached static variables on-demand would be useful. 137297 11 34131 zherczeg 2009-08-05 05:54:36 -0700 Created attachment 34131 Second draft patch 137302 12 zherczeg 2009-08-05 06:45:06 -0700 Unfortunately there are several ways to define global variables, I don't think it is possible to merge them into a single preprocessor define: - using DEFINE_STATIC_LOCAL * creates static global variables inside a function * the object is created before the first call of the function - using DEFINE_GLOBAL (WebCore/platform/StaticConstructors.h) * these variables cannot be freed, since they are allocated on the heap * workaround: wrapper classes Any better idea? * fortunately it is a rarely used directive (only two classes: AtomicString and QualifiedName) - Plain global variables [static] class* [class_name::]variable; * I will try to use a static alayzer tool to find these objects * my propose: use '[static] WTF::StaticPtr<class> [class_name::]variable;' instead of them in the future WTF::StaticPtr similar to OwnPtr, except: - only one object can be assigned to it. The object can be passed to the constructor, or assigned later. > Is the goal here to make memory leak debugging tools work better? Or is there > value beyond that? Ok, you win here :) tonikitoo and ddkilzer mentioned they could use this feature. I also plan to use it for embedded devices, but first I would like to know whether it is possible to do it. But right know they are just plans, nothing more. > Could you write a document about how to use StaticPtr correctly? I'd like to > review that to get an idea how we would make sure we were using it properly on > various platforms. Would we consider it a coding style violation to make a > global that doesn't use StaticPtr? "WTF::StaticPtr<class>" would be a substitution of "class*", and it would mimic the default C++ pointer behaviour as possible (with operator overloading). I hope "class&" definitions are rare except for DEFINE_STATIC_LOCAL. > As part of this are you proposing that DEFINE_STATIC_LOCAL be the only legal > way to make global variables? No. DEFINE_STATIC_LOCAL has a special purpose, and looks like not cover all global variables. > I do not want to sign up everyone on the project to write a lot of code to > deallocate every last object if this code isn't actually useful to someone on > one of the ports. I need to hear more justification about why to take on all > this additional complexity. Making all the global data structures practical to > delete is an enormous task that this patch barely scratches the surface of. Well I think a global policy can be: - either do not write destructors (someone else can do later) - or write a working, and tested constructor. > > +#if !PLATFORM(QT) > > delete data; > > +#endif This delete cause a segmentation fault in Qt. It has not appeared until now, since this destructor is never called. (Although this code may have worked, when the destructor was implemented, but it was not covered by regression tests, and has gone wrong eventually). I think if we write a destructor, we have to maintain it as the other codes, and should cover them in regression tests. This may be a good aim for this project. I have fixed the typos and other things (the looks much better now), except: > > + PtrType operator=(PtrType); > > This seems like bad style. Since values stored in this pointer will be freed, I > think we want this to use some explicit style like OwnPtr rather than plain > assignment. Could you show me an example here? Anyway, a plain QtLauncher now frees 761 objects (without crash). After some browsing it grows to 812. 137307 13 manyoso 2009-08-05 08:24:38 -0700 (In reply to comment #12) > - using DEFINE_GLOBAL (WebCore/platform/StaticConstructors.h) > * these variables cannot be freed, since they are allocated on the heap > * workaround: wrapper classes > Any better idea? > * fortunately it is a rarely used directive (only two classes: AtomicString > and QualifiedName) And those classes have lots of instances. In fact, I'd wager the majority of static globals you'll find in WebCore are of this type. What's more, have fun trying to destruct them in the right order. One other concern I don't think you've considered is what happens when these global statics are allocated on the heap with placement new? This occurs right now in WebCore if you look carefully :) With placement new allocated global statics you'll have to explicitly call the destructor. Not sure how you are going to automate that one. 137323 14 zherczeg 2009-08-05 09:54:33 -0700 > And those classes have lots of instances. In fact, I'd wager the majority of > static globals you'll find in WebCore are of this type. What's more, have fun > trying to destruct them in the right order. > > One other concern I don't think you've considered is what happens when these > global statics are allocated on the heap with placement new? This occurs right > now in WebCore if you look carefully :) With placement new allocated global > statics you'll have to explicitly call the destructor. Not sure how you are > going to automate that one. In may patch a specialized wrapper class inherited from StaticPtrBase solves this problem (in WebCore at least). See GlobalAtomicString and GlobalQualifiedName. The placement news are replaced by a macro call (INIT_GLOBAL) which has a different behaviour depending on ENABLE(FREE_STATIC_PTRS). (I belive placement news are ugly, and now it looks much better) Adam, if you really want I can stop this task. I don't want to force anything if you don't like it. 137340 15 manyoso 2009-08-05 10:39:05 -0700 (In reply to comment #14) > > And those classes have lots of instances. In fact, I'd wager the majority of > > static globals you'll find in WebCore are of this type. What's more, have fun > > trying to destruct them in the right order. > > > > One other concern I don't think you've considered is what happens when these > > global statics are allocated on the heap with placement new? This occurs right > > now in WebCore if you look carefully :) With placement new allocated global > > statics you'll have to explicitly call the destructor. Not sure how you are > > going to automate that one. > > In may patch a specialized wrapper class inherited from StaticPtrBase solves > this problem (in WebCore at least). See GlobalAtomicString and > GlobalQualifiedName. The placement news are replaced by a macro call > (INIT_GLOBAL) which has a different behaviour depending on > ENABLE(FREE_STATIC_PTRS). (I belive placement news are ugly, and now it looks > much better) I see your second patch is special casing them, but it is not deleting them as you are not explicitly calling the destructor you are just deleting them as normal. > Adam, if you really want I can stop this task. I don't want to force anything > if you don't like it. No, feel free to continue I just have doubts that this method of dealing with it will be robust enough to deal with the stated goal without encuring a lot of new requirements. 137846 16 34265 zherczeg 2009-08-07 04:19:09 -0700 Created attachment 34265 Third patch The whole thing is in much better shape. I hope you will like it. 138147 17 eric 2009-08-07 14:24:02 -0700 In general I don't really like this idea. Ripping things down during quit is only useful for leak debugging. On Mac OS X we've not had this trouble with our leak debugging tools to my knowledge. I'm sad that we would have to jump through hoops for valgrind. But maybe I'm missing something obvious. Darin Adler is likely your best bet for a reviewer. He's still the best source for approval on such large sweeping changes. The man has more c++-fu in his pinky finger than all of me does. ;) 138936 18 34549 zherczeg 2009-08-11 04:42:13 -0700 Created attachment 34549 Fourth patch Actually WebCore is much better written than I expected, so uniforming the constant pointer handling is not that hard. 138937 19 zherczeg 2009-08-11 04:45:35 -0700 After starting and quiting from QtLauncher, the leak reduced from: ==18154== LEAK SUMMARY: ==18154== definitely lost: 66,632 bytes in 496 blocks. ==18154== possibly lost: 25,536 bytes in 7 blocks. ==18154== still reachable: 241,690 bytes in 5,595 blocks. ==18154== suppressed: 0 bytes in 0 blocks. Number of loss records: 295 To: ==6905== LEAK SUMMARY: ==6905== definitely lost: 344 bytes in 2 blocks. ==6905== indirectly lost: 20 bytes in 1 blocks. ==6905== possibly lost: 744 bytes in 3 blocks. ==6905== still reachable: 117,418 bytes in 2,859 blocks. ==6905== suppressed: 0 bytes in 0 blocks. Number of loss records: 131 And 50k from this space is a debug structure used by StructureID-s. 138976 20 yong.li.webkit 2009-08-11 08:50:37 -0700 Is there a specified webkit name pattern for global variables? In this patch, I've seen both "foo" (same as local variables) and "gFoo". I use "g_Foo" in my code, but Eric says it's wrong. So what pattern should be used for global variables? 138978 21 yong.li.webkit 2009-08-11 08:51:27 -0700 (In reply to comment #20) > Is there a specified webkit name pattern for global variables? In this patch, > I've seen both "foo" (same as local variables) and "gFoo". I use "g_Foo" in my > code, but Eric says it's wrong. So what pattern should be used for global > variables? correction: should be "g_foo" 138997 22 34549 darin 2009-08-11 09:50:30 -0700 Comment on attachment 34549 Fourth patch > +#include "wtf/StaticPtr.h" Includes of wtf from WebCore use angle brackets. <wtf/StaticPtr.h>, not "wtf/StaticPtr.h". > +static WTF::StaticPtr<JSGlobalData> sharedInstancePtr; This won't work with the restrictions we need to work as a Mac OS X framework. We can't have any static destructors in our Mac OS X system frameworks as a matter of policy to make process exit fast. No objects with destructors as globals or statics. That's the reason for the DEFINE_STATIC_LOCAL macro. A major reason this patch is unacceptable is that this creates many global objects with destructors. I didn't review further because that's a major problem with the current version. 139036 23 zherczeg 2009-08-11 10:49:13 -0700 > This won't work with the restrictions we need to work as a Mac OS X framework. > We can't have any static destructors in our Mac OS X system frameworks as a > matter of policy to make process exit fast. No objects with destructors as > globals or statics. That's the reason for the DEFINE_STATIC_LOCAL macro. I have realized why DEFINE_STATIC_LOCAL (probably DEFINE_GLOBAL is even better example, which use placement new to hide the destructor) defined, so the destructor of WTF::StaticPtr is empty of course, and never intended to do anything... 139044 24 darin 2009-08-11 11:15:23 -0700 (In reply to comment #23) > I have realized why DEFINE_STATIC_LOCAL (probably DEFINE_GLOBAL is even better > example, which use placement new to hide the destructor) defined, so the > destructor of WTF::StaticPtr is empty of course, and never intended to do > anything... Please check and see what the compiler generates for this before giving a patch that deploys it in tons of places. I'm pretty sure that an empty virtual function will indeed generate a static destructor, although a pointless empty one. There's a good chance it will even change the virtual pointer on the object. Anyway, if the technique works that's fine but it's pointless to review a patch to deploy the technique before you've tested it! 139060 25 yong.li.webkit 2009-08-11 12:02:42 -0700 (In reply to comment #2) > (In reply to comment #1) > > Created an attachment (id=34058) [details] [details] > > First draft patch > > This patch is intended to be a draft. I would like to hear your opinion about > this solution: > - two new files are added to wtf directory: StaticPtr.h and StaticPtr.cpp > - enabling FREE_STATIC_PTRS allows to free the pointers in a reversed > creation order > - Although c++ supports automatic destructors, I think it would not be wise > to free the pointers in random order. Why not just let ~StaticPtr() to free memory? Static objects should be destructed in the reverse order of construction, as when a static object is constructed, atexit will be pushed to onexit queue. Also, you can always destruct all static objects by calling _cexit() explicitly. The only benefit of using a chain I can see is that it destructs all object first, and then frees all the memory, so that when a destructor accesses to another destructed static object, it won't result segment fault... 139061 26 yong.li.webkit 2009-08-11 12:03:49 -0700 (In reply to comment #25) > (In reply to comment #2) > > (In reply to comment #1) > > > Created an attachment (id=34058) [details] [details] [details] > > > First draft patch > > > > This patch is intended to be a draft. I would like to hear your opinion about > > this solution: > > - two new files are added to wtf directory: StaticPtr.h and StaticPtr.cpp > > - enabling FREE_STATIC_PTRS allows to free the pointers in a reversed > > creation order > > - Although c++ supports automatic destructors, I think it would not be wise > > to free the pointers in random order. > > Why not just let ~StaticPtr() to free memory? Static objects should be > destructed in the reverse order of construction, as when a static object is > constructed, atexit will be pushed to onexit queue. Also, you can always > destruct all static objects by calling _cexit() explicitly. The only benefit of > using a chain I can see is that it destructs all object first, and then frees > all the memory, so that when a destructor accesses to another destructed static > object, it won't result segment fault... correction: atexit pushes the destructor to the onexit stack 141898 27 kbalazs 2009-08-21 09:53:18 -0700 A branch had been set up on gitorius where I tried to extend the patch(es) for all statics: git@gitorious.org/~balazs/qtwebkit/balazs-clone/commits/free-static-ptrs. Actually it is tested only in interpreter mode (DEFINES='ENABLE_JIT=0 ENABLE_YARR_JIT=0' at the end of the build-webkit ... command line) of JSC because I had some problems with JIT. 143788 28 38848 zherczeg 2009-09-01 01:22:07 -0700 Created attachment 38848 Fifth patch Sorry for my long silence, I was away on Holiday. From the start of this week I am back again and has rewritten most of the core parts of the patch. Global pointers are changed to structures (these structures are allocated on .bss (according to objdump). They are simple C structures -> no constructors or destructors are called (tested by gdb)). Now every structure has an own separate file () The new files are: - contains a C struct create mode 100644 JavaScriptCore/wtf/GlobalPtr.h - contains a C++ class create mode 100644 JavaScriptCore/wtf/LocalStaticArrayPtr.h - contains a C++ class create mode 100644 JavaScriptCore/wtf/LocalStaticPtr.h - freeing static variables create mode 100644 JavaScriptCore/wtf/StaticPtrBase.cpp - contains a C struct create mode 100644 JavaScriptCore/wtf/StaticPtrBase.h There is no inheritance, since a struct is converted to class if inheritance applied (was strange for me, but it is true). Instead StaticPtrBase must be the first member of its descendants. The descendants must not contain any virtual method (to avoid vptr). 144846 29 zherczeg 2009-09-04 10:01:44 -0700 Darin, could you take a look at the patch, please. I had a qestion on webkit-dev about whether should I unifying the names of global variables along this work. What is your opinion? 144850 30 darin 2009-09-04 10:07:22 -0700 Zoltan, I understand your enthusiasm for this project and I am willing to review when I have the time. But this patch is not a high priority for me. I would like this to be done right if it is done, I still don't think it's worth doing. Who exactly is planning to take advantage of this change, and for what? Is the goal making leak-detection tools work better? Is someone planning to unload the WebKit library without exiting the process it's hosted in? You say "sometimes it is good to free statically allocated pointers". When? 144858 31 darin 2009-09-04 10:23:04 -0700 (In reply to comment #29) > I had a qestion on > webkit-dev about whether should I unifying the names of global variables along > this work. What is your opinion? I think it's best to do renames separately. I'm always tempted to do such things together and it tends to make patches harder to review, and if there is a problem later, more conflicts and difficulty rolling a change out. 144862 32 yong.li.webkit 2009-09-04 10:40:28 -0700 (In reply to comment #30) > > You say "sometimes it is good to free statically allocated pointers". When? One case is that webkit is used as a dll, and the dll can be loaded and unloaded multiple times. Those global pointers will leak in this case. But I guess an OwnPtr or something should be good for this purpose. The dtors will be called when the dll is unloaded. Also there is a c_exit or _cexit in MSVC to explicitly call all dtors for global/static objects. When constructing a global object, the compiler will add the dtor to the exit stack with atexit. So the order of destruction is reverse order of construction. and explicitly calling c_exit() also clears the stack, so no need to worry about the problem of calling dtor twice. Is there a compiler that doesn't guarantee this? ENABLE(FREE_STATIC_PTRS) is good for not affecting people who don't want to use it. But GlobalPtr must be freed by explicit call to deletePtr(). That's not an easy life. Considering a coding guideline that requires using same macros for global objects. What are the goals? 1. construct and destruct global objects in safe order 2. ability to free all memory allocated by global pointers 3. ability to leave those global pointers as leaks. We can just define a GlobalPtr same as OwnPtr, except there's a compile-time switch for deleting the object in destructor or not. That would be simple but enough for most ports I guess. 144863 33 darin 2009-09-04 10:44:20 -0700 (In reply to comment #32) > One case is that webkit is used as a dll, and the dll can be loaded and > unloaded multiple times. Is there someone who wants to use WebKit this way? Is the global variable issue the only issue preventing this? I think the project to make it so you can load and unload WebKit multiple times is a pretty big project. And we should not do it unless we have to. 144869 34 yong.li.webkit 2009-09-04 10:57:34 -0700 (In reply to comment #33) > (In reply to comment #32) > > One case is that webkit is used as a dll, and the dll can be loaded and > > unloaded multiple times. > > Is there someone who wants to use WebKit this way? Yes. for example, webkit is used to render html page in other applications, like a COM object provider, or other ways. > Is the global variable issue the only issue preventing this? > I think the project to make it so you can load and unload WebKit multiple times > is a pretty big project. And we should not do it unless we have to. There may be other resources to consider, but those static global pointers are hard to be explicitly freed outside of WebCore. Loading/unloading webkit dll multiple times is fine except the leaks. 144878 35 zherczeg 2009-09-04 11:31:06 -0700 (In reply to comment #30) > Zoltan, I understand your enthusiasm for this project and I am willing to > review when I have the time. But this patch is not a high priority for me. > > I would like this to be done right if it is done, I still don't think it's > worth doing. > > Who exactly is planning to take advantage of this change, and for what? Is the > goal making leak-detection tools work better? Is someone planning to unload the > WebKit library without exiting the process it's hosted in? > > You say "sometimes it is good to free statically allocated pointers". When? Perhaps this patch will be destined as an experimental solution. The big qestion is: whether it is possible to make WebKit to an unloadable dll / shared object. The answer is unknown at this moment, since noone tried it before, so noone will start to consider this as an option because they feel this is a too risky project. We just close the way before an interesting feature without trying it. First, I try to sort all global variables into groups. How globals are declared and used in WebKit. Is there a redundant form, or all of them are necessary (now I have only 3 groups). Second, are the globals handled correctly. Some globals are change their value, and we must make sure (in debug mode) their previous value is freed. Right now I found only one exception to the reversed free order: WebCore::pageCache() is allocated too early in QtLauncher (using setMaximumPagesInCache), and its destructor frees a timer object. The calling of timer::stop() causes segmentaion fault at that time. I don't insist on the current form of global handling. If all globals are declared as templates, anyone can change their behaviour (and make GlobalPtr to a class if someone prefers that way). The patch really helps to valgrind: a simple QtLauncher start-exit process left around 300k leak, and this is reduced to 100k. The number of loss records decreased from 400 to 100. It is much easier to find real leaks from that 100 loss records (especially because the remaing loss records are belongs to font config and Qt internals). There is one really good news: the work started 1.5 monts ago, and I had no trouble upgrading it to the most recent version so far. Looks like maintaining of this patch is not a hard work (hopefully). 146134 36 39334 zherczeg 2009-09-10 02:07:35 -0700 Created attachment 39334 Sixth patch Just a regular update. Many new pointers are freed now. 149430 37 39334 darin 2009-09-23 10:23:07 -0700 Comment on attachment 39334 Sixth patch I really dislike the direction this is going. Adding many new classes and lots of complexity. And lots of code that won't compile in most platforms, so will cause platform-specific build failures. I don't think this is worth it. > +#include "wtf/GlobalPtr.h" Includes of wtf should be: #include <wtf/GlobalPtr.h> I think GlobalPtr should probably be named GlobalOwnPtr and have an interface as close as possible to the OwnPtr class, since it's a sort of hybrid between OwnPtr and a raw pointer. > +WTF::GlobalPtr<JSGlobalData> sharedInstancePtr; Items in the WTF namespace are supposed to have "using WTF::GlobalPtr" in the header and not be qualified by WTF explicitly in code. I don't understand why it's better to move the actual pointer outside of a function. It still seems a good programming style to scope a global variable inside a function when that's possible. > +#include "wtf/FastMalloc.h" > +#include "wtf/StaticPtrBase.h" Need to use angle brackets for these includes. > +// All HashTables are static and generated by a script (see the comment in the header file) Need a period at the end of this sentence. > +struct HashTableDeleter { > +public: No need for "public" since this is a struct. A struct where everything is public should omit the public: part. > + WTF::StaticPtrBase m_base; No WTF:: prefix. > + HashTable* m_hashTable; > + > + static void free(void* ptr) > + { > + reinterpret_cast<HashTableDeleter*>(ptr)->m_hashTable->deleteTable(); This should be a static_cast, not reinterpret_cast. > +#if ENABLE(FREE_STATIC_PTRS) > + HashTableDeleter* deleter = reinterpret_cast<HashTableDeleter*>(fastMalloc(sizeof(HashTableDeleter))); This should be a static_cast, not a reinterpret_cast. Why use fastMalloc here and not new? > +// The classes here are defined as structs to avoid > +// the call of C++ constructors and destructors This comment and technique is incorrect. Using the keyword "struct" instead of "class" has no effect on the presence of C++ constructors and destructors. There are only two differences between class and struct: 1) Default visibility is public for struct, private for class. 2) Visual Studio treats struct and class as distinct for type identity and name mangling. This goes against the C++ standard, but requires that we be consistent if we want compatibility with that compiler. Otherwise, they are identical and struct vs. class has no effect on whether something has a non-trivial constructor and destructor. > + // Has NO C++ constructor The terminology here is strange. Why say "C++" when all this code is C++? The comments in this file are not clarifying what this class is for. They need to say that it's intended to be used for global data. And to satisfy our requirement that there be no global destructors in the WebKit projects if FREE_STATIC_PTRS is not set, they must have no non-trivial destructor. And to satisfy our requirement that there be no global constructors in the WebKit projects they must have no non-trivial constructor. Some of that needs to be said. > + void set(PtrType); > + void setPtr(PtrType); I have no idea how set differs from setPtr. Does not seem to be good design to have both, but perhaps there is some real difference here. If so we need to use a more descriptive name. For example, in other places we use terms like "adopt". Somehow I guess setPtr means "take this pointer value, but not ownership". And if so, it seems very strange design to have a pointer that sometimes owns what it points to, and other times does not. Seems like overkill to have that. If it's not going to own something, then we can use a raw pointer. > + void operator=(PtrType); And also have an = operator. Why have all three of these? > + void deletePtr(); What is this for? > +#if ENABLE(FREE_STATIC_PTRS) > + StaticPtrBase m_base; > +#endif This makes every global pointer 8 bytes. Is this really the best we can do? > + delete reinterpret_cast<GlobalPtr<T>*>(ptr)->get(); This should be a static_cast, not reinterpret_cast. > + void setFree(StaticPtrBaseFree func) The type name StaticPtrBaseFree is not so good, because "free" is a verb or adjective, not a noun. Types normally should be nouns. Instead of "func" please use "function". There's no need to abbreviate. Except in certain cases where something needs to be > + // Detect memory leaks > + ASSERT(!m_ptr || (m_ptr == value)); The comment here is confusing. How does this comment "detect memory leaks"? I think it's strange to have this function allow you to set the same value multiple times, given that the set operation is really "give ownership". Why do we need that flexibility? I think the set function should probably be named "adopt" if it is taking ownership. > +template<typename T> > +ALWAYS_INLINE void GlobalPtr<T>::operator=(PtrType value) Do we really need this? I think assignment is confusing when it transfers ownership of a raw pointer, so it would be best to leave this out unless it's really needed. > +// Wrapper class for arrays, which assigned to a static variable > +// By default, it behaves like a simple C++ array without performance overhead These comments need periods. The comment leaves out what really matters, which is what this class is for! It says that by default it works as a simple array, but what does it do when not default? > + delete[] reinterpret_cast<LocalStaticArrayPtr<T>*>(ptr)->m_ptr; This should be static_cast. > + while (current) { > + // Some pointers (i.e: HashTableDeleter) frees themself "Some pointers free themselves." would be correct grammar. The Latin abbreviation "i.e." means "in other words". I think you mean "for example" here and that should be written either as "for example" or as "e.g." if you want to use the Latin abbreviation. The comment is *almost* helpful, but is just a bit too obscure. The comment needs to be more explicit and say clearly that we follow the next pointer before calling free because in some cases the free function will delete the item including the next pointer. > + ptr->m_free(reinterpret_cast<void*>(ptr)); There is no need for this cast at all. > + // Perhaps a double linked list may be suitable if remove() called frequently This is a confusing comment, because it does not say what the tradeoff is. Why aren't we using a doubly-linked list now? I suggest we not even include the remove() function unless we need it. And if we need it we should have the doubly-linked list from the start, unless there's a clear reason we should not. > + StaticPtrBase* current = head(); > + if (current == this) { > + m_head = current->next(); > + return; > + } > + > + while (current->next() != this) { > + current = current->next(); > + ASSERT(current); > + } > + current->m_next = next(); > +} It's a little strange to use next() to get the pointer and then m_next to set it. There's no abstraction there, just slight confusion, by having some of each. There are cleaner ways to write the linked list algorithms that require fewer special cases and don't fetch current->next() multiple times, but this is probably OK as-is. > + // Methods > + void append(); > + void remove(); This comment is not good. First of all, "methods" is not a C++ term, and second, what does that comment add? > + static StaticPtrBase* m_head; > + StaticPtrBase* m_next; > + StaticPtrBaseFree m_free; > + > + static inline StaticPtrBase* head() { return m_head; } > + inline StaticPtrBase* next() { return m_next; } The use of inline here does no good -- functions defined inside a C++ class are always treated as if they had "inline" specified, so there's no point in saying it explicitly. It doesn't make sense to have both public data members and public function members that get at that same data. Either the data should be private, or the functions should be omitted. > +#if !PLATFORM(QT) > delete data; > +#endif Why is Qt a special case here? This is very confusing! > --- a/WebCore/WebCore.pro > +++ b/WebCore/WebCore.pro > @@ -1044,6 +1044,7 @@ SOURCES += \ > html/HTMLViewSourceDocument.cpp \ > html/ImageData.cpp \ > html/PreloadScanner.cpp \ > + html/TimeRanges.cpp \ > html/ValidityState.cpp \ > inspector/ConsoleMessage.cpp \ > inspector/InspectorBackend.cpp \ > @@ -2629,7 +2630,6 @@ contains(DEFINES, ENABLE_VIDEO=1) { > html/HTMLMediaElement.cpp \ > html/HTMLSourceElement.cpp \ > html/HTMLVideoElement.cpp \ > - html/TimeRanges.cpp \ > platform/graphics/MediaPlayer.cpp \ > rendering/MediaControlElements.cpp \ > rendering/RenderVideo.cpp \ Can you make the above change in a separate check-in first? > +#if !ENABLE(FREE_STATIC_PTRS) > ~IdentifierRep() > { > // IdentifierReps should never be deleted. > ASSERT_NOT_REACHED(); > } > +#endif This is a good example of something that's probably wrong. I think there is storage to be freed here. Simply changing things so it compiles means that we have a storage leak in the FREE_STATIC_PTRS case. This patch is way too big, doing too much at once. It is easy to miss mistakes like this in a patch of this size. > static PassRefPtr<CSSInitialValue> createExplicit() > { > - static CSSInitialValue* explicitValue = new CSSInitialValue(false); > - return explicitValue; > + DEFINE_STATIC_LOCAL(CSSInitialValue, explicitValue, (false)); > + return &explicitValue; > } > static PassRefPtr<CSSInitialValue> createImplicit() > { > - static CSSInitialValue* explicitValue = new CSSInitialValue(true); > - return explicitValue; > + DEFINE_STATIC_LOCAL(CSSInitialValue, explicitValue, (true)); > + return &explicitValue; > } These kinds of changes should go in first, in a separate patch. > - delete defaultStyle; > - delete simpleDefaultStyleSheet; > + defaultStyle.deletePtr(); > + simpleDefaultStyleSheet.deletePtr(); > defaultStyle = new CSSRuleSet; > simpleDefaultStyleSheet = 0; This is a bad idiom. The global pointer is a variation on OwnPtr, and the right idiom there is to delete things automatically when assigning a new value. Having an explicit deletePtr makes it too easy to use it wrong. It's extremely important to have a patch that creates the mechanism separate from a patch that deploys it in so many places. By making a single large patch you're making it very hard to review, and there are lots of things you will have to change now based on my feedback. I can't read the rest of this right now. 155257 38 ap 2009-10-16 14:44:08 -0700 *** Bug 30408 has been marked as a duplicate of this bug. *** 155851 39 carol 2009-10-19 13:04:39 -0700 I believe that the value of being able to clean up static pointers goes well beyond reporting memory leaks. There are operating systems that run on embedded devices that use WebKit that run all applications in one process space. They unload the WebKit library, but any unfreed memory is leaked until the device is reset. On these devices snapshots of WebKit have been customized to free these pointers. It would be nice to have this code merged to the trunk. There are applications that host various WebKit based WebWidgets that are created and destroyed without the application quitting. For this class of applications deleting the static pointers on library unload is important. Next, there is the case described in an earlier comment of resetting the state of WebKit. Also, I believe that the proposal suggested earlier by somebody to run all destructors before actually freeing the static allocations should take care of circular references and delete order despite the fact that in a well designed class architecture delete order of global objects should be irrelevant. I am not saying that the default Mac build or even any platform's default build should be affected in any way by these changes, but one should have the option to make a build that supports a clean uninitialization. Whenever something is built without provisions for clean tearing down sooner or later problems will appear (think nuclear plants and nuclear waste). 157888 40 41886 carol 2009-10-26 13:12:20 -0700 Created attachment 41886 Proposed Partial Patch This topic appears to be pretty controversial. It appears that there is not much value at least for the Mac version of WebKit in making WebKit clean up its singletons before it being unloaded. Since a large change appears to be expensive in terms of development and review time, and risky enough to be found unjustifiable for Apple, I propose this small safe change, that does not solve the whole problem, but can constitute a first step towards solving the problem. My final goal is to have global resources (such as cashes, custom memory management maps, default stylesheets, etc.) implemented in such a way that after the last WebKit page, frame, document, script object, worker thread, etc. has been deleted, these resources can be freed in any order, thus they can be implemented as global variables, or via global smart pointers, etc. if one wanted to. I plan to provide macros for declaring and defining these global resources. I also plan that by default these macros shall expand to pretty much the same code as it is now used for the resources such that there is no impact on performance. In the absence of any other value, this current patch provides: 1. No impact on performance if the user does not redefine the DEFINE_STATIC_LOCAL macro. 2. A slightly smaller, more consistent yet more configurable WebKit source code which benefits future maintainability and usability. I believe that on the basis of the above benefits alone, my patch should be accepted, regardless of whether I manage to find a solution to the underlying problem of singleton cleanup. 158285 41 41886 darin 2009-10-27 11:37:45 -0700 Comment on attachment 41886 Proposed Partial Patch It seems fine to use DEFINE_STATIC_LOCAL in one more place. And since that's all the patch does, we don't have to have any deep debate about it. It also seems OK to allow a version of DEFINE_STATIC_LOCAL defined elsewhere to override the version in StdLibExtras.h, but I don't see any reason the two need to be done in a single patch. > +#ifndef DEFINE_STATIC_LOCAL > #if COMPILER(GCC) && defined(__APPLE_CC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 0 && __GNUC_PATCHLEVEL__ == 1 > #define DEFINE_STATIC_LOCAL(type, name, arguments) \ > static type* name##Ptr = new type arguments; \ > @@ -40,7 +41,7 @@ > #define DEFINE_STATIC_LOCAL(type, name, arguments) \ > static type& name = *new type arguments > #endif > - > +#endif > // OBJECT_OFFSETOF: Like the C++ offsetof macro, but you can use it with classes. > // The magic number 0x4000 is insignificant. We use it to avoid using NULL, since > // NULL can cause compiler problems, especially in cases of multiple inheritance. You should move the #endif here so that there's still a blank line before OBJECT_OFFSETOF. > + * platform/ThreadGlobalData.cpp: > + (WebCore::threadGlobalData): > + Allocated threadGlobalData statically, not on heap such that it > + will be destroyed when the library is unloaded. I do not think the comment here is clear. My comment would be something more like, "Use DEFINE_STATIC_LOCAL macro instead of doing a one-offer version here. Helpful because we are using DEFINE_STATIC_LOCAL to experiment with unloading the library and deallocating memory". I think these patches are OK, but the change log should talk about what they do rather than saying these give WebKit ability to free memory when unloading. That's a big project that this patch is only a tiny part of. review- because of the minor problem with #endif and because the change log could be a lot clearer, but the patch seems fine otherwise 158300 42 41972 carol 2009-10-27 11:58:32 -0700 Created attachment 41972 Allowing for override of DEFINE_STATIC_LOCAL Per Darin's comment, I split my patch in 2 and I placed the appropriate comment in the ChangeLog. I apologize for my carelessness in the previous patch proposal which had unrelated comments in the ChangeLog as a result of reusing the log from a previous more substantial attempt. 158302 43 41972 eric 2009-10-27 12:00:37 -0700 Comment on attachment 41972 Allowing for override of DEFINE_STATIC_LOCAL So can DEFINE_STATIC_LOCAL still eventually be removed once we no longer support this broken version of Apple's GCC? Or does this new usage make us forever dependent on this macro? 158303 44 darin 2009-10-27 12:03:07 -0700 (In reply to comment #43) > So can DEFINE_STATIC_LOCAL still eventually be removed once we no longer > support this broken version of Apple's GCC? Or does this new usage make us > forever dependent on this macro? I don't think removing DEFINE_STATIC_LOCAL is a good idea, regardless of this new usage. It's true that we use it to work around a GCC bug. But we also use it to make indicate the idiom of using a local variable in a way that avoids static destructors. It's better to that than to handwrite the idiom each time. We might want to rename it, but it seems unlikely we'd want to remove it. 158352 45 41972 commit-queue 2009-10-27 14:04:29 -0700 Comment on attachment 41972 Allowing for override of DEFINE_STATIC_LOCAL Clearing flags on attachment: 41972 Committed r50171: <http://trac.webkit.org/changeset/50171> 158353 46 commit-queue 2009-10-27 14:04:37 -0700 All reviewed patches have been landed. Closing bug. 160555 47 tonikitoo 2009-11-04 12:16:00 -0800 i think carol's landed patch is a small part of the big thing here (?) or zoltan's implementation showed up itself as unfeasible and was "dropped" (and i missed it in the bug comments) ? commitbot landed and closed the bug by accident then if so (?) ps: sorry for bug spamming 160574 48 ap 2009-11-04 12:52:03 -0800 Definitely so, reopening. 160651 49 eric 2009-11-04 16:25:48 -0800 We try to use one change per bug. It would be better to create a new "meta bug" and if there are multipel changes, do those in individual bugs blockign the meta bug. 160659 50 ap 2009-11-04 16:40:26 -0800 There is a lot of discussion in this bug, better not start over, in my opinion. 34058 2009-08-04 04:39:13 -0700 2009-08-05 05:54:36 -0700 First draft patch StaticPtrs-draft-0.1.patch text/plain 13224 zherczeg ZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLnByaSBiL0phdmFTY3Jp cHRDb3JlL0phdmFTY3JpcHRDb3JlLnByaQppbmRleCBkYjkzMTU3Li4zM2QwZjI3IDEwMDY0NAot LS0gYS9KYXZhU2NyaXB0Q29yZS9KYXZhU2NyaXB0Q29yZS5wcmkKKysrIGIvSmF2YVNjcmlwdENv cmUvSmF2YVNjcmlwdENvcmUucHJpCkBAIC03Niw2ICs3Niw3IEBAIFNPVVJDRVMgKz0gXAogICAg IHd0Zi9SYW5kb21OdW1iZXIuY3BwIFwKICAgICB3dGYvUmVmQ291bnRlZExlYWtDb3VudGVyLmNw cCBcCiAgICAgd3RmL1R5cGVUcmFpdHMuY3BwIFwKKyAgICB3dGYvU3RhdGljUHRyLmNwcCBcCiAg ICAgd3RmL3VuaWNvZGUvQ29sbGF0b3JEZWZhdWx0LmNwcCBcCiAgICAgd3RmL3VuaWNvZGUvaWN1 L0NvbGxhdG9ySUNVLmNwcCBcCiAgICAgd3RmL3VuaWNvZGUvVVRGOC5jcHAgXApkaWZmIC0tZ2l0 IGEvSmF2YVNjcmlwdENvcmUvd3RmL1BsYXRmb3JtLmggYi9KYXZhU2NyaXB0Q29yZS93dGYvUGxh dGZvcm0uaAppbmRleCAzZjY0Yzc3Li43NDhlNzE3IDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0Q29y ZS93dGYvUGxhdGZvcm0uaAorKysgYi9KYXZhU2NyaXB0Q29yZS93dGYvUGxhdGZvcm0uaApAQCAt NzA0LDQgKzcwNCw2IEBACiAjZGVmaW5lIFdURl9VU0VfQUNDRUxFUkFURURfQ09NUE9TSVRJTkcg MQogI2VuZGlmCiAKKyNkZWZpbmUgRU5BQkxFX0ZSRUVfU1RBVElDX1BUUlMgMQorCiAjZW5kaWYg LyogV1RGX1BsYXRmb3JtX2ggKi8KZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL3d0Zi9TdGF0 aWNQdHIuY3BwIGIvSmF2YVNjcmlwdENvcmUvd3RmL1N0YXRpY1B0ci5jcHAKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNGRjMzc5NwotLS0gL2Rldi9udWxsCisrKyBiL0phdmFT Y3JpcHRDb3JlL3d0Zi9TdGF0aWNQdHIuY3BwCkBAIC0wLDAgKzEsNDkgQEAKKy8qCisgKiBDb3B5 cmlnaHQgKEMpIDIwMDkgVW5pdmVyc2l0eSBvZiBTemVnZWQKKyAqIEFsbCByaWdodHMgcmVzZXJ2 ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBm b3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJv dmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBS ZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHly aWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxv d2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11 c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0 IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAg IGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBk aXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBVTklWRVJT SVRZIE9GIFNaRUdFRCBgYEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdB UlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQg V0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxB UgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIFVOSVZFUlNJ VFkgT0YgU1pFR0VEIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNU LCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VR VUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NV UkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRB LCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNF RCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNU LCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1Ig T1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMg U09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1B R0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorCisjaW5jbHVkZSAiU3RhdGljUHRyLmgi CisKK25hbWVzcGFjZSBXVEYgeworCisjaWYgRU5BQkxFKEZSRUVfU1RBVElDX1BUUlMpCisKK1N0 YXRpY1B0ckJhc2U6OlN0YXRpY1B0ckJhc2UqIFN0YXRpY1B0ckJhc2U6Om1faGVhZCA9IDA7CisK K3ZvaWQgU3RhdGljUHRyQmFzZTo6ZnJlZVN0YXRpY1B0cnMoKQoreworICAgIC8vIEZyZWUgdGhl bSBpbiBhIHJldmVyc2VkIGNyZWF0aW9uIG9yZGVyCisgICAgU3RhdGljUHRyQmFzZSogY3VycmVu dCA9IGhlYWQoKTsKKyAgICB3aGlsZSAoY3VycmVudCkgeworICAgICAgICBjdXJyZW50LT5mcmVl KCk7CisgICAgICAgIGN1cnJlbnQgPSBjdXJyZW50LT5uZXh0KCk7CisgICAgfQorfQorCisjZW5k aWYgLy8gRU5BQkxFKEZSRUVfU1RBVElDX1BUUlMpCisKK30gLy8gbmFtZXNwYWNlIFdURgpkaWZm IC0tZ2l0IGEvSmF2YVNjcmlwdENvcmUvd3RmL1N0YXRpY1B0ci5oIGIvSmF2YVNjcmlwdENvcmUv d3RmL1N0YXRpY1B0ci5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmQzNTVh MDcKLS0tIC9kZXYvbnVsbAorKysgYi9KYXZhU2NyaXB0Q29yZS93dGYvU3RhdGljUHRyLmgKQEAg LTAsMCArMSwxNTUgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMDkgVW5pdmVyc2l0eSBvZiBT emVnZWQKKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5k IHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2Rp ZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRp dGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUg bXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qg b2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0 cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmln aHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1h dGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZU V0FSRSBJUyBQUk9WSURFRCBCWSBVTklWRVJTSVRZIE9GIFNaRUdFRCBgYEFTIElTJycgQU5EIEFO WQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBM SU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkg QU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4g IElOIE5PIEVWRU5UIFNIQUxMIFVOSVZFUlNJVFkgT0YgU1pFR0VEIE9SCisgKiBDT05UUklCVVRP UlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lB TCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJV VCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1Ig U0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1Mg SU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElB QklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisg KiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkg T1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBU SEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBXVEZfU3RhdGlj UHRyX2gKKyNkZWZpbmUgV1RGX1N0YXRpY1B0cl9oCisKKyNpbmNsdWRlICJBc3NlcnRpb25zLmgi CisjaW5jbHVkZSAiVHlwZVRyYWl0cy5oIgorI2luY2x1ZGUgIkFsd2F5c0lubGluZS5oIgorI2lu Y2x1ZGUgIlVudXNlZFBhcmFtLmgiCisKK25hbWVzcGFjZSBXVEYgeworCitjbGFzcyBTdGF0aWNQ dHJCYXNlIHsKK3B1YmxpYzoKKyAgICBTdGF0aWNQdHJCYXNlKCkgeworI2lmIEVOQUJMRShGUkVF X1NUQVRJQ19QVFJTKQorICAgICAgICBtX25leHQgPSBoZWFkKCk7CisgICAgICAgIG1faGVhZCA9 IHRoaXM7CisjZW5kaWYKKyAgICB9OworCisjaWYgRU5BQkxFKEZSRUVfU1RBVElDX1BUUlMpCisg ICAgc3RhdGljIHZvaWQgZnJlZVN0YXRpY1B0cnMoKTsKKworICAgIC8vIFN1cHByZXNzIEdDQyB3 YXJuaW5nCisgICAgdmlydHVhbCB+U3RhdGljUHRyQmFzZSgpIHsgfQorCitwcml2YXRlOgorICAg IHN0YXRpYyBTdGF0aWNQdHJCYXNlKiBtX2hlYWQ7CisgICAgU3RhdGljUHRyQmFzZSogbV9uZXh0 OworCisgICAgc3RhdGljIFN0YXRpY1B0ckJhc2UqIGhlYWQoKSB7IHJldHVybiBtX2hlYWQ7IH0K KyAgICBTdGF0aWNQdHJCYXNlKiBuZXh0KCkgeyByZXR1cm4gbV9uZXh0OyB9CisKKyAgICB2aXJ0 dWFsIHZvaWQgZnJlZSgpID0gMDsKKyNlbmRpZgorfTsKKworLy8gV3JhcHBlciBjbGFzcyBmb3Ig c3RhdGljIHBvaW50ZXJzLgorLy8gQnkgZGVmYXVsdCwgaXQgYmVoYXZlcyBsaWtlIGEgc2ltcGxl IHBvaW50ZXIgd2l0aG91dCBwZXJmb3JtYW5jZSBvdmVyaGVhZAordGVtcGxhdGU8dHlwZW5hbWUg VD4gY2xhc3MgU3RhdGljUHRyIDogcHVibGljIFN0YXRpY1B0ckJhc2UgeworcHVibGljOgorICAg IHR5cGVkZWYgdHlwZW5hbWUgUmVtb3ZlUG9pbnRlcjxUPjo6VHlwZSBWYWx1ZVR5cGU7CisgICAg dHlwZWRlZiBWYWx1ZVR5cGUqIFB0clR5cGU7CisKKyAgICBTdGF0aWNQdHIoUHRyVHlwZSBwdHIp IDogU3RhdGljUHRyQmFzZSgpLCBtX3B0cihwdHIpIHsgfTsKKyAgICBTdGF0aWNQdHIoKSA6IFN0 YXRpY1B0ckJhc2UoKSwgbV9wdHIoMCkgeyB9OworICAgIH5TdGF0aWNQdHIoKSB7IH07CisKKyAg ICAvLyBBc3NpZ25tZW50IG9wZXJhdG9ycworICAgIFB0clR5cGUgb3BlcmF0b3I9KFB0clR5cGUp OworICAgIFZhbHVlVHlwZSYgb3BlcmF0b3I9KFZhbHVlVHlwZSYpOworCisgICAgLy8gVmFsdWUg YWNjZXNzIG9wZXJhdG9ycworICAgIFZhbHVlVHlwZSYgb3BlcmF0b3IqKCk7CisgICAgUHRyVHlw ZSBvcGVyYXRvci0+KCk7CisgICAgUHRyVHlwZSBvcGVyYXRvciYoKTsKKyAgICBWYWx1ZVR5cGUm IG9wZXJhdG9yKigpIGNvbnN0OworICAgIFB0clR5cGUgb3BlcmF0b3ItPigpIGNvbnN0OworICAg IFB0clR5cGUgb3BlcmF0b3ImKCkgY29uc3Q7CisKKyAgICAvLyBDb25kaXRpb24gb3BlcmF0b3Jz CisgICAgYm9vbCBvcGVyYXRvciEoKTsKKworcHJvdGVjdGVkOgorICAgIFB0clR5cGUgbV9wdHI7 CisKKyNpZiBFTkFCTEUoRlJFRV9TVEFUSUNfUFRSUykKKyAgICB2aXJ0dWFsIHZvaWQgZnJlZSgp IHsgZGVsZXRlIG1fcHRyOyB9CisjZW5kaWYKK307CisKK3RlbXBsYXRlPHR5cGVuYW1lIFQ+CitB TFdBWVNfSU5MSU5FIHR5cGVuYW1lIFN0YXRpY1B0cjxUPjo6UHRyVHlwZSBTdGF0aWNQdHI8VD46 Om9wZXJhdG9yPShTdGF0aWNQdHI8VD46OlB0clR5cGUgdmFsdWUpCit7CisgICAgbV9wdHIgPSB2 YWx1ZTsKKyAgICByZXR1cm4gdmFsdWU7Cit9CisKK3RlbXBsYXRlPHR5cGVuYW1lIFQ+CitBTFdB WVNfSU5MSU5FIHR5cGVuYW1lIFN0YXRpY1B0cjxUPjo6VmFsdWVUeXBlJiBTdGF0aWNQdHI8VD46 Om9wZXJhdG9yPShTdGF0aWNQdHI8VD46OlZhbHVlVHlwZSYgdmFsdWUpCit7CisgICAgbV9wdHIg PSAmdmFsdWU7CisgICAgcmV0dXJuIHZhbHVlOworfQorCit0ZW1wbGF0ZTx0eXBlbmFtZSBUPgor QUxXQVlTX0lOTElORSB0eXBlbmFtZSBTdGF0aWNQdHI8VD46OlZhbHVlVHlwZSYgU3RhdGljUHRy PFQ+OjpvcGVyYXRvciooKQoreworICAgIHJldHVybiAqbV9wdHI7Cit9CisKK3RlbXBsYXRlPHR5 cGVuYW1lIFQ+CitBTFdBWVNfSU5MSU5FIHR5cGVuYW1lIFN0YXRpY1B0cjxUPjo6UHRyVHlwZSBT dGF0aWNQdHI8VD46Om9wZXJhdG9yLT4oKQoreworICAgIHJldHVybiBtX3B0cjsKK30KKwordGVt cGxhdGU8dHlwZW5hbWUgVD4KK0FMV0FZU19JTkxJTkUgdHlwZW5hbWUgU3RhdGljUHRyPFQ+OjpQ dHJUeXBlIFN0YXRpY1B0cjxUPjo6b3BlcmF0b3ImKCkKK3sKKyAgICByZXR1cm4gbV9wdHI7Cit9 CisKK3RlbXBsYXRlPHR5cGVuYW1lIFQ+CitBTFdBWVNfSU5MSU5FIHR5cGVuYW1lIFN0YXRpY1B0 cjxUPjo6VmFsdWVUeXBlJiBTdGF0aWNQdHI8VD46Om9wZXJhdG9yKigpIGNvbnN0Cit7CisgICAg cmV0dXJuICptX3B0cjsKK30KKwordGVtcGxhdGU8dHlwZW5hbWUgVD4KK0FMV0FZU19JTkxJTkUg dHlwZW5hbWUgU3RhdGljUHRyPFQ+OjpQdHJUeXBlIFN0YXRpY1B0cjxUPjo6b3BlcmF0b3ItPigp IGNvbnN0Cit7CisgICAgcmV0dXJuIG1fcHRyOworfQorCit0ZW1wbGF0ZTx0eXBlbmFtZSBUPgor QUxXQVlTX0lOTElORSB0eXBlbmFtZSBTdGF0aWNQdHI8VD46OlB0clR5cGUgU3RhdGljUHRyPFQ+ OjpvcGVyYXRvciYoKSBjb25zdAoreworICAgIHJldHVybiBtX3B0cjsKK30KKwordGVtcGxhdGU8 dHlwZW5hbWUgVD4KK0FMV0FZU19JTkxJTkUgYm9vbCBTdGF0aWNQdHI8VD46Om9wZXJhdG9yISgp Cit7CisgICAgcmV0dXJuICFtX3B0cjsKK30KKworfSAvLyBuYW1lc3BhY2UgV1RGCisKKyNlbmRp ZgpkaWZmIC0tZ2l0IGEvSmF2YVNjcmlwdENvcmUvd3RmL1N0ZExpYkV4dHJhcy5oIGIvSmF2YVNj cmlwdENvcmUvd3RmL1N0ZExpYkV4dHJhcy5oCmluZGV4IGFmYzVlOGEuLjA5NGM0YmYgMTAwNjQ0 Ci0tLSBhL0phdmFTY3JpcHRDb3JlL3d0Zi9TdGRMaWJFeHRyYXMuaAorKysgYi9KYXZhU2NyaXB0 Q29yZS93dGYvU3RkTGliRXh0cmFzLmgKQEAgLTI4LDE3ICsyOCwyMiBAQAogCiAjaW5jbHVkZSA8 d3RmL1BsYXRmb3JtLmg+CiAjaW5jbHVkZSA8d3RmL0Fzc2VydGlvbnMuaD4KKyNpbmNsdWRlIDx3 dGYvU3RhdGljUHRyLmg+CiAKIC8vIFVzZSB0aGVzZSB0byBkZWNsYXJlIGFuZCBkZWZpbmUgYSBz dGF0aWMgbG9jYWwgdmFyaWFibGUgKHN0YXRpYyBUOykgc28gdGhhdAogLy8gIGl0IGlzIGxlYWtl ZCBzbyB0aGF0IGl0cyBkZXN0cnVjdG9ycyBhcmUgbm90IGNhbGxlZCBhdCBleGl0LiBVc2luZyB0 aGlzCiAvLyAgbWFjcm8gYWxzbyBhbGxvd3Mgd29ya2Fyb3VuZHMgYSBjb21waWxlciBidWcgcHJl c2VudCBpbiBBcHBsZSdzIHZlcnNpb24gb2YgR0NDIDQuMC4xLgotI2lmIENPTVBJTEVSKEdDQykg JiYgZGVmaW5lZChfX0FQUExFX0NDX18pICYmIF9fR05VQ19fID09IDQgJiYgX19HTlVDX01JTk9S X18gPT0gMCAmJiBfX0dOVUNfUEFUQ0hMRVZFTF9fID09IDEKKyNpZiBFTkFCTEUoRlJFRV9TVEFU SUNfUFRSUykKKyNkZWZpbmUgREVGSU5FX1NUQVRJQ19MT0NBTCh0eXBlLCBuYW1lLCBhcmd1bWVu dHMpIFwKKyAgICBzdGF0aWMgV1RGOjpTdGF0aWNQdHI8IHR5cGUgPiBuYW1lIyNQdHIobmV3IHR5 cGUgYXJndW1lbnRzKTsgXAorICAgIHR5cGUmIG5hbWUgPSAqbmFtZSMjUHRyCisjZWxpZiBDT01Q SUxFUihHQ0MpICYmIGRlZmluZWQoX19BUFBMRV9DQ19fKSAmJiBfX0dOVUNfXyA9PSA0ICYmIF9f R05VQ19NSU5PUl9fID09IDAgJiYgX19HTlVDX1BBVENITEVWRUxfXyA9PSAxCiAjZGVmaW5lIERF RklORV9TVEFUSUNfTE9DQUwodHlwZSwgbmFtZSwgYXJndW1lbnRzKSBcCiAgICAgc3RhdGljIHR5 cGUqIG5hbWUjI1B0ciA9IG5ldyB0eXBlIGFyZ3VtZW50czsgXAogICAgIHR5cGUmIG5hbWUgPSAq bmFtZSMjUHRyCiAjZWxzZQogI2RlZmluZSBERUZJTkVfU1RBVElDX0xPQ0FMKHR5cGUsIG5hbWUs IGFyZ3VtZW50cykgXAotICAgIHN0YXRpYyB0eXBlJiBuYW1lID0gKm5ldyB0eXBlIGFyZ3VtZW50 cworICAgIHN0YXRpYyB0eXBlJiBuYW1lID0gKm5ldyB0eXBlIGFyZ3VtZW50czsKICNlbmRpZgog CiBuYW1lc3BhY2UgV1RGIHsKZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL3d0Zi9UaHJlYWRT cGVjaWZpYy5oIGIvSmF2YVNjcmlwdENvcmUvd3RmL1RocmVhZFNwZWNpZmljLmgKaW5kZXggNGQ1 ZDJmNy4uOGJmZGNjZiAxMDA2NDQKLS0tIGEvSmF2YVNjcmlwdENvcmUvd3RmL1RocmVhZFNwZWNp ZmljLmgKKysrIGIvSmF2YVNjcmlwdENvcmUvd3RmL1RocmVhZFNwZWNpZmljLmgKQEAgLTIzMiw3 ICsyMzIsOSBAQCBpbmxpbmUgdm9pZCBUaHJlYWRTcGVjaWZpYzxUPjo6ZGVzdHJveSh2b2lkKiBw dHIpCiAjZXJyb3IgVGhyZWFkU3BlY2lmaWMgaXMgbm90IGltcGxlbWVudGVkIGZvciB0aGlzIHBs YXRmb3JtLgogI2VuZGlmCiAKKyNpZiAhUExBVEZPUk0oUVQpCiAgICAgZGVsZXRlIGRhdGE7Cisj ZW5kaWYKIH0KIAogdGVtcGxhdGU8dHlwZW5hbWUgVD4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvYmlu ZGluZ3MvanMvSlNET01XaW5kb3dCYXNlLmNwcCBiL1dlYkNvcmUvYmluZGluZ3MvanMvSlNET01X aW5kb3dCYXNlLmNwcAppbmRleCBkZjYwNjhhLi4yYzZlZGE5IDEwMDY0NAotLS0gYS9XZWJDb3Jl L2JpbmRpbmdzL2pzL0pTRE9NV2luZG93QmFzZS5jcHAKKysrIGIvV2ViQ29yZS9iaW5kaW5ncy9q cy9KU0RPTVdpbmRvd0Jhc2UuY3BwCkBAIC0zNSw2ICszNSw3IEBACiAjaW5jbHVkZSAiU2NyaXB0 Q29udHJvbGxlci5oIgogI2luY2x1ZGUgIlNlY3VyaXR5T3JpZ2luLmgiCiAjaW5jbHVkZSAiU2V0 dGluZ3MuaCIKKyNpbmNsdWRlICJ3dGYvU3RhdGljUHRyLmgiCiAKIHVzaW5nIG5hbWVzcGFjZSBK U0M7CiAKQEAgLTE2MSwxNSArMTYyLDM1IEBAIEpTRE9NV2luZG93U2hlbGwqIEpTRE9NV2luZG93 QmFzZTo6c2hlbGwoKSBjb25zdAogICAgIHJldHVybiBkKCktPnNoZWxsOwogfQogCitjbGFzcyBT dGF0aWNHbG9iYWxEYXRhIDogcHVibGljIFdURjo6U3RhdGljUHRyPEpTR2xvYmFsRGF0YT4gewor cHVibGljOgorICAgIFN0YXRpY0dsb2JhbERhdGEoKSA6IFdURjo6U3RhdGljUHRyPEpTR2xvYmFs RGF0YT4oKSB7IH07CisKKyAgICBKU0dsb2JhbERhdGEqIG9wZXJhdG9yPShKU0dsb2JhbERhdGEq KTsKKworcHJvdGVjdGVkOgorI2lmIEVOQUJMRShGUkVFX1NUQVRJQ19QVFJTKQorICAgIHZpcnR1 YWwgdm9pZCBmcmVlKCkgeworICAgICAgICBtX3B0ci0+aGVhcC5kZXN0cm95KCk7CisgICAgICAg IGRlbGV0ZSBtX3B0cjsKKyAgICB9CisjZW5kaWYKK307CisKK0FMV0FZU19JTkxJTkUgSlNHbG9i YWxEYXRhKiBTdGF0aWNHbG9iYWxEYXRhOjpvcGVyYXRvcj0oSlNHbG9iYWxEYXRhKiB2YWx1ZSkK K3sKKyAgICBtX3B0ciA9IHZhbHVlOworfQorCiBKU0dsb2JhbERhdGEqIEpTRE9NV2luZG93QmFz ZTo6Y29tbW9uSlNHbG9iYWxEYXRhKCkKIHsKLSAgICBzdGF0aWMgSlNHbG9iYWxEYXRhKiBnbG9i YWxEYXRhOworICAgIHN0YXRpYyBTdGF0aWNHbG9iYWxEYXRhIGdsb2JhbERhdGE7CiAgICAgaWYg KCFnbG9iYWxEYXRhKSB7CiAgICAgICAgIGdsb2JhbERhdGEgPSBKU0dsb2JhbERhdGE6OmNyZWF0 ZUxlYWtlZCgpLnJlbGVhc2VSZWYoKTsKICAgICAgICAgZ2xvYmFsRGF0YS0+dGltZW91dENoZWNr ZXIuc2V0VGltZW91dEludGVydmFsKDEwMDAwKTsgLy8gMTAgc2Vjb25kcwogICAgIH0KIAotICAg IHJldHVybiBnbG9iYWxEYXRhOworICAgIHJldHVybiAmZ2xvYmFsRGF0YTsKIH0KIAogLy8gSlNE T01HbG9iYWxPYmplY3QqIGlzIGlnbm9yZWQsIGFjY2VzaW5nIGEgd2luZG93IGluIGFueSBjb250 ZXh0IHdpbGwKZGlmZiAtLWdpdCBhL1dlYkNvcmUvaW5zcGVjdG9yL0phdmFTY3JpcHREZWJ1Z1Nl cnZlci5oIGIvV2ViQ29yZS9pbnNwZWN0b3IvSmF2YVNjcmlwdERlYnVnU2VydmVyLmgKaW5kZXgg YmFhNjY5OS4uNTIwYjQ4MyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9pbnNwZWN0b3IvSmF2YVNjcmlw dERlYnVnU2VydmVyLmgKKysrIGIvV2ViQ29yZS9pbnNwZWN0b3IvSmF2YVNjcmlwdERlYnVnU2Vy dmVyLmgKQEAgLTg1LDkgKzg1LDEwIEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgdHlw ZWRlZiBIYXNoU2V0PEphdmFTY3JpcHREZWJ1Z0xpc3RlbmVyKj4gTGlzdGVuZXJTZXQ7CiAgICAg ICAgIHR5cGVkZWYgdm9pZCAoSmF2YVNjcmlwdERlYnVnTGlzdGVuZXI6OipKYXZhU2NyaXB0RXhl Y3V0aW9uQ2FsbGJhY2spKCk7CiAKKyAgICAgICAgfkphdmFTY3JpcHREZWJ1Z1NlcnZlcigpOwor CiAgICAgcHJpdmF0ZToKICAgICAgICAgSmF2YVNjcmlwdERlYnVnU2VydmVyKCk7Ci0gICAgICAg IH5KYXZhU2NyaXB0RGVidWdTZXJ2ZXIoKTsKIAogICAgICAgICBib29sIGhhc0xpc3RlbmVycygp IGNvbnN0IHsgcmV0dXJuICFtX2xpc3RlbmVycy5pc0VtcHR5KCkgfHwgIW1fcGFnZUxpc3RlbmVy c01hcC5pc0VtcHR5KCk7IH0KICAgICAgICAgYm9vbCBoYXNHbG9iYWxMaXN0ZW5lcnMoKSBjb25z dCB7IHJldHVybiAhbV9saXN0ZW5lcnMuaXNFbXB0eSgpOyB9CmRpZmYgLS1naXQgYS9XZWJDb3Jl L2xvYWRlci9JbWFnZUxvYWRlci5jcHAgYi9XZWJDb3JlL2xvYWRlci9JbWFnZUxvYWRlci5jcHAK aW5kZXggYjE4M2E2Ni4uMmQ2ZWFmZiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9sb2FkZXIvSW1hZ2VM b2FkZXIuY3BwCisrKyBiL1dlYkNvcmUvbG9hZGVyL0ltYWdlTG9hZGVyLmNwcApAQCAtNDEsNyAr NDEsNiBAQCBwdWJsaWM6CiAgICAgdm9pZCBkaXNwYXRjaFBlbmRpbmdMb2FkRXZlbnRzKCk7CiAK IHByaXZhdGU6Ci0gICAgfkltYWdlTG9hZEV2ZW50U2VuZGVyKCk7CiAKICAgICB2b2lkIHRpbWVy RmlyZWQoVGltZXI8SW1hZ2VMb2FkRXZlbnRTZW5kZXI+Kik7CiAKZGlmZiAtLWdpdCBhL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvRm9udENhY2hlLmggYi9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL0ZvbnRDYWNoZS5oCmluZGV4IDNjMGYyZDkuLjg4MjAwNDUgMTAwNjQ0Ci0tLSBhL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvRm9udENhY2hlLmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9Gb250Q2FjaGUuaApAQCAtODUsNyArODUsNiBAQCBwdWJsaWM6CiAKIHByaXZhdGU6 CiAgICAgRm9udENhY2hlKCk7Ci0gICAgfkZvbnRDYWNoZSgpOwogCiAgICAgLy8gVGhlc2UgbWV0 aG9kcyBhcmUgaW1wbGVtZW50ZWQgYnkgZWFjaCBwbGF0Zm9ybS4KICAgICBGb250UGxhdGZvcm1E YXRhKiBnZXRTaW1pbGFyRm9udFBsYXRmb3JtRGF0YShjb25zdCBGb250Jik7CmRpZmYgLS1naXQg YS9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5jcHAgYi9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5j cHAKaW5kZXggMjNjYjQ3My4uYTRlZjMyMiAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L0FwaS9xd2Vi ZnJhbWUuY3BwCisrKyBiL1dlYktpdC9xdC9BcGkvcXdlYmZyYW1lLmNwcApAQCAtNzgsNiArNzgs MTAgQEAKICNpbmNsdWRlIDxxcHJpbnRlci5oPgogI2luY2x1ZGUgPHFyZWdpb24uaD4KIAorI2lm IEVOQUJMRShGUkVFX1NUQVRJQ19QVFJTKQorI2luY2x1ZGUgInd0Zi9TdGF0aWNQdHIuaCIKKyNl bmRpZgorCiAjaWYgUVRfVkVSU0lPTiA8IDB4MDQwNDAwCiAjaW5jbHVkZSAicXdlYm5ldHdvcmtp bnRlcmZhY2UuaCIKICNlbmRpZgpAQCAtMTg1LDYgKzE4OSwxMyBAQCB2b2lkIFFXRUJLSVRfRVhQ T1JUIHF0X2RydF9nYXJiYWdlQ29sbGVjdG9yX2NvbGxlY3RPbkFsdGVybmF0ZVRocmVhZChib29s IHdhaXRVbgogICAgIGdjQ29udHJvbGxlcigpLmdhcmJhZ2VDb2xsZWN0T25BbHRlcm5hdGVUaHJl YWRGb3JEZWJ1Z2dpbmcod2FpdFVudGlsRG9uZSk7CiB9CiAKKyNpZiBFTkFCTEUoRlJFRV9TVEFU SUNfUFRSUykKK3ZvaWQgUVdFQktJVF9FWFBPUlQgcXRfZHJ0X2ZyZWVTdGF0aWNQdHJzKCkKK3sK KyAgICBXVEY6OlN0YXRpY1B0ckJhc2U6OmZyZWVTdGF0aWNQdHJzKCk7Cit9CisjZW5kaWYKKwog UVdlYkZyYW1lRGF0YTo6UVdlYkZyYW1lRGF0YShXZWJDb3JlOjpQYWdlKiBwYXJlbnRQYWdlLCBX ZWJDb3JlOjpGcmFtZSogcGFyZW50RnJhbWUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IFdlYkNvcmU6OkhUTUxGcmFtZU93bmVyRWxlbWVudCogb3duZXJGcmFtZUVsZW1lbnQsCiAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IFdlYkNvcmU6OlN0cmluZyYgZnJhbWVOYW1l KQpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L1F0TGF1bmNoZXIvbWFpbi5jcHAgYi9XZWJLaXQvcXQv UXRMYXVuY2hlci9tYWluLmNwcAppbmRleCBhMjE5NmYxLi5mMGNkNWJlIDEwMDY0NAotLS0gYS9X ZWJLaXQvcXQvUXRMYXVuY2hlci9tYWluLmNwcAorKysgYi9XZWJLaXQvcXQvUXRMYXVuY2hlci9t YWluLmNwcApAQCAtNTMsNiArNTMsNyBAQAogCiAjaWZuZGVmIE5ERUJVRwogdm9pZCBRV0VCS0lU X0VYUE9SVCBxdF9kcnRfZ2FyYmFnZUNvbGxlY3Rvcl9jb2xsZWN0KCk7Cit2b2lkIFFXRUJLSVRf RVhQT1JUIHF0X2RydF9mcmVlU3RhdGljUHRycygpOwogI2VuZGlmCiAKIGNsYXNzIFdlYlBhZ2Ug OiBwdWJsaWMgUVdlYlBhZ2UKQEAgLTQ2Miw2ICs0NjMsNyBAQCBpbnQgbWFpbihpbnQgYXJnYywg Y2hhciAqKmFyZ3YpCiAgICAgICAgIGludCByZXRWYWwgPSBhcHAuZXhlYygpOwogICAgICAgICBx dF9kcnRfZ2FyYmFnZUNvbGxlY3Rvcl9jb2xsZWN0KCk7CiAgICAgICAgIFFXZWJTZXR0aW5nczo6 Y2xlYXJNZW1vcnlDYWNoZXMoKTsKKyAgICAgICAgcXRfZHJ0X2ZyZWVTdGF0aWNQdHJzKCk7CiAg ICAgICAgIHJldHVybiByZXRWYWw7CiAjZWxzZQogICAgICAgICByZXR1cm4gYXBwLmV4ZWMoKTsK 34131 2009-08-05 05:54:36 -0700 2009-08-07 04:19:09 -0700 Second draft patch StaticPtrs-draft-0.2.patch text/plain 18203 zherczeg ZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLnByaSBiL0phdmFTY3Jp cHRDb3JlL0phdmFTY3JpcHRDb3JlLnByaQppbmRleCBkYjkzMTU3Li5jMmZkYTYyIDEwMDY0NAot LS0gYS9KYXZhU2NyaXB0Q29yZS9KYXZhU2NyaXB0Q29yZS5wcmkKKysrIGIvSmF2YVNjcmlwdENv cmUvSmF2YVNjcmlwdENvcmUucHJpCkBAIC03NSw2ICs3NSw3IEBAIFNPVVJDRVMgKz0gXAogICAg IHd0Zi9NYWluVGhyZWFkLmNwcCBcCiAgICAgd3RmL1JhbmRvbU51bWJlci5jcHAgXAogICAgIHd0 Zi9SZWZDb3VudGVkTGVha0NvdW50ZXIuY3BwIFwKKyAgICB3dGYvU3RhdGljUHRyLmNwcCBcCiAg ICAgd3RmL1R5cGVUcmFpdHMuY3BwIFwKICAgICB3dGYvdW5pY29kZS9Db2xsYXRvckRlZmF1bHQu Y3BwIFwKICAgICB3dGYvdW5pY29kZS9pY3UvQ29sbGF0b3JJQ1UuY3BwIFwKZGlmZiAtLWdpdCBh L0phdmFTY3JpcHRDb3JlL3d0Zi9QbGF0Zm9ybS5oIGIvSmF2YVNjcmlwdENvcmUvd3RmL1BsYXRm b3JtLmgKaW5kZXggM2Y2NGM3Ny4uNzQ4ZTcxNyAxMDA2NDQKLS0tIGEvSmF2YVNjcmlwdENvcmUv d3RmL1BsYXRmb3JtLmgKKysrIGIvSmF2YVNjcmlwdENvcmUvd3RmL1BsYXRmb3JtLmgKQEAgLTcw NCw0ICs3MDQsNiBAQAogI2RlZmluZSBXVEZfVVNFX0FDQ0VMRVJBVEVEX0NPTVBPU0lUSU5HIDEK ICNlbmRpZgogCisjZGVmaW5lIEVOQUJMRV9GUkVFX1NUQVRJQ19QVFJTIDEKKwogI2VuZGlmIC8q IFdURl9QbGF0Zm9ybV9oICovCmRpZmYgLS1naXQgYS9KYXZhU2NyaXB0Q29yZS93dGYvU3RhdGlj UHRyLmNwcCBiL0phdmFTY3JpcHRDb3JlL3d0Zi9TdGF0aWNQdHIuY3BwCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAuLjc1OTUwY2MKLS0tIC9kZXYvbnVsbAorKysgYi9KYXZhU2Ny aXB0Q29yZS93dGYvU3RhdGljUHRyLmNwcApAQCAtMCwwICsxLDQ5IEBACisvKgorICogQ29weXJp Z2h0IChDKSAyMDA5IFVuaXZlcnNpdHkgb2YgU3plZ2VkCisgKiBBbGwgcmlnaHRzIHJlc2VydmVk LgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9y bXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3Zp ZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVk aXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmln aHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0 IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBv ZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBk b2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlz dHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVU5JVkVSU0lU WSBPRiBTWkVHRUQgYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJS QU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdB UlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIK KyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBVTklWRVJTSVRZ IE9GIFNaRUdFRCBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwg SU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVF TlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJF TUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwg T1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQg QU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwg U1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9U SEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNP RlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdF LgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJTdGF0aWNQdHIuaCIKKyNp bmNsdWRlIDxzdGRpby5oPgorCituYW1lc3BhY2UgV1RGIHsKKworI2lmIEVOQUJMRShGUkVFX1NU QVRJQ19QVFJTKQorCitTdGF0aWNQdHJCYXNlOjpTdGF0aWNQdHJCYXNlKiBTdGF0aWNQdHJCYXNl OjptX2hlYWQgPSAwOworCit2b2lkIFN0YXRpY1B0ckJhc2U6OmZyZWVTdGF0aWNQdHJzKCkKK3sK KyAgICAvLyBGcmVlIHRoZW0gaW4gYSByZXZlcnNlZCBjcmVhdGlvbiBvcmRlcgorICAgIFN0YXRp Y1B0ckJhc2UqIGN1cnJlbnQgPSBoZWFkKCk7CisgICAgd2hpbGUgKGN1cnJlbnQpIHsKKyAgICAg ICAgY3VycmVudC0+ZnJlZSgpOworICAgICAgICBjdXJyZW50ID0gY3VycmVudC0+bmV4dCgpOwor ICAgIH0KK30KKworI2VuZGlmIC8vIEVOQUJMRShGUkVFX1NUQVRJQ19QVFJTKQorCit9IC8vIG5h bWVzcGFjZSBXVEYKZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL3d0Zi9TdGF0aWNQdHIuaCBi L0phdmFTY3JpcHRDb3JlL3d0Zi9TdGF0aWNQdHIuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwLi5hZmUwNzRkCi0tLSAvZGV2L251bGwKKysrIGIvSmF2YVNjcmlwdENvcmUvd3Rm L1N0YXRpY1B0ci5oCkBAIC0wLDAgKzEsMTU1IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDA5 IFVuaXZlcnNpdHkgb2YgU3plZ2VkCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJl ZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Ig d2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhl IGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25z IG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5v dGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1l ci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0 aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9u IGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgor ICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVU5JVkVSU0lUWSBPRiBTWkVHRUQg YGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNM VURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0Yg TUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0Ug QVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBVTklWRVJTSVRZIE9GIFNaRUdFRCBP UgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElO Q0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdF UyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBPRiBTVUJT VElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJ VFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBU SEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJ TElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJ U0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVO IElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNp Zm5kZWYgV1RGX1N0YXRpY1B0cl9oCisjZGVmaW5lIFdURl9TdGF0aWNQdHJfaAorCisjaW5jbHVk ZSAiQXNzZXJ0aW9ucy5oIgorI2luY2x1ZGUgIlR5cGVUcmFpdHMuaCIKKyNpbmNsdWRlICJBbHdh eXNJbmxpbmUuaCIKKworbmFtZXNwYWNlIFdURiB7CisKK2NsYXNzIFN0YXRpY1B0ckJhc2Ugewor cHVibGljOgorI2lmIEVOQUJMRShGUkVFX1NUQVRJQ19QVFJTKQorICAgIC8vIFRoaXMgY2xhc3Mg aXMgZW1wdHkgaWYgRlJFRV9TVEFUSUNfUFRSUyBpcyBub3QgZGVmaW5lZAorCisgICAgU3RhdGlj UHRyQmFzZSgpCisgICAgeworICAgICAgICBtX25leHQgPSBoZWFkKCk7CisgICAgICAgIG1faGVh ZCA9IHRoaXM7CisgICAgfQorCisgICAgc3RhdGljIHZvaWQgZnJlZVN0YXRpY1B0cnMoKTsKKwor ICAgIC8vIFN1cHByZXNzIEdDQyB3YXJuaW5nCisgICAgdmlydHVhbCB+U3RhdGljUHRyQmFzZSgp IHsgfQorCitwcml2YXRlOgorICAgIHN0YXRpYyBTdGF0aWNQdHJCYXNlKiBtX2hlYWQ7CisgICAg U3RhdGljUHRyQmFzZSogbV9uZXh0OworCisgICAgc3RhdGljIFN0YXRpY1B0ckJhc2UqIGhlYWQo KSB7IHJldHVybiBtX2hlYWQ7IH0KKyAgICBTdGF0aWNQdHJCYXNlKiBuZXh0KCkgeyByZXR1cm4g bV9uZXh0OyB9CisKKyAgICB2aXJ0dWFsIHZvaWQgZnJlZSgpID0gMDsKKyNlbmRpZgorfTsKKwor Ly8gV3JhcHBlciBjbGFzcyBmb3Igc3RhdGljIHBvaW50ZXJzLgorLy8gQnkgZGVmYXVsdCwgaXQg YmVoYXZlcyBsaWtlIGEgc2ltcGxlIHBvaW50ZXIgd2l0aG91dCBwZXJmb3JtYW5jZSBvdmVyaGVh ZAordGVtcGxhdGU8dHlwZW5hbWUgVD4gY2xhc3MgU3RhdGljUHRyIDogcHVibGljIFN0YXRpY1B0 ckJhc2UgeworcHVibGljOgorICAgIHR5cGVkZWYgdHlwZW5hbWUgUmVtb3ZlUG9pbnRlcjxUPjo6 VHlwZSBWYWx1ZVR5cGU7CisgICAgdHlwZWRlZiBWYWx1ZVR5cGUqIFB0clR5cGU7CisKKyAgICBT dGF0aWNQdHIoUHRyVHlwZSBwdHIpIDogU3RhdGljUHRyQmFzZSgpLCBtX3B0cihwdHIpIHsgfQor ICAgIFN0YXRpY1B0cigpIDogU3RhdGljUHRyQmFzZSgpLCBtX3B0cigwKSB7IH0KKworICAgIC8v IEFzc2lnbm1lbnQgb3BlcmF0b3JzCisgICAgUHRyVHlwZSBvcGVyYXRvcj0oUHRyVHlwZSk7CisK KyAgICBQdHJUeXBlIGdldCgpIGNvbnN0OworICAgIHZvaWQgc2V0KFB0clR5cGUpOworCisgICAg Ly8gVmFsdWUgYWNjZXNzIG9wZXJhdG9ycworICAgIFZhbHVlVHlwZSYgb3BlcmF0b3IqKCk7Cisg ICAgUHRyVHlwZSBvcGVyYXRvci0+KCk7CisgICAgVmFsdWVUeXBlJiBvcGVyYXRvciooKSBjb25z dDsKKyAgICBQdHJUeXBlIG9wZXJhdG9yLT4oKSBjb25zdDsKKworICAgIC8vIENvbmRpdGlvbiBv cGVyYXRvcnMKKyAgICBib29sIG9wZXJhdG9yISgpIGNvbnN0OworCitwcml2YXRlOgorICAgIC8v IFRoaXMgcG9pbnRlciBjYW4gYmUgaW5pdGlhbGl6ZWQgYXQgbW9zdCBvbmNlCisgICAgUHRyVHlw ZSBtX3B0cjsKKworI2lmIEVOQUJMRShGUkVFX1NUQVRJQ19QVFJTKQorICAgIHZpcnR1YWwgdm9p ZCBmcmVlKCkgeyBkZWxldGUgbV9wdHI7IH0KKyNlbmRpZgorfTsKKwordGVtcGxhdGU8dHlwZW5h bWUgVD4KK0FMV0FZU19JTkxJTkUgdHlwZW5hbWUgU3RhdGljUHRyPFQ+OjpQdHJUeXBlIFN0YXRp Y1B0cjxUPjo6b3BlcmF0b3I9KFN0YXRpY1B0cjxUPjo6UHRyVHlwZSB2YWx1ZSkKK3sKKyAgICBB U1NFUlQoIW1fcHRyKTsKKyAgICBtX3B0ciA9IHZhbHVlOworICAgIHJldHVybiB2YWx1ZTsKK30K KwordGVtcGxhdGU8dHlwZW5hbWUgVD4KK0FMV0FZU19JTkxJTkUgdHlwZW5hbWUgU3RhdGljUHRy PFQ+OjpQdHJUeXBlIFN0YXRpY1B0cjxUPjo6Z2V0KCkgY29uc3QKK3sKKyAgICBBU1NFUlQobV9w dHIpOworICAgIHJldHVybiBtX3B0cjsKK30KKwordGVtcGxhdGU8dHlwZW5hbWUgVD4KK0FMV0FZ U19JTkxJTkUgdm9pZCBTdGF0aWNQdHI8VD46OnNldChQdHJUeXBlIHZhbHVlKQoreworICAgIEFT U0VSVCghbV9wdHIpOworICAgIG1fcHRyID0gdmFsdWU7Cit9CisKK3RlbXBsYXRlPHR5cGVuYW1l IFQ+CitBTFdBWVNfSU5MSU5FIHR5cGVuYW1lIFN0YXRpY1B0cjxUPjo6VmFsdWVUeXBlJiBTdGF0 aWNQdHI8VD46Om9wZXJhdG9yKigpCit7CisgICAgQVNTRVJUKG1fcHRyKTsKKyAgICByZXR1cm4g Km1fcHRyOworfQorCit0ZW1wbGF0ZTx0eXBlbmFtZSBUPgorQUxXQVlTX0lOTElORSB0eXBlbmFt ZSBTdGF0aWNQdHI8VD46OlB0clR5cGUgU3RhdGljUHRyPFQ+OjpvcGVyYXRvci0+KCkKK3sKKyAg ICBBU1NFUlQobV9wdHIpOworICAgIHJldHVybiBtX3B0cjsKK30KKwordGVtcGxhdGU8dHlwZW5h bWUgVD4KK0FMV0FZU19JTkxJTkUgdHlwZW5hbWUgU3RhdGljUHRyPFQ+OjpWYWx1ZVR5cGUmIFN0 YXRpY1B0cjxUPjo6b3BlcmF0b3IqKCkgY29uc3QKK3sKKyAgICBBU1NFUlQobV9wdHIpOworICAg IHJldHVybiAqbV9wdHI7Cit9CisKK3RlbXBsYXRlPHR5cGVuYW1lIFQ+CitBTFdBWVNfSU5MSU5F IHR5cGVuYW1lIFN0YXRpY1B0cjxUPjo6UHRyVHlwZSBTdGF0aWNQdHI8VD46Om9wZXJhdG9yLT4o KSBjb25zdAoreworICAgIEFTU0VSVChtX3B0cik7CisgICAgcmV0dXJuIG1fcHRyOworfQorCit0 ZW1wbGF0ZTx0eXBlbmFtZSBUPgorQUxXQVlTX0lOTElORSBib29sIFN0YXRpY1B0cjxUPjo6b3Bl cmF0b3IhKCkgY29uc3QKK3sKKyAgICByZXR1cm4gIW1fcHRyOworfQorCit9IC8vIG5hbWVzcGFj ZSBXVEYKKworI2VuZGlmCmRpZmYgLS1naXQgYS9KYXZhU2NyaXB0Q29yZS93dGYvU3RkTGliRXh0 cmFzLmggYi9KYXZhU2NyaXB0Q29yZS93dGYvU3RkTGliRXh0cmFzLmgKaW5kZXggYWZjNWU4YS4u ZWI2ODI4NiAxMDA2NDQKLS0tIGEvSmF2YVNjcmlwdENvcmUvd3RmL1N0ZExpYkV4dHJhcy5oCisr KyBiL0phdmFTY3JpcHRDb3JlL3d0Zi9TdGRMaWJFeHRyYXMuaApAQCAtMjgsMTEgKzI4LDE2IEBA CiAKICNpbmNsdWRlIDx3dGYvUGxhdGZvcm0uaD4KICNpbmNsdWRlIDx3dGYvQXNzZXJ0aW9ucy5o PgorI2luY2x1ZGUgPHd0Zi9TdGF0aWNQdHIuaD4KIAogLy8gVXNlIHRoZXNlIHRvIGRlY2xhcmUg YW5kIGRlZmluZSBhIHN0YXRpYyBsb2NhbCB2YXJpYWJsZSAoc3RhdGljIFQ7KSBzbyB0aGF0CiAv LyAgaXQgaXMgbGVha2VkIHNvIHRoYXQgaXRzIGRlc3RydWN0b3JzIGFyZSBub3QgY2FsbGVkIGF0 IGV4aXQuIFVzaW5nIHRoaXMKIC8vICBtYWNybyBhbHNvIGFsbG93cyB3b3JrYXJvdW5kcyBhIGNv bXBpbGVyIGJ1ZyBwcmVzZW50IGluIEFwcGxlJ3MgdmVyc2lvbiBvZiBHQ0MgNC4wLjEuCi0jaWYg Q09NUElMRVIoR0NDKSAmJiBkZWZpbmVkKF9fQVBQTEVfQ0NfXykgJiYgX19HTlVDX18gPT0gNCAm JiBfX0dOVUNfTUlOT1JfXyA9PSAwICYmIF9fR05VQ19QQVRDSExFVkVMX18gPT0gMQorI2lmIEVO QUJMRShGUkVFX1NUQVRJQ19QVFJTKQorI2RlZmluZSBERUZJTkVfU1RBVElDX0xPQ0FMKHR5cGUs IG5hbWUsIGFyZ3VtZW50cykgXAorICAgIHN0YXRpYyBXVEY6OlN0YXRpY1B0cjwgdHlwZSA+IG5h bWUjI1B0cihuZXcgdHlwZSBhcmd1bWVudHMpOyBcCisgICAgdHlwZSYgbmFtZSA9ICpuYW1lIyNQ dHIKKyNlbGlmIENPTVBJTEVSKEdDQykgJiYgZGVmaW5lZChfX0FQUExFX0NDX18pICYmIF9fR05V Q19fID09IDQgJiYgX19HTlVDX01JTk9SX18gPT0gMCAmJiBfX0dOVUNfUEFUQ0hMRVZFTF9fID09 IDEKICNkZWZpbmUgREVGSU5FX1NUQVRJQ19MT0NBTCh0eXBlLCBuYW1lLCBhcmd1bWVudHMpIFwK ICAgICBzdGF0aWMgdHlwZSogbmFtZSMjUHRyID0gbmV3IHR5cGUgYXJndW1lbnRzOyBcCiAgICAg dHlwZSYgbmFtZSA9ICpuYW1lIyNQdHIKZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL3d0Zi9U aHJlYWRTcGVjaWZpYy5oIGIvSmF2YVNjcmlwdENvcmUvd3RmL1RocmVhZFNwZWNpZmljLmgKaW5k ZXggNGQ1ZDJmNy4uOGJmZGNjZiAxMDA2NDQKLS0tIGEvSmF2YVNjcmlwdENvcmUvd3RmL1RocmVh ZFNwZWNpZmljLmgKKysrIGIvSmF2YVNjcmlwdENvcmUvd3RmL1RocmVhZFNwZWNpZmljLmgKQEAg LTIzMiw3ICsyMzIsOSBAQCBpbmxpbmUgdm9pZCBUaHJlYWRTcGVjaWZpYzxUPjo6ZGVzdHJveSh2 b2lkKiBwdHIpCiAjZXJyb3IgVGhyZWFkU3BlY2lmaWMgaXMgbm90IGltcGxlbWVudGVkIGZvciB0 aGlzIHBsYXRmb3JtLgogI2VuZGlmCiAKKyNpZiAhUExBVEZPUk0oUVQpCiAgICAgZGVsZXRlIGRh dGE7CisjZW5kaWYKIH0KIAogdGVtcGxhdGU8dHlwZW5hbWUgVD4KZGlmZiAtLWdpdCBhL1dlYkNv cmUvYmluZGluZ3MvanMvSlNET01XaW5kb3dCYXNlLmNwcCBiL1dlYkNvcmUvYmluZGluZ3MvanMv SlNET01XaW5kb3dCYXNlLmNwcAppbmRleCBkZjYwNjhhLi44OWZlYjNmIDEwMDY0NAotLS0gYS9X ZWJDb3JlL2JpbmRpbmdzL2pzL0pTRE9NV2luZG93QmFzZS5jcHAKKysrIGIvV2ViQ29yZS9iaW5k aW5ncy9qcy9KU0RPTVdpbmRvd0Jhc2UuY3BwCkBAIC0zNSw2ICszNSw3IEBACiAjaW5jbHVkZSAi U2NyaXB0Q29udHJvbGxlci5oIgogI2luY2x1ZGUgIlNlY3VyaXR5T3JpZ2luLmgiCiAjaW5jbHVk ZSAiU2V0dGluZ3MuaCIKKyNpbmNsdWRlICJ3dGYvU3RhdGljUHRyLmgiCiAKIHVzaW5nIG5hbWVz cGFjZSBKU0M7CiAKQEAgLTE2MSwxNSArMTYyLDI1IEBAIEpTRE9NV2luZG93U2hlbGwqIEpTRE9N V2luZG93QmFzZTo6c2hlbGwoKSBjb25zdAogICAgIHJldHVybiBkKCktPnNoZWxsOwogfQogCitj bGFzcyBTdGF0aWNHbG9iYWxEYXRhIDogcHVibGljIFdURjo6U3RhdGljUHRyPEpTR2xvYmFsRGF0 YT4geworcHJpdmF0ZToKKyNpZiBFTkFCTEUoRlJFRV9TVEFUSUNfUFRSUykKKyAgICB2aXJ0dWFs IHZvaWQgZnJlZSgpIHsKKyAgICAgICAgZ2V0KCktPmhlYXAuZGVzdHJveSgpOworICAgICAgICBk ZWxldGUgZ2V0KCk7CisgICAgfQorI2VuZGlmCit9OworCiBKU0dsb2JhbERhdGEqIEpTRE9NV2lu ZG93QmFzZTo6Y29tbW9uSlNHbG9iYWxEYXRhKCkKIHsKLSAgICBzdGF0aWMgSlNHbG9iYWxEYXRh KiBnbG9iYWxEYXRhOworICAgIHN0YXRpYyBTdGF0aWNHbG9iYWxEYXRhIGdsb2JhbERhdGE7CiAg ICAgaWYgKCFnbG9iYWxEYXRhKSB7Ci0gICAgICAgIGdsb2JhbERhdGEgPSBKU0dsb2JhbERhdGE6 OmNyZWF0ZUxlYWtlZCgpLnJlbGVhc2VSZWYoKTsKKyAgICAgICAgZ2xvYmFsRGF0YS5zZXQoSlNH bG9iYWxEYXRhOjpjcmVhdGVMZWFrZWQoKS5yZWxlYXNlUmVmKCkpOwogICAgICAgICBnbG9iYWxE YXRhLT50aW1lb3V0Q2hlY2tlci5zZXRUaW1lb3V0SW50ZXJ2YWwoMTAwMDApOyAvLyAxMCBzZWNv bmRzCiAgICAgfQogCi0gICAgcmV0dXJuIGdsb2JhbERhdGE7CisgICAgcmV0dXJuIGdsb2JhbERh dGEuZ2V0KCk7CiB9CiAKIC8vIEpTRE9NR2xvYmFsT2JqZWN0KiBpcyBpZ25vcmVkLCBhY2Nlc2lu ZyBhIHdpbmRvdyBpbiBhbnkgY29udGV4dCB3aWxsCmRpZmYgLS1naXQgYS9XZWJDb3JlL2RvbS9R dWFsaWZpZWROYW1lLmNwcCBiL1dlYkNvcmUvZG9tL1F1YWxpZmllZE5hbWUuY3BwCmluZGV4IDYw N2M4NDYuLmY3MGY3YTggMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZG9tL1F1YWxpZmllZE5hbWUuY3Bw CisrKyBiL1dlYkNvcmUvZG9tL1F1YWxpZmllZE5hbWUuY3BwCkBAIC05Miw3ICs5Miw3IEBAIHZv aWQgUXVhbGlmaWVkTmFtZTo6aW5pdCgpCiAgICAgICAgIC8vIFVzZSBwbGFjZW1lbnQgbmV3IHRv IGluaXRpYWxpemUgdGhlIGdsb2JhbHMuCiAgICAgICAgIAogICAgICAgICBBdG9taWNTdHJpbmc6 OmluaXQoKTsKLSAgICAgICAgbmV3ICgodm9pZCopJmFueU5hbWUpIFF1YWxpZmllZE5hbWUobnVs bEF0b20sIHN0YXJBdG9tLCBzdGFyQXRvbSk7CisgICAgICAgIElOSVRfR0xPQkFMKGFueU5hbWUs IEdsb2JhbFF1YWxpZmllZE5hbWUsIFF1YWxpZmllZE5hbWUobnVsbEF0b20sIHN0YXJBdG9tLCBz dGFyQXRvbSkpOwogICAgICAgICBpbml0aWFsaXplZCA9IHRydWU7CiAgICAgfQogfQpkaWZmIC0t Z2l0IGEvV2ViQ29yZS9kb20vUXVhbGlmaWVkTmFtZS5oIGIvV2ViQ29yZS9kb20vUXVhbGlmaWVk TmFtZS5oCmluZGV4IDkzOTkyN2IuLjAwMzY0NmQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZG9tL1F1 YWxpZmllZE5hbWUuaAorKysgYi9XZWJDb3JlL2RvbS9RdWFsaWZpZWROYW1lLmgKQEAgLTIzLDYg KzIzLDcgQEAKIAogI2luY2x1ZGUgIkF0b21pY1N0cmluZy5oIgogI2luY2x1ZGUgPHd0Zi9IYXNo RnVuY3Rpb25zLmg+CisjaW5jbHVkZSA8d3RmL1N0YXRpY1B0ci5oPgogCiBuYW1lc3BhY2UgV2Vi Q29yZSB7CiAKQEAgLTkwLDYgKzkxLDE3IEBAIHByaXZhdGU6CiAgICAgUXVhbGlmaWVkTmFtZUlt cGwqIG1faW1wbDsKIH07CiAKKyNpZiBFTkFCTEUoRlJFRV9TVEFUSUNfUFRSUykKK2NsYXNzIEds b2JhbFF1YWxpZmllZE5hbWUgOiBwdWJsaWMgV1RGOjpTdGF0aWNQdHJCYXNlIHsKK3B1YmxpYzoK KyAgICBHbG9iYWxRdWFsaWZpZWROYW1lKHZvaWQqIHB0cikgOiBtX3B0cihyZWludGVycHJldF9j YXN0PFF1YWxpZmllZE5hbWUqPihwdHIpLT5pbXBsKCkpIHsgfQorcHJpdmF0ZToKKyAgICBRdWFs aWZpZWROYW1lOjpRdWFsaWZpZWROYW1lSW1wbCogbV9wdHI7CisKKyAgICB2aXJ0dWFsIHZvaWQg ZnJlZSgpIHsgbV9wdHItPmRlcmVmKCk7IH07Cit9OworI2VuZGlmCisKICNpZm5kZWYgV0VCQ09S RV9RVUFMSUZJRUROQU1FX0hJREVfR0xPQkFMUwogZXh0ZXJuIGNvbnN0IFF1YWxpZmllZE5hbWUg YW55TmFtZTsKIGlubGluZSBjb25zdCBRdWFsaWZpZWROYW1lJiBhbnlRTmFtZSgpIHsgcmV0dXJu IGFueU5hbWU7IH0KZGlmZiAtLWdpdCBhL1dlYkNvcmUvZG9tL21ha2VfbmFtZXMucGwgYi9XZWJD b3JlL2RvbS9tYWtlX25hbWVzLnBsCmluZGV4IGU2ZDU5YTAuLjgwMjU1NTggMTAwNzU1Ci0tLSBh L1dlYkNvcmUvZG9tL21ha2VfbmFtZXMucGwKKysrIGIvV2ViQ29yZS9kb20vbWFrZV9uYW1lcy5w bApAQCAtNTUyLDcgKzU1Miw3IEBAIHByaW50IEYgIlxudm9pZCBpbml0KCkKICAgICBwcmludChG ICIgICAgQXRvbWljU3RyaW5nICR7bG93ZXJOYW1lc3BhY2V9TlMoXCIkcGFyYW1ldGVyc3snbmFt ZXNwYWNlVVJJJ31cIik7XG5cbiIpOwogCiAgICAgcHJpbnQoRiAiICAgIC8vIE5hbWVzcGFjZVxu Iik7Ci0gICAgcHJpbnQoRiAiICAgIG5ldyAoKHZvaWQqKSYke2xvd2VyTmFtZXNwYWNlfU5hbWVz cGFjZVVSSSkgQXRvbWljU3RyaW5nKCR7bG93ZXJOYW1lc3BhY2V9TlMpO1xuXG4iKTsKKyAgICBw cmludChGICIgICAgSU5JVF9HTE9CQUwoJHtsb3dlck5hbWVzcGFjZX1OYW1lc3BhY2VVUkksIEds b2JhbEF0b21pY1N0cmluZywgQXRvbWljU3RyaW5nKCR7bG93ZXJOYW1lc3BhY2V9TlMpKTtcblxu Iik7CiAgICAgaWYgKGtleXMgJXRhZ3MpIHsKICAgICAgICAgbXkgJHRhZ3NOYW1lc3BhY2UgPSAk cGFyYW1ldGVyc3sndGFnc051bGxOYW1lc3BhY2UnfSA/ICJudWxsQXRvbSIgOiAiJHtsb3dlck5h bWVzcGFjZX1OUyI7CiAgICAgICAgIHByaW50RGVmaW5pdGlvbnMoJEYsIFwldGFncywgInRhZ3Mi LCAkdGFnc05hbWVzcGFjZSk7CkBAIC02MzUsNyArNjM1LDcgQEAgc3ViIHByaW50RGVmaW5pdGlv bnMKICAgICBwcmludCAiXG4iOwogCiAgICAgZm9yIG15ICRuYW1lIChzb3J0IGtleXMgJSRuYW1l c1JlZikgewotICAgICAgICBwcmludCBGICIgICAgbmV3ICgodm9pZCopJiRuYW1lIiwiJHtzaG9y dENhbWVsVHlwZX0pIFF1YWxpZmllZE5hbWUobnVsbEF0b20sICRuYW1lIiwiJHtzaG9ydENhbWVs VHlwZX1TdHJpbmcsICRuYW1lc3BhY2VVUkkpO1xuIjsKKyAgICAgICAgcHJpbnQgRiAiICAgIElO SVRfR0xPQkFMKCRuYW1lIiwiJHtzaG9ydENhbWVsVHlwZX0sIEdsb2JhbFF1YWxpZmllZE5hbWUs IFF1YWxpZmllZE5hbWUobnVsbEF0b20sICRuYW1lIiwiJHtzaG9ydENhbWVsVHlwZX1TdHJpbmcs ICRuYW1lc3BhY2VVUkkpKTtcbiI7CiAgICAgfQogfQogCmRpZmYgLS1naXQgYS9XZWJDb3JlL2lu c3BlY3Rvci9KYXZhU2NyaXB0RGVidWdTZXJ2ZXIuaCBiL1dlYkNvcmUvaW5zcGVjdG9yL0phdmFT Y3JpcHREZWJ1Z1NlcnZlci5oCmluZGV4IGJhYTY2OTkuLjUyMGI0ODMgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvaW5zcGVjdG9yL0phdmFTY3JpcHREZWJ1Z1NlcnZlci5oCisrKyBiL1dlYkNvcmUvaW5z cGVjdG9yL0phdmFTY3JpcHREZWJ1Z1NlcnZlci5oCkBAIC04NSw5ICs4NSwxMCBAQCBuYW1lc3Bh Y2UgV2ViQ29yZSB7CiAgICAgICAgIHR5cGVkZWYgSGFzaFNldDxKYXZhU2NyaXB0RGVidWdMaXN0 ZW5lcio+IExpc3RlbmVyU2V0OwogICAgICAgICB0eXBlZGVmIHZvaWQgKEphdmFTY3JpcHREZWJ1 Z0xpc3RlbmVyOjoqSmF2YVNjcmlwdEV4ZWN1dGlvbkNhbGxiYWNrKSgpOwogCisgICAgICAgIH5K YXZhU2NyaXB0RGVidWdTZXJ2ZXIoKTsKKwogICAgIHByaXZhdGU6CiAgICAgICAgIEphdmFTY3Jp cHREZWJ1Z1NlcnZlcigpOwotICAgICAgICB+SmF2YVNjcmlwdERlYnVnU2VydmVyKCk7CiAKICAg ICAgICAgYm9vbCBoYXNMaXN0ZW5lcnMoKSBjb25zdCB7IHJldHVybiAhbV9saXN0ZW5lcnMuaXNF bXB0eSgpIHx8ICFtX3BhZ2VMaXN0ZW5lcnNNYXAuaXNFbXB0eSgpOyB9CiAgICAgICAgIGJvb2wg aGFzR2xvYmFsTGlzdGVuZXJzKCkgY29uc3QgeyByZXR1cm4gIW1fbGlzdGVuZXJzLmlzRW1wdHko KTsgfQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9sb2FkZXIvSW1hZ2VMb2FkZXIuY3BwIGIvV2ViQ29y ZS9sb2FkZXIvSW1hZ2VMb2FkZXIuY3BwCmluZGV4IGIxODNhNjYuLjJkNmVhZmYgMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvbG9hZGVyL0ltYWdlTG9hZGVyLmNwcAorKysgYi9XZWJDb3JlL2xvYWRlci9J bWFnZUxvYWRlci5jcHAKQEAgLTQxLDcgKzQxLDYgQEAgcHVibGljOgogICAgIHZvaWQgZGlzcGF0 Y2hQZW5kaW5nTG9hZEV2ZW50cygpOwogCiBwcml2YXRlOgotICAgIH5JbWFnZUxvYWRFdmVudFNl bmRlcigpOwogCiAgICAgdm9pZCB0aW1lckZpcmVkKFRpbWVyPEltYWdlTG9hZEV2ZW50U2VuZGVy PiopOwogCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL1N0YXRpY0NvbnN0cnVjdG9ycy5o IGIvV2ViQ29yZS9wbGF0Zm9ybS9TdGF0aWNDb25zdHJ1Y3RvcnMuaAppbmRleCAyNmI0NGRlLi5j ZDI3ZmQ5IDEwMDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL1N0YXRpY0NvbnN0cnVjdG9ycy5o CisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vU3RhdGljQ29uc3RydWN0b3JzLmgKQEAgLTIzLDYgKzIz LDggQEAKICNpZm5kZWYgU3RhdGljQ29uc3RydWN0b3JzX2gKICNkZWZpbmUgU3RhdGljQ29uc3Ry dWN0b3JzX2gKIAorI2luY2x1ZGUgInd0Zi9TdGF0aWNQdHIuaCIKKwogLy8gRm9yIFdlYkNvcmUg d2UgbmVlZCB0byBhdm9pZCBoYXZpbmcgc3RhdGljIGNvbnN0cnVjdG9ycy4gV2UgYWNoaWV2ZSB0 aGlzCiAvLyB3aXRoIHR3byBzZXBhcmF0ZSBtZXRob2RzIGZvciBHQ0MgYW5kIE1TVkMuIEJvdGgg bWV0aG9kcyBwcmV2ZW50IHRoZSBzdGF0aWMKIC8vIGluaXRpYWxpemVycyBmcm9tIGJlaW5nIHJl Z2lzdGVyZWQgYW5kIGNhbGxlZCBvbiBwcm9ncmFtIHN0YXJ0dXAuIE9uIEdDQywgd2UKQEAgLTcz LDQgKzc1LDEzIEBACiAjZW5kaWYKICNlbmRpZgogCisjaWYgRU5BQkxFKEZSRUVfU1RBVElDX1BU UlMpCisjZGVmaW5lIElOSVRfR0xPQkFMKG5hbWUsIHR5cGUsIGFyZ3VtZW50cykgXAorICAgIG5l dyAoKHZvaWQqKSZuYW1lKSBhcmd1bWVudHM7IFwKKyAgICBzdGF0aWMgdHlwZSBuYW1lIyNQdHIo cmVpbnRlcnByZXRfY2FzdDx2b2lkKj4oJm5hbWUpKQorI2Vsc2UKKyNkZWZpbmUgSU5JVF9HTE9C QUwobmFtZSwgdHlwZSwgYXJndW1lbnRzKSBcCisgICAgbmV3ICgodm9pZCopJm5hbWUpIGFyZ3Vt ZW50cworI2VuZGlmCisKICNlbmRpZiAvLyBTdGF0aWNDb25zdHJ1Y3RvcnNfaApkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9Gb250Q2FjaGUuaCBiL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvRm9udENhY2hlLmgKaW5kZXggM2MwZjJkOS4uODgyMDA0NSAxMDA2NDQKLS0t IGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9Gb250Q2FjaGUuaAorKysgYi9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL0ZvbnRDYWNoZS5oCkBAIC04NSw3ICs4NSw2IEBAIHB1YmxpYzoKIAog cHJpdmF0ZToKICAgICBGb250Q2FjaGUoKTsKLSAgICB+Rm9udENhY2hlKCk7CiAKICAgICAvLyBU aGVzZSBtZXRob2RzIGFyZSBpbXBsZW1lbnRlZCBieSBlYWNoIHBsYXRmb3JtLgogICAgIEZvbnRQ bGF0Zm9ybURhdGEqIGdldFNpbWlsYXJGb250UGxhdGZvcm1EYXRhKGNvbnN0IEZvbnQmKTsKZGlm ZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vdGV4dC9BdG9taWNTdHJpbmcuY3BwIGIvV2ViQ29y ZS9wbGF0Zm9ybS90ZXh0L0F0b21pY1N0cmluZy5jcHAKaW5kZXggNDA5NDM5ZS4uNTFjZTU1ZSAx MDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS90ZXh0L0F0b21pY1N0cmluZy5jcHAKKysrIGIv V2ViQ29yZS9wbGF0Zm9ybS90ZXh0L0F0b21pY1N0cmluZy5jcHAKQEAgLTI5NSwxMSArMjk1LDEx IEBAIHZvaWQgQXRvbWljU3RyaW5nOjppbml0KCkKICAgICAgICAgQVNTRVJUKGlzTWFpblRocmVh ZCgpKTsKIAogICAgICAgICAvLyBVc2UgcGxhY2VtZW50IG5ldyB0byBpbml0aWFsaXplIHRoZSBn bG9iYWxzLgotICAgICAgICBuZXcgKCh2b2lkKikmbnVsbEF0b20pIEF0b21pY1N0cmluZzsKLSAg ICAgICAgbmV3ICgodm9pZCopJmVtcHR5QXRvbSkgQXRvbWljU3RyaW5nKCIiKTsKLSAgICAgICAg bmV3ICgodm9pZCopJnRleHRBdG9tKSBBdG9taWNTdHJpbmcoIiN0ZXh0Iik7Ci0gICAgICAgIG5l dyAoKHZvaWQqKSZjb21tZW50QXRvbSkgQXRvbWljU3RyaW5nKCIjY29tbWVudCIpOwotICAgICAg ICBuZXcgKCh2b2lkKikmc3RhckF0b20pIEF0b21pY1N0cmluZygiKiIpOworICAgICAgICBJTklU X0dMT0JBTChudWxsQXRvbSwgR2xvYmFsQXRvbWljU3RyaW5nLCBBdG9taWNTdHJpbmcpOworICAg ICAgICBJTklUX0dMT0JBTChlbXB0eUF0b20sIEdsb2JhbEF0b21pY1N0cmluZywgQXRvbWljU3Ry aW5nKCIiKSk7CisgICAgICAgIElOSVRfR0xPQkFMKHRleHRBdG9tLCBHbG9iYWxBdG9taWNTdHJp bmcsIEF0b21pY1N0cmluZygiI3RleHQiKSk7CisgICAgICAgIElOSVRfR0xPQkFMKGNvbW1lbnRB dG9tLCBHbG9iYWxBdG9taWNTdHJpbmcsIEF0b21pY1N0cmluZygiI2NvbW1lbnQiKSk7CisgICAg ICAgIElOSVRfR0xPQkFMKHN0YXJBdG9tLCBHbG9iYWxBdG9taWNTdHJpbmcsIEF0b21pY1N0cmlu ZygiKiIpKTsKIAogICAgICAgICBpbml0aWFsaXplZCA9IHRydWU7CiAgICAgfQpkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9wbGF0Zm9ybS90ZXh0L0F0b21pY1N0cmluZy5oIGIvV2ViQ29yZS9wbGF0Zm9y bS90ZXh0L0F0b21pY1N0cmluZy5oCmluZGV4IDMzMDdhMmQuLjllYWUwZDQgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvcGxhdGZvcm0vdGV4dC9BdG9taWNTdHJpbmcuaAorKysgYi9XZWJDb3JlL3BsYXRm b3JtL3RleHQvQXRvbWljU3RyaW5nLmgKQEAgLTIzLDYgKzIzLDcgQEAKIAogI2luY2x1ZGUgIkF0 b21pY1N0cmluZ0ltcGwuaCIKICNpbmNsdWRlICJQbGF0Zm9ybVN0cmluZy5oIgorI2luY2x1ZGUg Ind0Zi9TdGF0aWNQdHIuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCkBAIC0xMTksNiArMTIw LDE3IEBAIHByaXZhdGU6CiAjZW5kaWYKIH07CiAKKyNpZiBFTkFCTEUoRlJFRV9TVEFUSUNfUFRS UykKK2NsYXNzIEdsb2JhbEF0b21pY1N0cmluZyA6IHB1YmxpYyBXVEY6OlN0YXRpY1B0ckJhc2Ug eworcHVibGljOgorICAgIEdsb2JhbEF0b21pY1N0cmluZyh2b2lkKiBwdHIpIDogbV9wdHIocmVp bnRlcnByZXRfY2FzdDxBdG9taWNTdHJpbmcqPihwdHIpLT5pbXBsKCkpIHsgfQorcHJpdmF0ZToK KyAgICBBdG9taWNTdHJpbmdJbXBsKiBtX3B0cjsKKworICAgIHZpcnR1YWwgdm9pZCBmcmVlKCkg eyBkZWxldGUgbV9wdHI7IH07Cit9OworI2VuZGlmCisKIGlubGluZSBib29sIG9wZXJhdG9yPT0o Y29uc3QgQXRvbWljU3RyaW5nJiBhLCBjb25zdCBBdG9taWNTdHJpbmcmIGIpIHsgcmV0dXJuIGEu aW1wbCgpID09IGIuaW1wbCgpOyB9CiBib29sIG9wZXJhdG9yPT0oY29uc3QgQXRvbWljU3RyaW5n JiBhLCBjb25zdCBjaGFyKiBiKTsKIGlubGluZSBib29sIG9wZXJhdG9yPT0oY29uc3QgQXRvbWlj U3RyaW5nJiBhLCBjb25zdCBTdHJpbmcmIGIpIHsgcmV0dXJuIGVxdWFsKGEuaW1wbCgpLCBiLmlt cGwoKSk7IH0KZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9BcGkvcXdlYmZyYW1lLmNwcCBiL1dlYktp dC9xdC9BcGkvcXdlYmZyYW1lLmNwcAppbmRleCAyM2NiNDczLi5hNGVmMzIyIDEwMDY0NAotLS0g YS9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5jcHAKKysrIGIvV2ViS2l0L3F0L0FwaS9xd2ViZnJh bWUuY3BwCkBAIC03OCw2ICs3OCwxMCBAQAogI2luY2x1ZGUgPHFwcmludGVyLmg+CiAjaW5jbHVk ZSA8cXJlZ2lvbi5oPgogCisjaWYgRU5BQkxFKEZSRUVfU1RBVElDX1BUUlMpCisjaW5jbHVkZSAi d3RmL1N0YXRpY1B0ci5oIgorI2VuZGlmCisKICNpZiBRVF9WRVJTSU9OIDwgMHgwNDA0MDAKICNp bmNsdWRlICJxd2VibmV0d29ya2ludGVyZmFjZS5oIgogI2VuZGlmCkBAIC0xODUsNiArMTg5LDEz IEBAIHZvaWQgUVdFQktJVF9FWFBPUlQgcXRfZHJ0X2dhcmJhZ2VDb2xsZWN0b3JfY29sbGVjdE9u QWx0ZXJuYXRlVGhyZWFkKGJvb2wgd2FpdFVuCiAgICAgZ2NDb250cm9sbGVyKCkuZ2FyYmFnZUNv bGxlY3RPbkFsdGVybmF0ZVRocmVhZEZvckRlYnVnZ2luZyh3YWl0VW50aWxEb25lKTsKIH0KIAor I2lmIEVOQUJMRShGUkVFX1NUQVRJQ19QVFJTKQordm9pZCBRV0VCS0lUX0VYUE9SVCBxdF9kcnRf ZnJlZVN0YXRpY1B0cnMoKQoreworICAgIFdURjo6U3RhdGljUHRyQmFzZTo6ZnJlZVN0YXRpY1B0 cnMoKTsKK30KKyNlbmRpZgorCiBRV2ViRnJhbWVEYXRhOjpRV2ViRnJhbWVEYXRhKFdlYkNvcmU6 OlBhZ2UqIHBhcmVudFBhZ2UsIFdlYkNvcmU6OkZyYW1lKiBwYXJlbnRGcmFtZSwKICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgV2ViQ29yZTo6SFRNTEZyYW1lT3duZXJFbGVtZW50KiBvd25l ckZyYW1lRWxlbWVudCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgV2ViQ29y ZTo6U3RyaW5nJiBmcmFtZU5hbWUpCmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvUXRMYXVuY2hlci9t YWluLmNwcCBiL1dlYktpdC9xdC9RdExhdW5jaGVyL21haW4uY3BwCmluZGV4IGEyMTk2ZjEuLmYw Y2Q1YmUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC9RdExhdW5jaGVyL21haW4uY3BwCisrKyBiL1dl YktpdC9xdC9RdExhdW5jaGVyL21haW4uY3BwCkBAIC01Myw2ICs1Myw3IEBACiAKICNpZm5kZWYg TkRFQlVHCiB2b2lkIFFXRUJLSVRfRVhQT1JUIHF0X2RydF9nYXJiYWdlQ29sbGVjdG9yX2NvbGxl Y3QoKTsKK3ZvaWQgUVdFQktJVF9FWFBPUlQgcXRfZHJ0X2ZyZWVTdGF0aWNQdHJzKCk7CiAjZW5k aWYKIAogY2xhc3MgV2ViUGFnZSA6IHB1YmxpYyBRV2ViUGFnZQpAQCAtNDYyLDYgKzQ2Myw3IEBA IGludCBtYWluKGludCBhcmdjLCBjaGFyICoqYXJndikKICAgICAgICAgaW50IHJldFZhbCA9IGFw cC5leGVjKCk7CiAgICAgICAgIHF0X2RydF9nYXJiYWdlQ29sbGVjdG9yX2NvbGxlY3QoKTsKICAg ICAgICAgUVdlYlNldHRpbmdzOjpjbGVhck1lbW9yeUNhY2hlcygpOworICAgICAgICBxdF9kcnRf ZnJlZVN0YXRpY1B0cnMoKTsKICAgICAgICAgcmV0dXJuIHJldFZhbDsKICNlbHNlCiAgICAgICAg IHJldHVybiBhcHAuZXhlYygpOwo= 34265 2009-08-07 04:19:09 -0700 2009-08-11 04:42:13 -0700 Third patch StaticPtrs-draft-0.3.patch text/plain 27364 zherczeg ZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLnByaSBiL0phdmFTY3Jp cHRDb3JlL0phdmFTY3JpcHRDb3JlLnByaQppbmRleCBkYjkzMTU3Li5jMmZkYTYyIDEwMDY0NAot LS0gYS9KYXZhU2NyaXB0Q29yZS9KYXZhU2NyaXB0Q29yZS5wcmkKKysrIGIvSmF2YVNjcmlwdENv cmUvSmF2YVNjcmlwdENvcmUucHJpCkBAIC03NSw2ICs3NSw3IEBAIFNPVVJDRVMgKz0gXAogICAg IHd0Zi9NYWluVGhyZWFkLmNwcCBcCiAgICAgd3RmL1JhbmRvbU51bWJlci5jcHAgXAogICAgIHd0 Zi9SZWZDb3VudGVkTGVha0NvdW50ZXIuY3BwIFwKKyAgICB3dGYvU3RhdGljUHRyLmNwcCBcCiAg ICAgd3RmL1R5cGVUcmFpdHMuY3BwIFwKICAgICB3dGYvdW5pY29kZS9Db2xsYXRvckRlZmF1bHQu Y3BwIFwKICAgICB3dGYvdW5pY29kZS9pY3UvQ29sbGF0b3JJQ1UuY3BwIFwKZGlmZiAtLWdpdCBh L0phdmFTY3JpcHRDb3JlL3d0Zi9QbGF0Zm9ybS5oIGIvSmF2YVNjcmlwdENvcmUvd3RmL1BsYXRm b3JtLmgKaW5kZXggM2Y2NGM3Ny4uNzQ4ZTcxNyAxMDA2NDQKLS0tIGEvSmF2YVNjcmlwdENvcmUv d3RmL1BsYXRmb3JtLmgKKysrIGIvSmF2YVNjcmlwdENvcmUvd3RmL1BsYXRmb3JtLmgKQEAgLTcw NCw0ICs3MDQsNiBAQAogI2RlZmluZSBXVEZfVVNFX0FDQ0VMRVJBVEVEX0NPTVBPU0lUSU5HIDEK ICNlbmRpZgogCisjZGVmaW5lIEVOQUJMRV9GUkVFX1NUQVRJQ19QVFJTIDEKKwogI2VuZGlmIC8q IFdURl9QbGF0Zm9ybV9oICovCmRpZmYgLS1naXQgYS9KYXZhU2NyaXB0Q29yZS93dGYvU3RhdGlj UHRyLmNwcCBiL0phdmFTY3JpcHRDb3JlL3d0Zi9TdGF0aWNQdHIuY3BwCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAuLjBkMmY5OTgKLS0tIC9kZXYvbnVsbAorKysgYi9KYXZhU2Ny aXB0Q29yZS93dGYvU3RhdGljUHRyLmNwcApAQCAtMCwwICsxLDcwIEBACisvKgorICogQ29weXJp Z2h0IChDKSAyMDA5IFVuaXZlcnNpdHkgb2YgU3plZ2VkCisgKiBBbGwgcmlnaHRzIHJlc2VydmVk LgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9y bXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3Zp ZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVk aXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmln aHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0 IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBv ZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBk b2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlz dHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVU5JVkVSU0lU WSBPRiBTWkVHRUQgYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJS QU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdB UlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIK KyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBVTklWRVJTSVRZ IE9GIFNaRUdFRCBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwg SU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVF TlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJF TUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwg T1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQg QU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwg U1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9U SEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNP RlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdF LgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJTdGF0aWNQdHIuaCIKKwor bmFtZXNwYWNlIFdURiB7CisKKyNpZiBFTkFCTEUoRlJFRV9TVEFUSUNfUFRSUykKKworU3RhdGlj UHRyQmFzZTo6U3RhdGljUHRyQmFzZSogU3RhdGljUHRyQmFzZTo6bV9oZWFkID0gMDsKKwordm9p ZCBTdGF0aWNQdHJCYXNlOjpmcmVlU3RhdGljUHRycygpCit7CisgICAgLy8gRnJlZSB0aGVtIGlu IGEgcmV2ZXJzZWQgY3JlYXRpb24gb3JkZXIKKyAgICBTdGF0aWNQdHJCYXNlKiBjdXJyZW50ID0g aGVhZCgpOworICAgIHdoaWxlIChjdXJyZW50KSB7CisgICAgICAgIGN1cnJlbnQtPmZyZWUoKTsK KyAgICAgICAgY3VycmVudCA9IGN1cnJlbnQtPm5leHQoKTsKKyAgICB9Cit9CisKK3ZvaWQgU3Rh dGljUHRyQmFzZTo6YXBwZW5kKCkKK3sKKyAgICBtX25leHQgPSBoZWFkKCk7CisgICAgbV9oZWFk ID0gdGhpczsKK30KKwordm9pZCBTdGF0aWNQdHJCYXNlOjpyZW1vdmUoKQoreworICAgIC8vIFBl cmhhcHMgYSBkb3VibGUgbGlua2VkIGxpc3QgbWF5IGJlIHN1aXRhYmxlIGlmIHJlbW92ZSgpIGNh bGxlZCBmcmVxdWVudGx5CisgICAgU3RhdGljUHRyQmFzZSogY3VycmVudCA9IGhlYWQoKTsKKyAg ICBpZiAoY3VycmVudCA9PSB0aGlzKSB7CisgICAgICAgIG1faGVhZCA9IGN1cnJlbnQtPm5leHQo KTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIHdoaWxlIChjdXJyZW50LT5uZXh0KCkg IT0gdGhpcykgeworICAgICAgICBjdXJyZW50ID0gY3VycmVudC0+bmV4dCgpOworICAgICAgICBB U1NFUlQoY3VycmVudCk7CisgICAgfQorICAgIGN1cnJlbnQtPm1fbmV4dCA9IG5leHQoKTsKK30K KworI2VuZGlmIC8vIEVOQUJMRShGUkVFX1NUQVRJQ19QVFJTKQorCit9IC8vIG5hbWVzcGFjZSBX VEYKZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL3d0Zi9TdGF0aWNQdHIuaCBiL0phdmFTY3Jp cHRDb3JlL3d0Zi9TdGF0aWNQdHIuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw Li45NjQ0ZGQ0Ci0tLSAvZGV2L251bGwKKysrIGIvSmF2YVNjcmlwdENvcmUvd3RmL1N0YXRpY1B0 ci5oCkBAIC0wLDAgKzEsMjE1IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDA5IFVuaXZlcnNp dHkgb2YgU3plZ2VkCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0 aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAor ICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2lu ZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJj ZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIu IFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUg Y29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBv dGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRI SVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVU5JVkVSU0lUWSBPRiBTWkVHRUQgYGBBUyBJUycn IEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJV VCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRB QklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NM QUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBVTklWRVJTSVRZIE9GIFNaRUdFRCBPUgorICogQ09O VFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUws IFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVE SU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdP T0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJV U0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAq IE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1Ig VE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBB TlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklT RUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgV1RG X1N0YXRpY1B0cl9oCisjZGVmaW5lIFdURl9TdGF0aWNQdHJfaAorCisjaW5jbHVkZSAiQXNzZXJ0 aW9ucy5oIgorI2luY2x1ZGUgIlR5cGVUcmFpdHMuaCIKKyNpbmNsdWRlICJBbHdheXNJbmxpbmUu aCIKKworbmFtZXNwYWNlIFdURiB7CisKK2NsYXNzIFN0YXRpY1B0ckJhc2UgeworcHVibGljOgor I2lmICFFTkFCTEUoRlJFRV9TVEFUSUNfUFRSUykKKyAgICB2b2lkIGFwcGVuZCgpIHsgfQorI2Vs c2UKKyAgICB2b2lkIGFwcGVuZCgpOworICAgIHZvaWQgcmVtb3ZlKCk7CisKKyAgICBzdGF0aWMg dm9pZCBmcmVlU3RhdGljUHRycygpOworCisgICAgLy8gU3VwcHJlc3MgR0NDIHdhcm5pbmcKKyAg ICB2aXJ0dWFsIH5TdGF0aWNQdHJCYXNlKCkgeyB9CisKK3ByaXZhdGU6CisgICAgc3RhdGljIFN0 YXRpY1B0ckJhc2UqIG1faGVhZDsKKyAgICBTdGF0aWNQdHJCYXNlKiBtX25leHQ7CisKKyAgICBz dGF0aWMgU3RhdGljUHRyQmFzZSogaGVhZCgpIHsgcmV0dXJuIG1faGVhZDsgfQorICAgIFN0YXRp Y1B0ckJhc2UqIG5leHQoKSB7IHJldHVybiBtX25leHQ7IH0KKworICAgIHZpcnR1YWwgdm9pZCBm cmVlKCkgPSAwOworI2VuZGlmCit9OworCit0ZW1wbGF0ZTx0eXBlbmFtZSBUPiBjbGFzcyBTdGF0 aWNQdHIgOiBwdWJsaWMgU3RhdGljUHRyQmFzZSB7CitwdWJsaWM6CisgICAgdHlwZWRlZiB0eXBl bmFtZSBSZW1vdmVQb2ludGVyPFQ+OjpUeXBlIFZhbHVlVHlwZTsKKyAgICB0eXBlZGVmIFZhbHVl VHlwZSogUHRyVHlwZTsKKworICAgIFN0YXRpY1B0cihQdHJUeXBlIHB0cikgOiBtX3B0cihwdHIp IHsgYXBwZW5kKCk7IH0KKyAgICBTdGF0aWNQdHIoKSA6IG1fcHRyKDApIHsgfQorCisgICAgUHRy VHlwZSBnZXQoKSBjb25zdDsKKyAgICB2b2lkIHNldChQdHJUeXBlKTsKKworICAgIFB0clR5cGUg b3BlcmF0b3I9KFB0clR5cGUpOworCisgICAgLy8gVmFsdWUgYWNjZXNzIG9wZXJhdG9ycworICAg IFZhbHVlVHlwZSYgb3BlcmF0b3IqKCk7CisgICAgUHRyVHlwZSBvcGVyYXRvci0+KCk7CisgICAg VmFsdWVUeXBlJiBvcGVyYXRvciooKSBjb25zdDsKKyAgICBQdHJUeXBlIG9wZXJhdG9yLT4oKSBj b25zdDsKKworICAgIGJvb2wgb3BlcmF0b3IhKCkgY29uc3Q7CisKKyAgICB2b2lkIGRlbGV0ZVB0 cigpOworCitwcml2YXRlOgorICAgIC8vIFRoaXMgcG9pbnRlciBjYW4gYmUgaW5pdGlhbGl6ZWQg YXQgbW9zdCBvbmNlCisgICAgUHRyVHlwZSBtX3B0cjsKKworI2lmIEVOQUJMRShGUkVFX1NUQVRJ Q19QVFJTKQorICAgIHZpcnR1YWwgdm9pZCBmcmVlKCkgeyBBU1NFUlQobV9wdHIpOyBkZWxldGUg bV9wdHI7IH0KKyNlbmRpZgorfTsKKworLy8gV3JhcHBlciBjbGFzcyBmb3IgYXJyYXlzLCB3aGlj aCBhc3NpZ25lZCB0byBhIHN0YXRpYyB2YXJpYWJsZQorLy8gQnkgZGVmYXVsdCwgaXQgYmVoYXZl cyBsaWtlIGEgc2ltcGxlIEMrKyBhcnJheSB3aXRob3V0IHBlcmZvcm1hbmNlIG92ZXJoZWFkCit0 ZW1wbGF0ZTx0eXBlbmFtZSBUPiBjbGFzcyBTdGF0aWNBcnJheVB0ciA6IHB1YmxpYyBTdGF0aWNQ dHJCYXNlIHsKK3B1YmxpYzoKKyAgICB0eXBlZGVmIHR5cGVuYW1lIFJlbW92ZVBvaW50ZXI8VD46 OlR5cGUgVmFsdWVUeXBlOworICAgIHR5cGVkZWYgVmFsdWVUeXBlKiBQdHJUeXBlOworCisgICAg U3RhdGljQXJyYXlQdHIoUHRyVHlwZSBwdHIpIDogbV9wdHIocHRyKSB7IGFwcGVuZCgpOyB9CisK KyAgICBWYWx1ZVR5cGUmIG9wZXJhdG9yW10oc2l6ZV90KTsKKyAgICBjb25zdCBWYWx1ZVR5cGUm IG9wZXJhdG9yW10oc2l6ZV90KSBjb25zdDsKKworcHJpdmF0ZToKKyAgICAvLyBUaGlzIHBvaW50 ZXIgY2FuIGJlIGluaXRpYWxpemVkIGF0IG1vc3Qgb25jZQorICAgIFB0clR5cGUgbV9wdHI7CisK KyNpZiBFTkFCTEUoRlJFRV9TVEFUSUNfUFRSUykKKyAgICB2aXJ0dWFsIHZvaWQgZnJlZSgpIHsg QVNTRVJUKG1fcHRyKTsgZGVsZXRlW10gbV9wdHI7IH0KKyNlbmRpZgorfTsKKworI2lmIEVOQUJM RShGUkVFX1NUQVRJQ19QVFJTKQordGVtcGxhdGU8dHlwZW5hbWUgVD4gY2xhc3MgR2xvYmFsU3Rh dGljUHRyIDogcHVibGljIFdURjo6U3RhdGljUHRyQmFzZSB7CitwdWJsaWM6CisgICAgR2xvYmFs U3RhdGljUHRyKHZvaWQqIHJlZikgOiBtX3JlZihyZWludGVycHJldF9jYXN0PFQqPihyZWYpKSB7 IH0KK3ByaXZhdGU6CisgICAgVCogbV9yZWY7CisKKyAgICB2aXJ0dWFsIHZvaWQgZnJlZSgpIHsg bV9yZWYtPn5UKCk7IH0KK307CisjZW5kaWYKKwordGVtcGxhdGU8dHlwZW5hbWUgVD4KK0FMV0FZ U19JTkxJTkUgdHlwZW5hbWUgU3RhdGljUHRyPFQ+OjpQdHJUeXBlIFN0YXRpY1B0cjxUPjo6Z2V0 KCkgY29uc3QKK3sKKyAgICByZXR1cm4gbV9wdHI7Cit9CisKK3RlbXBsYXRlPHR5cGVuYW1lIFQ+ CitBTFdBWVNfSU5MSU5FIHZvaWQgU3RhdGljUHRyPFQ+OjpzZXQoUHRyVHlwZSB2YWx1ZSkKK3sK KyAgICAvLyBEZXRlY3QgbWVtb3J5IGxlYWtzCisgICAgQVNTRVJUKCFtX3B0ciB8fCAobV9wdHIg PT0gdmFsdWUpKTsKKyAgICBtX3B0ciA9IHZhbHVlOworI2lmIEVOQUJMRShGUkVFX1NUQVRJQ19Q VFJTKQorICAgIC8vIFRoZSAjaWYgbWF5IGJlIG5vdCBuZWNlc3NhcnkgaGVyZSwgc2luY2UgY29t cGlsZXJzIHNob3VsZAorICAgIC8vIGJlIGVsaW1pbmF0ZSB0aGUgImlmKHZhbHVlKSB7IH0iIGRl YWQgY29kZQorICAgIGlmICh2YWx1ZSkKKyAgICAgICAgYXBwZW5kKCk7CisjZW5kaWYKK30KKwor dGVtcGxhdGU8dHlwZW5hbWUgVD4KK0FMV0FZU19JTkxJTkUgdHlwZW5hbWUgU3RhdGljUHRyPFQ+ OjpQdHJUeXBlIFN0YXRpY1B0cjxUPjo6b3BlcmF0b3I9KFB0clR5cGUgdmFsdWUpCit7CisgICAg c2V0KHZhbHVlKTsKKyAgICByZXR1cm4gdmFsdWU7Cit9CisKK3RlbXBsYXRlPHR5cGVuYW1lIFQ+ CitBTFdBWVNfSU5MSU5FIHR5cGVuYW1lIFN0YXRpY1B0cjxUPjo6VmFsdWVUeXBlJiBTdGF0aWNQ dHI8VD46Om9wZXJhdG9yKigpCit7CisgICAgQVNTRVJUKG1fcHRyKTsKKyAgICByZXR1cm4gKm1f cHRyOworfQorCit0ZW1wbGF0ZTx0eXBlbmFtZSBUPgorQUxXQVlTX0lOTElORSB0eXBlbmFtZSBT dGF0aWNQdHI8VD46OlB0clR5cGUgU3RhdGljUHRyPFQ+OjpvcGVyYXRvci0+KCkKK3sKKyAgICBB U1NFUlQobV9wdHIpOworICAgIHJldHVybiBtX3B0cjsKK30KKwordGVtcGxhdGU8dHlwZW5hbWUg VD4KK0FMV0FZU19JTkxJTkUgdHlwZW5hbWUgU3RhdGljUHRyPFQ+OjpWYWx1ZVR5cGUmIFN0YXRp Y1B0cjxUPjo6b3BlcmF0b3IqKCkgY29uc3QKK3sKKyAgICBBU1NFUlQobV9wdHIpOworICAgIHJl dHVybiAqbV9wdHI7Cit9CisKK3RlbXBsYXRlPHR5cGVuYW1lIFQ+CitBTFdBWVNfSU5MSU5FIHR5 cGVuYW1lIFN0YXRpY1B0cjxUPjo6UHRyVHlwZSBTdGF0aWNQdHI8VD46Om9wZXJhdG9yLT4oKSBj b25zdAoreworICAgIEFTU0VSVChtX3B0cik7CisgICAgcmV0dXJuIG1fcHRyOworfQorCit0ZW1w bGF0ZTx0eXBlbmFtZSBUPgorQUxXQVlTX0lOTElORSBib29sIFN0YXRpY1B0cjxUPjo6b3BlcmF0 b3IhKCkgY29uc3QKK3sKKyAgICByZXR1cm4gIW1fcHRyOworfQorCit0ZW1wbGF0ZTx0eXBlbmFt ZSBUPgorQUxXQVlTX0lOTElORSB2b2lkIFN0YXRpY1B0cjxUPjo6ZGVsZXRlUHRyKCkKK3sKKyAg ICBBU1NFUlQobV9wdHIpOworICAgIGRlbGV0ZSBtX3B0cjsKKyNpZm5kZWYgTkRFQlVHCisgICAg Ly8gU2VlIFN0YXRpY1B0cjxUPjo6c2V0CisgICAgbV9wdHIgPSAwOworI2VuZGlmCisjaWYgRU5B QkxFKEZSRUVfU1RBVElDX1BUUlMpCisgICAgcmVtb3ZlKCk7CisjZW5kaWYKK30KKwordGVtcGxh dGU8dHlwZW5hbWUgVD4KK0FMV0FZU19JTkxJTkUgdHlwZW5hbWUgU3RhdGljQXJyYXlQdHI8VD46 OlZhbHVlVHlwZSYgU3RhdGljQXJyYXlQdHI8VD46Om9wZXJhdG9yW10oc2l6ZV90IGkpCit7Cisg ICAgQVNTRVJUKG1fcHRyKTsKKyAgICByZXR1cm4gbV9wdHJbaV07Cit9CisKK3RlbXBsYXRlPHR5 cGVuYW1lIFQ+CitBTFdBWVNfSU5MSU5FIGNvbnN0IHR5cGVuYW1lIFN0YXRpY0FycmF5UHRyPFQ+ OjpWYWx1ZVR5cGUmIFN0YXRpY0FycmF5UHRyPFQ+OjpvcGVyYXRvcltdKHNpemVfdCBpKSBjb25z dAoreworICAgIEFTU0VSVChtX3B0cik7CisgICAgcmV0dXJuIG1fcHRyW2ldOworfQorCit9IC8v IG5hbWVzcGFjZSBXVEYKKworI2VuZGlmCmRpZmYgLS1naXQgYS9KYXZhU2NyaXB0Q29yZS93dGYv U3RkTGliRXh0cmFzLmggYi9KYXZhU2NyaXB0Q29yZS93dGYvU3RkTGliRXh0cmFzLmgKaW5kZXgg YWZjNWU4YS4uZWI2ODI4NiAxMDA2NDQKLS0tIGEvSmF2YVNjcmlwdENvcmUvd3RmL1N0ZExpYkV4 dHJhcy5oCisrKyBiL0phdmFTY3JpcHRDb3JlL3d0Zi9TdGRMaWJFeHRyYXMuaApAQCAtMjgsMTEg KzI4LDE2IEBACiAKICNpbmNsdWRlIDx3dGYvUGxhdGZvcm0uaD4KICNpbmNsdWRlIDx3dGYvQXNz ZXJ0aW9ucy5oPgorI2luY2x1ZGUgPHd0Zi9TdGF0aWNQdHIuaD4KIAogLy8gVXNlIHRoZXNlIHRv IGRlY2xhcmUgYW5kIGRlZmluZSBhIHN0YXRpYyBsb2NhbCB2YXJpYWJsZSAoc3RhdGljIFQ7KSBz byB0aGF0CiAvLyAgaXQgaXMgbGVha2VkIHNvIHRoYXQgaXRzIGRlc3RydWN0b3JzIGFyZSBub3Qg Y2FsbGVkIGF0IGV4aXQuIFVzaW5nIHRoaXMKIC8vICBtYWNybyBhbHNvIGFsbG93cyB3b3JrYXJv dW5kcyBhIGNvbXBpbGVyIGJ1ZyBwcmVzZW50IGluIEFwcGxlJ3MgdmVyc2lvbiBvZiBHQ0MgNC4w LjEuCi0jaWYgQ09NUElMRVIoR0NDKSAmJiBkZWZpbmVkKF9fQVBQTEVfQ0NfXykgJiYgX19HTlVD X18gPT0gNCAmJiBfX0dOVUNfTUlOT1JfXyA9PSAwICYmIF9fR05VQ19QQVRDSExFVkVMX18gPT0g MQorI2lmIEVOQUJMRShGUkVFX1NUQVRJQ19QVFJTKQorI2RlZmluZSBERUZJTkVfU1RBVElDX0xP Q0FMKHR5cGUsIG5hbWUsIGFyZ3VtZW50cykgXAorICAgIHN0YXRpYyBXVEY6OlN0YXRpY1B0cjwg dHlwZSA+IG5hbWUjI1B0cihuZXcgdHlwZSBhcmd1bWVudHMpOyBcCisgICAgdHlwZSYgbmFtZSA9 ICpuYW1lIyNQdHIKKyNlbGlmIENPTVBJTEVSKEdDQykgJiYgZGVmaW5lZChfX0FQUExFX0NDX18p ICYmIF9fR05VQ19fID09IDQgJiYgX19HTlVDX01JTk9SX18gPT0gMCAmJiBfX0dOVUNfUEFUQ0hM RVZFTF9fID09IDEKICNkZWZpbmUgREVGSU5FX1NUQVRJQ19MT0NBTCh0eXBlLCBuYW1lLCBhcmd1 bWVudHMpIFwKICAgICBzdGF0aWMgdHlwZSogbmFtZSMjUHRyID0gbmV3IHR5cGUgYXJndW1lbnRz OyBcCiAgICAgdHlwZSYgbmFtZSA9ICpuYW1lIyNQdHIKZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRD b3JlL3d0Zi9UaHJlYWRTcGVjaWZpYy5oIGIvSmF2YVNjcmlwdENvcmUvd3RmL1RocmVhZFNwZWNp ZmljLmgKaW5kZXggNGQ1ZDJmNy4uOGJmZGNjZiAxMDA2NDQKLS0tIGEvSmF2YVNjcmlwdENvcmUv d3RmL1RocmVhZFNwZWNpZmljLmgKKysrIGIvSmF2YVNjcmlwdENvcmUvd3RmL1RocmVhZFNwZWNp ZmljLmgKQEAgLTIzMiw3ICsyMzIsOSBAQCBpbmxpbmUgdm9pZCBUaHJlYWRTcGVjaWZpYzxUPjo6 ZGVzdHJveSh2b2lkKiBwdHIpCiAjZXJyb3IgVGhyZWFkU3BlY2lmaWMgaXMgbm90IGltcGxlbWVu dGVkIGZvciB0aGlzIHBsYXRmb3JtLgogI2VuZGlmCiAKKyNpZiAhUExBVEZPUk0oUVQpCiAgICAg ZGVsZXRlIGRhdGE7CisjZW5kaWYKIH0KIAogdGVtcGxhdGU8dHlwZW5hbWUgVD4KZGlmZiAtLWdp dCBhL1dlYkNvcmUvYmluZGluZ3MvanMvSlNET01XaW5kb3dCYXNlLmNwcCBiL1dlYkNvcmUvYmlu ZGluZ3MvanMvSlNET01XaW5kb3dCYXNlLmNwcAppbmRleCBkZjYwNjhhLi44OWZlYjNmIDEwMDY0 NAotLS0gYS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTRE9NV2luZG93QmFzZS5jcHAKKysrIGIvV2Vi Q29yZS9iaW5kaW5ncy9qcy9KU0RPTVdpbmRvd0Jhc2UuY3BwCkBAIC0zNSw2ICszNSw3IEBACiAj aW5jbHVkZSAiU2NyaXB0Q29udHJvbGxlci5oIgogI2luY2x1ZGUgIlNlY3VyaXR5T3JpZ2luLmgi CiAjaW5jbHVkZSAiU2V0dGluZ3MuaCIKKyNpbmNsdWRlICJ3dGYvU3RhdGljUHRyLmgiCiAKIHVz aW5nIG5hbWVzcGFjZSBKU0M7CiAKQEAgLTE2MSwxNSArMTYyLDI1IEBAIEpTRE9NV2luZG93U2hl bGwqIEpTRE9NV2luZG93QmFzZTo6c2hlbGwoKSBjb25zdAogICAgIHJldHVybiBkKCktPnNoZWxs OwogfQogCitjbGFzcyBTdGF0aWNHbG9iYWxEYXRhIDogcHVibGljIFdURjo6U3RhdGljUHRyPEpT R2xvYmFsRGF0YT4geworcHJpdmF0ZToKKyNpZiBFTkFCTEUoRlJFRV9TVEFUSUNfUFRSUykKKyAg ICB2aXJ0dWFsIHZvaWQgZnJlZSgpIHsKKyAgICAgICAgZ2V0KCktPmhlYXAuZGVzdHJveSgpOwor ICAgICAgICBkZWxldGUgZ2V0KCk7CisgICAgfQorI2VuZGlmCit9OworCiBKU0dsb2JhbERhdGEq IEpTRE9NV2luZG93QmFzZTo6Y29tbW9uSlNHbG9iYWxEYXRhKCkKIHsKLSAgICBzdGF0aWMgSlNH bG9iYWxEYXRhKiBnbG9iYWxEYXRhOworICAgIHN0YXRpYyBTdGF0aWNHbG9iYWxEYXRhIGdsb2Jh bERhdGE7CiAgICAgaWYgKCFnbG9iYWxEYXRhKSB7Ci0gICAgICAgIGdsb2JhbERhdGEgPSBKU0ds b2JhbERhdGE6OmNyZWF0ZUxlYWtlZCgpLnJlbGVhc2VSZWYoKTsKKyAgICAgICAgZ2xvYmFsRGF0 YS5zZXQoSlNHbG9iYWxEYXRhOjpjcmVhdGVMZWFrZWQoKS5yZWxlYXNlUmVmKCkpOwogICAgICAg ICBnbG9iYWxEYXRhLT50aW1lb3V0Q2hlY2tlci5zZXRUaW1lb3V0SW50ZXJ2YWwoMTAwMDApOyAv LyAxMCBzZWNvbmRzCiAgICAgfQogCi0gICAgcmV0dXJuIGdsb2JhbERhdGE7CisgICAgcmV0dXJu IGdsb2JhbERhdGEuZ2V0KCk7CiB9CiAKIC8vIEpTRE9NR2xvYmFsT2JqZWN0KiBpcyBpZ25vcmVk LCBhY2Nlc2luZyBhIHdpbmRvdyBpbiBhbnkgY29udGV4dCB3aWxsCmRpZmYgLS1naXQgYS9XZWJD b3JlL2JyaWRnZS9JZGVudGlmaWVyUmVwLmNwcCBiL1dlYkNvcmUvYnJpZGdlL0lkZW50aWZpZXJS ZXAuY3BwCmluZGV4IDExNTYwZTMuLjhiZTBjN2IgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYnJpZGdl L0lkZW50aWZpZXJSZXAuY3BwCisrKyBiL1dlYkNvcmUvYnJpZGdlL0lkZW50aWZpZXJSZXAuY3Bw CkBAIC0zMCw2ICszMCw3IEBACiAjaW5jbHVkZSA8cnVudGltZS9VU3RyaW5nLmg+CiAjaW5jbHVk ZSA8d3RmL0hhc2hNYXAuaD4KICNpbmNsdWRlIDx3dGYvU3RkTGliRXh0cmFzLmg+CisjaW5jbHVk ZSA8d3RmL1N0YXRpY1B0ci5oPgogCiB1c2luZyBuYW1lc3BhY2UgSlNDOwogCkBAIC01NCw5ICs1 NSw5IEBAIHN0YXRpYyBJbnRJZGVudGlmaWVyTWFwJiBpbnRJZGVudGlmaWVyTWFwKCkKIElkZW50 aWZpZXJSZXAqIElkZW50aWZpZXJSZXA6OmdldChpbnQgaW50SUQpCiB7CiAgICAgaWYgKGludElE ID09IDAgfHwgaW50SUQgPT0gLTEpIHsKLSAgICAgICAgc3RhdGljIElkZW50aWZpZXJSZXAqIG5l Z2F0aXZlT25lQW5kWmVyb0lkZW50aWZpZXJzWzJdOworICAgICAgICBzdGF0aWMgV1RGOjpTdGF0 aWNQdHI8SWRlbnRpZmllclJlcD4gbmVnYXRpdmVPbmVBbmRaZXJvSWRlbnRpZmllcnNbMl07CiAK LSAgICAgICAgSWRlbnRpZmllclJlcCogaWRlbnRpZmllciA9IG5lZ2F0aXZlT25lQW5kWmVyb0lk ZW50aWZpZXJzW2ludElEICsgMV07CisgICAgICAgIElkZW50aWZpZXJSZXAqIGlkZW50aWZpZXIg PSBuZWdhdGl2ZU9uZUFuZFplcm9JZGVudGlmaWVyc1tpbnRJRCArIDFdLmdldCgpOwogICAgICAg ICBpZiAoIWlkZW50aWZpZXIpIHsKICAgICAgICAgICAgIGlkZW50aWZpZXIgPSBuZXcgSWRlbnRp ZmllclJlcChpbnRJRCk7CiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvYnJpZGdlL0lkZW50aWZpZXJS ZXAuaCBiL1dlYkNvcmUvYnJpZGdlL0lkZW50aWZpZXJSZXAuaAppbmRleCA4ZTBlMGQ5Li41MzNk MjY2IDEwMDY0NAotLS0gYS9XZWJDb3JlL2JyaWRnZS9JZGVudGlmaWVyUmVwLmgKKysrIGIvV2Vi Q29yZS9icmlkZ2UvSWRlbnRpZmllclJlcC5oCkBAIC01NiwxMSArNTYsMTMgQEAgcHJpdmF0ZToK ICAgICAgICAgbV92YWx1ZS5tX3N0cmluZyA9IHN0cmR1cChuYW1lKTsKICAgICB9CiAgICAgCisj aWYgIUVOQUJMRShGUkVFX1NUQVRJQ19QVFJTKQogICAgIH5JZGVudGlmaWVyUmVwKCkKICAgICB7 CiAgICAgICAgIC8vIElkZW50aWZpZXJSZXBzIHNob3VsZCBuZXZlciBiZSBkZWxldGVkLgogICAg ICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKICAgICB9CisjZW5kaWYKICAgICAKICAgICB1bmlv biB7CiAgICAgICAgIGNvbnN0IGNoYXIqIG1fc3RyaW5nOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9j c3MvQ1NTUHJpbWl0aXZlVmFsdWUuY3BwIGIvV2ViQ29yZS9jc3MvQ1NTUHJpbWl0aXZlVmFsdWUu Y3BwCmluZGV4IDYzNDNkYWMuLmYyZTVmOTQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvY3NzL0NTU1By aW1pdGl2ZVZhbHVlLmNwcAorKysgYi9XZWJDb3JlL2Nzcy9DU1NQcmltaXRpdmVWYWx1ZS5jcHAK QEAgLTM1LDYgKzM1LDcgQEAKICNpbmNsdWRlICJSZW5kZXJTdHlsZS5oIgogI2luY2x1ZGUgPHd0 Zi9BU0NJSUNUeXBlLmg+CiAjaW5jbHVkZSA8d3RmL1N0ZExpYkV4dHJhcy5oPgorI2luY2x1ZGUg PHd0Zi9TdGF0aWNQdHIuaD4KIAogI2lmIEVOQUJMRShEQVNIQk9BUkRfU1VQUE9SVCkKICNpbmNs dWRlICJEYXNoYm9hcmRSZWdpb24uaCIKQEAgLTUwLDcgKzUxLDcgQEAgbmFtZXNwYWNlIFdlYkNv cmUgewogCiBQYXNzUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVlPiBDU1NQcmltaXRpdmVWYWx1ZTo6 Y3JlYXRlSWRlbnRpZmllcihpbnQgaWRlbnQpCiB7Ci0gICAgc3RhdGljIFJlZlB0cjxDU1NQcmlt aXRpdmVWYWx1ZT4qIGlkZW50VmFsdWVDYWNoZSA9IG5ldyBSZWZQdHI8Q1NTUHJpbWl0aXZlVmFs dWU+W251bUNTU1ZhbHVlS2V5d29yZHNdOworICAgIHN0YXRpYyBTdGF0aWNBcnJheVB0cjxSZWZQ dHI8Q1NTUHJpbWl0aXZlVmFsdWU+ID4gaWRlbnRWYWx1ZUNhY2hlKG5ldyBSZWZQdHI8Q1NTUHJp bWl0aXZlVmFsdWU+W251bUNTU1ZhbHVlS2V5d29yZHNdKTsKICAgICBpZiAoaWRlbnQgPj0gMCAm JiBpZGVudCA8IG51bUNTU1ZhbHVlS2V5d29yZHMpIHsKICAgICAgICAgUmVmUHRyPENTU1ByaW1p dGl2ZVZhbHVlPiBwcmltaXRpdmVWYWx1ZSA9IGlkZW50VmFsdWVDYWNoZVtpZGVudF07CiAgICAg ICAgIGlmICghcHJpbWl0aXZlVmFsdWUpIHsKQEAgLTY1LDcgKzY2LDcgQEAgUGFzc1JlZlB0cjxD U1NQcmltaXRpdmVWYWx1ZT4gQ1NTUHJpbWl0aXZlVmFsdWU6OmNyZWF0ZUlkZW50aWZpZXIoaW50 IGlkZW50KQogUGFzc1JlZlB0cjxDU1NQcmltaXRpdmVWYWx1ZT4gQ1NTUHJpbWl0aXZlVmFsdWU6 OmNyZWF0ZUNvbG9yKHVuc2lnbmVkIHJnYlZhbHVlKQogewogICAgIHR5cGVkZWYgSGFzaE1hcDx1 bnNpZ25lZCwgUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVlPiA+IENvbG9yVmFsdWVDYWNoZTsKLSAg ICBzdGF0aWMgQ29sb3JWYWx1ZUNhY2hlKiBjb2xvclZhbHVlQ2FjaGUgPSBuZXcgQ29sb3JWYWx1 ZUNhY2hlOworICAgIHN0YXRpYyBXVEY6OlN0YXRpY1B0cjxDb2xvclZhbHVlQ2FjaGU+IGNvbG9y VmFsdWVDYWNoZSA9IG5ldyBDb2xvclZhbHVlQ2FjaGU7CiAgICAgLy8gVGhlc2UgYXJlIHRoZSBl bXB0eSBhbmQgZGVsZXRlZCB2YWx1ZXMgb2YgdGhlIGhhc2ggdGFibGUuCiAgICAgaWYgKHJnYlZh bHVlID09IENvbG9yOjp0cmFuc3BhcmVudCkgewogICAgICAgICBzdGF0aWMgQ1NTUHJpbWl0aXZl VmFsdWUqIGNvbG9yVHJhbnNwYXJlbnQgPSBuZXcgQ1NTUHJpbWl0aXZlVmFsdWUoQ29sb3I6OnRy YW5zcGFyZW50KTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvY3NzL0NTU1N0eWxlU2VsZWN0b3IuY3Bw IGIvV2ViQ29yZS9jc3MvQ1NTU3R5bGVTZWxlY3Rvci5jcHAKaW5kZXggZDU3NzE3Yi4uZDQwY2Ri NyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9jc3MvQ1NTU3R5bGVTZWxlY3Rvci5jcHAKKysrIGIvV2Vi Q29yZS9jc3MvQ1NTU3R5bGVTZWxlY3Rvci5jcHAKQEAgLTM3NiwxMyArMzc2LDEzIEBAIHB1Ymxp YzoKICAgICB1bnNpZ25lZCBtX3J1bGVDb3VudDsKIH07CiAKLXN0YXRpYyBDU1NSdWxlU2V0KiBk ZWZhdWx0U3R5bGU7Ci1zdGF0aWMgQ1NTUnVsZVNldCogZGVmYXVsdFF1aXJrc1N0eWxlOwotc3Rh dGljIENTU1J1bGVTZXQqIGRlZmF1bHRQcmludFN0eWxlOwotc3RhdGljIENTU1J1bGVTZXQqIGRl ZmF1bHRWaWV3U291cmNlU3R5bGU7Ci1zdGF0aWMgQ1NTU3R5bGVTaGVldCogc2ltcGxlRGVmYXVs dFN0eWxlU2hlZXQ7CitzdGF0aWMgV1RGOjpTdGF0aWNQdHI8Q1NTUnVsZVNldD4gZGVmYXVsdFN0 eWxlOworc3RhdGljIFdURjo6U3RhdGljUHRyPENTU1J1bGVTZXQ+IGRlZmF1bHRRdWlya3NTdHls ZTsKK3N0YXRpYyBXVEY6OlN0YXRpY1B0cjxDU1NSdWxlU2V0PiBkZWZhdWx0UHJpbnRTdHlsZTsK K3N0YXRpYyBXVEY6OlN0YXRpY1B0cjxDU1NSdWxlU2V0PiBkZWZhdWx0Vmlld1NvdXJjZVN0eWxl Oworc3RhdGljIFdURjo6U3RhdGljUHRyPENTU1N0eWxlU2hlZXQ+IHNpbXBsZURlZmF1bHRTdHls ZVNoZWV0OwogCi1SZW5kZXJTdHlsZSogQ1NTU3R5bGVTZWxlY3Rvcjo6c19zdHlsZU5vdFlldEF2 YWlsYWJsZTsKK1dURjo6U3RhdGljUHRyPFJlbmRlclN0eWxlPiBDU1NTdHlsZVNlbGVjdG9yOjpz X3N0eWxlTm90WWV0QXZhaWxhYmxlOwogCiBzdGF0aWMgUHNldWRvU3RhdGUgcHNldWRvU3RhdGU7 CiAKQEAgLTUxMiwxMCArNTEyLDEwIEBAIHN0YXRpYyBDU1NTdHlsZVNoZWV0KiBwYXJzZVVBU2hl ZXQoY29uc3QgY2hhciogY2hhcmFjdGVycywgdW5zaWduZWQgc2l6ZSkKIAogc3RhdGljIHZvaWQg bG9hZEZ1bGxEZWZhdWx0U3R5bGUoKQogewotICAgIGlmIChzaW1wbGVEZWZhdWx0U3R5bGVTaGVl dCkgeworICAgIGlmIChzaW1wbGVEZWZhdWx0U3R5bGVTaGVldC5nZXQoKSkgewogICAgICAgICBB U1NFUlQoZGVmYXVsdFN0eWxlKTsKLSAgICAgICAgZGVsZXRlIGRlZmF1bHRTdHlsZTsKLSAgICAg ICAgZGVsZXRlIHNpbXBsZURlZmF1bHRTdHlsZVNoZWV0OworICAgICAgICBkZWZhdWx0U3R5bGUu ZGVsZXRlUHRyKCk7CisgICAgICAgIHNpbXBsZURlZmF1bHRTdHlsZVNoZWV0LmRlbGV0ZVB0cigp OwogICAgICAgICBkZWZhdWx0U3R5bGUgPSBuZXcgQ1NTUnVsZVNldDsKICAgICAgICAgc2ltcGxl RGVmYXVsdFN0eWxlU2hlZXQgPSAwOwogICAgIH0gZWxzZSB7CkBAIC01NDcsNyArNTQ3LDcgQEAg c3RhdGljIHZvaWQgbG9hZFNpbXBsZURlZmF1bHRTdHlsZSgpCiAgICAgZGVmYXVsdFF1aXJrc1N0 eWxlID0gbmV3IENTU1J1bGVTZXQ7CiAKICAgICBzaW1wbGVEZWZhdWx0U3R5bGVTaGVldCA9IHBh cnNlVUFTaGVldChzaW1wbGVVc2VyQWdlbnRTdHlsZVNoZWV0LCBzdHJsZW4oc2ltcGxlVXNlckFn ZW50U3R5bGVTaGVldCkpOwotICAgIGRlZmF1bHRTdHlsZS0+YWRkUnVsZXNGcm9tU2hlZXQoc2lt cGxlRGVmYXVsdFN0eWxlU2hlZXQsIHNjcmVlbkV2YWwoKSk7CisgICAgZGVmYXVsdFN0eWxlLT5h ZGRSdWxlc0Zyb21TaGVldChzaW1wbGVEZWZhdWx0U3R5bGVTaGVldC5nZXQoKSwgc2NyZWVuRXZh bCgpKTsKICAgICAKICAgICAvLyBObyBuZWVkIHRvIGluaXRpYWxpemUgcXVpcmtzIHNoZWV0IHll dCBhcyB0aGVyZSBhcmUgbm8gcXVpcmsgcnVsZXMgZm9yIGVsZW1lbnRzIGFsbG93ZWQgaW4gc2lt cGxlIGRlZmF1bHQgc3R5bGUuCiB9CkBAIC0xMDY0LDE4ICsxMDY0LDE4IEBAIHZvaWQgQ1NTU3R5 bGVTZWxlY3Rvcjo6bWF0Y2hVQVJ1bGVzKGludCYgZmlyc3RVQVJ1bGUsIGludCYgbGFzdFVBUnVs ZSkKIHsKICAgICAvLyBGaXJzdCB3ZSBtYXRjaCBydWxlcyBmcm9tIHRoZSB1c2VyIGFnZW50IHNo ZWV0LgogICAgIENTU1J1bGVTZXQqIHVzZXJBZ2VudFN0eWxlU2hlZXQgPSBtX21lZGl1bS0+bWVk aWFUeXBlTWF0Y2hTcGVjaWZpYygicHJpbnQiKQotICAgICAgICA/IGRlZmF1bHRQcmludFN0eWxl IDogZGVmYXVsdFN0eWxlOworICAgICAgICA/IGRlZmF1bHRQcmludFN0eWxlLmdldCgpIDogZGVm YXVsdFN0eWxlLmdldCgpOwogICAgIG1hdGNoUnVsZXModXNlckFnZW50U3R5bGVTaGVldCwgZmly c3RVQVJ1bGUsIGxhc3RVQVJ1bGUpOwogCiAgICAgLy8gSW4gcXVpcmtzIG1vZGUsIHdlIG1hdGNo IHJ1bGVzIGZyb20gdGhlIHF1aXJrcyB1c2VyIGFnZW50IHNoZWV0LgogICAgIGlmICghbV9jaGVj a2VyLm1fc3RyaWN0UGFyc2luZykKLSAgICAgICAgbWF0Y2hSdWxlcyhkZWZhdWx0UXVpcmtzU3R5 bGUsIGZpcnN0VUFSdWxlLCBsYXN0VUFSdWxlKTsKKyAgICAgICAgbWF0Y2hSdWxlcyhkZWZhdWx0 UXVpcmtzU3R5bGUuZ2V0KCksIGZpcnN0VUFSdWxlLCBsYXN0VUFSdWxlKTsKICAgICAgICAgCiAg ICAgLy8gSWYgd2UncmUgaW4gdmlldyBzb3VyY2UgbW9kZSwgdGhlbiB3ZSBtYXRjaCBydWxlcyBm cm9tIHRoZSB2aWV3IHNvdXJjZSBzdHlsZSBzaGVldC4KICAgICBpZiAobV9jaGVja2VyLm1fZG9j dW1lbnQtPmZyYW1lKCkgJiYgbV9jaGVja2VyLm1fZG9jdW1lbnQtPmZyYW1lKCktPmluVmlld1Nv dXJjZU1vZGUoKSkgewogICAgICAgICBpZiAoIWRlZmF1bHRWaWV3U291cmNlU3R5bGUpCiAgICAg ICAgICAgICBsb2FkVmlld1NvdXJjZVN0eWxlKCk7Ci0gICAgICAgIG1hdGNoUnVsZXMoZGVmYXVs dFZpZXdTb3VyY2VTdHlsZSwgZmlyc3RVQVJ1bGUsIGxhc3RVQVJ1bGUpOworICAgICAgICBtYXRj aFJ1bGVzKGRlZmF1bHRWaWV3U291cmNlU3R5bGUuZ2V0KCksIGZpcnN0VUFSdWxlLCBsYXN0VUFS dWxlKTsKICAgICB9CiB9CiAKQEAgLTEwOTUsNyArMTA5NSw3IEBAIFBhc3NSZWZQdHI8UmVuZGVy U3R5bGU+IENTU1N0eWxlU2VsZWN0b3I6OnN0eWxlRm9yRWxlbWVudChFbGVtZW50KiBlLCBSZW5k ZXJTdHlsCiAgICAgICAgIH0KICAgICAgICAgc19zdHlsZU5vdFlldEF2YWlsYWJsZS0+cmVmKCk7 CiAgICAgICAgIGUtPmRvY3VtZW50KCktPnNldEhhc05vZGVzV2l0aFBsYWNlaG9sZGVyU3R5bGUo KTsKLSAgICAgICAgcmV0dXJuIHNfc3R5bGVOb3RZZXRBdmFpbGFibGU7CisgICAgICAgIHJldHVy biBzX3N0eWxlTm90WWV0QXZhaWxhYmxlLmdldCgpOwogICAgIH0KIAogICAgIGluaXRFbGVtZW50 QW5kUHNldWRvU3RhdGUoZSk7CkBAIC0xMTEzLDcgKzExMTMsNyBAQCBQYXNzUmVmUHRyPFJlbmRl clN0eWxlPiBDU1NTdHlsZVNlbGVjdG9yOjpzdHlsZUZvckVsZW1lbnQoRWxlbWVudCogZSwgUmVu ZGVyU3R5bAogICAgIGVsc2UKICAgICAgICAgbV9wYXJlbnRTdHlsZSA9IHN0eWxlKCk7CiAKLSAg ICBpZiAoc2ltcGxlRGVmYXVsdFN0eWxlU2hlZXQgJiYgIWVsZW1lbnRDYW5Vc2VTaW1wbGVEZWZh dWx0U3R5bGUoZSkpCisgICAgaWYgKHNpbXBsZURlZmF1bHRTdHlsZVNoZWV0LmdldCgpICYmICFl bGVtZW50Q2FuVXNlU2ltcGxlRGVmYXVsdFN0eWxlKGUpKQogICAgICAgICBsb2FkRnVsbERlZmF1 bHRTdHlsZSgpOwogCiAjaWYgRU5BQkxFKFNWRykKZGlmZiAtLWdpdCBhL1dlYkNvcmUvY3NzL0NT U1N0eWxlU2VsZWN0b3IuaCBiL1dlYkNvcmUvY3NzL0NTU1N0eWxlU2VsZWN0b3IuaAppbmRleCAy YjkyYTM4Li4xNGE1ZGI4IDEwMDY0NAotLS0gYS9XZWJDb3JlL2Nzcy9DU1NTdHlsZVNlbGVjdG9y LmgKKysrIGIvV2ViQ29yZS9jc3MvQ1NTU3R5bGVTZWxlY3Rvci5oCkBAIC0zMSw2ICszMSw3IEBA CiAjaW5jbHVkZSA8d3RmL0hhc2hNYXAuaD4KICNpbmNsdWRlIDx3dGYvSGFzaFNldC5oPgogI2lu Y2x1ZGUgPHd0Zi9SZWZQdHIuaD4KKyNpbmNsdWRlIDx3dGYvU3RhdGljUHRyLmg+CiAjaW5jbHVk ZSA8d3RmL1ZlY3Rvci5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CkBAIC0xODYsNyArMTg3LDcg QEAgcHVibGljOgogICAgICAgICBLZXlmcmFtZXNSdWxlTWFwIG1fa2V5ZnJhbWVzUnVsZU1hcDsK IAogICAgIHB1YmxpYzoKLSAgICAgICAgc3RhdGljIFJlbmRlclN0eWxlKiBzdHlsZU5vdFlldEF2 YWlsYWJsZSgpIHsgcmV0dXJuIHNfc3R5bGVOb3RZZXRBdmFpbGFibGU7IH0KKyAgICAgICAgc3Rh dGljIFJlbmRlclN0eWxlKiBzdHlsZU5vdFlldEF2YWlsYWJsZSgpIHsgcmV0dXJuIHNfc3R5bGVO b3RZZXRBdmFpbGFibGUuZ2V0KCk7IH0KIAogICAgICAgICBjbGFzcyBTZWxlY3RvckNoZWNrZXIg OiBwdWJsaWMgTm9uY29weWFibGUgewogICAgICAgICBwdWJsaWM6CkBAIC0yMTAsNyArMjExLDcg QEAgcHVibGljOgogICAgICAgICB9OwogCiAgICAgcHJpdmF0ZToKLSAgICAgICAgc3RhdGljIFJl bmRlclN0eWxlKiBzX3N0eWxlTm90WWV0QXZhaWxhYmxlOworICAgICAgICBzdGF0aWMgV1RGOjpT dGF0aWNQdHI8UmVuZGVyU3R5bGU+IHNfc3R5bGVOb3RZZXRBdmFpbGFibGU7CiAKICAgICAgICAg dm9pZCBpbml0KCk7CiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvY3NzL01lZGlhRmVhdHVyZU5hbWVz LmNwcCBiL1dlYkNvcmUvY3NzL01lZGlhRmVhdHVyZU5hbWVzLmNwcAppbmRleCBmY2VlNWRlLi40 ZGQwZDQyIDEwMDY0NAotLS0gYS9XZWJDb3JlL2Nzcy9NZWRpYUZlYXR1cmVOYW1lcy5jcHAKKysr IGIvV2ViQ29yZS9jc3MvTWVkaWFGZWF0dXJlTmFtZXMuY3BwCkBAIC00NCw3ICs0NCw3IEBAIHZv aWQgaW5pdCgpCiAgICAgICAgLy8gVXNlIHBsYWNlbWVudCBuZXcgdG8gaW5pdGlhbGl6ZSB0aGUg Z2xvYmFscy4KIAogICAgICAgICBBdG9taWNTdHJpbmc6OmluaXQoKTsKLSAgICAgICAgI2RlZmlu ZSBJTklUSUFMSVpFX0dMT0JBTChuYW1lLCBzdHIpIG5ldyAoKHZvaWQqKSZuYW1lIyNNZWRpYUZl YXR1cmUpIEF0b21pY1N0cmluZyhzdHIpOworICAgICAgICAjZGVmaW5lIElOSVRJQUxJWkVfR0xP QkFMKG5hbWUsIHN0cikgSU5JVF9HTE9CQUwobmFtZSMjTWVkaWFGZWF0dXJlLCBXVEY6Okdsb2Jh bFN0YXRpY1B0cjxBdG9taWNTdHJpbmc+LCBBdG9taWNTdHJpbmcoc3RyKSk7CiAgICAgICAgIENT U19NRURJQVFVRVJZX05BTUVTX0ZPUl9FQUNIX01FRElBRkVBVFVSRShJTklUSUFMSVpFX0dMT0JB TCkKICAgICAgICAgI3VuZGVmIElOSVRJQUxJWkVfR0xPQkFMCiAgICAgICAgIGluaXRpYWxpemVk ID0gdHJ1ZTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvY3NzL01lZGlhUXVlcnlFdmFsdWF0b3IuY3Bw IGIvV2ViQ29yZS9jc3MvTWVkaWFRdWVyeUV2YWx1YXRvci5jcHAKaW5kZXggNDk2M2VkNC4uYThl NDZlZiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9jc3MvTWVkaWFRdWVyeUV2YWx1YXRvci5jcHAKKysr IGIvV2ViQ29yZS9jc3MvTWVkaWFRdWVyeUV2YWx1YXRvci5jcHAKQEAgLTQ2LDYgKzQ2LDcgQEAK ICNpbmNsdWRlICJSZW5kZXJTdHlsZS5oIgogI2luY2x1ZGUgIlBsYXRmb3JtU2NyZWVuLmgiCiAj aW5jbHVkZSA8d3RmL0hhc2hNYXAuaD4KKyNpbmNsdWRlIDx3dGYvU3RhdGljUHRyLmg+CiAKICNp ZiBFTkFCTEUoM0RfUkVOREVSSU5HKQogI2luY2x1ZGUgIlJlbmRlckxheWVyQ29tcG9zaXRvci5o IgpAQCAtNTksNyArNjAsNyBAQCBlbnVtIE1lZGlhRmVhdHVyZVByZWZpeCB7IE1pblByZWZpeCwg TWF4UHJlZml4LCBOb1ByZWZpeCB9OwogCiB0eXBlZGVmIGJvb2wgKCpFdmFsRnVuYykoQ1NTVmFs dWUqLCBSZW5kZXJTdHlsZSosIEZyYW1lKiwgTWVkaWFGZWF0dXJlUHJlZml4KTsKIHR5cGVkZWYg SGFzaE1hcDxBdG9taWNTdHJpbmdJbXBsKiwgRXZhbEZ1bmM+IEZ1bmN0aW9uTWFwOwotc3RhdGlj IEZ1bmN0aW9uTWFwKiBnRnVuY3Rpb25NYXA7CitzdGF0aWMgV1RGOjpTdGF0aWNQdHI8RnVuY3Rp b25NYXA+IGdGdW5jdGlvbk1hcDsKIAogLyoKICAqIEZJWE1FOiBmb2xsb3dpbmcgbWVkaWEgZmVh dHVyZXMgYXJlIG5vdCBpbXBsZW1lbnRlZDogY29sb3JfaW5kZXgsIHNjYW4sIHJlc29sdXRpb24K ZGlmZiAtLWdpdCBhL1dlYkNvcmUvZG9tL1F1YWxpZmllZE5hbWUuY3BwIGIvV2ViQ29yZS9kb20v UXVhbGlmaWVkTmFtZS5jcHAKaW5kZXggNjA3Yzg0Ni4uNjQ2MjVjMCAxMDA2NDQKLS0tIGEvV2Vi Q29yZS9kb20vUXVhbGlmaWVkTmFtZS5jcHAKKysrIGIvV2ViQ29yZS9kb20vUXVhbGlmaWVkTmFt ZS5jcHAKQEAgLTkyLDcgKzkyLDcgQEAgdm9pZCBRdWFsaWZpZWROYW1lOjppbml0KCkKICAgICAg ICAgLy8gVXNlIHBsYWNlbWVudCBuZXcgdG8gaW5pdGlhbGl6ZSB0aGUgZ2xvYmFscy4KICAgICAg ICAgCiAgICAgICAgIEF0b21pY1N0cmluZzo6aW5pdCgpOwotICAgICAgICBuZXcgKCh2b2lkKikm YW55TmFtZSkgUXVhbGlmaWVkTmFtZShudWxsQXRvbSwgc3RhckF0b20sIHN0YXJBdG9tKTsKKyAg ICAgICAgSU5JVF9HTE9CQUwoYW55TmFtZSwgV1RGOjpHbG9iYWxTdGF0aWNQdHI8UXVhbGlmaWVk TmFtZT4sIFF1YWxpZmllZE5hbWUobnVsbEF0b20sIHN0YXJBdG9tLCBzdGFyQXRvbSkpOwogICAg ICAgICBpbml0aWFsaXplZCA9IHRydWU7CiAgICAgfQogfQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9k b20vbWFrZV9uYW1lcy5wbCBiL1dlYkNvcmUvZG9tL21ha2VfbmFtZXMucGwKaW5kZXggZTZkNTlh MC4uZTBlZGE1OCAxMDA3NTUKLS0tIGEvV2ViQ29yZS9kb20vbWFrZV9uYW1lcy5wbAorKysgYi9X ZWJDb3JlL2RvbS9tYWtlX25hbWVzLnBsCkBAIC01NTIsNyArNTUyLDcgQEAgcHJpbnQgRiAiXG52 b2lkIGluaXQoKQogICAgIHByaW50KEYgIiAgICBBdG9taWNTdHJpbmcgJHtsb3dlck5hbWVzcGFj ZX1OUyhcIiRwYXJhbWV0ZXJzeyduYW1lc3BhY2VVUkknfVwiKTtcblxuIik7CiAKICAgICBwcmlu dChGICIgICAgLy8gTmFtZXNwYWNlXG4iKTsKLSAgICBwcmludChGICIgICAgbmV3ICgodm9pZCop JiR7bG93ZXJOYW1lc3BhY2V9TmFtZXNwYWNlVVJJKSBBdG9taWNTdHJpbmcoJHtsb3dlck5hbWVz cGFjZX1OUyk7XG5cbiIpOworICAgIHByaW50KEYgIiAgICBJTklUX0dMT0JBTCgke2xvd2VyTmFt ZXNwYWNlfU5hbWVzcGFjZVVSSSwgV1RGOjpHbG9iYWxTdGF0aWNQdHI8QXRvbWljU3RyaW5nPiwg QXRvbWljU3RyaW5nKCR7bG93ZXJOYW1lc3BhY2V9TlMpKTtcblxuIik7CiAgICAgaWYgKGtleXMg JXRhZ3MpIHsKICAgICAgICAgbXkgJHRhZ3NOYW1lc3BhY2UgPSAkcGFyYW1ldGVyc3sndGFnc051 bGxOYW1lc3BhY2UnfSA/ICJudWxsQXRvbSIgOiAiJHtsb3dlck5hbWVzcGFjZX1OUyI7CiAgICAg ICAgIHByaW50RGVmaW5pdGlvbnMoJEYsIFwldGFncywgInRhZ3MiLCAkdGFnc05hbWVzcGFjZSk7 CkBAIC02MzUsNyArNjM1LDcgQEAgc3ViIHByaW50RGVmaW5pdGlvbnMKICAgICBwcmludCAiXG4i OwogCiAgICAgZm9yIG15ICRuYW1lIChzb3J0IGtleXMgJSRuYW1lc1JlZikgewotICAgICAgICBw cmludCBGICIgICAgbmV3ICgodm9pZCopJiRuYW1lIiwiJHtzaG9ydENhbWVsVHlwZX0pIFF1YWxp ZmllZE5hbWUobnVsbEF0b20sICRuYW1lIiwiJHtzaG9ydENhbWVsVHlwZX1TdHJpbmcsICRuYW1l c3BhY2VVUkkpO1xuIjsKKyAgICAgICAgcHJpbnQgRiAiICAgIElOSVRfR0xPQkFMKCRuYW1lIiwi JHtzaG9ydENhbWVsVHlwZX0sIFdURjo6R2xvYmFsU3RhdGljUHRyPFF1YWxpZmllZE5hbWU+LCBR dWFsaWZpZWROYW1lKG51bGxBdG9tLCAkbmFtZSIsIiR7c2hvcnRDYW1lbFR5cGV9U3RyaW5nLCAk bmFtZXNwYWNlVVJJKSk7XG4iOwogICAgIH0KIH0KIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9pbnNw ZWN0b3IvSmF2YVNjcmlwdERlYnVnU2VydmVyLmggYi9XZWJDb3JlL2luc3BlY3Rvci9KYXZhU2Ny aXB0RGVidWdTZXJ2ZXIuaAppbmRleCBiYWE2Njk5Li41MjBiNDgzIDEwMDY0NAotLS0gYS9XZWJD b3JlL2luc3BlY3Rvci9KYXZhU2NyaXB0RGVidWdTZXJ2ZXIuaAorKysgYi9XZWJDb3JlL2luc3Bl Y3Rvci9KYXZhU2NyaXB0RGVidWdTZXJ2ZXIuaApAQCAtODUsOSArODUsMTAgQEAgbmFtZXNwYWNl IFdlYkNvcmUgewogICAgICAgICB0eXBlZGVmIEhhc2hTZXQ8SmF2YVNjcmlwdERlYnVnTGlzdGVu ZXIqPiBMaXN0ZW5lclNldDsKICAgICAgICAgdHlwZWRlZiB2b2lkIChKYXZhU2NyaXB0RGVidWdM aXN0ZW5lcjo6KkphdmFTY3JpcHRFeGVjdXRpb25DYWxsYmFjaykoKTsKIAorICAgICAgICB+SmF2 YVNjcmlwdERlYnVnU2VydmVyKCk7CisKICAgICBwcml2YXRlOgogICAgICAgICBKYXZhU2NyaXB0 RGVidWdTZXJ2ZXIoKTsKLSAgICAgICAgfkphdmFTY3JpcHREZWJ1Z1NlcnZlcigpOwogCiAgICAg ICAgIGJvb2wgaGFzTGlzdGVuZXJzKCkgY29uc3QgeyByZXR1cm4gIW1fbGlzdGVuZXJzLmlzRW1w dHkoKSB8fCAhbV9wYWdlTGlzdGVuZXJzTWFwLmlzRW1wdHkoKTsgfQogICAgICAgICBib29sIGhh c0dsb2JhbExpc3RlbmVycygpIGNvbnN0IHsgcmV0dXJuICFtX2xpc3RlbmVycy5pc0VtcHR5KCk7 IH0KZGlmZiAtLWdpdCBhL1dlYkNvcmUvbG9hZGVyL0ltYWdlTG9hZGVyLmNwcCBiL1dlYkNvcmUv bG9hZGVyL0ltYWdlTG9hZGVyLmNwcAppbmRleCBiMTgzYTY2Li4yZDZlYWZmIDEwMDY0NAotLS0g YS9XZWJDb3JlL2xvYWRlci9JbWFnZUxvYWRlci5jcHAKKysrIGIvV2ViQ29yZS9sb2FkZXIvSW1h Z2VMb2FkZXIuY3BwCkBAIC00MSw3ICs0MSw2IEBAIHB1YmxpYzoKICAgICB2b2lkIGRpc3BhdGNo UGVuZGluZ0xvYWRFdmVudHMoKTsKIAogcHJpdmF0ZToKLSAgICB+SW1hZ2VMb2FkRXZlbnRTZW5k ZXIoKTsKIAogICAgIHZvaWQgdGltZXJGaXJlZChUaW1lcjxJbWFnZUxvYWRFdmVudFNlbmRlcj4q KTsKIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9TdGF0aWNDb25zdHJ1Y3RvcnMuaCBi L1dlYkNvcmUvcGxhdGZvcm0vU3RhdGljQ29uc3RydWN0b3JzLmgKaW5kZXggMjZiNDRkZS4uOTg1 ZmFjOCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9TdGF0aWNDb25zdHJ1Y3RvcnMuaAor KysgYi9XZWJDb3JlL3BsYXRmb3JtL1N0YXRpY0NvbnN0cnVjdG9ycy5oCkBAIC0yMyw2ICsyMyw4 IEBACiAjaWZuZGVmIFN0YXRpY0NvbnN0cnVjdG9yc19oCiAjZGVmaW5lIFN0YXRpY0NvbnN0cnVj dG9yc19oCiAKKyNpbmNsdWRlICJ3dGYvU3RhdGljUHRyLmgiCisKIC8vIEZvciBXZWJDb3JlIHdl IG5lZWQgdG8gYXZvaWQgaGF2aW5nIHN0YXRpYyBjb25zdHJ1Y3RvcnMuIFdlIGFjaGlldmUgdGhp cwogLy8gd2l0aCB0d28gc2VwYXJhdGUgbWV0aG9kcyBmb3IgR0NDIGFuZCBNU1ZDLiBCb3RoIG1l dGhvZHMgcHJldmVudCB0aGUgc3RhdGljCiAvLyBpbml0aWFsaXplcnMgZnJvbSBiZWluZyByZWdp c3RlcmVkIGFuZCBjYWxsZWQgb24gcHJvZ3JhbSBzdGFydHVwLiBPbiBHQ0MsIHdlCkBAIC03Myw0 ICs3NSwxMyBAQAogI2VuZGlmCiAjZW5kaWYKIAorI2lmIEVOQUJMRShGUkVFX1NUQVRJQ19QVFJT KQorI2RlZmluZSBJTklUX0dMT0JBTChuYW1lLCB0eXBlLCBhcmd1bWVudHMpIFwKKyAgICBuZXcg KCh2b2lkKikmbmFtZSkgYXJndW1lbnRzOyBcCisgICAgc3RhdGljIHR5cGUgbmFtZSMjUmVmKCh2 b2lkKikmbmFtZSkKKyNlbHNlCisjZGVmaW5lIElOSVRfR0xPQkFMKG5hbWUsIHR5cGUsIGFyZ3Vt ZW50cykgXAorICAgIG5ldyAoKHZvaWQqKSZuYW1lKSBhcmd1bWVudHMKKyNlbmRpZgorCiAjZW5k aWYgLy8gU3RhdGljQ29uc3RydWN0b3JzX2gKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvRm9udENhY2hlLmggYi9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0ZvbnRDYWNo ZS5oCmluZGV4IDNjMGYyZDkuLjg4MjAwNDUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvRm9udENhY2hlLmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9Gb250 Q2FjaGUuaApAQCAtODUsNyArODUsNiBAQCBwdWJsaWM6CiAKIHByaXZhdGU6CiAgICAgRm9udENh Y2hlKCk7Ci0gICAgfkZvbnRDYWNoZSgpOwogCiAgICAgLy8gVGhlc2UgbWV0aG9kcyBhcmUgaW1w bGVtZW50ZWQgYnkgZWFjaCBwbGF0Zm9ybS4KICAgICBGb250UGxhdGZvcm1EYXRhKiBnZXRTaW1p bGFyRm9udFBsYXRmb3JtRGF0YShjb25zdCBGb250Jik7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3Bs YXRmb3JtL3RleHQvQXRvbWljU3RyaW5nLmNwcCBiL1dlYkNvcmUvcGxhdGZvcm0vdGV4dC9BdG9t aWNTdHJpbmcuY3BwCmluZGV4IDQwOTQzOWUuLjhiZGNmYTAgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUv cGxhdGZvcm0vdGV4dC9BdG9taWNTdHJpbmcuY3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vdGV4 dC9BdG9taWNTdHJpbmcuY3BwCkBAIC0yOTUsMTEgKzI5NSwxMSBAQCB2b2lkIEF0b21pY1N0cmlu Zzo6aW5pdCgpCiAgICAgICAgIEFTU0VSVChpc01haW5UaHJlYWQoKSk7CiAKICAgICAgICAgLy8g VXNlIHBsYWNlbWVudCBuZXcgdG8gaW5pdGlhbGl6ZSB0aGUgZ2xvYmFscy4KLSAgICAgICAgbmV3 ICgodm9pZCopJm51bGxBdG9tKSBBdG9taWNTdHJpbmc7Ci0gICAgICAgIG5ldyAoKHZvaWQqKSZl bXB0eUF0b20pIEF0b21pY1N0cmluZygiIik7Ci0gICAgICAgIG5ldyAoKHZvaWQqKSZ0ZXh0QXRv bSkgQXRvbWljU3RyaW5nKCIjdGV4dCIpOwotICAgICAgICBuZXcgKCh2b2lkKikmY29tbWVudEF0 b20pIEF0b21pY1N0cmluZygiI2NvbW1lbnQiKTsKLSAgICAgICAgbmV3ICgodm9pZCopJnN0YXJB dG9tKSBBdG9taWNTdHJpbmcoIioiKTsKKyAgICAgICAgSU5JVF9HTE9CQUwobnVsbEF0b20sIFdU Rjo6R2xvYmFsU3RhdGljUHRyPEF0b21pY1N0cmluZz4sIEF0b21pY1N0cmluZyk7CisgICAgICAg IElOSVRfR0xPQkFMKGVtcHR5QXRvbSwgV1RGOjpHbG9iYWxTdGF0aWNQdHI8QXRvbWljU3RyaW5n PiwgQXRvbWljU3RyaW5nKCIiKSk7CisgICAgICAgIElOSVRfR0xPQkFMKHRleHRBdG9tLCBXVEY6 Okdsb2JhbFN0YXRpY1B0cjxBdG9taWNTdHJpbmc+LCBBdG9taWNTdHJpbmcoIiN0ZXh0IikpOwor ICAgICAgICBJTklUX0dMT0JBTChjb21tZW50QXRvbSwgV1RGOjpHbG9iYWxTdGF0aWNQdHI8QXRv bWljU3RyaW5nPiwgQXRvbWljU3RyaW5nKCIjY29tbWVudCIpKTsKKyAgICAgICAgSU5JVF9HTE9C QUwoc3RhckF0b20sIFdURjo6R2xvYmFsU3RhdGljUHRyPEF0b21pY1N0cmluZz4sIEF0b21pY1N0 cmluZygiKiIpKTsKIAogICAgICAgICBpbml0aWFsaXplZCA9IHRydWU7CiAgICAgfQpkaWZmIC0t Z2l0IGEvV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuY3BwIGIvV2ViS2l0L3F0L0FwaS9xd2ViZnJh bWUuY3BwCmluZGV4IDIzY2I0NzMuLmE0ZWYzMjIgMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC9BcGkv cXdlYmZyYW1lLmNwcAorKysgYi9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5jcHAKQEAgLTc4LDYg Kzc4LDEwIEBACiAjaW5jbHVkZSA8cXByaW50ZXIuaD4KICNpbmNsdWRlIDxxcmVnaW9uLmg+CiAK KyNpZiBFTkFCTEUoRlJFRV9TVEFUSUNfUFRSUykKKyNpbmNsdWRlICJ3dGYvU3RhdGljUHRyLmgi CisjZW5kaWYKKwogI2lmIFFUX1ZFUlNJT04gPCAweDA0MDQwMAogI2luY2x1ZGUgInF3ZWJuZXR3 b3JraW50ZXJmYWNlLmgiCiAjZW5kaWYKQEAgLTE4NSw2ICsxODksMTMgQEAgdm9pZCBRV0VCS0lU X0VYUE9SVCBxdF9kcnRfZ2FyYmFnZUNvbGxlY3Rvcl9jb2xsZWN0T25BbHRlcm5hdGVUaHJlYWQo Ym9vbCB3YWl0VW4KICAgICBnY0NvbnRyb2xsZXIoKS5nYXJiYWdlQ29sbGVjdE9uQWx0ZXJuYXRl VGhyZWFkRm9yRGVidWdnaW5nKHdhaXRVbnRpbERvbmUpOwogfQogCisjaWYgRU5BQkxFKEZSRUVf U1RBVElDX1BUUlMpCit2b2lkIFFXRUJLSVRfRVhQT1JUIHF0X2RydF9mcmVlU3RhdGljUHRycygp Cit7CisgICAgV1RGOjpTdGF0aWNQdHJCYXNlOjpmcmVlU3RhdGljUHRycygpOworfQorI2VuZGlm CisKIFFXZWJGcmFtZURhdGE6OlFXZWJGcmFtZURhdGEoV2ViQ29yZTo6UGFnZSogcGFyZW50UGFn ZSwgV2ViQ29yZTo6RnJhbWUqIHBhcmVudEZyYW1lLAogICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBXZWJDb3JlOjpIVE1MRnJhbWVPd25lckVsZW1lbnQqIG93bmVyRnJhbWVFbGVtZW50LAog ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBXZWJDb3JlOjpTdHJpbmcmIGZyYW1l TmFtZSkKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9RdExhdW5jaGVyL21haW4uY3BwIGIvV2ViS2l0 L3F0L1F0TGF1bmNoZXIvbWFpbi5jcHAKaW5kZXggYTIxOTZmMS4uZjBjZDViZSAxMDA2NDQKLS0t IGEvV2ViS2l0L3F0L1F0TGF1bmNoZXIvbWFpbi5jcHAKKysrIGIvV2ViS2l0L3F0L1F0TGF1bmNo ZXIvbWFpbi5jcHAKQEAgLTUzLDYgKzUzLDcgQEAKIAogI2lmbmRlZiBOREVCVUcKIHZvaWQgUVdF QktJVF9FWFBPUlQgcXRfZHJ0X2dhcmJhZ2VDb2xsZWN0b3JfY29sbGVjdCgpOwordm9pZCBRV0VC S0lUX0VYUE9SVCBxdF9kcnRfZnJlZVN0YXRpY1B0cnMoKTsKICNlbmRpZgogCiBjbGFzcyBXZWJQ YWdlIDogcHVibGljIFFXZWJQYWdlCkBAIC00NjIsNiArNDYzLDcgQEAgaW50IG1haW4oaW50IGFy Z2MsIGNoYXIgKiphcmd2KQogICAgICAgICBpbnQgcmV0VmFsID0gYXBwLmV4ZWMoKTsKICAgICAg ICAgcXRfZHJ0X2dhcmJhZ2VDb2xsZWN0b3JfY29sbGVjdCgpOwogICAgICAgICBRV2ViU2V0dGlu Z3M6OmNsZWFyTWVtb3J5Q2FjaGVzKCk7CisgICAgICAgIHF0X2RydF9mcmVlU3RhdGljUHRycygp OwogICAgICAgICByZXR1cm4gcmV0VmFsOwogI2Vsc2UKICAgICAgICAgcmV0dXJuIGFwcC5leGVj KCk7Cg== 34549 2009-08-11 04:42:13 -0700 2009-09-01 01:22:07 -0700 Fourth patch StaticPtrs-draft-0.4.patch text/plain 40840 zherczeg RnJvbSAwN2ZkZTkzZTRmZmFhMzkwZDU3MTllOGZmZWUzY2U5NmQwZTQ3OTRmIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBab2x0YW4gSGVyY3plZyA8emhlcmN6ZWdAaW5mLnUtc3plZ2Vk Lmh1PgpEYXRlOiBUdWUsIDExIEF1ZyAyMDA5IDEzOjM3OjAxICswMjAwClN1YmplY3Q6IFtQQVRD SF0gU3RhdGljIHBvaW50ZXJzCgpTaWduZWQtb2ZmLWJ5OiBab2x0YW4gSGVyY3plZyA8emhlcmN6 ZWdAaW5mLnUtc3plZ2VkLmh1PgotLS0KIEphdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLnBy aSAgICAgICAgIHwgICAgMSArCiBKYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTR2xvYmFsRGF0YS5j cHAgICB8ICAgMjMgKystLQogSmF2YVNjcmlwdENvcmUvcnVudGltZS9KU0dsb2JhbERhdGEuaCAg ICAgfCAgICAxIC0KIEphdmFTY3JpcHRDb3JlL3J1bnRpbWUvVVN0cmluZy5jcHAgICAgICAgIHwg ICAgNiArLQogSmF2YVNjcmlwdENvcmUvcnVudGltZS9VU3RyaW5nLmggICAgICAgICAgfCAgICA3 ICstCiBKYXZhU2NyaXB0Q29yZS93dGYvUGxhdGZvcm0uaCAgICAgICAgICAgICB8ICAgIDIgKwog SmF2YVNjcmlwdENvcmUvd3RmL1N0YXRpY1B0ci5jcHAgICAgICAgICAgfCAgIDcxICsrKysrKysr KysKIEphdmFTY3JpcHRDb3JlL3d0Zi9TdGF0aWNQdHIuaCAgICAgICAgICAgIHwgIDIxNSArKysr KysrKysrKysrKysrKysrKysrKysrKysrKwogSmF2YVNjcmlwdENvcmUvd3RmL1N0ZExpYkV4dHJh cy5oICAgICAgICAgfCAgICA3ICstCiBKYXZhU2NyaXB0Q29yZS93dGYvVGhyZWFkU3BlY2lmaWMu aCAgICAgICB8ICAgIDIgKwogV2ViQ29yZS9XZWJDb3JlLnBybyAgICAgICAgICAgICAgICAgICAg ICAgfCAgICAyICstCiBXZWJDb3JlL2JpbmRpbmdzL2pzL0pTRE9NV2luZG93QmFzZS5jcHAgICB8 ICAgMTcgKystCiBXZWJDb3JlL2JyaWRnZS9JZGVudGlmaWVyUmVwLmNwcCAgICAgICAgICB8ICAg IDUgKy0KIFdlYkNvcmUvYnJpZGdlL0lkZW50aWZpZXJSZXAuaCAgICAgICAgICAgIHwgICAgMiAr CiBXZWJDb3JlL2Nzcy9DU1NQcmltaXRpdmVWYWx1ZS5jcHAgICAgICAgICB8ICAgIDkgKy0KIFdl YkNvcmUvY3NzL0NTU1N0eWxlU2VsZWN0b3IuY3BwICAgICAgICAgIHwgICAzMCArKy0tCiBXZWJD b3JlL2Nzcy9DU1NTdHlsZVNlbGVjdG9yLmggICAgICAgICAgICB8ICAgIDUgKy0KIFdlYkNvcmUv Y3NzL01lZGlhRmVhdHVyZU5hbWVzLmNwcCAgICAgICAgIHwgICAgMiArLQogV2ViQ29yZS9jc3Mv TWVkaWFRdWVyeUV2YWx1YXRvci5jcHAgICAgICAgfCAgICAzICstCiBXZWJDb3JlL2RvbS9RdWFs aWZpZWROYW1lLmNwcCAgICAgICAgICAgICB8ICAgMTkgKystCiBXZWJDb3JlL2RvbS9tYWtlX25h bWVzLnBsICAgICAgICAgICAgICAgICB8ICAgIDQgKy0KIFdlYkNvcmUvaW5zcGVjdG9yL0phdmFT Y3JpcHREZWJ1Z1NlcnZlci5oIHwgICAgMyArLQogV2ViQ29yZS9sb2FkZXIvSW1hZ2VMb2FkZXIu Y3BwICAgICAgICAgICAgfCAgICAxIC0KIFdlYkNvcmUvcGxhdGZvcm0vU3RhdGljQ29uc3RydWN0 b3JzLmggICAgIHwgICAxMSArKwogV2ViQ29yZS9wbGF0Zm9ybS9UaHJlYWRHbG9iYWxEYXRhLmNw cCAgICAgfCAgICA3ICstCiBXZWJDb3JlL3BsYXRmb3JtL1RocmVhZFRpbWVycy5jcHAgICAgICAg ICB8ICAgIDUgKy0KIFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvRm9udENhY2hlLmggICAgIHwg ICAgMSAtCiBXZWJDb3JlL3BsYXRmb3JtL3F0L1NoYXJlZFRpbWVyUXQuY3BwICAgICB8ICAgIDIg KwogV2ViQ29yZS9wbGF0Zm9ybS90ZXh0L0F0b21pY1N0cmluZy5jcHAgICAgfCAgIDEwICstCiBX ZWJDb3JlL3BsdWdpbnMvUGx1Z2luRGF0YWJhc2UuY3BwICAgICAgICB8ICAgIDUgKy0KIFdlYkNv cmUvcmVuZGVyaW5nL3N0eWxlL1JlbmRlclN0eWxlLmNwcCAgIHwgICAgNSArLQogV2ViS2l0L3F0 L0FwaS9xd2ViZnJhbWUuY3BwICAgICAgICAgICAgICAgfCAgIDExICsrCiBXZWJLaXQvcXQvUXRM YXVuY2hlci9tYWluLmNwcCAgICAgICAgICAgICB8ICAgIDQgKy0KIDMzIGZpbGVzIGNoYW5nZWQs IDQyNSBpbnNlcnRpb25zKCspLCA3MyBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBK YXZhU2NyaXB0Q29yZS93dGYvU3RhdGljUHRyLmNwcAogY3JlYXRlIG1vZGUgMTAwNjQ0IEphdmFT Y3JpcHRDb3JlL3d0Zi9TdGF0aWNQdHIuaAoKZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL0ph dmFTY3JpcHRDb3JlLnByaSBiL0phdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLnByaQppbmRl eCAwZGU0ZjE1Li4xNWNhYzdkIDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0Q29yZS9KYXZhU2NyaXB0 Q29yZS5wcmkKKysrIGIvSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUucHJpCkBAIC03NSw2 ICs3NSw3IEBAIFNPVVJDRVMgKz0gXAogICAgIHd0Zi9NYWluVGhyZWFkLmNwcCBcCiAgICAgd3Rm L1JhbmRvbU51bWJlci5jcHAgXAogICAgIHd0Zi9SZWZDb3VudGVkTGVha0NvdW50ZXIuY3BwIFwK KyAgICB3dGYvU3RhdGljUHRyLmNwcCBcCiAgICAgd3RmL1R5cGVUcmFpdHMuY3BwIFwKICAgICB3 dGYvdW5pY29kZS9Db2xsYXRvckRlZmF1bHQuY3BwIFwKICAgICB3dGYvdW5pY29kZS9pY3UvQ29s bGF0b3JJQ1UuY3BwIFwKZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNHbG9i YWxEYXRhLmNwcCBiL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNHbG9iYWxEYXRhLmNwcAppbmRl eCAxNTZkMTAyLi45YzAzYjMwIDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pT R2xvYmFsRGF0YS5jcHAKKysrIGIvSmF2YVNjcmlwdENvcmUvcnVudGltZS9KU0dsb2JhbERhdGEu Y3BwCkBAIC00Niw2ICs0Niw3IEBACiAjaW5jbHVkZSAiTGV4ZXIuaCIKICNpbmNsdWRlICJMb29r dXAuaCIKICNpbmNsdWRlICJOb2Rlcy5oIgorI2luY2x1ZGUgInd0Zi9TdGF0aWNQdHIuaCIKIAog I2lmIEVOQUJMRShKU0NfTVVMVElQTEVfVEhSRUFEUykKICNpbmNsdWRlIDx3dGYvVGhyZWFkaW5n Lmg+CkBAIC0yMDAsMjggKzIwMSwyNCBAQCBQYXNzUmVmUHRyPEpTR2xvYmFsRGF0YT4gSlNHbG9i YWxEYXRhOjpjcmVhdGVMZWFrZWQoKQogICAgIHJldHVybiBkYXRhLnJlbGVhc2UoKTsKIH0KIAor c3RhdGljIFdURjo6U3RhdGljUHRyPEpTR2xvYmFsRGF0YT4gc2hhcmVkSW5zdGFuY2VQdHI7CisK IGJvb2wgSlNHbG9iYWxEYXRhOjpzaGFyZWRJbnN0YW5jZUV4aXN0cygpCiB7Ci0gICAgcmV0dXJu IHNoYXJlZEluc3RhbmNlSW50ZXJuYWwoKTsKKyAgICBBU1NFUlQoSlNMb2NrOjpjdXJyZW50VGhy ZWFkSXNIb2xkaW5nTG9jaygpKTsKKyAgICByZXR1cm4gc2hhcmVkSW5zdGFuY2VQdHIuZ2V0KCk7 CiB9CiAKIEpTR2xvYmFsRGF0YSYgSlNHbG9iYWxEYXRhOjpzaGFyZWRJbnN0YW5jZSgpCiB7Ci0g ICAgSlNHbG9iYWxEYXRhKiYgaW5zdGFuY2UgPSBzaGFyZWRJbnN0YW5jZUludGVybmFsKCk7Ci0g ICAgaWYgKCFpbnN0YW5jZSkgewotICAgICAgICBpbnN0YW5jZSA9IGNyZWF0ZSh0cnVlKS5yZWxl YXNlUmVmKCk7CisgICAgQVNTRVJUKEpTTG9jazo6Y3VycmVudFRocmVhZElzSG9sZGluZ0xvY2so KSk7CisgICAgaWYgKCFzaGFyZWRJbnN0YW5jZVB0cikgeworICAgICAgICBzaGFyZWRJbnN0YW5j ZVB0ciA9IGNyZWF0ZSh0cnVlKS5yZWxlYXNlUmVmKCk7CiAjaWYgRU5BQkxFKEpTQ19NVUxUSVBM RV9USFJFQURTKQotICAgICAgICBpbnN0YW5jZS0+bWFrZVVzYWJsZUZyb21NdWx0aXBsZVRocmVh ZHMoKTsKKyAgICAgICAgc2hhcmVkSW5zdGFuY2VQdHItPm1ha2VVc2FibGVGcm9tTXVsdGlwbGVU aHJlYWRzKCk7CiAjZW5kaWYKICAgICB9Ci0gICAgcmV0dXJuICppbnN0YW5jZTsKLX0KLQotSlNH bG9iYWxEYXRhKiYgSlNHbG9iYWxEYXRhOjpzaGFyZWRJbnN0YW5jZUludGVybmFsKCkKLXsKLSAg ICBBU1NFUlQoSlNMb2NrOjpjdXJyZW50VGhyZWFkSXNIb2xkaW5nTG9jaygpKTsKLSAgICBzdGF0 aWMgSlNHbG9iYWxEYXRhKiBzaGFyZWRJbnN0YW5jZTsKLSAgICByZXR1cm4gc2hhcmVkSW5zdGFu Y2U7CisgICAgcmV0dXJuICpzaGFyZWRJbnN0YW5jZVB0cjsKIH0KIAogLy8gRklYTUU6IFdlIGNh biBhbHNvIGRldGVjdCBmb3JtcyBsaWtlIHYxIDwgdjIgPyAtMSA6IDAsIHJldmVyc2UgY29tcGFy aXNvbiwgZXRjLgpkaWZmIC0tZ2l0IGEvSmF2YVNjcmlwdENvcmUvcnVudGltZS9KU0dsb2JhbERh dGEuaCBiL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNHbG9iYWxEYXRhLmgKaW5kZXggNzQzNGQ5 OS4uN2JlNmJhZSAxMDA2NDQKLS0tIGEvSmF2YVNjcmlwdENvcmUvcnVudGltZS9KU0dsb2JhbERh dGEuaAorKysgYi9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTR2xvYmFsRGF0YS5oCkBAIC0xNDUs NyArMTQ1LDYgQEAgbmFtZXNwYWNlIEpTQyB7CiAKICAgICBwcml2YXRlOgogICAgICAgICBKU0ds b2JhbERhdGEoYm9vbCBpc1NoYXJlZCwgY29uc3QgVlB0clNldCYpOwotICAgICAgICBzdGF0aWMg SlNHbG9iYWxEYXRhKiYgc2hhcmVkSW5zdGFuY2VJbnRlcm5hbCgpOwogICAgICAgICB2b2lkIGNy ZWF0ZU5hdGl2ZVRodW5rKCk7CiAgICAgfTsKIApkaWZmIC0tZ2l0IGEvSmF2YVNjcmlwdENvcmUv cnVudGltZS9VU3RyaW5nLmNwcCBiL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvVVN0cmluZy5jcHAK aW5kZXggMTE4NzUxZS4uYzNmMGY2OCAxMDA2NDQKLS0tIGEvSmF2YVNjcmlwdENvcmUvcnVudGlt ZS9VU3RyaW5nLmNwcAorKysgYi9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1VTdHJpbmcuY3BwCkBA IC0xOTAsOSArMTkwLDkgQEAgYm9vbCBvcGVyYXRvcj09KGNvbnN0IENTdHJpbmcmIGMxLCBjb25z dCBDU3RyaW5nJiBjMikKIC8vIFRoZXNlIHN0YXRpYyBzdHJpbmdzIGFyZSBpbW11dGFibGUsIGV4 Y2VwdCBmb3IgcmMsIHdob3NlIGluaXRpYWwgdmFsdWUgaXMgY2hvc2VuIHRvIAogLy8gcmVkdWNl IHRoZSBwb3NzaWJpbGl0eSBvZiBpdCBiZWNvbWluZyB6ZXJvIGR1ZSB0byByZWYvZGVyZWYgbm90 IGJlaW5nIHRocmVhZC1zYWZlLgogc3RhdGljIFVDaGFyIHNoYXJlZEVtcHR5Q2hhcjsKLVVTdHJp bmc6OkJhc2VTdHJpbmcqIFVTdHJpbmc6OlJlcDo6bnVsbEJhc2VTdHJpbmc7Ci1VU3RyaW5nOjpC YXNlU3RyaW5nKiBVU3RyaW5nOjpSZXA6OmVtcHR5QmFzZVN0cmluZzsKLVVTdHJpbmcqIFVTdHJp bmc6Om51bGxVU3RyaW5nOworV1RGOjpTdGF0aWNQdHI8VVN0cmluZzo6QmFzZVN0cmluZz4gVVN0 cmluZzo6UmVwOjpudWxsQmFzZVN0cmluZzsKK1dURjo6U3RhdGljUHRyPFVTdHJpbmc6OkJhc2VT dHJpbmc+IFVTdHJpbmc6OlJlcDo6ZW1wdHlCYXNlU3RyaW5nOworV1RGOjpTdGF0aWNQdHI8VVN0 cmluZz4gVVN0cmluZzo6bnVsbFVTdHJpbmc7CiAKIHN0YXRpYyB2b2lkIGluaXRpYWxpemVTdGF0 aWNCYXNlU3RyaW5nKFVTdHJpbmc6OkJhc2VTdHJpbmcmIGJhc2UpCiB7CmRpZmYgLS1naXQgYS9K YXZhU2NyaXB0Q29yZS9ydW50aW1lL1VTdHJpbmcuaCBiL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUv VVN0cmluZy5oCmluZGV4IGQwMWI3NWQuLjk1NzRmN2EgMTAwNjQ0Ci0tLSBhL0phdmFTY3JpcHRD b3JlL3J1bnRpbWUvVVN0cmluZy5oCisrKyBiL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvVVN0cmlu Zy5oCkBAIC0zMiw2ICszMiw3IEBACiAjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KICNpbmNs dWRlIDx3dGYvUHRyQW5kRmxhZ3MuaD4KICNpbmNsdWRlIDx3dGYvUmVmUHRyLmg+CisjaW5jbHVk ZSA8d3RmL1N0YXRpY1B0ci5oPgogI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4KICNpbmNsdWRlIDx3 dGYvdW5pY29kZS9Vbmljb2RlLmg+CiAKQEAgLTE4NSw4ICsxODYsOCBAQCBuYW1lc3BhY2UgSlND IHsKIAogICAgICAgICAgICAgZnJpZW5kIGNsYXNzIFNtYWxsU3RyaW5nc1N0b3JhZ2U7CiAgICAg ICAgICAgICBmcmllbmQgdm9pZCBpbml0aWFsaXplVVN0cmluZygpOwotICAgICAgICAgICAgSlNf RVhQT1JUREFUQSBzdGF0aWMgQmFzZVN0cmluZyogbnVsbEJhc2VTdHJpbmc7Ci0gICAgICAgICAg ICBKU19FWFBPUlREQVRBIHN0YXRpYyBCYXNlU3RyaW5nKiBlbXB0eUJhc2VTdHJpbmc7CisgICAg ICAgICAgICBKU19FWFBPUlREQVRBIHN0YXRpYyBXVEY6OlN0YXRpY1B0cjxCYXNlU3RyaW5nPiBu dWxsQmFzZVN0cmluZzsKKyAgICAgICAgICAgIEpTX0VYUE9SVERBVEEgc3RhdGljIFdURjo6U3Rh dGljUHRyPEJhc2VTdHJpbmc+IGVtcHR5QmFzZVN0cmluZzsKICAgICAgICAgfTsKIAogCkBAIC0z NjcsNyArMzY4LDcgQEAgbmFtZXNwYWNlIEpTQyB7CiAgICAgICAgIHZvaWQgbWFrZU51bGwoKTsK IAogICAgICAgICBSZWZQdHI8UmVwPiBtX3JlcDsKLSAgICAgICAgc3RhdGljIFVTdHJpbmcqIG51 bGxVU3RyaW5nOworICAgICAgICBzdGF0aWMgV1RGOjpTdGF0aWNQdHI8VVN0cmluZz4gbnVsbFVT dHJpbmc7CiAKICAgICAgICAgZnJpZW5kIHZvaWQgaW5pdGlhbGl6ZVVTdHJpbmcoKTsKICAgICAg ICAgZnJpZW5kIGJvb2wgb3BlcmF0b3I9PShjb25zdCBVU3RyaW5nJiwgY29uc3QgVVN0cmluZyYp OwpkaWZmIC0tZ2l0IGEvSmF2YVNjcmlwdENvcmUvd3RmL1BsYXRmb3JtLmggYi9KYXZhU2NyaXB0 Q29yZS93dGYvUGxhdGZvcm0uaAppbmRleCAzY2EzYWFmLi4xMGZkMDJmIDEwMDY0NAotLS0gYS9K YXZhU2NyaXB0Q29yZS93dGYvUGxhdGZvcm0uaAorKysgYi9KYXZhU2NyaXB0Q29yZS93dGYvUGxh dGZvcm0uaApAQCAtNzEyLDQgKzcxMiw2IEBACiAjZGVmaW5lIFdURl9VU0VfQUNDRUxFUkFURURf Q09NUE9TSVRJTkcgMQogI2VuZGlmCiAKKyNkZWZpbmUgRU5BQkxFX0ZSRUVfU1RBVElDX1BUUlMg MQorCiAjZW5kaWYgLyogV1RGX1BsYXRmb3JtX2ggKi8KZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRD b3JlL3d0Zi9TdGF0aWNQdHIuY3BwIGIvSmF2YVNjcmlwdENvcmUvd3RmL1N0YXRpY1B0ci5jcHAK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYmFiMWJmZAotLS0gL2Rldi9udWxs CisrKyBiL0phdmFTY3JpcHRDb3JlL3d0Zi9TdGF0aWNQdHIuY3BwCkBAIC0wLDAgKzEsNzEgQEAK Ky8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMDkgVW5pdmVyc2l0eSBvZiBTemVnZWQKKyAqIEFsbCBy aWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2Ug YW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBw ZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBt ZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhl IGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBh bmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJp bmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBp biB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRl ZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURF RCBCWSBVTklWRVJTSVRZIE9GIFNaRUdFRCBgYEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBP UiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUK KyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9S IEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNI QUxMIFVOSVZFUlNJVFkgT0YgU1pFR0VEIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZP UiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFS WSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBU TywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1Mg T0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBI T1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVS IElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5F R0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UK KyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkg T0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIlN0 YXRpY1B0ci5oIgorI2luY2x1ZGUgPHN0ZGlvLmg+CisKK25hbWVzcGFjZSBXVEYgeworCisjaWYg RU5BQkxFKEZSRUVfU1RBVElDX1BUUlMpCisKK1N0YXRpY1B0ckJhc2U6OlN0YXRpY1B0ckJhc2Uq IFN0YXRpY1B0ckJhc2U6Om1faGVhZCA9IDA7CisKK3ZvaWQgU3RhdGljUHRyQmFzZTo6ZnJlZVN0 YXRpY1B0cnMoKQoreworICAgIC8vIEZyZWUgdGhlbSBpbiBhIHJldmVyc2VkIGNyZWF0aW9uIG9y ZGVyCisgICAgU3RhdGljUHRyQmFzZSogY3VycmVudCA9IGhlYWQoKTsKKyAgICB3aGlsZSAoY3Vy cmVudCkgeworICAgICAgICBjdXJyZW50LT5mcmVlKCk7CisgICAgICAgIGN1cnJlbnQgPSBjdXJy ZW50LT5uZXh0KCk7CisgICAgfQorfQorCit2b2lkIFN0YXRpY1B0ckJhc2U6OmFwcGVuZCgpCit7 CisgICAgbV9uZXh0ID0gaGVhZCgpOworICAgIG1faGVhZCA9IHRoaXM7Cit9CisKK3ZvaWQgU3Rh dGljUHRyQmFzZTo6cmVtb3ZlKCkKK3sKKyAgICAvLyBQZXJoYXBzIGEgZG91YmxlIGxpbmtlZCBs aXN0IG1heSBiZSBzdWl0YWJsZSBpZiByZW1vdmUoKSBjYWxsZWQgZnJlcXVlbnRseQorICAgIFN0 YXRpY1B0ckJhc2UqIGN1cnJlbnQgPSBoZWFkKCk7CisgICAgaWYgKGN1cnJlbnQgPT0gdGhpcykg eworICAgICAgICBtX2hlYWQgPSBjdXJyZW50LT5uZXh0KCk7CisgICAgICAgIHJldHVybjsKKyAg ICB9CisKKyAgICB3aGlsZSAoY3VycmVudC0+bmV4dCgpICE9IHRoaXMpIHsKKyAgICAgICAgY3Vy cmVudCA9IGN1cnJlbnQtPm5leHQoKTsKKyAgICAgICAgQVNTRVJUKGN1cnJlbnQpOworICAgIH0K KyAgICBjdXJyZW50LT5tX25leHQgPSBuZXh0KCk7Cit9CisKKyNlbmRpZiAvLyBFTkFCTEUoRlJF RV9TVEFUSUNfUFRSUykKKworfSAvLyBuYW1lc3BhY2UgV1RGCmRpZmYgLS1naXQgYS9KYXZhU2Ny aXB0Q29yZS93dGYvU3RhdGljUHRyLmggYi9KYXZhU2NyaXB0Q29yZS93dGYvU3RhdGljUHRyLmgK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOTY0NGRkNAotLS0gL2Rldi9udWxs CisrKyBiL0phdmFTY3JpcHRDb3JlL3d0Zi9TdGF0aWNQdHIuaApAQCAtMCwwICsxLDIxNSBAQAor LyoKKyAqIENvcHlyaWdodCAoQykgMjAwOSBVbml2ZXJzaXR5IG9mIFN6ZWdlZAorICogQWxsIHJp Z2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBh bmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBl cm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1l dDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUg YWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFu ZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmlu YXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNl LCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGlu IHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVk IHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVE IEJZIFVOSVZFUlNJVFkgT0YgU1pFR0VEIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9S IElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQor ICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1Ig QSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hB TEwgVU5JVkVSU0lUWSBPRiBTWkVHRUQgT1IKKyAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9S IEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAorICogRVhFTVBMQVJZ LCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRP LAorICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBP RiBVU0UsIERBVEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhP V0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJVFksIFdIRVRIRVIg SU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVH TElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQor ICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBP RiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVmIFdURl9TdGF0aWNQdHJfaAorI2RlZmluZSBX VEZfU3RhdGljUHRyX2gKKworI2luY2x1ZGUgIkFzc2VydGlvbnMuaCIKKyNpbmNsdWRlICJUeXBl VHJhaXRzLmgiCisjaW5jbHVkZSAiQWx3YXlzSW5saW5lLmgiCisKK25hbWVzcGFjZSBXVEYgewor CitjbGFzcyBTdGF0aWNQdHJCYXNlIHsKK3B1YmxpYzoKKyNpZiAhRU5BQkxFKEZSRUVfU1RBVElD X1BUUlMpCisgICAgdm9pZCBhcHBlbmQoKSB7IH0KKyNlbHNlCisgICAgdm9pZCBhcHBlbmQoKTsK KyAgICB2b2lkIHJlbW92ZSgpOworCisgICAgc3RhdGljIHZvaWQgZnJlZVN0YXRpY1B0cnMoKTsK KworICAgIC8vIFN1cHByZXNzIEdDQyB3YXJuaW5nCisgICAgdmlydHVhbCB+U3RhdGljUHRyQmFz ZSgpIHsgfQorCitwcml2YXRlOgorICAgIHN0YXRpYyBTdGF0aWNQdHJCYXNlKiBtX2hlYWQ7Cisg ICAgU3RhdGljUHRyQmFzZSogbV9uZXh0OworCisgICAgc3RhdGljIFN0YXRpY1B0ckJhc2UqIGhl YWQoKSB7IHJldHVybiBtX2hlYWQ7IH0KKyAgICBTdGF0aWNQdHJCYXNlKiBuZXh0KCkgeyByZXR1 cm4gbV9uZXh0OyB9CisKKyAgICB2aXJ0dWFsIHZvaWQgZnJlZSgpID0gMDsKKyNlbmRpZgorfTsK KwordGVtcGxhdGU8dHlwZW5hbWUgVD4gY2xhc3MgU3RhdGljUHRyIDogcHVibGljIFN0YXRpY1B0 ckJhc2UgeworcHVibGljOgorICAgIHR5cGVkZWYgdHlwZW5hbWUgUmVtb3ZlUG9pbnRlcjxUPjo6 VHlwZSBWYWx1ZVR5cGU7CisgICAgdHlwZWRlZiBWYWx1ZVR5cGUqIFB0clR5cGU7CisKKyAgICBT dGF0aWNQdHIoUHRyVHlwZSBwdHIpIDogbV9wdHIocHRyKSB7IGFwcGVuZCgpOyB9CisgICAgU3Rh dGljUHRyKCkgOiBtX3B0cigwKSB7IH0KKworICAgIFB0clR5cGUgZ2V0KCkgY29uc3Q7CisgICAg dm9pZCBzZXQoUHRyVHlwZSk7CisKKyAgICBQdHJUeXBlIG9wZXJhdG9yPShQdHJUeXBlKTsKKwor ICAgIC8vIFZhbHVlIGFjY2VzcyBvcGVyYXRvcnMKKyAgICBWYWx1ZVR5cGUmIG9wZXJhdG9yKigp OworICAgIFB0clR5cGUgb3BlcmF0b3ItPigpOworICAgIFZhbHVlVHlwZSYgb3BlcmF0b3IqKCkg Y29uc3Q7CisgICAgUHRyVHlwZSBvcGVyYXRvci0+KCkgY29uc3Q7CisKKyAgICBib29sIG9wZXJh dG9yISgpIGNvbnN0OworCisgICAgdm9pZCBkZWxldGVQdHIoKTsKKworcHJpdmF0ZToKKyAgICAv LyBUaGlzIHBvaW50ZXIgY2FuIGJlIGluaXRpYWxpemVkIGF0IG1vc3Qgb25jZQorICAgIFB0clR5 cGUgbV9wdHI7CisKKyNpZiBFTkFCTEUoRlJFRV9TVEFUSUNfUFRSUykKKyAgICB2aXJ0dWFsIHZv aWQgZnJlZSgpIHsgQVNTRVJUKG1fcHRyKTsgZGVsZXRlIG1fcHRyOyB9CisjZW5kaWYKK307CisK Ky8vIFdyYXBwZXIgY2xhc3MgZm9yIGFycmF5cywgd2hpY2ggYXNzaWduZWQgdG8gYSBzdGF0aWMg dmFyaWFibGUKKy8vIEJ5IGRlZmF1bHQsIGl0IGJlaGF2ZXMgbGlrZSBhIHNpbXBsZSBDKysgYXJy YXkgd2l0aG91dCBwZXJmb3JtYW5jZSBvdmVyaGVhZAordGVtcGxhdGU8dHlwZW5hbWUgVD4gY2xh c3MgU3RhdGljQXJyYXlQdHIgOiBwdWJsaWMgU3RhdGljUHRyQmFzZSB7CitwdWJsaWM6CisgICAg dHlwZWRlZiB0eXBlbmFtZSBSZW1vdmVQb2ludGVyPFQ+OjpUeXBlIFZhbHVlVHlwZTsKKyAgICB0 eXBlZGVmIFZhbHVlVHlwZSogUHRyVHlwZTsKKworICAgIFN0YXRpY0FycmF5UHRyKFB0clR5cGUg cHRyKSA6IG1fcHRyKHB0cikgeyBhcHBlbmQoKTsgfQorCisgICAgVmFsdWVUeXBlJiBvcGVyYXRv cltdKHNpemVfdCk7CisgICAgY29uc3QgVmFsdWVUeXBlJiBvcGVyYXRvcltdKHNpemVfdCkgY29u c3Q7CisKK3ByaXZhdGU6CisgICAgLy8gVGhpcyBwb2ludGVyIGNhbiBiZSBpbml0aWFsaXplZCBh dCBtb3N0IG9uY2UKKyAgICBQdHJUeXBlIG1fcHRyOworCisjaWYgRU5BQkxFKEZSRUVfU1RBVElD X1BUUlMpCisgICAgdmlydHVhbCB2b2lkIGZyZWUoKSB7IEFTU0VSVChtX3B0cik7IGRlbGV0ZVtd IG1fcHRyOyB9CisjZW5kaWYKK307CisKKyNpZiBFTkFCTEUoRlJFRV9TVEFUSUNfUFRSUykKK3Rl bXBsYXRlPHR5cGVuYW1lIFQ+IGNsYXNzIEdsb2JhbFN0YXRpY1B0ciA6IHB1YmxpYyBXVEY6OlN0 YXRpY1B0ckJhc2UgeworcHVibGljOgorICAgIEdsb2JhbFN0YXRpY1B0cih2b2lkKiByZWYpIDog bV9yZWYocmVpbnRlcnByZXRfY2FzdDxUKj4ocmVmKSkgeyB9Citwcml2YXRlOgorICAgIFQqIG1f cmVmOworCisgICAgdmlydHVhbCB2b2lkIGZyZWUoKSB7IG1fcmVmLT5+VCgpOyB9Cit9OworI2Vu ZGlmCisKK3RlbXBsYXRlPHR5cGVuYW1lIFQ+CitBTFdBWVNfSU5MSU5FIHR5cGVuYW1lIFN0YXRp Y1B0cjxUPjo6UHRyVHlwZSBTdGF0aWNQdHI8VD46OmdldCgpIGNvbnN0Cit7CisgICAgcmV0dXJu IG1fcHRyOworfQorCit0ZW1wbGF0ZTx0eXBlbmFtZSBUPgorQUxXQVlTX0lOTElORSB2b2lkIFN0 YXRpY1B0cjxUPjo6c2V0KFB0clR5cGUgdmFsdWUpCit7CisgICAgLy8gRGV0ZWN0IG1lbW9yeSBs ZWFrcworICAgIEFTU0VSVCghbV9wdHIgfHwgKG1fcHRyID09IHZhbHVlKSk7CisgICAgbV9wdHIg PSB2YWx1ZTsKKyNpZiBFTkFCTEUoRlJFRV9TVEFUSUNfUFRSUykKKyAgICAvLyBUaGUgI2lmIG1h eSBiZSBub3QgbmVjZXNzYXJ5IGhlcmUsIHNpbmNlIGNvbXBpbGVycyBzaG91bGQKKyAgICAvLyBi ZSBlbGltaW5hdGUgdGhlICJpZih2YWx1ZSkgeyB9IiBkZWFkIGNvZGUKKyAgICBpZiAodmFsdWUp CisgICAgICAgIGFwcGVuZCgpOworI2VuZGlmCit9CisKK3RlbXBsYXRlPHR5cGVuYW1lIFQ+CitB TFdBWVNfSU5MSU5FIHR5cGVuYW1lIFN0YXRpY1B0cjxUPjo6UHRyVHlwZSBTdGF0aWNQdHI8VD46 Om9wZXJhdG9yPShQdHJUeXBlIHZhbHVlKQoreworICAgIHNldCh2YWx1ZSk7CisgICAgcmV0dXJu IHZhbHVlOworfQorCit0ZW1wbGF0ZTx0eXBlbmFtZSBUPgorQUxXQVlTX0lOTElORSB0eXBlbmFt ZSBTdGF0aWNQdHI8VD46OlZhbHVlVHlwZSYgU3RhdGljUHRyPFQ+OjpvcGVyYXRvciooKQorewor ICAgIEFTU0VSVChtX3B0cik7CisgICAgcmV0dXJuICptX3B0cjsKK30KKwordGVtcGxhdGU8dHlw ZW5hbWUgVD4KK0FMV0FZU19JTkxJTkUgdHlwZW5hbWUgU3RhdGljUHRyPFQ+OjpQdHJUeXBlIFN0 YXRpY1B0cjxUPjo6b3BlcmF0b3ItPigpCit7CisgICAgQVNTRVJUKG1fcHRyKTsKKyAgICByZXR1 cm4gbV9wdHI7Cit9CisKK3RlbXBsYXRlPHR5cGVuYW1lIFQ+CitBTFdBWVNfSU5MSU5FIHR5cGVu YW1lIFN0YXRpY1B0cjxUPjo6VmFsdWVUeXBlJiBTdGF0aWNQdHI8VD46Om9wZXJhdG9yKigpIGNv bnN0Cit7CisgICAgQVNTRVJUKG1fcHRyKTsKKyAgICByZXR1cm4gKm1fcHRyOworfQorCit0ZW1w bGF0ZTx0eXBlbmFtZSBUPgorQUxXQVlTX0lOTElORSB0eXBlbmFtZSBTdGF0aWNQdHI8VD46OlB0 clR5cGUgU3RhdGljUHRyPFQ+OjpvcGVyYXRvci0+KCkgY29uc3QKK3sKKyAgICBBU1NFUlQobV9w dHIpOworICAgIHJldHVybiBtX3B0cjsKK30KKwordGVtcGxhdGU8dHlwZW5hbWUgVD4KK0FMV0FZ U19JTkxJTkUgYm9vbCBTdGF0aWNQdHI8VD46Om9wZXJhdG9yISgpIGNvbnN0Cit7CisgICAgcmV0 dXJuICFtX3B0cjsKK30KKwordGVtcGxhdGU8dHlwZW5hbWUgVD4KK0FMV0FZU19JTkxJTkUgdm9p ZCBTdGF0aWNQdHI8VD46OmRlbGV0ZVB0cigpCit7CisgICAgQVNTRVJUKG1fcHRyKTsKKyAgICBk ZWxldGUgbV9wdHI7CisjaWZuZGVmIE5ERUJVRworICAgIC8vIFNlZSBTdGF0aWNQdHI8VD46OnNl dAorICAgIG1fcHRyID0gMDsKKyNlbmRpZgorI2lmIEVOQUJMRShGUkVFX1NUQVRJQ19QVFJTKQor ICAgIHJlbW92ZSgpOworI2VuZGlmCit9CisKK3RlbXBsYXRlPHR5cGVuYW1lIFQ+CitBTFdBWVNf SU5MSU5FIHR5cGVuYW1lIFN0YXRpY0FycmF5UHRyPFQ+OjpWYWx1ZVR5cGUmIFN0YXRpY0FycmF5 UHRyPFQ+OjpvcGVyYXRvcltdKHNpemVfdCBpKQoreworICAgIEFTU0VSVChtX3B0cik7CisgICAg cmV0dXJuIG1fcHRyW2ldOworfQorCit0ZW1wbGF0ZTx0eXBlbmFtZSBUPgorQUxXQVlTX0lOTElO RSBjb25zdCB0eXBlbmFtZSBTdGF0aWNBcnJheVB0cjxUPjo6VmFsdWVUeXBlJiBTdGF0aWNBcnJh eVB0cjxUPjo6b3BlcmF0b3JbXShzaXplX3QgaSkgY29uc3QKK3sKKyAgICBBU1NFUlQobV9wdHIp OworICAgIHJldHVybiBtX3B0cltpXTsKK30KKworfSAvLyBuYW1lc3BhY2UgV1RGCisKKyNlbmRp ZgpkaWZmIC0tZ2l0IGEvSmF2YVNjcmlwdENvcmUvd3RmL1N0ZExpYkV4dHJhcy5oIGIvSmF2YVNj cmlwdENvcmUvd3RmL1N0ZExpYkV4dHJhcy5oCmluZGV4IGQyMWQxZmYuLjgxMmE2YWQgMTAwNjQ0 Ci0tLSBhL0phdmFTY3JpcHRDb3JlL3d0Zi9TdGRMaWJFeHRyYXMuaAorKysgYi9KYXZhU2NyaXB0 Q29yZS93dGYvU3RkTGliRXh0cmFzLmgKQEAgLTI4LDExICsyOCwxNiBAQAogCiAjaW5jbHVkZSA8 d3RmL1BsYXRmb3JtLmg+CiAjaW5jbHVkZSA8d3RmL0Fzc2VydGlvbnMuaD4KKyNpbmNsdWRlIDx3 dGYvU3RhdGljUHRyLmg+CiAKIC8vIFVzZSB0aGVzZSB0byBkZWNsYXJlIGFuZCBkZWZpbmUgYSBz dGF0aWMgbG9jYWwgdmFyaWFibGUgKHN0YXRpYyBUOykgc28gdGhhdAogLy8gIGl0IGlzIGxlYWtl ZCBzbyB0aGF0IGl0cyBkZXN0cnVjdG9ycyBhcmUgbm90IGNhbGxlZCBhdCBleGl0LiBVc2luZyB0 aGlzCiAvLyAgbWFjcm8gYWxzbyBhbGxvd3Mgd29ya2Fyb3VuZHMgYSBjb21waWxlciBidWcgcHJl c2VudCBpbiBBcHBsZSdzIHZlcnNpb24gb2YgR0NDIDQuMC4xLgotI2lmIENPTVBJTEVSKEdDQykg JiYgZGVmaW5lZChfX0FQUExFX0NDX18pICYmIF9fR05VQ19fID09IDQgJiYgX19HTlVDX01JTk9S X18gPT0gMCAmJiBfX0dOVUNfUEFUQ0hMRVZFTF9fID09IDEKKyNpZiBFTkFCTEUoRlJFRV9TVEFU SUNfUFRSUykKKyNkZWZpbmUgREVGSU5FX1NUQVRJQ19MT0NBTCh0eXBlLCBuYW1lLCBhcmd1bWVu dHMpIFwKKyAgICBzdGF0aWMgV1RGOjpTdGF0aWNQdHI8IHR5cGUgPiBuYW1lIyNQdHIobmV3IHR5 cGUgYXJndW1lbnRzKTsgXAorICAgIHR5cGUmIG5hbWUgPSAqbmFtZSMjUHRyCisjZWxpZiBDT01Q SUxFUihHQ0MpICYmIGRlZmluZWQoX19BUFBMRV9DQ19fKSAmJiBfX0dOVUNfXyA9PSA0ICYmIF9f R05VQ19NSU5PUl9fID09IDAgJiYgX19HTlVDX1BBVENITEVWRUxfXyA9PSAxCiAjZGVmaW5lIERF RklORV9TVEFUSUNfTE9DQUwodHlwZSwgbmFtZSwgYXJndW1lbnRzKSBcCiAgICAgc3RhdGljIHR5 cGUqIG5hbWUjI1B0ciA9IG5ldyB0eXBlIGFyZ3VtZW50czsgXAogICAgIHR5cGUmIG5hbWUgPSAq bmFtZSMjUHRyCmRpZmYgLS1naXQgYS9KYXZhU2NyaXB0Q29yZS93dGYvVGhyZWFkU3BlY2lmaWMu aCBiL0phdmFTY3JpcHRDb3JlL3d0Zi9UaHJlYWRTcGVjaWZpYy5oCmluZGV4IDRkNWQyZjcuLjhi ZmRjY2YgMTAwNjQ0Ci0tLSBhL0phdmFTY3JpcHRDb3JlL3d0Zi9UaHJlYWRTcGVjaWZpYy5oCisr KyBiL0phdmFTY3JpcHRDb3JlL3d0Zi9UaHJlYWRTcGVjaWZpYy5oCkBAIC0yMzIsNyArMjMyLDkg QEAgaW5saW5lIHZvaWQgVGhyZWFkU3BlY2lmaWM8VD46OmRlc3Ryb3kodm9pZCogcHRyKQogI2Vy cm9yIFRocmVhZFNwZWNpZmljIGlzIG5vdCBpbXBsZW1lbnRlZCBmb3IgdGhpcyBwbGF0Zm9ybS4K ICNlbmRpZgogCisjaWYgIVBMQVRGT1JNKFFUKQogICAgIGRlbGV0ZSBkYXRhOworI2VuZGlmCiB9 CiAKIHRlbXBsYXRlPHR5cGVuYW1lIFQ+CmRpZmYgLS1naXQgYS9XZWJDb3JlL1dlYkNvcmUucHJv IGIvV2ViQ29yZS9XZWJDb3JlLnBybwppbmRleCA5YTVhMzEyLi5kNTJkYzMyIDEwMDY0NAotLS0g YS9XZWJDb3JlL1dlYkNvcmUucHJvCisrKyBiL1dlYkNvcmUvV2ViQ29yZS5wcm8KQEAgLTEwMTAs NiArMTAxMCw3IEBAIFNPVVJDRVMgKz0gXAogICAgIGh0bWwvSFRNTFZpZXdTb3VyY2VEb2N1bWVu dC5jcHAgXAogICAgIGh0bWwvSW1hZ2VEYXRhLmNwcCBcCiAgICAgaHRtbC9QcmVsb2FkU2Nhbm5l ci5jcHAgXAorICAgIGh0bWwvVGltZVJhbmdlcy5jcHAgXAogICAgIGh0bWwvVmFsaWRpdHlTdGF0 ZS5jcHAgXAogICAgIGluc3BlY3Rvci9Db25zb2xlTWVzc2FnZS5jcHAgXAogICAgIGluc3BlY3Rv ci9JbnNwZWN0b3JCYWNrZW5kLmNwcCBcCkBAIC0yNTc4LDcgKzI1NzksNiBAQCBjb250YWlucyhE RUZJTkVTLCBFTkFCTEVfVklERU89MSkgewogICAgICAgICBodG1sL0hUTUxNZWRpYUVsZW1lbnQu Y3BwIFwKICAgICAgICAgaHRtbC9IVE1MU291cmNlRWxlbWVudC5jcHAgXAogICAgICAgICBodG1s L0hUTUxWaWRlb0VsZW1lbnQuY3BwIFwKLSAgICAgICAgaHRtbC9UaW1lUmFuZ2VzLmNwcCBcCiAg ICAgICAgIHBsYXRmb3JtL2dyYXBoaWNzL01lZGlhUGxheWVyLmNwcCBcCiAgICAgICAgIHJlbmRl cmluZy9NZWRpYUNvbnRyb2xFbGVtZW50cy5jcHAgXAogICAgICAgICByZW5kZXJpbmcvUmVuZGVy VmlkZW8uY3BwIFwKZGlmZiAtLWdpdCBhL1dlYkNvcmUvYmluZGluZ3MvanMvSlNET01XaW5kb3dC YXNlLmNwcCBiL1dlYkNvcmUvYmluZGluZ3MvanMvSlNET01XaW5kb3dCYXNlLmNwcAppbmRleCBk ZjYwNjhhLi44OWZlYjNmIDEwMDY0NAotLS0gYS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTRE9NV2lu ZG93QmFzZS5jcHAKKysrIGIvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0RPTVdpbmRvd0Jhc2UuY3Bw CkBAIC0zNSw2ICszNSw3IEBACiAjaW5jbHVkZSAiU2NyaXB0Q29udHJvbGxlci5oIgogI2luY2x1 ZGUgIlNlY3VyaXR5T3JpZ2luLmgiCiAjaW5jbHVkZSAiU2V0dGluZ3MuaCIKKyNpbmNsdWRlICJ3 dGYvU3RhdGljUHRyLmgiCiAKIHVzaW5nIG5hbWVzcGFjZSBKU0M7CiAKQEAgLTE2MSwxNSArMTYy LDI1IEBAIEpTRE9NV2luZG93U2hlbGwqIEpTRE9NV2luZG93QmFzZTo6c2hlbGwoKSBjb25zdAog ICAgIHJldHVybiBkKCktPnNoZWxsOwogfQogCitjbGFzcyBTdGF0aWNHbG9iYWxEYXRhIDogcHVi bGljIFdURjo6U3RhdGljUHRyPEpTR2xvYmFsRGF0YT4geworcHJpdmF0ZToKKyNpZiBFTkFCTEUo RlJFRV9TVEFUSUNfUFRSUykKKyAgICB2aXJ0dWFsIHZvaWQgZnJlZSgpIHsKKyAgICAgICAgZ2V0 KCktPmhlYXAuZGVzdHJveSgpOworICAgICAgICBkZWxldGUgZ2V0KCk7CisgICAgfQorI2VuZGlm Cit9OworCiBKU0dsb2JhbERhdGEqIEpTRE9NV2luZG93QmFzZTo6Y29tbW9uSlNHbG9iYWxEYXRh KCkKIHsKLSAgICBzdGF0aWMgSlNHbG9iYWxEYXRhKiBnbG9iYWxEYXRhOworICAgIHN0YXRpYyBT dGF0aWNHbG9iYWxEYXRhIGdsb2JhbERhdGE7CiAgICAgaWYgKCFnbG9iYWxEYXRhKSB7Ci0gICAg ICAgIGdsb2JhbERhdGEgPSBKU0dsb2JhbERhdGE6OmNyZWF0ZUxlYWtlZCgpLnJlbGVhc2VSZWYo KTsKKyAgICAgICAgZ2xvYmFsRGF0YS5zZXQoSlNHbG9iYWxEYXRhOjpjcmVhdGVMZWFrZWQoKS5y ZWxlYXNlUmVmKCkpOwogICAgICAgICBnbG9iYWxEYXRhLT50aW1lb3V0Q2hlY2tlci5zZXRUaW1l b3V0SW50ZXJ2YWwoMTAwMDApOyAvLyAxMCBzZWNvbmRzCiAgICAgfQogCi0gICAgcmV0dXJuIGds b2JhbERhdGE7CisgICAgcmV0dXJuIGdsb2JhbERhdGEuZ2V0KCk7CiB9CiAKIC8vIEpTRE9NR2xv YmFsT2JqZWN0KiBpcyBpZ25vcmVkLCBhY2Nlc2luZyBhIHdpbmRvdyBpbiBhbnkgY29udGV4dCB3 aWxsCmRpZmYgLS1naXQgYS9XZWJDb3JlL2JyaWRnZS9JZGVudGlmaWVyUmVwLmNwcCBiL1dlYkNv cmUvYnJpZGdlL0lkZW50aWZpZXJSZXAuY3BwCmluZGV4IDExNTYwZTMuLjhiZTBjN2IgMTAwNjQ0 Ci0tLSBhL1dlYkNvcmUvYnJpZGdlL0lkZW50aWZpZXJSZXAuY3BwCisrKyBiL1dlYkNvcmUvYnJp ZGdlL0lkZW50aWZpZXJSZXAuY3BwCkBAIC0zMCw2ICszMCw3IEBACiAjaW5jbHVkZSA8cnVudGlt ZS9VU3RyaW5nLmg+CiAjaW5jbHVkZSA8d3RmL0hhc2hNYXAuaD4KICNpbmNsdWRlIDx3dGYvU3Rk TGliRXh0cmFzLmg+CisjaW5jbHVkZSA8d3RmL1N0YXRpY1B0ci5oPgogCiB1c2luZyBuYW1lc3Bh Y2UgSlNDOwogCkBAIC01NCw5ICs1NSw5IEBAIHN0YXRpYyBJbnRJZGVudGlmaWVyTWFwJiBpbnRJ ZGVudGlmaWVyTWFwKCkKIElkZW50aWZpZXJSZXAqIElkZW50aWZpZXJSZXA6OmdldChpbnQgaW50 SUQpCiB7CiAgICAgaWYgKGludElEID09IDAgfHwgaW50SUQgPT0gLTEpIHsKLSAgICAgICAgc3Rh dGljIElkZW50aWZpZXJSZXAqIG5lZ2F0aXZlT25lQW5kWmVyb0lkZW50aWZpZXJzWzJdOworICAg ICAgICBzdGF0aWMgV1RGOjpTdGF0aWNQdHI8SWRlbnRpZmllclJlcD4gbmVnYXRpdmVPbmVBbmRa ZXJvSWRlbnRpZmllcnNbMl07CiAKLSAgICAgICAgSWRlbnRpZmllclJlcCogaWRlbnRpZmllciA9 IG5lZ2F0aXZlT25lQW5kWmVyb0lkZW50aWZpZXJzW2ludElEICsgMV07CisgICAgICAgIElkZW50 aWZpZXJSZXAqIGlkZW50aWZpZXIgPSBuZWdhdGl2ZU9uZUFuZFplcm9JZGVudGlmaWVyc1tpbnRJ RCArIDFdLmdldCgpOwogICAgICAgICBpZiAoIWlkZW50aWZpZXIpIHsKICAgICAgICAgICAgIGlk ZW50aWZpZXIgPSBuZXcgSWRlbnRpZmllclJlcChpbnRJRCk7CiAKZGlmZiAtLWdpdCBhL1dlYkNv cmUvYnJpZGdlL0lkZW50aWZpZXJSZXAuaCBiL1dlYkNvcmUvYnJpZGdlL0lkZW50aWZpZXJSZXAu aAppbmRleCA4ZTBlMGQ5Li41MzNkMjY2IDEwMDY0NAotLS0gYS9XZWJDb3JlL2JyaWRnZS9JZGVu dGlmaWVyUmVwLmgKKysrIGIvV2ViQ29yZS9icmlkZ2UvSWRlbnRpZmllclJlcC5oCkBAIC01Niwx MSArNTYsMTMgQEAgcHJpdmF0ZToKICAgICAgICAgbV92YWx1ZS5tX3N0cmluZyA9IHN0cmR1cChu YW1lKTsKICAgICB9CiAgICAgCisjaWYgIUVOQUJMRShGUkVFX1NUQVRJQ19QVFJTKQogICAgIH5J ZGVudGlmaWVyUmVwKCkKICAgICB7CiAgICAgICAgIC8vIElkZW50aWZpZXJSZXBzIHNob3VsZCBu ZXZlciBiZSBkZWxldGVkLgogICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKICAgICB9Cisj ZW5kaWYKICAgICAKICAgICB1bmlvbiB7CiAgICAgICAgIGNvbnN0IGNoYXIqIG1fc3RyaW5nOwpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9jc3MvQ1NTUHJpbWl0aXZlVmFsdWUuY3BwIGIvV2ViQ29yZS9j c3MvQ1NTUHJpbWl0aXZlVmFsdWUuY3BwCmluZGV4IDYzNDNkYWMuLjFiZjllYTYgMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvY3NzL0NTU1ByaW1pdGl2ZVZhbHVlLmNwcAorKysgYi9XZWJDb3JlL2Nzcy9D U1NQcmltaXRpdmVWYWx1ZS5jcHAKQEAgLTM1LDYgKzM1LDcgQEAKICNpbmNsdWRlICJSZW5kZXJT dHlsZS5oIgogI2luY2x1ZGUgPHd0Zi9BU0NJSUNUeXBlLmg+CiAjaW5jbHVkZSA8d3RmL1N0ZExp YkV4dHJhcy5oPgorI2luY2x1ZGUgPHd0Zi9TdGF0aWNQdHIuaD4KIAogI2lmIEVOQUJMRShEQVNI Qk9BUkRfU1VQUE9SVCkKICNpbmNsdWRlICJEYXNoYm9hcmRSZWdpb24uaCIKQEAgLTUwLDcgKzUx LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogCiBQYXNzUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVl PiBDU1NQcmltaXRpdmVWYWx1ZTo6Y3JlYXRlSWRlbnRpZmllcihpbnQgaWRlbnQpCiB7Ci0gICAg c3RhdGljIFJlZlB0cjxDU1NQcmltaXRpdmVWYWx1ZT4qIGlkZW50VmFsdWVDYWNoZSA9IG5ldyBS ZWZQdHI8Q1NTUHJpbWl0aXZlVmFsdWU+W251bUNTU1ZhbHVlS2V5d29yZHNdOworICAgIHN0YXRp YyBTdGF0aWNBcnJheVB0cjxSZWZQdHI8Q1NTUHJpbWl0aXZlVmFsdWU+ID4gaWRlbnRWYWx1ZUNh Y2hlKG5ldyBSZWZQdHI8Q1NTUHJpbWl0aXZlVmFsdWU+W251bUNTU1ZhbHVlS2V5d29yZHNdKTsK ICAgICBpZiAoaWRlbnQgPj0gMCAmJiBpZGVudCA8IG51bUNTU1ZhbHVlS2V5d29yZHMpIHsKICAg ICAgICAgUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVlPiBwcmltaXRpdmVWYWx1ZSA9IGlkZW50VmFs dWVDYWNoZVtpZGVudF07CiAgICAgICAgIGlmICghcHJpbWl0aXZlVmFsdWUpIHsKQEAgLTY1LDcg KzY2LDcgQEAgUGFzc1JlZlB0cjxDU1NQcmltaXRpdmVWYWx1ZT4gQ1NTUHJpbWl0aXZlVmFsdWU6 OmNyZWF0ZUlkZW50aWZpZXIoaW50IGlkZW50KQogUGFzc1JlZlB0cjxDU1NQcmltaXRpdmVWYWx1 ZT4gQ1NTUHJpbWl0aXZlVmFsdWU6OmNyZWF0ZUNvbG9yKHVuc2lnbmVkIHJnYlZhbHVlKQogewog ICAgIHR5cGVkZWYgSGFzaE1hcDx1bnNpZ25lZCwgUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVlPiA+ IENvbG9yVmFsdWVDYWNoZTsKLSAgICBzdGF0aWMgQ29sb3JWYWx1ZUNhY2hlKiBjb2xvclZhbHVl Q2FjaGUgPSBuZXcgQ29sb3JWYWx1ZUNhY2hlOworICAgIHN0YXRpYyBXVEY6OlN0YXRpY1B0cjxD b2xvclZhbHVlQ2FjaGU+IGNvbG9yVmFsdWVDYWNoZSA9IG5ldyBDb2xvclZhbHVlQ2FjaGU7CiAg ICAgLy8gVGhlc2UgYXJlIHRoZSBlbXB0eSBhbmQgZGVsZXRlZCB2YWx1ZXMgb2YgdGhlIGhhc2gg dGFibGUuCiAgICAgaWYgKHJnYlZhbHVlID09IENvbG9yOjp0cmFuc3BhcmVudCkgewogICAgICAg ICBzdGF0aWMgQ1NTUHJpbWl0aXZlVmFsdWUqIGNvbG9yVHJhbnNwYXJlbnQgPSBuZXcgQ1NTUHJp bWl0aXZlVmFsdWUoQ29sb3I6OnRyYW5zcGFyZW50KTsKQEAgLTk0LDggKzk1LDggQEAgUGFzc1Jl ZlB0cjxDU1NQcmltaXRpdmVWYWx1ZT4gQ1NTUHJpbWl0aXZlVmFsdWU6OmNyZWF0ZShkb3VibGUg dmFsdWUsIFVuaXRUeXBlcwogICAgIGNvbnN0IGludCBjYWNoZWRJbnRlZ2VyQ291bnQgPSAxMjg7 CiAgICAgLy8gT3RoZXIgY29tbW9uIHByaW1pdGl2ZSB0eXBlcyBoYXZlIFVuaXRUeXBlcyBzbWFs bGVyIHRoYW4gdGhpcy4KICAgICBjb25zdCBpbnQgbWF4Q2FjaGVkVW5pdFR5cGUgPSBDU1NfUFg7 Ci0gICAgdHlwZWRlZiBSZWZQdHI8Q1NTUHJpbWl0aXZlVmFsdWU+KCogSW50ZWdlclZhbHVlQ2Fj aGUpW21heENhY2hlZFVuaXRUeXBlICsgMV07Ci0gICAgc3RhdGljIEludGVnZXJWYWx1ZUNhY2hl IGludGVnZXJWYWx1ZUNhY2hlID0gbmV3IFJlZlB0cjxDU1NQcmltaXRpdmVWYWx1ZT5bY2FjaGVk SW50ZWdlckNvdW50XVttYXhDYWNoZWRVbml0VHlwZSArIDFdOworICAgIHR5cGVkZWYgUmVmUHRy PENTU1ByaW1pdGl2ZVZhbHVlPiBJbnRlZ2VyVmFsdWVDYWNoZVttYXhDYWNoZWRVbml0VHlwZSAr IDFdOworICAgIHN0YXRpYyBXVEY6OlN0YXRpY0FycmF5UHRyPEludGVnZXJWYWx1ZUNhY2hlPiBp bnRlZ2VyVmFsdWVDYWNoZShuZXcgUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVlPltjYWNoZWRJbnRl Z2VyQ291bnRdW21heENhY2hlZFVuaXRUeXBlICsgMV0pOwogICAgIGlmICh0eXBlIDw9IG1heENh Y2hlZFVuaXRUeXBlICYmIHZhbHVlID49IDAgJiYgdmFsdWUgPCBjYWNoZWRJbnRlZ2VyQ291bnQp IHsKICAgICAgICAgaW50IGludFZhbHVlID0gc3RhdGljX2Nhc3Q8aW50Pih2YWx1ZSk7CiAgICAg ICAgIGlmICh2YWx1ZSA9PSBpbnRWYWx1ZSkgewpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9jc3MvQ1NT U3R5bGVTZWxlY3Rvci5jcHAgYi9XZWJDb3JlL2Nzcy9DU1NTdHlsZVNlbGVjdG9yLmNwcAppbmRl eCA3Y2ZhM2UxLi4yNjRjZjk0IDEwMDY0NAotLS0gYS9XZWJDb3JlL2Nzcy9DU1NTdHlsZVNlbGVj dG9yLmNwcAorKysgYi9XZWJDb3JlL2Nzcy9DU1NTdHlsZVNlbGVjdG9yLmNwcApAQCAtMzc2LDEz ICszNzYsMTMgQEAgcHVibGljOgogICAgIHVuc2lnbmVkIG1fcnVsZUNvdW50OwogfTsKIAotc3Rh dGljIENTU1J1bGVTZXQqIGRlZmF1bHRTdHlsZTsKLXN0YXRpYyBDU1NSdWxlU2V0KiBkZWZhdWx0 UXVpcmtzU3R5bGU7Ci1zdGF0aWMgQ1NTUnVsZVNldCogZGVmYXVsdFByaW50U3R5bGU7Ci1zdGF0 aWMgQ1NTUnVsZVNldCogZGVmYXVsdFZpZXdTb3VyY2VTdHlsZTsKLXN0YXRpYyBDU1NTdHlsZVNo ZWV0KiBzaW1wbGVEZWZhdWx0U3R5bGVTaGVldDsKK3N0YXRpYyBXVEY6OlN0YXRpY1B0cjxDU1NS dWxlU2V0PiBkZWZhdWx0U3R5bGU7CitzdGF0aWMgV1RGOjpTdGF0aWNQdHI8Q1NTUnVsZVNldD4g ZGVmYXVsdFF1aXJrc1N0eWxlOworc3RhdGljIFdURjo6U3RhdGljUHRyPENTU1J1bGVTZXQ+IGRl ZmF1bHRQcmludFN0eWxlOworc3RhdGljIFdURjo6U3RhdGljUHRyPENTU1J1bGVTZXQ+IGRlZmF1 bHRWaWV3U291cmNlU3R5bGU7CitzdGF0aWMgV1RGOjpTdGF0aWNQdHI8Q1NTU3R5bGVTaGVldD4g c2ltcGxlRGVmYXVsdFN0eWxlU2hlZXQ7CiAKLVJlbmRlclN0eWxlKiBDU1NTdHlsZVNlbGVjdG9y OjpzX3N0eWxlTm90WWV0QXZhaWxhYmxlOworV1RGOjpTdGF0aWNQdHI8UmVuZGVyU3R5bGU+IENT U1N0eWxlU2VsZWN0b3I6OnNfc3R5bGVOb3RZZXRBdmFpbGFibGU7CiAKIHN0YXRpYyBQc2V1ZG9T dGF0ZSBwc2V1ZG9TdGF0ZTsKIApAQCAtNTEyLDEwICs1MTIsMTAgQEAgc3RhdGljIENTU1N0eWxl U2hlZXQqIHBhcnNlVUFTaGVldChjb25zdCBjaGFyKiBjaGFyYWN0ZXJzLCB1bnNpZ25lZCBzaXpl KQogCiBzdGF0aWMgdm9pZCBsb2FkRnVsbERlZmF1bHRTdHlsZSgpCiB7Ci0gICAgaWYgKHNpbXBs ZURlZmF1bHRTdHlsZVNoZWV0KSB7CisgICAgaWYgKHNpbXBsZURlZmF1bHRTdHlsZVNoZWV0Lmdl dCgpKSB7CiAgICAgICAgIEFTU0VSVChkZWZhdWx0U3R5bGUpOwotICAgICAgICBkZWxldGUgZGVm YXVsdFN0eWxlOwotICAgICAgICBkZWxldGUgc2ltcGxlRGVmYXVsdFN0eWxlU2hlZXQ7CisgICAg ICAgIGRlZmF1bHRTdHlsZS5kZWxldGVQdHIoKTsKKyAgICAgICAgc2ltcGxlRGVmYXVsdFN0eWxl U2hlZXQuZGVsZXRlUHRyKCk7CiAgICAgICAgIGRlZmF1bHRTdHlsZSA9IG5ldyBDU1NSdWxlU2V0 OwogICAgICAgICBzaW1wbGVEZWZhdWx0U3R5bGVTaGVldCA9IDA7CiAgICAgfSBlbHNlIHsKQEAg LTU0Nyw3ICs1NDcsNyBAQCBzdGF0aWMgdm9pZCBsb2FkU2ltcGxlRGVmYXVsdFN0eWxlKCkKICAg ICBkZWZhdWx0UXVpcmtzU3R5bGUgPSBuZXcgQ1NTUnVsZVNldDsKIAogICAgIHNpbXBsZURlZmF1 bHRTdHlsZVNoZWV0ID0gcGFyc2VVQVNoZWV0KHNpbXBsZVVzZXJBZ2VudFN0eWxlU2hlZXQsIHN0 cmxlbihzaW1wbGVVc2VyQWdlbnRTdHlsZVNoZWV0KSk7Ci0gICAgZGVmYXVsdFN0eWxlLT5hZGRS dWxlc0Zyb21TaGVldChzaW1wbGVEZWZhdWx0U3R5bGVTaGVldCwgc2NyZWVuRXZhbCgpKTsKKyAg ICBkZWZhdWx0U3R5bGUtPmFkZFJ1bGVzRnJvbVNoZWV0KHNpbXBsZURlZmF1bHRTdHlsZVNoZWV0 LmdldCgpLCBzY3JlZW5FdmFsKCkpOwogICAgIAogICAgIC8vIE5vIG5lZWQgdG8gaW5pdGlhbGl6 ZSBxdWlya3Mgc2hlZXQgeWV0IGFzIHRoZXJlIGFyZSBubyBxdWlyayBydWxlcyBmb3IgZWxlbWVu dHMgYWxsb3dlZCBpbiBzaW1wbGUgZGVmYXVsdCBzdHlsZS4KIH0KQEAgLTEwNjQsMTggKzEwNjQs MTggQEAgdm9pZCBDU1NTdHlsZVNlbGVjdG9yOjptYXRjaFVBUnVsZXMoaW50JiBmaXJzdFVBUnVs ZSwgaW50JiBsYXN0VUFSdWxlKQogewogICAgIC8vIEZpcnN0IHdlIG1hdGNoIHJ1bGVzIGZyb20g dGhlIHVzZXIgYWdlbnQgc2hlZXQuCiAgICAgQ1NTUnVsZVNldCogdXNlckFnZW50U3R5bGVTaGVl dCA9IG1fbWVkaXVtLT5tZWRpYVR5cGVNYXRjaFNwZWNpZmljKCJwcmludCIpCi0gICAgICAgID8g ZGVmYXVsdFByaW50U3R5bGUgOiBkZWZhdWx0U3R5bGU7CisgICAgICAgID8gZGVmYXVsdFByaW50 U3R5bGUuZ2V0KCkgOiBkZWZhdWx0U3R5bGUuZ2V0KCk7CiAgICAgbWF0Y2hSdWxlcyh1c2VyQWdl bnRTdHlsZVNoZWV0LCBmaXJzdFVBUnVsZSwgbGFzdFVBUnVsZSk7CiAKICAgICAvLyBJbiBxdWly a3MgbW9kZSwgd2UgbWF0Y2ggcnVsZXMgZnJvbSB0aGUgcXVpcmtzIHVzZXIgYWdlbnQgc2hlZXQu CiAgICAgaWYgKCFtX2NoZWNrZXIubV9zdHJpY3RQYXJzaW5nKQotICAgICAgICBtYXRjaFJ1bGVz KGRlZmF1bHRRdWlya3NTdHlsZSwgZmlyc3RVQVJ1bGUsIGxhc3RVQVJ1bGUpOworICAgICAgICBt YXRjaFJ1bGVzKGRlZmF1bHRRdWlya3NTdHlsZS5nZXQoKSwgZmlyc3RVQVJ1bGUsIGxhc3RVQVJ1 bGUpOwogICAgICAgICAKICAgICAvLyBJZiB3ZSdyZSBpbiB2aWV3IHNvdXJjZSBtb2RlLCB0aGVu IHdlIG1hdGNoIHJ1bGVzIGZyb20gdGhlIHZpZXcgc291cmNlIHN0eWxlIHNoZWV0LgogICAgIGlm IChtX2NoZWNrZXIubV9kb2N1bWVudC0+ZnJhbWUoKSAmJiBtX2NoZWNrZXIubV9kb2N1bWVudC0+ ZnJhbWUoKS0+aW5WaWV3U291cmNlTW9kZSgpKSB7CiAgICAgICAgIGlmICghZGVmYXVsdFZpZXdT b3VyY2VTdHlsZSkKICAgICAgICAgICAgIGxvYWRWaWV3U291cmNlU3R5bGUoKTsKLSAgICAgICAg bWF0Y2hSdWxlcyhkZWZhdWx0Vmlld1NvdXJjZVN0eWxlLCBmaXJzdFVBUnVsZSwgbGFzdFVBUnVs ZSk7CisgICAgICAgIG1hdGNoUnVsZXMoZGVmYXVsdFZpZXdTb3VyY2VTdHlsZS5nZXQoKSwgZmly c3RVQVJ1bGUsIGxhc3RVQVJ1bGUpOwogICAgIH0KIH0KIApAQCAtMTA5NSw3ICsxMDk1LDcgQEAg UGFzc1JlZlB0cjxSZW5kZXJTdHlsZT4gQ1NTU3R5bGVTZWxlY3Rvcjo6c3R5bGVGb3JFbGVtZW50 KEVsZW1lbnQqIGUsIFJlbmRlclN0eWwKICAgICAgICAgfQogICAgICAgICBzX3N0eWxlTm90WWV0 QXZhaWxhYmxlLT5yZWYoKTsKICAgICAgICAgZS0+ZG9jdW1lbnQoKS0+c2V0SGFzTm9kZXNXaXRo UGxhY2Vob2xkZXJTdHlsZSgpOwotICAgICAgICByZXR1cm4gc19zdHlsZU5vdFlldEF2YWlsYWJs ZTsKKyAgICAgICAgcmV0dXJuIHNfc3R5bGVOb3RZZXRBdmFpbGFibGUuZ2V0KCk7CiAgICAgfQog CiAgICAgaW5pdEVsZW1lbnRBbmRQc2V1ZG9TdGF0ZShlKTsKQEAgLTExMTMsNyArMTExMyw3IEBA IFBhc3NSZWZQdHI8UmVuZGVyU3R5bGU+IENTU1N0eWxlU2VsZWN0b3I6OnN0eWxlRm9yRWxlbWVu dChFbGVtZW50KiBlLCBSZW5kZXJTdHlsCiAgICAgZWxzZQogICAgICAgICBtX3BhcmVudFN0eWxl ID0gc3R5bGUoKTsKIAotICAgIGlmIChzaW1wbGVEZWZhdWx0U3R5bGVTaGVldCAmJiAhZWxlbWVu dENhblVzZVNpbXBsZURlZmF1bHRTdHlsZShlKSkKKyAgICBpZiAoc2ltcGxlRGVmYXVsdFN0eWxl U2hlZXQuZ2V0KCkgJiYgIWVsZW1lbnRDYW5Vc2VTaW1wbGVEZWZhdWx0U3R5bGUoZSkpCiAgICAg ICAgIGxvYWRGdWxsRGVmYXVsdFN0eWxlKCk7CiAKICNpZiBFTkFCTEUoU1ZHKQpkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9jc3MvQ1NTU3R5bGVTZWxlY3Rvci5oIGIvV2ViQ29yZS9jc3MvQ1NTU3R5bGVT ZWxlY3Rvci5oCmluZGV4IDY2OGM2YzMuLmFjOWYwY2EgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvY3Nz L0NTU1N0eWxlU2VsZWN0b3IuaAorKysgYi9XZWJDb3JlL2Nzcy9DU1NTdHlsZVNlbGVjdG9yLmgK QEAgLTMxLDYgKzMxLDcgQEAKICNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgogI2luY2x1ZGUgPHd0 Zi9IYXNoU2V0Lmg+CiAjaW5jbHVkZSA8d3RmL1JlZlB0ci5oPgorI2luY2x1ZGUgPHd0Zi9TdGF0 aWNQdHIuaD4KICNpbmNsdWRlIDx3dGYvVmVjdG9yLmg+CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsK QEAgLTE4Niw3ICsxODcsNyBAQCBwdWJsaWM6CiAgICAgICAgIEtleWZyYW1lc1J1bGVNYXAgbV9r ZXlmcmFtZXNSdWxlTWFwOwogCiAgICAgcHVibGljOgotICAgICAgICBzdGF0aWMgUmVuZGVyU3R5 bGUqIHN0eWxlTm90WWV0QXZhaWxhYmxlKCkgeyByZXR1cm4gc19zdHlsZU5vdFlldEF2YWlsYWJs ZTsgfQorICAgICAgICBzdGF0aWMgUmVuZGVyU3R5bGUqIHN0eWxlTm90WWV0QXZhaWxhYmxlKCkg eyByZXR1cm4gc19zdHlsZU5vdFlldEF2YWlsYWJsZS5nZXQoKTsgfQogCiAgICAgICAgIGNsYXNz IFNlbGVjdG9yQ2hlY2tlciA6IHB1YmxpYyBOb25jb3B5YWJsZSB7CiAgICAgICAgIHB1YmxpYzoK QEAgLTIxMCw3ICsyMTEsNyBAQCBwdWJsaWM6CiAgICAgICAgIH07CiAKICAgICBwcml2YXRlOgot ICAgICAgICBzdGF0aWMgUmVuZGVyU3R5bGUqIHNfc3R5bGVOb3RZZXRBdmFpbGFibGU7CisgICAg ICAgIHN0YXRpYyBXVEY6OlN0YXRpY1B0cjxSZW5kZXJTdHlsZT4gc19zdHlsZU5vdFlldEF2YWls YWJsZTsKIAogICAgICAgICB2b2lkIGluaXQoKTsKIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9jc3Mv TWVkaWFGZWF0dXJlTmFtZXMuY3BwIGIvV2ViQ29yZS9jc3MvTWVkaWFGZWF0dXJlTmFtZXMuY3Bw CmluZGV4IGZjZWU1ZGUuLjRkZDBkNDIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvY3NzL01lZGlhRmVh dHVyZU5hbWVzLmNwcAorKysgYi9XZWJDb3JlL2Nzcy9NZWRpYUZlYXR1cmVOYW1lcy5jcHAKQEAg LTQ0LDcgKzQ0LDcgQEAgdm9pZCBpbml0KCkKICAgICAgICAvLyBVc2UgcGxhY2VtZW50IG5ldyB0 byBpbml0aWFsaXplIHRoZSBnbG9iYWxzLgogCiAgICAgICAgIEF0b21pY1N0cmluZzo6aW5pdCgp OwotICAgICAgICAjZGVmaW5lIElOSVRJQUxJWkVfR0xPQkFMKG5hbWUsIHN0cikgbmV3ICgodm9p ZCopJm5hbWUjI01lZGlhRmVhdHVyZSkgQXRvbWljU3RyaW5nKHN0cik7CisgICAgICAgICNkZWZp bmUgSU5JVElBTElaRV9HTE9CQUwobmFtZSwgc3RyKSBJTklUX0dMT0JBTChuYW1lIyNNZWRpYUZl YXR1cmUsIFdURjo6R2xvYmFsU3RhdGljUHRyPEF0b21pY1N0cmluZz4sIEF0b21pY1N0cmluZyhz dHIpKTsKICAgICAgICAgQ1NTX01FRElBUVVFUllfTkFNRVNfRk9SX0VBQ0hfTUVESUFGRUFUVVJF KElOSVRJQUxJWkVfR0xPQkFMKQogICAgICAgICAjdW5kZWYgSU5JVElBTElaRV9HTE9CQUwKICAg ICAgICAgaW5pdGlhbGl6ZWQgPSB0cnVlOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9jc3MvTWVkaWFR dWVyeUV2YWx1YXRvci5jcHAgYi9XZWJDb3JlL2Nzcy9NZWRpYVF1ZXJ5RXZhbHVhdG9yLmNwcApp bmRleCA0OTYzZWQ0Li5hOGU0NmVmIDEwMDY0NAotLS0gYS9XZWJDb3JlL2Nzcy9NZWRpYVF1ZXJ5 RXZhbHVhdG9yLmNwcAorKysgYi9XZWJDb3JlL2Nzcy9NZWRpYVF1ZXJ5RXZhbHVhdG9yLmNwcApA QCAtNDYsNiArNDYsNyBAQAogI2luY2x1ZGUgIlJlbmRlclN0eWxlLmgiCiAjaW5jbHVkZSAiUGxh dGZvcm1TY3JlZW4uaCIKICNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgorI2luY2x1ZGUgPHd0Zi9T dGF0aWNQdHIuaD4KIAogI2lmIEVOQUJMRSgzRF9SRU5ERVJJTkcpCiAjaW5jbHVkZSAiUmVuZGVy TGF5ZXJDb21wb3NpdG9yLmgiCkBAIC01OSw3ICs2MCw3IEBAIGVudW0gTWVkaWFGZWF0dXJlUHJl Zml4IHsgTWluUHJlZml4LCBNYXhQcmVmaXgsIE5vUHJlZml4IH07CiAKIHR5cGVkZWYgYm9vbCAo KkV2YWxGdW5jKShDU1NWYWx1ZSosIFJlbmRlclN0eWxlKiwgRnJhbWUqLCBNZWRpYUZlYXR1cmVQ cmVmaXgpOwogdHlwZWRlZiBIYXNoTWFwPEF0b21pY1N0cmluZ0ltcGwqLCBFdmFsRnVuYz4gRnVu Y3Rpb25NYXA7Ci1zdGF0aWMgRnVuY3Rpb25NYXAqIGdGdW5jdGlvbk1hcDsKK3N0YXRpYyBXVEY6 OlN0YXRpY1B0cjxGdW5jdGlvbk1hcD4gZ0Z1bmN0aW9uTWFwOwogCiAvKgogICogRklYTUU6IGZv bGxvd2luZyBtZWRpYSBmZWF0dXJlcyBhcmUgbm90IGltcGxlbWVudGVkOiBjb2xvcl9pbmRleCwg c2NhbiwgcmVzb2x1dGlvbgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9kb20vUXVhbGlmaWVkTmFtZS5j cHAgYi9XZWJDb3JlL2RvbS9RdWFsaWZpZWROYW1lLmNwcAppbmRleCA2MDdjODQ2Li45NmJlZDdm IDEwMDY0NAotLS0gYS9XZWJDb3JlL2RvbS9RdWFsaWZpZWROYW1lLmNwcAorKysgYi9XZWJDb3Jl L2RvbS9RdWFsaWZpZWROYW1lLmNwcApAQCAtMjksNiArMjksNyBAQAogI2luY2x1ZGUgIlN0YXRp Y0NvbnN0cnVjdG9ycy5oIgogI2luY2x1ZGUgPHd0Zi9Bc3NlcnRpb25zLmg+CiAjaW5jbHVkZSA8 d3RmL0hhc2hTZXQuaD4KKyNpbmNsdWRlIDx3dGYvU3RhdGljUHRyLmg+CiAKIG5hbWVzcGFjZSBX ZWJDb3JlIHsKIApAQCAtNDksMTIgKzUwLDI0IEBAIHN0cnVjdCBRTmFtZUNvbXBvbmVudHNUcmFu c2xhdG9yIHsKICAgICB9CiB9OwogCi1zdGF0aWMgUU5hbWVTZXQqIGdOYW1lQ2FjaGU7CitjbGFz cyBTdGF0aWNRTmFtZVNldCA6IHB1YmxpYyBXVEY6OlN0YXRpY1B0cjxRTmFtZVNldD4geworcHJp dmF0ZToKKyNpZiBFTkFCTEUoRlJFRV9TVEFUSUNfUFRSUykKKyAgICB2aXJ0dWFsIHZvaWQgZnJl ZSgpIHsKKyAgICAgICAgUU5hbWVTZXQ6Oml0ZXJhdG9yIGVuZCA9IGdldCgpLT5lbmQoKTsKKyAg ICAgICAgZm9yIChRTmFtZVNldDo6aXRlcmF0b3IgY3VyciA9IGdldCgpLT5iZWdpbigpOyBjdXJy ICE9IGVuZDsgKytjdXJyKQorICAgICAgICAgICAgZGVsZXRlICpjdXJyOworICAgICAgICBkZWxl dGUgZ2V0KCk7CisgICAgfQorI2VuZGlmCit9OworCitzdGF0aWMgU3RhdGljUU5hbWVTZXQgZ05h bWVDYWNoZTsKIAogUXVhbGlmaWVkTmFtZTo6UXVhbGlmaWVkTmFtZShjb25zdCBBdG9taWNTdHJp bmcmIHAsIGNvbnN0IEF0b21pY1N0cmluZyYgbCwgY29uc3QgQXRvbWljU3RyaW5nJiBuKQogewog ICAgIGlmICghZ05hbWVDYWNoZSkKLSAgICAgICAgZ05hbWVDYWNoZSA9IG5ldyBRTmFtZVNldDsK KyAgICAgICAgZ05hbWVDYWNoZS5zZXQobmV3IFFOYW1lU2V0KTsKICAgICBRdWFsaWZpZWROYW1l Q29tcG9uZW50cyBjb21wb25lbnRzID0geyBwLmltcGwoKSwgbC5pbXBsKCksIG4uaXNFbXB0eSgp ID8gbnVsbEF0b20uaW1wbCgpIDogbi5pbXBsKCkgfTsKICAgICBwYWlyPFFOYW1lU2V0OjppdGVy YXRvciwgYm9vbD4gYWRkUmVzdWx0ID0gZ05hbWVDYWNoZS0+YWRkPFF1YWxpZmllZE5hbWVDb21w b25lbnRzLCBRTmFtZUNvbXBvbmVudHNUcmFuc2xhdG9yPihjb21wb25lbnRzKTsKICAgICBtX2lt cGwgPSAqYWRkUmVzdWx0LmZpcnN0OyAgICAKQEAgLTkyLDcgKzEwNSw3IEBAIHZvaWQgUXVhbGlm aWVkTmFtZTo6aW5pdCgpCiAgICAgICAgIC8vIFVzZSBwbGFjZW1lbnQgbmV3IHRvIGluaXRpYWxp emUgdGhlIGdsb2JhbHMuCiAgICAgICAgIAogICAgICAgICBBdG9taWNTdHJpbmc6OmluaXQoKTsK LSAgICAgICAgbmV3ICgodm9pZCopJmFueU5hbWUpIFF1YWxpZmllZE5hbWUobnVsbEF0b20sIHN0 YXJBdG9tLCBzdGFyQXRvbSk7CisgICAgICAgIElOSVRfR0xPQkFMKGFueU5hbWUsIFdURjo6R2xv YmFsU3RhdGljUHRyPFF1YWxpZmllZE5hbWU+LCBRdWFsaWZpZWROYW1lKG51bGxBdG9tLCBzdGFy QXRvbSwgc3RhckF0b20pKTsKICAgICAgICAgaW5pdGlhbGl6ZWQgPSB0cnVlOwogICAgIH0KIH0K ZGlmZiAtLWdpdCBhL1dlYkNvcmUvZG9tL21ha2VfbmFtZXMucGwgYi9XZWJDb3JlL2RvbS9tYWtl X25hbWVzLnBsCmluZGV4IGU2ZDU5YTAuLmUwZWRhNTggMTAwNzU1Ci0tLSBhL1dlYkNvcmUvZG9t L21ha2VfbmFtZXMucGwKKysrIGIvV2ViQ29yZS9kb20vbWFrZV9uYW1lcy5wbApAQCAtNTUyLDcg KzU1Miw3IEBAIHByaW50IEYgIlxudm9pZCBpbml0KCkKICAgICBwcmludChGICIgICAgQXRvbWlj U3RyaW5nICR7bG93ZXJOYW1lc3BhY2V9TlMoXCIkcGFyYW1ldGVyc3snbmFtZXNwYWNlVVJJJ31c Iik7XG5cbiIpOwogCiAgICAgcHJpbnQoRiAiICAgIC8vIE5hbWVzcGFjZVxuIik7Ci0gICAgcHJp bnQoRiAiICAgIG5ldyAoKHZvaWQqKSYke2xvd2VyTmFtZXNwYWNlfU5hbWVzcGFjZVVSSSkgQXRv bWljU3RyaW5nKCR7bG93ZXJOYW1lc3BhY2V9TlMpO1xuXG4iKTsKKyAgICBwcmludChGICIgICAg SU5JVF9HTE9CQUwoJHtsb3dlck5hbWVzcGFjZX1OYW1lc3BhY2VVUkksIFdURjo6R2xvYmFsU3Rh dGljUHRyPEF0b21pY1N0cmluZz4sIEF0b21pY1N0cmluZygke2xvd2VyTmFtZXNwYWNlfU5TKSk7 XG5cbiIpOwogICAgIGlmIChrZXlzICV0YWdzKSB7CiAgICAgICAgIG15ICR0YWdzTmFtZXNwYWNl ID0gJHBhcmFtZXRlcnN7J3RhZ3NOdWxsTmFtZXNwYWNlJ30gPyAibnVsbEF0b20iIDogIiR7bG93 ZXJOYW1lc3BhY2V9TlMiOwogICAgICAgICBwcmludERlZmluaXRpb25zKCRGLCBcJXRhZ3MsICJ0 YWdzIiwgJHRhZ3NOYW1lc3BhY2UpOwpAQCAtNjM1LDcgKzYzNSw3IEBAIHN1YiBwcmludERlZmlu aXRpb25zCiAgICAgcHJpbnQgIlxuIjsKIAogICAgIGZvciBteSAkbmFtZSAoc29ydCBrZXlzICUk bmFtZXNSZWYpIHsKLSAgICAgICAgcHJpbnQgRiAiICAgIG5ldyAoKHZvaWQqKSYkbmFtZSIsIiR7 c2hvcnRDYW1lbFR5cGV9KSBRdWFsaWZpZWROYW1lKG51bGxBdG9tLCAkbmFtZSIsIiR7c2hvcnRD YW1lbFR5cGV9U3RyaW5nLCAkbmFtZXNwYWNlVVJJKTtcbiI7CisgICAgICAgIHByaW50IEYgIiAg ICBJTklUX0dMT0JBTCgkbmFtZSIsIiR7c2hvcnRDYW1lbFR5cGV9LCBXVEY6Okdsb2JhbFN0YXRp Y1B0cjxRdWFsaWZpZWROYW1lPiwgUXVhbGlmaWVkTmFtZShudWxsQXRvbSwgJG5hbWUiLCIke3No b3J0Q2FtZWxUeXBlfVN0cmluZywgJG5hbWVzcGFjZVVSSSkpO1xuIjsKICAgICB9CiB9CiAKZGlm ZiAtLWdpdCBhL1dlYkNvcmUvaW5zcGVjdG9yL0phdmFTY3JpcHREZWJ1Z1NlcnZlci5oIGIvV2Vi Q29yZS9pbnNwZWN0b3IvSmF2YVNjcmlwdERlYnVnU2VydmVyLmgKaW5kZXggYmFhNjY5OS4uNTIw YjQ4MyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9pbnNwZWN0b3IvSmF2YVNjcmlwdERlYnVnU2VydmVy LmgKKysrIGIvV2ViQ29yZS9pbnNwZWN0b3IvSmF2YVNjcmlwdERlYnVnU2VydmVyLmgKQEAgLTg1 LDkgKzg1LDEwIEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgdHlwZWRlZiBIYXNoU2V0 PEphdmFTY3JpcHREZWJ1Z0xpc3RlbmVyKj4gTGlzdGVuZXJTZXQ7CiAgICAgICAgIHR5cGVkZWYg dm9pZCAoSmF2YVNjcmlwdERlYnVnTGlzdGVuZXI6OipKYXZhU2NyaXB0RXhlY3V0aW9uQ2FsbGJh Y2spKCk7CiAKKyAgICAgICAgfkphdmFTY3JpcHREZWJ1Z1NlcnZlcigpOworCiAgICAgcHJpdmF0 ZToKICAgICAgICAgSmF2YVNjcmlwdERlYnVnU2VydmVyKCk7Ci0gICAgICAgIH5KYXZhU2NyaXB0 RGVidWdTZXJ2ZXIoKTsKIAogICAgICAgICBib29sIGhhc0xpc3RlbmVycygpIGNvbnN0IHsgcmV0 dXJuICFtX2xpc3RlbmVycy5pc0VtcHR5KCkgfHwgIW1fcGFnZUxpc3RlbmVyc01hcC5pc0VtcHR5 KCk7IH0KICAgICAgICAgYm9vbCBoYXNHbG9iYWxMaXN0ZW5lcnMoKSBjb25zdCB7IHJldHVybiAh bV9saXN0ZW5lcnMuaXNFbXB0eSgpOyB9CmRpZmYgLS1naXQgYS9XZWJDb3JlL2xvYWRlci9JbWFn ZUxvYWRlci5jcHAgYi9XZWJDb3JlL2xvYWRlci9JbWFnZUxvYWRlci5jcHAKaW5kZXggYjE4M2E2 Ni4uMmQ2ZWFmZiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9sb2FkZXIvSW1hZ2VMb2FkZXIuY3BwCisr KyBiL1dlYkNvcmUvbG9hZGVyL0ltYWdlTG9hZGVyLmNwcApAQCAtNDEsNyArNDEsNiBAQCBwdWJs aWM6CiAgICAgdm9pZCBkaXNwYXRjaFBlbmRpbmdMb2FkRXZlbnRzKCk7CiAKIHByaXZhdGU6Ci0g ICAgfkltYWdlTG9hZEV2ZW50U2VuZGVyKCk7CiAKICAgICB2b2lkIHRpbWVyRmlyZWQoVGltZXI8 SW1hZ2VMb2FkRXZlbnRTZW5kZXI+Kik7CiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0v U3RhdGljQ29uc3RydWN0b3JzLmggYi9XZWJDb3JlL3BsYXRmb3JtL1N0YXRpY0NvbnN0cnVjdG9y cy5oCmluZGV4IDI2YjQ0ZGUuLjk4NWZhYzggMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0v U3RhdGljQ29uc3RydWN0b3JzLmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9TdGF0aWNDb25zdHJ1 Y3RvcnMuaApAQCAtMjMsNiArMjMsOCBAQAogI2lmbmRlZiBTdGF0aWNDb25zdHJ1Y3RvcnNfaAog I2RlZmluZSBTdGF0aWNDb25zdHJ1Y3RvcnNfaAogCisjaW5jbHVkZSAid3RmL1N0YXRpY1B0ci5o IgorCiAvLyBGb3IgV2ViQ29yZSB3ZSBuZWVkIHRvIGF2b2lkIGhhdmluZyBzdGF0aWMgY29uc3Ry dWN0b3JzLiBXZSBhY2hpZXZlIHRoaXMKIC8vIHdpdGggdHdvIHNlcGFyYXRlIG1ldGhvZHMgZm9y IEdDQyBhbmQgTVNWQy4gQm90aCBtZXRob2RzIHByZXZlbnQgdGhlIHN0YXRpYwogLy8gaW5pdGlh bGl6ZXJzIGZyb20gYmVpbmcgcmVnaXN0ZXJlZCBhbmQgY2FsbGVkIG9uIHByb2dyYW0gc3RhcnR1 cC4gT24gR0NDLCB3ZQpAQCAtNzMsNCArNzUsMTMgQEAKICNlbmRpZgogI2VuZGlmCiAKKyNpZiBF TkFCTEUoRlJFRV9TVEFUSUNfUFRSUykKKyNkZWZpbmUgSU5JVF9HTE9CQUwobmFtZSwgdHlwZSwg YXJndW1lbnRzKSBcCisgICAgbmV3ICgodm9pZCopJm5hbWUpIGFyZ3VtZW50czsgXAorICAgIHN0 YXRpYyB0eXBlIG5hbWUjI1JlZigodm9pZCopJm5hbWUpCisjZWxzZQorI2RlZmluZSBJTklUX0dM T0JBTChuYW1lLCB0eXBlLCBhcmd1bWVudHMpIFwKKyAgICBuZXcgKCh2b2lkKikmbmFtZSkgYXJn dW1lbnRzCisjZW5kaWYKKwogI2VuZGlmIC8vIFN0YXRpY0NvbnN0cnVjdG9yc19oCmRpZmYgLS1n aXQgYS9XZWJDb3JlL3BsYXRmb3JtL1RocmVhZEdsb2JhbERhdGEuY3BwIGIvV2ViQ29yZS9wbGF0 Zm9ybS9UaHJlYWRHbG9iYWxEYXRhLmNwcAppbmRleCBhNDNlOWJkLi5hZDc2NjkzIDEwMDY0NAot LS0gYS9XZWJDb3JlL3BsYXRmb3JtL1RocmVhZEdsb2JhbERhdGEuY3BwCisrKyBiL1dlYkNvcmUv cGxhdGZvcm0vVGhyZWFkR2xvYmFsRGF0YS5jcHAKQEAgLTMwLDYgKzMwLDcgQEAKICNpbmNsdWRl ICJFdmVudE5hbWVzLmgiCiAjaW5jbHVkZSAiU3RyaW5nSW1wbC5oIgogI2luY2x1ZGUgIlRocmVh ZFRpbWVycy5oIgorI2luY2x1ZGUgPHd0Zi9TdGF0aWNQdHIuaD4KICNpbmNsdWRlIDx3dGYvVW51 c2VkUGFyYW0uaD4KIAogI2lmIFVTRShJQ1VfVU5JQ09ERSkgfHwgVVNFKEdMSUJfSUNVX1VOSUNP REVfSFlCUklEKQpAQCAtNTQsMTQgKzU1LDE0IEBAIFRocmVhZEdsb2JhbERhdGEmIHRocmVhZEds b2JhbERhdGEoKQogICAgIC8vIFdlIG5lZWQgdG8gY2hlY2sgZm9yIGUuZy4gZGF0YWJhc2Ugb2Jq ZWN0cyBtYW5pcHVsYXRpbmcgc3RyaW5ncyBvbiBzZWNvbmRhcnkgdGhyZWFkcy4KICNpZiBFTkFC TEUoV09SS0VSUykKICAgICAvLyBUaHJlYWRHbG9iYWxEYXRhIGlzIHVzZWQgb24gbWFpbiB0aHJl YWQgYmVmb3JlIGl0IGNvdWxkIHBvc3NpYmx5IGJlIHVzZWQgb24gc2Vjb25kYXJ5IG9uZXMsIHNv IHRoZXJlIGlzIG5vIG5lZWQgZm9yIHN5bmNocm9uaXphdGlvbiBoZXJlLgotICAgIHN0YXRpYyBU aHJlYWRTcGVjaWZpYzxUaHJlYWRHbG9iYWxEYXRhPiogdGhyZWFkR2xvYmFsRGF0YSA9IG5ldyBU aHJlYWRTcGVjaWZpYzxUaHJlYWRHbG9iYWxEYXRhPjsKKyAgICBzdGF0aWMgV1RGOjpTdGF0aWNQ dHI8IFRocmVhZFNwZWNpZmljPFRocmVhZEdsb2JhbERhdGE+ID4gdGhyZWFkR2xvYmFsRGF0YSA9 IG5ldyBUaHJlYWRTcGVjaWZpYzxUaHJlYWRHbG9iYWxEYXRhPjsKICAgICByZXR1cm4gKip0aHJl YWRHbG9iYWxEYXRhOwogI2Vsc2UKLSAgICBzdGF0aWMgVGhyZWFkR2xvYmFsRGF0YSogc3RhdGlj RGF0YTsKKyAgICBzdGF0aWMgV1RGOjpTdGF0aWNQdHI8VGhyZWFkR2xvYmFsRGF0YT4gc3RhdGlj RGF0YTsKICAgICBpZiAoIXN0YXRpY0RhdGEpIHsKICAgICAgICAgc3RhdGljRGF0YSA9IHN0YXRp Y19jYXN0PFRocmVhZEdsb2JhbERhdGEqPihmYXN0TWFsbG9jKHNpemVvZihUaHJlYWRHbG9iYWxE YXRhKSkpOwogICAgICAgICAvLyBUaHJlYWRHbG9iYWxEYXRhIGNvbnN0cnVjdG9yIGluZGlyZWN0 bHkgdXNlcyBzdGF0aWNEYXRhLCBzbyB3ZSBuZWVkIHRvIHNldCB1cCB0aGUgbWVtb3J5IGJlZm9y ZSBpbnZva2luZyBpdC4KLSAgICAgICAgbmV3IChzdGF0aWNEYXRhKSBUaHJlYWRHbG9iYWxEYXRh OworICAgICAgICBuZXcgKHN0YXRpY0RhdGEuZ2V0KCkpIFRocmVhZEdsb2JhbERhdGE7CiAgICAg fQogICAgIHJldHVybiAqc3RhdGljRGF0YTsKICNlbmRpZgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9w bGF0Zm9ybS9UaHJlYWRUaW1lcnMuY3BwIGIvV2ViQ29yZS9wbGF0Zm9ybS9UaHJlYWRUaW1lcnMu Y3BwCmluZGV4IDcxYTA2YjAuLjYwYjU5NTEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0v VGhyZWFkVGltZXJzLmNwcAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL1RocmVhZFRpbWVycy5jcHAK QEAgLTMxLDYgKzMxLDcgQEAKICNpbmNsdWRlICJUaHJlYWRHbG9iYWxEYXRhLmgiCiAjaW5jbHVk ZSAiVGltZXIuaCIKICNpbmNsdWRlIDx3dGYvQ3VycmVudFRpbWUuaD4KKyNpbmNsdWRlIDx3dGYv U3RhdGljUHRyLmg+CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIApAQCAtMzksOCArNDAsOCBAQCBu YW1lc3BhY2UgV2ViQ29yZSB7CiAKIHN0YXRpYyBNYWluVGhyZWFkU2hhcmVkVGltZXIqIG1haW5U aHJlYWRTaGFyZWRUaW1lcigpCiB7Ci0gICAgc3RhdGljIE1haW5UaHJlYWRTaGFyZWRUaW1lciog dGltZXIgPSBuZXcgTWFpblRocmVhZFNoYXJlZFRpbWVyOwotICAgIHJldHVybiB0aW1lcjsKKyAg ICBzdGF0aWMgV1RGOjpTdGF0aWNQdHI8TWFpblRocmVhZFNoYXJlZFRpbWVyPiB0aW1lciA9IG5l dyBNYWluVGhyZWFkU2hhcmVkVGltZXI7CisgICAgcmV0dXJuIHRpbWVyLmdldCgpOwogfQogCiBU aHJlYWRUaW1lcnM6OlRocmVhZFRpbWVycygpCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL0ZvbnRDYWNoZS5oIGIvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9Gb250Q2Fj aGUuaAppbmRleCAzYzBmMmQ5Li44ODIwMDQ1IDEwMDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL0ZvbnRDYWNoZS5oCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvRm9u dENhY2hlLmgKQEAgLTg1LDcgKzg1LDYgQEAgcHVibGljOgogCiBwcml2YXRlOgogICAgIEZvbnRD YWNoZSgpOwotICAgIH5Gb250Q2FjaGUoKTsKIAogICAgIC8vIFRoZXNlIG1ldGhvZHMgYXJlIGlt cGxlbWVudGVkIGJ5IGVhY2ggcGxhdGZvcm0uCiAgICAgRm9udFBsYXRmb3JtRGF0YSogZ2V0U2lt aWxhckZvbnRQbGF0Zm9ybURhdGEoY29uc3QgRm9udCYpOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9w bGF0Zm9ybS9xdC9TaGFyZWRUaW1lclF0LmNwcCBiL1dlYkNvcmUvcGxhdGZvcm0vcXQvU2hhcmVk VGltZXJRdC5jcHAKaW5kZXggZTliY2FlZS4uODg0MTJhNyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9w bGF0Zm9ybS9xdC9TaGFyZWRUaW1lclF0LmNwcAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL3F0L1No YXJlZFRpbWVyUXQuY3BwCkBAIC02NCw4ICs2NCwxMCBAQCBTaGFyZWRUaW1lclF0OjpTaGFyZWRU aW1lclF0KFFPYmplY3QqIHBhcmVudCkKIAogU2hhcmVkVGltZXJRdDo6flNoYXJlZFRpbWVyUXQo KQogeworI2lmICFFTkFCTEUoRlJFRV9TVEFUSUNfUFRSUykKICAgICBpZiAobV90aW1lci5pc0Fj dGl2ZSgpKQogICAgICAgICAobV90aW1lckZ1bmN0aW9uKSgpOworI2VuZGlmCiB9CiAKIFNoYXJl ZFRpbWVyUXQqIFNoYXJlZFRpbWVyUXQ6Omluc3QoKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0 Zm9ybS90ZXh0L0F0b21pY1N0cmluZy5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL3RleHQvQXRvbWlj U3RyaW5nLmNwcAppbmRleCA0MDk0MzllLi44YmRjZmEwIDEwMDY0NAotLS0gYS9XZWJDb3JlL3Bs YXRmb3JtL3RleHQvQXRvbWljU3RyaW5nLmNwcAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL3RleHQv QXRvbWljU3RyaW5nLmNwcApAQCAtMjk1LDExICsyOTUsMTEgQEAgdm9pZCBBdG9taWNTdHJpbmc6 OmluaXQoKQogICAgICAgICBBU1NFUlQoaXNNYWluVGhyZWFkKCkpOwogCiAgICAgICAgIC8vIFVz ZSBwbGFjZW1lbnQgbmV3IHRvIGluaXRpYWxpemUgdGhlIGdsb2JhbHMuCi0gICAgICAgIG5ldyAo KHZvaWQqKSZudWxsQXRvbSkgQXRvbWljU3RyaW5nOwotICAgICAgICBuZXcgKCh2b2lkKikmZW1w dHlBdG9tKSBBdG9taWNTdHJpbmcoIiIpOwotICAgICAgICBuZXcgKCh2b2lkKikmdGV4dEF0b20p IEF0b21pY1N0cmluZygiI3RleHQiKTsKLSAgICAgICAgbmV3ICgodm9pZCopJmNvbW1lbnRBdG9t KSBBdG9taWNTdHJpbmcoIiNjb21tZW50Iik7Ci0gICAgICAgIG5ldyAoKHZvaWQqKSZzdGFyQXRv bSkgQXRvbWljU3RyaW5nKCIqIik7CisgICAgICAgIElOSVRfR0xPQkFMKG51bGxBdG9tLCBXVEY6 Okdsb2JhbFN0YXRpY1B0cjxBdG9taWNTdHJpbmc+LCBBdG9taWNTdHJpbmcpOworICAgICAgICBJ TklUX0dMT0JBTChlbXB0eUF0b20sIFdURjo6R2xvYmFsU3RhdGljUHRyPEF0b21pY1N0cmluZz4s IEF0b21pY1N0cmluZygiIikpOworICAgICAgICBJTklUX0dMT0JBTCh0ZXh0QXRvbSwgV1RGOjpH bG9iYWxTdGF0aWNQdHI8QXRvbWljU3RyaW5nPiwgQXRvbWljU3RyaW5nKCIjdGV4dCIpKTsKKyAg ICAgICAgSU5JVF9HTE9CQUwoY29tbWVudEF0b20sIFdURjo6R2xvYmFsU3RhdGljUHRyPEF0b21p Y1N0cmluZz4sIEF0b21pY1N0cmluZygiI2NvbW1lbnQiKSk7CisgICAgICAgIElOSVRfR0xPQkFM KHN0YXJBdG9tLCBXVEY6Okdsb2JhbFN0YXRpY1B0cjxBdG9taWNTdHJpbmc+LCBBdG9taWNTdHJp bmcoIioiKSk7CiAKICAgICAgICAgaW5pdGlhbGl6ZWQgPSB0cnVlOwogICAgIH0KZGlmZiAtLWdp dCBhL1dlYkNvcmUvcGx1Z2lucy9QbHVnaW5EYXRhYmFzZS5jcHAgYi9XZWJDb3JlL3BsdWdpbnMv UGx1Z2luRGF0YWJhc2UuY3BwCmluZGV4IDI5OTA4MzYuLmFiMDliNDQgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvcGx1Z2lucy9QbHVnaW5EYXRhYmFzZS5jcHAKKysrIGIvV2ViQ29yZS9wbHVnaW5zL1Bs dWdpbkRhdGFiYXNlLmNwcApAQCAtMzEsNiArMzEsNyBAQAogI2luY2x1ZGUgIktVUkwuaCIKICNp bmNsdWRlICJQbHVnaW5QYWNrYWdlLmgiCiAjaW5jbHVkZSA8c3RkbGliLmg+CisjaW5jbHVkZSA8 d3RmL1N0YXRpY1B0ci5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKQEAgLTM4LDcgKzM5LDcg QEAgdHlwZWRlZiBIYXNoTWFwPFN0cmluZywgUmVmUHRyPFBsdWdpblBhY2thZ2U+ID4gUGx1Z2lu UGFja2FnZUJ5TmFtZU1hcDsKIAogUGx1Z2luRGF0YWJhc2UqIFBsdWdpbkRhdGFiYXNlOjppbnN0 YWxsZWRQbHVnaW5zKGJvb2wgcG9wdWxhdGUpCiB7Ci0gICAgc3RhdGljIFBsdWdpbkRhdGFiYXNl KiBwbHVnaW5zID0gMDsKKyAgICBzdGF0aWMgV1RGOjpTdGF0aWNQdHI8UGx1Z2luRGF0YWJhc2U+ IHBsdWdpbnMgPSAwOwogCiAgICAgaWYgKCFwbHVnaW5zKSB7CiAgICAgICAgIHBsdWdpbnMgPSBu ZXcgUGx1Z2luRGF0YWJhc2U7CkBAIC00OSw3ICs1MCw3IEBAIFBsdWdpbkRhdGFiYXNlKiBQbHVn aW5EYXRhYmFzZTo6aW5zdGFsbGVkUGx1Z2lucyhib29sIHBvcHVsYXRlKQogICAgICAgICB9CiAg ICAgfQogCi0gICAgcmV0dXJuIHBsdWdpbnM7CisgICAgcmV0dXJuIHBsdWdpbnMuZ2V0KCk7CiB9 CiAKIGJvb2wgUGx1Z2luRGF0YWJhc2U6OmlzTUlNRVR5cGVSZWdpc3RlcmVkKGNvbnN0IFN0cmlu ZyYgbWltZVR5cGUpCmRpZmYgLS1naXQgYS9XZWJDb3JlL3JlbmRlcmluZy9zdHlsZS9SZW5kZXJT dHlsZS5jcHAgYi9XZWJDb3JlL3JlbmRlcmluZy9zdHlsZS9SZW5kZXJTdHlsZS5jcHAKaW5kZXgg MGUyNThjOC4uM2MxZGY0ZCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9yZW5kZXJpbmcvc3R5bGUvUmVu ZGVyU3R5bGUuY3BwCisrKyBiL1dlYkNvcmUvcmVuZGVyaW5nL3N0eWxlL1JlbmRlclN0eWxlLmNw cApAQCAtMjksNiArMjksNyBAQAogI2luY2x1ZGUgIlJlbmRlckFyZW5hLmgiCiAjaW5jbHVkZSAi UmVuZGVyT2JqZWN0LmgiCiAjaW5jbHVkZSAiU3R5bGVJbWFnZS5oIgorI2luY2x1ZGUgPHd0Zi9T dGF0aWNQdHIuaD4KICNpbmNsdWRlIDx3dGYvU3RkTGliRXh0cmFzLmg+CiAjaW5jbHVkZSA8YWxn b3JpdGhtPgogCkBAIC0zOCw4ICszOSw4IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogaW5saW5l IFJlbmRlclN0eWxlKiBkZWZhdWx0U3R5bGUoKQogewotICAgIHN0YXRpYyBSZW5kZXJTdHlsZSog c19kZWZhdWx0U3R5bGUgPSBSZW5kZXJTdHlsZTo6Y3JlYXRlRGVmYXVsdFN0eWxlKCkucmVsZWFz ZVJlZigpOwotICAgIHJldHVybiBzX2RlZmF1bHRTdHlsZTsKKyAgICBzdGF0aWMgV1RGOjpTdGF0 aWNQdHI8UmVuZGVyU3R5bGU+IHNfZGVmYXVsdFN0eWxlKFJlbmRlclN0eWxlOjpjcmVhdGVEZWZh dWx0U3R5bGUoKS5yZWxlYXNlUmVmKCkpOworICAgIHJldHVybiBzX2RlZmF1bHRTdHlsZS5nZXQo KTsKIH0KIAogUGFzc1JlZlB0cjxSZW5kZXJTdHlsZT4gUmVuZGVyU3R5bGU6OmNyZWF0ZSgpCmRp ZmYgLS1naXQgYS9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5jcHAgYi9XZWJLaXQvcXQvQXBpL3F3 ZWJmcmFtZS5jcHAKaW5kZXggYzg1N2RmMi4uYmUwYTM0OCAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0 L0FwaS9xd2ViZnJhbWUuY3BwCisrKyBiL1dlYktpdC9xdC9BcGkvcXdlYmZyYW1lLmNwcApAQCAt NzgsNiArNzgsMTAgQEAKICNpbmNsdWRlIDxxcHJpbnRlci5oPgogI2luY2x1ZGUgPHFyZWdpb24u aD4KIAorI2lmIEVOQUJMRShGUkVFX1NUQVRJQ19QVFJTKQorI2luY2x1ZGUgInd0Zi9TdGF0aWNQ dHIuaCIKKyNlbmRpZgorCiAjaWYgUVRfVkVSU0lPTiA8IDB4MDQwNDAwCiAjaW5jbHVkZSAicXdl Ym5ldHdvcmtpbnRlcmZhY2UuaCIKICNlbmRpZgpAQCAtMTg1LDYgKzE4OSwxMyBAQCB2b2lkIFFX RUJLSVRfRVhQT1JUIHF0X2RydF9nYXJiYWdlQ29sbGVjdG9yX2NvbGxlY3RPbkFsdGVybmF0ZVRo cmVhZChib29sIHdhaXRVbgogICAgIGdjQ29udHJvbGxlcigpLmdhcmJhZ2VDb2xsZWN0T25BbHRl cm5hdGVUaHJlYWRGb3JEZWJ1Z2dpbmcod2FpdFVudGlsRG9uZSk7CiB9CiAKKyNpZiBFTkFCTEUo RlJFRV9TVEFUSUNfUFRSUykKK3ZvaWQgUVdFQktJVF9FWFBPUlQgcXRfZHJ0X2ZyZWVTdGF0aWNQ dHJzKCkKK3sKKyAgICBXVEY6OlN0YXRpY1B0ckJhc2U6OmZyZWVTdGF0aWNQdHJzKCk7Cit9Cisj ZW5kaWYKKwogUVdlYkZyYW1lRGF0YTo6UVdlYkZyYW1lRGF0YShXZWJDb3JlOjpQYWdlKiBwYXJl bnRQYWdlLCBXZWJDb3JlOjpGcmFtZSogcGFyZW50RnJhbWUsCiAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIFdlYkNvcmU6OkhUTUxGcmFtZU93bmVyRWxlbWVudCogb3duZXJGcmFtZUVsZW1l bnQsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IFdlYkNvcmU6OlN0cmluZyYg ZnJhbWVOYW1lKQpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L1F0TGF1bmNoZXIvbWFpbi5jcHAgYi9X ZWJLaXQvcXQvUXRMYXVuY2hlci9tYWluLmNwcAppbmRleCA5Y2JhYjUzLi5mN2UzYjBmIDEwMDY0 NAotLS0gYS9XZWJLaXQvcXQvUXRMYXVuY2hlci9tYWluLmNwcAorKysgYi9XZWJLaXQvcXQvUXRM YXVuY2hlci9tYWluLmNwcApAQCAtNTMsNiArNTMsNyBAQAogCiAjaWZuZGVmIE5ERUJVRwogdm9p ZCBRV0VCS0lUX0VYUE9SVCBxdF9kcnRfZ2FyYmFnZUNvbGxlY3Rvcl9jb2xsZWN0KCk7Cit2b2lk IFFXRUJLSVRfRVhQT1JUIHF0X2RydF9mcmVlU3RhdGljUHRycygpOwogI2VuZGlmCiAKIGNsYXNz IFdlYlBhZ2UgOiBwdWJsaWMgUVdlYlBhZ2UKQEAgLTI4NSw3ICsyODYsNyBAQCBwcml2YXRlOgog ICAgICAgICB2aWV3TWVudS0+YWRkU2VwYXJhdG9yKCk7CiAgICAgICAgIHZpZXdNZW51LT5hZGRB Y3Rpb24oIkR1bXAgSFRNTCIsIHRoaXMsIFNMT1QoZHVtcEh0bWwoKSkpOwogCi0gICAgICAgIFFN ZW51ICpmb3JtYXRNZW51ID0gbmV3IFFNZW51KCJGJm9ybWF0Iik7CisgICAgICAgIFFNZW51ICpm b3JtYXRNZW51ID0gbmV3IFFNZW51KCJGJm9ybWF0IiwgdGhpcyk7CiAgICAgICAgIGZvcm1hdE1l bnVBY3Rpb24gPSBtZW51QmFyKCktPmFkZE1lbnUoZm9ybWF0TWVudSk7CiAgICAgICAgIGZvcm1h dE1lbnVBY3Rpb24tPnNldFZpc2libGUoZmFsc2UpOwogICAgICAgICBmb3JtYXRNZW51LT5hZGRB Y3Rpb24odmlldy0+cGFnZUFjdGlvbihRV2ViUGFnZTo6VG9nZ2xlQm9sZCkpOwpAQCAtNDIwLDYg KzQyMSw3IEBAIGludCBsYXVuY2hlck1haW4oY29uc3QgUUFwcGxpY2F0aW9uJiBhcHApCiAgICAg aW50IHJldFZhbCA9IGFwcC5leGVjKCk7CiAgICAgcXRfZHJ0X2dhcmJhZ2VDb2xsZWN0b3JfY29s bGVjdCgpOwogICAgIFFXZWJTZXR0aW5nczo6Y2xlYXJNZW1vcnlDYWNoZXMoKTsKKyAgICBxdF9k cnRfZnJlZVN0YXRpY1B0cnMoKTsKICAgICByZXR1cm4gcmV0VmFsOwogI2Vsc2UKICAgICByZXR1 cm4gYXBwLmV4ZWMoKTsKLS0gCjEuNi4wLjQKCg== 38848 2009-09-01 01:22:07 -0700 2009-09-10 02:07:35 -0700 Fifth patch StaticPtrs-draft-0.5.patch text/plain 49069 zherczeg RnJvbSA3MWY3NzI2MzAwMWU0MjkxZTlkMjBhZGQ2NzdmZjU0MjRhNmM3ZmFlIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBab2x0YW4gSGVyY3plZyA8emhlcmN6ZWdAaW5mLnUtc3plZ2Vk Lmh1PgpEYXRlOiBUdWUsIDEgU2VwIDIwMDkgMTA6MDM6MjIgKzAyMDAKU3ViamVjdDogW1BBVENI XSBTdGF0aWMgUHRyIGRyYWZ0CgpTaWduZWQtb2ZmLWJ5OiBab2x0YW4gSGVyY3plZyA8emhlcmN6 ZWdAaW5mLnUtc3plZ2VkLmh1PgotLS0KIEphdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLnBy aSAgICAgICAgIHwgICAgMSArCiBKYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTR2xvYmFsRGF0YS5j cHAgICB8ICAgMjMgKystLS0KIEphdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNHbG9iYWxEYXRhLmgg ICAgIHwgICAgMSAtCiBKYXZhU2NyaXB0Q29yZS9ydW50aW1lL1VTdHJpbmcuY3BwICAgICAgICB8 ICAgIDYgKy0KIEphdmFTY3JpcHRDb3JlL3J1bnRpbWUvVVN0cmluZy5oICAgICAgICAgIHwgICAg NyArLQogSmF2YVNjcmlwdENvcmUvd3RmL0dsb2JhbFB0ci5oICAgICAgICAgICAgfCAgMTU0ICsr KysrKysrKysrKysrKysrKysrKysrKysrKysrCiBKYXZhU2NyaXB0Q29yZS93dGYvTG9jYWxTdGF0 aWNBcnJheVB0ci5oICB8ICAgODcgKysrKysrKysrKysrKysrKwogSmF2YVNjcmlwdENvcmUvd3Rm L0xvY2FsU3RhdGljUHRyLmggICAgICAgfCAgMTE4ICsrKysrKysrKysrKysrKysrKysrKysKIEph dmFTY3JpcHRDb3JlL3d0Zi9QbGF0Zm9ybS5oICAgICAgICAgICAgIHwgICAgMiArCiBKYXZhU2Ny aXB0Q29yZS93dGYvU3RhdGljUHRyQmFzZS5jcHAgICAgICB8ICAgNzAgKysrKysrKysrKysrKwog SmF2YVNjcmlwdENvcmUvd3RmL1N0YXRpY1B0ckJhc2UuaCAgICAgICAgfCAgIDYyICsrKysrKysr KysrKwogSmF2YVNjcmlwdENvcmUvd3RmL1N0ZExpYkV4dHJhcy5oICAgICAgICAgfCAgICA3ICst CiBKYXZhU2NyaXB0Q29yZS93dGYvVGhyZWFkU3BlY2lmaWMuaCAgICAgICB8ICAgIDIgKwogV2Vi Q29yZS9XZWJDb3JlLnBybyAgICAgICAgICAgICAgICAgICAgICAgfCAgICAyICstCiBXZWJDb3Jl L2JpbmRpbmdzL2pzL0pTRE9NV2luZG93QmFzZS5jcHAgICB8ICAgMTggKysrLQogV2ViQ29yZS9i cmlkZ2UvSWRlbnRpZmllclJlcC5jcHAgICAgICAgICAgfCAgICA1ICstCiBXZWJDb3JlL2JyaWRn ZS9JZGVudGlmaWVyUmVwLmggICAgICAgICAgICB8ICAgIDIgKwogV2ViQ29yZS9jc3MvQ1NTUHJp bWl0aXZlVmFsdWUuY3BwICAgICAgICAgfCAgIDEwICstCiBXZWJDb3JlL2Nzcy9DU1NTdHlsZVNl bGVjdG9yLmNwcCAgICAgICAgICB8ICAgMzAgKysrLS0tCiBXZWJDb3JlL2Nzcy9DU1NTdHlsZVNl bGVjdG9yLmggICAgICAgICAgICB8ICAgIDUgKy0KIFdlYkNvcmUvY3NzL01lZGlhRmVhdHVyZU5h bWVzLmNwcCAgICAgICAgIHwgICAgMiArLQogV2ViQ29yZS9jc3MvTWVkaWFRdWVyeUV2YWx1YXRv ci5jcHAgICAgICAgfCAgICAzICstCiBXZWJDb3JlL2RvbS9RdWFsaWZpZWROYW1lLmNwcCAgICAg ICAgICAgICB8ICAgMjQgKysrKy0KIFdlYkNvcmUvZG9tL21ha2VfbmFtZXMucGwgICAgICAgICAg ICAgICAgIHwgICAgNCArLQogV2ViQ29yZS9pbnNwZWN0b3IvSmF2YVNjcmlwdERlYnVnU2VydmVy LmggfCAgICAzICstCiBXZWJDb3JlL2xvYWRlci9JbWFnZUxvYWRlci5jcHAgICAgICAgICAgICB8 ICAgIDEgLQogV2ViQ29yZS9wbGF0Zm9ybS9TdGF0aWNDb25zdHJ1Y3RvcnMuaCAgICAgfCAgIDEy ICsrKwogV2ViQ29yZS9wbGF0Zm9ybS9UaHJlYWRHbG9iYWxEYXRhLmNwcCAgICAgfCAgICA3ICst CiBXZWJDb3JlL3BsYXRmb3JtL1RocmVhZFRpbWVycy5jcHAgICAgICAgICB8ICAgIDUgKy0KIFdl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvRm9udENhY2hlLmggICAgIHwgICAgMSAtCiBXZWJDb3Jl L3BsYXRmb3JtL3F0L1NoYXJlZFRpbWVyUXQuY3BwICAgICB8ICAgIDIgKwogV2ViQ29yZS9wbGF0 Zm9ybS90ZXh0L0F0b21pY1N0cmluZy5jcHAgICAgfCAgIDEwICstCiBXZWJDb3JlL3BsdWdpbnMv UGx1Z2luRGF0YWJhc2UuY3BwICAgICAgICB8ICAgIDUgKy0KIFdlYkNvcmUvcmVuZGVyaW5nL3N0 eWxlL1JlbmRlclN0eWxlLmNwcCAgIHwgICAgNSArLQogV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUu Y3BwICAgICAgICAgICAgICAgfCAgIDEyICsrKwogV2ViS2l0L3F0L1F0TGF1bmNoZXIvbWFpbi5j cHAgICAgICAgICAgICAgfCAgICA0ICstCiAzNiBmaWxlcyBjaGFuZ2VkLCA2MzggaW5zZXJ0aW9u cygrKSwgNzQgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgSmF2YVNjcmlwdENvcmUv d3RmL0dsb2JhbFB0ci5oCiBjcmVhdGUgbW9kZSAxMDA2NDQgSmF2YVNjcmlwdENvcmUvd3RmL0xv Y2FsU3RhdGljQXJyYXlQdHIuaAogY3JlYXRlIG1vZGUgMTAwNjQ0IEphdmFTY3JpcHRDb3JlL3d0 Zi9Mb2NhbFN0YXRpY1B0ci5oCiBjcmVhdGUgbW9kZSAxMDA2NDQgSmF2YVNjcmlwdENvcmUvd3Rm L1N0YXRpY1B0ckJhc2UuY3BwCiBjcmVhdGUgbW9kZSAxMDA2NDQgSmF2YVNjcmlwdENvcmUvd3Rm L1N0YXRpY1B0ckJhc2UuaAoKZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRD b3JlLnByaSBiL0phdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLnByaQppbmRleCAwZjNmOTA5 Li4zN2NmY2MxIDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0Q29yZS9KYXZhU2NyaXB0Q29yZS5wcmkK KysrIGIvSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUucHJpCkBAIC03NSw2ICs3NSw3IEBA IFNPVVJDRVMgKz0gXAogICAgIHd0Zi9NYWluVGhyZWFkLmNwcCBcCiAgICAgd3RmL1JhbmRvbU51 bWJlci5jcHAgXAogICAgIHd0Zi9SZWZDb3VudGVkTGVha0NvdW50ZXIuY3BwIFwKKyAgICB3dGYv U3RhdGljUHRyQmFzZS5jcHAgXAogICAgIHd0Zi9UeXBlVHJhaXRzLmNwcCBcCiAgICAgd3RmL3Vu aWNvZGUvQ29sbGF0b3JEZWZhdWx0LmNwcCBcCiAgICAgd3RmL3VuaWNvZGUvaWN1L0NvbGxhdG9y SUNVLmNwcCBcCmRpZmYgLS1naXQgYS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTR2xvYmFsRGF0 YS5jcHAgYi9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTR2xvYmFsRGF0YS5jcHAKaW5kZXggYmQz NWNiNy4uNjczMWY3NCAxMDA2NDQKLS0tIGEvSmF2YVNjcmlwdENvcmUvcnVudGltZS9KU0dsb2Jh bERhdGEuY3BwCisrKyBiL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNHbG9iYWxEYXRhLmNwcApA QCAtNDksNiArNDksNyBAQAogI2luY2x1ZGUgIkxleGVyLmgiCiAjaW5jbHVkZSAiTG9va3VwLmgi CiAjaW5jbHVkZSAiTm9kZXMuaCIKKyNpbmNsdWRlICJ3dGYvR2xvYmFsUHRyLmgiCiAKICNpZiBF TkFCTEUoSlNDX01VTFRJUExFX1RIUkVBRFMpCiAjaW5jbHVkZSA8d3RmL1RocmVhZGluZy5oPgpA QCAtMjA3LDI4ICsyMDgsMjQgQEAgUGFzc1JlZlB0cjxKU0dsb2JhbERhdGE+IEpTR2xvYmFsRGF0 YTo6Y3JlYXRlTGVha2VkKCkKICAgICByZXR1cm4gZGF0YS5yZWxlYXNlKCk7CiB9CiAKK1dURjo6 R2xvYmFsUHRyPEpTR2xvYmFsRGF0YT4gc2hhcmVkSW5zdGFuY2VQdHI7CisKIGJvb2wgSlNHbG9i YWxEYXRhOjpzaGFyZWRJbnN0YW5jZUV4aXN0cygpCiB7Ci0gICAgcmV0dXJuIHNoYXJlZEluc3Rh bmNlSW50ZXJuYWwoKTsKKyAgICBBU1NFUlQoSlNMb2NrOjpjdXJyZW50VGhyZWFkSXNIb2xkaW5n TG9jaygpKTsKKyAgICByZXR1cm4gc2hhcmVkSW5zdGFuY2VQdHIuZ2V0KCk7CiB9CiAKIEpTR2xv YmFsRGF0YSYgSlNHbG9iYWxEYXRhOjpzaGFyZWRJbnN0YW5jZSgpCiB7Ci0gICAgSlNHbG9iYWxE YXRhKiYgaW5zdGFuY2UgPSBzaGFyZWRJbnN0YW5jZUludGVybmFsKCk7Ci0gICAgaWYgKCFpbnN0 YW5jZSkgewotICAgICAgICBpbnN0YW5jZSA9IGNyZWF0ZSh0cnVlKS5yZWxlYXNlUmVmKCk7Cisg ICAgQVNTRVJUKEpTTG9jazo6Y3VycmVudFRocmVhZElzSG9sZGluZ0xvY2soKSk7CisgICAgaWYg KCFzaGFyZWRJbnN0YW5jZVB0cikgeworICAgICAgICBzaGFyZWRJbnN0YW5jZVB0ciA9IGNyZWF0 ZSh0cnVlKS5yZWxlYXNlUmVmKCk7CiAjaWYgRU5BQkxFKEpTQ19NVUxUSVBMRV9USFJFQURTKQot ICAgICAgICBpbnN0YW5jZS0+bWFrZVVzYWJsZUZyb21NdWx0aXBsZVRocmVhZHMoKTsKKyAgICAg ICAgc2hhcmVkSW5zdGFuY2VQdHItPm1ha2VVc2FibGVGcm9tTXVsdGlwbGVUaHJlYWRzKCk7CiAj ZW5kaWYKICAgICB9Ci0gICAgcmV0dXJuICppbnN0YW5jZTsKLX0KLQotSlNHbG9iYWxEYXRhKiYg SlNHbG9iYWxEYXRhOjpzaGFyZWRJbnN0YW5jZUludGVybmFsKCkKLXsKLSAgICBBU1NFUlQoSlNM b2NrOjpjdXJyZW50VGhyZWFkSXNIb2xkaW5nTG9jaygpKTsKLSAgICBzdGF0aWMgSlNHbG9iYWxE YXRhKiBzaGFyZWRJbnN0YW5jZTsKLSAgICByZXR1cm4gc2hhcmVkSW5zdGFuY2U7CisgICAgcmV0 dXJuICpzaGFyZWRJbnN0YW5jZVB0cjsKIH0KIAogLy8gRklYTUU6IFdlIGNhbiBhbHNvIGRldGVj dCBmb3JtcyBsaWtlIHYxIDwgdjIgPyAtMSA6IDAsIHJldmVyc2UgY29tcGFyaXNvbiwgZXRjLgpk aWZmIC0tZ2l0IGEvSmF2YVNjcmlwdENvcmUvcnVudGltZS9KU0dsb2JhbERhdGEuaCBiL0phdmFT Y3JpcHRDb3JlL3J1bnRpbWUvSlNHbG9iYWxEYXRhLmgKaW5kZXggNzgxMWM4NS4uZjY4ZWE4NyAx MDA2NDQKLS0tIGEvSmF2YVNjcmlwdENvcmUvcnVudGltZS9KU0dsb2JhbERhdGEuaAorKysgYi9K YXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTR2xvYmFsRGF0YS5oCkBAIC0xNTIsNyArMTUyLDYgQEAg bmFtZXNwYWNlIEpTQyB7CiAgICAgICAgIE1hcmtTdGFjayBtYXJrU3RhY2s7CiAgICAgcHJpdmF0 ZToKICAgICAgICAgSlNHbG9iYWxEYXRhKGJvb2wgaXNTaGFyZWQsIGNvbnN0IFZQdHJTZXQmKTsK LSAgICAgICAgc3RhdGljIEpTR2xvYmFsRGF0YSomIHNoYXJlZEluc3RhbmNlSW50ZXJuYWwoKTsK ICAgICAgICAgdm9pZCBjcmVhdGVOYXRpdmVUaHVuaygpOwogICAgIH07CiAKZGlmZiAtLWdpdCBh L0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvVVN0cmluZy5jcHAgYi9KYXZhU2NyaXB0Q29yZS9ydW50 aW1lL1VTdHJpbmcuY3BwCmluZGV4IGFhODAyYzguLjBiYTQ2MWQgMTAwNjQ0Ci0tLSBhL0phdmFT Y3JpcHRDb3JlL3J1bnRpbWUvVVN0cmluZy5jcHAKKysrIGIvSmF2YVNjcmlwdENvcmUvcnVudGlt ZS9VU3RyaW5nLmNwcApAQCAtMTkyLDkgKzE5Miw5IEBAIGJvb2wgb3BlcmF0b3I9PShjb25zdCBD U3RyaW5nJiBjMSwgY29uc3QgQ1N0cmluZyYgYzIpCiAvLyBUaGVzZSBzdGF0aWMgc3RyaW5ncyBh cmUgaW1tdXRhYmxlLCBleGNlcHQgZm9yIHJjLCB3aG9zZSBpbml0aWFsIHZhbHVlIGlzIGNob3Nl biB0byAKIC8vIHJlZHVjZSB0aGUgcG9zc2liaWxpdHkgb2YgaXQgYmVjb21pbmcgemVybyBkdWUg dG8gcmVmL2RlcmVmIG5vdCBiZWluZyB0aHJlYWQtc2FmZS4KIHN0YXRpYyBVQ2hhciBzaGFyZWRF bXB0eUNoYXI7Ci1VU3RyaW5nOjpCYXNlU3RyaW5nKiBVU3RyaW5nOjpSZXA6Om51bGxCYXNlU3Ry aW5nOwotVVN0cmluZzo6QmFzZVN0cmluZyogVVN0cmluZzo6UmVwOjplbXB0eUJhc2VTdHJpbmc7 Ci1VU3RyaW5nKiBVU3RyaW5nOjpudWxsVVN0cmluZzsKK1dURjo6R2xvYmFsUHRyPFVTdHJpbmc6 OkJhc2VTdHJpbmc+IFVTdHJpbmc6OlJlcDo6bnVsbEJhc2VTdHJpbmc7CitXVEY6Okdsb2JhbFB0 cjxVU3RyaW5nOjpCYXNlU3RyaW5nPiBVU3RyaW5nOjpSZXA6OmVtcHR5QmFzZVN0cmluZzsKK1dU Rjo6R2xvYmFsUHRyPFVTdHJpbmc+IFVTdHJpbmc6Om51bGxVU3RyaW5nOwogCiBzdGF0aWMgdm9p ZCBpbml0aWFsaXplU3RhdGljQmFzZVN0cmluZyhVU3RyaW5nOjpCYXNlU3RyaW5nJiBiYXNlKQog ewpkaWZmIC0tZ2l0IGEvSmF2YVNjcmlwdENvcmUvcnVudGltZS9VU3RyaW5nLmggYi9KYXZhU2Ny aXB0Q29yZS9ydW50aW1lL1VTdHJpbmcuaAppbmRleCBjNGRhZDJhLi5lMWEwYTA2IDEwMDY0NAot LS0gYS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1VTdHJpbmcuaAorKysgYi9KYXZhU2NyaXB0Q29y ZS9ydW50aW1lL1VTdHJpbmcuaApAQCAtMjgsNiArMjgsNyBAQAogI2luY2x1ZGUgPHN0cmluZy5o PgogI2luY2x1ZGUgPHd0Zi9Bc3NlcnRpb25zLmg+CiAjaW5jbHVkZSA8d3RmL0Nyb3NzVGhyZWFk UmVmQ291bnRlZC5oPgorI2luY2x1ZGUgPHd0Zi9HbG9iYWxQdHIuaD4KICNpbmNsdWRlIDx3dGYv T3duRmFzdE1hbGxvY1B0ci5oPgogI2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+CiAjaW5jbHVk ZSA8d3RmL1B0ckFuZEZsYWdzLmg+CkBAIC0xODYsOCArMTg3LDggQEAgbmFtZXNwYWNlIEpTQyB7 CiAKICAgICAgICAgICAgIGZyaWVuZCBjbGFzcyBTbWFsbFN0cmluZ3NTdG9yYWdlOwogICAgICAg ICAgICAgZnJpZW5kIHZvaWQgaW5pdGlhbGl6ZVVTdHJpbmcoKTsKLSAgICAgICAgICAgIEpTX0VY UE9SVERBVEEgc3RhdGljIEJhc2VTdHJpbmcqIG51bGxCYXNlU3RyaW5nOwotICAgICAgICAgICAg SlNfRVhQT1JUREFUQSBzdGF0aWMgQmFzZVN0cmluZyogZW1wdHlCYXNlU3RyaW5nOworICAgICAg ICAgICAgSlNfRVhQT1JUREFUQSBzdGF0aWMgV1RGOjpHbG9iYWxQdHI8QmFzZVN0cmluZz4gbnVs bEJhc2VTdHJpbmc7CisgICAgICAgICAgICBKU19FWFBPUlREQVRBIHN0YXRpYyBXVEY6Okdsb2Jh bFB0cjxCYXNlU3RyaW5nPiBlbXB0eUJhc2VTdHJpbmc7CiAgICAgICAgIH07CiAKIApAQCAtMzY3 LDcgKzM2OCw3IEBAIG5hbWVzcGFjZSBKU0MgewogICAgICAgICB2b2lkIG1ha2VOdWxsKCk7CiAK ICAgICAgICAgUmVmUHRyPFJlcD4gbV9yZXA7Ci0gICAgICAgIHN0YXRpYyBVU3RyaW5nKiBudWxs VVN0cmluZzsKKyAgICAgICAgc3RhdGljIFdURjo6R2xvYmFsUHRyPFVTdHJpbmc+IG51bGxVU3Ry aW5nOwogCiAgICAgICAgIGZyaWVuZCB2b2lkIGluaXRpYWxpemVVU3RyaW5nKCk7CiAgICAgICAg IGZyaWVuZCBib29sIG9wZXJhdG9yPT0oY29uc3QgVVN0cmluZyYsIGNvbnN0IFVTdHJpbmcmKTsK ZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL3d0Zi9HbG9iYWxQdHIuaCBiL0phdmFTY3JpcHRD b3JlL3d0Zi9HbG9iYWxQdHIuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5j ZTAyNzE0Ci0tLSAvZGV2L251bGwKKysrIGIvSmF2YVNjcmlwdENvcmUvd3RmL0dsb2JhbFB0ci5o CkBAIC0wLDAgKzEsMTU0IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDA5IFVuaXZlcnNpdHkg b2YgU3plZ2VkCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9u IGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICog bW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBj b25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBj b2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJl ZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29w eXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9s bG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhl ciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMg U09GVFdBUkUgSVMgUFJPVklERUQgQlkgVU5JVkVSU0lUWSBPRiBTWkVHRUQgYGBBUyBJUycnIEFO RCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBO T1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklM SVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlN RUQuICBJTiBOTyBFVkVOVCBTSEFMTCBVTklWRVJTSVRZIE9GIFNaRUdFRCBPUgorICogQ09OVFJJ QlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQ RUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5H LCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RT IE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lO RVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9G IExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9S VAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkg V0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQg T0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgV1RGX0ds b2JhbFB0cl9oCisjZGVmaW5lIFdURl9HbG9iYWxQdHJfaAorCisjaW5jbHVkZSAiU3RhdGljUHRy QmFzZS5oIgorCituYW1lc3BhY2UgV1RGIHsKKworLy8gVGhlIGNsYXNzZXMgaGVyZSBhcmUgZGVm aW5lZCBhcyBzdHJ1Y3RzIHRvIGF2b2lkCisvLyB0aGUgY2FsbCBvZiBDKysgY29uc3RydWN0b3Jz IGFuZCBkZXN0cnVjdG9ycworCit0ZW1wbGF0ZTx0eXBlbmFtZSBUPiBzdHJ1Y3QgR2xvYmFsUHRy IHsKK3B1YmxpYzoKKyAgICB0eXBlZGVmIHR5cGVuYW1lIFJlbW92ZVBvaW50ZXI8VD46OlR5cGUg VmFsdWVUeXBlOworICAgIHR5cGVkZWYgVmFsdWVUeXBlKiBQdHJUeXBlOworCisgICAgLy8gSGFz IE5PIEMrKyBjb25zdHJ1Y3RvcgorCisgICAgUHRyVHlwZSBnZXQoKSBjb25zdDsKKyAgICB2b2lk IHNldChQdHJUeXBlKTsKKworICAgIHZvaWQgb3BlcmF0b3I9KFB0clR5cGUpOworCisgICAgLy8g VmFsdWUgYWNjZXNzIG9wZXJhdG9ycworICAgIFZhbHVlVHlwZSYgb3BlcmF0b3IqKCk7CisgICAg UHRyVHlwZSBvcGVyYXRvci0+KCk7CisgICAgVmFsdWVUeXBlJiBvcGVyYXRvciooKSBjb25zdDsK KyAgICBQdHJUeXBlIG9wZXJhdG9yLT4oKSBjb25zdDsKKworICAgIGJvb2wgb3BlcmF0b3IhKCkg Y29uc3Q7CisKKyAgICB2b2lkIGRlbGV0ZVB0cigpOworCisjaWYgRU5BQkxFKEZSRUVfU1RBVElD X1BUUlMpCisgICAgU3RhdGljUHRyQmFzZSBtX2Jhc2U7CisjZW5kaWYKKyAgICBQdHJUeXBlIG1f cHRyOworCisjaWYgRU5BQkxFKEZSRUVfU1RBVElDX1BUUlMpCisgICAgc3RhdGljIHZvaWQgZnJl ZSh2b2lkKiBwdHIpCisgICAgeworICAgICAgICBBU1NFUlQocHRyKTsKKyAgICAgICAgZGVsZXRl IHJlaW50ZXJwcmV0X2Nhc3Q8R2xvYmFsUHRyPFQ+Kj4ocHRyKS0+Z2V0KCk7CisgICAgfQorCisg ICAgdm9pZCBzZXRGcmVlKFN0YXRpY1B0ckJhc2VGcmVlIGZ1bmMpCisgICAgeworICAgICAgICBt X2Jhc2UubV9mcmVlID0gZnVuYzsKKyAgICB9CisjZW5kaWYKK307CisKK3RlbXBsYXRlPHR5cGVu YW1lIFQ+CitBTFdBWVNfSU5MSU5FIHR5cGVuYW1lIEdsb2JhbFB0cjxUPjo6UHRyVHlwZSBHbG9i YWxQdHI8VD46OmdldCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIG1fcHRyOworfQorCit0ZW1wbGF0 ZTx0eXBlbmFtZSBUPgorQUxXQVlTX0lOTElORSB2b2lkIEdsb2JhbFB0cjxUPjo6c2V0KFB0clR5 cGUgdmFsdWUpCit7CisgICAgLy8gRGV0ZWN0IG1lbW9yeSBsZWFrcworICAgIEFTU0VSVCghbV9w dHIgfHwgKG1fcHRyID09IHZhbHVlKSk7CisgICAgbV9wdHIgPSB2YWx1ZTsKKyNpZiBFTkFCTEUo RlJFRV9TVEFUSUNfUFRSUykKKyAgICBpZiAodmFsdWUpIHsKKyAgICAgICAgbV9iYXNlLm1fZnJl ZSA9IGZyZWU7CisgICAgICAgIG1fYmFzZS5hcHBlbmQoKTsKKyAgICB9CisjZW5kaWYKK30KKwor dGVtcGxhdGU8dHlwZW5hbWUgVD4KK0FMV0FZU19JTkxJTkUgdm9pZCBHbG9iYWxQdHI8VD46Om9w ZXJhdG9yPShQdHJUeXBlIHZhbHVlKQoreworICAgIHNldCh2YWx1ZSk7Cit9CisKK3RlbXBsYXRl PHR5cGVuYW1lIFQ+CitBTFdBWVNfSU5MSU5FIHR5cGVuYW1lIEdsb2JhbFB0cjxUPjo6VmFsdWVU eXBlJiBHbG9iYWxQdHI8VD46Om9wZXJhdG9yKigpCit7CisgICAgQVNTRVJUKG1fcHRyKTsKKyAg ICByZXR1cm4gKm1fcHRyOworfQorCit0ZW1wbGF0ZTx0eXBlbmFtZSBUPgorQUxXQVlTX0lOTElO RSB0eXBlbmFtZSBHbG9iYWxQdHI8VD46OlB0clR5cGUgR2xvYmFsUHRyPFQ+OjpvcGVyYXRvci0+ KCkKK3sKKyAgICBBU1NFUlQobV9wdHIpOworICAgIHJldHVybiBtX3B0cjsKK30KKwordGVtcGxh dGU8dHlwZW5hbWUgVD4KK0FMV0FZU19JTkxJTkUgdHlwZW5hbWUgR2xvYmFsUHRyPFQ+OjpWYWx1 ZVR5cGUmIEdsb2JhbFB0cjxUPjo6b3BlcmF0b3IqKCkgY29uc3QKK3sKKyAgICBBU1NFUlQobV9w dHIpOworICAgIHJldHVybiAqbV9wdHI7Cit9CisKK3RlbXBsYXRlPHR5cGVuYW1lIFQ+CitBTFdB WVNfSU5MSU5FIHR5cGVuYW1lIEdsb2JhbFB0cjxUPjo6UHRyVHlwZSBHbG9iYWxQdHI8VD46Om9w ZXJhdG9yLT4oKSBjb25zdAoreworICAgIEFTU0VSVChtX3B0cik7CisgICAgcmV0dXJuIG1fcHRy OworfQorCit0ZW1wbGF0ZTx0eXBlbmFtZSBUPgorQUxXQVlTX0lOTElORSBib29sIEdsb2JhbFB0 cjxUPjo6b3BlcmF0b3IhKCkgY29uc3QKK3sKKyAgICByZXR1cm4gIW1fcHRyOworfQorCit0ZW1w bGF0ZTx0eXBlbmFtZSBUPgorQUxXQVlTX0lOTElORSB2b2lkIEdsb2JhbFB0cjxUPjo6ZGVsZXRl UHRyKCkKK3sKKyAgICBBU1NFUlQobV9wdHIpOworICAgIGRlbGV0ZSBtX3B0cjsKKyNpZm5kZWYg TkRFQlVHCisgICAgLy8gU2VlIEdsb2JhbFB0cjxUPjo6c2V0CisgICAgbV9wdHIgPSAwOworI2Vu ZGlmCisjaWYgRU5BQkxFKEZSRUVfU1RBVElDX1BUUlMpCisgICAgbV9iYXNlLnJlbW92ZSgpOwor I2VuZGlmCit9CisKK30gLy8gbmFtZXNwYWNlIFdURgorCisjZW5kaWYKZGlmZiAtLWdpdCBhL0ph dmFTY3JpcHRDb3JlL3d0Zi9Mb2NhbFN0YXRpY0FycmF5UHRyLmggYi9KYXZhU2NyaXB0Q29yZS93 dGYvTG9jYWxTdGF0aWNBcnJheVB0ci5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAuLmJhM2NmYjMKLS0tIC9kZXYvbnVsbAorKysgYi9KYXZhU2NyaXB0Q29yZS93dGYvTG9jYWxT dGF0aWNBcnJheVB0ci5oCkBAIC0wLDAgKzEsODcgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIw MDkgVW5pdmVyc2l0eSBvZiBTemVnZWQKKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICog UmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBv ciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0 aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlv bnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAg bm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNl IHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRp b24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24u CisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBVTklWRVJTSVRZIE9GIFNaRUdF RCBgYEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElO Q0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBP RiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9T RSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIFVOSVZFUlNJVFkgT0YgU1pFR0VE IE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwg SU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1B R0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNV QlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJP RklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5Z IFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElB QklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBB UklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVW RU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKwor I2lmbmRlZiBXVEZfTG9jYWxTdGF0aWNBcnJheVB0cl9oCisjZGVmaW5lIFdURl9Mb2NhbFN0YXRp Y0FycmF5UHRyX2gKKworI2luY2x1ZGUgIlN0YXRpY1B0ckJhc2UuaCIKKworbmFtZXNwYWNlIFdU RiB7CisKKy8vIFdyYXBwZXIgY2xhc3MgZm9yIGFycmF5cywgd2hpY2ggYXNzaWduZWQgdG8gYSBz dGF0aWMgdmFyaWFibGUKKy8vIEJ5IGRlZmF1bHQsIGl0IGJlaGF2ZXMgbGlrZSBhIHNpbXBsZSBD KysgYXJyYXkgd2l0aG91dCBwZXJmb3JtYW5jZSBvdmVyaGVhZAordGVtcGxhdGU8dHlwZW5hbWUg VD4gc3RydWN0IExvY2FsU3RhdGljQXJyYXlQdHIgeworcHVibGljOgorICAgIHR5cGVkZWYgdHlw ZW5hbWUgUmVtb3ZlUG9pbnRlcjxUPjo6VHlwZSBWYWx1ZVR5cGU7CisgICAgdHlwZWRlZiBWYWx1 ZVR5cGUqIFB0clR5cGU7CisKKyAgICBMb2NhbFN0YXRpY0FycmF5UHRyKFZhbHVlVHlwZSogcHRy KTsKKworICAgIFZhbHVlVHlwZSYgb3BlcmF0b3JbXShzaXplX3QpOworICAgIGNvbnN0IFZhbHVl VHlwZSYgb3BlcmF0b3JbXShzaXplX3QpIGNvbnN0OworCisjaWYgRU5BQkxFKEZSRUVfU1RBVElD X1BUUlMpCisgICAgU3RhdGljUHRyQmFzZSBtX2Jhc2U7CisjZW5kaWYKKyAgICBQdHJUeXBlIG1f cHRyOworCisjaWYgRU5BQkxFKEZSRUVfU1RBVElDX1BUUlMpCisgICAgc3RhdGljIHZvaWQgZnJl ZSh2b2lkKiBwdHIpCisgICAgeworICAgICAgICBBU1NFUlQocHRyKTsKKyAgICAgICAgZGVsZXRl W10gcmVpbnRlcnByZXRfY2FzdDxMb2NhbFN0YXRpY0FycmF5UHRyPFQ+Kj4ocHRyKS0+bV9wdHI7 CisgICAgfQorI2VuZGlmCit9OworCit0ZW1wbGF0ZTx0eXBlbmFtZSBUPgorQUxXQVlTX0lOTElO RSBMb2NhbFN0YXRpY0FycmF5UHRyPFQ+OjpMb2NhbFN0YXRpY0FycmF5UHRyKFZhbHVlVHlwZSog cHRyKQorICAgIDogbV9wdHIocHRyKQoreworICAgIEFTU0VSVChwdHIpOworI2lmIEVOQUJMRShG UkVFX1NUQVRJQ19QVFJTKQorICAgIG1fYmFzZS5tX2ZyZWUgPSBmcmVlOworICAgIG1fYmFzZS5h cHBlbmQoKTsKKyNlbmRpZgorfQorCit0ZW1wbGF0ZTx0eXBlbmFtZSBUPgorQUxXQVlTX0lOTElO RSB0eXBlbmFtZSBMb2NhbFN0YXRpY0FycmF5UHRyPFQ+OjpWYWx1ZVR5cGUmIExvY2FsU3RhdGlj QXJyYXlQdHI8VD46Om9wZXJhdG9yW10oc2l6ZV90IGkpCit7CisgICAgQVNTRVJUKG1fcHRyKTsK KyAgICByZXR1cm4gbV9wdHJbaV07Cit9CisKK3RlbXBsYXRlPHR5cGVuYW1lIFQ+CitBTFdBWVNf SU5MSU5FIGNvbnN0IHR5cGVuYW1lIExvY2FsU3RhdGljQXJyYXlQdHI8VD46OlZhbHVlVHlwZSYg TG9jYWxTdGF0aWNBcnJheVB0cjxUPjo6b3BlcmF0b3JbXShzaXplX3QgaSkgY29uc3QKK3sKKyAg ICBBU1NFUlQobV9wdHIpOworICAgIHJldHVybiBtX3B0cltpXTsKK30KKworfSAvLyBuYW1lc3Bh Y2UgV1RGCisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvSmF2YVNjcmlwdENvcmUvd3RmL0xvY2FsU3Rh dGljUHRyLmggYi9KYXZhU2NyaXB0Q29yZS93dGYvTG9jYWxTdGF0aWNQdHIuaApuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jOTY0YTg5Ci0tLSAvZGV2L251bGwKKysrIGIvSmF2 YVNjcmlwdENvcmUvd3RmL0xvY2FsU3RhdGljUHRyLmgKQEAgLTAsMCArMSwxMTggQEAKKy8qCisg KiBDb3B5cmlnaHQgKEMpIDIwMDkgVW5pdmVyc2l0eSBvZiBTemVnZWQKKyAqIEFsbCByaWdodHMg cmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJp bmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0 ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6Cisg KiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3Zl IGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhl IGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBm b3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUK KyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRo IHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBV TklWRVJTSVRZIE9GIFNaRUdFRCBgYEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBM SUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElN UExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFS VElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIFVO SVZFUlNJVFkgT0YgU1pFR0VEIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkg RElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1Ig Q09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAq IFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNF LCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVS IENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENP TlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VO Q0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9G IFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VD SCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBXVEZfTG9jYWxTdGF0aWNQdHJfaAorI2RlZmluZSBX VEZfTG9jYWxTdGF0aWNQdHJfaAorCisjaW5jbHVkZSAiU3RhdGljUHRyQmFzZS5oIgorCituYW1l c3BhY2UgV1RGIHsKKwordGVtcGxhdGU8dHlwZW5hbWUgVD4gc3RydWN0IExvY2FsU3RhdGljUHRy IHsKK3B1YmxpYzoKKyAgICB0eXBlZGVmIHR5cGVuYW1lIFJlbW92ZVBvaW50ZXI8VD46OlR5cGUg VmFsdWVUeXBlOworICAgIHR5cGVkZWYgVmFsdWVUeXBlKiBQdHJUeXBlOworCisgICAgLy8gSGFz IEMrKyBjb25zdHJ1Y3RvcgorICAgIExvY2FsU3RhdGljUHRyKFB0clR5cGUgcHRyKTsKKworICAg IFB0clR5cGUgZ2V0KCkgY29uc3Q7CisKKyAgICAvLyBWYWx1ZSBhY2Nlc3Mgb3BlcmF0b3JzCisg ICAgVmFsdWVUeXBlJiBvcGVyYXRvciooKTsKKyAgICBQdHJUeXBlIG9wZXJhdG9yLT4oKTsKKyAg ICBWYWx1ZVR5cGUmIG9wZXJhdG9yKigpIGNvbnN0OworICAgIFB0clR5cGUgb3BlcmF0b3ItPigp IGNvbnN0OworCisjaWYgRU5BQkxFKEZSRUVfU1RBVElDX1BUUlMpCisgICAgU3RhdGljUHRyQmFz ZSBtX2Jhc2U7CisjZW5kaWYKKyAgICBQdHJUeXBlIG1fcHRyOworCisjaWYgRU5BQkxFKEZSRUVf U1RBVElDX1BUUlMpCisgICAgc3RhdGljIHZvaWQgZnJlZSh2b2lkKiBwdHIpCisgICAgeworICAg ICAgICBBU1NFUlQocHRyKTsKKyAgICAgICAgZGVsZXRlIHJlaW50ZXJwcmV0X2Nhc3Q8TG9jYWxT dGF0aWNQdHI8VD4qPihwdHIpLT5nZXQoKTsKKyAgICB9CisKKyAgICBzdGF0aWMgdm9pZCBkZXN0 cm95KHZvaWQqIHB0cikKKyAgICB7CisgICAgICAgIEFTU0VSVChwdHIpOworICAgICAgICByZWlu dGVycHJldF9jYXN0PExvY2FsU3RhdGljUHRyPFQ+Kj4ocHRyKS0+Z2V0KCktPn5UKCk7CisgICAg fQorCisgICAgdm9pZCBzZXRGcmVlKFN0YXRpY1B0ckJhc2VGcmVlIGZ1bmMpCisgICAgeworICAg ICAgICBtX2Jhc2UubV9mcmVlID0gZnVuYzsKKyAgICB9CisjZW5kaWYKK307CisKK3RlbXBsYXRl PHR5cGVuYW1lIFQ+CitBTFdBWVNfSU5MSU5FIExvY2FsU3RhdGljUHRyPFQ+OjpMb2NhbFN0YXRp Y1B0cihQdHJUeXBlIHB0cikKKyAgICA6IG1fcHRyKHB0cikKK3sKKyAgICBBU1NFUlQocHRyKTsK KyNpZiBFTkFCTEUoRlJFRV9TVEFUSUNfUFRSUykKKyAgICBtX2Jhc2UubV9mcmVlID0gZnJlZTsK KyAgICBtX2Jhc2UuYXBwZW5kKCk7CisjZW5kaWYKK30KKwordGVtcGxhdGU8dHlwZW5hbWUgVD4K K0FMV0FZU19JTkxJTkUgdHlwZW5hbWUgTG9jYWxTdGF0aWNQdHI8VD46OlB0clR5cGUgTG9jYWxT dGF0aWNQdHI8VD46OmdldCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIG1fcHRyOworfQorCit0ZW1w bGF0ZTx0eXBlbmFtZSBUPgorQUxXQVlTX0lOTElORSB0eXBlbmFtZSBMb2NhbFN0YXRpY1B0cjxU Pjo6VmFsdWVUeXBlJiBMb2NhbFN0YXRpY1B0cjxUPjo6b3BlcmF0b3IqKCkKK3sKKyAgICByZXR1 cm4gKm1fcHRyOworfQorCit0ZW1wbGF0ZTx0eXBlbmFtZSBUPgorQUxXQVlTX0lOTElORSB0eXBl bmFtZSBMb2NhbFN0YXRpY1B0cjxUPjo6UHRyVHlwZSBMb2NhbFN0YXRpY1B0cjxUPjo6b3BlcmF0 b3ItPigpCit7CisgICAgcmV0dXJuIG1fcHRyOworfQorCit0ZW1wbGF0ZTx0eXBlbmFtZSBUPgor QUxXQVlTX0lOTElORSB0eXBlbmFtZSBMb2NhbFN0YXRpY1B0cjxUPjo6VmFsdWVUeXBlJiBMb2Nh bFN0YXRpY1B0cjxUPjo6b3BlcmF0b3IqKCkgY29uc3QKK3sKKyAgICByZXR1cm4gKm1fcHRyOwor fQorCit0ZW1wbGF0ZTx0eXBlbmFtZSBUPgorQUxXQVlTX0lOTElORSB0eXBlbmFtZSBMb2NhbFN0 YXRpY1B0cjxUPjo6UHRyVHlwZSBMb2NhbFN0YXRpY1B0cjxUPjo6b3BlcmF0b3ItPigpIGNvbnN0 Cit7CisgICAgcmV0dXJuIG1fcHRyOworfQorCit9IC8vIG5hbWVzcGFjZSBXVEYKKworI2VuZGlm CmRpZmYgLS1naXQgYS9KYXZhU2NyaXB0Q29yZS93dGYvUGxhdGZvcm0uaCBiL0phdmFTY3JpcHRD b3JlL3d0Zi9QbGF0Zm9ybS5oCmluZGV4IGIyMDg0NmQuLjI2ODk1MzAgMTAwNjQ0Ci0tLSBhL0ph dmFTY3JpcHRDb3JlL3d0Zi9QbGF0Zm9ybS5oCisrKyBiL0phdmFTY3JpcHRDb3JlL3d0Zi9QbGF0 Zm9ybS5oCkBAIC03NjIsNCArNzYyLDYgQEAKIC8qIFNldCB1cCBhIGRlZmluZSBmb3IgYSBjb21t b24gZXJyb3IgdGhhdCBpcyBpbnRlbmRlZCB0byBjYXVzZSBhIGJ1aWxkIGVycm9yIC0tIHRodXMg dGhlIHNwYWNlIGFmdGVyIEVycm9yLiAqLwogI2RlZmluZSBXVEZfUExBVEZPUk1fQ0ZORVRXT1JL IEVycm9yIFVTRV9tYWNyb19zaG91bGRfYmVfdXNlZF93aXRoX0NGTkVUV09SSwogCisjZGVmaW5l IEVOQUJMRV9GUkVFX1NUQVRJQ19QVFJTIDEKKwogI2VuZGlmIC8qIFdURl9QbGF0Zm9ybV9oICov CmRpZmYgLS1naXQgYS9KYXZhU2NyaXB0Q29yZS93dGYvU3RhdGljUHRyQmFzZS5jcHAgYi9KYXZh U2NyaXB0Q29yZS93dGYvU3RhdGljUHRyQmFzZS5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMC4uNmFiYWRjZAotLS0gL2Rldi9udWxsCisrKyBiL0phdmFTY3JpcHRDb3JlL3d0 Zi9TdGF0aWNQdHJCYXNlLmNwcApAQCAtMCwwICsxLDcwIEBACisvKgorICogQ29weXJpZ2h0IChD KSAyMDA5IFVuaXZlcnNpdHkgb2YgU3plZ2VkCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoK KyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdp dGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRo YXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmli dXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAq ICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJv ZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVu dGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0 aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVU5JVkVSU0lUWSBPRiBT WkVHRUQgYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVT LCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJ RVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBV UlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBVTklWRVJTSVRZIE9GIFNa RUdFRCBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJF Q1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwg REFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBP RiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAq IFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9O IEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNU IExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lT RSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJF LCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICov CisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJTdGF0aWNQdHJCYXNlLmgiCisKK25h bWVzcGFjZSBXVEYgeworCisjaWYgRU5BQkxFKEZSRUVfU1RBVElDX1BUUlMpCisKK1N0YXRpY1B0 ckJhc2U6OlN0YXRpY1B0ckJhc2UqIFN0YXRpY1B0ckJhc2U6Om1faGVhZCA9IDA7CisKK3ZvaWQg U3RhdGljUHRyQmFzZTo6ZnJlZVN0YXRpY1B0cnMoKQoreworICAgIC8vIEZyZWUgdGhlbSBpbiBh IHJldmVyc2VkIGNyZWF0aW9uIG9yZGVyCisgICAgU3RhdGljUHRyQmFzZSogY3VycmVudCA9IGhl YWQoKTsKKyAgICB3aGlsZSAoY3VycmVudCkgeworICAgICAgICBjdXJyZW50LT5tX2ZyZWUocmVp bnRlcnByZXRfY2FzdDx2b2lkKj4oY3VycmVudCkpOworICAgICAgICBjdXJyZW50ID0gY3VycmVu dC0+bmV4dCgpOworICAgIH0KK30KKwordm9pZCBTdGF0aWNQdHJCYXNlOjphcHBlbmQoKQorewor ICAgIG1fbmV4dCA9IGhlYWQoKTsKKyAgICBtX2hlYWQgPSB0aGlzOworfQorCit2b2lkIFN0YXRp Y1B0ckJhc2U6OnJlbW92ZSgpCit7CisgICAgLy8gUGVyaGFwcyBhIGRvdWJsZSBsaW5rZWQgbGlz dCBtYXkgYmUgc3VpdGFibGUgaWYgcmVtb3ZlKCkgY2FsbGVkIGZyZXF1ZW50bHkKKyAgICBTdGF0 aWNQdHJCYXNlKiBjdXJyZW50ID0gaGVhZCgpOworICAgIGlmIChjdXJyZW50ID09IHRoaXMpIHsK KyAgICAgICAgbV9oZWFkID0gY3VycmVudC0+bmV4dCgpOworICAgICAgICByZXR1cm47CisgICAg fQorCisgICAgd2hpbGUgKGN1cnJlbnQtPm5leHQoKSAhPSB0aGlzKSB7CisgICAgICAgIGN1cnJl bnQgPSBjdXJyZW50LT5uZXh0KCk7CisgICAgICAgIEFTU0VSVChjdXJyZW50KTsKKyAgICB9Cisg ICAgY3VycmVudC0+bV9uZXh0ID0gbmV4dCgpOworfQorCisjZW5kaWYgLy8gRU5BQkxFKEZSRUVf U1RBVElDX1BUUlMpCisKK30gLy8gbmFtZXNwYWNlIFdURgpkaWZmIC0tZ2l0IGEvSmF2YVNjcmlw dENvcmUvd3RmL1N0YXRpY1B0ckJhc2UuaCBiL0phdmFTY3JpcHRDb3JlL3d0Zi9TdGF0aWNQdHJC YXNlLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZjhmN2Q1YQotLS0gL2Rl di9udWxsCisrKyBiL0phdmFTY3JpcHRDb3JlL3d0Zi9TdGF0aWNQdHJCYXNlLmgKQEAgLTAsMCAr MSw2MiBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAwOSBVbml2ZXJzaXR5IG9mIFN6ZWdlZAor ICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGlu IHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlv biwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwor ICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJl dGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlv bnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICog ICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxz IHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElT IFBST1ZJREVEIEJZIFVOSVZFUlNJVFkgT0YgU1pFR0VEIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBF WFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQg VE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklU TkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8g RVZFTlQgU0hBTEwgVU5JVkVSU0lUWSBPRiBTWkVHRUQgT1IKKyAqIENPTlRSSUJVVE9SUyBCRSBM SUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAorICog RVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBM SU1JVEVEIFRPLAorICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNF UzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJV UFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJVFks IFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNM VURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0Yg VEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NT SUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVmIFdURl9TdGF0aWNQdHJCYXNl X2gKKyNkZWZpbmUgV1RGX1N0YXRpY1B0ckJhc2VfaAorCisjaW5jbHVkZSAiQXNzZXJ0aW9ucy5o IgorI2luY2x1ZGUgIlR5cGVUcmFpdHMuaCIKKyNpbmNsdWRlICJBbHdheXNJbmxpbmUuaCIKKwor bmFtZXNwYWNlIFdURiB7CisKKy8vIFRoZSBjbGFzc2VzIGhlcmUgYXJlIGRlZmluZWQgYXMgc3Ry dWN0cyB0byBhdm9pZAorLy8gdGhlIGNhbGwgb2YgQysrIGNvbnN0cnVjdG9ycyBhbmQgZGVzdHJ1 Y3RvcnMKKworI2lmIEVOQUJMRShGUkVFX1NUQVRJQ19QVFJTKQordHlwZWRlZiB2b2lkICgqU3Rh dGljUHRyQmFzZUZyZWUpKHZvaWQqIHB0cik7CisKKy8vIE11c3QgYmUgdGhlIGZpcnN0IG1lbWJl ciBvZiBTdGF0aWNQdHJCYXNlIGRlc2NlbmRhbnRzCitzdHJ1Y3QgU3RhdGljUHRyQmFzZSB7Citw dWJsaWM6CisgICAgLy8gTWV0aG9kcworICAgIHZvaWQgYXBwZW5kKCk7CisgICAgdm9pZCByZW1v dmUoKTsKKworICAgIHN0YXRpYyB2b2lkIGZyZWVTdGF0aWNQdHJzKCk7CisKKyAgICBzdGF0aWMg U3RhdGljUHRyQmFzZSogbV9oZWFkOworICAgIFN0YXRpY1B0ckJhc2UqIG1fbmV4dDsKKyAgICBT dGF0aWNQdHJCYXNlRnJlZSBtX2ZyZWU7CisKKyAgICBzdGF0aWMgaW5saW5lIFN0YXRpY1B0ckJh c2UqIGhlYWQoKSB7IHJldHVybiBtX2hlYWQ7IH0KKyAgICBpbmxpbmUgU3RhdGljUHRyQmFzZSog bmV4dCgpIHsgcmV0dXJuIG1fbmV4dDsgfQorfTsKKyNlbmRpZgorCit9IC8vIG5hbWVzcGFjZSBX VEYKKworI2VuZGlmCmRpZmYgLS1naXQgYS9KYXZhU2NyaXB0Q29yZS93dGYvU3RkTGliRXh0cmFz LmggYi9KYXZhU2NyaXB0Q29yZS93dGYvU3RkTGliRXh0cmFzLmgKaW5kZXggZDIxZDFmZi4uMjlh M2YzYyAxMDA2NDQKLS0tIGEvSmF2YVNjcmlwdENvcmUvd3RmL1N0ZExpYkV4dHJhcy5oCisrKyBi L0phdmFTY3JpcHRDb3JlL3d0Zi9TdGRMaWJFeHRyYXMuaApAQCAtMjgsMTEgKzI4LDE2IEBACiAK ICNpbmNsdWRlIDx3dGYvUGxhdGZvcm0uaD4KICNpbmNsdWRlIDx3dGYvQXNzZXJ0aW9ucy5oPgor I2luY2x1ZGUgPHd0Zi9Mb2NhbFN0YXRpY1B0ci5oPgogCiAvLyBVc2UgdGhlc2UgdG8gZGVjbGFy ZSBhbmQgZGVmaW5lIGEgc3RhdGljIGxvY2FsIHZhcmlhYmxlIChzdGF0aWMgVDspIHNvIHRoYXQK IC8vICBpdCBpcyBsZWFrZWQgc28gdGhhdCBpdHMgZGVzdHJ1Y3RvcnMgYXJlIG5vdCBjYWxsZWQg YXQgZXhpdC4gVXNpbmcgdGhpcwogLy8gIG1hY3JvIGFsc28gYWxsb3dzIHdvcmthcm91bmRzIGEg Y29tcGlsZXIgYnVnIHByZXNlbnQgaW4gQXBwbGUncyB2ZXJzaW9uIG9mIEdDQyA0LjAuMS4KLSNp ZiBDT01QSUxFUihHQ0MpICYmIGRlZmluZWQoX19BUFBMRV9DQ19fKSAmJiBfX0dOVUNfXyA9PSA0 ICYmIF9fR05VQ19NSU5PUl9fID09IDAgJiYgX19HTlVDX1BBVENITEVWRUxfXyA9PSAxCisjaWYg RU5BQkxFKEZSRUVfU1RBVElDX1BUUlMpCisjZGVmaW5lIERFRklORV9TVEFUSUNfTE9DQUwodHlw ZSwgbmFtZSwgYXJndW1lbnRzKSBcCisgICAgc3RhdGljIFdURjo6TG9jYWxTdGF0aWNQdHI8dHlw ZT4gbmFtZSMjUHRyKG5ldyB0eXBlIGFyZ3VtZW50cyk7IFwKKyAgICB0eXBlJiBuYW1lID0gKm5h bWUjI1B0cgorI2VsaWYgQ09NUElMRVIoR0NDKSAmJiBkZWZpbmVkKF9fQVBQTEVfQ0NfXykgJiYg X19HTlVDX18gPT0gNCAmJiBfX0dOVUNfTUlOT1JfXyA9PSAwICYmIF9fR05VQ19QQVRDSExFVkVM X18gPT0gMQogI2RlZmluZSBERUZJTkVfU1RBVElDX0xPQ0FMKHR5cGUsIG5hbWUsIGFyZ3VtZW50 cykgXAogICAgIHN0YXRpYyB0eXBlKiBuYW1lIyNQdHIgPSBuZXcgdHlwZSBhcmd1bWVudHM7IFwK ICAgICB0eXBlJiBuYW1lID0gKm5hbWUjI1B0cgpkaWZmIC0tZ2l0IGEvSmF2YVNjcmlwdENvcmUv d3RmL1RocmVhZFNwZWNpZmljLmggYi9KYXZhU2NyaXB0Q29yZS93dGYvVGhyZWFkU3BlY2lmaWMu aAppbmRleCA0ZDVkMmY3Li44YmZkY2NmIDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0Q29yZS93dGYv VGhyZWFkU3BlY2lmaWMuaAorKysgYi9KYXZhU2NyaXB0Q29yZS93dGYvVGhyZWFkU3BlY2lmaWMu aApAQCAtMjMyLDcgKzIzMiw5IEBAIGlubGluZSB2b2lkIFRocmVhZFNwZWNpZmljPFQ+OjpkZXN0 cm95KHZvaWQqIHB0cikKICNlcnJvciBUaHJlYWRTcGVjaWZpYyBpcyBub3QgaW1wbGVtZW50ZWQg Zm9yIHRoaXMgcGxhdGZvcm0uCiAjZW5kaWYKIAorI2lmICFQTEFURk9STShRVCkKICAgICBkZWxl dGUgZGF0YTsKKyNlbmRpZgogfQogCiB0ZW1wbGF0ZTx0eXBlbmFtZSBUPgpkaWZmIC0tZ2l0IGEv V2ViQ29yZS9XZWJDb3JlLnBybyBiL1dlYkNvcmUvV2ViQ29yZS5wcm8KaW5kZXggODU5ZmM4Yy4u MmQxNDg1OCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9XZWJDb3JlLnBybworKysgYi9XZWJDb3JlL1dl YkNvcmUucHJvCkBAIC0xMDQzLDYgKzEwNDMsNyBAQCBTT1VSQ0VTICs9IFwKICAgICBodG1sL0hU TUxWaWV3U291cmNlRG9jdW1lbnQuY3BwIFwKICAgICBodG1sL0ltYWdlRGF0YS5jcHAgXAogICAg IGh0bWwvUHJlbG9hZFNjYW5uZXIuY3BwIFwKKyAgICBodG1sL1RpbWVSYW5nZXMuY3BwIFwKICAg ICBodG1sL1ZhbGlkaXR5U3RhdGUuY3BwIFwKICAgICBpbnNwZWN0b3IvQ29uc29sZU1lc3NhZ2Uu Y3BwIFwKICAgICBpbnNwZWN0b3IvSW5zcGVjdG9yQmFja2VuZC5jcHAgXApAQCAtMjYyOSw3ICsy NjMwLDYgQEAgY29udGFpbnMoREVGSU5FUywgRU5BQkxFX1ZJREVPPTEpIHsKICAgICAgICAgaHRt bC9IVE1MTWVkaWFFbGVtZW50LmNwcCBcCiAgICAgICAgIGh0bWwvSFRNTFNvdXJjZUVsZW1lbnQu Y3BwIFwKICAgICAgICAgaHRtbC9IVE1MVmlkZW9FbGVtZW50LmNwcCBcCi0gICAgICAgIGh0bWwv VGltZVJhbmdlcy5jcHAgXAogICAgICAgICBwbGF0Zm9ybS9ncmFwaGljcy9NZWRpYVBsYXllci5j cHAgXAogICAgICAgICByZW5kZXJpbmcvTWVkaWFDb250cm9sRWxlbWVudHMuY3BwIFwKICAgICAg ICAgcmVuZGVyaW5nL1JlbmRlclZpZGVvLmNwcCBcCmRpZmYgLS1naXQgYS9XZWJDb3JlL2JpbmRp bmdzL2pzL0pTRE9NV2luZG93QmFzZS5jcHAgYi9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTRE9NV2lu ZG93QmFzZS5jcHAKaW5kZXggZGY2MDY4YS4uYTFhZGRmNyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9i aW5kaW5ncy9qcy9KU0RPTVdpbmRvd0Jhc2UuY3BwCisrKyBiL1dlYkNvcmUvYmluZGluZ3MvanMv SlNET01XaW5kb3dCYXNlLmNwcApAQCAtMzUsNiArMzUsNyBAQAogI2luY2x1ZGUgIlNjcmlwdENv bnRyb2xsZXIuaCIKICNpbmNsdWRlICJTZWN1cml0eU9yaWdpbi5oIgogI2luY2x1ZGUgIlNldHRp bmdzLmgiCisjaW5jbHVkZSAid3RmL0dsb2JhbFB0ci5oIgogCiB1c2luZyBuYW1lc3BhY2UgSlND OwogCkBAIC0xNjEsMTUgKzE2MiwyNiBAQCBKU0RPTVdpbmRvd1NoZWxsKiBKU0RPTVdpbmRvd0Jh c2U6OnNoZWxsKCkgY29uc3QKICAgICByZXR1cm4gZCgpLT5zaGVsbDsKIH0KIAorI2lmIEVOQUJM RShGUkVFX1NUQVRJQ19QVFJTKQorc3RhdGljIHZvaWQgZ2xvYmFsRGF0YUZyZWUodm9pZCogcHRy KQoreworICAgIHJlaW50ZXJwcmV0X2Nhc3Q8V1RGOjpHbG9iYWxQdHI8SlNHbG9iYWxEYXRhPio+ KHB0ciktPmdldCgpLT5oZWFwLmRlc3Ryb3koKTsKKyAgICBkZWxldGUgcmVpbnRlcnByZXRfY2Fz dDxXVEY6Okdsb2JhbFB0cjxKU0dsb2JhbERhdGE+Kj4ocHRyKS0+Z2V0KCk7Cit9CisjZW5kaWYK KwogSlNHbG9iYWxEYXRhKiBKU0RPTVdpbmRvd0Jhc2U6OmNvbW1vbkpTR2xvYmFsRGF0YSgpCiB7 Ci0gICAgc3RhdGljIEpTR2xvYmFsRGF0YSogZ2xvYmFsRGF0YTsKKyAgICBzdGF0aWMgV1RGOjpH bG9iYWxQdHI8SlNHbG9iYWxEYXRhPiBnbG9iYWxEYXRhOwogICAgIGlmICghZ2xvYmFsRGF0YSkg ewotICAgICAgICBnbG9iYWxEYXRhID0gSlNHbG9iYWxEYXRhOjpjcmVhdGVMZWFrZWQoKS5yZWxl YXNlUmVmKCk7CisgICAgICAgIGdsb2JhbERhdGEuc2V0KEpTR2xvYmFsRGF0YTo6Y3JlYXRlTGVh a2VkKCkucmVsZWFzZVJlZigpKTsKKyNpZiBFTkFCTEUoRlJFRV9TVEFUSUNfUFRSUykKKyAgICAg ICAgZ2xvYmFsRGF0YS5zZXRGcmVlKGdsb2JhbERhdGFGcmVlKTsKKyNlbmRpZgogICAgICAgICBn bG9iYWxEYXRhLT50aW1lb3V0Q2hlY2tlci5zZXRUaW1lb3V0SW50ZXJ2YWwoMTAwMDApOyAvLyAx MCBzZWNvbmRzCiAgICAgfQogCi0gICAgcmV0dXJuIGdsb2JhbERhdGE7CisgICAgcmV0dXJuIGds b2JhbERhdGEuZ2V0KCk7CiB9CiAKIC8vIEpTRE9NR2xvYmFsT2JqZWN0KiBpcyBpZ25vcmVkLCBh Y2Nlc2luZyBhIHdpbmRvdyBpbiBhbnkgY29udGV4dCB3aWxsCmRpZmYgLS1naXQgYS9XZWJDb3Jl L2JyaWRnZS9JZGVudGlmaWVyUmVwLmNwcCBiL1dlYkNvcmUvYnJpZGdlL0lkZW50aWZpZXJSZXAu Y3BwCmluZGV4IDExNTYwZTMuLjE3MmUxNGQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYnJpZGdlL0lk ZW50aWZpZXJSZXAuY3BwCisrKyBiL1dlYkNvcmUvYnJpZGdlL0lkZW50aWZpZXJSZXAuY3BwCkBA IC0yOCw2ICsyOCw3IEBACiAKICNpbmNsdWRlICJQbGF0Zm9ybVN0cmluZy5oIgogI2luY2x1ZGUg PHJ1bnRpbWUvVVN0cmluZy5oPgorI2luY2x1ZGUgPHd0Zi9HbG9iYWxQdHIuaD4KICNpbmNsdWRl IDx3dGYvSGFzaE1hcC5oPgogI2luY2x1ZGUgPHd0Zi9TdGRMaWJFeHRyYXMuaD4KIApAQCAtNTQs OSArNTUsOSBAQCBzdGF0aWMgSW50SWRlbnRpZmllck1hcCYgaW50SWRlbnRpZmllck1hcCgpCiBJ ZGVudGlmaWVyUmVwKiBJZGVudGlmaWVyUmVwOjpnZXQoaW50IGludElEKQogewogICAgIGlmIChp bnRJRCA9PSAwIHx8IGludElEID09IC0xKSB7Ci0gICAgICAgIHN0YXRpYyBJZGVudGlmaWVyUmVw KiBuZWdhdGl2ZU9uZUFuZFplcm9JZGVudGlmaWVyc1syXTsKKyAgICAgICAgc3RhdGljIFdURjo6 R2xvYmFsUHRyPElkZW50aWZpZXJSZXA+IG5lZ2F0aXZlT25lQW5kWmVyb0lkZW50aWZpZXJzWzJd OwogCi0gICAgICAgIElkZW50aWZpZXJSZXAqIGlkZW50aWZpZXIgPSBuZWdhdGl2ZU9uZUFuZFpl cm9JZGVudGlmaWVyc1tpbnRJRCArIDFdOworICAgICAgICBJZGVudGlmaWVyUmVwKiBpZGVudGlm aWVyID0gbmVnYXRpdmVPbmVBbmRaZXJvSWRlbnRpZmllcnNbaW50SUQgKyAxXS5nZXQoKTsKICAg ICAgICAgaWYgKCFpZGVudGlmaWVyKSB7CiAgICAgICAgICAgICBpZGVudGlmaWVyID0gbmV3IElk ZW50aWZpZXJSZXAoaW50SUQpOwogCmRpZmYgLS1naXQgYS9XZWJDb3JlL2JyaWRnZS9JZGVudGlm aWVyUmVwLmggYi9XZWJDb3JlL2JyaWRnZS9JZGVudGlmaWVyUmVwLmgKaW5kZXggOGUwZTBkOS4u NTMzZDI2NiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9icmlkZ2UvSWRlbnRpZmllclJlcC5oCisrKyBi L1dlYkNvcmUvYnJpZGdlL0lkZW50aWZpZXJSZXAuaApAQCAtNTYsMTEgKzU2LDEzIEBAIHByaXZh dGU6CiAgICAgICAgIG1fdmFsdWUubV9zdHJpbmcgPSBzdHJkdXAobmFtZSk7CiAgICAgfQogICAg IAorI2lmICFFTkFCTEUoRlJFRV9TVEFUSUNfUFRSUykKICAgICB+SWRlbnRpZmllclJlcCgpCiAg ICAgewogICAgICAgICAvLyBJZGVudGlmaWVyUmVwcyBzaG91bGQgbmV2ZXIgYmUgZGVsZXRlZC4K ICAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CiAgICAgfQorI2VuZGlmCiAgICAgCiAgICAg dW5pb24gewogICAgICAgICBjb25zdCBjaGFyKiBtX3N0cmluZzsKZGlmZiAtLWdpdCBhL1dlYkNv cmUvY3NzL0NTU1ByaW1pdGl2ZVZhbHVlLmNwcCBiL1dlYkNvcmUvY3NzL0NTU1ByaW1pdGl2ZVZh bHVlLmNwcAppbmRleCAxZjJjOWNhLi4zMmJmNDg4IDEwMDY0NAotLS0gYS9XZWJDb3JlL2Nzcy9D U1NQcmltaXRpdmVWYWx1ZS5jcHAKKysrIGIvV2ViQ29yZS9jc3MvQ1NTUHJpbWl0aXZlVmFsdWUu Y3BwCkBAIC0zNCw2ICszNCw4IEBACiAjaW5jbHVkZSAiUmVjdC5oIgogI2luY2x1ZGUgIlJlbmRl clN0eWxlLmgiCiAjaW5jbHVkZSA8d3RmL0FTQ0lJQ1R5cGUuaD4KKyNpbmNsdWRlIDx3dGYvTG9j YWxTdGF0aWNQdHIuaD4KKyNpbmNsdWRlIDx3dGYvTG9jYWxTdGF0aWNBcnJheVB0ci5oPgogI2lu Y2x1ZGUgPHd0Zi9TdGRMaWJFeHRyYXMuaD4KIAogI2lmIEVOQUJMRShEQVNIQk9BUkRfU1VQUE9S VCkKQEAgLTUwLDcgKzUyLDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogCiBQYXNzUmVmUHRyPENT U1ByaW1pdGl2ZVZhbHVlPiBDU1NQcmltaXRpdmVWYWx1ZTo6Y3JlYXRlSWRlbnRpZmllcihpbnQg aWRlbnQpCiB7Ci0gICAgc3RhdGljIFJlZlB0cjxDU1NQcmltaXRpdmVWYWx1ZT4qIGlkZW50VmFs dWVDYWNoZSA9IG5ldyBSZWZQdHI8Q1NTUHJpbWl0aXZlVmFsdWU+W251bUNTU1ZhbHVlS2V5d29y ZHNdOworICAgIHN0YXRpYyBXVEY6OkxvY2FsU3RhdGljQXJyYXlQdHI8UmVmUHRyPENTU1ByaW1p dGl2ZVZhbHVlPiA+IGlkZW50VmFsdWVDYWNoZShuZXcgUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVl PltudW1DU1NWYWx1ZUtleXdvcmRzXSk7CiAgICAgaWYgKGlkZW50ID49IDAgJiYgaWRlbnQgPCBu dW1DU1NWYWx1ZUtleXdvcmRzKSB7CiAgICAgICAgIFJlZlB0cjxDU1NQcmltaXRpdmVWYWx1ZT4g cHJpbWl0aXZlVmFsdWUgPSBpZGVudFZhbHVlQ2FjaGVbaWRlbnRdOwogICAgICAgICBpZiAoIXBy aW1pdGl2ZVZhbHVlKSB7CkBAIC02NSw3ICs2Nyw3IEBAIFBhc3NSZWZQdHI8Q1NTUHJpbWl0aXZl VmFsdWU+IENTU1ByaW1pdGl2ZVZhbHVlOjpjcmVhdGVJZGVudGlmaWVyKGludCBpZGVudCkKIFBh c3NSZWZQdHI8Q1NTUHJpbWl0aXZlVmFsdWU+IENTU1ByaW1pdGl2ZVZhbHVlOjpjcmVhdGVDb2xv cih1bnNpZ25lZCByZ2JWYWx1ZSkKIHsKICAgICB0eXBlZGVmIEhhc2hNYXA8dW5zaWduZWQsIFJl ZlB0cjxDU1NQcmltaXRpdmVWYWx1ZT4gPiBDb2xvclZhbHVlQ2FjaGU7Ci0gICAgc3RhdGljIENv bG9yVmFsdWVDYWNoZSogY29sb3JWYWx1ZUNhY2hlID0gbmV3IENvbG9yVmFsdWVDYWNoZTsKKyAg ICBzdGF0aWMgV1RGOjpMb2NhbFN0YXRpY1B0cjxDb2xvclZhbHVlQ2FjaGU+IGNvbG9yVmFsdWVD YWNoZShuZXcgQ29sb3JWYWx1ZUNhY2hlKTsKICAgICAvLyBUaGVzZSBhcmUgdGhlIGVtcHR5IGFu ZCBkZWxldGVkIHZhbHVlcyBvZiB0aGUgaGFzaCB0YWJsZS4KICAgICBpZiAocmdiVmFsdWUgPT0g Q29sb3I6OnRyYW5zcGFyZW50KSB7CiAgICAgICAgIHN0YXRpYyBDU1NQcmltaXRpdmVWYWx1ZSog Y29sb3JUcmFuc3BhcmVudCA9IG5ldyBDU1NQcmltaXRpdmVWYWx1ZShDb2xvcjo6dHJhbnNwYXJl bnQpOwpAQCAtOTQsOCArOTYsOCBAQCBQYXNzUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVlPiBDU1NQ cmltaXRpdmVWYWx1ZTo6Y3JlYXRlKGRvdWJsZSB2YWx1ZSwgVW5pdFR5cGVzCiAgICAgY29uc3Qg aW50IGNhY2hlZEludGVnZXJDb3VudCA9IDEyODsKICAgICAvLyBPdGhlciBjb21tb24gcHJpbWl0 aXZlIHR5cGVzIGhhdmUgVW5pdFR5cGVzIHNtYWxsZXIgdGhhbiB0aGlzLgogICAgIGNvbnN0IGlu dCBtYXhDYWNoZWRVbml0VHlwZSA9IENTU19QWDsKLSAgICB0eXBlZGVmIFJlZlB0cjxDU1NQcmlt aXRpdmVWYWx1ZT4oKiBJbnRlZ2VyVmFsdWVDYWNoZSlbbWF4Q2FjaGVkVW5pdFR5cGUgKyAxXTsK LSAgICBzdGF0aWMgSW50ZWdlclZhbHVlQ2FjaGUgaW50ZWdlclZhbHVlQ2FjaGUgPSBuZXcgUmVm UHRyPENTU1ByaW1pdGl2ZVZhbHVlPltjYWNoZWRJbnRlZ2VyQ291bnRdW21heENhY2hlZFVuaXRU eXBlICsgMV07CisgICAgdHlwZWRlZiBSZWZQdHI8Q1NTUHJpbWl0aXZlVmFsdWU+IEludGVnZXJW YWx1ZUNhY2hlW21heENhY2hlZFVuaXRUeXBlICsgMV07CisgICAgc3RhdGljIFdURjo6TG9jYWxT dGF0aWNBcnJheVB0cjxJbnRlZ2VyVmFsdWVDYWNoZT4gaW50ZWdlclZhbHVlQ2FjaGUobmV3IFJl ZlB0cjxDU1NQcmltaXRpdmVWYWx1ZT5bY2FjaGVkSW50ZWdlckNvdW50XVttYXhDYWNoZWRVbml0 VHlwZSArIDFdKTsKICAgICBpZiAodHlwZSA8PSBtYXhDYWNoZWRVbml0VHlwZSAmJiB2YWx1ZSA+ PSAwICYmIHZhbHVlIDwgY2FjaGVkSW50ZWdlckNvdW50KSB7CiAgICAgICAgIGludCBpbnRWYWx1 ZSA9IHN0YXRpY19jYXN0PGludD4odmFsdWUpOwogICAgICAgICBpZiAodmFsdWUgPT0gaW50VmFs dWUpIHsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvY3NzL0NTU1N0eWxlU2VsZWN0b3IuY3BwIGIvV2Vi Q29yZS9jc3MvQ1NTU3R5bGVTZWxlY3Rvci5jcHAKaW5kZXggZTVhNzYzOC4uN2YzNWI1MyAxMDA2 NDQKLS0tIGEvV2ViQ29yZS9jc3MvQ1NTU3R5bGVTZWxlY3Rvci5jcHAKKysrIGIvV2ViQ29yZS9j c3MvQ1NTU3R5bGVTZWxlY3Rvci5jcHAKQEAgLTM3NiwxMyArMzc2LDEzIEBAIHB1YmxpYzoKICAg ICB1bnNpZ25lZCBtX3J1bGVDb3VudDsKIH07CiAKLXN0YXRpYyBDU1NSdWxlU2V0KiBkZWZhdWx0 U3R5bGU7Ci1zdGF0aWMgQ1NTUnVsZVNldCogZGVmYXVsdFF1aXJrc1N0eWxlOwotc3RhdGljIENT U1J1bGVTZXQqIGRlZmF1bHRQcmludFN0eWxlOwotc3RhdGljIENTU1J1bGVTZXQqIGRlZmF1bHRW aWV3U291cmNlU3R5bGU7Ci1zdGF0aWMgQ1NTU3R5bGVTaGVldCogc2ltcGxlRGVmYXVsdFN0eWxl U2hlZXQ7CitzdGF0aWMgV1RGOjpHbG9iYWxQdHI8Q1NTUnVsZVNldD4gZGVmYXVsdFN0eWxlOwor c3RhdGljIFdURjo6R2xvYmFsUHRyPENTU1J1bGVTZXQ+IGRlZmF1bHRRdWlya3NTdHlsZTsKK3N0 YXRpYyBXVEY6Okdsb2JhbFB0cjxDU1NSdWxlU2V0PiBkZWZhdWx0UHJpbnRTdHlsZTsKK3N0YXRp YyBXVEY6Okdsb2JhbFB0cjxDU1NSdWxlU2V0PiBkZWZhdWx0Vmlld1NvdXJjZVN0eWxlOworc3Rh dGljIFdURjo6R2xvYmFsUHRyPENTU1N0eWxlU2hlZXQ+IHNpbXBsZURlZmF1bHRTdHlsZVNoZWV0 OwogCi1SZW5kZXJTdHlsZSogQ1NTU3R5bGVTZWxlY3Rvcjo6c19zdHlsZU5vdFlldEF2YWlsYWJs ZTsKK1dURjo6R2xvYmFsUHRyPFJlbmRlclN0eWxlPiBDU1NTdHlsZVNlbGVjdG9yOjpzX3N0eWxl Tm90WWV0QXZhaWxhYmxlOwogCiBzdGF0aWMgUHNldWRvU3RhdGUgcHNldWRvU3RhdGU7CiAKQEAg LTUxMiwxMCArNTEyLDEwIEBAIHN0YXRpYyBDU1NTdHlsZVNoZWV0KiBwYXJzZVVBU2hlZXQoY29u c3QgY2hhciogY2hhcmFjdGVycywgdW5zaWduZWQgc2l6ZSkKIAogc3RhdGljIHZvaWQgbG9hZEZ1 bGxEZWZhdWx0U3R5bGUoKQogewotICAgIGlmIChzaW1wbGVEZWZhdWx0U3R5bGVTaGVldCkgewor ICAgIGlmIChzaW1wbGVEZWZhdWx0U3R5bGVTaGVldC5nZXQoKSkgewogICAgICAgICBBU1NFUlQo ZGVmYXVsdFN0eWxlKTsKLSAgICAgICAgZGVsZXRlIGRlZmF1bHRTdHlsZTsKLSAgICAgICAgZGVs ZXRlIHNpbXBsZURlZmF1bHRTdHlsZVNoZWV0OworICAgICAgICBkZWZhdWx0U3R5bGUuZGVsZXRl UHRyKCk7CisgICAgICAgIHNpbXBsZURlZmF1bHRTdHlsZVNoZWV0LmRlbGV0ZVB0cigpOwogICAg ICAgICBkZWZhdWx0U3R5bGUgPSBuZXcgQ1NTUnVsZVNldDsKICAgICAgICAgc2ltcGxlRGVmYXVs dFN0eWxlU2hlZXQgPSAwOwogICAgIH0gZWxzZSB7CkBAIC01NDcsNyArNTQ3LDcgQEAgc3RhdGlj IHZvaWQgbG9hZFNpbXBsZURlZmF1bHRTdHlsZSgpCiAgICAgZGVmYXVsdFF1aXJrc1N0eWxlID0g bmV3IENTU1J1bGVTZXQ7CiAKICAgICBzaW1wbGVEZWZhdWx0U3R5bGVTaGVldCA9IHBhcnNlVUFT aGVldChzaW1wbGVVc2VyQWdlbnRTdHlsZVNoZWV0LCBzdHJsZW4oc2ltcGxlVXNlckFnZW50U3R5 bGVTaGVldCkpOwotICAgIGRlZmF1bHRTdHlsZS0+YWRkUnVsZXNGcm9tU2hlZXQoc2ltcGxlRGVm YXVsdFN0eWxlU2hlZXQsIHNjcmVlbkV2YWwoKSk7CisgICAgZGVmYXVsdFN0eWxlLT5hZGRSdWxl c0Zyb21TaGVldChzaW1wbGVEZWZhdWx0U3R5bGVTaGVldC5nZXQoKSwgc2NyZWVuRXZhbCgpKTsK ICAgICAKICAgICAvLyBObyBuZWVkIHRvIGluaXRpYWxpemUgcXVpcmtzIHNoZWV0IHlldCBhcyB0 aGVyZSBhcmUgbm8gcXVpcmsgcnVsZXMgZm9yIGVsZW1lbnRzIGFsbG93ZWQgaW4gc2ltcGxlIGRl ZmF1bHQgc3R5bGUuCiB9CkBAIC0xMDcxLDE4ICsxMDcxLDE4IEBAIHZvaWQgQ1NTU3R5bGVTZWxl Y3Rvcjo6bWF0Y2hVQVJ1bGVzKGludCYgZmlyc3RVQVJ1bGUsIGludCYgbGFzdFVBUnVsZSkKIHsK ICAgICAvLyBGaXJzdCB3ZSBtYXRjaCBydWxlcyBmcm9tIHRoZSB1c2VyIGFnZW50IHNoZWV0Lgog ICAgIENTU1J1bGVTZXQqIHVzZXJBZ2VudFN0eWxlU2hlZXQgPSBtX21lZGl1bS0+bWVkaWFUeXBl TWF0Y2hTcGVjaWZpYygicHJpbnQiKQotICAgICAgICA/IGRlZmF1bHRQcmludFN0eWxlIDogZGVm YXVsdFN0eWxlOworICAgICAgICA/IGRlZmF1bHRQcmludFN0eWxlLmdldCgpIDogZGVmYXVsdFN0 eWxlLmdldCgpOwogICAgIG1hdGNoUnVsZXModXNlckFnZW50U3R5bGVTaGVldCwgZmlyc3RVQVJ1 bGUsIGxhc3RVQVJ1bGUpOwogCiAgICAgLy8gSW4gcXVpcmtzIG1vZGUsIHdlIG1hdGNoIHJ1bGVz IGZyb20gdGhlIHF1aXJrcyB1c2VyIGFnZW50IHNoZWV0LgogICAgIGlmICghbV9jaGVja2VyLm1f c3RyaWN0UGFyc2luZykKLSAgICAgICAgbWF0Y2hSdWxlcyhkZWZhdWx0UXVpcmtzU3R5bGUsIGZp cnN0VUFSdWxlLCBsYXN0VUFSdWxlKTsKKyAgICAgICAgbWF0Y2hSdWxlcyhkZWZhdWx0UXVpcmtz U3R5bGUuZ2V0KCksIGZpcnN0VUFSdWxlLCBsYXN0VUFSdWxlKTsKICAgICAgICAgCiAgICAgLy8g SWYgd2UncmUgaW4gdmlldyBzb3VyY2UgbW9kZSwgdGhlbiB3ZSBtYXRjaCBydWxlcyBmcm9tIHRo ZSB2aWV3IHNvdXJjZSBzdHlsZSBzaGVldC4KICAgICBpZiAobV9jaGVja2VyLm1fZG9jdW1lbnQt PmZyYW1lKCkgJiYgbV9jaGVja2VyLm1fZG9jdW1lbnQtPmZyYW1lKCktPmluVmlld1NvdXJjZU1v ZGUoKSkgewogICAgICAgICBpZiAoIWRlZmF1bHRWaWV3U291cmNlU3R5bGUpCiAgICAgICAgICAg ICBsb2FkVmlld1NvdXJjZVN0eWxlKCk7Ci0gICAgICAgIG1hdGNoUnVsZXMoZGVmYXVsdFZpZXdT b3VyY2VTdHlsZSwgZmlyc3RVQVJ1bGUsIGxhc3RVQVJ1bGUpOworICAgICAgICBtYXRjaFJ1bGVz KGRlZmF1bHRWaWV3U291cmNlU3R5bGUuZ2V0KCksIGZpcnN0VUFSdWxlLCBsYXN0VUFSdWxlKTsK ICAgICB9CiB9CiAKQEAgLTExMDIsNyArMTEwMiw3IEBAIFBhc3NSZWZQdHI8UmVuZGVyU3R5bGU+ IENTU1N0eWxlU2VsZWN0b3I6OnN0eWxlRm9yRWxlbWVudChFbGVtZW50KiBlLCBSZW5kZXJTdHls CiAgICAgICAgIH0KICAgICAgICAgc19zdHlsZU5vdFlldEF2YWlsYWJsZS0+cmVmKCk7CiAgICAg ICAgIGUtPmRvY3VtZW50KCktPnNldEhhc05vZGVzV2l0aFBsYWNlaG9sZGVyU3R5bGUoKTsKLSAg ICAgICAgcmV0dXJuIHNfc3R5bGVOb3RZZXRBdmFpbGFibGU7CisgICAgICAgIHJldHVybiBzX3N0 eWxlTm90WWV0QXZhaWxhYmxlLmdldCgpOwogICAgIH0KIAogICAgIGluaXRFbGVtZW50QW5kUHNl dWRvU3RhdGUoZSk7CkBAIC0xMTIwLDcgKzExMjAsNyBAQCBQYXNzUmVmUHRyPFJlbmRlclN0eWxl PiBDU1NTdHlsZVNlbGVjdG9yOjpzdHlsZUZvckVsZW1lbnQoRWxlbWVudCogZSwgUmVuZGVyU3R5 bAogICAgIGVsc2UKICAgICAgICAgbV9wYXJlbnRTdHlsZSA9IHN0eWxlKCk7CiAKLSAgICBpZiAo c2ltcGxlRGVmYXVsdFN0eWxlU2hlZXQgJiYgIWVsZW1lbnRDYW5Vc2VTaW1wbGVEZWZhdWx0U3R5 bGUoZSkpCisgICAgaWYgKHNpbXBsZURlZmF1bHRTdHlsZVNoZWV0LmdldCgpICYmICFlbGVtZW50 Q2FuVXNlU2ltcGxlRGVmYXVsdFN0eWxlKGUpKQogICAgICAgICBsb2FkRnVsbERlZmF1bHRTdHls ZSgpOwogCiAjaWYgRU5BQkxFKFNWRykKZGlmZiAtLWdpdCBhL1dlYkNvcmUvY3NzL0NTU1N0eWxl U2VsZWN0b3IuaCBiL1dlYkNvcmUvY3NzL0NTU1N0eWxlU2VsZWN0b3IuaAppbmRleCA2NjhjNmMz Li5hY2MyNmJlIDEwMDY0NAotLS0gYS9XZWJDb3JlL2Nzcy9DU1NTdHlsZVNlbGVjdG9yLmgKKysr IGIvV2ViQ29yZS9jc3MvQ1NTU3R5bGVTZWxlY3Rvci5oCkBAIC0yOCw2ICsyOCw3IEBACiAjaW5j bHVkZSAiTWVkaWFRdWVyeUV4cC5oIgogI2luY2x1ZGUgIlJlbmRlclN0eWxlLmgiCiAjaW5jbHVk ZSAiU3RyaW5nSGFzaC5oIgorI2luY2x1ZGUgPHd0Zi9HbG9iYWxQdHIuaD4KICNpbmNsdWRlIDx3 dGYvSGFzaE1hcC5oPgogI2luY2x1ZGUgPHd0Zi9IYXNoU2V0Lmg+CiAjaW5jbHVkZSA8d3RmL1Jl ZlB0ci5oPgpAQCAtMTg2LDcgKzE4Nyw3IEBAIHB1YmxpYzoKICAgICAgICAgS2V5ZnJhbWVzUnVs ZU1hcCBtX2tleWZyYW1lc1J1bGVNYXA7CiAKICAgICBwdWJsaWM6Ci0gICAgICAgIHN0YXRpYyBS ZW5kZXJTdHlsZSogc3R5bGVOb3RZZXRBdmFpbGFibGUoKSB7IHJldHVybiBzX3N0eWxlTm90WWV0 QXZhaWxhYmxlOyB9CisgICAgICAgIHN0YXRpYyBSZW5kZXJTdHlsZSogc3R5bGVOb3RZZXRBdmFp bGFibGUoKSB7IHJldHVybiBzX3N0eWxlTm90WWV0QXZhaWxhYmxlLmdldCgpOyB9CiAKICAgICAg ICAgY2xhc3MgU2VsZWN0b3JDaGVja2VyIDogcHVibGljIE5vbmNvcHlhYmxlIHsKICAgICAgICAg cHVibGljOgpAQCAtMjEwLDcgKzIxMSw3IEBAIHB1YmxpYzoKICAgICAgICAgfTsKIAogICAgIHBy aXZhdGU6Ci0gICAgICAgIHN0YXRpYyBSZW5kZXJTdHlsZSogc19zdHlsZU5vdFlldEF2YWlsYWJs ZTsKKyAgICAgICAgc3RhdGljIFdURjo6R2xvYmFsUHRyPFJlbmRlclN0eWxlPiBzX3N0eWxlTm90 WWV0QXZhaWxhYmxlOwogCiAgICAgICAgIHZvaWQgaW5pdCgpOwogCmRpZmYgLS1naXQgYS9XZWJD b3JlL2Nzcy9NZWRpYUZlYXR1cmVOYW1lcy5jcHAgYi9XZWJDb3JlL2Nzcy9NZWRpYUZlYXR1cmVO YW1lcy5jcHAKaW5kZXggZmNlZTVkZS4uNTZlNmUxOSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9jc3Mv TWVkaWFGZWF0dXJlTmFtZXMuY3BwCisrKyBiL1dlYkNvcmUvY3NzL01lZGlhRmVhdHVyZU5hbWVz LmNwcApAQCAtNDQsNyArNDQsNyBAQCB2b2lkIGluaXQoKQogICAgICAgIC8vIFVzZSBwbGFjZW1l bnQgbmV3IHRvIGluaXRpYWxpemUgdGhlIGdsb2JhbHMuCiAKICAgICAgICAgQXRvbWljU3RyaW5n Ojppbml0KCk7Ci0gICAgICAgICNkZWZpbmUgSU5JVElBTElaRV9HTE9CQUwobmFtZSwgc3RyKSBu ZXcgKCh2b2lkKikmbmFtZSMjTWVkaWFGZWF0dXJlKSBBdG9taWNTdHJpbmcoc3RyKTsKKyAgICAg ICAgI2RlZmluZSBJTklUSUFMSVpFX0dMT0JBTChuYW1lLCBzdHIpIElOSVRfR0xPQkFMKG5hbWUj I01lZGlhRmVhdHVyZSwgQXRvbWljU3RyaW5nLCBBdG9taWNTdHJpbmcoc3RyKSk7CiAgICAgICAg IENTU19NRURJQVFVRVJZX05BTUVTX0ZPUl9FQUNIX01FRElBRkVBVFVSRShJTklUSUFMSVpFX0dM T0JBTCkKICAgICAgICAgI3VuZGVmIElOSVRJQUxJWkVfR0xPQkFMCiAgICAgICAgIGluaXRpYWxp emVkID0gdHJ1ZTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvY3NzL01lZGlhUXVlcnlFdmFsdWF0b3Iu Y3BwIGIvV2ViQ29yZS9jc3MvTWVkaWFRdWVyeUV2YWx1YXRvci5jcHAKaW5kZXggNDk2M2VkNC4u MWVmZmZlNCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9jc3MvTWVkaWFRdWVyeUV2YWx1YXRvci5jcHAK KysrIGIvV2ViQ29yZS9jc3MvTWVkaWFRdWVyeUV2YWx1YXRvci5jcHAKQEAgLTQ1LDYgKzQ1LDcg QEAKICNpbmNsdWRlICJSZW5kZXJWaWV3LmgiCiAjaW5jbHVkZSAiUmVuZGVyU3R5bGUuaCIKICNp bmNsdWRlICJQbGF0Zm9ybVNjcmVlbi5oIgorI2luY2x1ZGUgPHd0Zi9HbG9iYWxQdHIuaD4KICNp bmNsdWRlIDx3dGYvSGFzaE1hcC5oPgogCiAjaWYgRU5BQkxFKDNEX1JFTkRFUklORykKQEAgLTU5 LDcgKzYwLDcgQEAgZW51bSBNZWRpYUZlYXR1cmVQcmVmaXggeyBNaW5QcmVmaXgsIE1heFByZWZp eCwgTm9QcmVmaXggfTsKIAogdHlwZWRlZiBib29sICgqRXZhbEZ1bmMpKENTU1ZhbHVlKiwgUmVu ZGVyU3R5bGUqLCBGcmFtZSosIE1lZGlhRmVhdHVyZVByZWZpeCk7CiB0eXBlZGVmIEhhc2hNYXA8 QXRvbWljU3RyaW5nSW1wbCosIEV2YWxGdW5jPiBGdW5jdGlvbk1hcDsKLXN0YXRpYyBGdW5jdGlv bk1hcCogZ0Z1bmN0aW9uTWFwOworc3RhdGljIFdURjo6R2xvYmFsUHRyPEZ1bmN0aW9uTWFwPiBn RnVuY3Rpb25NYXA7CiAKIC8qCiAgKiBGSVhNRTogZm9sbG93aW5nIG1lZGlhIGZlYXR1cmVzIGFy ZSBub3QgaW1wbGVtZW50ZWQ6IGNvbG9yX2luZGV4LCBzY2FuLCByZXNvbHV0aW9uCmRpZmYgLS1n aXQgYS9XZWJDb3JlL2RvbS9RdWFsaWZpZWROYW1lLmNwcCBiL1dlYkNvcmUvZG9tL1F1YWxpZmll ZE5hbWUuY3BwCmluZGV4IDYwN2M4NDYuLmFlMjNkMjEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZG9t L1F1YWxpZmllZE5hbWUuY3BwCisrKyBiL1dlYkNvcmUvZG9tL1F1YWxpZmllZE5hbWUuY3BwCkBA IC0yOCw2ICsyOCw3IEBACiAjaW5jbHVkZSAiUXVhbGlmaWVkTmFtZS5oIgogI2luY2x1ZGUgIlN0 YXRpY0NvbnN0cnVjdG9ycy5oIgogI2luY2x1ZGUgPHd0Zi9Bc3NlcnRpb25zLmg+CisjaW5jbHVk ZSA8d3RmL0dsb2JhbFB0ci5oPgogI2luY2x1ZGUgPHd0Zi9IYXNoU2V0Lmg+CiAKIG5hbWVzcGFj ZSBXZWJDb3JlIHsKQEAgLTQ5LDEyICs1MCwyNyBAQCBzdHJ1Y3QgUU5hbWVDb21wb25lbnRzVHJh bnNsYXRvciB7CiAgICAgfQogfTsKIAotc3RhdGljIFFOYW1lU2V0KiBnTmFtZUNhY2hlOworI2lm IEVOQUJMRShGUkVFX1NUQVRJQ19QVFJTKQorc3RhdGljIHZvaWQgZ05hbWVDYWNoZUZyZWUodm9p ZCogcHRyKQoreworICAgIFFOYW1lU2V0KiBnTmFtZUNhY2hlID0gcmVpbnRlcnByZXRfY2FzdDxX VEY6Okdsb2JhbFB0cjxRTmFtZVNldD4qPihwdHIpLT5nZXQoKTsKKyAgICBRTmFtZVNldDo6aXRl cmF0b3IgZW5kID0gZ05hbWVDYWNoZS0+ZW5kKCk7CisgICAgZm9yIChRTmFtZVNldDo6aXRlcmF0 b3IgY3VyciA9IGdOYW1lQ2FjaGUtPmJlZ2luKCk7IGN1cnIgIT0gZW5kOyArK2N1cnIpCisgICAg ICAgIGRlbGV0ZSAqY3VycjsKKyAgICBkZWxldGUgZ05hbWVDYWNoZTsKK30KKyNlbmRpZgorCitz dGF0aWMgV1RGOjpHbG9iYWxQdHI8UU5hbWVTZXQ+IGdOYW1lQ2FjaGU7CiAKIFF1YWxpZmllZE5h bWU6OlF1YWxpZmllZE5hbWUoY29uc3QgQXRvbWljU3RyaW5nJiBwLCBjb25zdCBBdG9taWNTdHJp bmcmIGwsIGNvbnN0IEF0b21pY1N0cmluZyYgbikKIHsKLSAgICBpZiAoIWdOYW1lQ2FjaGUpCi0g ICAgICAgIGdOYW1lQ2FjaGUgPSBuZXcgUU5hbWVTZXQ7CisgICAgaWYgKCFnTmFtZUNhY2hlKSB7 CisgICAgICAgIGdOYW1lQ2FjaGUuc2V0KG5ldyBRTmFtZVNldCk7CisjaWYgRU5BQkxFKEZSRUVf U1RBVElDX1BUUlMpCisgICAgICAgIGdOYW1lQ2FjaGUuc2V0RnJlZShnTmFtZUNhY2hlRnJlZSk7 CisjZW5kaWYKKyAgICB9CiAgICAgUXVhbGlmaWVkTmFtZUNvbXBvbmVudHMgY29tcG9uZW50cyA9 IHsgcC5pbXBsKCksIGwuaW1wbCgpLCBuLmlzRW1wdHkoKSA/IG51bGxBdG9tLmltcGwoKSA6IG4u aW1wbCgpIH07CiAgICAgcGFpcjxRTmFtZVNldDo6aXRlcmF0b3IsIGJvb2w+IGFkZFJlc3VsdCA9 IGdOYW1lQ2FjaGUtPmFkZDxRdWFsaWZpZWROYW1lQ29tcG9uZW50cywgUU5hbWVDb21wb25lbnRz VHJhbnNsYXRvcj4oY29tcG9uZW50cyk7CiAgICAgbV9pbXBsID0gKmFkZFJlc3VsdC5maXJzdDsg ICAgCkBAIC05Miw3ICsxMDgsNyBAQCB2b2lkIFF1YWxpZmllZE5hbWU6OmluaXQoKQogICAgICAg ICAvLyBVc2UgcGxhY2VtZW50IG5ldyB0byBpbml0aWFsaXplIHRoZSBnbG9iYWxzLgogICAgICAg ICAKICAgICAgICAgQXRvbWljU3RyaW5nOjppbml0KCk7Ci0gICAgICAgIG5ldyAoKHZvaWQqKSZh bnlOYW1lKSBRdWFsaWZpZWROYW1lKG51bGxBdG9tLCBzdGFyQXRvbSwgc3RhckF0b20pOworICAg ICAgICBJTklUX0dMT0JBTChhbnlOYW1lLCBRdWFsaWZpZWROYW1lLCBRdWFsaWZpZWROYW1lKG51 bGxBdG9tLCBzdGFyQXRvbSwgc3RhckF0b20pKTsKICAgICAgICAgaW5pdGlhbGl6ZWQgPSB0cnVl OwogICAgIH0KIH0KZGlmZiAtLWdpdCBhL1dlYkNvcmUvZG9tL21ha2VfbmFtZXMucGwgYi9XZWJD b3JlL2RvbS9tYWtlX25hbWVzLnBsCmluZGV4IDZiNWRkYjQuLjRjMDc5MmQgMTAwNzU1Ci0tLSBh L1dlYkNvcmUvZG9tL21ha2VfbmFtZXMucGwKKysrIGIvV2ViQ29yZS9kb20vbWFrZV9uYW1lcy5w bApAQCAtNTU3LDcgKzU1Nyw3IEBAIHByaW50IEYgIlxudm9pZCBpbml0KCkKICAgICBwcmludChG ICIgICAgQXRvbWljU3RyaW5nICR7bG93ZXJOYW1lc3BhY2V9TlMoXCIkcGFyYW1ldGVyc3tuYW1l c3BhY2VVUkl9XCIpO1xuXG4iKTsKIAogICAgIHByaW50KEYgIiAgICAvLyBOYW1lc3BhY2VcbiIp OwotICAgIHByaW50KEYgIiAgICBuZXcgKCh2b2lkKikmJHtsb3dlck5hbWVzcGFjZX1OYW1lc3Bh Y2VVUkkpIEF0b21pY1N0cmluZygke2xvd2VyTmFtZXNwYWNlfU5TKTtcblxuIik7CisgICAgcHJp bnQoRiAiICAgIElOSVRfR0xPQkFMKCR7bG93ZXJOYW1lc3BhY2V9TmFtZXNwYWNlVVJJLCBBdG9t aWNTdHJpbmcsIEF0b21pY1N0cmluZygke2xvd2VyTmFtZXNwYWNlfU5TKSk7XG5cbiIpOwogICAg IGlmIChrZXlzICV0YWdzKSB7CiAgICAgICAgIG15ICR0YWdzTmFtZXNwYWNlID0gJHBhcmFtZXRl cnN7dGFnc051bGxOYW1lc3BhY2V9ID8gIm51bGxBdG9tIiA6ICIke2xvd2VyTmFtZXNwYWNlfU5T IjsKICAgICAgICAgcHJpbnREZWZpbml0aW9ucygkRiwgXCV0YWdzLCAidGFncyIsICR0YWdzTmFt ZXNwYWNlKTsKQEAgLTY0MCw3ICs2NDAsNyBAQCBzdWIgcHJpbnREZWZpbml0aW9ucwogICAgIHBy aW50ICJcbiI7CiAKICAgICBmb3IgbXkgJG5hbWUgKHNvcnQga2V5cyAlJG5hbWVzUmVmKSB7Ci0g ICAgICAgIHByaW50IEYgIiAgICBuZXcgKCh2b2lkKikmJG5hbWUiLCIke3Nob3J0Q2FtZWxUeXBl fSkgUXVhbGlmaWVkTmFtZShudWxsQXRvbSwgJG5hbWUiLCIke3Nob3J0Q2FtZWxUeXBlfVN0cmlu ZywgJG5hbWVzcGFjZVVSSSk7XG4iOworICAgICAgICBwcmludCBGICIgICAgSU5JVF9HTE9CQUwo JG5hbWUiLCIke3Nob3J0Q2FtZWxUeXBlfSwgUXVhbGlmaWVkTmFtZSwgUXVhbGlmaWVkTmFtZShu dWxsQXRvbSwgJG5hbWUiLCIke3Nob3J0Q2FtZWxUeXBlfVN0cmluZywgJG5hbWVzcGFjZVVSSSkp O1xuIjsKICAgICB9CiB9CiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvaW5zcGVjdG9yL0phdmFTY3Jp cHREZWJ1Z1NlcnZlci5oIGIvV2ViQ29yZS9pbnNwZWN0b3IvSmF2YVNjcmlwdERlYnVnU2VydmVy LmgKaW5kZXggYmFhNjY5OS4uNTIwYjQ4MyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9pbnNwZWN0b3Iv SmF2YVNjcmlwdERlYnVnU2VydmVyLmgKKysrIGIvV2ViQ29yZS9pbnNwZWN0b3IvSmF2YVNjcmlw dERlYnVnU2VydmVyLmgKQEAgLTg1LDkgKzg1LDEwIEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAg ICAgICAgdHlwZWRlZiBIYXNoU2V0PEphdmFTY3JpcHREZWJ1Z0xpc3RlbmVyKj4gTGlzdGVuZXJT ZXQ7CiAgICAgICAgIHR5cGVkZWYgdm9pZCAoSmF2YVNjcmlwdERlYnVnTGlzdGVuZXI6OipKYXZh U2NyaXB0RXhlY3V0aW9uQ2FsbGJhY2spKCk7CiAKKyAgICAgICAgfkphdmFTY3JpcHREZWJ1Z1Nl cnZlcigpOworCiAgICAgcHJpdmF0ZToKICAgICAgICAgSmF2YVNjcmlwdERlYnVnU2VydmVyKCk7 Ci0gICAgICAgIH5KYXZhU2NyaXB0RGVidWdTZXJ2ZXIoKTsKIAogICAgICAgICBib29sIGhhc0xp c3RlbmVycygpIGNvbnN0IHsgcmV0dXJuICFtX2xpc3RlbmVycy5pc0VtcHR5KCkgfHwgIW1fcGFn ZUxpc3RlbmVyc01hcC5pc0VtcHR5KCk7IH0KICAgICAgICAgYm9vbCBoYXNHbG9iYWxMaXN0ZW5l cnMoKSBjb25zdCB7IHJldHVybiAhbV9saXN0ZW5lcnMuaXNFbXB0eSgpOyB9CmRpZmYgLS1naXQg YS9XZWJDb3JlL2xvYWRlci9JbWFnZUxvYWRlci5jcHAgYi9XZWJDb3JlL2xvYWRlci9JbWFnZUxv YWRlci5jcHAKaW5kZXggYjE4M2E2Ni4uMmQ2ZWFmZiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9sb2Fk ZXIvSW1hZ2VMb2FkZXIuY3BwCisrKyBiL1dlYkNvcmUvbG9hZGVyL0ltYWdlTG9hZGVyLmNwcApA QCAtNDEsNyArNDEsNiBAQCBwdWJsaWM6CiAgICAgdm9pZCBkaXNwYXRjaFBlbmRpbmdMb2FkRXZl bnRzKCk7CiAKIHByaXZhdGU6Ci0gICAgfkltYWdlTG9hZEV2ZW50U2VuZGVyKCk7CiAKICAgICB2 b2lkIHRpbWVyRmlyZWQoVGltZXI8SW1hZ2VMb2FkRXZlbnRTZW5kZXI+Kik7CiAKZGlmZiAtLWdp dCBhL1dlYkNvcmUvcGxhdGZvcm0vU3RhdGljQ29uc3RydWN0b3JzLmggYi9XZWJDb3JlL3BsYXRm b3JtL1N0YXRpY0NvbnN0cnVjdG9ycy5oCmluZGV4IDI2YjQ0ZGUuLmQ1YTMwNzEgMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvcGxhdGZvcm0vU3RhdGljQ29uc3RydWN0b3JzLmgKKysrIGIvV2ViQ29yZS9w bGF0Zm9ybS9TdGF0aWNDb25zdHJ1Y3RvcnMuaApAQCAtMjMsNiArMjMsOCBAQAogI2lmbmRlZiBT dGF0aWNDb25zdHJ1Y3RvcnNfaAogI2RlZmluZSBTdGF0aWNDb25zdHJ1Y3RvcnNfaAogCisjaW5j bHVkZSAid3RmL0xvY2FsU3RhdGljUHRyLmgiCisKIC8vIEZvciBXZWJDb3JlIHdlIG5lZWQgdG8g YXZvaWQgaGF2aW5nIHN0YXRpYyBjb25zdHJ1Y3RvcnMuIFdlIGFjaGlldmUgdGhpcwogLy8gd2l0 aCB0d28gc2VwYXJhdGUgbWV0aG9kcyBmb3IgR0NDIGFuZCBNU1ZDLiBCb3RoIG1ldGhvZHMgcHJl dmVudCB0aGUgc3RhdGljCiAvLyBpbml0aWFsaXplcnMgZnJvbSBiZWluZyByZWdpc3RlcmVkIGFu ZCBjYWxsZWQgb24gcHJvZ3JhbSBzdGFydHVwLiBPbiBHQ0MsIHdlCkBAIC03Myw0ICs3NSwxNCBA QAogI2VuZGlmCiAjZW5kaWYKIAorI2lmIEVOQUJMRShGUkVFX1NUQVRJQ19QVFJTKQorI2RlZmlu ZSBJTklUX0dMT0JBTChuYW1lLCB0eXBlLCBhcmd1bWVudHMpIFwKKyAgICBuZXcgKCh2b2lkKikm bmFtZSkgYXJndW1lbnRzOyBcCisgICAgc3RhdGljIFdURjo6TG9jYWxTdGF0aWNQdHI8dHlwZT4g bmFtZSMjUmVmKCh0eXBlKikmbmFtZSk7IFwKKyAgICBuYW1lIyNSZWYuc2V0RnJlZShXVEY6Okxv Y2FsU3RhdGljUHRyPHR5cGU+OjpkZXN0cm95KTsKKyNlbHNlCisjZGVmaW5lIElOSVRfR0xPQkFM KG5hbWUsIHR5cGUsIGFyZ3VtZW50cykgXAorICAgIG5ldyAoKHZvaWQqKSZuYW1lKSBhcmd1bWVu dHMKKyNlbmRpZgorCiAjZW5kaWYgLy8gU3RhdGljQ29uc3RydWN0b3JzX2gKZGlmZiAtLWdpdCBh L1dlYkNvcmUvcGxhdGZvcm0vVGhyZWFkR2xvYmFsRGF0YS5jcHAgYi9XZWJDb3JlL3BsYXRmb3Jt L1RocmVhZEdsb2JhbERhdGEuY3BwCmluZGV4IGE0M2U5YmQuLjQ2MmVmNjQgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvcGxhdGZvcm0vVGhyZWFkR2xvYmFsRGF0YS5jcHAKKysrIGIvV2ViQ29yZS9wbGF0 Zm9ybS9UaHJlYWRHbG9iYWxEYXRhLmNwcApAQCAtMzAsNiArMzAsNyBAQAogI2luY2x1ZGUgIkV2 ZW50TmFtZXMuaCIKICNpbmNsdWRlICJTdHJpbmdJbXBsLmgiCiAjaW5jbHVkZSAiVGhyZWFkVGlt ZXJzLmgiCisjaW5jbHVkZSA8d3RmL0xvY2FsU3RhdGljUHRyLmg+CiAjaW5jbHVkZSA8d3RmL1Vu dXNlZFBhcmFtLmg+CiAKICNpZiBVU0UoSUNVX1VOSUNPREUpIHx8IFVTRShHTElCX0lDVV9VTklD T0RFX0hZQlJJRCkKQEAgLTU0LDE0ICs1NSwxNCBAQCBUaHJlYWRHbG9iYWxEYXRhJiB0aHJlYWRH bG9iYWxEYXRhKCkKICAgICAvLyBXZSBuZWVkIHRvIGNoZWNrIGZvciBlLmcuIGRhdGFiYXNlIG9i amVjdHMgbWFuaXB1bGF0aW5nIHN0cmluZ3Mgb24gc2Vjb25kYXJ5IHRocmVhZHMuCiAjaWYgRU5B QkxFKFdPUktFUlMpCiAgICAgLy8gVGhyZWFkR2xvYmFsRGF0YSBpcyB1c2VkIG9uIG1haW4gdGhy ZWFkIGJlZm9yZSBpdCBjb3VsZCBwb3NzaWJseSBiZSB1c2VkIG9uIHNlY29uZGFyeSBvbmVzLCBz byB0aGVyZSBpcyBubyBuZWVkIGZvciBzeW5jaHJvbml6YXRpb24gaGVyZS4KLSAgICBzdGF0aWMg VGhyZWFkU3BlY2lmaWM8VGhyZWFkR2xvYmFsRGF0YT4qIHRocmVhZEdsb2JhbERhdGEgPSBuZXcg VGhyZWFkU3BlY2lmaWM8VGhyZWFkR2xvYmFsRGF0YT47CisgICAgc3RhdGljIFdURjo6TG9jYWxT dGF0aWNQdHI8IFRocmVhZFNwZWNpZmljPFRocmVhZEdsb2JhbERhdGE+ID4gdGhyZWFkR2xvYmFs RGF0YShuZXcgVGhyZWFkU3BlY2lmaWM8VGhyZWFkR2xvYmFsRGF0YT4pOwogICAgIHJldHVybiAq KnRocmVhZEdsb2JhbERhdGE7CiAjZWxzZQotICAgIHN0YXRpYyBUaHJlYWRHbG9iYWxEYXRhKiBz dGF0aWNEYXRhOworICAgIHN0YXRpYyBXVEY6OlN0YXRpY1B0cjxUaHJlYWRHbG9iYWxEYXRhPiBz dGF0aWNEYXRhOwogICAgIGlmICghc3RhdGljRGF0YSkgewogICAgICAgICBzdGF0aWNEYXRhID0g c3RhdGljX2Nhc3Q8VGhyZWFkR2xvYmFsRGF0YSo+KGZhc3RNYWxsb2Moc2l6ZW9mKFRocmVhZEds b2JhbERhdGEpKSk7CiAgICAgICAgIC8vIFRocmVhZEdsb2JhbERhdGEgY29uc3RydWN0b3IgaW5k aXJlY3RseSB1c2VzIHN0YXRpY0RhdGEsIHNvIHdlIG5lZWQgdG8gc2V0IHVwIHRoZSBtZW1vcnkg YmVmb3JlIGludm9raW5nIGl0LgotICAgICAgICBuZXcgKHN0YXRpY0RhdGEpIFRocmVhZEdsb2Jh bERhdGE7CisgICAgICAgIG5ldyAoc3RhdGljRGF0YS5nZXQoKSkgVGhyZWFkR2xvYmFsRGF0YTsK ICAgICB9CiAgICAgcmV0dXJuICpzdGF0aWNEYXRhOwogI2VuZGlmCmRpZmYgLS1naXQgYS9XZWJD b3JlL3BsYXRmb3JtL1RocmVhZFRpbWVycy5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL1RocmVhZFRp bWVycy5jcHAKaW5kZXggNzFhMDZiMC4uNDRhMGRkMSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0 Zm9ybS9UaHJlYWRUaW1lcnMuY3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vVGhyZWFkVGltZXJz LmNwcApAQCAtMzEsNiArMzEsNyBAQAogI2luY2x1ZGUgIlRocmVhZEdsb2JhbERhdGEuaCIKICNp bmNsdWRlICJUaW1lci5oIgogI2luY2x1ZGUgPHd0Zi9DdXJyZW50VGltZS5oPgorI2luY2x1ZGUg PHd0Zi9Mb2NhbFN0YXRpY1B0ci5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKQEAgLTM5LDgg KzQwLDggQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogCiBzdGF0aWMgTWFpblRocmVhZFNoYXJlZFRp bWVyKiBtYWluVGhyZWFkU2hhcmVkVGltZXIoKQogewotICAgIHN0YXRpYyBNYWluVGhyZWFkU2hh cmVkVGltZXIqIHRpbWVyID0gbmV3IE1haW5UaHJlYWRTaGFyZWRUaW1lcjsKLSAgICByZXR1cm4g dGltZXI7CisgICAgc3RhdGljIFdURjo6TG9jYWxTdGF0aWNQdHI8TWFpblRocmVhZFNoYXJlZFRp bWVyPiB0aW1lcihuZXcgTWFpblRocmVhZFNoYXJlZFRpbWVyKTsKKyAgICByZXR1cm4gdGltZXIu Z2V0KCk7CiB9CiAKIFRocmVhZFRpbWVyczo6VGhyZWFkVGltZXJzKCkKZGlmZiAtLWdpdCBhL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvRm9udENhY2hlLmggYi9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL0ZvbnRDYWNoZS5oCmluZGV4IDNjMGYyZDkuLjg4MjAwNDUgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvRm9udENhY2hlLmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9Gb250Q2FjaGUuaApAQCAtODUsNyArODUsNiBAQCBwdWJsaWM6CiAKIHByaXZh dGU6CiAgICAgRm9udENhY2hlKCk7Ci0gICAgfkZvbnRDYWNoZSgpOwogCiAgICAgLy8gVGhlc2Ug bWV0aG9kcyBhcmUgaW1wbGVtZW50ZWQgYnkgZWFjaCBwbGF0Zm9ybS4KICAgICBGb250UGxhdGZv cm1EYXRhKiBnZXRTaW1pbGFyRm9udFBsYXRmb3JtRGF0YShjb25zdCBGb250Jik7CmRpZmYgLS1n aXQgYS9XZWJDb3JlL3BsYXRmb3JtL3F0L1NoYXJlZFRpbWVyUXQuY3BwIGIvV2ViQ29yZS9wbGF0 Zm9ybS9xdC9TaGFyZWRUaW1lclF0LmNwcAppbmRleCBlOWJjYWVlLi44ODQxMmE3IDEwMDY0NAot LS0gYS9XZWJDb3JlL3BsYXRmb3JtL3F0L1NoYXJlZFRpbWVyUXQuY3BwCisrKyBiL1dlYkNvcmUv cGxhdGZvcm0vcXQvU2hhcmVkVGltZXJRdC5jcHAKQEAgLTY0LDggKzY0LDEwIEBAIFNoYXJlZFRp bWVyUXQ6OlNoYXJlZFRpbWVyUXQoUU9iamVjdCogcGFyZW50KQogCiBTaGFyZWRUaW1lclF0Ojp+ U2hhcmVkVGltZXJRdCgpCiB7CisjaWYgIUVOQUJMRShGUkVFX1NUQVRJQ19QVFJTKQogICAgIGlm IChtX3RpbWVyLmlzQWN0aXZlKCkpCiAgICAgICAgIChtX3RpbWVyRnVuY3Rpb24pKCk7CisjZW5k aWYKIH0KIAogU2hhcmVkVGltZXJRdCogU2hhcmVkVGltZXJRdDo6aW5zdCgpCmRpZmYgLS1naXQg YS9XZWJDb3JlL3BsYXRmb3JtL3RleHQvQXRvbWljU3RyaW5nLmNwcCBiL1dlYkNvcmUvcGxhdGZv cm0vdGV4dC9BdG9taWNTdHJpbmcuY3BwCmluZGV4IDQwOTQzOWUuLjI1ZmJmZDIgMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvcGxhdGZvcm0vdGV4dC9BdG9taWNTdHJpbmcuY3BwCisrKyBiL1dlYkNvcmUv cGxhdGZvcm0vdGV4dC9BdG9taWNTdHJpbmcuY3BwCkBAIC0yOTUsMTEgKzI5NSwxMSBAQCB2b2lk IEF0b21pY1N0cmluZzo6aW5pdCgpCiAgICAgICAgIEFTU0VSVChpc01haW5UaHJlYWQoKSk7CiAK ICAgICAgICAgLy8gVXNlIHBsYWNlbWVudCBuZXcgdG8gaW5pdGlhbGl6ZSB0aGUgZ2xvYmFscy4K LSAgICAgICAgbmV3ICgodm9pZCopJm51bGxBdG9tKSBBdG9taWNTdHJpbmc7Ci0gICAgICAgIG5l dyAoKHZvaWQqKSZlbXB0eUF0b20pIEF0b21pY1N0cmluZygiIik7Ci0gICAgICAgIG5ldyAoKHZv aWQqKSZ0ZXh0QXRvbSkgQXRvbWljU3RyaW5nKCIjdGV4dCIpOwotICAgICAgICBuZXcgKCh2b2lk KikmY29tbWVudEF0b20pIEF0b21pY1N0cmluZygiI2NvbW1lbnQiKTsKLSAgICAgICAgbmV3ICgo dm9pZCopJnN0YXJBdG9tKSBBdG9taWNTdHJpbmcoIioiKTsKKyAgICAgICAgSU5JVF9HTE9CQUwo bnVsbEF0b20sIEF0b21pY1N0cmluZywgQXRvbWljU3RyaW5nKTsKKyAgICAgICAgSU5JVF9HTE9C QUwoZW1wdHlBdG9tLCBBdG9taWNTdHJpbmcsIEF0b21pY1N0cmluZygiIikpOworICAgICAgICBJ TklUX0dMT0JBTCh0ZXh0QXRvbSwgQXRvbWljU3RyaW5nLCBBdG9taWNTdHJpbmcoIiN0ZXh0Iikp OworICAgICAgICBJTklUX0dMT0JBTChjb21tZW50QXRvbSwgQXRvbWljU3RyaW5nLCBBdG9taWNT dHJpbmcoIiNjb21tZW50IikpOworICAgICAgICBJTklUX0dMT0JBTChzdGFyQXRvbSwgQXRvbWlj U3RyaW5nLCBBdG9taWNTdHJpbmcoIioiKSk7CiAKICAgICAgICAgaW5pdGlhbGl6ZWQgPSB0cnVl OwogICAgIH0KZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGx1Z2lucy9QbHVnaW5EYXRhYmFzZS5jcHAg Yi9XZWJDb3JlL3BsdWdpbnMvUGx1Z2luRGF0YWJhc2UuY3BwCmluZGV4IDI5OTA4MzYuLmU3M2Qz ZTQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGx1Z2lucy9QbHVnaW5EYXRhYmFzZS5jcHAKKysrIGIv V2ViQ29yZS9wbHVnaW5zL1BsdWdpbkRhdGFiYXNlLmNwcApAQCAtMzEsNiArMzEsNyBAQAogI2lu Y2x1ZGUgIktVUkwuaCIKICNpbmNsdWRlICJQbHVnaW5QYWNrYWdlLmgiCiAjaW5jbHVkZSA8c3Rk bGliLmg+CisjaW5jbHVkZSA8d3RmL0dsb2JhbFB0ci5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7 CiAKQEAgLTM4LDcgKzM5LDcgQEAgdHlwZWRlZiBIYXNoTWFwPFN0cmluZywgUmVmUHRyPFBsdWdp blBhY2thZ2U+ID4gUGx1Z2luUGFja2FnZUJ5TmFtZU1hcDsKIAogUGx1Z2luRGF0YWJhc2UqIFBs dWdpbkRhdGFiYXNlOjppbnN0YWxsZWRQbHVnaW5zKGJvb2wgcG9wdWxhdGUpCiB7Ci0gICAgc3Rh dGljIFBsdWdpbkRhdGFiYXNlKiBwbHVnaW5zID0gMDsKKyAgICBzdGF0aWMgV1RGOjpHbG9iYWxQ dHI8UGx1Z2luRGF0YWJhc2U+IHBsdWdpbnM7CiAKICAgICBpZiAoIXBsdWdpbnMpIHsKICAgICAg ICAgcGx1Z2lucyA9IG5ldyBQbHVnaW5EYXRhYmFzZTsKQEAgLTQ5LDcgKzUwLDcgQEAgUGx1Z2lu RGF0YWJhc2UqIFBsdWdpbkRhdGFiYXNlOjppbnN0YWxsZWRQbHVnaW5zKGJvb2wgcG9wdWxhdGUp CiAgICAgICAgIH0KICAgICB9CiAKLSAgICByZXR1cm4gcGx1Z2luczsKKyAgICByZXR1cm4gcGx1 Z2lucy5nZXQoKTsKIH0KIAogYm9vbCBQbHVnaW5EYXRhYmFzZTo6aXNNSU1FVHlwZVJlZ2lzdGVy ZWQoY29uc3QgU3RyaW5nJiBtaW1lVHlwZSkKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcmVuZGVyaW5n L3N0eWxlL1JlbmRlclN0eWxlLmNwcCBiL1dlYkNvcmUvcmVuZGVyaW5nL3N0eWxlL1JlbmRlclN0 eWxlLmNwcAppbmRleCBhODYxZmVhLi5lNGM4N2VlIDEwMDY0NAotLS0gYS9XZWJDb3JlL3JlbmRl cmluZy9zdHlsZS9SZW5kZXJTdHlsZS5jcHAKKysrIGIvV2ViQ29yZS9yZW5kZXJpbmcvc3R5bGUv UmVuZGVyU3R5bGUuY3BwCkBAIC0yOSw2ICsyOSw3IEBACiAjaW5jbHVkZSAiUmVuZGVyQXJlbmEu aCIKICNpbmNsdWRlICJSZW5kZXJPYmplY3QuaCIKICNpbmNsdWRlICJTdHlsZUltYWdlLmgiCisj aW5jbHVkZSA8d3RmL0xvY2FsU3RhdGljUHRyLmg+CiAjaW5jbHVkZSA8d3RmL1N0ZExpYkV4dHJh cy5oPgogI2luY2x1ZGUgPGFsZ29yaXRobT4KIApAQCAtMzgsOCArMzksOCBAQCBuYW1lc3BhY2Ug V2ViQ29yZSB7CiAKIGlubGluZSBSZW5kZXJTdHlsZSogZGVmYXVsdFN0eWxlKCkKIHsKLSAgICBz dGF0aWMgUmVuZGVyU3R5bGUqIHNfZGVmYXVsdFN0eWxlID0gUmVuZGVyU3R5bGU6OmNyZWF0ZURl ZmF1bHRTdHlsZSgpLnJlbGVhc2VSZWYoKTsKLSAgICByZXR1cm4gc19kZWZhdWx0U3R5bGU7Cisg ICAgc3RhdGljIFdURjo6TG9jYWxTdGF0aWNQdHI8UmVuZGVyU3R5bGU+IHNfZGVmYXVsdFN0eWxl KFJlbmRlclN0eWxlOjpjcmVhdGVEZWZhdWx0U3R5bGUoKS5yZWxlYXNlUmVmKCkpOworICAgIHJl dHVybiBzX2RlZmF1bHRTdHlsZS5nZXQoKTsKIH0KIAogUGFzc1JlZlB0cjxSZW5kZXJTdHlsZT4g UmVuZGVyU3R5bGU6OmNyZWF0ZSgpCmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFt ZS5jcHAgYi9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5jcHAKaW5kZXggNGVhM2Q0Yy4uNjBjY2Nl OCAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuY3BwCisrKyBiL1dlYktpdC9x dC9BcGkvcXdlYmZyYW1lLmNwcApAQCAtNzgsNiArNzgsMTAgQEAKICNpbmNsdWRlIDxxcHJpbnRl ci5oPgogI2luY2x1ZGUgPHFyZWdpb24uaD4KIAorI2lmIEVOQUJMRShGUkVFX1NUQVRJQ19QVFJT KQorI2luY2x1ZGUgInd0Zi9TdGF0aWNQdHJCYXNlLmgiCisjZW5kaWYKKwogI2lmIFFUX1ZFUlNJ T04gPCAweDA0MDQwMAogI2luY2x1ZGUgInF3ZWJuZXR3b3JraW50ZXJmYWNlLmgiCiAjZW5kaWYK QEAgLTE4NSw2ICsxODksMTQgQEAgdm9pZCBRV0VCS0lUX0VYUE9SVCBxdF9kcnRfZ2FyYmFnZUNv bGxlY3Rvcl9jb2xsZWN0T25BbHRlcm5hdGVUaHJlYWQoYm9vbCB3YWl0VW4KICAgICBnY0NvbnRy b2xsZXIoKS5nYXJiYWdlQ29sbGVjdE9uQWx0ZXJuYXRlVGhyZWFkRm9yRGVidWdnaW5nKHdhaXRV bnRpbERvbmUpOwogfQogCit2b2lkIFFXRUJLSVRfRVhQT1JUIHF0X2RydF9mcmVlU3RhdGljUHRy cygpCit7CisjaWYgRU5BQkxFKEZSRUVfU1RBVElDX1BUUlMpCisgICAgLy8gRG9lcyBub3RoaW5n IGlmIEZSRUVfU1RBVElDX1BUUlMgZGlzYWJsZWQKKyAgICBXVEY6OlN0YXRpY1B0ckJhc2U6OmZy ZWVTdGF0aWNQdHJzKCk7CisjZW5kaWYKK30KKwogUVdlYkZyYW1lRGF0YTo6UVdlYkZyYW1lRGF0 YShXZWJDb3JlOjpQYWdlKiBwYXJlbnRQYWdlLCBXZWJDb3JlOjpGcmFtZSogcGFyZW50RnJhbWUs CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFdlYkNvcmU6OkhUTUxGcmFtZU93bmVyRWxl bWVudCogb3duZXJGcmFtZUVsZW1lbnQsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNv bnN0IFdlYkNvcmU6OlN0cmluZyYgZnJhbWVOYW1lKQpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L1F0 TGF1bmNoZXIvbWFpbi5jcHAgYi9XZWJLaXQvcXQvUXRMYXVuY2hlci9tYWluLmNwcAppbmRleCAz NzkwOWFmLi41YWE3MjE2IDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvUXRMYXVuY2hlci9tYWluLmNw cAorKysgYi9XZWJLaXQvcXQvUXRMYXVuY2hlci9tYWluLmNwcApAQCAtNTMsNiArNTMsNyBAQAog CiAjaWZuZGVmIE5ERUJVRwogdm9pZCBRV0VCS0lUX0VYUE9SVCBxdF9kcnRfZ2FyYmFnZUNvbGxl Y3Rvcl9jb2xsZWN0KCk7Cit2b2lkIFFXRUJLSVRfRVhQT1JUIHF0X2RydF9mcmVlU3RhdGljUHRy cygpOwogI2VuZGlmCiAKIGNsYXNzIFdlYlBhZ2UgOiBwdWJsaWMgUVdlYlBhZ2UKQEAgLTI4Niw3 ICsyODcsNyBAQCBwcml2YXRlOgogICAgICAgICB2aWV3TWVudS0+YWRkU2VwYXJhdG9yKCk7CiAg ICAgICAgIHZpZXdNZW51LT5hZGRBY3Rpb24oIkR1bXAgSFRNTCIsIHRoaXMsIFNMT1QoZHVtcEh0 bWwoKSkpOwogCi0gICAgICAgIFFNZW51ICpmb3JtYXRNZW51ID0gbmV3IFFNZW51KCJGJm9ybWF0 Iik7CisgICAgICAgIFFNZW51ICpmb3JtYXRNZW51ID0gbmV3IFFNZW51KCJGJm9ybWF0IiwgdGhp cyk7CiAgICAgICAgIGZvcm1hdE1lbnVBY3Rpb24gPSBtZW51QmFyKCktPmFkZE1lbnUoZm9ybWF0 TWVudSk7CiAgICAgICAgIGZvcm1hdE1lbnVBY3Rpb24tPnNldFZpc2libGUoZmFsc2UpOwogICAg ICAgICBmb3JtYXRNZW51LT5hZGRBY3Rpb24odmlldy0+cGFnZUFjdGlvbihRV2ViUGFnZTo6VG9n Z2xlQm9sZCkpOwpAQCAtNDIxLDYgKzQyMiw3IEBAIGludCBsYXVuY2hlck1haW4oY29uc3QgUUFw cGxpY2F0aW9uJiBhcHApCiAgICAgaW50IHJldFZhbCA9IGFwcC5leGVjKCk7CiAgICAgcXRfZHJ0 X2dhcmJhZ2VDb2xsZWN0b3JfY29sbGVjdCgpOwogICAgIFFXZWJTZXR0aW5nczo6Y2xlYXJNZW1v cnlDYWNoZXMoKTsKKyAgICBxdF9kcnRfZnJlZVN0YXRpY1B0cnMoKTsKICAgICByZXR1cm4gcmV0 VmFsOwogI2Vsc2UKICAgICByZXR1cm4gYXBwLmV4ZWMoKTsKLS0gCjEuNi4wLjQKCg== 39334 2009-09-10 02:07:35 -0700 2010-06-10 19:43:26 -0700 Sixth patch StaticPtrs-draft-0.6.patch text/plain 61008 zherczeg RnJvbSAyZmY4MmRmMzQ4OGQ0YWIzZTJkMzhiYjVmNTgxMGViYWMyNTY1MDkwIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBab2x0YW4gSGVyY3plZyA8emhlcmN6ZWdAaW5mLnUtc3plZ2Vk Lmh1PgpEYXRlOiBUaHUsIDEwIFNlcCAyMDA5IDEwOjIxOjA1ICswMjAwClN1YmplY3Q6IFtQQVRD SF0gU3RhdGljIFB0ciBkcmFmdAoKU2lnbmVkLW9mZi1ieTogWm9sdGFuIEhlcmN6ZWcgPHpoZXJj emVnQGluZi51LXN6ZWdlZC5odT4KLS0tCiBKYXZhU2NyaXB0Q29yZS9KYXZhU2NyaXB0Q29yZS5w cmkgICAgICAgICAgfCAgICAxICsKIEphdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNHbG9iYWxEYXRh LmNwcCAgICB8ICAgMjMgKystLQogSmF2YVNjcmlwdENvcmUvcnVudGltZS9KU0dsb2JhbERhdGEu aCAgICAgIHwgICAgMSAtCiBKYXZhU2NyaXB0Q29yZS9ydW50aW1lL0xvb2t1cC5jcHAgICAgICAg ICAgfCAgIDIzICsrKysKIEphdmFTY3JpcHRDb3JlL3J1bnRpbWUvVVN0cmluZy5jcHAgICAgICAg ICB8ICAgIDYgKy0KIEphdmFTY3JpcHRDb3JlL3J1bnRpbWUvVVN0cmluZy5oICAgICAgICAgICB8 ICAgIDcgKy0KIEphdmFTY3JpcHRDb3JlL3d0Zi9HbG9iYWxQdHIuaCAgICAgICAgICAgICB8ICAx NjcgKysrKysrKysrKysrKysrKysrKysrKysrKysrKwogSmF2YVNjcmlwdENvcmUvd3RmL0xvY2Fs U3RhdGljQXJyYXlQdHIuaCAgIHwgICA4NyArKysrKysrKysrKysrKwogSmF2YVNjcmlwdENvcmUv d3RmL0xvY2FsU3RhdGljUHRyLmggICAgICAgIHwgIDExOCArKysrKysrKysrKysrKysrKysrKwog SmF2YVNjcmlwdENvcmUvd3RmL1BsYXRmb3JtLmggICAgICAgICAgICAgIHwgICAgMiArCiBKYXZh U2NyaXB0Q29yZS93dGYvU3RhdGljUHRyQmFzZS5jcHAgICAgICAgfCAgIDcyICsrKysrKysrKysr KwogSmF2YVNjcmlwdENvcmUvd3RmL1N0YXRpY1B0ckJhc2UuaCAgICAgICAgIHwgICA2MiArKysr KysrKysrCiBKYXZhU2NyaXB0Q29yZS93dGYvU3RkTGliRXh0cmFzLmggICAgICAgICAgfCAgICA3 ICstCiBKYXZhU2NyaXB0Q29yZS93dGYvVGhyZWFkU3BlY2lmaWMuaCAgICAgICAgfCAgICAyICsK IEphdmFTY3JpcHRDb3JlL3d0Zi9xdC9UaHJlYWRpbmdRdC5jcHAgICAgICB8ICAgIDMgKy0KIFdl YkNvcmUvV2ViQ29yZS5wcm8gICAgICAgICAgICAgICAgICAgICAgICB8ICAgIDIgKy0KIFdlYkNv cmUvYmluZGluZ3MvanMvSlNET01XaW5kb3dCYXNlLmNwcCAgICB8ICAgMTggKysrLQogV2ViQ29y ZS9icmlkZ2UvSWRlbnRpZmllclJlcC5jcHAgICAgICAgICAgIHwgICAgNSArLQogV2ViQ29yZS9i cmlkZ2UvSWRlbnRpZmllclJlcC5oICAgICAgICAgICAgIHwgICAgMiArCiBXZWJDb3JlL2Nzcy9D U1NJbml0aWFsVmFsdWUuaCAgICAgICAgICAgICAgfCAgICA5ICstCiBXZWJDb3JlL2Nzcy9DU1NQ cmltaXRpdmVWYWx1ZS5jcHAgICAgICAgICAgfCAgIDEwICstCiBXZWJDb3JlL2Nzcy9DU1NTdHls ZVNlbGVjdG9yLmNwcCAgICAgICAgICAgfCAgIDMwICsrKy0tLQogV2ViQ29yZS9jc3MvQ1NTU3R5 bGVTZWxlY3Rvci5oICAgICAgICAgICAgIHwgICAgNSArLQogV2ViQ29yZS9jc3MvTWVkaWFGZWF0 dXJlTmFtZXMuY3BwICAgICAgICAgIHwgICAgMiArLQogV2ViQ29yZS9jc3MvTWVkaWFRdWVyeUV2 YWx1YXRvci5jcHAgICAgICAgIHwgICAgMyArLQogV2ViQ29yZS9kb20vUXVhbGlmaWVkTmFtZS5j cHAgICAgICAgICAgICAgIHwgICAyNCArKysrLQogV2ViQ29yZS9kb20vU3R5bGVkRWxlbWVudC5j cHAgICAgICAgICAgICAgIHwgICAzMSArKysrKy0KIFdlYkNvcmUvZG9tL21ha2VfbmFtZXMucGwg ICAgICAgICAgICAgICAgICB8ICAgIDQgKy0KIFdlYkNvcmUvaW5zcGVjdG9yL0phdmFTY3JpcHRE ZWJ1Z1NlcnZlci5oICB8ICAgIDMgKy0KIFdlYkNvcmUvbG9hZGVyL0ltYWdlTG9hZGVyLmNwcCAg ICAgICAgICAgICB8ICAgIDEgLQogV2ViQ29yZS9sb2FkZXIvaWNvbi9JY29uRGF0YWJhc2UuY3Bw ICAgICAgIHwgICAxMSArLQogV2ViQ29yZS9sb2FkZXIvaWNvbi9JY29uRGF0YWJhc2UuaCAgICAg ICAgIHwgICAgNiArCiBXZWJDb3JlL3BsYXRmb3JtL1N0YXRpY0NvbnN0cnVjdG9ycy5oICAgICAg fCAgIDEyICsrCiBXZWJDb3JlL3BsYXRmb3JtL1RocmVhZEdsb2JhbERhdGEuY3BwICAgICAgfCAg ICA3ICstCiBXZWJDb3JlL3BsYXRmb3JtL1RocmVhZFRpbWVycy5jcHAgICAgICAgICAgfCAgICA1 ICstCiBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0ZvbnRDYWNoZS5oICAgICAgfCAgICAxIC0K IFdlYkNvcmUvcGxhdGZvcm0vcXQvU2hhcmVkVGltZXJRdC5jcHAgICAgICB8ICAgIDIgKwogV2Vi Q29yZS9wbGF0Zm9ybS90ZXh0L0F0b21pY1N0cmluZy5jcHAgICAgIHwgICAxMCArLQogV2ViQ29y ZS9wbGF0Zm9ybS90ZXh0L3F0L1RleHRDb2RlY1F0LmNwcCAgIHwgICAgMyArLQogV2ViQ29yZS9w bHVnaW5zL1BsdWdpbkRhdGFiYXNlLmNwcCAgICAgICAgIHwgICAgNSArLQogV2ViQ29yZS9yZW5k ZXJpbmcvc3R5bGUvUmVuZGVyU3R5bGUuY3BwICAgIHwgICAgNSArLQogV2ViQ29yZS9yZW5kZXJp bmcvc3R5bGUvU1ZHUmVuZGVyU3R5bGUuY3BwIHwgICAyMSArKy0tCiBXZWJLaXQvcXQvQXBpL3F3 ZWJmcmFtZS5jcHAgICAgICAgICAgICAgICAgfCAgIDEyICsrCiBXZWJLaXQvcXQvQXBpL3F3ZWJz ZXR0aW5ncy5jcHAgICAgICAgICAgICAgfCAgIDI0ICsrKystCiBXZWJLaXQvcXQvQXBpL3F3ZWJz ZXR0aW5ncy5oICAgICAgICAgICAgICAgfCAgICAyICsKIFdlYktpdC9xdC9RdExhdW5jaGVyL21h aW4uY3BwICAgICAgICAgICAgICB8ICAgIDQgKy0KIDQ2IGZpbGVzIGNoYW5nZWQsIDc1NyBpbnNl cnRpb25zKCspLCAxMDMgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgSmF2YVNjcmlw dENvcmUvd3RmL0dsb2JhbFB0ci5oCiBjcmVhdGUgbW9kZSAxMDA2NDQgSmF2YVNjcmlwdENvcmUv d3RmL0xvY2FsU3RhdGljQXJyYXlQdHIuaAogY3JlYXRlIG1vZGUgMTAwNjQ0IEphdmFTY3JpcHRD b3JlL3d0Zi9Mb2NhbFN0YXRpY1B0ci5oCiBjcmVhdGUgbW9kZSAxMDA2NDQgSmF2YVNjcmlwdENv cmUvd3RmL1N0YXRpY1B0ckJhc2UuY3BwCiBjcmVhdGUgbW9kZSAxMDA2NDQgSmF2YVNjcmlwdENv cmUvd3RmL1N0YXRpY1B0ckJhc2UuaAoKZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL0phdmFT Y3JpcHRDb3JlLnByaSBiL0phdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLnByaQppbmRleCAw ZjNmOTA5Li4zN2NmY2MxIDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0Q29yZS9KYXZhU2NyaXB0Q29y ZS5wcmkKKysrIGIvSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUucHJpCkBAIC03NSw2ICs3 NSw3IEBAIFNPVVJDRVMgKz0gXAogICAgIHd0Zi9NYWluVGhyZWFkLmNwcCBcCiAgICAgd3RmL1Jh bmRvbU51bWJlci5jcHAgXAogICAgIHd0Zi9SZWZDb3VudGVkTGVha0NvdW50ZXIuY3BwIFwKKyAg ICB3dGYvU3RhdGljUHRyQmFzZS5jcHAgXAogICAgIHd0Zi9UeXBlVHJhaXRzLmNwcCBcCiAgICAg d3RmL3VuaWNvZGUvQ29sbGF0b3JEZWZhdWx0LmNwcCBcCiAgICAgd3RmL3VuaWNvZGUvaWN1L0Nv bGxhdG9ySUNVLmNwcCBcCmRpZmYgLS1naXQgYS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTR2xv YmFsRGF0YS5jcHAgYi9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTR2xvYmFsRGF0YS5jcHAKaW5k ZXggYmQzNWNiNy4uNjczMWY3NCAxMDA2NDQKLS0tIGEvSmF2YVNjcmlwdENvcmUvcnVudGltZS9K U0dsb2JhbERhdGEuY3BwCisrKyBiL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNHbG9iYWxEYXRh LmNwcApAQCAtNDksNiArNDksNyBAQAogI2luY2x1ZGUgIkxleGVyLmgiCiAjaW5jbHVkZSAiTG9v a3VwLmgiCiAjaW5jbHVkZSAiTm9kZXMuaCIKKyNpbmNsdWRlICJ3dGYvR2xvYmFsUHRyLmgiCiAK ICNpZiBFTkFCTEUoSlNDX01VTFRJUExFX1RIUkVBRFMpCiAjaW5jbHVkZSA8d3RmL1RocmVhZGlu Zy5oPgpAQCAtMjA3LDI4ICsyMDgsMjQgQEAgUGFzc1JlZlB0cjxKU0dsb2JhbERhdGE+IEpTR2xv YmFsRGF0YTo6Y3JlYXRlTGVha2VkKCkKICAgICByZXR1cm4gZGF0YS5yZWxlYXNlKCk7CiB9CiAK K1dURjo6R2xvYmFsUHRyPEpTR2xvYmFsRGF0YT4gc2hhcmVkSW5zdGFuY2VQdHI7CisKIGJvb2wg SlNHbG9iYWxEYXRhOjpzaGFyZWRJbnN0YW5jZUV4aXN0cygpCiB7Ci0gICAgcmV0dXJuIHNoYXJl ZEluc3RhbmNlSW50ZXJuYWwoKTsKKyAgICBBU1NFUlQoSlNMb2NrOjpjdXJyZW50VGhyZWFkSXNI b2xkaW5nTG9jaygpKTsKKyAgICByZXR1cm4gc2hhcmVkSW5zdGFuY2VQdHIuZ2V0KCk7CiB9CiAK IEpTR2xvYmFsRGF0YSYgSlNHbG9iYWxEYXRhOjpzaGFyZWRJbnN0YW5jZSgpCiB7Ci0gICAgSlNH bG9iYWxEYXRhKiYgaW5zdGFuY2UgPSBzaGFyZWRJbnN0YW5jZUludGVybmFsKCk7Ci0gICAgaWYg KCFpbnN0YW5jZSkgewotICAgICAgICBpbnN0YW5jZSA9IGNyZWF0ZSh0cnVlKS5yZWxlYXNlUmVm KCk7CisgICAgQVNTRVJUKEpTTG9jazo6Y3VycmVudFRocmVhZElzSG9sZGluZ0xvY2soKSk7Cisg ICAgaWYgKCFzaGFyZWRJbnN0YW5jZVB0cikgeworICAgICAgICBzaGFyZWRJbnN0YW5jZVB0ciA9 IGNyZWF0ZSh0cnVlKS5yZWxlYXNlUmVmKCk7CiAjaWYgRU5BQkxFKEpTQ19NVUxUSVBMRV9USFJF QURTKQotICAgICAgICBpbnN0YW5jZS0+bWFrZVVzYWJsZUZyb21NdWx0aXBsZVRocmVhZHMoKTsK KyAgICAgICAgc2hhcmVkSW5zdGFuY2VQdHItPm1ha2VVc2FibGVGcm9tTXVsdGlwbGVUaHJlYWRz KCk7CiAjZW5kaWYKICAgICB9Ci0gICAgcmV0dXJuICppbnN0YW5jZTsKLX0KLQotSlNHbG9iYWxE YXRhKiYgSlNHbG9iYWxEYXRhOjpzaGFyZWRJbnN0YW5jZUludGVybmFsKCkKLXsKLSAgICBBU1NF UlQoSlNMb2NrOjpjdXJyZW50VGhyZWFkSXNIb2xkaW5nTG9jaygpKTsKLSAgICBzdGF0aWMgSlNH bG9iYWxEYXRhKiBzaGFyZWRJbnN0YW5jZTsKLSAgICByZXR1cm4gc2hhcmVkSW5zdGFuY2U7Cisg ICAgcmV0dXJuICpzaGFyZWRJbnN0YW5jZVB0cjsKIH0KIAogLy8gRklYTUU6IFdlIGNhbiBhbHNv IGRldGVjdCBmb3JtcyBsaWtlIHYxIDwgdjIgPyAtMSA6IDAsIHJldmVyc2UgY29tcGFyaXNvbiwg ZXRjLgpkaWZmIC0tZ2l0IGEvSmF2YVNjcmlwdENvcmUvcnVudGltZS9KU0dsb2JhbERhdGEuaCBi L0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNHbG9iYWxEYXRhLmgKaW5kZXggNzgxMWM4NS4uZjY4 ZWE4NyAxMDA2NDQKLS0tIGEvSmF2YVNjcmlwdENvcmUvcnVudGltZS9KU0dsb2JhbERhdGEuaAor KysgYi9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTR2xvYmFsRGF0YS5oCkBAIC0xNTIsNyArMTUy LDYgQEAgbmFtZXNwYWNlIEpTQyB7CiAgICAgICAgIE1hcmtTdGFjayBtYXJrU3RhY2s7CiAgICAg cHJpdmF0ZToKICAgICAgICAgSlNHbG9iYWxEYXRhKGJvb2wgaXNTaGFyZWQsIGNvbnN0IFZQdHJT ZXQmKTsKLSAgICAgICAgc3RhdGljIEpTR2xvYmFsRGF0YSomIHNoYXJlZEluc3RhbmNlSW50ZXJu YWwoKTsKICAgICAgICAgdm9pZCBjcmVhdGVOYXRpdmVUaHVuaygpOwogICAgIH07CiAKZGlmZiAt LWdpdCBhL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvTG9va3VwLmNwcCBiL0phdmFTY3JpcHRDb3Jl L3J1bnRpbWUvTG9va3VwLmNwcAppbmRleCA4MzU5ZmY3Li43ZGUxODYwIDEwMDY0NAotLS0gYS9K YXZhU2NyaXB0Q29yZS9ydW50aW1lL0xvb2t1cC5jcHAKKysrIGIvSmF2YVNjcmlwdENvcmUvcnVu dGltZS9Mb29rdXAuY3BwCkBAIC0yMiw5ICsyMiwyNiBAQAogCiAjaW5jbHVkZSAiSlNGdW5jdGlv bi5oIgogI2luY2x1ZGUgIlByb3RvdHlwZUZ1bmN0aW9uLmgiCisjaW5jbHVkZSAid3RmL0Zhc3RN YWxsb2MuaCIKKyNpbmNsdWRlICJ3dGYvU3RhdGljUHRyQmFzZS5oIgogCiBuYW1lc3BhY2UgSlND IHsKIAorI2lmIEVOQUJMRShGUkVFX1NUQVRJQ19QVFJTKQorLy8gQWxsIEhhc2hUYWJsZXMgYXJl IHN0YXRpYyBhbmQgZ2VuZXJhdGVkIGJ5IGEgc2NyaXB0IChzZWUgdGhlIGNvbW1lbnQgaW4gdGhl IGhlYWRlciBmaWxlKQorc3RydWN0IEhhc2hUYWJsZURlbGV0ZXIgeworcHVibGljOgorICAgIFdU Rjo6U3RhdGljUHRyQmFzZSBtX2Jhc2U7CisgICAgSGFzaFRhYmxlKiBtX2hhc2hUYWJsZTsKKwor ICAgIHN0YXRpYyB2b2lkIGZyZWUodm9pZCogcHRyKQorICAgIHsKKyAgICAgICAgcmVpbnRlcnBy ZXRfY2FzdDxIYXNoVGFibGVEZWxldGVyKj4ocHRyKS0+bV9oYXNoVGFibGUtPmRlbGV0ZVRhYmxl KCk7CisgICAgICAgIGZhc3RGcmVlKHB0cik7CisgICAgfQorfTsKKyNlbmRpZgorCiB2b2lkIEhh c2hUYWJsZTo6Y3JlYXRlVGFibGUoSlNHbG9iYWxEYXRhKiBnbG9iYWxEYXRhKSBjb25zdAogewog ICAgIEFTU0VSVCghdGFibGUpOwpAQCAtNDgsNiArNjUsMTIgQEAgdm9pZCBIYXNoVGFibGU6OmNy ZWF0ZVRhYmxlKEpTR2xvYmFsRGF0YSogZ2xvYmFsRGF0YSkgY29uc3QKIAogICAgICAgICBlbnRy eS0+aW5pdGlhbGl6ZShpZGVudGlmaWVyLCB2YWx1ZXNbaV0uYXR0cmlidXRlcywgdmFsdWVzW2ld LnZhbHVlMSwgdmFsdWVzW2ldLnZhbHVlMik7CiAgICAgfQorI2lmIEVOQUJMRShGUkVFX1NUQVRJ Q19QVFJTKQorICAgIEhhc2hUYWJsZURlbGV0ZXIqIGRlbGV0ZXIgPSByZWludGVycHJldF9jYXN0 PEhhc2hUYWJsZURlbGV0ZXIqPihmYXN0TWFsbG9jKHNpemVvZihIYXNoVGFibGVEZWxldGVyKSkp OworICAgIGRlbGV0ZXItPm1fYmFzZS5tX2ZyZWUgPSBIYXNoVGFibGVEZWxldGVyOjpmcmVlOwor ICAgIGRlbGV0ZXItPm1fYmFzZS5hcHBlbmQoKTsKKyAgICBkZWxldGVyLT5tX2hhc2hUYWJsZSA9 IGNvbnN0X2Nhc3Q8SGFzaFRhYmxlKj4odGhpcyk7CisjZW5kaWYKICAgICB0YWJsZSA9IGVudHJp ZXM7CiB9CiAKZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvVVN0cmluZy5jcHAg Yi9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1VTdHJpbmcuY3BwCmluZGV4IGFhODAyYzguLjBiYTQ2 MWQgMTAwNjQ0Ci0tLSBhL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvVVN0cmluZy5jcHAKKysrIGIv SmF2YVNjcmlwdENvcmUvcnVudGltZS9VU3RyaW5nLmNwcApAQCAtMTkyLDkgKzE5Miw5IEBAIGJv b2wgb3BlcmF0b3I9PShjb25zdCBDU3RyaW5nJiBjMSwgY29uc3QgQ1N0cmluZyYgYzIpCiAvLyBU aGVzZSBzdGF0aWMgc3RyaW5ncyBhcmUgaW1tdXRhYmxlLCBleGNlcHQgZm9yIHJjLCB3aG9zZSBp bml0aWFsIHZhbHVlIGlzIGNob3NlbiB0byAKIC8vIHJlZHVjZSB0aGUgcG9zc2liaWxpdHkgb2Yg aXQgYmVjb21pbmcgemVybyBkdWUgdG8gcmVmL2RlcmVmIG5vdCBiZWluZyB0aHJlYWQtc2FmZS4K IHN0YXRpYyBVQ2hhciBzaGFyZWRFbXB0eUNoYXI7Ci1VU3RyaW5nOjpCYXNlU3RyaW5nKiBVU3Ry aW5nOjpSZXA6Om51bGxCYXNlU3RyaW5nOwotVVN0cmluZzo6QmFzZVN0cmluZyogVVN0cmluZzo6 UmVwOjplbXB0eUJhc2VTdHJpbmc7Ci1VU3RyaW5nKiBVU3RyaW5nOjpudWxsVVN0cmluZzsKK1dU Rjo6R2xvYmFsUHRyPFVTdHJpbmc6OkJhc2VTdHJpbmc+IFVTdHJpbmc6OlJlcDo6bnVsbEJhc2VT dHJpbmc7CitXVEY6Okdsb2JhbFB0cjxVU3RyaW5nOjpCYXNlU3RyaW5nPiBVU3RyaW5nOjpSZXA6 OmVtcHR5QmFzZVN0cmluZzsKK1dURjo6R2xvYmFsUHRyPFVTdHJpbmc+IFVTdHJpbmc6Om51bGxV U3RyaW5nOwogCiBzdGF0aWMgdm9pZCBpbml0aWFsaXplU3RhdGljQmFzZVN0cmluZyhVU3RyaW5n OjpCYXNlU3RyaW5nJiBiYXNlKQogewpkaWZmIC0tZ2l0IGEvSmF2YVNjcmlwdENvcmUvcnVudGlt ZS9VU3RyaW5nLmggYi9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1VTdHJpbmcuaAppbmRleCBjNGRh ZDJhLi5lMWEwYTA2IDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1VTdHJpbmcu aAorKysgYi9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1VTdHJpbmcuaApAQCAtMjgsNiArMjgsNyBA QAogI2luY2x1ZGUgPHN0cmluZy5oPgogI2luY2x1ZGUgPHd0Zi9Bc3NlcnRpb25zLmg+CiAjaW5j bHVkZSA8d3RmL0Nyb3NzVGhyZWFkUmVmQ291bnRlZC5oPgorI2luY2x1ZGUgPHd0Zi9HbG9iYWxQ dHIuaD4KICNpbmNsdWRlIDx3dGYvT3duRmFzdE1hbGxvY1B0ci5oPgogI2luY2x1ZGUgPHd0Zi9Q YXNzUmVmUHRyLmg+CiAjaW5jbHVkZSA8d3RmL1B0ckFuZEZsYWdzLmg+CkBAIC0xODYsOCArMTg3 LDggQEAgbmFtZXNwYWNlIEpTQyB7CiAKICAgICAgICAgICAgIGZyaWVuZCBjbGFzcyBTbWFsbFN0 cmluZ3NTdG9yYWdlOwogICAgICAgICAgICAgZnJpZW5kIHZvaWQgaW5pdGlhbGl6ZVVTdHJpbmco KTsKLSAgICAgICAgICAgIEpTX0VYUE9SVERBVEEgc3RhdGljIEJhc2VTdHJpbmcqIG51bGxCYXNl U3RyaW5nOwotICAgICAgICAgICAgSlNfRVhQT1JUREFUQSBzdGF0aWMgQmFzZVN0cmluZyogZW1w dHlCYXNlU3RyaW5nOworICAgICAgICAgICAgSlNfRVhQT1JUREFUQSBzdGF0aWMgV1RGOjpHbG9i YWxQdHI8QmFzZVN0cmluZz4gbnVsbEJhc2VTdHJpbmc7CisgICAgICAgICAgICBKU19FWFBPUlRE QVRBIHN0YXRpYyBXVEY6Okdsb2JhbFB0cjxCYXNlU3RyaW5nPiBlbXB0eUJhc2VTdHJpbmc7CiAg ICAgICAgIH07CiAKIApAQCAtMzY3LDcgKzM2OCw3IEBAIG5hbWVzcGFjZSBKU0MgewogICAgICAg ICB2b2lkIG1ha2VOdWxsKCk7CiAKICAgICAgICAgUmVmUHRyPFJlcD4gbV9yZXA7Ci0gICAgICAg IHN0YXRpYyBVU3RyaW5nKiBudWxsVVN0cmluZzsKKyAgICAgICAgc3RhdGljIFdURjo6R2xvYmFs UHRyPFVTdHJpbmc+IG51bGxVU3RyaW5nOwogCiAgICAgICAgIGZyaWVuZCB2b2lkIGluaXRpYWxp emVVU3RyaW5nKCk7CiAgICAgICAgIGZyaWVuZCBib29sIG9wZXJhdG9yPT0oY29uc3QgVVN0cmlu ZyYsIGNvbnN0IFVTdHJpbmcmKTsKZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL3d0Zi9HbG9i YWxQdHIuaCBiL0phdmFTY3JpcHRDb3JlL3d0Zi9HbG9iYWxQdHIuaApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwLi5hNTZmYmE4Ci0tLSAvZGV2L251bGwKKysrIGIvSmF2YVNjcmlw dENvcmUvd3RmL0dsb2JhbFB0ci5oCkBAIC0wLDAgKzEsMTY3IEBACisvKgorICogQ29weXJpZ2h0 IChDKSAyMDA5IFVuaXZlcnNpdHkgb2YgU3plZ2VkCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgor ICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMs IHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVk IHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0 cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQK KyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJl cHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBj b25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1 bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJp YnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVU5JVkVSU0lUWSBP RiBTWkVHRUQgYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5U SUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJB TlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAq IFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBVTklWRVJTSVRZIE9G IFNaRUdFRCBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5E SVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJ QUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVO VCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IK KyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5E IE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RS SUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVS V0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRX QVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgor ICovCisKKyNpZm5kZWYgV1RGX0dsb2JhbFB0cl9oCisjZGVmaW5lIFdURl9HbG9iYWxQdHJfaAor CisjaW5jbHVkZSAiU3RhdGljUHRyQmFzZS5oIgorCituYW1lc3BhY2UgV1RGIHsKKworLy8gVGhl IGNsYXNzZXMgaGVyZSBhcmUgZGVmaW5lZCBhcyBzdHJ1Y3RzIHRvIGF2b2lkCisvLyB0aGUgY2Fs bCBvZiBDKysgY29uc3RydWN0b3JzIGFuZCBkZXN0cnVjdG9ycworCit0ZW1wbGF0ZTx0eXBlbmFt ZSBUPiBzdHJ1Y3QgR2xvYmFsUHRyIHsKK3B1YmxpYzoKKyAgICB0eXBlZGVmIHR5cGVuYW1lIFJl bW92ZVBvaW50ZXI8VD46OlR5cGUgVmFsdWVUeXBlOworICAgIHR5cGVkZWYgVmFsdWVUeXBlKiBQ dHJUeXBlOworCisgICAgLy8gSGFzIE5PIEMrKyBjb25zdHJ1Y3RvcgorCisgICAgUHRyVHlwZSBn ZXQoKSBjb25zdDsKKyAgICB2b2lkIHNldChQdHJUeXBlKTsKKyAgICB2b2lkIHNldFB0cihQdHJU eXBlKTsKKworICAgIHZvaWQgb3BlcmF0b3I9KFB0clR5cGUpOworCisgICAgLy8gVmFsdWUgYWNj ZXNzIG9wZXJhdG9ycworICAgIFZhbHVlVHlwZSYgb3BlcmF0b3IqKCk7CisgICAgUHRyVHlwZSBv cGVyYXRvci0+KCk7CisgICAgVmFsdWVUeXBlJiBvcGVyYXRvciooKSBjb25zdDsKKyAgICBQdHJU eXBlIG9wZXJhdG9yLT4oKSBjb25zdDsKKworICAgIGJvb2wgb3BlcmF0b3IhKCkgY29uc3Q7CisK KyAgICB2b2lkIGRlbGV0ZVB0cigpOworCisjaWYgRU5BQkxFKEZSRUVfU1RBVElDX1BUUlMpCisg ICAgU3RhdGljUHRyQmFzZSBtX2Jhc2U7CisjZW5kaWYKKyAgICBQdHJUeXBlIG1fcHRyOworCisj aWYgRU5BQkxFKEZSRUVfU1RBVElDX1BUUlMpCisgICAgc3RhdGljIHZvaWQgZnJlZSh2b2lkKiBw dHIpCisgICAgeworICAgICAgICBBU1NFUlQocHRyKTsKKyAgICAgICAgZGVsZXRlIHJlaW50ZXJw cmV0X2Nhc3Q8R2xvYmFsUHRyPFQ+Kj4ocHRyKS0+Z2V0KCk7CisgICAgfQorCisgICAgdm9pZCBz ZXRGcmVlKFN0YXRpY1B0ckJhc2VGcmVlIGZ1bmMpCisgICAgeworICAgICAgICBtX2Jhc2UubV9m cmVlID0gZnVuYzsKKyAgICB9CisjZW5kaWYKK307CisKK3RlbXBsYXRlPHR5cGVuYW1lIFQ+CitB TFdBWVNfSU5MSU5FIHR5cGVuYW1lIEdsb2JhbFB0cjxUPjo6UHRyVHlwZSBHbG9iYWxQdHI8VD46 OmdldCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIG1fcHRyOworfQorCit0ZW1wbGF0ZTx0eXBlbmFt ZSBUPgorQUxXQVlTX0lOTElORSB2b2lkIEdsb2JhbFB0cjxUPjo6c2V0KFB0clR5cGUgdmFsdWUp Cit7CisgICAgLy8gRGV0ZWN0IG1lbW9yeSBsZWFrcworICAgIEFTU0VSVCghbV9wdHIgfHwgKG1f cHRyID09IHZhbHVlKSk7CisgICAgbV9wdHIgPSB2YWx1ZTsKKyNpZiBFTkFCTEUoRlJFRV9TVEFU SUNfUFRSUykKKyAgICBpZiAodmFsdWUpIHsKKyAgICAgICAgbV9iYXNlLm1fZnJlZSA9IGZyZWU7 CisgICAgICAgIG1fYmFzZS5hcHBlbmQoKTsKKyAgICB9CisjZW5kaWYKK30KKwordGVtcGxhdGU8 dHlwZW5hbWUgVD4KK0FMV0FZU19JTkxJTkUgdm9pZCBHbG9iYWxQdHI8VD46OnNldFB0cihQdHJU eXBlIHZhbHVlKQoreworICAgIC8vIERldGVjdCBtZW1vcnkgbGVha3MKKyAgICBBU1NFUlQoIW1f cHRyIHx8IChtX3B0ciA9PSB2YWx1ZSkpOworICAgIG1fcHRyID0gdmFsdWU7CisjaWYgRU5BQkxF KEZSRUVfU1RBVElDX1BUUlMpCisgICAgaWYgKHZhbHVlKQorICAgICAgICBtX2Jhc2UuYXBwZW5k KCk7CisjZW5kaWYKK30KKwordGVtcGxhdGU8dHlwZW5hbWUgVD4KK0FMV0FZU19JTkxJTkUgdm9p ZCBHbG9iYWxQdHI8VD46Om9wZXJhdG9yPShQdHJUeXBlIHZhbHVlKQoreworICAgIHNldCh2YWx1 ZSk7Cit9CisKK3RlbXBsYXRlPHR5cGVuYW1lIFQ+CitBTFdBWVNfSU5MSU5FIHR5cGVuYW1lIEds b2JhbFB0cjxUPjo6VmFsdWVUeXBlJiBHbG9iYWxQdHI8VD46Om9wZXJhdG9yKigpCit7CisgICAg QVNTRVJUKG1fcHRyKTsKKyAgICByZXR1cm4gKm1fcHRyOworfQorCit0ZW1wbGF0ZTx0eXBlbmFt ZSBUPgorQUxXQVlTX0lOTElORSB0eXBlbmFtZSBHbG9iYWxQdHI8VD46OlB0clR5cGUgR2xvYmFs UHRyPFQ+OjpvcGVyYXRvci0+KCkKK3sKKyAgICBBU1NFUlQobV9wdHIpOworICAgIHJldHVybiBt X3B0cjsKK30KKwordGVtcGxhdGU8dHlwZW5hbWUgVD4KK0FMV0FZU19JTkxJTkUgdHlwZW5hbWUg R2xvYmFsUHRyPFQ+OjpWYWx1ZVR5cGUmIEdsb2JhbFB0cjxUPjo6b3BlcmF0b3IqKCkgY29uc3QK K3sKKyAgICBBU1NFUlQobV9wdHIpOworICAgIHJldHVybiAqbV9wdHI7Cit9CisKK3RlbXBsYXRl PHR5cGVuYW1lIFQ+CitBTFdBWVNfSU5MSU5FIHR5cGVuYW1lIEdsb2JhbFB0cjxUPjo6UHRyVHlw ZSBHbG9iYWxQdHI8VD46Om9wZXJhdG9yLT4oKSBjb25zdAoreworICAgIEFTU0VSVChtX3B0cik7 CisgICAgcmV0dXJuIG1fcHRyOworfQorCit0ZW1wbGF0ZTx0eXBlbmFtZSBUPgorQUxXQVlTX0lO TElORSBib29sIEdsb2JhbFB0cjxUPjo6b3BlcmF0b3IhKCkgY29uc3QKK3sKKyAgICByZXR1cm4g IW1fcHRyOworfQorCit0ZW1wbGF0ZTx0eXBlbmFtZSBUPgorQUxXQVlTX0lOTElORSB2b2lkIEds b2JhbFB0cjxUPjo6ZGVsZXRlUHRyKCkKK3sKKyAgICBBU1NFUlQobV9wdHIpOworICAgIGRlbGV0 ZSBtX3B0cjsKKyNpZm5kZWYgTkRFQlVHCisgICAgLy8gU2VlIEdsb2JhbFB0cjxUPjo6c2V0Cisg ICAgbV9wdHIgPSAwOworI2VuZGlmCisjaWYgRU5BQkxFKEZSRUVfU1RBVElDX1BUUlMpCisgICAg bV9iYXNlLnJlbW92ZSgpOworI2VuZGlmCit9CisKK30gLy8gbmFtZXNwYWNlIFdURgorCisjZW5k aWYKZGlmZiAtLWdpdCBhL0phdmFTY3JpcHRDb3JlL3d0Zi9Mb2NhbFN0YXRpY0FycmF5UHRyLmgg Yi9KYXZhU2NyaXB0Q29yZS93dGYvTG9jYWxTdGF0aWNBcnJheVB0ci5oCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAuLmJhM2NmYjMKLS0tIC9kZXYvbnVsbAorKysgYi9KYXZhU2Ny aXB0Q29yZS93dGYvTG9jYWxTdGF0aWNBcnJheVB0ci5oCkBAIC0wLDAgKzEsODcgQEAKKy8qCisg KiBDb3B5cmlnaHQgKEMpIDIwMDkgVW5pdmVyc2l0eSBvZiBTemVnZWQKKyAqIEFsbCByaWdodHMg cmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJp bmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0 ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6Cisg KiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3Zl IGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhl IGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBm b3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUK KyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRo IHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBV TklWRVJTSVRZIE9GIFNaRUdFRCBgYEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBM SUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElN UExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFS VElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIFVO SVZFUlNJVFkgT0YgU1pFR0VEIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkg RElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1Ig Q09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAq IFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNF LCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVS IENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENP TlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VO Q0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9G IFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VD SCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBXVEZfTG9jYWxTdGF0aWNBcnJheVB0cl9oCisjZGVm aW5lIFdURl9Mb2NhbFN0YXRpY0FycmF5UHRyX2gKKworI2luY2x1ZGUgIlN0YXRpY1B0ckJhc2Uu aCIKKworbmFtZXNwYWNlIFdURiB7CisKKy8vIFdyYXBwZXIgY2xhc3MgZm9yIGFycmF5cywgd2hp Y2ggYXNzaWduZWQgdG8gYSBzdGF0aWMgdmFyaWFibGUKKy8vIEJ5IGRlZmF1bHQsIGl0IGJlaGF2 ZXMgbGlrZSBhIHNpbXBsZSBDKysgYXJyYXkgd2l0aG91dCBwZXJmb3JtYW5jZSBvdmVyaGVhZAor dGVtcGxhdGU8dHlwZW5hbWUgVD4gc3RydWN0IExvY2FsU3RhdGljQXJyYXlQdHIgeworcHVibGlj OgorICAgIHR5cGVkZWYgdHlwZW5hbWUgUmVtb3ZlUG9pbnRlcjxUPjo6VHlwZSBWYWx1ZVR5cGU7 CisgICAgdHlwZWRlZiBWYWx1ZVR5cGUqIFB0clR5cGU7CisKKyAgICBMb2NhbFN0YXRpY0FycmF5 UHRyKFZhbHVlVHlwZSogcHRyKTsKKworICAgIFZhbHVlVHlwZSYgb3BlcmF0b3JbXShzaXplX3Qp OworICAgIGNvbnN0IFZhbHVlVHlwZSYgb3BlcmF0b3JbXShzaXplX3QpIGNvbnN0OworCisjaWYg RU5BQkxFKEZSRUVfU1RBVElDX1BUUlMpCisgICAgU3RhdGljUHRyQmFzZSBtX2Jhc2U7CisjZW5k aWYKKyAgICBQdHJUeXBlIG1fcHRyOworCisjaWYgRU5BQkxFKEZSRUVfU1RBVElDX1BUUlMpCisg ICAgc3RhdGljIHZvaWQgZnJlZSh2b2lkKiBwdHIpCisgICAgeworICAgICAgICBBU1NFUlQocHRy KTsKKyAgICAgICAgZGVsZXRlW10gcmVpbnRlcnByZXRfY2FzdDxMb2NhbFN0YXRpY0FycmF5UHRy PFQ+Kj4ocHRyKS0+bV9wdHI7CisgICAgfQorI2VuZGlmCit9OworCit0ZW1wbGF0ZTx0eXBlbmFt ZSBUPgorQUxXQVlTX0lOTElORSBMb2NhbFN0YXRpY0FycmF5UHRyPFQ+OjpMb2NhbFN0YXRpY0Fy cmF5UHRyKFZhbHVlVHlwZSogcHRyKQorICAgIDogbV9wdHIocHRyKQoreworICAgIEFTU0VSVChw dHIpOworI2lmIEVOQUJMRShGUkVFX1NUQVRJQ19QVFJTKQorICAgIG1fYmFzZS5tX2ZyZWUgPSBm cmVlOworICAgIG1fYmFzZS5hcHBlbmQoKTsKKyNlbmRpZgorfQorCit0ZW1wbGF0ZTx0eXBlbmFt ZSBUPgorQUxXQVlTX0lOTElORSB0eXBlbmFtZSBMb2NhbFN0YXRpY0FycmF5UHRyPFQ+OjpWYWx1 ZVR5cGUmIExvY2FsU3RhdGljQXJyYXlQdHI8VD46Om9wZXJhdG9yW10oc2l6ZV90IGkpCit7Cisg ICAgQVNTRVJUKG1fcHRyKTsKKyAgICByZXR1cm4gbV9wdHJbaV07Cit9CisKK3RlbXBsYXRlPHR5 cGVuYW1lIFQ+CitBTFdBWVNfSU5MSU5FIGNvbnN0IHR5cGVuYW1lIExvY2FsU3RhdGljQXJyYXlQ dHI8VD46OlZhbHVlVHlwZSYgTG9jYWxTdGF0aWNBcnJheVB0cjxUPjo6b3BlcmF0b3JbXShzaXpl X3QgaSkgY29uc3QKK3sKKyAgICBBU1NFUlQobV9wdHIpOworICAgIHJldHVybiBtX3B0cltpXTsK K30KKworfSAvLyBuYW1lc3BhY2UgV1RGCisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvSmF2YVNjcmlw dENvcmUvd3RmL0xvY2FsU3RhdGljUHRyLmggYi9KYXZhU2NyaXB0Q29yZS93dGYvTG9jYWxTdGF0 aWNQdHIuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jOTY0YTg5Ci0tLSAv ZGV2L251bGwKKysrIGIvSmF2YVNjcmlwdENvcmUvd3RmL0xvY2FsU3RhdGljUHRyLmgKQEAgLTAs MCArMSwxMTggQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMDkgVW5pdmVyc2l0eSBvZiBTemVn ZWQKKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVz ZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmlj YXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlv bnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVz dCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmli dXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQK KyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVy aWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FS RSBJUyBQUk9WSURFRCBCWSBVTklWRVJTSVRZIE9GIFNaRUdFRCBgYEFTIElTJycgQU5EIEFOWQor ICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1J VEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5E IEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElO IE5PIEVWRU5UIFNIQUxMIFVOSVZFUlNJVFkgT0YgU1pFR0VEIE9SCisgKiBDT05UUklCVVRPUlMg QkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwK KyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBO T1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VS VklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5U RVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklM SVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAo SU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VU IE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUg UE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBXVEZfTG9jYWxTdGF0 aWNQdHJfaAorI2RlZmluZSBXVEZfTG9jYWxTdGF0aWNQdHJfaAorCisjaW5jbHVkZSAiU3RhdGlj UHRyQmFzZS5oIgorCituYW1lc3BhY2UgV1RGIHsKKwordGVtcGxhdGU8dHlwZW5hbWUgVD4gc3Ry dWN0IExvY2FsU3RhdGljUHRyIHsKK3B1YmxpYzoKKyAgICB0eXBlZGVmIHR5cGVuYW1lIFJlbW92 ZVBvaW50ZXI8VD46OlR5cGUgVmFsdWVUeXBlOworICAgIHR5cGVkZWYgVmFsdWVUeXBlKiBQdHJU eXBlOworCisgICAgLy8gSGFzIEMrKyBjb25zdHJ1Y3RvcgorICAgIExvY2FsU3RhdGljUHRyKFB0 clR5cGUgcHRyKTsKKworICAgIFB0clR5cGUgZ2V0KCkgY29uc3Q7CisKKyAgICAvLyBWYWx1ZSBh Y2Nlc3Mgb3BlcmF0b3JzCisgICAgVmFsdWVUeXBlJiBvcGVyYXRvciooKTsKKyAgICBQdHJUeXBl IG9wZXJhdG9yLT4oKTsKKyAgICBWYWx1ZVR5cGUmIG9wZXJhdG9yKigpIGNvbnN0OworICAgIFB0 clR5cGUgb3BlcmF0b3ItPigpIGNvbnN0OworCisjaWYgRU5BQkxFKEZSRUVfU1RBVElDX1BUUlMp CisgICAgU3RhdGljUHRyQmFzZSBtX2Jhc2U7CisjZW5kaWYKKyAgICBQdHJUeXBlIG1fcHRyOwor CisjaWYgRU5BQkxFKEZSRUVfU1RBVElDX1BUUlMpCisgICAgc3RhdGljIHZvaWQgZnJlZSh2b2lk KiBwdHIpCisgICAgeworICAgICAgICBBU1NFUlQocHRyKTsKKyAgICAgICAgZGVsZXRlIHJlaW50 ZXJwcmV0X2Nhc3Q8TG9jYWxTdGF0aWNQdHI8VD4qPihwdHIpLT5nZXQoKTsKKyAgICB9CisKKyAg ICBzdGF0aWMgdm9pZCBkZXN0cm95KHZvaWQqIHB0cikKKyAgICB7CisgICAgICAgIEFTU0VSVChw dHIpOworICAgICAgICByZWludGVycHJldF9jYXN0PExvY2FsU3RhdGljUHRyPFQ+Kj4ocHRyKS0+ Z2V0KCktPn5UKCk7CisgICAgfQorCisgICAgdm9pZCBzZXRGcmVlKFN0YXRpY1B0ckJhc2VGcmVl IGZ1bmMpCisgICAgeworICAgICAgICBtX2Jhc2UubV9mcmVlID0gZnVuYzsKKyAgICB9CisjZW5k aWYKK307CisKK3RlbXBsYXRlPHR5cGVuYW1lIFQ+CitBTFdBWVNfSU5MSU5FIExvY2FsU3RhdGlj UHRyPFQ+OjpMb2NhbFN0YXRpY1B0cihQdHJUeXBlIHB0cikKKyAgICA6IG1fcHRyKHB0cikKK3sK KyAgICBBU1NFUlQocHRyKTsKKyNpZiBFTkFCTEUoRlJFRV9TVEFUSUNfUFRSUykKKyAgICBtX2Jh c2UubV9mcmVlID0gZnJlZTsKKyAgICBtX2Jhc2UuYXBwZW5kKCk7CisjZW5kaWYKK30KKwordGVt cGxhdGU8dHlwZW5hbWUgVD4KK0FMV0FZU19JTkxJTkUgdHlwZW5hbWUgTG9jYWxTdGF0aWNQdHI8 VD46OlB0clR5cGUgTG9jYWxTdGF0aWNQdHI8VD46OmdldCgpIGNvbnN0Cit7CisgICAgcmV0dXJu IG1fcHRyOworfQorCit0ZW1wbGF0ZTx0eXBlbmFtZSBUPgorQUxXQVlTX0lOTElORSB0eXBlbmFt ZSBMb2NhbFN0YXRpY1B0cjxUPjo6VmFsdWVUeXBlJiBMb2NhbFN0YXRpY1B0cjxUPjo6b3BlcmF0 b3IqKCkKK3sKKyAgICByZXR1cm4gKm1fcHRyOworfQorCit0ZW1wbGF0ZTx0eXBlbmFtZSBUPgor QUxXQVlTX0lOTElORSB0eXBlbmFtZSBMb2NhbFN0YXRpY1B0cjxUPjo6UHRyVHlwZSBMb2NhbFN0 YXRpY1B0cjxUPjo6b3BlcmF0b3ItPigpCit7CisgICAgcmV0dXJuIG1fcHRyOworfQorCit0ZW1w bGF0ZTx0eXBlbmFtZSBUPgorQUxXQVlTX0lOTElORSB0eXBlbmFtZSBMb2NhbFN0YXRpY1B0cjxU Pjo6VmFsdWVUeXBlJiBMb2NhbFN0YXRpY1B0cjxUPjo6b3BlcmF0b3IqKCkgY29uc3QKK3sKKyAg ICByZXR1cm4gKm1fcHRyOworfQorCit0ZW1wbGF0ZTx0eXBlbmFtZSBUPgorQUxXQVlTX0lOTElO RSB0eXBlbmFtZSBMb2NhbFN0YXRpY1B0cjxUPjo6UHRyVHlwZSBMb2NhbFN0YXRpY1B0cjxUPjo6 b3BlcmF0b3ItPigpIGNvbnN0Cit7CisgICAgcmV0dXJuIG1fcHRyOworfQorCit9IC8vIG5hbWVz cGFjZSBXVEYKKworI2VuZGlmCmRpZmYgLS1naXQgYS9KYXZhU2NyaXB0Q29yZS93dGYvUGxhdGZv cm0uaCBiL0phdmFTY3JpcHRDb3JlL3d0Zi9QbGF0Zm9ybS5oCmluZGV4IGRmNTdmMGYuLjAwM2E0 YTggMTAwNjQ0Ci0tLSBhL0phdmFTY3JpcHRDb3JlL3d0Zi9QbGF0Zm9ybS5oCisrKyBiL0phdmFT Y3JpcHRDb3JlL3d0Zi9QbGF0Zm9ybS5oCkBAIC03NjAsNCArNzYwLDYgQEAKIC8qIFNldCB1cCBh IGRlZmluZSBmb3IgYSBjb21tb24gZXJyb3IgdGhhdCBpcyBpbnRlbmRlZCB0byBjYXVzZSBhIGJ1 aWxkIGVycm9yIC0tIHRodXMgdGhlIHNwYWNlIGFmdGVyIEVycm9yLiAqLwogI2RlZmluZSBXVEZf UExBVEZPUk1fQ0ZORVRXT1JLIEVycm9yIFVTRV9tYWNyb19zaG91bGRfYmVfdXNlZF93aXRoX0NG TkVUV09SSwogCisjZGVmaW5lIEVOQUJMRV9GUkVFX1NUQVRJQ19QVFJTIDEKKwogI2VuZGlmIC8q IFdURl9QbGF0Zm9ybV9oICovCmRpZmYgLS1naXQgYS9KYXZhU2NyaXB0Q29yZS93dGYvU3RhdGlj UHRyQmFzZS5jcHAgYi9KYXZhU2NyaXB0Q29yZS93dGYvU3RhdGljUHRyQmFzZS5jcHAKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYTZkNGM3NgotLS0gL2Rldi9udWxsCisrKyBi L0phdmFTY3JpcHRDb3JlL3d0Zi9TdGF0aWNQdHJCYXNlLmNwcApAQCAtMCwwICsxLDcyIEBACisv KgorICogQ29weXJpZ2h0IChDKSAyMDA5IFVuaXZlcnNpdHkgb2YgU3plZ2VkCisgKiBBbGwgcmln aHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFu ZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVy bWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0 OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBh Ym92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5k IHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5h cnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2Us IHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4g dGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQg d2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQg QlkgVU5JVkVSU0lUWSBPRiBTWkVHRUQgYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1Ig SU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisg KiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBB IFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFM TCBVTklWRVJTSVRZIE9GIFNaRUdFRCBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1Ig QU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlks IE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8s CisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9G IFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9X RVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJ TiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdM SUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisg KiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9G IFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJTdGF0 aWNQdHJCYXNlLmgiCisKK25hbWVzcGFjZSBXVEYgeworCisjaWYgRU5BQkxFKEZSRUVfU1RBVElD X1BUUlMpCisKK1N0YXRpY1B0ckJhc2U6OlN0YXRpY1B0ckJhc2UqIFN0YXRpY1B0ckJhc2U6Om1f aGVhZCA9IDA7CisKK3ZvaWQgU3RhdGljUHRyQmFzZTo6ZnJlZVN0YXRpY1B0cnMoKQoreworICAg IC8vIEZyZWUgdGhlbSBpbiBhIHJldmVyc2VkIGNyZWF0aW9uIG9yZGVyCisgICAgU3RhdGljUHRy QmFzZSogY3VycmVudCA9IGhlYWQoKTsKKyAgICB3aGlsZSAoY3VycmVudCkgeworICAgICAgICAv LyBTb21lIHBvaW50ZXJzIChpLmU6IEhhc2hUYWJsZURlbGV0ZXIpIGZyZWVzIHRoZW1zZWxmCisg ICAgICAgIFN0YXRpY1B0ckJhc2UqIHB0ciA9IGN1cnJlbnQ7CisgICAgICAgIGN1cnJlbnQgPSBj dXJyZW50LT5uZXh0KCk7CisgICAgICAgIHB0ci0+bV9mcmVlKHJlaW50ZXJwcmV0X2Nhc3Q8dm9p ZCo+KHB0cikpOworICAgIH0KK30KKwordm9pZCBTdGF0aWNQdHJCYXNlOjphcHBlbmQoKQorewor ICAgIG1fbmV4dCA9IGhlYWQoKTsKKyAgICBtX2hlYWQgPSB0aGlzOworfQorCit2b2lkIFN0YXRp Y1B0ckJhc2U6OnJlbW92ZSgpCit7CisgICAgLy8gUGVyaGFwcyBhIGRvdWJsZSBsaW5rZWQgbGlz dCBtYXkgYmUgc3VpdGFibGUgaWYgcmVtb3ZlKCkgY2FsbGVkIGZyZXF1ZW50bHkKKyAgICBTdGF0 aWNQdHJCYXNlKiBjdXJyZW50ID0gaGVhZCgpOworICAgIGlmIChjdXJyZW50ID09IHRoaXMpIHsK KyAgICAgICAgbV9oZWFkID0gY3VycmVudC0+bmV4dCgpOworICAgICAgICByZXR1cm47CisgICAg fQorCisgICAgd2hpbGUgKGN1cnJlbnQtPm5leHQoKSAhPSB0aGlzKSB7CisgICAgICAgIGN1cnJl bnQgPSBjdXJyZW50LT5uZXh0KCk7CisgICAgICAgIEFTU0VSVChjdXJyZW50KTsKKyAgICB9Cisg ICAgY3VycmVudC0+bV9uZXh0ID0gbmV4dCgpOworfQorCisjZW5kaWYgLy8gRU5BQkxFKEZSRUVf U1RBVElDX1BUUlMpCisKK30gLy8gbmFtZXNwYWNlIFdURgpkaWZmIC0tZ2l0IGEvSmF2YVNjcmlw dENvcmUvd3RmL1N0YXRpY1B0ckJhc2UuaCBiL0phdmFTY3JpcHRDb3JlL3d0Zi9TdGF0aWNQdHJC YXNlLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZjhmN2Q1YQotLS0gL2Rl di9udWxsCisrKyBiL0phdmFTY3JpcHRDb3JlL3d0Zi9TdGF0aWNQdHJCYXNlLmgKQEAgLTAsMCAr MSw2MiBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAwOSBVbml2ZXJzaXR5IG9mIFN6ZWdlZAor ICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGlu IHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlv biwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwor ICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJl dGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlv bnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICog ICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxz IHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElT IFBST1ZJREVEIEJZIFVOSVZFUlNJVFkgT0YgU1pFR0VEIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBF WFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQg VE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklU TkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8g RVZFTlQgU0hBTEwgVU5JVkVSU0lUWSBPRiBTWkVHRUQgT1IKKyAqIENPTlRSSUJVVE9SUyBCRSBM SUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAorICog RVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBM SU1JVEVEIFRPLAorICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNF UzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJV UFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJVFks IFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNM VURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0Yg VEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NT SUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVmIFdURl9TdGF0aWNQdHJCYXNl X2gKKyNkZWZpbmUgV1RGX1N0YXRpY1B0ckJhc2VfaAorCisjaW5jbHVkZSAiQXNzZXJ0aW9ucy5o IgorI2luY2x1ZGUgIlR5cGVUcmFpdHMuaCIKKyNpbmNsdWRlICJBbHdheXNJbmxpbmUuaCIKKwor bmFtZXNwYWNlIFdURiB7CisKKy8vIFRoZSBjbGFzc2VzIGhlcmUgYXJlIGRlZmluZWQgYXMgc3Ry dWN0cyB0byBhdm9pZAorLy8gdGhlIGNhbGwgb2YgQysrIGNvbnN0cnVjdG9ycyBhbmQgZGVzdHJ1 Y3RvcnMKKworI2lmIEVOQUJMRShGUkVFX1NUQVRJQ19QVFJTKQordHlwZWRlZiB2b2lkICgqU3Rh dGljUHRyQmFzZUZyZWUpKHZvaWQqIHB0cik7CisKKy8vIE11c3QgYmUgdGhlIGZpcnN0IG1lbWJl ciBvZiBTdGF0aWNQdHJCYXNlIGRlc2NlbmRhbnRzCitzdHJ1Y3QgU3RhdGljUHRyQmFzZSB7Citw dWJsaWM6CisgICAgLy8gTWV0aG9kcworICAgIHZvaWQgYXBwZW5kKCk7CisgICAgdm9pZCByZW1v dmUoKTsKKworICAgIHN0YXRpYyB2b2lkIGZyZWVTdGF0aWNQdHJzKCk7CisKKyAgICBzdGF0aWMg U3RhdGljUHRyQmFzZSogbV9oZWFkOworICAgIFN0YXRpY1B0ckJhc2UqIG1fbmV4dDsKKyAgICBT dGF0aWNQdHJCYXNlRnJlZSBtX2ZyZWU7CisKKyAgICBzdGF0aWMgaW5saW5lIFN0YXRpY1B0ckJh c2UqIGhlYWQoKSB7IHJldHVybiBtX2hlYWQ7IH0KKyAgICBpbmxpbmUgU3RhdGljUHRyQmFzZSog bmV4dCgpIHsgcmV0dXJuIG1fbmV4dDsgfQorfTsKKyNlbmRpZgorCit9IC8vIG5hbWVzcGFjZSBX VEYKKworI2VuZGlmCmRpZmYgLS1naXQgYS9KYXZhU2NyaXB0Q29yZS93dGYvU3RkTGliRXh0cmFz LmggYi9KYXZhU2NyaXB0Q29yZS93dGYvU3RkTGliRXh0cmFzLmgKaW5kZXggZDIxZDFmZi4uMjlh M2YzYyAxMDA2NDQKLS0tIGEvSmF2YVNjcmlwdENvcmUvd3RmL1N0ZExpYkV4dHJhcy5oCisrKyBi L0phdmFTY3JpcHRDb3JlL3d0Zi9TdGRMaWJFeHRyYXMuaApAQCAtMjgsMTEgKzI4LDE2IEBACiAK ICNpbmNsdWRlIDx3dGYvUGxhdGZvcm0uaD4KICNpbmNsdWRlIDx3dGYvQXNzZXJ0aW9ucy5oPgor I2luY2x1ZGUgPHd0Zi9Mb2NhbFN0YXRpY1B0ci5oPgogCiAvLyBVc2UgdGhlc2UgdG8gZGVjbGFy ZSBhbmQgZGVmaW5lIGEgc3RhdGljIGxvY2FsIHZhcmlhYmxlIChzdGF0aWMgVDspIHNvIHRoYXQK IC8vICBpdCBpcyBsZWFrZWQgc28gdGhhdCBpdHMgZGVzdHJ1Y3RvcnMgYXJlIG5vdCBjYWxsZWQg YXQgZXhpdC4gVXNpbmcgdGhpcwogLy8gIG1hY3JvIGFsc28gYWxsb3dzIHdvcmthcm91bmRzIGEg Y29tcGlsZXIgYnVnIHByZXNlbnQgaW4gQXBwbGUncyB2ZXJzaW9uIG9mIEdDQyA0LjAuMS4KLSNp ZiBDT01QSUxFUihHQ0MpICYmIGRlZmluZWQoX19BUFBMRV9DQ19fKSAmJiBfX0dOVUNfXyA9PSA0 ICYmIF9fR05VQ19NSU5PUl9fID09IDAgJiYgX19HTlVDX1BBVENITEVWRUxfXyA9PSAxCisjaWYg RU5BQkxFKEZSRUVfU1RBVElDX1BUUlMpCisjZGVmaW5lIERFRklORV9TVEFUSUNfTE9DQUwodHlw ZSwgbmFtZSwgYXJndW1lbnRzKSBcCisgICAgc3RhdGljIFdURjo6TG9jYWxTdGF0aWNQdHI8dHlw ZT4gbmFtZSMjUHRyKG5ldyB0eXBlIGFyZ3VtZW50cyk7IFwKKyAgICB0eXBlJiBuYW1lID0gKm5h bWUjI1B0cgorI2VsaWYgQ09NUElMRVIoR0NDKSAmJiBkZWZpbmVkKF9fQVBQTEVfQ0NfXykgJiYg X19HTlVDX18gPT0gNCAmJiBfX0dOVUNfTUlOT1JfXyA9PSAwICYmIF9fR05VQ19QQVRDSExFVkVM X18gPT0gMQogI2RlZmluZSBERUZJTkVfU1RBVElDX0xPQ0FMKHR5cGUsIG5hbWUsIGFyZ3VtZW50 cykgXAogICAgIHN0YXRpYyB0eXBlKiBuYW1lIyNQdHIgPSBuZXcgdHlwZSBhcmd1bWVudHM7IFwK ICAgICB0eXBlJiBuYW1lID0gKm5hbWUjI1B0cgpkaWZmIC0tZ2l0IGEvSmF2YVNjcmlwdENvcmUv d3RmL1RocmVhZFNwZWNpZmljLmggYi9KYXZhU2NyaXB0Q29yZS93dGYvVGhyZWFkU3BlY2lmaWMu aAppbmRleCA0ZDVkMmY3Li44YmZkY2NmIDEwMDY0NAotLS0gYS9KYXZhU2NyaXB0Q29yZS93dGYv VGhyZWFkU3BlY2lmaWMuaAorKysgYi9KYXZhU2NyaXB0Q29yZS93dGYvVGhyZWFkU3BlY2lmaWMu aApAQCAtMjMyLDcgKzIzMiw5IEBAIGlubGluZSB2b2lkIFRocmVhZFNwZWNpZmljPFQ+OjpkZXN0 cm95KHZvaWQqIHB0cikKICNlcnJvciBUaHJlYWRTcGVjaWZpYyBpcyBub3QgaW1wbGVtZW50ZWQg Zm9yIHRoaXMgcGxhdGZvcm0uCiAjZW5kaWYKIAorI2lmICFQTEFURk9STShRVCkKICAgICBkZWxl dGUgZGF0YTsKKyNlbmRpZgogfQogCiB0ZW1wbGF0ZTx0eXBlbmFtZSBUPgpkaWZmIC0tZ2l0IGEv SmF2YVNjcmlwdENvcmUvd3RmL3F0L1RocmVhZGluZ1F0LmNwcCBiL0phdmFTY3JpcHRDb3JlL3d0 Zi9xdC9UaHJlYWRpbmdRdC5jcHAKaW5kZXggMWZkZDJiYi4uODdjODE3MSAxMDA2NDQKLS0tIGEv SmF2YVNjcmlwdENvcmUvd3RmL3F0L1RocmVhZGluZ1F0LmNwcAorKysgYi9KYXZhU2NyaXB0Q29y ZS93dGYvcXQvVGhyZWFkaW5nUXQuY3BwCkBAIC0zMyw2ICszMyw3IEBACiAjaW5jbHVkZSAiSGFz aE1hcC5oIgogI2luY2x1ZGUgIk1haW5UaHJlYWQuaCIKICNpbmNsdWRlICJSYW5kb21OdW1iZXJT ZWVkLmgiCisjaW5jbHVkZSAiR2xvYmFsUHRyLmgiCiAKICNpbmNsdWRlIDxRQ29yZUFwcGxpY2F0 aW9uPgogI2luY2x1ZGUgPFFNdXRleD4KQEAgLTY1LDcgKzY2LDcgQEAgdm9pZCBUaHJlYWRQcml2 YXRlOjpydW4oKQogfQogCiAKLXN0YXRpYyBNdXRleCogYXRvbWljYWxseUluaXRpYWxpemVkU3Rh dGljTXV0ZXg7CitzdGF0aWMgV1RGOjpHbG9iYWxQdHI8TXV0ZXg+IGF0b21pY2FsbHlJbml0aWFs aXplZFN0YXRpY011dGV4OwogCiBzdGF0aWMgVGhyZWFkSWRlbnRpZmllciBtYWluVGhyZWFkSWRl bnRpZmllcjsKIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9XZWJDb3JlLnBybyBiL1dlYkNvcmUvV2Vi Q29yZS5wcm8KaW5kZXggNjEzNTYyYy4uMjdlNTM1MyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9XZWJD b3JlLnBybworKysgYi9XZWJDb3JlL1dlYkNvcmUucHJvCkBAIC0xMDQ0LDYgKzEwNDQsNyBAQCBT T1VSQ0VTICs9IFwKICAgICBodG1sL0hUTUxWaWV3U291cmNlRG9jdW1lbnQuY3BwIFwKICAgICBo dG1sL0ltYWdlRGF0YS5jcHAgXAogICAgIGh0bWwvUHJlbG9hZFNjYW5uZXIuY3BwIFwKKyAgICBo dG1sL1RpbWVSYW5nZXMuY3BwIFwKICAgICBodG1sL1ZhbGlkaXR5U3RhdGUuY3BwIFwKICAgICBp bnNwZWN0b3IvQ29uc29sZU1lc3NhZ2UuY3BwIFwKICAgICBpbnNwZWN0b3IvSW5zcGVjdG9yQmFj a2VuZC5jcHAgXApAQCAtMjYyOSw3ICsyNjMwLDYgQEAgY29udGFpbnMoREVGSU5FUywgRU5BQkxF X1ZJREVPPTEpIHsKICAgICAgICAgaHRtbC9IVE1MTWVkaWFFbGVtZW50LmNwcCBcCiAgICAgICAg IGh0bWwvSFRNTFNvdXJjZUVsZW1lbnQuY3BwIFwKICAgICAgICAgaHRtbC9IVE1MVmlkZW9FbGVt ZW50LmNwcCBcCi0gICAgICAgIGh0bWwvVGltZVJhbmdlcy5jcHAgXAogICAgICAgICBwbGF0Zm9y bS9ncmFwaGljcy9NZWRpYVBsYXllci5jcHAgXAogICAgICAgICByZW5kZXJpbmcvTWVkaWFDb250 cm9sRWxlbWVudHMuY3BwIFwKICAgICAgICAgcmVuZGVyaW5nL1JlbmRlclZpZGVvLmNwcCBcCmRp ZmYgLS1naXQgYS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTRE9NV2luZG93QmFzZS5jcHAgYi9XZWJD b3JlL2JpbmRpbmdzL2pzL0pTRE9NV2luZG93QmFzZS5jcHAKaW5kZXggZGY2MDY4YS4uMWI4YzJm NCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0RPTVdpbmRvd0Jhc2UuY3BwCisr KyBiL1dlYkNvcmUvYmluZGluZ3MvanMvSlNET01XaW5kb3dCYXNlLmNwcApAQCAtMzUsNiArMzUs NyBAQAogI2luY2x1ZGUgIlNjcmlwdENvbnRyb2xsZXIuaCIKICNpbmNsdWRlICJTZWN1cml0eU9y aWdpbi5oIgogI2luY2x1ZGUgIlNldHRpbmdzLmgiCisjaW5jbHVkZSAid3RmL0dsb2JhbFB0ci5o IgogCiB1c2luZyBuYW1lc3BhY2UgSlNDOwogCkBAIC0xNjEsMTUgKzE2MiwyNiBAQCBKU0RPTVdp bmRvd1NoZWxsKiBKU0RPTVdpbmRvd0Jhc2U6OnNoZWxsKCkgY29uc3QKICAgICByZXR1cm4gZCgp LT5zaGVsbDsKIH0KIAorI2lmIEVOQUJMRShGUkVFX1NUQVRJQ19QVFJTKQorc3RhdGljIHZvaWQg Z2xvYmFsRGF0YUZyZWUodm9pZCogcHRyKQoreworICAgIHJlaW50ZXJwcmV0X2Nhc3Q8V1RGOjpH bG9iYWxQdHI8SlNHbG9iYWxEYXRhPio+KHB0ciktPmdldCgpLT5oZWFwLmRlc3Ryb3koKTsKKyAg ICBkZWxldGUgcmVpbnRlcnByZXRfY2FzdDxXVEY6Okdsb2JhbFB0cjxKU0dsb2JhbERhdGE+Kj4o cHRyKS0+Z2V0KCk7Cit9CisjZW5kaWYKKwogSlNHbG9iYWxEYXRhKiBKU0RPTVdpbmRvd0Jhc2U6 OmNvbW1vbkpTR2xvYmFsRGF0YSgpCiB7Ci0gICAgc3RhdGljIEpTR2xvYmFsRGF0YSogZ2xvYmFs RGF0YTsKKyAgICBzdGF0aWMgV1RGOjpHbG9iYWxQdHI8SlNHbG9iYWxEYXRhPiBnbG9iYWxEYXRh OwogICAgIGlmICghZ2xvYmFsRGF0YSkgewotICAgICAgICBnbG9iYWxEYXRhID0gSlNHbG9iYWxE YXRhOjpjcmVhdGVMZWFrZWQoKS5yZWxlYXNlUmVmKCk7CisgICAgICAgIGdsb2JhbERhdGEuc2V0 UHRyKEpTR2xvYmFsRGF0YTo6Y3JlYXRlTGVha2VkKCkucmVsZWFzZVJlZigpKTsKKyNpZiBFTkFC TEUoRlJFRV9TVEFUSUNfUFRSUykKKyAgICAgICAgZ2xvYmFsRGF0YS5zZXRGcmVlKGdsb2JhbERh dGFGcmVlKTsKKyNlbmRpZgogICAgICAgICBnbG9iYWxEYXRhLT50aW1lb3V0Q2hlY2tlci5zZXRU aW1lb3V0SW50ZXJ2YWwoMTAwMDApOyAvLyAxMCBzZWNvbmRzCiAgICAgfQogCi0gICAgcmV0dXJu IGdsb2JhbERhdGE7CisgICAgcmV0dXJuIGdsb2JhbERhdGEuZ2V0KCk7CiB9CiAKIC8vIEpTRE9N R2xvYmFsT2JqZWN0KiBpcyBpZ25vcmVkLCBhY2Nlc2luZyBhIHdpbmRvdyBpbiBhbnkgY29udGV4 dCB3aWxsCmRpZmYgLS1naXQgYS9XZWJDb3JlL2JyaWRnZS9JZGVudGlmaWVyUmVwLmNwcCBiL1dl YkNvcmUvYnJpZGdlL0lkZW50aWZpZXJSZXAuY3BwCmluZGV4IDExNTYwZTMuLjE3MmUxNGQgMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvYnJpZGdlL0lkZW50aWZpZXJSZXAuY3BwCisrKyBiL1dlYkNvcmUv YnJpZGdlL0lkZW50aWZpZXJSZXAuY3BwCkBAIC0yOCw2ICsyOCw3IEBACiAKICNpbmNsdWRlICJQ bGF0Zm9ybVN0cmluZy5oIgogI2luY2x1ZGUgPHJ1bnRpbWUvVVN0cmluZy5oPgorI2luY2x1ZGUg PHd0Zi9HbG9iYWxQdHIuaD4KICNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgogI2luY2x1ZGUgPHd0 Zi9TdGRMaWJFeHRyYXMuaD4KIApAQCAtNTQsOSArNTUsOSBAQCBzdGF0aWMgSW50SWRlbnRpZmll ck1hcCYgaW50SWRlbnRpZmllck1hcCgpCiBJZGVudGlmaWVyUmVwKiBJZGVudGlmaWVyUmVwOjpn ZXQoaW50IGludElEKQogewogICAgIGlmIChpbnRJRCA9PSAwIHx8IGludElEID09IC0xKSB7Ci0g ICAgICAgIHN0YXRpYyBJZGVudGlmaWVyUmVwKiBuZWdhdGl2ZU9uZUFuZFplcm9JZGVudGlmaWVy c1syXTsKKyAgICAgICAgc3RhdGljIFdURjo6R2xvYmFsUHRyPElkZW50aWZpZXJSZXA+IG5lZ2F0 aXZlT25lQW5kWmVyb0lkZW50aWZpZXJzWzJdOwogCi0gICAgICAgIElkZW50aWZpZXJSZXAqIGlk ZW50aWZpZXIgPSBuZWdhdGl2ZU9uZUFuZFplcm9JZGVudGlmaWVyc1tpbnRJRCArIDFdOworICAg ICAgICBJZGVudGlmaWVyUmVwKiBpZGVudGlmaWVyID0gbmVnYXRpdmVPbmVBbmRaZXJvSWRlbnRp ZmllcnNbaW50SUQgKyAxXS5nZXQoKTsKICAgICAgICAgaWYgKCFpZGVudGlmaWVyKSB7CiAgICAg ICAgICAgICBpZGVudGlmaWVyID0gbmV3IElkZW50aWZpZXJSZXAoaW50SUQpOwogCmRpZmYgLS1n aXQgYS9XZWJDb3JlL2JyaWRnZS9JZGVudGlmaWVyUmVwLmggYi9XZWJDb3JlL2JyaWRnZS9JZGVu dGlmaWVyUmVwLmgKaW5kZXggOGUwZTBkOS4uNTMzZDI2NiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9i cmlkZ2UvSWRlbnRpZmllclJlcC5oCisrKyBiL1dlYkNvcmUvYnJpZGdlL0lkZW50aWZpZXJSZXAu aApAQCAtNTYsMTEgKzU2LDEzIEBAIHByaXZhdGU6CiAgICAgICAgIG1fdmFsdWUubV9zdHJpbmcg PSBzdHJkdXAobmFtZSk7CiAgICAgfQogICAgIAorI2lmICFFTkFCTEUoRlJFRV9TVEFUSUNfUFRS UykKICAgICB+SWRlbnRpZmllclJlcCgpCiAgICAgewogICAgICAgICAvLyBJZGVudGlmaWVyUmVw cyBzaG91bGQgbmV2ZXIgYmUgZGVsZXRlZC4KICAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7 CiAgICAgfQorI2VuZGlmCiAgICAgCiAgICAgdW5pb24gewogICAgICAgICBjb25zdCBjaGFyKiBt X3N0cmluZzsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvY3NzL0NTU0luaXRpYWxWYWx1ZS5oIGIvV2Vi Q29yZS9jc3MvQ1NTSW5pdGlhbFZhbHVlLmgKaW5kZXggOTZiYzJhNS4uZjYwMzczOSAxMDA2NDQK LS0tIGEvV2ViQ29yZS9jc3MvQ1NTSW5pdGlhbFZhbHVlLmgKKysrIGIvV2ViQ29yZS9jc3MvQ1NT SW5pdGlhbFZhbHVlLmgKQEAgLTIzLDYgKzIzLDcgQEAKIAogI2luY2x1ZGUgIkNTU1ZhbHVlLmgi CiAjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KKyNpbmNsdWRlIDx3dGYvU3RkTGliRXh0cmFz Lmg+CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIApAQCAtMzAsMTMgKzMxLDEzIEBAIGNsYXNzIENT U0luaXRpYWxWYWx1ZSA6IHB1YmxpYyBDU1NWYWx1ZSB7CiBwdWJsaWM6CiAgICAgc3RhdGljIFBh c3NSZWZQdHI8Q1NTSW5pdGlhbFZhbHVlPiBjcmVhdGVFeHBsaWNpdCgpCiAgICAgewotICAgICAg ICBzdGF0aWMgQ1NTSW5pdGlhbFZhbHVlKiBleHBsaWNpdFZhbHVlID0gbmV3IENTU0luaXRpYWxW YWx1ZShmYWxzZSk7Ci0gICAgICAgIHJldHVybiBleHBsaWNpdFZhbHVlOworICAgICAgICBERUZJ TkVfU1RBVElDX0xPQ0FMKENTU0luaXRpYWxWYWx1ZSwgZXhwbGljaXRWYWx1ZSwgKGZhbHNlKSk7 CisgICAgICAgIHJldHVybiAmZXhwbGljaXRWYWx1ZTsKICAgICB9CiAgICAgc3RhdGljIFBhc3NS ZWZQdHI8Q1NTSW5pdGlhbFZhbHVlPiBjcmVhdGVJbXBsaWNpdCgpCiAgICAgewotICAgICAgICBz dGF0aWMgQ1NTSW5pdGlhbFZhbHVlKiBleHBsaWNpdFZhbHVlID0gbmV3IENTU0luaXRpYWxWYWx1 ZSh0cnVlKTsKLSAgICAgICAgcmV0dXJuIGV4cGxpY2l0VmFsdWU7CisgICAgICAgIERFRklORV9T VEFUSUNfTE9DQUwoQ1NTSW5pdGlhbFZhbHVlLCBleHBsaWNpdFZhbHVlLCAodHJ1ZSkpOworICAg ICAgICByZXR1cm4gJmV4cGxpY2l0VmFsdWU7CiAgICAgfQogCiAgICAgdmlydHVhbCBTdHJpbmcg Y3NzVGV4dCgpIGNvbnN0OwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9jc3MvQ1NTUHJpbWl0aXZlVmFs dWUuY3BwIGIvV2ViQ29yZS9jc3MvQ1NTUHJpbWl0aXZlVmFsdWUuY3BwCmluZGV4IDFmMmM5Y2Eu LjMyYmY0ODggMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvY3NzL0NTU1ByaW1pdGl2ZVZhbHVlLmNwcAor KysgYi9XZWJDb3JlL2Nzcy9DU1NQcmltaXRpdmVWYWx1ZS5jcHAKQEAgLTM0LDYgKzM0LDggQEAK ICNpbmNsdWRlICJSZWN0LmgiCiAjaW5jbHVkZSAiUmVuZGVyU3R5bGUuaCIKICNpbmNsdWRlIDx3 dGYvQVNDSUlDVHlwZS5oPgorI2luY2x1ZGUgPHd0Zi9Mb2NhbFN0YXRpY1B0ci5oPgorI2luY2x1 ZGUgPHd0Zi9Mb2NhbFN0YXRpY0FycmF5UHRyLmg+CiAjaW5jbHVkZSA8d3RmL1N0ZExpYkV4dHJh cy5oPgogCiAjaWYgRU5BQkxFKERBU0hCT0FSRF9TVVBQT1JUKQpAQCAtNTAsNyArNTIsNyBAQCBu YW1lc3BhY2UgV2ViQ29yZSB7CiAKIFBhc3NSZWZQdHI8Q1NTUHJpbWl0aXZlVmFsdWU+IENTU1By aW1pdGl2ZVZhbHVlOjpjcmVhdGVJZGVudGlmaWVyKGludCBpZGVudCkKIHsKLSAgICBzdGF0aWMg UmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVlPiogaWRlbnRWYWx1ZUNhY2hlID0gbmV3IFJlZlB0cjxD U1NQcmltaXRpdmVWYWx1ZT5bbnVtQ1NTVmFsdWVLZXl3b3Jkc107CisgICAgc3RhdGljIFdURjo6 TG9jYWxTdGF0aWNBcnJheVB0cjxSZWZQdHI8Q1NTUHJpbWl0aXZlVmFsdWU+ID4gaWRlbnRWYWx1 ZUNhY2hlKG5ldyBSZWZQdHI8Q1NTUHJpbWl0aXZlVmFsdWU+W251bUNTU1ZhbHVlS2V5d29yZHNd KTsKICAgICBpZiAoaWRlbnQgPj0gMCAmJiBpZGVudCA8IG51bUNTU1ZhbHVlS2V5d29yZHMpIHsK ICAgICAgICAgUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVlPiBwcmltaXRpdmVWYWx1ZSA9IGlkZW50 VmFsdWVDYWNoZVtpZGVudF07CiAgICAgICAgIGlmICghcHJpbWl0aXZlVmFsdWUpIHsKQEAgLTY1 LDcgKzY3LDcgQEAgUGFzc1JlZlB0cjxDU1NQcmltaXRpdmVWYWx1ZT4gQ1NTUHJpbWl0aXZlVmFs dWU6OmNyZWF0ZUlkZW50aWZpZXIoaW50IGlkZW50KQogUGFzc1JlZlB0cjxDU1NQcmltaXRpdmVW YWx1ZT4gQ1NTUHJpbWl0aXZlVmFsdWU6OmNyZWF0ZUNvbG9yKHVuc2lnbmVkIHJnYlZhbHVlKQog ewogICAgIHR5cGVkZWYgSGFzaE1hcDx1bnNpZ25lZCwgUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVl PiA+IENvbG9yVmFsdWVDYWNoZTsKLSAgICBzdGF0aWMgQ29sb3JWYWx1ZUNhY2hlKiBjb2xvclZh bHVlQ2FjaGUgPSBuZXcgQ29sb3JWYWx1ZUNhY2hlOworICAgIHN0YXRpYyBXVEY6OkxvY2FsU3Rh dGljUHRyPENvbG9yVmFsdWVDYWNoZT4gY29sb3JWYWx1ZUNhY2hlKG5ldyBDb2xvclZhbHVlQ2Fj aGUpOwogICAgIC8vIFRoZXNlIGFyZSB0aGUgZW1wdHkgYW5kIGRlbGV0ZWQgdmFsdWVzIG9mIHRo ZSBoYXNoIHRhYmxlLgogICAgIGlmIChyZ2JWYWx1ZSA9PSBDb2xvcjo6dHJhbnNwYXJlbnQpIHsK ICAgICAgICAgc3RhdGljIENTU1ByaW1pdGl2ZVZhbHVlKiBjb2xvclRyYW5zcGFyZW50ID0gbmV3 IENTU1ByaW1pdGl2ZVZhbHVlKENvbG9yOjp0cmFuc3BhcmVudCk7CkBAIC05NCw4ICs5Niw4IEBA IFBhc3NSZWZQdHI8Q1NTUHJpbWl0aXZlVmFsdWU+IENTU1ByaW1pdGl2ZVZhbHVlOjpjcmVhdGUo ZG91YmxlIHZhbHVlLCBVbml0VHlwZXMKICAgICBjb25zdCBpbnQgY2FjaGVkSW50ZWdlckNvdW50 ID0gMTI4OwogICAgIC8vIE90aGVyIGNvbW1vbiBwcmltaXRpdmUgdHlwZXMgaGF2ZSBVbml0VHlw ZXMgc21hbGxlciB0aGFuIHRoaXMuCiAgICAgY29uc3QgaW50IG1heENhY2hlZFVuaXRUeXBlID0g Q1NTX1BYOwotICAgIHR5cGVkZWYgUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVlPigqIEludGVnZXJW YWx1ZUNhY2hlKVttYXhDYWNoZWRVbml0VHlwZSArIDFdOwotICAgIHN0YXRpYyBJbnRlZ2VyVmFs dWVDYWNoZSBpbnRlZ2VyVmFsdWVDYWNoZSA9IG5ldyBSZWZQdHI8Q1NTUHJpbWl0aXZlVmFsdWU+ W2NhY2hlZEludGVnZXJDb3VudF1bbWF4Q2FjaGVkVW5pdFR5cGUgKyAxXTsKKyAgICB0eXBlZGVm IFJlZlB0cjxDU1NQcmltaXRpdmVWYWx1ZT4gSW50ZWdlclZhbHVlQ2FjaGVbbWF4Q2FjaGVkVW5p dFR5cGUgKyAxXTsKKyAgICBzdGF0aWMgV1RGOjpMb2NhbFN0YXRpY0FycmF5UHRyPEludGVnZXJW YWx1ZUNhY2hlPiBpbnRlZ2VyVmFsdWVDYWNoZShuZXcgUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVl PltjYWNoZWRJbnRlZ2VyQ291bnRdW21heENhY2hlZFVuaXRUeXBlICsgMV0pOwogICAgIGlmICh0 eXBlIDw9IG1heENhY2hlZFVuaXRUeXBlICYmIHZhbHVlID49IDAgJiYgdmFsdWUgPCBjYWNoZWRJ bnRlZ2VyQ291bnQpIHsKICAgICAgICAgaW50IGludFZhbHVlID0gc3RhdGljX2Nhc3Q8aW50Pih2 YWx1ZSk7CiAgICAgICAgIGlmICh2YWx1ZSA9PSBpbnRWYWx1ZSkgewpkaWZmIC0tZ2l0IGEvV2Vi Q29yZS9jc3MvQ1NTU3R5bGVTZWxlY3Rvci5jcHAgYi9XZWJDb3JlL2Nzcy9DU1NTdHlsZVNlbGVj dG9yLmNwcAppbmRleCBjZWRlZWE5Li45NzQ5OTE0IDEwMDY0NAotLS0gYS9XZWJDb3JlL2Nzcy9D U1NTdHlsZVNlbGVjdG9yLmNwcAorKysgYi9XZWJDb3JlL2Nzcy9DU1NTdHlsZVNlbGVjdG9yLmNw cApAQCAtMzc2LDEzICszNzYsMTMgQEAgcHVibGljOgogICAgIHVuc2lnbmVkIG1fcnVsZUNvdW50 OwogfTsKIAotc3RhdGljIENTU1J1bGVTZXQqIGRlZmF1bHRTdHlsZTsKLXN0YXRpYyBDU1NSdWxl U2V0KiBkZWZhdWx0UXVpcmtzU3R5bGU7Ci1zdGF0aWMgQ1NTUnVsZVNldCogZGVmYXVsdFByaW50 U3R5bGU7Ci1zdGF0aWMgQ1NTUnVsZVNldCogZGVmYXVsdFZpZXdTb3VyY2VTdHlsZTsKLXN0YXRp YyBDU1NTdHlsZVNoZWV0KiBzaW1wbGVEZWZhdWx0U3R5bGVTaGVldDsKK3N0YXRpYyBXVEY6Okds b2JhbFB0cjxDU1NSdWxlU2V0PiBkZWZhdWx0U3R5bGU7CitzdGF0aWMgV1RGOjpHbG9iYWxQdHI8 Q1NTUnVsZVNldD4gZGVmYXVsdFF1aXJrc1N0eWxlOworc3RhdGljIFdURjo6R2xvYmFsUHRyPENT U1J1bGVTZXQ+IGRlZmF1bHRQcmludFN0eWxlOworc3RhdGljIFdURjo6R2xvYmFsUHRyPENTU1J1 bGVTZXQ+IGRlZmF1bHRWaWV3U291cmNlU3R5bGU7CitzdGF0aWMgV1RGOjpHbG9iYWxQdHI8Q1NT U3R5bGVTaGVldD4gc2ltcGxlRGVmYXVsdFN0eWxlU2hlZXQ7CiAKLVJlbmRlclN0eWxlKiBDU1NT dHlsZVNlbGVjdG9yOjpzX3N0eWxlTm90WWV0QXZhaWxhYmxlOworV1RGOjpHbG9iYWxQdHI8UmVu ZGVyU3R5bGU+IENTU1N0eWxlU2VsZWN0b3I6OnNfc3R5bGVOb3RZZXRBdmFpbGFibGU7CiAKIHN0 YXRpYyBQc2V1ZG9TdGF0ZSBwc2V1ZG9TdGF0ZTsKIApAQCAtNTEyLDEwICs1MTIsMTAgQEAgc3Rh dGljIENTU1N0eWxlU2hlZXQqIHBhcnNlVUFTaGVldChjb25zdCBjaGFyKiBjaGFyYWN0ZXJzLCB1 bnNpZ25lZCBzaXplKQogCiBzdGF0aWMgdm9pZCBsb2FkRnVsbERlZmF1bHRTdHlsZSgpCiB7Ci0g ICAgaWYgKHNpbXBsZURlZmF1bHRTdHlsZVNoZWV0KSB7CisgICAgaWYgKHNpbXBsZURlZmF1bHRT dHlsZVNoZWV0LmdldCgpKSB7CiAgICAgICAgIEFTU0VSVChkZWZhdWx0U3R5bGUpOwotICAgICAg ICBkZWxldGUgZGVmYXVsdFN0eWxlOwotICAgICAgICBkZWxldGUgc2ltcGxlRGVmYXVsdFN0eWxl U2hlZXQ7CisgICAgICAgIGRlZmF1bHRTdHlsZS5kZWxldGVQdHIoKTsKKyAgICAgICAgc2ltcGxl RGVmYXVsdFN0eWxlU2hlZXQuZGVsZXRlUHRyKCk7CiAgICAgICAgIGRlZmF1bHRTdHlsZSA9IG5l dyBDU1NSdWxlU2V0OwogICAgICAgICBzaW1wbGVEZWZhdWx0U3R5bGVTaGVldCA9IDA7CiAgICAg fSBlbHNlIHsKQEAgLTU0Nyw3ICs1NDcsNyBAQCBzdGF0aWMgdm9pZCBsb2FkU2ltcGxlRGVmYXVs dFN0eWxlKCkKICAgICBkZWZhdWx0UXVpcmtzU3R5bGUgPSBuZXcgQ1NTUnVsZVNldDsKIAogICAg IHNpbXBsZURlZmF1bHRTdHlsZVNoZWV0ID0gcGFyc2VVQVNoZWV0KHNpbXBsZVVzZXJBZ2VudFN0 eWxlU2hlZXQsIHN0cmxlbihzaW1wbGVVc2VyQWdlbnRTdHlsZVNoZWV0KSk7Ci0gICAgZGVmYXVs dFN0eWxlLT5hZGRSdWxlc0Zyb21TaGVldChzaW1wbGVEZWZhdWx0U3R5bGVTaGVldCwgc2NyZWVu RXZhbCgpKTsKKyAgICBkZWZhdWx0U3R5bGUtPmFkZFJ1bGVzRnJvbVNoZWV0KHNpbXBsZURlZmF1 bHRTdHlsZVNoZWV0LmdldCgpLCBzY3JlZW5FdmFsKCkpOwogICAgIAogICAgIC8vIE5vIG5lZWQg dG8gaW5pdGlhbGl6ZSBxdWlya3Mgc2hlZXQgeWV0IGFzIHRoZXJlIGFyZSBubyBxdWlyayBydWxl cyBmb3IgZWxlbWVudHMgYWxsb3dlZCBpbiBzaW1wbGUgZGVmYXVsdCBzdHlsZS4KIH0KQEAgLTEw NzEsMTggKzEwNzEsMTggQEAgdm9pZCBDU1NTdHlsZVNlbGVjdG9yOjptYXRjaFVBUnVsZXMoaW50 JiBmaXJzdFVBUnVsZSwgaW50JiBsYXN0VUFSdWxlKQogewogICAgIC8vIEZpcnN0IHdlIG1hdGNo IHJ1bGVzIGZyb20gdGhlIHVzZXIgYWdlbnQgc2hlZXQuCiAgICAgQ1NTUnVsZVNldCogdXNlckFn ZW50U3R5bGVTaGVldCA9IG1fbWVkaXVtLT5tZWRpYVR5cGVNYXRjaFNwZWNpZmljKCJwcmludCIp Ci0gICAgICAgID8gZGVmYXVsdFByaW50U3R5bGUgOiBkZWZhdWx0U3R5bGU7CisgICAgICAgID8g ZGVmYXVsdFByaW50U3R5bGUuZ2V0KCkgOiBkZWZhdWx0U3R5bGUuZ2V0KCk7CiAgICAgbWF0Y2hS dWxlcyh1c2VyQWdlbnRTdHlsZVNoZWV0LCBmaXJzdFVBUnVsZSwgbGFzdFVBUnVsZSk7CiAKICAg ICAvLyBJbiBxdWlya3MgbW9kZSwgd2UgbWF0Y2ggcnVsZXMgZnJvbSB0aGUgcXVpcmtzIHVzZXIg YWdlbnQgc2hlZXQuCiAgICAgaWYgKCFtX2NoZWNrZXIubV9zdHJpY3RQYXJzaW5nKQotICAgICAg ICBtYXRjaFJ1bGVzKGRlZmF1bHRRdWlya3NTdHlsZSwgZmlyc3RVQVJ1bGUsIGxhc3RVQVJ1bGUp OworICAgICAgICBtYXRjaFJ1bGVzKGRlZmF1bHRRdWlya3NTdHlsZS5nZXQoKSwgZmlyc3RVQVJ1 bGUsIGxhc3RVQVJ1bGUpOwogICAgICAgICAKICAgICAvLyBJZiB3ZSdyZSBpbiB2aWV3IHNvdXJj ZSBtb2RlLCB0aGVuIHdlIG1hdGNoIHJ1bGVzIGZyb20gdGhlIHZpZXcgc291cmNlIHN0eWxlIHNo ZWV0LgogICAgIGlmIChtX2NoZWNrZXIubV9kb2N1bWVudC0+ZnJhbWUoKSAmJiBtX2NoZWNrZXIu bV9kb2N1bWVudC0+ZnJhbWUoKS0+aW5WaWV3U291cmNlTW9kZSgpKSB7CiAgICAgICAgIGlmICgh ZGVmYXVsdFZpZXdTb3VyY2VTdHlsZSkKICAgICAgICAgICAgIGxvYWRWaWV3U291cmNlU3R5bGUo KTsKLSAgICAgICAgbWF0Y2hSdWxlcyhkZWZhdWx0Vmlld1NvdXJjZVN0eWxlLCBmaXJzdFVBUnVs ZSwgbGFzdFVBUnVsZSk7CisgICAgICAgIG1hdGNoUnVsZXMoZGVmYXVsdFZpZXdTb3VyY2VTdHls ZS5nZXQoKSwgZmlyc3RVQVJ1bGUsIGxhc3RVQVJ1bGUpOwogICAgIH0KIH0KIApAQCAtMTEwMiw3 ICsxMTAyLDcgQEAgUGFzc1JlZlB0cjxSZW5kZXJTdHlsZT4gQ1NTU3R5bGVTZWxlY3Rvcjo6c3R5 bGVGb3JFbGVtZW50KEVsZW1lbnQqIGUsIFJlbmRlclN0eWwKICAgICAgICAgfQogICAgICAgICBz X3N0eWxlTm90WWV0QXZhaWxhYmxlLT5yZWYoKTsKICAgICAgICAgZS0+ZG9jdW1lbnQoKS0+c2V0 SGFzTm9kZXNXaXRoUGxhY2Vob2xkZXJTdHlsZSgpOwotICAgICAgICByZXR1cm4gc19zdHlsZU5v dFlldEF2YWlsYWJsZTsKKyAgICAgICAgcmV0dXJuIHNfc3R5bGVOb3RZZXRBdmFpbGFibGUuZ2V0 KCk7CiAgICAgfQogCiAgICAgaW5pdEVsZW1lbnRBbmRQc2V1ZG9TdGF0ZShlKTsKQEAgLTExMjAs NyArMTEyMCw3IEBAIFBhc3NSZWZQdHI8UmVuZGVyU3R5bGU+IENTU1N0eWxlU2VsZWN0b3I6OnN0 eWxlRm9yRWxlbWVudChFbGVtZW50KiBlLCBSZW5kZXJTdHlsCiAgICAgZWxzZQogICAgICAgICBt X3BhcmVudFN0eWxlID0gc3R5bGUoKTsKIAotICAgIGlmIChzaW1wbGVEZWZhdWx0U3R5bGVTaGVl dCAmJiAhZWxlbWVudENhblVzZVNpbXBsZURlZmF1bHRTdHlsZShlKSkKKyAgICBpZiAoc2ltcGxl RGVmYXVsdFN0eWxlU2hlZXQuZ2V0KCkgJiYgIWVsZW1lbnRDYW5Vc2VTaW1wbGVEZWZhdWx0U3R5 bGUoZSkpCiAgICAgICAgIGxvYWRGdWxsRGVmYXVsdFN0eWxlKCk7CiAKICNpZiBFTkFCTEUoU1ZH KQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9jc3MvQ1NTU3R5bGVTZWxlY3Rvci5oIGIvV2ViQ29yZS9j c3MvQ1NTU3R5bGVTZWxlY3Rvci5oCmluZGV4IDllOGEzNGQuLjk2ODViNWQgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvY3NzL0NTU1N0eWxlU2VsZWN0b3IuaAorKysgYi9XZWJDb3JlL2Nzcy9DU1NTdHls ZVNlbGVjdG9yLmgKQEAgLTI4LDYgKzI4LDcgQEAKICNpbmNsdWRlICJNZWRpYVF1ZXJ5RXhwLmgi CiAjaW5jbHVkZSAiUmVuZGVyU3R5bGUuaCIKICNpbmNsdWRlICJTdHJpbmdIYXNoLmgiCisjaW5j bHVkZSA8d3RmL0dsb2JhbFB0ci5oPgogI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CiAjaW5jbHVk ZSA8d3RmL0hhc2hTZXQuaD4KICNpbmNsdWRlIDx3dGYvUmVmUHRyLmg+CkBAIC0xODYsNyArMTg3 LDcgQEAgcHVibGljOgogICAgICAgICBLZXlmcmFtZXNSdWxlTWFwIG1fa2V5ZnJhbWVzUnVsZU1h cDsKIAogICAgIHB1YmxpYzoKLSAgICAgICAgc3RhdGljIFJlbmRlclN0eWxlKiBzdHlsZU5vdFll dEF2YWlsYWJsZSgpIHsgcmV0dXJuIHNfc3R5bGVOb3RZZXRBdmFpbGFibGU7IH0KKyAgICAgICAg c3RhdGljIFJlbmRlclN0eWxlKiBzdHlsZU5vdFlldEF2YWlsYWJsZSgpIHsgcmV0dXJuIHNfc3R5 bGVOb3RZZXRBdmFpbGFibGUuZ2V0KCk7IH0KIAogICAgICAgICBjbGFzcyBTZWxlY3RvckNoZWNr ZXIgOiBwdWJsaWMgTm9uY29weWFibGUgewogICAgICAgICBwdWJsaWM6CkBAIC0yMTAsNyArMjEx LDcgQEAgcHVibGljOgogICAgICAgICB9OwogCiAgICAgcHJpdmF0ZToKLSAgICAgICAgc3RhdGlj IFJlbmRlclN0eWxlKiBzX3N0eWxlTm90WWV0QXZhaWxhYmxlOworICAgICAgICBzdGF0aWMgV1RG OjpHbG9iYWxQdHI8UmVuZGVyU3R5bGU+IHNfc3R5bGVOb3RZZXRBdmFpbGFibGU7CiAKICAgICAg ICAgdm9pZCBpbml0KCk7CiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvY3NzL01lZGlhRmVhdHVyZU5h bWVzLmNwcCBiL1dlYkNvcmUvY3NzL01lZGlhRmVhdHVyZU5hbWVzLmNwcAppbmRleCBmY2VlNWRl Li41NmU2ZTE5IDEwMDY0NAotLS0gYS9XZWJDb3JlL2Nzcy9NZWRpYUZlYXR1cmVOYW1lcy5jcHAK KysrIGIvV2ViQ29yZS9jc3MvTWVkaWFGZWF0dXJlTmFtZXMuY3BwCkBAIC00NCw3ICs0NCw3IEBA IHZvaWQgaW5pdCgpCiAgICAgICAgLy8gVXNlIHBsYWNlbWVudCBuZXcgdG8gaW5pdGlhbGl6ZSB0 aGUgZ2xvYmFscy4KIAogICAgICAgICBBdG9taWNTdHJpbmc6OmluaXQoKTsKLSAgICAgICAgI2Rl ZmluZSBJTklUSUFMSVpFX0dMT0JBTChuYW1lLCBzdHIpIG5ldyAoKHZvaWQqKSZuYW1lIyNNZWRp YUZlYXR1cmUpIEF0b21pY1N0cmluZyhzdHIpOworICAgICAgICAjZGVmaW5lIElOSVRJQUxJWkVf R0xPQkFMKG5hbWUsIHN0cikgSU5JVF9HTE9CQUwobmFtZSMjTWVkaWFGZWF0dXJlLCBBdG9taWNT dHJpbmcsIEF0b21pY1N0cmluZyhzdHIpKTsKICAgICAgICAgQ1NTX01FRElBUVVFUllfTkFNRVNf Rk9SX0VBQ0hfTUVESUFGRUFUVVJFKElOSVRJQUxJWkVfR0xPQkFMKQogICAgICAgICAjdW5kZWYg SU5JVElBTElaRV9HTE9CQUwKICAgICAgICAgaW5pdGlhbGl6ZWQgPSB0cnVlOwpkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9jc3MvTWVkaWFRdWVyeUV2YWx1YXRvci5jcHAgYi9XZWJDb3JlL2Nzcy9NZWRp YVF1ZXJ5RXZhbHVhdG9yLmNwcAppbmRleCA0OTYzZWQ0Li4xZWZmZmU0IDEwMDY0NAotLS0gYS9X ZWJDb3JlL2Nzcy9NZWRpYVF1ZXJ5RXZhbHVhdG9yLmNwcAorKysgYi9XZWJDb3JlL2Nzcy9NZWRp YVF1ZXJ5RXZhbHVhdG9yLmNwcApAQCAtNDUsNiArNDUsNyBAQAogI2luY2x1ZGUgIlJlbmRlclZp ZXcuaCIKICNpbmNsdWRlICJSZW5kZXJTdHlsZS5oIgogI2luY2x1ZGUgIlBsYXRmb3JtU2NyZWVu LmgiCisjaW5jbHVkZSA8d3RmL0dsb2JhbFB0ci5oPgogI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+ CiAKICNpZiBFTkFCTEUoM0RfUkVOREVSSU5HKQpAQCAtNTksNyArNjAsNyBAQCBlbnVtIE1lZGlh RmVhdHVyZVByZWZpeCB7IE1pblByZWZpeCwgTWF4UHJlZml4LCBOb1ByZWZpeCB9OwogCiB0eXBl ZGVmIGJvb2wgKCpFdmFsRnVuYykoQ1NTVmFsdWUqLCBSZW5kZXJTdHlsZSosIEZyYW1lKiwgTWVk aWFGZWF0dXJlUHJlZml4KTsKIHR5cGVkZWYgSGFzaE1hcDxBdG9taWNTdHJpbmdJbXBsKiwgRXZh bEZ1bmM+IEZ1bmN0aW9uTWFwOwotc3RhdGljIEZ1bmN0aW9uTWFwKiBnRnVuY3Rpb25NYXA7Citz dGF0aWMgV1RGOjpHbG9iYWxQdHI8RnVuY3Rpb25NYXA+IGdGdW5jdGlvbk1hcDsKIAogLyoKICAq IEZJWE1FOiBmb2xsb3dpbmcgbWVkaWEgZmVhdHVyZXMgYXJlIG5vdCBpbXBsZW1lbnRlZDogY29s b3JfaW5kZXgsIHNjYW4sIHJlc29sdXRpb24KZGlmZiAtLWdpdCBhL1dlYkNvcmUvZG9tL1F1YWxp ZmllZE5hbWUuY3BwIGIvV2ViQ29yZS9kb20vUXVhbGlmaWVkTmFtZS5jcHAKaW5kZXggNjA3Yzg0 Ni4uZmQ5NzZkNSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9kb20vUXVhbGlmaWVkTmFtZS5jcHAKKysr IGIvV2ViQ29yZS9kb20vUXVhbGlmaWVkTmFtZS5jcHAKQEAgLTI4LDYgKzI4LDcgQEAKICNpbmNs dWRlICJRdWFsaWZpZWROYW1lLmgiCiAjaW5jbHVkZSAiU3RhdGljQ29uc3RydWN0b3JzLmgiCiAj aW5jbHVkZSA8d3RmL0Fzc2VydGlvbnMuaD4KKyNpbmNsdWRlIDx3dGYvR2xvYmFsUHRyLmg+CiAj aW5jbHVkZSA8d3RmL0hhc2hTZXQuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewpAQCAtNDksMTIg KzUwLDI3IEBAIHN0cnVjdCBRTmFtZUNvbXBvbmVudHNUcmFuc2xhdG9yIHsKICAgICB9CiB9Owog Ci1zdGF0aWMgUU5hbWVTZXQqIGdOYW1lQ2FjaGU7CisjaWYgRU5BQkxFKEZSRUVfU1RBVElDX1BU UlMpCitzdGF0aWMgdm9pZCBnTmFtZUNhY2hlRnJlZSh2b2lkKiBwdHIpCit7CisgICAgUU5hbWVT ZXQqIGdOYW1lQ2FjaGUgPSByZWludGVycHJldF9jYXN0PFdURjo6R2xvYmFsUHRyPFFOYW1lU2V0 Pio+KHB0ciktPmdldCgpOworICAgIFFOYW1lU2V0OjppdGVyYXRvciBlbmQgPSBnTmFtZUNhY2hl LT5lbmQoKTsKKyAgICBmb3IgKFFOYW1lU2V0OjppdGVyYXRvciBjdXJyID0gZ05hbWVDYWNoZS0+ YmVnaW4oKTsgY3VyciAhPSBlbmQ7ICsrY3VycikKKyAgICAgICAgZGVsZXRlICpjdXJyOworICAg IGRlbGV0ZSBnTmFtZUNhY2hlOworfQorI2VuZGlmCisKK3N0YXRpYyBXVEY6Okdsb2JhbFB0cjxR TmFtZVNldD4gZ05hbWVDYWNoZTsKIAogUXVhbGlmaWVkTmFtZTo6UXVhbGlmaWVkTmFtZShjb25z dCBBdG9taWNTdHJpbmcmIHAsIGNvbnN0IEF0b21pY1N0cmluZyYgbCwgY29uc3QgQXRvbWljU3Ry aW5nJiBuKQogewotICAgIGlmICghZ05hbWVDYWNoZSkKLSAgICAgICAgZ05hbWVDYWNoZSA9IG5l dyBRTmFtZVNldDsKKyAgICBpZiAoIWdOYW1lQ2FjaGUpIHsKKyAgICAgICAgZ05hbWVDYWNoZS5z ZXRQdHIobmV3IFFOYW1lU2V0KTsKKyNpZiBFTkFCTEUoRlJFRV9TVEFUSUNfUFRSUykKKyAgICAg ICAgZ05hbWVDYWNoZS5zZXRGcmVlKGdOYW1lQ2FjaGVGcmVlKTsKKyNlbmRpZgorICAgIH0KICAg ICBRdWFsaWZpZWROYW1lQ29tcG9uZW50cyBjb21wb25lbnRzID0geyBwLmltcGwoKSwgbC5pbXBs KCksIG4uaXNFbXB0eSgpID8gbnVsbEF0b20uaW1wbCgpIDogbi5pbXBsKCkgfTsKICAgICBwYWly PFFOYW1lU2V0OjppdGVyYXRvciwgYm9vbD4gYWRkUmVzdWx0ID0gZ05hbWVDYWNoZS0+YWRkPFF1 YWxpZmllZE5hbWVDb21wb25lbnRzLCBRTmFtZUNvbXBvbmVudHNUcmFuc2xhdG9yPihjb21wb25l bnRzKTsKICAgICBtX2ltcGwgPSAqYWRkUmVzdWx0LmZpcnN0OyAgICAKQEAgLTkyLDcgKzEwOCw3 IEBAIHZvaWQgUXVhbGlmaWVkTmFtZTo6aW5pdCgpCiAgICAgICAgIC8vIFVzZSBwbGFjZW1lbnQg bmV3IHRvIGluaXRpYWxpemUgdGhlIGdsb2JhbHMuCiAgICAgICAgIAogICAgICAgICBBdG9taWNT dHJpbmc6OmluaXQoKTsKLSAgICAgICAgbmV3ICgodm9pZCopJmFueU5hbWUpIFF1YWxpZmllZE5h bWUobnVsbEF0b20sIHN0YXJBdG9tLCBzdGFyQXRvbSk7CisgICAgICAgIElOSVRfR0xPQkFMKGFu eU5hbWUsIFF1YWxpZmllZE5hbWUsIFF1YWxpZmllZE5hbWUobnVsbEF0b20sIHN0YXJBdG9tLCBz dGFyQXRvbSkpOwogICAgICAgICBpbml0aWFsaXplZCA9IHRydWU7CiAgICAgfQogfQpkaWZmIC0t Z2l0IGEvV2ViQ29yZS9kb20vU3R5bGVkRWxlbWVudC5jcHAgYi9XZWJDb3JlL2RvbS9TdHlsZWRF bGVtZW50LmNwcAppbmRleCA1MjEyMzgwLi5mYzA5MjhmIDEwMDY0NAotLS0gYS9XZWJDb3JlL2Rv bS9TdHlsZWRFbGVtZW50LmNwcAorKysgYi9XZWJDb3JlL2RvbS9TdHlsZWRFbGVtZW50LmNwcApA QCAtMzEsNiArMzEsNyBAQAogI2luY2x1ZGUgIkhUTUxOYW1lcy5oIgogI2luY2x1ZGUgIk1hcHBl ZEF0dHJpYnV0ZS5oIgogI2luY2x1ZGUgPHd0Zi9IYXNoRnVuY3Rpb25zLmg+CisjaW5jbHVkZSA8 d3RmL0dsb2JhbFB0ci5oPgogCiB1c2luZyBuYW1lc3BhY2Ugc3RkOwogCkBAIC02NCw3ICs2NSwx OSBAQCBzdHJ1Y3QgTWFwcGVkQXR0cmlidXRlSGFzaCB7CiAKIHR5cGVkZWYgSGFzaE1hcDxNYXBw ZWRBdHRyaWJ1dGVLZXksIENTU01hcHBlZEF0dHJpYnV0ZURlY2xhcmF0aW9uKiwgTWFwcGVkQXR0 cmlidXRlSGFzaCwgTWFwcGVkQXR0cmlidXRlS2V5VHJhaXRzPiBNYXBwZWRBdHRyaWJ1dGVEZWNs czsKIAotc3RhdGljIE1hcHBlZEF0dHJpYnV0ZURlY2xzKiBtYXBwZWRBdHRyaWJ1dGVEZWNscyA9 IDA7CitzdGF0aWMgV1RGOjpHbG9iYWxQdHI8TWFwcGVkQXR0cmlidXRlRGVjbHM+IG1hcHBlZEF0 dHJpYnV0ZURlY2xzOworCisjaWYgRU5BQkxFKEZSRUVfU1RBVElDX1BUUlMpCitzdGF0aWMgdm9p ZCBtYXBwZWRBdHRyaWJ1dGVEZWNsc0ZyZWUodm9pZCogcHRyKQoreworICAgIE1hcHBlZEF0dHJp YnV0ZURlY2xzKiBtYXBwZWRBdHRyaWJ1dGVEZWNscyA9IHJlaW50ZXJwcmV0X2Nhc3Q8V1RGOjpH bG9iYWxQdHI8TWFwcGVkQXR0cmlidXRlRGVjbHM+Kj4ocHRyKS0+Z2V0KCk7CisgICAgTWFwcGVk QXR0cmlidXRlRGVjbHM6Oml0ZXJhdG9yIGVuZCA9IG1hcHBlZEF0dHJpYnV0ZURlY2xzLT5lbmQo KTsKKyAgICAvLyBNYXBwZWRBdHRyaWJ1dGVLZXkgbmFtZSwgdmFsdWUgaXMgYWxzbyBmcmVlZCBi eSBjdXJyLT5zZWNvbmQKKyAgICBmb3IgKE1hcHBlZEF0dHJpYnV0ZURlY2xzOjppdGVyYXRvciBj dXJyID0gbWFwcGVkQXR0cmlidXRlRGVjbHMtPmJlZ2luKCk7IGN1cnIgIT0gZW5kOyArK2N1cnIp CisgICAgICAgIGRlbGV0ZSBjdXJyLT5zZWNvbmQ7CisgICAgZGVsZXRlIG1hcHBlZEF0dHJpYnV0 ZURlY2xzOworfQorI2VuZGlmCiAKIENTU01hcHBlZEF0dHJpYnV0ZURlY2xhcmF0aW9uKiBTdHls ZWRFbGVtZW50OjpnZXRNYXBwZWRBdHRyaWJ1dGVEZWNsKE1hcHBlZEF0dHJpYnV0ZUVudHJ5IGVu dHJ5VHlwZSwgQXR0cmlidXRlKiBhdHRyKQogewpAQCAtODIsMTUgKzk1LDIzIEBAIENTU01hcHBl ZEF0dHJpYnV0ZURlY2xhcmF0aW9uKiBTdHlsZWRFbGVtZW50OjpnZXRNYXBwZWRBdHRyaWJ1dGVE ZWNsKE1hcHBlZEF0dHJpCiAKIHZvaWQgU3R5bGVkRWxlbWVudDo6c2V0TWFwcGVkQXR0cmlidXRl RGVjbChNYXBwZWRBdHRyaWJ1dGVFbnRyeSBlbnRyeVR5cGUsIEF0dHJpYnV0ZSogYXR0ciwgQ1NT TWFwcGVkQXR0cmlidXRlRGVjbGFyYXRpb24qIGRlY2wpCiB7Ci0gICAgaWYgKCFtYXBwZWRBdHRy aWJ1dGVEZWNscykKLSAgICAgICAgbWFwcGVkQXR0cmlidXRlRGVjbHMgPSBuZXcgTWFwcGVkQXR0 cmlidXRlRGVjbHM7CisgICAgaWYgKCFtYXBwZWRBdHRyaWJ1dGVEZWNscykgeworICAgICAgICBt YXBwZWRBdHRyaWJ1dGVEZWNscy5zZXRQdHIobmV3IE1hcHBlZEF0dHJpYnV0ZURlY2xzKTsKKyNp ZiBFTkFCTEUoRlJFRV9TVEFUSUNfUFRSUykKKyAgICAgICAgbWFwcGVkQXR0cmlidXRlRGVjbHMu c2V0RnJlZShtYXBwZWRBdHRyaWJ1dGVEZWNsc0ZyZWUpOworI2VuZGlmCisgICAgfQogICAgIG1h cHBlZEF0dHJpYnV0ZURlY2xzLT5zZXQoTWFwcGVkQXR0cmlidXRlS2V5KGVudHJ5VHlwZSwgYXR0 ci0+bmFtZSgpLmxvY2FsTmFtZSgpLmltcGwoKSwgYXR0ci0+dmFsdWUoKS5pbXBsKCkpLCBkZWNs KTsKIH0KIAogdm9pZCBTdHlsZWRFbGVtZW50OjpzZXRNYXBwZWRBdHRyaWJ1dGVEZWNsKE1hcHBl ZEF0dHJpYnV0ZUVudHJ5IGVudHJ5VHlwZSwgY29uc3QgUXVhbGlmaWVkTmFtZSYgbmFtZSwgY29u c3QgQXRvbWljU3RyaW5nJiB2YWx1ZSwgQ1NTTWFwcGVkQXR0cmlidXRlRGVjbGFyYXRpb24qIGRl Y2wpCiB7Ci0gICAgaWYgKCFtYXBwZWRBdHRyaWJ1dGVEZWNscykKLSAgICAgICAgbWFwcGVkQXR0 cmlidXRlRGVjbHMgPSBuZXcgTWFwcGVkQXR0cmlidXRlRGVjbHM7CisgICAgaWYgKCFtYXBwZWRB dHRyaWJ1dGVEZWNscykgeworICAgICAgICBtYXBwZWRBdHRyaWJ1dGVEZWNscy5zZXRQdHIobmV3 IE1hcHBlZEF0dHJpYnV0ZURlY2xzKTsKKyNpZiBFTkFCTEUoRlJFRV9TVEFUSUNfUFRSUykKKyAg ICAgICAgbWFwcGVkQXR0cmlidXRlRGVjbHMuc2V0RnJlZShtYXBwZWRBdHRyaWJ1dGVEZWNsc0Zy ZWUpOworI2VuZGlmCisgICAgfQogICAgIG1hcHBlZEF0dHJpYnV0ZURlY2xzLT5zZXQoTWFwcGVk QXR0cmlidXRlS2V5KGVudHJ5VHlwZSwgbmFtZS5sb2NhbE5hbWUoKS5pbXBsKCksIHZhbHVlLmlt cGwoKSksIGRlY2wpOwogfQogCmRpZmYgLS1naXQgYS9XZWJDb3JlL2RvbS9tYWtlX25hbWVzLnBs IGIvV2ViQ29yZS9kb20vbWFrZV9uYW1lcy5wbAppbmRleCA2YjVkZGI0Li40YzA3OTJkIDEwMDc1 NQotLS0gYS9XZWJDb3JlL2RvbS9tYWtlX25hbWVzLnBsCisrKyBiL1dlYkNvcmUvZG9tL21ha2Vf bmFtZXMucGwKQEAgLTU1Nyw3ICs1NTcsNyBAQCBwcmludCBGICJcbnZvaWQgaW5pdCgpCiAgICAg cHJpbnQoRiAiICAgIEF0b21pY1N0cmluZyAke2xvd2VyTmFtZXNwYWNlfU5TKFwiJHBhcmFtZXRl cnN7bmFtZXNwYWNlVVJJfVwiKTtcblxuIik7CiAKICAgICBwcmludChGICIgICAgLy8gTmFtZXNw YWNlXG4iKTsKLSAgICBwcmludChGICIgICAgbmV3ICgodm9pZCopJiR7bG93ZXJOYW1lc3BhY2V9 TmFtZXNwYWNlVVJJKSBBdG9taWNTdHJpbmcoJHtsb3dlck5hbWVzcGFjZX1OUyk7XG5cbiIpOwor ICAgIHByaW50KEYgIiAgICBJTklUX0dMT0JBTCgke2xvd2VyTmFtZXNwYWNlfU5hbWVzcGFjZVVS SSwgQXRvbWljU3RyaW5nLCBBdG9taWNTdHJpbmcoJHtsb3dlck5hbWVzcGFjZX1OUykpO1xuXG4i KTsKICAgICBpZiAoa2V5cyAldGFncykgewogICAgICAgICBteSAkdGFnc05hbWVzcGFjZSA9ICRw YXJhbWV0ZXJze3RhZ3NOdWxsTmFtZXNwYWNlfSA/ICJudWxsQXRvbSIgOiAiJHtsb3dlck5hbWVz cGFjZX1OUyI7CiAgICAgICAgIHByaW50RGVmaW5pdGlvbnMoJEYsIFwldGFncywgInRhZ3MiLCAk dGFnc05hbWVzcGFjZSk7CkBAIC02NDAsNyArNjQwLDcgQEAgc3ViIHByaW50RGVmaW5pdGlvbnMK ICAgICBwcmludCAiXG4iOwogCiAgICAgZm9yIG15ICRuYW1lIChzb3J0IGtleXMgJSRuYW1lc1Jl ZikgewotICAgICAgICBwcmludCBGICIgICAgbmV3ICgodm9pZCopJiRuYW1lIiwiJHtzaG9ydENh bWVsVHlwZX0pIFF1YWxpZmllZE5hbWUobnVsbEF0b20sICRuYW1lIiwiJHtzaG9ydENhbWVsVHlw ZX1TdHJpbmcsICRuYW1lc3BhY2VVUkkpO1xuIjsKKyAgICAgICAgcHJpbnQgRiAiICAgIElOSVRf R0xPQkFMKCRuYW1lIiwiJHtzaG9ydENhbWVsVHlwZX0sIFF1YWxpZmllZE5hbWUsIFF1YWxpZmll ZE5hbWUobnVsbEF0b20sICRuYW1lIiwiJHtzaG9ydENhbWVsVHlwZX1TdHJpbmcsICRuYW1lc3Bh Y2VVUkkpKTtcbiI7CiAgICAgfQogfQogCmRpZmYgLS1naXQgYS9XZWJDb3JlL2luc3BlY3Rvci9K YXZhU2NyaXB0RGVidWdTZXJ2ZXIuaCBiL1dlYkNvcmUvaW5zcGVjdG9yL0phdmFTY3JpcHREZWJ1 Z1NlcnZlci5oCmluZGV4IDMzYzZlM2QuLmE3M2UwODAgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaW5z cGVjdG9yL0phdmFTY3JpcHREZWJ1Z1NlcnZlci5oCisrKyBiL1dlYkNvcmUvaW5zcGVjdG9yL0ph dmFTY3JpcHREZWJ1Z1NlcnZlci5oCkBAIC04Nyw2ICs4Nyw4IEBAIG5hbWVzcGFjZSBXZWJDb3Jl IHsKICAgICAgICAgdHlwZWRlZiBIYXNoU2V0PEphdmFTY3JpcHREZWJ1Z0xpc3RlbmVyKj4gTGlz dGVuZXJTZXQ7CiAgICAgICAgIHR5cGVkZWYgdm9pZCAoSmF2YVNjcmlwdERlYnVnTGlzdGVuZXI6 OipKYXZhU2NyaXB0RXhlY3V0aW9uQ2FsbGJhY2spKCk7CiAKKyAgICAgICAgfkphdmFTY3JpcHRE ZWJ1Z1NlcnZlcigpOworCiAgICAgcHJpdmF0ZToKICAgICAgICAgY2xhc3MgQnJlYWtwb2ludElu Zm8gewogICAgICAgICBwdWJsaWM6CkBAIC05OCw3ICsxMDAsNiBAQCBuYW1lc3BhY2UgV2ViQ29y ZSB7CiAgICAgICAgIH07CiAKICAgICAgICAgSmF2YVNjcmlwdERlYnVnU2VydmVyKCk7Ci0gICAg ICAgIH5KYXZhU2NyaXB0RGVidWdTZXJ2ZXIoKTsKIAogICAgICAgICBib29sIGhhc0xpc3RlbmVy cygpIGNvbnN0IHsgcmV0dXJuICFtX2xpc3RlbmVycy5pc0VtcHR5KCkgfHwgIW1fcGFnZUxpc3Rl bmVyc01hcC5pc0VtcHR5KCk7IH0KICAgICAgICAgYm9vbCBoYXNHbG9iYWxMaXN0ZW5lcnMoKSBj b25zdCB7IHJldHVybiAhbV9saXN0ZW5lcnMuaXNFbXB0eSgpOyB9CmRpZmYgLS1naXQgYS9XZWJD b3JlL2xvYWRlci9JbWFnZUxvYWRlci5jcHAgYi9XZWJDb3JlL2xvYWRlci9JbWFnZUxvYWRlci5j cHAKaW5kZXggYjE4M2E2Ni4uMmQ2ZWFmZiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9sb2FkZXIvSW1h Z2VMb2FkZXIuY3BwCisrKyBiL1dlYkNvcmUvbG9hZGVyL0ltYWdlTG9hZGVyLmNwcApAQCAtNDEs NyArNDEsNiBAQCBwdWJsaWM6CiAgICAgdm9pZCBkaXNwYXRjaFBlbmRpbmdMb2FkRXZlbnRzKCk7 CiAKIHByaXZhdGU6Ci0gICAgfkltYWdlTG9hZEV2ZW50U2VuZGVyKCk7CiAKICAgICB2b2lkIHRp bWVyRmlyZWQoVGltZXI8SW1hZ2VMb2FkRXZlbnRTZW5kZXI+Kik7CiAKZGlmZiAtLWdpdCBhL1dl YkNvcmUvbG9hZGVyL2ljb24vSWNvbkRhdGFiYXNlLmNwcCBiL1dlYkNvcmUvbG9hZGVyL2ljb24v SWNvbkRhdGFiYXNlLmNwcAppbmRleCBiNzgyOTFkLi45YTRkYjI4IDEwMDY0NAotLS0gYS9XZWJD b3JlL2xvYWRlci9pY29uL0ljb25EYXRhYmFzZS5jcHAKKysrIGIvV2ViQ29yZS9sb2FkZXIvaWNv bi9JY29uRGF0YWJhc2UuY3BwCkBAIC00MSw2ICs0MSw3IEBACiAjaW5jbHVkZSAiU3VkZGVuVGVy bWluYXRpb24uaCIKICNpbmNsdWRlIDxydW50aW1lL0luaXRpYWxpemVUaHJlYWRpbmcuaD4KICNp bmNsdWRlIDx3dGYvQ3VycmVudFRpbWUuaD4KKyNpbmNsdWRlIDx3dGYvR2xvYmFsUHRyLmg+CiAj aW5jbHVkZSA8d3RmL01haW5UaHJlYWQuaD4KICNpbmNsdWRlIDx3dGYvU3RkTGliRXh0cmFzLmg+ CiAKQEAgLTU3LDcgKzU4LDcgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1zdGF0aWMgSWNv bkRhdGFiYXNlKiBzaGFyZWRJY29uRGF0YWJhc2UgPSAwOworc3RhdGljIFdURjo6R2xvYmFsUHRy PEljb25EYXRhYmFzZT4gc2hhcmVkSWNvbkRhdGFiYXNlOwogc3RhdGljIGludCBkYXRhYmFzZUNs ZWFudXBDb3VudGVyID0gMDsKIAogLy8gVGhpcyB2ZXJzaW9uIG51bWJlciBpcyBpbiB0aGUgREIg YW5kIG1hcmtzIHRoZSBjdXJyZW50IGdlbmVyYXRpb24gb2YgdGhlIHNjaGVtYQpAQCAtODYsOCAr ODcsOCBAQCBzdGF0aWMgU3RyaW5nIHVybEZvckxvZ2dpbmcoY29uc3QgU3RyaW5nJiB1cmwpCiAK IHN0YXRpYyBJY29uRGF0YWJhc2VDbGllbnQqIGRlZmF1bHRDbGllbnQoKSAKIHsKLSAgICBzdGF0 aWMgSWNvbkRhdGFiYXNlQ2xpZW50KiBkZWZhdWx0Q2xpZW50ID0gbmV3IEljb25EYXRhYmFzZUNs aWVudCgpOwotICAgIHJldHVybiBkZWZhdWx0Q2xpZW50OworICAgIERFRklORV9TVEFUSUNfTE9D QUwoSWNvbkRhdGFiYXNlQ2xpZW50LCBkZWZhdWx0Q2xpZW50LCAoKSk7CisgICAgcmV0dXJuICZk ZWZhdWx0Q2xpZW50OwogfQogCiBJY29uRGF0YWJhc2UqIGljb25EYXRhYmFzZSgpCkBAIC05Niw3 ICs5Nyw3IEBAIEljb25EYXRhYmFzZSogaWNvbkRhdGFiYXNlKCkKICAgICAgICAgSlNDOjppbml0 aWFsaXplVGhyZWFkaW5nKCk7CiAgICAgICAgIHNoYXJlZEljb25EYXRhYmFzZSA9IG5ldyBJY29u RGF0YWJhc2U7CiAgICAgfQotICAgIHJldHVybiBzaGFyZWRJY29uRGF0YWJhc2U7CisgICAgcmV0 dXJuIHNoYXJlZEljb25EYXRhYmFzZS5nZXQoKTsKIH0KIAogLy8gKioqKioqKioqKioqKioqKioq KioqKioqCkBAIC03NzMsNyArNzc0LDkgQEAgSWNvbkRhdGFiYXNlOjpJY29uRGF0YWJhc2UoKQog CiBJY29uRGF0YWJhc2U6On5JY29uRGF0YWJhc2UoKQogeworI2lmICFFTkFCTEUoRlJFRV9TVEFU SUNfUFRSUykKICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyNlbmRpZgogfQogCiB2b2lkIElj b25EYXRhYmFzZTo6bm90aWZ5UGVuZGluZ0xvYWREZWNpc2lvbnNPbk1haW5UaHJlYWQodm9pZCog Y29udGV4dCkKZGlmZiAtLWdpdCBhL1dlYkNvcmUvbG9hZGVyL2ljb24vSWNvbkRhdGFiYXNlLmgg Yi9XZWJDb3JlL2xvYWRlci9pY29uL0ljb25EYXRhYmFzZS5oCmluZGV4IDQ0ZWYyMmEuLjQ1OGVl NTYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvbG9hZGVyL2ljb24vSWNvbkRhdGFiYXNlLmgKKysrIGIv V2ViQ29yZS9sb2FkZXIvaWNvbi9JY29uRGF0YWJhc2UuaApAQCAtMTAzLDkgKzEwMywxNSBAQCBw dWJsaWM6CiAgICAgc2l6ZV90IGljb25SZWNvcmRDb3VudCgpOwogICAgIHNpemVfdCBpY29uUmVj b3JkQ291bnRXaXRoRGF0YSgpOwogCisjaWYgRU5BQkxFKEZSRUVfU1RBVElDX1BUUlMpCisgICAg fkljb25EYXRhYmFzZSgpOworI2VuZGlmCisKIHByaXZhdGU6CiAgICAgSWNvbkRhdGFiYXNlKCk7 CisjaWYgIUVOQUJMRShGUkVFX1NUQVRJQ19QVFJTKQogICAgIH5JY29uRGF0YWJhc2UoKTsKKyNl bmRpZgogICAgIGZyaWVuZCBJY29uRGF0YWJhc2UqIGljb25EYXRhYmFzZSgpOwogCiAjaWYgRU5B QkxFKElDT05EQVRBQkFTRSkKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vU3RhdGljQ29u c3RydWN0b3JzLmggYi9XZWJDb3JlL3BsYXRmb3JtL1N0YXRpY0NvbnN0cnVjdG9ycy5oCmluZGV4 IDI2YjQ0ZGUuLmQ1YTMwNzEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vU3RhdGljQ29u c3RydWN0b3JzLmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9TdGF0aWNDb25zdHJ1Y3RvcnMuaApA QCAtMjMsNiArMjMsOCBAQAogI2lmbmRlZiBTdGF0aWNDb25zdHJ1Y3RvcnNfaAogI2RlZmluZSBT dGF0aWNDb25zdHJ1Y3RvcnNfaAogCisjaW5jbHVkZSAid3RmL0xvY2FsU3RhdGljUHRyLmgiCisK IC8vIEZvciBXZWJDb3JlIHdlIG5lZWQgdG8gYXZvaWQgaGF2aW5nIHN0YXRpYyBjb25zdHJ1Y3Rv cnMuIFdlIGFjaGlldmUgdGhpcwogLy8gd2l0aCB0d28gc2VwYXJhdGUgbWV0aG9kcyBmb3IgR0ND IGFuZCBNU1ZDLiBCb3RoIG1ldGhvZHMgcHJldmVudCB0aGUgc3RhdGljCiAvLyBpbml0aWFsaXpl cnMgZnJvbSBiZWluZyByZWdpc3RlcmVkIGFuZCBjYWxsZWQgb24gcHJvZ3JhbSBzdGFydHVwLiBP biBHQ0MsIHdlCkBAIC03Myw0ICs3NSwxNCBAQAogI2VuZGlmCiAjZW5kaWYKIAorI2lmIEVOQUJM RShGUkVFX1NUQVRJQ19QVFJTKQorI2RlZmluZSBJTklUX0dMT0JBTChuYW1lLCB0eXBlLCBhcmd1 bWVudHMpIFwKKyAgICBuZXcgKCh2b2lkKikmbmFtZSkgYXJndW1lbnRzOyBcCisgICAgc3RhdGlj IFdURjo6TG9jYWxTdGF0aWNQdHI8dHlwZT4gbmFtZSMjUmVmKCh0eXBlKikmbmFtZSk7IFwKKyAg ICBuYW1lIyNSZWYuc2V0RnJlZShXVEY6OkxvY2FsU3RhdGljUHRyPHR5cGU+OjpkZXN0cm95KTsK KyNlbHNlCisjZGVmaW5lIElOSVRfR0xPQkFMKG5hbWUsIHR5cGUsIGFyZ3VtZW50cykgXAorICAg IG5ldyAoKHZvaWQqKSZuYW1lKSBhcmd1bWVudHMKKyNlbmRpZgorCiAjZW5kaWYgLy8gU3RhdGlj Q29uc3RydWN0b3JzX2gKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vVGhyZWFkR2xvYmFs RGF0YS5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL1RocmVhZEdsb2JhbERhdGEuY3BwCmluZGV4IGE0 M2U5YmQuLjQ2MmVmNjQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vVGhyZWFkR2xvYmFs RGF0YS5jcHAKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9UaHJlYWRHbG9iYWxEYXRhLmNwcApAQCAt MzAsNiArMzAsNyBAQAogI2luY2x1ZGUgIkV2ZW50TmFtZXMuaCIKICNpbmNsdWRlICJTdHJpbmdJ bXBsLmgiCiAjaW5jbHVkZSAiVGhyZWFkVGltZXJzLmgiCisjaW5jbHVkZSA8d3RmL0xvY2FsU3Rh dGljUHRyLmg+CiAjaW5jbHVkZSA8d3RmL1VudXNlZFBhcmFtLmg+CiAKICNpZiBVU0UoSUNVX1VO SUNPREUpIHx8IFVTRShHTElCX0lDVV9VTklDT0RFX0hZQlJJRCkKQEAgLTU0LDE0ICs1NSwxNCBA QCBUaHJlYWRHbG9iYWxEYXRhJiB0aHJlYWRHbG9iYWxEYXRhKCkKICAgICAvLyBXZSBuZWVkIHRv IGNoZWNrIGZvciBlLmcuIGRhdGFiYXNlIG9iamVjdHMgbWFuaXB1bGF0aW5nIHN0cmluZ3Mgb24g c2Vjb25kYXJ5IHRocmVhZHMuCiAjaWYgRU5BQkxFKFdPUktFUlMpCiAgICAgLy8gVGhyZWFkR2xv YmFsRGF0YSBpcyB1c2VkIG9uIG1haW4gdGhyZWFkIGJlZm9yZSBpdCBjb3VsZCBwb3NzaWJseSBi ZSB1c2VkIG9uIHNlY29uZGFyeSBvbmVzLCBzbyB0aGVyZSBpcyBubyBuZWVkIGZvciBzeW5jaHJv bml6YXRpb24gaGVyZS4KLSAgICBzdGF0aWMgVGhyZWFkU3BlY2lmaWM8VGhyZWFkR2xvYmFsRGF0 YT4qIHRocmVhZEdsb2JhbERhdGEgPSBuZXcgVGhyZWFkU3BlY2lmaWM8VGhyZWFkR2xvYmFsRGF0 YT47CisgICAgc3RhdGljIFdURjo6TG9jYWxTdGF0aWNQdHI8IFRocmVhZFNwZWNpZmljPFRocmVh ZEdsb2JhbERhdGE+ID4gdGhyZWFkR2xvYmFsRGF0YShuZXcgVGhyZWFkU3BlY2lmaWM8VGhyZWFk R2xvYmFsRGF0YT4pOwogICAgIHJldHVybiAqKnRocmVhZEdsb2JhbERhdGE7CiAjZWxzZQotICAg IHN0YXRpYyBUaHJlYWRHbG9iYWxEYXRhKiBzdGF0aWNEYXRhOworICAgIHN0YXRpYyBXVEY6OlN0 YXRpY1B0cjxUaHJlYWRHbG9iYWxEYXRhPiBzdGF0aWNEYXRhOwogICAgIGlmICghc3RhdGljRGF0 YSkgewogICAgICAgICBzdGF0aWNEYXRhID0gc3RhdGljX2Nhc3Q8VGhyZWFkR2xvYmFsRGF0YSo+ KGZhc3RNYWxsb2Moc2l6ZW9mKFRocmVhZEdsb2JhbERhdGEpKSk7CiAgICAgICAgIC8vIFRocmVh ZEdsb2JhbERhdGEgY29uc3RydWN0b3IgaW5kaXJlY3RseSB1c2VzIHN0YXRpY0RhdGEsIHNvIHdl IG5lZWQgdG8gc2V0IHVwIHRoZSBtZW1vcnkgYmVmb3JlIGludm9raW5nIGl0LgotICAgICAgICBu ZXcgKHN0YXRpY0RhdGEpIFRocmVhZEdsb2JhbERhdGE7CisgICAgICAgIG5ldyAoc3RhdGljRGF0 YS5nZXQoKSkgVGhyZWFkR2xvYmFsRGF0YTsKICAgICB9CiAgICAgcmV0dXJuICpzdGF0aWNEYXRh OwogI2VuZGlmCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL1RocmVhZFRpbWVycy5jcHAg Yi9XZWJDb3JlL3BsYXRmb3JtL1RocmVhZFRpbWVycy5jcHAKaW5kZXggM2FlODIwNy4uZTFmYjMx YiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9UaHJlYWRUaW1lcnMuY3BwCisrKyBiL1dl YkNvcmUvcGxhdGZvcm0vVGhyZWFkVGltZXJzLmNwcApAQCAtMzEsNiArMzEsNyBAQAogI2luY2x1 ZGUgIlRocmVhZEdsb2JhbERhdGEuaCIKICNpbmNsdWRlICJUaW1lci5oIgogI2luY2x1ZGUgPHd0 Zi9DdXJyZW50VGltZS5oPgorI2luY2x1ZGUgPHd0Zi9Mb2NhbFN0YXRpY1B0ci5oPgogCiBuYW1l c3BhY2UgV2ViQ29yZSB7CiAKQEAgLTQ0LDggKzQ1LDggQEAgc3RhdGljIGNvbnN0IGRvdWJsZSBt YXhEdXJhdGlvbk9mRmlyaW5nVGltZXJzID0gMC4wNTA7CiAKIHN0YXRpYyBNYWluVGhyZWFkU2hh cmVkVGltZXIqIG1haW5UaHJlYWRTaGFyZWRUaW1lcigpCiB7Ci0gICAgc3RhdGljIE1haW5UaHJl YWRTaGFyZWRUaW1lciogdGltZXIgPSBuZXcgTWFpblRocmVhZFNoYXJlZFRpbWVyOwotICAgIHJl dHVybiB0aW1lcjsKKyAgICBzdGF0aWMgV1RGOjpMb2NhbFN0YXRpY1B0cjxNYWluVGhyZWFkU2hh cmVkVGltZXI+IHRpbWVyKG5ldyBNYWluVGhyZWFkU2hhcmVkVGltZXIpOworICAgIHJldHVybiB0 aW1lci5nZXQoKTsKIH0KIAogVGhyZWFkVGltZXJzOjpUaHJlYWRUaW1lcnMoKQpkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9Gb250Q2FjaGUuaCBiL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvRm9udENhY2hlLmgKaW5kZXggYTU5MTQ3NC4uZjAxZDEwMSAxMDA2NDQKLS0t IGEvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9Gb250Q2FjaGUuaAorKysgYi9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL0ZvbnRDYWNoZS5oCkBAIC05NCw3ICs5NCw2IEBAIHB1YmxpYzoKIAog cHJpdmF0ZToKICAgICBGb250Q2FjaGUoKTsKLSAgICB+Rm9udENhY2hlKCk7CiAKICAgICAvLyBU aGVzZSBtZXRob2RzIGFyZSBpbXBsZW1lbnRlZCBieSBlYWNoIHBsYXRmb3JtLgogICAgIEZvbnRQ bGF0Zm9ybURhdGEqIGdldFNpbWlsYXJGb250UGxhdGZvcm1EYXRhKGNvbnN0IEZvbnQmKTsKZGlm ZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vcXQvU2hhcmVkVGltZXJRdC5jcHAgYi9XZWJDb3Jl L3BsYXRmb3JtL3F0L1NoYXJlZFRpbWVyUXQuY3BwCmluZGV4IGU5YmNhZWUuLjg4NDEyYTcgMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vcXQvU2hhcmVkVGltZXJRdC5jcHAKKysrIGIvV2Vi Q29yZS9wbGF0Zm9ybS9xdC9TaGFyZWRUaW1lclF0LmNwcApAQCAtNjQsOCArNjQsMTAgQEAgU2hh cmVkVGltZXJRdDo6U2hhcmVkVGltZXJRdChRT2JqZWN0KiBwYXJlbnQpCiAKIFNoYXJlZFRpbWVy UXQ6On5TaGFyZWRUaW1lclF0KCkKIHsKKyNpZiAhRU5BQkxFKEZSRUVfU1RBVElDX1BUUlMpCiAg ICAgaWYgKG1fdGltZXIuaXNBY3RpdmUoKSkKICAgICAgICAgKG1fdGltZXJGdW5jdGlvbikoKTsK KyNlbmRpZgogfQogCiBTaGFyZWRUaW1lclF0KiBTaGFyZWRUaW1lclF0OjppbnN0KCkKZGlmZiAt LWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vdGV4dC9BdG9taWNTdHJpbmcuY3BwIGIvV2ViQ29yZS9w bGF0Zm9ybS90ZXh0L0F0b21pY1N0cmluZy5jcHAKaW5kZXggNDA5NDM5ZS4uMjVmYmZkMiAxMDA2 NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS90ZXh0L0F0b21pY1N0cmluZy5jcHAKKysrIGIvV2Vi Q29yZS9wbGF0Zm9ybS90ZXh0L0F0b21pY1N0cmluZy5jcHAKQEAgLTI5NSwxMSArMjk1LDExIEBA IHZvaWQgQXRvbWljU3RyaW5nOjppbml0KCkKICAgICAgICAgQVNTRVJUKGlzTWFpblRocmVhZCgp KTsKIAogICAgICAgICAvLyBVc2UgcGxhY2VtZW50IG5ldyB0byBpbml0aWFsaXplIHRoZSBnbG9i YWxzLgotICAgICAgICBuZXcgKCh2b2lkKikmbnVsbEF0b20pIEF0b21pY1N0cmluZzsKLSAgICAg ICAgbmV3ICgodm9pZCopJmVtcHR5QXRvbSkgQXRvbWljU3RyaW5nKCIiKTsKLSAgICAgICAgbmV3 ICgodm9pZCopJnRleHRBdG9tKSBBdG9taWNTdHJpbmcoIiN0ZXh0Iik7Ci0gICAgICAgIG5ldyAo KHZvaWQqKSZjb21tZW50QXRvbSkgQXRvbWljU3RyaW5nKCIjY29tbWVudCIpOwotICAgICAgICBu ZXcgKCh2b2lkKikmc3RhckF0b20pIEF0b21pY1N0cmluZygiKiIpOworICAgICAgICBJTklUX0dM T0JBTChudWxsQXRvbSwgQXRvbWljU3RyaW5nLCBBdG9taWNTdHJpbmcpOworICAgICAgICBJTklU X0dMT0JBTChlbXB0eUF0b20sIEF0b21pY1N0cmluZywgQXRvbWljU3RyaW5nKCIiKSk7CisgICAg ICAgIElOSVRfR0xPQkFMKHRleHRBdG9tLCBBdG9taWNTdHJpbmcsIEF0b21pY1N0cmluZygiI3Rl eHQiKSk7CisgICAgICAgIElOSVRfR0xPQkFMKGNvbW1lbnRBdG9tLCBBdG9taWNTdHJpbmcsIEF0 b21pY1N0cmluZygiI2NvbW1lbnQiKSk7CisgICAgICAgIElOSVRfR0xPQkFMKHN0YXJBdG9tLCBB dG9taWNTdHJpbmcsIEF0b21pY1N0cmluZygiKiIpKTsKIAogICAgICAgICBpbml0aWFsaXplZCA9 IHRydWU7CiAgICAgfQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS90ZXh0L3F0L1RleHRD b2RlY1F0LmNwcCBiL1dlYkNvcmUvcGxhdGZvcm0vdGV4dC9xdC9UZXh0Q29kZWNRdC5jcHAKaW5k ZXggYzZjMDJjZi4uOTk1OWY2MyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS90ZXh0L3F0 L1RleHRDb2RlY1F0LmNwcAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL3RleHQvcXQvVGV4dENvZGVj UXQuY3BwCkBAIC0yOSwxMSArMjksMTIgQEAKICNpbmNsdWRlICJQbGF0Zm9ybVN0cmluZy5oIgog I2luY2x1ZGUgIkNTdHJpbmcuaCIKICNpbmNsdWRlIDxxc2V0Lmg+CisjaW5jbHVkZSA8d3RmL0ds b2JhbFB0ci5oPgogLy8gI2luY2x1ZGUgPFFEZWJ1Zz4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewog Ci1zdGF0aWMgUVNldDxRQnl0ZUFycmF5PiAqdW5pcXVlX25hbWVzID0gMDsKK3N0YXRpYyBXVEY6 Okdsb2JhbFB0cjwgUVNldDxRQnl0ZUFycmF5PiA+IHVuaXF1ZV9uYW1lczsKIAogc3RhdGljIGNv bnN0IGNoYXIgKmdldEF0b21pY05hbWUoY29uc3QgUUJ5dGVBcnJheSAmbmFtZSkKIHsKZGlmZiAt LWdpdCBhL1dlYkNvcmUvcGx1Z2lucy9QbHVnaW5EYXRhYmFzZS5jcHAgYi9XZWJDb3JlL3BsdWdp bnMvUGx1Z2luRGF0YWJhc2UuY3BwCmluZGV4IGY0MGVkOTUuLmVjNGJmZTEgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvcGx1Z2lucy9QbHVnaW5EYXRhYmFzZS5jcHAKKysrIGIvV2ViQ29yZS9wbHVnaW5z L1BsdWdpbkRhdGFiYXNlLmNwcApAQCAtMzIsNiArMzIsNyBAQAogI2luY2x1ZGUgIlBsdWdpbkRh dGFiYXNlQ2xpZW50LmgiCiAjaW5jbHVkZSAiUGx1Z2luUGFja2FnZS5oIgogI2luY2x1ZGUgPHN0 ZGxpYi5oPgorI2luY2x1ZGUgPHd0Zi9HbG9iYWxQdHIuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUg ewogCkBAIC00NCw3ICs0NSw3IEBAIFBsdWdpbkRhdGFiYXNlOjpQbHVnaW5EYXRhYmFzZSgpCiAK IFBsdWdpbkRhdGFiYXNlKiBQbHVnaW5EYXRhYmFzZTo6aW5zdGFsbGVkUGx1Z2lucyhib29sIHBv cHVsYXRlKQogewotICAgIHN0YXRpYyBQbHVnaW5EYXRhYmFzZSogcGx1Z2lucyA9IDA7CisgICAg c3RhdGljIFdURjo6R2xvYmFsUHRyPFBsdWdpbkRhdGFiYXNlPiBwbHVnaW5zOwogCiAgICAgaWYg KCFwbHVnaW5zKSB7CiAgICAgICAgIHBsdWdpbnMgPSBuZXcgUGx1Z2luRGF0YWJhc2U7CkBAIC01 NSw3ICs1Niw3IEBAIFBsdWdpbkRhdGFiYXNlKiBQbHVnaW5EYXRhYmFzZTo6aW5zdGFsbGVkUGx1 Z2lucyhib29sIHBvcHVsYXRlKQogICAgICAgICB9CiAgICAgfQogCi0gICAgcmV0dXJuIHBsdWdp bnM7CisgICAgcmV0dXJuIHBsdWdpbnMuZ2V0KCk7CiB9CiAKIGJvb2wgUGx1Z2luRGF0YWJhc2U6 OmlzTUlNRVR5cGVSZWdpc3RlcmVkKGNvbnN0IFN0cmluZyYgbWltZVR5cGUpCmRpZmYgLS1naXQg YS9XZWJDb3JlL3JlbmRlcmluZy9zdHlsZS9SZW5kZXJTdHlsZS5jcHAgYi9XZWJDb3JlL3JlbmRl cmluZy9zdHlsZS9SZW5kZXJTdHlsZS5jcHAKaW5kZXggYTg2MWZlYS4uZTRjODdlZSAxMDA2NDQK LS0tIGEvV2ViQ29yZS9yZW5kZXJpbmcvc3R5bGUvUmVuZGVyU3R5bGUuY3BwCisrKyBiL1dlYkNv cmUvcmVuZGVyaW5nL3N0eWxlL1JlbmRlclN0eWxlLmNwcApAQCAtMjksNiArMjksNyBAQAogI2lu Y2x1ZGUgIlJlbmRlckFyZW5hLmgiCiAjaW5jbHVkZSAiUmVuZGVyT2JqZWN0LmgiCiAjaW5jbHVk ZSAiU3R5bGVJbWFnZS5oIgorI2luY2x1ZGUgPHd0Zi9Mb2NhbFN0YXRpY1B0ci5oPgogI2luY2x1 ZGUgPHd0Zi9TdGRMaWJFeHRyYXMuaD4KICNpbmNsdWRlIDxhbGdvcml0aG0+CiAKQEAgLTM4LDgg KzM5LDggQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogCiBpbmxpbmUgUmVuZGVyU3R5bGUqIGRlZmF1 bHRTdHlsZSgpCiB7Ci0gICAgc3RhdGljIFJlbmRlclN0eWxlKiBzX2RlZmF1bHRTdHlsZSA9IFJl bmRlclN0eWxlOjpjcmVhdGVEZWZhdWx0U3R5bGUoKS5yZWxlYXNlUmVmKCk7Ci0gICAgcmV0dXJu IHNfZGVmYXVsdFN0eWxlOworICAgIHN0YXRpYyBXVEY6OkxvY2FsU3RhdGljUHRyPFJlbmRlclN0 eWxlPiBzX2RlZmF1bHRTdHlsZShSZW5kZXJTdHlsZTo6Y3JlYXRlRGVmYXVsdFN0eWxlKCkucmVs ZWFzZVJlZigpKTsKKyAgICByZXR1cm4gc19kZWZhdWx0U3R5bGUuZ2V0KCk7CiB9CiAKIFBhc3NS ZWZQdHI8UmVuZGVyU3R5bGU+IFJlbmRlclN0eWxlOjpjcmVhdGUoKQpkaWZmIC0tZ2l0IGEvV2Vi Q29yZS9yZW5kZXJpbmcvc3R5bGUvU1ZHUmVuZGVyU3R5bGUuY3BwIGIvV2ViQ29yZS9yZW5kZXJp bmcvc3R5bGUvU1ZHUmVuZGVyU3R5bGUuY3BwCmluZGV4IDEyODliMDYuLjYzMjJjZDggMTAwNjQ0 Ci0tLSBhL1dlYkNvcmUvcmVuZGVyaW5nL3N0eWxlL1NWR1JlbmRlclN0eWxlLmNwcAorKysgYi9X ZWJDb3JlL3JlbmRlcmluZy9zdHlsZS9TVkdSZW5kZXJTdHlsZS5jcHAKQEAgLTM2LDIxICszNiwy MiBAQAogI2luY2x1ZGUgIlJlbmRlck9iamVjdC5oIgogI2luY2x1ZGUgIlJlbmRlclN0eWxlLmgi CiAjaW5jbHVkZSAiU1ZHU3R5bGVkRWxlbWVudC5oIgorI2luY2x1ZGUgPHd0Zi9TdGRMaWJFeHRy YXMuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBTVkdSZW5kZXJTdHlsZTo6U1ZHUmVuZGVy U3R5bGUoKQogewotICAgIHN0YXRpYyBTVkdSZW5kZXJTdHlsZSogZGVmYXVsdFN0eWxlID0gbmV3 IFNWR1JlbmRlclN0eWxlKENyZWF0ZURlZmF1bHQpOwotCi0gICAgZmlsbCA9IGRlZmF1bHRTdHls ZS0+ZmlsbDsKLSAgICBzdHJva2UgPSBkZWZhdWx0U3R5bGUtPnN0cm9rZTsKLSAgICB0ZXh0ID0g ZGVmYXVsdFN0eWxlLT50ZXh0OwotICAgIHN0b3BzID0gZGVmYXVsdFN0eWxlLT5zdG9wczsKLSAg ICBjbGlwID0gZGVmYXVsdFN0eWxlLT5jbGlwOwotICAgIG1hc2sgPSBkZWZhdWx0U3R5bGUtPm1h c2s7Ci0gICAgbWlzYyA9IGRlZmF1bHRTdHlsZS0+bWlzYzsKLSAgICBtYXJrZXJzID0gZGVmYXVs dFN0eWxlLT5tYXJrZXJzOworICAgIERFRklORV9TVEFUSUNfTE9DQUwoU1ZHUmVuZGVyU3R5bGUs IGRlZmF1bHRTdHlsZSwgKENyZWF0ZURlZmF1bHQpKTsKKworICAgIGZpbGwgPSBkZWZhdWx0U3R5 bGUuZmlsbDsKKyAgICBzdHJva2UgPSBkZWZhdWx0U3R5bGUuc3Ryb2tlOworICAgIHRleHQgPSBk ZWZhdWx0U3R5bGUudGV4dDsKKyAgICBzdG9wcyA9IGRlZmF1bHRTdHlsZS5zdG9wczsKKyAgICBj bGlwID0gZGVmYXVsdFN0eWxlLmNsaXA7CisgICAgbWFzayA9IGRlZmF1bHRTdHlsZS5tYXNrOwor ICAgIG1pc2MgPSBkZWZhdWx0U3R5bGUubWlzYzsKKyAgICBtYXJrZXJzID0gZGVmYXVsdFN0eWxl Lm1hcmtlcnM7CiAKICAgICBzZXRCaXREZWZhdWx0cygpOwogfQpkaWZmIC0tZ2l0IGEvV2ViS2l0 L3F0L0FwaS9xd2ViZnJhbWUuY3BwIGIvV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuY3BwCmluZGV4 IDZiZmQ4YTQuLmQ5NjY4ZjcgMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC9BcGkvcXdlYmZyYW1lLmNw cAorKysgYi9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5jcHAKQEAgLTc4LDYgKzc4LDEwIEBACiAj aW5jbHVkZSA8cXByaW50ZXIuaD4KICNpbmNsdWRlIDxxcmVnaW9uLmg+CiAKKyNpZiBFTkFCTEUo RlJFRV9TVEFUSUNfUFRSUykKKyNpbmNsdWRlICJ3dGYvU3RhdGljUHRyQmFzZS5oIgorI2VuZGlm CisKICNpZiBRVF9WRVJTSU9OIDwgMHgwNDA0MDAKICNpbmNsdWRlICJxd2VibmV0d29ya2ludGVy ZmFjZS5oIgogI2VuZGlmCkBAIC0xODUsNiArMTg5LDE0IEBAIHZvaWQgUVdFQktJVF9FWFBPUlQg cXRfZHJ0X2dhcmJhZ2VDb2xsZWN0b3JfY29sbGVjdE9uQWx0ZXJuYXRlVGhyZWFkKGJvb2wgd2Fp dFVuCiAgICAgZ2NDb250cm9sbGVyKCkuZ2FyYmFnZUNvbGxlY3RPbkFsdGVybmF0ZVRocmVhZEZv ckRlYnVnZ2luZyh3YWl0VW50aWxEb25lKTsKIH0KIAordm9pZCBRV0VCS0lUX0VYUE9SVCBxdF9k cnRfZnJlZVN0YXRpY1B0cnMoKQoreworI2lmIEVOQUJMRShGUkVFX1NUQVRJQ19QVFJTKQorICAg IC8vIERvZXMgbm90aGluZyBpZiBGUkVFX1NUQVRJQ19QVFJTIGRpc2FibGVkCisgICAgV1RGOjpT dGF0aWNQdHJCYXNlOjpmcmVlU3RhdGljUHRycygpOworI2VuZGlmCit9CisKIFFXZWJGcmFtZURh dGE6OlFXZWJGcmFtZURhdGEoV2ViQ29yZTo6UGFnZSogcGFyZW50UGFnZSwgV2ViQ29yZTo6RnJh bWUqIHBhcmVudEZyYW1lLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICBXZWJDb3JlOjpI VE1MRnJhbWVPd25lckVsZW1lbnQqIG93bmVyRnJhbWVFbGVtZW50LAogICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBjb25zdCBXZWJDb3JlOjpTdHJpbmcmIGZyYW1lTmFtZSkKZGlmZiAtLWdp dCBhL1dlYktpdC9xdC9BcGkvcXdlYnNldHRpbmdzLmNwcCBiL1dlYktpdC9xdC9BcGkvcXdlYnNl dHRpbmdzLmNwcAppbmRleCAxNTcxNDcwLi42MzliZmQ4IDEwMDY0NAotLS0gYS9XZWJLaXQvcXQv QXBpL3F3ZWJzZXR0aW5ncy5jcHAKKysrIGIvV2ViS2l0L3F0L0FwaS9xd2Vic2V0dGluZ3MuY3Bw CkBAIC0zNyw2ICszNyw3IEBACiAjaW5jbHVkZSAiSW50U2l6ZS5oIgogI2luY2x1ZGUgIkFwcGxp Y2F0aW9uQ2FjaGVTdG9yYWdlLmgiCiAjaW5jbHVkZSAiRGF0YWJhc2VUcmFja2VyLmgiCisjaW5j bHVkZSA8d3RmL0dsb2JhbFB0ci5oPgogCiAjaW5jbHVkZSA8UUhhc2g+CiAjaW5jbHVkZSA8UVNo YXJlZERhdGE+CkBAIC0yMDUsNiArMjA2LDE3IEBAIHZvaWQgUVdlYlNldHRpbmdzUHJpdmF0ZTo6 YXBwbHkoKQogICAgIH0KIH0KIAorI2lmIEVOQUJMRShGUkVFX1NUQVRJQ19QVFJTKQorY2xhc3Mg UVdlYlNldHRpbmdzRGVsZXRlciB7CitwdWJsaWM6CisgICAgc3RhdGljIHZvaWQgZnJlZSh2b2lk KiBwdHIpCisgICAgeworICAgICAgICBBU1NFUlQocHRyKTsKKyAgICAgICAgZGVsZXRlIHJlaW50 ZXJwcmV0X2Nhc3Q8V1RGOjpHbG9iYWxQdHI8UVdlYlNldHRpbmdzPio+KHB0ciktPmdldCgpOwor ICAgIH0KK307CisjZW5kaWYKKwogLyohCiAgICAgUmV0dXJucyB0aGUgZ2xvYmFsIHNldHRpbmdz IG9iamVjdC4KIApAQCAtMjEzLDEwICsyMjUsMTQgQEAgdm9pZCBRV2ViU2V0dGluZ3NQcml2YXRl OjphcHBseSgpCiAqLwogUVdlYlNldHRpbmdzKiBRV2ViU2V0dGluZ3M6Omdsb2JhbFNldHRpbmdz KCkKIHsKLSAgICBzdGF0aWMgUVdlYlNldHRpbmdzKiBnbG9iYWwgPSAwOwotICAgIGlmICghZ2xv YmFsKQotICAgICAgICBnbG9iYWwgPSBuZXcgUVdlYlNldHRpbmdzOwotICAgIHJldHVybiBnbG9i YWw7CisgICAgc3RhdGljIFdURjo6R2xvYmFsUHRyPFFXZWJTZXR0aW5ncz4gZ2xvYmFsOworICAg IGlmICghZ2xvYmFsKSB7CisgICAgICAgIGdsb2JhbC5zZXRQdHIobmV3IFFXZWJTZXR0aW5ncyk7 CisjaWYgRU5BQkxFKEZSRUVfU1RBVElDX1BUUlMpCisgICAgICAgIGdsb2JhbC5zZXRGcmVlKFFX ZWJTZXR0aW5nc0RlbGV0ZXI6OmZyZWUpOworI2VuZGlmCisgICAgfQorICAgIHJldHVybiBnbG9i YWwuZ2V0KCk7CiB9CiAKIC8qIQpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0FwaS9xd2Vic2V0dGlu Z3MuaCBiL1dlYktpdC9xdC9BcGkvcXdlYnNldHRpbmdzLmgKaW5kZXggNTYwODdhNy4uYmRhNzRm NSAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L0FwaS9xd2Vic2V0dGluZ3MuaAorKysgYi9XZWJLaXQv cXQvQXBpL3F3ZWJzZXR0aW5ncy5oCkBAIC0zNCw2ICszNCw3IEBAIG5hbWVzcGFjZSBXZWJDb3Jl IHsKIGNsYXNzIFFXZWJQYWdlOwogY2xhc3MgUVdlYlBsdWdpbkRhdGFiYXNlOwogY2xhc3MgUVdl YlNldHRpbmdzUHJpdmF0ZTsKK2NsYXNzIFFXZWJTZXR0aW5nc0RlbGV0ZXI7CiBRVF9CRUdJTl9O QU1FU1BBQ0UKIGNsYXNzIFFVcmw7CiBRVF9FTkRfTkFNRVNQQUNFCkBAIC0xMzcsNiArMTM4LDcg QEAgcHVibGljOgogcHJpdmF0ZToKICAgICBmcmllbmQgY2xhc3MgUVdlYlBhZ2VQcml2YXRlOwog ICAgIGZyaWVuZCBjbGFzcyBRV2ViU2V0dGluZ3NQcml2YXRlOworICAgIGZyaWVuZCBjbGFzcyBR V2ViU2V0dGluZ3NEZWxldGVyOwogCiAgICAgUV9ESVNBQkxFX0NPUFkoUVdlYlNldHRpbmdzKQog CmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvUXRMYXVuY2hlci9tYWluLmNwcCBiL1dlYktpdC9xdC9R dExhdW5jaGVyL21haW4uY3BwCmluZGV4IDM3OTA5YWYuLjVhYTcyMTYgMTAwNjQ0Ci0tLSBhL1dl YktpdC9xdC9RdExhdW5jaGVyL21haW4uY3BwCisrKyBiL1dlYktpdC9xdC9RdExhdW5jaGVyL21h aW4uY3BwCkBAIC01Myw2ICs1Myw3IEBACiAKICNpZm5kZWYgTkRFQlVHCiB2b2lkIFFXRUJLSVRf RVhQT1JUIHF0X2RydF9nYXJiYWdlQ29sbGVjdG9yX2NvbGxlY3QoKTsKK3ZvaWQgUVdFQktJVF9F WFBPUlQgcXRfZHJ0X2ZyZWVTdGF0aWNQdHJzKCk7CiAjZW5kaWYKIAogY2xhc3MgV2ViUGFnZSA6 IHB1YmxpYyBRV2ViUGFnZQpAQCAtMjg2LDcgKzI4Nyw3IEBAIHByaXZhdGU6CiAgICAgICAgIHZp ZXdNZW51LT5hZGRTZXBhcmF0b3IoKTsKICAgICAgICAgdmlld01lbnUtPmFkZEFjdGlvbigiRHVt cCBIVE1MIiwgdGhpcywgU0xPVChkdW1wSHRtbCgpKSk7CiAKLSAgICAgICAgUU1lbnUgKmZvcm1h dE1lbnUgPSBuZXcgUU1lbnUoIkYmb3JtYXQiKTsKKyAgICAgICAgUU1lbnUgKmZvcm1hdE1lbnUg PSBuZXcgUU1lbnUoIkYmb3JtYXQiLCB0aGlzKTsKICAgICAgICAgZm9ybWF0TWVudUFjdGlvbiA9 IG1lbnVCYXIoKS0+YWRkTWVudShmb3JtYXRNZW51KTsKICAgICAgICAgZm9ybWF0TWVudUFjdGlv bi0+c2V0VmlzaWJsZShmYWxzZSk7CiAgICAgICAgIGZvcm1hdE1lbnUtPmFkZEFjdGlvbih2aWV3 LT5wYWdlQWN0aW9uKFFXZWJQYWdlOjpUb2dnbGVCb2xkKSk7CkBAIC00MjEsNiArNDIyLDcgQEAg aW50IGxhdW5jaGVyTWFpbihjb25zdCBRQXBwbGljYXRpb24mIGFwcCkKICAgICBpbnQgcmV0VmFs ID0gYXBwLmV4ZWMoKTsKICAgICBxdF9kcnRfZ2FyYmFnZUNvbGxlY3Rvcl9jb2xsZWN0KCk7CiAg ICAgUVdlYlNldHRpbmdzOjpjbGVhck1lbW9yeUNhY2hlcygpOworICAgIHF0X2RydF9mcmVlU3Rh dGljUHRycygpOwogICAgIHJldHVybiByZXRWYWw7CiAjZWxzZQogICAgIHJldHVybiBhcHAuZXhl YygpOwotLSAKMS42LjAuNAoK 41886 2009-10-26 13:12:20 -0700 2009-10-27 11:58:32 -0700 Proposed Partial Patch patchFor27980-1.patch text/plain 3439 carol SW5kZXg6IEphdmFTY3JpcHRDb3JlL3d0Zi9TdGRMaWJFeHRyYXMuaAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBK YXZhU2NyaXB0Q29yZS93dGYvU3RkTGliRXh0cmFzLmgJKHJldmlzaW9uIDUwMDgzKQorKysgSmF2 YVNjcmlwdENvcmUvd3RmL1N0ZExpYkV4dHJhcy5oCSh3b3JraW5nIGNvcHkpCkBAIC0zMiw2ICsz Miw3IEBACiAvLyBVc2UgdGhlc2UgdG8gZGVjbGFyZSBhbmQgZGVmaW5lIGEgc3RhdGljIGxvY2Fs IHZhcmlhYmxlIChzdGF0aWMgVDspIHNvIHRoYXQKIC8vICBpdCBpcyBsZWFrZWQgc28gdGhhdCBp dHMgZGVzdHJ1Y3RvcnMgYXJlIG5vdCBjYWxsZWQgYXQgZXhpdC4gVXNpbmcgdGhpcwogLy8gIG1h Y3JvIGFsc28gYWxsb3dzIHdvcmthcm91bmRzIGEgY29tcGlsZXIgYnVnIHByZXNlbnQgaW4gQXBw bGUncyB2ZXJzaW9uIG9mIEdDQyA0LjAuMS4KKyNpZm5kZWYgREVGSU5FX1NUQVRJQ19MT0NBTAog I2lmIENPTVBJTEVSKEdDQykgJiYgZGVmaW5lZChfX0FQUExFX0NDX18pICYmIF9fR05VQ19fID09 IDQgJiYgX19HTlVDX01JTk9SX18gPT0gMCAmJiBfX0dOVUNfUEFUQ0hMRVZFTF9fID09IDEKICNk ZWZpbmUgREVGSU5FX1NUQVRJQ19MT0NBTCh0eXBlLCBuYW1lLCBhcmd1bWVudHMpIFwKICAgICBz dGF0aWMgdHlwZSogbmFtZSMjUHRyID0gbmV3IHR5cGUgYXJndW1lbnRzOyBcCkBAIC00MCw3ICs0 MSw3IEBACiAjZGVmaW5lIERFRklORV9TVEFUSUNfTE9DQUwodHlwZSwgbmFtZSwgYXJndW1lbnRz KSBcCiAgICAgc3RhdGljIHR5cGUmIG5hbWUgPSAqbmV3IHR5cGUgYXJndW1lbnRzCiAjZW5kaWYK LQorI2VuZGlmCiAvLyBPQkpFQ1RfT0ZGU0VUT0Y6IExpa2UgdGhlIEMrKyBvZmZzZXRvZiBtYWNy bywgYnV0IHlvdSBjYW4gdXNlIGl0IHdpdGggY2xhc3Nlcy4KIC8vIFRoZSBtYWdpYyBudW1iZXIg MHg0MDAwIGlzIGluc2lnbmlmaWNhbnQuIFdlIHVzZSBpdCB0byBhdm9pZCB1c2luZyBOVUxMLCBz aW5jZQogLy8gTlVMTCBjYW4gY2F1c2UgY29tcGlsZXIgcHJvYmxlbXMsIGVzcGVjaWFsbHkgaW4g Y2FzZXMgb2YgbXVsdGlwbGUgaW5oZXJpdGFuY2UuCkluZGV4OiBXZWJDb3JlL0NoYW5nZUxvZwo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBXZWJDb3JlL0NoYW5nZUxvZwkocmV2aXNpb24gNTAwODMpCisrKyBXZWJD b3JlL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE5IEBACisyMDA5LTEwLTI2 ICBDYXJvbCBTemFibyAgPGNhcm9sLnN6YWJvQG5va2lhLmNvbT4KKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBSZXNvdXJjZXMgYXNzb2NpYXRlZCB3aXRo IHNvbWUgc2luZ2xldG9ucyBhcmUgbm90IGZyZWVkIHdoZW4gdGhlCisgICAgICAgIFdlYktpdCBs aWJyYXJ5IGlzIHVubG9hZGVkLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MzA0MDgKKworICAgICAgICBObyBuZXcgdGVzdHMgZm9yIHRoaXMgYXMgdGhl IGNoYW5nZSBkb2VzIG5vdCBhZmZlY3QgV2ViS2l0CisgICAgICAgIGZ1bmN0aW9uYWxpdHksIGJ1 dCBvbmx5IG1lbW9yeSB1c2FnZS4KKworICAgICAgICAqIHBsYXRmb3JtL1RocmVhZEdsb2JhbERh dGEuY3BwOgorICAgICAgICAoV2ViQ29yZTo6dGhyZWFkR2xvYmFsRGF0YSk6CisgICAgICAgIEFs bG9jYXRlZCB0aHJlYWRHbG9iYWxEYXRhIHN0YXRpY2FsbHksIG5vdCBvbiBoZWFwIHN1Y2ggdGhh dCBpdAorICAgICAgICB3aWxsIGJlIGRlc3Ryb3llZCB3aGVuIHRoZSBsaWJyYXJ5IGlzIHVubG9h ZGVkLgorCiAyMDA5LTEwLTI2ICBSYWh1bCBLdWNoaGFsICA8a3VjaGhhbEBjaHJvbWl1bS5vcmc+ CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRXJpYyBTZWlkZWwuCkluZGV4OiBXZWJDb3JlL3BsYXRm b3JtL1RocmVhZEdsb2JhbERhdGEuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZvcm0v VGhyZWFkR2xvYmFsRGF0YS5jcHAJKHJldmlzaW9uIDUwMDgzKQorKysgV2ViQ29yZS9wbGF0Zm9y bS9UaHJlYWRHbG9iYWxEYXRhLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzAsNiArMzAsNyBAQAog I2luY2x1ZGUgIkV2ZW50TmFtZXMuaCIKICNpbmNsdWRlICJTdHJpbmdJbXBsLmgiCiAjaW5jbHVk ZSAiVGhyZWFkVGltZXJzLmgiCisjaW5jbHVkZSA8d3RmL1N0ZExpYkV4dHJhcy5oPgogI2luY2x1 ZGUgPHd0Zi9VbnVzZWRQYXJhbS5oPgogCiAjaWYgVVNFKElDVV9VTklDT0RFKSB8fCBVU0UoR0xJ Ql9JQ1VfVU5JQ09ERV9IWUJSSUQpCkBAIC01NCwxNiArNTUsMTEgQEAgVGhyZWFkR2xvYmFsRGF0 YSYgdGhyZWFkR2xvYmFsRGF0YSgpCiAgICAgLy8gV2UgbmVlZCB0byBjaGVjayBmb3IgZS5nLiBk YXRhYmFzZSBvYmplY3RzIG1hbmlwdWxhdGluZyBzdHJpbmdzIG9uIHNlY29uZGFyeSB0aHJlYWRz LgogI2lmIEVOQUJMRShXT1JLRVJTKQogICAgIC8vIFRocmVhZEdsb2JhbERhdGEgaXMgdXNlZCBv biBtYWluIHRocmVhZCBiZWZvcmUgaXQgY291bGQgcG9zc2libHkgYmUgdXNlZCBvbiBzZWNvbmRh cnkgb25lcywgc28gdGhlcmUgaXMgbm8gbmVlZCBmb3Igc3luY2hyb25pemF0aW9uIGhlcmUuCi0g ICAgc3RhdGljIFRocmVhZFNwZWNpZmljPFRocmVhZEdsb2JhbERhdGE+KiB0aHJlYWRHbG9iYWxE YXRhID0gbmV3IFRocmVhZFNwZWNpZmljPFRocmVhZEdsb2JhbERhdGE+OwotICAgIHJldHVybiAq KnRocmVhZEdsb2JhbERhdGE7CisgICAgREVGSU5FX1NUQVRJQ19MT0NBTChUaHJlYWRTcGVjaWZp YzxUaHJlYWRHbG9iYWxEYXRhPiwgdGhyZWFkR2xvYmFsRGF0YSwgKCkpOworICAgIHJldHVybiAq dGhyZWFkR2xvYmFsRGF0YTsKICNlbHNlCi0gICAgc3RhdGljIFRocmVhZEdsb2JhbERhdGEqIHN0 YXRpY0RhdGE7Ci0gICAgaWYgKCFzdGF0aWNEYXRhKSB7Ci0gICAgICAgIHN0YXRpY0RhdGEgPSBz dGF0aWNfY2FzdDxUaHJlYWRHbG9iYWxEYXRhKj4oZmFzdE1hbGxvYyhzaXplb2YoVGhyZWFkR2xv YmFsRGF0YSkpKTsKLSAgICAgICAgLy8gVGhyZWFkR2xvYmFsRGF0YSBjb25zdHJ1Y3RvciBpbmRp cmVjdGx5IHVzZXMgc3RhdGljRGF0YSwgc28gd2UgbmVlZCB0byBzZXQgdXAgdGhlIG1lbW9yeSBi ZWZvcmUgaW52b2tpbmcgaXQuCi0gICAgICAgIG5ldyAoc3RhdGljRGF0YSkgVGhyZWFkR2xvYmFs RGF0YTsKLSAgICB9Ci0gICAgcmV0dXJuICpzdGF0aWNEYXRhOworICAgIERFRklORV9TVEFUSUNf TE9DQUwoVGhyZWFkR2xvYmFsRGF0YSwgc3RhdGljRGF0YSwgKCkpOworICAgIHJldHVybiBzdGF0 aWNEYXRhOwogI2VuZGlmCiB9Cg== 41972 2009-10-27 11:58:32 -0700 2009-10-27 14:04:29 -0700 Allowing for override of DEFINE_STATIC_LOCAL patchFor27980-2.patch text/plain 1950 carol SW5kZXg6IEphdmFTY3JpcHRDb3JlL3d0Zi9TdGRMaWJFeHRyYXMuaAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBK YXZhU2NyaXB0Q29yZS93dGYvU3RkTGliRXh0cmFzLmgJKHJldmlzaW9uIDUwMDgzKQorKysgSmF2 YVNjcmlwdENvcmUvd3RmL1N0ZExpYkV4dHJhcy5oCSh3b3JraW5nIGNvcHkpCkBAIC0zMiw2ICsz Miw3IEBACiAvLyBVc2UgdGhlc2UgdG8gZGVjbGFyZSBhbmQgZGVmaW5lIGEgc3RhdGljIGxvY2Fs IHZhcmlhYmxlIChzdGF0aWMgVDspIHNvIHRoYXQKIC8vICBpdCBpcyBsZWFrZWQgc28gdGhhdCBp dHMgZGVzdHJ1Y3RvcnMgYXJlIG5vdCBjYWxsZWQgYXQgZXhpdC4gVXNpbmcgdGhpcwogLy8gIG1h Y3JvIGFsc28gYWxsb3dzIHdvcmthcm91bmRzIGEgY29tcGlsZXIgYnVnIHByZXNlbnQgaW4gQXBw bGUncyB2ZXJzaW9uIG9mIEdDQyA0LjAuMS4KKyNpZm5kZWYgREVGSU5FX1NUQVRJQ19MT0NBTAog I2lmIENPTVBJTEVSKEdDQykgJiYgZGVmaW5lZChfX0FQUExFX0NDX18pICYmIF9fR05VQ19fID09 IDQgJiYgX19HTlVDX01JTk9SX18gPT0gMCAmJiBfX0dOVUNfUEFUQ0hMRVZFTF9fID09IDEKICNk ZWZpbmUgREVGSU5FX1NUQVRJQ19MT0NBTCh0eXBlLCBuYW1lLCBhcmd1bWVudHMpIFwKICAgICBz dGF0aWMgdHlwZSogbmFtZSMjUHRyID0gbmV3IHR5cGUgYXJndW1lbnRzOyBcCkBAIC00MCw2ICs0 MSw3IEBACiAjZGVmaW5lIERFRklORV9TVEFUSUNfTE9DQUwodHlwZSwgbmFtZSwgYXJndW1lbnRz KSBcCiAgICAgc3RhdGljIHR5cGUmIG5hbWUgPSAqbmV3IHR5cGUgYXJndW1lbnRzCiAjZW5kaWYK KyNlbmRpZgogCiAvLyBPQkpFQ1RfT0ZGU0VUT0Y6IExpa2UgdGhlIEMrKyBvZmZzZXRvZiBtYWNy bywgYnV0IHlvdSBjYW4gdXNlIGl0IHdpdGggY2xhc3Nlcy4KIC8vIFRoZSBtYWdpYyBudW1iZXIg MHg0MDAwIGlzIGluc2lnbmlmaWNhbnQuIFdlIHVzZSBpdCB0byBhdm9pZCB1c2luZyBOVUxMLCBz aW5jZQpJbmRleDogV2ViQ29yZS9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9DaGFu Z2VMb2cJKHJldmlzaW9uIDUwMDgzKQorKysgV2ViQ29yZS9DaGFuZ2VMb2cJKHdvcmtpbmcgY29w eSkKQEAgLTEsMyArMSwyMCBAQAorMjAwOS0xMC0yNyAgQ2Fyb2wgU3phYm8gIDxjYXJvbC5zemFi b0Bub2tpYS5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAg ICAgICAgR2l2ZSBhbiBhYmlsaXR5IHRvIFdlYktpdCB0byBmcmVlIHN0YXRpY2FsbHkgYWxsb2Nh dGVkIHBvaW50ZXJzCisgICAgICAgIGJlZm9yZSBxdWl0LgorICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mjc5ODAKKworICAgICAgICBObyBuZXcgdGVzdHMg Zm9yIHRoaXMgYXMgdGhlIGNoYW5nZSBkb2VzIG5vdCBhZmZlY3QgV2ViS2l0CisgICAgICAgIGZ1 bmN0aW9uYWxpdHksIGJ1dCBvbmx5IG1lbW9yeSB1c2FnZS4KKworICAgICAgICAqIEphdmFTY3Jp cHRDb3JlL3d0Zi9TdGRMaWJFeHRyYXMuaDoKKyAgICAgICAgQWxsb3dlZCBmb3IgdGhlIG92ZXJy aWRlIG9mIERFRklORV9TVEFUSUNfTE9DQUwgdmlhIGNvbXBpbGVyIAorICAgICAgICBjb21tYW5k bGluZSBvcHRpb25zIG9yIGVsc2V3aGVyZSBpbiB0aGUgY29kZS4gVXNlZnVsIGZvciAKKyAgICAg ICAgaW1wbGVtZW50aW5nIGN1c3RvbSBidWlsZHMgdGhhdCBmcmVlIHJlc291cmNlcyBhbGxvY2F0 ZWQgdmlhCisgICAgICAgIERFRklORV9TVEFUSUNfTE9DQUwuCisKIDIwMDktMTAtMjYgIFJhaHVs IEt1Y2hoYWwgIDxrdWNoaGFsQGNocm9taXVtLm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBF cmljIFNlaWRlbC4K