44729 2010-08-26 15:54:14 -0700 Add support for GPU accelerated path rendering 2015-02-06 11:41:17 -0800 1 1 1 Unclassified WebKit Layout and Rendering 528+ (Nightly build) All All RESOLVED FIXED P2 Normal --- 45359 44666 44707 44970 44994 45015 45059 45060 45160 45161 45249 45250 45251 45252 45472 45519 45520 45521 1 kbr kbr abarth bsalomon cmarrin darin enne eric fishd hyatt jamesr jmuizelaar joone krit mdelaney7 mjs mmaxfield peter reed robin.webkit sam senorblanco simon.fraser webkit webkit.review.bot zimmermann oldest_to_newest 270180 0 kbr 2010-08-26 15:54:14 -0700 As part of the effort to perform more of WebKit's rendering using the GPU, support is needed for rendering paths on the GPU. The approach taken in this bug will be an implementation of Loop and Blinn's "Rendering Vector Art on the GPU" in Chapter 25 of GPU Gems 3. 270195 1 65642 kbr 2010-08-26 16:15:41 -0700 Created attachment 65642 Core data structures: Arena, RedBlackTree and IntervalTree From the ChangeLog: This initial patch adds two key data structures needed for the processing of paths, and a specialized arena allocator which does not call the destructors of allocated objects. It will be more obvious how these data structures are used in later patches. We can consider making them more general and incorporating them into WTF, but this will require very careful thought and possibly significant redesign, and I would like to first land a working version of this code. The scoping of #include paths and the use of a sub-namespace is deliberate. While this pattern is rarely used in the WebKit project, there are existing examples (WTF), and I believe that it is a good one to enforce modularity. I strongly desire to avoid collisions with other headers and class names in WebCore, and want to be able to export a few selected classes from this package. The few style violations are the scoped #include guards and the use of streams for debug-only printing code. The former are necessary to avoid header collisions; the latter could be changed if desired. 270196 2 webkit.review.bot 2010-08-26 16:17:07 -0700 Attachment 65642 did not pass style-queue: Failed to run "['WebKitTools/Scripts/check-webkit-style']" exit_code: 1 WebCore/platform/graphics/gpu/Arena.h:38: #ifndef header guard has wrong style, please use: Arena_h [build/header_guard] [5] WebCore/platform/graphics/gpu/IntervalTree.h:33: #ifndef header guard has wrong style, please use: IntervalTree_h [build/header_guard] [5] WebCore/platform/graphics/gpu/IntervalTree.h:42: Streams are highly discouraged. [readability/streams] [3] WebCore/platform/graphics/gpu/RedBlackTree.h:68: #ifndef header guard has wrong style, please use: RedBlackTree_h [build/header_guard] [5] WebCore/platform/graphics/gpu/RedBlackTree.h:76: Streams are highly discouraged. [readability/streams] [3] Total errors found: 5 in 4 files If any of these errors are false positives, please file a bug against check-webkit-style. 270199 3 darin 2010-08-26 16:19:46 -0700 Because of the way that Xcode processes headers, using scoped #includes won't prevent collisions. If I understand your comment correctly, then I think it’s not right. 270201 4 jamesr 2010-08-26 16:20:52 -0700 Could you elaborate? What does XCode do differently from other build systems? 270211 5 cmarrin 2010-08-26 16:51:13 -0700 I'm not sure why the additional 'gpu' namespace is needed. Seems like it makes thing unnecessarily complex. 270218 6 65642 sam 2010-08-26 16:58:38 -0700 Comment on attachment 65642 Core data structures: Arena, RedBlackTree and IntervalTree A redblack tree implementation should not be in platform/graphics but rather in WTF. r- 270221 7 kbr 2010-08-26 16:59:17 -0700 (In reply to comment #5) > I'm not sure why the additional 'gpu' namespace is needed. Seems like it makes thing unnecessarily complex. I mentioned in the ChangeLog that there are some classes that I do not necessarily want to expose from this directory to the rest of WebCore. The public interface to this functionality can be extremely narrow, but there are several implementing classes behind it. I believe that enclosing it in a sub-namespace is the best way to encapsulate it. 270224 8 kbr 2010-08-26 17:06:40 -0700 (In reply to comment #6) > (From update of attachment 65642 [details]) > A redblack tree implementation should not be in platform/graphics but rather in WTF. > > r- Please don't blindly r- this patch for this reason. As I mentioned in the ChangeLog, this red/black tree can potentially be promoted to WTF, but this will require a significant restructuring (and I'll need to ask for help from template experts in order to do it) and I strongly desire to land a working version of this code before beginning major restructuring. These few classes are only about 25% of the code to be checked in to this directory; there are more patches to follow. I'm going to proactively change this back to r?. Please consider the above. 270228 9 sam 2010-08-26 17:14:45 -0700 (In reply to comment #8) > (In reply to comment #6) > > (From update of attachment 65642 [details] [details]) > > A redblack tree implementation should not be in platform/graphics but rather in WTF. > > > > r- > > Please don't blindly r- this patch for this reason. As I mentioned in the ChangeLog, this red/black tree can potentially be promoted to WTF, but this will require a significant restructuring (and I'll need to ask for help from template experts in order to do it) and I strongly desire to land a working version of this code before beginning major restructuring. These few classes are only about 25% of the code to be checked in to this directory; there are more patches to follow. It seems like the only dependency for the red black tree is Arena, which could also go into WTF. What changes do you think need to be made to it. Why should we land this code before it is right? 270234 10 darin 2010-08-26 17:27:06 -0700 (In reply to comment #4) > Could you elaborate? What does XCode do differently from other build systems? It has something called a header map that works with a flat namespace for all header files in the project. Mark Rowe might know more details than I do. 270236 11 simon.fraser 2010-08-26 17:29:02 -0700 (In reply to comment #8) > (In reply to comment #6) > > (From update of attachment 65642 [details] [details]) > > A redblack tree implementation should not be in platform/graphics but rather in WTF. > > > > r- > > Please don't blindly r- this patch for this reason. As I mentioned in the ChangeLog, this red/black tree can potentially be promoted to WTF, but this will require a significant restructuring (and I'll need to ask for help from template experts in order to do it) and I strongly desire to land a working version of this code before beginning major restructuring. These few classes are only about 25% of the code to be checked in to this directory; there are more patches to follow. So the way we normally recommend development of significant new pieces of functionality like this is to do so on a branch first, and then merge them to TOT once they have baked for a while. Chris Rogers is doing this with Web Audio, and I think you should do the same here. 270239 12 kbr 2010-08-26 17:33:11 -0700 (In reply to comment #9) > (In reply to comment #8) > > (In reply to comment #6) > > > (From update of attachment 65642 [details] [details] [details]) > > > A redblack tree implementation should not be in platform/graphics but rather in WTF. > > > > > > r- > > > > Please don't blindly r- this patch for this reason. As I mentioned in the ChangeLog, this red/black tree can potentially be promoted to WTF, but this will require a significant restructuring (and I'll need to ask for help from template experts in order to do it) and I strongly desire to land a working version of this code before beginning major restructuring. These few classes are only about 25% of the code to be checked in to this directory; there are more patches to follow. > > It seems like the only dependency for the red black tree is Arena, which could also go into WTF. What changes do you think need to be made to it. This red/black tree and arena are currently deliberately designed to only hold and allocate POD (plain old data) or classes or structs bottoming out to only POD, which do not allocate any dynamic storage and whose destructors do not need to be called. The curve processing algorithm allocates many small structures while running and there is a strong desire to not have to do the same kind of alloc/free bookkeeping typically done for a fully general data structure, but to be able to deallocate these structures in bulk. I gather that it may be possible to both make this data structure fully general and also allow the optimization above using traits, but I currently have no experience with this. I would be interested in generalizing it, but doing so before checkpointing the working, tested code puts the project at risk. > Why should we land this code before it is right? The code is not wrong. It matches the desired uses well and is a good starting point for generalization. I think the right thing to do is to incorporate the entire working algorithm and then iterate on the implementation. 270243 13 kbr 2010-08-26 17:39:12 -0700 (In reply to comment #11) > (In reply to comment #8) > > (In reply to comment #6) > > > (From update of attachment 65642 [details] [details] [details]) > > > A redblack tree implementation should not be in platform/graphics but rather in WTF. > > > > > > r- > > > > Please don't blindly r- this patch for this reason. As I mentioned in the ChangeLog, this red/black tree can potentially be promoted to WTF, but this will require a significant restructuring (and I'll need to ask for help from template experts in order to do it) and I strongly desire to land a working version of this code before beginning major restructuring. These few classes are only about 25% of the code to be checked in to this directory; there are more patches to follow. > > So the way we normally recommend development of significant new pieces of functionality like this is to do so on a branch first, and then merge them to TOT once they have baked for a while. Chris Rogers is doing this with Web Audio, and I think you should do the same here. I respectfully disagree. Several people are actively collaborating on GPU acceleration of various aspects of WebKit's rendering, and this code is not a prototype -- it has been baking for several months in a non-WebKit project (Google's O3D web plugin). Forcing it onto a branch will make collaboration extremely difficult. There seems to be strong interest in incorporating this functionality in multiple ports, which is why I have submitted the patch under a platform-neutral directory. If there are objections to placement there, it could be placed under platform/graphics/chromium/, but that will defeat code sharing. 270253 14 65655 kbr 2010-08-26 18:09:58 -0700 Created attachment 65655 Cubic curve classification, texture coordinate assignment, local triangulation and math utilities It seems to me that it will make it easier to understand the motivation for some of this code to have all of it available for perusal in patch form, so I am continuing to upload patches before review decisions are made on earlier ones. From the ChangeLog: This patch adds the classification of cubic curve segments into categories, assignment of texture coordinates to the curves' control points for later rendering on the GPU, the algorithm for triangulating an individual cubic curve and walking its interior edges for assembly into a complete filled shape, and several utility routines related to geometry and cubic curve processing, some ported from Skia. The reason for the style violations in the header guards is described in the earlier patch. There is another violation around the use of the letter l as an identifier, but the algorithm defines coordinates k, l, and m, so it seems best to match the algorithm's terminology rather than the style guide in this case. 270254 15 webkit.review.bot 2010-08-26 18:13:17 -0700 Attachment 65655 did not pass style-queue: Failed to run "['WebKitTools/Scripts/check-webkit-style']" exit_code: 1 WebCore/platform/graphics/gpu/LocalTriangulator.h:32: #ifndef header guard has wrong style, please use: LocalTriangulator_h [build/header_guard] [5] WebCore/platform/graphics/gpu/LocalTriangulator.h:70: l is incorrectly named. Don't use the single letter 'l' as an identifier name. [readability/naming] [4] WebCore/platform/graphics/gpu/LocalTriangulator.h:134: m_l is incorrectly named. Don't use the single letter 'l' as an identifier name. [readability/naming] [4] WebCore/platform/graphics/gpu/CubicMathUtils.h:32: #ifndef header guard has wrong style, please use: CubicMathUtils_h [build/header_guard] [5] WebCore/platform/graphics/gpu/CubicClassifier.h:35: #ifndef header guard has wrong style, please use: CubicClassifier_h [build/header_guard] [5] WebCore/platform/graphics/gpu/CubicTextureCoords.h:36: #ifndef header guard has wrong style, please use: CubicTextureCoords_h [build/header_guard] [5] Total errors found: 6 in 9 files If any of these errors are false positives, please file a bug against check-webkit-style. 270259 16 65657 kbr 2010-08-26 18:23:11 -0700 Created attachment 65657 Path processing results and shader management classes From the ChangeLog: This patch adds the PathCache data structure produced by the path processing algorithm (to follow), as well as helper classes to manage the shaders used to fill the paths. The reason for the style violations in the header guards is described in an earlier patch. 270260 17 webkit.review.bot 2010-08-26 18:25:25 -0700 Attachment 65657 did not pass style-queue: Failed to run "['WebKitTools/Scripts/check-webkit-style']" exit_code: 1 WebCore/platform/graphics/gpu/PathCache.h:32: #ifndef header guard has wrong style, please use: PathCache_h [build/header_guard] [5] WebCore/platform/graphics/gpu/ShaderCache.h:32: #ifndef header guard has wrong style, please use: ShaderCache_h [build/header_guard] [5] WebCore/platform/graphics/gpu/ShaderObject.h:32: #ifndef header guard has wrong style, please use: ShaderObject_h [build/header_guard] [5] Total errors found: 3 in 7 files If any of these errors are false positives, please file a bug against check-webkit-style. 270263 18 kbr 2010-08-26 18:37:17 -0700 I just realized I incorrectly named the new source files with the .cc suffix instead of the .cpp suffix, and that was why check-webkit-style wasn't catching style errors in them. Correcting this now and uploading new patches. 270274 19 65661 kbr 2010-08-26 19:34:06 -0700 Created attachment 65661 Cubic curve classification, texture coordinate assignment, local triangulation and math utilities Revised version of cubic curve classification patch. Renamed .cc files to .cpp and fixed style violations. Updated ChangeLog. 270276 20 65663 kbr 2010-08-26 19:37:49 -0700 Created attachment 65663 Path processing results and shader management classes Renamed new .cc files to .cpp and fixed style violations. Updated ChangeLog. 270278 21 65664 kbr 2010-08-26 19:40:06 -0700 Created attachment 65664 The PathProcessor, which implements the main algorithm From the ChangeLog: This is the main algorithm. It takes as input a Path which may contain one or more closed contours including holes. It produces as output two triangle meshes which, when drawn on the GPU, render the filled path. The mesh can be transformed arbitrarily with no re-processing, and the resulting on-screen curves maintain resolution independence. PathProcessor::process is the main entry point, and should illustrate the steps of the algorithm fairly clearly. The two style violations are the style of the include guards, the reason for which is described in an earlier patch, and the use of streams for debug-only printing, which could be changed if necessary. 270279 22 webkit.review.bot 2010-08-26 19:40:24 -0700 Attachment 65661 did not pass style-queue: Failed to run "['WebKitTools/Scripts/check-webkit-style']" exit_code: 1 WebCore/platform/graphics/gpu/LocalTriangulator.h:32: #ifndef header guard has wrong style, please use: LocalTriangulator_h [build/header_guard] [5] WebCore/platform/graphics/gpu/LocalTriangulator.h:70: l is incorrectly named. Don't use the single letter 'l' as an identifier name. [readability/naming] [4] WebCore/platform/graphics/gpu/LocalTriangulator.h:134: m_l is incorrectly named. Don't use the single letter 'l' as an identifier name. [readability/naming] [4] WebCore/platform/graphics/gpu/CubicMathUtils.h:32: #ifndef header guard has wrong style, please use: CubicMathUtils_h [build/header_guard] [5] WebCore/platform/graphics/gpu/CubicClassifier.h:35: #ifndef header guard has wrong style, please use: CubicClassifier_h [build/header_guard] [5] WebCore/platform/graphics/gpu/CubicTextureCoords.h:36: #ifndef header guard has wrong style, please use: CubicTextureCoords_h [build/header_guard] [5] Total errors found: 6 in 9 files If any of these errors are false positives, please file a bug against check-webkit-style. 270280 23 webkit.review.bot 2010-08-26 19:41:35 -0700 Attachment 65663 did not pass style-queue: Failed to run "['WebKitTools/Scripts/check-webkit-style']" exit_code: 1 WebCore/platform/graphics/gpu/PathCache.h:32: #ifndef header guard has wrong style, please use: PathCache_h [build/header_guard] [5] WebCore/platform/graphics/gpu/ShaderCache.h:32: #ifndef header guard has wrong style, please use: ShaderCache_h [build/header_guard] [5] WebCore/platform/graphics/gpu/ShaderObject.h:32: #ifndef header guard has wrong style, please use: ShaderObject_h [build/header_guard] [5] Total errors found: 3 in 7 files If any of these errors are false positives, please file a bug against check-webkit-style. 270281 24 webkit.review.bot 2010-08-26 19:42:23 -0700 Attachment 65664 did not pass style-queue: Failed to run "['WebKitTools/Scripts/check-webkit-style']" exit_code: 1 WebCore/platform/graphics/gpu/PathProcessor.cpp:54: Streams are highly discouraged. [readability/streams] [3] WebCore/platform/graphics/gpu/PathProcessor.h:35: #ifndef header guard has wrong style, please use: PathProcessor_h [build/header_guard] [5] Total errors found: 2 in 3 files If any of these errors are false positives, please file a bug against check-webkit-style. 270284 25 senorblanco 2010-08-26 19:54:20 -0700 Could we consider moving the arena and red/black tree implementation, etc to WTF as-is for now, with strongly-worded comments indicating the caveats (only to be used for POD types), and that they could be generalized later? 270317 26 fishd 2010-08-26 22:44:44 -0700 (In reply to comment #13) > > So the way we normally recommend development of significant new pieces of functionality like this is to do so on a branch first, and then merge them to TOT once they have baked for a while. Chris Rogers is doing this with Web Audio, and I think you should do the same here. > > I respectfully disagree. Several people are actively collaborating on GPU acceleration of various aspects of WebKit's rendering, and this code is not a prototype -- it has been baking for several months in a non-WebKit project (Google's O3D web plugin). Forcing it onto a branch will make collaboration extremely difficult. There seems to be strong interest in incorporating this functionality in multiple ports, which is why I have submitted the patch under a platform-neutral directory. If there are objections to placement there, it could be placed under platform/graphics/chromium/, but that will defeat code sharing. Agreed, there's no need to punt this to a branch. Moreover, Chromium development happens much better when done on ToT. We have infrastructure to support development of new features on ToT that we'd like to leverage here. I have not been a big fan of the audio branch because it doesn't benefit from that infrastructure. 270323 27 fishd 2010-08-26 23:07:25 -0700 So, it sounds like there are three main objections to this patch: 1- The namespace 2- The scoped includes 3- The arena class Those are all fairly cosmetic to the core of what this patch adds. When Ken asked me about the namespace and scoping before he posted this patch, I pointed out that it didn't seem to match convention. However, I agreed with him that it seemed to have merits. For one thing, the namespace helps identify this subcomponent. The scoped include has a similar benefit. There also seemed to be some recent convention for subcomponents getting their own namespace (JSC::Yarr::), and even some convention for scoped includes (#include "yarr/RegexJIT.h"). Since Yarr was created "recently," I figured this might even be a popular new convention! (Perhaps "gpu::" should be "Gpu::" or "GPU::" instead.) As for the Arena class, I tend to agree that housing it in platform/graphics/gpu/ is suboptimal. It makes sense to put it either in wtf/ or platform/ along side the existing Arena.h. One idea would be to simply call this new Arena class PODArena instead. That would both avoid conflicts with the existing Arena and help clarify the feature that destructors are not called. 270340 28 65642 abarth 2010-08-26 23:50:28 -0700 Comment on attachment 65642 Core data structures: Arena, RedBlackTree and IntervalTree WebCore/platform/graphics/gpu/Arena.h:81 + return ::malloc(size); Why ::malloc instead of fastMalloc? WebCore/platform/graphics/gpu/Arena.h:86 + ::free(ptr); fastFree? WebCore/platform/graphics/gpu/Arena.h:126 + m_current = new Chunk(m_allocator.get(), m_currentChunkSize); naked new. Did you mean to call adoptPtr? WebCore/platform/graphics/gpu/Arena.h:133 + new(ptr) T(); Multiline if should have { }. Also, I'm not familiar with this construct, but I assume others are. WebCore/platform/graphics/gpu/Arena.h:226 + Chunk* m_current; OwnPtr? I don't understand the ownership of this memory. WebCore/platform/graphics/gpu/Arena.h:227 + Vector<Chunk*> m_chunks; Does this variable own this memory? WebCore/platform/graphics/gpu/IntervalTree.h:42 + #include <iostream> We don't usually use iostream. Perhaps you means to use LOG? WebCore/platform/graphics/gpu/IntervalTree.h:96 + const T& low() const These can be on a single line. WebCore/platform/graphics/gpu/IntervalTree.h:122 + // Returns true if this interval overlaps the other. This comment is pretty content-free. WebCore/platform/graphics/gpu/IntervalTree.h:112 + // given low and high endpoints. This comment is pretty content-free. WebCore/platform/graphics/gpu/IntervalTree.h:144 + // Summary information needed for efficient queries. Please remove this comment. WebCore/platform/graphics/gpu/IntervalTree.h:154 + void setMaxHigh(const T& maxHigh) const Seems strange to have a const setter. WebCore/platform/graphics/gpu/IntervalTree.h:218 + void allOverlaps(const IntervalType& interval, These parameters should be on one line. WebCore/platform/graphics/gpu/IntervalTree.h:221 + // gcc requires explicit dereference of "this" here Why? Is there a variable shadowing root? WebCore/platform/graphics/gpu/IntervalTree.h:228 + const UserData data = 0) One line for these parameters. WebCore/platform/graphics/gpu/IntervalTree.h:226 + static IntervalType makeInterval(const T& low, Usually we call these sorts of functions createInterval. WebCore/platform/graphics/gpu/IntervalTree.h:234 + // Returns true if the tree's invariants are preserved. Maybe remove this comment and rename to checkInvariants? WebCore/platform/graphics/gpu/IntervalTree.h:251 + // gcc requires explicit dereference of "this" here ?? WebCore/platform/graphics/gpu/IntervalTree.h:260 + Vector<IntervalType>& res) One line WebCore/platform/graphics/gpu/IntervalTree.h:272 + // interval.low() <= left->data().maxHigh() Can we make this an ASSERT instead of a comment? WebCore/platform/graphics/gpu/IntervalTree.h:282 + // node->data().low() <= interval.high() Again, perhaps an ASSERT? WebCore/platform/graphics/gpu/IntervalTree.h:293 + if (left) Multiline if should have { } WebCore/platform/graphics/gpu/IntervalTree.h:297 + if (right) ditto WebCore/platform/graphics/gpu/IntervalTree.h:309 + // Returns true if the tree's invariants are preserved. Again, why not just name the function what this comment says and remove the comment? WebCore/platform/graphics/gpu/RedBlackTree.h:69 + #define gpu_RedBlackTree_h As the stylebot says, these include guards don't match the style guide. WebCore/platform/graphics/gpu/RedBlackTree.h:71 + #ifndef NDEBUG We don't need to guard these includes. WebCore/platform/graphics/gpu/RedBlackTree.h:93 + virtual ~Visitor() {} Are you really going to destruct the visitor? I'd move this to a private destructor. WebCore/platform/graphics/gpu/RedBlackTree.h:122 + virtual ~RedBlackTree() One line is sufficient here. WebCore/platform/graphics/gpu/RedBlackTree.h:126 + // Inserts a datum into the tree. Please remove useless comment. WebCore/platform/graphics/gpu/RedBlackTree.h:146 + bool contains(const T& data) One line. What's the point of having this function if it just calls through to treeSearch? WebCore/platform/graphics/gpu/RedBlackTree.h:152 + // each one. Please remove useless comment. WebCore/platform/graphics/gpu/RedBlackTree.h:155 + if (m_root) Prefer early returns. WebCore/platform/graphics/gpu/RedBlackTree.h:159 + // Returns the number of elements in the tree. Really? WebCore/platform/graphics/gpu/RedBlackTree.h:223 + Color color() const One line. WebCore/platform/graphics/gpu/RedBlackTree.h:358 + void treeInsert(Node* z) These variable names are kind of mysterious to me. Maybe z -> newNode? WebCore/platform/graphics/gpu/RedBlackTree.h:511 + if (m_verboseDebugging) Bad indent? WebCore/platform/graphics/gpu/RedBlackTree.h:723 + int count() One line. const 270347 29 65661 abarth 2010-08-27 00:05:59 -0700 Comment on attachment 65661 Cubic curve classification, texture coordinate assignment, local triangulation and math utilities WebCore/platform/graphics/gpu/CubicClassifier.cpp:44 + float b3x, float b3y) { { should be on the next line. WebCore/platform/graphics/gpu/CubicClassifier.cpp:45 + Vector3 b0(b0x, b0y, 1); These names are terrible. WebCore/platform/graphics/gpu/CubicClassifier.h:67 + CurveType curveType() const one line WebCore/platform/graphics/gpu/CubicClassifier.h:72 + float d1() const one line WebCore/platform/graphics/gpu/CubicMathUtils.cpp:52 + // p3 = (x3, y3) This comment is mysterious to me. Should we be using a Point class instead of passing around disconnected floats? WebCore/platform/graphics/gpu/CubicMathUtils.cpp:114 + != orientation(p1x, p1y, q1x, q1y, q2x, q2y)) Please merge with previous line. WebCore/platform/graphics/gpu/CubicMathUtils.cpp:116 + != orientation(p2x, p2y, q2x, q2y, q1x, q1y))); Please merge with previous line. WebCore/platform/graphics/gpu/CubicMathUtils.cpp:119 + bool pointInTriangle(float px, float py, All this code is really begging for FloatPoint (see IntPoint in the render tree for the int version). WebCore/platform/graphics/gpu/CubicMathUtils.cpp:156 + // Derived from coplanar_tri_tri() at What's the license on that code? If this is a derived work, we need to be careful about copyright. WebCore/platform/graphics/gpu/CubicMathUtils.cpp:162 + if (edgeAgainstTriEdges(a1x, a1y, b1x, b1y, a2x, a2y, b2x, b2y, c2x, c2y)) Can we merge all these using || ? WebCore/platform/graphics/gpu/CubicMathUtils.cpp:190 + #define NearlyZeroConstant (1.0f / (1 << 12)) Why a macro and not a const float? WebCore/platform/graphics/gpu/CubicMathUtils.cpp:194 + ASSERT(tolerance > 0.0); This could be a COMPILE_ASSERT WebCore/platform/graphics/gpu/CubicMathUtils.cpp:201 + static inline float interp(float a, float b, float t) Please don't abbreviate word like this. You and I might know what interp means, but someone reading this code in the future might be confused. Also, static is redundant with inline. WebCore/platform/graphics/gpu/CubicMathUtils.cpp:218 + float bcd = interp(bc, cd, t); More mysterious variable names. WebCore/platform/graphics/gpu/CubicMathUtils.cpp:224 + static bool evalCubicAt(const FloatPoint cubic[4], float t, FloatPoint& pt) Oh! We do have FloatPoint! We should really use that all over this code. Also, instead of declaring all these functions static, just put them in an anonymous namespace. That's the C++ way of doing the same thing. WebCore/platform/graphics/gpu/CubicMathUtils.cpp:230 + static bool xRayCrossesMonotonicCubic(const XRay& xRay, const FloatPoint cubic[4], bool* ambiguous) We use non-const references for outparams. Yes, that sucks, but it's the way we roll. WebCore/platform/graphics/gpu/CubicMathUtils.cpp:249 + bool pointAtExtremum = (xRay.y() == cubic[3].y()); const? WebCore/platform/graphics/gpu/CubicMathUtils.cpp:278 + float upperT; What is T? WebCore/platform/graphics/gpu/CubicMathUtils.cpp:290 + float t = 0.5 * (upperT + lowerT); I see. Hum... WebCore/platform/graphics/gpu/CubicMathUtils.cpp:296 + } while (++iter < MaxIter && !nearlyZero(eval.y() - xRay.y())); I usually put a blank line after a do .. while since they're pretty rare. WebCore/platform/graphics/gpu/CubicMathUtils.cpp:305 + static int validUnitDivide(float numer, float denom, float* ratio) again, & for outparams WebCore/platform/graphics/gpu/CubicMathUtils.cpp:324 + return 1; In this case, maybe we should just return a struct? WebCore/platform/graphics/gpu/CubicMathUtils.cpp:315 + return 0; Why 0/1 instead of true/false? I don't quite get what's going on here. WebCore/platform/graphics/gpu/CubicMathUtils.cpp:347 + r += validUnitDivide(c, Q, r); I see. That's pretty mysterious. WebCore/platform/graphics/gpu/CubicMathUtils.cpp:423 + for (int i = 0; i < roots - 1; i++) { We prefer preincrement. WebCore/platform/graphics/gpu/CubicMathUtils.cpp:432 + memcpy(dst, src, 4*sizeof(FloatPoint)); Ouch! Shouldn't we use Vector<FloatPoint> rather than raw pointers! WebCore/platform/graphics/gpu/CubicMathUtils.cpp:430 + if (dst) { early return rather than massive nesting level? WebCore/platform/graphics/gpu/CubicMathUtils.cpp:433 + else { early return? WebCore/platform/graphics/gpu/CubicMathUtils.cpp:444 + memcpy(tmp, dst, 4 * sizeof(FloatPoint)); This is a really unsafe pattern. This code has no way to be sure how big dst or tValues are. WebCore/platform/graphics/gpu/CubicMathUtils.cpp:445 + src = tmp; Yuck! Please don't assign to your input parameters. WebCore/platform/graphics/gpu/CubicMathUtils.cpp:489 + for (int i = 0; i < 7; i++) Magic constants make me sad. Even if they are lucky number 7. WebCore/platform/graphics/gpu/CubicMathUtils.cpp:493 + // Public XRay queries. Ok. I got tired. This is as far as I got. 270350 30 65663 abarth 2010-08-27 00:20:12 -0700 Comment on attachment 65663 Path processing results and shader management classes WebCore/platform/graphics/gpu/PathCache.cpp:39 + unsigned int PathCache::numVertices() const We usually just say "unsigned" and drop the int. WebCore/platform/graphics/gpu/PathCache.cpp:39 + unsigned int PathCache::numVertices() const Why not just put this in the header? WebCore/platform/graphics/gpu/PathCache.cpp:59 + float k, float l, float m) More inscrutable variable names WebCore/platform/graphics/gpu/PathCache.cpp:78 + unsigned int PathCache::numInteriorVertices() const Move to header? WebCore/platform/graphics/gpu/PathCache.h:51 + PathCache() We can't just use the constructor the compiler gives us? WebCore/platform/graphics/gpu/PathCache.h:55 + // The number of vertices in the mesh. Remove useless comment. WebCore/platform/graphics/gpu/PathCache.h:61 + // vertices in the mesh. Can we use some data structures here instead of just a vector of floats? It seems like this ought to be a vector of FloatPoints. Also, why not just expose a getter for the underlying Vector? Splitting up the length and the pointer seems counter productive. A client can always get them from the vector, but you can't really get the vector back. WebCore/platform/graphics/gpu/PathCache.h:67 + // there are no vertices in the mesh. Again, some structuring of data would make these comments self-evident. WebCore/platform/graphics/gpu/PathCache.h:77 + // The number of interior vertices. Really? WebCore/platform/graphics/gpu/PathCache.h:78 + unsigned int numInteriorVertices() const; Please don't abbreviate words. WebCore/platform/graphics/gpu/ShaderCache.cpp:45 + , m_shaders(new OwnPtr<ShaderObject>[NumShaderTypes * NumRegionTypes * NumAntialiasTypes]) Wat? OwnPtr is a stack-object. We don't allocate them on the heap. This isn't the right patter here. WebCore/platform/graphics/gpu/ShaderCache.cpp:50 + const char* uniforms; what are these? Some more informative variable names would be helpful. WebCore/platform/graphics/gpu/ShaderCache.cpp:76 + antialiasIndex); Wow, that's kind of nutty. Also, why the giant ( ) around the whole thing? WebCore/platform/graphics/gpu/ShaderCache.cpp:94 + vertexShaderSource += Please use StringBuilder rather than +=. += makes folks cry. WebCore/platform/graphics/gpu/ShaderCache.cpp:88 + String vertexShaderSource = Did you want a Unicode string here or an 8-bit string? WebCore/platform/graphics/gpu/ShaderCache.cpp:82 + PassOwnPtr<ShaderObject> ShaderCache::loadShader(ShaderType shaderType, One line for parameters. WebCore/platform/graphics/gpu/ShaderCache.cpp:84 + AntialiasType antialiasType) Ok, this function is really nutty. Can we do something that's easier to understand? I feel like the pattern you're using will quickly turn into spagetti (if it's not already there). WebCore/platform/graphics/gpu/ShaderCache.cpp:180 + fprintf(stderr, "ShaderCache: error compiling shader: %s\n", log.ascii().data()); fprintf? LOG maybe? WebCore/platform/graphics/gpu/ShaderCache.cpp:169 + Platform3DObject ShaderCache::createShaderFromSource(GraphicsContext3D::WebGLEnumType shaderType, One line. WebCore/platform/graphics/gpu/ShaderCache.h:73 + ShaderObject* getShader(ShaderType shaderType, One line. WebCore/platform/graphics/gpu/ShaderCache.h:78 + PassOwnPtr<ShaderObject> loadShader(ShaderType shaderType, createShader? One line. WebCore/platform/graphics/gpu/ShaderCache.h:81 + Platform3DObject createShaderFromSource(GraphicsContext3D::WebGLEnumType shaderType, One line. WebCore/platform/graphics/gpu/ShaderCache.h:85 + OwnArrayPtr<OwnPtr<ShaderObject> > m_shaders; Oh, maybe that's ok. That's kind of strange, but it might just work. WebCore/platform/graphics/gpu/ShaderObject.cpp:40 + Platform3DObject program) one line. WebCore/platform/graphics/gpu/ShaderObject.cpp:54 + if (iter == m_uniformLocations.end()) { I'd permute these for early return, but that's a matter of personal preference. WebCore/platform/graphics/gpu/ShaderObject.cpp:55 + // Look it up Remove useless comment. WebCore/platform/graphics/gpu/ShaderObject.cpp:67 + // Look it up ditto WebCore/platform/graphics/gpu/ShaderObject.h:51 + void use(); Maybe rename to makeProgramCurrentInContext() ? In general, you shouldn't need a comment to explain what a function like this does. Just name the function what you would have written in the comment. WebCore/platform/graphics/gpu/ShaderObject.h:53 + // Returns the location of the given uniform, or -1 if it does not mjs will be sad about this in-band signaling. 270354 31 65664 abarth 2010-08-27 00:32:57 -0700 Comment on attachment 65664 The PathProcessor, which implements the main algorithm Please consider using one bug per patch. This bug will quickly become impossible to understand. WebCore/platform/graphics/gpu/PathProcessor.cpp:81 + T min3(const T& v1, const T& v2, const T& v3) We can rely on C++ overloading to avoid having to number these functions. WebCore/platform/graphics/gpu/PathProcessor.cpp:87 + T max3(const T& v1, const T& v2, const T& v3) Why are these functions here instead of in a more general location? WebCore/platform/graphics/gpu/PathProcessor.cpp:109 + class BBox : public Noncopyable { BBox => BoundingBox? WebCore/platform/graphics/gpu/PathProcessor.cpp:120 + void setup(float minX, One line. Again, FloatPoint calls to you. WebCore/platform/graphics/gpu/PathProcessor.cpp:131 + // Initializes the bounding box to surround the given triangle. Really? Maybe call the function initialize? Why isn't this a constructor? WebCore/platform/graphics/gpu/PathProcessor.cpp:148 + // Initializes this bounding box to the contents of the other. Kind of like a copy constructor? Why is the class NonCopyable then? WebCore/platform/graphics/gpu/PathProcessor.cpp:166 + float minX() const these should all be on one line. WebCore/platform/graphics/gpu/PathProcessor.cpp:187 + float m_minX; Isn't this just FloatRect? Why about this class is specific to bounding boxes versus other types of FloatRects? If you like explicitness of the name, you can make an empty subclass of FloatRect. WebCore/platform/graphics/gpu/PathProcessor.cpp:198 + ostr << "[BBox minX=" << arg.minX() Please don't use iostream. WebCore/platform/graphics/gpu/PathProcessor.cpp:215 + class Segment : public Noncopyable { Many of my comments for BBox apply to Segment. WebCore/platform/graphics/gpu/PathProcessor.cpp:267 + // Returns the kind of segment. For realz? WebCore/platform/graphics/gpu/PathProcessor.cpp:344 + Segment* subdivide() Can we give this a different name to more clearly distinguish it from the above function? WebCore/platform/graphics/gpu/PathProcessor.cpp:360 + int numCrossingsForXRay(FloatPoint pt, bool* ambiguous) const pt -> point? Again, & for outparams. WebCore/platform/graphics/gpu/PathProcessor.cpp:372 + CubicTextureCoords::Result* texCoords); One line. WebCore/platform/graphics/gpu/PathProcessor.cpp:401 + return 2; Magic constants are sadness. WebCore/platform/graphics/gpu/PathProcessor.cpp:219 + kCubic, We don't use the k prefix. WebCore/platform/graphics/gpu/PathProcessor.cpp:468 + default: Please omit the default case. The compiler will error out if we don't handle all the cases. WebCore/platform/graphics/gpu/PathProcessor.cpp:519 + // Adds a segment to this contour. ... WebCore/platform/graphics/gpu/PathProcessor.cpp:565 + Segment* begin() const Why not call this first? WebCore/platform/graphics/gpu/PathProcessor.cpp:574 + // cur = cur->next()) { I see. Maybe we should define a proper iterator class to make this easier? WebCore/platform/graphics/gpu/PathProcessor.cpp:583 + bool ccw() const ccw => isOrientedCounterclockwise WebCore/platform/graphics/gpu/PathProcessor.cpp:588 + void setCCW(bool ccw) setXYZZY(bool xyzzy) WebCore/platform/graphics/gpu/PathProcessor.cpp:593 + // Returns the bounding box of this contour. ... WebCore/platform/graphics/gpu/PathProcessor.cpp:612 + bool fillRightSide() const This function name sounds like a verb, which would seem to instruct this object to fill the right side. Perhaps isRightSideFilled() ? WebCore/platform/graphics/gpu/PathProcessor.cpp:614 + return m_fillRightSide; and then you can rename m_fillRightSide => m_isRightSideFilled WebCore/platform/graphics/gpu/PathProcessor.cpp:630 + Segment m_sentinel; Can't we just use null for the sentinel? Better yet, we should have a real iterator instead of a fake half-iterator. WebCore/platform/graphics/gpu/PathProcessor.cpp:633 + bool m_ccw; Again, the comments is unnecessary if the variable is named m_isOrientedCounterclockwise. WebCore/platform/graphics/gpu/PathProcessor.cpp:635 + // This contour's bounding box. really? WebCore/platform/graphics/gpu/PathProcessor.cpp:658 + for (int i = 0; i < 4; i++) { magic 4 WebCore/platform/graphics/gpu/PathProcessor.cpp:660 + if (texCoords) Multiline if should have {} . Or just put the function call on one line. WebCore/platform/graphics/gpu/PathProcessor.cpp:677 + // PathProcessor Ok. I got tired and stopped here. 270356 32 abarth 2010-08-27 00:34:25 -0700 These patches are pretty large and generally far out of WebKit style / convention. They read like code from another project rather than like WebKit code. Hopefully the comments above are a useful starting point for revising these patches. Again, please consider using one patch per bug and liking then against the master bug using the blocks relation in bugzilla. 270524 33 simon.fraser 2010-08-27 09:03:14 -0700 I'd also like to see some consideration of how you plan to test that these new data structures don't have bugs, and that the higher level features are working as expected. 270564 34 kbr 2010-08-27 09:58:20 -0700 (In reply to comment #32) > These patches are pretty large and generally far out of WebKit style / convention. They read like code from another project rather than like WebKit code. Hopefully the comments above are a useful starting point for revising these patches. Again, please consider using one patch per bug and liking then against the master bug using the blocks relation in bugzilla. You're right, the majority of this code originated in a project (O3D) covered by the Google C++ style guide, and it was ported over to WebKit style. Some of the math utilities were ported verbatim from Skia, which is why they diverge even more from both coding styles. Thanks for your extensive comments. I'll go through and address them, and probably file separate additional bugs and make this one depend on them. 270568 35 kbr 2010-08-27 10:05:08 -0700 (In reply to comment #33) > I'd also like to see some consideration of how you plan to test that these new data structures don't have bugs, and that the higher level features are working as expected. Extensive unit tests were written for these data structures in their originating project. See the various _test.cc files in http://src.chromium.org/viewvc/chrome/trunk/src/o3d/core/cross/gpu2d/ . I would be very happy to port these unit tests over. Does WebKit have a unit testing framework? The best way I have found so far to verify the higher level functionality is to do manual or side-by-side verification of the rendering results. The algorithm is known to produce correct results for several samples including the SVG butterfly. More content needs to be fed through the algorithm to shake out any remaining bugs. 270650 36 fishd 2010-08-27 12:15:59 -0700 (In reply to comment #35) > (In reply to comment #33) > > I'd also like to see some consideration of how you plan to test that these new data structures don't have bugs, and that the higher level features are working as expected. > > Extensive unit tests were written for these data structures in their originating project. See the various _test.cc files in http://src.chromium.org/viewvc/chrome/trunk/src/o3d/core/cross/gpu2d/ . I would be very happy to port these unit tests over. Does WebKit have a unit testing framework? The Chromium port does. You can add unit tests in WebKit/chromium/tests/. This is not the best location for generic unit tests, but it seems like a reasonable starting point since the framework exists. 270870 37 mjs 2010-08-27 18:24:39 -0700 I agree that fundamental data structures should go in WTF and should be aligned with our general approach for basic data structures (handles all types, matching style of API, etc). This definitely applies to the RedBlackTree. As for the Arena, ideally I would like to see it merged with the current Arena class, or else hear a clear reason for why it is beneficial to have a separate arena implementation. I am dubious about the idea of landing the code first and fixing it later, particularly since later is unspecified, may be much later, and may have to be done by someone else. Doing things on a rush basis, where you overlook certain problems, creates technical debt for the project. This project, though aiming at highly desirable goals, is somewhat experimental in the sense that the WebKit community is not 100% clear that the approach is quire right. It's hard to see how a project can both be experimental and yet worth incurring technical debt. It would also be much easier to review this if it were split into smaller and logically coherent pieces. These chunks are somewhat large, and have some recurring issues. Here are some examples: - The class Vector3 is used throughout at least one of these patches, but none of them contain its definition (it doesn't seem to already exist in WebKit). - It's not entirely clear why Vector3 is used to represent 2-dimentional points instead of using FloatPoint. - Many functions take coordinates as individual floats instead of using FloatPoint or Vector3. - Many variables have mysterious 1-3 letter names - this is not up to our standards of variable naming. - A bunch of the code uses "long" without a clear indication of why it needs to vary between 32-bit and 64-bit platforms. We usually use size_t or a similar typedef to make variable-size integer types self-documenting. - The BBox class seems to duplicate FloatRect. If it has added functionality, that should go in FloatRect. Due to these issues, as well as the many that Adam spotted, I think all of these patches should be r- for now. 270873 38 eric 2010-08-27 18:30:35 -0700 I agree with Maciej that we should r- all these patchs and try again with a master bug, and a bunch of blocking bugs. If I were doing this work, I would start by landing each of the individual data structures one at a time. OR, alternatively landing a version of some of the later work using existing data structures, with the idea to move them to better ones when the better ones land. I strongly oppose the idea of doing this work on a branch. WebKit has a horrible track record of merging branches. I believe Ken already has a pretty good sense of WebKit (demonstrated by the fact that he's a reviewer if nothing else). I would r- all these patches, close this bug, and start over. I think we've learned a lot here. Starting by adding one data structure to WTF or adding a version of PathProcessor or some of the math utilities which are self-contained would be fine. I'm happy to review smaller (ideally <20k) versions of these patches. 270913 39 mjs 2010-08-27 20:20:22 -0700 (In reply to comment #38) > I agree with Maciej that we should r- all these patchs and try again with a master bug, and a bunch of blocking bugs. > > If I were doing this work, I would start by landing each of the individual data structures one at a time. OR, alternatively landing a version of some of the later work using existing data structures, with the idea to move them to better ones when the better ones land. > > I strongly oppose the idea of doing this work on a branch. WebKit has a horrible track record of merging branches. I believe Ken already has a pretty good sense of WebKit (demonstrated by the fact that he's a reviewer if nothing else). Using a branch might not be the best fit for this work. Here's the tradeoffs: On a branch, you are free to land code that doesn't properly integrate with WebKit or follow the style guidelines. This makes it easier to sprint to demonstrate that an experimental idea is viable before you expend the effort to properly integrate it with WebKit. On the other hand, getting work from a branch in shape for trunk can be really hard - we don't have a whole lot of successes here yet. Short version, it's probably better to do the code on trunk, but with all the care and caution that any other WebKit code would call for. 271097 40 kbr 2010-08-28 19:42:48 -0700 (In reply to comment #37) > I agree that fundamental data structures should go in WTF and should be aligned with our general approach for basic data structures (handles all types, matching style of API, etc). This definitely applies to the RedBlackTree. As for the Arena, ideally I would like to see it merged with the current Arena class, or else hear a clear reason for why it is beneficial to have a separate arena implementation. > > I am dubious about the idea of landing the code first and fixing it later, particularly since later is unspecified, may be much later, and may have to be done by someone else. Doing things on a rush basis, where you overlook certain problems, creates technical debt for the project. This project, though aiming at highly desirable goals, is somewhat experimental in the sense that the WebKit community is not 100% clear that the approach is quire right. It's hard to see how a project can both be experimental and yet worth incurring technical debt. > > It would also be much easier to review this if it were split into smaller and logically coherent pieces. These chunks are somewhat large, and have some recurring issues. Here are some examples: > > - The class Vector3 is used throughout at least one of these patches, but none of them contain its definition (it doesn't seem to already exist in WebKit). > > - It's not entirely clear why Vector3 is used to represent 2-dimentional points instead of using FloatPoint. There are some situations where 3-dimensional operations like cross products need to be done. I originally thought the right thing to do was to expose a Vector3 class (see https://bugs.webkit.org/show_bug.cgi?id=44666 ), but now I realize the better approach would have been to enhance FloatPoint3D slightly, which I'm going to do instead. In some places like LocalTriangulator I'll switch it to use FloatPoint, though. > - Many functions take coordinates as individual floats instead of using FloatPoint or Vector3. I'll improve these. > - Many variables have mysterious 1-3 letter names - this is not up to our standards of variable naming. Most of these are either because the paper describes (k, l, m) coordinates, or because the code was originally ported from Skia and I was hesitant to do widespread variable renaming. > - A bunch of the code uses "long" without a clear indication of why it needs to vary between 32-bit and 64-bit platforms. We usually use size_t or a similar typedef to make variable-size integer types self-documenting. These are artifacts of GraphicsContext3D's use of long. We should clean up that class. > - The BBox class seems to duplicate FloatRect. If it has added functionality, that should go in FloatRect. Agreed, the BBox class is an artifact from the previous framework, which didn't have an appropriate class. > Due to these issues, as well as the many that Adam spotted, I think all of these patches should be r- for now. I agree. I'll revise the code according to all review feedback and try again, submitting each patch under an individual bug. 271098 41 kbr 2010-08-28 19:45:40 -0700 (In reply to comment #38) > I would r- all these patches, close this bug, and start over. I think we've learned a lot here. Starting by adding one data structure to WTF or adding a version of PathProcessor or some of the math utilities which are self-contained would be fine. I'm happy to review smaller (ideally <20k) versions of these patches. Please go ahead and r- all of these patches. However, I think we should leave this bug open as the master bug. I'll open new bugs for the new individual patches, and make this one dependent on those. 271530 42 65642 cmarrin 2010-08-30 11:50:01 -0700 Comment on attachment 65642 Core data structures: Arena, RedBlackTree and IntervalTree Reject patch based on recent discussion 271531 43 65661 cmarrin 2010-08-30 11:50:21 -0700 Comment on attachment 65661 Cubic curve classification, texture coordinate assignment, local triangulation and math utilities Reject patch based on recent discussion 271533 44 65663 cmarrin 2010-08-30 11:50:51 -0700 Comment on attachment 65663 Path processing results and shader management classes Reject patch based on recent discussion 271534 45 65664 cmarrin 2010-08-30 11:51:06 -0700 Comment on attachment 65664 The PathProcessor, which implements the main algorithm Reject patch based on recent discussion 273012 46 kbr 2010-09-01 14:15:49 -0700 The revised red-black tree is out for review under https://bugs.webkit.org/show_bug.cgi?id=45059 , but I'd like to reply to these review comments here. The Arena class has been gutted, is now named PODArena and uses Arena.h for its implementation. Removing all of the review feedback for that class below. (In reply to comment #28) > (From update of attachment 65642 [details]) > WebCore/platform/graphics/gpu/IntervalTree.h:42 > + #include <iostream> > We don't usually use iostream. Perhaps you means to use LOG? Changed throughout. > WebCore/platform/graphics/gpu/IntervalTree.h:96 > + const T& low() const > These can be on a single line. Done. > WebCore/platform/graphics/gpu/IntervalTree.h:122 > + // Returns true if this interval overlaps the other. > This comment is pretty content-free. Removed. There were a bunch of redundant comments in the previous code to obey the Google C++ coding style. > WebCore/platform/graphics/gpu/IntervalTree.h:112 > + // given low and high endpoints. > This comment is pretty content-free. Removed. > WebCore/platform/graphics/gpu/IntervalTree.h:144 > + // Summary information needed for efficient queries. > Please remove this comment. Done, though I think it is probably worth documenting what it is. > WebCore/platform/graphics/gpu/IntervalTree.h:154 > + void setMaxHigh(const T& maxHigh) const > Seems strange to have a const setter. This was only to obey Google C++ style rules, which don't allow non-const references. Changed. > WebCore/platform/graphics/gpu/IntervalTree.h:218 > + void allOverlaps(const IntervalType& interval, > These parameters should be on one line. Done. > WebCore/platform/graphics/gpu/IntervalTree.h:221 > + // gcc requires explicit dereference of "this" here > Why? Is there a variable shadowing root? No, it's because of C++ rules about inheritance in template classes. It just happens that certain non-compliant C++ compilers allow "this" to be elided. Updated the comment. > WebCore/platform/graphics/gpu/IntervalTree.h:228 > + const UserData data = 0) > One line for these parameters. Done. > WebCore/platform/graphics/gpu/IntervalTree.h:226 > + static IntervalType makeInterval(const T& low, > Usually we call these sorts of functions createInterval. Changed. > WebCore/platform/graphics/gpu/IntervalTree.h:234 > + // Returns true if the tree's invariants are preserved. > Maybe remove this comment and rename to checkInvariants? Done. > WebCore/platform/graphics/gpu/IntervalTree.h:251 > + // gcc requires explicit dereference of "this" here > ?? See above. > WebCore/platform/graphics/gpu/IntervalTree.h:260 > + Vector<IntervalType>& res) > One line Done. > WebCore/platform/graphics/gpu/IntervalTree.h:272 > + // interval.low() <= left->data().maxHigh() > Can we make this an ASSERT instead of a comment? No, because the whole point is to avoid needing operator <= on type T. Adjusted the comment. > WebCore/platform/graphics/gpu/IntervalTree.h:282 > + // node->data().low() <= interval.high() > Again, perhaps an ASSERT? See above. > WebCore/platform/graphics/gpu/IntervalTree.h:293 > + if (left) > Multiline if should have { } This is really unclear in the WebKit style guidelines. I had been thinking that if the if or else clause was a single expression that there were supposed to be no braces. Changed. > WebCore/platform/graphics/gpu/IntervalTree.h:297 > + if (right) > ditto Done. > WebCore/platform/graphics/gpu/IntervalTree.h:309 > + // Returns true if the tree's invariants are preserved. > Again, why not just name the function what this comment says and remove the comment? Done. > WebCore/platform/graphics/gpu/RedBlackTree.h:69 > + #define gpu_RedBlackTree_h > As the stylebot says, these include guards don't match the style guide. I've removed the nested namespace. > WebCore/platform/graphics/gpu/RedBlackTree.h:71 > + #ifndef NDEBUG > We don't need to guard these includes. They are unused except in debug mode, where the printing code is enabled. I think it is better to guard them. > WebCore/platform/graphics/gpu/RedBlackTree.h:93 > + virtual ~Visitor() {} > Are you really going to destruct the visitor? I'd move this to a private destructor. I've made the virtual destructor protected, which seems to match the style in other interface-like classes in WebKit. > WebCore/platform/graphics/gpu/RedBlackTree.h:122 > + virtual ~RedBlackTree() > One line is sufficient here. Done. > WebCore/platform/graphics/gpu/RedBlackTree.h:126 > + // Inserts a datum into the tree. > Please remove useless comment. Done. > WebCore/platform/graphics/gpu/RedBlackTree.h:146 > + bool contains(const T& data) > One line. What's the point of having this function if it just calls through to treeSearch? Done. The wrapper is needed. TreeSearch returns a private Node* data type, and is called from more than one public method. > WebCore/platform/graphics/gpu/RedBlackTree.h:152 > + // each one. > Please remove useless comment. Done. > WebCore/platform/graphics/gpu/RedBlackTree.h:155 > + if (m_root) > Prefer early returns. Changed. > WebCore/platform/graphics/gpu/RedBlackTree.h:159 > + // Returns the number of elements in the tree. > Really? Ha ha. Removed. > WebCore/platform/graphics/gpu/RedBlackTree.h:223 > + Color color() const > One line. Done. > WebCore/platform/graphics/gpu/RedBlackTree.h:358 > + void treeInsert(Node* z) > These variable names are kind of mysterious to me. Maybe z -> newNode? The names match those in the algorithms book. I *really* do not want to change them. > WebCore/platform/graphics/gpu/RedBlackTree.h:511 > + if (m_verboseDebugging) > Bad indent? Fixed. > WebCore/platform/graphics/gpu/RedBlackTree.h:723 > + int count() > One line. const Done. 274488 47 kbr 2010-09-05 22:44:11 -0700 I've uploaded a new patch for the classifier under https://bugs.webkit.org/show_bug.cgi?id=45249, but I'll reply to your review feedback here. (In reply to comment #29) > (From update of attachment 65661 [details]) > WebCore/platform/graphics/gpu/CubicClassifier.cpp:44 > + float b3x, float b3y) { > { should be on the next line. This code has been rewritten to use FloatPoint, so this line doesn't exist in this form any more. > WebCore/platform/graphics/gpu/CubicClassifier.cpp:45 > + Vector3 b0(b0x, b0y, 1); > These names are terrible. These match precisely the terminology in the GPU Gems 3 chapter. I've added a comment indicating this. > WebCore/platform/graphics/gpu/CubicClassifier.h:67 > + CurveType curveType() const > one line Done. > WebCore/platform/graphics/gpu/CubicClassifier.h:72 > + float d1() const > one line Done. 274489 48 kbr 2010-09-05 22:54:14 -0700 I've uploaded a new patch for the math utilities needed for this algorithm under https://bugs.webkit.org/show_bug.cgi?id=45251 , but I'll reply to your review feedback here. Note that I rewrote the code based on your and Maciej's feedback to use FloatPoint everywhere possible, which cleaned it up quite a bit (thanks) and addresses several of your review points. (In reply to comment #29) > (From update of attachment 65661 [details]) > WebCore/platform/graphics/gpu/CubicMathUtils.cpp:52 > + // p3 = (x3, y3) > This comment is mysterious to me. Should we be using a Point class instead of passing around disconnected floats? Yes. Done. > WebCore/platform/graphics/gpu/CubicMathUtils.cpp:114 > + != orientation(p1x, p1y, q1x, q1y, q2x, q2y)) > Please merge with previous line. Done. > WebCore/platform/graphics/gpu/CubicMathUtils.cpp:116 > + != orientation(p2x, p2y, q2x, q2y, q1x, q1y))); > Please merge with previous line. Done. > WebCore/platform/graphics/gpu/CubicMathUtils.cpp:119 > + bool pointInTriangle(float px, float py, > All this code is really begging for FloatPoint (see IntPoint in the render tree for the int version). Agreed. It's been rewritten. > WebCore/platform/graphics/gpu/CubicMathUtils.cpp:156 > + // Derived from coplanar_tri_tri() at > What's the license on that code? If this is a derived work, we need to be careful about copyright. There is no explicit license in the original code or any mentioned in the paper. > WebCore/platform/graphics/gpu/CubicMathUtils.cpp:162 > + if (edgeAgainstTriEdges(a1x, a1y, b1x, b1y, a2x, a2y, b2x, b2y, c2x, c2y)) > Can we merge all these using || ? Yes. Done. > WebCore/platform/graphics/gpu/CubicMathUtils.cpp:190 > + #define NearlyZeroConstant (1.0f / (1 << 12)) > Why a macro and not a const float? Only because it was a macro in the original Skia code. Changed. > WebCore/platform/graphics/gpu/CubicMathUtils.cpp:194 > + ASSERT(tolerance > 0.0); > This could be a COMPILE_ASSERT I don't follow this. Left it as is. > WebCore/platform/graphics/gpu/CubicMathUtils.cpp:201 > + static inline float interp(float a, float b, float t) > Please don't abbreviate word like this. You and I might know what interp means, but someone reading this code in the future might be confused. Also, static is redundant with inline. Sorry. Renamed to interpolate. Removed static. > WebCore/platform/graphics/gpu/CubicMathUtils.cpp:218 > + float bcd = interp(bc, cd, t); > More mysterious variable names. This particular code came directly from Skia and I really don't want to mess with the naming conventions. > WebCore/platform/graphics/gpu/CubicMathUtils.cpp:224 > + static bool evalCubicAt(const FloatPoint cubic[4], float t, FloatPoint& pt) > Oh! We do have FloatPoint! We should really use that all over this code. Also, instead of declaring all these functions static, just put them in an anonymous namespace. That's the C++ way of doing the same thing. Changed to use FloatPoint and anonymous namespaces. > WebCore/platform/graphics/gpu/CubicMathUtils.cpp:230 > + static bool xRayCrossesMonotonicCubic(const XRay& xRay, const FloatPoint cubic[4], bool* ambiguous) > We use non-const references for outparams. Yes, that sucks, but it's the way we roll. Changed. > WebCore/platform/graphics/gpu/CubicMathUtils.cpp:249 > + bool pointAtExtremum = (xRay.y() == cubic[3].y()); > const? Changed. > WebCore/platform/graphics/gpu/CubicMathUtils.cpp:278 > + float upperT; > What is T? Basically the evaluation parameter for the cubic, [0..1]. > WebCore/platform/graphics/gpu/CubicMathUtils.cpp:290 > + float t = 0.5 * (upperT + lowerT); > I see. Hum... > > WebCore/platform/graphics/gpu/CubicMathUtils.cpp:296 > + } while (++iter < MaxIter && !nearlyZero(eval.y() - xRay.y())); > I usually put a blank line after a do .. while since they're pretty rare. Done. > WebCore/platform/graphics/gpu/CubicMathUtils.cpp:305 > + static int validUnitDivide(float numer, float denom, float* ratio) > again, & for outparams I can't change this one. This code came from Skia, again, and does some pretty hairy pointer arithmetic while solving for roots. > WebCore/platform/graphics/gpu/CubicMathUtils.cpp:324 > + return 1; > In this case, maybe we should just return a struct? Code came from Skia. I really don't want to touch it. > WebCore/platform/graphics/gpu/CubicMathUtils.cpp:315 > + return 0; > Why 0/1 instead of true/false? I don't quite get what's going on here. > > WebCore/platform/graphics/gpu/CubicMathUtils.cpp:347 > + r += validUnitDivide(c, Q, r); > I see. That's pretty mysterious. Agreed. Again, this code came verbatim from Skia and I don't want to mess with it. > WebCore/platform/graphics/gpu/CubicMathUtils.cpp:423 > + for (int i = 0; i < roots - 1; i++) { > We prefer preincrement. Changed. > WebCore/platform/graphics/gpu/CubicMathUtils.cpp:432 > + memcpy(dst, src, 4*sizeof(FloatPoint)); > Ouch! Shouldn't we use Vector<FloatPoint> rather than raw pointers! Again, this code came verbatim from Skia and I don't want to mess with it. > WebCore/platform/graphics/gpu/CubicMathUtils.cpp:430 > + if (dst) { > early return rather than massive nesting level? Sure. Changed this particular Skia code. > WebCore/platform/graphics/gpu/CubicMathUtils.cpp:433 > + else { > early return? Sure. Changed this Skia code too. > WebCore/platform/graphics/gpu/CubicMathUtils.cpp:444 > + memcpy(tmp, dst, 4 * sizeof(FloatPoint)); > This is a really unsafe pattern. This code has no way to be sure how big dst or tValues are. I agree, but this code came from Skia and I don't want to change it. > WebCore/platform/graphics/gpu/CubicMathUtils.cpp:445 > + src = tmp; > Yuck! Please don't assign to your input parameters. Skia code again. > WebCore/platform/graphics/gpu/CubicMathUtils.cpp:489 > + for (int i = 0; i < 7; i++) > Magic constants make me sad. Even if they are lucky number 7. Skia code again. > WebCore/platform/graphics/gpu/CubicMathUtils.cpp:493 > + // Public XRay queries. > Ok. I got tired. This is as far as I got. I think you'll find that this function and the one below (which I contributed to Skia and then ported out) are reasonably well structured. 352545 49 82741 kbr 2011-02-16 19:35:16 -0800 Created attachment 82741 Patch 352791 50 reed 2011-02-17 06:11:54 -0800 LGTM 353031 51 82741 jamesr 2011-02-17 11:05:30 -0800 Comment on attachment 82741 Patch R=me 353222 52 kbr 2011-02-17 15:50:07 -0800 Committed r78923: <http://trac.webkit.org/changeset/78923> 353231 53 webkit.review.bot 2011-02-17 16:11:18 -0800 http://trac.webkit.org/changeset/78923 might have broken Leopard Intel Release (Build) 65642 2010-08-26 16:15:41 -0700 2010-08-30 11:50:34 -0700 Core data structures: Arena, RedBlackTree and IntervalTree arena-and-trees.patch text/plain 52002 kbr SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA2NjE0NCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMTE1IEBACisyMDEwLTA4LTI2ICBLZW5uZXRoIFJ1c3NlbGwgIDxrYnJAZ29vZ2xl LmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBB ZGQgc3VwcG9ydCBmb3IgR1BVIGFjY2VsZXJhdGVkIHBhdGggcmVuZGVyaW5nCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD00NDcyOQorCisgICAgICAgIFRo aXMgaW5pdGlhbCBwYXRjaCBhZGRzIHR3byBrZXkgZGF0YSBzdHJ1Y3R1cmVzIG5lZWRlZCBmb3Ig dGhlCisgICAgICAgIHByb2Nlc3Npbmcgb2YgcGF0aHMsIGFuZCBhIHNwZWNpYWxpemVkIGFyZW5h IGFsbG9jYXRvciB3aGljaCBkb2VzCisgICAgICAgIG5vdCBjYWxsIHRoZSBkZXN0cnVjdG9ycyBv ZiBhbGxvY2F0ZWQgb2JqZWN0cy4gSXQgd2lsbCBiZSBtb3JlCisgICAgICAgIG9idmlvdXMgaG93 IHRoZXNlIGRhdGEgc3RydWN0dXJlcyBhcmUgdXNlZCBpbiBsYXRlciBwYXRjaGVzLiBXZQorICAg ICAgICBjYW4gY29uc2lkZXIgbWFraW5nIHRoZW0gbW9yZSBnZW5lcmFsIGFuZCBpbmNvcnBvcmF0 aW5nIHRoZW0gaW50bworICAgICAgICBXVEYsIGJ1dCB0aGlzIHdpbGwgcmVxdWlyZSB2ZXJ5IGNh cmVmdWwgdGhvdWdodCBhbmQgcG9zc2libHkKKyAgICAgICAgc2lnbmlmaWNhbnQgcmVkZXNpZ24s IGFuZCBJIHdvdWxkIGxpa2UgdG8gZmlyc3QgbGFuZCBhIHdvcmtpbmcKKyAgICAgICAgdmVyc2lv biBvZiB0aGlzIGNvZGUuCisKKyAgICAgICAgVGhlIHNjb3Bpbmcgb2YgI2luY2x1ZGUgcGF0aHMg YW5kIHRoZSB1c2Ugb2YgYSBzdWItbmFtZXNwYWNlIGlzCisgICAgICAgIGRlbGliZXJhdGUuIFdo aWxlIHRoaXMgcGF0dGVybiBpcyByYXJlbHkgdXNlZCBpbiB0aGUgV2ViS2l0CisgICAgICAgIHBy b2plY3QsIHRoZXJlIGFyZSBleGlzdGluZyBleGFtcGxlcyAoV1RGKSwgYW5kIEkgYmVsaWV2ZSB0 aGF0IGl0CisgICAgICAgIGlzIGEgZ29vZCBvbmUgdG8gZW5mb3JjZSBtb2R1bGFyaXR5LiBJIHN0 cm9uZ2x5IGRlc2lyZSB0byBhdm9pZAorICAgICAgICBjb2xsaXNpb25zIHdpdGggb3RoZXIgaGVh ZGVycyBhbmQgY2xhc3MgbmFtZXMgaW4gV2ViQ29yZSwgYW5kIHdhbnQKKyAgICAgICAgdG8gYmUg YWJsZSB0byBleHBvcnQgYSBmZXcgc2VsZWN0ZWQgY2xhc3NlcyBmcm9tIHRoaXMgcGFja2FnZS4K KworICAgICAgICBUaGUgZmV3IHN0eWxlIHZpb2xhdGlvbnMgYXJlIHRoZSBzY29wZWQgI2luY2x1 ZGUgZ3VhcmRzIGFuZCB0aGUKKyAgICAgICAgdXNlIG9mIHN0cmVhbXMgZm9yIGRlYnVnLW9ubHkg cHJpbnRpbmcgY29kZS4gVGhlIGZvcm1lciBhcmUKKyAgICAgICAgbmVjZXNzYXJ5IHRvIGF2b2lk IGhlYWRlciBjb2xsaXNpb25zOyB0aGUgbGF0dGVyIGNvdWxkIGJlIGNoYW5nZWQKKyAgICAgICAg aWYgZGVzaXJlZC4KKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2dwdTogQWRkZWQuCisg ICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L0FyZW5hLmg6IEFkZGVkLgorICAgICAgICAo V2ViQ29yZTo6Z3B1OjpBcmVuYTo6QWxsb2NhdG9yOjp+QWxsb2NhdG9yKToKKyAgICAgICAgKFdl YkNvcmU6OmdwdTo6QXJlbmE6OkFsbG9jYXRvcjo6QWxsb2NhdG9yKToKKyAgICAgICAgKFdlYkNv cmU6OmdwdTo6QXJlbmE6Ok1hbGxvY0FsbG9jYXRvcjo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNv cmU6OmdwdTo6QXJlbmE6Ok1hbGxvY0FsbG9jYXRvcjo6YWxsb2NhdGUpOgorICAgICAgICAoV2Vi Q29yZTo6Z3B1OjpBcmVuYTo6TWFsbG9jQWxsb2NhdG9yOjpmcmVlKToKKyAgICAgICAgKFdlYkNv cmU6OmdwdTo6QXJlbmE6Ok1hbGxvY0FsbG9jYXRvcjo6TWFsbG9jQWxsb2NhdG9yKToKKyAgICAg ICAgKFdlYkNvcmU6OmdwdTo6QXJlbmE6OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpncHU6 OkFyZW5hOjp+QXJlbmEpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpBcmVuYTo6YWxsb2MpOgor ICAgICAgICAoV2ViQ29yZTo6Z3B1OjpBcmVuYTo6QXJlbmEpOgorICAgICAgICAoV2ViQ29yZTo6 Z3B1OjpBcmVuYTo6KToKKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6QXJlbmE6Om1pbkFsaWdubWVu dCk6CisgICAgICAgIChXZWJDb3JlOjpncHU6OkFyZW5hOjpyb3VuZFVwKToKKyAgICAgICAgKFdl YkNvcmU6OmdwdTo6QXJlbmE6OkNodW5rOjpDaHVuayk6CisgICAgICAgIChXZWJDb3JlOjpncHU6 OkFyZW5hOjpDaHVuazo6fkNodW5rKToKKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6QXJlbmE6OkNo dW5rOjphbGxvY2F0ZSk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L0ludGVydmFs VHJlZS5oOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6SW50ZXJ2YWw6OkludGVydmFs KToKKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6SW50ZXJ2YWw6Omxvdyk6CisgICAgICAgIChXZWJD b3JlOjpncHU6OkludGVydmFsOjpoaWdoKToKKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6SW50ZXJ2 YWw6OmRhdGEpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpJbnRlcnZhbDo6b3ZlcmxhcHMpOgor ICAgICAgICAoV2ViQ29yZTo6Z3B1OjpJbnRlcnZhbDo6b3BlcmF0b3I8KToKKyAgICAgICAgKFdl YkNvcmU6OmdwdTo6SW50ZXJ2YWw6Om9wZXJhdG9yPT0pOgorICAgICAgICAoV2ViQ29yZTo6Z3B1 OjpJbnRlcnZhbDo6bWF4SGlnaCk6CisgICAgICAgIChXZWJDb3JlOjpncHU6OkludGVydmFsOjpz ZXRNYXhIaWdoKToKKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6b3BlcmF0b3I8PCk6CisgICAgICAg IChXZWJDb3JlOjpncHU6OkludGVydmFsVHJlZTo6SW50ZXJ2YWxUcmVlKToKKyAgICAgICAgKFdl YkNvcmU6OmdwdTo6SW50ZXJ2YWxUcmVlOjphbGxPdmVybGFwcyk6CisgICAgICAgIChXZWJDb3Jl OjpncHU6OkludGVydmFsVHJlZTo6bWFrZUludGVydmFsKToKKyAgICAgICAgKFdlYkNvcmU6Omdw dTo6SW50ZXJ2YWxUcmVlOjp2ZXJpZnkpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpJbnRlcnZh bFRyZWU6OmluaXQpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpJbnRlcnZhbFRyZWU6OnNlYXJj aEZvck92ZXJsYXBzRnJvbSk6CisgICAgICAgIChXZWJDb3JlOjpncHU6OkludGVydmFsVHJlZTo6 dXBkYXRlTm9kZSk6CisgICAgICAgIChXZWJDb3JlOjpncHU6OkludGVydmFsVHJlZTo6dmVyaWZ5 RnJvbU5vZGUpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2dwdS9SZWRCbGFja1RyZWUu aDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpncHU6OlJlZEJsYWNrVHJlZTo6VmlzaXRvcjo6 flZpc2l0b3IpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpSZWRCbGFja1RyZWU6OlJlZEJsYWNr VHJlZSk6CisgICAgICAgIChXZWJDb3JlOjpncHU6OlJlZEJsYWNrVHJlZTo6flJlZEJsYWNrVHJl ZSk6CisgICAgICAgIChXZWJDb3JlOjpncHU6OlJlZEJsYWNrVHJlZTo6aW5zZXJ0KToKKyAgICAg ICAgKFdlYkNvcmU6OmdwdTo6UmVkQmxhY2tUcmVlOjpyZW1vdmUpOgorICAgICAgICAoV2ViQ29y ZTo6Z3B1OjpSZWRCbGFja1RyZWU6OmNvbnRhaW5zKToKKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6 UmVkQmxhY2tUcmVlOjp2aXNpdElub3JkZXIpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpSZWRC bGFja1RyZWU6Om51bUVsZW1lbnRzKToKKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6UmVkQmxhY2tU cmVlOjpzZXROZWVkc0Z1bGxPcmRlcmluZ0NvbXBhcmlzb25zKToKKyAgICAgICAgKFdlYkNvcmU6 OmdwdTo6UmVkQmxhY2tUcmVlOjp2ZXJpZnkpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpSZWRC bGFja1RyZWU6OmR1bXApOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpSZWRCbGFja1RyZWU6OnNl dFZlcmJvc2VEZWJ1Z2dpbmcpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpSZWRCbGFja1RyZWU6 Oik6CisgICAgICAgIChXZWJDb3JlOjpncHU6OlJlZEJsYWNrVHJlZTo6Tm9kZTo6Tm9kZSk6Cisg ICAgICAgIChXZWJDb3JlOjpncHU6OlJlZEJsYWNrVHJlZTo6Tm9kZTo6fk5vZGUpOgorICAgICAg ICAoV2ViQ29yZTo6Z3B1OjpSZWRCbGFja1RyZWU6Ok5vZGU6OmNvbG9yKToKKyAgICAgICAgKFdl YkNvcmU6OmdwdTo6UmVkQmxhY2tUcmVlOjpOb2RlOjpzZXRDb2xvcik6CisgICAgICAgIChXZWJD b3JlOjpncHU6OlJlZEJsYWNrVHJlZTo6Tm9kZTo6ZGF0YSk6CisgICAgICAgIChXZWJDb3JlOjpn cHU6OlJlZEJsYWNrVHJlZTo6Tm9kZTo6Y29weUZyb20pOgorICAgICAgICAoV2ViQ29yZTo6Z3B1 OjpSZWRCbGFja1RyZWU6Ok5vZGU6OmxlZnQpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpSZWRC bGFja1RyZWU6Ok5vZGU6OnNldExlZnQpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpSZWRCbGFj a1RyZWU6Ok5vZGU6OnJpZ2h0KToKKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6UmVkQmxhY2tUcmVl OjpOb2RlOjpzZXRSaWdodCk6CisgICAgICAgIChXZWJDb3JlOjpncHU6OlJlZEJsYWNrVHJlZTo6 Tm9kZTo6cGFyZW50KToKKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6UmVkQmxhY2tUcmVlOjpOb2Rl OjpzZXRQYXJlbnQpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpSZWRCbGFja1RyZWU6OnJvb3Qp OgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpSZWRCbGFja1RyZWU6OnVwZGF0ZU5vZGUpOgorICAg ICAgICAoV2ViQ29yZTo6Z3B1OjpSZWRCbGFja1RyZWU6OnRyZWVTZWFyY2gpOgorICAgICAgICAo V2ViQ29yZTo6Z3B1OjpSZWRCbGFja1RyZWU6OnRyZWVTZWFyY2hOb3JtYWwpOgorICAgICAgICAo V2ViQ29yZTo6Z3B1OjpSZWRCbGFja1RyZWU6OnRyZWVTZWFyY2hGdWxsQ29tcGFyaXNvbnMpOgor ICAgICAgICAoV2ViQ29yZTo6Z3B1OjpSZWRCbGFja1RyZWU6OnRyZWVJbnNlcnQpOgorICAgICAg ICAoV2ViQ29yZTo6Z3B1OjpSZWRCbGFja1RyZWU6OnRyZWVTdWNjZXNzb3IpOgorICAgICAgICAo V2ViQ29yZTo6Z3B1OjpSZWRCbGFja1RyZWU6OnRyZWVNaW5pbXVtKToKKyAgICAgICAgKFdlYkNv cmU6OmdwdTo6UmVkQmxhY2tUcmVlOjpwcm9wYWdhdGVVcGRhdGVzKToKKyAgICAgICAgKFdlYkNv cmU6OmdwdTo6UmVkQmxhY2tUcmVlOjpsZWZ0Um90YXRlKToKKyAgICAgICAgKFdlYkNvcmU6Omdw dTo6UmVkQmxhY2tUcmVlOjpyaWdodFJvdGF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpncHU6OlJl ZEJsYWNrVHJlZTo6aW5zZXJ0Tm9kZSk6CisgICAgICAgIChXZWJDb3JlOjpncHU6OlJlZEJsYWNr VHJlZTo6ZGVsZXRlRml4dXApOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpSZWRCbGFja1RyZWU6 OmRlbGV0ZU5vZGUpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpSZWRCbGFja1RyZWU6OnZpc2l0 SW5vcmRlckltcGwpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpSZWRCbGFja1RyZWU6OkNvdW50 ZXI6OkNvdW50ZXIpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpSZWRCbGFja1RyZWU6OkNvdW50 ZXI6OlZpc2l0KToKKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6UmVkQmxhY2tUcmVlOjpDb3VudGVy Ojpjb3VudCk6CisgICAgICAgIChXZWJDb3JlOjpncHU6OlJlZEJsYWNrVHJlZTo6dmVyaWZ5RnJv bU5vZGUpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpSZWRCbGFja1RyZWU6OmR1bXBGcm9tTm9k ZSk6CisKIDIwMTAtMDgtMjYgIFJ5b3N1a2UgTml3YSAgPHJuaXdhQHdlYmtpdC5vcmc+CiAKICAg ICAgICAgVW5yZXZpZXdlZDsgYnVpbGQgZml4LgpJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9ncHUvQXJlbmEuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L2dwdS9BcmVuYS5oCShyZXZpc2lvbiAwKQorKysgV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9n cHUvQXJlbmEuaAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwyMzQgQEAKKy8qCisgKiBDb3B5cmln aHQgMjAxMCwgR29vZ2xlIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVk aXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3 aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUg Zm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0cmli dXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAq IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xh aW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJv ZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRp b25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9u IGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlv bi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1l cyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21v dGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lm aWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJP VklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJ UyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQg Tk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJ TElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJ TUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklC VVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAq IFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcs IEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMg T1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5F U1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0Yg TElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JU CisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBX QVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBP RiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworLy8gQW4gYXJlbmEgYWxs b2NhdGVzIGxhcmdlIGNodW5rcyBvZiBtZW1vcnkgaW50ZXJuYWxseSBhbmQgYWxsb2NhdGVzCisv LyBpbmRpdmlkdWFsIG9iamVjdHMgb3V0IG9mIHRob3NlIGNodW5rcy4gT2JqZWN0cyBhcmUgbm90 IGZyZWVkCisvLyBpbmRpdmlkdWFsbHk7IHRoZWlyIHN0b3JhZ2UgaXMgcmVjbGFpbWVkIGFsbCBh dCBvbmNlIHdoZW4gdGhlIGFyZW5hCisvLyBpcyBkZXN0cm95ZWQuIFRoZSBhcmVuYSBjYWxscyB0 aGUgY29uc3RydWN0b3JzIG9mIHRoZSBvYmplY3RzCisvLyBhbGxvY2F0ZWQgd2l0aGluLCBidXQg Tk9UIHRoZWlyIGRlc3RydWN0b3JzLgorCisjaWZuZGVmIGdwdV9BcmVuYV9oCisjZGVmaW5lIGdw dV9BcmVuYV9oCisKKyNpbmNsdWRlIDxzdGRkZWYuaD4KKworI2luY2x1ZGUgPHd0Zi9Bc3NlcnRp b25zLmg+CisjaW5jbHVkZSA8d3RmL05vbmNvcHlhYmxlLmg+CisjaW5jbHVkZSA8d3RmL1JlZkNv dW50ZWQuaD4KKyNpbmNsdWRlIDx3dGYvVmVjdG9yLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsK K25hbWVzcGFjZSBncHUgeworCitjbGFzcyBBcmVuYSA6IHB1YmxpYyBSZWZDb3VudGVkPEFyZW5h PiB7CitwdWJsaWM6CisgICAgLy8gVGhlIGFyZW5hIGlzIGNvbmZpZ3VyZWQgd2l0aCBhbiBhbGxv Y2F0b3IsIHdoaWNoIGlzIHJlc3BvbnNpYmxlCisgICAgLy8gZm9yIGFsbG9jYXRpbmcgYW5kIGZy ZWVpbmcgY2h1bmtzIG9mIG1lbW9yeSBhdCBhIHRpbWUuCisgICAgY2xhc3MgQWxsb2NhdG9yIDog cHVibGljIFJlZkNvdW50ZWQ8QWxsb2NhdG9yPiB7CisgICAgcHVibGljOgorICAgICAgICB2aXJ0 dWFsIH5BbGxvY2F0b3IoKQorICAgICAgICB7CisgICAgICAgIH0KKworICAgICAgICB2aXJ0dWFs IHZvaWQqIGFsbG9jYXRlKHNpemVfdCBzaXplKSA9IDA7CisgICAgICAgIHZpcnR1YWwgdm9pZCBm cmVlKHZvaWQqIHB0cikgPSAwOworCisgICAgcHJvdGVjdGVkOgorICAgICAgICBBbGxvY2F0b3Io KQorICAgICAgICB7CisgICAgICAgIH0KKyAgICB9OworCisgICAgLy8gVGhlIEFyZW5hJ3MgZGVm YXVsdCBhbGxvY2F0b3IsIHdoaWNoIHVzZXMgbWFsbG9jIGFuZCBmcmVlIHRvCisgICAgLy8gYWxs b2NhdGUgY2h1bmtzIG9mIHN0b3JhZ2UuCisgICAgY2xhc3MgTWFsbG9jQWxsb2NhdG9yIDogcHVi bGljIEFsbG9jYXRvciB7CisgICAgcHVibGljOgorICAgICAgICBzdGF0aWMgUGFzc1JlZlB0cjxN YWxsb2NBbGxvY2F0b3I+IGNyZWF0ZSgpCisgICAgICAgIHsKKyAgICAgICAgICAgIHJldHVybiBh ZG9wdFJlZihuZXcgTWFsbG9jQWxsb2NhdG9yKTsKKyAgICAgICAgfQorCisgICAgICAgIHZpcnR1 YWwgdm9pZCogYWxsb2NhdGUoc2l6ZV90IHNpemUpCisgICAgICAgIHsKKyAgICAgICAgICAgIHJl dHVybiA6Om1hbGxvYyhzaXplKTsKKyAgICAgICAgfQorCisgICAgICAgIHZpcnR1YWwgdm9pZCBm cmVlKHZvaWQqIHB0cikKKyAgICAgICAgeworICAgICAgICAgICAgOjpmcmVlKHB0cik7CisgICAg ICAgIH0KKworICAgIHByaXZhdGU6CisgICAgICAgIE1hbGxvY0FsbG9jYXRvcigpIHt9CisgICAg fTsKKworICAgIC8vIENyZWF0ZXMgYSBuZXcgQXJlbmEgY29uZmlndXJlZCB3aXRoIGEgTWFsbG9j QWxsb2NhdG9yLgorICAgIHN0YXRpYyBQYXNzUmVmUHRyPEFyZW5hPiBjcmVhdGUoKQorICAgIHsK KyAgICAgICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBBcmVuYSk7CisgICAgfQorCisgICAgLy8gQ3Jl YXRlcyBhIG5ldyBBcmVuYSBjb25maWd1cmVkIHdpdGggdGhlIGdpdmVuIEFsbG9jYXRvci4KKyAg ICBzdGF0aWMgUGFzc1JlZlB0cjxBcmVuYT4gY3JlYXRlKEFsbG9jYXRvciogYWxsb2NhdG9yKQor ICAgIHsKKyAgICAgICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBBcmVuYShhbGxvY2F0b3IpKTsKKyAg ICB9CisKKyAgICAvLyBEZWxldGVzIHRoaXMgYXJlbmEuCisgICAgfkFyZW5hKCkKKyAgICB7Cisg ICAgICAgIC8vIE5PVEU6IGFuIGF0dGVtcHQgd2FzIG1hZGUgdG8gdXNlIHN0ZDo6Zm9yX2VhY2gg Zm9yIHRoaXMgbG9vcCwKKyAgICAgICAgLy8gYnV0IGZvciBzb21lIHJlYXNvbiB0aGlzIGludHJv ZHVjZWQgYSB0cmVtZW5kb3VzIG1lbW9yeSBsZWFrLgorICAgICAgICBmb3IgKFZlY3RvcjxDaHVu ayo+OjppdGVyYXRvciBpdGVyID0gbV9jaHVua3MuYmVnaW4oKTsgaXRlciAhPSBtX2NodW5rcy5l bmQoKTsgKytpdGVyKQorICAgICAgICAgICAgZGVsZXRlICppdGVyOworICAgIH0KKworICAgIC8v IEFsbG9jYXRlcyBhbiBvYmplY3QgZnJvbSB0aGUgYXJlbmEuCisgICAgdGVtcGxhdGU8Y2xhc3Mg VD4KKyAgICBUKiBhbGxvYygpCisgICAgeworICAgICAgICB2b2lkKiBwdHIgPSAwOworICAgICAg ICBzaXplX3Qgcm91bmRlZFNpemUgPSByb3VuZFVwKHNpemVvZihUKSwgbWluQWxpZ25tZW50KCkp OworICAgICAgICBpZiAobV9jdXJyZW50KQorICAgICAgICAgICAgcHRyID0gbV9jdXJyZW50LT5h bGxvY2F0ZShyb3VuZGVkU2l6ZSk7CisKKyAgICAgICAgaWYgKCFwdHIpIHsKKyAgICAgICAgICAg IGlmIChyb3VuZGVkU2l6ZSA+IG1fY3VycmVudENodW5rU2l6ZSkKKyAgICAgICAgICAgICAgICBt X2N1cnJlbnRDaHVua1NpemUgPSByb3VuZGVkU2l6ZTsKKyAgICAgICAgICAgIG1fY3VycmVudCA9 IG5ldyBDaHVuayhtX2FsbG9jYXRvci5nZXQoKSwgbV9jdXJyZW50Q2h1bmtTaXplKTsKKyAgICAg ICAgICAgIG1fY2h1bmtzLmFwcGVuZChtX2N1cnJlbnQpOworICAgICAgICAgICAgcHRyID0gbV9j dXJyZW50LT5hbGxvY2F0ZShyb3VuZGVkU2l6ZSk7CisgICAgICAgIH0KKworICAgICAgICBpZiAo cHRyKQorICAgICAgICAgICAgLy8gQWxsb2NhdGUgYSBUIGF0IHRoaXMgc3BvdAorICAgICAgICAg ICAgbmV3KHB0cikgVCgpOworCisgICAgICAgIHJldHVybiBzdGF0aWNfY2FzdDxUKj4ocHRyKTsK KyAgICB9CisKK3ByaXZhdGU6CisgICAgQXJlbmEoKQorICAgICAgICA6IG1fYWxsb2NhdG9yKE1h bGxvY0FsbG9jYXRvcjo6Y3JlYXRlKCkpCisgICAgICAgICwgbV9jdXJyZW50KDApCisgICAgICAg ICwgbV9jdXJyZW50Q2h1bmtTaXplKGtEZWZhdWx0Q2h1bmtTaXplKQorICAgIHsKKyAgICB9CisK KyAgICBleHBsaWNpdCBBcmVuYShBbGxvY2F0b3IqIGFsbG9jYXRvcikKKyAgICAgICAgOiBtX2Fs bG9jYXRvcihhbGxvY2F0b3IpCisgICAgICAgICwgbV9jdXJyZW50KDApCisgICAgICAgICwgbV9j dXJyZW50Q2h1bmtTaXplKGtEZWZhdWx0Q2h1bmtTaXplKQorICAgIHsKKyAgICB9CisKKyAgICBl bnVtIHsKKyAgICAgICAga0RlZmF1bHRDaHVua1NpemUgPSAxNjM4NAorICAgIH07CisKKyAgICAv LyBUaGUgZm9sbG93aW5nIHR3byBzdHJ1Y3R1cmVzIGFyZSBpbnRlbmRlZCB0byBhdXRvbWF0aWNh bGx5CisgICAgLy8gZGV0ZXJtaW5lIHRoZSBwbGF0Zm9ybSdzIGFsaWdubWVudCBjb25zdHJhaW50 IGZvciBzdHJ1Y3R1cmVzLgorICAgIHN0cnVjdCBBbGlnbm1lbnRJbm5lciB7CisgICAgICAgIGlu dDY0X3QgeDsKKyAgICB9OworICAgIHN0cnVjdCBBbGlnbm1lbnRTdHJ1Y3QgeworICAgICAgICBj aGFyIGYxOworICAgICAgICBBbGlnbm1lbnRJbm5lciBmMjsKKyAgICB9OworCisgICAgLy8gUmV0 dXJucyB0aGUgYWxpZ25tZW50IHJlcXVpcmVtZW50IGZvciBjbGFzc2VzIGFuZCBzdHJ1Y3RzIG9u IHRoZQorICAgIC8vIGN1cnJlbnQgcGxhdGZvcm0uCisgICAgc3RhdGljIHNpemVfdCBtaW5BbGln bm1lbnQoKQorICAgIHsKKyAgICAgICAgcmV0dXJuIG9mZnNldG9mKEFsaWdubWVudFN0cnVjdCwg ZjIpOworICAgIH0KKworICAgIC8vIFJvdW5kcyB1cCB0aGUgZ2l2ZW4gYWxsb2NhdGlvbiBzaXpl IHRvIHRoZSBzcGVjaWZpZWQgYWxpZ25tZW50LgorICAgIHNpemVfdCByb3VuZFVwKHNpemVfdCBz aXplLCBzaXplX3QgYWxpZ25tZW50KQorICAgIHsKKyAgICAgICAgQVNTRVJUKCEoYWxpZ25tZW50 ICUgMikpOworICAgICAgICByZXR1cm4gKHNpemUgKyBhbGlnbm1lbnQgLSAxKSAmIH4oYWxpZ25t ZW50IC0gMSk7CisgICAgfQorCisgICAgUmVmUHRyPEFsbG9jYXRvcj4gbV9hbGxvY2F0b3I7CisK KyAgICAvLyBNYW5hZ2VzIGEgY2h1bmsgb2YgbWVtb3J5IGFuZCBpbmRpdmlkdWFsIGFsbG9jYXRp b25zIG91dCBvZiBpdC4KKyAgICBjbGFzcyBDaHVuayA6IHB1YmxpYyBOb25jb3B5YWJsZSB7Cisg ICAgcHVibGljOgorICAgICAgICAvLyBBbGxvY2F0ZXMgYSBibG9jayBvZiBtZW1vcnkgb2YgdGhl IGdpdmVuIHNpemUgZnJvbSB0aGUgcGFzc2VkCisgICAgICAgIC8vIEFsbG9jYXRvci4KKyAgICAg ICAgQ2h1bmsoQWxsb2NhdG9yKiBhbGxvY2F0b3IsIHNpemVfdCBzaXplKQorICAgICAgICAgICAg OiBtX2FsbG9jYXRvcihhbGxvY2F0b3IpCisgICAgICAgICAgICAsIG1fc2l6ZShzaXplKQorICAg ICAgICAgICAgLCBtX2N1cnJlbnRPZmZzZXQoMCkKKyAgICAgICAgeworICAgICAgICAgICAgbV9i YXNlID0gc3RhdGljX2Nhc3Q8dWludDhfdCo+KG1fYWxsb2NhdG9yLT5hbGxvY2F0ZShzaXplKSk7 CisgICAgICAgIH0KKworICAgICAgICAvLyBGcmVlcyB0aGUgbWVtb3J5IGFsbG9jYXRlZCBmcm9t IHRoZSBBbGxvY2F0b3IgaW4gdGhlCisgICAgICAgIC8vIGNvbnN0cnVjdG9yLgorICAgICAgICB+ Q2h1bmsoKQorICAgICAgICB7CisgICAgICAgICAgICBtX2FsbG9jYXRvci0+ZnJlZShtX2Jhc2Up OworICAgICAgICB9CisKKyAgICAgICAgLy8gUmV0dXJucyBhIHBvaW50ZXIgdG8gInNpemUiIGJ5 dGVzIG9mIHN0b3JhZ2UsIG9yIDAgaWYgdGhpcworICAgICAgICAvLyBDaHVuayBjb3VsZCBub3Qg c2F0aXNmeSB0aGUgYWxsb2NhdGlvbi4KKyAgICAgICAgdm9pZCogYWxsb2NhdGUoc2l6ZV90IHNp emUpCisgICAgICAgIHsKKyAgICAgICAgICAgIC8vIENoZWNrIGZvciBvdmVyZmxvdworICAgICAg ICAgICAgaWYgKG1fY3VycmVudE9mZnNldCArIHNpemUgPCBtX2N1cnJlbnRPZmZzZXQpCisgICAg ICAgICAgICAgICAgcmV0dXJuIDA7CisKKyAgICAgICAgICAgIGlmIChtX2N1cnJlbnRPZmZzZXQg KyBzaXplID4gbV9zaXplKQorICAgICAgICAgICAgICAgIHJldHVybiAwOworCisgICAgICAgICAg ICB2b2lkKiByZXN1bHQgPSBtX2Jhc2UgKyBtX2N1cnJlbnRPZmZzZXQ7CisgICAgICAgICAgICBt X2N1cnJlbnRPZmZzZXQgKz0gc2l6ZTsKKyAgICAgICAgICAgIHJldHVybiByZXN1bHQ7CisgICAg ICAgIH0KKworICAgIHByaXZhdGU6CisgICAgICAgIEFsbG9jYXRvciogbV9hbGxvY2F0b3I7Cisg ICAgICAgIHVpbnQ4X3QqIG1fYmFzZTsKKyAgICAgICAgc2l6ZV90IG1fc2l6ZTsKKyAgICAgICAg c2l6ZV90IG1fY3VycmVudE9mZnNldDsKKyAgICB9OworCisgICAgQ2h1bmsqIG1fY3VycmVudDsK KyAgICBWZWN0b3I8Q2h1bmsqPiBtX2NodW5rczsKKyAgICBzaXplX3QgbV9jdXJyZW50Q2h1bmtT aXplOworfTsKKworfSAvLyBuYW1lc3BhY2UgZ3B1Cit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisK KyNlbmRpZiAvLyBncHVfQXJlbmFfaApJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9n cHUvSW50ZXJ2YWxUcmVlLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9ncHUvSW50ZXJ2YWxUcmVlLmgJKHJldmlzaW9uIDApCisrKyBXZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2dwdS9JbnRlcnZhbFRyZWUuaAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwzNTMgQEAK Ky8qCisgKiBDb3B5cmlnaHQgMjAxMCwgR29vZ2xlIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2 ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBm b3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJv dmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICog ICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92 ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBm b2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkg Zm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMg bGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRo ZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUK KyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIElu Yy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBl bmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJl IHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMg U09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklC VVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywg SU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVT IE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQ T1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBP V05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwg SU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1B R0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNV QlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJP RklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5Z CisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElB QklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBB UklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVW RU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKwor CisjaWZuZGVmIGdwdV9JbnRlcnZhbFRyZWVfaAorI2RlZmluZSBncHVfSW50ZXJ2YWxUcmVlX2gK KworI2luY2x1ZGUgImdwdS9BcmVuYS5oIgorI2luY2x1ZGUgImdwdS9SZWRCbGFja1RyZWUuaCIK KyNpbmNsdWRlIDx3dGYvTm9uY29weWFibGUuaD4KKyNpbmNsdWRlIDx3dGYvVmVjdG9yLmg+CisK KyNpZm5kZWYgTkRFQlVHCisjaW5jbHVkZSA8aW9zdHJlYW0+CisjZW5kaWYKKworbmFtZXNwYWNl IFdlYkNvcmUgeworbmFtZXNwYWNlIGdwdSB7CisKKy8vIENsYXNzIHJlcHJlc2VudGluZyBhIGNs b3NlZCBpbnRlcnZhbCB3aGljaCBjYW4gaG9sZCBhbiBhcmJpdHJhcnkKKy8vIHR5cGUgYXMgaXRz IGVuZHBvaW50cyBhbmQgYSBwaWVjZSBvZiB1c2VyIGRhdGEuIEFuIGltcG9ydGFudAorLy8gY2hh cmFjdGVyaXN0aWMgZm9yIHRoZSBhbGdvcml0aG1zIHdlIHVzZSBpcyB0aGF0IGlmIHR3byBpbnRl cnZhbHMKKy8vIGhhdmUgaWRlbnRpY2FsIGVuZHBvaW50cyBidXQgZGlmZmVyZW50IHVzZXIgZGF0 YSwgdGhleSBhcmUgbm90CisvLyBjb25zaWRlcmVkIHRvIGJlIGVxdWFsLiBUaGlzIHNpdHVhdGlv biBjYW4gYXJpc2Ugd2hlbiByZXByZXNlbnRpbmcKKy8vIHRoZSB2ZXJ0aWNhbCBleHRlbnRzIG9m IGJvdW5kaW5nIGJveGVzIG9mIG92ZXJsYXBwaW5nIHRyaWFuZ2xlcywKKy8vIHdoZXJlIHRoZSBw b2ludGVyIHRvIHRoZSB0cmlhbmdsZSBpcyB0aGUgdXNlciBkYXRhIG9mIHRoZSBpbnRlcnZhbC4K Ky8vCisvLyBUaGUgZm9sbG93aW5nIGNvbnN0cnVjdG9ycyBhbmQgb3BlcmF0b3JzIG11c3QgYmUg aW1wbGVtZW50ZWQgb24KKy8vIHR5cGUgVDoKKy8vCisvLyAgIC0gQ29weSBjb25zdHJ1Y3RvciAo aWYgdXNlciBkYXRhIGlzIGRlc2lyZWQpCisvLyAgIC0gb3BlcmF0b3I8CisvLyAgIC0gb3BlcmF0 b3I9PQorLy8gICAtIG9wZXJhdG9yPQorLy8KKy8vIElmIHRoZSBVc2VyRGF0YSB0eXBlIGlzIHNw ZWNpZmllZCwgaXQgbXVzdCBzdXBwb3J0IGEgY29weQorLy8gY29uc3RydWN0b3IgYW5kIGFzc2ln bm1lbnQgb3BlcmF0b3IuCisvLworLy8gKk5vdGUqIHRoYXQgdGhlIGRlc3RydWN0b3JzIG9mIHR5 cGUgVCBhbmQgVXNlckRhdGEgd2lsbCAqbm90KiBiZQorLy8gY2FsbGVkIGJ5IHRoaXMgY2xhc3Mu IFRoZXkgbXVzdCBub3QgYWxsb2NhdGUgYW55IG1lbW9yeSB0aGF0IGlzCisvLyByZXF1aXJlZCB0 byBiZSBjbGVhbmVkIHVwIGluIHRoZWlyIGRlc3RydWN0b3JzLgorLy8KKy8vIE5vdGUgdGhhdCB0 aGlzIGNsYXNzIHJlcXVpcmVzIGEgY29weSBjb25zdHJ1Y3RvciBhbmQgYXNzaWdubWVudAorLy8g b3BlcmF0b3IgaW4gb3JkZXIgdG8gYmUgc3RvcmVkIGluIHRoZSByZWQtYmxhY2sgdHJlZS4KK3Rl bXBsYXRlPGNsYXNzIFQsIGNsYXNzIFVzZXJEYXRhID0gdm9pZCo+CitjbGFzcyBJbnRlcnZhbCB7 CitwdWJsaWM6CisgICAgLy8gQ29uc3RydWN0b3IgZnJvbSBlbmRwb2ludHMuIFRoaXMgY29uc3Ry dWN0b3Igb25seSB3b3JrcyB3aGVuIHRoZQorICAgIC8vIFVzZXJEYXRhIHR5cGUgaXMgYSBwb2lu dGVyIG9yIG90aGVyIHR5cGUgd2hpY2ggY2FuIGJlIGluaXRpYWxpemVkCisgICAgLy8gd2l0aCAw LgorICAgIEludGVydmFsKGNvbnN0IFQmIGxvdywgY29uc3QgVCYgaGlnaCkKKyAgICAgICAgOiBt X2xvdyhsb3cpCisgICAgICAgICwgbV9oaWdoKGhpZ2gpCisgICAgICAgICwgbV9kYXRhKDApCisg ICAgICAgICwgbV9tYXhIaWdoKGhpZ2gpCisgICAgeworICAgIH0KKworICAgIC8vIENvbnN0cnVj dG9yIGZyb20gdHdvIGVuZHBvaW50cyBwbHVzIGV4cGxpY2l0IHVzZXIgZGF0YS4KKyAgICBJbnRl cnZhbChjb25zdCBUJiBsb3csIGNvbnN0IFQmIGhpZ2gsIGNvbnN0IFVzZXJEYXRhIGRhdGEpCisg ICAgICAgIDogbV9sb3cobG93KQorICAgICAgICAsIG1faGlnaChoaWdoKQorICAgICAgICAsIG1f ZGF0YShkYXRhKQorICAgICAgICAsIG1fbWF4SGlnaChoaWdoKQorICAgIHsKKyAgICB9CisKKyAg ICBjb25zdCBUJiBsb3coKSBjb25zdAorICAgIHsKKyAgICAgICAgcmV0dXJuIG1fbG93OworICAg IH0KKworICAgIGNvbnN0IFQmIGhpZ2goKSBjb25zdAorICAgIHsKKyAgICAgICAgcmV0dXJuIG1f aGlnaDsKKyAgICB9CisKKyAgICBjb25zdCBVc2VyRGF0YSYgZGF0YSgpIGNvbnN0CisgICAgewor ICAgICAgICByZXR1cm4gbV9kYXRhOworICAgIH0KKworICAgIC8vIFJldHVybnMgdHJ1ZSBpZiB0 aGlzIGludGVydmFsIG92ZXJsYXBzIHRoYXQgc3BlY2lmaWVkIGJ5IHRoZQorICAgIC8vIGdpdmVu IGxvdyBhbmQgaGlnaCBlbmRwb2ludHMuCisgICAgYm9vbCBvdmVybGFwcyhjb25zdCBUJiBsb3cs IGNvbnN0IFQmIGhpZ2gpIGNvbnN0CisgICAgeworICAgICAgICBpZiAodGhpcy0+aGlnaCgpIDwg bG93KQorICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworICAgICAgICBpZiAoaGlnaCA8IHRoaXMt PmxvdygpKQorICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworICAgICAgICByZXR1cm4gdHJ1ZTsK KyAgICB9CisKKyAgICAvLyBSZXR1cm5zIHRydWUgaWYgdGhpcyBpbnRlcnZhbCBvdmVybGFwcyB0 aGUgb3RoZXIuCisgICAgYm9vbCBvdmVybGFwcyhjb25zdCBJbnRlcnZhbCYgb3RoZXIpIGNvbnN0 CisgICAgeworICAgICAgICByZXR1cm4gb3ZlcmxhcHMob3RoZXIubG93KCksIG90aGVyLmhpZ2go KSk7CisgICAgfQorCisgICAgLy8gUmV0dXJucyB0cnVlIGlmIHRoaXMgaW50ZXJ2YWwgaXMgImxl c3MiIHRoYW4gdGhlIG90aGVyLiBUaGUKKyAgICAvLyBjb21wYXJpc29uIGlzIHBlcmZvcm1lZCBv biB0aGUgbG93IGVuZHBvaW50cyBvZiB0aGUgaW50ZXJ2YWxzLgorICAgIGJvb2wgb3BlcmF0b3I8 KGNvbnN0IEludGVydmFsJiBvdGhlcikgY29uc3QKKyAgICB7CisgICAgICAgIHJldHVybiBsb3co KSA8IG90aGVyLmxvdygpOworICAgIH0KKworICAgIC8vIFJldHVybnMgdHJ1ZSBpZiB0aGlzIGlu dGVydmFsIGlzIHN0cmljdGx5IGVxdWFsIHRvIHRoZSBvdGhlciwKKyAgICAvLyBpbmNsdWRpbmcg Y29tcGFyaXNvbiBvZiB0aGUgdXNlciBkYXRhLgorICAgIGJvb2wgb3BlcmF0b3I9PShjb25zdCBJ bnRlcnZhbCYgb3RoZXIpIGNvbnN0CisgICAgeworICAgICAgICByZXR1cm4gKGxvdygpID09IG90 aGVyLmxvdygpCisgICAgICAgICAgICAgICAgJiYgaGlnaCgpID09IG90aGVyLmhpZ2goKQorICAg ICAgICAgICAgICAgICYmIGRhdGEoKSA9PSBvdGhlci5kYXRhKCkpOworICAgIH0KKworICAgIC8v IFN1bW1hcnkgaW5mb3JtYXRpb24gbmVlZGVkIGZvciBlZmZpY2llbnQgcXVlcmllcy4KKyAgICBj b25zdCBUJiBtYXhIaWdoKCkgY29uc3QKKyAgICB7CisgICAgICAgIHJldHVybiBtX21heEhpZ2g7 CisgICAgfQorCisgICAgLy8gVXBkYXRlcyB0aGUgY2FjaGUgb2YgdGhlIHN1bW1hcnkgaW5mb3Jt YXRpb24gZm9yIHRoaXMgaW50ZXJ2YWwuCisgICAgLy8gSXQgaXMgbm90IHJlYWxseSBjb25zdCwg YnV0IGl0IGRvZXMgbm90IGFmZmVjdCB0aGUgdXNlci1sZXZlbAorICAgIC8vIHN0YXRlLCBhbmQg bXVzdCBiZSBkZWNsYXJlZCBjb25zdCB0byBvYmV5IHRoZSBjb250cmFjdCBpbiB0aGUKKyAgICAv LyBSZWRCbGFja1RyZWUgdGhhdCBOb2RlOjpkYXRhKCkgcmV0dXJucyBhIGNvbnN0IHJlZmVyZW5j ZS4KKyAgICB2b2lkIHNldE1heEhpZ2goY29uc3QgVCYgbWF4SGlnaCkgY29uc3QKKyAgICB7Cisg ICAgICAgIG1fbWF4SGlnaCA9IG1heEhpZ2g7CisgICAgfQorCisgcHJpdmF0ZToKKyAgICBUIG1f bG93OworICAgIFQgbV9oaWdoOworICAgIFVzZXJEYXRhIG1fZGF0YTsKKyAgICAvLyBTZWUgdGhl IGRvY3VtZW50YXRpb24gZm9yIHNldE1heEhpZ2goKSBmb3IgYW4gZXhwbGFuYXRpb24gb2YKKyAg ICAvLyB3aHkgdGhpcyBtdXN0IGJlIG11dGFibGUuCisgICAgbXV0YWJsZSBUIG1fbWF4SGlnaDsK K307CisKKyNpZm5kZWYgTkRFQlVHCisvLyBTdXBwcG9ydCBmb3IgcHJpbnRpbmcgSW50ZXJ2YWxz LgordGVtcGxhdGU8Y2xhc3MgVCwgY2xhc3MgVXNlckRhdGE+CitzdGQ6Om9zdHJlYW0mIG9wZXJh dG9yPDwoc3RkOjpvc3RyZWFtJiBvc3RyLAorICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0 IEludGVydmFsPFQsIFVzZXJEYXRhPiYgYXJnKQoreworICAgIG9zdHIgPDwgIltJbnRlcnZhbCAo IiA8PCBhcmcubG93KCkKKyAgICAgICAgIDw8ICIsICIgPDwgYXJnLmhpZ2goKQorICAgICAgICAg PDwgIiksIGRhdGE9IiA8PCBhcmcuZGF0YSgpCisgICAgICAgICA8PCAiLCBtYXhIaWdoPSIgPDwg YXJnLm1heEhpZ2goKSA8PCAiXSI7CisgICAgcmV0dXJuIG9zdHI7Cit9CisjZW5kaWYKKworLy8g QW4gaW50ZXJ2YWwgdHJlZSwgd2hpY2ggaXMgYSBmb3JtIG9mIGF1Z21lbnRlZCByZWQtYmxhY2sg dHJlZS4gSXQKKy8vIHN1cHBvcnRzIGVmZmljaWVudCAoTyhsZyBuKSkgaW5zZXJ0aW9uLCByZW1v dmFsIGFuZCBxdWVyeWluZyBvZgorLy8gaW50ZXJ2YWxzIGluIHRoZSB0cmVlLgordGVtcGxhdGU8 Y2xhc3MgVCwgY2xhc3MgVXNlckRhdGEgPSB2b2lkKj4KK2NsYXNzIEludGVydmFsVHJlZSA6IHB1 YmxpYyBOb25jb3B5YWJsZSwKKyAgICAgICAgICAgICAgICAgICAgIHB1YmxpYyBSZWRCbGFja1Ry ZWU8SW50ZXJ2YWw8VCwgVXNlckRhdGE+ID4geworcHVibGljOgorICAgIC8vIFR5cGVkZWYgdG8g cmVkdWNlIHR5cGluZyB3aGVuIGRlY2xhcmluZyBpbnRlcnZhbHMgdG8gYmUgc3RvcmVkIGluCisg ICAgLy8gdGhpcyB0cmVlLgorICAgIHR5cGVkZWYgSW50ZXJ2YWw8VCwgVXNlckRhdGE+IEludGVy dmFsVHlwZTsKKworICAgIEludGVydmFsVHJlZSgpCisgICAgICAgIDogUmVkQmxhY2tUcmVlPElu dGVydmFsVHlwZT4oKQorICAgIHsKKyAgICAgICAgaW5pdCgpOworICAgIH0KKworICAgIGV4cGxp Y2l0IEludGVydmFsVHJlZShBcmVuYSogYXJlbmEpCisgICAgICAgIDogUmVkQmxhY2tUcmVlPElu dGVydmFsVHlwZT4oYXJlbmEpCisgICAgeworICAgICAgICBpbml0KCk7CisgICAgfQorCisgICAg Ly8gUmV0dXJucyBhbGwgaW50ZXJ2YWxzIGluIHRoZSB0cmVlIHdoaWNoIG92ZXJsYXAgdGhlIGdp dmVuIHF1ZXJ5CisgICAgLy8gaW50ZXJ2YWwuIFRoZSByZXR1cm5lZCBpbnRlcnZhbHMgYXJlIHNv cnRlZCBieSBpbmNyZWFzaW5nIGxvdworICAgIC8vIGVuZHBvaW50LgorICAgIFZlY3RvcjxJbnRl cnZhbFR5cGU+IGFsbE92ZXJsYXBzKGNvbnN0IEludGVydmFsVHlwZSYgaW50ZXJ2YWwpCisgICAg eworICAgICAgICBWZWN0b3I8SW50ZXJ2YWxUeXBlPiByZXN1bHQ7CisgICAgICAgIGFsbE92ZXJs YXBzKGludGVydmFsLCByZXN1bHQpOworICAgICAgICByZXR1cm4gcmVzdWx0OworICAgIH0KKwor ICAgIC8vIFJldHVybnMgYWxsIGludGVydmFscyBpbiB0aGUgdHJlZSB3aGljaCBvdmVybGFwIHRo ZSBnaXZlbiBxdWVyeQorICAgIC8vIGludGVydmFsLiBUaGUgcmV0dXJuZWQgaW50ZXJ2YWxzIGFy ZSBzb3J0ZWQgYnkgaW5jcmVhc2luZyBsb3cKKyAgICAvLyBlbmRwb2ludC4KKyAgICB2b2lkIGFs bE92ZXJsYXBzKGNvbnN0IEludGVydmFsVHlwZSYgaW50ZXJ2YWwsCisgICAgICAgICAgICAgICAg ICAgICBWZWN0b3I8SW50ZXJ2YWxUeXBlPiYgcmVzdWx0KQorICAgIHsKKyAgICAgICAgLy8gZ2Nj IHJlcXVpcmVzIGV4cGxpY2l0IGRlcmVmZXJlbmNlIG9mICJ0aGlzIiBoZXJlCisgICAgICAgIHNl YXJjaEZvck92ZXJsYXBzRnJvbSh0aGlzLT5yb290KCksIGludGVydmFsLCByZXN1bHQpOworICAg IH0KKworICAgIC8vIEhlbHBlciB0byBjcmVhdGUgaW50ZXJ2YWwgb2JqZWN0cy4KKyAgICBzdGF0 aWMgSW50ZXJ2YWxUeXBlIG1ha2VJbnRlcnZhbChjb25zdCBUJiBsb3csCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgVCYgaGlnaCwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBjb25zdCBVc2VyRGF0YSBkYXRhID0gMCkKKyAgICB7CisgICAg ICAgIHJldHVybiBJbnRlcnZhbFR5cGUobG93LCBoaWdoLCBkYXRhKTsKKyAgICB9CisKKyNpZm5k ZWYgTkRFQlVHCisgICAgLy8gUmV0dXJucyB0cnVlIGlmIHRoZSB0cmVlJ3MgaW52YXJpYW50cyBh cmUgcHJlc2VydmVkLgorICAgIHZpcnR1YWwgYm9vbCB2ZXJpZnkoKQorICAgIHsKKyAgICAgICAg aWYgKCFSZWRCbGFja1RyZWU8SW50ZXJ2YWxUeXBlPjo6dmVyaWZ5KCkpCisgICAgICAgICAgICBy ZXR1cm4gZmFsc2U7CisgICAgICAgIGlmICghdGhpcy0+cm9vdCgpKQorICAgICAgICAgICAgcmV0 dXJuIHRydWU7CisgICAgICAgIHJldHVybiB2ZXJpZnlGcm9tTm9kZSh0aGlzLT5yb290KCksIDAp OworICAgIH0KKyNlbmRpZgorCitwcml2YXRlOgorICAgIHR5cGVkZWYgdHlwZW5hbWUgUmVkQmxh Y2tUcmVlPEludGVydmFsVHlwZT46Ok5vZGUgSW50ZXJ2YWxOb2RlOworCisgICAgLy8gSW5pdGlh bGl6ZXMgdGhlIHRyZWUuCisgICAgdm9pZCBpbml0KCkKKyAgICB7CisgICAgICAgIC8vIGdjYyBy ZXF1aXJlcyBleHBsaWNpdCBkZXJlZmVyZW5jZSBvZiAidGhpcyIgaGVyZQorICAgICAgICB0aGlz LT5zZXROZWVkc0Z1bGxPcmRlcmluZ0NvbXBhcmlzb25zKHRydWUpOworICAgIH0KKworICAgIC8v IFN0YXJ0aW5nIGZyb20gdGhlIGdpdmVuIG5vZGUsIGFkZHMgYWxsIG92ZXJsYXBzIHdpdGggdGhl IGdpdmVuCisgICAgLy8gaW50ZXJ2YWwgdG8gdGhlIHJlc3VsdCB2ZWN0b3IuIFRoZSBpbnRlcnZh bHMgYXJlIHNvcnRlZCBieQorICAgIC8vIGluY3JlYXNpbmcgbG93IGVuZHBvaW50LgorICAgIHZv aWQgc2VhcmNoRm9yT3ZlcmxhcHNGcm9tKEludGVydmFsTm9kZSogbm9kZSwKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBjb25zdCBJbnRlcnZhbFR5cGUmIGludGVydmFsLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIFZlY3RvcjxJbnRlcnZhbFR5cGU+JiByZXMpCisgICAg eworICAgICAgICBpZiAoIW5vZGUpCisgICAgICAgICAgICByZXR1cm47CisKKyAgICAgICAgLy8g QmVjYXVzZSB0aGUgaW50ZXJ2YWxzIGFyZSBzb3J0ZWQgYnkgbGVmdCBlbmRwb2ludCwgaW5vcmRl cgorICAgICAgICAvLyB0cmF2ZXJzYWwgcHJvZHVjZXMgcmVzdWx0cyBzb3J0ZWQgYXMgZGVzaXJl ZC4KKworICAgICAgICAvLyBTZWUgd2hldGhlciB3ZSBuZWVkIHRvIHRyYXZlcnNlIHRoZSBsZWZ0 IHN1YnRyZWUuCisgICAgICAgIEludGVydmFsTm9kZSogbGVmdCA9IG5vZGUtPmxlZnQoKTsKKyAg ICAgICAgaWYgKGxlZnQKKyAgICAgICAgICAgIC8vIFRoaXMgaXMgZXF1aXZhbGVudCB0bzoKKyAg ICAgICAgICAgIC8vIGludGVydmFsLmxvdygpIDw9IGxlZnQtPmRhdGEoKS5tYXhIaWdoKCkKKyAg ICAgICAgICAgICYmICEobGVmdC0+ZGF0YSgpLm1heEhpZ2goKSA8IGludGVydmFsLmxvdygpKSkK KyAgICAgICAgICAgIHNlYXJjaEZvck92ZXJsYXBzRnJvbShsZWZ0LCBpbnRlcnZhbCwgcmVzKTsK KworICAgICAgICAvLyBDaGVjayBmb3Igb3ZlcmxhcCB3aXRoIGN1cnJlbnQgbm9kZS4KKyAgICAg ICAgaWYgKG5vZGUtPmRhdGEoKS5vdmVybGFwcyhpbnRlcnZhbCkpCisgICAgICAgICAgICByZXMu YXBwZW5kKG5vZGUtPmRhdGEoKSk7CisKKyAgICAgICAgLy8gU2VlIHdoZXRoZXIgd2UgbmVlZCB0 byB0cmF2ZXJzZSB0aGUgcmlnaHQgc3VidHJlZS4KKyAgICAgICAgLy8gVGhpcyBpcyBlcXVpdmFs ZW50IHRvOgorICAgICAgICAvLyBub2RlLT5kYXRhKCkubG93KCkgPD0gaW50ZXJ2YWwuaGlnaCgp CisgICAgICAgIGlmICghKGludGVydmFsLmhpZ2goKSA8IG5vZGUtPmRhdGEoKS5sb3coKSkpCisg ICAgICAgICAgICBzZWFyY2hGb3JPdmVybGFwc0Zyb20obm9kZS0+cmlnaHQoKSwgaW50ZXJ2YWws IHJlcyk7CisgICAgfQorCisgICAgdmlydHVhbCBib29sIHVwZGF0ZU5vZGUoSW50ZXJ2YWxOb2Rl KiBub2RlKQorICAgIHsKKyAgICAgICAgLy8gV291bGQgdXNlIGNvbnN0IFQmLCBidXQgbmVlZCB0 byByZWFzc2lnbiB0aGlzIHJlZmVyZW5jZSBpbiB0aGlzCisgICAgICAgIC8vIGZ1bmN0aW9uLgor ICAgICAgICBjb25zdCBUKiBjdXJNYXggPSAmbm9kZS0+ZGF0YSgpLmhpZ2goKTsKKyAgICAgICAg SW50ZXJ2YWxOb2RlKiBsZWZ0ID0gbm9kZS0+bGVmdCgpOworICAgICAgICBpZiAobGVmdCkKKyAg ICAgICAgICAgIGlmICgqY3VyTWF4IDwgbGVmdC0+ZGF0YSgpLm1heEhpZ2goKSkKKyAgICAgICAg ICAgICAgICBjdXJNYXggPSAmbGVmdC0+ZGF0YSgpLm1heEhpZ2goKTsKKyAgICAgICAgSW50ZXJ2 YWxOb2RlKiByaWdodCA9IG5vZGUtPnJpZ2h0KCk7CisgICAgICAgIGlmIChyaWdodCkKKyAgICAg ICAgICAgIGlmICgqY3VyTWF4IDwgcmlnaHQtPmRhdGEoKS5tYXhIaWdoKCkpCisgICAgICAgICAg ICAgICAgY3VyTWF4ID0gJnJpZ2h0LT5kYXRhKCkubWF4SGlnaCgpOworICAgICAgICAvLyBUaGlz IGlzIHBocmFzZWQgbGlrZSB0aGlzIHRvIGF2b2lkIG5lZWRpbmcgb3BlcmF0b3IhPSBvbiB0eXBl IFQuCisgICAgICAgIGlmICghKCpjdXJNYXggPT0gbm9kZS0+ZGF0YSgpLm1heEhpZ2goKSkpIHsK KyAgICAgICAgICAgIG5vZGUtPmRhdGEoKS5zZXRNYXhIaWdoKCpjdXJNYXgpOworICAgICAgICAg ICAgcmV0dXJuIHRydWU7CisgICAgICAgIH0KKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAgIH0K KworI2lmbmRlZiBOREVCVUcKKyAgICAvLyBSZXR1cm5zIHRydWUgaWYgdGhlIHRyZWUncyBpbnZh cmlhbnRzIGFyZSBwcmVzZXJ2ZWQuCisgICAgYm9vbCB2ZXJpZnlGcm9tTm9kZShJbnRlcnZhbE5v ZGUqIG5vZGUsIFQqIGN1cnJlbnRNYXhWYWx1ZSkKKyAgICB7CisgICAgICAgIFQgbGVmdE1heFZh bHVlLCByaWdodE1heFZhbHVlOworICAgICAgICBJbnRlcnZhbE5vZGUqIGxlZnQgPSBub2RlLT5s ZWZ0KCk7CisgICAgICAgIEludGVydmFsTm9kZSogcmlnaHQgPSBub2RlLT5yaWdodCgpOworICAg ICAgICBpZiAobGVmdCkKKyAgICAgICAgICAgIGlmICghdmVyaWZ5RnJvbU5vZGUobGVmdCwgJmxl ZnRNYXhWYWx1ZSkpCisgICAgICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworICAgICAgICBpZiAo cmlnaHQpCisgICAgICAgICAgICBpZiAoIXZlcmlmeUZyb21Ob2RlKHJpZ2h0LCAmcmlnaHRNYXhW YWx1ZSkpCisgICAgICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworICAgICAgICBpZiAoIWxlZnQg JiYgIXJpZ2h0KSB7CisgICAgICAgICAgICAvLyBCYXNlIGNhc2UuCisgICAgICAgICAgICBpZiAo Y3VycmVudE1heFZhbHVlKQorICAgICAgICAgICAgICAgICpjdXJyZW50TWF4VmFsdWUgPSBub2Rl LT5kYXRhKCkuaGlnaCgpOworICAgICAgICAgICAgcmV0dXJuIChub2RlLT5kYXRhKCkuaGlnaCgp ID09IG5vZGUtPmRhdGEoKS5tYXhIaWdoKCkpOworICAgICAgICB9CisgICAgICAgIC8vIEF2b2lk IGNvbXBhcmluZyB1bmluaXRpYWxpemVkIHZhbHVlcy4KKyAgICAgICAgVCBsb2NhbE1heFZhbHVl OworICAgICAgICBpZiAoIWxlZnQgfHwgIXJpZ2h0KSB7CisgICAgICAgICAgICBpZiAobGVmdCkK KyAgICAgICAgICAgICAgICBsb2NhbE1heFZhbHVlID0gbGVmdE1heFZhbHVlOworICAgICAgICAg ICAgZWxzZQorICAgICAgICAgICAgICAgIGxvY2FsTWF4VmFsdWUgPSByaWdodE1heFZhbHVlOwor ICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgIGxvY2FsTWF4VmFsdWUgPSAobGVmdE1heFZhbHVl IDwgcmlnaHRNYXhWYWx1ZSkgPyByaWdodE1heFZhbHVlIDogbGVmdE1heFZhbHVlOworICAgICAg ICBpZiAobG9jYWxNYXhWYWx1ZSA8IG5vZGUtPmRhdGEoKS5oaWdoKCkpCisgICAgICAgICAgICBs b2NhbE1heFZhbHVlID0gbm9kZS0+ZGF0YSgpLmhpZ2goKTsKKyAgICAgICAgaWYgKCEobG9jYWxN YXhWYWx1ZSA9PSBub2RlLT5kYXRhKCkubWF4SGlnaCgpKSkgeworICAgICAgICAgICAgc3RkOjpj ZXJyIDw8ICJWZXJpZmljYXRpb24gZmFpbGVkIGF0ICIgPDwgbm9kZSA8PCAiOiBsb2NhbE1heFZh bHVlPSIgPDwgbG9jYWxNYXhWYWx1ZQorICAgICAgICAgICAgICAgICAgICAgIDw8ICIgYW5kICIg PDwgbm9kZS0+ZGF0YSgpIDw8IHN0ZDo6ZW5kbDsKKyAgICAgICAgICAgIHJldHVybiBmYWxzZTsK KyAgICAgICAgfQorICAgICAgICBpZiAoY3VycmVudE1heFZhbHVlKQorICAgICAgICAgICAgKmN1 cnJlbnRNYXhWYWx1ZSA9IGxvY2FsTWF4VmFsdWU7CisgICAgICAgIHJldHVybiB0cnVlOworICAg IH0KKyNlbmRpZgorfTsKKworfSAvLyBuYW1lc3BhY2UgZ3B1Cit9IC8vIG5hbWVzcGFjZSBXZWJD b3JlCisKKyNlbmRpZiAvLyBncHVfSW50ZXJ2YWxUcmVlX2gKSW5kZXg6IFdlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvZ3B1L1JlZEJsYWNrVHJlZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvZ3B1L1JlZEJsYWNrVHJlZS5oCShyZXZpc2lvbiAwKQorKysgV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUvUmVkQmxhY2tUcmVlLmgJKHJldmlzaW9uIDApCkBAIC0w LDAgKzEsODA1IEBACisvKgorICogQ29weXJpZ2h0IDIwMTAsIEdvb2dsZSBJbmMuCisgKiBBbGwg cmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNl IGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUg cGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorICog bWV0OgorICoKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJl dGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRp b25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlv bnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5cmlnaHQg bm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyCisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3Zp ZGVkIHdpdGggdGhlCisgKiBkaXN0cmlidXRpb24uCisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1l IG9mIEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisgKiBjb250cmlidXRvcnMgbWF5 IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorICog dGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4K KyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVS UyBBTkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVE IFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJ RUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBB UlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENP UFlSSUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVD VCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNF UVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9D VVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAq IERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVT RUQgQU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFD VCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9S IE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElT IFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFN QUdFLgorICovCisKKy8vIEEgcmVkLWJsYWNrIHRyZWUsIHdoaWNoIGlzIGEgZm9ybSBvZiBhIGJh bGFuY2VkIGJpbmFyeSB0cmVlLiBJdAorLy8gc3VwcG9ydHMgZWZmaWNpZW50IGluc2VydGlvbiwg ZGVsZXRpb24gYW5kIHF1ZXJpZXMgb2YgY29tcGFyYWJsZQorLy8gZWxlbWVudHMuIFRoZSBzYW1l IGVsZW1lbnQgbWF5IGJlIGluc2VydGVkIG11bHRpcGxlIHRpbWVzLiBUaGUKKy8vIGFsZ29yaXRo bWljIGNvbXBsZXhpdHkgb2YgY29tbW9uIG9wZXJhdGlvbnMgaXM6CisvLworLy8gICBJbnNlcnRp b246IE8obGcobikpCisvLyAgIERlbGV0aW9uOiAgTyhsZyhuKSkKKy8vICAgUXVlcnlpbmc6ICBP KGxnKG4pKQorLy8KKy8vIFRoZSBkYXRhIHR5cGUgdGhhdCBpcyBzdG9yZWQgaW4gdGhpcyByZWQt YmxhY2sgdHJlZSBtdXN0IHN1cHBvcnQKKy8vIHRoZSBkZWZhdWx0IGNvbnN0cnVjdG9yLCB0aGUg Y29weSBjb25zdHJ1Y3RvciwgYW5kIHRoZSAiPCIgYW5kICI9PSIKKy8vIG9wZXJhdG9ycy4gSXQg bXVzdCBfbm90XyByZWx5IG9uIGhhdmluZyBpdHMgZGVzdHJ1Y3RvciBjYWxsZWQuIFRoaXMKKy8v IGltcGxlbWVudGF0aW9uIGludGVybmFsbHkgYWxsb2NhdGVzIHN0b3JhZ2UgaW4gbGFyZ2UgY2h1 bmtzIGFuZAorLy8gZG9lcyBub3QgY2FsbCB0aGUgZGVzdHJ1Y3RvciBvbiBlYWNoIG9iamVjdC4K Ky8vCisvLyBOb3RlIHRoYXQgd2hlbiBjb21wbGV4IHR5cGVzIGFyZSBzdG9yZWQgaW4gdGhpcyBy ZWQvYmxhY2sgdHJlZSwgaXQKKy8vIGlzIHBvc3NpYmxlIHRoYXQgc2luZ2xlIGludm9jYXRpb25z IG9mIHRoZSAiPCIgYW5kICI9PSIgb3BlcmF0b3JzCisvLyB3aWxsIGJlIGluc3VmZmljaWVudCB0 byBkZXNjcmliZSB0aGUgb3JkZXJpbmcgb2YgZWxlbWVudHMgaW4gdGhlCisvLyB0cmVlIGR1cmlu ZyBxdWVyaWVzLiBBcyBhIGNvbmNyZXRlIGV4YW1wbGUsIGNvbnNpZGVyIHRoZSBjYXNlIHdoZXJl CisvLyBpbnRlcnZhbHMgYXJlIHN0b3JlZCBpbiB0aGUgdHJlZSBzb3J0ZWQgYnkgbG93IGVuZHBv aW50LiBUaGUgIjwiCisvLyBvcGVyYXRvciBvbiB0aGUgSW50ZXJ2YWwgY2xhc3Mgb25seSBjb21w YXJlcyB0aGUgbG93IGVuZHBvaW50LCBidXQKKy8vIHRoZSAiPT0iIG9wZXJhdG9yIHRha2VzIGlu dG8gYWNjb3VudCB0aGUgaGlnaCBlbmRwb2ludCBhcyB3ZWxsLgorLy8gVGhpcyBtYWtlcyB0aGUg bmVjZXNzYXJ5IGxvZ2ljIGZvciBxdWVyeWluZyBhbmQgZGVsZXRpb24gc29tZXdoYXQKKy8vIG1v cmUgY29tcGxleC4gSW4gb3JkZXIgdG8gcHJvcGVybHkgaGFuZGxlIHN1Y2ggc2l0dWF0aW9ucywg dGhlCisvLyBwcm9wZXJ0eSAibmVlZHNGdWxsT3JkZXJpbmdDb21wYXJpc29ucyIgbXVzdCBiZSBz ZXQgdG8gdHJ1ZSBvbgorLy8gdGhlIHRyZWUuCisvLworLy8gVGhpcyByZWQtYmxhY2sgdHJlZSBp cyBkZXNpZ25lZCB0byBiZSBfYXVnbWVudGVkXzsgc3ViY2xhc3NlcyBjYW4KKy8vIGFkZCBhZGRp dGlvbmFsIGFuZCBzdW1tYXJ5IGluZm9ybWF0aW9uIHRvIGVhY2ggbm9kZSB0byBlZmZpY2llbnRs eQorLy8gc3RvcmUgYW5kIGluZGV4IG1vcmUgY29tcGxleCBkYXRhIHN0cnVjdHVyZXMuIEEgY29u Y3JldGUgZXhhbXBsZSBpcworLy8gdGhlIEludGVydmFsVHJlZSwgd2hpY2ggZXh0ZW5kcyBlYWNo IG5vZGUgd2l0aCBhIHN1bW1hcnkgc3RhdGlzdGljCisvLyB0byBlZmZpY2llbnRseSBzdG9yZSBv bmUtZGltZW5zaW9uYWwgaW50ZXJ2YWxzLgorLy8KKy8vIFRoZSBkZXNpZ24gb2YgdGhpcyByZWQt YmxhY2sgdHJlZSBjb21lcyBmcm9tIENvcm1lbiwgTGVpc2Vyc29uLAorLy8gYW5kIFJpdmVzdCwg X0ludHJvZHVjdGlvbiB0byBBbGdvcml0aG1zXywgTUlUIFByZXNzLCAxOTkwLgorCisjaWZuZGVm IGdwdV9SZWRCbGFja1RyZWVfaAorI2RlZmluZSBncHVfUmVkQmxhY2tUcmVlX2gKKworI2lmbmRl ZiBOREVCVUcKKyNpbmNsdWRlICJQbGF0Zm9ybVN0cmluZy5oIgorI2VuZGlmCisjaW5jbHVkZSAi Z3B1L0FyZW5hLmgiCisjaWZuZGVmIE5ERUJVRworI2luY2x1ZGUgPGlvc3RyZWFtPgorI2VuZGlm CisjaW5jbHVkZSA8d3RmL05vbmNvcHlhYmxlLmg+CisjaW5jbHVkZSA8d3RmL1JlZlB0ci5oPgor I2lmbmRlZiBOREVCVUcKKyNpbmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+CisjZW5kaWYKKwor bmFtZXNwYWNlIFdlYkNvcmUgeworbmFtZXNwYWNlIGdwdSB7CisKK3RlbXBsYXRlPGNsYXNzIFQ+ CitjbGFzcyBSZWRCbGFja1RyZWUgeworcHVibGljOgorICAgIC8vIFZpc2l0b3IgaW50ZXJmYWNl IGZvciB3YWxraW5nIGFsbCBvZiB0aGUgdHJlZSdzIGVsZW1lbnRzLgorICAgIGNsYXNzIFZpc2l0 b3IgeworICAgIHB1YmxpYzoKKyAgICAgICAgdmlydHVhbCB+VmlzaXRvcigpIHt9CisgICAgICAg IHZpcnR1YWwgdm9pZCBWaXNpdChjb25zdCBUJiBkYXRhKSA9IDA7CisgICAgfTsKKworICAgIC8v IENvbnN0cnVjdHMgYSBuZXcgcmVkLWJsYWNrIHRyZWUsIGFsbG9jYXRpbmcgdGVtcG9yYXJ5IG9i amVjdHMKKyAgICAvLyBmcm9tIGEgbmV3bHkgY29uc3RydWN0ZWQgQXJlbmEuCisgICAgUmVkQmxh Y2tUcmVlKCkKKyAgICAgICAgOiBtX2FyZW5hKEFyZW5hOjpjcmVhdGUoKSkKKyAgICAgICAgLCBt X3Jvb3QoMCkKKyAgICAgICAgLCBtX25lZWRzRnVsbE9yZGVyaW5nQ29tcGFyaXNvbnMoZmFsc2Up CisjaWZuZGVmIE5ERUJVRworICAgICAgICAsIG1fdmVyYm9zZURlYnVnZ2luZyhmYWxzZSkKKyNl bmRpZgorICAgIHsKKyAgICB9CisKKyAgICAvLyBDb25zdHJ1Y3RzIGEgbmV3IHJlZC1ibGFjayB0 cmVlLCBhbGxvY2F0aW5nIHRlbXBvcmFyeSBvYmplY3RzCisgICAgLy8gZnJvbSB0aGUgZ2l2ZW4g QXJlbmEuIFRoZSBBcmVuYSBpcyBub3QgZGVzdHJveWVkIHdoZW4gdGhpcyB0cmVlCisgICAgLy8g aXMuCisgICAgZXhwbGljaXQgUmVkQmxhY2tUcmVlKEFyZW5hKiBhcmVuYSkKKyAgICAgICAgOiBt X2FyZW5hKGFyZW5hKQorICAgICAgICAsIG1fcm9vdCgwKQorICAgICAgICAsIG1fbmVlZHNGdWxs T3JkZXJpbmdDb21wYXJpc29ucyhmYWxzZSkKKyNpZm5kZWYgTkRFQlVHCisgICAgICAgICwgbV92 ZXJib3NlRGVidWdnaW5nKGZhbHNlKQorI2VuZGlmCisgICAgeworICAgIH0KKworICAgIHZpcnR1 YWwgflJlZEJsYWNrVHJlZSgpCisgICAgeworICAgIH0KKworICAgIC8vIEluc2VydHMgYSBkYXR1 bSBpbnRvIHRoZSB0cmVlLgorICAgIHZvaWQgaW5zZXJ0KGNvbnN0IFQmIGRhdGEpCisgICAgewor ICAgICAgICBOb2RlKiBub2RlID0gbmV3IE5vZGUoZGF0YSk7CisgICAgICAgIGluc2VydE5vZGUo bm9kZSk7CisgICAgfQorCisgICAgLy8gUmVtb3ZlcyB0aGUgZ2l2ZW4gZGF0dW0gZnJvbSB0aGUg dHJlZS4gUmV0dXJucyB0cnVlIGlmIHRoZSBkYXR1bQorICAgIC8vIHdhcyBmb3VuZCBpbiB0aGUg dHJlZS4KKyAgICBib29sIHJlbW92ZShjb25zdCBUJiBkYXRhKQorICAgIHsKKyAgICAgICAgTm9k ZSogbm9kZSA9IHRyZWVTZWFyY2goZGF0YSk7CisgICAgICAgIGlmIChub2RlKSB7CisgICAgICAg ICAgICBkZWxldGVOb2RlKG5vZGUpOworICAgICAgICAgICAgcmV0dXJuIHRydWU7CisgICAgICAg IH0KKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAgIH0KKworICAgIC8vIFJldHVybnMgdHJ1ZSBp ZiB0aGUgdHJlZSBjb250YWlucyB0aGUgZ2l2ZW4gZGF0dW0uCisgICAgYm9vbCBjb250YWlucyhj b25zdCBUJiBkYXRhKQorICAgIHsKKyAgICAgICAgcmV0dXJuIHRyZWVTZWFyY2goZGF0YSk7Cisg ICAgfQorCisgICAgLy8gVmlzaXRzIHRoZSBub2RlcyBvZiB0aGlzIHRyZWUgaW4gb3JkZXIsIGNh bGxpbmcgdGhlIHZpc2l0b3Igb24KKyAgICAvLyBlYWNoIG9uZS4KKyAgICB2b2lkIHZpc2l0SW5v cmRlcihWaXNpdG9yKiB2aXNpdG9yKQorICAgIHsKKyAgICAgICAgaWYgKG1fcm9vdCkKKyAgICAg ICAgICAgIHZpc2l0SW5vcmRlckltcGwobV9yb290LCB2aXNpdG9yKTsKKyAgICB9CisKKyAgICAv LyBSZXR1cm5zIHRoZSBudW1iZXIgb2YgZWxlbWVudHMgaW4gdGhlIHRyZWUuCisgICAgaW50IG51 bUVsZW1lbnRzKCkKKyAgICB7CisgICAgICAgIENvdW50ZXIgY291bnRlcjsKKyAgICAgICAgdmlz aXRJbm9yZGVyKCZjb3VudGVyKTsKKyAgICAgICAgcmV0dXJuIGNvdW50ZXIuY291bnQoKTsKKyAg ICB9CisKKyAgICAvLyBTZXRzIHdoZXRoZXIgdGhpcyB0cmVlIHJlcXVpcmVzIGZ1bGwgb3JkZXJp bmcgY29tcGFyaXNvbnM7IHNlZQorICAgIC8vIHRoZSBjbGFzcyBkb2N1bWVudGF0aW9uIGZvciBh biBleHBsYW5hdGlvbiBvZiB0aGlzIHByb3BlcnR5LgorICAgIHZvaWQgc2V0TmVlZHNGdWxsT3Jk ZXJpbmdDb21wYXJpc29ucyhib29sIG5lZWRzRnVsbE9yZGVyaW5nQ29tcGFyaXNvbnMpCisgICAg eworICAgICAgICBtX25lZWRzRnVsbE9yZGVyaW5nQ29tcGFyaXNvbnMgPSBuZWVkc0Z1bGxPcmRl cmluZ0NvbXBhcmlzb25zOworICAgIH0KKworI2lmbmRlZiBOREVCVUcKKyAgICAvLyBSZXR1cm5z IHRydWUgaWYgdGhlIHRyZWUncyBpbnZhcmlhbnRzIGFyZSBwcmVzZXJ2ZWQuCisgICAgdmlydHVh bCBib29sIHZlcmlmeSgpCisgICAgeworICAgICAgICBpbnQgYmxhY2tDb3VudDsKKyAgICAgICAg cmV0dXJuIHZlcmlmeUZyb21Ob2RlKG1fcm9vdCwgJmJsYWNrQ291bnQpOworICAgIH0KKworICAg IC8vIER1bXBzIHRoZSB0cmVlJ3MgY29udGVudHMgdG8gdGhlIGxvZ2dpbmcgaW5mbyBzdHJlYW0g Zm9yCisgICAgLy8gZGVidWdnaW5nIHB1cnBvc2VzLgorICAgIHZvaWQgZHVtcCgpCisgICAgewor ICAgICAgICBkdW1wRnJvbU5vZGUobV9yb290LCAwKTsKKyAgICB9CisKKyAgICAvLyBUdXJucyBv biBvciBvZmYgdmVyYm9zZSBkZWJ1Z2dpbmcgb2YgdGhlIHRyZWUsIGNhdXNpbmcgbWFueQorICAg IC8vIG1lc3NhZ2VzIHRvIGJlIGxvZ2dlZCBkdXJpbmcgaW5zZXJ0aW9uIGFuZCBvdGhlciBvcGVy YXRpb25zIGluCisgICAgLy8gZGVidWcgbW9kZS4KKyAgICB2b2lkIHNldFZlcmJvc2VEZWJ1Z2dp bmcoYm9vbCBvbk9yT2ZmKQorICAgIHsKKyAgICAgICAgbV92ZXJib3NlRGVidWdnaW5nID0gb25P ck9mZjsKKyAgICB9CisjZW5kaWYKKworcHJvdGVjdGVkOgorICAgIGVudW0gQ29sb3IgeworICAg ICAgICBrUmVkID0gMSwKKyAgICAgICAga0JsYWNrCisgICAgfTsKKworICAgIC8vIFRoZSBiYXNl IE5vZGUgY2xhc3Mgd2hpY2ggaXMgc3RvcmVkIGluIHRoZSB0cmVlLiBOb2RlcyBhcmUgb25seQor ICAgIC8vIGFuIGludGVybmFsIGNvbmNlcHQ7IHVzZXJzIG9mIHRoZSB0cmVlIGRlYWwgb25seSB3 aXRoIHRoZSBkYXRhCisgICAgLy8gdGhleSBzdG9yZSBpbiBpdC4KKyAgICBjbGFzcyBOb2RlIDog cHVibGljIE5vbmNvcHlhYmxlIHsKKyAgICBwdWJsaWM6CisgICAgICAgIC8vIENvbnN0cnVjdG9y LiBOZXdseS1jcmVhdGVkIG5vZGVzIGFyZSBjb2xvcmVkIHJlZC4KKyAgICAgICAgZXhwbGljaXQg Tm9kZShjb25zdCBUJiBkYXRhKQorICAgICAgICAgICAgOiBtX2xlZnQoMCkKKyAgICAgICAgICAg ICwgbV9yaWdodCgwKQorICAgICAgICAgICAgLCBtX3BhcmVudCgwKQorICAgICAgICAgICAgLCBt X2NvbG9yKGtSZWQpCisgICAgICAgICAgICAsIG1fZGF0YShkYXRhKQorICAgICAgICB7CisgICAg ICAgIH0KKworICAgICAgICB2aXJ0dWFsIH5Ob2RlKCkKKyAgICAgICAgeworICAgICAgICB9CisK KyAgICAgICAgQ29sb3IgY29sb3IoKSBjb25zdAorICAgICAgICB7CisgICAgICAgICAgICByZXR1 cm4gbV9jb2xvcjsKKyAgICAgICAgfQorCisgICAgICAgIHZvaWQgc2V0Q29sb3IoQ29sb3IgY29s b3IpCisgICAgICAgIHsKKyAgICAgICAgICAgIG1fY29sb3IgPSBjb2xvcjsKKyAgICAgICAgfQor CisgICAgICAgIC8vIEZldGNoZXMgdGhlIHVzZXIgZGF0YS4KKyAgICAgICAgY29uc3QgVCYgZGF0 YSgpIGNvbnN0CisgICAgICAgIHsKKyAgICAgICAgICAgIHJldHVybiBtX2RhdGE7CisgICAgICAg IH0KKworICAgICAgICAvLyBDb3BpZXMgYWxsIHVzZXItbGV2ZWwgZmllbGRzIGZyb20gdGhlIHNv dXJjZSBub2RlLCBidXQgbm90CisgICAgICAgIC8vIGludGVybmFsIGZpZWxkcy4gRm9yIGV4YW1w bGUsIHRoZSBiYXNlIGltcGxlbWVudGF0aW9uIG9mIHRoaXMKKyAgICAgICAgLy8gbWV0aG9kIGNv cGllcyB0aGUgIm1fZGF0YSIgZmllbGQsIGJ1dCBub3QgdGhlIGNoaWxkIG9yIHBhcmVudAorICAg ICAgICAvLyBmaWVsZHMuIEFueSBhdWdtZW50YXRpb24gaW5mb3JtYXRpb24gYWxzbyBkb2VzIG5v dCBuZWVkIHRvIGJlCisgICAgICAgIC8vIGNvcGllZCwgYXMgaXQgd2lsbCBiZSByZWNvbXB1dGVk LiBTdWJjbGFzc2VzIG11c3QgY2FsbCB0aGUKKyAgICAgICAgLy8gc3VwZXJjbGFzcyBpbXBsZW1l bnRhdGlvbi4KKyAgICAgICAgdmlydHVhbCB2b2lkIGNvcHlGcm9tKE5vZGUqIHNyYykKKyAgICAg ICAgeworICAgICAgICAgICAgbV9kYXRhID0gc3JjLT5kYXRhKCk7CisgICAgICAgIH0KKworICAg ICAgICBOb2RlKiBsZWZ0KCkgY29uc3QKKyAgICAgICAgeworICAgICAgICAgICAgcmV0dXJuIG1f bGVmdDsKKyAgICAgICAgfQorCisgICAgICAgIHZvaWQgc2V0TGVmdChOb2RlKiBub2RlKQorICAg ICAgICB7CisgICAgICAgICAgICBtX2xlZnQgPSBub2RlOworICAgICAgICB9CisKKyAgICAgICAg Tm9kZSogcmlnaHQoKSBjb25zdAorICAgICAgICB7CisgICAgICAgICAgICByZXR1cm4gbV9yaWdo dDsKKyAgICAgICAgfQorCisgICAgICAgIHZvaWQgc2V0UmlnaHQoTm9kZSogbm9kZSkKKyAgICAg ICAgeworICAgICAgICAgICAgbV9yaWdodCA9IG5vZGU7CisgICAgICAgIH0KKworICAgICAgICBO b2RlKiBwYXJlbnQoKSBjb25zdAorICAgICAgICB7CisgICAgICAgICAgICByZXR1cm4gbV9wYXJl bnQ7CisgICAgICAgIH0KKworICAgICAgICB2b2lkIHNldFBhcmVudChOb2RlKiBub2RlKQorICAg ICAgICB7CisgICAgICAgICAgICBtX3BhcmVudCA9IG5vZGU7CisgICAgICAgIH0KKworICAgIHBy aXZhdGU6CisgICAgICAgIE5vZGUqIG1fbGVmdDsKKyAgICAgICAgTm9kZSogbV9yaWdodDsKKyAg ICAgICAgTm9kZSogbV9wYXJlbnQ7CisgICAgICAgIENvbG9yIG1fY29sb3I7CisgICAgICAgIFQg bV9kYXRhOworICAgIH07CisKKyAgICAvLyBSZXR1cm5zIHRoZSByb290IG9mIHRoZSB0cmVlLCB3 aGljaCBpcyBuZWVkZWQgYnkgc29tZSBzdWJjbGFzc2VzLgorICAgIE5vZGUqIHJvb3QoKSBjb25z dAorICAgIHsKKyAgICAgICAgcmV0dXJuIG1fcm9vdDsKKyAgICB9CisKK3ByaXZhdGU6CisgICAg Ly8gVGhpcyB2aXJ0dWFsIG1ldGhvZCBpcyB0aGUgaG9vayB0aGF0IHN1YmNsYXNzZXMgc2hvdWxk IHVzZSB3aGVuCisgICAgLy8gYXVnbWVudGluZyB0aGUgcmVkLWJsYWNrIHRyZWUgd2l0aCBhZGRp dGlvbmFsIHBlci1ub2RlIHN1bW1hcnkKKyAgICAvLyBpbmZvcm1hdGlvbi4gRm9yIGV4YW1wbGUs IGluIHRoZSBjYXNlIG9mIGFuIGludGVydmFsIHRyZWUsIHRoaXMKKyAgICAvLyBpcyB1c2VkIHRv IGNvbXB1dGUgdGhlIG1heGltdW0gZW5kcG9pbnQgb2YgdGhlIHN1YnRyZWUgYmVsb3cgdGhlCisg ICAgLy8gZ2l2ZW4gbm9kZSBiYXNlZCBvbiB0aGUgdmFsdWVzIGluIHRoZSBsZWZ0IGFuZCByaWdo dCBjaGlsZHJlbi4gSXQKKyAgICAvLyBpcyBndWFyYW50ZWVkIHRoYXQgdGhpcyB3aWxsIGJlIGNh bGxlZCBpbiB0aGUgY29ycmVjdCBvcmRlciB0bworICAgIC8vIHByb3Blcmx5IHVwZGF0ZSBzdWNo IHN1bW1hcnkgaW5mb3JtYXRpb24gYmFzZWQgb25seSBvbiB0aGUgdmFsdWVzCisgICAgLy8gaW4g dGhlIGxlZnQgYW5kIHJpZ2h0IGNoaWxkcmVuLiBUaGlzIG1ldGhvZCBzaG91bGQgcmV0dXJuIHRy dWUgaWYKKyAgICAvLyB0aGUgbm9kZSdzIHN1bW1hcnkgaW5mb3JtYXRpb24gY2hhbmdlZC4KKyAg ICB2aXJ0dWFsIGJvb2wgdXBkYXRlTm9kZShOb2RlKiBub2RlKQorICAgIHsKKyAgICAgICAgcmV0 dXJuIGZhbHNlOworICAgIH0KKworICAgIC8vLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICAgIC8vIEdlbmVyaWMg YmluYXJ5IHNlYXJjaCB0cmVlIG9wZXJhdGlvbnMKKyAgICAvLworCisgICAgLy8gU2VhcmNoZXMg dGhlIHRyZWUgZm9yIHRoZSBnaXZlbiBkYXR1bS4KKyAgICBOb2RlKiB0cmVlU2VhcmNoKGNvbnN0 IFQmIGRhdGEpCisgICAgeworICAgICAgICBpZiAobV9uZWVkc0Z1bGxPcmRlcmluZ0NvbXBhcmlz b25zKQorICAgICAgICAgICAgcmV0dXJuIHRyZWVTZWFyY2hGdWxsQ29tcGFyaXNvbnMobV9yb290 LCBkYXRhKTsKKworICAgICAgICByZXR1cm4gdHJlZVNlYXJjaE5vcm1hbChtX3Jvb3QsIGRhdGEp OworICAgIH0KKworICAgIC8vIFNlYXJjaGVzIHRoZSB0cmVlIHVzaW5nIHRoZSBub3JtYWwgY29t cGFyaXNvbiBvcGVyYXRpb25zLAorICAgIC8vIHN1aXRhYmxlIGZvciBzaW1wbGUgZGF0YSB0eXBl cyBzdWNoIGFzIG51bWJlcnMuCisgICAgTm9kZSogdHJlZVNlYXJjaE5vcm1hbChOb2RlKiBjdXJy ZW50LCBjb25zdCBUJiBkYXRhKQorICAgIHsKKyAgICAgICAgd2hpbGUgKGN1cnJlbnQpIHsKKyAg ICAgICAgICAgIGlmIChjdXJyZW50LT5kYXRhKCkgPT0gZGF0YSkKKyAgICAgICAgICAgICAgICBy ZXR1cm4gY3VycmVudDsKKyAgICAgICAgICAgIGlmIChkYXRhIDwgY3VycmVudC0+ZGF0YSgpKQor ICAgICAgICAgICAgICAgIGN1cnJlbnQgPSBjdXJyZW50LT5sZWZ0KCk7CisgICAgICAgICAgICBl bHNlCisgICAgICAgICAgICAgICAgY3VycmVudCA9IGN1cnJlbnQtPnJpZ2h0KCk7CisgICAgICAg IH0KKyAgICAgICAgcmV0dXJuIDA7CisgICAgfQorCisgICAgLy8gU2VhcmNoZXMgdGhlIHRyZWUg dXNpbmcgbXVsdGlwbGUgY29tcGFyaXNvbiBvcGVyYXRpb25zLCByZXF1aXJlZAorICAgIC8vIGZv ciBkYXRhIHR5cGVzIHdpdGggbW9yZSBjb21wbGV4IGJlaGF2aW9yIHN1Y2ggYXMgaW50ZXJ2YWxz LgorICAgIE5vZGUqIHRyZWVTZWFyY2hGdWxsQ29tcGFyaXNvbnMoTm9kZSogY3VycmVudCwgY29u c3QgVCYgZGF0YSkKKyAgICB7CisgICAgICAgIGlmICghY3VycmVudCkKKyAgICAgICAgICAgIHJl dHVybiAwOworICAgICAgICBpZiAoZGF0YSA8IGN1cnJlbnQtPmRhdGEoKSkKKyAgICAgICAgICAg IHJldHVybiB0cmVlU2VhcmNoRnVsbENvbXBhcmlzb25zKGN1cnJlbnQtPmxlZnQoKSwgZGF0YSk7 CisgICAgICAgIGlmIChjdXJyZW50LT5kYXRhKCkgPCBkYXRhKQorICAgICAgICAgICAgcmV0dXJu IHRyZWVTZWFyY2hGdWxsQ29tcGFyaXNvbnMoY3VycmVudC0+cmlnaHQoKSwgZGF0YSk7CisgICAg ICAgIGlmIChkYXRhID09IGN1cnJlbnQtPmRhdGEoKSkKKyAgICAgICAgICAgIHJldHVybiBjdXJy ZW50OworCisgICAgICAgIC8vIFdlIG1heSBuZWVkIHRvIHRyYXZlcnNlIGJvdGggdGhlIGxlZnQg YW5kIHJpZ2h0IHN1YnRyZWVzLgorICAgICAgICBOb2RlKiByZXN1bHQgPSB0cmVlU2VhcmNoRnVs bENvbXBhcmlzb25zKGN1cnJlbnQtPmxlZnQoKSwgZGF0YSk7CisgICAgICAgIGlmICghcmVzdWx0 KQorICAgICAgICAgICAgcmVzdWx0ID0gdHJlZVNlYXJjaEZ1bGxDb21wYXJpc29ucyhjdXJyZW50 LT5yaWdodCgpLCBkYXRhKTsKKyAgICAgICAgcmV0dXJuIHJlc3VsdDsKKyAgICB9CisKKyAgICAv LyBJbnNlcnRzIHRoZSBnaXZlbiBub2RlIGludG8gdGhlIHRyZWUuCisgICAgdm9pZCB0cmVlSW5z ZXJ0KE5vZGUqIHopCisgICAgeworICAgICAgICBOb2RlKiB5ID0gMDsKKyAgICAgICAgTm9kZSog eCA9IG1fcm9vdDsKKyAgICAgICAgd2hpbGUgKHgpIHsKKyAgICAgICAgICAgIHkgPSB4OworICAg ICAgICAgICAgaWYgKHotPmRhdGEoKSA8IHgtPmRhdGEoKSkKKyAgICAgICAgICAgICAgICB4ID0g eC0+bGVmdCgpOworICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgIHggPSB4LT5yaWdo dCgpOworICAgICAgICB9CisgICAgICAgIHotPnNldFBhcmVudCh5KTsKKyAgICAgICAgaWYgKCF5 KQorICAgICAgICAgICAgbV9yb290ID0gejsKKyAgICAgICAgZWxzZQorICAgICAgICAgICAgaWYg KHotPmRhdGEoKSA8IHktPmRhdGEoKSkKKyAgICAgICAgICAgICAgICB5LT5zZXRMZWZ0KHopOwor ICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgIHktPnNldFJpZ2h0KHopOworICAgIH0K KworICAgIC8vIEZpbmRzIHRoZSBub2RlIGZvbGxvd2luZyB0aGUgZ2l2ZW4gb25lIGluIHNlcXVl bnRpYWwgb3JkZXJpbmcgb2YKKyAgICAvLyB0aGVpciBkYXRhLCBvciBudWxsIGlmIG5vbmUgZXhp c3RzLgorICAgIE5vZGUqIHRyZWVTdWNjZXNzb3IoTm9kZSogeCkKKyAgICB7CisgICAgICAgIGlm ICh4LT5yaWdodCgpKQorICAgICAgICAgICAgcmV0dXJuIHRyZWVNaW5pbXVtKHgtPnJpZ2h0KCkp OworICAgICAgICBOb2RlKiB5ID0geC0+cGFyZW50KCk7CisgICAgICAgIHdoaWxlICh5ICYmIHgg PT0geS0+cmlnaHQoKSkgeworICAgICAgICAgICAgeCA9IHk7CisgICAgICAgICAgICB5ID0geS0+ cGFyZW50KCk7CisgICAgICAgIH0KKyAgICAgICAgcmV0dXJuIHk7CisgICAgfQorCisgICAgLy8g RmluZHMgdGhlIG1pbmltdW0gZWxlbWVudCBpbiB0aGUgc3ViLXRyZWUgcm9vdGVkIGF0IHRoZSBn aXZlbgorICAgIC8vIG5vZGUuCisgICAgTm9kZSogdHJlZU1pbmltdW0oTm9kZSogeCkKKyAgICB7 CisgICAgICAgIHdoaWxlICh4LT5sZWZ0KCkpCisgICAgICAgICAgICB4ID0geC0+bGVmdCgpOwor ICAgICAgICByZXR1cm4geDsKKyAgICB9CisKKyAgICAvLyBIZWxwZXIgZm9yIG1haW50YWluaW5n IHRoZSBhdWdtZW50ZWQgcmVkLWJsYWNrIHRyZWUuCisgICAgdm9pZCBwcm9wYWdhdGVVcGRhdGVz KE5vZGUqIHN0YXJ0KQorICAgIHsKKyAgICAgICAgYm9vbCBzaG91bGRDb250aW51ZSA9IHRydWU7 CisgICAgICAgIHdoaWxlIChzdGFydCAmJiBzaG91bGRDb250aW51ZSkgeworICAgICAgICAgICAg c2hvdWxkQ29udGludWUgPSB1cGRhdGVOb2RlKHN0YXJ0KTsKKyAgICAgICAgICAgIHN0YXJ0ID0g c3RhcnQtPnBhcmVudCgpOworICAgICAgICB9CisgICAgfQorCisgICAgLy8tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t CisgICAgLy8gUmVkLUJsYWNrIHRyZWUgb3BlcmF0aW9ucworICAgIC8vCisKKyAgICAvLyBMZWZ0 LXJvdGF0ZXMgdGhlIHN1YnRyZWUgcm9vdGVkIGF0IHguCisgICAgdm9pZCBsZWZ0Um90YXRlKE5v ZGUqIHgpCisgICAgeworICAgICAgICAvLyBTZXQgeS4KKyAgICAgICAgTm9kZSogeSA9IHgtPnJp Z2h0KCk7CisgICAgICAgIC8vIFR1cm4geSdzIGxlZnQgc3VidHJlZSBpbnRvIHgncyByaWdodCBz dWJ0cmVlLgorICAgICAgICB4LT5zZXRSaWdodCh5LT5sZWZ0KCkpOworICAgICAgICBpZiAoeS0+ bGVmdCgpKQorICAgICAgICAgICAgeS0+bGVmdCgpLT5zZXRQYXJlbnQoeCk7CisgICAgICAgIC8v IExpbmsgeCdzIHBhcmVudCB0byB5LgorICAgICAgICB5LT5zZXRQYXJlbnQoeC0+cGFyZW50KCkp OworICAgICAgICBpZiAoIXgtPnBhcmVudCgpKQorICAgICAgICAgICAgbV9yb290ID0geTsKKyAg ICAgICAgZWxzZQorICAgICAgICAgICAgaWYgKHggPT0geC0+cGFyZW50KCktPmxlZnQoKSkKKyAg ICAgICAgICAgICAgICB4LT5wYXJlbnQoKS0+c2V0TGVmdCh5KTsKKyAgICAgICAgICAgIGVsc2UK KyAgICAgICAgICAgICAgICB4LT5wYXJlbnQoKS0+c2V0UmlnaHQoeSk7CisgICAgICAgIC8vIFB1 dCB4IG9uIHkncyBsZWZ0LgorICAgICAgICB5LT5zZXRMZWZ0KHgpOworICAgICAgICB4LT5zZXRQ YXJlbnQoeSk7CisgICAgICAgIC8vIFVwZGF0ZSBub2RlcyBsb3dlc3QgdG8gaGlnaGVzdC4KKyAg ICAgICAgdXBkYXRlTm9kZSh4KTsKKyAgICAgICAgdXBkYXRlTm9kZSh5KTsKKyAgICB9CisKKyAg ICAvLyBSaWdodC1yb3RhdGVzIHRoZSBzdWJ0cmVlIHJvb3RlZCBhdCB5LgorICAgIHZvaWQgcmln aHRSb3RhdGUoTm9kZSogeSkKKyAgICB7CisgICAgICAgIC8vIFNldCB4LgorICAgICAgICBOb2Rl KiB4ID0geS0+bGVmdCgpOworICAgICAgICAvLyBUdXJuIHgncyByaWdodCBzdWJ0cmVlIGludG8g eSdzIGxlZnQgc3VidHJlZS4KKyAgICAgICAgeS0+c2V0TGVmdCh4LT5yaWdodCgpKTsKKyAgICAg ICAgaWYgKHgtPnJpZ2h0KCkpCisgICAgICAgICAgICB4LT5yaWdodCgpLT5zZXRQYXJlbnQoeSk7 CisgICAgICAgIC8vIExpbmsgeSdzIHBhcmVudCB0byB4LgorICAgICAgICB4LT5zZXRQYXJlbnQo eS0+cGFyZW50KCkpOworICAgICAgICBpZiAoIXktPnBhcmVudCgpKQorICAgICAgICAgICAgbV9y b290ID0geDsKKyAgICAgICAgZWxzZQorICAgICAgICAgICAgaWYgKHkgPT0geS0+cGFyZW50KCkt PmxlZnQoKSkKKyAgICAgICAgICAgICAgICB5LT5wYXJlbnQoKS0+c2V0TGVmdCh4KTsKKyAgICAg ICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICB5LT5wYXJlbnQoKS0+c2V0UmlnaHQoeCk7Cisg ICAgICAgIC8vIFB1dCB5IG9uIHgncyByaWdodC4KKyAgICAgICAgeC0+c2V0UmlnaHQoeSk7Cisg ICAgICAgIHktPnNldFBhcmVudCh4KTsKKyAgICAgICAgLy8gVXBkYXRlIG5vZGVzIGxvd2VzdCB0 byBoaWdoZXN0LgorICAgICAgICB1cGRhdGVOb2RlKHkpOworICAgICAgICB1cGRhdGVOb2RlKHgp OworICAgIH0KKworICAgIC8vIEluc2VydHMgdGhlIGdpdmVuIG5vZGUgaW50byB0aGUgdHJlZS4K KyAgICB2b2lkIGluc2VydE5vZGUoTm9kZSogeCkKKyAgICB7CisgICAgICAgIHRyZWVJbnNlcnQo eCk7CisgICAgICAgIHgtPnNldENvbG9yKGtSZWQpOworICAgICAgICB1cGRhdGVOb2RlKHgpOwor CisjaWZuZGVmIE5ERUJVRworICAgICAgICBpZiAobV92ZXJib3NlRGVidWdnaW5nKQorICAgICAg ICAgICAgc3RkOjpjZXJyIDw8ICIgIFJlZEJsYWNrVHJlZTo6SW5zZXJ0Tm9kZSIgPDwgc3RkOjpl bmRsOworI2VuZGlmCisKKyAgICAgICAgLy8gVGhlIG5vZGUgZnJvbSB3aGljaCB0byBzdGFydCBw cm9wYWdhdGluZyB1cGRhdGVzIHVwd2FyZHMuCisgICAgICAgIE5vZGUqIHVwZGF0ZVN0YXJ0ID0g eC0+cGFyZW50KCk7CisKKyAgICAgICAgd2hpbGUgKHggIT0gbV9yb290ICYmIHgtPnBhcmVudCgp LT5jb2xvcigpID09IGtSZWQpIHsKKyAgICAgICAgICAgIGlmICh4LT5wYXJlbnQoKSA9PSB4LT5w YXJlbnQoKS0+cGFyZW50KCktPmxlZnQoKSkgeworICAgICAgICAgICAgICAgIE5vZGUqIHkgPSB4 LT5wYXJlbnQoKS0+cGFyZW50KCktPnJpZ2h0KCk7CisgICAgICAgICAgICAgICAgaWYgKHkgJiYg eS0+Y29sb3IoKSA9PSBrUmVkKSB7CisgICAgICAgICAgICAgICAgICAgIC8vIENhc2UgMQorI2lm bmRlZiBOREVCVUcKKyAgICAgICAgICAgICAgICAgICAgaWYgKG1fdmVyYm9zZURlYnVnZ2luZykK KyAgICAgICAgICAgICAgICAgICAgICAgIHN0ZDo6Y2VyciA8PCAiICBDYXNlIDEvMSIgPDwgc3Rk OjplbmRsOworI2VuZGlmCisgICAgICAgICAgICAgICAgICAgIHgtPnBhcmVudCgpLT5zZXRDb2xv cihrQmxhY2spOworICAgICAgICAgICAgICAgICAgICB5LT5zZXRDb2xvcihrQmxhY2spOworICAg ICAgICAgICAgICAgICAgICB4LT5wYXJlbnQoKS0+cGFyZW50KCktPnNldENvbG9yKGtSZWQpOwor ICAgICAgICAgICAgICAgICAgICB1cGRhdGVOb2RlKHgtPnBhcmVudCgpKTsKKyAgICAgICAgICAg ICAgICAgICAgeCA9IHgtPnBhcmVudCgpLT5wYXJlbnQoKTsKKyAgICAgICAgICAgICAgICAgICAg dXBkYXRlTm9kZSh4KTsKKyAgICAgICAgICAgICAgICAgICAgdXBkYXRlU3RhcnQgPSB4LT5wYXJl bnQoKTsKKyAgICAgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgICAgICBpZiAo eCA9PSB4LT5wYXJlbnQoKS0+cmlnaHQoKSkgeworI2lmbmRlZiBOREVCVUcKKyAgICAgICAgICAg ICAgICAgICAgICAgIGlmIChtX3ZlcmJvc2VEZWJ1Z2dpbmcpCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgc3RkOjpjZXJyIDw8ICIgIENhc2UgMS8yIiA8PCBzdGQ6OmVuZGw7CisjZW5kaWYK KyAgICAgICAgICAgICAgICAgICAgICAgIC8vIENhc2UgMgorICAgICAgICAgICAgICAgICAgICAg ICAgeCA9IHgtPnBhcmVudCgpOworICAgICAgICAgICAgICAgICAgICAgICAgbGVmdFJvdGF0ZSh4 KTsKKyAgICAgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgICAgICAvLyBDYXNlIDMK KyNpZm5kZWYgTkRFQlVHCisgICAgICAgICAgICAgICAgICAgICAgICBpZiAobV92ZXJib3NlRGVi dWdnaW5nKQorICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN0ZDo6Y2VyciA8PCAiICBDYXNl IDEvMyIgPDwgc3RkOjplbmRsOworI2VuZGlmCisgICAgICAgICAgICAgICAgICAgIHgtPnBhcmVu dCgpLT5zZXRDb2xvcihrQmxhY2spOworICAgICAgICAgICAgICAgICAgICB4LT5wYXJlbnQoKS0+ cGFyZW50KCktPnNldENvbG9yKGtSZWQpOworICAgICAgICAgICAgICAgICAgICByaWdodFJvdGF0 ZSh4LT5wYXJlbnQoKS0+cGFyZW50KCkpOworICAgICAgICAgICAgICAgICAgICB1cGRhdGVTdGFy dCA9IHgtPnBhcmVudCgpLT5wYXJlbnQoKTsKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAg ICB9IGVsc2UgeworICAgICAgICAgICAgICAgIC8vIFNhbWUgYXMgInRoZW4iIGNsYXVzZSB3aXRo ICJyaWdodCIgYW5kICJsZWZ0IiBleGNoYW5nZWQuCisgICAgICAgICAgICAgICAgTm9kZSogeSA9 IHgtPnBhcmVudCgpLT5wYXJlbnQoKS0+bGVmdCgpOworICAgICAgICAgICAgICAgIGlmICh5ICYm IHktPmNvbG9yKCkgPT0ga1JlZCkgeworICAgICAgICAgICAgICAgICAgICAvLyBDYXNlIDEKKyNp Zm5kZWYgTkRFQlVHCisgICAgICAgICAgICAgICAgICAgICAgICBpZiAobV92ZXJib3NlRGVidWdn aW5nKQorICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN0ZDo6Y2VyciA8PCAiICBDYXNlIDIv MSIgPDwgc3RkOjplbmRsOworI2VuZGlmCisgICAgICAgICAgICAgICAgICAgIHgtPnBhcmVudCgp LT5zZXRDb2xvcihrQmxhY2spOworICAgICAgICAgICAgICAgICAgICB5LT5zZXRDb2xvcihrQmxh Y2spOworICAgICAgICAgICAgICAgICAgICB4LT5wYXJlbnQoKS0+cGFyZW50KCktPnNldENvbG9y KGtSZWQpOworICAgICAgICAgICAgICAgICAgICB1cGRhdGVOb2RlKHgtPnBhcmVudCgpKTsKKyAg ICAgICAgICAgICAgICAgICAgeCA9IHgtPnBhcmVudCgpLT5wYXJlbnQoKTsKKyAgICAgICAgICAg ICAgICAgICAgdXBkYXRlTm9kZSh4KTsKKyAgICAgICAgICAgICAgICAgICAgdXBkYXRlU3RhcnQg PSB4LT5wYXJlbnQoKTsKKyAgICAgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAg ICAgICBpZiAoeCA9PSB4LT5wYXJlbnQoKS0+bGVmdCgpKSB7CisgICAgICAgICAgICAgICAgICAg ICAgICAvLyBDYXNlIDIKKyNpZm5kZWYgTkRFQlVHCisgICAgICAgICAgICAgICAgICAgICAgICBp ZiAobV92ZXJib3NlRGVidWdnaW5nKQorICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN0ZDo6 Y2VyciAgPDwgIiAgQ2FzZSAyLzIiIDw8IHN0ZDo6ZW5kbDsKKyNlbmRpZgorICAgICAgICAgICAg ICAgICAgICAgICAgeCA9IHgtPnBhcmVudCgpOworICAgICAgICAgICAgICAgICAgICAgICAgcmln aHRSb3RhdGUoeCk7CisgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICAgICAg Ly8gQ2FzZSAzCisjaWZuZGVmIE5ERUJVRworICAgICAgICAgICAgICAgICAgICAgICAgaWYgKG1f dmVyYm9zZURlYnVnZ2luZykKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBzdGQ6OmNlcnIg PDwgIiAgQ2FzZSAyLzMiIDw8IHN0ZDo6ZW5kbDsKKyNlbmRpZgorICAgICAgICAgICAgICAgICAg ICB4LT5wYXJlbnQoKS0+c2V0Q29sb3Ioa0JsYWNrKTsKKyAgICAgICAgICAgICAgICAgICAgeC0+ cGFyZW50KCktPnBhcmVudCgpLT5zZXRDb2xvcihrUmVkKTsKKyAgICAgICAgICAgICAgICAgICAg bGVmdFJvdGF0ZSh4LT5wYXJlbnQoKS0+cGFyZW50KCkpOworICAgICAgICAgICAgICAgICAgICB1 cGRhdGVTdGFydCA9IHgtPnBhcmVudCgpLT5wYXJlbnQoKTsKKyAgICAgICAgICAgICAgICB9Cisg ICAgICAgICAgICB9CisgICAgICAgIH0KKworICAgICAgICBwcm9wYWdhdGVVcGRhdGVzKHVwZGF0 ZVN0YXJ0KTsKKworICAgICAgICBtX3Jvb3QtPnNldENvbG9yKGtCbGFjayk7CisgICAgfQorCisg ICAgLy8gUmVzdG9yZXMgdGhlIHJlZC1ibGFjayBwcm9wZXJ0eSB0byB0aGUgdHJlZSBhZnRlciBz cGxpY2luZyBvdXQKKyAgICAvLyBhIG5vZGUuIE5vdGUgdGhhdCB4IG1heSBiZSBudWxsLCB3aGlj aCBpcyB3aHkgeFBhcmVudCBtdXN0IGJlCisgICAgLy8gc3VwcGxpZWQuCisgICAgdm9pZCBkZWxl dGVGaXh1cChOb2RlKiB4LCBOb2RlKiB4UGFyZW50KQorICAgIHsKKyAgICAgICAgd2hpbGUgKHgg IT0gbV9yb290ICYmICgheCB8fCB4LT5jb2xvcigpID09IGtCbGFjaykpIHsKKyAgICAgICAgICAg IGlmICh4ID09IHhQYXJlbnQtPmxlZnQoKSkgeworICAgICAgICAgICAgICAgIC8vIE5vdGU6IHRo ZSB0ZXh0IHBvaW50cyBvdXQgdGhhdCB3IGNhbiBub3QgYmUgbnVsbC4KKyAgICAgICAgICAgICAg ICAvLyBUaGUgcmVhc29uIGlzIG5vdCBvYnZpb3VzIGZyb20gc2ltcGx5IGxvb2tpbmcgYXQKKyAg ICAgICAgICAgICAgICAvLyB0aGUgY29kZTsgaXQgY29tZXMgYWJvdXQgZnJvbSB0aGUgcHJvcGVy dGllcyBvZiB0aGUKKyAgICAgICAgICAgICAgICAvLyByZWQtYmxhY2sgdHJlZS4KKyAgICAgICAg ICAgICAgICBOb2RlKiB3ID0geFBhcmVudC0+cmlnaHQoKTsKKyAgICAgICAgICAgICAgICBBU1NF UlQodyk7IC8vIHgncyBzaWJsaW5nIHNob3VsZCBub3QgYmUgbnVsbC4KKyAgICAgICAgICAgICAg ICBpZiAody0+Y29sb3IoKSA9PSBrUmVkKSB7CisgICAgICAgICAgICAgICAgICAgIC8vIENhc2Ug MQorICAgICAgICAgICAgICAgICAgICB3LT5zZXRDb2xvcihrQmxhY2spOworICAgICAgICAgICAg ICAgICAgICB4UGFyZW50LT5zZXRDb2xvcihrUmVkKTsKKyAgICAgICAgICAgICAgICAgICAgbGVm dFJvdGF0ZSh4UGFyZW50KTsKKyAgICAgICAgICAgICAgICAgICAgdyA9IHhQYXJlbnQtPnJpZ2h0 KCk7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgIGlmICgoIXctPmxlZnQoKSB8 fCB3LT5sZWZ0KCktPmNvbG9yKCkgPT0ga0JsYWNrKQorICAgICAgICAgICAgICAgICAgICAmJiAo IXctPnJpZ2h0KCkgfHwgdy0+cmlnaHQoKS0+Y29sb3IoKSA9PSBrQmxhY2spKSB7CisgICAgICAg ICAgICAgICAgICAgIC8vIENhc2UgMgorICAgICAgICAgICAgICAgICAgICB3LT5zZXRDb2xvcihr UmVkKTsKKyAgICAgICAgICAgICAgICAgICAgeCA9IHhQYXJlbnQ7CisgICAgICAgICAgICAgICAg ICAgIHhQYXJlbnQgPSB4LT5wYXJlbnQoKTsKKyAgICAgICAgICAgICAgICB9IGVsc2UgeworICAg ICAgICAgICAgICAgICAgICBpZiAoIXctPnJpZ2h0KCkgfHwgdy0+cmlnaHQoKS0+Y29sb3IoKSA9 PSBrQmxhY2spIHsKKyAgICAgICAgICAgICAgICAgICAgICAgIC8vIENhc2UgMworICAgICAgICAg ICAgICAgICAgICAgICAgdy0+bGVmdCgpLT5zZXRDb2xvcihrQmxhY2spOworICAgICAgICAgICAg ICAgICAgICAgICAgdy0+c2V0Q29sb3Ioa1JlZCk7CisgICAgICAgICAgICAgICAgICAgICAgICBy aWdodFJvdGF0ZSh3KTsKKyAgICAgICAgICAgICAgICAgICAgICAgIHcgPSB4UGFyZW50LT5yaWdo dCgpOworICAgICAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgICAgIC8vIENhc2Ug NAorICAgICAgICAgICAgICAgICAgICB3LT5zZXRDb2xvcih4UGFyZW50LT5jb2xvcigpKTsKKyAg ICAgICAgICAgICAgICAgICAgeFBhcmVudC0+c2V0Q29sb3Ioa0JsYWNrKTsKKyAgICAgICAgICAg ICAgICAgICAgaWYgKHctPnJpZ2h0KCkpCisgICAgICAgICAgICAgICAgICAgICAgICB3LT5yaWdo dCgpLT5zZXRDb2xvcihrQmxhY2spOworICAgICAgICAgICAgICAgICAgICBsZWZ0Um90YXRlKHhQ YXJlbnQpOworICAgICAgICAgICAgICAgICAgICB4ID0gbV9yb290OworICAgICAgICAgICAgICAg ICAgICB4UGFyZW50ID0geC0+cGFyZW50KCk7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAg ICAgfSBlbHNlIHsKKyAgICAgICAgICAgICAgICAvLyBTYW1lIGFzICJ0aGVuIiBjbGF1c2Ugd2l0 aCAicmlnaHQiIGFuZCAibGVmdCIKKyAgICAgICAgICAgICAgICAvLyBleGNoYW5nZWQuCisKKyAg ICAgICAgICAgICAgICAvLyBOb3RlOiB0aGUgdGV4dCBwb2ludHMgb3V0IHRoYXQgdyBjYW4gbm90 IGJlIG51bGwuCisgICAgICAgICAgICAgICAgLy8gVGhlIHJlYXNvbiBpcyBub3Qgb2J2aW91cyBm cm9tIHNpbXBseSBsb29raW5nIGF0CisgICAgICAgICAgICAgICAgLy8gdGhlIGNvZGU7IGl0IGNv bWVzIGFib3V0IGZyb20gdGhlIHByb3BlcnRpZXMgb2YgdGhlCisgICAgICAgICAgICAgICAgLy8g cmVkLWJsYWNrIHRyZWUuCisgICAgICAgICAgICAgICAgTm9kZSogdyA9IHhQYXJlbnQtPmxlZnQo KTsKKyAgICAgICAgICAgICAgICBBU1NFUlQodyk7IC8vIHgncyBzaWJsaW5nIHNob3VsZCBub3Qg YmUgbnVsbC4KKyAgICAgICAgICAgICAgICBpZiAody0+Y29sb3IoKSA9PSBrUmVkKSB7CisgICAg ICAgICAgICAgICAgICAgIC8vIENhc2UgMQorICAgICAgICAgICAgICAgICAgICB3LT5zZXRDb2xv cihrQmxhY2spOworICAgICAgICAgICAgICAgICAgICB4UGFyZW50LT5zZXRDb2xvcihrUmVkKTsK KyAgICAgICAgICAgICAgICAgICAgcmlnaHRSb3RhdGUoeFBhcmVudCk7CisgICAgICAgICAgICAg ICAgICAgIHcgPSB4UGFyZW50LT5sZWZ0KCk7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAg ICAgICAgIGlmICgoIXctPnJpZ2h0KCkgfHwgdy0+cmlnaHQoKS0+Y29sb3IoKSA9PSBrQmxhY2sp CisgICAgICAgICAgICAgICAgICAgICYmICghdy0+bGVmdCgpIHx8IHctPmxlZnQoKS0+Y29sb3Io KSA9PSBrQmxhY2spKSB7CisgICAgICAgICAgICAgICAgICAgIC8vIENhc2UgMgorICAgICAgICAg ICAgICAgICAgICB3LT5zZXRDb2xvcihrUmVkKTsKKyAgICAgICAgICAgICAgICAgICAgeCA9IHhQ YXJlbnQ7CisgICAgICAgICAgICAgICAgICAgIHhQYXJlbnQgPSB4LT5wYXJlbnQoKTsKKyAgICAg ICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgICAgICBpZiAoIXctPmxlZnQoKSB8 fCB3LT5sZWZ0KCktPmNvbG9yKCkgPT0ga0JsYWNrKSB7CisgICAgICAgICAgICAgICAgICAgICAg ICAvLyBDYXNlIDMKKyAgICAgICAgICAgICAgICAgICAgICAgIHctPnJpZ2h0KCktPnNldENvbG9y KGtCbGFjayk7CisgICAgICAgICAgICAgICAgICAgICAgICB3LT5zZXRDb2xvcihrUmVkKTsKKyAg ICAgICAgICAgICAgICAgICAgICAgIGxlZnRSb3RhdGUodyk7CisgICAgICAgICAgICAgICAgICAg ICAgICB3ID0geFBhcmVudC0+bGVmdCgpOworICAgICAgICAgICAgICAgICAgICB9CisgICAgICAg ICAgICAgICAgICAgIC8vIENhc2UgNAorICAgICAgICAgICAgICAgICAgICB3LT5zZXRDb2xvcih4 UGFyZW50LT5jb2xvcigpKTsKKyAgICAgICAgICAgICAgICAgICAgeFBhcmVudC0+c2V0Q29sb3Io a0JsYWNrKTsKKyAgICAgICAgICAgICAgICAgICAgaWYgKHctPmxlZnQoKSkKKyAgICAgICAgICAg ICAgICAgICAgICAgIHctPmxlZnQoKS0+c2V0Q29sb3Ioa0JsYWNrKTsKKyAgICAgICAgICAgICAg ICAgICAgcmlnaHRSb3RhdGUoeFBhcmVudCk7CisgICAgICAgICAgICAgICAgICAgIHggPSBtX3Jv b3Q7CisgICAgICAgICAgICAgICAgICAgIHhQYXJlbnQgPSB4LT5wYXJlbnQoKTsKKyAgICAgICAg ICAgICAgICB9CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICAgICAgaWYgKHgpCisgICAg ICAgICAgICB4LT5zZXRDb2xvcihrQmxhY2spOworICAgIH0KKworICAgIC8vIERlbGV0ZXMgdGhl IGdpdmVuIG5vZGUgZnJvbSB0aGUgdHJlZS4gTm90ZSB0aGF0IHRoaXMKKyAgICAvLyBwYXJ0aWN1 bGFyIG5vZGUgbWF5IG5vdCBhY3R1YWxseSBiZSByZW1vdmVkIGZyb20gdGhlIHRyZWU7CisgICAg Ly8gaW5zdGVhZCwgYW5vdGhlciBub2RlIG1pZ2h0IGJlIHJlbW92ZWQgYW5kIGl0cyBjb250ZW50 cworICAgIC8vIGNvcGllZCBpbnRvIHouCisgICAgdm9pZCBkZWxldGVOb2RlKE5vZGUqIHopCisg ICAgeworICAgICAgICAvLyBZIGlzIHRoZSBub2RlIHRvIGJlIHVubGlua2VkIGZyb20gdGhlIHRy ZWUuCisgICAgICAgIE5vZGUqIHk7CisgICAgICAgIGlmICghei0+bGVmdCgpIHx8ICF6LT5yaWdo dCgpKQorICAgICAgICAgICAgeSA9IHo7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIHkgPSB0 cmVlU3VjY2Vzc29yKHopOworICAgICAgICAvLyBZIGlzIGd1YXJhbnRlZWQgdG8gYmUgbm9uLTAg YXQgdGhpcyBwb2ludC4KKyAgICAgICAgTm9kZSogeDsKKyAgICAgICAgaWYgKHktPmxlZnQoKSkK KyAgICAgICAgICAgIHggPSB5LT5sZWZ0KCk7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIHgg PSB5LT5yaWdodCgpOworICAgICAgICAvLyBYIGlzIHRoZSBjaGlsZCBvZiB5IHdoaWNoIG1pZ2h0 IHBvdGVudGlhbGx5IHJlcGxhY2UgeSBpbgorICAgICAgICAvLyB0aGUgdHJlZS4gWCBtaWdodCBi ZSBudWxsIGF0IHRoaXMgcG9pbnQuCisgICAgICAgIE5vZGUqIHhQYXJlbnQ7CisgICAgICAgIGlm ICh4KSB7CisgICAgICAgICAgICB4LT5zZXRQYXJlbnQoeS0+cGFyZW50KCkpOworICAgICAgICAg ICAgeFBhcmVudCA9IHgtPnBhcmVudCgpOworICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgIHhQ YXJlbnQgPSB5LT5wYXJlbnQoKTsKKyAgICAgICAgaWYgKCF5LT5wYXJlbnQoKSkKKyAgICAgICAg ICAgIG1fcm9vdCA9IHg7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIGlmICh5ID09IHktPnBh cmVudCgpLT5sZWZ0KCkpCisgICAgICAgICAgICAgICAgeS0+cGFyZW50KCktPnNldExlZnQoeCk7 CisgICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAgeS0+cGFyZW50KCktPnNldFJpZ2h0 KHgpOworICAgICAgICAvLyBJdCBoYXMgYmVlbiBmb3VuZCBlbXBpcmljYWxseSB0aGF0IGJvdGgg b2YgdGhlc2UgdXB3YXJkCisgICAgICAgIC8vIHByb3BhZ2F0aW9ucyBhcmUgbmVjZXNzYXJ5Lgor ICAgICAgICBpZiAoeSAhPSB6KSB7CisgICAgICAgICAgICB6LT5jb3B5RnJvbSh5KTsKKyAgICAg ICAgICAgIHByb3BhZ2F0ZVVwZGF0ZXMoeik7CisgICAgICAgIH0KKyAgICAgICAgaWYgKHhQYXJl bnQpCisgICAgICAgICAgICBwcm9wYWdhdGVVcGRhdGVzKHhQYXJlbnQpOworICAgICAgICBpZiAo eS0+Y29sb3IoKSA9PSBrQmxhY2spCisgICAgICAgICAgICBkZWxldGVGaXh1cCh4LCB4UGFyZW50 KTsKKyAgICB9CisKKyAgICAvLyBWaXNpdHMgdGhlIHN1YnRyZWUgcm9vdGVkIGF0IHRoZSBnaXZl biBub2RlIGluIG9yZGVyLgorICAgIHZvaWQgdmlzaXRJbm9yZGVySW1wbChOb2RlKiBub2RlLCBW aXNpdG9yKiB2aXNpdG9yKQorICAgIHsKKyAgICAgICAgaWYgKG5vZGUtPmxlZnQoKSkKKyAgICAg ICAgICAgIHZpc2l0SW5vcmRlckltcGwobm9kZS0+bGVmdCgpLCB2aXNpdG9yKTsKKyAgICAgICAg dmlzaXRvci0+VmlzaXQobm9kZS0+ZGF0YSgpKTsKKyAgICAgICAgaWYgKG5vZGUtPnJpZ2h0KCkp CisgICAgICAgICAgICB2aXNpdElub3JkZXJJbXBsKG5vZGUtPnJpZ2h0KCksIHZpc2l0b3IpOwor ICAgIH0KKworICAgIC8vLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICAgIC8vIEhlbHBlciBjbGFzcyBmb3IgTnVt RWxlbWVudHMoKQorCisgICAgLy8gQSBWaXNpdG9yIHdoaWNoIHNpbXBseSBjb3VudHMgdGhlIG51 bWJlciBvZiB2aXNpdGVkIGVsZW1lbnRzLgorICAgIGNsYXNzIENvdW50ZXIgOiBwdWJsaWMgVmlz aXRvciwgcHVibGljIE5vbmNvcHlhYmxlIHsKKyAgICBwdWJsaWM6CisgICAgICAgIENvdW50ZXIo KQorICAgICAgICAgICAgOiBtX2NvdW50KDApCisgICAgICAgIHsKKyAgICAgICAgfQorCisgICAg ICAgIHZpcnR1YWwgdm9pZCBWaXNpdChjb25zdCBUJiBkYXRhKQorICAgICAgICB7CisgICAgICAg ICAgICArK21fY291bnQ7CisgICAgICAgIH0KKworICAgICAgICBpbnQgY291bnQoKQorICAgICAg ICB7CisgICAgICAgICAgICByZXR1cm4gbV9jb3VudDsKKyAgICAgICAgfQorCisgICAgcHJpdmF0 ZToKKyAgICAgICAgaW50IG1fY291bnQ7CisgICAgfTsKKworI2lmbmRlZiBOREVCVUcKKyAgICAv Ly0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0KKyAgICAvLyBWZXJpZmljYXRpb24gYW5kIGRlYnVnZ2luZyByb3V0aW5l cworICAgIC8vCisKKyAgICAvLyBSZXR1cm5zIHRydWUgaWYgdmVyaWZpY2F0aW9uIHN1Y2NlZWRl ZC4gUmV0dXJucyBpbiB0aGUKKyAgICAvLyAiYmxhY2tDb3VudCIgcGFyYW1ldGVyIHRoZSBudW1i ZXIgb2YgYmxhY2sgY2hpbGRyZW4gYWxvbmcgYWxsCisgICAgLy8gcGF0aHMgdG8gYWxsIGxlYXZl cyBvZiB0aGUgZ2l2ZW4gbm9kZS4KKyAgICBib29sIHZlcmlmeUZyb21Ob2RlKE5vZGUqIG5vZGUs IGludCogYmxhY2tDb3VudCkKKyAgICB7CisgICAgICAgIC8vIEJhc2UgY2FzZSBpcyBhIGxlYWYg bm9kZS4KKyAgICAgICAgaWYgKCFub2RlKSB7CisgICAgICAgICAgICAqYmxhY2tDb3VudCA9IDE7 CisgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICAgICAgfQorCisgICAgICAgIC8vIEVhY2gg bm9kZSBpcyBlaXRoZXIgcmVkIG9yIGJsYWNrLgorICAgICAgICBpZiAoIShub2RlLT5jb2xvcigp ID09IGtSZWQgfHwgbm9kZS0+Y29sb3IoKSA9PSBrQmxhY2spKQorICAgICAgICAgICAgcmV0dXJu IGZhbHNlOworCisgICAgICAgIC8vIEV2ZXJ5IGxlYWYgKG9yIG51bGwpIGlzIGJsYWNrLgorCisg ICAgICAgIGlmIChub2RlLT5jb2xvcigpID09IGtSZWQpIHsKKyAgICAgICAgICAgIC8vIEJvdGgg b2YgaXRzIGNoaWxkcmVuIGFyZSBibGFjay4KKyAgICAgICAgICAgIGlmICghKCghbm9kZS0+bGVm dCgpIHx8IG5vZGUtPmxlZnQoKS0+Y29sb3IoKSA9PSBrQmxhY2spKSkKKyAgICAgICAgICAgICAg ICByZXR1cm4gZmFsc2U7CisgICAgICAgICAgICBpZiAoISgoIW5vZGUtPnJpZ2h0KCkgfHwgbm9k ZS0+cmlnaHQoKS0+Y29sb3IoKSA9PSBrQmxhY2spKSkKKyAgICAgICAgICAgICAgICByZXR1cm4g ZmFsc2U7CisgICAgICAgIH0KKworICAgICAgICAvLyBFdmVyeSBzaW1wbGUgcGF0aCB0byBhIGxl YWYgbm9kZSBjb250YWlucyB0aGUgc2FtZSBudW1iZXIgb2YKKyAgICAgICAgLy8gYmxhY2sgbm9k ZXMuCisgICAgICAgIGludCBsZWZ0Q291bnQgPSAwLCByaWdodENvdW50ID0gMDsKKyAgICAgICAg Ym9vbCBsZWZ0VmFsaWQgPSB2ZXJpZnlGcm9tTm9kZShub2RlLT5sZWZ0KCksICZsZWZ0Q291bnQp OworICAgICAgICBib29sIHJpZ2h0VmFsaWQgPSB2ZXJpZnlGcm9tTm9kZShub2RlLT5yaWdodCgp LCAmcmlnaHRDb3VudCk7CisgICAgICAgIGlmICghbGVmdFZhbGlkIHx8ICFyaWdodFZhbGlkKQor ICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworICAgICAgICAqYmxhY2tDb3VudCA9IGxlZnRDb3Vu dCArIChub2RlLT5jb2xvcigpID09IGtCbGFjayA/IDEgOiAwKTsKKyAgICAgICAgcmV0dXJuIGxl ZnRDb3VudCA9PSByaWdodENvdW50OworICAgIH0KKworICAgIC8vIER1bXBzIHRoZSBzdWJ0cmVl IHJvb3RlZCBhdCB0aGUgZ2l2ZW4gbm9kZS4KKyAgICB2b2lkIGR1bXBGcm9tTm9kZShOb2RlKiBu b2RlLCBpbnQgaW5kZW50YXRpb24pCisgICAgeworICAgICAgICBTdHJpbmcgcHJlZml4OworICAg ICAgICBmb3IgKGludCBpID0gMDsgaSA8IGluZGVudGF0aW9uOyBpKyspCisgICAgICAgICAgICBw cmVmaXggKz0gIiAiOworICAgICAgICBwcmVmaXggKz0gIi0iOworICAgICAgICBpZiAoIW5vZGUp IHsKKyAgICAgICAgICAgIHN0ZDo6Y2VyciA8PCBwcmVmaXgudXRmOCgpLmRhdGEoKSA8PCBzdGQ6 OmVuZGw7CisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0KKyAgICAgICAgc3RkOjpjZXJy IDw8IHByZWZpeC51dGY4KCkuZGF0YSgpIDw8ICIgIiA8PCBub2RlLT5kYXRhKCkKKyAgICAgICAg ICAgICAgICAgIDw8ICgobm9kZS0+Y29sb3IoKSA9PSBrQmxhY2spID8gIiAoYmxhY2spIiA6ICIg KHJlZCkiKSA8PCBzdGQ6OmVuZGw7CisgICAgICAgIGR1bXBGcm9tTm9kZShub2RlLT5sZWZ0KCks IGluZGVudGF0aW9uICsgMik7CisgICAgICAgIGR1bXBGcm9tTm9kZShub2RlLT5yaWdodCgpLCBp bmRlbnRhdGlvbiArIDIpOworICAgIH0KKyNlbmRpZgorCisgICAgLy8tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisg ICAgLy8gRGF0YSBtZW1iZXJzCisKKyAgICBSZWZQdHI8QXJlbmE+IG1fYXJlbmE7CisgICAgTm9k ZSogbV9yb290OworICAgIGJvb2wgbV9uZWVkc0Z1bGxPcmRlcmluZ0NvbXBhcmlzb25zOworI2lm bmRlZiBOREVCVUcKKyAgICBib29sIG1fdmVyYm9zZURlYnVnZ2luZzsKKyNlbmRpZgorfTsKKwor fSAvLyBuYW1lc3BhY2UgZ3B1Cit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBn cHVfUmVkQmxhY2tUcmVlX2gK 65655 2010-08-26 18:09:58 -0700 2010-08-26 19:34:06 -0700 Cubic curve classification, texture coordinate assignment, local triangulation and math utilities cubic.patch text/plain 71380 kbr SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA2NjE2MSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsNjggQEAKKzIwMTAtMDgtMjYgIEtlbm5ldGggUnVzc2VsbCAgPGtickBnb29nbGUu Y29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFk ZCBzdXBwb3J0IGZvciBHUFUgYWNjZWxlcmF0ZWQgcGF0aCByZW5kZXJpbmcKKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ0NzI5CisKKyAgICAgICAgVGhp cyBwYXRjaCBhZGRzIHRoZSBjbGFzc2lmaWNhdGlvbiBvZiBjdWJpYyBjdXJ2ZSBzZWdtZW50cyBp bnRvCisgICAgICAgIGNhdGVnb3JpZXMsIGFzc2lnbm1lbnQgb2YgdGV4dHVyZSBjb29yZGluYXRl cyB0byB0aGUgY3VydmVzJworICAgICAgICBjb250cm9sIHBvaW50cyBmb3IgbGF0ZXIgcmVuZGVy aW5nIG9uIHRoZSBHUFUsIHRoZSBhbGdvcml0aG0gZm9yCisgICAgICAgIHRyaWFuZ3VsYXRpbmcg YW4gaW5kaXZpZHVhbCBjdWJpYyBjdXJ2ZSBhbmQgd2Fsa2luZyBpdHMgaW50ZXJpb3IKKyAgICAg ICAgZWRnZXMgZm9yIGFzc2VtYmx5IGludG8gYSBjb21wbGV0ZSBmaWxsZWQgc2hhcGUsIGFuZCBz ZXZlcmFsCisgICAgICAgIHV0aWxpdHkgcm91dGluZXMgcmVsYXRlZCB0byBnZW9tZXRyeSBhbmQg Y3ViaWMgY3VydmUgcHJvY2Vzc2luZywKKyAgICAgICAgc29tZSBwb3J0ZWQgZnJvbSBTa2lhLgor CisgICAgICAgIFRoZSByZWFzb24gZm9yIHRoZSBzdHlsZSB2aW9sYXRpb25zIGluIHRoZSBoZWFk ZXIgZ3VhcmRzIGlzCisgICAgICAgIGRlc2NyaWJlZCBpbiB0aGUgZWFybGllciBwYXRjaC4gVGhl cmUgaXMgYW5vdGhlciB2aW9sYXRpb24gYXJvdW5kCisgICAgICAgIHRoZSB1c2Ugb2YgdGhlIGxl dHRlciBsIGFzIGFuIGlkZW50aWZpZXIsIGJ1dCB0aGUgYWxnb3JpdGhtCisgICAgICAgIGRlZmlu ZXMgY29vcmRpbmF0ZXMgaywgbCwgYW5kIG0sIHNvIGl0IHNlZW1zIGJlc3QgdG8gbWF0Y2ggdGhl CisgICAgICAgIGFsZ29yaXRobSdzIHRlcm1pbm9sb2d5IHJhdGhlciB0aGFuIHRoZSBzdHlsZSBn dWlkZSBpbiB0aGlzIGNhc2UuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9ncHU6IEFk ZGVkLgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2dwdS9DdWJpY0NsYXNzaWZpZXIuY2M6 IEFkZGVkLgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2dwdS9DdWJpY0NsYXNzaWZpZXIu aDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpncHU6OkN1YmljQ2xhc3NpZmllcjo6KToKKyAg ICAgICAgKFdlYkNvcmU6OmdwdTo6Q3ViaWNDbGFzc2lmaWVyOjpSZXN1bHQ6OlJlc3VsdCk6Cisg ICAgICAgIChXZWJDb3JlOjpncHU6OkN1YmljQ2xhc3NpZmllcjo6UmVzdWx0OjpjdXJ2ZVR5cGUp OgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpDdWJpY0NsYXNzaWZpZXI6OlJlc3VsdDo6ZDEpOgor ICAgICAgICAoV2ViQ29yZTo6Z3B1OjpDdWJpY0NsYXNzaWZpZXI6OlJlc3VsdDo6ZDIpOgorICAg ICAgICAoV2ViQ29yZTo6Z3B1OjpDdWJpY0NsYXNzaWZpZXI6OlJlc3VsdDo6ZDMpOgorICAgICAg ICAoV2ViQ29yZTo6Z3B1OjpDdWJpY0NsYXNzaWZpZXI6OkN1YmljQ2xhc3NpZmllcik6CisgICAg ICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L0N1YmljTWF0aFV0aWxzLmNjOiBBZGRlZC4KKyAg ICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9ncHUvQ3ViaWNNYXRoVXRpbHMuaDogQWRkZWQuCisg ICAgICAgIChXZWJDb3JlOjpncHU6OnJvdW5kVG9aZXJvKToKKyAgICAgICAgKFdlYkNvcmU6Omdw dTo6ZGlzdGFuY2UpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjphcHByb3hFcXVhbCk6CisgICAg ICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L0N1YmljVGV4dHVyZUNvb3Jkcy5jYzogQWRkZWQu CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L0N1YmljVGV4dHVyZUNvb3Jkcy5oOiBB ZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6Q3ViaWNUZXh0dXJlQ29vcmRzOjpSZXN1bHQ6 OlJlc3VsdCk6CisgICAgICAgIChXZWJDb3JlOjpncHU6OkN1YmljVGV4dHVyZUNvb3Jkczo6Q3Vi aWNUZXh0dXJlQ29vcmRzKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9ncHUvTG9jYWxU cmlhbmd1bGF0b3IuY2M6IEFkZGVkLgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2dwdS9M b2NhbFRyaWFuZ3VsYXRvci5oOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6TG9jYWxU cmlhbmd1bGF0b3I6OlZlcnRleDo6VmVydGV4KToKKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6TG9j YWxUcmlhbmd1bGF0b3I6OlZlcnRleDo6eCk6CisgICAgICAgIChXZWJDb3JlOjpncHU6OkxvY2Fs VHJpYW5ndWxhdG9yOjpWZXJ0ZXg6OnkpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpMb2NhbFRy aWFuZ3VsYXRvcjo6VmVydGV4OjprKToKKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6TG9jYWxUcmlh bmd1bGF0b3I6OlZlcnRleDo6bCk6CisgICAgICAgIChXZWJDb3JlOjpncHU6OkxvY2FsVHJpYW5n dWxhdG9yOjpWZXJ0ZXg6Om0pOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpMb2NhbFRyaWFuZ3Vs YXRvcjo6VmVydGV4OjpzZXQpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpMb2NhbFRyaWFuZ3Vs YXRvcjo6VmVydGV4OjplbmQpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpMb2NhbFRyaWFuZ3Vs YXRvcjo6VmVydGV4OjpzZXRFbmQpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpMb2NhbFRyaWFu Z3VsYXRvcjo6VmVydGV4OjptYXJrZWQpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpMb2NhbFRy aWFuZ3VsYXRvcjo6VmVydGV4OjpzZXRNYXJrZWQpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpM b2NhbFRyaWFuZ3VsYXRvcjo6VmVydGV4OjppbnRlcmlvcik6CisgICAgICAgIChXZWJDb3JlOjpn cHU6OkxvY2FsVHJpYW5ndWxhdG9yOjpWZXJ0ZXg6OnNldEludGVyaW9yKToKKyAgICAgICAgKFdl YkNvcmU6OmdwdTo6TG9jYWxUcmlhbmd1bGF0b3I6OlZlcnRleDo6cmVzZXRGbGFncyk6CisgICAg ICAgIChXZWJDb3JlOjpncHU6OkxvY2FsVHJpYW5ndWxhdG9yOjpUcmlhbmdsZTo6VHJpYW5nbGUp OgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpMb2NhbFRyaWFuZ3VsYXRvcjo6VHJpYW5nbGU6Omdl dFZlcnRleCk6CisgICAgICAgIChXZWJDb3JlOjpncHU6OkxvY2FsVHJpYW5ndWxhdG9yOjpUcmlh bmdsZTo6c2V0VmVydGljZXMpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpMb2NhbFRyaWFuZ3Vs YXRvcjo6Z2V0VmVydGV4KToKKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6TG9jYWxUcmlhbmd1bGF0 b3I6Om51bVRyaWFuZ2xlcyk6CisgICAgICAgIChXZWJDb3JlOjpncHU6OkxvY2FsVHJpYW5ndWxh dG9yOjpnZXRUcmlhbmdsZSk6CisgICAgICAgIChXZWJDb3JlOjpncHU6OkxvY2FsVHJpYW5ndWxh dG9yOjpudW1JbnRlcmlvclZlcnRpY2VzKToKKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6TG9jYWxU cmlhbmd1bGF0b3I6OmdldEludGVyaW9yVmVydGV4KToKKwogMjAxMC0wOC0yNiAgTWFyayBSb3dl ICA8bXJvd2VAYXBwbGUuY29tPgogCiAgICAgICAgIERhcmluIHBvaW50ZWQgb3V0IHRoYXQgdGhl IGJyYWNlcyBhcmUgdW5uZWNlc3NhcnkgaW4gYW4gT2JqZWN0aXZlLUMgaW50ZXJmYWNlCkluZGV4 OiBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9DdWJpY0NsYXNzaWZpZXIuY2MKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUvQ3ViaWNDbGFzc2lmaWVyLmNj CShyZXZpc2lvbiAwKQorKysgV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUvQ3ViaWNDbGFz c2lmaWVyLmNjCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDEyNSBAQAorLyoKKyAqIENvcHlyaWdo dCAyMDEwLCBHb29nbGUgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRp c3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdp dGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBm b2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1 dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICog bm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9k dWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRpb24g YW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0aW9u LgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVz IG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90 ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZp YyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9W SURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElT IiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBO T1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklM SVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlN RUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJV VE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICog U1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywg QlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBP UiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVT UyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBM SUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQK KyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdB WSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9G IFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmln LmgiCisKKyNpbmNsdWRlICJncHUvQ3ViaWNDbGFzc2lmaWVyLmgiCisKKyNpbmNsdWRlICJncHUv Q3ViaWNNYXRoVXRpbHMuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworbmFtZXNwYWNlIGdwdSB7 CisKK0N1YmljQ2xhc3NpZmllcjo6UmVzdWx0IEN1YmljQ2xhc3NpZmllcjo6Y2xhc3NpZnkoZmxv YXQgYjB4LCBmbG9hdCBiMHksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIGZsb2F0IGIxeCwgZmxvYXQgYjF5LAorICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBmbG9hdCBiMngsIGZsb2F0IGIyeSwKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZmxvYXQgYjN4LCBm bG9hdCBiM3kpIHsKKyAgICBWZWN0b3IzIGIwKGIweCwgYjB5LCAxKTsKKyAgICBWZWN0b3IzIGIx KGIxeCwgYjF5LCAxKTsKKyAgICBWZWN0b3IzIGIyKGIyeCwgYjJ5LCAxKTsKKyAgICBWZWN0b3Iz IGIzKGIzeCwgYjN5LCAxKTsKKworICAgIC8vIENvbXB1dGUgYTEuLmEzCisgICAgZmxvYXQgYTEg PSBiMC5kb3QoYjMuY3Jvc3MoYjIpKTsKKyAgICBmbG9hdCBhMiA9IGIxLmRvdChiMC5jcm9zcyhi MykpOworICAgIGZsb2F0IGEzID0gYjIuZG90KGIxLmNyb3NzKGIwKSk7CisKKyAgICAvLyBDb21w dXRlIGQxLi5kMworICAgIGZsb2F0IGQxID0gYTEgLSAyICogYTIgKyAzICogYTM7CisgICAgZmxv YXQgZDIgPSAtYTIgKyAzICogYTM7CisgICAgZmxvYXQgZDMgPSAzICogYTM7CisKKyAgICAvLyBF eHBlcmltZW50YXRpb24gaGFzIHNob3duIHRoYXQgdGhlIHRleHR1cmUgY29vcmRpbmF0ZXMgY29t cHV0ZWQKKyAgICAvLyBmcm9tIHRoZXNlIHZhbHVlcyBxdWlja2x5IGJlY29tZSBodWdlLCBsZWFk aW5nIHRvIHJvdW5kb2ZmIGVycm9ycworICAgIC8vIGFuZCBhcnRpZmFjdHMgaW4gdGhlIHNoYWRl ci4gSXQgdHVybnMgb3V0IHRoYXQgaWYgd2Ugbm9ybWFsaXplCisgICAgLy8gdGhlIHZlY3RvciBk ZWZpbmVkIGJ5IChkMSwgZDIsIGQzKSwgdGhpcyBmaXhlcyB0aGUgcHJvYmxlbSBvZiB0aGUKKyAg ICAvLyB0ZXh0dXJlIGNvb3JkaW5hdGVzIGdldHRpbmcgdG9vIGxhcmdlIHdpdGhvdXQgYWZmZWN0 aW5nIHRoZQorICAgIC8vIGNsYXNzaWZpY2F0aW9uIHJlc3VsdHMuCisgICAgVmVjdG9yMyBuZChk MSwgZDIsIGQzKTsKKyAgICBuZC5ub3JtYWxpemUoKTsKKyAgICBkMSA9IG5kLngoKTsKKyAgICBk MiA9IG5kLnkoKTsKKyAgICBkMyA9IG5kLnooKTsKKworICAgIC8vIENvbXB1dGUgdGhlIGRpc2Ny aW1pbmFudC4KKyAgICAvLyB0ZXJtMCBpcyBhIGNvbW1vbiB0ZXJtIGluIHRoZSBjb21wdXRhdGlv biB3aGljaCBoZWxwcyBkZWNpZGUKKyAgICAvLyB3aGljaCB3YXkgdG8gY2xhc3NpZnkgdGhlIGN1 c3AgY2FzZTogYXMgc2VycGVudGluZSBvciBsb29wLgorICAgIGZsb2F0IHRlcm0wID0gKDMgKiBk MiAqIGQyIC0gNCAqIGQxICogZDMpOworICAgIGZsb2F0IGRpc2NyID0gZDEgKiBkMSAqIHRlcm0w OworCisgICAgLy8gRXhwZXJpbWVudGF0aW9uIGhhcyBhbHNvIHNob3duIHRoYXQgd2hlbiB0aGUg Y2xhc3NpZmljYXRpb24gaXMKKyAgICAvLyBuZWFyIHRoZSBib3VuZGFyeSBiZXR3ZWVuIG9uZSBj dXJ2ZSB0eXBlIGFuZCBhbm90aGVyLCB0aGUgc2hhZGVyCisgICAgLy8gYmVjb21lcyBudW1lcmlj YWxseSB1bnN0YWJsZSwgcGFydGljdWxhcmx5IHdpdGggdGhlIGN1c3AgY2FzZS4KKyAgICAvLyBD b3JyZWN0IGZvciB0aGlzIGJ5IHJvdW5kaW5nIGQxLi5kMyBhbmQgdGhlIGRpc2NyaW1pbmFudCB0 byB6ZXJvCisgICAgLy8gd2hlbiB0aGV5IGdldCBuZWFyIGl0LgorICAgIGQxID0gcm91bmRUb1pl cm8oZDEpOworICAgIGQyID0gcm91bmRUb1plcm8oZDIpOworICAgIGQzID0gcm91bmRUb1plcm8o ZDMpOworICAgIGRpc2NyID0gcm91bmRUb1plcm8oZGlzY3IpOworCisgICAgLy8gRG8gdGhlIGNs YXNzaWZpY2F0aW9uCisgICAgaWYgKGFwcHJveEVxdWFsKGIwLCBiMSkgJiYKKyAgICAgICAgYXBw cm94RXF1YWwoYjAsIGIyKSAmJgorICAgICAgICBhcHByb3hFcXVhbChiMCwgYjMpKSB7CisgICAg ICAgIHJldHVybiBSZXN1bHQoa1BvaW50LCBkMSwgZDIsIGQzKTsKKyAgICB9CisKKyAgICBpZiAo ZGlzY3IgPT0gMCkgeworICAgICAgICBpZiAoZDEgPT0gMCAmJiBkMiA9PSAwKSB7CisgICAgICAg ICAgICBpZiAoZDMgPT0gMCkKKyAgICAgICAgICAgICAgICByZXR1cm4gUmVzdWx0KGtMaW5lLCBk MSwgZDIsIGQzKTsKKyAgICAgICAgICAgIHJldHVybiBSZXN1bHQoa1F1YWRyYXRpYywgZDEsIGQy LCBkMyk7CisgICAgICAgIH0KKworICAgICAgICBpZiAoZDEgPT0gMCkKKyAgICAgICAgICAgIHJl dHVybiBSZXN1bHQoa0N1c3AsIGQxLCBkMiwgZDMpOworCisgICAgICAgIC8vIFRoaXMgaXMgdGhl IGJvdW5kYXJ5IGNhc2UgZGVzY3JpYmVkIGluIExvb3AgYW5kIEJsaW5uJ3MKKyAgICAgICAgLy8g U0lHR1JBUEggJzA1IHBhcGVyIG9mIGEgY3VzcCB3aXRoIGluZmxlY3Rpb24gYXQgaW5maW5pdHku CisgICAgICAgIC8vIEJlY2F1c2UgdGVybTAgbWlnaHQgbm90IGJlIGV4YWN0bHkgMCwgd2UgZGVj aWRlIGJldHdlZW4gdXNpbmcKKyAgICAgICAgLy8gdGhlIHNlcnBlbnRpbmUgYW5kIGxvb3AgY2Fz ZXMgZGVwZW5kaW5nIG9uIGl0cyBzaWduIHRvIGF2b2lkCisgICAgICAgIC8vIHRha2luZyB0aGUg c3F1YXJlIHJvb3Qgb2YgYSBuZWdhdGl2ZSBudW1iZXIgd2hlbiBjb21wdXRpbmcgdGhlCisgICAg ICAgIC8vIGN1YmljIHRleHR1cmUgY29vcmRpbmF0ZXMuCisgICAgICAgIGlmICh0ZXJtMCA8IDAp CisgICAgICAgICAgICByZXR1cm4gUmVzdWx0KGtMb29wLCBkMSwgZDIsIGQzKTsKKworICAgICAg ICByZXR1cm4gUmVzdWx0KGtTZXJwZW50aW5lLCBkMSwgZDIsIGQzKTsKKyAgICB9IGVsc2UgaWYg KGRpc2NyID4gMCkgeworICAgICAgICByZXR1cm4gUmVzdWx0KGtTZXJwZW50aW5lLCBkMSwgZDIs IGQzKTsKKyAgICB9IGVsc2UgeworICAgICAgICAvLyBkaXNjciA8IDAKKyAgICAgICAgcmV0dXJu IFJlc3VsdChrTG9vcCwgZDEsIGQyLCBkMyk7CisgICAgfQorfQorCit9ICAvLyBuYW1lc3BhY2Ug Z3B1Cit9ICAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2dwdS9DdWJpY0NsYXNzaWZpZXIuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL2dwdS9DdWJpY0NsYXNzaWZpZXIuaAkocmV2aXNpb24gMCkKKysrIFdlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L0N1YmljQ2xhc3NpZmllci5oCShyZXZpc2lvbiAwKQpA QCAtMCwwICsxLDExMCBAQAorLyoKKyAqIENvcHlyaWdodCAyMDEwLCBHb29nbGUgSW5jLgorICog QWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNv dXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwg YXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUK KyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVz dCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29u ZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmli dXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJp Z2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBw cm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUg bmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cworICogY29udHJpYnV0b3Jz IG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20K KyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Np b24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhP TERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1Q TElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJ TVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICog QSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRI RSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBE SVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBD T05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywg UFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0Us CisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIg Q0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09O VFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5D RSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0Yg VEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNI IERBTUFHRS4KKyAqLworCisvLyBDdWJpYyBjdXJ2ZSBjbGFzc2lmaWNhdGlvbiBhbGdvcml0aG0g ZnJvbSAiUmVuZGVyaW5nIFZlY3RvciBBcnQgb24KKy8vIHRoZSBHUFUiIGJ5IExvb3AgYW5kIEJs aW5uLCBHUFUgR2VtcyAzLCBDaGFwdGVyIDI1LgorCisjaWZuZGVmIGdwdV9DdWJpY0NsYXNzaWZp ZXJfaAorI2RlZmluZSBncHVfQ3ViaWNDbGFzc2lmaWVyX2gKKworI2luY2x1ZGUgPHd0Zi9Ob25j b3B5YWJsZS5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CituYW1lc3BhY2UgZ3B1IHsKKworLy8g Q2xhc3NpZmllcyBjdWJpYyBjdXJ2ZXMgaW50byBzcGVjaWZpYyB0eXBlcy4KK2NsYXNzIEN1Ymlj Q2xhc3NpZmllciA6IHB1YmxpYyBOb25jb3B5YWJsZSB7CitwdWJsaWM6CisgICAgLy8gVGhlIHR5 cGVzIG9mIGN1YmljIGN1cnZlcy4KKyAgICBlbnVtIEN1cnZlVHlwZSB7CisgICAgICAgIGtTZXJw ZW50aW5lLAorICAgICAgICBrQ3VzcCwKKyAgICAgICAga0xvb3AsCisgICAgICAgIGtRdWFkcmF0 aWMsCisgICAgICAgIGtMaW5lLAorICAgICAgICBrUG9pbnQKKyAgICB9OworCisgICAgLy8gVGhl IHJlc3VsdCBvZiB0aGUgY2xhc3NpZmllci4KKyAgICBjbGFzcyBSZXN1bHQgeworICAgIHB1Ymxp YzoKKyAgICAgICAgUmVzdWx0KEN1cnZlVHlwZSBjdXJ2ZVR5cGUsIGZsb2F0IGQxLCBmbG9hdCBk MiwgZmxvYXQgZDMpCisgICAgICAgICAgICA6IG1fY3VydmVUeXBlKGN1cnZlVHlwZSkKKyAgICAg ICAgICAgICwgbV9kMShkMSkKKyAgICAgICAgICAgICwgbV9kMihkMikKKyAgICAgICAgICAgICwg bV9kMyhkMykKKyAgICAgICAgeworICAgICAgICB9CisKKyAgICAgICAgQ3VydmVUeXBlIGN1cnZl VHlwZSgpIGNvbnN0CisgICAgICAgIHsKKyAgICAgICAgICAgIHJldHVybiBtX2N1cnZlVHlwZTsK KyAgICAgICAgfQorCisgICAgICAgIGZsb2F0IGQxKCkgY29uc3QKKyAgICAgICAgeworICAgICAg ICAgICAgcmV0dXJuIG1fZDE7CisgICAgICAgIH0KKworICAgICAgICBmbG9hdCBkMigpIGNvbnN0 CisgICAgICAgIHsKKyAgICAgICAgICAgIHJldHVybiBtX2QyOworICAgICAgICB9CisKKyAgICAg ICAgZmxvYXQgZDMoKSBjb25zdAorICAgICAgICB7CisgICAgICAgICAgICByZXR1cm4gbV9kMzsK KyAgICAgICAgfQorCisgICAgcHJpdmF0ZToKKyAgICAgICAgQ3VydmVUeXBlIG1fY3VydmVUeXBl OworICAgICAgICBmbG9hdCBtX2QxOworICAgICAgICBmbG9hdCBtX2QyOworICAgICAgICBmbG9h dCBtX2QzOworICAgIH07CisKKyAgICAvLyBDbGFzc2lmaWVzIHRoZSBnaXZlbiBjdWJpYyBiZXpp ZXIgY3VydmUgc3RhcnRpbmcgYXQgKGIweCwgYjB5KSwKKyAgICAvLyBlbmRpbmcgYXQgKGIzeCwg YjN5KSwgYW5kIGFmZmVjdGVkIGJ5IGNvbnRyb2wgcG9pbnRzIChiMXgsIGIxeSkKKyAgICAvLyBh bmQgKGIyeCwgYjJ5KS4KKyAgICBzdGF0aWMgUmVzdWx0IGNsYXNzaWZ5KGZsb2F0IGIweCwgZmxv YXQgYjB5LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgZmxvYXQgYjF4LCBmbG9hdCBiMXks CisgICAgICAgICAgICAgICAgICAgICAgICAgICBmbG9hdCBiMngsIGZsb2F0IGIyeSwKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgIGZsb2F0IGIzeCwgZmxvYXQgYjN5KTsKKworcHJpdmF0ZToK KyAgICAvLyBUaGlzIGNsYXNzIGRvZXMgbm90IG5lZWQgdG8gYmUgaW5zdGFudGlhdGVkLgorICAg IEN1YmljQ2xhc3NpZmllcigpIHt9Cit9OworCit9IC8vIG5hbWVzcGFjZSBncHUKK30gLy8gbmFt ZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIGdwdV9DdWJpY0NsYXNzaWZpZXJfaApJbmRleDog V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUvQ3ViaWNNYXRoVXRpbHMuY2MKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUvQ3ViaWNNYXRoVXRpbHMuY2MJKHJl dmlzaW9uIDApCisrKyBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9DdWJpY01hdGhVdGls cy5jYwkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw1NzggQEAKKy8qCisgKiBDb3B5cmlnaHQgMjAx MCwgR29vZ2xlIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmli dXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0 CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93 aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0cmlidXRpb25z IG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4K KyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0 aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFu ZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9v ciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAq ICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBp dHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJv ZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJp b3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQg QlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5E IEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisg KiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBB TkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJ TiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMg QkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJ QUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBO T1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VS VklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5U RVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklM SVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAo SU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VU IE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUg UE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgor CisjaW5jbHVkZSAiZ3B1L0N1YmljTWF0aFV0aWxzLmgiCisKKyNpbmNsdWRlIDxhbGdvcml0aG0+ CisjaW5jbHVkZSAiRmxvYXRQb2ludC5oIgorI2luY2x1ZGUgIk1hdGhFeHRyYXMuaCIKKyNpbmNs dWRlIDxzdHJpbmcuaD4gLy8gZm9yIG1lbWNweQorCituYW1lc3BhY2UgV2ViQ29yZSB7CituYW1l c3BhY2UgZ3B1IHsKKworLy8gVXRpbGl0eSBmdW5jdGlvbnMgbG9jYWwgdG8gdGhpcyBmaWxlCisK K3N0YXRpYyBpbnQgb3JpZW50YXRpb24oZmxvYXQgeDEsIGZsb2F0IHkxLAorICAgICAgICAgICAg ICAgICAgICAgICBmbG9hdCB4MiwgZmxvYXQgeTIsCisgICAgICAgICAgICAgICAgICAgICAgIGZs b2F0IHgzLCBmbG9hdCB5MykKK3sKKyAgICAvLyBwMSA9ICh4MSwgeTEpCisgICAgLy8gcDIgPSAo eDIsIHkyKQorICAgIC8vIHAzID0gKHgzLCB5MykKKyAgICBmbG9hdCBjcm9zc1Byb2R1Y3QgPSAo eTIgLSB5MSkgKiAoeDMgLSB4MikgLSAoeTMgLSB5MikgKiAoeDIgLSB4MSk7CisgICAgcmV0dXJu IChjcm9zc1Byb2R1Y3QgPCAwLjBmKSA/IC0xIDogKChjcm9zc1Byb2R1Y3QgPiAwLjBmKSA/IDEg OiAwKTsKK30KKworc3RhdGljIGJvb2wgZWRnZUVkZ2VUZXN0KGZsb2F0IGF4LCBmbG9hdCBheSwK KyAgICAgICAgICAgICAgICAgICAgICAgICBmbG9hdCB2MHgsIGZsb2F0IHYweSwKKyAgICAgICAg ICAgICAgICAgICAgICAgICBmbG9hdCB1MHgsIGZsb2F0IHUweSwKKyAgICAgICAgICAgICAgICAg ICAgICAgICBmbG9hdCB1MXgsIGZsb2F0IHUxeSkKK3sKKyAgICAvLyBUaGlzIGVkZ2UgdG8gZWRn ZSB0ZXN0IGlzIGJhc2VkIG9uIEZyYW5saW4gQW50b25pbydzIGdlbTogIkZhc3RlcgorICAgIC8v IExpbmUgU2VnbWVudCBJbnRlcnNlY3Rpb24iLCBpbiBHcmFwaGljcyBHZW1zIElJSSwgcHAuIDE5 OS0yMDIuCisgICAgZmxvYXQgYnggPSB1MHggLSB1MXg7CisgICAgZmxvYXQgYnkgPSB1MHkgLSB1 MXk7CisgICAgZmxvYXQgY3ggPSB2MHggLSB1MHg7CisgICAgZmxvYXQgY3kgPSB2MHkgLSB1MHk7 CisgICAgZmxvYXQgZiA9IGF5ICogYnggLSBheCAqIGJ5OworICAgIGZsb2F0IGQgPSBieSAqIGN4 IC0gYnggKiBjeTsKKyAgICBpZiAoKGYgPiAwICYmIGQgPj0gMCAmJiBkIDw9IGYpIHx8IChmIDwg MCAmJiBkIDw9IDAgJiYgZCA+PSBmKSkgeworICAgICAgICBmbG9hdCBlID0gYXggKiBjeSAtIGF5 ICogY3g7CisKKyAgICAgICAgLy8gVGhpcyBhZGRpdGlvbmFsIHRlc3QgYXZvaWRzIHJlcG9ydGlu ZyBjb2luY2lkZW50IGVkZ2VzLCB3aGljaAorICAgICAgICAvLyBpcyB0aGUgYmVoYXZpb3Igd2Ug d2FudC4KKyAgICAgICAgaWYgKGFwcHJveEVxdWFsKGUsIDApIHx8IGFwcHJveEVxdWFsKGYsIDAp IHx8IGFwcHJveEVxdWFsKGUsIGYpKQorICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAg ICAgIGlmIChmID4gMCkKKyAgICAgICAgICAgIHJldHVybiBlID49IDAgJiYgZSA8PSBmOworICAg ICAgICBlbHNlCisgICAgICAgICAgICByZXR1cm4gZSA8PSAwICYmIGUgPj0gZjsKKyAgICB9Cisg ICAgcmV0dXJuIGZhbHNlOworfQorCitzdGF0aWMgYm9vbCBlZGdlQWdhaW5zdFRyaUVkZ2VzKGZs b2F0IHYweCwgZmxvYXQgdjB5LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBmbG9h dCB2MXgsIGZsb2F0IHYxeSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZmxvYXQg dTB4LCBmbG9hdCB1MHksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGZsb2F0IHUx eCwgZmxvYXQgdTF5LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBmbG9hdCB1Mngs IGZsb2F0IHUyeSkKK3sKKyAgICBmbG9hdCBheCwgYXk7CisgICAgYXggPSB2MXggLSB2MHg7Cisg ICAgYXkgPSB2MXkgLSB2MHk7CisgICAgLy8gVGVzdCBlZGdlIHUwLCB1MSBhZ2FpbnN0IHYwLCB2 MS4KKyAgICBpZiAoZWRnZUVkZ2VUZXN0KGF4LCBheSwgdjB4LCB2MHksIHUweCwgdTB5LCB1MXgs IHUxeSkpCisgICAgICAgIHJldHVybiB0cnVlOworICAgIC8vIFRlc3QgZWRnZSB1MSwgdTIgYWdh aW5zdCB2MCwgdjEuCisgICAgaWYgKGVkZ2VFZGdlVGVzdChheCwgYXksIHYweCwgdjB5LCB1MXgs IHUxeSwgdTJ4LCB1MnkpKQorICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICAvLyBUZXN0IGVkZ2Ug dTIsIHUxIGFnYWluc3QgdjAsIHYxLgorICAgIGlmIChlZGdlRWRnZVRlc3QoYXgsIGF5LCB2MHgs IHYweSwgdTJ4LCB1MnksIHUweCwgdTB5KSkKKyAgICAgICAgcmV0dXJuIHRydWU7CisgICAgcmV0 dXJuIGZhbHNlOworfQorCisvLyBFeHBvcnRlZCByb3V0aW5lcworCitib29sIGxpbmVzSW50ZXJz ZWN0KGZsb2F0IHAxeCwgZmxvYXQgcDF5LAorICAgICAgICAgICAgICAgICAgICBmbG9hdCBxMXgs IGZsb2F0IHExeSwKKyAgICAgICAgICAgICAgICAgICAgZmxvYXQgcDJ4LCBmbG9hdCBwMnksCisg ICAgICAgICAgICAgICAgICAgIGZsb2F0IHEyeCwgZmxvYXQgcTJ5KSB7CisgICAgcmV0dXJuICgo b3JpZW50YXRpb24ocDF4LCBwMXksIHExeCwgcTF5LCBwMngsIHAyeSkgIT0KKyAgICAgICAgICAg ICBvcmllbnRhdGlvbihwMXgsIHAxeSwgcTF4LCBxMXksIHEyeCwgcTJ5KSkgJiYKKyAgICAgICAg ICAgIChvcmllbnRhdGlvbihwMngsIHAyeSwgcTJ4LCBxMnksIHAxeCwgcDF5KSAhPQorICAgICAg ICAgICAgIG9yaWVudGF0aW9uKHAyeCwgcDJ5LCBxMngsIHEyeSwgcTF4LCBxMXkpKSk7Cit9CisK K2Jvb2wgcG9pbnRJblRyaWFuZ2xlKGZsb2F0IHB4LCBmbG9hdCBweSwKKyAgICAgICAgICAgICAg ICAgICAgIGZsb2F0IGF4LCBmbG9hdCBheSwKKyAgICAgICAgICAgICAgICAgICAgIGZsb2F0IGJ4 LCBmbG9hdCBieSwKKyAgICAgICAgICAgICAgICAgICAgIGZsb2F0IGN4LCBmbG9hdCBjeSkKK3sK KyAgICAvLyBBbGdvcml0aG0gZnJvbSBodHRwOi8vd3d3LmJsYWNrcGF3bi5jb20vdGV4dHMvcG9p bnRpbnBvbHkvZGVmYXVsdC5odG1sCisgICAgZmxvYXQgeDAgPSBjeCAtIGF4OworICAgIGZsb2F0 IHkwID0gY3kgLSBheTsKKyAgICBmbG9hdCB4MSA9IGJ4IC0gYXg7CisgICAgZmxvYXQgeTEgPSBi eSAtIGF5OworICAgIGZsb2F0IHgyID0gcHggLSBheDsKKyAgICBmbG9hdCB5MiA9IHB5IC0gYXk7 CisKKyAgICBmbG9hdCBkb3QwMCA9IHgwICogeDAgKyB5MCAqIHkwOworICAgIGZsb2F0IGRvdDAx ID0geDAgKiB4MSArIHkwICogeTE7CisgICAgZmxvYXQgZG90MDIgPSB4MCAqIHgyICsgeTAgKiB5 MjsKKyAgICBmbG9hdCBkb3QxMSA9IHgxICogeDEgKyB5MSAqIHkxOworICAgIGZsb2F0IGRvdDEy ID0geDEgKiB4MiArIHkxICogeTI7CisgICAgZmxvYXQgZGVub20gPSBkb3QwMCAqIGRvdDExIC0g ZG90MDEgKiBkb3QwMTsKKyAgICBpZiAoZGVub20gPT0gMC4wZikKKyAgICAgICAgLy8gVHJpYW5n bGUgaXMgemVyby1hcmVhLiBUcmVhdCBxdWVyeSBwb2ludCBhcyBub3QgYmVpbmcgaW5zaWRlLgor ICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgLy8gQ29tcHV0ZQorICAgIGZsb2F0IGludkRlbm9t ID0gMS4wZiAvIGRlbm9tOworICAgIGZsb2F0IHUgPSAoZG90MTEgKiBkb3QwMiAtIGRvdDAxICog ZG90MTIpICogaW52RGVub207CisgICAgZmxvYXQgdiA9IChkb3QwMCAqIGRvdDEyIC0gZG90MDEg KiBkb3QwMikgKiBpbnZEZW5vbTsKKworICAgIHJldHVybiAodSA+IDAuMGYpICYmICh2ID4gMC4w ZikgJiYgKHUgKyB2IDwgMS4wZik7Cit9CisKK2Jvb2wgdHJpYW5nbGVzT3ZlcmxhcChmbG9hdCBh MXgsIGZsb2F0IGExeSwKKyAgICAgICAgICAgICAgICAgICAgICBmbG9hdCBiMXgsIGZsb2F0IGIx eSwKKyAgICAgICAgICAgICAgICAgICAgICBmbG9hdCBjMXgsIGZsb2F0IGMxeSwKKyAgICAgICAg ICAgICAgICAgICAgICBmbG9hdCBhMngsIGZsb2F0IGEyeSwKKyAgICAgICAgICAgICAgICAgICAg ICBmbG9hdCBiMngsIGZsb2F0IGIyeSwKKyAgICAgICAgICAgICAgICAgICAgICBmbG9hdCBjMngs IGZsb2F0IGMyeSkKK3sKKyAgICAvLyBEZXJpdmVkIGZyb20gY29wbGFuYXJfdHJpX3RyaSgpIGF0 CisgICAgLy8gaHR0cDovL2pndC5ha3BldGVycy5jb20vcGFwZXJzL1NoZW5IZW5nVGFuZzAzL3Ry aV90cmkuaHRtbCAsCisgICAgLy8gc2ltcGxpZmllZCBmb3IgdGhlIDJEIGNhc2UgYW5kIG1vZGlm aWVkIHNvIHRoYXQgb3ZlcmxhcHBpbmcgZWRnZXMKKyAgICAvLyBkbyBub3QgcmVwb3J0IG92ZXJs YXBwaW5nIHRyaWFuZ2xlcy4KKworICAgIC8vIFRlc3QgYWxsIGVkZ2VzIG9mIHRyaWFuZ2xlIDEg YWdhaW5zdCB0aGUgZWRnZXMgb2YgdHJpYW5nbGUgMi4KKyAgICBpZiAoZWRnZUFnYWluc3RUcmlF ZGdlcyhhMXgsIGExeSwgYjF4LCBiMXksIGEyeCwgYTJ5LCBiMngsIGIyeSwgYzJ4LCBjMnkpKQor ICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICBpZiAoZWRnZUFnYWluc3RUcmlFZGdlcyhiMXgsIGIx eSwgYzF4LCBjMXksIGEyeCwgYTJ5LCBiMngsIGIyeSwgYzJ4LCBjMnkpKQorICAgICAgICByZXR1 cm4gdHJ1ZTsKKyAgICBpZiAoZWRnZUFnYWluc3RUcmlFZGdlcyhjMXgsIGMxeSwgYTF4LCBhMXks IGEyeCwgYTJ5LCBiMngsIGIyeSwgYzJ4LCBjMnkpKQorICAgICAgICByZXR1cm4gdHJ1ZTsKKyAg ICAvLyBGaW5hbGx5LCB0ZXN0IGlmIHRyaTEgaXMgdG90YWxseSBjb250YWluZWQgaW4gdHJpMiBv ciB2aWNlIHZlcnNhLgorICAgIGlmIChwb2ludEluVHJpYW5nbGUoYTF4LCBhMXksIGEyeCwgYTJ5 LCBiMngsIGIyeSwgYzJ4LCBjMnkpKQorICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICBpZiAocG9p bnRJblRyaWFuZ2xlKGEyeCwgYTJ5LCBhMXgsIGExeSwgYjF4LCBiMXksIGMxeCwgYzF5KSkKKyAg ICAgICAgcmV0dXJuIHRydWU7CisKKyAgICAvLyBCZWNhdXNlIHdlIGRlZmluZSB0aGF0IHRyaWFu Z2xlcyBzaGFyaW5nIGEgdmVydGV4IG9yIGVkZ2UgZG9uJ3QKKyAgICAvLyBvdmVybGFwLCB3ZSBt dXN0IHBlcmZvcm0gYWRkaXRpb25hbCBwb2ludC1pbi10cmlhbmdsZSB0ZXN0cyB0bworICAgIC8v IHNlZSB3aGV0aGVyIG9uZSB0cmlhbmdsZSBpcyBjb250YWluZWQgaW4gdGhlIG90aGVyLgorICAg IGlmIChwb2ludEluVHJpYW5nbGUoYjF4LCBiMXksIGEyeCwgYTJ5LCBiMngsIGIyeSwgYzJ4LCBj MnkpKQorICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICBpZiAocG9pbnRJblRyaWFuZ2xlKGMxeCwg YzF5LCBhMngsIGEyeSwgYjJ4LCBiMnksIGMyeCwgYzJ5KSkKKyAgICAgICAgcmV0dXJuIHRydWU7 CisgICAgaWYgKHBvaW50SW5UcmlhbmdsZShiMngsIGIyeSwgYTF4LCBhMXksIGIxeCwgYjF5LCBj MXgsIGMxeSkpCisgICAgICAgIHJldHVybiB0cnVlOworICAgIGlmIChwb2ludEluVHJpYW5nbGUo YzJ4LCBjMnksIGExeCwgYTF5LCBiMXgsIGIxeSwgYzF4LCBjMXkpKQorICAgICAgICByZXR1cm4g dHJ1ZTsKKyAgICByZXR1cm4gZmFsc2U7Cit9CisKKy8vIEhlbHBlciByb3V0aW5lcyBmb3IgcHVi bGljIFhSYXkgcXVlcmllcyBiZWxvdy4KKworI2RlZmluZSBOZWFybHlaZXJvQ29uc3RhbnQgKDEu MGYgLyAoMSA8PCAxMikpCisKK3N0YXRpYyBib29sIG5lYXJseVplcm8oZmxvYXQgeCwgZmxvYXQg dG9sZXJhbmNlID0gTmVhcmx5WmVyb0NvbnN0YW50KQoreworICAgIEFTU0VSVCh0b2xlcmFuY2Ug PiAwLjApOworICAgIHJldHVybiA6OmZhYnNmKHgpIDwgdG9sZXJhbmNlOworfQorCisvLyBMaW5l YXJseSBpbnRlcnBvbGF0ZSBiZXR3ZWVuIGEgYW5kIGIsIGJhc2VkIG9uIHQuCisvLyBJZiB0IGlz IDAsIHJldHVybiBhOyBpZiB0IGlzIDEsIHJldHVybiBiOyBlbHNlIGludGVycG9sYXRlLgorLy8g dCBtdXN0IGJlIFswLi4xXS4KK3N0YXRpYyBpbmxpbmUgZmxvYXQgaW50ZXJwKGZsb2F0IGEsIGZs b2F0IGIsIGZsb2F0IHQpIHsKKyAgICBBU1NFUlQodCA+PSAwICYmIHQgPD0gMSk7CisgICAgcmV0 dXJuIGEgKyAoYiAtIGEpICogdDsKK30KKworc3RhdGljIGZsb2F0IGV2YWxDdWJpYyhmbG9hdCBz MCwgZmxvYXQgczIsIGZsb2F0IHM0LCBmbG9hdCBzNiwgZmxvYXQgdCkKK3sKKyAgICBBU1NFUlQo dCA+PSAwICYmIHQgPD0gMSk7CisKKyAgICBpZiAodCA9PSAwKQorICAgICAgICByZXR1cm4gczA7 CisKKyAgICBmbG9hdCBhYiA9IGludGVycChzMCwgczIsIHQpOworICAgIGZsb2F0IGJjID0gaW50 ZXJwKHMyLCBzNCwgdCk7CisgICAgZmxvYXQgY2QgPSBpbnRlcnAoczQsIHM2LCB0KTsKKyAgICBm bG9hdCBhYmMgPSBpbnRlcnAoYWIsIGJjLCB0KTsKKyAgICBmbG9hdCBiY2QgPSBpbnRlcnAoYmMs IGNkLCB0KTsKKyAgICByZXR1cm4gaW50ZXJwKGFiYywgYmNkLCB0KTsKK30KKworLy8gU2V0IHB0 IHRvIHRoZSBwb2ludCBvbiB0aGUgc291cmNlIGN1YmljIHNwZWNpZmllZCBieSB0LgorLy8gdCBt dXN0IGJlIDAgPD0gdCA8PSAxLjAuCitzdGF0aWMgYm9vbCBldmFsQ3ViaWNBdChjb25zdCBGbG9h dFBvaW50IGN1YmljWzRdLCBmbG9hdCB0LCBGbG9hdFBvaW50JiBwdCkKK3sKKyAgICBwdC5zZXQo ZXZhbEN1YmljKGN1YmljWzBdLngoKSwgY3ViaWNbMV0ueCgpLCBjdWJpY1syXS54KCksIGN1Ymlj WzNdLngoKSwgdCksCisgICAgICAgICAgIGV2YWxDdWJpYyhjdWJpY1swXS55KCksIGN1YmljWzFd LnkoKSwgY3ViaWNbMl0ueSgpLCBjdWJpY1szXS55KCksIHQpKTsKK30KKworc3RhdGljIGJvb2wg eFJheUNyb3NzZXNNb25vdG9uaWNDdWJpYyhjb25zdCBYUmF5JiB4UmF5LCBjb25zdCBGbG9hdFBv aW50IGN1YmljWzRdLCBib29sKiBhbWJpZ3VvdXMpCit7CisgICAgaWYgKGFtYmlndW91cykKKyAg ICAgICAgKmFtYmlndW91cyA9IGZhbHNlOworCisgICAgLy8gRmluZCB0aGUgbWluaW11bSBhbmQg bWF4aW11bSB5IG9mIHRoZSBleHRyZW1hLCB3aGljaCBhcmUgdGhlCisgICAgLy8gZmlyc3QgYW5k IGxhc3QgcG9pbnRzIHNpbmNlIHRoaXMgY3ViaWMgaXMgbW9ub3RvbmljCisgICAgZmxvYXQgbWlu WSA9IHN0ZDo6bWluKGN1YmljWzBdLnkoKSwgY3ViaWNbM10ueSgpKTsKKyAgICBmbG9hdCBtYXhZ ID0gc3RkOjptYXgoY3ViaWNbMF0ueSgpLCBjdWJpY1szXS55KCkpOworCisgICAgaWYgKHhSYXku eSgpID09IGN1YmljWzBdLnkoKQorICAgICAgICB8fCB4UmF5LnkoKSA8IG1pblkKKyAgICAgICAg fHwgeFJheS55KCkgPiBtYXhZKSB7CisgICAgICAgIC8vIFRoZSBxdWVyeSBsaW5lIGRlZmluaXRl bHkgZG9lcyBub3QgY3Jvc3MgdGhlIGN1cnZlCisgICAgICAgIGlmIChhbWJpZ3VvdXMpCisgICAg ICAgICAgICAqYW1iaWd1b3VzID0gKHhSYXkueSgpID09IGN1YmljWzBdLnkoKSk7CisgICAgICAg IHJldHVybiBmYWxzZTsKKyAgICB9CisKKyAgICBib29sIHBvaW50QXRFeHRyZW11bSA9ICh4UmF5 LnkoKSA9PSBjdWJpY1szXS55KCkpOworCisgICAgZmxvYXQgbWluWCA9IHN0ZDo6bWluKHN0ZDo6 bWluKHN0ZDo6bWluKGN1YmljWzBdLngoKSwgY3ViaWNbMV0ueCgpKSwKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgY3ViaWNbMl0ueCgpKSwKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgY3ViaWNbM10ueCgpKTsKKyAgICBpZiAoeFJheS54KCkgPCBtaW5YKSB7CisgICAgICAg IC8vIFRoZSBxdWVyeSBsaW5lIGRlZmluaXRlbHkgY3Jvc3NlcyB0aGUgY3VydmUKKyAgICAgICAg aWYgKGFtYmlndW91cykKKyAgICAgICAgICAgICphbWJpZ3VvdXMgPSBwb2ludEF0RXh0cmVtdW07 CisgICAgICAgIHJldHVybiB0cnVlOworICAgIH0KKworICAgIGZsb2F0IG1heFggPSBzdGQ6Om1h eChzdGQ6Om1heChzdGQ6Om1heChjdWJpY1swXS54KCksIGN1YmljWzFdLngoKSksCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIGN1YmljWzJdLngoKSksCisgICAgICAgICAgICAg ICAgICAgICAgICAgIGN1YmljWzNdLngoKSk7CisgICAgaWYgKHhSYXkueCgpID4gbWF4WCkKKyAg ICAgICAgLy8gVGhlIHF1ZXJ5IGxpbmUgZGVmaW5pdGVseSBkb2VzIG5vdCBjcm9zcyB0aGUgY3Vy dmUKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgLy8gRG8gYSBiaW5hcnkgc2VhcmNoIHRv IGZpbmQgdGhlIHBhcmFtZXRlciB2YWx1ZSB3aGljaCBtYWtlcyB5IGFzCisgICAgLy8gY2xvc2Ug YXMgcG9zc2libGUgdG8gdGhlIHF1ZXJ5IHBvaW50LiBTZWUgd2hldGhlciB0aGUgcXVlcnkKKyAg ICAvLyBsaW5lJ3Mgb3JpZ2luIGlzIHRvIHRoZSBsZWZ0IG9mIHRoZSBhc3NvY2lhdGVkIHggY29v cmRpbmF0ZS4KKworICAgIC8vIE1heEl0ZXIgaXMgY2hvc2VuIGFzIHRoZSBudW1iZXIgb2YgbWFu dGlzc2EgYml0cyBmb3IgYSBmbG9hdCwKKyAgICAvLyBzaW5jZSB0aGVyZSdzIG5vIHdheSB3ZSBh cmUgZ29pbmcgdG8gZ2V0IG1vcmUgcHJlY2lzaW9uIGJ5CisgICAgLy8gaXRlcmF0aW5nIG1vcmUg dGltZXMgdGhhbiB0aGF0LgorICAgIGNvbnN0IGludCBNYXhJdGVyID0gMjM7CisgICAgRmxvYXRQ b2ludCBldmFsOworICAgIGludCBpdGVyID0gMDsKKyAgICBmbG9hdCB1cHBlclQ7CisgICAgZmxv YXQgbG93ZXJUOworICAgIC8vIE5lZWQgdG8gaW52ZXJ0IGRpcmVjdGlvbiBvZiB0IHBhcmFtZXRl ciBpZiBjdWJpYyBnb2VzIHVwCisgICAgLy8gaW5zdGVhZCBvZiBkb3duCisgICAgaWYgKGN1Ymlj WzNdLnkoKSA+IGN1YmljWzBdLnkoKSkgeworICAgICAgICB1cHBlclQgPSAxOworICAgICAgICBs b3dlclQgPSAwOworICAgIH0gZWxzZSB7CisgICAgICAgIHVwcGVyVCA9IDA7CisgICAgICAgIGxv d2VyVCA9IDE7CisgICAgfQorICAgIGRvIHsKKyAgICAgICAgZmxvYXQgdCA9IDAuNSAqICh1cHBl clQgKyBsb3dlclQpOworICAgICAgICBldmFsQ3ViaWNBdChjdWJpYywgdCwgZXZhbCk7CisgICAg ICAgIGlmICh4UmF5LnkoKSA+IGV2YWwueSgpKQorICAgICAgICAgICAgbG93ZXJUID0gdDsKKyAg ICAgICAgZWxzZQorICAgICAgICAgICAgdXBwZXJUID0gdDsKKyAgICB9IHdoaWxlICgrK2l0ZXIg PCBNYXhJdGVyICYmICFuZWFybHlaZXJvKGV2YWwueSgpIC0geFJheS55KCkpKTsKKyAgICBpZiAo eFJheS54KCkgPD0gZXZhbC54KCkpIHsKKyAgICAgICAgaWYgKGFtYmlndW91cykKKyAgICAgICAg ICAgICphbWJpZ3VvdXMgPSBwb2ludEF0RXh0cmVtdW07CisgICAgICAgIHJldHVybiB0cnVlOwor ICAgIH0KKyAgICByZXR1cm4gZmFsc2U7Cit9CisKK3N0YXRpYyBpbnQgdmFsaWRVbml0RGl2aWRl KGZsb2F0IG51bWVyLCBmbG9hdCBkZW5vbSwgZmxvYXQqIHJhdGlvKQoreworICAgIEFTU0VSVChy YXRpbyk7CisKKyAgICBpZiAobnVtZXIgPCAwKQorICAgIHsKKyAgICAgICAgbnVtZXIgPSAtbnVt ZXI7CisgICAgICAgIGRlbm9tID0gLWRlbm9tOworICAgIH0KKworICAgIGlmICghZGVub20gfHwg IW51bWVyIHx8IG51bWVyID49IGRlbm9tKQorICAgICAgICByZXR1cm4gMDsKKworICAgIGZsb2F0 IHIgPSBudW1lciAvIGRlbm9tOworICAgIGlmIChpc25hbihyKSkKKyAgICAgICAgcmV0dXJuIDA7 CisgICAgQVNTRVJUKHIgPj0gMCAmJiByIDwgMSk7CisgICAgaWYgKCFyKSAvLyBjYXRjaCB1bmRl cmZsb3cgaWYgbnVtZXIgPDw8PCBkZW5vbQorICAgICAgICByZXR1cm4gMDsKKyAgICAqcmF0aW8g PSByOworICAgIHJldHVybiAxOworfQorCisvKiogRnJvbSBOdW1lcmljYWwgUmVjaXBlcyBpbiBD LgorCisgICAgcSA9IC0xLzIgKGIgKyBzaWduKGIpIHNxcnRbYipiIC0gNCphKmNdKQorICAgIHgx ID0gcSAvIGEKKyAgICB4MiA9IGMgLyBxCisqLworc3RhdGljIGludCBmaW5kVW5pdFF1YWRSb290 cyhmbG9hdCBhLCBmbG9hdCBiLCBmbG9hdCBjLCBmbG9hdCByb290c1syXSkKK3sKKyAgICBpZiAo IWEpCisgICAgICAgIHJldHVybiB2YWxpZFVuaXREaXZpZGUoLWMsIGIsIHJvb3RzKTsKKworICAg IGZsb2F0KiByID0gcm9vdHM7CisKKyAgICBmbG9hdCBSID0gYipiIC0gNCphKmM7CisgICAgaWYg KFIgPCAwIHx8IGlzbmFuKFIpKSAvLyBjb21wbGV4IHJvb3RzCisgICAgICAgIHJldHVybiAwOwor ICAgIFIgPSBzcXJ0ZihSKTsKKworICAgIGZsb2F0IFEgPSAoYiA8IDApID8gLShiLVIpLzIgOiAt KGIrUikvMjsKKyAgICByICs9IHZhbGlkVW5pdERpdmlkZShRLCBhLCByKTsKKyAgICByICs9IHZh bGlkVW5pdERpdmlkZShjLCBRLCByKTsKKyAgICBpZiAociAtIHJvb3RzID09IDIpCisgICAgewor ICAgICAgICBpZiAocm9vdHNbMF0gPiByb290c1sxXSkKKyAgICAgICAgICAgIHN0ZDo6c3dhcChy b290c1swXSwgcm9vdHNbMV0pOworICAgICAgICBlbHNlIGlmIChyb290c1swXSA9PSByb290c1sx XSkgIC8vIG5lYXJseS1lcXVhbD8KKyAgICAgICAgICAgIHIgLT0gMTsgLy8gc2tpcCB0aGUgZG91 YmxlIHJvb3QKKyAgICB9CisgICAgcmV0dXJuIChpbnQpKHIgLSByb290cyk7Cit9CisKKy8qKiBD dWJpYycodCkgPSBwdF4yICsgcXQgKyByLCB3aGVyZQorICAgIHAgPSAzKC1hICsgMyhiIC0gYykg KyBkKQorICAgIHEgPSA2KGEgLSAyYiArIGMpCisgICAgciA9IDMoYiAtIGEpCisgICAgU29sdmUg Zm9yIHQsIGtlZXBpbmcgb25seSB0aG9zZSB0aGF0IGZpdCBiZXR3ZWUgMCA8IHQgPCAxCisqLwor c3RhdGljIGludCBmaW5kQ3ViaWNFeHRyZW1hKGZsb2F0IGEsIGZsb2F0IGIsIGZsb2F0IGMsIGZs b2F0IGQsIGZsb2F0IHRWYWx1ZXNbMl0pCit7CisgICAgLy8gd2UgZGl2aWRlIHAsIHEsIGFuZCBy IGJ5IDMgdG8gc2ltcGxpZnkKKyAgICBmbG9hdCBwID0gZCAtIGEgKyAzKihiIC0gYyk7CisgICAg ZmxvYXQgcSA9IDIqKGEgLSBiIC0gYiArIGMpOworICAgIGZsb2F0IHIgPSBiIC0gYTsKKworICAg IHJldHVybiBmaW5kVW5pdFF1YWRSb290cyhwLCBxLCByLCB0VmFsdWVzKTsKK30KKworc3RhdGlj IHZvaWQgaW50ZXJwQ3ViaWNDb29yZHMoZmxvYXQgczAsIGZsb2F0IHMyLCBmbG9hdCBzNCwgZmxv YXQgczYsIGZsb2F0KiBkc3QsIGZsb2F0IHQpCit7CisgICAgZmxvYXQgYWIgPSBpbnRlcnAoczAs IHMyLCB0KTsKKyAgICBmbG9hdCBiYyA9IGludGVycChzMiwgczQsIHQpOworICAgIGZsb2F0IGNk ID0gaW50ZXJwKHM0LCBzNiwgdCk7CisgICAgZmxvYXQgYWJjID0gaW50ZXJwKGFiLCBiYywgdCk7 CisgICAgZmxvYXQgYmNkID0gaW50ZXJwKGJjLCBjZCwgdCk7CisgICAgZmxvYXQgYWJjZCA9IGlu dGVycChhYmMsIGJjZCwgdCk7CisKKyAgICBkc3RbMF0gPSBzMDsKKyAgICBkc3RbMl0gPSBhYjsK KyAgICBkc3RbNF0gPSBhYmM7CisgICAgZHN0WzZdID0gYWJjZDsKKyAgICBkc3RbOF0gPSBiY2Q7 CisgICAgZHN0WzEwXSA9IGNkOworICAgIGRzdFsxMl0gPSBzNjsKK30KKworI2lmbmRlZiBOREVC VUcKK3N0YXRpYyBib29sIGlzVW5pdEludGVydmFsKGZsb2F0IHgpCit7CisgICAgcmV0dXJuIHgg PiAwICYmIHggPCAxOworfQorI2VuZGlmCisKKy8qICBodHRwOi8vY29kZS5nb29nbGUuY29tL3Av c2tpYS9pc3N1ZXMvZGV0YWlsP2lkPTMyCisKKyAgICBUaGlzIHRlc3QgY29kZSB3b3VsZCBmYWls IHdoZW4gd2UgZGlkbid0IGNoZWNrIHRoZSByZXR1cm4gcmVzdWx0IG9mCisgICAgdmFsaWRfdW5p dF9kaXZpZGUgaW4gU2tDaG9wQ3ViaWNBdCguLi4gdFZhbHVlc1tdLCBpbnQgcm9vdHMpLiBUaGUg cmVhc29uIGlzCisgICAgdGhhdCBhZnRlciB0aGUgZmlyc3QgY2hvcCwgdGhlIHBhcmFtZXRlcnMg dG8gdmFsaWRfdW5pdF9kaXZpZGUgYXJlIGVxdWFsCisgICAgKHRoYW5rcyB0byBmaW5pdGUgZmxv YXQgcHJlY2lzaW9uIGFuZCByb3VuZGluZyBpbiB0aGUgc3VidHJhY3RzKS4gVGh1cworICAgIGV2 ZW4gdGhvdWdoIHRoZSAybmQgdFZhbHVlIGxvb2tzIDwgMS4wLCBhZnRlciB3ZSByZW5vcm1hbGl6 ZSBpdCwgd2UgZW5kCisgICAgdXAgd2l0aCAxLjAsIGhlbmNlIHRoZSBuZWVkIHRvIGNoZWNrIGFu ZCBqdXN0IHJldHVybiB0aGUgbGFzdCBjdWJpYyBhcworICAgIGEgZGVnZW5lcmF0ZSBjbHVtcCBv ZiA0IHBvaW50cyBpbiB0aGUgc2FtZSBwbGFjZS4KKworICAgIHN0YXRpYyB2b2lkIHRlc3RfY3Vi aWMoKSB7CisgICAgICAgIFNrUG9pbnQgc3JjWzRdID0geworICAgICAgICAgICAgeyA1NTYuMjUw MDAsIDUyMy4wMzAwMyB9LAorICAgICAgICAgICAgeyA1NTYuMjM5OTksIDUyMi45NjAwMiB9LAor ICAgICAgICAgICAgeyA1NTYuMjE5OTcsIDUyMi44OTAwMSB9LAorICAgICAgICAgICAgeyA1NTYu MjE5OTcsIDUyMi44MjAwMSB9CisgICAgICAgIH07CisgICAgICAgIFNrUG9pbnQgZHN0WzEwXTsK KyAgICAgICAgU2tTY2FsYXIgdHZhbFtdID0geyAwLjMzMzMzMzM0ZiwgMC45OTk5OTk5NGYgfTsK KyAgICAgICAgU2tDaG9wQ3ViaWNBdChzcmMsIGRzdCwgdHZhbCwgMik7CisgICAgfQorKi8KKwor c3RhdGljIHZvaWQgY2hvcEN1YmljQXQoY29uc3QgRmxvYXRQb2ludCBzcmNbNF0sIEZsb2F0UG9p bnQgZHN0W10sIGNvbnN0IGZsb2F0IHRWYWx1ZXNbXSwgaW50IHJvb3RzKQoreworI2lmbmRlZiBO REVCVUcKKyAgICBmb3IgKGludCBpID0gMDsgaSA8IHJvb3RzIC0gMTsgaSsrKSB7CisgICAgICAg IEFTU0VSVChpc1VuaXRJbnRlcnZhbCh0VmFsdWVzW2ldKSk7CisgICAgICAgIEFTU0VSVChpc1Vu aXRJbnRlcnZhbCh0VmFsdWVzW2krMV0pKTsKKyAgICAgICAgQVNTRVJUKHRWYWx1ZXNbaV0gPCB0 VmFsdWVzW2krMV0pOworICAgIH0KKyNlbmRpZgorCisgICAgaWYgKGRzdCkgeworICAgICAgICBp ZiAocm9vdHMgPT0gMCkgLy8gbm90aGluZyB0byBjaG9wCisgICAgICAgICAgICBtZW1jcHkoZHN0 LCBzcmMsIDQqc2l6ZW9mKEZsb2F0UG9pbnQpKTsKKyAgICAgICAgZWxzZQorICAgICAgICB7Cisg ICAgICAgICAgICBmbG9hdCB0ID0gdFZhbHVlc1swXTsKKyAgICAgICAgICAgIEZsb2F0UG9pbnQg dG1wWzRdOworCisgICAgICAgICAgICBmb3IgKGludCBpID0gMDsgaSA8IHJvb3RzOyBpKyspIHsK KyAgICAgICAgICAgICAgICBjaG9wQ3ViaWNBdChzcmMsIGRzdCwgdCk7CisgICAgICAgICAgICAg ICAgaWYgKGkgPT0gcm9vdHMgLSAxKQorICAgICAgICAgICAgICAgICAgICBicmVhazsKKworICAg ICAgICAgICAgICAgIGRzdCArPSAzOworICAgICAgICAgICAgICAgIC8vIGhhdmUgc3JjIHBvaW50 IHRvIHRoZSByZW1haW5pbmcgY3ViaWMgKGFmdGVyIHRoZSBjaG9wKQorICAgICAgICAgICAgICAg IG1lbWNweSh0bXAsIGRzdCwgNCAqIHNpemVvZihGbG9hdFBvaW50KSk7CisgICAgICAgICAgICAg ICAgc3JjID0gdG1wOworCisgICAgICAgICAgICAgICAgLy8gd2F0Y2ggb3V0IGluIGNhc2UgdGhl IHJlbm9ybWFsaXplZCB0IGlzbid0IGluIHJhbmdlCisgICAgICAgICAgICAgICAgaWYgKCF2YWxp ZFVuaXREaXZpZGUodFZhbHVlc1tpKzFdIC0gdFZhbHVlc1tpXSwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAxIC0gdFZhbHVlc1tpXSwgJnQpKSB7CisgICAgICAgICAgICAg ICAgICAgIC8vIGlmIHdlIGNhbid0LCBqdXN0IGNyZWF0ZSBhIGRlZ2VuZXJhdGUgY3ViaWMKKyAg ICAgICAgICAgICAgICAgICAgZHN0WzRdID0gZHN0WzVdID0gZHN0WzZdID0gc3JjWzNdOworICAg ICAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICB9 CisgICAgICAgIH0KKyAgICB9Cit9CisKK3N0YXRpYyB2b2lkIGZsYXR0ZW5Eb3VibGVDdWJpY1lF eHRyZW1hKEZsb2F0UG9pbnQgY29vcmRzWzddKQoreworICAgIGNvb3Jkc1syXS5zZXRZKGNvb3Jk c1szXS55KCkpOworICAgIGNvb3Jkc1s0XS5zZXRZKGNvb3Jkc1szXS55KCkpOworfQorCitzdGF0 aWMgaW50IGNob3BDdWJpY0F0WUV4dHJlbWEoY29uc3QgRmxvYXRQb2ludCBzcmNbNF0sIEZsb2F0 UG9pbnQgZHN0WzEwXSkgeworICAgIGZsb2F0IHRWYWx1ZXNbMl07CisgICAgaW50IHJvb3RzID0g ZmluZEN1YmljRXh0cmVtYShzcmNbMF0ueSgpLCBzcmNbMV0ueSgpLCBzcmNbMl0ueSgpLCBzcmNb M10ueSgpLCB0VmFsdWVzKTsKKworICAgIGNob3BDdWJpY0F0KHNyYywgZHN0LCB0VmFsdWVzLCBy b290cyk7CisgICAgaWYgKGRzdCAmJiByb290cyA+IDApIHsKKyAgICAgICAgLy8gd2UgZG8gc29t ZSBjbGVhbnVwIHRvIGVuc3VyZSBvdXIgWSBleHRyZW1hIGFyZSBmbGF0CisgICAgICAgIGZsYXR0 ZW5Eb3VibGVDdWJpY1lFeHRyZW1hKCZkc3RbMF0pOworICAgICAgICBpZiAocm9vdHMgPT0gMikK KyAgICAgICAgICAgIGZsYXR0ZW5Eb3VibGVDdWJpY1lFeHRyZW1hKCZkc3RbM10pOworICAgIH0K KyAgICByZXR1cm4gcm9vdHM7Cit9CisKKy8vIFB1YmxpYyBjdWJpYyBvcGVyYXRpb25zLgorCit2 b2lkIGNob3BDdWJpY0F0KGNvbnN0IEZsb2F0UG9pbnQgc3JjWzRdLCBGbG9hdFBvaW50IGRzdFs3 XSwgZmxvYXQgdCkKK3sKKyAgICBBU1NFUlQodCA+IDAgJiYgdCA8IDEpOworCisgICAgZmxvYXQg b3V0cHV0WzE0XTsKKyAgICBpbnRlcnBDdWJpY0Nvb3JkcyhzcmNbMF0ueCgpLCBzcmNbMV0ueCgp LCBzcmNbMl0ueCgpLCBzcmNbM10ueCgpLCAmb3V0cHV0WzBdLCB0KTsKKyAgICBpbnRlcnBDdWJp Y0Nvb3JkcyhzcmNbMF0ueSgpLCBzcmNbMV0ueSgpLCBzcmNbMl0ueSgpLCBzcmNbM10ueSgpLCAm b3V0cHV0WzFdLCB0KTsKKyAgICBmb3IgKGludCBpID0gMDsgaSA8IDc7IGkrKykKKyAgICAgICAg ZHN0W2ldLnNldChvdXRwdXRbMiAqIGldLCBvdXRwdXRbMiAqIGkgKyAxXSk7Cit9CisKKy8vIFB1 YmxpYyBYUmF5IHF1ZXJpZXMuCisKK2Jvb2wgeFJheUNyb3NzZXNMaW5lKGNvbnN0IFhSYXkmIHhS YXksIGNvbnN0IEZsb2F0UG9pbnQgcHRzWzJdLCBib29sKiBhbWJpZ3VvdXMpCit7CisgICAgaWYg KGFtYmlndW91cykKKyAgICAgICAgKmFtYmlndW91cyA9IGZhbHNlOworCisgICAgLy8gRGV0ZXJt aW5lIHF1aWNrIGRpc2NhcmRzLgorICAgIC8vIENvbnNpZGVyIHF1ZXJ5IGxpbmUgZ29pbmcgZXhh Y3RseSB0aHJvdWdoIHBvaW50IDAgdG8gbm90CisgICAgLy8gaW50ZXJzZWN0LCBmb3Igc3ltbWV0 cnkgd2l0aCBTa1hSYXlDcm9zc2VzTW9ub3RvbmljQ3ViaWMuCisgICAgaWYgKHhSYXkueSgpID09 IHB0c1swXS55KCkpIHsKKyAgICAgICAgaWYgKGFtYmlndW91cykKKyAgICAgICAgICAgICphbWJp Z3VvdXMgPSB0cnVlOworICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgfQorICAgIGlmICh4UmF5 LnkoKSA8IHB0c1swXS55KCkgJiYgeFJheS55KCkgPCBwdHNbMV0ueSgpKQorICAgICAgICByZXR1 cm4gZmFsc2U7CisgICAgaWYgKHhSYXkueSgpID4gcHRzWzBdLnkoKSAmJiB4UmF5LnkoKSA+IHB0 c1sxXS55KCkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICBpZiAoeFJheS54KCkgPiBwdHNb MF0ueCgpICYmIHhSYXkueCgpID4gcHRzWzFdLngoKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOwor ICAgIC8vIERldGVybWluZSBkZWdlbmVyYXRlIGNhc2VzCisgICAgaWYgKG5lYXJseVplcm8ocHRz WzBdLnkoKSAtIHB0c1sxXS55KCkpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgaWYgKG5l YXJseVplcm8ocHRzWzBdLngoKSAtIHB0c1sxXS54KCkpKSB7CisgICAgICAgIC8vIFdlJ3ZlIGFs cmVhZHkgZGV0ZXJtaW5lZCB0aGUgcXVlcnkgcG9pbnQgbGllcyB3aXRoaW4gdGhlCisgICAgICAg IC8vIHZlcnRpY2FsIHJhbmdlIG9mIHRoZSBsaW5lIHNlZ21lbnQuCisgICAgICAgIGlmICh4UmF5 LngoKSA8PSBwdHNbMF0ueCgpKSB7CisgICAgICAgICAgICBpZiAoYW1iaWd1b3VzKQorICAgICAg ICAgICAgICAgICphbWJpZ3VvdXMgPSAoeFJheS55KCkgPT0gcHRzWzFdLnkoKSk7CisgICAgICAg ICAgICByZXR1cm4gdHJ1ZTsKKyAgICAgICAgfQorICAgICAgICByZXR1cm4gZmFsc2U7CisgICAg fQorICAgIC8vIEFtYmlndWl0eSBjaGVjaworICAgIGlmICh4UmF5LnkoKSA9PSBwdHNbMV0ueSgp KSB7CisgICAgICAgIGlmICh4UmF5LngoKSA8PSBwdHNbMV0ueCgpKSB7CisgICAgICAgICAgICBp ZiAoYW1iaWd1b3VzKQorICAgICAgICAgICAgICAgICphbWJpZ3VvdXMgPSB0cnVlOworICAgICAg ICAgICAgcmV0dXJuIHRydWU7CisgICAgICAgIH0KKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAg IH0KKyAgICAvLyBGdWxsIGxpbmUgc2VnbWVudCBldmFsdWF0aW9uCisgICAgZmxvYXQgZGVsdGFZ ID0gcHRzWzFdLnkoKSAtIHB0c1swXS55KCk7CisgICAgZmxvYXQgZGVsdGFYID0gcHRzWzFdLngo KSAtIHB0c1swXS54KCk7CisgICAgZmxvYXQgc2xvcGUgPSBkZWx0YVkgLyBkZWx0YVg7CisgICAg ZmxvYXQgYiA9IHB0c1swXS55KCkgLSBzbG9wZSAqIHB0c1swXS54KCk7CisgICAgLy8gU29sdmUg Zm9yIHggY29vcmRpbmF0ZSBhdCB5ID0geFJheS55KCkKKyAgICBmbG9hdCB4ID0gKHhSYXkueSgp IC0gYikgLyBzbG9wZTsKKyAgICByZXR1cm4geFJheS54KCkgPD0geDsKK30KKworaW50IG51bVhS YXlDcm9zc2luZ3NGb3JDdWJpYyhjb25zdCBYUmF5JiBwdCwgY29uc3QgRmxvYXRQb2ludCBjdWJp Y1s0XSwgYm9vbCogYW1iaWd1b3VzKQoreworICAgIGludCBudW1Dcm9zc2luZ3MgPSAwOworICAg IEZsb2F0UG9pbnQgbW9ub3RvbmljQ3ViaWNzWzEwXTsKKyAgICBpbnQgbnVtTW9ub3RvbmljQ3Vi aWNzID0gY2hvcEN1YmljQXRZRXh0cmVtYShjdWJpYywgbW9ub3RvbmljQ3ViaWNzKTsKKyAgICBp ZiAoYW1iaWd1b3VzKSB7CisgICAgICAgICphbWJpZ3VvdXMgPSBmYWxzZTsKKyAgICB9CisgICAg Ym9vbCBsb2NhbGx5QW1iaWd1b3VzOworICAgIGlmICh4UmF5Q3Jvc3Nlc01vbm90b25pY0N1Ymlj KHB0LCAmbW9ub3RvbmljQ3ViaWNzWzBdLCAmbG9jYWxseUFtYmlndW91cykpCisgICAgICAgICsr bnVtQ3Jvc3NpbmdzOworICAgIGlmIChhbWJpZ3VvdXMpIHsKKyAgICAgICAgKmFtYmlndW91cyB8 PSBsb2NhbGx5QW1iaWd1b3VzOworICAgIH0KKyAgICBpZiAobnVtTW9ub3RvbmljQ3ViaWNzID4g MCkKKyAgICAgICAgaWYgKHhSYXlDcm9zc2VzTW9ub3RvbmljQ3ViaWMocHQsICZtb25vdG9uaWND dWJpY3NbM10sICZsb2NhbGx5QW1iaWd1b3VzKSkKKyAgICAgICAgICAgICsrbnVtQ3Jvc3Npbmdz OworICAgIGlmIChhbWJpZ3VvdXMpIHsKKyAgICAgICAgKmFtYmlndW91cyB8PSBsb2NhbGx5QW1i aWd1b3VzOworICAgIH0KKyAgICBpZiAobnVtTW9ub3RvbmljQ3ViaWNzID4gMSkKKyAgICAgICAg aWYgKHhSYXlDcm9zc2VzTW9ub3RvbmljQ3ViaWMocHQsICZtb25vdG9uaWNDdWJpY3NbNl0sICZs b2NhbGx5QW1iaWd1b3VzKSkKKyAgICAgICAgICAgICsrbnVtQ3Jvc3NpbmdzOworICAgIGlmIChh bWJpZ3VvdXMpIHsKKyAgICAgICAgKmFtYmlndW91cyB8PSBsb2NhbGx5QW1iaWd1b3VzOworICAg IH0KKyAgICByZXR1cm4gbnVtQ3Jvc3NpbmdzOworfQorCit9IC8vIG5hbWVzcGFjZSBncHUKK30g Ly8gbmFtZXNwYWNlIFdlYkNvcmUKSW5kZXg6IFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1 L0N1YmljTWF0aFV0aWxzLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9ncHUvQ3ViaWNNYXRoVXRpbHMuaAkocmV2aXNpb24gMCkKKysrIFdlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvZ3B1L0N1YmljTWF0aFV0aWxzLmgJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMTUz IEBACisvKgorICogQ29weXJpZ2h0IDIwMTAsIEdvb2dsZSBJbmMuCisgKiBBbGwgcmlnaHRzIHJl c2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5h cnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVk IHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorICogbWV0OgorICoK KyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUg YWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmlu YXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5cmlnaHQgbm90aWNlLCB0 aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisgKiBp biB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGgg dGhlCisgKiBkaXN0cmlidXRpb24uCisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9mIEdvb2ds ZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisgKiBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQg dG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorICogdGhpcyBzb2Z0 d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBU SElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09O VFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJ RVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFO VElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VMQVIg UFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAor ICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJF Q1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwg REFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBP RiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEsIE9S IFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9O IEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNU IExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lT RSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJF LCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICov CisKKyNpZm5kZWYgZ3B1X0N1YmljTWF0aFV0aWxzX2gKKyNkZWZpbmUgZ3B1X0N1YmljTWF0aFV0 aWxzX2gKKworI2luY2x1ZGUgIlRyYW5zZm9ybWF0aW9uTWF0cml4LmgiCisjaW5jbHVkZSA8bWF0 aC5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIEZsb2F0UG9pbnQ7CisKK25hbWVz cGFjZSBncHUgeworCisvLyBBIHJvdW5kb2ZmIGZhY3RvciBpbiB0aGUgY3ViaWMgY2xhc3NpZmlj YXRpb24gYW5kIHRleHR1cmUgY29vcmRpbmF0ZQorLy8gZ2VuZXJhdGlvbiBhbGdvcml0aG1zLiBU aGlzIHByaW1hcmlseSBkZXRlcm1pbmVzIHRoZSBoYW5kbGluZyBvZiBjb3JuZXIKKy8vIGNhc2Vz IGR1cmluZyB0aGUgY2xhc3NpZmljYXRpb24gcHJvY2Vzcy4gQmUgY2FyZWZ1bCB3aGVuIGFkanVz dGluZyB0aGlzOworLy8gaXQgaGFzIGJlZW4gZGV0ZXJtaW5lZCBlbXBpcmljYWxseSB0byB3b3Jr IHdlbGwuCitjb25zdCBmbG9hdCBFcHNpbG9uID0gNS4wZS00ZjsKKworLy8gUmV0dXJucyB6ZXJv IGlmIHZhbHVlIGlzIHdpdGhpbiArLy1rRXBzaWxvbiBvZiB6ZXJvLgoraW5saW5lIGZsb2F0IHJv dW5kVG9aZXJvKGZsb2F0IHZhbCkKK3sKKyAgICBpZiAodmFsIDwgRXBzaWxvbiAmJiB2YWwgPiAt RXBzaWxvbikKKyAgICAgICAgcmV0dXJuIDA7CisgICAgcmV0dXJuIHZhbDsKK30KKworLy8gUmV0 dXJucyBkaXN0YW5jZSBiZXR3ZWVuIHR3byBwb2ludHMgaW4gdGhlIDJEIHBsYW5lLgoraW5saW5l IGZsb2F0IGRpc3RhbmNlKGZsb2F0IHgwLCBmbG9hdCB5MCwKKyAgICAgICAgICAgICAgICAgICAg ICBmbG9hdCB4MSwgZmxvYXQgeTEpCit7CisgICAgZmxvYXQgeGQgPSB4MSAtIHgwOworICAgIGZs b2F0IHlkID0geTEgLSB5MDsKKyAgICByZXR1cm4gc3FydGYoeGQgKiB4ZCArIHlkICogeWQpOwor fQorCisvLyBSZXR1cm5zIHRydWUgaWYgdGhlIGdpdmVuIHBvaW50cyBhcmUgd2l0aGluIEVwc2ls b24gZGlzdGFuY2Ugb2YKKy8vIGVhY2ggb3RoZXIuCitpbmxpbmUgYm9vbCBhcHByb3hFcXVhbChj b25zdCBWZWN0b3IzJiB2MCwgY29uc3QgVmVjdG9yMyYgdjEpCit7CisgICAgcmV0dXJuICh2MCAt IHYxKS5sZW5ndGhTcXVhcmVkKCkgPCBFcHNpbG9uICogRXBzaWxvbjsKK30KKworLy8gUmV0dXJu cyB0cnVlIGlmIHRoZSBnaXZlbiAyRCBwb2ludHMgYXJlIHdpdGhpbiBFcHNpbG9uIGRpc3RhbmNl IG9mCisvLyBlYWNoIG90aGVyLgoraW5saW5lIGJvb2wgYXBwcm94RXF1YWwoZmxvYXQgeDAsIGZs b2F0IHkwLAorICAgICAgICAgICAgICAgICAgICAgICAgZmxvYXQgeDEsIGZsb2F0IHkxKQorewor ICAgIHJldHVybiBkaXN0YW5jZSh4MCwgeTAsIHgxLCB5MSkgPCBFcHNpbG9uOworfQorCisvLyBS ZXR1cm5zIHRydWUgaWYgdGhlIGdpdmVuIHNjYWxhciB2YWx1ZXMgYXJlIHdpdGhpbiBFcHNpbG9u IG9mIGVhY2ggb3RoZXIuCitpbmxpbmUgYm9vbCBhcHByb3hFcXVhbChmbG9hdCBmMCwgZmxvYXQg ZjEpCit7CisgICAgcmV0dXJuIGZhYnNmKGYwIC0gZjEpIDwgRXBzaWxvbjsKK30KKworLy8gRGV0 ZXJtaW5lcyB3aGV0aGVyIHRoZSBsaW5lIHNlZ21lbnQgYmV0d2VlbiAocDEsIHExKSBpbnRlcnNl Y3RzCisvLyB0aGF0IGJldHdlZW4gKHAyLCBxMikuCitib29sIGxpbmVzSW50ZXJzZWN0KGZsb2F0 IHAxeCwgZmxvYXQgcDF5LAorICAgICAgICAgICAgICAgICAgICBmbG9hdCBxMXgsIGZsb2F0IHEx eSwKKyAgICAgICAgICAgICAgICAgICAgZmxvYXQgcDJ4LCBmbG9hdCBwMnksCisgICAgICAgICAg ICAgICAgICAgIGZsb2F0IHEyeCwgZmxvYXQgcTJ5KTsKKworLy8gRGV0ZXJtaW5lcyB3aGV0aGVy IHRoZSAyRCBwb2ludCBkZWZpbmVkIGJ5IChweCwgcHkpIGlzIGluc2lkZSB0aGUKKy8vIDJEIHRy aWFuZ2xlIGRlZmluZWQgYnkgdmVydGljZXMgKGF4LCBheSksIChieCwgYnkpLCBhbmQgKGN4LCBj eSkuCisvLyBUaGlzIHRlc3QgZGVmaW5lcyB0aGF0IHBvaW50cyBleGFjdGx5IG9uIGFuIGVkZ2Ug YXJlIG5vdCBjb25zaWRlcmVkCisvLyB0byBiZSBpbnNpZGUgdGhlIHRyaWFuZ2xlLgorYm9vbCBw b2ludEluVHJpYW5nbGUoZmxvYXQgcHgsIGZsb2F0IHB5LAorICAgICAgICAgICAgICAgICAgICAg ZmxvYXQgYXgsIGZsb2F0IGF5LAorICAgICAgICAgICAgICAgICAgICAgZmxvYXQgYngsIGZsb2F0 IGJ5LAorICAgICAgICAgICAgICAgICAgICAgZmxvYXQgY3gsIGZsb2F0IGN5KTsKKworLy8gRGV0 ZXJtaW5lcyB3aGV0aGVyIHRoZSB0cmlhbmdsZXMgZGVmaW5lZCBieSB0aGUgcG9pbnRzIChhMSwg YjEsIGMxKQorLy8gYW5kIChhMiwgYjIsIGMyKSBvdmVybGFwLiBUaGUgZGVmaW5pdGlvbiBvZiB0 aGlzIGZ1bmN0aW9uIGlzIHRoYXQKKy8vIGlmIHRoZSB0d28gdHJpYW5nbGVzIG9ubHkgc2hhcmUg YW4gYWRqYWNlbnQgZWRnZSBvciB2ZXJ0ZXgsIHRoZXkKKy8vIGFyZSBub3QgY29uc2lkZXJlZCB0 byBvdmVybGFwLgorYm9vbCB0cmlhbmdsZXNPdmVybGFwKGZsb2F0IGExeCwgZmxvYXQgYTF5LAor ICAgICAgICAgICAgICAgICAgICAgIGZsb2F0IGIxeCwgZmxvYXQgYjF5LAorICAgICAgICAgICAg ICAgICAgICAgIGZsb2F0IGMxeCwgZmxvYXQgYzF5LAorICAgICAgICAgICAgICAgICAgICAgIGZs b2F0IGEyeCwgZmxvYXQgYTJ5LAorICAgICAgICAgICAgICAgICAgICAgIGZsb2F0IGIyeCwgZmxv YXQgYjJ5LAorICAgICAgICAgICAgICAgICAgICAgIGZsb2F0IGMyeCwgZmxvYXQgYzJ5KTsKKwor Ly8gR2l2ZW4gYSBzcmMgY3ViaWMgYmV6aWVyLCBjaG9wcyBpdCBhdCB0aGUgc3BlY2lmaWVkIHQg dmFsdWUsCisvLyB3aGVyZSAwIDwgdCA8IDEsIGFuZCByZXR1cm5zIHRoZSB0d28gbmV3IGN1Ymlj cyBpbiBkc3RbMC4uM10KKy8vIGFuZCBkc3RbMy4uNl0uCit2b2lkIGNob3BDdWJpY0F0KGNvbnN0 IEZsb2F0UG9pbnQgc3JjWzRdLCBGbG9hdFBvaW50IGRzdFs3XSwgZmxvYXQgdCk7CisKKy8vICJY LVJheSIgcXVlcmllcy4gQW4gWFJheSBpcyBhIGhhbGYtbGluZSBvcmlnaW5hdGluZyBhdCB0aGUg Z2l2ZW4KKy8vIHBvaW50IGFuZCBleHRlbmRpbmcgdG8geD0raW5maW5pdHkuCit0eXBlZGVmIEZs b2F0UG9pbnQgWFJheTsKKworLy8gR2l2ZW4gYW4gYXJiaXRyYXJ5IGN1YmljIGJlemllciwgcmV0 dXJuIHRoZSBudW1iZXIgb2YgdGltZXMgYW4gWFJheQorLy8gY3Jvc3NlcyB0aGUgY3ViaWMuIFZh bGlkIHJldHVybiB2YWx1ZXMgYXJlIFswLi4zXS4KKy8vCisvLyBCeSBkZWZpbml0aW9uIHRoZSBj dWJpYyBpcyBvcGVuIGF0IHRoZSBzdGFydGluZyBwb2ludDsgaW4gb3RoZXIKKy8vIHdvcmRzLCBp ZiBwdC5mWSBpcyBlcXVpdmFsZW50IHRvIGN1YmljWzBdLmZZLCBhbmQgcHQuZlggaXMgdG8gdGhl CisvLyBsZWZ0IG9mIHRoZSBjdXJ2ZSwgdGhlIGxpbmUgaXMgbm90IGNvbnNpZGVyZWQgdG8gY3Jv c3MgdGhlIGN1cnZlLAorLy8gYnV0IGlmIGl0IGlzIGVxdWFsIHRvIGN1YmljWzNdLmZZIHRoZW4g aXQgaXMgY29uc2lkZXJlZCB0bworLy8gY3Jvc3MuCisvLworLy8gT3B0aW9uYWwgb3V0Z29pbmcg ImFtYmlndW91cyIgYXJndW1lbnQgaW5kaWNhdGVzIHdoZXRoZXIgdGhlIGFuc3dlciBpcworLy8g YW1iaWd1b3VzIGJlY2F1c2UgdGhlIHF1ZXJ5IG9jY3VycmVkIGV4YWN0bHkgYXQgb25lIG9mIHRo ZSBlbmRwb2ludHMnIHkKKy8vIGNvb3JkaW5hdGVzIG9yIGF0IGEgdGFuZ2VudCBwb2ludCwgaW5k aWNhdGluZyB0aGF0IGFub3RoZXIgcXVlcnkgeQorLy8gY29vcmRpbmF0ZSBpcyBwcmVmZXJyZWQg Zm9yIHJvYnVzdG5lc3MuCitpbnQgbnVtWFJheUNyb3NzaW5nc0ZvckN1YmljKGNvbnN0IFhSYXkm IHhSYXksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IEZsb2F0UG9pbnQgY3Vi aWNbNF0sCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGJvb2wqIGFtYmlndW91cyA9IDAp OworCisvLyBHaXZlbiBhIGxpbmUgc2VnbWVudCBmcm9tIGxpbmVFbmRwb2ludHNbMF0gdG8gbGlu ZUVuZHBvaW50c1sxXSwgYW5kIGFuCisvLyBYUmF5LCByZXR1cm5zIHRydWUgaWYgdGhleSBpbnRl cnNlY3QuIE9wdGlvbmFsIG91dGdvaW5nICJhbWJpZ3VvdXMiCisvLyBhcmd1bWVudCBpbmRpY2F0 ZXMgd2hldGhlciB0aGUgYW5zd2VyIGlzIGFtYmlndW91cyBiZWNhdXNlIHRoZSBxdWVyeQorLy8g b2NjdXJyZWQgZXhhY3RseSBhdCBvbmUgb2YgdGhlIGVuZHBvaW50cycgeSBjb29yZGluYXRlcywg aW5kaWNhdGluZyB0aGF0CisvLyBhbm90aGVyIHF1ZXJ5IHkgY29vcmRpbmF0ZSBpcyBwcmVmZXJy ZWQgZm9yIHJvYnVzdG5lc3MuCitib29sIHhSYXlDcm9zc2VzTGluZShjb25zdCBYUmF5JiB4UmF5 LAorICAgICAgICAgICAgICAgICAgICAgY29uc3QgRmxvYXRQb2ludCBsaW5lRW5kcG9pbnRzWzJd LAorICAgICAgICAgICAgICAgICAgICAgYm9vbCogYW1iaWd1b3VzID0gMCk7CisKK30gLy8gbmFt ZXNwYWNlIGdwdQorfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gZ3B1X0N1Ymlj TWF0aFV0aWxzX2gKSW5kZXg6IFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L0N1YmljVGV4 dHVyZUNvb3Jkcy5jYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dw dS9DdWJpY1RleHR1cmVDb29yZHMuY2MJKHJldmlzaW9uIDApCisrKyBXZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2dwdS9DdWJpY1RleHR1cmVDb29yZHMuY2MJKHJldmlzaW9uIDApCkBAIC0wLDAg KzEsMTkzIEBACisvKgorICogQ29weXJpZ2h0IDIwMTAsIEdvb2dsZSBJbmMuCisgKiBBbGwgcmln aHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFu ZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVy bWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorICogbWV0 OgorICoKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFp biB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMg aW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5cmlnaHQgbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy CisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVk IHdpdGggdGhlCisgKiBkaXN0cmlidXRpb24uCisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9m IEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisgKiBjb250cmlidXRvcnMgbWF5IGJl IHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorICogdGhp cyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAq CisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBB TkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdB UlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQg V0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJ Q1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlS SUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwg SU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVF TlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJF TUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERB VEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQg QU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwg U1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9U SEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNP RlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdF LgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKworI2luY2x1ZGUgImdwdS9DdWJpY1RleHR1 cmVDb29yZHMuaCIKKworI2luY2x1ZGUgImdwdS9DdWJpY01hdGhVdGlscy5oIgorI2luY2x1ZGUg PG1hdGguaD4KKyNpbmNsdWRlIDx3dGYvQXNzZXJ0aW9ucy5oPgorCituYW1lc3BhY2UgV2ViQ29y ZSB7CituYW1lc3BhY2UgZ3B1IHsKKwordm9pZCBDdWJpY1RleHR1cmVDb29yZHM6OkNvbXB1dGUo Y29uc3QgQ3ViaWNDbGFzc2lmaWVyOjpSZXN1bHQmIGMsCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBib29sIGZpbGxSaWdodFNpZGUsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBDdWJpY1RleHR1cmVDb29yZHM6OlJlc3VsdCogcmVzdWx0KQoreworICAgIC8vIExv b3AgYW5kIEJsaW5uJ3MgZm9ybXVsYXRpb24gc3RhdGVzIHRoYXQgdGhlIHJpZ2h0IHNpZGUgb2Yg dGhlCisgICAgLy8gY3VydmUgaXMgZGVmaW5lZCB0byBiZSB0aGUgaW5zaWRlIChmaWxsZWQgcmVn aW9uKSwgYnV0IGZvciBzb21lCisgICAgLy8gcmVhc29uIGl0IGxvb2tzIGxpa2Ugd2l0aCB0aGUg ZGVmYXVsdCBvcmllbnRhdGlvbiBwYXJhbWV0ZXJzIHdlCisgICAgLy8gYXJlIGZpbGxpbmcgdGhl IGxlZnQgc2lkZSBvZiB0aGUgY3VydmUuIFJlZ2FyZGxlc3MsIGJlY2F1c2Ugd2UKKyAgICAvLyBj YW4gcmVjZWl2ZSBhcmJpdHJhcmlseSBvcmllbnRlZCBjdXJ2ZXMgYXMgaW5wdXQsIHdlIG1pZ2h0 IGhhdmUKKyAgICAvLyB0byByZXZlcnNlIHRoZSBvcmllbnRhdGlvbiBvZiB0aGUgY3ViaWMgdGV4 dHVyZSBjb29yZGluYXRlcyBldmVuCisgICAgLy8gaW4gY2FzZXMgd2hlcmUgdGhlIHBhcGVyIGRv ZW4ndCBzYXkgaXQgaXMgbmVjZXNzYXJ5LgorICAgIGJvb2wgcmV2ZXJzZU9yaWVudGF0aW9uID0g ZmFsc2U7CisgICAgY29uc3QgZmxvYXQgT25lVGhpcmQgPSAxLjBmIC8gMy4wZjsKKyAgICBjb25z dCBmbG9hdCBUd29UaGlyZHMgPSAyLjBmIC8gMy4wZjsKKyAgICBDdWJpY0NsYXNzaWZpZXI6OkN1 cnZlVHlwZSBjdXJ2ZVR5cGUgPSBjLmN1cnZlVHlwZSgpOworCisgICAgcmVzdWx0LT5pc0xpbmVP clBvaW50ID0gZmFsc2U7CisgICAgcmVzdWx0LT5oYXNSZW5kZXJpbmdBcnRpZmFjdCA9IGZhbHNl OworICAgIHJlc3VsdC0+c3ViZGl2aXNpb25QYXJhbWV0ZXJWYWx1ZSA9IDAuMGY7CisKKyAgICBz d2l0Y2ggKGN1cnZlVHlwZSkgeworICAgIGNhc2UgQ3ViaWNDbGFzc2lmaWVyOjprU2VycGVudGlu ZTogeworICAgICAgICBmbG9hdCB0MSA9IHNxcnRmKDkuMGYgKiBjLmQyKCkgKiBjLmQyKCkgLSAx MiAqIGMuZDEoKSAqIGMuZDMoKSk7CisgICAgICAgIGZsb2F0IGxzID0gMy4wZiAqIGMuZDIoKSAt IHQxOworICAgICAgICBmbG9hdCBsdCA9IDYuMGYgKiBjLmQxKCk7CisgICAgICAgIGZsb2F0IG1z ID0gMy4wZiAqIGMuZDIoKSArIHQxOworICAgICAgICBmbG9hdCBtdCA9IGx0OworICAgICAgICBm bG9hdCBsdG1scyA9IGx0IC0gbHM7CisgICAgICAgIGZsb2F0IG10bW1zID0gbXQgLSBtczsKKyAg ICAgICAgcmVzdWx0LT5jb29yZHNbMF0gPSBWZWN0b3IzKGxzICogbXMsCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBscyAqIGxzICogbHMsCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBtcyAqIG1zICogbXMpOworICAgICAgICByZXN1bHQtPmNvb3Jkc1sx XSA9IFZlY3RvcjMoT25lVGhpcmQgKiAoMy4wZiAqIGxzICogbXMgLQorICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbHMgKiBtdCAtCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBsdCAqIG1zKSwKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIGxzICogbHMgKiAobHMgLSBsdCksCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBtcyAqIG1zICogKG1zIC0gbXQpKTsKKyAgICAgICAg cmVzdWx0LT5jb29yZHNbMl0gPSBWZWN0b3IzKE9uZVRoaXJkICogKGx0ICogKG10IC0gMi4wZiAq IG1zKSArCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBs cyAqICgzLjBmICogbXMgLSAyLjBmICogbXQpKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIGx0bWxzICogbHRtbHMgKiBscywKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIG10bW1zICogbXRtbXMgKiBtcyk7CisgICAgICAgIHJlc3VsdC0+Y29vcmRzWzNd ID0gVmVjdG9yMyhsdG1scyAqIG10bW1zLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgLShsdG1scyAqIGx0bWxzICogbHRtbHMpLAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgLShtdG1tcyAqIG10bW1zICogbXRtbXMpKTsKKyAgICAgICAgaWYgKGMuZDEo KSA8IDAuMGYpCisgICAgICAgICAgICByZXZlcnNlT3JpZW50YXRpb24gPSB0cnVlOworICAgICAg ICBicmVhazsKKyAgICB9CisKKyAgICBjYXNlIEN1YmljQ2xhc3NpZmllcjo6a0xvb3A6IHsKKyAg ICAgICAgZmxvYXQgdDEgPSBzcXJ0Zig0LjBmICogYy5kMSgpICogYy5kMygpIC0gMy4wZiAqIGMu ZDIoKSAqIGMuZDIoKSk7CisgICAgICAgIGZsb2F0IGxzID0gYy5kMigpIC0gdDE7CisgICAgICAg IGZsb2F0IGx0ID0gMi4wZiAqIGMuZDEoKTsKKyAgICAgICAgZmxvYXQgbXMgPSBjLmQyKCkgKyB0 MTsKKyAgICAgICAgZmxvYXQgbXQgPSBsdDsKKworICAgICAgICAvLyBGaWd1cmUgb3V0IHdoZXRo ZXIgdGhlcmUgaXMgYSByZW5kZXJpbmcgYXJ0aWZhY3QgcmVxdWlyaW5nCisgICAgICAgIC8vIHRo ZSBjdXJ2ZSB0byBiZSBzdWJkaXZpZGVkIGJ5IHRoZSBjYWxsZXIuCisgICAgICAgIGZsb2F0IHFs ID0gbHMgLyBsdDsKKyAgICAgICAgZmxvYXQgcW0gPSBtcyAvIG10OworICAgICAgICBpZiAoMC4w ZiA8IHFsICYmIHFsIDwgMS4wZikgeworICAgICAgICAgICAgcmVzdWx0LT5oYXNSZW5kZXJpbmdB cnRpZmFjdCA9IHRydWU7CisgICAgICAgICAgICByZXN1bHQtPnN1YmRpdmlzaW9uUGFyYW1ldGVy VmFsdWUgPSBxbDsKKyAgICAgICAgICAgIC8vIFRPRE8oa2JyKTogbWF5IHJlcXVpcmUgbW9yZSB3 b3JrPworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIH0KKworICAgICAgICBpZiAoMC4wZiA8 IHFtICYmIHFtIDwgMS4wZikgeworICAgICAgICAgICAgcmVzdWx0LT5oYXNSZW5kZXJpbmdBcnRp ZmFjdCA9IHRydWU7CisgICAgICAgICAgICByZXN1bHQtPnN1YmRpdmlzaW9uUGFyYW1ldGVyVmFs dWUgPSBxbTsKKyAgICAgICAgICAgIC8vIFRPRE8oa2JyKTogbWF5IHJlcXVpcmUgbW9yZSB3b3Jr PworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIH0KKworICAgICAgICBmbG9hdCBsdG1scyA9 IGx0IC0gbHM7CisgICAgICAgIGZsb2F0IG10bW1zID0gbXQgLSBtczsKKyAgICAgICAgcmVzdWx0 LT5jb29yZHNbMF0gPSBWZWN0b3IzKGxzICogbXMsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBscyAqIGxzICogbXMsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBscyAqIG1zICogbXMpOworICAgICAgICByZXN1bHQtPmNvb3Jkc1sxXSA9CisgICAgICAg ICAgICAgICAgVmVjdG9yMyhPbmVUaGlyZCAqICgtbHMgKiBtdCAtIGx0ICogbXMgKyAzLjBmICog bHMgKiBtcyksCisgICAgICAgICAgICAgICAgICAgICAgICAtT25lVGhpcmQgKiBscyAqIChscyAq IChtdCAtIDMuMGYgKiBtcykgKyAyLjBmICogbHQgKiBtcyksCisgICAgICAgICAgICAgICAgICAg ICAgICAtT25lVGhpcmQgKiBtcyAqIChscyAqICgyLjBmICogbXQgLSAzLjBmICogbXMpICsgbHQg KiBtcykpOworICAgICAgICByZXN1bHQtPmNvb3Jkc1syXSA9CisgICAgICAgICAgICAgICAgVmVj dG9yMyhPbmVUaGlyZCAqIChsdCAqIChtdCAtIDIuMGYgKiBtcykgKworICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgbHMgKiAoMy4wZiAqIG1zIC0gMi4wZiAqIG10KSksCisgICAg ICAgICAgICAgICAgICAgICAgICBPbmVUaGlyZCAqIChsdCAtIGxzKSAqIChscyAqICgyLjBmICog bXQgLSAzLjBmICogbXMpICsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIGx0ICogbXMpLAorICAgICAgICAgICAgICAgICAgICAgICAgT25lVGhpcmQgKiAo bXQgLSBtcykgKiAobHMgKiAobXQgLSAzLjBmICogbXMpICsKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIDIuMGYgKiBsdCAqIG1zKSk7CisgICAgICAgIHJl c3VsdC0+Y29vcmRzWzNdID0KKyAgICAgICAgICAgICAgICBWZWN0b3IzKGx0bWxzICogbXRtbXMs CisgICAgICAgICAgICAgICAgICAgICAgICAtKGx0bWxzICogbHRtbHMpICogbXRtbXMsCisgICAg ICAgICAgICAgICAgICAgICAgICAtbHRtbHMgKiBtdG1tcyAqIG10bW1zKTsKKyAgICAgICAgcmV2 ZXJzZU9yaWVudGF0aW9uID0KKyAgICAgICAgICAgICAgICAoKGMuZDEoKSA+IDAuMGYgJiYgcmVz dWx0LT5jb29yZHNbMF0ueCgpIDwgMC4wZikgfHwKKyAgICAgICAgICAgICAgICAgKGMuZDEoKSA8 IDAuMGYgJiYgcmVzdWx0LT5jb29yZHNbMF0ueCgpID4gMC4wZikpOworICAgICAgICBicmVhazsK KyAgICB9CisKKyAgICBjYXNlIEN1YmljQ2xhc3NpZmllcjo6a0N1c3A6IHsKKyAgICAgICAgZmxv YXQgbHMgPSBjLmQzKCk7CisgICAgICAgIGZsb2F0IGx0ID0gMy4wZiAqIGMuZDIoKTsKKyAgICAg ICAgZmxvYXQgbHNtbHQgPSBscyAtIGx0OworICAgICAgICByZXN1bHQtPmNvb3Jkc1swXSA9IFZl Y3RvcjMobHMsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBscyAqIGxzICog bHMsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAxLjBmKTsKKyAgICAgICAg cmVzdWx0LT5jb29yZHNbMV0gPSBWZWN0b3IzKGxzIC0gT25lVGhpcmQgKiBsdCwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIGxzICogbHMgKiBsc21sdCwKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIDEuMGYpOworICAgICAgICByZXN1bHQtPmNvb3Jkc1sy XSA9IFZlY3RvcjMobHMgLSBUd29UaGlyZHMgKiBsdCwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIGxzbWx0ICogbHNtbHQgKiBscywKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIDEuMGYpOworICAgICAgICByZXN1bHQtPmNvb3Jkc1szXSA9IFZlY3RvcjMo bHNtbHQsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBsc21sdCAqIGxzbWx0 ICogbHNtbHQsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAxLjBmKTsKKyAg ICAgICAgYnJlYWs7CisgICAgfQorCisgICAgY2FzZSBDdWJpY0NsYXNzaWZpZXI6OmtRdWFkcmF0 aWM6IHsKKyAgICAgICAgcmVzdWx0LT5jb29yZHNbMF0gPSBWZWN0b3IzKDAsIDAsIDApOworICAg ICAgICByZXN1bHQtPmNvb3Jkc1sxXSA9IFZlY3RvcjMoT25lVGhpcmQsIDAsIE9uZVRoaXJkKTsK KyAgICAgICAgcmVzdWx0LT5jb29yZHNbMl0gPSBWZWN0b3IzKFR3b1RoaXJkcywgT25lVGhpcmQs IFR3b1RoaXJkcyk7CisgICAgICAgIHJlc3VsdC0+Y29vcmRzWzNdID0gVmVjdG9yMygxLCAxLCAx KTsKKyAgICAgICAgaWYgKGMuZDMoKSA8IDApCisgICAgICAgICAgICByZXZlcnNlT3JpZW50YXRp b24gPSB0cnVlOworICAgICAgICBicmVhazsKKyAgICB9CisKKyAgICBjYXNlIEN1YmljQ2xhc3Np Zmllcjo6a0xpbmU6CisgICAgY2FzZSBDdWJpY0NsYXNzaWZpZXI6OmtQb2ludDoKKyAgICAgICAg cmVzdWx0LT5pc0xpbmVPclBvaW50ID0gdHJ1ZTsKKyAgICAgICAgYnJlYWs7CisKKyAgICBkZWZh dWx0OgorICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICAgICAgYnJlYWs7CisgICAg fQorCisgICAgaWYgKGZpbGxSaWdodFNpZGUpCisgICAgICAgIHJldmVyc2VPcmllbnRhdGlvbiA9 ICFyZXZlcnNlT3JpZW50YXRpb247CisKKyAgICBpZiAocmV2ZXJzZU9yaWVudGF0aW9uKQorICAg ICAgICBmb3IgKGludCBpID0gMDsgaSA8IDQ7IGkrKykgeworICAgICAgICAgICAgcmVzdWx0LT5j b29yZHNbaV0uc2V0WCgtcmVzdWx0LT5jb29yZHNbaV0ueCgpKTsKKyAgICAgICAgICAgIHJlc3Vs dC0+Y29vcmRzW2ldLnNldFkoLXJlc3VsdC0+Y29vcmRzW2ldLnkoKSk7CisgICAgICAgIH0KK30K KworfSAvLyBuYW1lc3BhY2UgZ3B1Cit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCkluZGV4OiBXZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9DdWJpY1RleHR1cmVDb29yZHMuaAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9DdWJpY1RleHR1cmVDb29yZHMuaAko cmV2aXNpb24gMCkKKysrIFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L0N1YmljVGV4dHVy ZUNvb3Jkcy5oCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDk0IEBACisvKgorICogQ29weXJpZ2h0 IDIwMTAsIEdvb2dsZSBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlz dHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0 aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZv bGxvd2luZyBjb25kaXRpb25zIGFyZQorICogbWV0OgorICoKKyAqICAgICAqIFJlZGlzdHJpYnV0 aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIuCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1 Y2UgdGhlIGFib3ZlCisgKiBjb3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9u cyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBh bmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCisgKiBkaXN0cmlidXRpb24u CisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9mIEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMg b2YgaXRzCisgKiBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3Rl IHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorICogdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmlj IHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJ REVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMi IEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5P VAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJ VFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1F RC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVU T1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBT UEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBC VVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9S IFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNT IElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJ QUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAor ICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZ IE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0Yg VEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKy8vIENvbXB1dGVzIHRocmVl LWRpbWVuc2lvbmFsIHRleHR1cmUgY29vcmRpbmF0ZXMgZm9yIHRoZSBjb250cm9sCisvLyBwb2lu dHMgb2YgYSBjdWJpYyBjdXJ2ZSBmb3IgcmVuZGVyaW5nIHZpYSB0aGUgc2hhZGVyIGluICJSZW5k ZXJpbmcKKy8vIFZlY3RvciBBcnQgb24gdGhlIEdQVSIgYnkgTG9vcCBhbmQgQmxpbm4sIEdQVSBH ZW1zIDMsIENoYXB0ZXIgMjUuCisKKyNpZm5kZWYgZ3B1X0N1YmljVGV4dHVyZUNvb3Jkc19oCisj ZGVmaW5lIGdwdV9DdWJpY1RleHR1cmVDb29yZHNfaAorCisjaW5jbHVkZSAiVHJhbnNmb3JtYXRp b25NYXRyaXguaCIKKyNpbmNsdWRlICJncHUvQ3ViaWNDbGFzc2lmaWVyLmgiCisKKyNpbmNsdWRl IDx3dGYvTm9uY29weWFibGUuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworbmFtZXNwYWNlIGdw dSB7CisKKy8vIENvbXB1dGVzIHRleHR1cmUgY29vcmRpbmF0ZXMgZm9yIHJlbmRlcmluZyBjdWJp YyBjdXJ2ZXMgb24gdGhlIEdQVS4KK2NsYXNzIEN1YmljVGV4dHVyZUNvb3JkcyB7CitwdWJsaWM6 CisgICAgLy8gQ29udGFpbmVyIGZvciB0aGUgY3ViaWMgdGV4dHVyZSBjb29yZGluYXRlcyBhbmQg b3RoZXIgYXNzb2NpYXRlZAorICAgIC8vIGluZm9ybWF0aW9uLgorICAgIHN0cnVjdCBSZXN1bHQg eworICAgICAgICBSZXN1bHQoKQorICAgICAgICAgICAgOiBpc0xpbmVPclBvaW50KGZhbHNlKQor ICAgICAgICAgICAgLCBoYXNSZW5kZXJpbmdBcnRpZmFjdChmYWxzZSkKKyAgICAgICAgICAgICwg c3ViZGl2aXNpb25QYXJhbWV0ZXJWYWx1ZSgwLjBmKQorICAgICAgICB7CisgICAgICAgIH0KKwor ICAgICAgICAvLyBUaGUgM0QgdGV4dHVyZSBjb29yZGluYXRlcyB0aGF0IGFyZSB0byBiZSBhc3Nv Y2lhdGVkIHdpdGggdGhlCisgICAgICAgIC8vIGZvdXIgY29udHJvbCBwb2ludHMgb2YgdGhlIGN1 YmljIGN1cnZlLgorICAgICAgICBWZWN0b3IzIGNvb3Jkc1s0XTsKKworICAgICAgICAvLyBJbmRp Y2F0ZXMgd2hldGhlciB0aGUgY3VydmUgaXMgYSBsaW5lIG9yIGEgcG9pbnQsIGluIHdoaWNoIGNh c2UKKyAgICAgICAgLy8gd2UgZG8gbm90IG5lZWQgdG8gYWRkIGl0cyB0cmlhbmdsZXMgdG8gdGhl IG1lc2guCisgICAgICAgIGJvb2wgaXNMaW5lT3JQb2ludDsKKworICAgICAgICAvLyBGb3IgdGhl IGxvb3AgY2FzZSwgaW5kaWNhdGVzIHdoZXRoZXIgYSByZW5kZXJpbmcgYXJ0aWZhY3Qgd2FzCisg ICAgICAgIC8vIGRldGVjdGVkLCBpbiB3aGljaCBjYXNlIHRoZSBjdXJ2ZSBuZWVkcyB0byBiZSBm dXJ0aGVyCisgICAgICAgIC8vIHN1YmRpdmlkZWQuCisgICAgICAgIGJvb2wgaGFzUmVuZGVyaW5n QXJ0aWZhY3Q7CisKKyAgICAgICAgLy8gSWYgYSByZW5kZXJpbmcgYXJ0aWZhY3Qgd2lsbCBvY2N1 ciBmb3IgdGhlIGdpdmVuIGxvb3AgY3VydmUsCisgICAgICAgIC8vIHRoaXMgaXMgdGhlIHBhcmFt ZXRlciB2YWx1ZSAoMCA8PSB2YWx1ZSA8PSAxKSBhdCB3aGljaCB0aGUKKyAgICAgICAgLy8gY3Vy dmUgbmVlZHMgdG8gYmUgc3ViZGl2aWRlZCB0byBmaXggdGhlIGFydGlmYWN0LgorICAgICAgICBm bG9hdCBzdWJkaXZpc2lvblBhcmFtZXRlclZhbHVlOworICAgIH07CisKKyAgICAvLyBDb21wdXRl cyB0aGUgdGV4dHVyZSBjb29yZGluYXRlcyBmb3IgYSBjdWJpYyBjdXJ2ZSBzZWdtZW50J3MKKyAg ICAvLyBjb250cm9sIHBvaW50cywgZ2l2ZW4gdGhlIGNsYXNzaWZpY2F0aW9uIG9mIHRoZSBjdXJ2 ZSBhcyB3ZWxsIGFzCisgICAgLy8gYW4gaW5kaWNhdGlvbiBvZiB3aGljaCBzaWRlIGlzIHRvIGJl IGZpbGxlZC4KKyAgICBzdGF0aWMgdm9pZCBDb21wdXRlKGNvbnN0IEN1YmljQ2xhc3NpZmllcjo6 UmVzdWx0JiBjbGFzc2lmaWNhdGlvbiwKKyAgICAgICAgICAgICAgICAgICAgICAgIGJvb2wgZmls bFJpZ2h0U2lkZSwKKyAgICAgICAgICAgICAgICAgICAgICAgIFJlc3VsdCogcmVzdWx0KTsKKwor cHJpdmF0ZToKKyAgICAvLyBUaGlzIGNsYXNzIGRvZXMgbm90IG5lZWQgdG8gYmUgaW5zdGFudGlh dGVkLgorICAgIEN1YmljVGV4dHVyZUNvb3JkcygpIHt9Cit9OworCit9IC8vIG5hbWVzcGFjZSBn cHUKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIGdwdV9DdWJpY1RleHR1cmVD b29yZHNfaApJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUvTG9jYWxUcmlhbmd1 bGF0b3IuY2MKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUvTG9j YWxUcmlhbmd1bGF0b3IuY2MJKHJldmlzaW9uIDApCisrKyBXZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2dwdS9Mb2NhbFRyaWFuZ3VsYXRvci5jYwkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwyODkg QEAKKy8qCisgKiBDb3B5cmlnaHQgMjAxMCwgR29vZ2xlIEluYy4KKyAqIEFsbCByaWdodHMgcmVz ZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFy eSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQg cHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgor ICogICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBh Ym92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRo ZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5h cnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRo aXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGlu IHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0 aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xl IEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0 byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3 YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRI SVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05U UklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElF UywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5U SUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQ VVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisg KiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVD VCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBE QU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9G IFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1Ig UFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04g QU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1Qg TElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNF KSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUs IEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8K KworI2luY2x1ZGUgImNvbmZpZy5oIgorCisjaW5jbHVkZSAiZ3B1L0xvY2FsVHJpYW5ndWxhdG9y LmgiCisKKyNpbmNsdWRlIDxhbGdvcml0aG0+CisjaW5jbHVkZSAiZ3B1L0N1YmljTWF0aFV0aWxz LmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKK25hbWVzcGFjZSBncHUgeworCitib29sIExvY2Fs VHJpYW5ndWxhdG9yOjpUcmlhbmdsZTo6Y29udGFpbnMoTG9jYWxUcmlhbmd1bGF0b3I6OlZlcnRl eCogdikKK3sKKyAgICBmb3IgKGludCBpID0gMDsgaSA8IDM7IGkrKykKKyAgICAgICAgaWYgKG1f dmVydGljZXNbaV0gPT0gdikKKyAgICAgICAgICAgIHJldHVybiB0cnVlOworICAgIHJldHVybiBm YWxzZTsKK30KKworTG9jYWxUcmlhbmd1bGF0b3I6OlZlcnRleCogTG9jYWxUcmlhbmd1bGF0b3I6 OlRyaWFuZ2xlOjpuZXh0VmVydGV4KExvY2FsVHJpYW5ndWxhdG9yOjpWZXJ0ZXgqIGN1ciwgYm9v bCBjY3cpCit7CisgICAgaW50IGlkeCA9IGluZGV4Rm9yVmVydGV4KGN1cik7CisgICAgQVNTRVJU KGlkeCA+PSAwKTsKKyAgICBpZiAoY2N3KQorICAgICAgICArK2lkeDsKKyAgICBlbHNlCisgICAg ICAgIC0taWR4OworICAgIGlmIChpZHggPCAwKQorICAgICAgICBpZHggKz0gMzsKKyAgICBlbHNl CisgICAgICAgIGlkeCA9IGlkeCAlIDM7CisgICAgcmV0dXJuIG1fdmVydGljZXNbaWR4XTsKK30K KworaW50IExvY2FsVHJpYW5ndWxhdG9yOjpUcmlhbmdsZTo6aW5kZXhGb3JWZXJ0ZXgoTG9jYWxU cmlhbmd1bGF0b3I6OlZlcnRleCogdmVydGV4KQoreworICAgIGZvciAoaW50IGkgPSAwOyBpIDwg MzsgaSsrKQorICAgICAgICBpZiAobV92ZXJ0aWNlc1tpXSA9PSB2ZXJ0ZXgpCisgICAgICAgICAg ICByZXR1cm4gaTsKKyAgICByZXR1cm4gLTE7Cit9CisKK3ZvaWQgTG9jYWxUcmlhbmd1bGF0b3I6 OlRyaWFuZ2xlOjptYWtlQ0NXKCkKK3sKKyAgICAvLyBQb3NzaWJseSBzd2FwcyB0d28gdmVydGlj ZXMgc28gdGhhdCB0aGUgdHJpYW5nbGUncyB2ZXJ0aWNlcyBhcmUKKyAgICAvLyBhbHdheXMgc3Bl Y2lmaWVkIGluIGNvdW50ZXJjbG9ja3dpc2Ugb3JkZXIuIFRoaXMgb3JkZXJzIHRoZQorICAgIC8v IHZlcnRpY2VzIGNhbm9uaWNhbGx5IHdoZW4gd2Fsa2luZyB0aGUgaW50ZXJpb3IgZWRnZXMgZnJv bSB0aGUKKyAgICAvLyBzdGFydCB0byB0aGUgZW5kIHZlcnRleC4KKyAgICBWZWN0b3IzIHZlYzAo bV92ZXJ0aWNlc1swXS0+eCgpLCBtX3ZlcnRpY2VzWzBdLT55KCksIDApOworICAgIFZlY3RvcjMg dmVjMShtX3ZlcnRpY2VzWzFdLT54KCksIG1fdmVydGljZXNbMV0tPnkoKSwgMCk7CisgICAgVmVj dG9yMyB2ZWMyKG1fdmVydGljZXNbMl0tPngoKSwgbV92ZXJ0aWNlc1syXS0+eSgpLCAwKTsKKyAg ICBWZWN0b3IzIGRpZmYxID0gdmVjMSAtIHZlYzA7CisgICAgVmVjdG9yMyBkaWZmMiA9IHZlYzIg LSB2ZWMwOworICAgIFZlY3RvcjMgY3AgPSBkaWZmMS5jcm9zcyhkaWZmMik7CisgICAgaWYgKGNw LnooKSA8IDApCisgICAgICAgIHN0ZDo6c3dhcChtX3ZlcnRpY2VzWzFdLCBtX3ZlcnRpY2VzWzJd KTsKK30KKworTG9jYWxUcmlhbmd1bGF0b3I6OkxvY2FsVHJpYW5ndWxhdG9yKCkKK3sKKyAgICBy ZXNldCgpOworfQorCit2b2lkIExvY2FsVHJpYW5ndWxhdG9yOjpyZXNldCgpCit7CisgICAgbV9u dW1UcmlhbmdsZXMgPSAwOworICAgIG1fbnVtSW50ZXJpb3JWZXJ0aWNlcyA9IDA7CisgICAgZm9y IChpbnQgaSA9IDA7IGkgPCA0OyBpKyspIHsKKyAgICAgICAgbV9pbnRlcmlvclZlcnRpY2VzW2ld ID0gMDsKKyAgICAgICAgbV92ZXJ0aWNlc1tpXS5yZXNldEZsYWdzKCk7CisgICAgfQorfQorCit2 b2lkIExvY2FsVHJpYW5ndWxhdG9yOjp0cmlhbmd1bGF0ZShib29sIGNvbXB1dGVJbnNpZGVFZGdl cywgYm9vbCBmaWxsUmlnaHRTaWRlKQoreworICAgIHJlc2V0KCk7CisKKyAgICBib29sIGRvbmUg PSBmYWxzZTsKKworICAgIG1fdmVydGljZXNbM10uc2V0RW5kKHRydWUpOworCisgICAgLy8gRmly c3QgdGVzdCBmb3IgZGVnZW5lcmF0ZSBjYXNlcy4KKyAgICBmb3IgKGludCBpID0gMDsgaSA8IDQg JiYgIWRvbmU7IGkrKykKKyAgICAgICAgZm9yIChpbnQgaiA9IGkgKyAxOyBqIDwgNCAmJiAhZG9u ZTsgaisrKQorICAgICAgICAgICAgaWYgKGFwcHJveEVxdWFsKG1fdmVydGljZXNbaV0ueCgpLCBt X3ZlcnRpY2VzW2ldLnkoKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBtX3ZlcnRpY2Vz W2pdLngoKSwgbV92ZXJ0aWNlc1tqXS55KCkpKSB7CisgICAgICAgICAgICAgICAgLy8gVHdvIG9m IHRoZSB2ZXJ0aWNlcyBhcmUgY29pbmNpZGVudCwgc28gd2UgY2FuIGVsaW1pbmF0ZSBhdAorICAg ICAgICAgICAgICAgIC8vIGxlYXN0IG9uZSB0cmlhbmdsZS4gV2UgbWlnaHQgYmUgYWJsZSB0byBl bGltaW5hdGUgdGhlIG90aGVyCisgICAgICAgICAgICAgICAgLy8gYXMgd2VsbCwgYnV0IHRoaXMg c2VlbXMgc3VmZmljaWVudCB0byBhdm9pZCBkZWdlbmVyYXRlCisgICAgICAgICAgICAgICAgLy8g dHJpYW5ndWxhdGlvbnMuCisgICAgICAgICAgICAgICAgaW50IGluZGljZXNbM10gPSB7IDAgfTsK KyAgICAgICAgICAgICAgICBpbnQgaW5kZXggPSAwOworICAgICAgICAgICAgICAgIGZvciAoaW50 IGsgPSAwOyBrIDwgNDsgaysrKQorICAgICAgICAgICAgICAgICAgICBpZiAoayAhPSBqKQorICAg ICAgICAgICAgICAgICAgICAgICAgaW5kaWNlc1tpbmRleCsrXSA9IGs7CisgICAgICAgICAgICAg ICAgYWRkVHJpYW5nbGUoJm1fdmVydGljZXNbaW5kaWNlc1swXV0sCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgJm1fdmVydGljZXNbaW5kaWNlc1sxXV0sCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgJm1fdmVydGljZXNbaW5kaWNlc1syXV0pOworICAgICAgICAgICAgICAgIGRvbmUg PSB0cnVlOworICAgICAgICAgICAgfQorCisgICAgaWYgKCFkb25lKSB7CisgICAgICAgIC8vIFNl ZSB3aGV0aGVyIGFueSBvZiB0aGUgcG9pbnRzIGFyZSBmdWxseSBjb250YWluZWQgaW4gdGhlCisg ICAgICAgIC8vIHRyaWFuZ2xlIGRlZmluZWQgYnkgdGhlIG90aGVyIHRocmVlLgorICAgICAgICBm b3IgKGludCBpID0gMDsgaSA8IDQgJiYgIWRvbmU7IGkrKykgeworICAgICAgICAgICAgaW50IGlu ZGljZXNbM10gPSB7IDAgfTsKKyAgICAgICAgICAgIGludCBpbmRleCA9IDA7CisgICAgICAgICAg ICBmb3IgKGludCBqID0gMDsgaiA8IDQ7IGorKykKKyAgICAgICAgICAgICAgICBpZiAoaSAhPSBq KQorICAgICAgICAgICAgICAgICAgICBpbmRpY2VzW2luZGV4KytdID0gajsKKyAgICAgICAgICAg IGlmIChwb2ludEluVHJpYW5nbGUobV92ZXJ0aWNlc1tpXS54KCksIG1fdmVydGljZXNbaV0ueSgp LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBtX3ZlcnRpY2VzW2luZGljZXNbMF1d LngoKSwgbV92ZXJ0aWNlc1tpbmRpY2VzWzBdXS55KCksCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIG1fdmVydGljZXNbaW5kaWNlc1sxXV0ueCgpLCBtX3ZlcnRpY2VzW2luZGljZXNb MV1dLnkoKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbV92ZXJ0aWNlc1tpbmRp Y2VzWzJdXS54KCksIG1fdmVydGljZXNbaW5kaWNlc1syXV0ueSgpKSkgeworICAgICAgICAgICAg ICAgIC8vIFByb2R1Y2UgdGhyZWUgdHJpYW5nbGVzIHN1cnJvdW5kaW5nIHRoaXMgaW50ZXJpb3Ig dmVydGV4LgorICAgICAgICAgICAgICAgIGZvciAoaW50IGogPSAwOyBqIDwgMzsgaisrKQorICAg ICAgICAgICAgICAgICAgICBhZGRUcmlhbmdsZSgmbV92ZXJ0aWNlc1tpbmRpY2VzW2ogJSAzXV0s CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICZtX3ZlcnRpY2VzW2luZGljZXNbKGog KyAxKSAlIDNdXSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJm1fdmVydGljZXNb aV0pOworICAgICAgICAgICAgICAgIC8vIE1hcmsgdGhlIGludGVyaW9yIHZlcnRleCBzbyB3ZSBp Z25vcmUgaXQgaWYgdHJ5aW5nIHRvIHRyYWNlCisgICAgICAgICAgICAgICAgLy8gdGhlIGludGVy aW9yIGVkZ2UuCisgICAgICAgICAgICAgICAgbV92ZXJ0aWNlc1tpXS5zZXRJbnRlcmlvcih0cnVl KTsKKyAgICAgICAgICAgICAgICBkb25lID0gdHJ1ZTsKKyAgICAgICAgICAgIH0KKyAgICAgICAg fQorICAgIH0KKworICAgIGlmICghZG9uZSkgeworICAgICAgICAvLyBUaGVyZSBhcmUgb25seSBh IGZldyBwZXJtdXRhdGlvbnMgb2YgdGhlIHZlcnRpY2VzLCBpZ25vcmluZworICAgICAgICAvLyBy b3RhdGlvbnMsIHdoaWNoIGFyZSBpcnJlbGV2YW50OgorICAgICAgICAvLworICAgICAgICAvLyAg MC0tMyAgMC0tMiAgMC0tMyAgMC0tMSAgMC0tMiAgMC0tMQorICAgICAgICAvLyAgfCAgfCAgfCAg fCAgfCAgfCAgfCAgfCAgfCAgfCAgfCAgfAorICAgICAgICAvLyAgfCAgfCAgfCAgfCAgfCAgfCAg fCAgfCAgfCAgfCAgfCAgfAorICAgICAgICAvLyAgMS0tMiAgMS0tMyAgMi0tMSAgMi0tMyAgMy0t MSAgMy0tMgorICAgICAgICAvLworICAgICAgICAvLyBOb3RlIHRoYXQgdGhyZWUgb2YgdGhlc2Ug YXJlIHJlZmxlY3Rpb25zIG9mIGVhY2ggb3RoZXIuCisgICAgICAgIC8vIFRoZXJlZm9yZSB0aGVy ZSBhcmUgb25seSB0aHJlZSBwb3NzaWJsZSB0cmlhbmd1bGF0aW9uczoKKyAgICAgICAgLy8KKyAg ICAgICAgLy8gIDAtLTMgIDAtLTIgIDAtLTMKKyAgICAgICAgLy8gIHxcIHwgIHxcIHwgIHxcIHwK KyAgICAgICAgLy8gIHwgXHwgIHwgXHwgIHwgXHwKKyAgICAgICAgLy8gIDEtLTIgIDEtLTMgIDIt LTEKKyAgICAgICAgLy8KKyAgICAgICAgLy8gRnJvbSB3aGljaCB3ZSBjYW4gY2hvb3NlIGJ5IHNl ZWluZyB3aGljaCBvZiB0aGUgcG90ZW50aWFsCisgICAgICAgIC8vIGRpYWdvbmFscyBpbnRlcnNl Y3QuIE5vdGUgdGhhdCB3ZSBjaG9vc2UgdGhlIHNob3J0ZXN0IGRpYWdvbmFsCisgICAgICAgIC8v IHRvIHNwbGl0IHRoZSBxdWFkLgorICAgICAgICBpZiAobGluZXNJbnRlcnNlY3QobV92ZXJ0aWNl c1swXS54KCksIG1fdmVydGljZXNbMF0ueSgpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAg bV92ZXJ0aWNlc1syXS54KCksIG1fdmVydGljZXNbMl0ueSgpLAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgbV92ZXJ0aWNlc1sxXS54KCksIG1fdmVydGljZXNbMV0ueSgpLAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgbV92ZXJ0aWNlc1szXS54KCksIG1fdmVydGljZXNbM10ueSgpKSkg eworICAgICAgICAgICAgaWYgKGRpc3RhbmNlKG1fdmVydGljZXNbMF0ueCgpLCBtX3ZlcnRpY2Vz WzBdLnkoKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICBtX3ZlcnRpY2VzWzJdLngoKSwgbV92 ZXJ0aWNlc1syXS55KCkpIDwKKyAgICAgICAgICAgICAgICBkaXN0YW5jZShtX3ZlcnRpY2VzWzFd LngoKSwgbV92ZXJ0aWNlc1sxXS55KCksCisgICAgICAgICAgICAgICAgICAgICAgICAgbV92ZXJ0 aWNlc1szXS54KCksIG1fdmVydGljZXNbM10ueSgpKSkgeworICAgICAgICAgICAgICAgIGFkZFRy aWFuZ2xlKCZtX3ZlcnRpY2VzWzBdLCAmbV92ZXJ0aWNlc1sxXSwgJm1fdmVydGljZXNbMl0pOwor ICAgICAgICAgICAgICAgIGFkZFRyaWFuZ2xlKCZtX3ZlcnRpY2VzWzBdLCAmbV92ZXJ0aWNlc1sy XSwgJm1fdmVydGljZXNbM10pOworICAgICAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgICAg ICBhZGRUcmlhbmdsZSgmbV92ZXJ0aWNlc1swXSwgJm1fdmVydGljZXNbMV0sICZtX3ZlcnRpY2Vz WzNdKTsKKyAgICAgICAgICAgICAgICBhZGRUcmlhbmdsZSgmbV92ZXJ0aWNlc1sxXSwgJm1fdmVy dGljZXNbMl0sICZtX3ZlcnRpY2VzWzNdKTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfSBlbHNl IGlmIChsaW5lc0ludGVyc2VjdCgKKyAgICAgICAgICAgIG1fdmVydGljZXNbMF0ueCgpLCBtX3Zl cnRpY2VzWzBdLnkoKSwKKyAgICAgICAgICAgIG1fdmVydGljZXNbM10ueCgpLCBtX3ZlcnRpY2Vz WzNdLnkoKSwKKyAgICAgICAgICAgIG1fdmVydGljZXNbMV0ueCgpLCBtX3ZlcnRpY2VzWzFdLnko KSwKKyAgICAgICAgICAgIG1fdmVydGljZXNbMl0ueCgpLCBtX3ZlcnRpY2VzWzJdLnkoKSkpIHsK KyAgICAgICAgICAgIGlmIChkaXN0YW5jZShtX3ZlcnRpY2VzWzBdLngoKSwgbV92ZXJ0aWNlc1sw XS55KCksCisgICAgICAgICAgICAgICAgICAgICAgICAgbV92ZXJ0aWNlc1szXS54KCksIG1fdmVy dGljZXNbM10ueSgpKSA8CisgICAgICAgICAgICAgICAgZGlzdGFuY2UobV92ZXJ0aWNlc1sxXS54 KCksIG1fdmVydGljZXNbMV0ueSgpLAorICAgICAgICAgICAgICAgICAgICAgICAgIG1fdmVydGlj ZXNbMl0ueCgpLCBtX3ZlcnRpY2VzWzJdLnkoKSkpIHsKKyAgICAgICAgICAgICAgICBhZGRUcmlh bmdsZSgmbV92ZXJ0aWNlc1swXSwgJm1fdmVydGljZXNbMV0sICZtX3ZlcnRpY2VzWzNdKTsKKyAg ICAgICAgICAgICAgICBhZGRUcmlhbmdsZSgmbV92ZXJ0aWNlc1swXSwgJm1fdmVydGljZXNbM10s ICZtX3ZlcnRpY2VzWzJdKTsKKyAgICAgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICAgICAg YWRkVHJpYW5nbGUoJm1fdmVydGljZXNbMF0sICZtX3ZlcnRpY2VzWzFdLCAmbV92ZXJ0aWNlc1sy XSk7CisgICAgICAgICAgICAgICAgYWRkVHJpYW5nbGUoJm1fdmVydGljZXNbMl0sICZtX3ZlcnRp Y2VzWzFdLCAmbV92ZXJ0aWNlc1szXSk7CisgICAgICAgICAgICB9CisgICAgICAgIH0gZWxzZSB7 CisgICAgICAgICAgICAvLyBMaW5lcyAoMC0+MSksICgyLT4zKSBpbnRlcnNlY3QgLS0gb3Igc2hv dWxkLCBtb2R1bG8gbnVtZXJpY2FsCisgICAgICAgICAgICAvLyBwcmVjaXNpb24gaXNzdWVzCisg ICAgICAgICAgICBpZiAoZGlzdGFuY2UobV92ZXJ0aWNlc1swXS54KCksIG1fdmVydGljZXNbMF0u eSgpLAorICAgICAgICAgICAgICAgICAgICAgICAgIG1fdmVydGljZXNbMV0ueCgpLCBtX3ZlcnRp Y2VzWzFdLnkoKSkgPAorICAgICAgICAgICAgICAgIGRpc3RhbmNlKG1fdmVydGljZXNbMl0ueCgp LCBtX3ZlcnRpY2VzWzJdLnkoKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICBtX3ZlcnRpY2Vz WzNdLngoKSwgbV92ZXJ0aWNlc1szXS55KCkpKSB7CisgICAgICAgICAgICAgICAgYWRkVHJpYW5n bGUoJm1fdmVydGljZXNbMF0sICZtX3ZlcnRpY2VzWzJdLCAmbV92ZXJ0aWNlc1sxXSk7CisgICAg ICAgICAgICAgICAgYWRkVHJpYW5nbGUoJm1fdmVydGljZXNbMF0sICZtX3ZlcnRpY2VzWzFdLCAm bV92ZXJ0aWNlc1szXSk7CisgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgIGFk ZFRyaWFuZ2xlKCZtX3ZlcnRpY2VzWzBdLCAmbV92ZXJ0aWNlc1syXSwgJm1fdmVydGljZXNbM10p OworICAgICAgICAgICAgICAgIGFkZFRyaWFuZ2xlKCZtX3ZlcnRpY2VzWzNdLCAmbV92ZXJ0aWNl c1syXSwgJm1fdmVydGljZXNbMV0pOworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgfQor CisgICAgaWYgKGNvbXB1dGVJbnNpZGVFZGdlcykgeworICAgICAgICAvLyBXZSBuZWVkIHRvIGNv bXB1dGUgd2hpY2ggdmVydGljZXMgZGVzY3JpYmUgdGhlIHBhdGggYWxvbmcgdGhlCisgICAgICAg IC8vIGludGVyaW9yIHBvcnRpb24gb2YgdGhlIHNoYXBlLCB0byBmZWVkIHRoZXNlIHZlcnRpY2Vz IHRvIHRoZQorICAgICAgICAvLyBtb3JlIGdlbmVyYWwgdGVzc2VsbGF0aW9uIGFsZ29yaXRobS4g SXQgaXMgcG9zc2libGUgdGhhdCB3ZQorICAgICAgICAvLyBjb3VsZCBkZXRlcm1pbmUgdGhpcyBk aXJlY3RseSB3aGlsZSBwcm9kdWNpbmcgdHJpYW5nbGVzIGFib3ZlLgorICAgICAgICAvLyBIZXJl IHdlIHRyeSB0byBkbyBpdCBnZW5lcmFsbHkganVzdCBieSBleGFtaW5pbmcgdGhlIHRyaWFuZ2xl cworICAgICAgICAvLyB0aGF0IGhhdmUgYWxyZWFkeSBiZWVuIHByb2R1Y2VkLiBXZSB3YWxrIGFy b3VuZCB0aGVtIGluIGEKKyAgICAgICAgLy8gc3BlY2lmaWMgZGlyZWN0aW9uIGRldGVybWluZWQg Ynkgd2hpY2ggc2lkZSBvZiB0aGUgY3VydmUgaXMKKyAgICAgICAgLy8gYmVpbmcgZmlsbGVkLiBX ZSBpZ25vcmUgdGhlIGludGVyaW9yIHZlcnRleCB1bmxlc3MgaXQgaXMgYWxzbworICAgICAgICAv LyB0aGUgZW5kaW5nIHZlcnRleCwgYW5kIHNraXAgdGhlIGVkZ2VzIHNoYXJlZCBiZXR3ZWVuIHR3 bworICAgICAgICAvLyB0cmlhbmdsZXMuCisgICAgICAgIFZlcnRleCogdiA9ICZtX3ZlcnRpY2Vz WzBdOworICAgICAgICBhZGRJbnRlcmlvclZlcnRleCh2KTsKKyAgICAgICAgaW50IG51bVN0ZXBz ID0gMDsKKyAgICAgICAgd2hpbGUgKCF2LT5lbmQoKSAmJiBudW1TdGVwcyA8IDQpIHsKKyAgICAg ICAgICAgIC8vIEZpbmQgdGhlIG5leHQgdmVydGV4IGFjY29yZGluZyB0byB0aGUgYWJvdmUgcnVs ZXMKKyAgICAgICAgICAgIGJvb2wgZ290TmV4dCA9IGZhbHNlOworICAgICAgICAgICAgZm9yIChp bnQgaSA9IDA7IGkgPCBudW1UcmlhbmdsZXMoKSAmJiAhZ290TmV4dDsgaSsrKSB7CisgICAgICAg ICAgICAgICAgVHJpYW5nbGUqIHRyaSA9IGdldFRyaWFuZ2xlKGkpOworICAgICAgICAgICAgICAg IGlmICh0cmktPmNvbnRhaW5zKHYpKSB7CisgICAgICAgICAgICAgICAgICAgIFZlcnRleCogbmV4 dCA9IHRyaS0+bmV4dFZlcnRleCh2LCBmaWxsUmlnaHRTaWRlKTsKKyAgICAgICAgICAgICAgICAg ICAgaWYgKCFuZXh0LT5tYXJrZWQoKSAmJgorICAgICAgICAgICAgICAgICAgICAgICAgIWlzU2hh cmVkRWRnZSh2LCBuZXh0KSAmJgorICAgICAgICAgICAgICAgICAgICAgICAgKCFuZXh0LT5pbnRl cmlvcigpIHx8IG5leHQtPmVuZCgpKSkgeworICAgICAgICAgICAgICAgICAgICAgICAgYWRkSW50 ZXJpb3JWZXJ0ZXgobmV4dCk7CisgICAgICAgICAgICAgICAgICAgICAgICB2ID0gbmV4dDsKKyAg ICAgICAgICAgICAgICAgICAgICAgIC8vIEJyZWFrIG91dCBvZiBmb3IgbG9vcAorICAgICAgICAg ICAgICAgICAgICAgICAgZ290TmV4dCA9IHRydWU7CisgICAgICAgICAgICAgICAgICAgIH0KKyAg ICAgICAgICAgICAgICB9CisgICAgICAgICAgICB9CisgICAgICAgICAgICArK251bVN0ZXBzOwor ICAgICAgICB9CisgICAgICAgIGlmICghdi0+ZW5kKCkpIHsKKyAgICAgICAgICAgIC8vIFNvbWV0 aGluZyB3ZW50IHdyb25nIHdpdGggdGhlIGFib3ZlIGFsZ29yaXRobTsgYWRkIHRoZSBsYXN0Cisg ICAgICAgICAgICAvLyB2ZXJ0ZXggdG8gdGhlIGludGVyaW9yIHZlcnRpY2VzIGFueXdheS4KKyAg ICAgICAgICAgIGFkZEludGVyaW9yVmVydGV4KCZtX3ZlcnRpY2VzWzNdKTsKKyAgICAgICAgfQor ICAgIH0KK30KKwordm9pZCBMb2NhbFRyaWFuZ3VsYXRvcjo6YWRkVHJpYW5nbGUoVmVydGV4KiB2 MCwgVmVydGV4KiB2MSwgVmVydGV4KiB2MikgeworICAgIEFTU0VSVChtX251bVRyaWFuZ2xlcyA8 IDMpOworICAgIG1fdHJpYW5nbGVzW21fbnVtVHJpYW5nbGVzKytdLnNldFZlcnRpY2VzKHYwLCB2 MSwgdjIpOworfQorCit2b2lkIExvY2FsVHJpYW5ndWxhdG9yOjphZGRJbnRlcmlvclZlcnRleChW ZXJ0ZXgqIHYpIHsKKyAgICBBU1NFUlQobV9udW1JbnRlcmlvclZlcnRpY2VzIDwgNCk7CisgICAg bV9pbnRlcmlvclZlcnRpY2VzW21fbnVtSW50ZXJpb3JWZXJ0aWNlcysrXSA9IHY7CisgICAgdi0+ c2V0TWFya2VkKHRydWUpOworfQorCitib29sIExvY2FsVHJpYW5ndWxhdG9yOjppc1NoYXJlZEVk Z2UoVmVydGV4KiB2MCwgVmVydGV4KiB2MSkgeworICAgIGJvb2wgaGF2ZUVkZ2UwMSA9IGZhbHNl OworICAgIGJvb2wgaGF2ZUVkZ2UxMCA9IGZhbHNlOworICAgIGZvciAoaW50IGkgPSAwOyBpIDwg bnVtVHJpYW5nbGVzKCk7IGkrKykgeworICAgICAgICBUcmlhbmdsZSogdHJpID0gZ2V0VHJpYW5n bGUoaSk7CisgICAgICAgIGlmICh0cmktPmNvbnRhaW5zKHYwKSAmJiB0cmktPm5leHRWZXJ0ZXgo djAsIHRydWUpID09IHYxKQorICAgICAgICAgICAgaGF2ZUVkZ2UwMSA9IHRydWU7CisgICAgICAg IGlmICh0cmktPmNvbnRhaW5zKHYxKSAmJiB0cmktPm5leHRWZXJ0ZXgodjEsIHRydWUpID09IHYw KQorICAgICAgICAgICAgaGF2ZUVkZ2UxMCA9IHRydWU7CisgICAgfQorICAgIHJldHVybiBoYXZl RWRnZTAxICYmIGhhdmVFZGdlMTA7Cit9CisKK30gIC8vIG5hbWVzcGFjZSBncHUKK30gIC8vIG5h bWVzcGFjZSBXZWJDb3JlCkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9Mb2Nh bFRyaWFuZ3VsYXRvci5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Z3B1L0xvY2FsVHJpYW5ndWxhdG9yLmgJKHJldmlzaW9uIDApCisrKyBXZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2dwdS9Mb2NhbFRyaWFuZ3VsYXRvci5oCShyZXZpc2lvbiAwKQpAQCAtMCwwICsx LDI4NCBAQAorLyoKKyAqIENvcHlyaWdodCAyMDEwLCBHb29nbGUgSW5jLgorICogQWxsIHJpZ2h0 cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQg YmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1p dHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoK KyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4g dGhlIGFib3ZlIGNvcHlyaWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBh bmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGlu IGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgor ICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3 aXRoIHRoZQorICogZGlzdHJpYnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBH b29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1 c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMg c29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgor ICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5E IENPTlRSSUJVVE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJS QU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdB UlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNV TEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklH SFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElO RElSRUNULCBJTkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5U SUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1F TlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRB LCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFO RCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNU UklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhF UldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZU V0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4K KyAqLworCisjaWZuZGVmIGdwdV9Mb2NhbFRyaWFuZ3VsYXRvcl9oCisjZGVmaW5lIGdwdV9Mb2Nh bFRyaWFuZ3VsYXRvcl9oCisKKyNpbmNsdWRlIDx3dGYvQXNzZXJ0aW9ucy5oPgorI2luY2x1ZGUg PHd0Zi9Ob25jb3B5YWJsZS5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CituYW1lc3BhY2UgZ3B1 IHsKKworLy8gUGVyZm9ybXMgYSBsb2NhbGl6ZWQgdHJpYW5ndWxhdGlvbiBvZiB0aGUgdHJpYW5n bGUgbWVzaAorLy8gY29ycmVzcG9uZGluZyB0byB0aGUgZm91ciBjb250cm9sIHBvaW50IHZlcnRp Y2VzIG9mIGEgY3ViaWMgY3VydmUKKy8vIHNlZ21lbnQuCitjbGFzcyBMb2NhbFRyaWFuZ3VsYXRv ciA6IHB1YmxpYyBOb25jb3B5YWJsZSB7CitwdWJsaWM6CisgICAgLy8gVGhlIHZlcnRpY2VzIHRo YXQgdGhlIHRyaWFuZ3VsYXRvciBvcGVyYXRlcyB1cG9uLCBjb250YWluaW5nIGJvdGgKKyAgICAv LyB0aGUgcG9zaXRpb24gaW5mb3JtYXRpb24gYXMgd2VsbCBhcyB0aGUgY3ViaWMgdGV4dHVyZQor ICAgIC8vIGNvb3JkaW5hdGVzLgorICAgIGNsYXNzIFZlcnRleCA6IHB1YmxpYyBOb25jb3B5YWJs ZSB7CisgICAgcHVibGljOgorICAgICAgICBWZXJ0ZXgoKQorICAgICAgICB7CisgICAgICAgIH0K KworICAgICAgICBmbG9hdCB4KCkKKyAgICAgICAgeworICAgICAgICAgICAgcmV0dXJuIG1feDsK KyAgICAgICAgfQorCisgICAgICAgIGZsb2F0IHkoKQorICAgICAgICB7CisgICAgICAgICAgICBy ZXR1cm4gbV95OworICAgICAgICB9CisKKyAgICAgICAgZmxvYXQgaygpCisgICAgICAgIHsKKyAg ICAgICAgICAgIHJldHVybiBtX2s7CisgICAgICAgIH0KKworICAgICAgICBmbG9hdCBsKCkKKyAg ICAgICAgeworICAgICAgICAgICAgcmV0dXJuIG1fbDsKKyAgICAgICAgfQorCisgICAgICAgIGZs b2F0IG0oKQorICAgICAgICB7CisgICAgICAgICAgICByZXR1cm4gbV9tOworICAgICAgICB9CisK KyAgICAgICAgLy8gU2V0cyB0aGUgcG9zaXRpb24gYW5kIHRleHR1cmUgY29vcmRpbmF0ZXMgb2Yg dGhlIHZlcnRleC4KKyAgICAgICAgdm9pZCBzZXQoZmxvYXQgeCwgZmxvYXQgeSwKKyAgICAgICAg ICAgICAgICAgZmxvYXQgaywgZmxvYXQgbCwgZmxvYXQgbSkKKyAgICAgICAgeworICAgICAgICAg ICAgbV94ID0geDsKKyAgICAgICAgICAgIG1feSA9IHk7CisgICAgICAgICAgICBtX2sgPSBrOwor ICAgICAgICAgICAgbV9sID0gbDsKKyAgICAgICAgICAgIG1fbSA9IG07CisgICAgICAgIH0KKwor ICAgICAgICAvLyBGbGFncyBmb3Igd2Fsa2luZyBmcm9tIHRoZSBzdGFydCB2ZXJ0ZXggdG8gdGhl IGVuZCB2ZXJ0ZXguCisgICAgICAgIGJvb2wgZW5kKCkKKyAgICAgICAgeworICAgICAgICAgICAg cmV0dXJuIG1fZW5kOworICAgICAgICB9CisKKyAgICAgICAgdm9pZCBzZXRFbmQoYm9vbCBlbmQp CisgICAgICAgIHsKKyAgICAgICAgICAgIG1fZW5kID0gZW5kOworICAgICAgICB9CisKKyAgICAg ICAgYm9vbCBtYXJrZWQoKQorICAgICAgICB7CisgICAgICAgICAgICByZXR1cm4gbV9tYXJrZWQ7 CisgICAgICAgIH0KKworICAgICAgICB2b2lkIHNldE1hcmtlZChib29sIG1hcmtlZCkKKyAgICAg ICAgeworICAgICAgICAgICAgbV9tYXJrZWQgPSBtYXJrZWQ7CisgICAgICAgIH0KKworICAgICAg ICBib29sIGludGVyaW9yKCkKKyAgICAgICAgeworICAgICAgICAgICAgcmV0dXJuIG1faW50ZXJp b3I7CisgICAgICAgIH0KKworICAgICAgICB2b2lkIHNldEludGVyaW9yKGJvb2wgaW50ZXJpb3Ip CisgICAgICAgIHsKKyAgICAgICAgICAgIG1faW50ZXJpb3IgPSBpbnRlcmlvcjsKKyAgICAgICAg fQorCisgICAgICAgIHZvaWQgcmVzZXRGbGFncygpCisgICAgICAgIHsKKyAgICAgICAgICAgIG1f ZW5kID0gZmFsc2U7CisgICAgICAgICAgICBtX21hcmtlZCA9IGZhbHNlOworICAgICAgICAgICAg bV9pbnRlcmlvciA9IGZhbHNlOworICAgICAgICB9CisKKyAgICBwcml2YXRlOgorICAgICAgICAv LyAyRCBjb29yZGluYXRlcyBvZiB0aGUgdmVydGV4IGluIHRoZSBwbGFuZS4KKyAgICAgICAgZmxv YXQgbV94OworICAgICAgICBmbG9hdCBtX3k7CisgICAgICAgIC8vIEN1YmljIHRleHR1cmUgY29v cmRpbmF0ZXMgZm9yIHJlbmRlcmluZyB0aGUgY3VydmUuCisgICAgICAgIGZsb2F0IG1faywgbV9s LCBtX207CisKKyAgICAgICAgLy8gRmxhZ3MgZm9yIHdhbGtpbmcgZnJvbSB0aGUgc3RhcnQgdmVy dGV4IHRvIHRoZSBlbmQgdmVydGV4LgorICAgICAgICBib29sIG1fZW5kOworICAgICAgICBib29s IG1fbWFya2VkOworICAgICAgICBib29sIG1faW50ZXJpb3I7CisgICAgfTsKKworICAgIC8vIFRo ZSB0cmlhbmdsZXMgdGhlIFRyaWFuZ3VsYXRvciBwcm9kdWNlcy4KKyAgICBjbGFzcyBUcmlhbmds ZSB7CisgICAgcHVibGljOgorICAgICAgICBUcmlhbmdsZSgpCisgICAgICAgIHsKKyAgICAgICAg ICAgIG1fdmVydGljZXNbMF0gPSAwOworICAgICAgICAgICAgbV92ZXJ0aWNlc1sxXSA9IDA7Cisg ICAgICAgICAgICBtX3ZlcnRpY2VzWzJdID0gMDsKKyAgICAgICAgfQorCisgICAgICAgIC8vIEdl dHMgdGhlIHZlcnRleCBhdCB0aGUgZ2l2ZW4gaW5kZXgsIDAgPD0gaW5kZXggPCAzLgorICAgICAg ICBWZXJ0ZXgqIGdldFZlcnRleChpbnQgaW5kZXgpCisgICAgICAgIHsKKyAgICAgICAgICAgIEFT U0VSVChpbmRleCA+PSAwICYmIGluZGV4IDwgMyk7CisgICAgICAgICAgICByZXR1cm4gbV92ZXJ0 aWNlc1tpbmRleF07CisgICAgICAgIH0KKworICAgICAgICAvLyBSZXR1cm5zIHRydWUgaWYgdGhp cyB0cmlhbmdsZSBjb250YWlucyB0aGUgZ2l2ZW4gdmVydGV4IChieQorICAgICAgICAvLyBpZGVu dGl0eSwgbm90IGdlb21ldHJpY2FsbHkpLgorICAgICAgICBib29sIGNvbnRhaW5zKFZlcnRleCog dik7CisKKyAgICAgICAgLy8gUmV0dXJucyB0aGUgdmVydGV4IGZvbGxvd2luZyB0aGUgY3VycmVu dCBvbmUgaW4gdGhlIHNwZWNpZmllZAorICAgICAgICAvLyBkaXJlY3Rpb24sIGNvdW50ZXJjbG9j a3dpc2Ugb3IgY2xvY2t3aXNlLgorICAgICAgICBWZXJ0ZXgqIG5leHRWZXJ0ZXgoVmVydGV4KiBj dXIsIGJvb2wgY2N3KTsKKworICAgICAgICAvLyBTZXRzIHRoZSB2ZXJ0aWNlcyBvZiB0aGlzIHRy aWFuZ2xlLCBwb3RlbnRpYWxseSByZW9yZGVyaW5nIHRoZW0KKyAgICAgICAgLy8gdG8gcHJvZHVj ZSBhIGNhbm9uaWNhbCBvcmllbnRhdGlvbi4KKyAgICAgICAgdm9pZCBzZXRWZXJ0aWNlcyhWZXJ0 ZXgqIHYwLAorICAgICAgICAgICAgICAgICAgICAgICAgIFZlcnRleCogdjEsCisgICAgICAgICAg ICAgICAgICAgICAgICAgVmVydGV4KiB2MikKKyAgICAgICAgeworICAgICAgICAgICAgbV92ZXJ0 aWNlc1swXSA9IHYwOworICAgICAgICAgICAgbV92ZXJ0aWNlc1sxXSA9IHYxOworICAgICAgICAg ICAgbV92ZXJ0aWNlc1syXSA9IHYyOworICAgICAgICAgICAgbWFrZUNDVygpOworICAgICAgICB9 CisKKyAgICBwcml2YXRlOgorICAgICAgICAvLyBSZXR1cm5zIHRoZSBpbmRleCBbMC4uMl0gYXNz b2NpYXRlZCB3aXRoIHRoZSBnaXZlbiB2ZXJ0ZXgsIG9yCisgICAgICAgIC8vIC0xIGlmIG5vdCBm b3VuZC4KKyAgICAgICAgaW50IGluZGV4Rm9yVmVydGV4KFZlcnRleCogdmVydGV4KTsKKworICAg ICAgICAvLyBSZW9yZGVycyB0aGUgdmVydGljZXMgaW4gdGhpcyB0cmlhbmdsZSB0byBtYWtlIHRo ZW0KKyAgICAgICAgLy8gY291bnRlcmNsb2Nrd2lzZSB3aGVuIHZpZXdlZCBpbiB0aGUgMkQgcGxh bmUsIGluIG9yZGVyIHRvCisgICAgICAgIC8vIGFjaGlldmUgYSBjYW5vbmljYWwgb3JkZXJpbmcu CisgICAgICAgIHZvaWQgbWFrZUNDVygpOworCisgICAgICAgIFZlcnRleCogbV92ZXJ0aWNlc1sz XTsKKyAgICB9OworCisgICAgTG9jYWxUcmlhbmd1bGF0b3IoKTsKKworICAgIC8vIFJlc2V0cyB0 aGUgdHJpYW5ndWxhdG9yJ3Mgc3RhdGUuIEFmdGVyIGVhY2ggdHJpYW5ndWxhdGlvbiBhbmQKKyAg ICAvLyBiZWZvcmUgdGhlIG5leHQsIGNhbGwgdGhpcyB0byByZS1pbml0aWFsaXplIHRoZSBpbnRl cm5hbAorICAgIC8vIHZlcnRpY2VzJyBzdGF0ZS4KKyAgICB2b2lkIHJlc2V0KCk7CisKKyAgICAv LyBSZXR1cm5zIGEgbXV0YWJsZSB2ZXJ0ZXggc3RvcmVkIGluIHRoZSB0cmlhbmd1bGF0b3IuIFVz ZSB0aGlzIHRvCisgICAgLy8gc2V0IHVwIHRoZSB2ZXJ0aWNlcyBiZWZvcmUgYSB0cmlhbmd1bGF0 aW9uLgorICAgIFZlcnRleCogZ2V0VmVydGV4KGludCBpbmRleCkKKyAgICB7CisgICAgICAgIEFT U0VSVChpbmRleCA+PSAwICYmIGluZGV4IDwgNCk7CisgICAgICAgIHJldHVybiAmbV92ZXJ0aWNl c1tpbmRleF07CisgICAgfQorCisgICAgLy8gT25jZSB0aGUgdmVydGljZXMnIGNvbnRlbnRzIGhh dmUgYmVlbiBzZXQgdXAsIGNhbGwgdHJpYW5ndWxhdGUoKQorICAgIC8vIHRvIHJlY29tcHV0ZSB0 aGUgdHJpYW5nbGVzLgorICAgIC8vCisgICAgLy8gSWYgY29tcHV0ZUluc2lkZUVkZ2VzIGlzIHRy dWUsIHRoZW4gZmlsbFJpZ2h0U2lkZSB3aWxsIGJlCisgICAgLy8gdXNlZCB0byBkZXRlcm1pbmUg d2hpY2ggc2lkZSBvZiB0aGUgY3ViaWMgY3VydmUgZGVmaW5lZCBieSB0aGUKKyAgICAvLyBmb3Vy IGNvbnRyb2wgcG9pbnRzIGlzIHRvIGJlIGZpbGxlZC4KKyAgICAvLworICAgIC8vIFRoZSB0cmlh bmd1bGF0aW9uIG9iZXlzIHRoZSBmb2xsb3dpbmcgZ3VhcmFudGVlczoKKyAgICAvLyAgIC0gSWYg dGhlIGNvbnZleCBodWxsIGlzIGEgcXVhZHJpbGF0ZXJhbCwgdGhlbiB0aGUgc2hvcnRlc3QgZWRn ZQorICAgIC8vICAgICB3aWxsIGJlIGNob3NlbiBmb3IgdGhlIGN1dCBpbnRvIHR3byB0cmlhbmds ZXMuCisgICAgLy8gICAtIElmIG9uZSBvZiB0aGUgdmVydGljZXMgaXMgY29udGFpbmVkIGluIHRo ZSB0cmlhbmdsZSBzcGFubmVkCisgICAgLy8gICAgIGJ5IHRoZSBvdGhlciB0aHJlZSwgdGhyZWUg dHJpYW5nbGVzIHdpbGwgYmUgcHJvZHVjZWQuCisgICAgdm9pZCB0cmlhbmd1bGF0ZShib29sIGNv bXB1dGVJbnNpZGVFZGdlcywKKyAgICAgICAgICAgICAgICAgICAgIGJvb2wgZmlsbFJpZ2h0U2lk ZSk7CisKKyAgICAvLyBOdW1iZXIgb2YgdHJpYW5nbGVzIGNvbXB1dGVkIGJ5IHRyaWFuZ3VsYXRl KCkuCisgICAgaW50IG51bVRyaWFuZ2xlcygpIGNvbnN0CisgICAgeworICAgICAgICByZXR1cm4g bV9udW1UcmlhbmdsZXM7CisgICAgfQorCisgICAgLy8gUmV0dXJucyB0aGUgY29tcHV0ZWQgdHJp YW5nbGUgYXQgaW5kZXgsIDAgPD0gaW5kZXggPAorICAgIC8vIG51bV90cmlhbmdsZXMoKS4KKyAg ICBUcmlhbmdsZSogZ2V0VHJpYW5nbGUoaW50IGluZGV4KQorICAgIHsKKyAgICAgICAgQVNTRVJU KGluZGV4ID49IDAgJiYgaW5kZXggPCBtX251bVRyaWFuZ2xlcyk7CisgICAgICAgIHJldHVybiAm bV90cmlhbmdsZXNbaW5kZXhdOworICAgIH0KKworICAgIC8vIE51bWJlciBvZiB2ZXJ0aWNlcyBm YWNpbmcgdGhlIGluc2lkZSBvZiB0aGUgc2hhcGUsIGlmCisgICAgLy8gY29tcHV0ZV9pbnNpZGVf ZWRnZXMgd2FzIHRydWUgd2hlbiB0cmlhbmd1bGF0ZSgpIHdhcyBjYWxsZWQuCisgICAgaW50IG51 bUludGVyaW9yVmVydGljZXMoKSBjb25zdAorICAgIHsKKyAgICAgICAgcmV0dXJuIG1fbnVtSW50 ZXJpb3JWZXJ0aWNlczsKKyAgICB9CisKKyAgICAvLyBGZXRjaGVzIHRoZSBnaXZlbiBpbnRlcmlv ciB2ZXJ0ZXgsIDAgPD0gaW5kZXggPAorICAgIC8vIG51bUludGVyaW9yVmVydGljZXMoKS4KKyAg ICBWZXJ0ZXgqIGdldEludGVyaW9yVmVydGV4KGludCBpbmRleCkKKyAgICB7CisgICAgICAgIEFT U0VSVChpbmRleCA+PSAwICYmIGluZGV4IDwgbV9udW1JbnRlcmlvclZlcnRpY2VzKTsKKyAgICAg ICAgcmV0dXJuIG1faW50ZXJpb3JWZXJ0aWNlc1tpbmRleF07CisgICAgfQorCitwcml2YXRlOgor ICAgIC8vIEFkZHMgYSB0cmlhbmdsZSB0byB0aGUgdHJpYW5ndWxhdGlvbi4KKyAgICB2b2lkIGFk ZFRyaWFuZ2xlKFZlcnRleCogdjAsIFZlcnRleCogdjEsIFZlcnRleCogdjIpOworCisgICAgLy8g QWRkcyBhIHZlcnRleCB0byB0aGUgbGlzdCBvZiBpbnRlcmlvciB2ZXJ0aWNlcy4KKyAgICB2b2lk IGFkZEludGVyaW9yVmVydGV4KFZlcnRleCogdik7CisKKyAgICAvLyBJbmRpY2F0ZXMgd2hldGhl ciB0aGUgZWRnZSBiZXR3ZWVuIHZlcnRleCB2MCBhbmQgdjEgaXMgc2hhcmVkCisgICAgLy8gYmV0 d2VlbiB0d28gb3IgbW9yZSB0cmlhbmdsZXMuCisgICAgYm9vbCBpc1NoYXJlZEVkZ2UoVmVydGV4 KiB2MCwgVmVydGV4KiB2MSk7CisKKyAgICAvLyBUaGUgdmVydGljZXMgYmVpbmcgdHJpYW5ndWxh dGVkLgorICAgIFZlcnRleCBtX3ZlcnRpY2VzWzRdOworCisgICAgLy8gVGhlIHZlcnRpY2VzIGNv cnJlc3BvbmRpbmcgdG8gdGhlIGVkZ2VzIGZhY2luZyB0aGUgaW5zaWRlIG9mIHRoZQorICAgIC8v IHNoYXBlLCBpbiBvcmRlciBmcm9tIHRoZSBzdGFydCB2ZXJ0ZXggdG8gdGhlIGVuZCB2ZXJ0ZXgu IFRoZSBtb3JlCisgICAgLy8gZ2VuZXJhbCB0cmlhbmd1bGF0aW9uIGFsZ29yaXRobSB0ZXNzZWxs YXRlcyB0aGlzIGludGVyaW9yIHJlZ2lvbi4KKyAgICBWZXJ0ZXgqIG1faW50ZXJpb3JWZXJ0aWNl c1s0XTsKKyAgICAvLyBUaGUgbnVtYmVyIG9mIGludGVyaW9yIHZlcnRpY2VzIHRoYXQgYXJlIHZh bGlkIGZvciB0aGUgY3VycmVudAorICAgIC8vIHRyaWFuZ3VsYXRpb24uCisgICAgaW50IG1fbnVt SW50ZXJpb3JWZXJ0aWNlczsKKworICAgIC8vIFRoZXJlIGNhbiBiZSBhdCBtb3N0IHRocmVlIHRy aWFuZ2xlcyBjb21wdXRlZCBieSB0aGlzIGxvY2FsCisgICAgLy8gYWxnb3JpdGhtLCB3aGljaCBv Y2N1cnMgd2hlbiBvbmUgb2YgdGhlIHZlcnRpY2VzIGlzIGNvbnRhaW5lZCBpbgorICAgIC8vIHRo ZSB0cmlhbmdsZSBzcGFubmVkIGJ5IHRoZSBvdGhlciB0aHJlZS4gTW9zdCBvZiB0aGUgdGltZSB0 aGUKKyAgICAvLyBhbGdvcml0aG0gY29tcHV0ZXMgdHdvIHRyaWFuZ2xlcy4KKyAgICBUcmlhbmds ZSBtX3RyaWFuZ2xlc1szXTsKKyAgICBpbnQgbV9udW1UcmlhbmdsZXM7Cit9OworCit9IC8vIG5h bWVzcGFjZSBncHUKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIGdwdV9Mb2Nh bFRyaWFuZ3VsYXRvcl9oCg== 65657 2010-08-26 18:23:11 -0700 2010-08-26 19:37:49 -0700 Path processing results and shader management classes cache-and-shaders.patch text/plain 27369 kbr SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA2NjE2MSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjcgQEAKKzIwMTAtMDgtMjYgIEtlbm5ldGggUnVzc2VsbCAgPGtickBnb29nbGUu Y29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFk ZCBzdXBwb3J0IGZvciBHUFUgYWNjZWxlcmF0ZWQgcGF0aCByZW5kZXJpbmcKKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ0NzI5CisKKyAgICAgICAgVGhp cyBwYXRjaCBhZGRzIHRoZSBQYXRoQ2FjaGUgZGF0YSBzdHJ1Y3R1cmUgcHJvZHVjZWQgYnkgdGhl IHBhdGgKKyAgICAgICAgcHJvY2Vzc2luZyBhbGdvcml0aG0gKHRvIGZvbGxvdyksIGFzIHdlbGwg YXMgaGVscGVyIGNsYXNzZXMgdG8KKyAgICAgICAgbWFuYWdlIHRoZSBzaGFkZXJzIHVzZWQgdG8g ZmlsbCB0aGUgcGF0aHMuCisKKyAgICAgICAgVGhlIHJlYXNvbiBmb3IgdGhlIHN0eWxlIHZpb2xh dGlvbnMgaW4gdGhlIGhlYWRlciBndWFyZHMgaXMKKyAgICAgICAgZGVzY3JpYmVkIGluIGFuIGVh cmxpZXIgcGF0Y2guCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9ncHU6IEFkZGVkLgor ICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2dwdS9QYXRoQ2FjaGUuY2M6IEFkZGVkLgorICAg ICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2dwdS9QYXRoQ2FjaGUuaDogQWRkZWQuCisgICAgICAg IChXZWJDb3JlOjpncHU6OlBhdGhDYWNoZTo6UGF0aENhY2hlKToKKyAgICAgICAgKiBwbGF0Zm9y bS9ncmFwaGljcy9ncHUvU2hhZGVyQ2FjaGUuY2M6IEFkZGVkLgorICAgICAgICAqIHBsYXRmb3Jt L2dyYXBoaWNzL2dwdS9TaGFkZXJDYWNoZS5oOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6Omdw dTo6U2hhZGVyQ2FjaGU6Oik6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L1NoYWRl ck9iamVjdC5jYzogQWRkZWQuCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L1NoYWRl ck9iamVjdC5oOiBBZGRlZC4KKwogMjAxMC0wOC0yNiAgTWFyayBSb3dlICA8bXJvd2VAYXBwbGUu Y29tPgogCiAgICAgICAgIERhcmluIHBvaW50ZWQgb3V0IHRoYXQgdGhlIGJyYWNlcyBhcmUgdW5u ZWNlc3NhcnkgaW4gYW4gT2JqZWN0aXZlLUMgaW50ZXJmYWNlCkluZGV4OiBXZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL2dwdS9QYXRoQ2FjaGUuY2MKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9ncHUvUGF0aENhY2hlLmNjCShyZXZpc2lvbiAwKQorKysgV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9ncHUvUGF0aENhY2hlLmNjCShyZXZpc2lvbiAwKQpAQCAtMCwwICsx LDExNyBAQAorLyoKKyAqIENvcHlyaWdodCAyMDEwLCBHb29nbGUgSW5jLgorICogQWxsIHJpZ2h0 cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQg YmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1p dHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoK KyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4g dGhlIGFib3ZlIGNvcHlyaWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBh bmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGlu IGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgor ICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3 aXRoIHRoZQorICogZGlzdHJpYnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBH b29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1 c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMg c29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgor ICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5E IENPTlRSSUJVVE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJS QU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdB UlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNV TEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklH SFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElO RElSRUNULCBJTkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5U SUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1F TlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRB LCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFO RCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNU UklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhF UldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZU V0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4K KyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisKKyNpbmNsdWRlICJncHUvUGF0aENhY2hlLmgi CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKK25hbWVzcGFjZSBncHUgeworCit1bnNpZ25lZCBpbnQg UGF0aENhY2hlOjpudW1WZXJ0aWNlcygpIGNvbnN0Cit7CisgIHJldHVybiBtX3ZlcnRpY2VzLnNp emUoKSAvIDI7Cit9CisKK2NvbnN0IGZsb2F0KiBQYXRoQ2FjaGU6OnZlcnRpY2VzKCkgY29uc3QK K3sKKyAgICBpZiAoIW51bVZlcnRpY2VzKCkpCisgICAgICAgIHJldHVybiAwOworICAgIHJldHVy biBtX3ZlcnRpY2VzLmRhdGEoKTsKK30KKworY29uc3QgZmxvYXQqIFBhdGhDYWNoZTo6dGV4Y29v cmRzKCkgY29uc3QKK3sKKyAgICBpZiAoIW51bVZlcnRpY2VzKCkpCisgICAgICAgIHJldHVybiAw OworICAgIHJldHVybiBtX3RleGNvb3Jkcy5kYXRhKCk7Cit9CisKK3ZvaWQgUGF0aENhY2hlOjph ZGRWZXJ0ZXgoZmxvYXQgeCwgZmxvYXQgeSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgZmxv YXQgaywgZmxvYXQgbCwgZmxvYXQgbSkKK3sKKyAgICBtX3ZlcnRpY2VzLmFwcGVuZCh4KTsKKyAg ICBtX3ZlcnRpY2VzLmFwcGVuZCh5KTsKKyAgICBtX3RleGNvb3Jkcy5hcHBlbmQoayk7CisgICAg bV90ZXhjb29yZHMuYXBwZW5kKGwpOworICAgIG1fdGV4Y29vcmRzLmFwcGVuZChtKTsKK30KKwor dm9pZCBQYXRoQ2FjaGU6OmNsZWFyKCkKK3sKKyAgICBtX3ZlcnRpY2VzLmNsZWFyKCk7CisgICAg bV90ZXhjb29yZHMuY2xlYXIoKTsKKyAgICBtX2ludGVyaW9yVmVydGljZXMuY2xlYXIoKTsKKyNp ZmRlZiBHUFVfUEFUSF9DQUNIRV9ERUJVR19JTlRFUklPUl9FREdFUworICAgIG1faW50ZXJpb3JF ZGdlVmVydGljZXMuY2xlYXIoKTsKKyNlbmRpZiAgLy8gR1BVX1BBVEhfQ0FDSEVfREVCVUdfSU5U RVJJT1JfRURHRVMKK30KKwordW5zaWduZWQgaW50IFBhdGhDYWNoZTo6bnVtSW50ZXJpb3JWZXJ0 aWNlcygpIGNvbnN0Cit7CisgICAgcmV0dXJuIG1faW50ZXJpb3JWZXJ0aWNlcy5zaXplKCkgLyAy OworfQorCitjb25zdCBmbG9hdCogUGF0aENhY2hlOjppbnRlcmlvclZlcnRpY2VzKCkgY29uc3QK K3sKKyAgICBpZiAoIW51bUludGVyaW9yVmVydGljZXMoKSkKKyAgICAgICAgcmV0dXJuIDA7Cisg ICAgcmV0dXJuIG1faW50ZXJpb3JWZXJ0aWNlcy5kYXRhKCk7Cit9CisKK3ZvaWQgUGF0aENhY2hl OjphZGRJbnRlcmlvclZlcnRleChmbG9hdCB4LCBmbG9hdCB5KQoreworICAgIG1faW50ZXJpb3JW ZXJ0aWNlcy5hcHBlbmQoeCk7CisgICAgbV9pbnRlcmlvclZlcnRpY2VzLmFwcGVuZCh5KTsKK30K KworI2lmZGVmIEdQVV9QQVRIX0NBQ0hFX0RFQlVHX0lOVEVSSU9SX0VER0VTCit1bnNpZ25lZCBp bnQgUGF0aENhY2hlOjpudW1JbnRlcmlvckVkZ2VWZXJ0aWNlcygpIGNvbnN0Cit7CisgICAgcmV0 dXJuIG1faW50ZXJpb3JFZGdlVmVydGljZXMuc2l6ZSgpIC8gMjsKK30KKworY29uc3QgZmxvYXQq IFBhdGhDYWNoZTo6aW50ZXJpb3JFZGdlVmVydGljZXMoKSBjb25zdAoreworICAgIGlmICghbnVt X2ludGVyaW9yX2VkZ2VfdmVydGljZXMoKSkKKyAgICAgICAgcmV0dXJuIDA7CisgICAgcmV0dXJu IG1faW50ZXJpb3JFZGdlVmVydGljZXMuZGF0YSgpOworfQorCit2b2lkIFBhdGhDYWNoZTo6YWRk SW50ZXJpb3JFZGdlVmVydGV4KGZsb2F0IHgsIGZsb2F0IHkpCit7CisgICAgbV9pbnRlcmlvckVk Z2VWZXJ0aWNlcy5hcHBlbmQoeCk7CisgICAgbV9pbnRlcmlvckVkZ2VWZXJ0aWNlcy5hcHBlbmQo eSk7Cit9CisjZW5kaWYgLy8gR1BVX1BBVEhfQ0FDSEVfREVCVUdfSU5URVJJT1JfRURHRVMKKwor fSAvLyBuYW1lc3BhY2UgZ3B1Cit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCkluZGV4OiBXZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9QYXRoQ2FjaGUuaAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9QYXRoQ2FjaGUuaAkocmV2aXNpb24gMCkKKysrIFdlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L1BhdGhDYWNoZS5oCShyZXZpc2lvbiAwKQpAQCAtMCww ICsxLDExNyBAQAorLyoKKyAqIENvcHlyaWdodCAyMDEwLCBHb29nbGUgSW5jLgorICogQWxsIHJp Z2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBh bmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBl cm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1l dDoKKyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRh aW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9u cyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25z IGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5v dGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1l cgorICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRl ZCB3aXRoIHRoZQorICogZGlzdHJpYnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBv ZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBi ZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRo aXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisg KgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMg QU5EIENPTlRSSUJVVE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBX QVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVE IFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJU SUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZ UklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1Qs IElORElSRUNULCBJTkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFV RU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VS RU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBE QVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VE IEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1Qs IFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBP VEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBT T0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFH RS4KKyAqLworCisjaWZuZGVmIGdwdV9QYXRoQ2FjaGVfaAorI2RlZmluZSBncHVfUGF0aENhY2hl X2gKKworI2luY2x1ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgorI2luY2x1ZGUgPHd0Zi9WZWN0b3Iu aD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworbmFtZXNwYWNlIGdwdSB7CisKKy8vIEEgY2FjaGUg b2YgdGhlIHByb2Nlc3NlZCB0cmlhbmdsZSBtZXNoIGZvciBhIGdpdmVuIHBhdGguIEJlY2F1c2UK Ky8vIHRoZXNlIG1pZ2h0IGJlIGV4cGVuc2l2ZSB0byBhbGxvY2F0ZSAodXNpbmcgbWFsbG9jL2Zy ZWUKKy8vIGludGVybmFsbHkpLCBpdCBpcyByZWNvbW1lbmRlZCB0byB0cnkgdG8gcmV1c2UgdGhl bSB3aGVuIHBvc3NpYmxlLgorCisvLyBVbmNvbW1lbnQgdGhlIGZvbGxvd2luZyB0byBvYnRhaW4g ZGVidWdnaW5nIGluZm9ybWF0aW9uIGZvciB0aGUgZWRnZXMgZmFjaW5nCisvLyB0aGUgaW50ZXJp b3IgcmVnaW9uIG9mIHRoZSBtZXNoLgorLy8gI2RlZmluZSBHUFVfUEFUSF9DQUNIRV9ERUJVR19J TlRFUklPUl9FREdFUworCitjbGFzcyBQYXRoQ2FjaGUgOiBwdWJsaWMgTm9uY29weWFibGUgewor cHVibGljOgorICAgIFBhdGhDYWNoZSgpCisgICAgeworICAgIH0KKworICAgIC8vIFRoZSBudW1i ZXIgb2YgdmVydGljZXMgaW4gdGhlIG1lc2guCisgICAgdW5zaWduZWQgaW50IG51bVZlcnRpY2Vz KCkgY29uc3Q7CisKKyAgICAvLyBHZXQgdGhlIGJhc2UgcG9pbnRlciB0byB0aGUgdmVydGV4IGlu Zm9ybWF0aW9uLiBUaGVyZSBhcmUgdHdvCisgICAgLy8gY29vcmRpbmF0ZXMgcGVyIHZlcnRleC4g VGhpcyBwb2ludGVyIGlzIHZhbGlkIHVudGlsIHRoZSBjYWNoZSBpcworICAgIC8vIGNsZWFyZWQg b3IgYW5vdGhlciB2ZXJ0ZXggaXMgYWRkZWQuIFJldHVybnMgMCBpZiB0aGVyZSBhcmUgbm8KKyAg ICAvLyB2ZXJ0aWNlcyBpbiB0aGUgbWVzaC4KKyAgICBjb25zdCBmbG9hdCogdmVydGljZXMoKSBj b25zdDsKKworICAgIC8vIEdldCB0aGUgYmFzZSBwb2ludGVyIHRvIHRoZSB0ZXh0dXJlIGNvb3Jk aW5hdGUgaW5mb3JtYXRpb24uIFRoZXJlCisgICAgLy8gYXJlIHRocmVlIGNvb3JkaW5hdGVzIHBl ciB2ZXJ0ZXguIFRoaXMgcG9pbnRlciBpcyB2YWxpZCB1bnRpbCB0aGUKKyAgICAvLyBjYWNoZSBp cyBjbGVhcmVkIG9yIGFub3RoZXIgdmVydGV4IGlzIGFkZGVkLiBSZXR1cm5zIDAgaWYKKyAgICAv LyB0aGVyZSBhcmUgbm8gdmVydGljZXMgaW4gdGhlIG1lc2guCisgICAgY29uc3QgZmxvYXQqIHRl eGNvb3JkcygpIGNvbnN0OworCisgICAgLy8gQWRkcyBhIHZlcnRleCdzIGluZm9ybWF0aW9uIHRv IHRoZSBjYWNoZS4gVGhlIGZpcnN0IHR3byBhcmd1bWVudHMKKyAgICAvLyBhcmUgdGhlIHggYW5k IHkgY29vcmRpbmF0ZXMgb2YgdGhlIHZlcnRleCBvbiB0aGUgcGxhbmU7IHRoZSBsYXN0CisgICAg Ly8gdGhyZWUgYXJndW1lbnRzIGFyZSB0aGUgY3ViaWMgdGV4dHVyZSBjb29yZGluYXRlcyBhc3Nv Y2lhdGVkIHdpdGgKKyAgICAvLyB0aGlzIHZlcnRleC4KKyAgICB2b2lkIGFkZFZlcnRleChmbG9h dCB4LCBmbG9hdCB5LAorICAgICAgICAgICAgICAgICAgIGZsb2F0IGssIGZsb2F0IGwsIGZsb2F0 IG0pOworCisgICAgLy8gVGhlIG51bWJlciBvZiBpbnRlcmlvciB2ZXJ0aWNlcy4KKyAgICB1bnNp Z25lZCBpbnQgbnVtSW50ZXJpb3JWZXJ0aWNlcygpIGNvbnN0OworICAgIC8vIEJhc2UgcG9pbnRl ciB0byB0aGUgaW50ZXJpb3IgdmVydGljZXM7IHR3byBjb29yZGluYXRlcyBwZXIKKyAgICAvLyB2 ZXJ0ZXgsIHdoaWNoIGNhbiBiZSBkcmF3biBhcyBHTF9UUklBTkdMRVMuIFJldHVybnMgMCBpZiB0 aGVyZQorICAgIC8vIGFyZSBubyBpbnRlcmlvciB2ZXJ0aWNlcyBpbiB0aGUgbWVzaC4KKyAgICBj b25zdCBmbG9hdCogaW50ZXJpb3JWZXJ0aWNlcygpIGNvbnN0OworICAgIC8vIEFkZHMgYW4gaW50 ZXJpb3IgdmVydGV4IHRvIHRoZSBjYWNoZS4KKyAgICB2b2lkIGFkZEludGVyaW9yVmVydGV4KGZs b2F0IHgsIGZsb2F0IHkpOworCisgICAgLy8gQ2xlYXJzIGFsbCBvZiB0aGUgc3RvcmVkIHZlcnRl eCBpbmZvcm1hdGlvbiBpbiB0aGlzIGNhY2hlLgorICAgIHZvaWQgY2xlYXIoKTsKKworI2lmZGVm IEdQVV9QQVRIX0NBQ0hFX0RFQlVHX0lOVEVSSU9SX0VER0VTCisgICAgLy8gVGhlIG51bWJlciBv ZiBpbnRlcmlvciBlZGdlIHZlcnRpY2VzCisgICAgdW5zaWduZWQgaW50IG51bUludGVyaW9yRWRn ZVZlcnRpY2VzKCkgY29uc3Q7CisgICAgLy8gQmFzZSBwb2ludGVyIHRvIHRoZSBpbnRlcmlvciB2 ZXJ0aWNlczsgdHdvIGNvb3JkaW5hdGVzIHBlcgorICAgIC8vIHZlcnRleCwgd2hpY2ggY2FuIGJl IGRyYXduIGFzIEdMX0xJTkVTLiBSZXR1cm5zIDAgaWYgdGhlcmUgYXJlCisgICAgLy8gbm8gaW50 ZXJpb3IgZWRnZSB2ZXJ0aWNlcyBpbiB0aGUgbWVzaC4KKyAgICBjb25zdCBmbG9hdCogaW50ZXJp b3JFZGdlVmVydGljZXMoKSBjb25zdDsKKyAgICB2b2lkIGFkZEludGVyaW9yRWRnZVZlcnRleChm bG9hdCB4LCBmbG9hdCB5KTsKKyNlbmRpZiAvLyBHUFVfUEFUSF9DQUNIRV9ERUJVR19JTlRFUklP Ul9FREdFUworCitwcml2YXRlOgorICAgIC8vIFRoZSB0d28tZGltZW5zaW9uYWwgdmVydGljZXMg b2YgdGhlIHRyaWFuZ2xlIG1lc2guCisgICAgVmVjdG9yPGZsb2F0PiBtX3ZlcnRpY2VzOworCisg ICAgLy8gVGhlIHRocmVlLWRpbWVuc2lvbmFsIGN1YmljIHRleHR1cmUgY29vcmRpbmF0ZXMuCisg ICAgVmVjdG9yPGZsb2F0PiBtX3RleGNvb3JkczsKKworICAgIFZlY3RvcjxmbG9hdD4gbV9pbnRl cmlvclZlcnRpY2VzOworCisjaWZkZWYgR1BVX1BBVEhfQ0FDSEVfREVCVUdfSU5URVJJT1JfRURH RVMKKyAgICAvLyBUaGUgZm9sbG93aW5nIGlzIG9ubHkgZm9yIGRlYnVnZ2luZworICAgIFZlY3Rv cjxmbG9hdD4gbV9pbnRlcmlvckVkZ2VWZXJ0aWNlczsKKyNlbmRpZiAvLyBHUFVfUEFUSF9DQUNI RV9ERUJVR19JTlRFUklPUl9FREdFUworfTsKKworfSAvLyBuYW1lc3BhY2UgZ3B1Cit9IC8vIG5h bWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBncHVfUGF0aENhY2hlX2gKSW5kZXg6IFdlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L1NoYWRlckNhY2hlLmNjCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L1NoYWRlckNhY2hlLmNjCShyZXZpc2lvbiAwKQor KysgV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUvU2hhZGVyQ2FjaGUuY2MJKHJldmlzaW9u IDApCkBAIC0wLDAgKzEsMTkxIEBACisvKgorICogQ29weXJpZ2h0IDIwMTAsIEdvb2dsZSBJbmMu CisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2Ug aW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0 aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25z IGFyZQorICogbWV0OgorICoKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29k ZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlzdCBv ZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBSZWRp c3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBj b3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2lu ZyBkaXNjbGFpbWVyCisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJp YWxzIHByb3ZpZGVkIHdpdGggdGhlCisgKiBkaXN0cmlidXRpb24uCisgKiAgICAgKiBOZWl0aGVy IHRoZSBuYW1lIG9mIEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisgKiBjb250cmli dXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQg ZnJvbQorICogdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVy bWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklH SFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBP UiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywg VEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9S CisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hB TEwgVEhFIENPUFlSSUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1Ig QU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlks IE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVE IFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9G IFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9X RVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJ TiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdM SUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisg KiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9G IFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKworI2luY2x1ZGUgImdw dS9TaGFkZXJDYWNoZS5oIgorCisjaW5jbHVkZSAiZ3B1L1NoYWRlck9iamVjdC5oIgorI2luY2x1 ZGUgIlBsYXRmb3JtU3RyaW5nLmgiCisjaW5jbHVkZSA8d3RmL3RleHQvQ1N0cmluZy5oPgorCitu YW1lc3BhY2UgV2ViQ29yZSB7CituYW1lc3BhY2UgZ3B1IHsKKworU2hhZGVyQ2FjaGU6OlNoYWRl ckNhY2hlKEdyYXBoaWNzQ29udGV4dDNEKiBjb250ZXh0KQorICAgIDogbV9jb250ZXh0KGNvbnRl eHQpCisgICAgLCBtX3NoYWRlcnMobmV3IE93blB0cjxTaGFkZXJPYmplY3Q+W051bVNoYWRlclR5 cGVzICogTnVtUmVnaW9uVHlwZXMgKiBOdW1BbnRpYWxpYXNUeXBlc10pCit7Cit9CisKK3N0cnVj dCBGaWxsQ29kZSB7CisgICAgY29uc3QgY2hhciogdW5pZm9ybXM7CisgICAgY29uc3QgY2hhciog c291cmNlOworfTsKKworLy8gU2hhZGVyIGNvZGUgZm9yIHRoZSB2YXJpb3VzIGZpbGxzLCBpbmRl eGVkIGJ5IFNoYWRlclR5cGUuCitzdGF0aWMgY29uc3QgRmlsbENvZGUgZmlsbENvZGVbU2hhZGVy Q2FjaGU6Ok51bVNoYWRlclR5cGVzXSA9IHsKKyAgICB7CisgICAgICAgIC8vIFNvbGlkIGZpbGwK KyAgICAgICAgInVuaWZvcm0gdmVjNCBjb2xvcjtcbiIsCisgICAgICAgICJnbF9GcmFnQ29sb3Ig PSBjb2xvciAqIGFscGhhO1xuIgorICAgIH0KK307CisKK1NoYWRlck9iamVjdCogU2hhZGVyQ2Fj aGU6OmdldFNoYWRlcihTaGFkZXJUeXBlIHNoYWRlclR5cGUsCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgUmVnaW9uVHlwZSByZWdpb25UeXBlLAorICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIEFudGlhbGlhc1R5cGUgYW50aWFsaWFzVHlwZSkKK3sKKyAg ICBpbnQgc2hhZGVySW5kZXggPSBzdGF0aWNfY2FzdDxpbnQ+KHNoYWRlclR5cGUpOworICAgIGlu dCBudW1TaGFkZXJzID0gc3RhdGljX2Nhc3Q8aW50PihOdW1TaGFkZXJUeXBlcyk7CisgICAgaW50 IHJlZ2lvbkluZGV4ID0gc3RhdGljX2Nhc3Q8aW50PihyZWdpb25UeXBlKTsKKyAgICBpbnQgbnVt UmVnaW9ucyA9IHN0YXRpY19jYXN0PGludD4oTnVtUmVnaW9uVHlwZXMpOworICAgIGludCBhbnRp YWxpYXNJbmRleCA9IHN0YXRpY19jYXN0PGludD4oYW50aWFsaWFzVHlwZSk7CisgICAgaW50IG51 bUFudGlhbGlhc2VzID0gc3RhdGljX2Nhc3Q8aW50PihOdW1BbnRpYWxpYXNUeXBlcyk7CisKKyAg ICBpbnQgaW5kZXggPSAoc2hhZGVySW5kZXggKiBudW1SZWdpb25zICogbnVtQW50aWFsaWFzZXMg KworICAgICAgICAgICAgICAgICByZWdpb25JbmRleCAqIG51bUFudGlhbGlhc2VzICsKKyAgICAg ICAgICAgICAgICAgYW50aWFsaWFzSW5kZXgpOworICAgIGlmIChtX3NoYWRlcnNbaW5kZXhdLmdl dCgpID09IDApCisgICAgICAgIG1fc2hhZGVyc1tpbmRleF0gPSBsb2FkU2hhZGVyKHNoYWRlclR5 cGUsIHJlZ2lvblR5cGUsIGFudGlhbGlhc1R5cGUpOworICAgIHJldHVybiBtX3NoYWRlcnNbaW5k ZXhdLmdldCgpOworfQorCitQYXNzT3duUHRyPFNoYWRlck9iamVjdD4gU2hhZGVyQ2FjaGU6Omxv YWRTaGFkZXIoU2hhZGVyVHlwZSBzaGFkZXJUeXBlLAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIFJlZ2lvblR5cGUgcmVnaW9uVHlwZSwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBBbnRpYWxpYXNUeXBlIGFu dGlhbGlhc1R5cGUpCit7CisgICAgY29uc3QgRmlsbENvZGUmIGZpbGwgPSBmaWxsQ29kZVtzaGFk ZXJUeXBlXTsKKworICAgIFN0cmluZyB2ZXJ0ZXhTaGFkZXJTb3VyY2UgPQorICAgICAgICAiLy8g VmVydGV4IHNoYWRlclxuIgorICAgICAgICAidW5pZm9ybSBtYXQ0IHdvcmxkVmlld1Byb2plY3Rp b247XG4iCisgICAgICAgICJcbiIKKyAgICAgICAgImF0dHJpYnV0ZSB2ZWMyIHBvc2l0aW9uO1xu IjsKKyAgICBpZiAocmVnaW9uVHlwZSA9PSBFeHRlcmlvcikgeworICAgICAgICB2ZXJ0ZXhTaGFk ZXJTb3VyY2UgKz0KKyAgICAgICAgICAgICJhdHRyaWJ1dGUgdmVjMyB0ZXhDb29yZDA7XG4iCisg ICAgICAgICAgICAiXG4iCisgICAgICAgICAgICAidmFyeWluZyB2ZWMzIGtsbTtcbiI7CisgICAg fQorICAgIHZlcnRleFNoYWRlclNvdXJjZSArPQorICAgICAgICAiXG4iCisgICAgICAgICJ2b2lk IG1haW4oKSB7XG4iCisgICAgICAgICIgIGdsX1Bvc2l0aW9uID0gd29ybGRWaWV3UHJvamVjdGlv biAqIHZlYzQocG9zaXRpb24sIDAuMCwgMS4wKTtcbiI7CisgICAgaWYgKHJlZ2lvblR5cGUgPT0g RXh0ZXJpb3IpCisgICAgICAgIHZlcnRleFNoYWRlclNvdXJjZSArPSAiICBrbG0gPSB0ZXhDb29y ZDA7XG4iOworICAgIHZlcnRleFNoYWRlclNvdXJjZSArPSAifVxuIjsKKworICAgIFN0cmluZyBm cmFnbWVudFNoYWRlclNvdXJjZSA9CisgICAgICAgICIjaWZkZWYgR0xfRVNcbiIKKyAgICAgICAg InByZWNpc2lvbiBtZWRpdW1wIGZsb2F0O1xuIgorICAgICAgICAiI2VuZGlmXG4iOworICAgIGlm IChyZWdpb25UeXBlID09IEV4dGVyaW9yKQorICAgICAgICBmcmFnbWVudFNoYWRlclNvdXJjZSAr PSAidmFyeWluZyB2ZWMzIGtsbTtcbiI7CisgICAgZnJhZ21lbnRTaGFkZXJTb3VyY2UgKz0gZmls bC51bmlmb3JtczsKKyAgICBmcmFnbWVudFNoYWRlclNvdXJjZSArPQorICAgICAgICAidm9pZCBt YWluKCkge1xuIjsKKyAgICBpZiAocmVnaW9uVHlwZSA9PSBJbnRlcmlvcikgeworICAgICAgICBm cmFnbWVudFNoYWRlclNvdXJjZSArPSAiICBmbG9hdCBhbHBoYSA9IDEuMDtcbiI7CisgICAgfSBl bHNlIHsKKyAgICAgICAgaWYgKGFudGlhbGlhc1R5cGUgPT0gQW50aWFsaWFzZWQpIHsKKyAgICAg ICAgICAgIGZyYWdtZW50U2hhZGVyU291cmNlICs9CisgICAgICAgICAgICAgICAgIiAgLy8gR3Jh ZGllbnRzXG4iCisgICAgICAgICAgICAgICAgIiAgdmVjMyBweCA9IGRGZHgoa2xtKTtcbiIKKyAg ICAgICAgICAgICAgICAiICB2ZWMzIHB5ID0gZEZkeShrbG0pO1xuIgorICAgICAgICAgICAgICAg ICJcbiIKKyAgICAgICAgICAgICAgICAiICAvLyBDaGFpbiBydWxlXG4iCisgICAgICAgICAgICAg ICAgIiAgZmxvYXQgazIgPSBrbG0ueCAqIGtsbS54O1xuIgorICAgICAgICAgICAgICAgICIgIGZs b2F0IGMgPSBrMiAqIGtsbS54IC0ga2xtLnkgKiBrbG0uejtcbiIKKyAgICAgICAgICAgICAgICAi ICBmbG9hdCBrMjMgPSAzLjAgKiBrMjtcbiIKKyAgICAgICAgICAgICAgICAiICBmbG9hdCBjeCA9 IGsyMyAqIHB4LnggLSBrbG0ueiAqIHB4LnkgLSBrbG0ueSAqIHB4Lno7XG4iCisgICAgICAgICAg ICAgICAgIiAgZmxvYXQgY3kgPSBrMjMgKiBweS54IC0ga2xtLnogKiBweS55IC0ga2xtLnkgKiBw eS56O1xuIgorICAgICAgICAgICAgICAgICJcbiIKKyAgICAgICAgICAgICAgICAiICAvLyBTaWdu ZWQgZGlzdGFuY2VcbiIKKyAgICAgICAgICAgICAgICAiICBmbG9hdCBzZCA9IGMgLyBzcXJ0KGN4 ICogY3ggKyBjeSAqIGN5KTtcbiIKKyAgICAgICAgICAgICAgICAiXG4iCisgICAgICAgICAgICAg ICAgIiAgLy8gTGluZWFyIGFscGhhXG4iCisgICAgICAgICAgICAgICAgIiAgLy8gVE9ETyhrYnIp OiBmaWd1cmUgb3V0IHdoeSB0aGlzIG5lZWRzIHRvIGJlXG4iCisgICAgICAgICAgICAgICAgIiAg Ly8gbmVnYXRlZCBjb21wYXJlZCB0byBDZyB2ZXJzaW9uLCBhbmQgYWxzbyB3aHlcbiIKKyAgICAg ICAgICAgICAgICAiICAvLyB3ZSBuZWVkIGFuIGFkanVzdG1lbnQgYnkgKzEuMCBmb3IgaXQgdG8g bG9vayBnb29kLlxuIgorICAgICAgICAgICAgICAgICIgIC8vIGZsb2F0IGFscGhhID0gY2xhbXAo MC41IC0gc2QsIDAuMCwgMS4wKTtcbiIKKyAgICAgICAgICAgICAgICAiICBmbG9hdCBhbHBoYSA9 IGNsYW1wKHNkICsgMC41LCAwLjAsIDEuMCk7XG4iOworICAgICAgICB9IGVsc2UgeworICAgICAg ICAgICAgZnJhZ21lbnRTaGFkZXJTb3VyY2UgKz0KKyAgICAgICAgICAgICAgICAiICBmbG9hdCB0 ID0ga2xtLnggKiBrbG0ueCAqIGtsbS54IC0ga2xtLnkgKiBrbG0uejtcbiIKKyAgICAgICAgICAg ICAgICAiICBmbG9hdCBhbHBoYSA9IGNsYW1wKHNpZ24odCksIDAuMCwgMS4wKTtcbiI7CisgICAg ICAgIH0KKyAgICB9CisgICAgZnJhZ21lbnRTaGFkZXJTb3VyY2UgKz0gZmlsbC5zb3VyY2U7Cisg ICAgZnJhZ21lbnRTaGFkZXJTb3VyY2UgKz0gIn1cbiI7CisgICAgdW5zaWduZWQgdmVydGV4U2hh ZGVyID0gY3JlYXRlU2hhZGVyRnJvbVNvdXJjZShHcmFwaGljc0NvbnRleHQzRDo6VkVSVEVYX1NI QURFUiwgdmVydGV4U2hhZGVyU291cmNlKTsKKyAgICB1bnNpZ25lZCBmcmFnbWVudFNoYWRlciA9 IGNyZWF0ZVNoYWRlckZyb21Tb3VyY2UoR3JhcGhpY3NDb250ZXh0M0Q6OkZSQUdNRU5UX1NIQURF UiwgZnJhZ21lbnRTaGFkZXJTb3VyY2UpOworICAgIGlmICghdmVydGV4U2hhZGVyIHx8ICFmcmFn bWVudFNoYWRlcikKKyAgICAgICAgcmV0dXJuIDA7CisgICAgdW5zaWduZWQgcHJvZ3JhbSA9IG1f Y29udGV4dC0+Y3JlYXRlUHJvZ3JhbSgpOworICAgIG1fY29udGV4dC0+YXR0YWNoU2hhZGVyKHBy b2dyYW0sIHZlcnRleFNoYWRlcik7CisgICAgbV9jb250ZXh0LT5hdHRhY2hTaGFkZXIocHJvZ3Jh bSwgZnJhZ21lbnRTaGFkZXIpOworICAgIG1fY29udGV4dC0+bGlua1Byb2dyYW0ocHJvZ3JhbSk7 CisgICAgaW50IGxpbmtTdGF0dXMgPSAwOworICAgIG1fY29udGV4dC0+Z2V0UHJvZ3JhbWl2KHBy b2dyYW0sIEdyYXBoaWNzQ29udGV4dDNEOjpMSU5LX1NUQVRVUywgJmxpbmtTdGF0dXMpOworICAg IGlmICghbGlua1N0YXR1cykgeworI2lmbmRlZiBOREVCVUcKKyAgICAgICAgU3RyaW5nIGxvZyA9 IG1fY29udGV4dC0+Z2V0UHJvZ3JhbUluZm9Mb2cocHJvZ3JhbSk7CisgICAgICAgIGZwcmludGYo c3RkZXJyLCAiU2hhZGVyQ2FjaGU6IGVycm9yIGxpbmtpbmcgcHJvZ3JhbTogJXNcbiIsIGxvZy5h c2NpaSgpLmRhdGEoKSk7CisjZW5kaWYKKyAgICAgICAgcmV0dXJuIDA7CisgICAgfQorICAgIG1f Y29udGV4dC0+ZGVsZXRlU2hhZGVyKHZlcnRleFNoYWRlcik7CisgICAgbV9jb250ZXh0LT5kZWxl dGVTaGFkZXIoZnJhZ21lbnRTaGFkZXIpOworICAgIHJldHVybiBhZG9wdFB0cihuZXcgU2hhZGVy T2JqZWN0KG1fY29udGV4dCwgcHJvZ3JhbSkpOworfQorCitQbGF0Zm9ybTNET2JqZWN0IFNoYWRl ckNhY2hlOjpjcmVhdGVTaGFkZXJGcm9tU291cmNlKEdyYXBoaWNzQ29udGV4dDNEOjpXZWJHTEVu dW1UeXBlIHNoYWRlclR5cGUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIGNvbnN0IFN0cmluZyYgc291cmNlKQoreworICAgIHVuc2lnbmVkIHNo YWRlciA9IG1fY29udGV4dC0+Y3JlYXRlU2hhZGVyKHNoYWRlclR5cGUpOworICAgIG1fY29udGV4 dC0+c2hhZGVyU291cmNlKHNoYWRlciwgc291cmNlKTsKKyAgICBtX2NvbnRleHQtPmNvbXBpbGVT aGFkZXIoc2hhZGVyKTsKKyAgICBpbnQgY29tcGlsZVN0YXR1cyA9IDA7CisgICAgbV9jb250ZXh0 LT5nZXRTaGFkZXJpdihzaGFkZXIsIEdyYXBoaWNzQ29udGV4dDNEOjpDT01QSUxFX1NUQVRVUywg JmNvbXBpbGVTdGF0dXMpOworICAgIGlmICghY29tcGlsZVN0YXR1cykgeworI2lmbmRlZiBOREVC VUcKKyAgICAgICAgU3RyaW5nIGxvZyA9IG1fY29udGV4dC0+Z2V0U2hhZGVySW5mb0xvZyhzaGFk ZXIpOworICAgICAgICBmcHJpbnRmKHN0ZGVyciwgIlNoYWRlckNhY2hlOiBlcnJvciBjb21waWxp bmcgc2hhZGVyOiAlc1xuIiwgbG9nLmFzY2lpKCkuZGF0YSgpKTsKKyAgICAgICAgZnByaW50Zihz dGRlcnIsICJzb3VyY2U6XG4lc1xuIiwgc291cmNlLmFzY2lpKCkuZGF0YSgpKTsKKyNlbmRpZgor ICAgICAgICByZXR1cm4gMDsKKyAgICB9CisgICAgcmV0dXJuIHNoYWRlcjsKK30KKworfSAvLyBu YW1lc3BhY2UgZ3B1Cit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCkluZGV4OiBXZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL2dwdS9TaGFkZXJDYWNoZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvZ3B1L1NoYWRlckNhY2hlLmgJKHJldmlzaW9uIDApCisrKyBXZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9TaGFkZXJDYWNoZS5oCShyZXZpc2lvbiAwKQpAQCAtMCww ICsxLDkxIEBACisvKgorICogQ29weXJpZ2h0IDIwMTAsIEdvb2dsZSBJbmMuCisgKiBBbGwgcmln aHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFu ZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVy bWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorICogbWV0 OgorICoKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFp biB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMg aW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5cmlnaHQgbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy CisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVk IHdpdGggdGhlCisgKiBkaXN0cmlidXRpb24uCisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9m IEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisgKiBjb250cmlidXRvcnMgbWF5IGJl IHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorICogdGhp cyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAq CisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBB TkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdB UlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQg V0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJ Q1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlS SUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwg SU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVF TlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJF TUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERB VEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQg QU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwg U1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9U SEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNP RlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdF LgorICovCisKKyNpZm5kZWYgZ3B1X1NoYWRlckNhY2hlX2gKKyNkZWZpbmUgZ3B1X1NoYWRlckNh Y2hlX2gKKworI2luY2x1ZGUgIkdyYXBoaWNzQ29udGV4dDNELmgiCisjaW5jbHVkZSA8d3RmL05v bmNvcHlhYmxlLmg+CisjaW5jbHVkZSA8d3RmL093bkFycmF5UHRyLmg+CisjaW5jbHVkZSA8d3Rm L1Bhc3NPd25QdHIuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworbmFtZXNwYWNlIGdwdSB7CisK K2NsYXNzIFNoYWRlck9iamVjdDsKKworLy8gVGhlIFNoYWRlckNhY2hlIGxhemlseSBnZW5lcmF0 ZXMsIGxvYWRzIGFuZCBjYWNoZXMgdGhlIHNoYWRlcnMKKy8vIG5lZWRlZCB0byBmaWxsIHRoZSB0 cmlhbmdsZSBtZXNoZXMgZ2VuZXJhdGVkIGJ5IExvb3AgYW5kIEJsaW5uJ3MKKy8vIGFsZ29yaXRo bS4KKworY2xhc3MgU2hhZGVyQ2FjaGUgOiBwdWJsaWMgTm9uY29weWFibGUgeworcHVibGljOgor ICAgIFNoYWRlckNhY2hlKEdyYXBoaWNzQ29udGV4dDNEKiBjb250ZXh0KTsKKworICAgIGVudW0g U2hhZGVyVHlwZSB7CisgICAgICAgIFNvbGlkRmlsbCwKKyAgICAgICAgLy8gRklYTUU6IGFkZCBt b3JlIHR5cGVzIG9mIHNoYWRlcnMgKGdyYWRpZW50cywgcGF0dGVybnMsIGV0Yy4pCisgICAgICAg IE51bVNoYWRlclR5cGVzIC8vIE11c3QgYmUgbGFzdAorICAgIH07CisKKyAgICBlbnVtIFJlZ2lv blR5cGUgeworICAgICAgICBFeHRlcmlvciwgLy8gTG9vcCBhbmQgQmxpbm4ncyBzaGFkZXIKKyAg ICAgICAgSW50ZXJpb3IsIC8vIFNvbGlkIGZpbGxlZCByZWdpb24KKyAgICAgICAgTnVtUmVnaW9u VHlwZXMgLy8gTXVzdCBiZSBsYXN0CisgICAgfTsKKworICAgIC8vIFRoaXMgb25seSBhZmZlY3Rz IHRoZSBleHRlcmlvciBzaGFkZXIuCisgICAgZW51bSBBbnRpYWxpYXNUeXBlIHsKKyAgICAgICAg QW50aWFsaWFzZWQsCisgICAgICAgIE5vdEFudGlhbGlhc2VkLAorICAgICAgICBOdW1BbnRpYWxp YXNUeXBlcyAvLyBNdXN0IGJlIGxhc3QKKyAgICB9OworCisgICAgLy8gVGhlIFNoYWRlckNhY2hl IG93bnMgdGhlIHJldHVybmVkIHBvaW50ZXIuCisgICAgU2hhZGVyT2JqZWN0KiBnZXRTaGFkZXIo U2hhZGVyVHlwZSBzaGFkZXJUeXBlLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgIFJlZ2lv blR5cGUgcmVnaW9uVHlwZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBBbnRpYWxpYXNU eXBlIGFudGlhbGlhc1R5cGUpOworCitwcml2YXRlOgorICAgIFBhc3NPd25QdHI8U2hhZGVyT2Jq ZWN0PiBsb2FkU2hhZGVyKFNoYWRlclR5cGUgc2hhZGVyVHlwZSwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBSZWdpb25UeXBlIHJlZ2lvblR5cGUsCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQW50aWFsaWFzVHlwZSBhbnRpYWxpYXNUeXBl KTsKKyAgICBQbGF0Zm9ybTNET2JqZWN0IGNyZWF0ZVNoYWRlckZyb21Tb3VyY2UoR3JhcGhpY3ND b250ZXh0M0Q6OldlYkdMRW51bVR5cGUgc2hhZGVyVHlwZSwKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgU3RyaW5nJiBzb3VyY2UpOworCisgICAgR3Jh cGhpY3NDb250ZXh0M0QqIG1fY29udGV4dDsKKyAgICBPd25BcnJheVB0cjxPd25QdHI8U2hhZGVy T2JqZWN0PiA+IG1fc2hhZGVyczsKK307CisKK30gLy8gbmFtZXNwYWNlIGdwdQorfSAvLyBuYW1l c3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gZ3B1X1NoYWRlckNhY2hlX2gKSW5kZXg6IFdlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L1NoYWRlck9iamVjdC5jYwo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBX ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9TaGFkZXJPYmplY3QuY2MJKHJldmlzaW9uIDAp CisrKyBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9TaGFkZXJPYmplY3QuY2MJKHJldmlz aW9uIDApCkBAIC0wLDAgKzEsNzYgQEAKKy8qCisgKiBDb3B5cmlnaHQgMjAxMCwgR29vZ2xlIElu Yy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVz ZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmlj YXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlv bnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBj b2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwgdGhpcyBsaXN0 IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqICAgICAqIFJl ZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyAq IGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93 aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRl cmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAgICAqIE5laXRo ZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMKKyAqIGNvbnRy aWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZl ZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBw ZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlS SUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNT IE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRP LCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBG T1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBT SEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZP UiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVYRU1QTEFS WSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlU RUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1Mg T0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBI T1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVS IElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5F R0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UK KyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkg T0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorCisjaW5jbHVkZSAi Z3B1L1NoYWRlck9iamVjdC5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CituYW1lc3BhY2UgZ3B1 IHsKKworU2hhZGVyT2JqZWN0OjpTaGFkZXJPYmplY3QoR3JhcGhpY3NDb250ZXh0M0QqIGNvbnRl eHQsCisgICAgICAgICAgICAgICAgICAgICAgICAgICBQbGF0Zm9ybTNET2JqZWN0IHByb2dyYW0p CisgICAgOiBtX2NvbnRleHQoY29udGV4dCkKKyAgICAsIG1fcHJvZ3JhbShwcm9ncmFtKQorewor fQorCit2b2lkIFNoYWRlck9iamVjdDo6dXNlKCkKK3sKKyAgICBtX2NvbnRleHQtPnVzZVByb2dy YW0obV9wcm9ncmFtKTsKK30KKworbG9uZyBTaGFkZXJPYmplY3Q6OmdldFVuaWZvcm1Mb2NhdGlv bihjb25zdCBTdHJpbmcmIG5hbWUpCit7CisgICAgSGFzaE1hcDxTdHJpbmcsIGxvbmc+OjppdGVy YXRvciBpdGVyID0gbV91bmlmb3JtTG9jYXRpb25zLmZpbmQobmFtZSk7CisgICAgaWYgKGl0ZXIg PT0gbV91bmlmb3JtTG9jYXRpb25zLmVuZCgpKSB7CisgICAgICAgIC8vIExvb2sgaXQgdXAKKyAg ICAgICAgbG9uZyBsb2NhdGlvbiA9IG1fY29udGV4dC0+Z2V0VW5pZm9ybUxvY2F0aW9uKG1fcHJv Z3JhbSwgbmFtZSk7CisgICAgICAgIG1fdW5pZm9ybUxvY2F0aW9ucy5hZGQobmFtZSwgbG9jYXRp b24pOworICAgICAgICByZXR1cm4gbG9jYXRpb247CisgICAgfQorICAgIHJldHVybiBpdGVyLT5z ZWNvbmQ7Cit9CisKK2xvbmcgU2hhZGVyT2JqZWN0OjpnZXRBdHRyaWJMb2NhdGlvbihjb25zdCBT dHJpbmcmIG5hbWUpCit7CisgICAgSGFzaE1hcDxTdHJpbmcsIGxvbmc+OjppdGVyYXRvciBpdGVy ID0gbV9hdHRyaWJMb2NhdGlvbnMuZmluZChuYW1lKTsKKyAgICBpZiAoaXRlciA9PSBtX2F0dHJp YkxvY2F0aW9ucy5lbmQoKSkgeworICAgICAgICAvLyBMb29rIGl0IHVwCisgICAgICAgIGxvbmcg bG9jYXRpb24gPSBtX2NvbnRleHQtPmdldEF0dHJpYkxvY2F0aW9uKG1fcHJvZ3JhbSwgbmFtZSk7 CisgICAgICAgIG1fYXR0cmliTG9jYXRpb25zLmFkZChuYW1lLCBsb2NhdGlvbik7CisgICAgICAg IHJldHVybiBsb2NhdGlvbjsKKyAgICB9CisgICAgcmV0dXJuIGl0ZXItPnNlY29uZDsKK30KKwor fSAvLyBuYW1lc3BhY2UgZ3B1Cit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCkluZGV4OiBXZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9TaGFkZXJPYmplY3QuaAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9TaGFkZXJPYmplY3QuaAkocmV2aXNpb24gMCkKKysr IFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L1NoYWRlck9iamVjdC5oCShyZXZpc2lvbiAw KQpAQCAtMCwwICsxLDcxIEBACisvKgorICogQ29weXJpZ2h0IDIwMTAsIEdvb2dsZSBJbmMuCisg KiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4g c291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9u LCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFy ZQorICogbWV0OgorICoKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBt dXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlzdCBvZiBj b25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBSZWRpc3Ry aWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5 cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBk aXNjbGFpbWVyCisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxz IHByb3ZpZGVkIHdpdGggdGhlCisgKiBkaXN0cmlidXRpb24uCisgKiAgICAgKiBOZWl0aGVyIHRo ZSBuYW1lIG9mIEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisgKiBjb250cmlidXRv cnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJv bQorICogdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlz c2lvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQg SE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJ TVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhF IElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisg KiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwg VEhFIENPUFlSSUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5Z IERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9S IENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRP LCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVT RSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZF UiBDQVVTRUQgQU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBD T05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdF TkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBP RiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNV Q0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgZ3B1X1NoYWRlck9iamVjdF9oCisjZGVmaW5lIGdw dV9TaGFkZXJPYmplY3RfaAorCisjaW5jbHVkZSAiR3JhcGhpY3NDb250ZXh0M0QuaCIKKyNpbmNs dWRlICJQbGF0Zm9ybVN0cmluZy5oIgorI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CisjaW5jbHVk ZSA8d3RmL05vbmNvcHlhYmxlLmg+CisjaW5jbHVkZSA8d3RmL3RleHQvU3RyaW5nSGFzaC5oPgor CituYW1lc3BhY2UgV2ViQ29yZSB7CituYW1lc3BhY2UgZ3B1IHsKKworLy8gV3JhcHMgYW4gT3Bl bkdMIHNoYWRlciAobW9yZSBwcmVjaXNlbHksIGEgcHJvZ3JhbSBvYmplY3QpIGFuZAorLy8gcHJv dmlkZXMgYSBjYWNoZSBvZiBpdHMgdW5pZm9ybSBsb2NhdGlvbnMuCitjbGFzcyBTaGFkZXJPYmpl Y3QgOiBwdWJsaWMgTm9uY29weWFibGUgeworcHVibGljOgorICAgIFNoYWRlck9iamVjdChHcmFw aGljc0NvbnRleHQzRCogY29udGV4dCwgUGxhdGZvcm0zRE9iamVjdCBwcm9ncmFtKTsKKworICAg IC8vIE1ha2VzIHRoaXMgcHJvZ3JhbSB0aGUgY3VycmVudCBvbmUgaW4gdGhlIGNvbnRleHQuCisg ICAgdm9pZCB1c2UoKTsKKworICAgIC8vIFJldHVybnMgdGhlIGxvY2F0aW9uIG9mIHRoZSBnaXZl biB1bmlmb3JtLCBvciAtMSBpZiBpdCBkb2VzIG5vdAorICAgIC8vIGV4aXN0IGluIHRoZSBwcm9n cmFtLgorICAgIGxvbmcgZ2V0VW5pZm9ybUxvY2F0aW9uKGNvbnN0IFN0cmluZyYgbmFtZSk7CisK KyAgICAvLyBSZXR1cm5zIHRoZSBsb2NhdGlvbiBvZiB0aGUgZ2l2ZW4gYXR0cmlidXRlLCBvciAt MSBpZiBpdCBkb2VzCisgICAgLy8gbm90IGV4aXN0IGluIHRoZSBwcm9ncmFtLgorICAgIGxvbmcg Z2V0QXR0cmliTG9jYXRpb24oY29uc3QgU3RyaW5nJiBuYW1lKTsKKworcHJpdmF0ZToKKyAgICBH cmFwaGljc0NvbnRleHQzRCogbV9jb250ZXh0OworICAgIFBsYXRmb3JtM0RPYmplY3QgbV9wcm9n cmFtOworICAgIEhhc2hNYXA8U3RyaW5nLCBsb25nPiBtX3VuaWZvcm1Mb2NhdGlvbnM7CisgICAg SGFzaE1hcDxTdHJpbmcsIGxvbmc+IG1fYXR0cmliTG9jYXRpb25zOworfTsKKworfSAvLyBuYW1l c3BhY2UgZ3B1Cit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBncHVfU2hhZGVy T2JqZWN0X2gK 65661 2010-08-26 19:34:06 -0700 2010-08-30 11:50:21 -0700 Cubic curve classification, texture coordinate assignment, local triangulation and math utilities cubic.patch text/plain 72838 kbr SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA2NjE2NSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMTAxIEBACisyMDEwLTA4LTI2ICBLZW5uZXRoIFJ1c3NlbGwgIDxrYnJAZ29vZ2xl LmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBB ZGQgc3VwcG9ydCBmb3IgR1BVIGFjY2VsZXJhdGVkIHBhdGggcmVuZGVyaW5nCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD00NDcyOQorCisgICAgICAgIFRo aXMgcGF0Y2ggYWRkcyB0aGUgY2xhc3NpZmljYXRpb24gb2YgY3ViaWMgY3VydmUgc2VnbWVudHMg aW50bworICAgICAgICBjYXRlZ29yaWVzLCBhc3NpZ25tZW50IG9mIHRleHR1cmUgY29vcmRpbmF0 ZXMgdG8gdGhlIGN1cnZlcycKKyAgICAgICAgY29udHJvbCBwb2ludHMgZm9yIGxhdGVyIHJlbmRl cmluZyBvbiB0aGUgR1BVLCB0aGUgYWxnb3JpdGhtIGZvcgorICAgICAgICB0cmlhbmd1bGF0aW5n IGFuIGluZGl2aWR1YWwgY3ViaWMgY3VydmUgYW5kIHdhbGtpbmcgaXRzIGludGVyaW9yCisgICAg ICAgIGVkZ2VzIGZvciBhc3NlbWJseSBpbnRvIGEgY29tcGxldGUgZmlsbGVkIHNoYXBlLCBhbmQg c2V2ZXJhbAorICAgICAgICB1dGlsaXR5IHJvdXRpbmVzIHJlbGF0ZWQgdG8gZ2VvbWV0cnkgYW5k IGN1YmljIGN1cnZlIHByb2Nlc3NpbmcsCisgICAgICAgIHNvbWUgcG9ydGVkIGZyb20gU2tpYS4K KworICAgICAgICBUaGUgcmVhc29uIGZvciB0aGUgc3R5bGUgdmlvbGF0aW9ucyBpbiB0aGUgaGVh ZGVyIGd1YXJkcyBpcworICAgICAgICBkZXNjcmliZWQgaW4gdGhlIGVhcmxpZXIgcGF0Y2guIFRo ZXJlIGlzIGFub3RoZXIgdmlvbGF0aW9uIGFyb3VuZAorICAgICAgICB0aGUgdXNlIG9mIHRoZSBs ZXR0ZXIgbCBhcyBhbiBpZGVudGlmaWVyLCBidXQgdGhlIGFsZ29yaXRobQorICAgICAgICBkZWZp bmVzIGNvb3JkaW5hdGVzIGssIGwsIGFuZCBtLCBzbyBpdCBzZWVtcyBiZXN0IHRvIG1hdGNoIHRo ZQorICAgICAgICBhbGdvcml0aG0ncyB0ZXJtaW5vbG9neSByYXRoZXIgdGhhbiB0aGUgc3R5bGUg Z3VpZGUgaW4gdGhpcyBjYXNlLgorCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1OiBB ZGRlZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9ncHUvQ3ViaWNDbGFzc2lmaWVyLmNw cDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpncHU6OkN1YmljQ2xhc3NpZmllcjo6Y2xhc3Np ZnkpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2dwdS9DdWJpY0NsYXNzaWZpZXIuaDog QWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpncHU6OkN1YmljQ2xhc3NpZmllcjo6KToKKyAgICAg ICAgKFdlYkNvcmU6OmdwdTo6Q3ViaWNDbGFzc2lmaWVyOjpSZXN1bHQ6OlJlc3VsdCk6CisgICAg ICAgIChXZWJDb3JlOjpncHU6OkN1YmljQ2xhc3NpZmllcjo6UmVzdWx0OjpjdXJ2ZVR5cGUpOgor ICAgICAgICAoV2ViQ29yZTo6Z3B1OjpDdWJpY0NsYXNzaWZpZXI6OlJlc3VsdDo6ZDEpOgorICAg ICAgICAoV2ViQ29yZTo6Z3B1OjpDdWJpY0NsYXNzaWZpZXI6OlJlc3VsdDo6ZDIpOgorICAgICAg ICAoV2ViQ29yZTo6Z3B1OjpDdWJpY0NsYXNzaWZpZXI6OlJlc3VsdDo6ZDMpOgorICAgICAgICAo V2ViQ29yZTo6Z3B1OjpDdWJpY0NsYXNzaWZpZXI6OkN1YmljQ2xhc3NpZmllcik6CisgICAgICAg ICogcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L0N1YmljTWF0aFV0aWxzLmNwcDogQWRkZWQuCisgICAg ICAgIChXZWJDb3JlOjpncHU6Om9yaWVudGF0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6 ZWRnZUVkZ2VUZXN0KToKKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6ZWRnZUFnYWluc3RUcmlFZGdl cyk6CisgICAgICAgIChXZWJDb3JlOjpncHU6OmxpbmVzSW50ZXJzZWN0KToKKyAgICAgICAgKFdl YkNvcmU6OmdwdTo6cG9pbnRJblRyaWFuZ2xlKToKKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6dHJp YW5nbGVzT3ZlcmxhcCk6CisgICAgICAgIChXZWJDb3JlOjpncHU6Om5lYXJseVplcm8pOgorICAg ICAgICAoV2ViQ29yZTo6Z3B1OjppbnRlcnApOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpldmFs Q3ViaWMpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpldmFsQ3ViaWNBdCk6CisgICAgICAgIChX ZWJDb3JlOjpncHU6OnhSYXlDcm9zc2VzTW9ub3RvbmljQ3ViaWMpOgorICAgICAgICAoV2ViQ29y ZTo6Z3B1Ojp2YWxpZFVuaXREaXZpZGUpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpmaW5kVW5p dFF1YWRSb290cyk6CisgICAgICAgIChXZWJDb3JlOjpncHU6OmZpbmRDdWJpY0V4dHJlbWEpOgor ICAgICAgICAoV2ViQ29yZTo6Z3B1OjppbnRlcnBDdWJpY0Nvb3Jkcyk6CisgICAgICAgIChXZWJD b3JlOjpncHU6OmlzVW5pdEludGVydmFsKToKKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6Y2hvcEN1 YmljQXQpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpmbGF0dGVuRG91YmxlQ3ViaWNZRXh0cmVt YSk6CisgICAgICAgIChXZWJDb3JlOjpncHU6OmNob3BDdWJpY0F0WUV4dHJlbWEpOgorICAgICAg ICAoV2ViQ29yZTo6Z3B1Ojp4UmF5Q3Jvc3Nlc0xpbmUpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1 OjpudW1YUmF5Q3Jvc3NpbmdzRm9yQ3ViaWMpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNz L2dwdS9DdWJpY01hdGhVdGlscy5oOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6cm91 bmRUb1plcm8pOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpkaXN0YW5jZSk6CisgICAgICAgIChX ZWJDb3JlOjpncHU6OmFwcHJveEVxdWFsKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9n cHUvQ3ViaWNUZXh0dXJlQ29vcmRzLmNwcDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpncHU6 OkN1YmljVGV4dHVyZUNvb3Jkczo6Q29tcHV0ZSk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhp Y3MvZ3B1L0N1YmljVGV4dHVyZUNvb3Jkcy5oOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6Omdw dTo6Q3ViaWNUZXh0dXJlQ29vcmRzOjpSZXN1bHQ6OlJlc3VsdCk6CisgICAgICAgIChXZWJDb3Jl OjpncHU6OkN1YmljVGV4dHVyZUNvb3Jkczo6Q3ViaWNUZXh0dXJlQ29vcmRzKToKKyAgICAgICAg KiBwbGF0Zm9ybS9ncmFwaGljcy9ncHUvTG9jYWxUcmlhbmd1bGF0b3IuY3BwOiBBZGRlZC4KKyAg ICAgICAgKFdlYkNvcmU6OmdwdTo6TG9jYWxUcmlhbmd1bGF0b3I6OlRyaWFuZ2xlOjpjb250YWlu cyk6CisgICAgICAgIChXZWJDb3JlOjpncHU6OkxvY2FsVHJpYW5ndWxhdG9yOjpUcmlhbmdsZTo6 bmV4dFZlcnRleCk6CisgICAgICAgIChXZWJDb3JlOjpncHU6OkxvY2FsVHJpYW5ndWxhdG9yOjpU cmlhbmdsZTo6aW5kZXhGb3JWZXJ0ZXgpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpMb2NhbFRy aWFuZ3VsYXRvcjo6VHJpYW5nbGU6Om1ha2VDQ1cpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpM b2NhbFRyaWFuZ3VsYXRvcjo6TG9jYWxUcmlhbmd1bGF0b3IpOgorICAgICAgICAoV2ViQ29yZTo6 Z3B1OjpMb2NhbFRyaWFuZ3VsYXRvcjo6cmVzZXQpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpM b2NhbFRyaWFuZ3VsYXRvcjo6dHJpYW5ndWxhdGUpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpM b2NhbFRyaWFuZ3VsYXRvcjo6YWRkVHJpYW5nbGUpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpM b2NhbFRyaWFuZ3VsYXRvcjo6YWRkSW50ZXJpb3JWZXJ0ZXgpOgorICAgICAgICAoV2ViQ29yZTo6 Z3B1OjpMb2NhbFRyaWFuZ3VsYXRvcjo6aXNTaGFyZWRFZGdlKToKKyAgICAgICAgKiBwbGF0Zm9y bS9ncmFwaGljcy9ncHUvTG9jYWxUcmlhbmd1bGF0b3IuaDogQWRkZWQuCisgICAgICAgIChXZWJD b3JlOjpncHU6OkxvY2FsVHJpYW5ndWxhdG9yOjpWZXJ0ZXg6OlZlcnRleCk6CisgICAgICAgIChX ZWJDb3JlOjpncHU6OkxvY2FsVHJpYW5ndWxhdG9yOjpWZXJ0ZXg6OngpOgorICAgICAgICAoV2Vi Q29yZTo6Z3B1OjpMb2NhbFRyaWFuZ3VsYXRvcjo6VmVydGV4Ojp5KToKKyAgICAgICAgKFdlYkNv cmU6OmdwdTo6TG9jYWxUcmlhbmd1bGF0b3I6OlZlcnRleDo6ayk6CisgICAgICAgIChXZWJDb3Jl OjpncHU6OkxvY2FsVHJpYW5ndWxhdG9yOjpWZXJ0ZXg6OmwpOgorICAgICAgICAoV2ViQ29yZTo6 Z3B1OjpMb2NhbFRyaWFuZ3VsYXRvcjo6VmVydGV4OjptKToKKyAgICAgICAgKFdlYkNvcmU6Omdw dTo6TG9jYWxUcmlhbmd1bGF0b3I6OlZlcnRleDo6c2V0KToKKyAgICAgICAgKFdlYkNvcmU6Omdw dTo6TG9jYWxUcmlhbmd1bGF0b3I6OlZlcnRleDo6ZW5kKToKKyAgICAgICAgKFdlYkNvcmU6Omdw dTo6TG9jYWxUcmlhbmd1bGF0b3I6OlZlcnRleDo6c2V0RW5kKToKKyAgICAgICAgKFdlYkNvcmU6 OmdwdTo6TG9jYWxUcmlhbmd1bGF0b3I6OlZlcnRleDo6bWFya2VkKToKKyAgICAgICAgKFdlYkNv cmU6OmdwdTo6TG9jYWxUcmlhbmd1bGF0b3I6OlZlcnRleDo6c2V0TWFya2VkKToKKyAgICAgICAg KFdlYkNvcmU6OmdwdTo6TG9jYWxUcmlhbmd1bGF0b3I6OlZlcnRleDo6aW50ZXJpb3IpOgorICAg ICAgICAoV2ViQ29yZTo6Z3B1OjpMb2NhbFRyaWFuZ3VsYXRvcjo6VmVydGV4OjpzZXRJbnRlcmlv cik6CisgICAgICAgIChXZWJDb3JlOjpncHU6OkxvY2FsVHJpYW5ndWxhdG9yOjpWZXJ0ZXg6OnJl c2V0RmxhZ3MpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpMb2NhbFRyaWFuZ3VsYXRvcjo6VHJp YW5nbGU6OlRyaWFuZ2xlKToKKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6TG9jYWxUcmlhbmd1bGF0 b3I6OlRyaWFuZ2xlOjpnZXRWZXJ0ZXgpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpMb2NhbFRy aWFuZ3VsYXRvcjo6VHJpYW5nbGU6OnNldFZlcnRpY2VzKToKKyAgICAgICAgKFdlYkNvcmU6Omdw dTo6TG9jYWxUcmlhbmd1bGF0b3I6OmdldFZlcnRleCk6CisgICAgICAgIChXZWJDb3JlOjpncHU6 OkxvY2FsVHJpYW5ndWxhdG9yOjpudW1UcmlhbmdsZXMpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1 OjpMb2NhbFRyaWFuZ3VsYXRvcjo6Z2V0VHJpYW5nbGUpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1 OjpMb2NhbFRyaWFuZ3VsYXRvcjo6bnVtSW50ZXJpb3JWZXJ0aWNlcyk6CisgICAgICAgIChXZWJD b3JlOjpncHU6OkxvY2FsVHJpYW5ndWxhdG9yOjpnZXRJbnRlcmlvclZlcnRleCk6CisKIDIwMTAt MDgtMjYgIEphbWVzIFJvYmluc29uICA8amFtZXNyQGNocm9taXVtLm9yZz4KIAogICAgICAgICBG aXggY2hyb21pdW0gbWFjIGJ1aWxkLiBVbnJldmlld2VkLgpJbmRleDogV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9ncHUvQ3ViaWNDbGFzc2lmaWVyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9DdWJpY0NsYXNzaWZpZXIuY3BwCShyZXZpc2lvbiAwKQor KysgV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUvQ3ViaWNDbGFzc2lmaWVyLmNwcAkocmV2 aXNpb24gMCkKQEAgLTAsMCArMSwxMjUgQEAKKy8qCisgKiBDb3B5cmlnaHQgMjAxMCwgR29vZ2xl IEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5k IHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2Rp ZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRp dGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJj ZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqICAgICAq IFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUK KyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9s bG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBt YXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAgICAqIE5l aXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMKKyAqIGNv bnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVy aXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRl biBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENP UFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBS RVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVE IFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVT UyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVO VCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxF IEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVYRU1Q TEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJ TUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExP U1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9O KSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVU SEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5H IE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBV U0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJ VFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorCisjaW5jbHVk ZSAiZ3B1L0N1YmljQ2xhc3NpZmllci5oIgorCisjaW5jbHVkZSAiZ3B1L0N1YmljTWF0aFV0aWxz LmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKK25hbWVzcGFjZSBncHUgeworCitDdWJpY0NsYXNz aWZpZXI6OlJlc3VsdCBDdWJpY0NsYXNzaWZpZXI6OmNsYXNzaWZ5KGZsb2F0IGIweCwgZmxvYXQg YjB5LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBm bG9hdCBiMXgsIGZsb2F0IGIxeSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgZmxvYXQgYjJ4LCBmbG9hdCBiMnksCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGZsb2F0IGIzeCwgZmxvYXQgYjN5KSB7Cisg ICAgVmVjdG9yMyBiMChiMHgsIGIweSwgMSk7CisgICAgVmVjdG9yMyBiMShiMXgsIGIxeSwgMSk7 CisgICAgVmVjdG9yMyBiMihiMngsIGIyeSwgMSk7CisgICAgVmVjdG9yMyBiMyhiM3gsIGIzeSwg MSk7CisKKyAgICAvLyBDb21wdXRlIGExLi5hMworICAgIGZsb2F0IGExID0gYjAuZG90KGIzLmNy b3NzKGIyKSk7CisgICAgZmxvYXQgYTIgPSBiMS5kb3QoYjAuY3Jvc3MoYjMpKTsKKyAgICBmbG9h dCBhMyA9IGIyLmRvdChiMS5jcm9zcyhiMCkpOworCisgICAgLy8gQ29tcHV0ZSBkMS4uZDMKKyAg ICBmbG9hdCBkMSA9IGExIC0gMiAqIGEyICsgMyAqIGEzOworICAgIGZsb2F0IGQyID0gLWEyICsg MyAqIGEzOworICAgIGZsb2F0IGQzID0gMyAqIGEzOworCisgICAgLy8gRXhwZXJpbWVudGF0aW9u IGhhcyBzaG93biB0aGF0IHRoZSB0ZXh0dXJlIGNvb3JkaW5hdGVzIGNvbXB1dGVkCisgICAgLy8g ZnJvbSB0aGVzZSB2YWx1ZXMgcXVpY2tseSBiZWNvbWUgaHVnZSwgbGVhZGluZyB0byByb3VuZG9m ZiBlcnJvcnMKKyAgICAvLyBhbmQgYXJ0aWZhY3RzIGluIHRoZSBzaGFkZXIuIEl0IHR1cm5zIG91 dCB0aGF0IGlmIHdlIG5vcm1hbGl6ZQorICAgIC8vIHRoZSB2ZWN0b3IgZGVmaW5lZCBieSAoZDEs IGQyLCBkMyksIHRoaXMgZml4ZXMgdGhlIHByb2JsZW0gb2YgdGhlCisgICAgLy8gdGV4dHVyZSBj b29yZGluYXRlcyBnZXR0aW5nIHRvbyBsYXJnZSB3aXRob3V0IGFmZmVjdGluZyB0aGUKKyAgICAv LyBjbGFzc2lmaWNhdGlvbiByZXN1bHRzLgorICAgIFZlY3RvcjMgbmQoZDEsIGQyLCBkMyk7Cisg ICAgbmQubm9ybWFsaXplKCk7CisgICAgZDEgPSBuZC54KCk7CisgICAgZDIgPSBuZC55KCk7Cisg ICAgZDMgPSBuZC56KCk7CisKKyAgICAvLyBDb21wdXRlIHRoZSBkaXNjcmltaW5hbnQuCisgICAg Ly8gdGVybTAgaXMgYSBjb21tb24gdGVybSBpbiB0aGUgY29tcHV0YXRpb24gd2hpY2ggaGVscHMg ZGVjaWRlCisgICAgLy8gd2hpY2ggd2F5IHRvIGNsYXNzaWZ5IHRoZSBjdXNwIGNhc2U6IGFzIHNl cnBlbnRpbmUgb3IgbG9vcC4KKyAgICBmbG9hdCB0ZXJtMCA9ICgzICogZDIgKiBkMiAtIDQgKiBk MSAqIGQzKTsKKyAgICBmbG9hdCBkaXNjciA9IGQxICogZDEgKiB0ZXJtMDsKKworICAgIC8vIEV4 cGVyaW1lbnRhdGlvbiBoYXMgYWxzbyBzaG93biB0aGF0IHdoZW4gdGhlIGNsYXNzaWZpY2F0aW9u IGlzCisgICAgLy8gbmVhciB0aGUgYm91bmRhcnkgYmV0d2VlbiBvbmUgY3VydmUgdHlwZSBhbmQg YW5vdGhlciwgdGhlIHNoYWRlcgorICAgIC8vIGJlY29tZXMgbnVtZXJpY2FsbHkgdW5zdGFibGUs IHBhcnRpY3VsYXJseSB3aXRoIHRoZSBjdXNwIGNhc2UuCisgICAgLy8gQ29ycmVjdCBmb3IgdGhp cyBieSByb3VuZGluZyBkMS4uZDMgYW5kIHRoZSBkaXNjcmltaW5hbnQgdG8gemVybworICAgIC8v IHdoZW4gdGhleSBnZXQgbmVhciBpdC4KKyAgICBkMSA9IHJvdW5kVG9aZXJvKGQxKTsKKyAgICBk MiA9IHJvdW5kVG9aZXJvKGQyKTsKKyAgICBkMyA9IHJvdW5kVG9aZXJvKGQzKTsKKyAgICBkaXNj ciA9IHJvdW5kVG9aZXJvKGRpc2NyKTsKKworICAgIC8vIERvIHRoZSBjbGFzc2lmaWNhdGlvbgor ICAgIGlmIChhcHByb3hFcXVhbChiMCwgYjEpCisgICAgICAgICYmIGFwcHJveEVxdWFsKGIwLCBi MikKKyAgICAgICAgJiYgYXBwcm94RXF1YWwoYjAsIGIzKSkgeworICAgICAgICByZXR1cm4gUmVz dWx0KGtQb2ludCwgZDEsIGQyLCBkMyk7CisgICAgfQorCisgICAgaWYgKCFkaXNjcikgeworICAg ICAgICBpZiAoIWQxICYmICFkMikgeworICAgICAgICAgICAgaWYgKCFkMykKKyAgICAgICAgICAg ICAgICByZXR1cm4gUmVzdWx0KGtMaW5lLCBkMSwgZDIsIGQzKTsKKyAgICAgICAgICAgIHJldHVy biBSZXN1bHQoa1F1YWRyYXRpYywgZDEsIGQyLCBkMyk7CisgICAgICAgIH0KKworICAgICAgICBp ZiAoIWQxKQorICAgICAgICAgICAgcmV0dXJuIFJlc3VsdChrQ3VzcCwgZDEsIGQyLCBkMyk7CisK KyAgICAgICAgLy8gVGhpcyBpcyB0aGUgYm91bmRhcnkgY2FzZSBkZXNjcmliZWQgaW4gTG9vcCBh bmQgQmxpbm4ncworICAgICAgICAvLyBTSUdHUkFQSCAnMDUgcGFwZXIgb2YgYSBjdXNwIHdpdGgg aW5mbGVjdGlvbiBhdCBpbmZpbml0eS4KKyAgICAgICAgLy8gQmVjYXVzZSB0ZXJtMCBtaWdodCBu b3QgYmUgZXhhY3RseSAwLCB3ZSBkZWNpZGUgYmV0d2VlbiB1c2luZworICAgICAgICAvLyB0aGUg c2VycGVudGluZSBhbmQgbG9vcCBjYXNlcyBkZXBlbmRpbmcgb24gaXRzIHNpZ24gdG8gYXZvaWQK KyAgICAgICAgLy8gdGFraW5nIHRoZSBzcXVhcmUgcm9vdCBvZiBhIG5lZ2F0aXZlIG51bWJlciB3 aGVuIGNvbXB1dGluZyB0aGUKKyAgICAgICAgLy8gY3ViaWMgdGV4dHVyZSBjb29yZGluYXRlcy4K KyAgICAgICAgaWYgKHRlcm0wIDwgMCkKKyAgICAgICAgICAgIHJldHVybiBSZXN1bHQoa0xvb3As IGQxLCBkMiwgZDMpOworCisgICAgICAgIHJldHVybiBSZXN1bHQoa1NlcnBlbnRpbmUsIGQxLCBk MiwgZDMpOworICAgIH0KKworICAgIGlmIChkaXNjciA+IDApCisgICAgICAgIHJldHVybiBSZXN1 bHQoa1NlcnBlbnRpbmUsIGQxLCBkMiwgZDMpOworCisgICAgLy8gZGlzY3IgPCAwCisgICAgcmV0 dXJuIFJlc3VsdChrTG9vcCwgZDEsIGQyLCBkMyk7Cit9CisKK30gLy8gbmFtZXNwYWNlIGdwdQor fSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9n cHUvQ3ViaWNDbGFzc2lmaWVyLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9ncHUvQ3ViaWNDbGFzc2lmaWVyLmgJKHJldmlzaW9uIDApCisrKyBXZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL2dwdS9DdWJpY0NsYXNzaWZpZXIuaAkocmV2aXNpb24gMCkKQEAgLTAsMCAr MSwxMTAgQEAKKy8qCisgKiBDb3B5cmlnaHQgMjAxMCwgR29vZ2xlIEluYy4KKyAqIEFsbCByaWdo dHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5k IGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJt aXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6 CisgKgorICogICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWlu IHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMg YW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBp biBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3Rp Y2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIK KyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQg d2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2Yg R29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUg dXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlz IHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoK KyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFO RCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FS UkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBX QVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElD VUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJ R0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJ TkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVO VElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVN RU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFU QSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBB TkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBT VFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RI RVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09G VFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0Uu CisgKi8KKworLy8gQ3ViaWMgY3VydmUgY2xhc3NpZmljYXRpb24gYWxnb3JpdGhtIGZyb20gIlJl bmRlcmluZyBWZWN0b3IgQXJ0IG9uCisvLyB0aGUgR1BVIiBieSBMb29wIGFuZCBCbGlubiwgR1BV IEdlbXMgMywgQ2hhcHRlciAyNS4KKworI2lmbmRlZiBncHVfQ3ViaWNDbGFzc2lmaWVyX2gKKyNk ZWZpbmUgZ3B1X0N1YmljQ2xhc3NpZmllcl9oCisKKyNpbmNsdWRlIDx3dGYvTm9uY29weWFibGUu aD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworbmFtZXNwYWNlIGdwdSB7CisKKy8vIENsYXNzaWZp ZXMgY3ViaWMgY3VydmVzIGludG8gc3BlY2lmaWMgdHlwZXMuCitjbGFzcyBDdWJpY0NsYXNzaWZp ZXIgOiBwdWJsaWMgTm9uY29weWFibGUgeworcHVibGljOgorICAgIC8vIFRoZSB0eXBlcyBvZiBj dWJpYyBjdXJ2ZXMuCisgICAgZW51bSBDdXJ2ZVR5cGUgeworICAgICAgICBrU2VycGVudGluZSwK KyAgICAgICAga0N1c3AsCisgICAgICAgIGtMb29wLAorICAgICAgICBrUXVhZHJhdGljLAorICAg ICAgICBrTGluZSwKKyAgICAgICAga1BvaW50CisgICAgfTsKKworICAgIC8vIFRoZSByZXN1bHQg b2YgdGhlIGNsYXNzaWZpZXIuCisgICAgY2xhc3MgUmVzdWx0IHsKKyAgICBwdWJsaWM6CisgICAg ICAgIFJlc3VsdChDdXJ2ZVR5cGUgY3VydmVUeXBlLCBmbG9hdCBkMSwgZmxvYXQgZDIsIGZsb2F0 IGQzKQorICAgICAgICAgICAgOiBtX2N1cnZlVHlwZShjdXJ2ZVR5cGUpCisgICAgICAgICAgICAs IG1fZDEoZDEpCisgICAgICAgICAgICAsIG1fZDIoZDIpCisgICAgICAgICAgICAsIG1fZDMoZDMp CisgICAgICAgIHsKKyAgICAgICAgfQorCisgICAgICAgIEN1cnZlVHlwZSBjdXJ2ZVR5cGUoKSBj b25zdAorICAgICAgICB7CisgICAgICAgICAgICByZXR1cm4gbV9jdXJ2ZVR5cGU7CisgICAgICAg IH0KKworICAgICAgICBmbG9hdCBkMSgpIGNvbnN0CisgICAgICAgIHsKKyAgICAgICAgICAgIHJl dHVybiBtX2QxOworICAgICAgICB9CisKKyAgICAgICAgZmxvYXQgZDIoKSBjb25zdAorICAgICAg ICB7CisgICAgICAgICAgICByZXR1cm4gbV9kMjsKKyAgICAgICAgfQorCisgICAgICAgIGZsb2F0 IGQzKCkgY29uc3QKKyAgICAgICAgeworICAgICAgICAgICAgcmV0dXJuIG1fZDM7CisgICAgICAg IH0KKworICAgIHByaXZhdGU6CisgICAgICAgIEN1cnZlVHlwZSBtX2N1cnZlVHlwZTsKKyAgICAg ICAgZmxvYXQgbV9kMTsKKyAgICAgICAgZmxvYXQgbV9kMjsKKyAgICAgICAgZmxvYXQgbV9kMzsK KyAgICB9OworCisgICAgLy8gQ2xhc3NpZmllcyB0aGUgZ2l2ZW4gY3ViaWMgYmV6aWVyIGN1cnZl IHN0YXJ0aW5nIGF0IChiMHgsIGIweSksCisgICAgLy8gZW5kaW5nIGF0IChiM3gsIGIzeSksIGFu ZCBhZmZlY3RlZCBieSBjb250cm9sIHBvaW50cyAoYjF4LCBiMXkpCisgICAgLy8gYW5kIChiMngs IGIyeSkuCisgICAgc3RhdGljIFJlc3VsdCBjbGFzc2lmeShmbG9hdCBiMHgsIGZsb2F0IGIweSwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgIGZsb2F0IGIxeCwgZmxvYXQgYjF5LAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgZmxvYXQgYjJ4LCBmbG9hdCBiMnksCisgICAgICAgICAgICAg ICAgICAgICAgICAgICBmbG9hdCBiM3gsIGZsb2F0IGIzeSk7CisKK3ByaXZhdGU6CisgICAgLy8g VGhpcyBjbGFzcyBkb2VzIG5vdCBuZWVkIHRvIGJlIGluc3RhbnRpYXRlZC4KKyAgICBDdWJpY0Ns YXNzaWZpZXIoKSB7fQorfTsKKworfSAvLyBuYW1lc3BhY2UgZ3B1Cit9IC8vIG5hbWVzcGFjZSBX ZWJDb3JlCisKKyNlbmRpZiAvLyBncHVfQ3ViaWNDbGFzc2lmaWVyX2gKSW5kZXg6IFdlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L0N1YmljTWF0aFV0aWxzLmNwcAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBX ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9DdWJpY01hdGhVdGlscy5jcHAJKHJldmlzaW9u IDApCisrKyBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9DdWJpY01hdGhVdGlscy5jcHAJ KHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNTcyIEBACisvKgorICogQ29weXJpZ2h0IDIwMTAsIEdv b2dsZSBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9u IGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICog bW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBj b25kaXRpb25zIGFyZQorICogbWV0OgorICoKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBz b3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRo aXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAg ICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFi b3ZlCisgKiBjb3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhl IGZvbGxvd2luZyBkaXNjbGFpbWVyCisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3Ro ZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCisgKiBkaXN0cmlidXRpb24uCisgKiAgICAg KiBOZWl0aGVyIHRoZSBuYW1lIG9mIEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisg KiBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3Rz IGRlcml2ZWQgZnJvbQorICogdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdy aXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRI RSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkg RVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElN SVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJ VE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8g RVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJ QUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBF WEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisg KiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VT OyBMT1NTIE9GIFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQ VElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwg V0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xV RElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBU SEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJ QklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKworI2lu Y2x1ZGUgImdwdS9DdWJpY01hdGhVdGlscy5oIgorCisjaW5jbHVkZSAiRmxvYXRQb2ludC5oIgor I2luY2x1ZGUgIk1hdGhFeHRyYXMuaCIKKyNpbmNsdWRlIDxhbGdvcml0aG0+CisjaW5jbHVkZSA8 c3RyaW5nLmg+IC8vIGZvciBtZW1jcHkKKworbmFtZXNwYWNlIFdlYkNvcmUgeworbmFtZXNwYWNl IGdwdSB7CisKKy8vIFV0aWxpdHkgZnVuY3Rpb25zIGxvY2FsIHRvIHRoaXMgZmlsZQorCitzdGF0 aWMgaW50IG9yaWVudGF0aW9uKGZsb2F0IHgxLCBmbG9hdCB5MSwKKyAgICAgICAgICAgICAgICAg ICAgICAgZmxvYXQgeDIsIGZsb2F0IHkyLAorICAgICAgICAgICAgICAgICAgICAgICBmbG9hdCB4 MywgZmxvYXQgeTMpCit7CisgICAgLy8gcDEgPSAoeDEsIHkxKQorICAgIC8vIHAyID0gKHgyLCB5 MikKKyAgICAvLyBwMyA9ICh4MywgeTMpCisgICAgZmxvYXQgY3Jvc3NQcm9kdWN0ID0gKHkyIC0g eTEpICogKHgzIC0geDIpIC0gKHkzIC0geTIpICogKHgyIC0geDEpOworICAgIHJldHVybiAoY3Jv c3NQcm9kdWN0IDwgMC4wZikgPyAtMSA6ICgoY3Jvc3NQcm9kdWN0ID4gMC4wZikgPyAxIDogMCk7 Cit9CisKK3N0YXRpYyBib29sIGVkZ2VFZGdlVGVzdChmbG9hdCBheCwgZmxvYXQgYXksCisgICAg ICAgICAgICAgICAgICAgICAgICAgZmxvYXQgdjB4LCBmbG9hdCB2MHksCisgICAgICAgICAgICAg ICAgICAgICAgICAgZmxvYXQgdTB4LCBmbG9hdCB1MHksCisgICAgICAgICAgICAgICAgICAgICAg ICAgZmxvYXQgdTF4LCBmbG9hdCB1MXkpCit7CisgICAgLy8gVGhpcyBlZGdlIHRvIGVkZ2UgdGVz dCBpcyBiYXNlZCBvbiBGcmFubGluIEFudG9uaW8ncyBnZW06ICJGYXN0ZXIKKyAgICAvLyBMaW5l IFNlZ21lbnQgSW50ZXJzZWN0aW9uIiwgaW4gR3JhcGhpY3MgR2VtcyBJSUksIHBwLiAxOTktMjAy LgorICAgIGZsb2F0IGJ4ID0gdTB4IC0gdTF4OworICAgIGZsb2F0IGJ5ID0gdTB5IC0gdTF5Owor ICAgIGZsb2F0IGN4ID0gdjB4IC0gdTB4OworICAgIGZsb2F0IGN5ID0gdjB5IC0gdTB5OworICAg IGZsb2F0IGYgPSBheSAqIGJ4IC0gYXggKiBieTsKKyAgICBmbG9hdCBkID0gYnkgKiBjeCAtIGJ4 ICogY3k7CisgICAgaWYgKChmID4gMCAmJiBkID49IDAgJiYgZCA8PSBmKSB8fCAoZiA8IDAgJiYg ZCA8PSAwICYmIGQgPj0gZikpIHsKKyAgICAgICAgZmxvYXQgZSA9IGF4ICogY3kgLSBheSAqIGN4 OworCisgICAgICAgIC8vIFRoaXMgYWRkaXRpb25hbCB0ZXN0IGF2b2lkcyByZXBvcnRpbmcgY29p bmNpZGVudCBlZGdlcywgd2hpY2gKKyAgICAgICAgLy8gaXMgdGhlIGJlaGF2aW9yIHdlIHdhbnQu CisgICAgICAgIGlmIChhcHByb3hFcXVhbChlLCAwKSB8fCBhcHByb3hFcXVhbChmLCAwKSB8fCBh cHByb3hFcXVhbChlLCBmKSkKKyAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgICAgICBp ZiAoZiA+IDApCisgICAgICAgICAgICByZXR1cm4gZSA+PSAwICYmIGUgPD0gZjsKKworICAgICAg ICByZXR1cm4gZSA8PSAwICYmIGUgPj0gZjsKKyAgICB9CisgICAgcmV0dXJuIGZhbHNlOworfQor CitzdGF0aWMgYm9vbCBlZGdlQWdhaW5zdFRyaUVkZ2VzKGZsb2F0IHYweCwgZmxvYXQgdjB5LAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBmbG9hdCB2MXgsIGZsb2F0IHYxeSwKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZmxvYXQgdTB4LCBmbG9hdCB1MHksCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIGZsb2F0IHUxeCwgZmxvYXQgdTF5LAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBmbG9hdCB1MngsIGZsb2F0IHUyeSkKK3sKKyAgICBm bG9hdCBheCwgYXk7CisgICAgYXggPSB2MXggLSB2MHg7CisgICAgYXkgPSB2MXkgLSB2MHk7Cisg ICAgLy8gVGVzdCBlZGdlIHUwLCB1MSBhZ2FpbnN0IHYwLCB2MS4KKyAgICBpZiAoZWRnZUVkZ2VU ZXN0KGF4LCBheSwgdjB4LCB2MHksIHUweCwgdTB5LCB1MXgsIHUxeSkpCisgICAgICAgIHJldHVy biB0cnVlOworICAgIC8vIFRlc3QgZWRnZSB1MSwgdTIgYWdhaW5zdCB2MCwgdjEuCisgICAgaWYg KGVkZ2VFZGdlVGVzdChheCwgYXksIHYweCwgdjB5LCB1MXgsIHUxeSwgdTJ4LCB1MnkpKQorICAg ICAgICByZXR1cm4gdHJ1ZTsKKyAgICAvLyBUZXN0IGVkZ2UgdTIsIHUxIGFnYWluc3QgdjAsIHYx LgorICAgIGlmIChlZGdlRWRnZVRlc3QoYXgsIGF5LCB2MHgsIHYweSwgdTJ4LCB1MnksIHUweCwg dTB5KSkKKyAgICAgICAgcmV0dXJuIHRydWU7CisgICAgcmV0dXJuIGZhbHNlOworfQorCisvLyBF eHBvcnRlZCByb3V0aW5lcworCitib29sIGxpbmVzSW50ZXJzZWN0KGZsb2F0IHAxeCwgZmxvYXQg cDF5LAorICAgICAgICAgICAgICAgICAgICBmbG9hdCBxMXgsIGZsb2F0IHExeSwKKyAgICAgICAg ICAgICAgICAgICAgZmxvYXQgcDJ4LCBmbG9hdCBwMnksCisgICAgICAgICAgICAgICAgICAgIGZs b2F0IHEyeCwgZmxvYXQgcTJ5KSB7CisgICAgcmV0dXJuICgob3JpZW50YXRpb24ocDF4LCBwMXks IHExeCwgcTF5LCBwMngsIHAyeSkKKyAgICAgICAgICAgICAhPSBvcmllbnRhdGlvbihwMXgsIHAx eSwgcTF4LCBxMXksIHEyeCwgcTJ5KSkKKyAgICAgICAgICAgICYmIChvcmllbnRhdGlvbihwMngs IHAyeSwgcTJ4LCBxMnksIHAxeCwgcDF5KQorICAgICAgICAgICAgICAgICE9IG9yaWVudGF0aW9u KHAyeCwgcDJ5LCBxMngsIHEyeSwgcTF4LCBxMXkpKSk7Cit9CisKK2Jvb2wgcG9pbnRJblRyaWFu Z2xlKGZsb2F0IHB4LCBmbG9hdCBweSwKKyAgICAgICAgICAgICAgICAgICAgIGZsb2F0IGF4LCBm bG9hdCBheSwKKyAgICAgICAgICAgICAgICAgICAgIGZsb2F0IGJ4LCBmbG9hdCBieSwKKyAgICAg ICAgICAgICAgICAgICAgIGZsb2F0IGN4LCBmbG9hdCBjeSkKK3sKKyAgICAvLyBBbGdvcml0aG0g ZnJvbSBodHRwOi8vd3d3LmJsYWNrcGF3bi5jb20vdGV4dHMvcG9pbnRpbnBvbHkvZGVmYXVsdC5o dG1sCisgICAgZmxvYXQgeDAgPSBjeCAtIGF4OworICAgIGZsb2F0IHkwID0gY3kgLSBheTsKKyAg ICBmbG9hdCB4MSA9IGJ4IC0gYXg7CisgICAgZmxvYXQgeTEgPSBieSAtIGF5OworICAgIGZsb2F0 IHgyID0gcHggLSBheDsKKyAgICBmbG9hdCB5MiA9IHB5IC0gYXk7CisKKyAgICBmbG9hdCBkb3Qw MCA9IHgwICogeDAgKyB5MCAqIHkwOworICAgIGZsb2F0IGRvdDAxID0geDAgKiB4MSArIHkwICog eTE7CisgICAgZmxvYXQgZG90MDIgPSB4MCAqIHgyICsgeTAgKiB5MjsKKyAgICBmbG9hdCBkb3Qx MSA9IHgxICogeDEgKyB5MSAqIHkxOworICAgIGZsb2F0IGRvdDEyID0geDEgKiB4MiArIHkxICog eTI7CisgICAgZmxvYXQgZGVub20gPSBkb3QwMCAqIGRvdDExIC0gZG90MDEgKiBkb3QwMTsKKyAg ICBpZiAoIWRlbm9tKQorICAgICAgICAvLyBUcmlhbmdsZSBpcyB6ZXJvLWFyZWEuIFRyZWF0IHF1 ZXJ5IHBvaW50IGFzIG5vdCBiZWluZyBpbnNpZGUuCisgICAgICAgIHJldHVybiBmYWxzZTsKKyAg ICAvLyBDb21wdXRlCisgICAgZmxvYXQgaW52RGVub20gPSAxLjBmIC8gZGVub207CisgICAgZmxv YXQgdSA9IChkb3QxMSAqIGRvdDAyIC0gZG90MDEgKiBkb3QxMikgKiBpbnZEZW5vbTsKKyAgICBm bG9hdCB2ID0gKGRvdDAwICogZG90MTIgLSBkb3QwMSAqIGRvdDAyKSAqIGludkRlbm9tOworCisg ICAgcmV0dXJuICh1ID4gMC4wZikgJiYgKHYgPiAwLjBmKSAmJiAodSArIHYgPCAxLjBmKTsKK30K KworYm9vbCB0cmlhbmdsZXNPdmVybGFwKGZsb2F0IGExeCwgZmxvYXQgYTF5LAorICAgICAgICAg ICAgICAgICAgICAgIGZsb2F0IGIxeCwgZmxvYXQgYjF5LAorICAgICAgICAgICAgICAgICAgICAg IGZsb2F0IGMxeCwgZmxvYXQgYzF5LAorICAgICAgICAgICAgICAgICAgICAgIGZsb2F0IGEyeCwg ZmxvYXQgYTJ5LAorICAgICAgICAgICAgICAgICAgICAgIGZsb2F0IGIyeCwgZmxvYXQgYjJ5LAor ICAgICAgICAgICAgICAgICAgICAgIGZsb2F0IGMyeCwgZmxvYXQgYzJ5KQoreworICAgIC8vIERl cml2ZWQgZnJvbSBjb3BsYW5hcl90cmlfdHJpKCkgYXQKKyAgICAvLyBodHRwOi8vamd0LmFrcGV0 ZXJzLmNvbS9wYXBlcnMvU2hlbkhlbmdUYW5nMDMvdHJpX3RyaS5odG1sICwKKyAgICAvLyBzaW1w bGlmaWVkIGZvciB0aGUgMkQgY2FzZSBhbmQgbW9kaWZpZWQgc28gdGhhdCBvdmVybGFwcGluZyBl ZGdlcworICAgIC8vIGRvIG5vdCByZXBvcnQgb3ZlcmxhcHBpbmcgdHJpYW5nbGVzLgorCisgICAg Ly8gVGVzdCBhbGwgZWRnZXMgb2YgdHJpYW5nbGUgMSBhZ2FpbnN0IHRoZSBlZGdlcyBvZiB0cmlh bmdsZSAyLgorICAgIGlmIChlZGdlQWdhaW5zdFRyaUVkZ2VzKGExeCwgYTF5LCBiMXgsIGIxeSwg YTJ4LCBhMnksIGIyeCwgYjJ5LCBjMngsIGMyeSkpCisgICAgICAgIHJldHVybiB0cnVlOworICAg IGlmIChlZGdlQWdhaW5zdFRyaUVkZ2VzKGIxeCwgYjF5LCBjMXgsIGMxeSwgYTJ4LCBhMnksIGIy eCwgYjJ5LCBjMngsIGMyeSkpCisgICAgICAgIHJldHVybiB0cnVlOworICAgIGlmIChlZGdlQWdh aW5zdFRyaUVkZ2VzKGMxeCwgYzF5LCBhMXgsIGExeSwgYTJ4LCBhMnksIGIyeCwgYjJ5LCBjMngs IGMyeSkpCisgICAgICAgIHJldHVybiB0cnVlOworICAgIC8vIEZpbmFsbHksIHRlc3QgaWYgdHJp MSBpcyB0b3RhbGx5IGNvbnRhaW5lZCBpbiB0cmkyIG9yIHZpY2UgdmVyc2EuCisgICAgaWYgKHBv aW50SW5UcmlhbmdsZShhMXgsIGExeSwgYTJ4LCBhMnksIGIyeCwgYjJ5LCBjMngsIGMyeSkpCisg ICAgICAgIHJldHVybiB0cnVlOworICAgIGlmIChwb2ludEluVHJpYW5nbGUoYTJ4LCBhMnksIGEx eCwgYTF5LCBiMXgsIGIxeSwgYzF4LCBjMXkpKQorICAgICAgICByZXR1cm4gdHJ1ZTsKKworICAg IC8vIEJlY2F1c2Ugd2UgZGVmaW5lIHRoYXQgdHJpYW5nbGVzIHNoYXJpbmcgYSB2ZXJ0ZXggb3Ig ZWRnZSBkb24ndAorICAgIC8vIG92ZXJsYXAsIHdlIG11c3QgcGVyZm9ybSBhZGRpdGlvbmFsIHBv aW50LWluLXRyaWFuZ2xlIHRlc3RzIHRvCisgICAgLy8gc2VlIHdoZXRoZXIgb25lIHRyaWFuZ2xl IGlzIGNvbnRhaW5lZCBpbiB0aGUgb3RoZXIuCisgICAgaWYgKHBvaW50SW5UcmlhbmdsZShiMXgs IGIxeSwgYTJ4LCBhMnksIGIyeCwgYjJ5LCBjMngsIGMyeSkpCisgICAgICAgIHJldHVybiB0cnVl OworICAgIGlmIChwb2ludEluVHJpYW5nbGUoYzF4LCBjMXksIGEyeCwgYTJ5LCBiMngsIGIyeSwg YzJ4LCBjMnkpKQorICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICBpZiAocG9pbnRJblRyaWFuZ2xl KGIyeCwgYjJ5LCBhMXgsIGExeSwgYjF4LCBiMXksIGMxeCwgYzF5KSkKKyAgICAgICAgcmV0dXJu IHRydWU7CisgICAgaWYgKHBvaW50SW5UcmlhbmdsZShjMngsIGMyeSwgYTF4LCBhMXksIGIxeCwg YjF5LCBjMXgsIGMxeSkpCisgICAgICAgIHJldHVybiB0cnVlOworICAgIHJldHVybiBmYWxzZTsK K30KKworLy8gSGVscGVyIHJvdXRpbmVzIGZvciBwdWJsaWMgWFJheSBxdWVyaWVzIGJlbG93Lgor CisjZGVmaW5lIE5lYXJseVplcm9Db25zdGFudCAoMS4wZiAvICgxIDw8IDEyKSkKKworc3RhdGlj IGJvb2wgbmVhcmx5WmVybyhmbG9hdCB4LCBmbG9hdCB0b2xlcmFuY2UgPSBOZWFybHlaZXJvQ29u c3RhbnQpCit7CisgICAgQVNTRVJUKHRvbGVyYW5jZSA+IDAuMCk7CisgICAgcmV0dXJuIDo6ZmFi c2YoeCkgPCB0b2xlcmFuY2U7Cit9CisKKy8vIExpbmVhcmx5IGludGVycG9sYXRlIGJldHdlZW4g YSBhbmQgYiwgYmFzZWQgb24gdC4KKy8vIElmIHQgaXMgMCwgcmV0dXJuIGE7IGlmIHQgaXMgMSwg cmV0dXJuIGI7IGVsc2UgaW50ZXJwb2xhdGUuCisvLyB0IG11c3QgYmUgWzAuLjFdLgorc3RhdGlj IGlubGluZSBmbG9hdCBpbnRlcnAoZmxvYXQgYSwgZmxvYXQgYiwgZmxvYXQgdCkKK3sKKyAgICBB U1NFUlQodCA+PSAwICYmIHQgPD0gMSk7CisgICAgcmV0dXJuIGEgKyAoYiAtIGEpICogdDsKK30K Kworc3RhdGljIGZsb2F0IGV2YWxDdWJpYyhmbG9hdCBzMCwgZmxvYXQgczIsIGZsb2F0IHM0LCBm bG9hdCBzNiwgZmxvYXQgdCkKK3sKKyAgICBBU1NFUlQodCA+PSAwICYmIHQgPD0gMSk7CisKKyAg ICBpZiAoIXQpCisgICAgICAgIHJldHVybiBzMDsKKworICAgIGZsb2F0IGFiID0gaW50ZXJwKHMw LCBzMiwgdCk7CisgICAgZmxvYXQgYmMgPSBpbnRlcnAoczIsIHM0LCB0KTsKKyAgICBmbG9hdCBj ZCA9IGludGVycChzNCwgczYsIHQpOworICAgIGZsb2F0IGFiYyA9IGludGVycChhYiwgYmMsIHQp OworICAgIGZsb2F0IGJjZCA9IGludGVycChiYywgY2QsIHQpOworICAgIHJldHVybiBpbnRlcnAo YWJjLCBiY2QsIHQpOworfQorCisvLyBTZXQgcHQgdG8gdGhlIHBvaW50IG9uIHRoZSBzb3VyY2Ug Y3ViaWMgc3BlY2lmaWVkIGJ5IHQuCisvLyB0IG11c3QgYmUgMCA8PSB0IDw9IDEuMC4KK3N0YXRp YyBib29sIGV2YWxDdWJpY0F0KGNvbnN0IEZsb2F0UG9pbnQgY3ViaWNbNF0sIGZsb2F0IHQsIEZs b2F0UG9pbnQmIHB0KQoreworICAgIHB0LnNldChldmFsQ3ViaWMoY3ViaWNbMF0ueCgpLCBjdWJp Y1sxXS54KCksIGN1YmljWzJdLngoKSwgY3ViaWNbM10ueCgpLCB0KSwKKyAgICAgICAgICAgZXZh bEN1YmljKGN1YmljWzBdLnkoKSwgY3ViaWNbMV0ueSgpLCBjdWJpY1syXS55KCksIGN1YmljWzNd LnkoKSwgdCkpOworfQorCitzdGF0aWMgYm9vbCB4UmF5Q3Jvc3Nlc01vbm90b25pY0N1YmljKGNv bnN0IFhSYXkmIHhSYXksIGNvbnN0IEZsb2F0UG9pbnQgY3ViaWNbNF0sIGJvb2wqIGFtYmlndW91 cykKK3sKKyAgICBpZiAoYW1iaWd1b3VzKQorICAgICAgICAqYW1iaWd1b3VzID0gZmFsc2U7CisK KyAgICAvLyBGaW5kIHRoZSBtaW5pbXVtIGFuZCBtYXhpbXVtIHkgb2YgdGhlIGV4dHJlbWEsIHdo aWNoIGFyZSB0aGUKKyAgICAvLyBmaXJzdCBhbmQgbGFzdCBwb2ludHMgc2luY2UgdGhpcyBjdWJp YyBpcyBtb25vdG9uaWMKKyAgICBmbG9hdCBtaW5ZID0gc3RkOjptaW4oY3ViaWNbMF0ueSgpLCBj dWJpY1szXS55KCkpOworICAgIGZsb2F0IG1heFkgPSBzdGQ6Om1heChjdWJpY1swXS55KCksIGN1 YmljWzNdLnkoKSk7CisKKyAgICBpZiAoeFJheS55KCkgPT0gY3ViaWNbMF0ueSgpCisgICAgICAg IHx8IHhSYXkueSgpIDwgbWluWQorICAgICAgICB8fCB4UmF5LnkoKSA+IG1heFkpIHsKKyAgICAg ICAgLy8gVGhlIHF1ZXJ5IGxpbmUgZGVmaW5pdGVseSBkb2VzIG5vdCBjcm9zcyB0aGUgY3VydmUK KyAgICAgICAgaWYgKGFtYmlndW91cykKKyAgICAgICAgICAgICphbWJpZ3VvdXMgPSAoeFJheS55 KCkgPT0gY3ViaWNbMF0ueSgpKTsKKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAgIH0KKworICAg IGJvb2wgcG9pbnRBdEV4dHJlbXVtID0gKHhSYXkueSgpID09IGN1YmljWzNdLnkoKSk7CisKKyAg ICBmbG9hdCBtaW5YID0gc3RkOjptaW4oc3RkOjptaW4oc3RkOjptaW4oY3ViaWNbMF0ueCgpLCBj dWJpY1sxXS54KCkpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjdWJpY1sy XS54KCkpLAorICAgICAgICAgICAgICAgICAgICAgICAgICBjdWJpY1szXS54KCkpOworICAgIGlm ICh4UmF5LngoKSA8IG1pblgpIHsKKyAgICAgICAgLy8gVGhlIHF1ZXJ5IGxpbmUgZGVmaW5pdGVs eSBjcm9zc2VzIHRoZSBjdXJ2ZQorICAgICAgICBpZiAoYW1iaWd1b3VzKQorICAgICAgICAgICAg KmFtYmlndW91cyA9IHBvaW50QXRFeHRyZW11bTsKKyAgICAgICAgcmV0dXJuIHRydWU7CisgICAg fQorCisgICAgZmxvYXQgbWF4WCA9IHN0ZDo6bWF4KHN0ZDo6bWF4KHN0ZDo6bWF4KGN1YmljWzBd LngoKSwgY3ViaWNbMV0ueCgpKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg Y3ViaWNbMl0ueCgpKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgY3ViaWNbM10ueCgpKTsK KyAgICBpZiAoeFJheS54KCkgPiBtYXhYKQorICAgICAgICAvLyBUaGUgcXVlcnkgbGluZSBkZWZp bml0ZWx5IGRvZXMgbm90IGNyb3NzIHRoZSBjdXJ2ZQorICAgICAgICByZXR1cm4gZmFsc2U7CisK KyAgICAvLyBEbyBhIGJpbmFyeSBzZWFyY2ggdG8gZmluZCB0aGUgcGFyYW1ldGVyIHZhbHVlIHdo aWNoIG1ha2VzIHkgYXMKKyAgICAvLyBjbG9zZSBhcyBwb3NzaWJsZSB0byB0aGUgcXVlcnkgcG9p bnQuIFNlZSB3aGV0aGVyIHRoZSBxdWVyeQorICAgIC8vIGxpbmUncyBvcmlnaW4gaXMgdG8gdGhl IGxlZnQgb2YgdGhlIGFzc29jaWF0ZWQgeCBjb29yZGluYXRlLgorCisgICAgLy8gTWF4SXRlciBp cyBjaG9zZW4gYXMgdGhlIG51bWJlciBvZiBtYW50aXNzYSBiaXRzIGZvciBhIGZsb2F0LAorICAg IC8vIHNpbmNlIHRoZXJlJ3Mgbm8gd2F5IHdlIGFyZSBnb2luZyB0byBnZXQgbW9yZSBwcmVjaXNp b24gYnkKKyAgICAvLyBpdGVyYXRpbmcgbW9yZSB0aW1lcyB0aGFuIHRoYXQuCisgICAgY29uc3Qg aW50IE1heEl0ZXIgPSAyMzsKKyAgICBGbG9hdFBvaW50IGV2YWw7CisgICAgaW50IGl0ZXIgPSAw OworICAgIGZsb2F0IHVwcGVyVDsKKyAgICBmbG9hdCBsb3dlclQ7CisgICAgLy8gTmVlZCB0byBp bnZlcnQgZGlyZWN0aW9uIG9mIHQgcGFyYW1ldGVyIGlmIGN1YmljIGdvZXMgdXAKKyAgICAvLyBp bnN0ZWFkIG9mIGRvd24KKyAgICBpZiAoY3ViaWNbM10ueSgpID4gY3ViaWNbMF0ueSgpKSB7Cisg ICAgICAgIHVwcGVyVCA9IDE7CisgICAgICAgIGxvd2VyVCA9IDA7CisgICAgfSBlbHNlIHsKKyAg ICAgICAgdXBwZXJUID0gMDsKKyAgICAgICAgbG93ZXJUID0gMTsKKyAgICB9CisgICAgZG8gewor ICAgICAgICBmbG9hdCB0ID0gMC41ICogKHVwcGVyVCArIGxvd2VyVCk7CisgICAgICAgIGV2YWxD dWJpY0F0KGN1YmljLCB0LCBldmFsKTsKKyAgICAgICAgaWYgKHhSYXkueSgpID4gZXZhbC55KCkp CisgICAgICAgICAgICBsb3dlclQgPSB0OworICAgICAgICBlbHNlCisgICAgICAgICAgICB1cHBl clQgPSB0OworICAgIH0gd2hpbGUgKCsraXRlciA8IE1heEl0ZXIgJiYgIW5lYXJseVplcm8oZXZh bC55KCkgLSB4UmF5LnkoKSkpOworICAgIGlmICh4UmF5LngoKSA8PSBldmFsLngoKSkgeworICAg ICAgICBpZiAoYW1iaWd1b3VzKQorICAgICAgICAgICAgKmFtYmlndW91cyA9IHBvaW50QXRFeHRy ZW11bTsKKyAgICAgICAgcmV0dXJuIHRydWU7CisgICAgfQorICAgIHJldHVybiBmYWxzZTsKK30K Kworc3RhdGljIGludCB2YWxpZFVuaXREaXZpZGUoZmxvYXQgbnVtZXIsIGZsb2F0IGRlbm9tLCBm bG9hdCogcmF0aW8pCit7CisgICAgQVNTRVJUKHJhdGlvKTsKKworICAgIGlmIChudW1lciA8IDAp IHsKKyAgICAgICAgbnVtZXIgPSAtbnVtZXI7CisgICAgICAgIGRlbm9tID0gLWRlbm9tOworICAg IH0KKworICAgIGlmICghZGVub20gfHwgIW51bWVyIHx8IG51bWVyID49IGRlbm9tKQorICAgICAg ICByZXR1cm4gMDsKKworICAgIGZsb2F0IHIgPSBudW1lciAvIGRlbm9tOworICAgIGlmIChpc25h bihyKSkKKyAgICAgICAgcmV0dXJuIDA7CisgICAgQVNTRVJUKHIgPj0gMCAmJiByIDwgMSk7Cisg ICAgaWYgKCFyKSAvLyBjYXRjaCB1bmRlcmZsb3cgaWYgbnVtZXIgPDw8PCBkZW5vbQorICAgICAg ICByZXR1cm4gMDsKKyAgICAqcmF0aW8gPSByOworICAgIHJldHVybiAxOworfQorCisvKiogRnJv bSBOdW1lcmljYWwgUmVjaXBlcyBpbiBDLgorCisgICAgcSA9IC0xLzIgKGIgKyBzaWduKGIpIHNx cnRbYipiIC0gNCphKmNdKQorICAgIHgxID0gcSAvIGEKKyAgICB4MiA9IGMgLyBxCisqLworc3Rh dGljIGludCBmaW5kVW5pdFF1YWRSb290cyhmbG9hdCBhLCBmbG9hdCBiLCBmbG9hdCBjLCBmbG9h dCByb290c1syXSkKK3sKKyAgICBpZiAoIWEpCisgICAgICAgIHJldHVybiB2YWxpZFVuaXREaXZp ZGUoLWMsIGIsIHJvb3RzKTsKKworICAgIGZsb2F0KiByID0gcm9vdHM7CisKKyAgICBmbG9hdCBS ID0gYipiIC0gNCphKmM7CisgICAgaWYgKFIgPCAwIHx8IGlzbmFuKFIpKSAvLyBjb21wbGV4IHJv b3RzCisgICAgICAgIHJldHVybiAwOworICAgIFIgPSBzcXJ0ZihSKTsKKworICAgIGZsb2F0IFEg PSAoYiA8IDApID8gLShiIC0gUikgLyAyIDogLShiICsgUikgLyAyOworICAgIHIgKz0gdmFsaWRV bml0RGl2aWRlKFEsIGEsIHIpOworICAgIHIgKz0gdmFsaWRVbml0RGl2aWRlKGMsIFEsIHIpOwor ICAgIGlmIChyIC0gcm9vdHMgPT0gMikKKyAgICAgICAgaWYgKHJvb3RzWzBdID4gcm9vdHNbMV0p CisgICAgICAgICAgICBzdGQ6OnN3YXAocm9vdHNbMF0sIHJvb3RzWzFdKTsKKyAgICAgICAgZWxz ZSBpZiAocm9vdHNbMF0gPT0gcm9vdHNbMV0pIC8vIG5lYXJseS1lcXVhbD8KKyAgICAgICAgICAg IHIgLT0gMTsgLy8gc2tpcCB0aGUgZG91YmxlIHJvb3QKKyAgICByZXR1cm4gKGludCkociAtIHJv b3RzKTsKK30KKworLyoqIEN1YmljJyh0KSA9IHB0XjIgKyBxdCArIHIsIHdoZXJlCisgICAgcCA9 IDMoLWEgKyAzKGIgLSBjKSArIGQpCisgICAgcSA9IDYoYSAtIDJiICsgYykKKyAgICByID0gMyhi IC0gYSkKKyAgICBTb2x2ZSBmb3IgdCwga2VlcGluZyBvbmx5IHRob3NlIHRoYXQgZml0IGJldHdl ZSAwIDwgdCA8IDEKKyovCitzdGF0aWMgaW50IGZpbmRDdWJpY0V4dHJlbWEoZmxvYXQgYSwgZmxv YXQgYiwgZmxvYXQgYywgZmxvYXQgZCwgZmxvYXQgdFZhbHVlc1syXSkKK3sKKyAgICAvLyB3ZSBk aXZpZGUgcCwgcSwgYW5kIHIgYnkgMyB0byBzaW1wbGlmeQorICAgIGZsb2F0IHAgPSBkIC0gYSAr IDMqKGIgLSBjKTsKKyAgICBmbG9hdCBxID0gMiooYSAtIGIgLSBiICsgYyk7CisgICAgZmxvYXQg ciA9IGIgLSBhOworCisgICAgcmV0dXJuIGZpbmRVbml0UXVhZFJvb3RzKHAsIHEsIHIsIHRWYWx1 ZXMpOworfQorCitzdGF0aWMgdm9pZCBpbnRlcnBDdWJpY0Nvb3JkcyhmbG9hdCBzMCwgZmxvYXQg czIsIGZsb2F0IHM0LCBmbG9hdCBzNiwgZmxvYXQqIGRzdCwgZmxvYXQgdCkKK3sKKyAgICBmbG9h dCBhYiA9IGludGVycChzMCwgczIsIHQpOworICAgIGZsb2F0IGJjID0gaW50ZXJwKHMyLCBzNCwg dCk7CisgICAgZmxvYXQgY2QgPSBpbnRlcnAoczQsIHM2LCB0KTsKKyAgICBmbG9hdCBhYmMgPSBp bnRlcnAoYWIsIGJjLCB0KTsKKyAgICBmbG9hdCBiY2QgPSBpbnRlcnAoYmMsIGNkLCB0KTsKKyAg ICBmbG9hdCBhYmNkID0gaW50ZXJwKGFiYywgYmNkLCB0KTsKKworICAgIGRzdFswXSA9IHMwOwor ICAgIGRzdFsyXSA9IGFiOworICAgIGRzdFs0XSA9IGFiYzsKKyAgICBkc3RbNl0gPSBhYmNkOwor ICAgIGRzdFs4XSA9IGJjZDsKKyAgICBkc3RbMTBdID0gY2Q7CisgICAgZHN0WzEyXSA9IHM2Owor fQorCisjaWZuZGVmIE5ERUJVRworc3RhdGljIGJvb2wgaXNVbml0SW50ZXJ2YWwoZmxvYXQgeCkK K3sKKyAgICByZXR1cm4geCA+IDAgJiYgeCA8IDE7Cit9CisjZW5kaWYKKworLyogIGh0dHA6Ly9j b2RlLmdvb2dsZS5jb20vcC9za2lhL2lzc3Vlcy9kZXRhaWw/aWQ9MzIKKworICAgIFRoaXMgdGVz dCBjb2RlIHdvdWxkIGZhaWwgd2hlbiB3ZSBkaWRuJ3QgY2hlY2sgdGhlIHJldHVybiByZXN1bHQg b2YKKyAgICB2YWxpZF91bml0X2RpdmlkZSBpbiBTa0Nob3BDdWJpY0F0KC4uLiB0VmFsdWVzW10s IGludCByb290cykuIFRoZSByZWFzb24gaXMKKyAgICB0aGF0IGFmdGVyIHRoZSBmaXJzdCBjaG9w LCB0aGUgcGFyYW1ldGVycyB0byB2YWxpZF91bml0X2RpdmlkZSBhcmUgZXF1YWwKKyAgICAodGhh bmtzIHRvIGZpbml0ZSBmbG9hdCBwcmVjaXNpb24gYW5kIHJvdW5kaW5nIGluIHRoZSBzdWJ0cmFj dHMpLiBUaHVzCisgICAgZXZlbiB0aG91Z2ggdGhlIDJuZCB0VmFsdWUgbG9va3MgPCAxLjAsIGFm dGVyIHdlIHJlbm9ybWFsaXplIGl0LCB3ZSBlbmQKKyAgICB1cCB3aXRoIDEuMCwgaGVuY2UgdGhl IG5lZWQgdG8gY2hlY2sgYW5kIGp1c3QgcmV0dXJuIHRoZSBsYXN0IGN1YmljIGFzCisgICAgYSBk ZWdlbmVyYXRlIGNsdW1wIG9mIDQgcG9pbnRzIGluIHRoZSBzYW1lIHBsYWNlLgorCisgICAgc3Rh dGljIHZvaWQgdGVzdF9jdWJpYygpIHsKKyAgICAgICAgU2tQb2ludCBzcmNbNF0gPSB7CisgICAg ICAgICAgICB7IDU1Ni4yNTAwMCwgNTIzLjAzMDAzIH0sCisgICAgICAgICAgICB7IDU1Ni4yMzk5 OSwgNTIyLjk2MDAyIH0sCisgICAgICAgICAgICB7IDU1Ni4yMTk5NywgNTIyLjg5MDAxIH0sCisg ICAgICAgICAgICB7IDU1Ni4yMTk5NywgNTIyLjgyMDAxIH0KKyAgICAgICAgfTsKKyAgICAgICAg U2tQb2ludCBkc3RbMTBdOworICAgICAgICBTa1NjYWxhciB0dmFsW10gPSB7IDAuMzMzMzMzMzRm LCAwLjk5OTk5OTk0ZiB9OworICAgICAgICBTa0Nob3BDdWJpY0F0KHNyYywgZHN0LCB0dmFsLCAy KTsKKyAgICB9CisqLworCitzdGF0aWMgdm9pZCBjaG9wQ3ViaWNBdChjb25zdCBGbG9hdFBvaW50 IHNyY1s0XSwgRmxvYXRQb2ludCBkc3RbXSwgY29uc3QgZmxvYXQgdFZhbHVlc1tdLCBpbnQgcm9v dHMpCit7CisjaWZuZGVmIE5ERUJVRworICAgIGZvciAoaW50IGkgPSAwOyBpIDwgcm9vdHMgLSAx OyBpKyspIHsKKyAgICAgICAgQVNTRVJUKGlzVW5pdEludGVydmFsKHRWYWx1ZXNbaV0pKTsKKyAg ICAgICAgQVNTRVJUKGlzVW5pdEludGVydmFsKHRWYWx1ZXNbaSsxXSkpOworICAgICAgICBBU1NF UlQodFZhbHVlc1tpXSA8IHRWYWx1ZXNbaSsxXSk7CisgICAgfQorI2VuZGlmCisKKyAgICBpZiAo ZHN0KSB7CisgICAgICAgIGlmICghcm9vdHMpIC8vIG5vdGhpbmcgdG8gY2hvcAorICAgICAgICAg ICAgbWVtY3B5KGRzdCwgc3JjLCA0KnNpemVvZihGbG9hdFBvaW50KSk7CisgICAgICAgIGVsc2Ug eworICAgICAgICAgICAgZmxvYXQgdCA9IHRWYWx1ZXNbMF07CisgICAgICAgICAgICBGbG9hdFBv aW50IHRtcFs0XTsKKworICAgICAgICAgICAgZm9yIChpbnQgaSA9IDA7IGkgPCByb290czsgaSsr KSB7CisgICAgICAgICAgICAgICAgY2hvcEN1YmljQXQoc3JjLCBkc3QsIHQpOworICAgICAgICAg ICAgICAgIGlmIChpID09IHJvb3RzIC0gMSkKKyAgICAgICAgICAgICAgICAgICAgYnJlYWs7CisK KyAgICAgICAgICAgICAgICBkc3QgKz0gMzsKKyAgICAgICAgICAgICAgICAvLyBoYXZlIHNyYyBw b2ludCB0byB0aGUgcmVtYWluaW5nIGN1YmljIChhZnRlciB0aGUgY2hvcCkKKyAgICAgICAgICAg ICAgICBtZW1jcHkodG1wLCBkc3QsIDQgKiBzaXplb2YoRmxvYXRQb2ludCkpOworICAgICAgICAg ICAgICAgIHNyYyA9IHRtcDsKKworICAgICAgICAgICAgICAgIC8vIHdhdGNoIG91dCBpbiBjYXNl IHRoZSByZW5vcm1hbGl6ZWQgdCBpc24ndCBpbiByYW5nZQorICAgICAgICAgICAgICAgIGlmICgh dmFsaWRVbml0RGl2aWRlKHRWYWx1ZXNbaSsxXSAtIHRWYWx1ZXNbaV0sCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgMSAtIHRWYWx1ZXNbaV0sICZ0KSkgeworICAgICAgICAg ICAgICAgICAgICAvLyBpZiB3ZSBjYW4ndCwganVzdCBjcmVhdGUgYSBkZWdlbmVyYXRlIGN1Ymlj CisgICAgICAgICAgICAgICAgICAgIGRzdFs0XSA9IGRzdFs1XSA9IGRzdFs2XSA9IHNyY1szXTsK KyAgICAgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAg ICAgfQorICAgICAgICB9CisgICAgfQorfQorCitzdGF0aWMgdm9pZCBmbGF0dGVuRG91YmxlQ3Vi aWNZRXh0cmVtYShGbG9hdFBvaW50IGNvb3Jkc1s3XSkKK3sKKyAgICBjb29yZHNbMl0uc2V0WShj b29yZHNbM10ueSgpKTsKKyAgICBjb29yZHNbNF0uc2V0WShjb29yZHNbM10ueSgpKTsKK30KKwor c3RhdGljIGludCBjaG9wQ3ViaWNBdFlFeHRyZW1hKGNvbnN0IEZsb2F0UG9pbnQgc3JjWzRdLCBG bG9hdFBvaW50IGRzdFsxMF0pCit7CisgICAgZmxvYXQgdFZhbHVlc1syXTsKKyAgICBpbnQgcm9v dHMgPSBmaW5kQ3ViaWNFeHRyZW1hKHNyY1swXS55KCksIHNyY1sxXS55KCksIHNyY1syXS55KCks IHNyY1szXS55KCksIHRWYWx1ZXMpOworCisgICAgY2hvcEN1YmljQXQoc3JjLCBkc3QsIHRWYWx1 ZXMsIHJvb3RzKTsKKyAgICBpZiAoZHN0ICYmIHJvb3RzID4gMCkgeworICAgICAgICAvLyB3ZSBk byBzb21lIGNsZWFudXAgdG8gZW5zdXJlIG91ciBZIGV4dHJlbWEgYXJlIGZsYXQKKyAgICAgICAg ZmxhdHRlbkRvdWJsZUN1YmljWUV4dHJlbWEoJmRzdFswXSk7CisgICAgICAgIGlmIChyb290cyA9 PSAyKQorICAgICAgICAgICAgZmxhdHRlbkRvdWJsZUN1YmljWUV4dHJlbWEoJmRzdFszXSk7Cisg ICAgfQorICAgIHJldHVybiByb290czsKK30KKworLy8gUHVibGljIGN1YmljIG9wZXJhdGlvbnMu CisKK3ZvaWQgY2hvcEN1YmljQXQoY29uc3QgRmxvYXRQb2ludCBzcmNbNF0sIEZsb2F0UG9pbnQg ZHN0WzddLCBmbG9hdCB0KQoreworICAgIEFTU0VSVCh0ID4gMCAmJiB0IDwgMSk7CisKKyAgICBm bG9hdCBvdXRwdXRbMTRdOworICAgIGludGVycEN1YmljQ29vcmRzKHNyY1swXS54KCksIHNyY1sx XS54KCksIHNyY1syXS54KCksIHNyY1szXS54KCksICZvdXRwdXRbMF0sIHQpOworICAgIGludGVy cEN1YmljQ29vcmRzKHNyY1swXS55KCksIHNyY1sxXS55KCksIHNyY1syXS55KCksIHNyY1szXS55 KCksICZvdXRwdXRbMV0sIHQpOworICAgIGZvciAoaW50IGkgPSAwOyBpIDwgNzsgaSsrKQorICAg ICAgICBkc3RbaV0uc2V0KG91dHB1dFsyICogaV0sIG91dHB1dFsyICogaSArIDFdKTsKK30KKwor Ly8gUHVibGljIFhSYXkgcXVlcmllcy4KKworYm9vbCB4UmF5Q3Jvc3Nlc0xpbmUoY29uc3QgWFJh eSYgeFJheSwgY29uc3QgRmxvYXRQb2ludCBwdHNbMl0sIGJvb2wqIGFtYmlndW91cykKK3sKKyAg ICBpZiAoYW1iaWd1b3VzKQorICAgICAgICAqYW1iaWd1b3VzID0gZmFsc2U7CisKKyAgICAvLyBE ZXRlcm1pbmUgcXVpY2sgZGlzY2FyZHMuCisgICAgLy8gQ29uc2lkZXIgcXVlcnkgbGluZSBnb2lu ZyBleGFjdGx5IHRocm91Z2ggcG9pbnQgMCB0byBub3QKKyAgICAvLyBpbnRlcnNlY3QsIGZvciBz eW1tZXRyeSB3aXRoIFNrWFJheUNyb3NzZXNNb25vdG9uaWNDdWJpYy4KKyAgICBpZiAoeFJheS55 KCkgPT0gcHRzWzBdLnkoKSkgeworICAgICAgICBpZiAoYW1iaWd1b3VzKQorICAgICAgICAgICAg KmFtYmlndW91cyA9IHRydWU7CisgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICB9CisgICAgaWYg KHhSYXkueSgpIDwgcHRzWzBdLnkoKSAmJiB4UmF5LnkoKSA8IHB0c1sxXS55KCkpCisgICAgICAg IHJldHVybiBmYWxzZTsKKyAgICBpZiAoeFJheS55KCkgPiBwdHNbMF0ueSgpICYmIHhSYXkueSgp ID4gcHRzWzFdLnkoKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAgIGlmICh4UmF5LngoKSA+ IHB0c1swXS54KCkgJiYgeFJheS54KCkgPiBwdHNbMV0ueCgpKQorICAgICAgICByZXR1cm4gZmFs c2U7CisgICAgLy8gRGV0ZXJtaW5lIGRlZ2VuZXJhdGUgY2FzZXMKKyAgICBpZiAobmVhcmx5WmVy byhwdHNbMF0ueSgpIC0gcHRzWzFdLnkoKSkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICBp ZiAobmVhcmx5WmVybyhwdHNbMF0ueCgpIC0gcHRzWzFdLngoKSkpIHsKKyAgICAgICAgLy8gV2Un dmUgYWxyZWFkeSBkZXRlcm1pbmVkIHRoZSBxdWVyeSBwb2ludCBsaWVzIHdpdGhpbiB0aGUKKyAg ICAgICAgLy8gdmVydGljYWwgcmFuZ2Ugb2YgdGhlIGxpbmUgc2VnbWVudC4KKyAgICAgICAgaWYg KHhSYXkueCgpIDw9IHB0c1swXS54KCkpIHsKKyAgICAgICAgICAgIGlmIChhbWJpZ3VvdXMpCisg ICAgICAgICAgICAgICAgKmFtYmlndW91cyA9ICh4UmF5LnkoKSA9PSBwdHNbMV0ueSgpKTsKKyAg ICAgICAgICAgIHJldHVybiB0cnVlOworICAgICAgICB9CisgICAgICAgIHJldHVybiBmYWxzZTsK KyAgICB9CisgICAgLy8gQW1iaWd1aXR5IGNoZWNrCisgICAgaWYgKHhSYXkueSgpID09IHB0c1sx XS55KCkpIHsKKyAgICAgICAgaWYgKHhSYXkueCgpIDw9IHB0c1sxXS54KCkpIHsKKyAgICAgICAg ICAgIGlmIChhbWJpZ3VvdXMpCisgICAgICAgICAgICAgICAgKmFtYmlndW91cyA9IHRydWU7Cisg ICAgICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICAgICAgfQorICAgICAgICByZXR1cm4gZmFsc2U7 CisgICAgfQorICAgIC8vIEZ1bGwgbGluZSBzZWdtZW50IGV2YWx1YXRpb24KKyAgICBmbG9hdCBk ZWx0YVkgPSBwdHNbMV0ueSgpIC0gcHRzWzBdLnkoKTsKKyAgICBmbG9hdCBkZWx0YVggPSBwdHNb MV0ueCgpIC0gcHRzWzBdLngoKTsKKyAgICBmbG9hdCBzbG9wZSA9IGRlbHRhWSAvIGRlbHRhWDsK KyAgICBmbG9hdCBiID0gcHRzWzBdLnkoKSAtIHNsb3BlICogcHRzWzBdLngoKTsKKyAgICAvLyBT b2x2ZSBmb3IgeCBjb29yZGluYXRlIGF0IHkgPSB4UmF5LnkoKQorICAgIGZsb2F0IHggPSAoeFJh eS55KCkgLSBiKSAvIHNsb3BlOworICAgIHJldHVybiB4UmF5LngoKSA8PSB4OworfQorCitpbnQg bnVtWFJheUNyb3NzaW5nc0ZvckN1YmljKGNvbnN0IFhSYXkmIHB0LCBjb25zdCBGbG9hdFBvaW50 IGN1YmljWzRdLCBib29sKiBhbWJpZ3VvdXMpCit7CisgICAgaW50IG51bUNyb3NzaW5ncyA9IDA7 CisgICAgRmxvYXRQb2ludCBtb25vdG9uaWNDdWJpY3NbMTBdOworICAgIGludCBudW1Nb25vdG9u aWNDdWJpY3MgPSBjaG9wQ3ViaWNBdFlFeHRyZW1hKGN1YmljLCBtb25vdG9uaWNDdWJpY3MpOwor ICAgIGlmIChhbWJpZ3VvdXMpCisgICAgICAgICphbWJpZ3VvdXMgPSBmYWxzZTsKKyAgICBib29s IGxvY2FsbHlBbWJpZ3VvdXM7CisgICAgaWYgKHhSYXlDcm9zc2VzTW9ub3RvbmljQ3ViaWMocHQs ICZtb25vdG9uaWNDdWJpY3NbMF0sICZsb2NhbGx5QW1iaWd1b3VzKSkKKyAgICAgICAgKytudW1D cm9zc2luZ3M7CisgICAgaWYgKGFtYmlndW91cykKKyAgICAgICAgKmFtYmlndW91cyB8PSBsb2Nh bGx5QW1iaWd1b3VzOworICAgIGlmIChudW1Nb25vdG9uaWNDdWJpY3MgPiAwKQorICAgICAgICBp ZiAoeFJheUNyb3NzZXNNb25vdG9uaWNDdWJpYyhwdCwgJm1vbm90b25pY0N1Ymljc1szXSwgJmxv Y2FsbHlBbWJpZ3VvdXMpKQorICAgICAgICAgICAgKytudW1Dcm9zc2luZ3M7CisgICAgaWYgKGFt YmlndW91cykKKyAgICAgICAgKmFtYmlndW91cyB8PSBsb2NhbGx5QW1iaWd1b3VzOworICAgIGlm IChudW1Nb25vdG9uaWNDdWJpY3MgPiAxKQorICAgICAgICBpZiAoeFJheUNyb3NzZXNNb25vdG9u aWNDdWJpYyhwdCwgJm1vbm90b25pY0N1Ymljc1s2XSwgJmxvY2FsbHlBbWJpZ3VvdXMpKQorICAg ICAgICAgICAgKytudW1Dcm9zc2luZ3M7CisgICAgaWYgKGFtYmlndW91cykKKyAgICAgICAgKmFt YmlndW91cyB8PSBsb2NhbGx5QW1iaWd1b3VzOworICAgIHJldHVybiBudW1Dcm9zc2luZ3M7Cit9 CisKK30gLy8gbmFtZXNwYWNlIGdwdQorfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpJbmRleDogV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUvQ3ViaWNNYXRoVXRpbHMuaAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9DdWJpY01hdGhVdGlscy5oCShyZXZpc2lv biAwKQorKysgV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUvQ3ViaWNNYXRoVXRpbHMuaAko cmV2aXNpb24gMCkKQEAgLTAsMCArMSwxNTMgQEAKKy8qCisgKiBDb3B5cmlnaHQgMjAxMCwgR29v Z2xlIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24g YW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBt b2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNv bmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNv dXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqICAg ICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJv dmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhl ciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAgICAq IE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMKKyAq IGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMg ZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3Jp dHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhF IENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBF WFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1J VEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklU TkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBF VkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElB QkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVY RU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAq IExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7 IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBU SU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBX SEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVE SU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRI RSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lC SUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBncHVfQ3ViaWNNYXRoVXRpbHNf aAorI2RlZmluZSBncHVfQ3ViaWNNYXRoVXRpbHNfaAorCisjaW5jbHVkZSAiVHJhbnNmb3JtYXRp b25NYXRyaXguaCIKKyNpbmNsdWRlIDxtYXRoLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKwor Y2xhc3MgRmxvYXRQb2ludDsKKworbmFtZXNwYWNlIGdwdSB7CisKKy8vIEEgcm91bmRvZmYgZmFj dG9yIGluIHRoZSBjdWJpYyBjbGFzc2lmaWNhdGlvbiBhbmQgdGV4dHVyZSBjb29yZGluYXRlCisv LyBnZW5lcmF0aW9uIGFsZ29yaXRobXMuIFRoaXMgcHJpbWFyaWx5IGRldGVybWluZXMgdGhlIGhh bmRsaW5nIG9mIGNvcm5lcgorLy8gY2FzZXMgZHVyaW5nIHRoZSBjbGFzc2lmaWNhdGlvbiBwcm9j ZXNzLiBCZSBjYXJlZnVsIHdoZW4gYWRqdXN0aW5nIHRoaXM7CisvLyBpdCBoYXMgYmVlbiBkZXRl cm1pbmVkIGVtcGlyaWNhbGx5IHRvIHdvcmsgd2VsbC4KK2NvbnN0IGZsb2F0IEVwc2lsb24gPSA1 LjBlLTRmOworCisvLyBSZXR1cm5zIHplcm8gaWYgdmFsdWUgaXMgd2l0aGluICsvLWtFcHNpbG9u IG9mIHplcm8uCitpbmxpbmUgZmxvYXQgcm91bmRUb1plcm8oZmxvYXQgdmFsKQoreworICAgIGlm ICh2YWwgPCBFcHNpbG9uICYmIHZhbCA+IC1FcHNpbG9uKQorICAgICAgICByZXR1cm4gMDsKKyAg ICByZXR1cm4gdmFsOworfQorCisvLyBSZXR1cm5zIGRpc3RhbmNlIGJldHdlZW4gdHdvIHBvaW50 cyBpbiB0aGUgMkQgcGxhbmUuCitpbmxpbmUgZmxvYXQgZGlzdGFuY2UoZmxvYXQgeDAsIGZsb2F0 IHkwLAorICAgICAgICAgICAgICAgICAgICAgIGZsb2F0IHgxLCBmbG9hdCB5MSkKK3sKKyAgICBm bG9hdCB4ZCA9IHgxIC0geDA7CisgICAgZmxvYXQgeWQgPSB5MSAtIHkwOworICAgIHJldHVybiBz cXJ0Zih4ZCAqIHhkICsgeWQgKiB5ZCk7Cit9CisKKy8vIFJldHVybnMgdHJ1ZSBpZiB0aGUgZ2l2 ZW4gcG9pbnRzIGFyZSB3aXRoaW4gRXBzaWxvbiBkaXN0YW5jZSBvZgorLy8gZWFjaCBvdGhlci4K K2lubGluZSBib29sIGFwcHJveEVxdWFsKGNvbnN0IFZlY3RvcjMmIHYwLCBjb25zdCBWZWN0b3Iz JiB2MSkKK3sKKyAgICByZXR1cm4gKHYwIC0gdjEpLmxlbmd0aFNxdWFyZWQoKSA8IEVwc2lsb24g KiBFcHNpbG9uOworfQorCisvLyBSZXR1cm5zIHRydWUgaWYgdGhlIGdpdmVuIDJEIHBvaW50cyBh cmUgd2l0aGluIEVwc2lsb24gZGlzdGFuY2Ugb2YKKy8vIGVhY2ggb3RoZXIuCitpbmxpbmUgYm9v bCBhcHByb3hFcXVhbChmbG9hdCB4MCwgZmxvYXQgeTAsCisgICAgICAgICAgICAgICAgICAgICAg ICBmbG9hdCB4MSwgZmxvYXQgeTEpCit7CisgICAgcmV0dXJuIGRpc3RhbmNlKHgwLCB5MCwgeDEs IHkxKSA8IEVwc2lsb247Cit9CisKKy8vIFJldHVybnMgdHJ1ZSBpZiB0aGUgZ2l2ZW4gc2NhbGFy IHZhbHVlcyBhcmUgd2l0aGluIEVwc2lsb24gb2YgZWFjaCBvdGhlci4KK2lubGluZSBib29sIGFw cHJveEVxdWFsKGZsb2F0IGYwLCBmbG9hdCBmMSkKK3sKKyAgICByZXR1cm4gZmFic2YoZjAgLSBm MSkgPCBFcHNpbG9uOworfQorCisvLyBEZXRlcm1pbmVzIHdoZXRoZXIgdGhlIGxpbmUgc2VnbWVu dCBiZXR3ZWVuIChwMSwgcTEpIGludGVyc2VjdHMKKy8vIHRoYXQgYmV0d2VlbiAocDIsIHEyKS4K K2Jvb2wgbGluZXNJbnRlcnNlY3QoZmxvYXQgcDF4LCBmbG9hdCBwMXksCisgICAgICAgICAgICAg ICAgICAgIGZsb2F0IHExeCwgZmxvYXQgcTF5LAorICAgICAgICAgICAgICAgICAgICBmbG9hdCBw MngsIGZsb2F0IHAyeSwKKyAgICAgICAgICAgICAgICAgICAgZmxvYXQgcTJ4LCBmbG9hdCBxMnkp OworCisvLyBEZXRlcm1pbmVzIHdoZXRoZXIgdGhlIDJEIHBvaW50IGRlZmluZWQgYnkgKHB4LCBw eSkgaXMgaW5zaWRlIHRoZQorLy8gMkQgdHJpYW5nbGUgZGVmaW5lZCBieSB2ZXJ0aWNlcyAoYXgs IGF5KSwgKGJ4LCBieSksIGFuZCAoY3gsIGN5KS4KKy8vIFRoaXMgdGVzdCBkZWZpbmVzIHRoYXQg cG9pbnRzIGV4YWN0bHkgb24gYW4gZWRnZSBhcmUgbm90IGNvbnNpZGVyZWQKKy8vIHRvIGJlIGlu c2lkZSB0aGUgdHJpYW5nbGUuCitib29sIHBvaW50SW5UcmlhbmdsZShmbG9hdCBweCwgZmxvYXQg cHksCisgICAgICAgICAgICAgICAgICAgICBmbG9hdCBheCwgZmxvYXQgYXksCisgICAgICAgICAg ICAgICAgICAgICBmbG9hdCBieCwgZmxvYXQgYnksCisgICAgICAgICAgICAgICAgICAgICBmbG9h dCBjeCwgZmxvYXQgY3kpOworCisvLyBEZXRlcm1pbmVzIHdoZXRoZXIgdGhlIHRyaWFuZ2xlcyBk ZWZpbmVkIGJ5IHRoZSBwb2ludHMgKGExLCBiMSwgYzEpCisvLyBhbmQgKGEyLCBiMiwgYzIpIG92 ZXJsYXAuIFRoZSBkZWZpbml0aW9uIG9mIHRoaXMgZnVuY3Rpb24gaXMgdGhhdAorLy8gaWYgdGhl IHR3byB0cmlhbmdsZXMgb25seSBzaGFyZSBhbiBhZGphY2VudCBlZGdlIG9yIHZlcnRleCwgdGhl eQorLy8gYXJlIG5vdCBjb25zaWRlcmVkIHRvIG92ZXJsYXAuCitib29sIHRyaWFuZ2xlc092ZXJs YXAoZmxvYXQgYTF4LCBmbG9hdCBhMXksCisgICAgICAgICAgICAgICAgICAgICAgZmxvYXQgYjF4 LCBmbG9hdCBiMXksCisgICAgICAgICAgICAgICAgICAgICAgZmxvYXQgYzF4LCBmbG9hdCBjMXks CisgICAgICAgICAgICAgICAgICAgICAgZmxvYXQgYTJ4LCBmbG9hdCBhMnksCisgICAgICAgICAg ICAgICAgICAgICAgZmxvYXQgYjJ4LCBmbG9hdCBiMnksCisgICAgICAgICAgICAgICAgICAgICAg ZmxvYXQgYzJ4LCBmbG9hdCBjMnkpOworCisvLyBHaXZlbiBhIHNyYyBjdWJpYyBiZXppZXIsIGNo b3BzIGl0IGF0IHRoZSBzcGVjaWZpZWQgdCB2YWx1ZSwKKy8vIHdoZXJlIDAgPCB0IDwgMSwgYW5k IHJldHVybnMgdGhlIHR3byBuZXcgY3ViaWNzIGluIGRzdFswLi4zXQorLy8gYW5kIGRzdFszLi42 XS4KK3ZvaWQgY2hvcEN1YmljQXQoY29uc3QgRmxvYXRQb2ludCBzcmNbNF0sIEZsb2F0UG9pbnQg ZHN0WzddLCBmbG9hdCB0KTsKKworLy8gIlgtUmF5IiBxdWVyaWVzLiBBbiBYUmF5IGlzIGEgaGFs Zi1saW5lIG9yaWdpbmF0aW5nIGF0IHRoZSBnaXZlbgorLy8gcG9pbnQgYW5kIGV4dGVuZGluZyB0 byB4PStpbmZpbml0eS4KK3R5cGVkZWYgRmxvYXRQb2ludCBYUmF5OworCisvLyBHaXZlbiBhbiBh cmJpdHJhcnkgY3ViaWMgYmV6aWVyLCByZXR1cm4gdGhlIG51bWJlciBvZiB0aW1lcyBhbiBYUmF5 CisvLyBjcm9zc2VzIHRoZSBjdWJpYy4gVmFsaWQgcmV0dXJuIHZhbHVlcyBhcmUgWzAuLjNdLgor Ly8KKy8vIEJ5IGRlZmluaXRpb24gdGhlIGN1YmljIGlzIG9wZW4gYXQgdGhlIHN0YXJ0aW5nIHBv aW50OyBpbiBvdGhlcgorLy8gd29yZHMsIGlmIHB0LmZZIGlzIGVxdWl2YWxlbnQgdG8gY3ViaWNb MF0uZlksIGFuZCBwdC5mWCBpcyB0byB0aGUKKy8vIGxlZnQgb2YgdGhlIGN1cnZlLCB0aGUgbGlu ZSBpcyBub3QgY29uc2lkZXJlZCB0byBjcm9zcyB0aGUgY3VydmUsCisvLyBidXQgaWYgaXQgaXMg ZXF1YWwgdG8gY3ViaWNbM10uZlkgdGhlbiBpdCBpcyBjb25zaWRlcmVkIHRvCisvLyBjcm9zcy4K Ky8vCisvLyBPcHRpb25hbCBvdXRnb2luZyAiYW1iaWd1b3VzIiBhcmd1bWVudCBpbmRpY2F0ZXMg d2hldGhlciB0aGUgYW5zd2VyIGlzCisvLyBhbWJpZ3VvdXMgYmVjYXVzZSB0aGUgcXVlcnkgb2Nj dXJyZWQgZXhhY3RseSBhdCBvbmUgb2YgdGhlIGVuZHBvaW50cycgeQorLy8gY29vcmRpbmF0ZXMg b3IgYXQgYSB0YW5nZW50IHBvaW50LCBpbmRpY2F0aW5nIHRoYXQgYW5vdGhlciBxdWVyeSB5Cisv LyBjb29yZGluYXRlIGlzIHByZWZlcnJlZCBmb3Igcm9idXN0bmVzcy4KK2ludCBudW1YUmF5Q3Jv c3NpbmdzRm9yQ3ViaWMoY29uc3QgWFJheSYgeFJheSwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgY29uc3QgRmxvYXRQb2ludCBjdWJpY1s0XSwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgYm9vbCogYW1iaWd1b3VzID0gMCk7CisKKy8vIEdpdmVuIGEgbGluZSBzZWdtZW50IGZy b20gbGluZUVuZHBvaW50c1swXSB0byBsaW5lRW5kcG9pbnRzWzFdLCBhbmQgYW4KKy8vIFhSYXks IHJldHVybnMgdHJ1ZSBpZiB0aGV5IGludGVyc2VjdC4gT3B0aW9uYWwgb3V0Z29pbmcgImFtYmln dW91cyIKKy8vIGFyZ3VtZW50IGluZGljYXRlcyB3aGV0aGVyIHRoZSBhbnN3ZXIgaXMgYW1iaWd1 b3VzIGJlY2F1c2UgdGhlIHF1ZXJ5CisvLyBvY2N1cnJlZCBleGFjdGx5IGF0IG9uZSBvZiB0aGUg ZW5kcG9pbnRzJyB5IGNvb3JkaW5hdGVzLCBpbmRpY2F0aW5nIHRoYXQKKy8vIGFub3RoZXIgcXVl cnkgeSBjb29yZGluYXRlIGlzIHByZWZlcnJlZCBmb3Igcm9idXN0bmVzcy4KK2Jvb2wgeFJheUNy b3NzZXNMaW5lKGNvbnN0IFhSYXkmIHhSYXksCisgICAgICAgICAgICAgICAgICAgICBjb25zdCBG bG9hdFBvaW50IGxpbmVFbmRwb2ludHNbMl0sCisgICAgICAgICAgICAgICAgICAgICBib29sKiBh bWJpZ3VvdXMgPSAwKTsKKworfSAvLyBuYW1lc3BhY2UgZ3B1Cit9IC8vIG5hbWVzcGFjZSBXZWJD b3JlCisKKyNlbmRpZiAvLyBncHVfQ3ViaWNNYXRoVXRpbHNfaApJbmRleDogV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9ncHUvQ3ViaWNUZXh0dXJlQ29vcmRzLmNwcAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBX ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9DdWJpY1RleHR1cmVDb29yZHMuY3BwCShyZXZp c2lvbiAwKQorKysgV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUvQ3ViaWNUZXh0dXJlQ29v cmRzLmNwcAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwxOTMgQEAKKy8qCisgKiBDb3B5cmlnaHQg MjAxMCwgR29vZ2xlIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0 cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRo b3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9s bG93aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0cmlidXRp b25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5v dGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1l ci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVj ZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFu ZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4K KyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBv ZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUg cHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMg cHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklE RUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIg QU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9U CisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElU WSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVE LiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRP UlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQ RUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJV VCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1Ig U0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1Mg SU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElB QklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisg KiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkg T1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBU SEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5o IgorCisjaW5jbHVkZSAiZ3B1L0N1YmljVGV4dHVyZUNvb3Jkcy5oIgorCisjaW5jbHVkZSAiZ3B1 L0N1YmljTWF0aFV0aWxzLmgiCisjaW5jbHVkZSA8bWF0aC5oPgorI2luY2x1ZGUgPHd0Zi9Bc3Nl cnRpb25zLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKK25hbWVzcGFjZSBncHUgeworCit2b2lk IEN1YmljVGV4dHVyZUNvb3Jkczo6Q29tcHV0ZShjb25zdCBDdWJpY0NsYXNzaWZpZXI6OlJlc3Vs dCYgYywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGJvb2wgZmlsbFJpZ2h0U2lk ZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEN1YmljVGV4dHVyZUNvb3Jkczo6 UmVzdWx0KiByZXN1bHQpCit7CisgICAgLy8gTG9vcCBhbmQgQmxpbm4ncyBmb3JtdWxhdGlvbiBz dGF0ZXMgdGhhdCB0aGUgcmlnaHQgc2lkZSBvZiB0aGUKKyAgICAvLyBjdXJ2ZSBpcyBkZWZpbmVk IHRvIGJlIHRoZSBpbnNpZGUgKGZpbGxlZCByZWdpb24pLCBidXQgZm9yIHNvbWUKKyAgICAvLyBy ZWFzb24gaXQgbG9va3MgbGlrZSB3aXRoIHRoZSBkZWZhdWx0IG9yaWVudGF0aW9uIHBhcmFtZXRl cnMgd2UKKyAgICAvLyBhcmUgZmlsbGluZyB0aGUgbGVmdCBzaWRlIG9mIHRoZSBjdXJ2ZS4gUmVn YXJkbGVzcywgYmVjYXVzZSB3ZQorICAgIC8vIGNhbiByZWNlaXZlIGFyYml0cmFyaWx5IG9yaWVu dGVkIGN1cnZlcyBhcyBpbnB1dCwgd2UgbWlnaHQgaGF2ZQorICAgIC8vIHRvIHJldmVyc2UgdGhl IG9yaWVudGF0aW9uIG9mIHRoZSBjdWJpYyB0ZXh0dXJlIGNvb3JkaW5hdGVzIGV2ZW4KKyAgICAv LyBpbiBjYXNlcyB3aGVyZSB0aGUgcGFwZXIgZG9lbid0IHNheSBpdCBpcyBuZWNlc3NhcnkuCisg ICAgYm9vbCByZXZlcnNlT3JpZW50YXRpb24gPSBmYWxzZTsKKyAgICBjb25zdCBmbG9hdCBPbmVU aGlyZCA9IDEuMGYgLyAzLjBmOworICAgIGNvbnN0IGZsb2F0IFR3b1RoaXJkcyA9IDIuMGYgLyAz LjBmOworICAgIEN1YmljQ2xhc3NpZmllcjo6Q3VydmVUeXBlIGN1cnZlVHlwZSA9IGMuY3VydmVU eXBlKCk7CisKKyAgICByZXN1bHQtPmlzTGluZU9yUG9pbnQgPSBmYWxzZTsKKyAgICByZXN1bHQt Pmhhc1JlbmRlcmluZ0FydGlmYWN0ID0gZmFsc2U7CisgICAgcmVzdWx0LT5zdWJkaXZpc2lvblBh cmFtZXRlclZhbHVlID0gMC4wZjsKKworICAgIHN3aXRjaCAoY3VydmVUeXBlKSB7CisgICAgY2Fz ZSBDdWJpY0NsYXNzaWZpZXI6OmtTZXJwZW50aW5lOiB7CisgICAgICAgIGZsb2F0IHQxID0gc3Fy dGYoOS4wZiAqIGMuZDIoKSAqIGMuZDIoKSAtIDEyICogYy5kMSgpICogYy5kMygpKTsKKyAgICAg ICAgZmxvYXQgbHMgPSAzLjBmICogYy5kMigpIC0gdDE7CisgICAgICAgIGZsb2F0IGx0ID0gNi4w ZiAqIGMuZDEoKTsKKyAgICAgICAgZmxvYXQgbXMgPSAzLjBmICogYy5kMigpICsgdDE7CisgICAg ICAgIGZsb2F0IG10ID0gbHQ7CisgICAgICAgIGZsb2F0IGx0bWxzID0gbHQgLSBsczsKKyAgICAg ICAgZmxvYXQgbXRtbXMgPSBtdCAtIG1zOworICAgICAgICByZXN1bHQtPmNvb3Jkc1swXSA9IFZl Y3RvcjMobHMgKiBtcywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGxzICog bHMgKiBscywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1zICogbXMgKiBt cyk7CisgICAgICAgIHJlc3VsdC0+Y29vcmRzWzFdID0gVmVjdG9yMyhPbmVUaGlyZCAqICgzLjBm ICogbHMgKiBtcyAtCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBscyAqIG10IC0KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIGx0ICogbXMpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbHMg KiBscyAqIChscyAtIGx0KSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1z ICogbXMgKiAobXMgLSBtdCkpOworICAgICAgICByZXN1bHQtPmNvb3Jkc1syXSA9IFZlY3RvcjMo T25lVGhpcmQgKiAobHQgKiAobXQgLSAyLjBmICogbXMpICsKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIGxzICogKDMuMGYgKiBtcyAtIDIuMGYgKiBtdCkp LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbHRtbHMgKiBsdG1scyAqIGxz LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbXRtbXMgKiBtdG1tcyAqIG1z KTsKKyAgICAgICAgcmVzdWx0LT5jb29yZHNbM10gPSBWZWN0b3IzKGx0bWxzICogbXRtbXMsCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAtKGx0bWxzICogbHRtbHMgKiBsdG1s cyksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAtKG10bW1zICogbXRtbXMg KiBtdG1tcykpOworICAgICAgICBpZiAoYy5kMSgpIDwgMC4wZikKKyAgICAgICAgICAgIHJldmVy c2VPcmllbnRhdGlvbiA9IHRydWU7CisgICAgICAgIGJyZWFrOworICAgIH0KKworICAgIGNhc2Ug Q3ViaWNDbGFzc2lmaWVyOjprTG9vcDogeworICAgICAgICBmbG9hdCB0MSA9IHNxcnRmKDQuMGYg KiBjLmQxKCkgKiBjLmQzKCkgLSAzLjBmICogYy5kMigpICogYy5kMigpKTsKKyAgICAgICAgZmxv YXQgbHMgPSBjLmQyKCkgLSB0MTsKKyAgICAgICAgZmxvYXQgbHQgPSAyLjBmICogYy5kMSgpOwor ICAgICAgICBmbG9hdCBtcyA9IGMuZDIoKSArIHQxOworICAgICAgICBmbG9hdCBtdCA9IGx0Owor CisgICAgICAgIC8vIEZpZ3VyZSBvdXQgd2hldGhlciB0aGVyZSBpcyBhIHJlbmRlcmluZyBhcnRp ZmFjdCByZXF1aXJpbmcKKyAgICAgICAgLy8gdGhlIGN1cnZlIHRvIGJlIHN1YmRpdmlkZWQgYnkg dGhlIGNhbGxlci4KKyAgICAgICAgZmxvYXQgcWwgPSBscyAvIGx0OworICAgICAgICBmbG9hdCBx bSA9IG1zIC8gbXQ7CisgICAgICAgIGlmICgwLjBmIDwgcWwgJiYgcWwgPCAxLjBmKSB7CisgICAg ICAgICAgICByZXN1bHQtPmhhc1JlbmRlcmluZ0FydGlmYWN0ID0gdHJ1ZTsKKyAgICAgICAgICAg IHJlc3VsdC0+c3ViZGl2aXNpb25QYXJhbWV0ZXJWYWx1ZSA9IHFsOworICAgICAgICAgICAgLy8g VE9ETyhrYnIpOiBtYXkgcmVxdWlyZSBtb3JlIHdvcms/CisgICAgICAgICAgICBicmVhazsKKyAg ICAgICAgfQorCisgICAgICAgIGlmICgwLjBmIDwgcW0gJiYgcW0gPCAxLjBmKSB7CisgICAgICAg ICAgICByZXN1bHQtPmhhc1JlbmRlcmluZ0FydGlmYWN0ID0gdHJ1ZTsKKyAgICAgICAgICAgIHJl c3VsdC0+c3ViZGl2aXNpb25QYXJhbWV0ZXJWYWx1ZSA9IHFtOworICAgICAgICAgICAgLy8gVE9E TyhrYnIpOiBtYXkgcmVxdWlyZSBtb3JlIHdvcms/CisgICAgICAgICAgICBicmVhazsKKyAgICAg ICAgfQorCisgICAgICAgIGZsb2F0IGx0bWxzID0gbHQgLSBsczsKKyAgICAgICAgZmxvYXQgbXRt bXMgPSBtdCAtIG1zOworICAgICAgICByZXN1bHQtPmNvb3Jkc1swXSA9IFZlY3RvcjMobHMgKiBt cywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGxzICogbHMgKiBtcywKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGxzICogbXMgKiBtcyk7CisgICAgICAg IHJlc3VsdC0+Y29vcmRzWzFdID0KKyAgICAgICAgICAgICAgICBWZWN0b3IzKE9uZVRoaXJkICog KC1scyAqIG10IC0gbHQgKiBtcyArIDMuMGYgKiBscyAqIG1zKSwKKyAgICAgICAgICAgICAgICAg ICAgICAgIC1PbmVUaGlyZCAqIGxzICogKGxzICogKG10IC0gMy4wZiAqIG1zKSArIDIuMGYgKiBs dCAqIG1zKSwKKyAgICAgICAgICAgICAgICAgICAgICAgIC1PbmVUaGlyZCAqIG1zICogKGxzICog KDIuMGYgKiBtdCAtIDMuMGYgKiBtcykgKyBsdCAqIG1zKSk7CisgICAgICAgIHJlc3VsdC0+Y29v cmRzWzJdID0KKyAgICAgICAgICAgICAgICBWZWN0b3IzKE9uZVRoaXJkICogKGx0ICogKG10IC0g Mi4wZiAqIG1zKSArCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBscyAqICgz LjBmICogbXMgLSAyLjBmICogbXQpKSwKKyAgICAgICAgICAgICAgICAgICAgICAgIE9uZVRoaXJk ICogKGx0IC0gbHMpICogKGxzICogKDIuMGYgKiBtdCAtIDMuMGYgKiBtcykgKworICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbHQgKiBtcyksCisgICAgICAg ICAgICAgICAgICAgICAgICBPbmVUaGlyZCAqIChtdCAtIG1zKSAqIChscyAqIChtdCAtIDMuMGYg KiBtcykgKworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg Mi4wZiAqIGx0ICogbXMpKTsKKyAgICAgICAgcmVzdWx0LT5jb29yZHNbM10gPQorICAgICAgICAg ICAgICAgIFZlY3RvcjMobHRtbHMgKiBtdG1tcywKKyAgICAgICAgICAgICAgICAgICAgICAgIC0o bHRtbHMgKiBsdG1scykgKiBtdG1tcywKKyAgICAgICAgICAgICAgICAgICAgICAgIC1sdG1scyAq IG10bW1zICogbXRtbXMpOworICAgICAgICByZXZlcnNlT3JpZW50YXRpb24gPQorICAgICAgICAg ICAgICAgICgoYy5kMSgpID4gMC4wZiAmJiByZXN1bHQtPmNvb3Jkc1swXS54KCkgPCAwLjBmKQor ICAgICAgICAgICAgICAgICB8fCAoYy5kMSgpIDwgMC4wZiAmJiByZXN1bHQtPmNvb3Jkc1swXS54 KCkgPiAwLjBmKSk7CisgICAgICAgIGJyZWFrOworICAgIH0KKworICAgIGNhc2UgQ3ViaWNDbGFz c2lmaWVyOjprQ3VzcDogeworICAgICAgICBmbG9hdCBscyA9IGMuZDMoKTsKKyAgICAgICAgZmxv YXQgbHQgPSAzLjBmICogYy5kMigpOworICAgICAgICBmbG9hdCBsc21sdCA9IGxzIC0gbHQ7Cisg ICAgICAgIHJlc3VsdC0+Y29vcmRzWzBdID0gVmVjdG9yMyhscywKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIGxzICogbHMgKiBscywKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIDEuMGYpOworICAgICAgICByZXN1bHQtPmNvb3Jkc1sxXSA9IFZlY3RvcjMo bHMgLSBPbmVUaGlyZCAqIGx0LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg bHMgKiBscyAqIGxzbWx0LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMS4w Zik7CisgICAgICAgIHJlc3VsdC0+Y29vcmRzWzJdID0gVmVjdG9yMyhscyAtIFR3b1RoaXJkcyAq IGx0LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbHNtbHQgKiBsc21sdCAq IGxzLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMS4wZik7CisgICAgICAg IHJlc3VsdC0+Y29vcmRzWzNdID0gVmVjdG9yMyhsc21sdCwKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIGxzbWx0ICogbHNtbHQgKiBsc21sdCwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIDEuMGYpOworICAgICAgICBicmVhazsKKyAgICB9CisKKyAgICBj YXNlIEN1YmljQ2xhc3NpZmllcjo6a1F1YWRyYXRpYzogeworICAgICAgICByZXN1bHQtPmNvb3Jk c1swXSA9IFZlY3RvcjMoMCwgMCwgMCk7CisgICAgICAgIHJlc3VsdC0+Y29vcmRzWzFdID0gVmVj dG9yMyhPbmVUaGlyZCwgMCwgT25lVGhpcmQpOworICAgICAgICByZXN1bHQtPmNvb3Jkc1syXSA9 IFZlY3RvcjMoVHdvVGhpcmRzLCBPbmVUaGlyZCwgVHdvVGhpcmRzKTsKKyAgICAgICAgcmVzdWx0 LT5jb29yZHNbM10gPSBWZWN0b3IzKDEsIDEsIDEpOworICAgICAgICBpZiAoYy5kMygpIDwgMCkK KyAgICAgICAgICAgIHJldmVyc2VPcmllbnRhdGlvbiA9IHRydWU7CisgICAgICAgIGJyZWFrOwor ICAgIH0KKworICAgIGNhc2UgQ3ViaWNDbGFzc2lmaWVyOjprTGluZToKKyAgICBjYXNlIEN1Ymlj Q2xhc3NpZmllcjo6a1BvaW50OgorICAgICAgICByZXN1bHQtPmlzTGluZU9yUG9pbnQgPSB0cnVl OworICAgICAgICBicmVhazsKKworICAgIGRlZmF1bHQ6CisgICAgICAgIEFTU0VSVF9OT1RfUkVB Q0hFRCgpOworICAgICAgICBicmVhazsKKyAgICB9CisKKyAgICBpZiAoZmlsbFJpZ2h0U2lkZSkK KyAgICAgICAgcmV2ZXJzZU9yaWVudGF0aW9uID0gIXJldmVyc2VPcmllbnRhdGlvbjsKKworICAg IGlmIChyZXZlcnNlT3JpZW50YXRpb24pCisgICAgICAgIGZvciAoaW50IGkgPSAwOyBpIDwgNDsg aSsrKSB7CisgICAgICAgICAgICByZXN1bHQtPmNvb3Jkc1tpXS5zZXRYKC1yZXN1bHQtPmNvb3Jk c1tpXS54KCkpOworICAgICAgICAgICAgcmVzdWx0LT5jb29yZHNbaV0uc2V0WSgtcmVzdWx0LT5j b29yZHNbaV0ueSgpKTsKKyAgICAgICAgfQorfQorCit9IC8vIG5hbWVzcGFjZSBncHUKK30gLy8g bmFtZXNwYWNlIFdlYkNvcmUKSW5kZXg6IFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L0N1 YmljVGV4dHVyZUNvb3Jkcy5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvZ3B1L0N1YmljVGV4dHVyZUNvb3Jkcy5oCShyZXZpc2lvbiAwKQorKysgV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9ncHUvQ3ViaWNUZXh0dXJlQ29vcmRzLmgJKHJldmlzaW9uIDApCkBAIC0w LDAgKzEsOTQgQEAKKy8qCisgKiBDb3B5cmlnaHQgMjAxMCwgR29vZ2xlIEluYy4KKyAqIEFsbCBy aWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2Ug YW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBw ZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBt ZXQ6CisgKgorICogICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0 YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9u cyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlk ZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUg b2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkg YmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0 aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgor ICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJT IEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQg V0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElF RCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFS VElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09Q WVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNU LCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VR VUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NV UkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICog REFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNF RCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNU LCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1Ig T1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMg U09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1B R0UuCisgKi8KKworLy8gQ29tcHV0ZXMgdGhyZWUtZGltZW5zaW9uYWwgdGV4dHVyZSBjb29yZGlu YXRlcyBmb3IgdGhlIGNvbnRyb2wKKy8vIHBvaW50cyBvZiBhIGN1YmljIGN1cnZlIGZvciByZW5k ZXJpbmcgdmlhIHRoZSBzaGFkZXIgaW4gIlJlbmRlcmluZworLy8gVmVjdG9yIEFydCBvbiB0aGUg R1BVIiBieSBMb29wIGFuZCBCbGlubiwgR1BVIEdlbXMgMywgQ2hhcHRlciAyNS4KKworI2lmbmRl ZiBncHVfQ3ViaWNUZXh0dXJlQ29vcmRzX2gKKyNkZWZpbmUgZ3B1X0N1YmljVGV4dHVyZUNvb3Jk c19oCisKKyNpbmNsdWRlICJUcmFuc2Zvcm1hdGlvbk1hdHJpeC5oIgorI2luY2x1ZGUgImdwdS9D dWJpY0NsYXNzaWZpZXIuaCIKKworI2luY2x1ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgorCituYW1l c3BhY2UgV2ViQ29yZSB7CituYW1lc3BhY2UgZ3B1IHsKKworLy8gQ29tcHV0ZXMgdGV4dHVyZSBj b29yZGluYXRlcyBmb3IgcmVuZGVyaW5nIGN1YmljIGN1cnZlcyBvbiB0aGUgR1BVLgorY2xhc3Mg Q3ViaWNUZXh0dXJlQ29vcmRzIHsKK3B1YmxpYzoKKyAgICAvLyBDb250YWluZXIgZm9yIHRoZSBj dWJpYyB0ZXh0dXJlIGNvb3JkaW5hdGVzIGFuZCBvdGhlciBhc3NvY2lhdGVkCisgICAgLy8gaW5m b3JtYXRpb24uCisgICAgc3RydWN0IFJlc3VsdCB7CisgICAgICAgIFJlc3VsdCgpCisgICAgICAg ICAgICA6IGlzTGluZU9yUG9pbnQoZmFsc2UpCisgICAgICAgICAgICAsIGhhc1JlbmRlcmluZ0Fy dGlmYWN0KGZhbHNlKQorICAgICAgICAgICAgLCBzdWJkaXZpc2lvblBhcmFtZXRlclZhbHVlKDAu MGYpCisgICAgICAgIHsKKyAgICAgICAgfQorCisgICAgICAgIC8vIFRoZSAzRCB0ZXh0dXJlIGNv b3JkaW5hdGVzIHRoYXQgYXJlIHRvIGJlIGFzc29jaWF0ZWQgd2l0aCB0aGUKKyAgICAgICAgLy8g Zm91ciBjb250cm9sIHBvaW50cyBvZiB0aGUgY3ViaWMgY3VydmUuCisgICAgICAgIFZlY3RvcjMg Y29vcmRzWzRdOworCisgICAgICAgIC8vIEluZGljYXRlcyB3aGV0aGVyIHRoZSBjdXJ2ZSBpcyBh IGxpbmUgb3IgYSBwb2ludCwgaW4gd2hpY2ggY2FzZQorICAgICAgICAvLyB3ZSBkbyBub3QgbmVl ZCB0byBhZGQgaXRzIHRyaWFuZ2xlcyB0byB0aGUgbWVzaC4KKyAgICAgICAgYm9vbCBpc0xpbmVP clBvaW50OworCisgICAgICAgIC8vIEZvciB0aGUgbG9vcCBjYXNlLCBpbmRpY2F0ZXMgd2hldGhl ciBhIHJlbmRlcmluZyBhcnRpZmFjdCB3YXMKKyAgICAgICAgLy8gZGV0ZWN0ZWQsIGluIHdoaWNo IGNhc2UgdGhlIGN1cnZlIG5lZWRzIHRvIGJlIGZ1cnRoZXIKKyAgICAgICAgLy8gc3ViZGl2aWRl ZC4KKyAgICAgICAgYm9vbCBoYXNSZW5kZXJpbmdBcnRpZmFjdDsKKworICAgICAgICAvLyBJZiBh IHJlbmRlcmluZyBhcnRpZmFjdCB3aWxsIG9jY3VyIGZvciB0aGUgZ2l2ZW4gbG9vcCBjdXJ2ZSwK KyAgICAgICAgLy8gdGhpcyBpcyB0aGUgcGFyYW1ldGVyIHZhbHVlICgwIDw9IHZhbHVlIDw9IDEp IGF0IHdoaWNoIHRoZQorICAgICAgICAvLyBjdXJ2ZSBuZWVkcyB0byBiZSBzdWJkaXZpZGVkIHRv IGZpeCB0aGUgYXJ0aWZhY3QuCisgICAgICAgIGZsb2F0IHN1YmRpdmlzaW9uUGFyYW1ldGVyVmFs dWU7CisgICAgfTsKKworICAgIC8vIENvbXB1dGVzIHRoZSB0ZXh0dXJlIGNvb3JkaW5hdGVzIGZv ciBhIGN1YmljIGN1cnZlIHNlZ21lbnQncworICAgIC8vIGNvbnRyb2wgcG9pbnRzLCBnaXZlbiB0 aGUgY2xhc3NpZmljYXRpb24gb2YgdGhlIGN1cnZlIGFzIHdlbGwgYXMKKyAgICAvLyBhbiBpbmRp Y2F0aW9uIG9mIHdoaWNoIHNpZGUgaXMgdG8gYmUgZmlsbGVkLgorICAgIHN0YXRpYyB2b2lkIENv bXB1dGUoY29uc3QgQ3ViaWNDbGFzc2lmaWVyOjpSZXN1bHQmIGNsYXNzaWZpY2F0aW9uLAorICAg ICAgICAgICAgICAgICAgICAgICAgYm9vbCBmaWxsUmlnaHRTaWRlLAorICAgICAgICAgICAgICAg ICAgICAgICAgUmVzdWx0KiByZXN1bHQpOworCitwcml2YXRlOgorICAgIC8vIFRoaXMgY2xhc3Mg ZG9lcyBub3QgbmVlZCB0byBiZSBpbnN0YW50aWF0ZWQuCisgICAgQ3ViaWNUZXh0dXJlQ29vcmRz KCkge30KK307CisKK30gLy8gbmFtZXNwYWNlIGdwdQorfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQor CisjZW5kaWYgLy8gZ3B1X0N1YmljVGV4dHVyZUNvb3Jkc19oCkluZGV4OiBXZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL2dwdS9Mb2NhbFRyaWFuZ3VsYXRvci5jcHAKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUvTG9jYWxUcmlhbmd1bGF0b3IuY3BwCShyZXZpc2lv biAwKQorKysgV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUvTG9jYWxUcmlhbmd1bGF0b3Iu Y3BwCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDI5MiBAQAorLyoKKyAqIENvcHlyaWdodCAyMDEw LCBHb29nbGUgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1 dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQK KyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dp bmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMg b2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogbm90aWNl LCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgor ICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRo ZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5k IHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29y IG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0aW9uLgorICog ICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0 cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9k dWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlv ciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBC WSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElTIiBBTkQg QU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyAq IExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFO RCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElO IE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBC RSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICogU1BFQ0lB TCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5P VAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJW SUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRF UlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJ VFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJ TkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQg T0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQ T1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisK KyNpbmNsdWRlICJncHUvTG9jYWxUcmlhbmd1bGF0b3IuaCIKKworI2luY2x1ZGUgImdwdS9DdWJp Y01hdGhVdGlscy5oIgorI2luY2x1ZGUgPGFsZ29yaXRobT4KKworbmFtZXNwYWNlIFdlYkNvcmUg eworbmFtZXNwYWNlIGdwdSB7CisKK2Jvb2wgTG9jYWxUcmlhbmd1bGF0b3I6OlRyaWFuZ2xlOjpj b250YWlucyhMb2NhbFRyaWFuZ3VsYXRvcjo6VmVydGV4KiB2KQoreworICAgIGZvciAoaW50IGkg PSAwOyBpIDwgMzsgaSsrKQorICAgICAgICBpZiAobV92ZXJ0aWNlc1tpXSA9PSB2KQorICAgICAg ICAgICAgcmV0dXJuIHRydWU7CisgICAgcmV0dXJuIGZhbHNlOworfQorCitMb2NhbFRyaWFuZ3Vs YXRvcjo6VmVydGV4KiBMb2NhbFRyaWFuZ3VsYXRvcjo6VHJpYW5nbGU6Om5leHRWZXJ0ZXgoTG9j YWxUcmlhbmd1bGF0b3I6OlZlcnRleCogY3VyLCBib29sIGNjdykKK3sKKyAgICBpbnQgaWR4ID0g aW5kZXhGb3JWZXJ0ZXgoY3VyKTsKKyAgICBBU1NFUlQoaWR4ID49IDApOworICAgIGlmIChjY3cp CisgICAgICAgICsraWR4OworICAgIGVsc2UKKyAgICAgICAgLS1pZHg7CisgICAgaWYgKGlkeCA8 IDApCisgICAgICAgIGlkeCArPSAzOworICAgIGVsc2UKKyAgICAgICAgaWR4ID0gaWR4ICUgMzsK KyAgICByZXR1cm4gbV92ZXJ0aWNlc1tpZHhdOworfQorCitpbnQgTG9jYWxUcmlhbmd1bGF0b3I6 OlRyaWFuZ2xlOjppbmRleEZvclZlcnRleChMb2NhbFRyaWFuZ3VsYXRvcjo6VmVydGV4KiB2ZXJ0 ZXgpCit7CisgICAgZm9yIChpbnQgaSA9IDA7IGkgPCAzOyBpKyspCisgICAgICAgIGlmIChtX3Zl cnRpY2VzW2ldID09IHZlcnRleCkKKyAgICAgICAgICAgIHJldHVybiBpOworICAgIHJldHVybiAt MTsKK30KKwordm9pZCBMb2NhbFRyaWFuZ3VsYXRvcjo6VHJpYW5nbGU6Om1ha2VDQ1coKQorewor ICAgIC8vIFBvc3NpYmx5IHN3YXBzIHR3byB2ZXJ0aWNlcyBzbyB0aGF0IHRoZSB0cmlhbmdsZSdz IHZlcnRpY2VzIGFyZQorICAgIC8vIGFsd2F5cyBzcGVjaWZpZWQgaW4gY291bnRlcmNsb2Nrd2lz ZSBvcmRlci4gVGhpcyBvcmRlcnMgdGhlCisgICAgLy8gdmVydGljZXMgY2Fub25pY2FsbHkgd2hl biB3YWxraW5nIHRoZSBpbnRlcmlvciBlZGdlcyBmcm9tIHRoZQorICAgIC8vIHN0YXJ0IHRvIHRo ZSBlbmQgdmVydGV4LgorICAgIFZlY3RvcjMgdmVjMChtX3ZlcnRpY2VzWzBdLT54KCksIG1fdmVy dGljZXNbMF0tPnkoKSwgMCk7CisgICAgVmVjdG9yMyB2ZWMxKG1fdmVydGljZXNbMV0tPngoKSwg bV92ZXJ0aWNlc1sxXS0+eSgpLCAwKTsKKyAgICBWZWN0b3IzIHZlYzIobV92ZXJ0aWNlc1syXS0+ eCgpLCBtX3ZlcnRpY2VzWzJdLT55KCksIDApOworICAgIFZlY3RvcjMgZGlmZjEgPSB2ZWMxIC0g dmVjMDsKKyAgICBWZWN0b3IzIGRpZmYyID0gdmVjMiAtIHZlYzA7CisgICAgVmVjdG9yMyBjcCA9 IGRpZmYxLmNyb3NzKGRpZmYyKTsKKyAgICBpZiAoY3AueigpIDwgMCkKKyAgICAgICAgc3RkOjpz d2FwKG1fdmVydGljZXNbMV0sIG1fdmVydGljZXNbMl0pOworfQorCitMb2NhbFRyaWFuZ3VsYXRv cjo6TG9jYWxUcmlhbmd1bGF0b3IoKQoreworICAgIHJlc2V0KCk7Cit9CisKK3ZvaWQgTG9jYWxU cmlhbmd1bGF0b3I6OnJlc2V0KCkKK3sKKyAgICBtX251bVRyaWFuZ2xlcyA9IDA7CisgICAgbV9u dW1JbnRlcmlvclZlcnRpY2VzID0gMDsKKyAgICBmb3IgKGludCBpID0gMDsgaSA8IDQ7IGkrKykg eworICAgICAgICBtX2ludGVyaW9yVmVydGljZXNbaV0gPSAwOworICAgICAgICBtX3ZlcnRpY2Vz W2ldLnJlc2V0RmxhZ3MoKTsKKyAgICB9Cit9CisKK3ZvaWQgTG9jYWxUcmlhbmd1bGF0b3I6OnRy aWFuZ3VsYXRlKGJvb2wgY29tcHV0ZUluc2lkZUVkZ2VzLCBib29sIGZpbGxSaWdodFNpZGUpCit7 CisgICAgcmVzZXQoKTsKKworICAgIGJvb2wgZG9uZSA9IGZhbHNlOworCisgICAgbV92ZXJ0aWNl c1szXS5zZXRFbmQodHJ1ZSk7CisKKyAgICAvLyBGaXJzdCB0ZXN0IGZvciBkZWdlbmVyYXRlIGNh c2VzLgorICAgIGZvciAoaW50IGkgPSAwOyBpIDwgNCAmJiAhZG9uZTsgaSsrKQorICAgICAgICBm b3IgKGludCBqID0gaSArIDE7IGogPCA0ICYmICFkb25lOyBqKyspCisgICAgICAgICAgICBpZiAo YXBwcm94RXF1YWwobV92ZXJ0aWNlc1tpXS54KCksIG1fdmVydGljZXNbaV0ueSgpLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgIG1fdmVydGljZXNbal0ueCgpLCBtX3ZlcnRpY2VzW2pdLnko KSkpIHsKKyAgICAgICAgICAgICAgICAvLyBUd28gb2YgdGhlIHZlcnRpY2VzIGFyZSBjb2luY2lk ZW50LCBzbyB3ZSBjYW4gZWxpbWluYXRlIGF0CisgICAgICAgICAgICAgICAgLy8gbGVhc3Qgb25l IHRyaWFuZ2xlLiBXZSBtaWdodCBiZSBhYmxlIHRvIGVsaW1pbmF0ZSB0aGUgb3RoZXIKKyAgICAg ICAgICAgICAgICAvLyBhcyB3ZWxsLCBidXQgdGhpcyBzZWVtcyBzdWZmaWNpZW50IHRvIGF2b2lk IGRlZ2VuZXJhdGUKKyAgICAgICAgICAgICAgICAvLyB0cmlhbmd1bGF0aW9ucy4KKyAgICAgICAg ICAgICAgICBpbnQgaW5kaWNlc1szXSA9IHsgMCB9OworICAgICAgICAgICAgICAgIGludCBpbmRl eCA9IDA7CisgICAgICAgICAgICAgICAgZm9yIChpbnQgayA9IDA7IGsgPCA0OyBrKyspCisgICAg ICAgICAgICAgICAgICAgIGlmIChrICE9IGopCisgICAgICAgICAgICAgICAgICAgICAgICBpbmRp Y2VzW2luZGV4KytdID0gazsKKyAgICAgICAgICAgICAgICBhZGRUcmlhbmdsZSgmbV92ZXJ0aWNl c1tpbmRpY2VzWzBdXSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAmbV92ZXJ0aWNlc1tp bmRpY2VzWzFdXSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAmbV92ZXJ0aWNlc1tpbmRp Y2VzWzJdXSk7CisgICAgICAgICAgICAgICAgZG9uZSA9IHRydWU7CisgICAgICAgICAgICB9CisK KyAgICBpZiAoIWRvbmUpIHsKKyAgICAgICAgLy8gU2VlIHdoZXRoZXIgYW55IG9mIHRoZSBwb2lu dHMgYXJlIGZ1bGx5IGNvbnRhaW5lZCBpbiB0aGUKKyAgICAgICAgLy8gdHJpYW5nbGUgZGVmaW5l ZCBieSB0aGUgb3RoZXIgdGhyZWUuCisgICAgICAgIGZvciAoaW50IGkgPSAwOyBpIDwgNCAmJiAh ZG9uZTsgaSsrKSB7CisgICAgICAgICAgICBpbnQgaW5kaWNlc1szXSA9IHsgMCB9OworICAgICAg ICAgICAgaW50IGluZGV4ID0gMDsKKyAgICAgICAgICAgIGZvciAoaW50IGogPSAwOyBqIDwgNDsg aisrKQorICAgICAgICAgICAgICAgIGlmIChpICE9IGopCisgICAgICAgICAgICAgICAgICAgIGlu ZGljZXNbaW5kZXgrK10gPSBqOworICAgICAgICAgICAgaWYgKHBvaW50SW5UcmlhbmdsZShtX3Zl cnRpY2VzW2ldLngoKSwgbV92ZXJ0aWNlc1tpXS55KCksCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIG1fdmVydGljZXNbaW5kaWNlc1swXV0ueCgpLCBtX3ZlcnRpY2VzW2luZGljZXNb MF1dLnkoKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbV92ZXJ0aWNlc1tpbmRp Y2VzWzFdXS54KCksIG1fdmVydGljZXNbaW5kaWNlc1sxXV0ueSgpLAorICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBtX3ZlcnRpY2VzW2luZGljZXNbMl1dLngoKSwgbV92ZXJ0aWNlc1tp bmRpY2VzWzJdXS55KCkpKSB7CisgICAgICAgICAgICAgICAgLy8gUHJvZHVjZSB0aHJlZSB0cmlh bmdsZXMgc3Vycm91bmRpbmcgdGhpcyBpbnRlcmlvciB2ZXJ0ZXguCisgICAgICAgICAgICAgICAg Zm9yIChpbnQgaiA9IDA7IGogPCAzOyBqKyspCisgICAgICAgICAgICAgICAgICAgIGFkZFRyaWFu Z2xlKCZtX3ZlcnRpY2VzW2luZGljZXNbaiAlIDNdXSwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgJm1fdmVydGljZXNbaW5kaWNlc1soaiArIDEpICUgM11dLAorICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAmbV92ZXJ0aWNlc1tpXSk7CisgICAgICAgICAgICAgICAgLy8g TWFyayB0aGUgaW50ZXJpb3IgdmVydGV4IHNvIHdlIGlnbm9yZSBpdCBpZiB0cnlpbmcgdG8gdHJh Y2UKKyAgICAgICAgICAgICAgICAvLyB0aGUgaW50ZXJpb3IgZWRnZS4KKyAgICAgICAgICAgICAg ICBtX3ZlcnRpY2VzW2ldLnNldEludGVyaW9yKHRydWUpOworICAgICAgICAgICAgICAgIGRvbmUg PSB0cnVlOworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgfQorCisgICAgaWYgKCFkb25l KSB7CisgICAgICAgIC8vIFRoZXJlIGFyZSBvbmx5IGEgZmV3IHBlcm11dGF0aW9ucyBvZiB0aGUg dmVydGljZXMsIGlnbm9yaW5nCisgICAgICAgIC8vIHJvdGF0aW9ucywgd2hpY2ggYXJlIGlycmVs ZXZhbnQ6CisgICAgICAgIC8vCisgICAgICAgIC8vICAwLS0zICAwLS0yICAwLS0zICAwLS0xICAw LS0yICAwLS0xCisgICAgICAgIC8vICB8ICB8ICB8ICB8ICB8ICB8ICB8ICB8ICB8ICB8ICB8ICB8 CisgICAgICAgIC8vICB8ICB8ICB8ICB8ICB8ICB8ICB8ICB8ICB8ICB8ICB8ICB8CisgICAgICAg IC8vICAxLS0yICAxLS0zICAyLS0xICAyLS0zICAzLS0xICAzLS0yCisgICAgICAgIC8vCisgICAg ICAgIC8vIE5vdGUgdGhhdCB0aHJlZSBvZiB0aGVzZSBhcmUgcmVmbGVjdGlvbnMgb2YgZWFjaCBv dGhlci4KKyAgICAgICAgLy8gVGhlcmVmb3JlIHRoZXJlIGFyZSBvbmx5IHRocmVlIHBvc3NpYmxl IHRyaWFuZ3VsYXRpb25zOgorICAgICAgICAvLworICAgICAgICAvLyAgMC0tMyAgMC0tMiAgMC0t MworICAgICAgICAvLyAgfFwgfCAgfFwgfCAgfFwgfAorICAgICAgICAvLyAgfCBcfCAgfCBcfCAg fCBcfAorICAgICAgICAvLyAgMS0tMiAgMS0tMyAgMi0tMQorICAgICAgICAvLworICAgICAgICAv LyBGcm9tIHdoaWNoIHdlIGNhbiBjaG9vc2UgYnkgc2VlaW5nIHdoaWNoIG9mIHRoZSBwb3RlbnRp YWwKKyAgICAgICAgLy8gZGlhZ29uYWxzIGludGVyc2VjdC4gTm90ZSB0aGF0IHdlIGNob29zZSB0 aGUgc2hvcnRlc3QgZGlhZ29uYWwKKyAgICAgICAgLy8gdG8gc3BsaXQgdGhlIHF1YWQuCisgICAg ICAgIGlmIChsaW5lc0ludGVyc2VjdChtX3ZlcnRpY2VzWzBdLngoKSwgbV92ZXJ0aWNlc1swXS55 KCksCisgICAgICAgICAgICAgICAgICAgICAgICAgICBtX3ZlcnRpY2VzWzJdLngoKSwgbV92ZXJ0 aWNlc1syXS55KCksCisgICAgICAgICAgICAgICAgICAgICAgICAgICBtX3ZlcnRpY2VzWzFdLngo KSwgbV92ZXJ0aWNlc1sxXS55KCksCisgICAgICAgICAgICAgICAgICAgICAgICAgICBtX3ZlcnRp Y2VzWzNdLngoKSwgbV92ZXJ0aWNlc1szXS55KCkpKSB7CisgICAgICAgICAgICBpZiAoZGlzdGFu Y2UobV92ZXJ0aWNlc1swXS54KCksIG1fdmVydGljZXNbMF0ueSgpLAorICAgICAgICAgICAgICAg ICAgICAgICAgIG1fdmVydGljZXNbMl0ueCgpLCBtX3ZlcnRpY2VzWzJdLnkoKSkgPAorICAgICAg ICAgICAgICAgIGRpc3RhbmNlKG1fdmVydGljZXNbMV0ueCgpLCBtX3ZlcnRpY2VzWzFdLnkoKSwK KyAgICAgICAgICAgICAgICAgICAgICAgICBtX3ZlcnRpY2VzWzNdLngoKSwgbV92ZXJ0aWNlc1sz XS55KCkpKSB7CisgICAgICAgICAgICAgICAgYWRkVHJpYW5nbGUoJm1fdmVydGljZXNbMF0sICZt X3ZlcnRpY2VzWzFdLCAmbV92ZXJ0aWNlc1syXSk7CisgICAgICAgICAgICAgICAgYWRkVHJpYW5n bGUoJm1fdmVydGljZXNbMF0sICZtX3ZlcnRpY2VzWzJdLCAmbV92ZXJ0aWNlc1szXSk7CisgICAg ICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgIGFkZFRyaWFuZ2xlKCZtX3ZlcnRpY2Vz WzBdLCAmbV92ZXJ0aWNlc1sxXSwgJm1fdmVydGljZXNbM10pOworICAgICAgICAgICAgICAgIGFk ZFRyaWFuZ2xlKCZtX3ZlcnRpY2VzWzFdLCAmbV92ZXJ0aWNlc1syXSwgJm1fdmVydGljZXNbM10p OworICAgICAgICAgICAgfQorICAgICAgICB9IGVsc2UgaWYgKGxpbmVzSW50ZXJzZWN0KAorICAg ICAgICAgICAgbV92ZXJ0aWNlc1swXS54KCksIG1fdmVydGljZXNbMF0ueSgpLAorICAgICAgICAg ICAgbV92ZXJ0aWNlc1szXS54KCksIG1fdmVydGljZXNbM10ueSgpLAorICAgICAgICAgICAgbV92 ZXJ0aWNlc1sxXS54KCksIG1fdmVydGljZXNbMV0ueSgpLAorICAgICAgICAgICAgbV92ZXJ0aWNl c1syXS54KCksIG1fdmVydGljZXNbMl0ueSgpKSkgeworICAgICAgICAgICAgaWYgKGRpc3RhbmNl KG1fdmVydGljZXNbMF0ueCgpLCBtX3ZlcnRpY2VzWzBdLnkoKSwKKyAgICAgICAgICAgICAgICAg ICAgICAgICBtX3ZlcnRpY2VzWzNdLngoKSwgbV92ZXJ0aWNlc1szXS55KCkpIDwKKyAgICAgICAg ICAgICAgICBkaXN0YW5jZShtX3ZlcnRpY2VzWzFdLngoKSwgbV92ZXJ0aWNlc1sxXS55KCksCisg ICAgICAgICAgICAgICAgICAgICAgICAgbV92ZXJ0aWNlc1syXS54KCksIG1fdmVydGljZXNbMl0u eSgpKSkgeworICAgICAgICAgICAgICAgIGFkZFRyaWFuZ2xlKCZtX3ZlcnRpY2VzWzBdLCAmbV92 ZXJ0aWNlc1sxXSwgJm1fdmVydGljZXNbM10pOworICAgICAgICAgICAgICAgIGFkZFRyaWFuZ2xl KCZtX3ZlcnRpY2VzWzBdLCAmbV92ZXJ0aWNlc1szXSwgJm1fdmVydGljZXNbMl0pOworICAgICAg ICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgICAgICBhZGRUcmlhbmdsZSgmbV92ZXJ0aWNlc1sw XSwgJm1fdmVydGljZXNbMV0sICZtX3ZlcnRpY2VzWzJdKTsKKyAgICAgICAgICAgICAgICBhZGRU cmlhbmdsZSgmbV92ZXJ0aWNlc1syXSwgJm1fdmVydGljZXNbMV0sICZtX3ZlcnRpY2VzWzNdKTsK KyAgICAgICAgICAgIH0KKyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgIC8vIExpbmVzICgw LT4xKSwgKDItPjMpIGludGVyc2VjdCAtLSBvciBzaG91bGQsIG1vZHVsbyBudW1lcmljYWwKKyAg ICAgICAgICAgIC8vIHByZWNpc2lvbiBpc3N1ZXMKKyAgICAgICAgICAgIGlmIChkaXN0YW5jZSht X3ZlcnRpY2VzWzBdLngoKSwgbV92ZXJ0aWNlc1swXS55KCksCisgICAgICAgICAgICAgICAgICAg ICAgICAgbV92ZXJ0aWNlc1sxXS54KCksIG1fdmVydGljZXNbMV0ueSgpKSA8CisgICAgICAgICAg ICAgICAgZGlzdGFuY2UobV92ZXJ0aWNlc1syXS54KCksIG1fdmVydGljZXNbMl0ueSgpLAorICAg ICAgICAgICAgICAgICAgICAgICAgIG1fdmVydGljZXNbM10ueCgpLCBtX3ZlcnRpY2VzWzNdLnko KSkpIHsKKyAgICAgICAgICAgICAgICBhZGRUcmlhbmdsZSgmbV92ZXJ0aWNlc1swXSwgJm1fdmVy dGljZXNbMl0sICZtX3ZlcnRpY2VzWzFdKTsKKyAgICAgICAgICAgICAgICBhZGRUcmlhbmdsZSgm bV92ZXJ0aWNlc1swXSwgJm1fdmVydGljZXNbMV0sICZtX3ZlcnRpY2VzWzNdKTsKKyAgICAgICAg ICAgIH0gZWxzZSB7CisgICAgICAgICAgICAgICAgYWRkVHJpYW5nbGUoJm1fdmVydGljZXNbMF0s ICZtX3ZlcnRpY2VzWzJdLCAmbV92ZXJ0aWNlc1szXSk7CisgICAgICAgICAgICAgICAgYWRkVHJp YW5nbGUoJm1fdmVydGljZXNbM10sICZtX3ZlcnRpY2VzWzJdLCAmbV92ZXJ0aWNlc1sxXSk7Cisg ICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICB9CisKKyAgICBpZiAoY29tcHV0ZUluc2lkZUVk Z2VzKSB7CisgICAgICAgIC8vIFdlIG5lZWQgdG8gY29tcHV0ZSB3aGljaCB2ZXJ0aWNlcyBkZXNj cmliZSB0aGUgcGF0aCBhbG9uZyB0aGUKKyAgICAgICAgLy8gaW50ZXJpb3IgcG9ydGlvbiBvZiB0 aGUgc2hhcGUsIHRvIGZlZWQgdGhlc2UgdmVydGljZXMgdG8gdGhlCisgICAgICAgIC8vIG1vcmUg Z2VuZXJhbCB0ZXNzZWxsYXRpb24gYWxnb3JpdGhtLiBJdCBpcyBwb3NzaWJsZSB0aGF0IHdlCisg ICAgICAgIC8vIGNvdWxkIGRldGVybWluZSB0aGlzIGRpcmVjdGx5IHdoaWxlIHByb2R1Y2luZyB0 cmlhbmdsZXMgYWJvdmUuCisgICAgICAgIC8vIEhlcmUgd2UgdHJ5IHRvIGRvIGl0IGdlbmVyYWxs eSBqdXN0IGJ5IGV4YW1pbmluZyB0aGUgdHJpYW5nbGVzCisgICAgICAgIC8vIHRoYXQgaGF2ZSBh bHJlYWR5IGJlZW4gcHJvZHVjZWQuIFdlIHdhbGsgYXJvdW5kIHRoZW0gaW4gYQorICAgICAgICAv LyBzcGVjaWZpYyBkaXJlY3Rpb24gZGV0ZXJtaW5lZCBieSB3aGljaCBzaWRlIG9mIHRoZSBjdXJ2 ZSBpcworICAgICAgICAvLyBiZWluZyBmaWxsZWQuIFdlIGlnbm9yZSB0aGUgaW50ZXJpb3IgdmVy dGV4IHVubGVzcyBpdCBpcyBhbHNvCisgICAgICAgIC8vIHRoZSBlbmRpbmcgdmVydGV4LCBhbmQg c2tpcCB0aGUgZWRnZXMgc2hhcmVkIGJldHdlZW4gdHdvCisgICAgICAgIC8vIHRyaWFuZ2xlcy4K KyAgICAgICAgVmVydGV4KiB2ID0gJm1fdmVydGljZXNbMF07CisgICAgICAgIGFkZEludGVyaW9y VmVydGV4KHYpOworICAgICAgICBpbnQgbnVtU3RlcHMgPSAwOworICAgICAgICB3aGlsZSAoIXYt PmVuZCgpICYmIG51bVN0ZXBzIDwgNCkgeworICAgICAgICAgICAgLy8gRmluZCB0aGUgbmV4dCB2 ZXJ0ZXggYWNjb3JkaW5nIHRvIHRoZSBhYm92ZSBydWxlcworICAgICAgICAgICAgYm9vbCBnb3RO ZXh0ID0gZmFsc2U7CisgICAgICAgICAgICBmb3IgKGludCBpID0gMDsgaSA8IG51bVRyaWFuZ2xl cygpICYmICFnb3ROZXh0OyBpKyspIHsKKyAgICAgICAgICAgICAgICBUcmlhbmdsZSogdHJpID0g Z2V0VHJpYW5nbGUoaSk7CisgICAgICAgICAgICAgICAgaWYgKHRyaS0+Y29udGFpbnModikpIHsK KyAgICAgICAgICAgICAgICAgICAgVmVydGV4KiBuZXh0ID0gdHJpLT5uZXh0VmVydGV4KHYsIGZp bGxSaWdodFNpZGUpOworICAgICAgICAgICAgICAgICAgICBpZiAoIW5leHQtPm1hcmtlZCgpCisg ICAgICAgICAgICAgICAgICAgICAgICAmJiAhaXNTaGFyZWRFZGdlKHYsIG5leHQpCisgICAgICAg ICAgICAgICAgICAgICAgICAmJiAoIW5leHQtPmludGVyaW9yKCkgfHwgbmV4dC0+ZW5kKCkpKSB7 CisgICAgICAgICAgICAgICAgICAgICAgICBhZGRJbnRlcmlvclZlcnRleChuZXh0KTsKKyAgICAg ICAgICAgICAgICAgICAgICAgIHYgPSBuZXh0OworICAgICAgICAgICAgICAgICAgICAgICAgLy8g QnJlYWsgb3V0IG9mIGZvciBsb29wCisgICAgICAgICAgICAgICAgICAgICAgICBnb3ROZXh0ID0g dHJ1ZTsKKyAgICAgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgIH0KKyAgICAgICAg ICAgIH0KKyAgICAgICAgICAgICsrbnVtU3RlcHM7CisgICAgICAgIH0KKyAgICAgICAgaWYgKCF2 LT5lbmQoKSkgeworICAgICAgICAgICAgLy8gU29tZXRoaW5nIHdlbnQgd3Jvbmcgd2l0aCB0aGUg YWJvdmUgYWxnb3JpdGhtOyBhZGQgdGhlIGxhc3QKKyAgICAgICAgICAgIC8vIHZlcnRleCB0byB0 aGUgaW50ZXJpb3IgdmVydGljZXMgYW55d2F5LgorICAgICAgICAgICAgYWRkSW50ZXJpb3JWZXJ0 ZXgoJm1fdmVydGljZXNbM10pOworICAgICAgICB9CisgICAgfQorfQorCit2b2lkIExvY2FsVHJp YW5ndWxhdG9yOjphZGRUcmlhbmdsZShWZXJ0ZXgqIHYwLCBWZXJ0ZXgqIHYxLCBWZXJ0ZXgqIHYy KQoreworICAgIEFTU0VSVChtX251bVRyaWFuZ2xlcyA8IDMpOworICAgIG1fdHJpYW5nbGVzW21f bnVtVHJpYW5nbGVzKytdLnNldFZlcnRpY2VzKHYwLCB2MSwgdjIpOworfQorCit2b2lkIExvY2Fs VHJpYW5ndWxhdG9yOjphZGRJbnRlcmlvclZlcnRleChWZXJ0ZXgqIHYpCit7CisgICAgQVNTRVJU KG1fbnVtSW50ZXJpb3JWZXJ0aWNlcyA8IDQpOworICAgIG1faW50ZXJpb3JWZXJ0aWNlc1ttX251 bUludGVyaW9yVmVydGljZXMrK10gPSB2OworICAgIHYtPnNldE1hcmtlZCh0cnVlKTsKK30KKwor Ym9vbCBMb2NhbFRyaWFuZ3VsYXRvcjo6aXNTaGFyZWRFZGdlKFZlcnRleCogdjAsIFZlcnRleCog djEpCit7CisgICAgYm9vbCBoYXZlRWRnZTAxID0gZmFsc2U7CisgICAgYm9vbCBoYXZlRWRnZTEw ID0gZmFsc2U7CisgICAgZm9yIChpbnQgaSA9IDA7IGkgPCBudW1UcmlhbmdsZXMoKTsgaSsrKSB7 CisgICAgICAgIFRyaWFuZ2xlKiB0cmkgPSBnZXRUcmlhbmdsZShpKTsKKyAgICAgICAgaWYgKHRy aS0+Y29udGFpbnModjApICYmIHRyaS0+bmV4dFZlcnRleCh2MCwgdHJ1ZSkgPT0gdjEpCisgICAg ICAgICAgICBoYXZlRWRnZTAxID0gdHJ1ZTsKKyAgICAgICAgaWYgKHRyaS0+Y29udGFpbnModjEp ICYmIHRyaS0+bmV4dFZlcnRleCh2MSwgdHJ1ZSkgPT0gdjApCisgICAgICAgICAgICBoYXZlRWRn ZTEwID0gdHJ1ZTsKKyAgICB9CisgICAgcmV0dXJuIGhhdmVFZGdlMDEgJiYgaGF2ZUVkZ2UxMDsK K30KKworfSAvLyBuYW1lc3BhY2UgZ3B1Cit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCkluZGV4OiBX ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9Mb2NhbFRyaWFuZ3VsYXRvci5oCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L0xvY2FsVHJpYW5ndWxhdG9yLmgJ KHJldmlzaW9uIDApCisrKyBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9Mb2NhbFRyaWFu Z3VsYXRvci5oCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDI4NCBAQAorLyoKKyAqIENvcHlyaWdo dCAyMDEwLCBHb29nbGUgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRp c3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdp dGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBm b2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1 dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICog bm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9k dWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRpb24g YW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0aW9u LgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVz IG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90 ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZp YyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9W SURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElT IiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBO T1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklM SVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlN RUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJV VE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICog U1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywg QlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBP UiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVT UyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBM SUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQK KyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdB WSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9G IFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVmIGdwdV9Mb2Nh bFRyaWFuZ3VsYXRvcl9oCisjZGVmaW5lIGdwdV9Mb2NhbFRyaWFuZ3VsYXRvcl9oCisKKyNpbmNs dWRlIDx3dGYvQXNzZXJ0aW9ucy5oPgorI2luY2x1ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgorCitu YW1lc3BhY2UgV2ViQ29yZSB7CituYW1lc3BhY2UgZ3B1IHsKKworLy8gUGVyZm9ybXMgYSBsb2Nh bGl6ZWQgdHJpYW5ndWxhdGlvbiBvZiB0aGUgdHJpYW5nbGUgbWVzaAorLy8gY29ycmVzcG9uZGlu ZyB0byB0aGUgZm91ciBjb250cm9sIHBvaW50IHZlcnRpY2VzIG9mIGEgY3ViaWMgY3VydmUKKy8v IHNlZ21lbnQuCitjbGFzcyBMb2NhbFRyaWFuZ3VsYXRvciA6IHB1YmxpYyBOb25jb3B5YWJsZSB7 CitwdWJsaWM6CisgICAgLy8gVGhlIHZlcnRpY2VzIHRoYXQgdGhlIHRyaWFuZ3VsYXRvciBvcGVy YXRlcyB1cG9uLCBjb250YWluaW5nIGJvdGgKKyAgICAvLyB0aGUgcG9zaXRpb24gaW5mb3JtYXRp b24gYXMgd2VsbCBhcyB0aGUgY3ViaWMgdGV4dHVyZQorICAgIC8vIGNvb3JkaW5hdGVzLgorICAg IGNsYXNzIFZlcnRleCA6IHB1YmxpYyBOb25jb3B5YWJsZSB7CisgICAgcHVibGljOgorICAgICAg ICBWZXJ0ZXgoKQorICAgICAgICB7CisgICAgICAgIH0KKworICAgICAgICBmbG9hdCB4KCkKKyAg ICAgICAgeworICAgICAgICAgICAgcmV0dXJuIG1feDsKKyAgICAgICAgfQorCisgICAgICAgIGZs b2F0IHkoKQorICAgICAgICB7CisgICAgICAgICAgICByZXR1cm4gbV95OworICAgICAgICB9CisK KyAgICAgICAgZmxvYXQgaygpCisgICAgICAgIHsKKyAgICAgICAgICAgIHJldHVybiBtX2s7Cisg ICAgICAgIH0KKworICAgICAgICBmbG9hdCBsKCkKKyAgICAgICAgeworICAgICAgICAgICAgcmV0 dXJuIG1fbDsKKyAgICAgICAgfQorCisgICAgICAgIGZsb2F0IG0oKQorICAgICAgICB7CisgICAg ICAgICAgICByZXR1cm4gbV9tOworICAgICAgICB9CisKKyAgICAgICAgLy8gU2V0cyB0aGUgcG9z aXRpb24gYW5kIHRleHR1cmUgY29vcmRpbmF0ZXMgb2YgdGhlIHZlcnRleC4KKyAgICAgICAgdm9p ZCBzZXQoZmxvYXQgeCwgZmxvYXQgeSwKKyAgICAgICAgICAgICAgICAgZmxvYXQgaywgZmxvYXQg bCwgZmxvYXQgbSkKKyAgICAgICAgeworICAgICAgICAgICAgbV94ID0geDsKKyAgICAgICAgICAg IG1feSA9IHk7CisgICAgICAgICAgICBtX2sgPSBrOworICAgICAgICAgICAgbV9sID0gbDsKKyAg ICAgICAgICAgIG1fbSA9IG07CisgICAgICAgIH0KKworICAgICAgICAvLyBGbGFncyBmb3Igd2Fs a2luZyBmcm9tIHRoZSBzdGFydCB2ZXJ0ZXggdG8gdGhlIGVuZCB2ZXJ0ZXguCisgICAgICAgIGJv b2wgZW5kKCkKKyAgICAgICAgeworICAgICAgICAgICAgcmV0dXJuIG1fZW5kOworICAgICAgICB9 CisKKyAgICAgICAgdm9pZCBzZXRFbmQoYm9vbCBlbmQpCisgICAgICAgIHsKKyAgICAgICAgICAg IG1fZW5kID0gZW5kOworICAgICAgICB9CisKKyAgICAgICAgYm9vbCBtYXJrZWQoKQorICAgICAg ICB7CisgICAgICAgICAgICByZXR1cm4gbV9tYXJrZWQ7CisgICAgICAgIH0KKworICAgICAgICB2 b2lkIHNldE1hcmtlZChib29sIG1hcmtlZCkKKyAgICAgICAgeworICAgICAgICAgICAgbV9tYXJr ZWQgPSBtYXJrZWQ7CisgICAgICAgIH0KKworICAgICAgICBib29sIGludGVyaW9yKCkKKyAgICAg ICAgeworICAgICAgICAgICAgcmV0dXJuIG1faW50ZXJpb3I7CisgICAgICAgIH0KKworICAgICAg ICB2b2lkIHNldEludGVyaW9yKGJvb2wgaW50ZXJpb3IpCisgICAgICAgIHsKKyAgICAgICAgICAg IG1faW50ZXJpb3IgPSBpbnRlcmlvcjsKKyAgICAgICAgfQorCisgICAgICAgIHZvaWQgcmVzZXRG bGFncygpCisgICAgICAgIHsKKyAgICAgICAgICAgIG1fZW5kID0gZmFsc2U7CisgICAgICAgICAg ICBtX21hcmtlZCA9IGZhbHNlOworICAgICAgICAgICAgbV9pbnRlcmlvciA9IGZhbHNlOworICAg ICAgICB9CisKKyAgICBwcml2YXRlOgorICAgICAgICAvLyAyRCBjb29yZGluYXRlcyBvZiB0aGUg dmVydGV4IGluIHRoZSBwbGFuZS4KKyAgICAgICAgZmxvYXQgbV94OworICAgICAgICBmbG9hdCBt X3k7CisgICAgICAgIC8vIEN1YmljIHRleHR1cmUgY29vcmRpbmF0ZXMgZm9yIHJlbmRlcmluZyB0 aGUgY3VydmUuCisgICAgICAgIGZsb2F0IG1faywgbV9sLCBtX207CisKKyAgICAgICAgLy8gRmxh Z3MgZm9yIHdhbGtpbmcgZnJvbSB0aGUgc3RhcnQgdmVydGV4IHRvIHRoZSBlbmQgdmVydGV4Lgor ICAgICAgICBib29sIG1fZW5kOworICAgICAgICBib29sIG1fbWFya2VkOworICAgICAgICBib29s IG1faW50ZXJpb3I7CisgICAgfTsKKworICAgIC8vIFRoZSB0cmlhbmdsZXMgdGhlIFRyaWFuZ3Vs YXRvciBwcm9kdWNlcy4KKyAgICBjbGFzcyBUcmlhbmdsZSB7CisgICAgcHVibGljOgorICAgICAg ICBUcmlhbmdsZSgpCisgICAgICAgIHsKKyAgICAgICAgICAgIG1fdmVydGljZXNbMF0gPSAwOwor ICAgICAgICAgICAgbV92ZXJ0aWNlc1sxXSA9IDA7CisgICAgICAgICAgICBtX3ZlcnRpY2VzWzJd ID0gMDsKKyAgICAgICAgfQorCisgICAgICAgIC8vIEdldHMgdGhlIHZlcnRleCBhdCB0aGUgZ2l2 ZW4gaW5kZXgsIDAgPD0gaW5kZXggPCAzLgorICAgICAgICBWZXJ0ZXgqIGdldFZlcnRleChpbnQg aW5kZXgpCisgICAgICAgIHsKKyAgICAgICAgICAgIEFTU0VSVChpbmRleCA+PSAwICYmIGluZGV4 IDwgMyk7CisgICAgICAgICAgICByZXR1cm4gbV92ZXJ0aWNlc1tpbmRleF07CisgICAgICAgIH0K KworICAgICAgICAvLyBSZXR1cm5zIHRydWUgaWYgdGhpcyB0cmlhbmdsZSBjb250YWlucyB0aGUg Z2l2ZW4gdmVydGV4IChieQorICAgICAgICAvLyBpZGVudGl0eSwgbm90IGdlb21ldHJpY2FsbHkp LgorICAgICAgICBib29sIGNvbnRhaW5zKFZlcnRleCogdik7CisKKyAgICAgICAgLy8gUmV0dXJu cyB0aGUgdmVydGV4IGZvbGxvd2luZyB0aGUgY3VycmVudCBvbmUgaW4gdGhlIHNwZWNpZmllZAor ICAgICAgICAvLyBkaXJlY3Rpb24sIGNvdW50ZXJjbG9ja3dpc2Ugb3IgY2xvY2t3aXNlLgorICAg ICAgICBWZXJ0ZXgqIG5leHRWZXJ0ZXgoVmVydGV4KiBjdXIsIGJvb2wgY2N3KTsKKworICAgICAg ICAvLyBTZXRzIHRoZSB2ZXJ0aWNlcyBvZiB0aGlzIHRyaWFuZ2xlLCBwb3RlbnRpYWxseSByZW9y ZGVyaW5nIHRoZW0KKyAgICAgICAgLy8gdG8gcHJvZHVjZSBhIGNhbm9uaWNhbCBvcmllbnRhdGlv bi4KKyAgICAgICAgdm9pZCBzZXRWZXJ0aWNlcyhWZXJ0ZXgqIHYwLAorICAgICAgICAgICAgICAg ICAgICAgICAgIFZlcnRleCogdjEsCisgICAgICAgICAgICAgICAgICAgICAgICAgVmVydGV4KiB2 MikKKyAgICAgICAgeworICAgICAgICAgICAgbV92ZXJ0aWNlc1swXSA9IHYwOworICAgICAgICAg ICAgbV92ZXJ0aWNlc1sxXSA9IHYxOworICAgICAgICAgICAgbV92ZXJ0aWNlc1syXSA9IHYyOwor ICAgICAgICAgICAgbWFrZUNDVygpOworICAgICAgICB9CisKKyAgICBwcml2YXRlOgorICAgICAg ICAvLyBSZXR1cm5zIHRoZSBpbmRleCBbMC4uMl0gYXNzb2NpYXRlZCB3aXRoIHRoZSBnaXZlbiB2 ZXJ0ZXgsIG9yCisgICAgICAgIC8vIC0xIGlmIG5vdCBmb3VuZC4KKyAgICAgICAgaW50IGluZGV4 Rm9yVmVydGV4KFZlcnRleCogdmVydGV4KTsKKworICAgICAgICAvLyBSZW9yZGVycyB0aGUgdmVy dGljZXMgaW4gdGhpcyB0cmlhbmdsZSB0byBtYWtlIHRoZW0KKyAgICAgICAgLy8gY291bnRlcmNs b2Nrd2lzZSB3aGVuIHZpZXdlZCBpbiB0aGUgMkQgcGxhbmUsIGluIG9yZGVyIHRvCisgICAgICAg IC8vIGFjaGlldmUgYSBjYW5vbmljYWwgb3JkZXJpbmcuCisgICAgICAgIHZvaWQgbWFrZUNDVygp OworCisgICAgICAgIFZlcnRleCogbV92ZXJ0aWNlc1szXTsKKyAgICB9OworCisgICAgTG9jYWxU cmlhbmd1bGF0b3IoKTsKKworICAgIC8vIFJlc2V0cyB0aGUgdHJpYW5ndWxhdG9yJ3Mgc3RhdGUu IEFmdGVyIGVhY2ggdHJpYW5ndWxhdGlvbiBhbmQKKyAgICAvLyBiZWZvcmUgdGhlIG5leHQsIGNh bGwgdGhpcyB0byByZS1pbml0aWFsaXplIHRoZSBpbnRlcm5hbAorICAgIC8vIHZlcnRpY2VzJyBz dGF0ZS4KKyAgICB2b2lkIHJlc2V0KCk7CisKKyAgICAvLyBSZXR1cm5zIGEgbXV0YWJsZSB2ZXJ0 ZXggc3RvcmVkIGluIHRoZSB0cmlhbmd1bGF0b3IuIFVzZSB0aGlzIHRvCisgICAgLy8gc2V0IHVw IHRoZSB2ZXJ0aWNlcyBiZWZvcmUgYSB0cmlhbmd1bGF0aW9uLgorICAgIFZlcnRleCogZ2V0VmVy dGV4KGludCBpbmRleCkKKyAgICB7CisgICAgICAgIEFTU0VSVChpbmRleCA+PSAwICYmIGluZGV4 IDwgNCk7CisgICAgICAgIHJldHVybiAmbV92ZXJ0aWNlc1tpbmRleF07CisgICAgfQorCisgICAg Ly8gT25jZSB0aGUgdmVydGljZXMnIGNvbnRlbnRzIGhhdmUgYmVlbiBzZXQgdXAsIGNhbGwgdHJp YW5ndWxhdGUoKQorICAgIC8vIHRvIHJlY29tcHV0ZSB0aGUgdHJpYW5nbGVzLgorICAgIC8vCisg ICAgLy8gSWYgY29tcHV0ZUluc2lkZUVkZ2VzIGlzIHRydWUsIHRoZW4gZmlsbFJpZ2h0U2lkZSB3 aWxsIGJlCisgICAgLy8gdXNlZCB0byBkZXRlcm1pbmUgd2hpY2ggc2lkZSBvZiB0aGUgY3ViaWMg Y3VydmUgZGVmaW5lZCBieSB0aGUKKyAgICAvLyBmb3VyIGNvbnRyb2wgcG9pbnRzIGlzIHRvIGJl IGZpbGxlZC4KKyAgICAvLworICAgIC8vIFRoZSB0cmlhbmd1bGF0aW9uIG9iZXlzIHRoZSBmb2xs b3dpbmcgZ3VhcmFudGVlczoKKyAgICAvLyAgIC0gSWYgdGhlIGNvbnZleCBodWxsIGlzIGEgcXVh ZHJpbGF0ZXJhbCwgdGhlbiB0aGUgc2hvcnRlc3QgZWRnZQorICAgIC8vICAgICB3aWxsIGJlIGNo b3NlbiBmb3IgdGhlIGN1dCBpbnRvIHR3byB0cmlhbmdsZXMuCisgICAgLy8gICAtIElmIG9uZSBv ZiB0aGUgdmVydGljZXMgaXMgY29udGFpbmVkIGluIHRoZSB0cmlhbmdsZSBzcGFubmVkCisgICAg Ly8gICAgIGJ5IHRoZSBvdGhlciB0aHJlZSwgdGhyZWUgdHJpYW5nbGVzIHdpbGwgYmUgcHJvZHVj ZWQuCisgICAgdm9pZCB0cmlhbmd1bGF0ZShib29sIGNvbXB1dGVJbnNpZGVFZGdlcywKKyAgICAg ICAgICAgICAgICAgICAgIGJvb2wgZmlsbFJpZ2h0U2lkZSk7CisKKyAgICAvLyBOdW1iZXIgb2Yg dHJpYW5nbGVzIGNvbXB1dGVkIGJ5IHRyaWFuZ3VsYXRlKCkuCisgICAgaW50IG51bVRyaWFuZ2xl cygpIGNvbnN0CisgICAgeworICAgICAgICByZXR1cm4gbV9udW1UcmlhbmdsZXM7CisgICAgfQor CisgICAgLy8gUmV0dXJucyB0aGUgY29tcHV0ZWQgdHJpYW5nbGUgYXQgaW5kZXgsIDAgPD0gaW5k ZXggPAorICAgIC8vIG51bV90cmlhbmdsZXMoKS4KKyAgICBUcmlhbmdsZSogZ2V0VHJpYW5nbGUo aW50IGluZGV4KQorICAgIHsKKyAgICAgICAgQVNTRVJUKGluZGV4ID49IDAgJiYgaW5kZXggPCBt X251bVRyaWFuZ2xlcyk7CisgICAgICAgIHJldHVybiAmbV90cmlhbmdsZXNbaW5kZXhdOworICAg IH0KKworICAgIC8vIE51bWJlciBvZiB2ZXJ0aWNlcyBmYWNpbmcgdGhlIGluc2lkZSBvZiB0aGUg c2hhcGUsIGlmCisgICAgLy8gY29tcHV0ZV9pbnNpZGVfZWRnZXMgd2FzIHRydWUgd2hlbiB0cmlh bmd1bGF0ZSgpIHdhcyBjYWxsZWQuCisgICAgaW50IG51bUludGVyaW9yVmVydGljZXMoKSBjb25z dAorICAgIHsKKyAgICAgICAgcmV0dXJuIG1fbnVtSW50ZXJpb3JWZXJ0aWNlczsKKyAgICB9CisK KyAgICAvLyBGZXRjaGVzIHRoZSBnaXZlbiBpbnRlcmlvciB2ZXJ0ZXgsIDAgPD0gaW5kZXggPAor ICAgIC8vIG51bUludGVyaW9yVmVydGljZXMoKS4KKyAgICBWZXJ0ZXgqIGdldEludGVyaW9yVmVy dGV4KGludCBpbmRleCkKKyAgICB7CisgICAgICAgIEFTU0VSVChpbmRleCA+PSAwICYmIGluZGV4 IDwgbV9udW1JbnRlcmlvclZlcnRpY2VzKTsKKyAgICAgICAgcmV0dXJuIG1faW50ZXJpb3JWZXJ0 aWNlc1tpbmRleF07CisgICAgfQorCitwcml2YXRlOgorICAgIC8vIEFkZHMgYSB0cmlhbmdsZSB0 byB0aGUgdHJpYW5ndWxhdGlvbi4KKyAgICB2b2lkIGFkZFRyaWFuZ2xlKFZlcnRleCogdjAsIFZl cnRleCogdjEsIFZlcnRleCogdjIpOworCisgICAgLy8gQWRkcyBhIHZlcnRleCB0byB0aGUgbGlz dCBvZiBpbnRlcmlvciB2ZXJ0aWNlcy4KKyAgICB2b2lkIGFkZEludGVyaW9yVmVydGV4KFZlcnRl eCogdik7CisKKyAgICAvLyBJbmRpY2F0ZXMgd2hldGhlciB0aGUgZWRnZSBiZXR3ZWVuIHZlcnRl eCB2MCBhbmQgdjEgaXMgc2hhcmVkCisgICAgLy8gYmV0d2VlbiB0d28gb3IgbW9yZSB0cmlhbmds ZXMuCisgICAgYm9vbCBpc1NoYXJlZEVkZ2UoVmVydGV4KiB2MCwgVmVydGV4KiB2MSk7CisKKyAg ICAvLyBUaGUgdmVydGljZXMgYmVpbmcgdHJpYW5ndWxhdGVkLgorICAgIFZlcnRleCBtX3ZlcnRp Y2VzWzRdOworCisgICAgLy8gVGhlIHZlcnRpY2VzIGNvcnJlc3BvbmRpbmcgdG8gdGhlIGVkZ2Vz IGZhY2luZyB0aGUgaW5zaWRlIG9mIHRoZQorICAgIC8vIHNoYXBlLCBpbiBvcmRlciBmcm9tIHRo ZSBzdGFydCB2ZXJ0ZXggdG8gdGhlIGVuZCB2ZXJ0ZXguIFRoZSBtb3JlCisgICAgLy8gZ2VuZXJh bCB0cmlhbmd1bGF0aW9uIGFsZ29yaXRobSB0ZXNzZWxsYXRlcyB0aGlzIGludGVyaW9yIHJlZ2lv bi4KKyAgICBWZXJ0ZXgqIG1faW50ZXJpb3JWZXJ0aWNlc1s0XTsKKyAgICAvLyBUaGUgbnVtYmVy IG9mIGludGVyaW9yIHZlcnRpY2VzIHRoYXQgYXJlIHZhbGlkIGZvciB0aGUgY3VycmVudAorICAg IC8vIHRyaWFuZ3VsYXRpb24uCisgICAgaW50IG1fbnVtSW50ZXJpb3JWZXJ0aWNlczsKKworICAg IC8vIFRoZXJlIGNhbiBiZSBhdCBtb3N0IHRocmVlIHRyaWFuZ2xlcyBjb21wdXRlZCBieSB0aGlz IGxvY2FsCisgICAgLy8gYWxnb3JpdGhtLCB3aGljaCBvY2N1cnMgd2hlbiBvbmUgb2YgdGhlIHZl cnRpY2VzIGlzIGNvbnRhaW5lZCBpbgorICAgIC8vIHRoZSB0cmlhbmdsZSBzcGFubmVkIGJ5IHRo ZSBvdGhlciB0aHJlZS4gTW9zdCBvZiB0aGUgdGltZSB0aGUKKyAgICAvLyBhbGdvcml0aG0gY29t cHV0ZXMgdHdvIHRyaWFuZ2xlcy4KKyAgICBUcmlhbmdsZSBtX3RyaWFuZ2xlc1szXTsKKyAgICBp bnQgbV9udW1UcmlhbmdsZXM7Cit9OworCit9IC8vIG5hbWVzcGFjZSBncHUKK30gLy8gbmFtZXNw YWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIGdwdV9Mb2NhbFRyaWFuZ3VsYXRvcl9oCg== 65663 2010-08-26 19:37:49 -0700 2010-08-30 11:50:51 -0700 Path processing results and shader management classes cache-and-shaders.patch text/plain 28344 kbr SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA2NjE2NSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsNDcgQEAKKzIwMTAtMDgtMjYgIEtlbm5ldGggUnVzc2VsbCAgPGtickBnb29nbGUu Y29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFk ZCBzdXBwb3J0IGZvciBHUFUgYWNjZWxlcmF0ZWQgcGF0aCByZW5kZXJpbmcKKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ0NzI5CisKKyAgICAgICAgVGhp cyBwYXRjaCBhZGRzIHRoZSBQYXRoQ2FjaGUgZGF0YSBzdHJ1Y3R1cmUgcHJvZHVjZWQgYnkgdGhl IHBhdGgKKyAgICAgICAgcHJvY2Vzc2luZyBhbGdvcml0aG0gKHRvIGZvbGxvdyksIGFzIHdlbGwg YXMgaGVscGVyIGNsYXNzZXMgdG8KKyAgICAgICAgbWFuYWdlIHRoZSBzaGFkZXJzIHVzZWQgdG8g ZmlsbCB0aGUgcGF0aHMuCisKKyAgICAgICAgVGhlIHJlYXNvbiBmb3IgdGhlIHN0eWxlIHZpb2xh dGlvbnMgaW4gdGhlIGhlYWRlciBndWFyZHMgaXMKKyAgICAgICAgZGVzY3JpYmVkIGluIGFuIGVh cmxpZXIgcGF0Y2guCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9ncHU6IEFkZGVkLgor ICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2dwdS9QYXRoQ2FjaGUuY3BwOiBBZGRlZC4KKyAg ICAgICAgKFdlYkNvcmU6OmdwdTo6UGF0aENhY2hlOjpudW1WZXJ0aWNlcyk6CisgICAgICAgIChX ZWJDb3JlOjpncHU6OlBhdGhDYWNoZTo6dmVydGljZXMpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1 OjpQYXRoQ2FjaGU6OnRleGNvb3Jkcyk6CisgICAgICAgIChXZWJDb3JlOjpncHU6OlBhdGhDYWNo ZTo6YWRkVmVydGV4KToKKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6UGF0aENhY2hlOjpjbGVhcik6 CisgICAgICAgIChXZWJDb3JlOjpncHU6OlBhdGhDYWNoZTo6bnVtSW50ZXJpb3JWZXJ0aWNlcyk6 CisgICAgICAgIChXZWJDb3JlOjpncHU6OlBhdGhDYWNoZTo6aW50ZXJpb3JWZXJ0aWNlcyk6Cisg ICAgICAgIChXZWJDb3JlOjpncHU6OlBhdGhDYWNoZTo6YWRkSW50ZXJpb3JWZXJ0ZXgpOgorICAg ICAgICAoV2ViQ29yZTo6Z3B1OjpQYXRoQ2FjaGU6Om51bUludGVyaW9yRWRnZVZlcnRpY2VzKToK KyAgICAgICAgKFdlYkNvcmU6OmdwdTo6UGF0aENhY2hlOjppbnRlcmlvckVkZ2VWZXJ0aWNlcyk6 CisgICAgICAgIChXZWJDb3JlOjpncHU6OlBhdGhDYWNoZTo6YWRkSW50ZXJpb3JFZGdlVmVydGV4 KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9ncHUvUGF0aENhY2hlLmg6IEFkZGVkLgor ICAgICAgICAoV2ViQ29yZTo6Z3B1OjpQYXRoQ2FjaGU6OlBhdGhDYWNoZSk6CisgICAgICAgICog cGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L1NoYWRlckNhY2hlLmNwcDogQWRkZWQuCisgICAgICAgIChX ZWJDb3JlOjpncHU6OlNoYWRlckNhY2hlOjpTaGFkZXJDYWNoZSk6CisgICAgICAgIChXZWJDb3Jl OjpncHU6Oik6CisgICAgICAgIChXZWJDb3JlOjpncHU6OlNoYWRlckNhY2hlOjpnZXRTaGFkZXIp OgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpTaGFkZXJDYWNoZTo6bG9hZFNoYWRlcik6CisgICAg ICAgIChXZWJDb3JlOjpncHU6OlNoYWRlckNhY2hlOjpjcmVhdGVTaGFkZXJGcm9tU291cmNlKToK KyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9ncHUvU2hhZGVyQ2FjaGUuaDogQWRkZWQuCisg ICAgICAgIChXZWJDb3JlOjpncHU6OlNoYWRlckNhY2hlOjopOgorICAgICAgICAqIHBsYXRmb3Jt L2dyYXBoaWNzL2dwdS9TaGFkZXJPYmplY3QuY3BwOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6 OmdwdTo6U2hhZGVyT2JqZWN0OjpTaGFkZXJPYmplY3QpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1 OjpTaGFkZXJPYmplY3Q6OnVzZSk6CisgICAgICAgIChXZWJDb3JlOjpncHU6OlNoYWRlck9iamVj dDo6Z2V0VW5pZm9ybUxvY2F0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6U2hhZGVyT2Jq ZWN0OjpnZXRBdHRyaWJMb2NhdGlvbik6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1 L1NoYWRlck9iamVjdC5oOiBBZGRlZC4KKwogMjAxMC0wOC0yNiAgSmFtZXMgUm9iaW5zb24gIDxq YW1lc3JAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIEZpeCBjaHJvbWl1bSBtYWMgYnVpbGQuIFVu cmV2aWV3ZWQuCkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9QYXRoQ2FjaGUu Y3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L1BhdGhDYWNo ZS5jcHAJKHJldmlzaW9uIDApCisrKyBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9QYXRo Q2FjaGUuY3BwCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDExNyBAQAorLyoKKyAqIENvcHlyaWdo dCAyMDEwLCBHb29nbGUgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRp c3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdp dGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBm b2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1 dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICog bm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9k dWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRpb24g YW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0aW9u LgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVz IG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90 ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZp YyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9W SURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElT IiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBO T1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklM SVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlN RUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJV VE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICog U1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywg QlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBP UiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVT UyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBM SUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQK KyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdB WSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9G IFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmln LmgiCisKKyNpbmNsdWRlICJncHUvUGF0aENhY2hlLmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsK K25hbWVzcGFjZSBncHUgeworCit1bnNpZ25lZCBpbnQgUGF0aENhY2hlOjpudW1WZXJ0aWNlcygp IGNvbnN0Cit7CisgICAgcmV0dXJuIG1fdmVydGljZXMuc2l6ZSgpIC8gMjsKK30KKworY29uc3Qg ZmxvYXQqIFBhdGhDYWNoZTo6dmVydGljZXMoKSBjb25zdAoreworICAgIGlmICghbnVtVmVydGlj ZXMoKSkKKyAgICAgICAgcmV0dXJuIDA7CisgICAgcmV0dXJuIG1fdmVydGljZXMuZGF0YSgpOwor fQorCitjb25zdCBmbG9hdCogUGF0aENhY2hlOjp0ZXhjb29yZHMoKSBjb25zdAoreworICAgIGlm ICghbnVtVmVydGljZXMoKSkKKyAgICAgICAgcmV0dXJuIDA7CisgICAgcmV0dXJuIG1fdGV4Y29v cmRzLmRhdGEoKTsKK30KKwordm9pZCBQYXRoQ2FjaGU6OmFkZFZlcnRleChmbG9hdCB4LCBmbG9h dCB5LAorICAgICAgICAgICAgICAgICAgICAgICAgICBmbG9hdCBrLCBmbG9hdCBsLCBmbG9hdCBt KQoreworICAgIG1fdmVydGljZXMuYXBwZW5kKHgpOworICAgIG1fdmVydGljZXMuYXBwZW5kKHkp OworICAgIG1fdGV4Y29vcmRzLmFwcGVuZChrKTsKKyAgICBtX3RleGNvb3Jkcy5hcHBlbmQobCk7 CisgICAgbV90ZXhjb29yZHMuYXBwZW5kKG0pOworfQorCit2b2lkIFBhdGhDYWNoZTo6Y2xlYXIo KQoreworICAgIG1fdmVydGljZXMuY2xlYXIoKTsKKyAgICBtX3RleGNvb3Jkcy5jbGVhcigpOwor ICAgIG1faW50ZXJpb3JWZXJ0aWNlcy5jbGVhcigpOworI2lmZGVmIEdQVV9QQVRIX0NBQ0hFX0RF QlVHX0lOVEVSSU9SX0VER0VTCisgICAgbV9pbnRlcmlvckVkZ2VWZXJ0aWNlcy5jbGVhcigpOwor I2VuZGlmIC8vIEdQVV9QQVRIX0NBQ0hFX0RFQlVHX0lOVEVSSU9SX0VER0VTCit9CisKK3Vuc2ln bmVkIGludCBQYXRoQ2FjaGU6Om51bUludGVyaW9yVmVydGljZXMoKSBjb25zdAoreworICAgIHJl dHVybiBtX2ludGVyaW9yVmVydGljZXMuc2l6ZSgpIC8gMjsKK30KKworY29uc3QgZmxvYXQqIFBh dGhDYWNoZTo6aW50ZXJpb3JWZXJ0aWNlcygpIGNvbnN0Cit7CisgICAgaWYgKCFudW1JbnRlcmlv clZlcnRpY2VzKCkpCisgICAgICAgIHJldHVybiAwOworICAgIHJldHVybiBtX2ludGVyaW9yVmVy dGljZXMuZGF0YSgpOworfQorCit2b2lkIFBhdGhDYWNoZTo6YWRkSW50ZXJpb3JWZXJ0ZXgoZmxv YXQgeCwgZmxvYXQgeSkKK3sKKyAgICBtX2ludGVyaW9yVmVydGljZXMuYXBwZW5kKHgpOworICAg IG1faW50ZXJpb3JWZXJ0aWNlcy5hcHBlbmQoeSk7Cit9CisKKyNpZmRlZiBHUFVfUEFUSF9DQUNI RV9ERUJVR19JTlRFUklPUl9FREdFUwordW5zaWduZWQgaW50IFBhdGhDYWNoZTo6bnVtSW50ZXJp b3JFZGdlVmVydGljZXMoKSBjb25zdAoreworICAgIHJldHVybiBtX2ludGVyaW9yRWRnZVZlcnRp Y2VzLnNpemUoKSAvIDI7Cit9CisKK2NvbnN0IGZsb2F0KiBQYXRoQ2FjaGU6OmludGVyaW9yRWRn ZVZlcnRpY2VzKCkgY29uc3QKK3sKKyAgICBpZiAoIW51bV9pbnRlcmlvcl9lZGdlX3ZlcnRpY2Vz KCkpCisgICAgICAgIHJldHVybiAwOworICAgIHJldHVybiBtX2ludGVyaW9yRWRnZVZlcnRpY2Vz LmRhdGEoKTsKK30KKwordm9pZCBQYXRoQ2FjaGU6OmFkZEludGVyaW9yRWRnZVZlcnRleChmbG9h dCB4LCBmbG9hdCB5KQoreworICAgIG1faW50ZXJpb3JFZGdlVmVydGljZXMuYXBwZW5kKHgpOwor ICAgIG1faW50ZXJpb3JFZGdlVmVydGljZXMuYXBwZW5kKHkpOworfQorI2VuZGlmIC8vIEdQVV9Q QVRIX0NBQ0hFX0RFQlVHX0lOVEVSSU9SX0VER0VTCisKK30gLy8gbmFtZXNwYWNlIGdwdQorfSAv LyBuYW1lc3BhY2UgV2ViQ29yZQpJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUv UGF0aENhY2hlLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUv UGF0aENhY2hlLmgJKHJldmlzaW9uIDApCisrKyBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dw dS9QYXRoQ2FjaGUuaAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwxMTcgQEAKKy8qCisgKiBDb3B5 cmlnaHQgMjAxMCwgR29vZ2xlIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICog UmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBv ciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0 aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0 cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQK KyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJl cHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0 aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1 dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBu YW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHBy b21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3Bl Y2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMg UFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJB UyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBC VVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5U QUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVND TEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05U UklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwK KyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJ TkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09P RFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVT SU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkg T0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBU T1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFO WSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNF RCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBncHVf UGF0aENhY2hlX2gKKyNkZWZpbmUgZ3B1X1BhdGhDYWNoZV9oCisKKyNpbmNsdWRlIDx3dGYvTm9u Y29weWFibGUuaD4KKyNpbmNsdWRlIDx3dGYvVmVjdG9yLmg+CisKK25hbWVzcGFjZSBXZWJDb3Jl IHsKK25hbWVzcGFjZSBncHUgeworCisvLyBBIGNhY2hlIG9mIHRoZSBwcm9jZXNzZWQgdHJpYW5n bGUgbWVzaCBmb3IgYSBnaXZlbiBwYXRoLiBCZWNhdXNlCisvLyB0aGVzZSBtaWdodCBiZSBleHBl bnNpdmUgdG8gYWxsb2NhdGUgKHVzaW5nIG1hbGxvYy9mcmVlCisvLyBpbnRlcm5hbGx5KSwgaXQg aXMgcmVjb21tZW5kZWQgdG8gdHJ5IHRvIHJldXNlIHRoZW0gd2hlbiBwb3NzaWJsZS4KKworLy8g VW5jb21tZW50IHRoZSBmb2xsb3dpbmcgdG8gb2J0YWluIGRlYnVnZ2luZyBpbmZvcm1hdGlvbiBm b3IgdGhlIGVkZ2VzIGZhY2luZworLy8gdGhlIGludGVyaW9yIHJlZ2lvbiBvZiB0aGUgbWVzaC4K Ky8vICNkZWZpbmUgR1BVX1BBVEhfQ0FDSEVfREVCVUdfSU5URVJJT1JfRURHRVMKKworY2xhc3Mg UGF0aENhY2hlIDogcHVibGljIE5vbmNvcHlhYmxlIHsKK3B1YmxpYzoKKyAgICBQYXRoQ2FjaGUo KQorICAgIHsKKyAgICB9CisKKyAgICAvLyBUaGUgbnVtYmVyIG9mIHZlcnRpY2VzIGluIHRoZSBt ZXNoLgorICAgIHVuc2lnbmVkIGludCBudW1WZXJ0aWNlcygpIGNvbnN0OworCisgICAgLy8gR2V0 IHRoZSBiYXNlIHBvaW50ZXIgdG8gdGhlIHZlcnRleCBpbmZvcm1hdGlvbi4gVGhlcmUgYXJlIHR3 bworICAgIC8vIGNvb3JkaW5hdGVzIHBlciB2ZXJ0ZXguIFRoaXMgcG9pbnRlciBpcyB2YWxpZCB1 bnRpbCB0aGUgY2FjaGUgaXMKKyAgICAvLyBjbGVhcmVkIG9yIGFub3RoZXIgdmVydGV4IGlzIGFk ZGVkLiBSZXR1cm5zIDAgaWYgdGhlcmUgYXJlIG5vCisgICAgLy8gdmVydGljZXMgaW4gdGhlIG1l c2guCisgICAgY29uc3QgZmxvYXQqIHZlcnRpY2VzKCkgY29uc3Q7CisKKyAgICAvLyBHZXQgdGhl IGJhc2UgcG9pbnRlciB0byB0aGUgdGV4dHVyZSBjb29yZGluYXRlIGluZm9ybWF0aW9uLiBUaGVy ZQorICAgIC8vIGFyZSB0aHJlZSBjb29yZGluYXRlcyBwZXIgdmVydGV4LiBUaGlzIHBvaW50ZXIg aXMgdmFsaWQgdW50aWwgdGhlCisgICAgLy8gY2FjaGUgaXMgY2xlYXJlZCBvciBhbm90aGVyIHZl cnRleCBpcyBhZGRlZC4gUmV0dXJucyAwIGlmCisgICAgLy8gdGhlcmUgYXJlIG5vIHZlcnRpY2Vz IGluIHRoZSBtZXNoLgorICAgIGNvbnN0IGZsb2F0KiB0ZXhjb29yZHMoKSBjb25zdDsKKworICAg IC8vIEFkZHMgYSB2ZXJ0ZXgncyBpbmZvcm1hdGlvbiB0byB0aGUgY2FjaGUuIFRoZSBmaXJzdCB0 d28gYXJndW1lbnRzCisgICAgLy8gYXJlIHRoZSB4IGFuZCB5IGNvb3JkaW5hdGVzIG9mIHRoZSB2 ZXJ0ZXggb24gdGhlIHBsYW5lOyB0aGUgbGFzdAorICAgIC8vIHRocmVlIGFyZ3VtZW50cyBhcmUg dGhlIGN1YmljIHRleHR1cmUgY29vcmRpbmF0ZXMgYXNzb2NpYXRlZCB3aXRoCisgICAgLy8gdGhp cyB2ZXJ0ZXguCisgICAgdm9pZCBhZGRWZXJ0ZXgoZmxvYXQgeCwgZmxvYXQgeSwKKyAgICAgICAg ICAgICAgICAgICBmbG9hdCBrLCBmbG9hdCBsLCBmbG9hdCBtKTsKKworICAgIC8vIFRoZSBudW1i ZXIgb2YgaW50ZXJpb3IgdmVydGljZXMuCisgICAgdW5zaWduZWQgaW50IG51bUludGVyaW9yVmVy dGljZXMoKSBjb25zdDsKKyAgICAvLyBCYXNlIHBvaW50ZXIgdG8gdGhlIGludGVyaW9yIHZlcnRp Y2VzOyB0d28gY29vcmRpbmF0ZXMgcGVyCisgICAgLy8gdmVydGV4LCB3aGljaCBjYW4gYmUgZHJh d24gYXMgR0xfVFJJQU5HTEVTLiBSZXR1cm5zIDAgaWYgdGhlcmUKKyAgICAvLyBhcmUgbm8gaW50 ZXJpb3IgdmVydGljZXMgaW4gdGhlIG1lc2guCisgICAgY29uc3QgZmxvYXQqIGludGVyaW9yVmVy dGljZXMoKSBjb25zdDsKKyAgICAvLyBBZGRzIGFuIGludGVyaW9yIHZlcnRleCB0byB0aGUgY2Fj aGUuCisgICAgdm9pZCBhZGRJbnRlcmlvclZlcnRleChmbG9hdCB4LCBmbG9hdCB5KTsKKworICAg IC8vIENsZWFycyBhbGwgb2YgdGhlIHN0b3JlZCB2ZXJ0ZXggaW5mb3JtYXRpb24gaW4gdGhpcyBj YWNoZS4KKyAgICB2b2lkIGNsZWFyKCk7CisKKyNpZmRlZiBHUFVfUEFUSF9DQUNIRV9ERUJVR19J TlRFUklPUl9FREdFUworICAgIC8vIFRoZSBudW1iZXIgb2YgaW50ZXJpb3IgZWRnZSB2ZXJ0aWNl cworICAgIHVuc2lnbmVkIGludCBudW1JbnRlcmlvckVkZ2VWZXJ0aWNlcygpIGNvbnN0OworICAg IC8vIEJhc2UgcG9pbnRlciB0byB0aGUgaW50ZXJpb3IgdmVydGljZXM7IHR3byBjb29yZGluYXRl cyBwZXIKKyAgICAvLyB2ZXJ0ZXgsIHdoaWNoIGNhbiBiZSBkcmF3biBhcyBHTF9MSU5FUy4gUmV0 dXJucyAwIGlmIHRoZXJlIGFyZQorICAgIC8vIG5vIGludGVyaW9yIGVkZ2UgdmVydGljZXMgaW4g dGhlIG1lc2guCisgICAgY29uc3QgZmxvYXQqIGludGVyaW9yRWRnZVZlcnRpY2VzKCkgY29uc3Q7 CisgICAgdm9pZCBhZGRJbnRlcmlvckVkZ2VWZXJ0ZXgoZmxvYXQgeCwgZmxvYXQgeSk7CisjZW5k aWYgLy8gR1BVX1BBVEhfQ0FDSEVfREVCVUdfSU5URVJJT1JfRURHRVMKKworcHJpdmF0ZToKKyAg ICAvLyBUaGUgdHdvLWRpbWVuc2lvbmFsIHZlcnRpY2VzIG9mIHRoZSB0cmlhbmdsZSBtZXNoLgor ICAgIFZlY3RvcjxmbG9hdD4gbV92ZXJ0aWNlczsKKworICAgIC8vIFRoZSB0aHJlZS1kaW1lbnNp b25hbCBjdWJpYyB0ZXh0dXJlIGNvb3JkaW5hdGVzLgorICAgIFZlY3RvcjxmbG9hdD4gbV90ZXhj b29yZHM7CisKKyAgICBWZWN0b3I8ZmxvYXQ+IG1faW50ZXJpb3JWZXJ0aWNlczsKKworI2lmZGVm IEdQVV9QQVRIX0NBQ0hFX0RFQlVHX0lOVEVSSU9SX0VER0VTCisgICAgLy8gVGhlIGZvbGxvd2lu ZyBpcyBvbmx5IGZvciBkZWJ1Z2dpbmcKKyAgICBWZWN0b3I8ZmxvYXQ+IG1faW50ZXJpb3JFZGdl VmVydGljZXM7CisjZW5kaWYgLy8gR1BVX1BBVEhfQ0FDSEVfREVCVUdfSU5URVJJT1JfRURHRVMK K307CisKK30gLy8gbmFtZXNwYWNlIGdwdQorfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5k aWYgLy8gZ3B1X1BhdGhDYWNoZV9oCkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dw dS9TaGFkZXJDYWNoZS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9ncHUvU2hhZGVyQ2FjaGUuY3BwCShyZXZpc2lvbiAwKQorKysgV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9ncHUvU2hhZGVyQ2FjaGUuY3BwCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDE4OSBA QAorLyoKKyAqIENvcHlyaWdodCAyMDEwLCBHb29nbGUgSW5jLgorICogQWxsIHJpZ2h0cyByZXNl cnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5 IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBw cm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisg KiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFi b3ZlIGNvcHlyaWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhl IGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFy eSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4g dGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRo ZQorICogZGlzdHJpYnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUg SW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRv IGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdh cmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJ UyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRS SUJVVE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVT LCBJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJ RVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBV UlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAq IE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNU LCBJTkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERB TUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0Yg U1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQ Uk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBB TlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBM SUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0Up IEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwg RVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLwor CisjaW5jbHVkZSAiY29uZmlnLmgiCisKKyNpbmNsdWRlICJncHUvU2hhZGVyQ2FjaGUuaCIKKwor I2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgiCisjaW5jbHVkZSAiZ3B1L1NoYWRlck9iamVjdC5o IgorI2luY2x1ZGUgPHd0Zi90ZXh0L0NTdHJpbmcuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgewor bmFtZXNwYWNlIGdwdSB7CisKK1NoYWRlckNhY2hlOjpTaGFkZXJDYWNoZShHcmFwaGljc0NvbnRl eHQzRCogY29udGV4dCkKKyAgICA6IG1fY29udGV4dChjb250ZXh0KQorICAgICwgbV9zaGFkZXJz KG5ldyBPd25QdHI8U2hhZGVyT2JqZWN0PltOdW1TaGFkZXJUeXBlcyAqIE51bVJlZ2lvblR5cGVz ICogTnVtQW50aWFsaWFzVHlwZXNdKQoreworfQorCitzdHJ1Y3QgRmlsbENvZGUgeworICAgIGNv bnN0IGNoYXIqIHVuaWZvcm1zOworICAgIGNvbnN0IGNoYXIqIHNvdXJjZTsKK307CisKKy8vIFNo YWRlciBjb2RlIGZvciB0aGUgdmFyaW91cyBmaWxscywgaW5kZXhlZCBieSBTaGFkZXJUeXBlLgor c3RhdGljIGNvbnN0IEZpbGxDb2RlIGZpbGxDb2RlW1NoYWRlckNhY2hlOjpOdW1TaGFkZXJUeXBl c10gPSB7CisgICAgeworICAgICAgICAvLyBTb2xpZCBmaWxsCisgICAgICAgICJ1bmlmb3JtIHZl YzQgY29sb3I7XG4iLAorICAgICAgICAiZ2xfRnJhZ0NvbG9yID0gY29sb3IgKiBhbHBoYTtcbiIK KyAgICB9Cit9OworCitTaGFkZXJPYmplY3QqIFNoYWRlckNhY2hlOjpnZXRTaGFkZXIoU2hhZGVy VHlwZSBzaGFkZXJUeXBlLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFJl Z2lvblR5cGUgcmVnaW9uVHlwZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBBbnRpYWxpYXNUeXBlIGFudGlhbGlhc1R5cGUpCit7CisgICAgaW50IHNoYWRlckluZGV4ID0g c3RhdGljX2Nhc3Q8aW50PihzaGFkZXJUeXBlKTsKKyAgICBpbnQgbnVtU2hhZGVycyA9IHN0YXRp Y19jYXN0PGludD4oTnVtU2hhZGVyVHlwZXMpOworICAgIGludCByZWdpb25JbmRleCA9IHN0YXRp Y19jYXN0PGludD4ocmVnaW9uVHlwZSk7CisgICAgaW50IG51bVJlZ2lvbnMgPSBzdGF0aWNfY2Fz dDxpbnQ+KE51bVJlZ2lvblR5cGVzKTsKKyAgICBpbnQgYW50aWFsaWFzSW5kZXggPSBzdGF0aWNf Y2FzdDxpbnQ+KGFudGlhbGlhc1R5cGUpOworICAgIGludCBudW1BbnRpYWxpYXNlcyA9IHN0YXRp Y19jYXN0PGludD4oTnVtQW50aWFsaWFzVHlwZXMpOworCisgICAgaW50IGluZGV4ID0gKHNoYWRl ckluZGV4ICogbnVtUmVnaW9ucyAqIG51bUFudGlhbGlhc2VzICsKKyAgICAgICAgICAgICAgICAg cmVnaW9uSW5kZXggKiBudW1BbnRpYWxpYXNlcyArCisgICAgICAgICAgICAgICAgIGFudGlhbGlh c0luZGV4KTsKKyAgICBpZiAoIW1fc2hhZGVyc1tpbmRleF0uZ2V0KCkpCisgICAgICAgIG1fc2hh ZGVyc1tpbmRleF0gPSBsb2FkU2hhZGVyKHNoYWRlclR5cGUsIHJlZ2lvblR5cGUsIGFudGlhbGlh c1R5cGUpOworICAgIHJldHVybiBtX3NoYWRlcnNbaW5kZXhdLmdldCgpOworfQorCitQYXNzT3du UHRyPFNoYWRlck9iamVjdD4gU2hhZGVyQ2FjaGU6OmxvYWRTaGFkZXIoU2hhZGVyVHlwZSBzaGFk ZXJUeXBlLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IFJlZ2lvblR5cGUgcmVnaW9uVHlwZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBBbnRpYWxpYXNUeXBlIGFudGlhbGlhc1R5cGUpCit7CisgICAgY29u c3QgRmlsbENvZGUmIGZpbGwgPSBmaWxsQ29kZVtzaGFkZXJUeXBlXTsKKworICAgIFN0cmluZyB2 ZXJ0ZXhTaGFkZXJTb3VyY2UgPQorICAgICAgICAiLy8gVmVydGV4IHNoYWRlclxuIgorICAgICAg ICAidW5pZm9ybSBtYXQ0IHdvcmxkVmlld1Byb2plY3Rpb247XG4iCisgICAgICAgICJcbiIKKyAg ICAgICAgImF0dHJpYnV0ZSB2ZWMyIHBvc2l0aW9uO1xuIjsKKyAgICBpZiAocmVnaW9uVHlwZSA9 PSBFeHRlcmlvcikgeworICAgICAgICB2ZXJ0ZXhTaGFkZXJTb3VyY2UgKz0KKyAgICAgICAgICAg ICJhdHRyaWJ1dGUgdmVjMyB0ZXhDb29yZDA7XG4iCisgICAgICAgICAgICAiXG4iCisgICAgICAg ICAgICAidmFyeWluZyB2ZWMzIGtsbTtcbiI7CisgICAgfQorICAgIHZlcnRleFNoYWRlclNvdXJj ZSArPQorICAgICAgICAiXG4iCisgICAgICAgICJ2b2lkIG1haW4oKSB7XG4iCisgICAgICAgICIg IGdsX1Bvc2l0aW9uID0gd29ybGRWaWV3UHJvamVjdGlvbiAqIHZlYzQocG9zaXRpb24sIDAuMCwg MS4wKTtcbiI7CisgICAgaWYgKHJlZ2lvblR5cGUgPT0gRXh0ZXJpb3IpCisgICAgICAgIHZlcnRl eFNoYWRlclNvdXJjZSArPSAiICBrbG0gPSB0ZXhDb29yZDA7XG4iOworICAgIHZlcnRleFNoYWRl clNvdXJjZSArPSAifVxuIjsKKworICAgIFN0cmluZyBmcmFnbWVudFNoYWRlclNvdXJjZSA9Cisg ICAgICAgICIjaWZkZWYgR0xfRVNcbiIKKyAgICAgICAgInByZWNpc2lvbiBtZWRpdW1wIGZsb2F0 O1xuIgorICAgICAgICAiI2VuZGlmXG4iOworICAgIGlmIChyZWdpb25UeXBlID09IEV4dGVyaW9y KQorICAgICAgICBmcmFnbWVudFNoYWRlclNvdXJjZSArPSAidmFyeWluZyB2ZWMzIGtsbTtcbiI7 CisgICAgZnJhZ21lbnRTaGFkZXJTb3VyY2UgKz0gZmlsbC51bmlmb3JtczsKKyAgICBmcmFnbWVu dFNoYWRlclNvdXJjZSArPQorICAgICAgICAidm9pZCBtYWluKCkge1xuIjsKKyAgICBpZiAocmVn aW9uVHlwZSA9PSBJbnRlcmlvcikKKyAgICAgICAgZnJhZ21lbnRTaGFkZXJTb3VyY2UgKz0gIiAg ZmxvYXQgYWxwaGEgPSAxLjA7XG4iOworICAgIGVsc2UKKyAgICAgICAgaWYgKGFudGlhbGlhc1R5 cGUgPT0gQW50aWFsaWFzZWQpCisgICAgICAgICAgICBmcmFnbWVudFNoYWRlclNvdXJjZSArPQor ICAgICAgICAgICAgICAgICIgIC8vIEdyYWRpZW50c1xuIgorICAgICAgICAgICAgICAgICIgIHZl YzMgcHggPSBkRmR4KGtsbSk7XG4iCisgICAgICAgICAgICAgICAgIiAgdmVjMyBweSA9IGRGZHko a2xtKTtcbiIKKyAgICAgICAgICAgICAgICAiXG4iCisgICAgICAgICAgICAgICAgIiAgLy8gQ2hh aW4gcnVsZVxuIgorICAgICAgICAgICAgICAgICIgIGZsb2F0IGsyID0ga2xtLnggKiBrbG0ueDtc biIKKyAgICAgICAgICAgICAgICAiICBmbG9hdCBjID0gazIgKiBrbG0ueCAtIGtsbS55ICoga2xt Lno7XG4iCisgICAgICAgICAgICAgICAgIiAgZmxvYXQgazIzID0gMy4wICogazI7XG4iCisgICAg ICAgICAgICAgICAgIiAgZmxvYXQgY3ggPSBrMjMgKiBweC54IC0ga2xtLnogKiBweC55IC0ga2xt LnkgKiBweC56O1xuIgorICAgICAgICAgICAgICAgICIgIGZsb2F0IGN5ID0gazIzICogcHkueCAt IGtsbS56ICogcHkueSAtIGtsbS55ICogcHkuejtcbiIKKyAgICAgICAgICAgICAgICAiXG4iCisg ICAgICAgICAgICAgICAgIiAgLy8gU2lnbmVkIGRpc3RhbmNlXG4iCisgICAgICAgICAgICAgICAg IiAgZmxvYXQgc2QgPSBjIC8gc3FydChjeCAqIGN4ICsgY3kgKiBjeSk7XG4iCisgICAgICAgICAg ICAgICAgIlxuIgorICAgICAgICAgICAgICAgICIgIC8vIExpbmVhciBhbHBoYVxuIgorICAgICAg ICAgICAgICAgICIgIC8vIFRPRE8oa2JyKTogZmlndXJlIG91dCB3aHkgdGhpcyBuZWVkcyB0byBi ZVxuIgorICAgICAgICAgICAgICAgICIgIC8vIG5lZ2F0ZWQgY29tcGFyZWQgdG8gQ2cgdmVyc2lv biwgYW5kIGFsc28gd2h5XG4iCisgICAgICAgICAgICAgICAgIiAgLy8gd2UgbmVlZCBhbiBhZGp1 c3RtZW50IGJ5ICsxLjAgZm9yIGl0IHRvIGxvb2sgZ29vZC5cbiIKKyAgICAgICAgICAgICAgICAi ICAvLyBmbG9hdCBhbHBoYSA9IGNsYW1wKDAuNSAtIHNkLCAwLjAsIDEuMCk7XG4iCisgICAgICAg ICAgICAgICAgIiAgZmxvYXQgYWxwaGEgPSBjbGFtcChzZCArIDAuNSwgMC4wLCAxLjApO1xuIjsK KyAgICAgICAgZWxzZQorICAgICAgICAgICAgZnJhZ21lbnRTaGFkZXJTb3VyY2UgKz0KKyAgICAg ICAgICAgICAgICAiICBmbG9hdCB0ID0ga2xtLnggKiBrbG0ueCAqIGtsbS54IC0ga2xtLnkgKiBr bG0uejtcbiIKKyAgICAgICAgICAgICAgICAiICBmbG9hdCBhbHBoYSA9IGNsYW1wKHNpZ24odCks IDAuMCwgMS4wKTtcbiI7CisgICAgZnJhZ21lbnRTaGFkZXJTb3VyY2UgKz0gZmlsbC5zb3VyY2U7 CisgICAgZnJhZ21lbnRTaGFkZXJTb3VyY2UgKz0gIn1cbiI7CisgICAgdW5zaWduZWQgdmVydGV4 U2hhZGVyID0gY3JlYXRlU2hhZGVyRnJvbVNvdXJjZShHcmFwaGljc0NvbnRleHQzRDo6VkVSVEVY X1NIQURFUiwgdmVydGV4U2hhZGVyU291cmNlKTsKKyAgICB1bnNpZ25lZCBmcmFnbWVudFNoYWRl ciA9IGNyZWF0ZVNoYWRlckZyb21Tb3VyY2UoR3JhcGhpY3NDb250ZXh0M0Q6OkZSQUdNRU5UX1NI QURFUiwgZnJhZ21lbnRTaGFkZXJTb3VyY2UpOworICAgIGlmICghdmVydGV4U2hhZGVyIHx8ICFm cmFnbWVudFNoYWRlcikKKyAgICAgICAgcmV0dXJuIDA7CisgICAgdW5zaWduZWQgcHJvZ3JhbSA9 IG1fY29udGV4dC0+Y3JlYXRlUHJvZ3JhbSgpOworICAgIG1fY29udGV4dC0+YXR0YWNoU2hhZGVy KHByb2dyYW0sIHZlcnRleFNoYWRlcik7CisgICAgbV9jb250ZXh0LT5hdHRhY2hTaGFkZXIocHJv Z3JhbSwgZnJhZ21lbnRTaGFkZXIpOworICAgIG1fY29udGV4dC0+bGlua1Byb2dyYW0ocHJvZ3Jh bSk7CisgICAgaW50IGxpbmtTdGF0dXMgPSAwOworICAgIG1fY29udGV4dC0+Z2V0UHJvZ3JhbWl2 KHByb2dyYW0sIEdyYXBoaWNzQ29udGV4dDNEOjpMSU5LX1NUQVRVUywgJmxpbmtTdGF0dXMpOwor ICAgIGlmICghbGlua1N0YXR1cykgeworI2lmbmRlZiBOREVCVUcKKyAgICAgICAgU3RyaW5nIGxv ZyA9IG1fY29udGV4dC0+Z2V0UHJvZ3JhbUluZm9Mb2cocHJvZ3JhbSk7CisgICAgICAgIGZwcmlu dGYoc3RkZXJyLCAiU2hhZGVyQ2FjaGU6IGVycm9yIGxpbmtpbmcgcHJvZ3JhbTogJXNcbiIsIGxv Zy5hc2NpaSgpLmRhdGEoKSk7CisjZW5kaWYKKyAgICAgICAgcmV0dXJuIDA7CisgICAgfQorICAg IG1fY29udGV4dC0+ZGVsZXRlU2hhZGVyKHZlcnRleFNoYWRlcik7CisgICAgbV9jb250ZXh0LT5k ZWxldGVTaGFkZXIoZnJhZ21lbnRTaGFkZXIpOworICAgIHJldHVybiBhZG9wdFB0cihuZXcgU2hh ZGVyT2JqZWN0KG1fY29udGV4dCwgcHJvZ3JhbSkpOworfQorCitQbGF0Zm9ybTNET2JqZWN0IFNo YWRlckNhY2hlOjpjcmVhdGVTaGFkZXJGcm9tU291cmNlKEdyYXBoaWNzQ29udGV4dDNEOjpXZWJH TEVudW1UeXBlIHNoYWRlclR5cGUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIGNvbnN0IFN0cmluZyYgc291cmNlKQoreworICAgIHVuc2lnbmVk IHNoYWRlciA9IG1fY29udGV4dC0+Y3JlYXRlU2hhZGVyKHNoYWRlclR5cGUpOworICAgIG1fY29u dGV4dC0+c2hhZGVyU291cmNlKHNoYWRlciwgc291cmNlKTsKKyAgICBtX2NvbnRleHQtPmNvbXBp bGVTaGFkZXIoc2hhZGVyKTsKKyAgICBpbnQgY29tcGlsZVN0YXR1cyA9IDA7CisgICAgbV9jb250 ZXh0LT5nZXRTaGFkZXJpdihzaGFkZXIsIEdyYXBoaWNzQ29udGV4dDNEOjpDT01QSUxFX1NUQVRV UywgJmNvbXBpbGVTdGF0dXMpOworICAgIGlmICghY29tcGlsZVN0YXR1cykgeworI2lmbmRlZiBO REVCVUcKKyAgICAgICAgU3RyaW5nIGxvZyA9IG1fY29udGV4dC0+Z2V0U2hhZGVySW5mb0xvZyhz aGFkZXIpOworICAgICAgICBmcHJpbnRmKHN0ZGVyciwgIlNoYWRlckNhY2hlOiBlcnJvciBjb21w aWxpbmcgc2hhZGVyOiAlc1xuIiwgbG9nLmFzY2lpKCkuZGF0YSgpKTsKKyAgICAgICAgZnByaW50 ZihzdGRlcnIsICJzb3VyY2U6XG4lc1xuIiwgc291cmNlLmFzY2lpKCkuZGF0YSgpKTsKKyNlbmRp ZgorICAgICAgICByZXR1cm4gMDsKKyAgICB9CisgICAgcmV0dXJuIHNoYWRlcjsKK30KKworfSAv LyBuYW1lc3BhY2UgZ3B1Cit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCkluZGV4OiBXZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL2dwdS9TaGFkZXJDYWNoZS5oCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L1NoYWRlckNhY2hlLmgJKHJldmlzaW9uIDApCisrKyBXZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9TaGFkZXJDYWNoZS5oCShyZXZpc2lvbiAwKQpAQCAt MCwwICsxLDkxIEBACisvKgorICogQ29weXJpZ2h0IDIwMTAsIEdvb2dsZSBJbmMuCisgKiBBbGwg cmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNl IGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUg cGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorICog bWV0OgorICoKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJl dGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRp b25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlv bnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5cmlnaHQg bm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyCisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3Zp ZGVkIHdpdGggdGhlCisgKiBkaXN0cmlidXRpb24uCisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1l IG9mIEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisgKiBjb250cmlidXRvcnMgbWF5 IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorICog dGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4K KyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVS UyBBTkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVE IFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJ RUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBB UlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENP UFlSSUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVD VCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNF UVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9D VVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAq IERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVT RUQgQU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFD VCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9S IE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElT IFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFN QUdFLgorICovCisKKyNpZm5kZWYgZ3B1X1NoYWRlckNhY2hlX2gKKyNkZWZpbmUgZ3B1X1NoYWRl ckNhY2hlX2gKKworI2luY2x1ZGUgIkdyYXBoaWNzQ29udGV4dDNELmgiCisjaW5jbHVkZSA8d3Rm L05vbmNvcHlhYmxlLmg+CisjaW5jbHVkZSA8d3RmL093bkFycmF5UHRyLmg+CisjaW5jbHVkZSA8 d3RmL1Bhc3NPd25QdHIuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworbmFtZXNwYWNlIGdwdSB7 CisKK2NsYXNzIFNoYWRlck9iamVjdDsKKworLy8gVGhlIFNoYWRlckNhY2hlIGxhemlseSBnZW5l cmF0ZXMsIGxvYWRzIGFuZCBjYWNoZXMgdGhlIHNoYWRlcnMKKy8vIG5lZWRlZCB0byBmaWxsIHRo ZSB0cmlhbmdsZSBtZXNoZXMgZ2VuZXJhdGVkIGJ5IExvb3AgYW5kIEJsaW5uJ3MKKy8vIGFsZ29y aXRobS4KKworY2xhc3MgU2hhZGVyQ2FjaGUgOiBwdWJsaWMgTm9uY29weWFibGUgeworcHVibGlj OgorICAgIFNoYWRlckNhY2hlKEdyYXBoaWNzQ29udGV4dDNEKiBjb250ZXh0KTsKKworICAgIGVu dW0gU2hhZGVyVHlwZSB7CisgICAgICAgIFNvbGlkRmlsbCwKKyAgICAgICAgLy8gRklYTUU6IGFk ZCBtb3JlIHR5cGVzIG9mIHNoYWRlcnMgKGdyYWRpZW50cywgcGF0dGVybnMsIGV0Yy4pCisgICAg ICAgIE51bVNoYWRlclR5cGVzIC8vIE11c3QgYmUgbGFzdAorICAgIH07CisKKyAgICBlbnVtIFJl Z2lvblR5cGUgeworICAgICAgICBFeHRlcmlvciwgLy8gTG9vcCBhbmQgQmxpbm4ncyBzaGFkZXIK KyAgICAgICAgSW50ZXJpb3IsIC8vIFNvbGlkIGZpbGxlZCByZWdpb24KKyAgICAgICAgTnVtUmVn aW9uVHlwZXMgLy8gTXVzdCBiZSBsYXN0CisgICAgfTsKKworICAgIC8vIFRoaXMgb25seSBhZmZl Y3RzIHRoZSBleHRlcmlvciBzaGFkZXIuCisgICAgZW51bSBBbnRpYWxpYXNUeXBlIHsKKyAgICAg ICAgQW50aWFsaWFzZWQsCisgICAgICAgIE5vdEFudGlhbGlhc2VkLAorICAgICAgICBOdW1BbnRp YWxpYXNUeXBlcyAvLyBNdXN0IGJlIGxhc3QKKyAgICB9OworCisgICAgLy8gVGhlIFNoYWRlckNh Y2hlIG93bnMgdGhlIHJldHVybmVkIHBvaW50ZXIuCisgICAgU2hhZGVyT2JqZWN0KiBnZXRTaGFk ZXIoU2hhZGVyVHlwZSBzaGFkZXJUeXBlLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgIFJl Z2lvblR5cGUgcmVnaW9uVHlwZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBBbnRpYWxp YXNUeXBlIGFudGlhbGlhc1R5cGUpOworCitwcml2YXRlOgorICAgIFBhc3NPd25QdHI8U2hhZGVy T2JqZWN0PiBsb2FkU2hhZGVyKFNoYWRlclR5cGUgc2hhZGVyVHlwZSwKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBSZWdpb25UeXBlIHJlZ2lvblR5cGUsCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQW50aWFsaWFzVHlwZSBhbnRpYWxpYXNU eXBlKTsKKyAgICBQbGF0Zm9ybTNET2JqZWN0IGNyZWF0ZVNoYWRlckZyb21Tb3VyY2UoR3JhcGhp Y3NDb250ZXh0M0Q6OldlYkdMRW51bVR5cGUgc2hhZGVyVHlwZSwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgU3RyaW5nJiBzb3VyY2UpOworCisgICAg R3JhcGhpY3NDb250ZXh0M0QqIG1fY29udGV4dDsKKyAgICBPd25BcnJheVB0cjxPd25QdHI8U2hh ZGVyT2JqZWN0PiA+IG1fc2hhZGVyczsKK307CisKK30gLy8gbmFtZXNwYWNlIGdwdQorfSAvLyBu YW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gZ3B1X1NoYWRlckNhY2hlX2gKSW5kZXg6IFdl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L1NoYWRlck9iamVjdC5jcHAKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUvU2hhZGVyT2JqZWN0LmNwcAkocmV2aXNp b24gMCkKKysrIFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L1NoYWRlck9iamVjdC5jcHAJ KHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNzYgQEAKKy8qCisgKiBDb3B5cmlnaHQgMjAxMCwgR29v Z2xlIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24g YW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBt b2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNv bmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNv dXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqICAg ICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJv dmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhl ciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAgICAq IE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMKKyAq IGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMg ZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3Jp dHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhF IENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBF WFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1J VEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklU TkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBF VkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElB QkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVY RU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAq IExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7 IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBU SU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBX SEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVE SU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRI RSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lC SUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorCisjaW5j bHVkZSAiZ3B1L1NoYWRlck9iamVjdC5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CituYW1lc3Bh Y2UgZ3B1IHsKKworU2hhZGVyT2JqZWN0OjpTaGFkZXJPYmplY3QoR3JhcGhpY3NDb250ZXh0M0Qq IGNvbnRleHQsCisgICAgICAgICAgICAgICAgICAgICAgICAgICBQbGF0Zm9ybTNET2JqZWN0IHBy b2dyYW0pCisgICAgOiBtX2NvbnRleHQoY29udGV4dCkKKyAgICAsIG1fcHJvZ3JhbShwcm9ncmFt KQoreworfQorCit2b2lkIFNoYWRlck9iamVjdDo6dXNlKCkKK3sKKyAgICBtX2NvbnRleHQtPnVz ZVByb2dyYW0obV9wcm9ncmFtKTsKK30KKworbG9uZyBTaGFkZXJPYmplY3Q6OmdldFVuaWZvcm1M b2NhdGlvbihjb25zdCBTdHJpbmcmIG5hbWUpCit7CisgICAgSGFzaE1hcDxTdHJpbmcsIGxvbmc+ OjppdGVyYXRvciBpdGVyID0gbV91bmlmb3JtTG9jYXRpb25zLmZpbmQobmFtZSk7CisgICAgaWYg KGl0ZXIgPT0gbV91bmlmb3JtTG9jYXRpb25zLmVuZCgpKSB7CisgICAgICAgIC8vIExvb2sgaXQg dXAKKyAgICAgICAgbG9uZyBsb2NhdGlvbiA9IG1fY29udGV4dC0+Z2V0VW5pZm9ybUxvY2F0aW9u KG1fcHJvZ3JhbSwgbmFtZSk7CisgICAgICAgIG1fdW5pZm9ybUxvY2F0aW9ucy5hZGQobmFtZSwg bG9jYXRpb24pOworICAgICAgICByZXR1cm4gbG9jYXRpb247CisgICAgfQorICAgIHJldHVybiBp dGVyLT5zZWNvbmQ7Cit9CisKK2xvbmcgU2hhZGVyT2JqZWN0OjpnZXRBdHRyaWJMb2NhdGlvbihj b25zdCBTdHJpbmcmIG5hbWUpCit7CisgICAgSGFzaE1hcDxTdHJpbmcsIGxvbmc+OjppdGVyYXRv ciBpdGVyID0gbV9hdHRyaWJMb2NhdGlvbnMuZmluZChuYW1lKTsKKyAgICBpZiAoaXRlciA9PSBt X2F0dHJpYkxvY2F0aW9ucy5lbmQoKSkgeworICAgICAgICAvLyBMb29rIGl0IHVwCisgICAgICAg IGxvbmcgbG9jYXRpb24gPSBtX2NvbnRleHQtPmdldEF0dHJpYkxvY2F0aW9uKG1fcHJvZ3JhbSwg bmFtZSk7CisgICAgICAgIG1fYXR0cmliTG9jYXRpb25zLmFkZChuYW1lLCBsb2NhdGlvbik7Cisg ICAgICAgIHJldHVybiBsb2NhdGlvbjsKKyAgICB9CisgICAgcmV0dXJuIGl0ZXItPnNlY29uZDsK K30KKworfSAvLyBuYW1lc3BhY2UgZ3B1Cit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCkluZGV4OiBX ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9TaGFkZXJPYmplY3QuaAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9TaGFkZXJPYmplY3QuaAkocmV2aXNpb24g MCkKKysrIFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L1NoYWRlck9iamVjdC5oCShyZXZp c2lvbiAwKQpAQCAtMCwwICsxLDcxIEBACisvKgorICogQ29weXJpZ2h0IDIwMTAsIEdvb2dsZSBJ bmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1 c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZp Y2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRp b25zIGFyZQorICogbWV0OgorICoKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2Ug Y29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlz dCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBS ZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisg KiBjb3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxv d2luZyBkaXNjbGFpbWVyCisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0 ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCisgKiBkaXN0cmlidXRpb24uCisgKiAgICAgKiBOZWl0 aGVyIHRoZSBuYW1lIG9mIEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisgKiBjb250 cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2 ZWQgZnJvbQorICogdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4g cGVybWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZ UklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVT UyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBU TywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1Mg Rk9SCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQg U0hBTEwgVEhFIENPUFlSSUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBG T1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExB UlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1J VEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NT IE9GIFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikg SE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhF UiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBO RUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNF CisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZ IE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgZ3B1X1NoYWRlck9iamVjdF9oCisjZGVm aW5lIGdwdV9TaGFkZXJPYmplY3RfaAorCisjaW5jbHVkZSAiR3JhcGhpY3NDb250ZXh0M0QuaCIK KyNpbmNsdWRlICJQbGF0Zm9ybVN0cmluZy5oIgorI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+Cisj aW5jbHVkZSA8d3RmL05vbmNvcHlhYmxlLmg+CisjaW5jbHVkZSA8d3RmL3RleHQvU3RyaW5nSGFz aC5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CituYW1lc3BhY2UgZ3B1IHsKKworLy8gV3JhcHMg YW4gT3BlbkdMIHNoYWRlciAobW9yZSBwcmVjaXNlbHksIGEgcHJvZ3JhbSBvYmplY3QpIGFuZAor Ly8gcHJvdmlkZXMgYSBjYWNoZSBvZiBpdHMgdW5pZm9ybSBsb2NhdGlvbnMuCitjbGFzcyBTaGFk ZXJPYmplY3QgOiBwdWJsaWMgTm9uY29weWFibGUgeworcHVibGljOgorICAgIFNoYWRlck9iamVj dChHcmFwaGljc0NvbnRleHQzRCogY29udGV4dCwgUGxhdGZvcm0zRE9iamVjdCBwcm9ncmFtKTsK KworICAgIC8vIE1ha2VzIHRoaXMgcHJvZ3JhbSB0aGUgY3VycmVudCBvbmUgaW4gdGhlIGNvbnRl eHQuCisgICAgdm9pZCB1c2UoKTsKKworICAgIC8vIFJldHVybnMgdGhlIGxvY2F0aW9uIG9mIHRo ZSBnaXZlbiB1bmlmb3JtLCBvciAtMSBpZiBpdCBkb2VzIG5vdAorICAgIC8vIGV4aXN0IGluIHRo ZSBwcm9ncmFtLgorICAgIGxvbmcgZ2V0VW5pZm9ybUxvY2F0aW9uKGNvbnN0IFN0cmluZyYgbmFt ZSk7CisKKyAgICAvLyBSZXR1cm5zIHRoZSBsb2NhdGlvbiBvZiB0aGUgZ2l2ZW4gYXR0cmlidXRl LCBvciAtMSBpZiBpdCBkb2VzCisgICAgLy8gbm90IGV4aXN0IGluIHRoZSBwcm9ncmFtLgorICAg IGxvbmcgZ2V0QXR0cmliTG9jYXRpb24oY29uc3QgU3RyaW5nJiBuYW1lKTsKKworcHJpdmF0ZToK KyAgICBHcmFwaGljc0NvbnRleHQzRCogbV9jb250ZXh0OworICAgIFBsYXRmb3JtM0RPYmplY3Qg bV9wcm9ncmFtOworICAgIEhhc2hNYXA8U3RyaW5nLCBsb25nPiBtX3VuaWZvcm1Mb2NhdGlvbnM7 CisgICAgSGFzaE1hcDxTdHJpbmcsIGxvbmc+IG1fYXR0cmliTG9jYXRpb25zOworfTsKKworfSAv LyBuYW1lc3BhY2UgZ3B1Cit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBncHVf U2hhZGVyT2JqZWN0X2gK 65664 2010-08-26 19:40:06 -0700 2010-08-30 11:51:06 -0700 The PathProcessor, which implements the main algorithm path-processor.patch text/plain 61537 kbr SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA2NjE2OCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsOTUgQEAKKzIwMTAtMDgtMjYgIEtlbm5ldGggUnVzc2VsbCAgPGtickBnb29nbGUu Y29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFk ZCBzdXBwb3J0IGZvciBHUFUgYWNjZWxlcmF0ZWQgcGF0aCByZW5kZXJpbmcKKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ0NzI5CisKKyAgICAgICAgVGhp cyBpcyB0aGUgbWFpbiBhbGdvcml0aG0uIEl0IHRha2VzIGFzIGlucHV0IGEgUGF0aCB3aGljaCBt YXkKKyAgICAgICAgY29udGFpbiBvbmUgb3IgbW9yZSBjbG9zZWQgY29udG91cnMgaW5jbHVkaW5n IGhvbGVzLiBJdCBwcm9kdWNlcworICAgICAgICBhcyBvdXRwdXQgdHdvIHRyaWFuZ2xlIG1lc2hl cyB3aGljaCwgd2hlbiBkcmF3biBvbiB0aGUgR1BVLCByZW5kZXIKKyAgICAgICAgdGhlIGZpbGxl ZCBwYXRoLiBUaGUgbWVzaCBjYW4gYmUgdHJhbnNmb3JtZWQgYXJiaXRyYXJpbHkgd2l0aCBubwor ICAgICAgICByZS1wcm9jZXNzaW5nLCBhbmQgdGhlIHJlc3VsdGluZyBvbi1zY3JlZW4gY3VydmVz IG1haW50YWluCisgICAgICAgIHJlc29sdXRpb24gaW5kZXBlbmRlbmNlLgorCisgICAgICAgIFBh dGhQcm9jZXNzb3I6OnByb2Nlc3MgaXMgdGhlIG1haW4gZW50cnkgcG9pbnQsIGFuZCBzaG91bGQK KyAgICAgICAgaWxsdXN0cmF0ZSB0aGUgc3RlcHMgb2YgdGhlIGFsZ29yaXRobSBmYWlybHkgY2xl YXJseS4KKworICAgICAgICBUaGUgdHdvIHN0eWxlIHZpb2xhdGlvbnMgYXJlIHRoZSBzdHlsZSBv ZiB0aGUgaW5jbHVkZSBndWFyZHMsIHRoZQorICAgICAgICByZWFzb24gZm9yIHdoaWNoIGlzIGRl c2NyaWJlZCBpbiBhbiBlYXJsaWVyIHBhdGNoLCBhbmQgdGhlIHVzZSBvZgorICAgICAgICBzdHJl YW1zIGZvciBkZWJ1Zy1vbmx5IHByaW50aW5nLCB3aGljaCBjb3VsZCBiZSBjaGFuZ2VkIGlmIG5l Y2Vzc2FyeS4KKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2dwdTogQWRkZWQuCisgICAg ICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L1BhdGhQcm9jZXNzb3IuY3BwOiBBZGRlZC4KKyAg ICAgICAgKFdlYkNvcmU6OmdwdTo6bWluMik6CisgICAgICAgIChXZWJDb3JlOjpncHU6Om1heDIp OgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjptaW4zKToKKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6 bWF4Myk6CisgICAgICAgIChXZWJDb3JlOjpncHU6Om1pbjQpOgorICAgICAgICAoV2ViQ29yZTo6 Z3B1OjptYXg0KToKKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6QkJveDo6QkJveCk6CisgICAgICAg IChXZWJDb3JlOjpncHU6OkJCb3g6OnNldHVwKToKKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6QkJv eDo6ZXh0ZW5kKToKKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6QkJveDo6bWluWCk6CisgICAgICAg IChXZWJDb3JlOjpncHU6OkJCb3g6Om1pblkpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpCQm94 OjptYXhYKToKKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6QkJveDo6bWF4WSk6CisgICAgICAgIChX ZWJDb3JlOjpncHU6Om9wZXJhdG9yPDwpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpTZWdtZW50 OjopOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpTZWdtZW50OjpTZWdtZW50KToKKyAgICAgICAg KFdlYkNvcmU6OmdwdTo6U2VnbWVudDo6c2V0dXApOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpT ZWdtZW50OjpraW5kKToKKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6U2VnbWVudDo6Z2V0UG9pbnQp OgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpTZWdtZW50OjpuZXh0KToKKyAgICAgICAgKFdlYkNv cmU6OmdwdTo6U2VnbWVudDo6cHJldik6CisgICAgICAgIChXZWJDb3JlOjpncHU6OlNlZ21lbnQ6 OnNldE5leHQpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpTZWdtZW50OjpzZXRQcmV2KToKKyAg ICAgICAgKFdlYkNvcmU6OmdwdTo6U2VnbWVudDo6Y29udG91cik6CisgICAgICAgIChXZWJDb3Jl OjpncHU6OlNlZ21lbnQ6OnN1YmRpdmlkZSk6CisgICAgICAgIChXZWJDb3JlOjpncHU6OlNlZ21l bnQ6OmJib3gpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpTZWdtZW50OjpudW1Dcm9zc2luZ3NG b3JYUmF5KToKKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6U2VnbWVudDo6bnVtVHJpYW5nbGVzKToK KyAgICAgICAgKFdlYkNvcmU6OmdwdTo6U2VnbWVudDo6Z2V0VHJpYW5nbGUpOgorICAgICAgICAo V2ViQ29yZTo6Z3B1OjpTZWdtZW50OjpudW1JbnRlcmlvclZlcnRpY2VzKToKKyAgICAgICAgKFdl YkNvcmU6OmdwdTo6U2VnbWVudDo6Z2V0SW50ZXJpb3JWZXJ0ZXgpOgorICAgICAgICAoV2ViQ29y ZTo6Z3B1OjpTZWdtZW50OjptYXJrZWRGb3JTdWJkaXZpc2lvbik6CisgICAgICAgIChXZWJDb3Jl OjpncHU6OlNlZ21lbnQ6OnNldE1hcmtlZEZvclN1YmRpdmlzaW9uKToKKyAgICAgICAgKFdlYkNv cmU6OmdwdTo6U2VnbWVudDo6Y29tcHV0ZUJvdW5kaW5nQm94KToKKyAgICAgICAgKFdlYkNvcmU6 OmdwdTo6Q29udG91cjo6Q29udG91cik6CisgICAgICAgIChXZWJDb3JlOjpncHU6OkNvbnRvdXI6 OmFkZCk6CisgICAgICAgIChXZWJDb3JlOjpncHU6OkNvbnRvdXI6OnN1YmRpdmlkZSk6CisgICAg ICAgIChXZWJDb3JlOjpncHU6OkNvbnRvdXI6OmJlZ2luKToKKyAgICAgICAgKFdlYkNvcmU6Omdw dTo6Q29udG91cjo6ZW5kKToKKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6Q29udG91cjo6Y2N3KToK KyAgICAgICAgKFdlYkNvcmU6OmdwdTo6Q29udG91cjo6c2V0Q0NXKToKKyAgICAgICAgKFdlYkNv cmU6OmdwdTo6Q29udG91cjo6YmJveCk6CisgICAgICAgIChXZWJDb3JlOjpncHU6OkNvbnRvdXI6 OmZpbGxSaWdodFNpZGUpOgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpDb250b3VyOjpzZXRGaWxs UmlnaHRTaWRlKToKKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6U2VnbWVudDo6dHJpYW5ndWxhdGUp OgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpQYXRoUHJvY2Vzc29yOjpQYXRoUHJvY2Vzc29yKToK KyAgICAgICAgKFdlYkNvcmU6OmdwdTo6UGF0aFByb2Nlc3Nvcjo6flBhdGhQcm9jZXNzb3IpOgor ICAgICAgICAoV2ViQ29yZTo6Z3B1OjpQYXRoUHJvY2Vzc29yOjpwcm9jZXNzKToKKyAgICAgICAg KFdlYkNvcmU6OmdwdTo6UGF0aFByb2Nlc3Nvcjo6YnVpbGRDb250b3Vycyk6CisgICAgICAgIChX ZWJDb3JlOjpncHU6OlBhdGhQcm9jZXNzb3I6OmFsbFNlZ21lbnRzT3ZlcmxhcHBpbmdZKToKKyAg ICAgICAgKFdlYkNvcmU6OmdwdTo6UGF0aFByb2Nlc3Nvcjo6ZGV0ZXJtaW5lU2lkZXNUb0ZpbGwp OgorICAgICAgICAoV2ViQ29yZTo6Z3B1OjpQYXRoUHJvY2Vzc29yOjpkZXRlcm1pbmVPcmllbnRh dGlvbik6CisgICAgICAgIChXZWJDb3JlOjpncHU6OlN3ZWVwRGF0YTo6U3dlZXBEYXRhKToKKyAg ICAgICAgKFdlYkNvcmU6OmdwdTo6U3dlZXBFdmVudDo6U3dlZXBFdmVudCk6CisgICAgICAgIChX ZWJDb3JlOjpncHU6OlN3ZWVwRXZlbnQ6OnNldHVwKToKKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6 U3dlZXBFdmVudDo6eCk6CisgICAgICAgIChXZWJDb3JlOjpncHU6OlN3ZWVwRXZlbnQ6OmVudHJ5 KToKKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6U3dlZXBFdmVudDo6aW50ZXJ2YWwpOgorICAgICAg ICAoV2ViQ29yZTo6Z3B1OjpTd2VlcEV2ZW50OjpvcGVyYXRvcjwpOgorICAgICAgICAoV2ViQ29y ZTo6Z3B1Ojp0cmlhbmdsZXNPdmVybGFwKToKKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6UGF0aFBy b2Nlc3Nvcjo6c3ViZGl2aWRlQ3VydmVzKToKKyAgICAgICAgKFdlYkNvcmU6OmdwdTo6UGF0aFBy b2Nlc3Nvcjo6Y29uZGl0aW9uYWxseVN1YmRpdmlkZSk6CisgICAgICAgIChXZWJDb3JlOjpncHU6 OlBhdGhQcm9jZXNzb3I6OnN1YmRpdmlkZUN1cnZlc1Nsb3cpOgorICAgICAgICAoV2ViQ29yZTo6 Z3B1OjpWZXJ0ZXhDYWxsYmFjayk6CisgICAgICAgIChXZWJDb3JlOjpncHU6OkNvbWJpbmVDYWxs YmFjayk6CisgICAgICAgIChXZWJDb3JlOjpncHU6OkVkZ2VGbGFnQ2FsbGJhY2spOgorICAgICAg ICAoV2ViQ29yZTo6Z3B1OjpQYXRoUHJvY2Vzc29yOjp0ZXNzZWxsYXRlSW50ZXJpb3IpOgorICAg ICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2dwdS9QYXRoUHJvY2Vzc29yLmg6IEFkZGVkLgorCiAy MDEwLTA4LTI2ICBKYW1lcyBSb2JpbnNvbiAgPGphbWVzckBjaHJvbWl1bS5vcmc+CiAKICAgICAg ICAgQW5vdGhlciBjaHJvbWl1bSBtYWMgYnVpbGQgZml4LiBXaGF0IGEgZHVtYiB2ZXJzaW9uIG9m IEdDQy4KSW5kZXg6IFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L1BhdGhQcm9jZXNzb3Iu Y3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L1BhdGhQcm9j ZXNzb3IuY3BwCShyZXZpc2lvbiAwKQorKysgV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUv UGF0aFByb2Nlc3Nvci5jcHAJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMTQ1NyBAQAorLyoKKyAq IENvcHlyaWdodCAyMDEwLCBHb29nbGUgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAq CisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3 aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0 aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBS ZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHly aWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2lu ZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11 c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9m IGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3Vt ZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlz dHJpYnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3Ig dGhlIG5hbWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ug b3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91 dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FS RSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUwor ICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJ TkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVS Q0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJF IERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9S IENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVO VEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElO Q0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVU RSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBP UiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRI RU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFks IE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcg SU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBB RFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVk ZSAiY29uZmlnLmgiCisKKyNpbmNsdWRlICJncHUvUGF0aFByb2Nlc3Nvci5oIgorCisjaW5jbHVk ZSAiRmxvYXRQb2ludC5oIgorI2luY2x1ZGUgIlBhdGguaCIKKyNpbmNsdWRlICJncHUvQXJlbmEu aCIKKyNpbmNsdWRlICJncHUvQ3ViaWNDbGFzc2lmaWVyLmgiCisjaW5jbHVkZSAiZ3B1L0N1Ymlj TWF0aFV0aWxzLmgiCisjaW5jbHVkZSAiZ3B1L0N1YmljVGV4dHVyZUNvb3Jkcy5oIgorI2luY2x1 ZGUgImdwdS9JbnRlcnZhbFRyZWUuaCIKKyNpbmNsdWRlICJncHUvTG9jYWxUcmlhbmd1bGF0b3Iu aCIKKyNpbmNsdWRlICJncHUvUGF0aENhY2hlLmgiCisjaWYgUExBVEZPUk0oU0tJQSkKKyNpbmNs dWRlICJTa0dlb21ldHJ5LmgiCisjaW5jbHVkZSAiU2tQYXRoLmgiCisjaW5jbHVkZSAiU2tTY2Fs YXIuaCIKKyNlbHNlCisvLyBNdXN0IHBvcnQgdG8geW91ciBwbGF0Zm9ybS4KKyNlbmRpZgorI2lu Y2x1ZGUgPGFsZ29yaXRobT4KKyNpZm5kZWYgTkRFQlVHCisjaW5jbHVkZSA8aW9zdHJlYW0+Cisj ZW5kaWYKKyNpbmNsdWRlICJ0aGlyZHBhcnR5L2dsdS9pbnRlcm5hbF9nbHUuaCIKKyNpbmNsdWRl IDx3dGYvQXNzZXJ0aW9ucy5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CituYW1lc3BhY2UgZ3B1 IHsKKworY2xhc3MgQ29udG91cjsKKworLy8tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisvLyBtaW4gLyBtYXggaGVs cGVycworLy8KKwordGVtcGxhdGUgPHR5cGVuYW1lIFQ+CitUIG1pbjIoY29uc3QgVCYgdjEsIGNv bnN0IFQmIHYyKQoreworICAgIHJldHVybiBzdGQ6Om1pbih2MSwgdjIpOworfQorCit0ZW1wbGF0 ZSA8dHlwZW5hbWUgVD4KK1QgbWF4Mihjb25zdCBUJiB2MSwgY29uc3QgVCYgdjIpCit7CisgICAg cmV0dXJuIHN0ZDo6bWF4KHYxLCB2Mik7Cit9CisKK3RlbXBsYXRlIDx0eXBlbmFtZSBUPgorVCBt aW4zKGNvbnN0IFQmIHYxLCBjb25zdCBUJiB2MiwgY29uc3QgVCYgdjMpCit7CisgICAgcmV0dXJu IG1pbjIobWluMih2MSwgdjIpLCB2Myk7Cit9CisKK3RlbXBsYXRlIDx0eXBlbmFtZSBUPgorVCBt YXgzKGNvbnN0IFQmIHYxLCBjb25zdCBUJiB2MiwgY29uc3QgVCYgdjMpCit7CisgICAgcmV0dXJu IG1heDIobWF4Mih2MSwgdjIpLCB2Myk7Cit9CisKK3RlbXBsYXRlIDx0eXBlbmFtZSBUPgorVCBt aW40KGNvbnN0IFQmIHYxLCBjb25zdCBUJiB2MiwgY29uc3QgVCYgdjMsIGNvbnN0IFQmIHY0KQor eworICAgIHJldHVybiBtaW4yKG1pbjIodjEsIHYyKSwgbWluMih2MywgdjQpKTsKK30KKwordGVt cGxhdGUgPHR5cGVuYW1lIFQ+CitUIG1heDQoY29uc3QgVCYgdjEsIGNvbnN0IFQmIHYyLCBjb25z dCBUJiB2MywgY29uc3QgVCYgdjQpCit7CisgICAgcmV0dXJuIG1heDIobWF4Mih2MSwgdjIpLCBt YXgyKHYzLCB2NCkpOworfQorCisvLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKy8vIEJCb3gKKy8vCisKKy8vIEV4 dHJlbWVseSBzaW1wbGUgYm91bmRpbmcgYm94IGNsYXNzIGZvciBTZWdtZW50cyBhbmQgQ29udG91 cnMuCitjbGFzcyBCQm94IDogcHVibGljIE5vbmNvcHlhYmxlIHsKK3B1YmxpYzoKKyAgICBCQm94 KCkKKyAgICAgICAgOiBtX21pblgoMCkKKyAgICAgICAgLCBtX21pblkoMCkKKyAgICAgICAgLCBt X21heFgoMCkKKyAgICAgICAgLCBtX21heFkoMCkKKyAgICB7CisgICAgfQorCisgICAgLy8gSW5p dGlhbGl6ZXMgdGhlIHBhcmFtZXRlcnMgb2YgdGhlIGJvdW5kaW5nIGJveC4KKyAgICB2b2lkIHNl dHVwKGZsb2F0IG1pblgsCisgICAgICAgICAgICAgICBmbG9hdCBtaW5ZLAorICAgICAgICAgICAg ICAgZmxvYXQgbWF4WCwKKyAgICAgICAgICAgICAgIGZsb2F0IG1heFkpCisgICAgeworICAgICAg ICBtX21pblggPSBtaW5YOworICAgICAgICBtX21pblkgPSBtaW5ZOworICAgICAgICBtX21heFgg PSBtYXhYOworICAgICAgICBtX21heFkgPSBtYXhZOworICAgIH0KKworICAgIC8vIEluaXRpYWxp emVzIHRoZSBib3VuZGluZyBib3ggdG8gc3Vycm91bmQgdGhlIGdpdmVuIHRyaWFuZ2xlLgorICAg IHZvaWQgc2V0dXAoTG9jYWxUcmlhbmd1bGF0b3I6OlRyaWFuZ2xlKiB0cmlhbmdsZSkKKyAgICB7 CisgICAgICAgIHNldHVwKG1pbjModHJpYW5nbGUtPmdldFZlcnRleCgwKS0+eCgpLAorICAgICAg ICAgICAgICAgICAgIHRyaWFuZ2xlLT5nZXRWZXJ0ZXgoMSktPngoKSwKKyAgICAgICAgICAgICAg ICAgICB0cmlhbmdsZS0+Z2V0VmVydGV4KDIpLT54KCkpLAorICAgICAgICAgICAgICBtaW4zKHRy aWFuZ2xlLT5nZXRWZXJ0ZXgoMCktPnkoKSwKKyAgICAgICAgICAgICAgICAgICB0cmlhbmdsZS0+ Z2V0VmVydGV4KDEpLT55KCksCisgICAgICAgICAgICAgICAgICAgdHJpYW5nbGUtPmdldFZlcnRl eCgyKS0+eSgpKSwKKyAgICAgICAgICAgICAgbWF4Myh0cmlhbmdsZS0+Z2V0VmVydGV4KDApLT54 KCksCisgICAgICAgICAgICAgICAgICAgdHJpYW5nbGUtPmdldFZlcnRleCgxKS0+eCgpLAorICAg ICAgICAgICAgICAgICAgIHRyaWFuZ2xlLT5nZXRWZXJ0ZXgoMiktPngoKSksCisgICAgICAgICAg ICAgIG1heDModHJpYW5nbGUtPmdldFZlcnRleCgwKS0+eSgpLAorICAgICAgICAgICAgICAgICAg IHRyaWFuZ2xlLT5nZXRWZXJ0ZXgoMSktPnkoKSwKKyAgICAgICAgICAgICAgICAgICB0cmlhbmds ZS0+Z2V0VmVydGV4KDIpLT55KCkpKTsKKyAgICB9CisKKyAgICAvLyBJbml0aWFsaXplcyB0aGlz IGJvdW5kaW5nIGJveCB0byB0aGUgY29udGVudHMgb2YgdGhlIG90aGVyLgorICAgIHZvaWQgc2V0 dXAoY29uc3QgQkJveCYgYmJveCkKKyAgICB7CisgICAgICAgIG1fbWluWCA9IGJib3gubWluWCgp OworICAgICAgICBtX21pblkgPSBiYm94Lm1pblkoKTsKKyAgICAgICAgbV9tYXhYID0gYmJveC5t YXhYKCk7CisgICAgICAgIG1fbWF4WSA9IGJib3gubWF4WSgpOworICAgIH0KKworICAgIC8vIEV4 dGVuZHMgdGhpcyBib3VuZGluZyBib3ggdG8gc3Vycm91bmQgaXRzZWxmIGFuZCB0aGUgb3RoZXIu CisgICAgdm9pZCBleHRlbmQoY29uc3QgQkJveCYgb3RoZXIpCisgICAgeworICAgICAgICBzZXR1 cChtaW4yKG1pblgoKSwgb3RoZXIubWluWCgpKSwKKyAgICAgICAgICAgICAgbWluMihtaW5ZKCks IG90aGVyLm1pblkoKSksCisgICAgICAgICAgICAgIG1heDIobWF4WCgpLCBvdGhlci5tYXhYKCkp LAorICAgICAgICAgICAgICBtYXgyKG1heFkoKSwgb3RoZXIubWF4WSgpKSk7CisgICAgfQorCisg ICAgZmxvYXQgbWluWCgpIGNvbnN0CisgICAgeworICAgICAgICByZXR1cm4gbV9taW5YOworICAg IH0KKworICAgIGZsb2F0IG1pblkoKSBjb25zdAorICAgIHsKKyAgICAgICAgcmV0dXJuIG1fbWlu WTsKKyAgICB9CisKKyAgICBmbG9hdCBtYXhYKCkgY29uc3QKKyAgICB7CisgICAgICAgIHJldHVy biBtX21heFg7CisgICAgfQorCisgICAgZmxvYXQgbWF4WSgpIGNvbnN0CisgICAgeworICAgICAg ICByZXR1cm4gbV9tYXhZOworICAgIH0KKworcHJpdmF0ZToKKyAgICBmbG9hdCBtX21pblg7Cisg ICAgZmxvYXQgbV9taW5ZOworICAgIGZsb2F0IG1fbWF4WDsKKyAgICBmbG9hdCBtX21heFk7Cit9 OworCisjaWZuZGVmIE5ERUJVRworLy8gU3VwcHBvcnQgZm9yIGxvZ2dpbmcgQkJveGVzLgorc3Rk Ojpvc3RyZWFtJiBvcGVyYXRvcjw8KHN0ZDo6b3N0cmVhbSYgb3N0ciwKKyAgICAgICAgICAgICAg ICAgICAgICAgICBjb25zdCBCQm94JiBhcmcpCit7CisgICAgb3N0ciA8PCAiW0JCb3ggbWluWD0i IDw8IGFyZy5taW5YKCkKKyAgICAgICAgIDw8ICIgbWluWT0iIDw8IGFyZy5taW5ZKCkKKyAgICAg ICAgIDw8ICIgbWF4WD0iIDw8IGFyZy5tYXhYKCkKKyAgICAgICAgIDw8ICIgbWF4WT0iIDw8IGFy Zy5tYXhZKCkKKyAgICAgICAgIDw8ICJdIjsKKyAgICByZXR1cm4gb3N0cjsKK30KKyNlbmRpZgor CisvLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0KKy8vIFNlZ21lbnQKKy8vCisKKy8vIERlc2NyaWJlcyBhIHNlZ21l bnQgb2YgdGhlIHBhdGg6IGVpdGhlciBhIGN1YmljIG9yIGEgbGluZSBzZWdtZW50LgorLy8gVGhl c2UgYXJlIHN0b3JlZCBpbiBhIGRvdWJseSBsaW5rZWQgbGlzdCB0byBzcGVlZCB1cCBjdXJ2ZQor Ly8gc3ViZGl2aXNpb24sIHdoaWNoIG9jY3VycyBkdWUgdG8gZWl0aGVyIHJlbmRlcmluZyBhcnRp ZmFjdHMgaW4gdGhlCisvLyBsb29wIGNhc2Ugb3IgZHVlIHRvIG92ZXJsYXBwaW5nIHRyaWFuZ2xl cy4KK2NsYXNzIFNlZ21lbnQgOiBwdWJsaWMgTm9uY29weWFibGUgeworcHVibGljOgorICAgIC8v IFRoZSBraW5kIG9mIHNlZ21lbnQ6IGN1YmljIG9yIGxpbmUuCisgICAgZW51bSBLaW5kIHsKKyAg ICAgICAga0N1YmljLAorICAgICAgICBrTGluZQorICAgIH07CisKKyAgICAvLyBOby1hcmd1bWVu dCBjb25zdHJ1Y3RvciBhbGxvd3MgY29uc3RydWN0aW9uIGJ5IHRoZSBBcmVuYSBjbGFzcy4KKyAg ICBTZWdtZW50KCkKKyAgICAgICAgIDogbV9hcmVuYSgwKQorICAgICAgICAgLCBtX2tpbmQoa0N1 YmljKQorICAgICAgICAgLCBtX3ByZXYoMCkKKyAgICAgICAgICwgbV9uZXh0KDApCisgICAgICAg ICAsIG1fY29udG91cigwKQorICAgICAgICAgLCBtX3RyaWFuZ3VsYXRvcigwKQorICAgICAgICAg LCBtX21hcmtlZEZvclN1YmRpdmlzaW9uKGZhbHNlKQorICAgIHsKKyAgICB9CisKKyAgICAvLyBJ bml0aWFsaXplciBmb3IgY3ViaWMgY3VydmUgc2VnbWVudHMuCisgICAgdm9pZCBzZXR1cChBcmVu YSogYXJlbmEsCisgICAgICAgICAgICAgICBDb250b3VyKiBjb250b3VyLAorICAgICAgICAgICAg ICAgRmxvYXRQb2ludCBjcDAsCisgICAgICAgICAgICAgICBGbG9hdFBvaW50IGNwMSwKKyAgICAg ICAgICAgICAgIEZsb2F0UG9pbnQgY3AyLAorICAgICAgICAgICAgICAgRmxvYXRQb2ludCBjcDMp CisgICAgeworICAgICAgICBtX2FyZW5hID0gYXJlbmE7CisgICAgICAgIG1fY29udG91ciA9IGNv bnRvdXI7CisgICAgICAgIG1fa2luZCA9IGtDdWJpYzsKKyAgICAgICAgbV9wb2ludHNbMF0gPSBj cDA7CisgICAgICAgIG1fcG9pbnRzWzFdID0gY3AxOworICAgICAgICBtX3BvaW50c1syXSA9IGNw MjsKKyAgICAgICAgbV9wb2ludHNbM10gPSBjcDM7CisgICAgICAgIGNvbXB1dGVCb3VuZGluZ0Jv eCgpOworICAgIH0KKworICAgIC8vIEluaXRpYWxpemVyIGZvciBsaW5lIHNlZ21lbnRzLgorICAg IHZvaWQgc2V0dXAoQXJlbmEqIGFyZW5hLAorICAgICAgICAgICAgICAgQ29udG91ciogY29udG91 ciwKKyAgICAgICAgICAgICAgIEZsb2F0UG9pbnQgcDAsCisgICAgICAgICAgICAgICBGbG9hdFBv aW50IHAxKQorICAgIHsKKyAgICAgICAgbV9hcmVuYSA9IGFyZW5hOworICAgICAgICBtX2NvbnRv dXIgPSBjb250b3VyOworICAgICAgICBtX2tpbmQgPSBrTGluZTsKKyAgICAgICAgbV9wb2ludHNb MF0gPSBwMDsKKyAgICAgICAgbV9wb2ludHNbMV0gPSBwMTsKKyAgICAgICAgY29tcHV0ZUJvdW5k aW5nQm94KCk7CisgICAgfQorCisgICAgLy8gUmV0dXJucyB0aGUga2luZCBvZiBzZWdtZW50Lgor ICAgIEtpbmQga2luZCgpIGNvbnN0CisgICAgeworICAgICAgICByZXR1cm4gbV9raW5kOworICAg IH0KKworICAgIC8vIFJldHVybnMgdGhlIGkndGggY29udHJvbCBwb2ludCwgMCA8PSBpIDwgNC4K KyAgICBjb25zdCBGbG9hdFBvaW50JiBnZXRQb2ludChpbnQgaSkKKyAgICB7CisgICAgICAgIEFT U0VSVChpID49IDAgJiYgaSA8IDQpOworICAgICAgICByZXR1cm4gbV9wb2ludHNbaV07CisgICAg fQorCisgICAgLy8gUmV0dXJucyB0aGUgbmV4dCBzZWdtZW50IGluIHRoZSBjb250b3VyLgorICAg IFNlZ21lbnQqIG5leHQoKSBjb25zdAorICAgIHsKKyAgICAgICAgcmV0dXJuIG1fbmV4dDsKKyAg ICB9CisKKyAgICAvLyBSZXR1cm5zIHRoZSBwcmV2aW91cyBzZWdtZW50IGluIHRoZSBjb250b3Vy LgorICAgIFNlZ21lbnQqIHByZXYoKSBjb25zdAorICAgIHsKKyAgICAgICAgcmV0dXJuIG1fcHJl djsKKyAgICB9CisKKyAgICAvLyBTZXRzIHRoZSBuZXh0IHNlZ21lbnQgaW4gdGhlIGNvbnRvdXIu CisgICAgdm9pZCBzZXROZXh0KFNlZ21lbnQqIG5leHQpCisgICAgeworICAgICAgICBtX25leHQg PSBuZXh0OworICAgIH0KKworICAgIC8vIFNldHMgdGhlIHByZXZpb3VzIHNlZ21lbnQgaW4gdGhl IGNvbnRvdXIuCisgICAgdm9pZCBzZXRQcmV2KFNlZ21lbnQqIHByZXYpCisgICAgeworICAgICAg ICBtX3ByZXYgPSBwcmV2OworICAgIH0KKworICAgIC8vIFRoZSBjb250b3VyIHRoaXMgc2VnbWVu dCBiZWxvbmdzIHRvLgorICAgIENvbnRvdXIqIGNvbnRvdXIoKSBjb25zdAorICAgIHsKKyAgICAg ICAgcmV0dXJuIG1fY29udG91cjsKKyAgICB9CisKKyAgICAvLyBTdWJkaXZpZGVzIHRoZSBjdXJy ZW50IHNlZ21lbnQgYXQgdGhlIGdpdmVuIHBhcmFtZXRlciB2YWx1ZSAoMCA8PQorICAgIC8vIHQg PD0gMSkgYW5kIHJlcGxhY2VzIGl0IHdpdGggdGhlIHR3byBuZXdseSBjcmVhdGVkIFNlZ21lbnRz IGluCisgICAgLy8gdGhlIGxpbmtlZCBsaXN0LCBpZiBwb3NzaWJsZS4gUmV0dXJucyBhIHBvaW50 ZXIgdG8gdGhlIGxlZnRtb3N0CisgICAgLy8gU2VnbWVudC4KKyAgICBTZWdtZW50KiBzdWJkaXZp ZGUoZmxvYXQgcGFyYW0pCisgICAgeworICAgICAgICBGbG9hdFBvaW50IGRzdFs3XTsKKyAgICAg ICAgY2hvcEN1YmljQXQobV9wb2ludHMsIGRzdCwgcGFyYW0pOworICAgICAgICBTZWdtZW50KiBs ZWZ0ID0gbV9hcmVuYS0+YWxsb2M8U2VnbWVudD4oKTsKKyAgICAgICAgU2VnbWVudCogcmlnaHQg PSBtX2FyZW5hLT5hbGxvYzxTZWdtZW50PigpOworICAgICAgICBsZWZ0LT5zZXR1cChtX2FyZW5h LCBtX2NvbnRvdXIsIGRzdFswXSwgZHN0WzFdLCBkc3RbMl0sIGRzdFszXSk7CisgICAgICAgIHJp Z2h0LT5zZXR1cChtX2FyZW5hLCBtX2NvbnRvdXIsIGRzdFszXSwgZHN0WzRdLCBkc3RbNV0sIGRz dFs2XSk7CisgICAgICAgIGxlZnQtPnNldE5leHQocmlnaHQpOworICAgICAgICByaWdodC0+c2V0 UHJldihsZWZ0KTsKKyAgICAgICAgLy8gVHJ5IHRvIHNldCB1cCBhIGxpbmsgYmV0d2VlbiAidGhp cy0+cHJldigpIiBhbmQgImxlZnQiLgorICAgICAgICBpZiAocHJldigpKSB7CisgICAgICAgICAg ICBsZWZ0LT5zZXRQcmV2KHByZXYoKSk7CisgICAgICAgICAgICBwcmV2KCktPnNldE5leHQobGVm dCk7CisgICAgICAgIH0KKyAgICAgICAgLy8gVHJ5IHRvIHNldCB1cCBhIGxpbmsgYmV0d2VlbiAi dGhpcy0+bmV4dCgpIiBhbmQgInJpZ2h0Ii4KKyAgICAgICAgU2VnbWVudCogbiA9IG5leHQoKTsK KyAgICAgICAgaWYgKG4pIHsKKyAgICAgICAgICAgIHJpZ2h0LT5zZXROZXh0KG4pOworICAgICAg ICAgICAgbi0+c2V0UHJldihyaWdodCk7CisgICAgICAgIH0KKyAgICAgICAgLy8gU2V0IHVwIGEg bGluayBiZXR3ZWVuICJ0aGlzIiBhbmQgImxlZnQiOyB0aGlzIGlzIG9ubHkgdG8KKyAgICAgICAg Ly8gcHJvdmlkZSBhIGNlcnRhaW4gYW1vdW50IG9mIGNvbnRpbnVpdHkgZHVyaW5nIGZvcndhcmQg aXRlcmF0aW9uLgorICAgICAgICBzZXROZXh0KGxlZnQpOworICAgICAgICByZXR1cm4gbGVmdDsK KyAgICB9CisKKyAgICAvLyBTdWJkaXZpZGVzIHRoZSBjdXJyZW50IHNlZ21lbnQgYXQgdGhlIGhh bGZ3YXkgcG9pbnQgYW5kIHJlcGxhY2VzCisgICAgLy8gaXQgd2l0aCB0aGUgdHdvIG5ld2x5IGNy ZWF0ZWQgU2VnbWVudHMgaW4gdGhlIGxpbmtlZCBsaXN0LCBpZgorICAgIC8vIHBvc3NpYmxlLiBS ZXR1cm5zIGEgcG9pbnRlciB0byB0aGUgbGVmdG1vc3QgU2VnbWVudC4KKyAgICBTZWdtZW50KiBz dWJkaXZpZGUoKQorICAgIHsKKyAgICAgICAgcmV0dXJuIHN1YmRpdmlkZSgwLjVmKTsKKyAgICB9 CisKKyAgICAvLyBSZXR1cm5zIHRoZSBib3VuZGluZyBib3ggb2YgdGhpcyBzZWdtZW50LgorICAg IGNvbnN0IEJCb3gmIGJib3goKSBjb25zdAorICAgIHsKKyAgICAgICAgcmV0dXJuIG1fYmJveDsK KyAgICB9CisKKyAgICAvLyBDb21wdXRlcyB0aGUgbnVtYmVyIG9mIHRpbWVzIGEgcXVlcnkgbGlu ZSBzdGFydGluZyBhdCB0aGUgZ2l2ZW4KKyAgICAvLyBwb2ludCBhbmQgZXh0ZW5kaW5nIHRvIHg9 K2luZmluaXR5IGNyb3NzZXMgdGhpcyBzZWdtZW50LiBPdXRnb2luZworICAgIC8vICJhbWJpZ3Vv dXMiIGFyZ3VtZW50IGluZGljYXRlcyB3aGV0aGVyIHRoZSBxdWVyeSBpbnRlcnNlY3RlZCBhbgor ICAgIC8vIGVuZHBvaW50IG9yIHRhbmdlbnQgcG9pbnQgb2YgdGhlIHNlZ21lbnQsIGluZGljYXRp bmcgdGhhdCBhbm90aGVyCisgICAgLy8gcXVlcnkgcG9pbnQgaXMgcHJlZmVycmVkLgorICAgIGlu dCBudW1Dcm9zc2luZ3NGb3JYUmF5KEZsb2F0UG9pbnQgcHQsIGJvb2wqIGFtYmlndW91cykgY29u c3QKKyAgICB7CisgICAgICAgIGlmIChtX2tpbmQgPT0ga0N1YmljKQorICAgICAgICAgICAgLy8g U2hvdWxkIGNvbnNpZGVyIGNhY2hpbmcgdGhlIG1vbm90b25pYyBjdWJpY3MuCisgICAgICAgICAg ICByZXR1cm4gbnVtWFJheUNyb3NzaW5nc0ZvckN1YmljKHB0LCBtX3BvaW50cywgYW1iaWd1b3Vz KTsKKworICAgICAgICByZXR1cm4geFJheUNyb3NzZXNMaW5lKHB0LCBtX3BvaW50cywgYW1iaWd1 b3VzKSA/IDEgOiAwOworICAgIH0KKworICAgIC8vIFBlcmZvcm1zIGEgbG9jYWwgdHJpYW5ndWxh dGlvbiBvZiB0aGUgY29udHJvbCBwb2ludHMgaW4gdGhpcworICAgIC8vIHNlZ21lbnQuIFRoaXMg b3BlcmF0aW9uIG9ubHkgbWFrZXMgc2Vuc2UgZm9yIGN1YmljIHR5cGUgc2VnbWVudHMuCisgICAg dm9pZCB0cmlhbmd1bGF0ZShib29sIGNvbXB1dGVJbnNpZGVFZGdlcywKKyAgICAgICAgICAgICAg ICAgICAgIEN1YmljVGV4dHVyZUNvb3Jkczo6UmVzdWx0KiB0ZXhDb29yZHMpOworCisgICAgLy8g UmV0dXJucyB0aGUgbnVtYmVyIG9mIGNvbnRyb2wgcG9pbnQgdHJpYW5nbGVzIGFzc29jaWF0ZWQg d2l0aAorICAgIC8vIHRoaXMgc2VnbWVudC4KKyAgICBpbnQgbnVtVHJpYW5nbGVzKCkgY29uc3QK KyAgICB7CisgICAgICAgIGlmICghbV90cmlhbmd1bGF0b3IpCisgICAgICAgICAgICByZXR1cm4g MDsKKyAgICAgICAgcmV0dXJuIG1fdHJpYW5ndWxhdG9yLT5udW1UcmlhbmdsZXMoKTsKKyAgICB9 CisKKyAgICAvLyBGZXRjaGVzIHRoZSBnaXZlbiBjb250cm9sIHBvaW50IHRyaWFuZ2xlIGZvciB0 aGlzIHNlZ21lbnQuCisgICAgTG9jYWxUcmlhbmd1bGF0b3I6OlRyaWFuZ2xlKiBnZXRUcmlhbmds ZShpbnQgaW5kZXgpCisgICAgeworICAgICAgICBBU1NFUlQobV90cmlhbmd1bGF0b3IpOworICAg ICAgICByZXR1cm4gbV90cmlhbmd1bGF0b3ItPmdldFRyaWFuZ2xlKGluZGV4KTsKKyAgICB9CisK KyAgICAvLyBOdW1iZXIgb2YgdmVydGljZXMgYWxvbmcgdGhlIGluc2lkZSBlZGdlIG9mIHRoaXMg c2VnbWVudC4gVGhpcworICAgIC8vIGNhbiBiZSBjYWxsZWQgZWl0aGVyIGZvciBsaW5lIG9yIGN1 YmljIHR5cGUgc2VnbWVudHMuCisgICAgaW50IG51bUludGVyaW9yVmVydGljZXMoKSBjb25zdAor ICAgIHsKKyAgICAgICAgaWYgKG1fa2luZCA9PSBrQ3ViaWMpIHsKKyAgICAgICAgICAgIGlmICht X3RyaWFuZ3VsYXRvcikKKyAgICAgICAgICAgICAgICByZXR1cm4gbV90cmlhbmd1bGF0b3ItPm51 bUludGVyaW9yVmVydGljZXMoKTsKKworICAgICAgICAgICAgcmV0dXJuIDA7CisgICAgICAgIH0K KworICAgICAgICByZXR1cm4gMjsKKyAgICB9CisKKyAgICAvLyBSZXR1cm5zIHRoZSBnaXZlbiBp bnRlcmlvciB2ZXJ0ZXgsIDAgPD0gaW5kZXggPCBudW1JbnRlcmlvclZlcnRpY2VzKCkuCisgICAg RmxvYXRQb2ludCBnZXRJbnRlcmlvclZlcnRleChpbnQgaW5kZXgpIGNvbnN0CisgICAgeworICAg ICAgICBBU1NFUlQoaW5kZXggPj0gMCAmJiBpbmRleCA8IG51bUludGVyaW9yVmVydGljZXMoKSk7 CisgICAgICAgIGlmIChtX2tpbmQgPT0ga0N1YmljKSB7CisgICAgICAgICAgICBGbG9hdFBvaW50 IHJlczsKKyAgICAgICAgICAgIGlmIChtX3RyaWFuZ3VsYXRvcikgeworICAgICAgICAgICAgICAg IExvY2FsVHJpYW5ndWxhdG9yOjpWZXJ0ZXgqIHZlcnRleCA9IG1fdHJpYW5ndWxhdG9yLT5nZXRJ bnRlcmlvclZlcnRleChpbmRleCk7CisgICAgICAgICAgICAgICAgaWYgKHZlcnRleCkKKyAgICAg ICAgICAgICAgICAgICAgcmVzLnNldCh2ZXJ0ZXgtPngoKSwgdmVydGV4LT55KCkpOworICAgICAg ICAgICAgfQorICAgICAgICAgICAgcmV0dXJuIHJlczsKKyAgICAgICAgfQorCisgICAgICAgIHJl dHVybiBtX3BvaW50c1tpbmRleF07CisgICAgfQorCisgICAgLy8gU3RhdGUgdG8gYXNzaXN0IHdp dGggY3VydmUgc3ViZGl2aXNpb24uCisgICAgYm9vbCBtYXJrZWRGb3JTdWJkaXZpc2lvbigpIGNv bnN0CisgICAgeworICAgICAgICByZXR1cm4gbV9tYXJrZWRGb3JTdWJkaXZpc2lvbjsKKyAgICB9 CisKKyAgICAvLyBTdGF0ZSB0byBhc3Npc3Qgd2l0aCBjdXJ2ZSBzdWJkaXZpc2lvbi4KKyAgICB2 b2lkIHNldE1hcmtlZEZvclN1YmRpdmlzaW9uKGJvb2wgbWFya2VkRm9yU3ViZGl2aXNpb24pCisg ICAgeworICAgICAgICBtX21hcmtlZEZvclN1YmRpdmlzaW9uID0gbWFya2VkRm9yU3ViZGl2aXNp b247CisgICAgfQorCisgcHJpdmF0ZToKKyAgICAvLyBDb21wdXRlcyB0aGUgYm91bmRpbmcgYm94 IG9mIHRoaXMgU2VnbWVudC4KKyAgICB2b2lkIGNvbXB1dGVCb3VuZGluZ0JveCgpCisgICAgewor ICAgICAgICBzd2l0Y2ggKG1fa2luZCkgeworICAgICAgICBjYXNlIGtDdWJpYzoKKyAgICAgICAg ICAgIG1fYmJveC5zZXR1cChtaW40KG1fcG9pbnRzWzBdLngoKSwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIG1fcG9pbnRzWzFdLngoKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIG1fcG9pbnRzWzJdLngoKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1fcG9p bnRzWzNdLngoKSksCisgICAgICAgICAgICAgICAgICAgICAgICAgbWluNChtX3BvaW50c1swXS55 KCksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBtX3BvaW50c1sxXS55KCksCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBtX3BvaW50c1syXS55KCksCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBtX3BvaW50c1szXS55KCkpLAorICAgICAgICAgICAgICAgICAgICAg ICAgIG1heDQobV9wb2ludHNbMF0ueCgpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg bV9wb2ludHNbMV0ueCgpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbV9wb2ludHNb Ml0ueCgpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbV9wb2ludHNbM10ueCgpKSwK KyAgICAgICAgICAgICAgICAgICAgICAgICBtYXg0KG1fcG9pbnRzWzBdLnkoKSwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIG1fcG9pbnRzWzFdLnkoKSwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIG1fcG9pbnRzWzJdLnkoKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIG1fcG9pbnRzWzNdLnkoKSkpOworICAgICAgICAgICAgYnJlYWs7CisKKyAgICAgICAgY2Fz ZSBrTGluZToKKyAgICAgICAgICAgIG1fYmJveC5zZXR1cChtaW4yKG1fcG9pbnRzWzBdLngoKSwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1fcG9pbnRzWzFdLngoKSksCisgICAgICAg ICAgICAgICAgICAgICAgICAgbWluMihtX3BvaW50c1swXS55KCksCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBtX3BvaW50c1sxXS55KCkpLAorICAgICAgICAgICAgICAgICAgICAgICAg IG1heDIobV9wb2ludHNbMF0ueCgpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbV9w b2ludHNbMV0ueCgpKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICBtYXgyKG1fcG9pbnRzWzBd LnkoKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1fcG9pbnRzWzFdLnkoKSkpOwor ICAgICAgICAgICAgYnJlYWs7CisKKyAgICAgICAgZGVmYXVsdDoKKyAgICAgICAgICAgIEFTU0VS VF9OT1RfUkVBQ0hFRCgpOworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIH0KKyAgICB9CisK KyAgICBBcmVuYSogbV9hcmVuYTsKKyAgICBLaW5kIG1fa2luZDsKKyAgICBGbG9hdFBvaW50IG1f cG9pbnRzWzRdOworICAgIFNlZ21lbnQqIG1fcHJldjsKKyAgICBTZWdtZW50KiBtX25leHQ7Cisg ICAgQ29udG91ciogbV9jb250b3VyOworICAgIEJCb3ggbV9iYm94OworICAgIExvY2FsVHJpYW5n dWxhdG9yKiBtX3RyaWFuZ3VsYXRvcjsKKyAgICBib29sIG1fbWFya2VkRm9yU3ViZGl2aXNpb247 Cit9OworCisjaWZuZGVmIE5ERUJVRworLy8gU3VwcHBvcnQgZm9yIGxvZ2dpbmcgU2VnbWVudHMu CitzdGQ6Om9zdHJlYW0mIG9wZXJhdG9yPDwoc3RkOjpvc3RyZWFtJiBvc3RyLAorICAgICAgICAg ICAgICAgICAgICAgICAgIGNvbnN0IFNlZ21lbnQmIGFyZykKK3sKKyAgICBvc3RyIDw8ICJbU2Vn bWVudCBraW5kPSI7CisgICAgaWYgKGFyZy5raW5kKCkgPT0gU2VnbWVudDo6a0xpbmUpCisgICAg ICAgIG9zdHIgPDwgImxpbmUiOworICAgIGVsc2UKKyAgICAgICAgb3N0ciA8PCAiY3ViaWMiOwor ICAgIG9zdHIgPDwgIiBiYm94PSIgPDwgYXJnLmJib3goKTsKKyAgICBvc3RyIDw8ICIgY29udG91 cj0iIDw8IGFyZy5jb250b3VyKCk7CisgICAgb3N0ciA8PCAiIG1hcmtlZEZvclN1YmRpdmlzaW9u PSIgPDwgYXJnLm1hcmtlZEZvclN1YmRpdmlzaW9uKCkgPDwgIl0iOworICAgIHJldHVybiBvc3Ry OworfQorI2VuZGlmCisKKy8vLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorLy8gQ29udG91cgorLy8KKworLy8gRGVz Y3JpYmVzIGEgY2xvc2VkIGNvbnRvdXIgb2YgdGhlIHBhdGguCitjbGFzcyBDb250b3VyIDogcHVi bGljIE5vbmNvcHlhYmxlIHsKK3B1YmxpYzoKKyAgICBDb250b3VyKCkKKyAgICB7CisgICAgICAg IG1fZmlyc3QgPSAmbV9zZW50aW5lbDsKKyAgICAgICAgbV9maXJzdC0+c2V0TmV4dChtX2ZpcnN0 KTsKKyAgICAgICAgbV9maXJzdC0+c2V0UHJldihtX2ZpcnN0KTsKKyAgICAgICAgbV9jY3cgPSB0 cnVlOworICAgICAgICBtX2Jib3hEaXJ0eSA9IGZhbHNlOworICAgICAgICBtX2ZpbGxSaWdodFNp ZGUgPSB0cnVlOworICAgIH0KKworICAgIC8vIEFkZHMgYSBzZWdtZW50IHRvIHRoaXMgY29udG91 ci4KKyAgICB2b2lkIGFkZChTZWdtZW50KiBzZWdtZW50KQorICAgIHsKKyAgICAgICAgaWYgKG1f Zmlyc3QgPT0gJm1fc2VudGluZWwpIHsKKyAgICAgICAgICAgIC8vIEZpcnN0IGVsZW1lbnQgaXMg dGhlIHNlbnRpbmVsLiBSZXBsYWNlIGl0IHdpdGggdGhlIGluY29taW5nCisgICAgICAgICAgICAv LyBzZWdtZW50LgorICAgICAgICAgICAgc2VnbWVudC0+c2V0TmV4dChtX2ZpcnN0KTsKKyAgICAg ICAgICAgIHNlZ21lbnQtPnNldFByZXYobV9maXJzdCk7CisgICAgICAgICAgICBtX2ZpcnN0LT5z ZXROZXh0KHNlZ21lbnQpOworICAgICAgICAgICAgbV9maXJzdC0+c2V0UHJldihzZWdtZW50KTsK KyAgICAgICAgICAgIG1fZmlyc3QgPSBzZWdtZW50OworICAgICAgICB9IGVsc2UgeworICAgICAg ICAgICAgLy8gbV9maXJzdC0+cHJldigpIGlzIHRoZSBzZW50aW5lbC4KKyAgICAgICAgICAgIFNl Z21lbnQqIHNlbnRpbmVsID0gbV9maXJzdC0+cHJldigpOworICAgICAgICAgICAgU2VnbWVudCog bGFzdCA9IHNlbnRpbmVsLT5wcmV2KCk7CisgICAgICAgICAgICBsYXN0LT5zZXROZXh0KHNlZ21l bnQpOworICAgICAgICAgICAgc2VnbWVudC0+c2V0UHJldihsYXN0KTsKKyAgICAgICAgICAgIHNl Z21lbnQtPnNldE5leHQoc2VudGluZWwpOworICAgICAgICAgICAgc2VudGluZWwtPnNldFByZXYo c2VnbWVudCk7CisgICAgICAgIH0KKyAgICAgICAgbV9iYm94RGlydHkgPSB0cnVlOworICAgIH0K KworICAgIC8vIFN1YmRpdmlkZXMgdGhlIGdpdmVuIHNlZ21lbnQgYXQgdGhlIGdpdmVuIHBhcmFt ZXRyaWMgdmFsdWUuCisgICAgLy8gUmV0dXJucyBhIHBvaW50ZXIgdG8gdGhlIGZpcnN0IG9mIHRo ZSB0d28gcG9ydGlvbnMgb2YgdGhlCisgICAgLy8gc3ViZGl2aWRlZCBzZWdtZW50LgorICAgIFNl Z21lbnQqIHN1YmRpdmlkZShTZWdtZW50KiBzZWdtZW50LCBmbG9hdCBwYXJhbSkKKyAgICB7Cisg ICAgICAgIFNlZ21lbnQqIGxlZnQgPSBzZWdtZW50LT5zdWJkaXZpZGUocGFyYW0pOworICAgICAg ICBpZiAobV9maXJzdCA9PSBzZWdtZW50KQorICAgICAgICAgICAgbV9maXJzdCA9IGxlZnQ7Cisg ICAgICAgIHJldHVybiBsZWZ0OworICAgIH0KKworICAgIC8vIFN1YmRpdmlkZXMgdGhlIGdpdmVu IHNlZ21lbnQgYXQgdGhlIGhhbGZ3YXkgcG9pbnQuIFJldHVybnMgYQorICAgIC8vIHBvaW50ZXIg dG8gdGhlIGZpcnN0IG9mIHRoZSB0d28gcG9ydGlvbnMgb2YgdGhlIHN1YmRpdmlkZWQKKyAgICAv LyBzZWdtZW50LgorICAgIFNlZ21lbnQqIHN1YmRpdmlkZShTZWdtZW50KiBzZWdtZW50KQorICAg IHsKKyAgICAgICAgU2VnbWVudCogbGVmdCA9IHNlZ21lbnQtPnN1YmRpdmlkZSgpOworICAgICAg ICBpZiAobV9maXJzdCA9PSBzZWdtZW50KQorICAgICAgICAgICAgbV9maXJzdCA9IGxlZnQ7Cisg ICAgICAgIHJldHVybiBsZWZ0OworICAgIH0KKworICAgIC8vIFJldHVybnMgdGhlIGZpcnN0IHNl Z21lbnQgaW4gdGhlIGNvbnRvdXIgZm9yIGl0ZXJhdGlvbi4KKyAgICBTZWdtZW50KiBiZWdpbigp IGNvbnN0CisgICAgeworICAgICAgICByZXR1cm4gbV9maXJzdDsKKyAgICB9CisKKyAgICAvLyBS ZXR1cm5zIHRoZSBsYXN0IHNlZ21lbnQgaW4gdGhlIGNvbnRvdXIgZm9yIGl0ZXJhdGlvbi4gQ2Fs bGVycworICAgIC8vIHNob3VsZCBub3QgaXRlcmF0ZSBvdmVyIHRoaXMgc2VnbWVudC4gSW4gb3Ro ZXIgd29yZHM6CisgICAgLy8gIGZvciAoU2VnbWVudCogY3VyID0gY29udG91ci0+YmVnaW4oKTsK KyAgICAvLyAgICAgICBjdXIgIT0gY29udG91ci0+ZW5kKCk7CisgICAgLy8gICAgICAgY3VyID0g Y3VyLT5uZXh0KCkpIHsKKyAgICAvLyAgICAvLyAuLiBwcm9jZXNzIGN1ciAuLi4KKyAgICAvLyAg fQorICAgIFNlZ21lbnQqIGVuZCgpIGNvbnN0CisgICAgeworICAgICAgICByZXR1cm4gbV9maXJz dC0+cHJldigpOworICAgIH0KKworICAgIC8vIFJldHVybnMgd2hldGhlciB0aGlzIGNvbnRvdXIg aXMgb3JpZW50ZWQgY291bnRlcmNsb2Nrd2lzZS4KKyAgICBib29sIGNjdygpIGNvbnN0CisgICAg eworICAgICAgICByZXR1cm4gbV9jY3c7CisgICAgfQorCisgICAgdm9pZCBzZXRDQ1coYm9vbCBj Y3cpCisgICAgeworICAgICAgICBtX2NjdyA9IGNjdzsKKyAgICB9CisKKyAgICAvLyBSZXR1cm5z IHRoZSBib3VuZGluZyBib3ggb2YgdGhpcyBjb250b3VyLgorICAgIGNvbnN0IEJCb3gmIGJib3go KSBjb25zdAorICAgIHsKKyAgICAgICAgaWYgKG1fYmJveERpcnR5KSB7CisgICAgICAgICAgICBi b29sIGZpcnN0ID0gdHJ1ZTsKKyAgICAgICAgICAgIGZvciAoU2VnbWVudCogY3VyID0gYmVnaW4o KTsgY3VyICE9IGVuZCgpOyBjdXIgPSBjdXItPm5leHQoKSkgeworICAgICAgICAgICAgICAgIGlm IChmaXJzdCkKKyAgICAgICAgICAgICAgICAgICAgbV9iYm94LnNldHVwKGN1ci0+YmJveCgpKTsK KyAgICAgICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAgICAgIG1fYmJveC5leHRlbmQo Y3VyLT5iYm94KCkpOworICAgICAgICAgICAgICAgIGZpcnN0ID0gZmFsc2U7CisgICAgICAgICAg ICB9CisKKyAgICAgICAgICAgIG1fYmJveERpcnR5ID0gZmFsc2U7CisgICAgICAgIH0KKyAgICAg ICAgcmV0dXJuIG1fYmJveDsKKyAgICB9CisKKyAgICAvLyBSZXR1cm5zIHdoZXRoZXIgdGhlIHJp Z2h0IHNpZGUgb2YgdGhpcyBjb250b3VyIGlzIGZpbGxlZC4KKyAgICBib29sIGZpbGxSaWdodFNp ZGUoKSBjb25zdAorICAgIHsKKyAgICAgICAgcmV0dXJuIG1fZmlsbFJpZ2h0U2lkZTsKKyAgICB9 CisKKyAgICB2b2lkIHNldEZpbGxSaWdodFNpZGUoYm9vbCBmaWxsUmlnaHRTaWRlKQorICAgIHsK KyAgICAgICAgbV9maWxsUmlnaHRTaWRlID0gZmlsbFJpZ2h0U2lkZTsKKyAgICB9CisKK3ByaXZh dGU6CisgICAgLy8gVGhlIHN0YXJ0IG9mIHRoZSBzZWdtZW50IGNoYWluLiBUaGUgc2VnbWVudHMg YXJlIGtlcHQgaW4gYQorICAgIC8vIGNpcmN1bGFyIGRvdWJseSBsaW5rZWQgbGlzdCBmb3IgcmFw aWQgYWNjZXNzIHRvIHRoZSBiZWdpbm5pbmcgYW5kCisgICAgLy8gZW5kLgorICAgIFNlZ21lbnQq IG1fZmlyc3Q7CisKKyAgICAvLyBUaGUgc2VudGluZWwgZWxlbWVudCBhdCB0aGUgZW5kIG9mIHRo ZSBjaGFpbiwgbmVlZGVkIGZvcgorICAgIC8vIHJlYXNvbmFibGUgaXRlcmF0aW9uIHNlbWFudGlj cy4KKyAgICBTZWdtZW50IG1fc2VudGluZWw7CisKKyAgICAvLyBXaGV0aGVyIHRoaXMgY29udG91 ciBpcyBvcmllbnRlZCBjb3VudGVyY2xvY2t3aXNlLgorICAgIGJvb2wgbV9jY3c7CisKKyAgICAv LyBUaGlzIGNvbnRvdXIncyBib3VuZGluZyBib3guCisgICAgbXV0YWJsZSBCQm94IG1fYmJveDsK KworICAgIC8vIFdoZXRoZXIgdGhpcyBjb250b3VyJ3MgYm91bmRpbmcgYm94IGlzIGRpcnR5Lgor ICAgIG11dGFibGUgYm9vbCBtX2Jib3hEaXJ0eTsKKworICAgIC8vIFdoZXRoZXIgd2Ugc2hvdWxk IGZpbGwgdGhlIHJpZ2h0IChvciBsZWZ0KSBzaWRlIG9mIHRoaXMgY29udG91ci4KKyAgICBib29s IG1fZmlsbFJpZ2h0U2lkZTsKK307CisKKy8vLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorLy8gU2VnbWVudAorLy8K KworLy8gRGVmaW5pdGlvbiBvZiBTZWdtZW50Ojp0cmlhbmd1bGF0ZSgpLCB3aGljaCBtdXN0IGNv bWUgYWZ0ZXIKKy8vIGRlY2xhcmF0aW9uIG9mIENvbnRvdXIuCit2b2lkIFNlZ21lbnQ6OnRyaWFu Z3VsYXRlKGJvb2wgY29tcHV0ZUluc2lkZUVkZ2VzLAorICAgICAgICAgICAgICAgICAgICAgICAg ICBDdWJpY1RleHR1cmVDb29yZHM6OlJlc3VsdCogdGV4Q29vcmRzKQoreworICAgIEFTU0VSVCht X2tpbmQgPT0ga0N1YmljKTsKKyAgICBpZiAoIW1fdHJpYW5ndWxhdG9yKQorICAgICAgICBtX3Ry aWFuZ3VsYXRvciA9IG1fYXJlbmEtPmFsbG9jPExvY2FsVHJpYW5ndWxhdG9yPigpOworICAgIG1f dHJpYW5ndWxhdG9yLT5yZXNldCgpOworICAgIGZvciAoaW50IGkgPSAwOyBpIDwgNDsgaSsrKSB7 CisgICAgICAgIExvY2FsVHJpYW5ndWxhdG9yOjpWZXJ0ZXgqIHZlcnRleCA9IG1fdHJpYW5ndWxh dG9yLT5nZXRWZXJ0ZXgoaSk7CisgICAgICAgIGlmICh0ZXhDb29yZHMpCisgICAgICAgICAgICB2 ZXJ0ZXgtPnNldChnZXRQb2ludChpKS54KCksCisgICAgICAgICAgICAgICAgICAgICAgICBnZXRQ b2ludChpKS55KCksCisgICAgICAgICAgICAgICAgICAgICAgICB0ZXhDb29yZHMtPmNvb3Jkc1tp XS54KCksCisgICAgICAgICAgICAgICAgICAgICAgICB0ZXhDb29yZHMtPmNvb3Jkc1tpXS55KCks CisgICAgICAgICAgICAgICAgICAgICAgICB0ZXhDb29yZHMtPmNvb3Jkc1tpXS56KCkpOworICAg ICAgICBlbHNlCisgICAgICAgICAgICB2ZXJ0ZXgtPnNldChnZXRQb2ludChpKS54KCksCisgICAg ICAgICAgICAgICAgICAgICAgICBnZXRQb2ludChpKS55KCksCisgICAgICAgICAgICAgICAgICAg ICAgICAvLyBObyB0ZXh0dXJlIGNvb3JkaW5hdGVzIHlldAorICAgICAgICAgICAgICAgICAgICAg ICAgMCwgMCwgMCk7CisgICAgfQorICAgIG1fdHJpYW5ndWxhdG9yLT50cmlhbmd1bGF0ZShjb21w dXRlSW5zaWRlRWRnZXMsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnRvdXIo KS0+ZmlsbFJpZ2h0U2lkZSgpKTsKK30KKworLy8tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisvLyBQYXRoUHJvY2Vz c29yCisvLworCitQYXRoUHJvY2Vzc29yOjpQYXRoUHJvY2Vzc29yKCkKKyAgICA6IG1fYXJlbmEo QXJlbmE6OmNyZWF0ZSgpKQorI2lmbmRlZiBOREVCVUcKKyAgICAsIG1fdmVyYm9zZUxvZ2dpbmco ZmFsc2UpCisjZW5kaWYKK3sKK30KKworUGF0aFByb2Nlc3Nvcjo6UGF0aFByb2Nlc3NvcihBcmVu YSogYXJlbmEpCisgICAgOiBtX2FyZW5hKGFyZW5hKQorI2lmbmRlZiBOREVCVUcKKyAgICAsIG1f dmVyYm9zZUxvZ2dpbmcoZmFsc2UpCisjZW5kaWYKK3sKK30KKworUGF0aFByb2Nlc3Nvcjo6flBh dGhQcm9jZXNzb3IoKQoreworfQorCit2b2lkIFBhdGhQcm9jZXNzb3I6OnByb2Nlc3MoY29uc3Qg UGF0aCYgcGF0aCwgUGF0aENhY2hlKiBjYWNoZSkKK3sKKyAgICBidWlsZENvbnRvdXJzKHBhdGgp OworCisgICAgLy8gUnVuIHBsYW5lLXN3ZWVwIGFsZ29yaXRobSB0byBkZXRlcm1pbmUgb3Zlcmxh cHMgb2YgY29udHJvbCBwb2ludAorICAgIC8vIGN1cnZlcyBhbmQgc3ViZGl2aWRlIGN1cnZlcyBh cHByb3ByaWF0ZWx5LgorICAgIHN1YmRpdmlkZUN1cnZlcygpOworCisgICAgLy8gRGV0ZXJtaW5l IG9yaWVudGF0aW9ucyBvZiBjb3VudG91cnMuIEJhc2VkIG9uIG9yaWVudGF0aW9uIGFuZCB0aGUK KyAgICAvLyBudW1iZXIgb2YgY3VydmUgY3Jvc3NpbmdzIGF0IGEgcmFuZG9tIHBvaW50IG9uIHRo ZSBjb250b3VyLAorICAgIC8vIGRldGVybWluZSB3aGV0aGVyIHRvIGZpbGwgdGhlIGxlZnQgb3Ig cmlnaHQgc2lkZSBvZiB0aGUgY29udG91ci4KKyAgICBkZXRlcm1pbmVTaWRlc1RvRmlsbCgpOwor CisgICAgLy8gQ2xhc3NpZnkgY3VydmVzLCBjb21wdXRlIHRleHR1cmUgY29vcmRpbmF0ZXMgYW5k IHN1YmRpdmlkZSBhcworICAgIC8vIG5lY2Vzc2FyeSB0byBlbGltaW5hdGUgcmVuZGVyaW5nIGFy dGlmYWN0cy4gRG8gdGhlIGZpbmFsCisgICAgLy8gdHJpYW5ndWxhdGlvbiBvZiB0aGUgY3VydmUg c2VnbWVudHMsIGRldGVybWluaW5nIHRoZSBwYXRoIGFsb25nCisgICAgLy8gdGhlIGludGVyaW9y IG9mIHRoZSBzaGFwZS4KKyAgICBmb3IgKFZlY3RvcjxDb250b3VyKj46Oml0ZXJhdG9yIGl0ZXIg PSBtX2NvbnRvdXJzLmJlZ2luKCk7CisgICAgICAgICBpdGVyICE9IG1fY29udG91cnMuZW5kKCk7 CisgICAgICAgICBpdGVyKyspIHsKKyAgICAgICAgQ29udG91ciogY3VyID0gKml0ZXI7CisgICAg ICAgIGZvciAoU2VnbWVudCogc2VnID0gY3VyLT5iZWdpbigpOyBzZWcgIT0gY3VyLT5lbmQoKTsg c2VnID0gc2VnLT5uZXh0KCkpIHsKKyAgICAgICAgICAgIGlmIChzZWctPmtpbmQoKSA9PSBTZWdt ZW50OjprQ3ViaWMpIHsKKyAgICAgICAgICAgICAgICBDdWJpY0NsYXNzaWZpZXI6OlJlc3VsdCBj bGFzc2lmaWNhdGlvbiA9IEN1YmljQ2xhc3NpZmllcjo6Y2xhc3NpZnkoc2VnLT5nZXRQb2ludCgw KS54KCksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNlZy0+Z2V0UG9pbnQoMCkueSgpLAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBzZWctPmdldFBvaW50KDEpLngoKSwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgc2VnLT5nZXRQb2ludCgxKS55KCksCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHNlZy0+Z2V0UG9pbnQoMikueCgpLAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBzZWctPmdldFBvaW50KDIpLnkoKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc2VnLT5n ZXRQb2ludCgzKS54KCksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNlZy0+Z2V0UG9pbnQo MykueSgpKTsKKyNpZm5kZWYgTkRFQlVHCisgICAgICAgICAgICAgICAgaWYgKG1fdmVyYm9zZUxv Z2dpbmcpCisgICAgICAgICAgICAgICAgICAgIHN0ZDo6Y2VyciA8PCAiQ2xhc3NpZmljYXRpb246 IiA8PCBjbGFzc2lmaWNhdGlvbi5jdXJ2ZVR5cGUoKSA8PCBzdGQ6OmVuZGw7CisjZW5kaWYKKyAg ICAgICAgICAgICAgICBDdWJpY1RleHR1cmVDb29yZHM6OlJlc3VsdCB0ZXhDb29yZHM7CisgICAg ICAgICAgICAgICAgQ3ViaWNUZXh0dXJlQ29vcmRzOjpDb21wdXRlKGNsYXNzaWZpY2F0aW9uLAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjdXItPmZpbGxSaWdo dFNpZGUoKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJnRl eENvb3Jkcyk7CisgICAgICAgICAgICAgICAgaWYgKHRleENvb3Jkcy5oYXNSZW5kZXJpbmdBcnRp ZmFjdCkgeworICAgICAgICAgICAgICAgICAgICAvLyBGSVhNRTogc3BsaXQgYXQgdGhlIHN1YmRp dmlzaW9uIHBhcmFtZXRlciB2YWx1ZQorICAgICAgICAgICAgICAgICAgICBjdXItPnN1YmRpdmlk ZShzZWcpOworICAgICAgICAgICAgICAgICAgICAvLyBOZXh0IGl0ZXJhdGlvbiB3aWxsIGhhbmRs ZSB0aGUgbmV3bHkgc3ViZGl2aWRlZCBoYWx2ZXMKKyAgICAgICAgICAgICAgICB9IGVsc2Ugewor ICAgICAgICAgICAgICAgICAgICBpZiAoIXRleENvb3Jkcy5pc0xpbmVPclBvaW50KSB7CisgICAg ICAgICAgICAgICAgICAgICAgICBzZWctPnRyaWFuZ3VsYXRlKHRydWUsICZ0ZXhDb29yZHMpOwor ICAgICAgICAgICAgICAgICAgICAgICAgZm9yIChpbnQgaSA9IDA7IGkgPCBzZWctPm51bVRyaWFu Z2xlcygpOyBpKyspIHsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBMb2NhbFRyaWFuZ3Vs YXRvcjo6VHJpYW5nbGUqIHRyaWFuZ2xlID0gc2VnLT5nZXRUcmlhbmdsZShpKTsKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICBmb3IgKGludCBqID0gMDsgaiA8IDM7IGorKykgeworICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBMb2NhbFRyaWFuZ3VsYXRvcjo6VmVydGV4KiB2ZXJ0 ID0gdHJpYW5nbGUtPmdldFZlcnRleChqKTsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgY2FjaGUtPmFkZFZlcnRleCh2ZXJ0LT54KCksCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgdmVydC0+eSgpLAorICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIHZlcnQtPmsoKSwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB2ZXJ0LT5sKCksCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdmVydC0+bSgpKTsKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgICAgICAgICB9CisjaWZkZWYg R1BVX1BBVEhfQ0FDSEVfREVCVUdfSU5URVJJT1JfRURHRVMKKyAgICAgICAgICAgICAgICAgICAg ICAgIC8vIFNob3cgdGhlIGVuZCB1c2VyIHRoZSBpbnRlcmlvciBlZGdlcyBhcyB3ZWxsCisgICAg ICAgICAgICAgICAgICAgICAgICBmb3IgKGludCBpID0gMTsgaSA8IHNlZy0+bnVtSW50ZXJpb3JW ZXJ0aWNlcygpOyBpKyspIHsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBGbG9hdFBvaW50 IHZlcnQgPSBzZWctPmdldEludGVyaW9yVmVydGV4KGkpOworICAgICAgICAgICAgICAgICAgICAg ICAgICAgIC8vIER1cGxpY2F0ZSBwcmV2aW91cyB2ZXJ0ZXggdG8gYmUgYWJsZSB0byBkcmF3IEdM X0xJTkVTCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgRmxvYXRQb2ludCBwcmV2ID0gc2Vn LT5nZXRJbnRlcmlvclZlcnRleChpIC0gMSk7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAg Y2FjaGUtPmFkZEludGVyaW9yRWRnZVZlcnRleChwcmV2LngoKSwgcHJldi55KCkpOworICAgICAg ICAgICAgICAgICAgICAgICAgICAgIGNhY2hlLT5hZGRJbnRlcmlvckVkZ2VWZXJ0ZXgodmVydC54 KCksIHZlcnQueSgpKTsKKyAgICAgICAgICAgICAgICAgICAgICAgIH0KKyNlbmRpZiAvLyBHUFVf UEFUSF9DQUNIRV9ERUJVR19JTlRFUklPUl9FREdFUworICAgICAgICAgICAgICAgICAgICB9Cisg ICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgfQorCisgICAg Ly8gUnVuIHRoZSBpbnRlcmlvciBwYXRocyB0aHJvdWdoIGEgdGVzc2VsbGF0aW9uIGFsZ29yaXRo bQorICAgIC8vIHN1cHBvcnRpbmcgbXVsdGlwbGUgY29udG91cnMuCisgICAgdGVzc2VsbGF0ZUlu dGVyaW9yKGNhY2hlKTsKK30KKwordm9pZCBQYXRoUHJvY2Vzc29yOjpidWlsZENvbnRvdXJzKGNv bnN0IFBhdGgmIHBhdGgpCit7CisgICAgLy8gQ2xlYXIgb3V0IHRoZSBjb250b3VycworICAgIG1f Y29udG91cnMuY2xlYXIoKTsKKyNpZiBQTEFURk9STShTS0lBKQorICAgIFNrUGF0aDo6SXRlciBp dGVyKCpwYXRoLnBsYXRmb3JtUGF0aCgpLCBmYWxzZSk7CisgICAgU2tQb2ludCBwb2ludHNbNF07 CisgICAgU2tQYXRoOjpWZXJiIHZlcmI7CisgICAgQ29udG91ciogY29udG91ciA9IDA7CisgICAg U2tQb2ludCBjdXJQb2ludCA9IHsgMCB9OworICAgIFNrUG9pbnQgbW92ZVRvUG9pbnQgPSB7IDAg fTsKKyAgICBkbyB7CisgICAgICAgIHZlcmIgPSBpdGVyLm5leHQocG9pbnRzKTsKKyAgICAgICAg aWYgKHZlcmIgIT0gU2tQYXRoOjprTW92ZV9WZXJiKSB7CisgICAgICAgICAgICBpZiAoIWNvbnRv dXIpIHsKKyAgICAgICAgICAgICAgICBjb250b3VyID0gbV9hcmVuYS0+YWxsb2M8Q29udG91cj4o KTsKKyAgICAgICAgICAgICAgICBtX2NvbnRvdXJzLmFwcGVuZChjb250b3VyKTsKKyAgICAgICAg ICAgIH0KKyAgICAgICAgfQorICAgICAgICBzd2l0Y2ggKHZlcmIpIHsKKyAgICAgICAgY2FzZSBT a1BhdGg6OmtNb3ZlX1ZlcmI6IHsKKyAgICAgICAgICAgIGNvbnRvdXIgPSBtX2FyZW5hLT5hbGxv YzxDb250b3VyPigpOworICAgICAgICAgICAgbV9jb250b3Vycy5hcHBlbmQoY29udG91cik7Cisg ICAgICAgICAgICBjdXJQb2ludCA9IHBvaW50c1swXTsKKyAgICAgICAgICAgIG1vdmVUb1BvaW50 ID0gcG9pbnRzWzBdOworI2lmbmRlZiBOREVCVUcKKyAgICAgICAgICAgIGlmIChtX3ZlcmJvc2VM b2dnaW5nKQorICAgICAgICAgICAgICAgIHN0ZDo6Y2VyciA8PCAiTW92ZVRvICgiIDw8IHBvaW50 c1swXS5mWAorICAgICAgICAgICAgICAgICAgICAgICAgICA8PCAiLCAiIDw8IHBvaW50c1swXS5m WSA8PCAiKSIgPDwgc3RkOjplbmRsOworI2VuZGlmCisgICAgICAgICAgICBicmVhazsKKyAgICAg ICAgfQorICAgICAgICBjYXNlIFNrUGF0aDo6a0xpbmVfVmVyYjogeworICAgICAgICAgICAgU2Vn bWVudCogc2VnbWVudCA9IG1fYXJlbmEtPmFsbG9jPFNlZ21lbnQ+KCk7CisgICAgICAgICAgICBp ZiAoaXRlci5pc0Nsb3NlTGluZSgpKSB7CisgICAgICAgICAgICAgICAgc2VnbWVudC0+c2V0dXAo bV9hcmVuYS5nZXQoKSwgY29udG91ciwgY3VyUG9pbnQsIHBvaW50c1sxXSk7CisjaWZuZGVmIE5E RUJVRworICAgICAgICAgICAgICAgIGlmIChtX3ZlcmJvc2VMb2dnaW5nKQorICAgICAgICAgICAg ICAgICAgICBzdGQ6OmNlcnIgPDwgIkNsb3NlTGluZVRvICgiIDw8IGN1clBvaW50LmZYCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICA8PCAiLCAiIDw8IGN1clBvaW50LmZZCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICA8PCAiKSwgKCIgPDwgcG9pbnRzWzFdLmZYCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICA8PCAiLCAiIDw8IHBvaW50c1sxXS5mWSA8PCAiKSIgPDwg c3RkOjplbmRsOworI2VuZGlmCisgICAgICAgICAgICAgICAgY29udG91ci0+YWRkKHNlZ21lbnQp OworICAgICAgICAgICAgICAgIGNvbnRvdXIgPSAwOworICAgICAgICAgICAgfSBlbHNlIHsKKyAg ICAgICAgICAgICAgICBzZWdtZW50LT5zZXR1cChtX2FyZW5hLmdldCgpLCBjb250b3VyLCBwb2lu dHNbMF0sIHBvaW50c1sxXSk7CisjaWZuZGVmIE5ERUJVRworICAgICAgICAgICAgICAgIGlmICht X3ZlcmJvc2VMb2dnaW5nKQorICAgICAgICAgICAgICAgICAgICBzdGQ6OmNlcnIgPDwgIkxpbmVU byAoIiA8PCBwb2ludHNbMF0uZlgKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDw8ICIs ICIgPDwgcG9pbnRzWzBdLmZZCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8PCAiKSwg KCIgPDwgcG9pbnRzWzFdLmZYCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8PCAiLCAi IDw8IHBvaW50c1sxXS5mWSA8PCAiKSIgPDwgc3RkOjplbmRsOworI2VuZGlmCisgICAgICAgICAg ICAgICAgY29udG91ci0+YWRkKHNlZ21lbnQpOworICAgICAgICAgICAgICAgIGN1clBvaW50ID0g cG9pbnRzWzFdOworICAgICAgICAgICAgfQorICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIH0K KyAgICAgICAgY2FzZSBTa1BhdGg6OmtRdWFkX1ZlcmI6IHsKKyAgICAgICAgICAgIC8vIE5lZWQg dG8gZGVncmVlIGVsZXZhdGUgdGhlIHF1YWRyYXRpYyBpbnRvIGEgY3ViaWMKKyAgICAgICAgICAg IFNrUG9pbnQgY3ViaWNbNF07CisgICAgICAgICAgICBTa0NvbnZlcnRRdWFkVG9DdWJpYyhwb2lu dHMsIGN1YmljKTsKKyAgICAgICAgICAgIFNlZ21lbnQqIHNlZ21lbnQgPSBtX2FyZW5hLT5hbGxv YzxTZWdtZW50PigpOworICAgICAgICAgICAgc2VnbWVudC0+c2V0dXAobV9hcmVuYS5nZXQoKSwg Y29udG91ciwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgIGN1YmljWzBdLCBjdWJpY1sxXSwg Y3ViaWNbMl0sIGN1YmljWzNdKTsKKyNpZm5kZWYgTkRFQlVHCisgICAgICAgICAgICBpZiAobV92 ZXJib3NlTG9nZ2luZykKKyAgICAgICAgICAgICAgICBzdGQ6OmNlcnIgPDwgIlF1YWQtPkN1Ymlj VG8gKCIgPDwgY3ViaWNbMF0uZlgKKyAgICAgICAgICAgICAgICAgICAgICAgICAgPDwgIiwgIiA8 PCBjdWJpY1swXS5mWQorICAgICAgICAgICAgICAgICAgICAgICAgICA8PCAiKSwgKCIgPDwgY3Vi aWNbMV0uZlgKKyAgICAgICAgICAgICAgICAgICAgICAgICAgPDwgIiwgIiA8PCBjdWJpY1sxXS5m WQorICAgICAgICAgICAgICAgICAgICAgICAgICA8PCAiKSwgKCIgPDwgY3ViaWNbMl0uZlgKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgPDwgIiwgIiA8PCBjdWJpY1syXS5mWQorICAgICAgICAg ICAgICAgICAgICAgICAgICA8PCAiKSwgKCIgPDwgY3ViaWNbM10uZlgKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgPDwgIiwgIiA8PCBjdWJpY1szXS5mWSA8PCAiKSIgPDwgc3RkOjplbmRsOwor I2VuZGlmCisgICAgICAgICAgICBjb250b3VyLT5hZGQoc2VnbWVudCk7CisgICAgICAgICAgICBj dXJQb2ludCA9IGN1YmljWzNdOworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIH0KKyAgICAg ICAgY2FzZSBTa1BhdGg6OmtDdWJpY19WZXJiOiB7CisgICAgICAgICAgICBTZWdtZW50KiBzZWdt ZW50ID0gbV9hcmVuYS0+YWxsb2M8U2VnbWVudD4oKTsKKyAgICAgICAgICAgIHNlZ21lbnQtPnNl dHVwKG1fYXJlbmEuZ2V0KCksIGNvbnRvdXIsIHBvaW50c1swXSwgcG9pbnRzWzFdLCBwb2ludHNb Ml0sIHBvaW50c1szXSk7CisjaWZuZGVmIE5ERUJVRworICAgICAgICAgICAgaWYgKG1fdmVyYm9z ZUxvZ2dpbmcpCisgICAgICAgICAgICAgICAgc3RkOjpjZXJyIDw8ICJDdWJpY1RvICgiIDw8IHBv aW50c1swXS5mWAorICAgICAgICAgICAgICAgICAgICAgICAgICA8PCAiLCAiIDw8IHBvaW50c1sw XS5mWQorICAgICAgICAgICAgICAgICAgICAgICAgICA8PCAiKSwgKCIgPDwgcG9pbnRzWzFdLmZY CisgICAgICAgICAgICAgICAgICAgICAgICAgIDw8ICIsICIgPDwgcG9pbnRzWzFdLmZZCisgICAg ICAgICAgICAgICAgICAgICAgICAgIDw8ICIpLCAoIiA8PCBwb2ludHNbMl0uZlgKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgPDwgIiwgIiA8PCBwb2ludHNbMl0uZlkKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgPDwgIiksICgiIDw8IHBvaW50c1szXS5mWAorICAgICAgICAgICAgICAgICAg ICAgICAgICA8PCAiLCAiIDw8IHBvaW50c1szXS5mWSA8PCAiKSIgPDwgc3RkOjplbmRsOworI2Vu ZGlmCisgICAgICAgICAgICBjb250b3VyLT5hZGQoc2VnbWVudCk7CisgICAgICAgICAgICBjdXJQ b2ludCA9IHBvaW50c1szXTsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAgICB9CisgICAgICAg IGNhc2UgU2tQYXRoOjprQ2xvc2VfVmVyYjogeworICAgICAgICAgICAgU2VnbWVudCogc2VnbWVu dCA9IG1fYXJlbmEtPmFsbG9jPFNlZ21lbnQ+KCk7CisgICAgICAgICAgICBzZWdtZW50LT5zZXR1 cChtX2FyZW5hLmdldCgpLCBjb250b3VyLCBjdXJQb2ludCwgbW92ZVRvUG9pbnQpOworI2lmbmRl ZiBOREVCVUcKKyAgICAgICAgICAgIGlmIChtX3ZlcmJvc2VMb2dnaW5nKQorICAgICAgICAgICAg ICAgIHN0ZDo6Y2VyciA8PCAiQ2xvc2UgKCIgPDwgY3VyUG9pbnQuZlgKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgPDwgIiwgIiA8PCBjdXJQb2ludC5mWQorICAgICAgICAgICAgICAgICAgICAg ICAgICA8PCAiKSAtPiAoIiA8PCBtb3ZlVG9Qb2ludC5mWAorICAgICAgICAgICAgICAgICAgICAg ICAgICA8PCAiLCAiIDw8ICBtb3ZlVG9Qb2ludC5mWSA8PCAiKSIgPDwgc3RkOjplbmRsOworI2Vu ZGlmCisgICAgICAgICAgICBjb250b3VyLT5hZGQoc2VnbWVudCk7CisgICAgICAgICAgICBjb250 b3VyID0gMDsKKyAgICAgICAgfQorICAgICAgICBkZWZhdWx0OgorICAgICAgICAgICAgYnJlYWs7 CisgICAgICAgIH0KKyAgICB9IHdoaWxlICh2ZXJiICE9IFNrUGF0aDo6a0RvbmVfVmVyYik7Cisj ZWxzZSAvLyAhUExBVEZPUk0oU0tJQSkKKyAgICAvLyBNdXN0IHBvcnQgdG8geW91ciBwbGF0Zm9y bS4KKyAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyNlbmRpZgorfQorCitWZWN0b3I8U2VnbWVu dCo+IFBhdGhQcm9jZXNzb3I6OmFsbFNlZ21lbnRzT3ZlcmxhcHBpbmdZKENvbnRvdXIqIHF1ZXJ5 Q29udG91ciwgZmxvYXQgeCwgZmxvYXQgeSkKK3sKKyAgICBWZWN0b3I8U2VnbWVudCo+IHJlczsK KyAgICBmb3IgKFZlY3RvcjxDb250b3VyKj46Oml0ZXJhdG9yIGl0ZXIgPSBtX2NvbnRvdXJzLmJl Z2luKCk7CisgICAgICAgICBpdGVyICE9IG1fY29udG91cnMuZW5kKCk7CisgICAgICAgICBpdGVy KyspIHsKKyAgICAgICAgQ29udG91ciogY3VyID0gKml0ZXI7CisgICAgICAgIGZvciAoU2VnbWVu dCogc2VnID0gY3VyLT5iZWdpbigpOyBzZWcgIT0gY3VyLT5lbmQoKTsgc2VnID0gc2VnLT5uZXh0 KCkpIHsKKyAgICAgICAgICAgIGNvbnN0IEJCb3gmIGJib3ggPSBzZWctPmJib3goKTsKKyAgICAg ICAgICAgIGlmIChiYm94Lm1pblkoKSA8PSB5ICYmIHkgPD0gYmJveC5tYXhZKCkpCisgICAgICAg ICAgICAgICAgcmVzLmFwcGVuZChzZWcpOworICAgICAgICB9CisgICAgfQorICAgIHJldHVybiBy ZXM7Cit9CisKKy8vIFVuY29tbWVudCB0aGlzIHRvIGRlYnVnIHRoZSBvcmllbnRhdGlvbiBjb21w dXRhdGlvbi4KKy8vICNkZWZpbmUgR1BVX1BBVEhfUFJPQ0VTU09SX0RFQlVHX09SSUVOVEFUSU9O CisKK3ZvaWQgUGF0aFByb2Nlc3Nvcjo6ZGV0ZXJtaW5lU2lkZXNUb0ZpbGwoKQoreworICAgIC8v IExvb3AgYW5kIEJsaW5uJ3MgYWxnb3JpdGhtIGNhbiBvbmx5IGVhc2lseSBlbXVsYXRlIHRoZSBl dmVuL29kZAorICAgIC8vIGZpbGwgcnVsZSwgYW5kIG9ubHkgZm9yIG5vbi1pbnRlcnNlY3Rpbmcg Y3VydmVzLiBXZSBjYW4gZGV0ZXJtaW5lCisgICAgLy8gd2hpY2ggc2lkZSBvZiBlYWNoIGN1cnZl IHNlZ21lbnQgdG8gZmlsbCBiYXNlZCBvbiBpdHMKKyAgICAvLyBjbG9ja3dpc2UvY291bnRlcmNs b2Nrd2lzZSBvcmllbnRhdGlvbiBhbmQgaG93IG1hbnkgb3RoZXIKKyAgICAvLyBjb250b3VycyBz dXJyb3VuZCBpdC4KKworICAgIC8vIFRvIG9wdGltaXplIHRoZSBxdWVyeSBvZiBhbGwgY3VydmUg c2VnbWVudHMgaW50ZXJzZWN0aW5nIGEKKyAgICAvLyBob3Jpem9udGFsIGxpbmUgZ29pbmcgdG8g eD0raW5maW5pdHksIHdlIGJ1aWxkIHVwIGFuIGludGVydmFsCisgICAgLy8gdHJlZSB3aG9zZSBr ZXlzIGFyZSB0aGUgeSBleHRlbnRzIG9mIHRoZSBzZWdtZW50cy4KKyAgICBJbnRlcnZhbFRyZWU8 ZmxvYXQsIFNlZ21lbnQqPiB0cmVlKG1fYXJlbmEuZ2V0KCkpOworICAgIHR5cGVkZWYgSW50ZXJ2 YWxUcmVlPGZsb2F0LCBTZWdtZW50Kj46OkludGVydmFsVHlwZSBJbnRlcnZhbFR5cGU7CisKKyAg ICBmb3IgKFZlY3RvcjxDb250b3VyKj46Oml0ZXJhdG9yIGl0ZXIgPSBtX2NvbnRvdXJzLmJlZ2lu KCk7CisgICAgICAgICBpdGVyICE9IG1fY29udG91cnMuZW5kKCk7CisgICAgICAgICBpdGVyKysp IHsKKyAgICAgICAgQ29udG91ciogY3VyID0gKml0ZXI7CisgICAgICAgIGRldGVybWluZU9yaWVu dGF0aW9uKGN1cik7CisgICAgICAgIGZvciAoU2VnbWVudCogc2VnID0gY3VyLT5iZWdpbigpOyBz ZWcgIT0gY3VyLT5lbmQoKTsgc2VnID0gc2VnLT5uZXh0KCkpIHsKKyAgICAgICAgICAgIGNvbnN0 IEJCb3gmIGJib3ggPSBzZWctPmJib3goKTsKKyAgICAgICAgICAgIHRyZWUuaW5zZXJ0KHRyZWUu bWFrZUludGVydmFsKGJib3gubWluWSgpLCBiYm94Lm1heFkoKSwgc2VnKSk7CisgICAgICAgIH0K KyAgICB9CisKKyAgICAvLyBOb3cgaXRlcmF0ZSB0aHJvdWdoIHRoZSBjb250b3VycyBhbmQgcGlj ayBhIHJhbmRvbSBzZWdtZW50IChpbgorICAgIC8vIHRoaXMgY2FzZSB3ZSB1c2UgdGhlIGZpcnN0 KSBhbmQgYSByYW5kb20gcG9pbnQgb24gdGhhdCBzZWdtZW50LgorICAgIC8vIEZpbmQgYWxsIHNl Z21lbnRzIGZyb20gb3RoZXIgY29udG91cnMgd2hpY2ggaW50ZXJzZWN0IHRoaXMgb25lCisgICAg Ly8gYW5kIGNvdW50IHRoZSBudW1iZXIgb2YgY3Jvc3NpbmdzIGEgaG9yaXpvbnRhbCBsaW5lIHRv CisgICAgLy8geD0raW5maW5pdHkgbWFrZXMgd2l0aCB0aG9zZSBjb250b3Vycy4gVGhpcyBjb21i aW5lZCB3aXRoIHRoZQorICAgIC8vIG9yaWVudGF0aW9uIG9mIHRoZSBjdXJ2ZSB0ZWxscyB1cyB3 aGljaCBzaWRlIHRvIGZpbGwgLS0gYWdhaW4sCisgICAgLy8gYXNzdW1pbmcgYW4gZXZlbi9vZGQg ZmlsbCBydWxlLCB3aGljaCBpcyBhbGwgd2UgY2FuIGVhc2lseQorICAgIC8vIGhhbmRsZS4KKyAg ICBmb3IgKFZlY3RvcjxDb250b3VyKj46Oml0ZXJhdG9yIGl0ZXIgPSBtX2NvbnRvdXJzLmJlZ2lu KCk7CisgICAgICAgICBpdGVyICE9IG1fY29udG91cnMuZW5kKCk7CisgICAgICAgICBpdGVyKysp IHsKKyAgICAgICAgQ29udG91ciogY3VyID0gKml0ZXI7CisKKyAgICAgICAgYm9vbCBhbWJpZ3Vv dXMgPSB0cnVlOworICAgICAgICBpbnQgbnVtQ3Jvc3NpbmdzID0gMDsKKworICAgICAgICAvLyBG b3IgZWFjaCBjb250b3VyLCBhdHRlbXB0IHRvIGZpbmQgYSBwb2ludCBvbiB0aGUgY29udG91ciB3 aGljaCwKKyAgICAgICAgLy8gd2hlbiB3ZSBjYXN0IGFuIFhSYXksIGRvZXMgbm90IGludGVyc2Vj dCB0aGUgb3RoZXIgY29udG91cnMgYXQKKyAgICAgICAgLy8gYW4gYW1iaWd1b3VzIHBvaW50ICh0 aGUganVuY3Rpb24gYmV0d2VlbiB0d28gY3VydmVzIG9yIGF0IGEKKyAgICAgICAgLy8gdGFuZ2Vu dCBwb2ludCkuIEFtYmlndW91cyBwb2ludHMgbWFrZSB0aGUgZGV0ZXJtaW5hdGlvbiBvZgorICAg ICAgICAvLyB3aGV0aGVyIHRoaXMgY29udG91ciBpcyBjb250YWluZWQgd2l0aGluIGFub3RoZXIg ZnJhZ2lsZS4gTm90ZQorICAgICAgICAvLyB0aGF0IHRoaXMgbG9vcCBpcyBvbmx5IGFuIGFwcHJv eGltYXRpb24gdG8gdGhlIHNlbGVjdGlvbiBvZiBhCisgICAgICAgIC8vIGdvb2QgY2FzdGluZyBw b2ludC4gV2UgY291bGQgYXMgd2VsbCBldmFsdWF0ZSBhIHNlZ21lbnQgdG8KKyAgICAgICAgLy8g ZGV0ZXJtaW5lIGEgcG9pbnQgdXBvbiBpdC4KKyAgICAgICAgZm9yIChTZWdtZW50KiBzZWcgPSBj dXItPmJlZ2luKCk7CisgICAgICAgICAgICAgYW1iaWd1b3VzICYmIHNlZyAhPSBjdXItPmVuZCgp OworICAgICAgICAgICAgIHNlZyA9IHNlZy0+bmV4dCgpKSB7CisgICAgICAgICAgICBudW1Dcm9z c2luZ3MgPSAwOworICAgICAgICAgICAgLy8gV2UgdXNlIGEgemVyby1zaXplZCB2ZXJ0aWNhbCBp bnRlcnZhbCBmb3IgdGhlIHF1ZXJ5LgorICAgICAgICAgICAgVmVjdG9yPEludGVydmFsVHlwZT4g b3ZlcmxhcHMgPSB0cmVlLmFsbE92ZXJsYXBzKHRyZWUubWFrZUludGVydmFsKHNlZy0+Z2V0UG9p bnQoMCkueSgpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNlZy0+Z2V0UG9pbnQoMCkueSgpLAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIDApKTsKKyNpZiBkZWZpbmVkKEdQVV9QQVRIX1BST0NFU1NP Ul9ERUJVR19PUklFTlRBVElPTikKKyNpZm5kZWYgTkRFQlVHCisgICAgICAgICAgICAvLyBGb3Ig ZGVidWdnaW5nCisgICAgICAgICAgICBWZWN0b3I8U2VnbWVudCo+IHNsb3dPdmVybGFwcyA9IGFs bFNlZ21lbnRzT3ZlcmxhcHBpbmdZKGN1ciwgc2VnLT5nZXRQb2ludCgwKS54KCksIHNlZy0+Z2V0 UG9pbnQoMCkueSgpKTsKKyAgICAgICAgICAgIGlmIChvdmVybGFwcy5zaXplKCkgIT0gc2xvd092 ZXJsYXBzLnNpemUoKSkgeworICAgICAgICAgICAgICAgIHN0ZDo6Y2VyciA8PCAiZm9yIHF1ZXJ5 IHBvaW50ICgiIDw8IHNlZy0+Z2V0UG9pbnQoMCkueCgpIDw8ICIsICIgPDwgc2VnLT5nZXRQb2lu dCgwKS55KCkgPDwgIikgb24gY29udG91ciAiIDw8IGN1ciA8PCAiOiIgPDwgc3RkOjplbmRsOwor ICAgICAgICAgICAgICAgIHN0ZDo6Y2VyciA8PCAiIG92ZXJsYXBzOiIgPDwgc3RkOjplbmRsOwor ICAgICAgICAgICAgICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgb3ZlcmxhcHMuc2l6ZSgpOyBp KyspCisgICAgICAgICAgICAgICAgICAgIHN0ZDo6Y2VyciA8PCAiICAiIDw8IChpKzEpIDw8ICI6 ICIgPDwgKm92ZXJsYXBzW2ldLmRhdGEoKTsKKyAgICAgICAgICAgICAgICBzdGQ6OmNlcnIgPDwg c3RkOjplbmRsIDw8ICIgc2xvd092ZXJsYXBzOiIgPDwgc3RkOjplbmRsOworICAgICAgICAgICAg ICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgc2xvd092ZXJsYXBzLnNpemUoKTsgaSsrKQorICAg ICAgICAgICAgICAgICAgICBzdGQ6OmNlcnIgPDwgIiAgIiA8PCAoaSsxKSA8PCAiOiAiIDw8ICpz bG93T3ZlcmxhcHNbaV07CisgICAgICAgICAgICAgICAgc3RkOjpjZXJyIDw8IHN0ZDo6ZW5kbDsK KyAgICAgICAgICAgICAgICBzdGQ6OmNlcnIgPDwgImludGVydmFsIHRyZWU6IiA8PCBzdGQ6OmVu ZGw7CisgICAgICAgICAgICAgICAgdHJlZS5kdW1wKCk7CisgICAgICAgICAgICB9CisgICAgICAg ICAgICBBU1NFUlQob3ZlcmxhcHMuc2l6ZSgpID09IHNsb3dPdmVybGFwcy5zaXplKCkpOworI2Vu ZGlmIC8vIE5ERUJVRworI2VuZGlmIC8vIGRlZmluZWQoR1BVX1BBVEhfUFJPQ0VTU09SX0RFQlVH X09SSUVOVEFUSU9OKQorICAgICAgICAgICAgZm9yIChWZWN0b3I8SW50ZXJ2YWxUeXBlPjo6aXRl cmF0b3IgaXRlciA9IG92ZXJsYXBzLmJlZ2luKCk7CisgICAgICAgICAgICAgICAgIGl0ZXIgIT0g b3ZlcmxhcHMuZW5kKCk7CisgICAgICAgICAgICAgICAgIGl0ZXIrKykgeworICAgICAgICAgICAg ICAgIGNvbnN0IEludGVydmFsVHlwZSYgaW50ZXJ2YWwgPSAqaXRlcjsKKyAgICAgICAgICAgICAg ICBTZWdtZW50KiBxdWVyeVNlZ21lbnQgPSBpbnRlcnZhbC5kYXRhKCk7CisgICAgICAgICAgICAg ICAgLy8gSWdub3JlIHNlZ21lbnRzIGNvbWluZyBmcm9tIHRoZSBzYW1lIGNvbnRvdXIuCisgICAg ICAgICAgICAgICAgaWYgKHF1ZXJ5U2VnbWVudC0+Y29udG91cigpICE9IGN1cikgeworICAgICAg ICAgICAgICAgICAgICAvLyBPbmx5IHBlcmZvcm0gcXVlcmllcyB0aGF0IGNhbiBhZmZlY3QgdGhl IGNvbXB1dGF0aW9uLgorICAgICAgICAgICAgICAgICAgICBjb25zdCBCQm94JiBiYm94ID0gcXVl cnlTZWdtZW50LT5jb250b3VyKCktPmJib3goKTsKKyAgICAgICAgICAgICAgICAgICAgaWYgKHNl Zy0+Z2V0UG9pbnQoMCkueCgpID49IGJib3gubWluWCgpCisgICAgICAgICAgICAgICAgICAgICAg ICAmJiBzZWctPmdldFBvaW50KDApLngoKSA8PSBiYm94Lm1heFgoKSkgeworICAgICAgICAgICAg ICAgICAgICAgICAgbnVtQ3Jvc3NpbmdzICs9IHF1ZXJ5U2VnbWVudC0+bnVtQ3Jvc3NpbmdzRm9y WFJheShzZWctPmdldFBvaW50KDApLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAmYW1iaWd1b3VzKTsKKyAg ICAgICAgICAgICAgICAgICAgICAgIGlmIChhbWJpZ3VvdXMpIHsKKyNpZm5kZWYgTkRFQlVHCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgaWYgKG1fdmVyYm9zZUxvZ2dpbmcpIHsKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgc3RkOjpjZXJyIDw8ICJBbWJpZ3VvdXMgaW50ZXJz ZWN0aW9uIHF1ZXJ5IGF0IHBvaW50ICgiCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICA8PCBzZWctPmdldFBvaW50KDApLngoKSA8PCAiLCAiCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8PCBzZWctPmdldFBvaW50KDApLnkoKSA8PCAi KSIgPDwgc3RkOjplbmRsOworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzdGQ6OmNl cnIgPDwgIlF1ZXJ5IHNlZ21lbnQ6ICIgPDwgKnF1ZXJ5U2VnbWVudCA8PCBzdGQ6OmVuZGw7Cisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgfQorI2VuZGlmCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgYnJlYWs7IC8vIEFib3J0IGl0ZXJhdGlvbiBvdmVyIG92ZXJsYXBzLgorICAgICAg ICAgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAg ICAgfQorICAgICAgICAgICAgfQorICAgICAgICB9IC8vIGZvciAoU2VnbWVudCogc2VnID0gY3Vy LT5iZWdpbigpOyAuLi4KKworICAgICAgICBpZiAoY3VyLT5jY3coKSkKKyAgICAgICAgICAgIGlm IChudW1Dcm9zc2luZ3MgJiAxKQorICAgICAgICAgICAgICAgIGN1ci0+c2V0RmlsbFJpZ2h0U2lk ZSh0cnVlKTsKKyAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICBjdXItPnNldEZpbGxS aWdodFNpZGUoZmFsc2UpOworICAgICAgICBlbHNlCisgICAgICAgICAgICBpZiAobnVtQ3Jvc3Np bmdzICYgMSkKKyAgICAgICAgICAgICAgICBjdXItPnNldEZpbGxSaWdodFNpZGUoZmFsc2UpOwor ICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgIGN1ci0+c2V0RmlsbFJpZ2h0U2lkZSh0 cnVlKTsKKyAgICB9Cit9CisKK3ZvaWQgUGF0aFByb2Nlc3Nvcjo6ZGV0ZXJtaW5lT3JpZW50YXRp b24oQ29udG91ciogY29udG91cikKK3sKKyAgICAvLyBEZXRlcm1pbmUgc2lnbmVkIGFyZWEgb2Yg dGhlIHBvbHlnb24gcmVwcmVzZW50ZWQgYnkgdGhlIHBvaW50cworICAgIC8vIGFsb25nIHRoZSBz ZWdtZW50cy4gQ29uc2lkZXIgdGhpcyBhbiBhcHByb3hpbWF0aW9uIHRvIHRoZSB0cnVlCisgICAg Ly8gb3JpZW50YXRpb24gb2YgdGhlIHBvbHlnb247IGl0IHByb2JhYmx5IHdvbid0IGhhbmRsZQor ICAgIC8vIHNlbGYtaW50ZXJzZWN0aW5nIGN1cnZlcyBjb3JyZWN0bHkuCisgICAgLy8KKyAgICAv LyBUaGVyZSBpcyBhbHNvIGEgcHJldHR5IGJhc2ljIGFzc3VtcHRpb24gaGVyZSB0aGF0IHRoZSBj b250b3VyIGlzCisgICAgLy8gY2xvc2VkLgorICAgIGZsb2F0IHNpZ25lZEFyZWEgPSAwOworICAg IGZvciAoU2VnbWVudCogc2VnID0gY29udG91ci0+YmVnaW4oKTsKKyAgICAgICAgIHNlZyAhPSBj b250b3VyLT5lbmQoKTsKKyAgICAgICAgIHNlZyA9IHNlZy0+bmV4dCgpKSB7CisgICAgICAgIGlu dCBsaW1pdCA9IChzZWctPmtpbmQoKSA9PSBTZWdtZW50OjprQ3ViaWMpID8gNCA6IDI7CisgICAg ICAgIGZvciAoaW50IGkgPSAxOyBpIDwgbGltaXQ7IGkrKykgeworICAgICAgICAgICAgY29uc3Qg RmxvYXRQb2ludCYgcHJldlBvaW50ID0gc2VnLT5nZXRQb2ludChpIC0gMSk7CisgICAgICAgICAg ICBjb25zdCBGbG9hdFBvaW50JiBwb2ludCA9IHNlZy0+Z2V0UG9pbnQoaSk7CisgICAgICAgICAg ICBmbG9hdCBjdXJBcmVhID0gcHJldlBvaW50LngoKSAqIHBvaW50LnkoKSAtIHByZXZQb2ludC55 KCkgKiBwb2ludC54KCk7CisjaWZuZGVmIE5ERUJVRworICAgICAgICAgICAgaWYgKG1fdmVyYm9z ZUxvZ2dpbmcpCisgICAgICAgICAgICAgICAgc3RkOjpjZXJyIDw8ICJBZGRpbmcgdG8gc2lnbmVk IGFyZWEgKCIKKyAgICAgICAgICAgICAgICAgICAgICAgICAgPDwgcHJldlBvaW50LngoKSA8PCAi LCAiCisgICAgICAgICAgICAgICAgICAgICAgICAgIDw8IHByZXZQb2ludC55KCkgPDwgIikgLT4g KCIKKyAgICAgICAgICAgICAgICAgICAgICAgICAgPDwgcG9pbnQueCgpIDw8ICIsICIKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgPDwgcG9pbnQueSgpIDw8ICIpID0gIgorICAgICAgICAgICAg ICAgICAgICAgICAgICA8PCBjdXJBcmVhIDw8IHN0ZDo6ZW5kbDsKKyNlbmRpZgorICAgICAgICAg ICAgc2lnbmVkQXJlYSArPSBjdXJBcmVhOworICAgICAgICB9CisgICAgfQorCisgICAgaWYgKHNp Z25lZEFyZWEgPiAwKQorICAgICAgICBjb250b3VyLT5zZXRDQ1codHJ1ZSk7CisgICAgZWxzZQor ICAgICAgICBjb250b3VyLT5zZXRDQ1coZmFsc2UpOworfQorCisvLy0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKy8v IENsYXNzZXMgYW5kIHR5cGVkZWZzIG5lZWRlZCBmb3IgY3VydmUgc3ViZGl2aXNpb24uCisvLyBV bmZvcnR1bmF0ZWx5IGl0IGFwcGVhcnMgd2UgY2FuJ3Qgc2NvcGUgdGhlc2Ugd2l0aGluIHRoZQor Ly8gU3ViZGl2aWRlQ3VydmVzKCkgbWV0aG9kIGl0c2VsZiwgYmVjYXVzZSB0ZW1wbGF0ZXMgdGhl biBmYWlsIHRvCisvLyBpbnN0YW50aWF0ZS4KKworLy8gVGhlIHVzZXIgZGF0YSB3aGljaCBpcyBw bGFjZWQgaW4gdGhlIEludGVydmFsVHJlZS4KK3N0cnVjdCBTd2VlcERhdGEgeworICAgIFN3ZWVw RGF0YSgpCisgICAgICAgIDogdHJpYW5nbGUoMCkKKyAgICAgICAgLCBzZWdtZW50KDApCisgICAg eworICAgIH0KKworICAgIC8vIFRoZSB0cmlhbmdsZSB0aGlzIGludGVydmFsIGlzIGFzc29jaWF0 ZWQgd2l0aAorICAgIExvY2FsVHJpYW5ndWxhdG9yOjpUcmlhbmdsZSogdHJpYW5nbGU7CisgICAg Ly8gVGhlIHNlZ21lbnQgdGhlIHRyaWFuZ2xlIGlzIGFzc29jaWF0ZWQgd2l0aAorICAgIFNlZ21l bnQqIHNlZ21lbnQ7Cit9OworCit0eXBlZGVmIEludGVydmFsVHJlZTxmbG9hdCwgU3dlZXBEYXRh Kj4gU3dlZXBUcmVlOwordHlwZWRlZiBTd2VlcFRyZWU6OkludGVydmFsVHlwZSBTd2VlcEludGVy dmFsOworCisvLyBUaGUgZW50cnkgLyBleGl0IGV2ZW50cyB3aGljaCBvY2N1ciBhdCB0aGUgbWlu aW11bSBhbmQgbWF4aW11bSB4CisvLyBjb29yZGluYXRlcyBvZiB0aGUgY29udHJvbCBwb2ludCB0 cmlhbmdsZXMnIGJvdW5kaW5nIGJveGVzLgorLy8KKy8vIE5vdGUgdGhhdCB0aGlzIGNsYXNzIHJl cXVpcmVzIGl0cyBjb3B5IGNvbnN0cnVjdG9yIGFuZCBhc3NpZ25tZW50CisvLyBvcGVyYXRvciBz aW5jZSBpdCBuZWVkcyB0byBiZSBzdG9yZWQgaW4gYSBWZWN0b3IuCitjbGFzcyBTd2VlcEV2ZW50 IHsKK3B1YmxpYzoKKyAgICBTd2VlcEV2ZW50KCkKKyAgICAgICAgOiBtX3goMCkKKyAgICAgICAg LCBtX2VudHJ5KGZhbHNlKQorICAgICAgICAsIG1faW50ZXJ2YWwoMCwgMCwgMCkKKyAgICB7Cisg ICAgfQorCisgICAgLy8gSW5pdGlhbGl6ZXMgdGhlIFN3ZWVwRXZlbnQuCisgICAgdm9pZCBzZXR1 cChmbG9hdCB4LCBib29sIGVudHJ5LCBTd2VlcEludGVydmFsIGludGVydmFsKQorICAgIHsKKyAg ICAgICAgbV94ID0geDsKKyAgICAgICAgbV9lbnRyeSA9IGVudHJ5OworICAgICAgICBtX2ludGVy dmFsID0gaW50ZXJ2YWw7CisgICAgfQorCisgICAgZmxvYXQgeCgpIGNvbnN0IHsgcmV0dXJuIG1f eDsgfQorICAgIGJvb2wgZW50cnkoKSBjb25zdCB7IHJldHVybiBtX2VudHJ5OyB9CisgICAgY29u c3QgU3dlZXBJbnRlcnZhbCYgaW50ZXJ2YWwoKSBjb25zdCB7IHJldHVybiBtX2ludGVydmFsOyB9 CisKKyAgICBib29sIG9wZXJhdG9yPChjb25zdCBTd2VlcEV2ZW50JiBvdGhlcikgY29uc3QKKyAg ICB7CisgICAgICAgIHJldHVybiBtX3ggPCBvdGhlci5tX3g7CisgICAgfQorCitwcml2YXRlOgor ICAgIGZsb2F0IG1feDsKKyAgICBib29sIG1fZW50cnk7CisgICAgU3dlZXBJbnRlcnZhbCBtX2lu dGVydmFsOworfTsKKworc3RhdGljIGJvb2wgdHJpYW5nbGVzT3ZlcmxhcChMb2NhbFRyaWFuZ3Vs YXRvcjo6VHJpYW5nbGUqIHQwLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICBMb2NhbFRy aWFuZ3VsYXRvcjo6VHJpYW5nbGUqIHQxKQoreworICAgIExvY2FsVHJpYW5ndWxhdG9yOjpWZXJ0 ZXgqIHQwdjAgPSB0MC0+Z2V0VmVydGV4KDApOworICAgIExvY2FsVHJpYW5ndWxhdG9yOjpWZXJ0 ZXgqIHQwdjEgPSB0MC0+Z2V0VmVydGV4KDEpOworICAgIExvY2FsVHJpYW5ndWxhdG9yOjpWZXJ0 ZXgqIHQwdjIgPSB0MC0+Z2V0VmVydGV4KDIpOworICAgIExvY2FsVHJpYW5ndWxhdG9yOjpWZXJ0 ZXgqIHQxdjAgPSB0MS0+Z2V0VmVydGV4KDApOworICAgIExvY2FsVHJpYW5ndWxhdG9yOjpWZXJ0 ZXgqIHQxdjEgPSB0MS0+Z2V0VmVydGV4KDEpOworICAgIExvY2FsVHJpYW5ndWxhdG9yOjpWZXJ0 ZXgqIHQxdjIgPSB0MS0+Z2V0VmVydGV4KDIpOworICAgIHJldHVybiB0cmlhbmdsZXNPdmVybGFw KHQwdjAtPngoKSwgdDB2MC0+eSgpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgIHQwdjEt PngoKSwgdDB2MS0+eSgpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgIHQwdjItPngoKSwg dDB2Mi0+eSgpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgIHQxdjAtPngoKSwgdDF2MC0+ eSgpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgIHQxdjEtPngoKSwgdDF2MS0+eSgpLAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgIHQxdjItPngoKSwgdDF2Mi0+eSgpKTsKK30KKwor dm9pZCBQYXRoUHJvY2Vzc29yOjpzdWJkaXZpZGVDdXJ2ZXMoKQoreworICAgIC8vIFdlIG5lZWQg dG8gZGV0ZXJtaW5lIGFsbCBvdmVybGFwcyBvZiBhbGwgY29udHJvbCBwb2ludCB0cmlhbmdsZXMK KyAgICAvLyAoZnJvbSBkaWZmZXJlbnQgc2VnbWVudHMsIG5vdCB0aGUgc2FtZSBzZWdtZW50KSBh bmQsIGlmIGFueQorICAgIC8vIGV4aXN0LCBzdWJkaXZpZGUgdGhlIGFzc29jaWF0ZWQgY3VydmVz LgorICAgIC8vCisgICAgLy8gVGhlIHBsYW5lLXN3ZWVwIGFsZ29yaXRobSBkZXRlcm1pbmVzIGFs bCBvdmVybGFwcyBvZiBhIHNldCBvZgorICAgIC8vIHJlY3RhbmdsZXMgaW4gdGhlIDJEIHBsYW5l LiBPdXIgcHJvYmxlbSBtYXBzIHZlcnkgd2VsbCB0byB0aGlzCisgICAgLy8gYWxnb3JpdGhtIGFu ZCBzaWduaWZpY2FudGx5IHJlZHVjZXMgdGhlIGNvbXBsZXhpdHkgY29tcGFyZWQgdG8gYQorICAg IC8vIG5haXZlIGltcGxlbWVudGF0aW9uLgorICAgIC8vCisgICAgLy8gRWFjaCBib3VuZGluZyBi b3ggb2YgYSBjb250cm9sIHBvaW50IHRyaWFuZ2xlIGlzIGNvbnZlcnRlZCBpbnRvCisgICAgLy8g YW4gImVudHJ5IiBldmVudCBhdCBpdHMgc21hbGxlc3QgWCBjb29yZGluYXRlIGFuZCBhbiAiZXhp dCIgZXZlbnQKKyAgICAvLyBhdCBpdHMgbGFyZ2VzdCBYIGNvb3JkaW5hdGUuIEVhY2ggZXZlbnQg aGFzIGFuIGFzc29jaWF0ZWQKKyAgICAvLyBvbmUtZGltZW5zaW9uYWwgaW50ZXJ2YWwgcmVwcmVz ZW50aW5nIHRoZSBZIHNwYW4gb2YgdGhlIGJvdW5kaW5nCisgICAgLy8gYm94LiBXZSBzb3J0IHRo ZXNlIGV2ZW50cyBieSBpbmNyZWFzaW5nIFggY29vcmRpbmF0ZS4gV2UgdGhlbgorICAgIC8vIGl0 ZXJhdGUgdGhyb3VnaCB0aGVtLiBGb3IgZWFjaCBlbnRyeSBldmVudCB3ZSBhZGQgdGhlIGludGVy dmFsIHRvCisgICAgLy8gYSBzaWRlIGludGVydmFsIHRyZWUsIGFuZCBxdWVyeSB0aGlzIHRyZWUg Zm9yIG92ZXJsYXBwaW5nCisgICAgLy8gaW50ZXJ2YWxzLiBBbnkgb3ZlcmxhcHBpbmcgaW50ZXJ2 YWwgY29ycmVzcG9uZHMgdG8gYW4gb3ZlcmxhcHBpbmcKKyAgICAvLyBib3VuZGluZyBib3guIEZv ciBlYWNoIGV4aXQgZXZlbnQgd2UgcmVtb3ZlIHRoZSBhc3NvY2lhdGVkCisgICAgLy8gaW50ZXJ2 YWwgZnJvbSB0aGUgaW50ZXJ2YWwgdHJlZS4KKworICAgIFZlY3RvcjxTZWdtZW50Kj4gY3VyU2Vn bWVudHM7CisgICAgVmVjdG9yPFNlZ21lbnQqPiBuZXh0U2VnbWVudHM7CisKKyAgICAvLyBTdGFy dCB0aGluZ3Mgb2ZmIGJ5IGNvbnNpZGVyaW5nIGFsbCBvZiB0aGUgc2VnbWVudHMKKyAgICBmb3Ig KFZlY3RvcjxDb250b3VyKj46Oml0ZXJhdG9yIGl0ZXIgPSBtX2NvbnRvdXJzLmJlZ2luKCk7Cisg ICAgICAgICBpdGVyICE9IG1fY29udG91cnMuZW5kKCk7CisgICAgICAgICBpdGVyKyspIHsKKyAg ICAgICAgQ29udG91ciogY3VyID0gKml0ZXI7CisgICAgICAgIGZvciAoU2VnbWVudCogc2VnID0g Y3VyLT5iZWdpbigpOyBzZWcgIT0gY3VyLT5lbmQoKTsgc2VnID0gc2VnLT5uZXh0KCkpIHsKKyAg ICAgICAgICAgIGlmIChzZWctPmtpbmQoKSA9PSBTZWdtZW50OjprQ3ViaWMpIHsKKyAgICAgICAg ICAgICAgICBzZWctPnRyaWFuZ3VsYXRlKGZhbHNlLCAwKTsKKyAgICAgICAgICAgICAgICBjdXJT ZWdtZW50cy5hcHBlbmQoc2VnKTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfQorICAgIH0KKwor ICAgIC8vIFN1YmRpdmlkZSBjdXJ2ZXMgYXQgbW9zdCB0aGlzIG1hbnkgdGltZXMKKyAgICBjb25z dCBpbnQgTWF4SXRlcmF0aW9ucyA9IDU7CisgICAgVmVjdG9yPFN3ZWVwSW50ZXJ2YWw+IG92ZXJs YXBzOworCisgICAgZm9yIChpbnQgY3VycmVudEl0ZXJhdGlvbiA9IDA7IGN1cnJlbnRJdGVyYXRp b24gPCBNYXhJdGVyYXRpb25zOyArK2N1cnJlbnRJdGVyYXRpb24pIHsKKyAgICAgICAgaWYgKCFj dXJTZWdtZW50cy5zaXplKCkpCisgICAgICAgICAgICAvLyBEb25lCisgICAgICAgICAgICBicmVh azsKKworICAgICAgICBWZWN0b3I8U3dlZXBFdmVudD4gZXZlbnRzOworICAgICAgICBTd2VlcFRy ZWUgdHJlZShtX2FyZW5hLmdldCgpKTsKKyAgICAgICAgZm9yIChWZWN0b3I8U2VnbWVudCo+Ojpp dGVyYXRvciBpdGVyID0gY3VyU2VnbWVudHMuYmVnaW4oKTsKKyAgICAgICAgICAgICBpdGVyICE9 IGN1clNlZ21lbnRzLmVuZCgpOworICAgICAgICAgICAgIGl0ZXIrKykgeworICAgICAgICAgICAg U2VnbWVudCogc2VnID0gKml0ZXI7CisgICAgICAgICAgICBpZiAoc2VnLT5raW5kKCkgPT0gU2Vn bWVudDo6a0N1YmljKSB7CisgICAgICAgICAgICAgICAgZm9yIChpbnQgaSA9IDA7IGkgPCBzZWct Pm51bVRyaWFuZ2xlcygpOyBpKyspIHsKKyAgICAgICAgICAgICAgICAgICAgTG9jYWxUcmlhbmd1 bGF0b3I6OlRyaWFuZ2xlKiB0cmlhbmdsZSA9IHNlZy0+Z2V0VHJpYW5nbGUoaSk7CisgICAgICAg ICAgICAgICAgICAgIEJCb3ggYmJveDsKKyAgICAgICAgICAgICAgICAgICAgYmJveC5zZXR1cCh0 cmlhbmdsZSk7CisgICAgICAgICAgICAgICAgICAgIC8vIElnbm9yZSB6ZXJvLXdpZHRoIHRyaWFu Z2xlcyB0byBhdm9pZCBpc3N1ZXMgd2l0aAorICAgICAgICAgICAgICAgICAgICAvLyBjb2luY2lk ZW50IGVudHJ5IGFuZCBleGl0IGV2ZW50cyBmb3IgdGhlIHNhbWUgdHJpYW5nbGUKKyAgICAgICAg ICAgICAgICAgICAgaWYgKGJib3gubWF4WCgpID4gYmJveC5taW5YKCkpIHsKKyAgICAgICAgICAg ICAgICAgICAgICAgIFN3ZWVwRGF0YSogZGF0YSA9IG1fYXJlbmEtPmFsbG9jPFN3ZWVwRGF0YT4o KTsKKyAgICAgICAgICAgICAgICAgICAgICAgIGRhdGEtPnRyaWFuZ2xlID0gdHJpYW5nbGU7Cisg ICAgICAgICAgICAgICAgICAgICAgICBkYXRhLT5zZWdtZW50ID0gc2VnOworICAgICAgICAgICAg ICAgICAgICAgICAgU3dlZXBJbnRlcnZhbCBpbnRlcnZhbCA9IHRyZWUubWFrZUludGVydmFsKGJi b3gubWluWSgpLCBiYm94Lm1heFkoKSwgZGF0YSk7CisgICAgICAgICAgICAgICAgICAgICAgICAv LyBBZGQgZW50cnkgYW5kIGV4aXQgZXZlbnRzCisgICAgICAgICAgICAgICAgICAgICAgICBTd2Vl cEV2ZW50IGV2ZW50OworICAgICAgICAgICAgICAgICAgICAgICAgZXZlbnQuc2V0dXAoYmJveC5t aW5YKCksIHRydWUsIGludGVydmFsKTsKKyAgICAgICAgICAgICAgICAgICAgICAgIGV2ZW50cy5h cHBlbmQoZXZlbnQpOworICAgICAgICAgICAgICAgICAgICAgICAgZXZlbnQuc2V0dXAoYmJveC5t YXhYKCksIGZhbHNlLCBpbnRlcnZhbCk7CisgICAgICAgICAgICAgICAgICAgICAgICBldmVudHMu YXBwZW5kKGV2ZW50KTsKKyAgICAgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgIH0K KyAgICAgICAgICAgIH0KKyAgICAgICAgfQorCisgICAgICAgIC8vIFNvcnQgZXZlbnRzIGJ5IGlu Y3JlYXNpbmcgWCBjb29yZGluYXRlCisgICAgICAgIHN0ZDo6c29ydChldmVudHMuYmVnaW4oKSwg ZXZlbnRzLmVuZCgpKTsKKyNpZm5kZWYgTkRFQlVHCisgICAgICAgIGZvciAoc2l6ZV90IGlpID0g MTsgaWkgPCBldmVudHMuc2l6ZSgpOyArK2lpKQorICAgICAgICAgICAgQVNTRVJUKGV2ZW50c1tp aSAtIDFdLngoKSA8PSBldmVudHNbaWldLngoKSk7CisjZW5kaWYKKworICAgICAgICAvLyBOb3cg aXRlcmF0ZSB0aHJvdWdoIHRoZSBldmVudHMKKyAgICAgICAgZm9yIChWZWN0b3I8U3dlZXBFdmVu dD46Oml0ZXJhdG9yIGl0ZXIgPSBldmVudHMuYmVnaW4oKTsKKyAgICAgICAgICAgICBpdGVyICE9 IGV2ZW50cy5lbmQoKTsKKyAgICAgICAgICAgICBpdGVyKyspIHsKKyAgICAgICAgICAgIFN3ZWVw RXZlbnQgZXZlbnQgPSAqaXRlcjsKKyAgICAgICAgICAgIGlmIChldmVudC5lbnRyeSgpKSB7Cisg ICAgICAgICAgICAgICAgLy8gQWRkIHRoaXMgaW50ZXJ2YWwgaW50byB0aGUgdHJlZQorICAgICAg ICAgICAgICAgIHRyZWUuaW5zZXJ0KGV2ZW50LmludGVydmFsKCkpOworICAgICAgICAgICAgICAg IC8vIFNlZSB3aGV0aGVyIHRoZSBhc3NvY2lhdGVkIHNlZ21lbnQgaGFzIGJlZW4gc3ViZGl2aWRl ZCB5ZXQKKyAgICAgICAgICAgICAgICBpZiAoIWV2ZW50LmludGVydmFsKCkuZGF0YSgpLT5zZWdt ZW50LT5tYXJrZWRGb3JTdWJkaXZpc2lvbigpKSB7CisgICAgICAgICAgICAgICAgICAgIC8vIFF1 ZXJ5IHRoZSB0cmVlCisgICAgICAgICAgICAgICAgICAgIG92ZXJsYXBzLmNsZWFyKCk7CisgICAg ICAgICAgICAgICAgICAgIHRyZWUuYWxsT3ZlcmxhcHMoZXZlbnQuaW50ZXJ2YWwoKSwgb3Zlcmxh cHMpOworICAgICAgICAgICAgICAgICAgICAvLyBOb3cgc2VlIGV4YWN0bHkgd2hpY2ggdHJpYW5n bGVzIG92ZXJsYXAgdGhpcyBvbmUKKyAgICAgICAgICAgICAgICAgICAgZm9yIChWZWN0b3I8U3dl ZXBJbnRlcnZhbD46Oml0ZXJhdG9yIGl0ZXIgPSBvdmVybGFwcy5iZWdpbigpOworICAgICAgICAg ICAgICAgICAgICAgICAgIGl0ZXIgIT0gb3ZlcmxhcHMuZW5kKCk7CisgICAgICAgICAgICAgICAg ICAgICAgICAgaXRlcisrKSB7CisgICAgICAgICAgICAgICAgICAgICAgICBTd2VlcEludGVydmFs IG92ZXJsYXAgPSAqaXRlcjsKKyAgICAgICAgICAgICAgICAgICAgICAgIC8vIE9ubHkgcGF5IGF0 dGVudGlvbiB0byBvdmVybGFwcyBmcm9tIGEgZGlmZmVyZW50IFNlZ21lbnQKKyAgICAgICAgICAg ICAgICAgICAgICAgIGlmIChldmVudC5pbnRlcnZhbCgpLmRhdGEoKS0+c2VnbWVudCAhPSBvdmVy bGFwLmRhdGEoKS0+c2VnbWVudCkgeworICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8vIFNl ZSB3aGV0aGVyIHRoZSB0cmlhbmdsZXMgYWN0dWFsbHkgb3ZlcmxhcAorICAgICAgICAgICAgICAg ICAgICAgICAgICAgIGlmICh0cmlhbmdsZXNPdmVybGFwKGV2ZW50LmludGVydmFsKCkuZGF0YSgp LT50cmlhbmdsZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBvdmVybGFwLmRhdGEoKS0+dHJpYW5nbGUpKSB7CisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIC8vIEFjdHVhbGx5IHN1YmRpdmlkZSB0aGUgc2VnbWVudHMuCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIC8vIEVhY2ggb25lIG1pZ2h0IGFscmVhZHkgaGF2ZSBiZWVu IHN1YmRpdmlkZWQuCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFNlZ21lbnQqIHNl ZyA9IGV2ZW50LmludGVydmFsKCkuZGF0YSgpLT5zZWdtZW50OworICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBjb25kaXRpb25hbGx5U3ViZGl2aWRlKHNlZywgJm5leHRTZWdtZW50cyk7 CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNlZyA9IG92ZXJsYXAuZGF0YSgpLT5z ZWdtZW50OworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25kaXRpb25hbGx5U3Vi ZGl2aWRlKHNlZywgJm5leHRTZWdtZW50cyk7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAg fQorICAgICAgICAgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgICAgICB9CisgICAg ICAgICAgICAgICAgfQorICAgICAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgICAgICAvLyBS ZW1vdmUgdGhpcyBpbnRlcnZhbCBmcm9tIHRoZSB0cmVlCisgICAgICAgICAgICAgICAgdHJlZS5y ZW1vdmUoZXZlbnQuaW50ZXJ2YWwoKSk7CisgICAgICAgICAgICB9CisgICAgICAgIH0KKworICAg ICAgICBjdXJTZWdtZW50cyA9IG5leHRTZWdtZW50czsKKyAgICAgICAgbmV4dFNlZ21lbnRzLmNs ZWFyKCk7CisgICAgfQorfQorCit2b2lkIFBhdGhQcm9jZXNzb3I6OmNvbmRpdGlvbmFsbHlTdWJk aXZpZGUoU2VnbWVudCogc2VnLCBWZWN0b3I8U2VnbWVudCo+KiBuZXh0U2VnbWVudHMpCit7Cisg ICAgaWYgKCFzZWctPm1hcmtlZEZvclN1YmRpdmlzaW9uKCkpIHsKKyAgICAgICAgc2VnLT5zZXRN YXJrZWRGb3JTdWJkaXZpc2lvbih0cnVlKTsKKyAgICAgICAgU2VnbWVudCogbmV4dCA9IHNlZy0+ Y29udG91cigpLT5zdWJkaXZpZGUoc2VnKTsKKyAgICAgICAgLy8gVHJpYW5ndWxhdGUgdGhlIG5l d2x5IHN1YmRpdmlkZWQgc2VnbWVudHMuCisgICAgICAgIG5leHQtPnRyaWFuZ3VsYXRlKGZhbHNl LCAwKTsKKyAgICAgICAgbmV4dC0+bmV4dCgpLT50cmlhbmd1bGF0ZShmYWxzZSwgMCk7CisgICAg ICAgIC8vIEFkZCB0aGVtIGZvciB0aGUgbmV4dCBpdGVyYXRpb24uCisgICAgICAgIG5leHRTZWdt ZW50cy0+YXBwZW5kKG5leHQpOworICAgICAgICBuZXh0U2VnbWVudHMtPmFwcGVuZChuZXh0LT5u ZXh0KCkpOworICAgIH0KK30KKworI2lmbmRlZiBOREVCVUcKK3ZvaWQgUGF0aFByb2Nlc3Nvcjo6 c3ViZGl2aWRlQ3VydmVzU2xvdygpCit7CisgICAgLy8gQWx0ZXJuYXRlLCBzaWduaWZpY2FudGx5 IHNsb3dlciBhbGdvcml0aG0gZm9yIGN1cnZlIHN1YmRpdmlzaW9uCisgICAgLy8gZm9yIHVzZSBp biBkZWJ1Z2dpbmcuCisgICAgVmVjdG9yPFNlZ21lbnQqPiBjdXJTZWdtZW50czsKKyAgICBWZWN0 b3I8U2VnbWVudCo+IG5leHRTZWdtZW50czsKKworICAgIC8vIFN0YXJ0IHRoaW5ncyBvZmYgYnkg Y29uc2lkZXJpbmcgYWxsIG9mIHRoZSBzZWdtZW50cworICAgIGZvciAoVmVjdG9yPENvbnRvdXIq Pjo6aXRlcmF0b3IgaXRlciA9IG1fY29udG91cnMuYmVnaW4oKTsKKyAgICAgICAgIGl0ZXIgIT0g bV9jb250b3Vycy5lbmQoKTsKKyAgICAgICAgIGl0ZXIrKykgeworICAgICAgICBDb250b3VyKiBj dXIgPSAqaXRlcjsKKyAgICAgICAgZm9yIChTZWdtZW50KiBzZWcgPSBjdXItPmJlZ2luKCk7IHNl ZyAhPSBjdXItPmVuZCgpOyBzZWcgPSBzZWctPm5leHQoKSkgeworICAgICAgICAgICAgaWYgKHNl Zy0+a2luZCgpID09IFNlZ21lbnQ6OmtDdWJpYykgeworICAgICAgICAgICAgICAgIHNlZy0+dHJp YW5ndWxhdGUoZmFsc2UsIDApOworICAgICAgICAgICAgICAgIGN1clNlZ21lbnRzLmFwcGVuZChz ZWcpOworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgfQorCisgICAgLy8gU3ViZGl2aWRl IGN1cnZlcyBhdCBtb3N0IHRoaXMgbWFueSB0aW1lcworICAgIGNvbnN0IGludCBNYXhJdGVyYXRp b25zID0gNTsKKworICAgIGZvciAoaW50IGN1cnJlbnRJdGVyYXRpb24gPSAwOyBjdXJyZW50SXRl cmF0aW9uIDwgTWF4SXRlcmF0aW9uczsgKytjdXJyZW50SXRlcmF0aW9uKSB7CisgICAgICAgIGlm ICghY3VyU2VnbWVudHMuc2l6ZSgpKQorICAgICAgICAgICAgLy8gRG9uZQorICAgICAgICAgICAg YnJlYWs7CisKKyAgICAgICAgZm9yIChWZWN0b3I8U2VnbWVudCo+OjppdGVyYXRvciBpdGVyID0g Y3VyU2VnbWVudHMuYmVnaW4oKTsKKyAgICAgICAgICAgICBpdGVyICE9IGN1clNlZ21lbnRzLmVu ZCgpOworICAgICAgICAgICAgIGl0ZXIrKykgeworICAgICAgICAgICAgU2VnbWVudCogc2VnID0g Kml0ZXI7CisgICAgICAgICAgICBpZiAoc2VnLT5raW5kKCkgPT0gU2VnbWVudDo6a0N1YmljKSB7 CisgICAgICAgICAgICAgICAgZm9yIChWZWN0b3I8U2VnbWVudCo+OjppdGVyYXRvciBpdGVyMiA9 IGN1clNlZ21lbnRzLmJlZ2luKCk7CisgICAgICAgICAgICAgICAgICAgICBpdGVyMiAhPSBjdXJT ZWdtZW50cy5lbmQoKTsKKyAgICAgICAgICAgICAgICAgICAgIGl0ZXIyKyspIHsKKyAgICAgICAg ICAgICAgICAgICAgU2VnbWVudCogc2VnMiA9ICppdGVyMjsKKyAgICAgICAgICAgICAgICAgICAg aWYgKHNlZzItPmtpbmQoKSA9PSBTZWdtZW50OjprQ3ViaWMgJiYgc2VnICE9IHNlZzIpIHsKKyAg ICAgICAgICAgICAgICAgICAgICAgIGZvciAoaW50IGkgPSAwOyBpIDwgc2VnLT5udW1Ucmlhbmds ZXMoKTsgaSsrKSB7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgTG9jYWxUcmlhbmd1bGF0 b3I6OlRyaWFuZ2xlKiB0cmlhbmdsZSA9IHNlZy0+Z2V0VHJpYW5nbGUoaSk7CisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgZm9yIChpbnQgaiA9IDA7IGogPCBzZWcyLT5udW1UcmlhbmdsZXMo KTsgaisrKSB7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIExvY2FsVHJpYW5ndWxh dG9yOjpUcmlhbmdsZSogdHJpYW5nbGUyID0gc2VnMi0+Z2V0VHJpYW5nbGUoaik7CisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIGlmICh0cmlhbmdsZXNPdmVybGFwKHRyaWFuZ2xlLCB0 cmlhbmdsZTIpKSB7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25kaXRp b25hbGx5U3ViZGl2aWRlKHNlZywgJm5leHRTZWdtZW50cyk7CisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBjb25kaXRpb25hbGx5U3ViZGl2aWRlKHNlZzIsICZuZXh0U2VnbWVu dHMpOworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAg ICAgICB9CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgfQorICAgICAgICB9CisKKyAg ICAgICAgY3VyU2VnbWVudHMgPSBuZXh0U2VnbWVudHM7CisgICAgICAgIG5leHRTZWdtZW50cy5j bGVhcigpOworICAgIH0KK30KKyNlbmRpZgorCisvLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKy8vIFN0cnVjdHVy ZXMgYW5kIGNhbGxiYWNrcyBmb3IgdGVzc2VsbGF0aW9uIG9mIHRoZSBpbnRlcmlvciByZWdpb24g b2YKKy8vIHRoZSBjb250b3Vycy4KKworLy8gVGhlIHVzZXIgZGF0YSBmb3IgdGhlIEdMVSB0ZXNz ZWxsYXRvci4KK3N0cnVjdCBUZXNzZWxsYXRpb25TdGF0ZSB7CisgICAgUGF0aENhY2hlKiBjYWNo ZTsKKyAgICBWZWN0b3I8dm9pZCo+IGFsbG9jYXRlZFBvaW50ZXJzOworfTsKKworc3RhdGljIHZv aWQgVmVydGV4Q2FsbGJhY2sodm9pZCogdmVydGV4RGF0YSwgdm9pZCogZGF0YSkKK3sKKyAgICBU ZXNzZWxsYXRpb25TdGF0ZSogc3RhdGUgPSBzdGF0aWNfY2FzdDxUZXNzZWxsYXRpb25TdGF0ZSo+ KGRhdGEpOworICAgIFBhdGhDYWNoZSogY2FjaGUgPSBzdGF0ZS0+Y2FjaGU7CisgICAgR0xkb3Vi bGUqIGxvY2F0aW9uID0gc3RhdGljX2Nhc3Q8R0xkb3VibGUqPih2ZXJ0ZXhEYXRhKTsKKyAgICBj YWNoZS0+YWRkSW50ZXJpb3JWZXJ0ZXgoc3RhdGljX2Nhc3Q8ZmxvYXQ+KGxvY2F0aW9uWzBdKSwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc3RhdGljX2Nhc3Q8ZmxvYXQ+KGxvY2F0aW9u WzFdKSk7Cit9CisKK3N0YXRpYyB2b2lkIENvbWJpbmVDYWxsYmFjayhHTGRvdWJsZSBjb29yZHNb M10sIHZvaWQqIHZlcnRleERhdGFbNF0sCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgR0xm bG9hdCB3ZWlnaHRbNF0sIHZvaWQqKiBvdXREYXRhLAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHZvaWQqIHBvbHlnb25EYXRhKQoreworICAgIFRlc3NlbGxhdGlvblN0YXRlKiBzdGF0ZSA9 IHN0YXRpY19jYXN0PFRlc3NlbGxhdGlvblN0YXRlKj4ocG9seWdvbkRhdGEpOworICAgIEdMZG91 YmxlKiBvdXRWZXJ0ZXggPSBzdGF0aWNfY2FzdDxHTGRvdWJsZSo+KG1hbGxvYygzICogc2l6ZW9m KEdMZG91YmxlKSkpOworICAgIHN0YXRlLT5hbGxvY2F0ZWRQb2ludGVycy5hcHBlbmQob3V0VmVy dGV4KTsKKyAgICBvdXRWZXJ0ZXhbMF0gPSBjb29yZHNbMF07CisgICAgb3V0VmVydGV4WzFdID0g Y29vcmRzWzFdOworICAgIG91dFZlcnRleFsyXSA9IGNvb3Jkc1syXTsKKyAgICAqb3V0RGF0YSA9 IG91dFZlcnRleDsKK30KKworc3RhdGljIHZvaWQgRWRnZUZsYWdDYWxsYmFjayhHTGJvb2xlYW4g ZmxhZykKK3sKKyAgICAvLyBOby1vcCBqdXN0IHRvIHByZXZlbnQgdHJpYW5nbGUgc3RyaXBzIGFu ZCBmYW5zIGZyb20gYmVpbmcgcGFzc2VkCisgICAgLy8gdG8gdXMKK30KKwordm9pZCBQYXRoUHJv Y2Vzc29yOjp0ZXNzZWxsYXRlSW50ZXJpb3IoUGF0aENhY2hlKiBjYWNoZSkKK3sKKyAgICAvLyBC ZWNhdXNlIHRoZSBHTFUgdGVzc2VsbGF0b3IgcmVxdWlyZXMgaXRzIGlucHV0IGluCisgICAgLy8g ZG91YmxlLXByZWNpc2lvbiBmb3JtYXQsIHdlIG5lZWQgdG8gbWFrZSBhIHNlcGFyYXRlIGNvcHkg b2YgdGhlCisgICAgLy8gZGF0YS4KKyAgICBWZWN0b3I8R0xkb3VibGU+IHZlcnRleERhdGE7Cisg ICAgVmVjdG9yPHNpemVfdD4gY29udG91ckVuZGluZ3M7CisgICAgLy8gRm9yIGF2b2lkaW5nIGFk ZGluZyBjb2luY2lkZW50IHZlcnRpY2VzLgorICAgIGZsb2F0IGN1clggPSAwLCBjdXJZID0gMDsK KyAgICBmb3IgKFZlY3RvcjxDb250b3VyKj46Oml0ZXJhdG9yIGl0ZXIgPSBtX2NvbnRvdXJzLmJl Z2luKCk7CisgICAgICAgICBpdGVyICE9IG1fY29udG91cnMuZW5kKCk7CisgICAgICAgICBpdGVy KyspIHsKKyAgICAgICAgQ29udG91ciogY3VyID0gKml0ZXI7CisgICAgICAgIGJvb2wgZmlyc3Qg PSB0cnVlOworICAgICAgICBmb3IgKFNlZ21lbnQqIHNlZyA9IGN1ci0+YmVnaW4oKTsgc2VnICE9 IGN1ci0+ZW5kKCk7IHNlZyA9IHNlZy0+bmV4dCgpKSB7CisgICAgICAgICAgICBpbnQgbnVtSW50 ZXJpb3JWZXJ0aWNlcyA9IHNlZy0+bnVtSW50ZXJpb3JWZXJ0aWNlcygpOworICAgICAgICAgICAg Zm9yIChpbnQgaSA9IDA7IGkgPCBudW1JbnRlcmlvclZlcnRpY2VzIC0gMTsgaSsrKSB7CisgICAg ICAgICAgICAgICAgRmxvYXRQb2ludCBwb2ludCA9IHNlZy0+Z2V0SW50ZXJpb3JWZXJ0ZXgoaSk7 CisgICAgICAgICAgICAgICAgaWYgKGZpcnN0KSB7CisgICAgICAgICAgICAgICAgICAgIGZpcnN0 ID0gZmFsc2U7CisgICAgICAgICAgICAgICAgICAgIHZlcnRleERhdGEuYXBwZW5kKHBvaW50Lngo KSk7CisgICAgICAgICAgICAgICAgICAgIHZlcnRleERhdGEuYXBwZW5kKHBvaW50LnkoKSk7Cisg ICAgICAgICAgICAgICAgICAgIHZlcnRleERhdGEuYXBwZW5kKDApOworICAgICAgICAgICAgICAg ICAgICBjdXJYID0gcG9pbnQueCgpOworICAgICAgICAgICAgICAgICAgICBjdXJZID0gcG9pbnQu eSgpOworICAgICAgICAgICAgICAgIH0gZWxzZSBpZiAocG9pbnQueCgpICE9IGN1clggfHwgcG9p bnQueSgpICE9IGN1clkpICB7CisgICAgICAgICAgICAgICAgICAgIHZlcnRleERhdGEuYXBwZW5k KHBvaW50LngoKSk7CisgICAgICAgICAgICAgICAgICAgIHZlcnRleERhdGEuYXBwZW5kKHBvaW50 LnkoKSk7CisgICAgICAgICAgICAgICAgICAgIHZlcnRleERhdGEuYXBwZW5kKDApOworICAgICAg ICAgICAgICAgICAgICBjdXJYID0gcG9pbnQueCgpOworICAgICAgICAgICAgICAgICAgICBjdXJZ ID0gcG9pbnQueSgpOworICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgIH0KKyAgICAgICAg fQorICAgICAgICBjb250b3VyRW5kaW5ncy5hcHBlbmQodmVydGV4RGF0YS5zaXplKCkpOworICAg IH0KKyAgICAvLyBOb3cgdGhhdCB3ZSBoYXZlIGFsbCBvZiB0aGUgdmVydGV4IGRhdGEgaW4gYSBz dGFibGUgbG9jYXRpb24gaW4KKyAgICAvLyBtZW1vcnksIGNhbGwgdGhlIHRlc3NlbGxhdG9yLgor ICAgIEdMVXRlc3NlbGF0b3IqIHRlc3MgPSBpbnRlcm5hbF9nbHVOZXdUZXNzKCk7CisgICAgVGVz c2VsbGF0aW9uU3RhdGUgc3RhdGU7CisgICAgc3RhdGUuY2FjaGUgPSBjYWNoZTsKKyAgICBpbnRl cm5hbF9nbHVUZXNzQ2FsbGJhY2sodGVzcywgR0xVX1RFU1NfVkVSVEVYX0RBVEEsCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHJlaW50ZXJwcmV0X2Nhc3Q8R0x2b2lkICgqKSgpPihWZXJ0 ZXhDYWxsYmFjaykpOworICAgIGludGVybmFsX2dsdVRlc3NDYWxsYmFjayh0ZXNzLCBHTFVfVEVT U19DT01CSU5FX0RBVEEsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJlaW50ZXJwcmV0 X2Nhc3Q8R0x2b2lkICgqKSgpPihDb21iaW5lQ2FsbGJhY2spKTsKKyAgICBpbnRlcm5hbF9nbHVU ZXNzQ2FsbGJhY2sodGVzcywgR0xVX1RFU1NfRURHRV9GTEFHLAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICByZWludGVycHJldF9jYXN0PEdMdm9pZCAoKikoKT4oRWRnZUZsYWdDYWxsYmFj aykpOworICAgIGludGVybmFsX2dsdVRlc3NCZWdpblBvbHlnb24odGVzcywgJnN0YXRlKTsKKyAg ICBpbnRlcm5hbF9nbHVUZXNzQmVnaW5Db250b3VyKHRlc3MpOworICAgIEdMZG91YmxlKiBiYXNl ID0gdmVydGV4RGF0YS5kYXRhKCk7CisgICAgaW50IGNvbnRvdXJJbmRleCA9IDA7CisgICAgZm9y IChzaXplX3QgaSA9IDA7IGkgPCB2ZXJ0ZXhEYXRhLnNpemUoKTsgaSArPSAzKSB7CisgICAgICAg IGlmIChpID09IGNvbnRvdXJFbmRpbmdzW2NvbnRvdXJJbmRleF0pIHsKKyAgICAgICAgICAgIGlu dGVybmFsX2dsdVRlc3NFbmRDb250b3VyKHRlc3MpOworICAgICAgICAgICAgaW50ZXJuYWxfZ2x1 VGVzc0JlZ2luQ29udG91cih0ZXNzKTsKKyAgICAgICAgICAgICsrY29udG91ckluZGV4OworICAg ICAgICB9CisgICAgICAgIGludGVybmFsX2dsdVRlc3NWZXJ0ZXgodGVzcywgJmJhc2VbaV0sICZi YXNlW2ldKTsKKyAgICB9CisgICAgaW50ZXJuYWxfZ2x1VGVzc0VuZENvbnRvdXIodGVzcyk7Cisg ICAgaW50ZXJuYWxfZ2x1VGVzc0VuZFBvbHlnb24odGVzcyk7CisgICAgZm9yIChzaXplX3QgaSA9 IDA7IGkgPCBzdGF0ZS5hbGxvY2F0ZWRQb2ludGVycy5zaXplKCk7IGkrKykKKyAgICAgICAgZnJl ZShzdGF0ZS5hbGxvY2F0ZWRQb2ludGVyc1tpXSk7CisgICAgaW50ZXJuYWxfZ2x1RGVsZXRlVGVz cyh0ZXNzKTsKK30KKworfSAvLyBuYW1lc3BhY2UgZ3B1Cit9IC8vIG5hbWVzcGFjZSBXZWJDb3Jl CkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9QYXRoUHJvY2Vzc29yLmgKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUvUGF0aFByb2Nlc3Nvci5o CShyZXZpc2lvbiAwKQorKysgV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUvUGF0aFByb2Nl c3Nvci5oCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDEyNyBAQAorLyoKKyAqIENvcHlyaWdodCAy MDEwLCBHb29nbGUgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3Ry aWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhv dXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xs b3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlv bnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy LgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNl IHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMg YW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5k L29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0aW9uLgor ICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9m IGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBw cm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBw cmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURF RCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElTIiBB TkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QK KyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZ IEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQu IElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9S UyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICogU1BF Q0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVU IE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBT RVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJ TlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFC SUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAq IChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBP VVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRI RSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisvLyBUaGUgbWFpbiBlbnRyeSBw b2ludCBmb3IgTG9vcCBhbmQgQmxpbm4ncyBHUFUgYWNjZWxlcmF0ZWQgY3VydmUKKy8vIHJlbmRl cmluZyBhbGdvcml0aG0uCisKKyNpZm5kZWYgZ3B1X1BhdGhQcm9jZXNzb3JfaAorI2RlZmluZSBn cHVfUGF0aFByb2Nlc3Nvcl9oCisKKyNpbmNsdWRlIDx3dGYvTm9uY29weWFibGUuaD4KKyNpbmNs dWRlIDx3dGYvUmVmUHRyLmg+CisjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgorCituYW1lc3BhY2Ug V2ViQ29yZSB7CisKK2NsYXNzIFBhdGg7CisKK25hbWVzcGFjZSBncHUgeworCitjbGFzcyBBcmVu YTsKK2NsYXNzIENvbnRvdXI7CitjbGFzcyBQYXRoQ2FjaGU7CitjbGFzcyBTZWdtZW50OworCisv LyBUaGUgUGF0aFByb2Nlc3NvciB0dXJucyBhIFBhdGggKGFzc3VtZWQgdG8gY29udGFpbiBvbmUg b3IgbW9yZQorLy8gY2xvc2VkIHJlZ2lvbnMpIGludG8gYSBzZXQgb2YgZXh0ZXJpb3IgYW5kIGlu dGVyaW9yIHRyaWFuZ2xlcywKKy8vIHN0b3JlZCBpbiB0aGUgUGF0aENhY2hlLiBUaGUgZXh0ZXJp b3IgdHJpYW5nbGVzIGhhdmUgYXNzb2NpYXRlZCAzRAorLy8gdGV4dHVyZSBjb29yZGluYXRlcyB3 aGljaCBhcmUgdXNlZCB0byBldmFsdWF0ZSB0aGUgY3VydmUncworLy8gaW5zaWRlL291dHNpZGUg ZnVuY3Rpb24gb24gYSBwZXItcGl4ZWwgYmFzaXMuIFRoZSBpbnRlcmlvcgorLy8gdHJpYW5nbGVz IGFyZSBmaWxsZWQgd2l0aCAxMDAlIG9wYWNpdHkuCisvLworLy8gTm90ZSB0aGF0IHRoZSBmaWxs IHN0eWxlIGFuZCBtYW5hZ2VtZW50IG9mIG11bHRpcGxlIGxheWVycyBhcmUKKy8vIHNlcGFyYXRl IGNvbmNlcm5zLCBoYW5kbGVkIGF0IGEgaGlnaGVyIGxldmVsIHdpdGggc2hhZGVycyBhbmQKKy8v IHBvbHlnb24gb2Zmc2V0cy4KK2NsYXNzIFBhdGhQcm9jZXNzb3IgeworcHVibGljOgorICAgIFBh dGhQcm9jZXNzb3IoKTsKKyAgICBleHBsaWNpdCBQYXRoUHJvY2Vzc29yKEFyZW5hKiBhcmVuYSk7 CisgICAgflBhdGhQcm9jZXNzb3IoKTsKKworICAgIC8vIFRyYW5zZm9ybXMgdGhlIGdpdmVuIHBh dGggaW50byBhIHRyaWFuZ2xlIG1lc2ggZm9yIHJlbmRlcmluZworICAgIC8vIHVzaW5nIExvb3Ag YW5kIEJsaW5uJ3Mgc2hhZGVyLCBwbGFjaW5nIHRoZSByZXN1bHQgaW50byB0aGUgZ2l2ZW4KKyAg ICAvLyBQYXRoQ2FjaGUuCisgICAgdm9pZCBwcm9jZXNzKGNvbnN0IFBhdGgmIHBhdGgsIFBhdGhD YWNoZSogY2FjaGUpOworCisjaWZuZGVmIE5ERUJVRworICAgIC8vIEVuYWJsZXMgb3IgZGlzYWJs ZXMgdmVyYm9zZSBsb2dnaW5nIGluIGRlYnVnIG1vZGUuCisgICAgdm9pZCBzZXRWZXJib3NlTG9n Z2luZyhib29sIG9uT3JPZmYpOworI2VuZGlmCisKK3ByaXZhdGU6CisgICAgLy8gQnVpbGRzIGEg bGlzdCBvZiBjb250b3VycyBmb3IgdGhlIGdpdmVuIHBhdGguCisgICAgdm9pZCBidWlsZENvbnRv dXJzKGNvbnN0IFBhdGgmIHBhdGgpOworCisgICAgLy8gRGV0ZXJtaW5lcyB3aGV0aGVyIHRoZSBs ZWZ0IG9yIHJpZ2h0IHNpZGUgb2YgZWFjaCBjb250b3VyIHNob3VsZAorICAgIC8vIGJlIGZpbGxl ZC4KKyAgICB2b2lkIGRldGVybWluZVNpZGVzVG9GaWxsKCk7CisKKyAgICAvLyBEZXRlcm1pbmVz IHdoZXRoZXIgdGhlIGdpdmVuIChjbG9zZWQpIGNvbnRvdXIgaXMgb3JpZW50ZWQKKyAgICAvLyBj bG9ja3dpc2Ugb3IgY291bnRlcmNsb2Nrd2lzZS4KKyAgICB2b2lkIGRldGVybWluZU9yaWVudGF0 aW9uKENvbnRvdXIqIGNvbnRvdXIpOworCisgICAgLy8gU3ViZGl2aWRlcyB0aGUgY3VydmVzIHNv IHRoYXQgdGhlcmUgYXJlIG5vIG92ZXJsYXBzIG9mIHRoZQorICAgIC8vIHRyaWFuZ2xlcyBhc3Nv Y2lhdGVkIHdpdGggdGhlIGN1cnZlcycgY29udHJvbCBwb2ludHMuCisgICAgdm9pZCBzdWJkaXZp ZGVDdXJ2ZXMoKTsKKworICAgIC8vIEhlbHBlciBmdW5jdGlvbiB1c2VkIGR1cmluZyBjdXJ2ZSBz dWJkaXZpc2lvbi4KKyAgICB2b2lkIGNvbmRpdGlvbmFsbHlTdWJkaXZpZGUoU2VnbWVudCogc2Vn LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBWZWN0b3I8U2VnbWVudCo+KiBuZXh0 U2VnbWVudHMpOworCisgICAgLy8gVGVzc2VsbGF0ZXMgdGhlIGludGVyaW9yIHJlZ2lvbnMgb2Yg dGhlIGNvbnRvdXJzLgorICAgIHZvaWQgdGVzc2VsbGF0ZUludGVyaW9yKFBhdGhDYWNoZSogY2Fj aGUpOworCisgICAgLy8gRm9yIGRlYnVnZ2luZyB0aGUgb3JpZW50YXRpb24gY29tcHV0YXRpb24u IFJldHVybnMgYWxsIG9mIHRoZQorICAgIC8vIHNlZ21lbnRzIG92ZXJsYXBwaW5nIHRoZSBnaXZl biBZIGNvb3JkaW5hdGUuCisgICAgVmVjdG9yPFNlZ21lbnQqPiBhbGxTZWdtZW50c092ZXJsYXBw aW5nWShDb250b3VyKiBxdWVyeUNvbnRvdXIsIGZsb2F0IHgsIGZsb2F0IHkpOworCisjaWZuZGVm IE5ERUJVRworICAgIC8vIEZvciBkZWJ1Z2dpbmcgdGhlIGN1cnZlIHN1YmRpdmlzaW9uIGFsZ29y aXRobS4gU3ViZGl2aWRlcyB0aGUKKyAgICAvLyBjdXJ2ZXMgdXNpbmcgYW4gYWx0ZXJuYXRlLCBz bG93IChPKG5eMykpIGFsZ29yaXRobS4KKyAgICB2b2lkIHN1YmRpdmlkZUN1cnZlc1Nsb3coKTsK KyNlbmRpZgorCisgICAgLy8gQXJlbmEgZnJvbSB3aGljaCB0byBhbGxvY2F0ZSB0ZW1wb3Jhcnkg b2JqZWN0cy4KKyAgICBSZWZQdHI8QXJlbmE+IG1fYXJlbmE7CisKKyAgICAvLyBUaGUgY29udG91 cnMgZGVzY3JpYmVkIGJ5IHRoZSBwYXRoLgorICAgIFZlY3RvcjxDb250b3VyKj4gbV9jb250b3Vy czsKKworI2lmbmRlZiBOREVCVUcKKyAgICAvLyBXaGV0aGVyIG9yIG5vdCB0byBwZXJmb3JtIHZl cmJvc2UgbG9nZ2luZyBpbiBkZWJ1ZyBtb2RlLgorICAgIGJvb2wgbV92ZXJib3NlTG9nZ2luZzsK KyNlbmRpZgorfTsKKworfSAvLyBuYW1lc3BhY2UgZ3B1Cit9IC8vIG5hbWVzcGFjZSBXZWJDb3Jl CisKKyNlbmRpZiAvLyBncHVfUGF0aFByb2Nlc3Nvcl9oCg== 82741 2011-02-16 19:35:16 -0800 2011-02-17 11:05:30 -0800 Patch bug-44729-20110216193515.patch text/plain 17958 kbr SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDc4Nzc2KQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsNDMgQEAKKzIwMTEtMDItMTYgIEtlbm5ldGgg UnVzc2VsbCAgPGtickBnb29nbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIEFkZCBzdXBwb3J0IGZvciBHUFUgYWNjZWxlcmF0ZWQgcGF0aCBy ZW5kZXJpbmcKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTQ0NzI5CisKKyAgICAgICAgSW5jb3Jwb3JhdGVzIHRoZSBMb29wIGFuZCBCbGlubiBwYXRoIHJl bmRlcmluZyBhbGdvcml0aG0gYXMgYW4KKyAgICAgICAgb3B0aW9uIHRvIHRoZSBHUFUtYWNjZWxl cmF0ZWQgY2FudmFzIGNvZGUsIGN1cnJlbnRseSBvbmx5IGNvbXBpbGVkCisgICAgICAgIGluIHRv IHRoZSBDaHJvbWl1bSBwb3J0LiBDdXJyZW50bHkgaXQncyB0b2dnbGVkIGJ5IGNoYW5naW5nIGEK KyAgICAgICAgaGFyZGNvZGVkIGNvbnN0YW50IGluCisgICAgICAgIFNoYXJlZEdyYXBoaWNzQ29u dGV4dDNEOjp1c2VMb29wQmxpbm5Gb3JQYXRoUmVuZGVyaW5nKCkgYW5kIGlzCisgICAgICAgIGRp c2FibGVkIGJ5IGRlZmF1bHQuIFRoaXMgbWVjaGFuaXNtIGNhbiBiZSBpbXByb3ZlZCBvbmNlIHdl J3ZlCisgICAgICAgIGdhaW5lZCBtb3JlIGNvbmZpZGVuY2UgaW4gdGhlIGltcGxlbWVudGF0aW9u LiBUaGVyZSBhcmUgc29tZSBrbm93bgorICAgICAgICBidWdzIHRoYXQgbmVlZCB0byBiZSBmaXhl ZCBmaXJzdC4KKworICAgICAgICBObyBuZXcgdGVzdHM7IHJhbiBzb21lIDJEIENhbnZhcyB0ZXN0 cyBtYW51YWxseSB3aXRoIHRoZSBuZXcgZmxhZworICAgICAgICBib3RoIGVuYWJsZWQgYW5kIGRp c2FibGVkLgorCisgICAgICAgICogV2ViQ29yZS5neXBpOgorICAgICAgICAqIHBsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL0dMRVMyQ2FudmFzLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkdMRVMy Q2FudmFzOjpHTEVTMkNhbnZhcyk6CisgICAgICAgIChXZWJDb3JlOjpHTEVTMkNhbnZhczo6Zmls bFBhdGgpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0dMRVMyQ2FudmFz Lmg6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L0xvb3BCbGlubkNsYXNzaWZpZXIu aDoKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9ncHUvTG9vcEJsaW5uTG9jYWxUcmlhbmd1 bGF0b3IuaDoKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9ncHUvU2hhcmVkR3JhcGhpY3ND b250ZXh0M0QuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkR3JhcGhpY3NDb250ZXh0M0Q6 OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpTaGFyZWRHcmFwaGljc0NvbnRleHQzRDo6U2hh cmVkR3JhcGhpY3NDb250ZXh0M0QpOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkR3JhcGhpY3ND b250ZXh0M0Q6OmNyZWF0ZUJ1ZmZlcik6CisgICAgICAgIChXZWJDb3JlOjpTaGFyZWRHcmFwaGlj c0NvbnRleHQzRDo6YmluZEJ1ZmZlcik6CisgICAgICAgIChXZWJDb3JlOjpTaGFyZWRHcmFwaGlj c0NvbnRleHQzRDo6YnVmZmVyRGF0YSk6CisgICAgICAgIChXZWJDb3JlOjpTaGFyZWRHcmFwaGlj c0NvbnRleHQzRDo6YnVmZmVyU3ViRGF0YSk6CisgICAgICAgIChXZWJDb3JlOjpTaGFyZWRHcmFw aGljc0NvbnRleHQzRDo6dXNlTG9vcEJsaW5uRm9yUGF0aFJlbmRlcmluZyk6CisgICAgICAgIChX ZWJDb3JlOjpTaGFyZWRHcmFwaGljc0NvbnRleHQzRDo6dXNlTG9vcEJsaW5uSW50ZXJpb3JQcm9n cmFtKToKKyAgICAgICAgKFdlYkNvcmU6OlNoYXJlZEdyYXBoaWNzQ29udGV4dDNEOjp1c2VMb29w Qmxpbm5FeHRlcmlvclByb2dyYW0pOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2dwdS9T aGFyZWRHcmFwaGljc0NvbnRleHQzRC5oOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL3Nr aWEvR3JhcGhpY3NDb250ZXh0U2tpYS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0Nv bnRleHQ6OmZpbGxQYXRoKToKKwogMjAxMS0wMi0xNiAgQWJoaXNoZWsgQXJ5YSAgPGluZmVybm9A Y2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEphbWVzIFJvYmluc29uLgpJbmRl eDogU291cmNlL1dlYkNvcmUvV2ViQ29yZS5neXBpCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJD b3JlL1dlYkNvcmUuZ3lwaQkocmV2aXNpb24gNzg3NzYpCisrKyBTb3VyY2UvV2ViQ29yZS9XZWJD b3JlLmd5cGkJKHdvcmtpbmcgY29weSkKQEAgLTI2ODQsNiArMjY4NCwyMyBAQAogICAgICAgICAg ICAgJ3BsYXRmb3JtL2dyYXBoaWNzL2ZpbHRlcnMvU291cmNlR3JhcGhpYy5oJywKICAgICAgICAg ICAgICdwbGF0Zm9ybS9ncmFwaGljcy9ncHUvRHJhd2luZ0J1ZmZlci5jcHAnLAogICAgICAgICAg ICAgJ3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9EcmF3aW5nQnVmZmVyLmgnLAorICAgICAgICAgICAg J3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9Mb29wQmxpbm5DbGFzc2lmaWVyLmNwcCcsCisgICAgICAg ICAgICAncGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L0xvb3BCbGlubkNsYXNzaWZpZXIuaCcsCisgICAg ICAgICAgICAncGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L0xvb3BCbGlubkNvbnN0YW50cy5oJywKKyAg ICAgICAgICAgICdwbGF0Zm9ybS9ncmFwaGljcy9ncHUvTG9vcEJsaW5uTG9jYWxUcmlhbmd1bGF0 b3IuY3BwJywKKyAgICAgICAgICAgICdwbGF0Zm9ybS9ncmFwaGljcy9ncHUvTG9vcEJMaW5uTG9j YWxUcmlhbmd1bGF0b3IuaCcsCisgICAgICAgICAgICAncGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L0xv b3BCbGlubk1hdGhVdGlscy5jcHAnLAorICAgICAgICAgICAgJ3BsYXRmb3JtL2dyYXBoaWNzL2dw dS9Mb29wQmxpbm5NYXRoVXRpbHMuaCcsCisgICAgICAgICAgICAncGxhdGZvcm0vZ3JhcGhpY3Mv Z3B1L0xvb3BCbGlublBhdGhDYWNoZS5jcHAnLAorICAgICAgICAgICAgJ3BsYXRmb3JtL2dyYXBo aWNzL2dwdS9Mb29wQmxpbm5QYXRoQ2FjaGUuaCcsCisgICAgICAgICAgICAncGxhdGZvcm0vZ3Jh cGhpY3MvZ3B1L0xvb3BCbGlublBhdGhQcm9jZXNzb3IuY3BwJywKKyAgICAgICAgICAgICdwbGF0 Zm9ybS9ncmFwaGljcy9ncHUvTG9vcEJsaW5uUGF0aFByb2Nlc3Nvci5oJywKKyAgICAgICAgICAg ICdwbGF0Zm9ybS9ncmFwaGljcy9ncHUvTG9vcEJsaW5uU2hhZGVyLmNwcCcsCisgICAgICAgICAg ICAncGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L0xvb3BCbGlublNoYWRlci5oJywKKyAgICAgICAgICAg ICdwbGF0Zm9ybS9ncmFwaGljcy9ncHUvTG9vcEJsaW5uU29saWRGaWxsU2hhZGVyLmNwcCcsCisg ICAgICAgICAgICAncGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L0xvb3BCbGlublNvbGlkRmlsbFNoYWRl ci5oJywKKyAgICAgICAgICAgICdwbGF0Zm9ybS9ncmFwaGljcy9ncHUvTG9vcEJsaW5uVGV4dHVy ZUNvb3Jkcy5jcHAnLAorICAgICAgICAgICAgJ3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9Mb29wQmxp bm5UZXh0dXJlQ29vcmRzLmgnLAogICAgICAgICAgICAgJ3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9Q T0RBcmVuYS5oJywKICAgICAgICAgICAgICdwbGF0Zm9ybS9ncmFwaGljcy9ncHUvUE9ESW50ZXJ2 YWwuaCcsCiAgICAgICAgICAgICAncGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L1BPREludGVydmFsVHJl ZS5oJywKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0dM RVMyQ2FudmFzLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9HTEVTMkNhbnZhcy5jcHAJKHJldmlzaW9uIDc4Nzc2KQorKysgU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vR0xFUzJDYW52YXMuY3BwCSh3b3Jr aW5nIGNvcHkpCkBAIC0zOCw2ICszOCw4IEBACiAjaW5jbHVkZSAiR3JhcGhpY3NDb250ZXh0M0Qu aCIKICNpbmNsdWRlICJpbnRlcm5hbF9nbHUuaCIKICNpbmNsdWRlICJJbnRSZWN0LmgiCisjaW5j bHVkZSAiTG9vcEJsaW5uUGF0aFByb2Nlc3Nvci5oIgorI2luY2x1ZGUgIkxvb3BCbGlublNvbGlk RmlsbFNoYWRlci5oIgogI2luY2x1ZGUgIlBhdGguaCIKICNpbmNsdWRlICJQbGF0Zm9ybVN0cmlu Zy5oIgogI2luY2x1ZGUgIlNoYXJlZEdyYXBoaWNzQ29udGV4dDNELmgiCkBAIC0xNzAsNiArMTcy LDcgQEAgR0xFUzJDYW52YXM6OkdMRVMyQ2FudmFzKFNoYXJlZEdyYXBoaWNzQwogICAgICwgbV9j b250ZXh0KGNvbnRleHQpCiAgICAgLCBtX2RyYXdpbmdCdWZmZXIoZHJhd2luZ0J1ZmZlcikKICAg ICAsIG1fc3RhdGUoMCkKKyAgICAsIG1fcGF0aFZlcnRleEJ1ZmZlcigwKQogewogICAgIG1fZmxp cE1hdHJpeC50cmFuc2xhdGUoLTEuMGYsIDEuMGYpOwogICAgIG1fZmxpcE1hdHJpeC5zY2FsZSgy LjBmIC8gc2l6ZS53aWR0aCgpLCAtMi4wZiAvIHNpemUuaGVpZ2h0KCkpOwpAQCAtNTUzLDI4ICs1 NTYsNjEgQEAgdm9pZCBHTEVTMkNhbnZhczo6Y3JlYXRlVmVydGV4QnVmZmVyRnJvbQogCiB2b2lk IEdMRVMyQ2FudmFzOjpmaWxsUGF0aChjb25zdCBQYXRoJiBwYXRoLCBjb25zdCBDb2xvciYgY29s b3IpCiB7Ci0gICAgaW50IGNvdW50OwotICAgIHVuc2lnbmVkIHZlcnRleEJ1ZmZlciwgaW5kZXhC dWZmZXI7Ci0gICAgY3JlYXRlVmVydGV4QnVmZmVyRnJvbVBhdGgocGF0aCwgJmNvdW50LCAmdmVy dGV4QnVmZmVyLCAmaW5kZXhCdWZmZXIpOwotICAgIG1fY29udGV4dC0+Z3JhcGhpY3NDb250ZXh0 M0QoKS0+YmluZEJ1ZmZlcihHcmFwaGljc0NvbnRleHQzRDo6QVJSQVlfQlVGRkVSLCB2ZXJ0ZXhC dWZmZXIpOwotICAgIGNoZWNrR0xFcnJvcigiYmluZEJ1ZmZlciIpOwotICAgIG1fY29udGV4dC0+ Z3JhcGhpY3NDb250ZXh0M0QoKS0+YmluZEJ1ZmZlcihHcmFwaGljc0NvbnRleHQzRDo6RUxFTUVO VF9BUlJBWV9CVUZGRVIsIGluZGV4QnVmZmVyKTsKLSAgICBjaGVja0dMRXJyb3IoImJpbmRCdWZm ZXIiKTsKLQotICAgIEFmZmluZVRyYW5zZm9ybSBtYXRyaXgobV9mbGlwTWF0cml4KTsKLSAgICBt YXRyaXggKj0gbV9zdGF0ZS0+bV9jdG07Ci0KLSAgICBtX2NvbnRleHQtPnVzZUZpbGxTb2xpZFBy b2dyYW0obWF0cml4LCBjb2xvcik7Ci0gICAgY2hlY2tHTEVycm9yKCJ1c2VGaWxsU29saWRQcm9n cmFtIik7Ci0KLSAgICBtX2NvbnRleHQtPmdyYXBoaWNzQ29udGV4dDNEKCktPmRyYXdFbGVtZW50 cyhHcmFwaGljc0NvbnRleHQzRDo6VFJJQU5HTEVTLCBjb3VudCwgR3JhcGhpY3NDb250ZXh0M0Q6 OlVOU0lHTkVEX1NIT1JULCAwKTsKLSAgICBjaGVja0dMRXJyb3IoImRyYXdBcnJheXMiKTsKKyAg ICBpZiAoU2hhcmVkR3JhcGhpY3NDb250ZXh0M0Q6OnVzZUxvb3BCbGlubkZvclBhdGhSZW5kZXJp bmcoKSkgeworICAgICAgICBiaW5kRnJhbWVidWZmZXIoKTsKKyAgICAgICAgbV9jb250ZXh0LT5h cHBseUNvbXBvc2l0ZU9wZXJhdG9yKG1fc3RhdGUtPm1fY29tcG9zaXRlT3ApOworCisgICAgICAg IG1fcGF0aENhY2hlLmNsZWFyKCk7CisgICAgICAgIExvb3BCbGlublBhdGhQcm9jZXNzb3IgcHJv Y2Vzc29yOworICAgICAgICBwcm9jZXNzb3IucHJvY2VzcyhwYXRoLCBtX3BhdGhDYWNoZSk7Cisg ICAgICAgIGlmICghbV9wYXRoVmVydGV4QnVmZmVyKQorICAgICAgICAgICAgbV9wYXRoVmVydGV4 QnVmZmVyID0gbV9jb250ZXh0LT5jcmVhdGVCdWZmZXIoKTsKKyAgICAgICAgbV9jb250ZXh0LT5i aW5kQnVmZmVyKEdyYXBoaWNzQ29udGV4dDNEOjpBUlJBWV9CVUZGRVIsIG1fcGF0aFZlcnRleEJ1 ZmZlcik7CisgICAgICAgIGludCBieXRlU2l6ZU9mVmVydGljZXMgPSAyICogbV9wYXRoQ2FjaGUu bnVtYmVyT2ZWZXJ0aWNlcygpICogc2l6ZW9mKGZsb2F0KTsKKyAgICAgICAgaW50IGJ5dGVTaXpl T2ZUZXhDb29yZHMgPSAzICogbV9wYXRoQ2FjaGUubnVtYmVyT2ZWZXJ0aWNlcygpICogc2l6ZW9m KGZsb2F0KTsKKyAgICAgICAgaW50IGJ5dGVTaXplT2ZJbnRlcmlvclZlcnRpY2VzID0gMiAqIG1f cGF0aENhY2hlLm51bWJlck9mSW50ZXJpb3JWZXJ0aWNlcygpICogc2l6ZW9mKGZsb2F0KTsKKyAg ICAgICAgbV9jb250ZXh0LT5idWZmZXJEYXRhKEdyYXBoaWNzQ29udGV4dDNEOjpBUlJBWV9CVUZG RVIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBieXRlU2l6ZU9mVmVydGljZXMgKyBi eXRlU2l6ZU9mVGV4Q29vcmRzICsgYnl0ZVNpemVPZkludGVyaW9yVmVydGljZXMsCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBHcmFwaGljc0NvbnRleHQzRDo6U1RBVElDX0RSQVcpOwor ICAgICAgICBtX2NvbnRleHQtPmJ1ZmZlclN1YkRhdGEoR3JhcGhpY3NDb250ZXh0M0Q6OkFSUkFZ X0JVRkZFUiwgMCwgYnl0ZVNpemVPZlZlcnRpY2VzLCBtX3BhdGhDYWNoZS52ZXJ0aWNlcygpKTsK KyAgICAgICAgbV9jb250ZXh0LT5idWZmZXJTdWJEYXRhKEdyYXBoaWNzQ29udGV4dDNEOjpBUlJB WV9CVUZGRVIsIGJ5dGVTaXplT2ZWZXJ0aWNlcywgYnl0ZVNpemVPZlRleENvb3JkcywgbV9wYXRo Q2FjaGUudGV4Y29vcmRzKCkpOworICAgICAgICBtX2NvbnRleHQtPmJ1ZmZlclN1YkRhdGEoR3Jh cGhpY3NDb250ZXh0M0Q6OkFSUkFZX0JVRkZFUiwgYnl0ZVNpemVPZlZlcnRpY2VzICsgYnl0ZVNp emVPZlRleENvb3JkcywgYnl0ZVNpemVPZkludGVyaW9yVmVydGljZXMsIG1fcGF0aENhY2hlLmlu dGVyaW9yVmVydGljZXMoKSk7CisKKyAgICAgICAgQWZmaW5lVHJhbnNmb3JtIG1hdHJpeChtX2Zs aXBNYXRyaXgpOworICAgICAgICBtYXRyaXggKj0gbV9zdGF0ZS0+bV9jdG07CisKKyAgICAgICAg Ly8gRHJhdyB0aGUgZXh0ZXJpb3IKKyAgICAgICAgbV9jb250ZXh0LT51c2VMb29wQmxpbm5FeHRl cmlvclByb2dyYW0oMCwgYnl0ZVNpemVPZlZlcnRpY2VzLCBtYXRyaXgsIGNvbG9yKTsKKyAgICAg ICAgbV9jb250ZXh0LT5kcmF3QXJyYXlzKEdyYXBoaWNzQ29udGV4dDNEOjpUUklBTkdMRVMsIDAs IG1fcGF0aENhY2hlLm51bWJlck9mVmVydGljZXMoKSk7CisKKyAgICAgICAgLy8gRHJhdyB0aGUg aW50ZXJpb3IKKyAgICAgICAgbV9jb250ZXh0LT51c2VMb29wQmxpbm5JbnRlcmlvclByb2dyYW0o Ynl0ZVNpemVPZlZlcnRpY2VzICsgYnl0ZVNpemVPZlRleENvb3JkcywgbWF0cml4LCBjb2xvcik7 CisgICAgICAgIG1fY29udGV4dC0+ZHJhd0FycmF5cyhHcmFwaGljc0NvbnRleHQzRDo6VFJJQU5H TEVTLCAwLCBtX3BhdGhDYWNoZS5udW1iZXJPZkludGVyaW9yVmVydGljZXMoKSk7CisgICAgfSBl bHNlIHsKKyAgICAgICAgaW50IGNvdW50OworICAgICAgICB1bnNpZ25lZCB2ZXJ0ZXhCdWZmZXIs IGluZGV4QnVmZmVyOworICAgICAgICBjcmVhdGVWZXJ0ZXhCdWZmZXJGcm9tUGF0aChwYXRoLCAm Y291bnQsICZ2ZXJ0ZXhCdWZmZXIsICZpbmRleEJ1ZmZlcik7CisgICAgICAgIG1fY29udGV4dC0+ Z3JhcGhpY3NDb250ZXh0M0QoKS0+YmluZEJ1ZmZlcihHcmFwaGljc0NvbnRleHQzRDo6QVJSQVlf QlVGRkVSLCB2ZXJ0ZXhCdWZmZXIpOworICAgICAgICBjaGVja0dMRXJyb3IoImJpbmRCdWZmZXIi KTsKKyAgICAgICAgbV9jb250ZXh0LT5ncmFwaGljc0NvbnRleHQzRCgpLT5iaW5kQnVmZmVyKEdy YXBoaWNzQ29udGV4dDNEOjpFTEVNRU5UX0FSUkFZX0JVRkZFUiwgaW5kZXhCdWZmZXIpOworICAg ICAgICBjaGVja0dMRXJyb3IoImJpbmRCdWZmZXIiKTsKKworICAgICAgICBBZmZpbmVUcmFuc2Zv cm0gbWF0cml4KG1fZmxpcE1hdHJpeCk7CisgICAgICAgIG1hdHJpeCAqPSBtX3N0YXRlLT5tX2N0 bTsKKworICAgICAgICBtX2NvbnRleHQtPnVzZUZpbGxTb2xpZFByb2dyYW0obWF0cml4LCBjb2xv cik7CisgICAgICAgIGNoZWNrR0xFcnJvcigidXNlRmlsbFNvbGlkUHJvZ3JhbSIpOworCisgICAg ICAgIGJpbmRGcmFtZWJ1ZmZlcigpOworICAgICAgICBtX2NvbnRleHQtPmdyYXBoaWNzQ29udGV4 dDNEKCktPmRyYXdFbGVtZW50cyhHcmFwaGljc0NvbnRleHQzRDo6VFJJQU5HTEVTLCBjb3VudCwg R3JhcGhpY3NDb250ZXh0M0Q6OlVOU0lHTkVEX1NIT1JULCAwKTsKKyAgICAgICAgY2hlY2tHTEVy cm9yKCJkcmF3QXJyYXlzIik7CiAKLSAgICBtX2NvbnRleHQtPmdyYXBoaWNzQ29udGV4dDNEKCkt PmRlbGV0ZUJ1ZmZlcih2ZXJ0ZXhCdWZmZXIpOwotICAgIGNoZWNrR0xFcnJvcigiZGVsZXRlQnVm ZmVyIik7CisgICAgICAgIG1fY29udGV4dC0+Z3JhcGhpY3NDb250ZXh0M0QoKS0+ZGVsZXRlQnVm ZmVyKHZlcnRleEJ1ZmZlcik7CisgICAgICAgIGNoZWNrR0xFcnJvcigiZGVsZXRlQnVmZmVyIik7 CiAKLSAgICBtX2NvbnRleHQtPmdyYXBoaWNzQ29udGV4dDNEKCktPmRlbGV0ZUJ1ZmZlcihpbmRl eEJ1ZmZlcik7Ci0gICAgY2hlY2tHTEVycm9yKCJkZWxldGVCdWZmZXIiKTsKKyAgICAgICAgbV9j b250ZXh0LT5ncmFwaGljc0NvbnRleHQzRCgpLT5kZWxldGVCdWZmZXIoaW5kZXhCdWZmZXIpOwor ICAgICAgICBjaGVja0dMRXJyb3IoImRlbGV0ZUJ1ZmZlciIpOworICAgIH0KIH0KIAogdm9pZCBH TEVTMkNhbnZhczo6YmVnaW5TdGVuY2lsRHJhdygpCkluZGV4OiBTb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9HTEVTMkNhbnZhcy5oCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0dMRVMyQ2FudmFzLmgJKHJldmlz aW9uIDc4Nzc2KQorKysgU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0v R0xFUzJDYW52YXMuaAkod29ya2luZyBjb3B5KQpAQCAtMzYsNiArMzYsNyBAQAogI2luY2x1ZGUg IkNvbG9yU3BhY2UuaCIKICNpbmNsdWRlICJHcmFwaGljc1R5cGVzLmgiCiAjaW5jbHVkZSAiSW1h Z2VTb3VyY2UuaCIKKyNpbmNsdWRlICJMb29wQmxpbm5QYXRoQ2FjaGUuaCIKICNpbmNsdWRlICJU ZXh0dXJlLmgiCiAKICNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgpAQCAtMTE0LDYgKzExNSwxMCBA QCBwcml2YXRlOgogICAgIFN0YXRlVmVjdG9yIG1fc3RhdGVTdGFjazsKICAgICBTdGF0ZSogbV9z dGF0ZTsKICAgICBBZmZpbmVUcmFuc2Zvcm0gbV9mbGlwTWF0cml4OworCisgICAgLy8gTWVtYmVy cyBmb3IgR1BVLWFjY2VsZXJhdGVkIHBhdGggcmVuZGVyaW5nLgorICAgIExvb3BCbGlublBhdGhD YWNoZSBtX3BhdGhDYWNoZTsKKyAgICB1bnNpZ25lZCBtX3BhdGhWZXJ0ZXhCdWZmZXI7CiB9Owog CiB9CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUvTG9vcEJsaW5u Q2xhc3NpZmllci5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2dwdS9Mb29wQmxpbm5DbGFzc2lmaWVyLmgJKHJldmlzaW9uIDc4Nzc2KQorKysgU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L0xvb3BCbGlubkNsYXNzaWZpZXIuaAkod29y a2luZyBjb3B5KQpAQCAtMzAsNiArMzAsNyBAQAogI2lmbmRlZiBMb29wQmxpbm5DbGFzc2lmaWVy X2gKICNkZWZpbmUgTG9vcEJsaW5uQ2xhc3NpZmllcl9oCiAKKyNpbmNsdWRlIDx3dGYvTm9uY29w eWFibGUuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCkluZGV4OiBTb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9ncHUvTG9vcEJsaW5uTG9jYWxUcmlhbmd1bGF0b3IuaAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUvTG9vcEJsaW5uTG9j YWxUcmlhbmd1bGF0b3IuaAkocmV2aXNpb24gNzg3NzYpCisrKyBTb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9ncHUvTG9vcEJsaW5uTG9jYWxUcmlhbmd1bGF0b3IuaAkod29ya2luZyBj b3B5KQpAQCAtMzAsNiArMzAsNyBAQAogI2luY2x1ZGUgIkZsb2F0UG9pbnQzRC5oIgogI2luY2x1 ZGUgIkxvb3BCbGlubkNvbnN0YW50cy5oIgogI2luY2x1ZGUgPHd0Zi9Bc3NlcnRpb25zLmg+Cisj aW5jbHVkZSA8d3RmL05vbmNvcHlhYmxlLmg+CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIApJbmRl eDogU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L1NoYXJlZEdyYXBoaWNzQ29u dGV4dDNELmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9ncHUvU2hhcmVkR3JhcGhpY3NDb250ZXh0M0QuY3BwCShyZXZpc2lvbiA3ODc3NikKKysrIFNv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9TaGFyZWRHcmFwaGljc0NvbnRleHQz RC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTM5LDYgKzM5LDcgQEAKICNpbmNsdWRlICJFeHRlbnNp b25zM0QuaCIKICNpbmNsdWRlICJGbG9hdFJlY3QuaCIKICNpbmNsdWRlICJJbnRTaXplLmgiCisj aW5jbHVkZSAiTG9vcEJsaW5uU29saWRGaWxsU2hhZGVyLmgiCiAjaW5jbHVkZSAiU29saWRGaWxs U2hhZGVyLmgiCiAjaW5jbHVkZSAiVGV4U2hhZGVyLmgiCiAKQEAgLTUzLDcgKzU0LDcgQEAgUGFz c1JlZlB0cjxTaGFyZWRHcmFwaGljc0NvbnRleHQzRD4gU2hhcgogICAgIEdyYXBoaWNzQ29udGV4 dDNEOjpBdHRyaWJ1dGVzIGF0dHI7CiAgICAgYXR0ci5kZXB0aCA9IGZhbHNlOwogICAgIGF0dHIu c3RlbmNpbCA9IHRydWU7Ci0gICAgYXR0ci5hbnRpYWxpYXMgPSBmYWxzZTsKKyAgICBhdHRyLmFu dGlhbGlhcyA9IHVzZUxvb3BCbGlubkZvclBhdGhSZW5kZXJpbmcoKTsKICAgICBhdHRyLmNhblJl Y292ZXJGcm9tQ29udGV4dExvc3MgPSBmYWxzZTsgLy8gQ2FudmFzIGNvbnRleHRzIGNhbiBub3Qg aGFuZGxlIGxvc3QgY29udGV4dHMuCiAgICAgUmVmUHRyPEdyYXBoaWNzQ29udGV4dDNEPiBjb250 ZXh0ID0gR3JhcGhpY3NDb250ZXh0M0Q6OmNyZWF0ZShhdHRyLCBob3N0V2luZG93KTsKICAgICBp ZiAoIWNvbnRleHQpCkBAIC03Myw2ICs3NCw3IEBAIFNoYXJlZEdyYXBoaWNzQ29udGV4dDNEOjpT aGFyZWRHcmFwaGljc0MKICAgICAsIG1fcXVhZFZlcnRpY2VzKDApCiAgICAgLCBtX3NvbGlkRmls bFNoYWRlcihzb2xpZEZpbGxTaGFkZXIpCiAgICAgLCBtX3RleFNoYWRlcih0ZXhTaGFkZXIpCisg ICAgLCBtX29lc1N0YW5kYXJkRGVyaXZhdGl2ZXNTdXBwb3J0ZWQoZmFsc2UpCiB7CiAgICAgYWxs Q29udGV4dHMoKS0+YWRkKHRoaXMpOwogICAgIEV4dGVuc2lvbnMzRCogZXh0ZW5zaW9ucyA9IG1f Y29udGV4dC0+Z2V0RXh0ZW5zaW9ucygpOwpAQCAtODEsNiArODMsOSBAQCBTaGFyZWRHcmFwaGlj c0NvbnRleHQzRDo6U2hhcmVkR3JhcGhpY3NDCiAgICAgICAgIGV4dGVuc2lvbnMtPmVuc3VyZUVu YWJsZWQoIkdMX0VYVF90ZXh0dXJlX2Zvcm1hdF9CR1JBODg4OCIpOwogICAgICAgICBleHRlbnNp b25zLT5lbnN1cmVFbmFibGVkKCJHTF9FWFRfcmVhZF9mb3JtYXRfYmdyYSIpOwogICAgIH0KKyAg ICBtX29lc1N0YW5kYXJkRGVyaXZhdGl2ZXNTdXBwb3J0ZWQgPSBleHRlbnNpb25zLT5zdXBwb3J0 cygiR0xfT0VTX3N0YW5kYXJkX2Rlcml2YXRpdmVzIik7CisgICAgaWYgKG1fb2VzU3RhbmRhcmRE ZXJpdmF0aXZlc1N1cHBvcnRlZCkKKyAgICAgICAgZXh0ZW5zaW9ucy0+ZW5zdXJlRW5hYmxlZCgi R0xfT0VTX3N0YW5kYXJkX2Rlcml2YXRpdmVzIik7CiB9CiAKIFNoYXJlZEdyYXBoaWNzQ29udGV4 dDNEOjp+U2hhcmVkR3JhcGhpY3NDb250ZXh0M0QoKQpAQCAtMTQxLDYgKzE0NiwxMSBAQCB2b2lk IFNoYXJlZEdyYXBoaWNzQ29udGV4dDNEOjpmbHVzaCgpCiAgICAgbV9jb250ZXh0LT5mbHVzaCgp OwogfQogCitQbGF0Zm9ybTNET2JqZWN0IFNoYXJlZEdyYXBoaWNzQ29udGV4dDNEOjpjcmVhdGVC dWZmZXIoKQoreworICAgIHJldHVybiBtX2NvbnRleHQtPmNyZWF0ZUJ1ZmZlcigpOworfQorCiBQ bGF0Zm9ybTNET2JqZWN0IFNoYXJlZEdyYXBoaWNzQ29udGV4dDNEOjpjcmVhdGVGcmFtZWJ1ZmZl cigpCiB7CiAgICAgcmV0dXJuIG1fY29udGV4dC0+Y3JlYXRlRnJhbWVidWZmZXIoKTsKQEAgLTMy NCwxMSArMzM0LDMxIEBAIHZvaWQgU2hhcmVkR3JhcGhpY3NDb250ZXh0M0Q6OnNldEFjdGl2ZVQK ICAgICBtX2NvbnRleHQtPmFjdGl2ZVRleHR1cmUodGV4dHVyZVVuaXQpOwogfQogCit2b2lkIFNo YXJlZEdyYXBoaWNzQ29udGV4dDNEOjpiaW5kQnVmZmVyKEdDM0RlbnVtIHRhcmdldCwgUGxhdGZv cm0zRE9iamVjdCBidWZmZXIpCit7CisgICAgbV9jb250ZXh0LT5iaW5kQnVmZmVyKHRhcmdldCwg YnVmZmVyKTsKK30KKwogdm9pZCBTaGFyZWRHcmFwaGljc0NvbnRleHQzRDo6YmluZFRleHR1cmUo R0MzRGVudW0gdGFyZ2V0LCBQbGF0Zm9ybTNET2JqZWN0IHRleHR1cmUpCiB7CiAgICAgbV9jb250 ZXh0LT5iaW5kVGV4dHVyZSh0YXJnZXQsIHRleHR1cmUpOwogfQogCit2b2lkIFNoYXJlZEdyYXBo aWNzQ29udGV4dDNEOjpidWZmZXJEYXRhKEdDM0RlbnVtIHRhcmdldCwgR0MzRHNpemVpcHRyIHNp emUsIEdDM0RlbnVtIHVzYWdlKQoreworICAgIG1fY29udGV4dC0+YnVmZmVyRGF0YSh0YXJnZXQs IHNpemUsIHVzYWdlKTsKK30KKwordm9pZCBTaGFyZWRHcmFwaGljc0NvbnRleHQzRDo6YnVmZmVy RGF0YShHQzNEZW51bSB0YXJnZXQsIEdDM0RzaXplaXB0ciBzaXplLCBjb25zdCB2b2lkKiBkYXRh LCBHQzNEZW51bSB1c2FnZSkKK3sKKyAgICBtX2NvbnRleHQtPmJ1ZmZlckRhdGEodGFyZ2V0LCBz aXplLCBkYXRhLCB1c2FnZSk7Cit9CisKK3ZvaWQgU2hhcmVkR3JhcGhpY3NDb250ZXh0M0Q6OmJ1 ZmZlclN1YkRhdGEoR0MzRGVudW0gdGFyZ2V0LCBHQzNEaW50cHRyIG9mZnNldCwgR0MzRHNpemVp cHRyIHNpemUsIGNvbnN0IHZvaWQqIGRhdGEpCit7CisgICAgbV9jb250ZXh0LT5idWZmZXJTdWJE YXRhKHRhcmdldCwgb2Zmc2V0LCBzaXplLCBkYXRhKTsKK30KKwogdm9pZCBTaGFyZWRHcmFwaGlj c0NvbnRleHQzRDo6dXNlRmlsbFNvbGlkUHJvZ3JhbShjb25zdCBBZmZpbmVUcmFuc2Zvcm0mIHRy YW5zZm9ybSwgY29uc3QgQ29sb3ImIGNvbG9yKQogewogICAgIG1fc29saWRGaWxsU2hhZGVyLT51 c2UodHJhbnNmb3JtLCBjb2xvcik7CkBAIC0zNTQsNiArMzg0LDMzIEBAIGJvb2wgU2hhcmVkR3Jh cGhpY3NDb250ZXh0M0Q6OnBhaW50c0ludG8KICAgICByZXR1cm4gbV9jb250ZXh0LT5wYWludHNJ bnRvQ2FudmFzQnVmZmVyKCk7CiB9CiAKK2Jvb2wgU2hhcmVkR3JhcGhpY3NDb250ZXh0M0Q6OnVz ZUxvb3BCbGlubkZvclBhdGhSZW5kZXJpbmcoKQoreworICAgIHJldHVybiBmYWxzZTsKK30KKwor dm9pZCBTaGFyZWRHcmFwaGljc0NvbnRleHQzRDo6dXNlTG9vcEJsaW5uSW50ZXJpb3JQcm9ncmFt KHVuc2lnbmVkIHZlcnRleE9mZnNldCwgY29uc3QgQWZmaW5lVHJhbnNmb3JtJiB0cmFuc2Zvcm0s IGNvbnN0IENvbG9yJiBjb2xvcikKK3sKKyAgICBpZiAoIW1fbG9vcEJsaW5uSW50ZXJpb3JTaGFk ZXIpIHsKKyAgICAgICAgbV9sb29wQmxpbm5JbnRlcmlvclNoYWRlciA9IExvb3BCbGlublNvbGlk RmlsbFNoYWRlcjo6Y3JlYXRlKG1fY29udGV4dC5nZXQoKSwKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIExvb3BCbGlu blNoYWRlcjo6SW50ZXJpb3IsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBTaGFkZXI6Ok5vdEFudGlhbGlhc2VkKTsK KyAgICB9CisgICAgQVNTRVJUKG1fbG9vcEJsaW5uSW50ZXJpb3JTaGFkZXIpOworICAgIG1fbG9v cEJsaW5uSW50ZXJpb3JTaGFkZXItPnVzZSh2ZXJ0ZXhPZmZzZXQsIDAsIHRyYW5zZm9ybSwgY29s b3IpOworfQorCit2b2lkIFNoYXJlZEdyYXBoaWNzQ29udGV4dDNEOjp1c2VMb29wQmxpbm5FeHRl cmlvclByb2dyYW0odW5zaWduZWQgdmVydGV4T2Zmc2V0LCB1bnNpZ25lZCBrbG1PZmZzZXQsIGNv bnN0IEFmZmluZVRyYW5zZm9ybSYgdHJhbnNmb3JtLCBjb25zdCBDb2xvciYgY29sb3IpCit7Cisg ICAgaWYgKCFtX2xvb3BCbGlubkV4dGVyaW9yU2hhZGVyKSB7CisgICAgICAgIG1fbG9vcEJsaW5u RXh0ZXJpb3JTaGFkZXIgPSBMb29wQmxpbm5Tb2xpZEZpbGxTaGFkZXI6OmNyZWF0ZShtX2NvbnRl eHQuZ2V0KCksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBMb29wQmxpbm5TaGFkZXI6OkV4dGVyaW9yLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgbV9vZXNTdGFuZGFyZERlcml2YXRpdmVzU3VwcG9ydGVkID8gU2hhZGVyOjpBbnRpYWxp YXNlZCA6IFNoYWRlcjo6Tm90QW50aWFsaWFzZWQpOworICAgIH0KKyAgICBBU1NFUlQobV9sb29w Qmxpbm5FeHRlcmlvclNoYWRlcik7CisgICAgbV9sb29wQmxpbm5FeHRlcmlvclNoYWRlci0+dXNl KHZlcnRleE9mZnNldCwga2xtT2Zmc2V0LCB0cmFuc2Zvcm0sIGNvbG9yKTsKK30KKwogfSAvLyBu YW1lc3BhY2UgV2ViQ29yZQogCiAjZW5kaWYKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2dwdS9TaGFyZWRHcmFwaGljc0NvbnRleHQzRC5oCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9TaGFyZWRHcmFwaGljc0NvbnRleHQz RC5oCShyZXZpc2lvbiA3ODc3NikKKysrIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L2dwdS9TaGFyZWRHcmFwaGljc0NvbnRleHQzRC5oCSh3b3JraW5nIGNvcHkpCkBAIC00OSw2ICs0 OSw3IEBAIGNsYXNzIENvbG9yOwogY2xhc3MgRmxvYXRSZWN0OwogY2xhc3MgSG9zdFdpbmRvdzsK IGNsYXNzIEludFNpemU7CitjbGFzcyBMb29wQmxpbm5Tb2xpZEZpbGxTaGFkZXI7CiBjbGFzcyBT b2xpZEZpbGxTaGFkZXI7CiBjbGFzcyBUZXhTaGFkZXI7CiAKQEAgLTYxLDcgKzYyLDExIEBAIHB1 YmxpYzoKIAogICAgIC8vIEZ1bmN0aW9ucyB0aGF0IGRlbGVnYXRlIGRpcmVjdGx5IHRvIEdyYXBo aWNzQ29udGV4dDNELCB3aXRoIGNhY2hpbmcKICAgICB2b2lkIG1ha2VDb250ZXh0Q3VycmVudCgp OworICAgIHZvaWQgYmluZEJ1ZmZlcihHQzNEZW51bSB0YXJnZXQsIFBsYXRmb3JtM0RPYmplY3Qp OwogICAgIHZvaWQgYmluZEZyYW1lYnVmZmVyKFBsYXRmb3JtM0RPYmplY3QgZnJhbWVidWZmZXIp OworICAgIHZvaWQgYnVmZmVyRGF0YShHQzNEZW51bSB0YXJnZXQsIEdDM0RzaXplaXB0ciwgR0Mz RGVudW0gdXNhZ2UpOworICAgIHZvaWQgYnVmZmVyRGF0YShHQzNEZW51bSB0YXJnZXQsIEdDM0Rz aXplaXB0ciwgY29uc3Qgdm9pZCogZGF0YSwgR0MzRGVudW0gdXNhZ2UpOworICAgIHZvaWQgYnVm ZmVyU3ViRGF0YShHQzNEZW51bSB0YXJnZXQsIEdDM0RpbnRwdHIgb2Zmc2V0LCBHQzNEc2l6ZWlw dHIsIGNvbnN0IHZvaWQqIGRhdGEpOwogICAgIHZvaWQgc2V0Vmlld3BvcnQoY29uc3QgSW50U2l6 ZSYpOwogICAgIHZvaWQgc2Npc3NvcihHQzNEaW50IHgsIEdDM0RpbnQgeSwgR0MzRHNpemVpIHdp ZHRoLCBHQzNEc2l6ZWkgaGVpZ2h0KTsKICAgICB2b2lkIGVuYWJsZShHQzNEZW51bSBjYXBhY2l0 eSk7CkBAIC03Myw2ICs3OCw3IEBAIHB1YmxpYzoKICAgICB2b2lkIGdldEludGVnZXJ2KEdDM0Rl bnVtIHBuYW1lLCBHQzNEaW50KiB2YWx1ZSk7CiAgICAgdm9pZCBmbHVzaCgpOwogCisgICAgUGxh dGZvcm0zRE9iamVjdCBjcmVhdGVCdWZmZXIoKTsKICAgICBQbGF0Zm9ybTNET2JqZWN0IGNyZWF0 ZUZyYW1lYnVmZmVyKCk7CiAgICAgUGxhdGZvcm0zRE9iamVjdCBjcmVhdGVUZXh0dXJlKCk7CiAK QEAgLTExNyw2ICsxMjMsMTEgQEAgcHVibGljOgogCiAgICAgR3JhcGhpY3NDb250ZXh0M0QqIGdy YXBoaWNzQ29udGV4dDNEKCkgY29uc3QgeyByZXR1cm4gbV9jb250ZXh0LmdldCgpOyB9CiAKKyAg ICAvLyBNZW1iZXJzIGZvciBHUFUtYWNjZWxlcmF0ZWQgcGF0aCByZW5kZXJpbmcuCisgICAgc3Rh dGljIGJvb2wgdXNlTG9vcEJsaW5uRm9yUGF0aFJlbmRlcmluZygpOworICAgIHZvaWQgdXNlTG9v cEJsaW5uSW50ZXJpb3JQcm9ncmFtKHVuc2lnbmVkIHZlcnRleE9mZnNldCwgY29uc3QgQWZmaW5l VHJhbnNmb3JtJiwgY29uc3QgQ29sb3ImKTsKKyAgICB2b2lkIHVzZUxvb3BCbGlubkV4dGVyaW9y UHJvZ3JhbSh1bnNpZ25lZCB2ZXJ0ZXhPZmZzZXQsIHVuc2lnbmVkIGtsbU9mZnNldCwgY29uc3Qg QWZmaW5lVHJhbnNmb3JtJiwgY29uc3QgQ29sb3ImKTsKKwogcHJpdmF0ZToKICAgICBTaGFyZWRH cmFwaGljc0NvbnRleHQzRChQYXNzUmVmUHRyPEdyYXBoaWNzQ29udGV4dDNEPiwgUGFzc093blB0 cjxTb2xpZEZpbGxTaGFkZXI+LCBQYXNzT3duUHRyPFRleFNoYWRlcj4pOwogCkBAIC0xMzMsNiAr MTQ0LDEyIEBAIHByaXZhdGU6CiAgICAgT3duUHRyPFRleFNoYWRlcj4gbV90ZXhTaGFkZXI7CiAK ICAgICBUZXh0dXJlSGFzaE1hcCBtX3RleHR1cmVzOworCisgICAgLy8gTWVtYmVycyBmb3IgR1BV LWFjY2VsZXJhdGVkIHBhdGggcmVuZGVyaW5nLgorICAgIC8vIEZJWE1FOiBzdXBwb3J0IG1vcmUg a2luZHMgb2YgZmlsbCB0eXBlcyBmb3IgcGF0aHMuCisgICAgT3duUHRyPExvb3BCbGlublNvbGlk RmlsbFNoYWRlcj4gbV9sb29wQmxpbm5JbnRlcmlvclNoYWRlcjsKKyAgICBPd25QdHI8TG9vcEJs aW5uU29saWRGaWxsU2hhZGVyPiBtX2xvb3BCbGlubkV4dGVyaW9yU2hhZGVyOworICAgIGJvb2wg bV9vZXNTdGFuZGFyZERlcml2YXRpdmVzU3VwcG9ydGVkOwogfTsKIAogfSAvLyBuYW1lc3BhY2Ug V2ViQ29yZQpJbmRleDogU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mvc2tpYS9HcmFw aGljc0NvbnRleHRTa2lhLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9za2lhL0dyYXBoaWNzQ29udGV4dFNraWEuY3BwCShyZXZpc2lvbiA3ODc3NikK KysrIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3NraWEvR3JhcGhpY3NDb250ZXh0 U2tpYS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTczMSw2ICs3MzEsNyBAQCB2b2lkIEdyYXBoaWNz Q29udGV4dDo6ZmlsbFBhdGgoY29uc3QgUGF0CiAgICAgaWYgKHBhaW50aW5nRGlzYWJsZWQoKSkK ICAgICAgICAgcmV0dXJuOwogCisgICAgLy8gRklYTUU6IGFkZCBzdXBwb3J0IHRvIEdMRVMyQ2Fu dmFzIGZvciBtb3JlIHRoYW4ganVzdCBzb2xpZCBmaWxscy4KICAgICBpZiAocGxhdGZvcm1Db250 ZXh0KCktPnVzZUdQVSgpICYmIHBsYXRmb3JtQ29udGV4dCgpLT5jYW5BY2NlbGVyYXRlKCkpIHsK ICAgICAgICAgcGxhdGZvcm1Db250ZXh0KCktPnByZXBhcmVGb3JIYXJkd2FyZURyYXcoKTsKICAg ICAgICAgcGxhdGZvcm1Db250ZXh0KCktPmdwdUNhbnZhcygpLT5maWxsUGF0aChwYXRoVG9GaWxs KTsK