107185 2013-01-17 15:00:03 -0800 Prepare WebGL methods and binding generators for VM-allocated typed arrays 2013-04-03 14:18:21 -0700 1 1 1 Unclassified WebKit WebGL 528+ (Nightly build) All All RESOLVED WONTFIX P2 Normal --- 106975 1 kbr kbr abarth benjamin cmarrin danno dino fpizlo ggaren haraken japhet laszlo.gombos mhahnenberg ojan.autocc oliver sam tonikitoo ulan webkit.review.bot oldest_to_newest 809839 0 kbr 2013-01-17 15:00:03 -0800 Currently all instances of ArrayBuffer and ArrayBufferView created from JavaScript call down into WebCore to allocate their backing storage. This is problematic for two reasons: 1) A lot of C++ code is run when allocating these objects, and there are no hot spots in that code (measured by @ulan); it's just a large amount of "warm" code. 2) ECMAScript 6 subsumes these types into the language, which means that VMs like JSC and V8 will likely pull the entire implementation into the VM, and no longer call into the bindings at all when allocating these objects (at least in the common case). To eliminate bottleneck (1) and make progress on (2), JavaScript VMs can allocate most typed arrays so their storage lives in the JS heap. When passing these instances across the bindings into WebCore, it will be necessary to describe them as ArrayBuffer and ArrayBufferView instances to WebCore without actually instantiating the C++ ArrayBuffer and ArrayBufferView classes, thereby causing memory allocation and data copying. Lightweight structs which describe ArrayBuffers and ArrayBufferViews need to be introduced to allow JavaScript VMs to perform this optimization. Additionally, unifying the handling of ArrayBuffer and ArrayBufferView using these descriptors allows more code sharing in the WebGL implementation and probably elsewhere. 809858 1 fpizlo 2013-01-17 15:12:52 -0800 (In reply to comment #0) > Currently all instances of ArrayBuffer and ArrayBufferView created from JavaScript call down into WebCore to allocate their backing storage. This is problematic for two reasons: I'm with you, so far. > > 1) A lot of C++ code is run when allocating these objects, and there are no hot spots in that code (measured by @ulan); it's just a large amount of "warm" code. > 2) ECMAScript 6 subsumes these types into the language, which means that VMs like JSC and V8 will likely pull the entire implementation into the VM, and no longer call into the bindings at all when allocating these objects (at least in the common case). > > To eliminate bottleneck (1) and make progress on (2), JavaScript VMs can allocate most typed arrays so their storage lives in the JS heap. Agree. > When passing these instances across the bindings into WebCore, it will be necessary to describe them as ArrayBuffer and ArrayBufferView instances to WebCore without actually instantiating the C++ ArrayBuffer and ArrayBufferView classes, thereby causing memory allocation and data copying. You lost me. A typed array *is* an ArrayBufferView, so there is nothing that needs to be done there. The JS VM can allocate that directly. No changes in the bindings are needed. All that is needed is to un-dumb-ify the VM. For ArrayBuffer, it's true that allocating that is redundant. But we could just allocate it lazily when WebCore asks for it, and the ArrayBufferView didn't already have one. I.e.: JSC allocates ArrayBufferViews sans ArrayBuffers, with a backing store allocated in the JSC CopiedSpace heap. If you ask for an ArrayBuffer, or ask for the backing store from within WebCore, we then create the necessary data structures in the malloc heap. > > Lightweight structs which describe ArrayBuffers and ArrayBufferViews need to be introduced to allow JavaScript VMs to perform this optimization. Additionally, unifying the handling of ArrayBuffer and ArrayBufferView using these descriptors allows more code sharing in the WebGL implementation and probably elsewhere. 809883 2 183297 kbr 2013-01-17 15:26:15 -0800 Created attachment 183297 Patch 809890 3 kbr 2013-01-17 15:33:46 -0800 (In reply to comment #1) > (In reply to comment #0) > > When passing these instances across the bindings into WebCore, it will be necessary to describe them as ArrayBuffer and ArrayBufferView instances to WebCore without actually instantiating the C++ ArrayBuffer and ArrayBufferView classes, thereby causing memory allocation and data copying. > > You lost me. A typed array *is* an ArrayBufferView, so there is nothing that needs to be done there. The JS VM can allocate that directly. No changes in the bindings are needed. All that is needed is to un-dumb-ify the VM. > > For ArrayBuffer, it's true that allocating that is redundant. But we could just allocate it lazily when WebCore asks for it, and the ArrayBufferView didn't already have one. I.e.: JSC allocates ArrayBufferViews sans ArrayBuffers, with a backing store allocated in the JSC CopiedSpace heap. If you ask for an ArrayBuffer, or ask for the backing store from within WebCore, we then create the necessary data structures in the malloc heap. Creating these data structures in the malloc heap when touching the backing store from WebCore is exactly what we want to avoid. All of the WebGL entry points have the semantic that after they return, they no longer reference the incoming data. We want to pass direct pointers from the JS heap into WebCore, pinning the objects for the duration of the call, and avoid these allocations and data copies. 809898 4 fpizlo 2013-01-17 15:51:24 -0800 (In reply to comment #3) > (In reply to comment #1) > > (In reply to comment #0) > > > When passing these instances across the bindings into WebCore, it will be necessary to describe them as ArrayBuffer and ArrayBufferView instances to WebCore without actually instantiating the C++ ArrayBuffer and ArrayBufferView classes, thereby causing memory allocation and data copying. > > > > You lost me. A typed array *is* an ArrayBufferView, so there is nothing that needs to be done there. The JS VM can allocate that directly. No changes in the bindings are needed. All that is needed is to un-dumb-ify the VM. > > > > For ArrayBuffer, it's true that allocating that is redundant. But we could just allocate it lazily when WebCore asks for it, and the ArrayBufferView didn't already have one. I.e.: JSC allocates ArrayBufferViews sans ArrayBuffers, with a backing store allocated in the JSC CopiedSpace heap. If you ask for an ArrayBuffer, or ask for the backing store from within WebCore, we then create the necessary data structures in the malloc heap. > > Creating these data structures in the malloc heap when touching the backing store from WebCore is exactly what we want to avoid. All of the WebGL entry points have the semantic that after they return, they no longer reference the incoming data. We want to pass direct pointers from the JS heap into WebCore, pinning the objects for the duration of the call, and avoid these allocations and data copies. I looked at your patch. Can you articulate how this helps (a) pinning, (b) not copying, and (c) allocating array buffer views in JSC? It doesn't help pinning because it doesn't do pinning. And anyway, the standard way of doing pinning doesn't require a separate descriptor. Is this an attempt to refactor the code to do RAII for pinning? This change adds copying of the void* base and unsigned length fields. How does this reduce copying? As I've already stated, it would be super simple to allocate array buffer views in the JS heap. In the cases that your change covers, this would not require any changes. I.e. without your patch, things would still work just fine: JSC will not copy an object while it is blocked on a call into the DOM. It also won't copy an object while it is referenced from the C stack. So, your change doesn't actually help things. So as far as I can tell, this change is just adding noise - it doesn't achieve the thing that you claim it achieves. 809899 5 183297 fpizlo 2013-01-17 15:52:55 -0800 Comment on attachment 183297 Patch Marking as r- to be as unambiguous as possible about the fact that I view this change as adding entirely unneeded code. 809928 6 kbr 2013-01-17 16:18:27 -0800 (In reply to comment #4) > I looked at your patch. Can you articulate how this helps (a) pinning, (b) not copying, and (c) allocating array buffer views in JSC? > > It doesn't help pinning because it doesn't do pinning. And anyway, the standard way of doing pinning doesn't require a separate descriptor. Is this an attempt to refactor the code to do RAII for pinning? > > This change adds copying of the void* base and unsigned length fields. How does this reduce copying? > > As I've already stated, it would be super simple to allocate array buffer views in the JS heap. In the cases that your change covers, this would not require any changes. I.e. without your patch, things would still work just fine: JSC will not copy an object while it is blocked on a call into the DOM. It also won't copy an object while it is referenced from the C stack. So, your change doesn't actually help things. WebCore methods exposed via the IDL which take ArrayBuffer or ArrayBufferView need new overloads in order for the bindings to handle passing typed arrays allocated on the JS heap. A current ArrayBuffer* argument needs to be expanded into two arguments: the base pointer and size. A current ArrayBufferView* argument needs to be expanded into three: base pointer, size, and type. (The type is required; some WebGL APIs check it.) Without these changes it is not possible to efficiently pass a JS-heap-allocated typed array into WebCore. This initial patch does three things: 1) Supports passing JS-heap-allocated, pinned typed arrays to the modified WebGL methods. 2) Keeps the C++ method signatures readable. 3) Makes it easier to generate the binding code. It does not implement pinning, JS heap allocation for typed arrays, or binding code generator changes. 809940 7 fpizlo 2013-01-17 16:25:01 -0800 (In reply to comment #6) > (In reply to comment #4) > > I looked at your patch. Can you articulate how this helps (a) pinning, (b) not copying, and (c) allocating array buffer views in JSC? > > > > It doesn't help pinning because it doesn't do pinning. And anyway, the standard way of doing pinning doesn't require a separate descriptor. Is this an attempt to refactor the code to do RAII for pinning? > > > > This change adds copying of the void* base and unsigned length fields. How does this reduce copying? > > > > As I've already stated, it would be super simple to allocate array buffer views in the JS heap. In the cases that your change covers, this would not require any changes. I.e. without your patch, things would still work just fine: JSC will not copy an object while it is blocked on a call into the DOM. It also won't copy an object while it is referenced from the C stack. So, your change doesn't actually help things. > > WebCore methods exposed via the IDL which take ArrayBuffer or ArrayBufferView need new overloads in order for the bindings to handle passing typed arrays allocated on the JS heap. This statement is unsubstantiated, and strictly untrue in JSC. > > A current ArrayBuffer* argument needs to be expanded into two arguments: the base pointer and size. A current ArrayBufferView* argument needs to be expanded into three: base pointer, size, and type. (The type is required; some WebGL APIs check it.) Without these changes it is not possible to efficiently pass a JS-heap-allocated typed array into WebCore. Not true. Can you argue specifically why you believe this to be the case? It is strictly not true in JSC. Adding WebCore functionality to support flaws in the V8 object model is not, to my understanding, a goal of WebKit. > > This initial patch does three things: > > 1) Supports passing JS-heap-allocated, pinned typed arrays to the modified WebGL methods. It doesn't do this. You can already pass pinned typed arrays to the unmodified WebGL methods. > 2) Keeps the C++ method signatures readable. > 3) Makes it easier to generate the binding code. > > It does not implement pinning, JS heap allocation for typed arrays, or binding code generator changes. 810014 8 kbr 2013-01-17 17:52:32 -0800 (In reply to comment #7) > (In reply to comment #6) > > (In reply to comment #4) > > > I looked at your patch. Can you articulate how this helps (a) pinning, (b) not copying, and (c) allocating array buffer views in JSC? > > > > > > It doesn't help pinning because it doesn't do pinning. And anyway, the standard way of doing pinning doesn't require a separate descriptor. Is this an attempt to refactor the code to do RAII for pinning? > > > > > > This change adds copying of the void* base and unsigned length fields. How does this reduce copying? > > > > > > As I've already stated, it would be super simple to allocate array buffer views in the JS heap. In the cases that your change covers, this would not require any changes. I.e. without your patch, things would still work just fine: JSC will not copy an object while it is blocked on a call into the DOM. It also won't copy an object while it is referenced from the C stack. So, your change doesn't actually help things. > > > > WebCore methods exposed via the IDL which take ArrayBuffer or ArrayBufferView need new overloads in order for the bindings to handle passing typed arrays allocated on the JS heap. > > This statement is unsubstantiated, and strictly untrue in JSC. I believe my statement is true. Taking the JSC bindings for WebGLRenderingContext's bufferData(in unsigned long target, in ArrayBufferView? data, in unsigned long usage) as an example: static EncodedJSValue JSC_HOST_CALL jsWebGLRenderingContextPrototypeFunctionBufferData2(ExecState* exec) { // ... ArrayBufferView* data(toArrayBufferView(MAYBE_MISSING_PARAMETER(exec, 1, DefaultIsUndefined))); // ... impl->bufferData(target, data, usage, ec); // ... } If JSC (or V8) allocated typed arrays' storage in the JS heap then the operation of fetching an ArrayBufferView C++ instance for it would require allocation of a lot of C++ objects: the underlying ArrayBuffer, the right ArrayBufferView subclass (which contains a RefPtr to the ArrayBuffer), the ArrayBuffer's ArrayBufferContents, etc. Are you proposing that all of those objects would actually be allocated from a contiguous block in the JS heap, and the JS GC modified to support moving them (in case of a compacting collector) so that pointers to them can be passed to C++? This seems incredibly complicated. > > A current ArrayBuffer* argument needs to be expanded into two arguments: the base pointer and size. A current ArrayBufferView* argument needs to be expanded into three: base pointer, size, and type. (The type is required; some WebGL APIs check it.) Without these changes it is not possible to efficiently pass a JS-heap-allocated typed array into WebCore. > > Not true. Can you argue specifically why you believe this to be the case? It is strictly not true in JSC. Currently both the JSC and V8 bindings extract a C++ ArrayBuffer* or ArrayBufferView* from the incoming JavaScript wrappers. Right now the C++ classes own their storage. Without some change, whether it be to WTF or WebCore, there is no way to avoid a data copy, in either JSC or V8. > Adding WebCore functionality to support flaws in the V8 object model is not, to my understanding, a goal of WebKit. There is no need to be nasty. If I am misunderstanding your point then please help me understand exactly how you anticipate this working in JSC. > > This initial patch does three things: > > > > 1) Supports passing JS-heap-allocated, pinned typed arrays to the modified WebGL methods. > > It doesn't do this. The addition of the new WebGLRenderingContext methods taking ArrayBufferDescriptor and ArrayBufferViewDescriptor are what supports this. These can be stack-allocated in the bindings, and point into the JS heap during the native calls. > You can already pass pinned typed arrays to the unmodified WebGL methods. I don't believe this to be true for either JSC or V8. 810059 9 fpizlo 2013-01-17 18:19:18 -0800 (In reply to comment #8) > (In reply to comment #7) > > (In reply to comment #6) > > > (In reply to comment #4) > > > > I looked at your patch. Can you articulate how this helps (a) pinning, (b) not copying, and (c) allocating array buffer views in JSC? > > > > > > > > It doesn't help pinning because it doesn't do pinning. And anyway, the standard way of doing pinning doesn't require a separate descriptor. Is this an attempt to refactor the code to do RAII for pinning? > > > > > > > > This change adds copying of the void* base and unsigned length fields. How does this reduce copying? > > > > > > > > As I've already stated, it would be super simple to allocate array buffer views in the JS heap. In the cases that your change covers, this would not require any changes. I.e. without your patch, things would still work just fine: JSC will not copy an object while it is blocked on a call into the DOM. It also won't copy an object while it is referenced from the C stack. So, your change doesn't actually help things. > > > > > > WebCore methods exposed via the IDL which take ArrayBuffer or ArrayBufferView need new overloads in order for the bindings to handle passing typed arrays allocated on the JS heap. > > > > This statement is unsubstantiated, and strictly untrue in JSC. > > I believe my statement is true. Taking the JSC bindings for WebGLRenderingContext's bufferData(in unsigned long target, in ArrayBufferView? data, in unsigned long usage) as an example: > > static EncodedJSValue JSC_HOST_CALL jsWebGLRenderingContextPrototypeFunctionBufferData2(ExecState* exec) > { > // ... > ArrayBufferView* data(toArrayBufferView(MAYBE_MISSING_PARAMETER(exec, 1, DefaultIsUndefined))); > // ... > impl->bufferData(target, data, usage, ec); > // ... > } > > If JSC (or V8) allocated typed arrays' storage in the JS heap then the operation of fetching an ArrayBufferView C++ instance for it would require allocation of a lot of C++ objects: the underlying ArrayBuffer, the right ArrayBufferView subclass (which contains a RefPtr to the ArrayBuffer), the ArrayBuffer's ArrayBufferContents, etc. Are you proposing that all of those objects would actually be allocated from a contiguous block in the JS heap, and the JS GC modified to support moving them (in case of a compacting collector) so that pointers to them can be passed to C++? This seems incredibly complicated. JSC GC doesn't have to move objects, ever. So all of these objects can be allocated by the GC, and referenced from C++, and never moved. I view movable objects as a nice-to-have from a GC design standpoint. > > > > A current ArrayBuffer* argument needs to be expanded into two arguments: the base pointer and size. A current ArrayBufferView* argument needs to be expanded into three: base pointer, size, and type. (The type is required; some WebGL APIs check it.) Without these changes it is not possible to efficiently pass a JS-heap-allocated typed array into WebCore. > > > > Not true. Can you argue specifically why you believe this to be the case? It is strictly not true in JSC. > > Currently both the JSC and V8 bindings extract a C++ ArrayBuffer* or ArrayBufferView* from the incoming JavaScript wrappers. Right now the C++ classes own their storage. Without some change, whether it be to WTF or WebCore, there is no way to avoid a data copy, in either JSC or V8. My point is that the change that we could make is to pass the objects in the JS heap directly into WebCore. My point is also that your change doesn't appear to move us in that direction. And you haven't articulated what direction your code is going in or how it would comprehensively allow typed arrays to be cheaper to allocate from JavaScript. > > > Adding WebCore functionality to support flaws in the V8 object model is not, to my understanding, a goal of WebKit. > > There is no need to be nasty. If I am misunderstanding your point then please help me understand exactly how you anticipate this working in JSC. See above. JSC can pin things for free, by design. > > > > This initial patch does three things: > > > > > > 1) Supports passing JS-heap-allocated, pinned typed arrays to the modified WebGL methods. > > > > It doesn't do this. > > The addition of the new WebGLRenderingContext methods taking ArrayBufferDescriptor and ArrayBufferViewDescriptor are what supports this. These can be stack-allocated in the bindings, and point into the JS heap during the native calls. I don't believe that the stack pattern covers all cases of typed arrays being passed from JS to DOM. > > > You can already pass pinned typed arrays to the unmodified WebGL methods. > > I don't believe this to be true for either JSC or V8. Actually, you're right on this point - currently the WebCore object and the JS object are distinct. This is a bug, and we should fix that bug. My original point is that your change doesn't really get us into the world where a JS types array can always be passed for free into the DOM. Also, it doesn't address the heart of the problem, which is that ArrayBuffer and the Views are not JS objects, but rather DOM objects with JS wrappers. 810108 10 kbr 2013-01-17 19:20:14 -0800 (In reply to comment #9) > (In reply to comment #8) > > (In reply to comment #7) > > If JSC (or V8) allocated typed arrays' storage in the JS heap then the operation of fetching an ArrayBufferView C++ instance for it would require allocation of a lot of C++ objects: the underlying ArrayBuffer, the right ArrayBufferView subclass (which contains a RefPtr to the ArrayBuffer), the ArrayBuffer's ArrayBufferContents, etc. Are you proposing that all of those objects would actually be allocated from a contiguous block in the JS heap, and the JS GC modified to support moving them (in case of a compacting collector) so that pointers to them can be passed to C++? This seems incredibly complicated. > > JSC GC doesn't have to move objects, ever. So all of these objects can be allocated by the GC, and referenced from C++, and never moved. I see. Regardless, a lot of unnecessary initialization code would need to be run in order to set up these objects so that they look correct to C++. It's this initialization code which is making typed array allocations slow. > > > You can already pass pinned typed arrays to the unmodified WebGL methods. > > > > I don't believe this to be true for either JSC or V8. > > Actually, you're right on this point - currently the WebCore object and the JS object are distinct. This is a bug, and we should fix that bug. My original point is that your change doesn't really get us into the world where a JS types array can always be passed for free into the DOM. Also, it doesn't address the heart of the problem, which is that ArrayBuffer and the Views are not JS objects, but rather DOM objects with JS wrappers. I'm glad we're in agreement on this point. Let's focus on the technical details. The basic idea is to change the default representation for typed arrays in the VM so that the storage is allocated contiguously to the JS object representing the ArrayBuffer. Most likely there will still be two distinct JS objects; one for the typed array view (Uint8Array, Float32Array, etc.) and one for the underlying ArrayBuffer, to make it simpler to have multiple views for the same buffer. Both objects can still be allocated in one shot by the JS heap allocator and no C++ code would need to be run during their allocation, which is essential to improve allocation performance. Methods would be added (e.g. JSValue::isHeapAllocatedArrayBuffer) to identify these pure JS ArrayBuffer and view objects, and to extract their base addresses and sizes, and the type from the views. Most of the methods exposed in the IDL taking typed arrays (in APIs like AudioContext, WebSocket, XMLHttpRequest, and WebGL) don't reference the incoming ArrayBuffer or ArrayBufferView object after the call returns. These methods would be annotated with [SupportsHeapAllocatedTypedArrays] or similar. If called with one of these pure JS typed array objects, the bindings would call the runtime to fetch the base address and pointer (and type for views) from the JS object, and pass them to WebCore's C++ code. I think it would be nicer to pass one stack-allocated structure instead of multiple arguments, which is what this patch does for WebGL's C++ entry points. In fact, for such methods, we can completely eliminate the overloads which take C++ ArrayBuffer and ArrayBufferView pointers. If an "externally allocated" typed array is passed in, the bindings can just extract the values from the C++ objects. This would drive home the point that typed arrays are mostly owned by the VM and not by WebCore. The more difficult situation is when a JS-heap-allocated typed array is passed to a C++ method that references the object after the call returns (AudioContext.decodeAudioData) or does complex operations like transfer of ownership (Worker.postMessage). decodeAudioData can be supported by defining a JS handle type in WebCore which would prevent GC of the referenced object. Worker.postMessage with Transferables is harder and I expect the C++ backing objects would be allocated on demand, the data copied, and the JS objects transformed into simple wrappers. What are your thoughts? 810143 11 fpizlo 2013-01-17 19:50:43 -0800 (In reply to comment #10) > (In reply to comment #9) > > (In reply to comment #8) > > > (In reply to comment #7) > > > If JSC (or V8) allocated typed arrays' storage in the JS heap then the operation of fetching an ArrayBufferView C++ instance for it would require allocation of a lot of C++ objects: the underlying ArrayBuffer, the right ArrayBufferView subclass (which contains a RefPtr to the ArrayBuffer), the ArrayBuffer's ArrayBufferContents, etc. Are you proposing that all of those objects would actually be allocated from a contiguous block in the JS heap, and the JS GC modified to support moving them (in case of a compacting collector) so that pointers to them can be passed to C++? This seems incredibly complicated. > > > > JSC GC doesn't have to move objects, ever. So all of these objects can be allocated by the GC, and referenced from C++, and never moved. > > I see. Regardless, a lot of unnecessary initialization code would need to be run in order to set up these objects so that they look correct to C++. It's this initialization code which is making typed array allocations slow. I don't believe that this initialization code would be slow. Can you provide specific examples of things that would have to be set up, which would be slow? Consider this: let's say that the buffer is a contiguous object that contains both the backing store and the buffer head, and that a view is a separate object. That's two allocations. Each allocation is ~5-6 instructions on the fast path and another ~5-6 instructions on the slow path, so total ~10-12 instructions for two allocations. The fast path will have two loads and one store, per object. After the allocation, each JS object needs two stores to initialize its header. So we're up to four loads (2x 2 loads per allocation) and 6 stores (1 store per object allocation times 2 objects, plus 2 stores per object initialization times 2 objects). Then at minimum, even if the objects didn't have to look like C++ objects at all, the view would have to have a pointer to the buffer (1 store), the view probably would have to have its own notion of length and offset (another 2 stores, or at least 1 additional store - depends on how smart we are), and the buffer would have to have its size (another store). Optimisitically, if we assume that view initialization only requires a buffer pointer and a length, that's 3 additional stores on top of the 6 stores we already had. That's a total of 4 loads and 9 stores. At this point, this allocation sequence, which doesn't even take into consideration anything that would make these objects look like C++ objects, has enough cruft that adding another couple of stores is unlikely to create a measurable difference in performance. The surprising truth about inlined object allocators for managed languages is that adding a few instructions to them often doesn't impose significant overhead just because the true cost of a GC allocation ends up being the fact that it (1) accelerates you towards another GC, which is expensive and (2) you're most likely allocating the object in a part of memory that is less likely to be in cache than other parts of memory. Btw, this is the part that moving GCs, and generational GCs, try to avoid - a moving GenGC will increase the likelihood that a newly allocated object is on a hot cache line - but still it won't be as hot as other objects. Hence, the paradoxically, the cost of an additional store is quite low: usually the first store to do the first initialization of an allocated object is super expensive because it is likely to miss cache, but then subsequent stores are ultra fast by comparison because they hit cache. So, what additional stores would you have to do to make the objects look like C++ objects? If it's only a handful of stores, then it's no biggie. And by the way, the JSC object model should enable us to make the JS array buffer/view objects look like C++ objects by default without additional stores. Unless I'm forgetting something... > > > > > You can already pass pinned typed arrays to the unmodified WebGL methods. > > > > > > I don't believe this to be true for either JSC or V8. > > > > Actually, you're right on this point - currently the WebCore object and the JS object are distinct. This is a bug, and we should fix that bug. My original point is that your change doesn't really get us into the world where a JS types array can always be passed for free into the DOM. Also, it doesn't address the heart of the problem, which is that ArrayBuffer and the Views are not JS objects, but rather DOM objects with JS wrappers. > > I'm glad we're in agreement on this point. Let's focus on the technical details. > > The basic idea is to change the default representation for typed arrays in the VM so that the storage is allocated contiguously to the JS object representing the ArrayBuffer. Most likely there will still be two distinct JS objects; one for the typed array view (Uint8Array, Float32Array, etc.) and one for the underlying ArrayBuffer, to make it simpler to have multiple views for the same buffer. Both objects can still be allocated in one shot by the JS heap allocator and no C++ code would need to be run during their allocation, which is essential to improve allocation performance. > > Methods would be added (e.g. JSValue::isHeapAllocatedArrayBuffer) to identify these pure JS ArrayBuffer and view objects, and to extract their base addresses and sizes, and the type from the views. > > Most of the methods exposed in the IDL taking typed arrays (in APIs like AudioContext, WebSocket, XMLHttpRequest, and WebGL) don't reference the incoming ArrayBuffer or ArrayBufferView object after the call returns. These methods would be annotated with [SupportsHeapAllocatedTypedArrays] or similar. If called with one of these pure JS typed array objects, the bindings would call the runtime to fetch the base address and pointer (and type for views) from the JS object, and pass them to WebCore's C++ code. I think it would be nicer to pass one stack-allocated structure instead of multiple arguments, which is what this patch does for WebGL's C++ entry points. > > In fact, for such methods, we can completely eliminate the overloads which take C++ ArrayBuffer and ArrayBufferView pointers. If an "externally allocated" typed array is passed in, the bindings can just extract the values from the C++ objects. This would drive home the point that typed arrays are mostly owned by the VM and not by WebCore. > > The more difficult situation is when a JS-heap-allocated typed array is passed to a C++ method that references the object after the call returns (AudioContext.decodeAudioData) or does complex operations like transfer of ownership (Worker.postMessage). decodeAudioData can be supported by defining a JS handle type in WebCore which would prevent GC of the referenced object. Worker.postMessage with Transferables is harder and I expect the C++ backing objects would be allocated on demand, the data copied, and the JS objects transformed into simple wrappers. > > What are your thoughts? I agree that for cases where the C++ code only "borrows" an array buffer or view and doesn't hold on to it after returning, we shouldn't be allocating C++ state. But I disagree that we need the lightweight descriptors that you add in this patch in order to achieve goodness. If the goal is to only allocate JS objects for array buffers/views then we can just pass pointers to those directly into the methods that only borrow state. This will work by virtue of the fact that the JS VM is not running at that point, and already knows that the JS objects are live by virtue of them having to have been on the JS stack. The only way this would break is if someone made the awful mistake of trying to implement a concurrent copying GC for JavaScript. (If you want to know how bad that can get, then read either mine or McCloskey's dissertation on the horror that this leads to.) In short, descriptors buy us nothing here. For the cases of methods that do hold on to typed arrays after returning, your current patch doesn't help, either, since there we need some manner of stuff to inform the JS VM that the objects are referenced from C++ land. And I agree with your proposed way of doing that - it's just that the current patch doesn't actually accomplish that. In short, my objection is not to your high-level idea of what you're doing. I'm strictly disagreeing with this particular patch, which appears to not get you any closer to your goal. 810846 12 kbr 2013-01-18 11:03:46 -0800 (In reply to comment #11) > I agree that for cases where the C++ code only "borrows" an array buffer or view and doesn't hold on to it after returning, we shouldn't be allocating C++ state. Good. > In short, my objection is not to your high-level idea of what you're doing. I'm strictly disagreeing with this particular patch, which appears to not get you any closer to your goal. This patch would have made it easier for me to make the CodeGeneratorJS and CodeGeneratorV8 changes to support the new WebKit IDL extended attribute indicating that the callee doesn't retain the incoming typed arrays. It's unfortunate that I won't be able to build upon this patch when making those changes, but I'll upload a new patch implementing them without using these descriptors. 810851 13 fpizlo 2013-01-18 11:08:25 -0800 (In reply to comment #12) > (In reply to comment #11) > > I agree that for cases where the C++ code only "borrows" an array buffer or view and doesn't hold on to it after returning, we shouldn't be allocating C++ state. > > Good. > > > In short, my objection is not to your high-level idea of what you're doing. I'm strictly disagreeing with this particular patch, which appears to not get you any closer to your goal. > > This patch would have made it easier for me to make the CodeGeneratorJS and CodeGeneratorV8 changes to support the new WebKit IDL extended attribute indicating that the callee doesn't retain the incoming typed arrays. Can you elaborate on this? > > It's unfortunate that I won't be able to build upon this patch when making those changes, but I'll upload a new patch implementing them without using these descriptors. If you're making a change that by itself makes the code strictly more complex, you should be more specific about what the end goal is what what your plan is for getting there. As it stands, I still don't see how adding descriptors makes life better. 810994 14 oliver 2013-01-18 13:44:59 -0800 (In reply to comment #12) > (In reply to comment #11) > > I agree that for cases where the C++ code only "borrows" an array buffer or view and doesn't hold on to it after returning, we shouldn't be allocating C++ state. > > Good. > > > In short, my objection is not to your high-level idea of what you're doing. I'm strictly disagreeing with this particular patch, which appears to not get you any closer to your goal. > > This patch would have made it easier for me to make the CodeGeneratorJS and CodeGeneratorV8 changes to support the new WebKit IDL extended attribute indicating that the callee doesn't retain the incoming typed arrays. > This is kind of terrifying to me - IDL doesn't generally specify the lifetime of parameters passed to it, and i'm not sure how you can verify that what an attribute claims ends up matching the implementation behaviour deep in C++ landia. I'm also a little confused as to where this attribute would be applied as webgl is filled with typed array apis they take ownership for an unbound amount of time. What am I missing? 811025 15 kbr 2013-01-18 14:05:52 -0800 (In reply to comment #14) > This is kind of terrifying to me - IDL doesn't generally specify the lifetime of parameters passed to it, and i'm not sure how you can verify that what an attribute claims ends up matching the implementation behaviour deep in C++ landia. If this proposed extended attribute is supplied, then the WebCore code won't receive references to the WTF ArrayBuffer or ArrayBufferView objects at all. Of course it's possible that there could be a bug in the callee where it refers to the storage after it's allowed to, but that's no different than a refcounting bug where the callee fails to use RefPtr. > I'm also a little confused as to where this attribute would be applied as webgl is filled with typed array apis they take ownership for an unbound amount of time. What am I missing? This is not the case. None of the WebGL APIs that take ArrayBuffer or ArrayBufferView reference the incoming buffer or view after the call returns. I'm preparing a patch that should clarify things. 811033 16 oliver 2013-01-18 14:17:35 -0800 (In reply to comment #15) > (In reply to comment #14) > > This is kind of terrifying to me - IDL doesn't generally specify the lifetime of parameters passed to it, and i'm not sure how you can verify that what an attribute claims ends up matching the implementation behaviour deep in C++ landia. > > If this proposed extended attribute is supplied, then the WebCore code won't receive references to the WTF ArrayBuffer or ArrayBufferView objects at all. Of course it's possible that there could be a bug in the callee where it refers to the storage after it's allowed to, but that's no different than a refcounting bug where the callee fails to use RefPtr. > > > I'm also a little confused as to where this attribute would be applied as webgl is filled with typed array apis they take ownership for an unbound amount of time. What am I missing? > > This is not the case. None of the WebGL APIs that take ArrayBuffer or ArrayBufferView reference the incoming buffer or view after the call returns. > > I'm preparing a patch that should clarify things. So essentially this would not apply to any of the typed array apis? Or do we do security tracking in terms of the buffer objects, and the bufferData API copies immediately? 811042 17 kbr 2013-01-18 14:25:23 -0800 (In reply to comment #16) > So essentially this would not apply to any of the typed array apis? If I understand what you're asking, then no, the new attribute definitely won't be applied to the typed arrays' IDL files. To start, it will only be applied to methods on WebGLRenderingContext. > Or do we do security tracking in terms of the buffer objects, and the bufferData API copies immediately? CORS security checks are done during texImage2D and texSubImage2D calls, and the call immediately throws if the check fails. There is no notion of a tainted WebGL context, nor of tainted WebGL texture or buffer objects. The bufferData and bufferSubData APIs copy their incoming data immediately to the GPU. 813419 18 kbr 2013-01-22 14:34:12 -0800 Changing description to more accurately reflect coming patch, from: Add lightweight descriptors for ArrayBuffer and ArrayBufferView to: Prepare WebGL methods and binding generators for VM-allocated typed arrays 813465 19 184058 kbr 2013-01-22 15:19:43 -0800 Created attachment 184058 Patch 813474 20 fpizlo 2013-01-22 15:29:52 -0800 Kenneth: I think the previous two patches, and the discussion, has left us talking cross-purposes. Can you directly answer these questions: 1) Do you plan to make the existing ArrayBuffer/ArrayBufferView classes be VM-allocated? 2) What type will these classes have? My intuition is that making them VM allocated will result in us being able to pass an ArrayBuffer* or an ArrayBufferView* directly into WebGL code, without changing the APIs of those classes. If there is some V8 restriction that prevents this, then we should be careful about adding complexity to WebCore just because of V8 bugs. There is to my knowledge nothing in JavaScriptCore that would prevent the above. As such, this new patch of yours seems just as superfluous as the previous patch. 813568 21 kbr 2013-01-22 16:54:06 -0800 (In reply to comment #20) > Kenneth: I think the previous two patches, and the discussion, has left us talking cross-purposes. > > Can you directly answer these questions: > > 1) Do you plan to make the existing ArrayBuffer/ArrayBufferView classes be VM-allocated? Not the C++ implementations. The intent is to move the implementation of the JavaScript ArrayBuffer type and all of the views entirely into the VM for the majority of use cases. > 2) What type will these classes have? From JavaScript's point of view they will have the same types. They will obey instanceof checks and have all of the properties and functions defined by the spec. > My intuition is that making them VM allocated will result in us being able to pass an ArrayBuffer* or an ArrayBufferView* directly into WebGL code, without changing the APIs of those classes. > > If there is some V8 restriction that prevents this, then we should be careful about adding complexity to WebCore just because of V8 bugs. There is no bug nor restriction in V8. We do not want to have the overhead of setting up structures to make them look like instances of the WTF ArrayBuffer or ArrayBufferView classes. Ulan Degenbaev (CC'd) has profiled typed array allocation and found that the majority of the time is spent in this C++ code. We absolutely do not want to call out to C++ to initialize these objects, and we do not want to add code to the JIT to mimic what the C++ compiler does during initialization of these objects in the hope that simply avoiding the call out to C++ will speed things up. From the standpoint of most of the web APIs taking typed arrays, the setup of the C++ ArrayBuffer and ArrayBufferView structures is completely unnecessary overhead. > There is to my knowledge nothing in JavaScriptCore that would prevent the above. > > As such, this new patch of yours seems just as superfluous as the previous patch. JSC will want to avoid this initialization overhead in exactly the same manner as V8. This patch is neither V8-specific nor superflous. It allows the typed array internalization work to proceed in parallel, without the engineers having to carry around large patches to WebCore. 813582 22 fpizlo 2013-01-22 17:09:46 -0800 (In reply to comment #21) > (In reply to comment #20) > > Kenneth: I think the previous two patches, and the discussion, has left us talking cross-purposes. > > > > Can you directly answer these questions: > > > > 1) Do you plan to make the existing ArrayBuffer/ArrayBufferView classes be VM-allocated? > > Not the C++ implementations. The intent is to move the implementation of the JavaScript ArrayBuffer type and all of the views entirely into the VM for the majority of use cases. > > > 2) What type will these classes have? > > From JavaScript's point of view they will have the same types. They will obey instanceof checks and have all of the properties and functions defined by the spec. > > > My intuition is that making them VM allocated will result in us being able to pass an ArrayBuffer* or an ArrayBufferView* directly into WebGL code, without changing the APIs of those classes. > > > > If there is some V8 restriction that prevents this, then we should be careful about adding complexity to WebCore just because of V8 bugs. > > There is no bug nor restriction in V8. We do not want to have the overhead of setting up structures to make them look like instances of the WTF ArrayBuffer or ArrayBufferView classes. Ulan Degenbaev (CC'd) has profiled typed array allocation and found that the majority of the time is spent in this C++ code. We absolutely do not want to call out to C++ to initialize these objects, and we do not want to add code to the JIT to mimic what the C++ compiler does during initialization of these objects in the hope that simply avoiding the call out to C++ will speed things up. From the standpoint of most of the web APIs taking typed arrays, the setup of the C++ ArrayBuffer and ArrayBufferView structures is completely unnecessary overhead. Here's my desire: let's reach consensus on what exactly this means before moving forward. What do you mean by C++ initializing the objects? The dominant cost in the ArrayBuffer::create method appears to be the use of fastMalloc for allocation, rather than using inlined GC allocators. But I don't think even that is the current dominant cost: right now array buffer allocation is dominated by the fact that we have to allocate ~5 objects, each with fastMalloc calls. The problem is far more systemic than just the fact that it's done in C++. I think it would be worthwhile if you guys could share more data on this. In particular, I think when people blame performance of object allocations in a managed language on C++ allocators, they are often conflating these factors: A) The cost of calling malloc, as opposed to calling the VM's GC allocator. B) The ABI costs of making a call from managed code to native code. C) The cost of C++ code performing accesses into the heap (if C++ does such accesses it's usually slower than JS doing it, since the C++ code won't quite benefit from inline caching). D) The cost of the C++ code itself not counting (A). In the case of ArrayBuffer allocators, I don't think (C) is the problem. (A) is a problem, but I have a hard time believing that it's that big of a deal - and anyway, that's neither here nor there since the whole point is to make the allocation use the GC. And I really have a hard time buying that it's (D) since as I've pointed out before, this is just a handful of stores. Yet, it appears that you are arguing that (D) is indeed the problem. Visual inspection of the code implies that this can't be the case because the code isn't really doing that much. So please, if you want to convince me that the setup of C++ state is expensive, you're going to have to try harder. > > > There is to my knowledge nothing in JavaScriptCore that would prevent the above. > > > > As such, this new patch of yours seems just as superfluous as the previous patch. > > JSC will want to avoid this initialization overhead in exactly the same manner as V8. This patch is neither V8-specific nor superflous. It allows the typed array internalization work to proceed in parallel, without the engineers having to carry around large patches to WebCore. We (JSC) will not want to avoid this initialization overhead, because we don't have reason to believe that the overhead is significant. You need to do a better job of convincing me that the overhead is real. 868899 23 kbr 2013-04-03 14:18:21 -0700 Given recent developments, I am not going to pursue incorporating this patch into WebKit. 183297 2013-01-17 15:26:15 -0800 2013-01-22 15:19:40 -0800 Patch bug-107185-20130117152315.patch text/plain 43680 kbr U3VidmVyc2lvbiBSZXZpc2lvbjogMTQwMDUzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDA4YmRkMWMzNmY1YjcyNjMxNDI2N2Jh N2U5NWQ3ODQyZTk2ZDg2NjcuLjUwMjUxNjg0ZTc4MjAyMWU5MjIyYTBhNDk2ZWQ1NjYwMzkyMDNj ODEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMzMgQEAKKzIwMTMtMDEtMTcgIEtlbm5ldGggUnVzc2VsbCAgPGti ckBnb29nbGUuY29tPgorCisgICAgICAgIEFkZCBsaWdodHdlaWdodCBkZXNjcmlwdG9ycyBmb3Ig QXJyYXlCdWZmZXIgYW5kIEFycmF5QnVmZmVyVmlldworICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTA3MTg1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9C T0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkZWQgc3RydWN0cyBkZXNjcmliaW5nIEFycmF5QnVm ZmVyIGFuZCBBcnJheUJ1ZmZlclZpZXcgd2hpY2ggY2FuCisgICAgICAgIGJlIHN0YWNrLWFsbG9j YXRlZCBldmVuIHdpdGhvdXQgaGF2aW5nIGluc3RhbmNlcyBvZiB0aGVzZSBjbGFzc2VzLgorICAg ICAgICBUaGV5IGFyZSBuZWVkZWQgaW4gb3JkZXIgdG8gbW92ZSBhbGxvY2F0aW9uIG9mIHR5cGVk IGFycmF5cyBpbnRvCisgICAgICAgIHRoZSBKYXZhU2NyaXB0IGhlYXAsIGFuZCBhbHNvIGFsbG93 IHVuaWZpY2F0aW9uIG9mIGNvZGUgaW4gdGhlCisgICAgICAgIFdlYkdMIGltcGxlbWVudGF0aW9u IGFuZCBwcm9iYWJseSBlbHNld2hlcmUuCisKKyAgICAgICAgKiBHTlVtYWtlZmlsZS5saXN0LmFt OgorICAgICAgICAqIFdURi5neXBpOgorICAgICAgICAqIFdURi5wcm86CisgICAgICAgICogV1RG LnZjcHJvai9XVEYudmNwcm9qOgorICAgICAgICAqIFdURi54Y29kZXByb2ovcHJvamVjdC5wYnhw cm9qOgorICAgICAgICAgICAgQWRkZWQgbmV3IGhlYWRlcnMuCisgICAgICAgICogd3RmL0FycmF5 QnVmZmVyRGVzY3JpcHRvci5oOiBBZGRlZC4KKyAgICAgICAgKFdURik6CisgICAgICAgIChXVEY6 OkFycmF5QnVmZmVyRGVzY3JpcHRvcjo6QXJyYXlCdWZmZXJEZXNjcmlwdG9yKToKKyAgICAgICAg KEFycmF5QnVmZmVyRGVzY3JpcHRvcik6CisgICAgICAgICAgICBBZGRlZCBuZXcgbGlnaHR3ZWln aHQgZGVzY3JpcHRvciBzdHJ1Y3QuCisgICAgICAgICogd3RmL0FycmF5QnVmZmVyVmlld0Rlc2Ny aXB0b3IuaDogQWRkZWQuCisgICAgICAgIChXVEYpOgorICAgICAgICAoV1RGOjpBcnJheUJ1ZmZl clZpZXdEZXNjcmlwdG9yOjpBcnJheUJ1ZmZlclZpZXdEZXNjcmlwdG9yKToKKyAgICAgICAgKEFy cmF5QnVmZmVyVmlld0Rlc2NyaXB0b3IpOgorICAgICAgICAgICAgQWRkZWQgbmV3IGxpZ2h0d2Vp Z2h0IGRlc2NyaXB0b3Igc3RydWN0LgorCiAyMDEzLTAxLTE3ICBBZGFtIEJhcnRoICA8YWJhcnRo QHdlYmtpdC5vcmc+CiAKICAgICAgICAgVGVhY2ggRnVuY3Rpb25hbC5oIGFib3V0IFdlYWtQdHIK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCA2MTNjZGEwMDFlZmE1NWMzNTQ2NDNhZWI2YThhNDkwMmNlNmY5NTA5Li5l ZWY0N2IxYmI1OGRkZDA2Zjc0NTc2YWMzZjY2NzNiMWVjMzhhYmM4IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0x LDMgKzEsNDQgQEAKKzIwMTMtMDEtMTcgIEtlbm5ldGggUnVzc2VsbCAgPGtickBnb29nbGUuY29t PgorCisgICAgICAgIEFkZCBsaWdodHdlaWdodCBkZXNjcmlwdG9ycyBmb3IgQXJyYXlCdWZmZXIg YW5kIEFycmF5QnVmZmVyVmlldworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MTA3MTg1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgQWRkZWQgc3RydWN0cyBkZXNjcmliaW5nIEFycmF5QnVmZmVyIGFuZCBBcnJh eUJ1ZmZlclZpZXcgd2hpY2ggY2FuCisgICAgICAgIGJlIHN0YWNrLWFsbG9jYXRlZCBldmVuIHdp dGhvdXQgaGF2aW5nIGluc3RhbmNlcyBvZiB0aGVzZSBjbGFzc2VzLgorICAgICAgICBUaGV5IGFy ZSBuZWVkZWQgaW4gb3JkZXIgdG8gbW92ZSBhbGxvY2F0aW9uIG9mIHR5cGVkIGFycmF5cyBpbnRv CisgICAgICAgIHRoZSBKYXZhU2NyaXB0IGhlYXAsIGFuZCBhbHNvIGFsbG93IHVuaWZpY2F0aW9u IG9mIGNvZGUgaW4gdGhlCisgICAgICAgIFdlYkdMIGltcGxlbWVudGF0aW9uIGFuZCBwcm9iYWJs eSBlbHNld2hlcmUuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzOyBubyBzZW1hbnRpYyBjaGFuZ2Uu IENvdmVyZWQgYnkgZXhpc3RpbmcgdGVzdHMuIFJhbgorICAgICAgICBXZWJHTCBsYXlvdXQgdGVz dHMsIGNvbmZvcm1hbmNlIHRlc3RzLCBhbmQgb3RoZXIgZXhhbXBsZXMuCisKKyAgICAgICAgKiBo dG1sL2NhbnZhcy9XZWJHTEJ1ZmZlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpXZWJHTEJ1ZmZl cjo6YXNzb2NpYXRlQnVmZmVyRGF0YSk6CisgICAgICAgIChXZWJDb3JlOjpXZWJHTEJ1ZmZlcjo6 YXNzb2NpYXRlQnVmZmVyU3ViRGF0YSk6CisgICAgICAgICAgICBFeHBvc2VkIG92ZXJsb2FkcyB0 YWtpbmcgcG9pbnRlciBhbmQgc2l6ZS4KKyAgICAgICAgKiBodG1sL2NhbnZhcy9XZWJHTEJ1ZmZl ci5oOgorICAgICAgICAoV2ViR0xCdWZmZXIpOgorICAgICAgICAgICAgRXhwb3NlZCBvdmVybG9h ZHMgdGFraW5nIHBvaW50ZXIgYW5kIHNpemUuCisgICAgICAgICogaHRtbC9jYW52YXMvV2ViR0xS ZW5kZXJpbmdDb250ZXh0LmNwcDoKKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoV2ViQ29y ZTo6V2ViR0xSZW5kZXJpbmdDb250ZXh0OjpidWZmZXJEYXRhKToKKyAgICAgICAgKFdlYkNvcmU6 OldlYkdMUmVuZGVyaW5nQ29udGV4dDo6YnVmZmVyU3ViRGF0YSk6CisgICAgICAgIChXZWJDb3Jl OjpXZWJHTFJlbmRlcmluZ0NvbnRleHQ6OmNvbXByZXNzZWRUZXhJbWFnZTJEKToKKyAgICAgICAg KFdlYkNvcmU6OldlYkdMUmVuZGVyaW5nQ29udGV4dDo6Y29tcHJlc3NlZFRleFN1YkltYWdlMkQp OgorICAgICAgICAoV2ViQ29yZTo6V2ViR0xSZW5kZXJpbmdDb250ZXh0OjpyZWFkUGl4ZWxzKToK KyAgICAgICAgKFdlYkNvcmU6OldlYkdMUmVuZGVyaW5nQ29udGV4dDo6dGV4SW1hZ2UyRCk6Cisg ICAgICAgIChXZWJDb3JlOjpXZWJHTFJlbmRlcmluZ0NvbnRleHQ6OnRleFN1YkltYWdlMkQpOgor ICAgICAgICAgICAgQWRkZWQgb3ZlcmxvYWRzIHRha2luZyBBcnJheUJ1ZmZlckRlc2NyaXB0b3Ig YW5kIEFycmF5QnVmZmVyVmlld0Rlc2NyaXB0b3IgYW5kIGltcGxlbWVudGVkIG90aGVyIG9uZXMg aW4gdGVybXMgb2YgdGhlc2UuCisgICAgICAgIChXZWJDb3JlOjpXZWJHTFJlbmRlcmluZ0NvbnRl eHQ6OnZhbGlkYXRlVGV4RnVuY0RhdGEpOgorICAgICAgICAgICAgQ2hhbmdlZCB0byB0YWtlIEFy cmF5QnVmZmVyVmlld0Rlc2NyaXB0b3IgaW5zdGVhZCBvZiBBcnJheUJ1ZmZlclZpZXcuCisgICAg ICAgIChXZWJDb3JlOjpXZWJHTFJlbmRlcmluZ0NvbnRleHQ6OnZhbGlkYXRlQ29tcHJlc3NlZFRl eEZ1bmNEYXRhKToKKyAgICAgICAgICAgIENoYW5nZWQgdG8gdGFrZSBBcnJheUJ1ZmZlclZpZXdE ZXNjcmlwdG9yIGluc3RlYWQgb2YgQXJyYXlCdWZmZXJWaWV3LgorICAgICAgICAqIGh0bWwvY2Fu dmFzL1dlYkdMUmVuZGVyaW5nQ29udGV4dC5oOgorICAgICAgICAoV2ViR0xSZW5kZXJpbmdDb250 ZXh0KToKKyAgICAgICAgICAgIEFkZGVkIG92ZXJsb2FkcyB0YWtpbmcgQXJyYXlCdWZmZXJEZXNj cmlwdG9yIGFuZCBBcnJheUJ1ZmZlclZpZXdEZXNjcmlwdG9yIGFuZCBpbXBsZW1lbnRlZCBvdGhl ciBvbmVzIGluIHRlcm1zIG9mIHRoZXNlLgorCiAyMDEzLTAxLTE3ICBFcmljIFNlaWRlbCAgPGVy aWNAd2Via2l0Lm9yZz4KIAogICAgICAgICBTdG9wIHRoZSBiYWNrZ3JvdW5kIHBhcnNlciB3aGVu IGNhbmNlbGluZyBwYXJzaW5nIHRvIGF2b2lkIGNyYXNoaW5nIG9uIG1hbnkgbGF5b3V0IHRlc3Rz CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0dOVW1ha2VmaWxlLmxpc3QuYW0gYi9Tb3VyY2UvV1RG L0dOVW1ha2VmaWxlLmxpc3QuYW0KaW5kZXggMjFlODBhNjZiM2Q0YTNkNTg1NjA3OWViOGQ3NjBl Yzk3MzJmZWQ5My4uNzQyODdkZmY1ZGJmYTMwMGJkZjZjODc1NWI3NTVhMjdkMjZiODQyNyAxMDA2 NDQKLS0tIGEvU291cmNlL1dURi9HTlVtYWtlZmlsZS5saXN0LmFtCisrKyBiL1NvdXJjZS9XVEYv R05VbWFrZWZpbGUubGlzdC5hbQpAQCAtNyw4ICs3LDEwIEBAIHd0Zl9zb3VyY2VzICs9IFwKICAg ICBTb3VyY2UvV1RGL3d0Zi9BbHdheXNJbmxpbmUuaCBcCiAgICAgU291cmNlL1dURi93dGYvQXJy YXlCdWZmZXIuY3BwIFwKICAgICBTb3VyY2UvV1RGL3d0Zi9BcnJheUJ1ZmZlci5oIFwKKyAgICBT b3VyY2UvV1RGL3d0Zi9BcnJheUJ1ZmZlckRlc2NyaXB0b3IuaCBcCiAgICAgU291cmNlL1dURi93 dGYvQXJyYXlCdWZmZXJWaWV3LmNwcCBcCiAgICAgU291cmNlL1dURi93dGYvQXJyYXlCdWZmZXJW aWV3LmggXAorICAgIFNvdXJjZS9XVEYvd3RmL0FycmF5QnVmZmVyVmlld0Rlc2NyaXB0b3IuaCBc CiAgICAgU291cmNlL1dURi93dGYvQXNzZXJ0aW9ucy5jcHAgXAogICAgIFNvdXJjZS9XVEYvd3Rm L0Fzc2VydGlvbnMuaCBcCiAgICAgU291cmNlL1dURi93dGYvQXRvbWljcy5oIFwKZGlmZiAtLWdp dCBhL1NvdXJjZS9XVEYvV1RGLmd5cGkgYi9Tb3VyY2UvV1RGL1dURi5neXBpCmluZGV4IDUzMzZl MDk2ODA5NjI4ZTYyNmY1ZjBlZmJlYzIxN2FkZTNjMDYxMzguLmI0ZjU4NGMxNjlkNDllOWU3ZWI5 MmE1NzQyNDVjYmY2M2E2ZGU2MTggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvV1RGLmd5cGkKKysr IGIvU291cmNlL1dURi9XVEYuZ3lwaQpAQCAtMTQ5LDggKzE0OSwxMCBAQAogICAgICAgICAnd3Rm X2ZpbGVzJzogWwogICAgICAgICAgICAgJ3d0Zi9BcnJheUJ1ZmZlci5jcHAnLAogICAgICAgICAg ICAgJ3d0Zi9BcnJheUJ1ZmZlci5oJywKKyAgICAgICAgICAgICd3dGYvQXJyYXlCdWZmZXJEZXNj cmlwdG9yLmgnLAogICAgICAgICAgICAgJ3d0Zi9BcnJheUJ1ZmZlclZpZXcuY3BwJywKICAgICAg ICAgICAgICd3dGYvQXJyYXlCdWZmZXJWaWV3LmgnLAorICAgICAgICAgICAgJ3d0Zi9BcnJheUJ1 ZmZlclZpZXdEZXNjcmlwdG9yLmgnLAogICAgICAgICAgICAgJ3d0Zi9Bc3NlcnRpb25zLmNwcCcs CiAgICAgICAgICAgICAnd3RmL0JpdFZlY3Rvci5jcHAnLAogICAgICAgICAgICAgJ3d0Zi9Dcnlw dG9ncmFwaGljYWxseVJhbmRvbU51bWJlci5jcHAnLApkaWZmIC0tZ2l0IGEvU291cmNlL1dURi9X VEYucHJvIGIvU291cmNlL1dURi9XVEYucHJvCmluZGV4IGM5MjljNjgxNmFlZDZkNWZkN2NkYzkz YzVlNDlmMzljMDU2ZmRhZmQuLjNlYWViMGI2N2Q4OGE1YmJhMzEwZjY3ZWE2Mjg5NzFjMjYwMWU2 MzMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvV1RGLnBybworKysgYi9Tb3VyY2UvV1RGL1dURi5w cm8KQEAgLTIzLDcgKzIzLDkgQEAgSEVBREVSUyArPSBcCiAgICAgQWxpZ25tZW50LmggXAogICAg IEFsd2F5c0lubGluZS5oIFwKICAgICBBcnJheUJ1ZmZlci5oIFwKKyAgICBBcnJheUJ1ZmZlckRl c2NyaXB0b3IuaCBcCiAgICAgQXJyYXlCdWZmZXJWaWV3LmggXAorICAgIEFycmF5QnVmZmVyVmll d0Rlc2NyaXB0b3IuaCBcCiAgICAgQVNDSUlDVHlwZS5oIFwKICAgICBBc3NlcnRpb25zLmggXAog ICAgIEF0b21pY3MuaCBcCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL1dURi52Y3Byb2ovV1RGLnZj cHJvaiBiL1NvdXJjZS9XVEYvV1RGLnZjcHJvai9XVEYudmNwcm9qCmluZGV4IGY3M2I2ZmQ5ZTEx NTM4ZmViZTQ4OTg4ZDhlMWQ1MTY2YWI2NWY5OGUuLjRmYTVkM2EzYjBlZmM2MThlNDhjZDM5MTA3 MTE3MTNiYTY5MGRkMzAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvV1RGLnZjcHJvai9XVEYudmNw cm9qCisrKyBiL1NvdXJjZS9XVEYvV1RGLnZjcHJvai9XVEYudmNwcm9qCkBAIC01ODUsNiArNTg1 LDEwIEBACiAJCQk+CiAJCTwvRmlsZT4KIAkJPEZpbGUKKwkJCVJlbGF0aXZlUGF0aD0iLi5cd3Rm XEFycmF5QnVmZmVyRGVzY3JpcHRvci5oIgorCQkJPgorCQk8L0ZpbGU+CisJCTxGaWxlCiAJCQlS ZWxhdGl2ZVBhdGg9Ii4uXHd0ZlxBcnJheUJ1ZmZlclZpZXcuY3BwIgogCQkJPgogCQk8L0ZpbGU+ CkBAIC01OTMsNiArNTk3LDEwIEBACiAJCQk+CiAJCTwvRmlsZT4KIAkJPEZpbGUKKwkJCVJlbGF0 aXZlUGF0aD0iLi5cd3RmXEFycmF5QnVmZmVyVmlld0Rlc2NyaXB0b3IuaCIKKwkJCT4KKwkJPC9G aWxlPgorCQk8RmlsZQogCQkJUmVsYXRpdmVQYXRoPSIuLlx3dGZcQVNDSUlDVHlwZS5oIgogCQkJ PgogCQk8L0ZpbGU+CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL1dURi54Y29kZXByb2ovcHJvamVj dC5wYnhwcm9qIGIvU291cmNlL1dURi9XVEYueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagppbmRl eCA5OTlmNGM5ZWEwMDBlYjlhOWUyYTE4MmYwODU1NjMyMjMzODc4Y2ZkLi5lYTBjZDU1YmI2NjFm OTYxOTE3MjgxZWMxNjVkZjNhODMzNGI1YjU2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL1dURi54 Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1NvdXJjZS9XVEYvV1RGLnhjb2RlcHJvai9w cm9qZWN0LnBieHByb2oKQEAgLTY5LDYgKzY5LDggQEAKIAkJNEZDRjI3RTExNjE3MkU4NjAwQ0JG MDM3IC8qIE1lbW9yeUluc3RydW1lbnRhdGlvblN0cmluZy5oIGluIEhlYWRlcnMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNEZDRjI3RTAxNjE3MkU4NjAwQ0JGMDM3IC8qIE1l bW9yeUluc3RydW1lbnRhdGlvblN0cmluZy5oICovOyB9OwogCQk0RkQyQTM1OTE2MUIwRUUxMDBF QkYyMzYgLyogTWVtb3J5SW5zdHJ1bWVudGF0aW9uUGFyc2VkVVJMLmggaW4gSGVhZGVycyAqLyA9 IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0RkQyQTM1ODE2MUIwRUUxMDBFQkYyMzYg LyogTWVtb3J5SW5zdHJ1bWVudGF0aW9uUGFyc2VkVVJMLmggKi87IH07CiAJCTRGRDg1NTQ3MTYx MzNFMEUwMEM1QjcwNCAvKiBNZW1vcnlJbnN0cnVtZW50YXRpb25BcnJheUJ1ZmZlclZpZXcuaCBp biBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDRGRDg1NTQ2MTYx MzNFMEUwMEM1QjcwNCAvKiBNZW1vcnlJbnN0cnVtZW50YXRpb25BcnJheUJ1ZmZlclZpZXcuaCAq LzsgfTsKKwkJNkVEQzI1MUMxNkE4OTcxRDAwNjA5NkRGIC8qIEFycmF5QnVmZmVyRGVzY3JpcHRv ci5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNkVEQzI1 MUExNkE4OTcxRDAwNjA5NkRGIC8qIEFycmF5QnVmZmVyRGVzY3JpcHRvci5oICovOyB9OworCQk2 RURDMjUxRDE2QTg5NzFEMDA2MDk2REYgLyogQXJyYXlCdWZmZXJWaWV3RGVzY3JpcHRvci5oIGlu IEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNkVEQzI1MUIxNkE4 OTcxRDAwNjA5NkRGIC8qIEFycmF5QnVmZmVyVmlld0Rlc2NyaXB0b3IuaCAqLzsgfTsKIAkJN0Uy OUMzM0UxNUZGRDc5QjAwNTE2RDYxIC8qIE9iamNSdW50aW1lRXh0cmFzLmggaW4gSGVhZGVycyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3RTI5QzMzRDE1RkZENzlCMDA1MTZE NjEgLyogT2JqY1J1bnRpbWVFeHRyYXMuaCAqLzsgfTsKIAkJODEzNDAxMzgxNUIwOTJGRDAwMUZG MEI4IC8qIEJhc2U2NC5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZp bGVSZWYgPSA4MTM0MDEzNjE1QjA5MkZEMDAxRkYwQjggLyogQmFzZTY0LmNwcCAqLzsgfTsKIAkJ ODEzNDAxMzkxNUIwOTJGRDAwMUZGMEI4IC8qIEJhc2U2NC5oIGluIEhlYWRlcnMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gODEzNDAxMzcxNUIwOTJGRDAwMUZGMEI4IC8qIEJh c2U2NC5oICovOyB9OwpAQCAtMzc3LDYgKzM3OSw4IEBACiAJCTVEMjQ3QjczMTQ2ODlDNDcwMEU3 OEI3NiAvKiBXVEYueGNjb25maWcgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtu b3duRmlsZVR5cGUgPSB0ZXh0LnhjY29uZmlnOyBwYXRoID0gV1RGLnhjY29uZmlnOyBzb3VyY2VU cmVlID0gIjxncm91cD4iOyB9OwogCQk1RDI0N0VCMTE0NjhCMDE1MDBFNzhCNzYgLyogSGVhZGVy RGV0ZWN0aW9uLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0g NDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgbmFtZSA9IEhlYWRlckRldGVj dGlvbi5oOyBwYXRoID0gRGVyaXZlZFNvdXJjZXMvV1RGL0hlYWRlckRldGVjdGlvbi5oOyBzb3Vy Y2VUcmVlID0gQlVJTFRfUFJPRFVDVFNfRElSOyB9OwogCQk2NTQxQ0FGNDE2MzBEQjI2MDA2RDBE RUMgLyogQ29weVdURkhlYWRlcnMueGNjb25maWcgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5j ZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSB0ZXh0LnhjY29uZmlnOyBw YXRoID0gQ29weVdURkhlYWRlcnMueGNjb25maWc7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CisJCTZFREMyNTFBMTZBODk3MUQwMDYwOTZERiAvKiBBcnJheUJ1ZmZlckRlc2NyaXB0b3IuaCAq LyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25G aWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gQXJyYXlCdWZmZXJEZXNjcmlwdG9yLmg7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTZFREMyNTFCMTZBODk3MUQwMDYwOTZERiAv KiBBcnJheUJ1ZmZlclZpZXdEZXNjcmlwdG9yLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5j ZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsg cGF0aCA9IEFycmF5QnVmZmVyVmlld0Rlc2NyaXB0b3IuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+ IjsgfTsKIAkJN0UyOUMzM0QxNUZGRDc5QjAwNTE2RDYxIC8qIE9iamNSdW50aW1lRXh0cmFzLmgg Ki8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3du RmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IE9iamNSdW50aW1lRXh0cmFzLmg7IHNv dXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTgxMzQwMTM2MTVCMDkyRkQwMDFGRjBCOCAvKiBC YXNlNjQuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7 IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gQmFzZTY0LmNw cDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJODEzNDAxMzcxNUIwOTJGRDAwMUZGMEI4 IC8qIEJhc2U2NC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9 IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBCYXNlNjQuaDsg c291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTY4NSw4ICs2ODksMTAgQEAKIAkJCQlBOEE0 NzI1NTE1MUE4MjVBMDA0MTIzRkYgLyogQWx3YXlzSW5saW5lLmggKi8sCiAJCQkJQThBNDcyNTYx NTFBODI1QTAwNDEyM0ZGIC8qIEFycmF5QnVmZmVyLmNwcCAqLywKIAkJCQlBOEE0NzI1NzE1MUE4 MjVBMDA0MTIzRkYgLyogQXJyYXlCdWZmZXIuaCAqLywKKwkJCQk2RURDMjUxQTE2QTg5NzFEMDA2 MDk2REYgLyogQXJyYXlCdWZmZXJEZXNjcmlwdG9yLmggKi8sCiAJCQkJQThBNDcyNTgxNTFBODI1 QTAwNDEyM0ZGIC8qIEFycmF5QnVmZmVyVmlldy5jcHAgKi8sCiAJCQkJQThBNDcyNTkxNTFBODI1 QTAwNDEyM0ZGIC8qIEFycmF5QnVmZmVyVmlldy5oICovLAorCQkJCTZFREMyNTFCMTZBODk3MUQw MDYwOTZERiAvKiBBcnJheUJ1ZmZlclZpZXdEZXNjcmlwdG9yLmggKi8sCiAJCQkJQThBNDcyNUEx NTFBODI1QTAwNDEyM0ZGIC8qIEFTQ0lJQ1R5cGUuaCAqLywKIAkJCQlBOEE0NzI1QjE1MUE4MjVB MDA0MTIzRkYgLyogQXNzZXJ0aW9ucy5jcHAgKi8sCiAJCQkJQThBNDcyNUMxNTFBODI1QTAwNDEy M0ZGIC8qIEFzc2VydGlvbnMuaCAqLywKQEAgLTEyNTYsNiArMTI2Miw4IEBACiAJCQkJOTc0Q0ZD OEUxNkE0RjMyNzAwNkQ1NDA0IC8qIFdlYWtQdHIuaCBpbiBIZWFkZXJzICovLAogCQkJCUE4QTQ3 NDQ2MTUxQTgyNUIwMDQxMjNGRiAvKiBXVEZTdHJpbmcuaCBpbiBIZWFkZXJzICovLAogCQkJCUE4 QTQ3NDg3MTUxQTgyNUIwMDQxMjNGRiAvKiBXVEZUaHJlYWREYXRhLmggaW4gSGVhZGVycyAqLywK KwkJCQk2RURDMjUxQzE2QTg5NzFEMDA2MDk2REYgLyogQXJyYXlCdWZmZXJEZXNjcmlwdG9yLmgg aW4gSGVhZGVycyAqLywKKwkJCQk2RURDMjUxRDE2QTg5NzFEMDA2MDk2REYgLyogQXJyYXlCdWZm ZXJWaWV3RGVzY3JpcHRvci5oIGluIEhlYWRlcnMgKi8sCiAJCQkpOwogCQkJcnVuT25seUZvckRl cGxveW1lbnRQb3N0cHJvY2Vzc2luZyA9IDA7CiAJCX07CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RG L3d0Zi9BcnJheUJ1ZmZlckRlc2NyaXB0b3IuaCBiL1NvdXJjZS9XVEYvd3RmL0FycmF5QnVmZmVy RGVzY3JpcHRvci5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjM1MjE3OTNmMWI0NWI1YjQwMGE3NjNlNzRjYmEzZjQ4 OTlmY2Y1M2EKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9BcnJheUJ1ZmZlckRl c2NyaXB0b3IuaApAQCAtMCwwICsxLDY5IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEzIEdv b2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5k IHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2Rp ZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRp dGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUg bXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qg b2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0 cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmln aHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1h dGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZU V0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBDT01QVVRFUiwgSU5DLiBgYEFTIElTJycgQU5EIEFO WQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBM SU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkg QU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4g IElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIENPTVBVVEVSLCBJTkMuIE9SCisgKiBDT05UUklCVVRP UlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lB TCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJV VCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1Ig U0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1Mg SU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElB QklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisg KiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkg T1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBU SEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBBcnJheUJ1ZmZl ckRlc2NyaXB0b3JfaAorI2RlZmluZSBBcnJheUJ1ZmZlckRlc2NyaXB0b3JfaAorCisjaW5jbHVk ZSA8d3RmL0FycmF5QnVmZmVyLmg+CisjaW5jbHVkZSA8d3RmL0FycmF5QnVmZmVyVmlldy5oPgor CituYW1lc3BhY2UgV1RGIHsKKworLy8gQSBsaWdodHdlaWdodCBzdHJ1Y3QgZGVzY3JpYmluZyB0 aGUgY29udGVudHMgb2YgYW4gQXJyYXlCdWZmZXIsIHdoaWNoCisvLyBjYW4gYmUgYmUgc3RhY2st YWxsb2NhdGVkIGV2ZW4gd2l0aG91dCBhbiBBcnJheUJ1ZmZlciBpbnN0YW5jZS4KKworc3RydWN0 IEFycmF5QnVmZmVyRGVzY3JpcHRvciB7CisgICAgQXJyYXlCdWZmZXJEZXNjcmlwdG9yKHZvaWQq IGFkZHJlc3MsIHVuc2lnbmVkIGxlbmd0aCkKKyAgICAgICAgOiBiYXNlQWRkcmVzcyhhZGRyZXNz KSwgYnl0ZUxlbmd0aChsZW5ndGgpCisgICAgeworICAgIH0KKworICAgIGV4cGxpY2l0IEFycmF5 QnVmZmVyRGVzY3JpcHRvcihBcnJheUJ1ZmZlciogYnVmZmVyKQorICAgICAgICA6IGJhc2VBZGRy ZXNzKDApLCBieXRlTGVuZ3RoKDApCisgICAgeworICAgICAgICBpZiAoYnVmZmVyKSB7CisgICAg ICAgICAgICBiYXNlQWRkcmVzcyA9IGJ1ZmZlci0+ZGF0YSgpOworICAgICAgICAgICAgYnl0ZUxl bmd0aCA9IGJ1ZmZlci0+Ynl0ZUxlbmd0aCgpOworICAgICAgICB9CisgICAgfQorCisgICAgZXhw bGljaXQgQXJyYXlCdWZmZXJEZXNjcmlwdG9yKEFycmF5QnVmZmVyVmlldyogdmlldykKKyAgICAg ICAgOiBiYXNlQWRkcmVzcygwKSwgYnl0ZUxlbmd0aCgwKQorICAgIHsKKyAgICAgICAgaWYgKHZp ZXcpIHsKKyAgICAgICAgICAgIGJhc2VBZGRyZXNzID0gdmlldy0+YmFzZUFkZHJlc3MoKTsKKyAg ICAgICAgICAgIGJ5dGVMZW5ndGggPSB2aWV3LT5ieXRlTGVuZ3RoKCk7CisgICAgICAgIH0KKyAg ICB9CisKKyAgICB2b2lkKiBiYXNlQWRkcmVzczsKKyAgICB1bnNpZ25lZCBieXRlTGVuZ3RoOwor fTsKKworfSAvLyBuYW1lc3BhY2UgV1RGCisKK3VzaW5nIFdURjo6QXJyYXlCdWZmZXJEZXNjcmlw dG9yOworCisjZW5kaWYgLy8gQXJyYXlCdWZmZXJEZXNjcmlwdG9yX2gKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XVEYvd3RmL0FycmF5QnVmZmVyVmlld0Rlc2NyaXB0b3IuaCBiL1NvdXJjZS9XVEYvd3Rm L0FycmF5QnVmZmVyVmlld0Rlc2NyaXB0b3IuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4yYjc3MmRiYWIyMDcxNGFj NmVkMjRiZDUxNzllZDYzYTViOTNmZmUzCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dURi93 dGYvQXJyYXlCdWZmZXJWaWV3RGVzY3JpcHRvci5oCkBAIC0wLDAgKzEsNjAgQEAKKy8qCisgKiBD b3B5cmlnaHQgKEMpIDIwMTMgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisg KiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRo IG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0 IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0 aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAg ICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1 Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0 aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRh dGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlv bi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIENPTVBVVEVSLCBJ TkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywg SU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVT IE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQ T1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgQ09NUFVURVIsIElO Qy4gT1IKKyAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNU LCBJTkNJREVOVEFMLCBTUEVDSUFMLAorICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERB TUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogUFJPQ1VSRU1FTlQgT0Yg U1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCisgKiBQ Uk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBB TlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBM SUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0Up IEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwg RVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLwor CisjaWZuZGVmIEFycmF5QnVmZmVyVmlld0Rlc2NyaXB0b3JfaAorI2RlZmluZSBBcnJheUJ1ZmZl clZpZXdEZXNjcmlwdG9yX2gKKworI2luY2x1ZGUgPHd0Zi9BcnJheUJ1ZmZlckRlc2NyaXB0b3Iu aD4KKworI2luY2x1ZGUgPHd0Zi9BcnJheUJ1ZmZlclZpZXcuaD4KKworbmFtZXNwYWNlIFdURiB7 CisKKy8vIEEgbGlnaHR3ZWlnaHQgc3RydWN0IGRlc2NyaWJpbmcgdGhlIGNvbnRlbnRzIG9mIGFu IEFycmF5QnVmZmVyVmlldywgd2hpY2gKKy8vIGNhbiBiZSBiZSBzdGFjay1hbGxvY2F0ZWQgZXZl biB3aXRob3V0IGFuIEFycmF5QnVmZmVyVmlldyBpbnN0YW5jZS4KKworc3RydWN0IEFycmF5QnVm ZmVyVmlld0Rlc2NyaXB0b3IgOiBBcnJheUJ1ZmZlckRlc2NyaXB0b3IgeworICAgIEFycmF5QnVm ZmVyVmlld0Rlc2NyaXB0b3Iodm9pZCogYWRkcmVzcywgdW5zaWduZWQgbGVuZ3RoLCBBcnJheUJ1 ZmZlclZpZXc6OlZpZXdUeXBlIHR5cGUpCisgICAgICAgIDogQXJyYXlCdWZmZXJEZXNjcmlwdG9y KGFkZHJlc3MsIGxlbmd0aCkKKyAgICAgICAgLCB2aWV3VHlwZSh0eXBlKQorICAgIHsKKyAgICB9 CisKKyAgICBleHBsaWNpdCBBcnJheUJ1ZmZlclZpZXdEZXNjcmlwdG9yKEFycmF5QnVmZmVyVmll dyogdmlldykKKyAgICAgICAgOiBBcnJheUJ1ZmZlckRlc2NyaXB0b3IodmlldykKKyAgICAgICAg LCB2aWV3VHlwZShBcnJheUJ1ZmZlclZpZXc6OlR5cGVVaW50OCkKKyAgICB7CisgICAgICAgIGlm ICh2aWV3KQorICAgICAgICAgICAgdmlld1R5cGUgPSB2aWV3LT5nZXRUeXBlKCk7CisgICAgfQor CisgICAgQXJyYXlCdWZmZXJWaWV3OjpWaWV3VHlwZSB2aWV3VHlwZTsKK307CisKK30gLy8gbmFt ZXNwYWNlIFdURgorCit1c2luZyBXVEY6OkFycmF5QnVmZmVyVmlld0Rlc2NyaXB0b3I7CisKKyNl bmRpZiAvLyBBcnJheUJ1ZmZlclZpZXdEZXNjcmlwdG9yX2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL2h0bWwvY2FudmFzL1dlYkdMQnVmZmVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwv Y2FudmFzL1dlYkdMQnVmZmVyLmNwcAppbmRleCBmNWVhOTQ3ZTExOWJmYTVjMTc2NjZjMTZmOGIx MGJiMDM4ZDZiMzE5Li4wNjA5N2ZjYWM2ZTliYTBkOWRkYzEyZjViNmZhZGU2NDYwZjZkMTViIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL2NhbnZhcy9XZWJHTEJ1ZmZlci5jcHAKKysr IGIvU291cmNlL1dlYkNvcmUvaHRtbC9jYW52YXMvV2ViR0xCdWZmZXIuY3BwCkBAIC02MSw3ICs2 MSw3IEBAIHZvaWQgV2ViR0xCdWZmZXI6OmRlbGV0ZU9iamVjdEltcGwoR3JhcGhpY3NDb250ZXh0 M0QqIGNvbnRleHQzZCwgUGxhdGZvcm0zRE9iamVjCiAgICAgICBjb250ZXh0M2QtPmRlbGV0ZUJ1 ZmZlcihvYmplY3QpOwogfQogCi1ib29sIFdlYkdMQnVmZmVyOjphc3NvY2lhdGVCdWZmZXJEYXRh SW1wbChjb25zdCB2b2lkKiBkYXRhLCBHQzNEc2l6ZWlwdHIgYnl0ZUxlbmd0aCkKK2Jvb2wgV2Vi R0xCdWZmZXI6OmFzc29jaWF0ZUJ1ZmZlckRhdGEoY29uc3Qgdm9pZCogZGF0YSwgR0MzRHNpemVp cHRyIGJ5dGVMZW5ndGgpCiB7CiAgICAgaWYgKGJ5dGVMZW5ndGggPCAwKQogICAgICAgICByZXR1 cm4gZmFsc2U7CkBAIC05NSwyNCArOTUsMjQgQEAgYm9vbCBXZWJHTEJ1ZmZlcjo6YXNzb2NpYXRl QnVmZmVyRGF0YUltcGwoY29uc3Qgdm9pZCogZGF0YSwgR0MzRHNpemVpcHRyIGJ5dGVMZW4KIAog Ym9vbCBXZWJHTEJ1ZmZlcjo6YXNzb2NpYXRlQnVmZmVyRGF0YShHQzNEc2l6ZWlwdHIgc2l6ZSkK IHsKLSAgICByZXR1cm4gYXNzb2NpYXRlQnVmZmVyRGF0YUltcGwoMCwgc2l6ZSk7CisgICAgcmV0 dXJuIGFzc29jaWF0ZUJ1ZmZlckRhdGEoMCwgc2l6ZSk7CiB9CiAKIGJvb2wgV2ViR0xCdWZmZXI6 OmFzc29jaWF0ZUJ1ZmZlckRhdGEoQXJyYXlCdWZmZXIqIGFycmF5KQogewogICAgIGlmICghYXJy YXkpCiAgICAgICAgIHJldHVybiBmYWxzZTsKLSAgICByZXR1cm4gYXNzb2NpYXRlQnVmZmVyRGF0 YUltcGwoYXJyYXkgPyBhcnJheS0+ZGF0YSgpIDogMCwgYXJyYXkgPyBhcnJheS0+Ynl0ZUxlbmd0 aCgpIDogMCk7CisgICAgcmV0dXJuIGFzc29jaWF0ZUJ1ZmZlckRhdGEoYXJyYXkgPyBhcnJheS0+ ZGF0YSgpIDogMCwgYXJyYXkgPyBhcnJheS0+Ynl0ZUxlbmd0aCgpIDogMCk7CiB9CiAKIGJvb2wg V2ViR0xCdWZmZXI6OmFzc29jaWF0ZUJ1ZmZlckRhdGEoQXJyYXlCdWZmZXJWaWV3KiBhcnJheSkK IHsKICAgICBpZiAoIWFycmF5KQogICAgICAgICByZXR1cm4gZmFsc2U7Ci0gICAgcmV0dXJuIGFz c29jaWF0ZUJ1ZmZlckRhdGFJbXBsKGFycmF5ID8gYXJyYXktPmJhc2VBZGRyZXNzKCkgOiAwLCBh cnJheSA/IGFycmF5LT5ieXRlTGVuZ3RoKCkgOiAwKTsKKyAgICByZXR1cm4gYXNzb2NpYXRlQnVm ZmVyRGF0YShhcnJheSA/IGFycmF5LT5iYXNlQWRkcmVzcygpIDogMCwgYXJyYXkgPyBhcnJheS0+ Ynl0ZUxlbmd0aCgpIDogMCk7CiB9CiAKLWJvb2wgV2ViR0xCdWZmZXI6OmFzc29jaWF0ZUJ1ZmZl clN1YkRhdGFJbXBsKEdDM0RpbnRwdHIgb2Zmc2V0LCBjb25zdCB2b2lkKiBkYXRhLCBHQzNEc2l6 ZWlwdHIgYnl0ZUxlbmd0aCkKK2Jvb2wgV2ViR0xCdWZmZXI6OmFzc29jaWF0ZUJ1ZmZlclN1YkRh dGEoR0MzRGludHB0ciBvZmZzZXQsIGNvbnN0IHZvaWQqIGRhdGEsIEdDM0RzaXplaXB0ciBieXRl TGVuZ3RoKQogewogICAgIGlmICghZGF0YSB8fCBvZmZzZXQgPCAwIHx8IGJ5dGVMZW5ndGggPCAw KQogICAgICAgICByZXR1cm4gZmFsc2U7CkBAIC0xNDUsMTQgKzE0NSwxNCBAQCBib29sIFdlYkdM QnVmZmVyOjphc3NvY2lhdGVCdWZmZXJTdWJEYXRhKEdDM0RpbnRwdHIgb2Zmc2V0LCBBcnJheUJ1 ZmZlciogYXJyYXkpCiB7CiAgICAgaWYgKCFhcnJheSkKICAgICAgICAgcmV0dXJuIGZhbHNlOwot ICAgIHJldHVybiBhc3NvY2lhdGVCdWZmZXJTdWJEYXRhSW1wbChvZmZzZXQsIGFycmF5LT5kYXRh KCksIGFycmF5LT5ieXRlTGVuZ3RoKCkpOworICAgIHJldHVybiBhc3NvY2lhdGVCdWZmZXJTdWJE YXRhKG9mZnNldCwgYXJyYXktPmRhdGEoKSwgYXJyYXktPmJ5dGVMZW5ndGgoKSk7CiB9CiAKIGJv b2wgV2ViR0xCdWZmZXI6OmFzc29jaWF0ZUJ1ZmZlclN1YkRhdGEoR0MzRGludHB0ciBvZmZzZXQs IEFycmF5QnVmZmVyVmlldyogYXJyYXkpCiB7CiAgICAgaWYgKCFhcnJheSkKICAgICAgICAgcmV0 dXJuIGZhbHNlOwotICAgIHJldHVybiBhc3NvY2lhdGVCdWZmZXJTdWJEYXRhSW1wbChvZmZzZXQs IGFycmF5LT5iYXNlQWRkcmVzcygpLCBhcnJheS0+Ynl0ZUxlbmd0aCgpKTsKKyAgICByZXR1cm4g YXNzb2NpYXRlQnVmZmVyU3ViRGF0YShvZmZzZXQsIGFycmF5LT5iYXNlQWRkcmVzcygpLCBhcnJh eS0+Ynl0ZUxlbmd0aCgpKTsKIH0KIAogR0MzRHNpemVpcHRyIFdlYkdMQnVmZmVyOjpieXRlTGVu Z3RoKCkgY29uc3QKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvY2FudmFzL1dlYkdM QnVmZmVyLmggYi9Tb3VyY2UvV2ViQ29yZS9odG1sL2NhbnZhcy9XZWJHTEJ1ZmZlci5oCmluZGV4 IDRjZWVhOWJjOTViMTUyZmY4ODg5YWRiYWJhNTM4MThlZjEyMTM4NWIuLjdiNGIyYWU0N2EyZWUy MTJkNWM5N2Q2YzQ3ZjlmMTUyZmZkYTk5Y2IgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0 bWwvY2FudmFzL1dlYkdMQnVmZmVyLmgKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9jYW52YXMv V2ViR0xCdWZmZXIuaApAQCAtNDQsOCArNDQsMTAgQEAgcHVibGljOgogICAgIGJvb2wgYXNzb2Np YXRlQnVmZmVyRGF0YShHQzNEc2l6ZWlwdHIgc2l6ZSk7CiAgICAgYm9vbCBhc3NvY2lhdGVCdWZm ZXJEYXRhKEFycmF5QnVmZmVyKik7CiAgICAgYm9vbCBhc3NvY2lhdGVCdWZmZXJEYXRhKEFycmF5 QnVmZmVyVmlldyopOworICAgIGJvb2wgYXNzb2NpYXRlQnVmZmVyRGF0YShjb25zdCB2b2lkKiBk YXRhLCBHQzNEc2l6ZWlwdHIpOwogICAgIGJvb2wgYXNzb2NpYXRlQnVmZmVyU3ViRGF0YShHQzNE aW50cHRyIG9mZnNldCwgQXJyYXlCdWZmZXIqKTsKICAgICBib29sIGFzc29jaWF0ZUJ1ZmZlclN1 YkRhdGEoR0MzRGludHB0ciBvZmZzZXQsIEFycmF5QnVmZmVyVmlldyopOworICAgIGJvb2wgYXNz b2NpYXRlQnVmZmVyU3ViRGF0YShHQzNEaW50cHRyIG9mZnNldCwgY29uc3Qgdm9pZCogZGF0YSwg R0MzRHNpemVpcHRyKTsKIAogICAgIEdDM0RzaXplaXB0ciBieXRlTGVuZ3RoKCkgY29uc3Q7CiAg ICAgY29uc3QgQXJyYXlCdWZmZXIqIGVsZW1lbnRBcnJheUJ1ZmZlcigpIGNvbnN0IHsgcmV0dXJu IG1fZWxlbWVudEFycmF5QnVmZmVyLmdldCgpOyB9CkBAIC05MywxMSArOTUsNiBAQCBwcml2YXRl OgogCiAgICAgLy8gQ2xlYXJzIGFsbCBvZiB0aGUgY2FjaGVkIG1heCBpbmRpY2VzLgogICAgIHZv aWQgY2xlYXJDYWNoZWRNYXhJbmRpY2VzKCk7Ci0KLSAgICAvLyBIZWxwZXIgZnVuY3Rpb24gY2Fs bGVkIGJ5IHRoZSB0aHJlZSBhc3NvY2lhdGVCdWZmZXJEYXRhKCkuCi0gICAgYm9vbCBhc3NvY2lh dGVCdWZmZXJEYXRhSW1wbChjb25zdCB2b2lkKiBkYXRhLCBHQzNEc2l6ZWlwdHIgYnl0ZUxlbmd0 aCk7Ci0gICAgLy8gSGVscGVyIGZ1bmN0aW9uIGNhbGxlZCBieSB0aGUgdHdvIGFzc29jaWF0ZUJ1 ZmZlclN1YkRhdGEoKS4KLSAgICBib29sIGFzc29jaWF0ZUJ1ZmZlclN1YkRhdGFJbXBsKEdDM0Rp bnRwdHIgb2Zmc2V0LCBjb25zdCB2b2lkKiBkYXRhLCBHQzNEc2l6ZWlwdHIgYnl0ZUxlbmd0aCk7 CiB9OwogCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9odG1sL2NhbnZhcy9XZWJHTFJlbmRlcmluZ0NvbnRleHQuY3BwIGIvU291cmNlL1dlYkNvcmUv aHRtbC9jYW52YXMvV2ViR0xSZW5kZXJpbmdDb250ZXh0LmNwcAppbmRleCAxNzU5ZTFjOGNlNjA0 MDg2NWU1ZGE4MTQ0OGFhODBjYmVjOWNiYzEzLi5mZTI3ZmJkZGQ4MTUwNTFkYzhhY2ZmNTk5YjA4 NjJiZDE1MTllZWU4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL2NhbnZhcy9XZWJH TFJlbmRlcmluZ0NvbnRleHQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvY2FudmFzL1dl YkdMUmVuZGVyaW5nQ29udGV4dC5jcHAKQEAgLTExMTMsNzcgKzExMTMsNTYgQEAgdm9pZCBXZWJH TFJlbmRlcmluZ0NvbnRleHQ6OmJ1ZmZlckRhdGEoR0MzRGVudW0gdGFyZ2V0LCBsb25nIGxvbmcg c2l6ZSwgR0MzRGVudW0KIAogdm9pZCBXZWJHTFJlbmRlcmluZ0NvbnRleHQ6OmJ1ZmZlckRhdGEo R0MzRGVudW0gdGFyZ2V0LCBBcnJheUJ1ZmZlciogZGF0YSwgR0MzRGVudW0gdXNhZ2UsIEV4Y2Vw dGlvbkNvZGUmIGVjKQogewotICAgIFVOVVNFRF9QQVJBTShlYyk7Ci0gICAgaWYgKGlzQ29udGV4 dExvc3QoKSkKLSAgICAgICAgcmV0dXJuOwotICAgIFdlYkdMQnVmZmVyKiBidWZmZXIgPSB2YWxp ZGF0ZUJ1ZmZlckRhdGFQYXJhbWV0ZXJzKCJidWZmZXJEYXRhIiwgdGFyZ2V0LCB1c2FnZSk7Ci0g ICAgaWYgKCFidWZmZXIpCi0gICAgICAgIHJldHVybjsKLSAgICBpZiAoIWRhdGEpIHsKLSAgICAg ICAgc3ludGhlc2l6ZUdMRXJyb3IoR3JhcGhpY3NDb250ZXh0M0Q6OklOVkFMSURfVkFMVUUsICJi dWZmZXJEYXRhIiwgIm5vIGRhdGEiKTsKLSAgICAgICAgcmV0dXJuOwotICAgIH0KLSAgICBpZiAo IWlzRXJyb3JHZW5lcmF0ZWRPbk91dE9mQm91bmRzQWNjZXNzZXMoKSkgewotICAgICAgICBpZiAo IWJ1ZmZlci0+YXNzb2NpYXRlQnVmZmVyRGF0YShkYXRhKSkgewotICAgICAgICAgICAgc3ludGhl c2l6ZUdMRXJyb3IoR3JhcGhpY3NDb250ZXh0M0Q6OklOVkFMSURfVkFMVUUsICJidWZmZXJEYXRh IiwgImludmFsaWQgYnVmZmVyIik7Ci0gICAgICAgICAgICByZXR1cm47Ci0gICAgICAgIH0KLSAg ICB9Ci0KLSAgICBtX2NvbnRleHQtPmJ1ZmZlckRhdGEodGFyZ2V0LCBkYXRhLT5ieXRlTGVuZ3Ro KCksIGRhdGEtPmRhdGEoKSwgdXNhZ2UpOwotICAgIGNsZWFudXBBZnRlckdyYXBoaWNzQ2FsbChm YWxzZSk7CisgICAgQXJyYXlCdWZmZXJEZXNjcmlwdG9yIGRlc2NyaXB0b3IoZGF0YSk7CisgICAg YnVmZmVyRGF0YSh0YXJnZXQsIGRlc2NyaXB0b3IsIHVzYWdlLCBlYyk7CiB9CiAKKwogdm9pZCBX ZWJHTFJlbmRlcmluZ0NvbnRleHQ6OmJ1ZmZlckRhdGEoR0MzRGVudW0gdGFyZ2V0LCBBcnJheUJ1 ZmZlclZpZXcqIGRhdGEsIEdDM0RlbnVtIHVzYWdlLCBFeGNlcHRpb25Db2RlJiBlYykKIHsKKyAg ICBBcnJheUJ1ZmZlckRlc2NyaXB0b3IgZGVzY3JpcHRvcihkYXRhKTsKKyAgICBidWZmZXJEYXRh KHRhcmdldCwgZGVzY3JpcHRvciwgdXNhZ2UsIGVjKTsKK30KKworCit2b2lkIFdlYkdMUmVuZGVy aW5nQ29udGV4dDo6YnVmZmVyRGF0YShHQzNEZW51bSB0YXJnZXQsIGNvbnN0IEFycmF5QnVmZmVy RGVzY3JpcHRvciYgZGF0YSwgR0MzRGVudW0gdXNhZ2UsIEV4Y2VwdGlvbkNvZGUmIGVjKQorewog ICAgIFVOVVNFRF9QQVJBTShlYyk7CiAgICAgaWYgKGlzQ29udGV4dExvc3QoKSkKICAgICAgICAg cmV0dXJuOwogICAgIFdlYkdMQnVmZmVyKiBidWZmZXIgPSB2YWxpZGF0ZUJ1ZmZlckRhdGFQYXJh bWV0ZXJzKCJidWZmZXJEYXRhIiwgdGFyZ2V0LCB1c2FnZSk7CiAgICAgaWYgKCFidWZmZXIpCiAg ICAgICAgIHJldHVybjsKLSAgICBpZiAoIWRhdGEpIHsKKyAgICBpZiAoIWRhdGEuYmFzZUFkZHJl c3MpIHsKICAgICAgICAgc3ludGhlc2l6ZUdMRXJyb3IoR3JhcGhpY3NDb250ZXh0M0Q6OklOVkFM SURfVkFMVUUsICJidWZmZXJEYXRhIiwgIm5vIGRhdGEiKTsKICAgICAgICAgcmV0dXJuOwogICAg IH0KICAgICBpZiAoIWlzRXJyb3JHZW5lcmF0ZWRPbk91dE9mQm91bmRzQWNjZXNzZXMoKSkgewot ICAgICAgICBpZiAoIWJ1ZmZlci0+YXNzb2NpYXRlQnVmZmVyRGF0YShkYXRhKSkgeworICAgICAg ICBpZiAoIWJ1ZmZlci0+YXNzb2NpYXRlQnVmZmVyRGF0YShkYXRhLmJhc2VBZGRyZXNzLCBkYXRh LmJ5dGVMZW5ndGgpKSB7CiAgICAgICAgICAgICBzeW50aGVzaXplR0xFcnJvcihHcmFwaGljc0Nv bnRleHQzRDo6SU5WQUxJRF9WQUxVRSwgImJ1ZmZlckRhdGEiLCAiaW52YWxpZCBidWZmZXIiKTsK ICAgICAgICAgICAgIHJldHVybjsKICAgICAgICAgfQogICAgIH0KIAotICAgIG1fY29udGV4dC0+ YnVmZmVyRGF0YSh0YXJnZXQsIGRhdGEtPmJ5dGVMZW5ndGgoKSwgZGF0YS0+YmFzZUFkZHJlc3Mo KSwgdXNhZ2UpOworICAgIG1fY29udGV4dC0+YnVmZmVyRGF0YSh0YXJnZXQsIGRhdGEuYnl0ZUxl bmd0aCwgZGF0YS5iYXNlQWRkcmVzcywgdXNhZ2UpOwogICAgIGNsZWFudXBBZnRlckdyYXBoaWNz Q2FsbChmYWxzZSk7CiB9CiAKKwogdm9pZCBXZWJHTFJlbmRlcmluZ0NvbnRleHQ6OmJ1ZmZlclN1 YkRhdGEoR0MzRGVudW0gdGFyZ2V0LCBsb25nIGxvbmcgb2Zmc2V0LCBBcnJheUJ1ZmZlciogZGF0 YSwgRXhjZXB0aW9uQ29kZSYgZWMpCiB7Ci0gICAgVU5VU0VEX1BBUkFNKGVjKTsKLSAgICBpZiAo aXNDb250ZXh0TG9zdCgpKQotICAgICAgICByZXR1cm47Ci0gICAgV2ViR0xCdWZmZXIqIGJ1ZmZl ciA9IHZhbGlkYXRlQnVmZmVyRGF0YVBhcmFtZXRlcnMoImJ1ZmZlclN1YkRhdGEiLCB0YXJnZXQs IEdyYXBoaWNzQ29udGV4dDNEOjpTVEFUSUNfRFJBVyk7Ci0gICAgaWYgKCFidWZmZXIpCi0gICAg ICAgIHJldHVybjsKLSAgICBpZiAob2Zmc2V0IDwgMCkgewotICAgICAgICBzeW50aGVzaXplR0xF cnJvcihHcmFwaGljc0NvbnRleHQzRDo6SU5WQUxJRF9WQUxVRSwgImJ1ZmZlclN1YkRhdGEiLCAi b2Zmc2V0IDwgMCIpOwotICAgICAgICByZXR1cm47Ci0gICAgfQotICAgIGlmICghZGF0YSkKLSAg ICAgICAgcmV0dXJuOwotICAgIGlmICghaXNFcnJvckdlbmVyYXRlZE9uT3V0T2ZCb3VuZHNBY2Nl c3NlcygpKSB7Ci0gICAgICAgIGlmICghYnVmZmVyLT5hc3NvY2lhdGVCdWZmZXJTdWJEYXRhKHN0 YXRpY19jYXN0PEdDM0RpbnRwdHI+KG9mZnNldCksIGRhdGEpKSB7Ci0gICAgICAgICAgICBzeW50 aGVzaXplR0xFcnJvcihHcmFwaGljc0NvbnRleHQzRDo6SU5WQUxJRF9WQUxVRSwgImJ1ZmZlclN1 YkRhdGEiLCAib2Zmc2V0IG91dCBvZiByYW5nZSIpOwotICAgICAgICAgICAgcmV0dXJuOwotICAg ICAgICB9Ci0gICAgfQotCi0gICAgbV9jb250ZXh0LT5idWZmZXJTdWJEYXRhKHRhcmdldCwgc3Rh dGljX2Nhc3Q8R0MzRGludHB0cj4ob2Zmc2V0KSwgZGF0YS0+Ynl0ZUxlbmd0aCgpLCBkYXRhLT5k YXRhKCkpOwotICAgIGNsZWFudXBBZnRlckdyYXBoaWNzQ2FsbChmYWxzZSk7CisgICAgQXJyYXlC dWZmZXJEZXNjcmlwdG9yIGRlc2NyaXB0b3IoZGF0YSk7CisgICAgYnVmZmVyU3ViRGF0YSh0YXJn ZXQsIG9mZnNldCwgZGVzY3JpcHRvciwgZWMpOwogfQogCiB2b2lkIFdlYkdMUmVuZGVyaW5nQ29u dGV4dDo6YnVmZmVyU3ViRGF0YShHQzNEZW51bSB0YXJnZXQsIGxvbmcgbG9uZyBvZmZzZXQsIEFy cmF5QnVmZmVyVmlldyogZGF0YSwgRXhjZXB0aW9uQ29kZSYgZWMpCiB7CisgICAgQXJyYXlCdWZm ZXJEZXNjcmlwdG9yIGRlc2NyaXB0b3IoZGF0YSk7CisgICAgYnVmZmVyU3ViRGF0YSh0YXJnZXQs IG9mZnNldCwgZGVzY3JpcHRvciwgZWMpOworfQorCit2b2lkIFdlYkdMUmVuZGVyaW5nQ29udGV4 dDo6YnVmZmVyU3ViRGF0YShHQzNEZW51bSB0YXJnZXQsIGxvbmcgbG9uZyBvZmZzZXQsIGNvbnN0 IEFycmF5QnVmZmVyRGVzY3JpcHRvciYgZGF0YSwgRXhjZXB0aW9uQ29kZSYgZWMpCit7CiAgICAg VU5VU0VEX1BBUkFNKGVjKTsKICAgICBpZiAoaXNDb250ZXh0TG9zdCgpKQogICAgICAgICByZXR1 cm47CkBAIC0xMTk0LDE2ICsxMTczLDE2IEBAIHZvaWQgV2ViR0xSZW5kZXJpbmdDb250ZXh0Ojpi dWZmZXJTdWJEYXRhKEdDM0RlbnVtIHRhcmdldCwgbG9uZyBsb25nIG9mZnNldCwgQXJyCiAgICAg ICAgIHN5bnRoZXNpemVHTEVycm9yKEdyYXBoaWNzQ29udGV4dDNEOjpJTlZBTElEX1ZBTFVFLCAi YnVmZmVyU3ViRGF0YSIsICJvZmZzZXQgPCAwIik7CiAgICAgICAgIHJldHVybjsKICAgICB9Ci0g ICAgaWYgKCFkYXRhKQorICAgIGlmICghZGF0YS5iYXNlQWRkcmVzcykKICAgICAgICAgcmV0dXJu OwogICAgIGlmICghaXNFcnJvckdlbmVyYXRlZE9uT3V0T2ZCb3VuZHNBY2Nlc3NlcygpKSB7Ci0g ICAgICAgIGlmICghYnVmZmVyLT5hc3NvY2lhdGVCdWZmZXJTdWJEYXRhKHN0YXRpY19jYXN0PEdD M0RpbnRwdHI+KG9mZnNldCksIGRhdGEpKSB7CisgICAgICAgIGlmICghYnVmZmVyLT5hc3NvY2lh dGVCdWZmZXJTdWJEYXRhKHN0YXRpY19jYXN0PEdDM0RpbnRwdHI+KG9mZnNldCksIGRhdGEuYmFz ZUFkZHJlc3MsIGRhdGEuYnl0ZUxlbmd0aCkpIHsKICAgICAgICAgICAgIHN5bnRoZXNpemVHTEVy cm9yKEdyYXBoaWNzQ29udGV4dDNEOjpJTlZBTElEX1ZBTFVFLCAiYnVmZmVyU3ViRGF0YSIsICJv ZmZzZXQgb3V0IG9mIHJhbmdlIik7CiAgICAgICAgICAgICByZXR1cm47CiAgICAgICAgIH0KICAg ICB9CiAKLSAgICBtX2NvbnRleHQtPmJ1ZmZlclN1YkRhdGEodGFyZ2V0LCBzdGF0aWNfY2FzdDxH QzNEaW50cHRyPihvZmZzZXQpLCBkYXRhLT5ieXRlTGVuZ3RoKCksIGRhdGEtPmJhc2VBZGRyZXNz KCkpOworICAgIG1fY29udGV4dC0+YnVmZmVyU3ViRGF0YSh0YXJnZXQsIHN0YXRpY19jYXN0PEdD M0RpbnRwdHI+KG9mZnNldCksIGRhdGEuYnl0ZUxlbmd0aCwgZGF0YS5iYXNlQWRkcmVzcyk7CiAg ICAgY2xlYW51cEFmdGVyR3JhcGhpY3NDYWxsKGZhbHNlKTsKIH0KIApAQCAtMTMwOCw2ICsxMjg3 LDE1IEBAIHZvaWQgV2ViR0xSZW5kZXJpbmdDb250ZXh0Ojpjb21waWxlU2hhZGVyKFdlYkdMU2hh ZGVyKiBzaGFkZXIsIEV4Y2VwdGlvbkNvZGUmIGVjCiB2b2lkIFdlYkdMUmVuZGVyaW5nQ29udGV4 dDo6Y29tcHJlc3NlZFRleEltYWdlMkQoR0MzRGVudW0gdGFyZ2V0LCBHQzNEaW50IGxldmVsLCBH QzNEZW51bSBpbnRlcm5hbGZvcm1hdCwgR0MzRHNpemVpIHdpZHRoLAogICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEdDM0RzaXplaSBoZWlnaHQsIEdDM0Rp bnQgYm9yZGVyLCBBcnJheUJ1ZmZlclZpZXcqIGRhdGEpCiB7CisgICAgQXJyYXlCdWZmZXJWaWV3 RGVzY3JpcHRvciBkZXNjcmlwdG9yKGRhdGEpOworICAgIGNvbXByZXNzZWRUZXhJbWFnZTJEKHRh cmdldCwgbGV2ZWwsIGludGVybmFsZm9ybWF0LCB3aWR0aCwgaGVpZ2h0LCBib3JkZXIsIGRlc2Ny aXB0b3IpOworfQorCit2b2lkIFdlYkdMUmVuZGVyaW5nQ29udGV4dDo6Y29tcHJlc3NlZFRleElt YWdlMkQoCisgICAgR0MzRGVudW0gdGFyZ2V0LCBHQzNEaW50IGxldmVsLCBHQzNEZW51bSBpbnRl cm5hbGZvcm1hdCwgR0MzRHNpemVpIHdpZHRoLAorICAgIEdDM0RzaXplaSBoZWlnaHQsIEdDM0Rp bnQgYm9yZGVyLCBjb25zdCBBcnJheUJ1ZmZlclZpZXdEZXNjcmlwdG9yJiBkYXRhKQoreworCiAg ICAgaWYgKGlzQ29udGV4dExvc3QoKSkKICAgICAgICAgcmV0dXJuOwogICAgIGlmICghdmFsaWRh dGVUZXhGdW5jTGV2ZWwoImNvbXByZXNzZWRUZXhJbWFnZTJEIiwgdGFyZ2V0LCBsZXZlbCkpCkBA IC0xMzM1LDggKzEzMjMsOSBAQCB2b2lkIFdlYkdMUmVuZGVyaW5nQ29udGV4dDo6Y29tcHJlc3Nl ZFRleEltYWdlMkQoR0MzRGVudW0gdGFyZ2V0LCBHQzNEaW50IGxldmVsLAogICAgICAgICAgICAg cmV0dXJuOwogICAgICAgICB9CiAgICAgfQotICAgIGdyYXBoaWNzQ29udGV4dDNEKCktPmNvbXBy ZXNzZWRUZXhJbWFnZTJEKHRhcmdldCwgbGV2ZWwsIGludGVybmFsZm9ybWF0LCB3aWR0aCwgaGVp Z2h0LAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGJvcmRl ciwgZGF0YS0+Ynl0ZUxlbmd0aCgpLCBkYXRhLT5iYXNlQWRkcmVzcygpKTsKKyAgICBncmFwaGlj c0NvbnRleHQzRCgpLT5jb21wcmVzc2VkVGV4SW1hZ2UyRCgKKyAgICAgICAgdGFyZ2V0LCBsZXZl bCwgaW50ZXJuYWxmb3JtYXQsIHdpZHRoLCBoZWlnaHQsCisgICAgICAgIGJvcmRlciwgZGF0YS5i eXRlTGVuZ3RoLCBkYXRhLmJhc2VBZGRyZXNzKTsKICAgICB0ZXgtPnNldExldmVsSW5mbyh0YXJn ZXQsIGxldmVsLCBpbnRlcm5hbGZvcm1hdCwgd2lkdGgsIGhlaWdodCwgR3JhcGhpY3NDb250ZXh0 M0Q6OlVOU0lHTkVEX0JZVEUpOwogICAgIGNsZWFudXBBZnRlckdyYXBoaWNzQ2FsbChmYWxzZSk7 CiB9CkBAIC0xMzQ0LDYgKzEzMzMsMTQgQEAgdm9pZCBXZWJHTFJlbmRlcmluZ0NvbnRleHQ6OmNv bXByZXNzZWRUZXhJbWFnZTJEKEdDM0RlbnVtIHRhcmdldCwgR0MzRGludCBsZXZlbCwKIHZvaWQg V2ViR0xSZW5kZXJpbmdDb250ZXh0Ojpjb21wcmVzc2VkVGV4U3ViSW1hZ2UyRChHQzNEZW51bSB0 YXJnZXQsIEdDM0RpbnQgbGV2ZWwsIEdDM0RpbnQgeG9mZnNldCwgR0MzRGludCB5b2Zmc2V0LAog ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEdDM0Rz aXplaSB3aWR0aCwgR0MzRHNpemVpIGhlaWdodCwgR0MzRGVudW0gZm9ybWF0LCBBcnJheUJ1ZmZl clZpZXcqIGRhdGEpCiB7CisgICAgQXJyYXlCdWZmZXJWaWV3RGVzY3JpcHRvciBkZXNjcmlwdG9y KGRhdGEpOworICAgIGNvbXByZXNzZWRUZXhTdWJJbWFnZTJEKHRhcmdldCwgbGV2ZWwsIHhvZmZz ZXQsIHlvZmZzZXQsIHdpZHRoLCBoZWlnaHQsIGZvcm1hdCwgZGVzY3JpcHRvcik7Cit9CisKK3Zv aWQgV2ViR0xSZW5kZXJpbmdDb250ZXh0Ojpjb21wcmVzc2VkVGV4U3ViSW1hZ2UyRCgKKyAgICBH QzNEZW51bSB0YXJnZXQsIEdDM0RpbnQgbGV2ZWwsIEdDM0RpbnQgeG9mZnNldCwgR0MzRGludCB5 b2Zmc2V0LAorICAgIEdDM0RzaXplaSB3aWR0aCwgR0MzRHNpemVpIGhlaWdodCwgR0MzRGVudW0g Zm9ybWF0LCBjb25zdCBBcnJheUJ1ZmZlclZpZXdEZXNjcmlwdG9yJiBkYXRhKQorewogICAgIGlm IChpc0NvbnRleHRMb3N0KCkpCiAgICAgICAgIHJldHVybjsKICAgICBpZiAoIXZhbGlkYXRlVGV4 RnVuY0xldmVsKCJjb21wcmVzc2VkVGV4U3ViSW1hZ2UyRCIsIHRhcmdldCwgbGV2ZWwpKQpAQCAt MTM2Nyw4ICsxMzY0LDkgQEAgdm9pZCBXZWJHTFJlbmRlcmluZ0NvbnRleHQ6OmNvbXByZXNzZWRU ZXhTdWJJbWFnZTJEKEdDM0RlbnVtIHRhcmdldCwgR0MzRGludCBsZXYKICAgICBpZiAoIXZhbGlk YXRlQ29tcHJlc3NlZFRleFN1YkRpbWVuc2lvbnMoImNvbXByZXNzZWRUZXhTdWJJbWFnZTJEIiwg dGFyZ2V0LCBsZXZlbCwgeG9mZnNldCwgeW9mZnNldCwgd2lkdGgsIGhlaWdodCwgZm9ybWF0LCB0 ZXgpKQogICAgICAgICByZXR1cm47CiAKLSAgICBncmFwaGljc0NvbnRleHQzRCgpLT5jb21wcmVz c2VkVGV4U3ViSW1hZ2UyRCh0YXJnZXQsIGxldmVsLCB4b2Zmc2V0LCB5b2Zmc2V0LAotICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHdpZHRoLCBoZWlnaHQs IGZvcm1hdCwgZGF0YS0+Ynl0ZUxlbmd0aCgpLCBkYXRhLT5iYXNlQWRkcmVzcygpKTsKKyAgICBn cmFwaGljc0NvbnRleHQzRCgpLT5jb21wcmVzc2VkVGV4U3ViSW1hZ2UyRCgKKyAgICAgICAgdGFy Z2V0LCBsZXZlbCwgeG9mZnNldCwgeW9mZnNldCwKKyAgICAgICAgd2lkdGgsIGhlaWdodCwgZm9y bWF0LCBkYXRhLmJ5dGVMZW5ndGgsIGRhdGEuYmFzZUFkZHJlc3MpOwogICAgIGNsZWFudXBBZnRl ckdyYXBoaWNzQ2FsbChmYWxzZSk7CiB9CiAKQEAgLTMzMzIsNyArMzMzMCwxMyBAQCB2b2lkIFdl YkdMUmVuZGVyaW5nQ29udGV4dDo6cG9seWdvbk9mZnNldChHQzNEZmxvYXQgZmFjdG9yLCBHQzNE ZmxvYXQgdW5pdHMpCiAgICAgY2xlYW51cEFmdGVyR3JhcGhpY3NDYWxsKGZhbHNlKTsKIH0KIAot dm9pZCBXZWJHTFJlbmRlcmluZ0NvbnRleHQ6OnJlYWRQaXhlbHMoR0MzRGludCB4LCBHQzNEaW50 IHksIEdDM0RzaXplaSB3aWR0aCwgR0MzRHNpemVpIGhlaWdodCwgR0MzRGVudW0gZm9ybWF0LCBH QzNEZW51bSB0eXBlLCBBcnJheUJ1ZmZlclZpZXcqIHBpeGVscywgRXhjZXB0aW9uQ29kZSYpCit2 b2lkIFdlYkdMUmVuZGVyaW5nQ29udGV4dDo6cmVhZFBpeGVscyhHQzNEaW50IHgsIEdDM0RpbnQg eSwgR0MzRHNpemVpIHdpZHRoLCBHQzNEc2l6ZWkgaGVpZ2h0LCBHQzNEZW51bSBmb3JtYXQsIEdD M0RlbnVtIHR5cGUsIEFycmF5QnVmZmVyVmlldyogcGl4ZWxzLCBFeGNlcHRpb25Db2RlJiBlYykK K3sKKyAgICBBcnJheUJ1ZmZlclZpZXdEZXNjcmlwdG9yIGRlc2NyaXB0b3IocGl4ZWxzKTsKKyAg ICByZWFkUGl4ZWxzKHgsIHksIHdpZHRoLCBoZWlnaHQsIGZvcm1hdCwgdHlwZSwgZGVzY3JpcHRv ciwgZWMpOworfQorCit2b2lkIFdlYkdMUmVuZGVyaW5nQ29udGV4dDo6cmVhZFBpeGVscyhHQzNE aW50IHgsIEdDM0RpbnQgeSwgR0MzRHNpemVpIHdpZHRoLCBHQzNEc2l6ZWkgaGVpZ2h0LCBHQzNE ZW51bSBmb3JtYXQsIEdDM0RlbnVtIHR5cGUsIGNvbnN0IEFycmF5QnVmZmVyVmlld0Rlc2NyaXB0 b3ImIHBpeGVscywgRXhjZXB0aW9uQ29kZSYpCiB7CiAgICAgaWYgKGlzQ29udGV4dExvc3QoKSkK ICAgICAgICAgcmV0dXJuOwpAQCAtMzM0MCw3ICszMzQ0LDcgQEAgdm9pZCBXZWJHTFJlbmRlcmlu Z0NvbnRleHQ6OnJlYWRQaXhlbHMoR0MzRGludCB4LCBHQzNEaW50IHksIEdDM0RzaXplaSB3aWR0 aCwgR0MKICAgICAvLyB0YWludCB0aGUgb3JpZ2luIHVzaW5nIHRoZSBXZWJHTCBBUEkuCiAgICAg QVNTRVJUKGNhbnZhcygpLT5vcmlnaW5DbGVhbigpKTsKICAgICAvLyBWYWxpZGF0ZSBpbnB1dCBw YXJhbWV0ZXJzLgotICAgIGlmICghcGl4ZWxzKSB7CisgICAgaWYgKCFwaXhlbHMuYmFzZUFkZHJl c3MpIHsKICAgICAgICAgc3ludGhlc2l6ZUdMRXJyb3IoR3JhcGhpY3NDb250ZXh0M0Q6OklOVkFM SURfVkFMVUUsICJyZWFkUGl4ZWxzIiwgIm5vIGRlc3RpbmF0aW9uIEFycmF5QnVmZmVyVmlldyIp OwogICAgICAgICByZXR1cm47CiAgICAgfQpAQCAtMzM2OCw3ICszMzcyLDcgQEAgdm9pZCBXZWJH TFJlbmRlcmluZ0NvbnRleHQ6OnJlYWRQaXhlbHMoR0MzRGludCB4LCBHQzNEaW50IHksIEdDM0Rz aXplaSB3aWR0aCwgR0MKICAgICAgICAgcmV0dXJuOwogICAgIH0KICAgICAvLyBWYWxpZGF0ZSBh cnJheSB0eXBlIGFnYWluc3QgcGl4ZWwgdHlwZS4KLSAgICBpZiAocGl4ZWxzLT5nZXRUeXBlKCkg IT0gQXJyYXlCdWZmZXJWaWV3OjpUeXBlVWludDgpIHsKKyAgICBpZiAocGl4ZWxzLnZpZXdUeXBl ICE9IEFycmF5QnVmZmVyVmlldzo6VHlwZVVpbnQ4KSB7CiAgICAgICAgIHN5bnRoZXNpemVHTEVy cm9yKEdyYXBoaWNzQ29udGV4dDNEOjpJTlZBTElEX09QRVJBVElPTiwgInJlYWRQaXhlbHMiLCAi QXJyYXlCdWZmZXJWaWV3IG5vdCBVaW50OEFycmF5Iik7CiAgICAgICAgIHJldHVybjsKICAgICB9 CkBAIC0zMzg2LDE5ICszMzkwLDE5IEBAIHZvaWQgV2ViR0xSZW5kZXJpbmdDb250ZXh0OjpyZWFk UGl4ZWxzKEdDM0RpbnQgeCwgR0MzRGludCB5LCBHQzNEc2l6ZWkgd2lkdGgsIEdDCiAgICAgICAg ICAgICBzeW50aGVzaXplR0xFcnJvcihlcnJvciwgInJlYWRQaXhlbHMiLCAiaW52YWxpZCBkaW1l bnNpb25zIik7CiAgICAgICAgICAgICByZXR1cm47CiAgICAgICAgIH0KLSAgICAgICAgaWYgKHBp eGVscy0+Ynl0ZUxlbmd0aCgpIDwgdG90YWxCeXRlc1JlcXVpcmVkKSB7CisgICAgICAgIGlmIChw aXhlbHMuYnl0ZUxlbmd0aCA8IHRvdGFsQnl0ZXNSZXF1aXJlZCkgewogICAgICAgICAgICAgc3lu dGhlc2l6ZUdMRXJyb3IoR3JhcGhpY3NDb250ZXh0M0Q6OklOVkFMSURfT1BFUkFUSU9OLCAicmVh ZFBpeGVscyIsICJBcnJheUJ1ZmZlclZpZXcgbm90IGxhcmdlIGVub3VnaCBmb3IgZGltZW5zaW9u cyIpOwogICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICB9CiAgICAgfQogCiAgICAgY2xlYXJJ ZkNvbXBvc2l0ZWQoKTsKLSAgICB2b2lkKiBkYXRhID0gcGl4ZWxzLT5iYXNlQWRkcmVzcygpOwor ICAgIHZvaWQqIGRhdGEgPSBwaXhlbHMuYmFzZUFkZHJlc3M7CiAKICAgICB7CiAgICAgICAgIFNj b3BlZERyYXdpbmdCdWZmZXJCaW5kZXIgYmluZGVyKG1fZHJhd2luZ0J1ZmZlci5nZXQoKSwgbV9m cmFtZWJ1ZmZlckJpbmRpbmcuZ2V0KCkpOwogICAgICAgICBpZiAobV9pc1JvYnVzdG5lc3NFWFRT dXBwb3J0ZWQpCi0gICAgICAgICAgICBtX2NvbnRleHQtPmdldEV4dGVuc2lvbnMoKS0+cmVhZG5Q aXhlbHNFWFQoeCwgeSwgd2lkdGgsIGhlaWdodCwgZm9ybWF0LCB0eXBlLCBwaXhlbHMtPmJ5dGVM ZW5ndGgoKSwgZGF0YSk7CisgICAgICAgICAgICBtX2NvbnRleHQtPmdldEV4dGVuc2lvbnMoKS0+ cmVhZG5QaXhlbHNFWFQoeCwgeSwgd2lkdGgsIGhlaWdodCwgZm9ybWF0LCB0eXBlLCBwaXhlbHMu Ynl0ZUxlbmd0aCwgZGF0YSk7CiAgICAgICAgIGVsc2UKICAgICAgICAgICAgIG1fY29udGV4dC0+ cmVhZFBpeGVscyh4LCB5LCB3aWR0aCwgaGVpZ2h0LCBmb3JtYXQsIHR5cGUsIGRhdGEpOwogICAg IH0KQEAgLTM2NzAsOSArMzY3NCwxOCBAQCB2b2lkIFdlYkdMUmVuZGVyaW5nQ29udGV4dDo6dGV4 SW1hZ2UyRChHQzNEZW51bSB0YXJnZXQsIEdDM0RpbnQgbGV2ZWwsIEdDM0RlbnVtCiAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBHQzNEc2l6ZWkgd2lkdGgsIEdDM0RzaXpl aSBoZWlnaHQsIEdDM0RpbnQgYm9yZGVyLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgR0MzRGVudW0gZm9ybWF0LCBHQzNEZW51bSB0eXBlLCBBcnJheUJ1ZmZlclZpZXcq IHBpeGVscywgRXhjZXB0aW9uQ29kZSYgZWMpCiB7CisgICAgQXJyYXlCdWZmZXJWaWV3RGVzY3Jp cHRvciBkZXNjcmlwdG9yKHBpeGVscyk7CisgICAgdGV4SW1hZ2UyRCh0YXJnZXQsIGxldmVsLCBp bnRlcm5hbGZvcm1hdCwgd2lkdGgsIGhlaWdodCwgYm9yZGVyLCBmb3JtYXQsIHR5cGUsIGRlc2Ny aXB0b3IsIGVjKTsKK30KKwordm9pZCBXZWJHTFJlbmRlcmluZ0NvbnRleHQ6OnRleEltYWdlMkQo CisgICAgR0MzRGVudW0gdGFyZ2V0LCBHQzNEaW50IGxldmVsLCBHQzNEZW51bSBpbnRlcm5hbGZv cm1hdCwKKyAgICBHQzNEc2l6ZWkgd2lkdGgsIEdDM0RzaXplaSBoZWlnaHQsIEdDM0RpbnQgYm9y ZGVyLAorICAgIEdDM0RlbnVtIGZvcm1hdCwgR0MzRGVudW0gdHlwZSwgY29uc3QgQXJyYXlCdWZm ZXJWaWV3RGVzY3JpcHRvciYgcGl4ZWxzLCBFeGNlcHRpb25Db2RlJiBlYykKK3sKICAgICBpZiAo aXNDb250ZXh0TG9zdCgpIHx8ICF2YWxpZGF0ZVRleEZ1bmNEYXRhKCJ0ZXhJbWFnZTJEIiwgbGV2 ZWwsIHdpZHRoLCBoZWlnaHQsIGZvcm1hdCwgdHlwZSwgcGl4ZWxzLCBOdWxsQWxsb3dlZCkpCiAg ICAgICAgIHJldHVybjsKLSAgICB2b2lkKiBkYXRhID0gcGl4ZWxzID8gcGl4ZWxzLT5iYXNlQWRk cmVzcygpIDogMDsKKyAgICBjb25zdCB2b2lkKiBkYXRhID0gcGl4ZWxzLmJhc2VBZGRyZXNzOwog ICAgIFZlY3Rvcjx1aW50OF90PiB0ZW1wRGF0YTsKICAgICBib29sIGNoYW5nZVVucGFja0FsaWdu bWVudCA9IGZhbHNlOwogICAgIGlmIChkYXRhICYmIChtX3VucGFja0ZsaXBZIHx8IG1fdW5wYWNr UHJlbXVsdGlwbHlBbHBoYSkpIHsKQEAgLTM5MTQsOSArMzkyNywxOCBAQCB2b2lkIFdlYkdMUmVu ZGVyaW5nQ29udGV4dDo6dGV4U3ViSW1hZ2UyRChHQzNEZW51bSB0YXJnZXQsIEdDM0RpbnQgbGV2 ZWwsIEdDM0RpbgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR0Mz RHNpemVpIHdpZHRoLCBHQzNEc2l6ZWkgaGVpZ2h0LAogICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgR0MzRGVudW0gZm9ybWF0LCBHQzNEZW51bSB0eXBlLCBBcnJheUJ1 ZmZlclZpZXcqIHBpeGVscywgRXhjZXB0aW9uQ29kZSYgZWMpCiB7CisgICAgQXJyYXlCdWZmZXJW aWV3RGVzY3JpcHRvciBkZXNjcmlwdG9yKHBpeGVscyk7CisgICAgdGV4U3ViSW1hZ2UyRCh0YXJn ZXQsIGxldmVsLCB4b2Zmc2V0LCB5b2Zmc2V0LCB3aWR0aCwgaGVpZ2h0LCBmb3JtYXQsIHR5cGUs IGRlc2NyaXB0b3IsIGVjKTsKK30KKwordm9pZCBXZWJHTFJlbmRlcmluZ0NvbnRleHQ6OnRleFN1 YkltYWdlMkQoCisgICAgR0MzRGVudW0gdGFyZ2V0LCBHQzNEaW50IGxldmVsLCBHQzNEaW50IHhv ZmZzZXQsIEdDM0RpbnQgeW9mZnNldCwKKyAgICBHQzNEc2l6ZWkgd2lkdGgsIEdDM0RzaXplaSBo ZWlnaHQsCisgICAgR0MzRGVudW0gZm9ybWF0LCBHQzNEZW51bSB0eXBlLCBjb25zdCBBcnJheUJ1 ZmZlclZpZXdEZXNjcmlwdG9yJiBwaXhlbHMsIEV4Y2VwdGlvbkNvZGUmIGVjKQorewogICAgIGlm IChpc0NvbnRleHRMb3N0KCkgfHwgIXZhbGlkYXRlVGV4RnVuY0RhdGEoInRleFN1YkltYWdlMkQi LCBsZXZlbCwgd2lkdGgsIGhlaWdodCwgZm9ybWF0LCB0eXBlLCBwaXhlbHMsIE51bGxOb3RBbGxv d2VkKSkKICAgICAgICAgcmV0dXJuOwotICAgIHZvaWQqIGRhdGEgPSBwaXhlbHMtPmJhc2VBZGRy ZXNzKCk7CisgICAgY29uc3Qgdm9pZCogZGF0YSA9IHBpeGVscy5iYXNlQWRkcmVzczsKICAgICBW ZWN0b3I8dWludDhfdD4gdGVtcERhdGE7CiAgICAgYm9vbCBjaGFuZ2VVbnBhY2tBbGlnbm1lbnQg PSBmYWxzZTsKICAgICBpZiAoZGF0YSAmJiAobV91bnBhY2tGbGlwWSB8fCBtX3VucGFja1ByZW11 bHRpcGx5QWxwaGEpKSB7CkBAIC01MDUxLDEwICs1MDczLDEwIEBAIGJvb2wgV2ViR0xSZW5kZXJp bmdDb250ZXh0Ojp2YWxpZGF0ZVRleEZ1bmNQYXJhbWV0ZXJzKGNvbnN0IGNoYXIqIGZ1bmN0aW9u TmFtZSwKIGJvb2wgV2ViR0xSZW5kZXJpbmdDb250ZXh0Ojp2YWxpZGF0ZVRleEZ1bmNEYXRhKGNv bnN0IGNoYXIqIGZ1bmN0aW9uTmFtZSwgR0MzRGludCBsZXZlbCwKICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEdDM0RzaXplaSB3aWR0aCwgR0MzRHNpemVp IGhlaWdodCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IEdDM0RlbnVtIGZvcm1hdCwgR0MzRGVudW0gdHlwZSwKLSAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIEFycmF5QnVmZmVyVmlldyogcGl4ZWxzLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgQXJyYXlCdWZm ZXJWaWV3RGVzY3JpcHRvciYgcGl4ZWxzLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgTnVsbERpc3Bvc2l0aW9uIGRpc3Bvc2l0aW9uKQogewotICAgIGlm ICghcGl4ZWxzKSB7CisgICAgaWYgKCFwaXhlbHMuYmFzZUFkZHJlc3MpIHsKICAgICAgICAgaWYg KGRpc3Bvc2l0aW9uID09IE51bGxBbGxvd2VkKQogICAgICAgICAgICAgcmV0dXJuIHRydWU7CiAg ICAgICAgIHN5bnRoZXNpemVHTEVycm9yKEdyYXBoaWNzQ29udGV4dDNEOjpJTlZBTElEX1ZBTFVF LCBmdW5jdGlvbk5hbWUsICJubyBwaXhlbHMiKTsKQEAgLTUwNjgsNyArNTA5MCw3IEBAIGJvb2wg V2ViR0xSZW5kZXJpbmdDb250ZXh0Ojp2YWxpZGF0ZVRleEZ1bmNEYXRhKGNvbnN0IGNoYXIqIGZ1 bmN0aW9uTmFtZSwgR0MzRGluCiAKICAgICBzd2l0Y2ggKHR5cGUpIHsKICAgICBjYXNlIEdyYXBo aWNzQ29udGV4dDNEOjpVTlNJR05FRF9CWVRFOgotICAgICAgICBpZiAocGl4ZWxzLT5nZXRUeXBl KCkgIT0gQXJyYXlCdWZmZXJWaWV3OjpUeXBlVWludDgpIHsKKyAgICAgICAgaWYgKHBpeGVscy52 aWV3VHlwZSAhPSBBcnJheUJ1ZmZlclZpZXc6OlR5cGVVaW50OCkgewogICAgICAgICAgICAgc3lu dGhlc2l6ZUdMRXJyb3IoR3JhcGhpY3NDb250ZXh0M0Q6OklOVkFMSURfT1BFUkFUSU9OLCBmdW5j dGlvbk5hbWUsICJ0eXBlIFVOU0lHTkVEX0JZVEUgYnV0IEFycmF5QnVmZmVyVmlldyBub3QgVWlu dDhBcnJheSIpOwogICAgICAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgICAgICB9CkBAIC01MDc2 LDEzICs1MDk4LDEzIEBAIGJvb2wgV2ViR0xSZW5kZXJpbmdDb250ZXh0Ojp2YWxpZGF0ZVRleEZ1 bmNEYXRhKGNvbnN0IGNoYXIqIGZ1bmN0aW9uTmFtZSwgR0MzRGluCiAgICAgY2FzZSBHcmFwaGlj c0NvbnRleHQzRDo6VU5TSUdORURfU0hPUlRfNV82XzU6CiAgICAgY2FzZSBHcmFwaGljc0NvbnRl eHQzRDo6VU5TSUdORURfU0hPUlRfNF80XzRfNDoKICAgICBjYXNlIEdyYXBoaWNzQ29udGV4dDNE OjpVTlNJR05FRF9TSE9SVF81XzVfNV8xOgotICAgICAgICBpZiAocGl4ZWxzLT5nZXRUeXBlKCkg IT0gQXJyYXlCdWZmZXJWaWV3OjpUeXBlVWludDE2KSB7CisgICAgICAgIGlmIChwaXhlbHMudmll d1R5cGUgIT0gQXJyYXlCdWZmZXJWaWV3OjpUeXBlVWludDE2KSB7CiAgICAgICAgICAgICBzeW50 aGVzaXplR0xFcnJvcihHcmFwaGljc0NvbnRleHQzRDo6SU5WQUxJRF9PUEVSQVRJT04sIGZ1bmN0 aW9uTmFtZSwgInR5cGUgVU5TSUdORURfU0hPUlQgYnV0IEFycmF5QnVmZmVyVmlldyBub3QgVWlu dDE2QXJyYXkiKTsKICAgICAgICAgICAgIHJldHVybiBmYWxzZTsKICAgICAgICAgfQogICAgICAg ICBicmVhazsKICAgICBjYXNlIEdyYXBoaWNzQ29udGV4dDNEOjpGTE9BVDogLy8gT0VTX3RleHR1 cmVfZmxvYXQKLSAgICAgICAgaWYgKHBpeGVscy0+Z2V0VHlwZSgpICE9IEFycmF5QnVmZmVyVmll dzo6VHlwZUZsb2F0MzIpIHsKKyAgICAgICAgaWYgKHBpeGVscy52aWV3VHlwZSAhPSBBcnJheUJ1 ZmZlclZpZXc6OlR5cGVGbG9hdDMyKSB7CiAgICAgICAgICAgICBzeW50aGVzaXplR0xFcnJvcihH cmFwaGljc0NvbnRleHQzRDo6SU5WQUxJRF9PUEVSQVRJT04sIGZ1bmN0aW9uTmFtZSwgInR5cGUg RkxPQVQgYnV0IEFycmF5QnVmZmVyVmlldyBub3QgRmxvYXQzMkFycmF5Iik7CiAgICAgICAgICAg ICByZXR1cm4gZmFsc2U7CiAgICAgICAgIH0KQEAgLTUwOTcsMTMgKzUxMTksMTMgQEAgYm9vbCBX ZWJHTFJlbmRlcmluZ0NvbnRleHQ6OnZhbGlkYXRlVGV4RnVuY0RhdGEoY29uc3QgY2hhciogZnVu Y3Rpb25OYW1lLCBHQzNEaW4KICAgICAgICAgc3ludGhlc2l6ZUdMRXJyb3IoZXJyb3IsIGZ1bmN0 aW9uTmFtZSwgImludmFsaWQgdGV4dHVyZSBkaW1lbnNpb25zIik7CiAgICAgICAgIHJldHVybiBm YWxzZTsKICAgICB9Ci0gICAgaWYgKHBpeGVscy0+Ynl0ZUxlbmd0aCgpIDwgdG90YWxCeXRlc1Jl cXVpcmVkKSB7CisgICAgaWYgKHBpeGVscy5ieXRlTGVuZ3RoIDwgdG90YWxCeXRlc1JlcXVpcmVk KSB7CiAgICAgICAgIGlmIChtX3VucGFja0FsaWdubWVudCAhPSAxKSB7Ci0gICAgICAgICAgZXJy b3IgPSBtX2NvbnRleHQtPmNvbXB1dGVJbWFnZVNpemVJbkJ5dGVzKGZvcm1hdCwgdHlwZSwgd2lk dGgsIGhlaWdodCwgMSwgJnRvdGFsQnl0ZXNSZXF1aXJlZCwgMCk7Ci0gICAgICAgICAgaWYgKHBp eGVscy0+Ynl0ZUxlbmd0aCgpID09IHRvdGFsQnl0ZXNSZXF1aXJlZCkgewotICAgICAgICAgICAg c3ludGhlc2l6ZUdMRXJyb3IoR3JhcGhpY3NDb250ZXh0M0Q6OklOVkFMSURfT1BFUkFUSU9OLCBm dW5jdGlvbk5hbWUsICJBcnJheUJ1ZmZlclZpZXcgbm90IGJpZyBlbm91Z2ggZm9yIHJlcXVlc3Qg d2l0aCBVTlBBQ0tfQUxJR05NRU5UID4gMSIpOwotICAgICAgICAgICAgcmV0dXJuIGZhbHNlOwot ICAgICAgICAgIH0KKyAgICAgICAgICAgIGVycm9yID0gbV9jb250ZXh0LT5jb21wdXRlSW1hZ2VT aXplSW5CeXRlcyhmb3JtYXQsIHR5cGUsIHdpZHRoLCBoZWlnaHQsIDEsICZ0b3RhbEJ5dGVzUmVx dWlyZWQsIDApOworICAgICAgICAgICAgaWYgKHBpeGVscy5ieXRlTGVuZ3RoID09IHRvdGFsQnl0 ZXNSZXF1aXJlZCkgeworICAgICAgICAgICAgICAgIHN5bnRoZXNpemVHTEVycm9yKEdyYXBoaWNz Q29udGV4dDNEOjpJTlZBTElEX09QRVJBVElPTiwgZnVuY3Rpb25OYW1lLCAiQXJyYXlCdWZmZXJW aWV3IG5vdCBiaWcgZW5vdWdoIGZvciByZXF1ZXN0IHdpdGggVU5QQUNLX0FMSUdOTUVOVCA+IDEi KTsKKyAgICAgICAgICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgICAgICAgICB9CiAgICAgICAg IH0KICAgICAgICAgc3ludGhlc2l6ZUdMRXJyb3IoR3JhcGhpY3NDb250ZXh0M0Q6OklOVkFMSURf T1BFUkFUSU9OLCBmdW5jdGlvbk5hbWUsICJBcnJheUJ1ZmZlclZpZXcgbm90IGJpZyBlbm91Z2gg Zm9yIHJlcXVlc3QiKTsKICAgICAgICAgcmV0dXJuIGZhbHNlOwpAQCAtNTExNiwxMSArNTEzOCwx MiBAQCBib29sIFdlYkdMUmVuZGVyaW5nQ29udGV4dDo6dmFsaWRhdGVDb21wcmVzc2VkVGV4Rm9y bWF0KEdDM0RlbnVtIGZvcm1hdCkKICAgICByZXR1cm4gbV9jb21wcmVzc2VkVGV4dHVyZUZvcm1h dHMuY29udGFpbnMoZm9ybWF0KTsKIH0KIAotYm9vbCBXZWJHTFJlbmRlcmluZ0NvbnRleHQ6OnZh bGlkYXRlQ29tcHJlc3NlZFRleEZ1bmNEYXRhKGNvbnN0IGNoYXIqIGZ1bmN0aW9uTmFtZSwKLSAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBH QzNEc2l6ZWkgd2lkdGgsIEdDM0RzaXplaSBoZWlnaHQsCi0gICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR0MzRGVudW0gZm9ybWF0LCBBcnJh eUJ1ZmZlclZpZXcqIHBpeGVscykKK2Jvb2wgV2ViR0xSZW5kZXJpbmdDb250ZXh0Ojp2YWxpZGF0 ZUNvbXByZXNzZWRUZXhGdW5jRGF0YSgKKyAgICBjb25zdCBjaGFyKiBmdW5jdGlvbk5hbWUsCisg ICAgR0MzRHNpemVpIHdpZHRoLCBHQzNEc2l6ZWkgaGVpZ2h0LAorICAgIEdDM0RlbnVtIGZvcm1h dCwgY29uc3QgQXJyYXlCdWZmZXJWaWV3RGVzY3JpcHRvciYgZGF0YSkKIHsKLSAgICBpZiAoIXBp eGVscykgeworICAgIGlmICghZGF0YS5iYXNlQWRkcmVzcykgewogICAgICAgICBzeW50aGVzaXpl R0xFcnJvcihHcmFwaGljc0NvbnRleHQzRDo6SU5WQUxJRF9WQUxVRSwgZnVuY3Rpb25OYW1lLCAi bm8gcGl4ZWxzIik7CiAgICAgICAgIHJldHVybiBmYWxzZTsKICAgICB9CkBAIC01MTYxLDcgKzUx ODQsNyBAQCBib29sIFdlYkdMUmVuZGVyaW5nQ29udGV4dDo6dmFsaWRhdGVDb21wcmVzc2VkVGV4 RnVuY0RhdGEoY29uc3QgY2hhciogZnVuY3Rpb25OYQogICAgICAgICByZXR1cm4gZmFsc2U7CiAg ICAgfQogCi0gICAgaWYgKHBpeGVscy0+Ynl0ZUxlbmd0aCgpICE9IGJ5dGVzUmVxdWlyZWQpIHsK KyAgICBpZiAoZGF0YS5ieXRlTGVuZ3RoICE9IGJ5dGVzUmVxdWlyZWQpIHsKICAgICAgICAgc3lu dGhlc2l6ZUdMRXJyb3IoR3JhcGhpY3NDb250ZXh0M0Q6OklOVkFMSURfVkFMVUUsIGZ1bmN0aW9u TmFtZSwgImxlbmd0aCBvZiBBcnJheUJ1ZmZlclZpZXcgaXMgbm90IGNvcnJlY3QgZm9yIGRpbWVu c2lvbnMiKTsKICAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgIH0KZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL2h0bWwvY2FudmFzL1dlYkdMUmVuZGVyaW5nQ29udGV4dC5oIGIvU291cmNlL1dl YkNvcmUvaHRtbC9jYW52YXMvV2ViR0xSZW5kZXJpbmdDb250ZXh0LmgKaW5kZXggNWIwZmI5MTJm ODIyYmEyOGNjMTVjYTRiMWQzZmQwNzU5N2NjOWVjNy4uMzU1NGVjZTYwZWMwZDRiYTI1Y2MzZmM5 Mzg1ZTI0MGEwM2UyMjMyMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9jYW52YXMv V2ViR0xSZW5kZXJpbmdDb250ZXh0LmgKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9jYW52YXMv V2ViR0xSZW5kZXJpbmdDb250ZXh0LmgKQEAgLTM0LDYgKzM0LDggQEAKICNpbmNsdWRlICJUaW1l ci5oIgogI2luY2x1ZGUgIldlYkdMR2V0SW5mby5oIgogCisjaW5jbHVkZSA8d3RmL0FycmF5QnVm ZmVyRGVzY3JpcHRvci5oPgorI2luY2x1ZGUgPHd0Zi9BcnJheUJ1ZmZlclZpZXdEZXNjcmlwdG9y Lmg+CiAjaW5jbHVkZSA8d3RmL0Zsb2F0MzJBcnJheS5oPgogI2luY2x1ZGUgPHd0Zi9JbnQzMkFy cmF5Lmg+CiAjaW5jbHVkZSA8d3RmL093bkFycmF5UHRyLmg+CkBAIC0xMDMsOCArMTA1LDEwIEBA IHB1YmxpYzoKICAgICB2b2lkIGJ1ZmZlckRhdGEoR0MzRGVudW0gdGFyZ2V0LCBsb25nIGxvbmcg c2l6ZSwgR0MzRGVudW0gdXNhZ2UsIEV4Y2VwdGlvbkNvZGUmKTsKICAgICB2b2lkIGJ1ZmZlckRh dGEoR0MzRGVudW0gdGFyZ2V0LCBBcnJheUJ1ZmZlciogZGF0YSwgR0MzRGVudW0gdXNhZ2UsIEV4 Y2VwdGlvbkNvZGUmKTsKICAgICB2b2lkIGJ1ZmZlckRhdGEoR0MzRGVudW0gdGFyZ2V0LCBBcnJh eUJ1ZmZlclZpZXcqIGRhdGEsIEdDM0RlbnVtIHVzYWdlLCBFeGNlcHRpb25Db2RlJik7CisgICAg dm9pZCBidWZmZXJEYXRhKEdDM0RlbnVtIHRhcmdldCwgY29uc3QgQXJyYXlCdWZmZXJEZXNjcmlw dG9yJiBkYXRhLCBHQzNEZW51bSB1c2FnZSwgRXhjZXB0aW9uQ29kZSYpOwogICAgIHZvaWQgYnVm ZmVyU3ViRGF0YShHQzNEZW51bSB0YXJnZXQsIGxvbmcgbG9uZyBvZmZzZXQsIEFycmF5QnVmZmVy KiBkYXRhLCBFeGNlcHRpb25Db2RlJik7CiAgICAgdm9pZCBidWZmZXJTdWJEYXRhKEdDM0RlbnVt IHRhcmdldCwgbG9uZyBsb25nIG9mZnNldCwgQXJyYXlCdWZmZXJWaWV3KiBkYXRhLCBFeGNlcHRp b25Db2RlJik7CisgICAgdm9pZCBidWZmZXJTdWJEYXRhKEdDM0RlbnVtIHRhcmdldCwgbG9uZyBs b25nIG9mZnNldCwgY29uc3QgQXJyYXlCdWZmZXJEZXNjcmlwdG9yJiBkYXRhLCBFeGNlcHRpb25D b2RlJik7CiAKICAgICBHQzNEZW51bSBjaGVja0ZyYW1lYnVmZmVyU3RhdHVzKEdDM0RlbnVtIHRh cmdldCk7CiAgICAgdm9pZCBjbGVhcihHQzNEYml0ZmllbGQgbWFzayk7CkBAIC0xMTYsOCArMTIw LDE0IEBAIHB1YmxpYzoKIAogICAgIHZvaWQgY29tcHJlc3NlZFRleEltYWdlMkQoR0MzRGVudW0g dGFyZ2V0LCBHQzNEaW50IGxldmVsLCBHQzNEZW51bSBpbnRlcm5hbGZvcm1hdCwgR0MzRHNpemVp IHdpZHRoLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR0MzRHNpemVpIGhlaWdodCwg R0MzRGludCBib3JkZXIsIEFycmF5QnVmZmVyVmlldyogZGF0YSk7CisgICAgdm9pZCBjb21wcmVz c2VkVGV4SW1hZ2UyRCgKKyAgICAgICAgR0MzRGVudW0gdGFyZ2V0LCBHQzNEaW50IGxldmVsLCBH QzNEZW51bSBpbnRlcm5hbGZvcm1hdCwgR0MzRHNpemVpIHdpZHRoLAorICAgICAgICBHQzNEc2l6 ZWkgaGVpZ2h0LCBHQzNEaW50IGJvcmRlciwgY29uc3QgQXJyYXlCdWZmZXJWaWV3RGVzY3JpcHRv ciYgZGF0YSk7CiAgICAgdm9pZCBjb21wcmVzc2VkVGV4U3ViSW1hZ2UyRChHQzNEZW51bSB0YXJn ZXQsIEdDM0RpbnQgbGV2ZWwsIEdDM0RpbnQgeG9mZnNldCwgR0MzRGludCB5b2Zmc2V0LAogICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR0MzRHNpemVpIHdpZHRoLCBHQzNEc2l6ZWkg aGVpZ2h0LCBHQzNEZW51bSBmb3JtYXQsIEFycmF5QnVmZmVyVmlldyogZGF0YSk7CisgICAgdm9p ZCBjb21wcmVzc2VkVGV4U3ViSW1hZ2UyRCgKKyAgICAgICAgR0MzRGVudW0gdGFyZ2V0LCBHQzNE aW50IGxldmVsLCBHQzNEaW50IHhvZmZzZXQsIEdDM0RpbnQgeW9mZnNldCwKKyAgICAgICAgR0Mz RHNpemVpIHdpZHRoLCBHQzNEc2l6ZWkgaGVpZ2h0LCBHQzNEZW51bSBmb3JtYXQsIGNvbnN0IEFy cmF5QnVmZmVyVmlld0Rlc2NyaXB0b3ImIGRhdGEpOwogCiAgICAgdm9pZCBjb3B5VGV4SW1hZ2Uy RChHQzNEZW51bSB0YXJnZXQsIEdDM0RpbnQgbGV2ZWwsIEdDM0RlbnVtIGludGVybmFsZm9ybWF0 LCBHQzNEaW50IHgsIEdDM0RpbnQgeSwgR0MzRHNpemVpIHdpZHRoLCBHQzNEc2l6ZWkgaGVpZ2h0 LCBHQzNEaW50IGJvcmRlcik7CiAgICAgdm9pZCBjb3B5VGV4U3ViSW1hZ2UyRChHQzNEZW51bSB0 YXJnZXQsIEdDM0RpbnQgbGV2ZWwsIEdDM0RpbnQgeG9mZnNldCwgR0MzRGludCB5b2Zmc2V0LCBH QzNEaW50IHgsIEdDM0RpbnQgeSwgR0MzRHNpemVpIHdpZHRoLCBHQzNEc2l6ZWkgaGVpZ2h0KTsK QEAgLTE5NSw2ICsyMDUsNyBAQCBwdWJsaWM6CiAgICAgdm9pZCBwaXhlbFN0b3JlaShHQzNEZW51 bSBwbmFtZSwgR0MzRGludCBwYXJhbSk7CiAgICAgdm9pZCBwb2x5Z29uT2Zmc2V0KEdDM0RmbG9h dCBmYWN0b3IsIEdDM0RmbG9hdCB1bml0cyk7CiAgICAgdm9pZCByZWFkUGl4ZWxzKEdDM0RpbnQg eCwgR0MzRGludCB5LCBHQzNEc2l6ZWkgd2lkdGgsIEdDM0RzaXplaSBoZWlnaHQsIEdDM0RlbnVt IGZvcm1hdCwgR0MzRGVudW0gdHlwZSwgQXJyYXlCdWZmZXJWaWV3KiBwaXhlbHMsIEV4Y2VwdGlv bkNvZGUmKTsKKyAgICB2b2lkIHJlYWRQaXhlbHMoR0MzRGludCB4LCBHQzNEaW50IHksIEdDM0Rz aXplaSB3aWR0aCwgR0MzRHNpemVpIGhlaWdodCwgR0MzRGVudW0gZm9ybWF0LCBHQzNEZW51bSB0 eXBlLCBjb25zdCBBcnJheUJ1ZmZlclZpZXdEZXNjcmlwdG9yJiBwaXhlbHMsIEV4Y2VwdGlvbkNv ZGUmKTsKICAgICB2b2lkIHJlbGVhc2VTaGFkZXJDb21waWxlcigpOwogICAgIHZvaWQgcmVuZGVy YnVmZmVyU3RvcmFnZShHQzNEZW51bSB0YXJnZXQsIEdDM0RlbnVtIGludGVybmFsZm9ybWF0LCBH QzNEc2l6ZWkgd2lkdGgsIEdDM0RzaXplaSBoZWlnaHQpOwogICAgIHZvaWQgc2FtcGxlQ292ZXJh Z2UoR0MzRGZsb2F0IHZhbHVlLCBHQzNEYm9vbGVhbiBpbnZlcnQpOwpAQCAtMjEwLDYgKzIyMSwx MCBAQCBwdWJsaWM6CiAgICAgdm9pZCB0ZXhJbWFnZTJEKEdDM0RlbnVtIHRhcmdldCwgR0MzRGlu dCBsZXZlbCwgR0MzRGVudW0gaW50ZXJuYWxmb3JtYXQsCiAgICAgICAgICAgICAgICAgICAgIEdD M0RzaXplaSB3aWR0aCwgR0MzRHNpemVpIGhlaWdodCwgR0MzRGludCBib3JkZXIsCiAgICAgICAg ICAgICAgICAgICAgIEdDM0RlbnVtIGZvcm1hdCwgR0MzRGVudW0gdHlwZSwgQXJyYXlCdWZmZXJW aWV3KiwgRXhjZXB0aW9uQ29kZSYpOworICAgIHZvaWQgdGV4SW1hZ2UyRCgKKyAgICAgICAgR0Mz RGVudW0gdGFyZ2V0LCBHQzNEaW50IGxldmVsLCBHQzNEZW51bSBpbnRlcm5hbGZvcm1hdCwKKyAg ICAgICAgR0MzRHNpemVpIHdpZHRoLCBHQzNEc2l6ZWkgaGVpZ2h0LCBHQzNEaW50IGJvcmRlciwK KyAgICAgICAgR0MzRGVudW0gZm9ybWF0LCBHQzNEZW51bSB0eXBlLCBjb25zdCBBcnJheUJ1ZmZl clZpZXdEZXNjcmlwdG9yJiBkYXRhLCBFeGNlcHRpb25Db2RlJik7CiAgICAgdm9pZCB0ZXhJbWFn ZTJEKEdDM0RlbnVtIHRhcmdldCwgR0MzRGludCBsZXZlbCwgR0MzRGVudW0gaW50ZXJuYWxmb3Jt YXQsCiAgICAgICAgICAgICAgICAgICAgIEdDM0RlbnVtIGZvcm1hdCwgR0MzRGVudW0gdHlwZSwg SW1hZ2VEYXRhKiwgRXhjZXB0aW9uQ29kZSYpOwogICAgIHZvaWQgdGV4SW1hZ2UyRChHQzNEZW51 bSB0YXJnZXQsIEdDM0RpbnQgbGV2ZWwsIEdDM0RlbnVtIGludGVybmFsZm9ybWF0LApAQCAtMjI3 LDYgKzI0MiwxMCBAQCBwdWJsaWM6CiAgICAgdm9pZCB0ZXhTdWJJbWFnZTJEKEdDM0RlbnVtIHRh cmdldCwgR0MzRGludCBsZXZlbCwgR0MzRGludCB4b2Zmc2V0LCBHQzNEaW50IHlvZmZzZXQsCiAg ICAgICAgICAgICAgICAgICAgICAgIEdDM0RzaXplaSB3aWR0aCwgR0MzRHNpemVpIGhlaWdodCwK ICAgICAgICAgICAgICAgICAgICAgICAgR0MzRGVudW0gZm9ybWF0LCBHQzNEZW51bSB0eXBlLCBB cnJheUJ1ZmZlclZpZXcqLCBFeGNlcHRpb25Db2RlJik7CisgICAgdm9pZCB0ZXhTdWJJbWFnZTJE KAorICAgICAgICBHQzNEZW51bSB0YXJnZXQsIEdDM0RpbnQgbGV2ZWwsIEdDM0RpbnQgeG9mZnNl dCwgR0MzRGludCB5b2Zmc2V0LAorICAgICAgICBHQzNEc2l6ZWkgd2lkdGgsIEdDM0RzaXplaSBo ZWlnaHQsCisgICAgICAgIEdDM0RlbnVtIGZvcm1hdCwgR0MzRGVudW0gdHlwZSwgY29uc3QgQXJy YXlCdWZmZXJWaWV3RGVzY3JpcHRvciYgY29udGVudHMsIEV4Y2VwdGlvbkNvZGUmKTsKICAgICB2 b2lkIHRleFN1YkltYWdlMkQoR0MzRGVudW0gdGFyZ2V0LCBHQzNEaW50IGxldmVsLCBHQzNEaW50 IHhvZmZzZXQsIEdDM0RpbnQgeW9mZnNldCwKICAgICAgICAgICAgICAgICAgICAgICAgR0MzRGVu dW0gZm9ybWF0LCBHQzNEZW51bSB0eXBlLCBJbWFnZURhdGEqLCBFeGNlcHRpb25Db2RlJik7CiAg ICAgdm9pZCB0ZXhTdWJJbWFnZTJEKEdDM0RlbnVtIHRhcmdldCwgR0MzRGludCBsZXZlbCwgR0Mz RGludCB4b2Zmc2V0LCBHQzNEaW50IHlvZmZzZXQsCkBAIC02MDcsMTEgKzYyNiwxMiBAQCBwdWJs aWM6CiAgICAgLy8gSGVscGVyIGZ1bmN0aW9uIHRvIHZhbGlkYXRlIHRoYXQgdGhlIGdpdmVuIEFy cmF5QnVmZmVyVmlldwogICAgIC8vIGlzIG9mIHRoZSBjb3JyZWN0IHR5cGUgYW5kIGNvbnRhaW5z IGVub3VnaCBkYXRhIGZvciB0aGUgdGV4SW1hZ2UgY2FsbC4KICAgICAvLyBHZW5lcmF0ZXMgR0wg ZXJyb3IgYW5kIHJldHVybnMgZmFsc2UgaWYgcGFyYW1ldGVycyBhcmUgaW52YWxpZC4KLSAgICBi b29sIHZhbGlkYXRlVGV4RnVuY0RhdGEoY29uc3QgY2hhciogZnVuY3Rpb25OYW1lLCBHQzNEaW50 IGxldmVsLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICBHQzNEc2l6ZWkgd2lkdGgsIEdD M0RzaXplaSBoZWlnaHQsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgIEdDM0RlbnVtIGZv cm1hdCwgR0MzRGVudW0gdHlwZSwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQXJyYXlC dWZmZXJWaWV3KiBwaXhlbHMsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgIE51bGxEaXNw b3NpdGlvbik7CisgICAgYm9vbCB2YWxpZGF0ZVRleEZ1bmNEYXRhKAorICAgICAgICBjb25zdCBj aGFyKiBmdW5jdGlvbk5hbWUsIEdDM0RpbnQgbGV2ZWwsCisgICAgICAgIEdDM0RzaXplaSB3aWR0 aCwgR0MzRHNpemVpIGhlaWdodCwKKyAgICAgICAgR0MzRGVudW0gZm9ybWF0LCBHQzNEZW51bSB0 eXBlLAorICAgICAgICBjb25zdCBBcnJheUJ1ZmZlclZpZXdEZXNjcmlwdG9yJiBwaXhlbHMsCisg ICAgICAgIE51bGxEaXNwb3NpdGlvbik7CiAKICAgICAvLyBIZWxwZXIgZnVuY3Rpb24gdG8gdmFs aWRhdGUgYSBnaXZlbiB0ZXh0dXJlIGZvcm1hdCBpcyBzZXR0YWJsZSBhcyBpbgogICAgIC8vIHlv dSBjYW4gc3VwcGx5IGRhdGEgdG8gdGV4SW1hZ2UyRCwgb3IgY2FsbCB0ZXhJbWFnZTJELCBjb3B5 VGV4SW1hZ2UyRCBhbmQKQEAgLTYyMSw5ICs2NDEsMTAgQEAgcHVibGljOgogCiAgICAgLy8gSGVs cGVyIGZ1bmN0aW9uIHRvIHZhbGlkYXRlIGNvbXByZXNzZWQgdGV4dHVyZSBkYXRhIGlzIGNvcnJl Y3Qgc2l6ZQogICAgIC8vIGZvciB0aGUgZ2l2ZW4gZm9ybWF0IGFuZCBkaW1lbnNpb25zLgotICAg IGJvb2wgdmFsaWRhdGVDb21wcmVzc2VkVGV4RnVuY0RhdGEoY29uc3QgY2hhciogZnVuY3Rpb25O YW1lLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR0MzRHNpemVpIHdp ZHRoLCBHQzNEc2l6ZWkgaGVpZ2h0LAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgR0MzRGVudW0gZm9ybWF0LCBBcnJheUJ1ZmZlclZpZXcqIHBpeGVscyk7CisgICAgYm9v bCB2YWxpZGF0ZUNvbXByZXNzZWRUZXhGdW5jRGF0YSgKKyAgICAgICAgY29uc3QgY2hhciogZnVu Y3Rpb25OYW1lLAorICAgICAgICBHQzNEc2l6ZWkgd2lkdGgsIEdDM0RzaXplaSBoZWlnaHQsCisg ICAgICAgIEdDM0RlbnVtIGZvcm1hdCwgY29uc3QgQXJyYXlCdWZmZXJWaWV3RGVzY3JpcHRvciYg ZGF0YSk7CiAKICAgICAvLyBIZWxwZXIgZnVuY3Rpb24gZm9yIHZhbGlkYXRpbmcgY29tcHJlc3Nl ZCB0ZXh0dXJlIGZvcm1hdHMuCiAgICAgYm9vbCB2YWxpZGF0ZUNvbXByZXNzZWRUZXhGb3JtYXQo R0MzRGVudW0gZm9ybWF0KTsK 184058 2013-01-22 15:19:43 -0800 2013-04-03 14:18:01 -0700 Patch bug-107185-20130122151637.patch text/plain 47384 kbr U3VidmVyc2lvbiBSZXZpc2lvbjogMTQwNDcwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGE0NjgzNzJiNDg1MGJlNDExYWIyYjFj OTdhZWU0YWY3OGJhOTJjNGIuLjJmMGViNWRkMTU5MzA5NDEzZGNhNTk3NDY3ODg5Yzg1MDNhMzhl OTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTMgQEAKKzIwMTMtMDEtMjIgIEtlbm5ldGggUnVzc2VsbCAgPGti ckBnb29nbGUuY29tPgorCisgICAgICAgIFByZXBhcmUgV2ViR0wgbWV0aG9kcyBhbmQgYmluZGlu ZyBnZW5lcmF0b3JzIGZvciBWTS1hbGxvY2F0ZWQgdHlwZWQgYXJyYXlzCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDcxODUKKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIHd0Zi9BcnJheUJ1ZmZlclZpZXcu aDoKKyAgICAgICAgICAgIEFkZCBuZXcgZW51bSB2YWx1ZSB1c2VkIHRvIGluZGljYXRlIG51bGwg aW5zdGFuY2UgaW4gYmluZGluZ3MuCisKIDIwMTMtMDEtMjIgIFJvZ2VyIEZvbmcgIDxyb2dlcl9m b25nQGFwcGxlLmNvbT4KIAogICAgICAgICBXVEYgcHJvamVjdCBmaWxlcyBhbmQgcHJvcGVydHkg c2hlZXRzIGZvciBnZXR0aW5nIFdlYktpdCB0byBjb21waWxlIGluIFZTMjAxMC4KZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpp bmRleCBkZmE0NmZiM2RhYTVkZjJlMGI1YTllZmM2YjE5NDE1ZTAwNTZkMDVhLi44YTZkZjc3Zjhl YzNlYTYzODY4MzhmMzJhYzU1MzY2MzNjOTkyZjgzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNjIg QEAKKzIwMTMtMDEtMjIgIEtlbm5ldGggUnVzc2VsbCAgPGtickBnb29nbGUuY29tPgorCisgICAg ICAgIFByZXBhcmUgV2ViR0wgbWV0aG9kcyBhbmQgYmluZGluZyBnZW5lcmF0b3JzIGZvciBWTS1h bGxvY2F0ZWQgdHlwZWQgYXJyYXlzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0xMDcxODUKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBDaGFuZ2UgaG93IHR5cGVkIGFycmF5cyBhcmUgcGFzc2VkIHRvIFdlYkdM IG1ldGhvZHMgZnJvbSB0aGUKKyAgICAgICAgSmF2YVNjcmlwdCBiaW5kaW5nczsgaW5zdGVhZCBv ZiBwYXNzaW5nIEFycmF5QnVmZmVyIGFuZAorICAgICAgICBBcnJheUJ1ZmZlclZpZXcgaW5zdGFu Y2VzLCBwYXNzIHRoZSBzdG9yYWdlIHRoZXkgY29udGFpbi4gVGhpcyBpcworICAgICAgICBwcmVw YXJhdG9yeSB3b3JrIGZvciBhbGxvY2F0aW5nIHR5cGVkIGFycmF5cyBlbnRpcmVseSBpbiB0aGUK KyAgICAgICAgSmF2YVNjcmlwdCBWTSwgd2l0aG91dCBjYWxsaW5nIG91dCB0byBXVEYuCisKKyAg ICAgICAgVGhpcyBwYXRjaCBkb2VzIG5vdCBhY3R1YWxseSBpbXBsZW1lbnQgdGhlIFZNLXNpZGUg YWxsb2NhdGlvbiBvZgorICAgICAgICB0eXBlZCBhcnJheXMuIEl0IHByZXBhcmVzIFdlYkdMIGFu ZCB0aGUgY29kZSBnZW5lcmF0b3JzIGZvciB0aGF0CisgICAgICAgIHdvcmssIHdoaWNoIGNhbiBu b3cgYmUgZG9uZSBpbiBwYXJhbGxlbC4KKworICAgICAgICBObyBuZXcgdGVzdHM7IG5vIGNoYW5n ZSBpbiBmdW5jdGlvbmFsaXR5LiBSYW4gV2ViR0wgY29uZm9ybWFuY2UKKyAgICAgICAgdGVzdHMg YW5kIGxheW91dCB0ZXN0cyBpbiBib3RoIFNhZmFyaSBhbmQgQ2hyb21lLgorCisgICAgICAgICog YmluZGluZ3Mvc2NyaXB0cy9Db2RlR2VuZXJhdG9yLnBtOgorICAgICAgICAoSXNBcnJheUJ1ZmZl clR5cGUpOgorICAgICAgICAoRXh0cmFjdFR5cGVkQXJyYXlDb21wb25lbnRzRnJvbVBhcmFtZXRl cik6CisgICAgICAgIChBZGRUeXBlZEFycmF5Q29tcG9uZW50QXJndW1lbnRzRm9yUGFyYW1ldGVy KToKKyAgICAgICAgICAgIEdlbmVyYXRlIGNvZGUgZm9yIHVucGFja2luZyB0eXBlZCBhcnJheXMg aW4gdGhlIGJpbmRpbmdzLgorICAgICAgICAqIGJpbmRpbmdzL3NjcmlwdHMvQ29kZUdlbmVyYXRv ckpTLnBtOgorICAgICAgICAoR2VuZXJhdGVQYXJhbWV0ZXJzQ2hlY2spOgorICAgICAgICAgICAg VW5wYWNrIHR5cGVkIGFycmF5cyBpbiB0aGUgYmluZGluZ3MgZm9yIG1ldGhvZHMgbWFya2VkIERv ZXNOb3RSZXRhaW5UeXBlZEFycmF5cy4KKyAgICAgICAgKiBiaW5kaW5ncy9zY3JpcHRzL0NvZGVH ZW5lcmF0b3JWOC5wbToKKyAgICAgICAgKEdlbmVyYXRlUGFyYW1ldGVyc0NoZWNrKToKKyAgICAg ICAgKEdlbmVyYXRlRnVuY3Rpb25DYWxsU3RyaW5nKToKKyAgICAgICAgICAgIFVucGFjayB0eXBl ZCBhcnJheXMgaW4gdGhlIGJpbmRpbmdzIGZvciBtZXRob2RzIG1hcmtlZCBEb2VzTm90UmV0YWlu VHlwZWRBcnJheXMuCisgICAgICAgICogYmluZGluZ3Mvc2NyaXB0cy9JRExBdHRyaWJ1dGVzLnR4 dDoKKyAgICAgICAgICAgIEFkZGVkIG5ldyBwcm9wb3NlZCBEb2VzTm90UmV0YWluVHlwZWRBcnJh eXMgYXR0cmlidXRlLgorICAgICAgICAqIGh0bWwvY2FudmFzL1dlYkdMQnVmZmVyLmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OldlYkdMQnVmZmVyOjphc3NvY2lhdGVCdWZmZXJEYXRhKToKKyAgICAg ICAgKFdlYkNvcmU6OldlYkdMQnVmZmVyOjphc3NvY2lhdGVCdWZmZXJTdWJEYXRhKToKKyAgICAg ICAgICAgIFJlbW92ZWQgZW50cnkgcG9pbnRzIHRha2luZyBBcnJheUJ1ZmZlciBhbmQgQXJyYXlC dWZmZXJWaWV3LiBFeHBvc2VkIHZlcnNpb25zIHRha2luZyBwb2ludGVyIGFuZCBzaXplLgorICAg ICAgICAqIGh0bWwvY2FudmFzL1dlYkdMQnVmZmVyLmg6CisgICAgICAgIChXZWJHTEJ1ZmZlcik6 CisgICAgICAgICAgICBSZW1vdmVkIGVudHJ5IHBvaW50cyB0YWtpbmcgQXJyYXlCdWZmZXIgYW5k IEFycmF5QnVmZmVyVmlldy4gRXhwb3NlZCB2ZXJzaW9ucyB0YWtpbmcgcG9pbnRlciBhbmQgc2l6 ZS4KKyAgICAgICAgKiBodG1sL2NhbnZhcy9XZWJHTFJlbmRlcmluZ0NvbnRleHQuY3BwOgorICAg ICAgICAoV2ViQ29yZSk6CisgICAgICAgIChXZWJDb3JlOjpXZWJHTFJlbmRlcmluZ0NvbnRleHQ6 OmJ1ZmZlckRhdGEpOgorICAgICAgICAoV2ViQ29yZTo6V2ViR0xSZW5kZXJpbmdDb250ZXh0Ojpi dWZmZXJTdWJEYXRhKToKKyAgICAgICAgKFdlYkNvcmU6OldlYkdMUmVuZGVyaW5nQ29udGV4dDo6 Y29tcHJlc3NlZFRleEltYWdlMkQpOgorICAgICAgICAoV2ViQ29yZTo6V2ViR0xSZW5kZXJpbmdD b250ZXh0Ojpjb21wcmVzc2VkVGV4U3ViSW1hZ2UyRCk6CisgICAgICAgIChXZWJDb3JlOjpXZWJH TFJlbmRlcmluZ0NvbnRleHQ6OnJlYWRQaXhlbHMpOgorICAgICAgICAoV2ViQ29yZTo6V2ViR0xS ZW5kZXJpbmdDb250ZXh0Ojp0ZXhJbWFnZTJEKToKKyAgICAgICAgKFdlYkNvcmU6OldlYkdMUmVu ZGVyaW5nQ29udGV4dDo6dGV4U3ViSW1hZ2UyRCk6CisgICAgICAgIChXZWJDb3JlOjpXZWJHTFJl bmRlcmluZ0NvbnRleHQ6OnZhbGlkYXRlVGV4RnVuY0RhdGEpOgorICAgICAgICAoV2ViQ29yZTo6 V2ViR0xSZW5kZXJpbmdDb250ZXh0Ojp2YWxpZGF0ZUNvbXByZXNzZWRUZXhGdW5jRGF0YSk6Cisg ICAgICAgICAgICBDaGFuZ2UgZnJvbSB0YWtpbmcgQXJyYXlCdWZmZXIgYW5kIEFycmF5QnVmZmVy VmlldyBpbnN0YW5jZXMgdG8gcG9pbnRlcnMgdG8gdGhlaXIgY29udGFpbmVkIG1lbW9yeS4KKyAg ICAgICAgKiBodG1sL2NhbnZhcy9XZWJHTFJlbmRlcmluZ0NvbnRleHQuaDoKKyAgICAgICAgKFdl YkdMUmVuZGVyaW5nQ29udGV4dCk6CisgICAgICAgICAgICBDaGFuZ2UgZnJvbSB0YWtpbmcgQXJy YXlCdWZmZXIgYW5kIEFycmF5QnVmZmVyVmlldyBpbnN0YW5jZXMgdG8gcG9pbnRlcnMgdG8gdGhl aXIgY29udGFpbmVkIG1lbW9yeS4KKyAgICAgICAgKiBodG1sL2NhbnZhcy9XZWJHTFJlbmRlcmlu Z0NvbnRleHQuaWRsOgorICAgICAgICAgICAgTWFyayBXZWJHTCBtZXRob2RzIHRha2luZyB0eXBl ZCBhcnJheXMgd2l0aCBuZXcgRG9lc05vdFJldGFpblR5cGVkQXJyYXlzIGF0dHJpYnV0ZSB0byBp bmRpY2F0ZSB0aGF0IHRoZXkgb25seSByZWZlcmVuY2UgdGhlIG1lbW9yeSBkdXJpbmcgdGhlIG1l dGhvZCBjYWxsLgorCiAyMDEzLTAxLTIyICBBbnRob255IFNjaWFuICA8YXNjaWFuQHJpbS5jb20+ CiAKICAgICAgICAgW0JsYWNrYmVycnldIFN0YXRpYyBjb2RlIGFuYWx5c2lzIHdhcm5pbmcgZml4 ZXMKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL0FycmF5QnVmZmVyVmlldy5oIGIvU291cmNl L1dURi93dGYvQXJyYXlCdWZmZXJWaWV3LmgKaW5kZXggNDUxYzFiNmVkOTljMWFmYjY1OTc2MWE3 NTU4ZjExM2E0Njg0NTc4ZC4uMWJhYjY5YTNlNzljMDQ0OGFlODRiNmUzMWMwMGNhZDVkODBmYjM1 MCAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93dGYvQXJyYXlCdWZmZXJWaWV3LmgKKysrIGIvU291 cmNlL1dURi93dGYvQXJyYXlCdWZmZXJWaWV3LmgKQEAgLTQ4LDcgKzQ4LDkgQEAgY2xhc3MgV1RG X0VYUE9SVF9QUklWQVRFX1JUVEkgQXJyYXlCdWZmZXJWaWV3IDogcHVibGljIFJlZkNvdW50ZWQ8 QXJyYXlCdWZmZXJWaWUKICAgICAgICAgVHlwZVVpbnQzMiwKICAgICAgICAgVHlwZUZsb2F0MzIs CiAgICAgICAgIFR5cGVGbG9hdDY0LAotICAgICAgICBUeXBlRGF0YVZpZXcKKyAgICAgICAgVHlw ZURhdGFWaWV3LAorICAgICAgICAvLyBVc2VkIG9ubHkgYnkgSlMgYmluZGluZ3MgdG8gaW5kaWNh dGUgdGhhdCBubyBvYmplY3Qgd2FzIHBhc3NlZC4KKyAgICAgICAgVHlwZU5vbmUKICAgICB9Owog ICAgIHZpcnR1YWwgVmlld1R5cGUgZ2V0VHlwZSgpIGNvbnN0ID0gMDsKIApkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy9Db2RlR2VuZXJhdG9yLnBtIGIvU291cmNl L1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy9Db2RlR2VuZXJhdG9yLnBtCmluZGV4IDRjNzg1MDg1 MDMzNjNkMTJlZmJhNDA4Njg0MDkyMDEwYmYzZmU5YzMuLjkyZTNiNDcyYjNkNmU2NDc0MGU5YjU1 N2I4YzczNzg4MDU1YzkyNGQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3Nj cmlwdHMvQ29kZUdlbmVyYXRvci5wbQorKysgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9zY3Jp cHRzL0NvZGVHZW5lcmF0b3IucG0KQEAgLTM4OCw2ICszODgsMTQgQEAgc3ViIElzVHlwZWRBcnJh eVR5cGUKICAgICByZXR1cm4gMDsKIH0KIAorc3ViIElzQXJyYXlCdWZmZXJUeXBlCit7CisgICAg bXkgJG9iamVjdCA9IHNoaWZ0OworICAgIG15ICR0eXBlID0gc2hpZnQ7CisgICAgcmV0dXJuIDEg aWYgKCR0eXBlIGVxICJBcnJheUJ1ZmZlciIpOworICAgIHJldHVybiAwOworfQorCiBzdWIgSXNS ZWZQdHJUeXBlCiB7CiAgICAgbXkgJG9iamVjdCA9IHNoaWZ0OwpAQCAtNzUxLDQgKzc1OSwzOSBA QCBzdWIgSXNTdWJUeXBlCiAgICAgcmV0dXJuICRmb3VuZDsKIH0KIAorc3ViIEV4dHJhY3RUeXBl ZEFycmF5Q29tcG9uZW50c0Zyb21QYXJhbWV0ZXIKK3sKKyAgICBteSAkb2JqZWN0ID0gc2hpZnQ7 CisgICAgbXkgJHBhcmFtID0gc2hpZnQ7CisgICAgbXkgJHZhcmlhYmxlcyA9ICIiOworICAgIG15 ICRpc0FycmF5QnVmZmVyID0gJG9iamVjdC0+SXNBcnJheUJ1ZmZlclR5cGUoJHBhcmFtLT50eXBl KTsKKyAgICBteSAkcGFyYW1OYW1lID0gJHBhcmFtLT5uYW1lOworICAgICR2YXJpYWJsZXMgLj0g IiAgICB2b2lkKiAkcGFyYW1OYW1lIiAuICJCYXNlQWRkcmVzcyA9IDA7XG4iOworICAgICR2YXJp YWJsZXMgLj0gIiAgICB1bnNpZ25lZCAkcGFyYW1OYW1lIiAuICJCeXRlTGVuZ3RoID0gMDtcbiI7 CisgICAgaWYgKCEkaXNBcnJheUJ1ZmZlcikgeworICAgICAgICAkdmFyaWFibGVzIC49ICIgICAg QXJyYXlCdWZmZXJWaWV3OjpWaWV3VHlwZSAkcGFyYW1OYW1lIiAuICJWaWV3VHlwZSA9IEFycmF5 QnVmZmVyVmlldzo6VHlwZU5vbmU7XG4iOworICAgIH0KKyAgICAkdmFyaWFibGVzIC49ICIgICAg aWYgKCRwYXJhbU5hbWUpIHtcbiI7CisgICAgJHZhcmlhYmxlcyAuPSAiICAgICAgICAkcGFyYW1O YW1lIiAuICJCYXNlQWRkcmVzcyA9ICRwYXJhbU5hbWUtPiIgLiAoJGlzQXJyYXlCdWZmZXIgPyAi ZGF0YSIgOiAiYmFzZUFkZHJlc3MiKSAuICIoKTtcbiI7CisgICAgJHZhcmlhYmxlcyAuPSAiICAg ICAgICAkcGFyYW1OYW1lIiAuICJCeXRlTGVuZ3RoID0gJHBhcmFtTmFtZS0+Ynl0ZUxlbmd0aCgp O1xuIjsKKyAgICBpZiAoISRpc0FycmF5QnVmZmVyKSB7CisgICAgICAgICR2YXJpYWJsZXMgLj0g IiAgICAgICAgJHBhcmFtTmFtZSIgLiAiVmlld1R5cGUgPSAkcGFyYW1OYW1lLT5nZXRUeXBlKCk7 XG4iOworICAgIH0KKyAgICAkdmFyaWFibGVzIC49ICIgICAgfVxuIjsKKyAgICByZXR1cm4gJHZh cmlhYmxlczsKK30KKworc3ViIEFkZFR5cGVkQXJyYXlDb21wb25lbnRBcmd1bWVudHNGb3JQYXJh bWV0ZXIKK3sKKyAgICBteSAkb2JqZWN0ID0gc2hpZnQ7CisgICAgbXkgJHBhcmFtID0gc2hpZnQ7 CisgICAgbXkgJGFyZ3VtZW50cyA9IHNoaWZ0OworICAgIG15ICRwYXJhbU5hbWUgPSAkcGFyYW0t Pm5hbWU7CisgICAgcHVzaChAJGFyZ3VtZW50cywgIiRwYXJhbU5hbWUiIC4gIkJhc2VBZGRyZXNz Iik7CisgICAgcHVzaChAJGFyZ3VtZW50cywgIiRwYXJhbU5hbWUiIC4gIkJ5dGVMZW5ndGgiKTsK KyAgICBpZiAoISRvYmplY3QtPklzQXJyYXlCdWZmZXJUeXBlKCRwYXJhbS0+dHlwZSkpIHsKKyAg ICAgICAgcHVzaChAJGFyZ3VtZW50cywgIiRwYXJhbU5hbWUiIC4gIlZpZXdUeXBlIik7CisgICAg fQorfSAgICAKKwogMTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3Njcmlw dHMvQ29kZUdlbmVyYXRvckpTLnBtIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy9D b2RlR2VuZXJhdG9ySlMucG0KaW5kZXggOTBjZGM2MGRmNTQxM2NmM2UyODE0MDBjY2VlYzAzZWEz MjRkYWE5ZC4uNDE1ZmFiZWUzZDc1NTIwNjZmM2IxYzNjMGFhN2MyYTMzYjQ4MmYwNiAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy9Db2RlR2VuZXJhdG9ySlMucG0K KysrIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy9Db2RlR2VuZXJhdG9ySlMucG0K QEAgLTI3ODMsMTIgKzI3ODMsMjMgQEAgc3ViIEdlbmVyYXRlUGFyYW1ldGVyc0NoZWNrCiAgICAg ICAgICAgICAgICAgcHVzaChAJG91dHB1dEFycmF5LCAiICAgICAgICByZXR1cm4gSlNWYWx1ZTo6 ZW5jb2RlKGpzVW5kZWZpbmVkKCkpO1xuIik7CiAgICAgICAgICAgICAgICAgcHVzaChAJG91dHB1 dEFycmF5LCAiICAgIH1cbiIpOwogICAgICAgICAgICAgfQorCisgICAgICAgICAgICAjIElmIHRo ZSBtZXRob2QgdXNlcyB0eXBlZCBhcnJheXMgYW5kIGRlY2xhcmVzIHRoYXQgaXQgZG9lc24ndCBy ZXRhaW4gcmVmZXJlbmNlcyB0byB0aGVtLAorICAgICAgICAgICAgIyBleHRyYWN0IHRoZSBiYXNl IGFkZHJlc3MsIGxlbmd0aCwgYW5kIG9wdGlvbmFsbHkgdGhlIHZpZXcgdHlwZSBpbiB0aGUgYmlu ZGluZ3MsIGFuZCBkb24ndAorICAgICAgICAgICAgIyBwYXNzIHRoZSBXVEYgQXJyYXlCdWZmZXIg b3IgQXJyYXlCdWZmZXJWaWV3IG9iamVjdHMgaW50byBXZWJDb3JlIGF0IGFsbC4KKyAgICAgICAg ICAgICMgVGhpcyBpcyB3aGVyZSB0eXBlZCBhcnJheXMgYWxsb2NhdGVkIHB1cmVseSBpbiB0aGUg SlMgVk0gd2lsbCBldmVudHVhbGx5IGJlIGhhbmRsZWQgKGFuZAorICAgICAgICAgICAgIyB0aGUg cGFyYW1ldGVyIGV4dHJhY3Rpb24gY29kZSwgYWJvdmUsIHdpbGwgY2hhbmdlKS4KKyAgICAgICAg ICAgIGlmICgkZnVuY3Rpb24tPnNpZ25hdHVyZS0+ZXh0ZW5kZWRBdHRyaWJ1dGVzLT57IkRvZXNO b3RSZXRhaW5UeXBlZEFycmF5cyJ9ICYmICRjb2RlR2VuZXJhdG9yLT5Jc1R5cGVkQXJyYXlUeXBl KCRhcmdUeXBlKSkgeworICAgICAgICAgICAgICAgIHB1c2goQCRvdXRwdXRBcnJheSwgJGNvZGVH ZW5lcmF0b3ItPkV4dHJhY3RUeXBlZEFycmF5Q29tcG9uZW50c0Zyb21QYXJhbWV0ZXIoJHBhcmFt ZXRlcikpOworICAgICAgICAgICAgfQogICAgICAgICB9CiAKICAgICAgICAgaWYgKCRhcmdUeXBl IGVxICJOb2RlRmlsdGVyIikgewogICAgICAgICAgICAgcHVzaCBAYXJndW1lbnRzLCAiJG5hbWUu Z2V0KCkiOwogICAgICAgICB9IGVsc2lmICgkY29kZUdlbmVyYXRvci0+SXNTVkdUeXBlTmVlZGlu Z1RlYXJPZmYoJGFyZ1R5cGUpIGFuZCBub3QgJGludGVyZmFjZU5hbWUgPX4gL0xpc3QkLykgewog ICAgICAgICAgICAgcHVzaCBAYXJndW1lbnRzLCAiJG5hbWUtPnByb3BlcnR5UmVmZXJlbmNlKCki OworICAgICAgICB9IGVsc2lmICgkZnVuY3Rpb24tPnNpZ25hdHVyZS0+ZXh0ZW5kZWRBdHRyaWJ1 dGVzLT57IkRvZXNOb3RSZXRhaW5UeXBlZEFycmF5cyJ9ICYmICRjb2RlR2VuZXJhdG9yLT5Jc1R5 cGVkQXJyYXlUeXBlKCRhcmdUeXBlKSkgeworICAgICAgICAgICAgJGNvZGVHZW5lcmF0b3ItPkFk ZFR5cGVkQXJyYXlDb21wb25lbnRBcmd1bWVudHNGb3JQYXJhbWV0ZXIoJHBhcmFtZXRlciwgXEBh cmd1bWVudHMpOwogICAgICAgICB9IGVsc2UgewogICAgICAgICAgICAgcHVzaCBAYXJndW1lbnRz LCAkbmFtZTsKICAgICAgICAgfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3Mv c2NyaXB0cy9Db2RlR2VuZXJhdG9yVjgucG0gYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9zY3Jp cHRzL0NvZGVHZW5lcmF0b3JWOC5wbQppbmRleCBmZjk1Y2ExYzgzMGYxNjI3N2Q4ZDlmZGY4MTcy YmM4ZTA5NWZjNGRhLi42YTdkNzQ1NjliMjkzMDNmZDQ2ODFkNGIxOWYxNmM3ODFkYzNmYmRjIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9zY3JpcHRzL0NvZGVHZW5lcmF0b3JW OC5wbQorKysgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9zY3JpcHRzL0NvZGVHZW5lcmF0b3JW OC5wbQpAQCAtMTgxOSw2ICsxODE5LDE0IEBAIHN1YiBHZW5lcmF0ZVBhcmFtZXRlcnNDaGVjawog ICAgICAgICAgICAgICAgJHBhcmFtZXRlckNoZWNrU3RyaW5nIC49ICIgICAgaWYgKCEkcGFyYW1l dGVyTmFtZS5pc1VuZGVmaW5lZE9yTnVsbCgpICYmICEkcGFyYW1ldGVyTmFtZS5pc09iamVjdCgp KVxuIjsKICAgICAgICAgICAgICAgICRwYXJhbWV0ZXJDaGVja1N0cmluZyAuPSAiICAgICAgICBy ZXR1cm4gdGhyb3dUeXBlRXJyb3IoXCJOb3QgYW4gb2JqZWN0LlwiLCBhcmdzLkdldElzb2xhdGUo KSk7XG4iOwogICAgICAgICAgICAgfQorICAgICAgICAgICAgIyBJZiB0aGUgbWV0aG9kIHVzZXMg dHlwZWQgYXJyYXlzIGFuZCBkZWNsYXJlcyB0aGF0IGl0IGRvZXNuJ3QgcmV0YWluIHJlZmVyZW5j ZXMgdG8gdGhlbSwKKyAgICAgICAgICAgICMgZXh0cmFjdCB0aGUgYmFzZSBhZGRyZXNzLCBsZW5n dGgsIGFuZCBvcHRpb25hbGx5IHRoZSB2aWV3IHR5cGUgaW4gdGhlIGJpbmRpbmdzLCBhbmQgZG9u J3QKKyAgICAgICAgICAgICMgcGFzcyB0aGUgV1RGIEFycmF5QnVmZmVyIG9yIEFycmF5QnVmZmVy VmlldyBvYmplY3RzIGludG8gV2ViQ29yZSBhdCBhbGwuCisgICAgICAgICAgICAjIFRoaXMgaXMg d2hlcmUgdHlwZWQgYXJyYXlzIGFsbG9jYXRlZCBwdXJlbHkgaW4gdGhlIEpTIFZNIHdpbGwgZXZl bnR1YWxseSBiZSBoYW5kbGVkIChhbmQKKyAgICAgICAgICAgICMgdGhlIHBhcmFtZXRlciBleHRy YWN0aW9uIGNvZGUsIGFib3ZlLCB3aWxsIGNoYW5nZSkuCisgICAgICAgICAgICBpZiAoJGZ1bmN0 aW9uLT5zaWduYXR1cmUtPmV4dGVuZGVkQXR0cmlidXRlcy0+eyJEb2VzTm90UmV0YWluVHlwZWRB cnJheXMifSAmJiAkY29kZUdlbmVyYXRvci0+SXNUeXBlZEFycmF5VHlwZSgkcGFyYW1ldGVyLT50 eXBlKSkgeworICAgICAgICAgICAgICAgICRwYXJhbWV0ZXJDaGVja1N0cmluZyAuPSAkY29kZUdl bmVyYXRvci0+RXh0cmFjdFR5cGVkQXJyYXlDb21wb25lbnRzRnJvbVBhcmFtZXRlcigkcGFyYW1l dGVyKTsKKyAgICAgICAgICAgIH0KICAgICAgICAgfQogCiAgICAgICAgIGlmICgkcGFyYW1ldGVy LT5leHRlbmRlZEF0dHJpYnV0ZXMtPnsiSXNJbmRleCJ9KSB7CkBAIC0zNTU2LDYgKzM1NjQsOCBA QCBzdWIgR2VuZXJhdGVGdW5jdGlvbkNhbGxTdHJpbmcoKQogICAgICAgICAgICAgJHJlc3VsdCAu PSAkaW5kZW50IC4gIiAgICByZXR1cm4gc2V0RE9NRXhjZXB0aW9uKFdlYkNvcmU6OlRZUEVfTUlT TUFUQ0hfRVJSLCBhcmdzLkdldElzb2xhdGUoKSk7XG4iOwogICAgICAgICB9IGVsc2lmICgkcGFy YW1ldGVyLT50eXBlIGVxICJTVkdNYXRyaXgiIGFuZCAkaW50ZXJmYWNlTmFtZSBlcSAiU1ZHVHJh bnNmb3JtTGlzdCIpIHsKICAgICAgICAgICAgIHB1c2ggQGFyZ3VtZW50cywgIiRwYXJhbU5hbWUu Z2V0KCkiOworICAgICAgICB9IGVsc2lmICgkZnVuY3Rpb24tPnNpZ25hdHVyZS0+ZXh0ZW5kZWRB dHRyaWJ1dGVzLT57IkRvZXNOb3RSZXRhaW5UeXBlZEFycmF5cyJ9ICYmICRjb2RlR2VuZXJhdG9y LT5Jc1R5cGVkQXJyYXlUeXBlKCRwYXJhbWV0ZXItPnR5cGUpKSB7CisgICAgICAgICAgICAkY29k ZUdlbmVyYXRvci0+QWRkVHlwZWRBcnJheUNvbXBvbmVudEFyZ3VtZW50c0ZvclBhcmFtZXRlcigk cGFyYW1ldGVyLCBcQGFyZ3VtZW50cyk7CiAgICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgICBw dXNoIEBhcmd1bWVudHMsICRwYXJhbU5hbWU7CiAgICAgICAgIH0KZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvSURMQXR0cmlidXRlcy50eHQgYi9Tb3VyY2UvV2Vi Q29yZS9iaW5kaW5ncy9zY3JpcHRzL0lETEF0dHJpYnV0ZXMudHh0CmluZGV4IDcwNTQ0M2ViNTIx YjM2MDRhY2VmNGNlM2UwOWIyNzFhODg5ZjQyZjYuLmZhYzRiNjcwMzFmOTNhNWI0MzgwNjY0MzVk NjdjYTBkOGQ1ZDA1YmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3Njcmlw dHMvSURMQXR0cmlidXRlcy50eHQKKysrIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0 cy9JRExBdHRyaWJ1dGVzLnR4dApAQCAtNDgsNiArNDgsNyBAQCBDdXN0b21SZXR1cm4KIEN1c3Rv bVNldHRlcgogQ3VzdG9tVG9KU09iamVjdAogRGVsZXRhYmxlCitEb2VzTm90UmV0YWluVHlwZWRB cnJheXMKIERvTm90Q2hlY2tDb25zdGFudHMKIERvTm90Q2hlY2tTZWN1cml0eQogRG9Ob3RDaGVj a1NlY3VyaXR5T25HZXR0ZXIKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvY2FudmFz L1dlYkdMQnVmZmVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvY2FudmFzL1dlYkdMQnVmZmVy LmNwcAppbmRleCBmNWVhOTQ3ZTExOWJmYTVjMTc2NjZjMTZmOGIxMGJiMDM4ZDZiMzE5Li4xNDVi NGMyNGNmYmM5YjJjYTFlNjEzNWZkOGRhMmJhNzhkMWQ0ODVlIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9odG1sL2NhbnZhcy9XZWJHTEJ1ZmZlci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUv aHRtbC9jYW52YXMvV2ViR0xCdWZmZXIuY3BwCkBAIC02MSw3ICs2MSw3IEBAIHZvaWQgV2ViR0xC dWZmZXI6OmRlbGV0ZU9iamVjdEltcGwoR3JhcGhpY3NDb250ZXh0M0QqIGNvbnRleHQzZCwgUGxh dGZvcm0zRE9iamVjCiAgICAgICBjb250ZXh0M2QtPmRlbGV0ZUJ1ZmZlcihvYmplY3QpOwogfQog Ci1ib29sIFdlYkdMQnVmZmVyOjphc3NvY2lhdGVCdWZmZXJEYXRhSW1wbChjb25zdCB2b2lkKiBk YXRhLCBHQzNEc2l6ZWlwdHIgYnl0ZUxlbmd0aCkKK2Jvb2wgV2ViR0xCdWZmZXI6OmFzc29jaWF0 ZUJ1ZmZlckRhdGEoY29uc3Qgdm9pZCogZGF0YSwgR0MzRHNpemVpcHRyIGJ5dGVMZW5ndGgpCiB7 CiAgICAgaWYgKGJ5dGVMZW5ndGggPCAwKQogICAgICAgICByZXR1cm4gZmFsc2U7CkBAIC05NSwy NCArOTUsMTAgQEAgYm9vbCBXZWJHTEJ1ZmZlcjo6YXNzb2NpYXRlQnVmZmVyRGF0YUltcGwoY29u c3Qgdm9pZCogZGF0YSwgR0MzRHNpemVpcHRyIGJ5dGVMZW4KIAogYm9vbCBXZWJHTEJ1ZmZlcjo6 YXNzb2NpYXRlQnVmZmVyRGF0YShHQzNEc2l6ZWlwdHIgc2l6ZSkKIHsKLSAgICByZXR1cm4gYXNz b2NpYXRlQnVmZmVyRGF0YUltcGwoMCwgc2l6ZSk7CisgICAgcmV0dXJuIGFzc29jaWF0ZUJ1ZmZl ckRhdGEoMCwgc2l6ZSk7CiB9CiAKLWJvb2wgV2ViR0xCdWZmZXI6OmFzc29jaWF0ZUJ1ZmZlckRh dGEoQXJyYXlCdWZmZXIqIGFycmF5KQotewotICAgIGlmICghYXJyYXkpCi0gICAgICAgIHJldHVy biBmYWxzZTsKLSAgICByZXR1cm4gYXNzb2NpYXRlQnVmZmVyRGF0YUltcGwoYXJyYXkgPyBhcnJh eS0+ZGF0YSgpIDogMCwgYXJyYXkgPyBhcnJheS0+Ynl0ZUxlbmd0aCgpIDogMCk7Ci19Ci0KLWJv b2wgV2ViR0xCdWZmZXI6OmFzc29jaWF0ZUJ1ZmZlckRhdGEoQXJyYXlCdWZmZXJWaWV3KiBhcnJh eSkKLXsKLSAgICBpZiAoIWFycmF5KQotICAgICAgICByZXR1cm4gZmFsc2U7Ci0gICAgcmV0dXJu IGFzc29jaWF0ZUJ1ZmZlckRhdGFJbXBsKGFycmF5ID8gYXJyYXktPmJhc2VBZGRyZXNzKCkgOiAw LCBhcnJheSA/IGFycmF5LT5ieXRlTGVuZ3RoKCkgOiAwKTsKLX0KLQotYm9vbCBXZWJHTEJ1ZmZl cjo6YXNzb2NpYXRlQnVmZmVyU3ViRGF0YUltcGwoR0MzRGludHB0ciBvZmZzZXQsIGNvbnN0IHZv aWQqIGRhdGEsIEdDM0RzaXplaXB0ciBieXRlTGVuZ3RoKQorYm9vbCBXZWJHTEJ1ZmZlcjo6YXNz b2NpYXRlQnVmZmVyU3ViRGF0YShHQzNEaW50cHRyIG9mZnNldCwgY29uc3Qgdm9pZCogZGF0YSwg R0MzRHNpemVpcHRyIGJ5dGVMZW5ndGgpCiB7CiAgICAgaWYgKCFkYXRhIHx8IG9mZnNldCA8IDAg fHwgYnl0ZUxlbmd0aCA8IDApCiAgICAgICAgIHJldHVybiBmYWxzZTsKQEAgLTE0MSwyMCArMTI3 LDYgQEAgYm9vbCBXZWJHTEJ1ZmZlcjo6YXNzb2NpYXRlQnVmZmVyU3ViRGF0YUltcGwoR0MzRGlu dHB0ciBvZmZzZXQsIGNvbnN0IHZvaWQqIGRhdGEKICAgICB9CiB9CiAKLWJvb2wgV2ViR0xCdWZm ZXI6OmFzc29jaWF0ZUJ1ZmZlclN1YkRhdGEoR0MzRGludHB0ciBvZmZzZXQsIEFycmF5QnVmZmVy KiBhcnJheSkKLXsKLSAgICBpZiAoIWFycmF5KQotICAgICAgICByZXR1cm4gZmFsc2U7Ci0gICAg cmV0dXJuIGFzc29jaWF0ZUJ1ZmZlclN1YkRhdGFJbXBsKG9mZnNldCwgYXJyYXktPmRhdGEoKSwg YXJyYXktPmJ5dGVMZW5ndGgoKSk7Ci19Ci0KLWJvb2wgV2ViR0xCdWZmZXI6OmFzc29jaWF0ZUJ1 ZmZlclN1YkRhdGEoR0MzRGludHB0ciBvZmZzZXQsIEFycmF5QnVmZmVyVmlldyogYXJyYXkpCi17 Ci0gICAgaWYgKCFhcnJheSkKLSAgICAgICAgcmV0dXJuIGZhbHNlOwotICAgIHJldHVybiBhc3Nv Y2lhdGVCdWZmZXJTdWJEYXRhSW1wbChvZmZzZXQsIGFycmF5LT5iYXNlQWRkcmVzcygpLCBhcnJh eS0+Ynl0ZUxlbmd0aCgpKTsKLX0KLQogR0MzRHNpemVpcHRyIFdlYkdMQnVmZmVyOjpieXRlTGVu Z3RoKCkgY29uc3QKIHsKICAgICByZXR1cm4gbV9ieXRlTGVuZ3RoOwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvaHRtbC9jYW52YXMvV2ViR0xCdWZmZXIuaCBiL1NvdXJjZS9XZWJDb3JlL2h0 bWwvY2FudmFzL1dlYkdMQnVmZmVyLmgKaW5kZXggNGNlZWE5YmM5NWIxNTJmZjg4ODlhZGJhYmE1 MzgxOGVmMTIxMzg1Yi4uMzk3OTQ3MDg2NWFkNThkODllNjg5NjA5NDA2OGFiZjdlMGRhZjAzOCAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9jYW52YXMvV2ViR0xCdWZmZXIuaAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9odG1sL2NhbnZhcy9XZWJHTEJ1ZmZlci5oCkBAIC0yOCw3ICsyOCw2 IEBACiAKICNpbmNsdWRlICJXZWJHTFNoYXJlZE9iamVjdC5oIgogCi0jaW5jbHVkZSA8d3RmL0Fy cmF5QnVmZmVyLmg+CiAjaW5jbHVkZSA8d3RmL0ZvcndhcmQuaD4KICNpbmNsdWRlIDx3dGYvUGFz c1JlZlB0ci5oPgogI2luY2x1ZGUgPHd0Zi9SZWZDb3VudGVkLmg+CkBAIC00MiwxMCArNDEsOCBA QCBwdWJsaWM6CiAgICAgc3RhdGljIFBhc3NSZWZQdHI8V2ViR0xCdWZmZXI+IGNyZWF0ZShXZWJH TFJlbmRlcmluZ0NvbnRleHQqKTsKIAogICAgIGJvb2wgYXNzb2NpYXRlQnVmZmVyRGF0YShHQzNE c2l6ZWlwdHIgc2l6ZSk7Ci0gICAgYm9vbCBhc3NvY2lhdGVCdWZmZXJEYXRhKEFycmF5QnVmZmVy Kik7Ci0gICAgYm9vbCBhc3NvY2lhdGVCdWZmZXJEYXRhKEFycmF5QnVmZmVyVmlldyopOwotICAg IGJvb2wgYXNzb2NpYXRlQnVmZmVyU3ViRGF0YShHQzNEaW50cHRyIG9mZnNldCwgQXJyYXlCdWZm ZXIqKTsKLSAgICBib29sIGFzc29jaWF0ZUJ1ZmZlclN1YkRhdGEoR0MzRGludHB0ciBvZmZzZXQs IEFycmF5QnVmZmVyVmlldyopOworICAgIGJvb2wgYXNzb2NpYXRlQnVmZmVyRGF0YShjb25zdCB2 b2lkKiBkYXRhLCBHQzNEc2l6ZWlwdHIgYnl0ZUxlbmd0aCk7CisgICAgYm9vbCBhc3NvY2lhdGVC dWZmZXJTdWJEYXRhKEdDM0RpbnRwdHIgb2Zmc2V0LCBjb25zdCB2b2lkKiBkYXRhLCBHQzNEc2l6 ZWlwdHIgYnl0ZUxlbmd0aCk7CiAKICAgICBHQzNEc2l6ZWlwdHIgYnl0ZUxlbmd0aCgpIGNvbnN0 OwogICAgIGNvbnN0IEFycmF5QnVmZmVyKiBlbGVtZW50QXJyYXlCdWZmZXIoKSBjb25zdCB7IHJl dHVybiBtX2VsZW1lbnRBcnJheUJ1ZmZlci5nZXQoKTsgfQpAQCAtOTMsMTEgKzkwLDYgQEAgcHJp dmF0ZToKIAogICAgIC8vIENsZWFycyBhbGwgb2YgdGhlIGNhY2hlZCBtYXggaW5kaWNlcy4KICAg ICB2b2lkIGNsZWFyQ2FjaGVkTWF4SW5kaWNlcygpOwotCi0gICAgLy8gSGVscGVyIGZ1bmN0aW9u IGNhbGxlZCBieSB0aGUgdGhyZWUgYXNzb2NpYXRlQnVmZmVyRGF0YSgpLgotICAgIGJvb2wgYXNz b2NpYXRlQnVmZmVyRGF0YUltcGwoY29uc3Qgdm9pZCogZGF0YSwgR0MzRHNpemVpcHRyIGJ5dGVM ZW5ndGgpOwotICAgIC8vIEhlbHBlciBmdW5jdGlvbiBjYWxsZWQgYnkgdGhlIHR3byBhc3NvY2lh dGVCdWZmZXJTdWJEYXRhKCkuCi0gICAgYm9vbCBhc3NvY2lhdGVCdWZmZXJTdWJEYXRhSW1wbChH QzNEaW50cHRyIG9mZnNldCwgY29uc3Qgdm9pZCogZGF0YSwgR0MzRHNpemVpcHRyIGJ5dGVMZW5n dGgpOwogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvaHRtbC9jYW52YXMvV2ViR0xSZW5kZXJpbmdDb250ZXh0LmNwcCBiL1NvdXJjZS9XZWJD b3JlL2h0bWwvY2FudmFzL1dlYkdMUmVuZGVyaW5nQ29udGV4dC5jcHAKaW5kZXggMTc1OWUxYzhj ZTYwNDA4NjVlNWRhODE0NDhhYTgwY2JlYzljYmMxMy4uYmIyYzk3YjI4M2YyNzAwOTQ4YzY1ZWNl YWRkNDNjZGQ3YzNhODZhNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9jYW52YXMv V2ViR0xSZW5kZXJpbmdDb250ZXh0LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL2NhbnZh cy9XZWJHTFJlbmRlcmluZ0NvbnRleHQuY3BwCkBAIC0xMTExLDcgKzExMTEsNyBAQCB2b2lkIFdl YkdMUmVuZGVyaW5nQ29udGV4dDo6YnVmZmVyRGF0YShHQzNEZW51bSB0YXJnZXQsIGxvbmcgbG9u ZyBzaXplLCBHQzNEZW51bQogICAgIGNsZWFudXBBZnRlckdyYXBoaWNzQ2FsbChmYWxzZSk7CiB9 CiAKLXZvaWQgV2ViR0xSZW5kZXJpbmdDb250ZXh0OjpidWZmZXJEYXRhKEdDM0RlbnVtIHRhcmdl dCwgQXJyYXlCdWZmZXIqIGRhdGEsIEdDM0RlbnVtIHVzYWdlLCBFeGNlcHRpb25Db2RlJiBlYykK K3ZvaWQgV2ViR0xSZW5kZXJpbmdDb250ZXh0OjpidWZmZXJEYXRhKEdDM0RlbnVtIHRhcmdldCwg dm9pZCogZGF0YSwgdW5zaWduZWQgYnl0ZUxlbmd0aCwgR0MzRGVudW0gdXNhZ2UsIEV4Y2VwdGlv bkNvZGUmIGVjKQogewogICAgIFVOVVNFRF9QQVJBTShlYyk7CiAgICAgaWYgKGlzQ29udGV4dExv c3QoKSkKQEAgLTExMjQsNDAgKzExMjQsMjIgQEAgdm9pZCBXZWJHTFJlbmRlcmluZ0NvbnRleHQ6 OmJ1ZmZlckRhdGEoR0MzRGVudW0gdGFyZ2V0LCBBcnJheUJ1ZmZlciogZGF0YSwgR0MzRGUKICAg ICAgICAgcmV0dXJuOwogICAgIH0KICAgICBpZiAoIWlzRXJyb3JHZW5lcmF0ZWRPbk91dE9mQm91 bmRzQWNjZXNzZXMoKSkgewotICAgICAgICBpZiAoIWJ1ZmZlci0+YXNzb2NpYXRlQnVmZmVyRGF0 YShkYXRhKSkgeworICAgICAgICBpZiAoIWJ1ZmZlci0+YXNzb2NpYXRlQnVmZmVyRGF0YShkYXRh LCBieXRlTGVuZ3RoKSkgewogICAgICAgICAgICAgc3ludGhlc2l6ZUdMRXJyb3IoR3JhcGhpY3ND b250ZXh0M0Q6OklOVkFMSURfVkFMVUUsICJidWZmZXJEYXRhIiwgImludmFsaWQgYnVmZmVyIik7 CiAgICAgICAgICAgICByZXR1cm47CiAgICAgICAgIH0KICAgICB9CiAKLSAgICBtX2NvbnRleHQt PmJ1ZmZlckRhdGEodGFyZ2V0LCBkYXRhLT5ieXRlTGVuZ3RoKCksIGRhdGEtPmRhdGEoKSwgdXNh Z2UpOworICAgIG1fY29udGV4dC0+YnVmZmVyRGF0YSh0YXJnZXQsIGJ5dGVMZW5ndGgsIGRhdGEs IHVzYWdlKTsKICAgICBjbGVhbnVwQWZ0ZXJHcmFwaGljc0NhbGwoZmFsc2UpOwogfQogCi12b2lk IFdlYkdMUmVuZGVyaW5nQ29udGV4dDo6YnVmZmVyRGF0YShHQzNEZW51bSB0YXJnZXQsIEFycmF5 QnVmZmVyVmlldyogZGF0YSwgR0MzRGVudW0gdXNhZ2UsIEV4Y2VwdGlvbkNvZGUmIGVjKQordm9p ZCBXZWJHTFJlbmRlcmluZ0NvbnRleHQ6OmJ1ZmZlckRhdGEoR0MzRGVudW0gdGFyZ2V0LCB2b2lk KiBkYXRhLCB1bnNpZ25lZCBieXRlTGVuZ3RoLCBBcnJheUJ1ZmZlclZpZXc6OlZpZXdUeXBlLCBH QzNEZW51bSB1c2FnZSwgRXhjZXB0aW9uQ29kZSYgZWMpCiB7Ci0gICAgVU5VU0VEX1BBUkFNKGVj KTsKLSAgICBpZiAoaXNDb250ZXh0TG9zdCgpKQotICAgICAgICByZXR1cm47Ci0gICAgV2ViR0xC dWZmZXIqIGJ1ZmZlciA9IHZhbGlkYXRlQnVmZmVyRGF0YVBhcmFtZXRlcnMoImJ1ZmZlckRhdGEi LCB0YXJnZXQsIHVzYWdlKTsKLSAgICBpZiAoIWJ1ZmZlcikKLSAgICAgICAgcmV0dXJuOwotICAg IGlmICghZGF0YSkgewotICAgICAgICBzeW50aGVzaXplR0xFcnJvcihHcmFwaGljc0NvbnRleHQz RDo6SU5WQUxJRF9WQUxVRSwgImJ1ZmZlckRhdGEiLCAibm8gZGF0YSIpOwotICAgICAgICByZXR1 cm47Ci0gICAgfQotICAgIGlmICghaXNFcnJvckdlbmVyYXRlZE9uT3V0T2ZCb3VuZHNBY2Nlc3Nl cygpKSB7Ci0gICAgICAgIGlmICghYnVmZmVyLT5hc3NvY2lhdGVCdWZmZXJEYXRhKGRhdGEpKSB7 Ci0gICAgICAgICAgICBzeW50aGVzaXplR0xFcnJvcihHcmFwaGljc0NvbnRleHQzRDo6SU5WQUxJ RF9WQUxVRSwgImJ1ZmZlckRhdGEiLCAiaW52YWxpZCBidWZmZXIiKTsKLSAgICAgICAgICAgIHJl dHVybjsKLSAgICAgICAgfQotICAgIH0KLQotICAgIG1fY29udGV4dC0+YnVmZmVyRGF0YSh0YXJn ZXQsIGRhdGEtPmJ5dGVMZW5ndGgoKSwgZGF0YS0+YmFzZUFkZHJlc3MoKSwgdXNhZ2UpOwotICAg IGNsZWFudXBBZnRlckdyYXBoaWNzQ2FsbChmYWxzZSk7CisgICAgYnVmZmVyRGF0YSh0YXJnZXQs IGRhdGEsIGJ5dGVMZW5ndGgsIHVzYWdlLCBlYyk7CiB9CiAKLXZvaWQgV2ViR0xSZW5kZXJpbmdD b250ZXh0OjpidWZmZXJTdWJEYXRhKEdDM0RlbnVtIHRhcmdldCwgbG9uZyBsb25nIG9mZnNldCwg QXJyYXlCdWZmZXIqIGRhdGEsIEV4Y2VwdGlvbkNvZGUmIGVjKQordm9pZCBXZWJHTFJlbmRlcmlu Z0NvbnRleHQ6OmJ1ZmZlclN1YkRhdGEoR0MzRGVudW0gdGFyZ2V0LCBsb25nIGxvbmcgb2Zmc2V0 LCB2b2lkKiBkYXRhLCB1bnNpZ25lZCBieXRlTGVuZ3RoLCBFeGNlcHRpb25Db2RlJiBlYykKIHsK ICAgICBVTlVTRURfUEFSQU0oZWMpOwogICAgIGlmIChpc0NvbnRleHRMb3N0KCkpCkBAIC0xMTcy LDM5ICsxMTU0LDE5IEBAIHZvaWQgV2ViR0xSZW5kZXJpbmdDb250ZXh0OjpidWZmZXJTdWJEYXRh KEdDM0RlbnVtIHRhcmdldCwgbG9uZyBsb25nIG9mZnNldCwgQXJyCiAgICAgaWYgKCFkYXRhKQog ICAgICAgICByZXR1cm47CiAgICAgaWYgKCFpc0Vycm9yR2VuZXJhdGVkT25PdXRPZkJvdW5kc0Fj Y2Vzc2VzKCkpIHsKLSAgICAgICAgaWYgKCFidWZmZXItPmFzc29jaWF0ZUJ1ZmZlclN1YkRhdGEo c3RhdGljX2Nhc3Q8R0MzRGludHB0cj4ob2Zmc2V0KSwgZGF0YSkpIHsKKyAgICAgICAgaWYgKCFi dWZmZXItPmFzc29jaWF0ZUJ1ZmZlclN1YkRhdGEoc3RhdGljX2Nhc3Q8R0MzRGludHB0cj4ob2Zm c2V0KSwgZGF0YSwgYnl0ZUxlbmd0aCkpIHsKICAgICAgICAgICAgIHN5bnRoZXNpemVHTEVycm9y KEdyYXBoaWNzQ29udGV4dDNEOjpJTlZBTElEX1ZBTFVFLCAiYnVmZmVyU3ViRGF0YSIsICJvZmZz ZXQgb3V0IG9mIHJhbmdlIik7CiAgICAgICAgICAgICByZXR1cm47CiAgICAgICAgIH0KICAgICB9 CiAKLSAgICBtX2NvbnRleHQtPmJ1ZmZlclN1YkRhdGEodGFyZ2V0LCBzdGF0aWNfY2FzdDxHQzNE aW50cHRyPihvZmZzZXQpLCBkYXRhLT5ieXRlTGVuZ3RoKCksIGRhdGEtPmRhdGEoKSk7CisgICAg bV9jb250ZXh0LT5idWZmZXJTdWJEYXRhKHRhcmdldCwgc3RhdGljX2Nhc3Q8R0MzRGludHB0cj4o b2Zmc2V0KSwgYnl0ZUxlbmd0aCwgZGF0YSk7CiAgICAgY2xlYW51cEFmdGVyR3JhcGhpY3NDYWxs KGZhbHNlKTsKIH0KIAotdm9pZCBXZWJHTFJlbmRlcmluZ0NvbnRleHQ6OmJ1ZmZlclN1YkRhdGEo R0MzRGVudW0gdGFyZ2V0LCBsb25nIGxvbmcgb2Zmc2V0LCBBcnJheUJ1ZmZlclZpZXcqIGRhdGEs IEV4Y2VwdGlvbkNvZGUmIGVjKQordm9pZCBXZWJHTFJlbmRlcmluZ0NvbnRleHQ6OmJ1ZmZlclN1 YkRhdGEoR0MzRGVudW0gdGFyZ2V0LCBsb25nIGxvbmcgb2Zmc2V0LCB2b2lkKiBkYXRhLCB1bnNp Z25lZCBieXRlTGVuZ3RoLCBBcnJheUJ1ZmZlclZpZXc6OlZpZXdUeXBlLCBFeGNlcHRpb25Db2Rl JiBlYykKIHsKLSAgICBVTlVTRURfUEFSQU0oZWMpOwotICAgIGlmIChpc0NvbnRleHRMb3N0KCkp Ci0gICAgICAgIHJldHVybjsKLSAgICBXZWJHTEJ1ZmZlciogYnVmZmVyID0gdmFsaWRhdGVCdWZm ZXJEYXRhUGFyYW1ldGVycygiYnVmZmVyU3ViRGF0YSIsIHRhcmdldCwgR3JhcGhpY3NDb250ZXh0 M0Q6OlNUQVRJQ19EUkFXKTsKLSAgICBpZiAoIWJ1ZmZlcikKLSAgICAgICAgcmV0dXJuOwotICAg IGlmIChvZmZzZXQgPCAwKSB7Ci0gICAgICAgIHN5bnRoZXNpemVHTEVycm9yKEdyYXBoaWNzQ29u dGV4dDNEOjpJTlZBTElEX1ZBTFVFLCAiYnVmZmVyU3ViRGF0YSIsICJvZmZzZXQgPCAwIik7Ci0g ICAgICAgIHJldHVybjsKLSAgICB9Ci0gICAgaWYgKCFkYXRhKQotICAgICAgICByZXR1cm47Ci0g ICAgaWYgKCFpc0Vycm9yR2VuZXJhdGVkT25PdXRPZkJvdW5kc0FjY2Vzc2VzKCkpIHsKLSAgICAg ICAgaWYgKCFidWZmZXItPmFzc29jaWF0ZUJ1ZmZlclN1YkRhdGEoc3RhdGljX2Nhc3Q8R0MzRGlu dHB0cj4ob2Zmc2V0KSwgZGF0YSkpIHsKLSAgICAgICAgICAgIHN5bnRoZXNpemVHTEVycm9yKEdy YXBoaWNzQ29udGV4dDNEOjpJTlZBTElEX1ZBTFVFLCAiYnVmZmVyU3ViRGF0YSIsICJvZmZzZXQg b3V0IG9mIHJhbmdlIik7Ci0gICAgICAgICAgICByZXR1cm47Ci0gICAgICAgIH0KLSAgICB9Ci0K LSAgICBtX2NvbnRleHQtPmJ1ZmZlclN1YkRhdGEodGFyZ2V0LCBzdGF0aWNfY2FzdDxHQzNEaW50 cHRyPihvZmZzZXQpLCBkYXRhLT5ieXRlTGVuZ3RoKCksIGRhdGEtPmJhc2VBZGRyZXNzKCkpOwot ICAgIGNsZWFudXBBZnRlckdyYXBoaWNzQ2FsbChmYWxzZSk7CisgICAgYnVmZmVyU3ViRGF0YSh0 YXJnZXQsIG9mZnNldCwgZGF0YSwgYnl0ZUxlbmd0aCwgZWMpOwogfQogCiBHQzNEZW51bSBXZWJH TFJlbmRlcmluZ0NvbnRleHQ6OmNoZWNrRnJhbWVidWZmZXJTdGF0dXMoR0MzRGVudW0gdGFyZ2V0 KQpAQCAtMTMwNSw4ICsxMjY3LDkgQEAgdm9pZCBXZWJHTFJlbmRlcmluZ0NvbnRleHQ6OmNvbXBp bGVTaGFkZXIoV2ViR0xTaGFkZXIqIHNoYWRlciwgRXhjZXB0aW9uQ29kZSYgZWMKICAgICBjbGVh bnVwQWZ0ZXJHcmFwaGljc0NhbGwoZmFsc2UpOwogfQogCi12b2lkIFdlYkdMUmVuZGVyaW5nQ29u dGV4dDo6Y29tcHJlc3NlZFRleEltYWdlMkQoR0MzRGVudW0gdGFyZ2V0LCBHQzNEaW50IGxldmVs LCBHQzNEZW51bSBpbnRlcm5hbGZvcm1hdCwgR0MzRHNpemVpIHdpZHRoLAotICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEdDM0RzaXplaSBoZWlnaHQsIEdD M0RpbnQgYm9yZGVyLCBBcnJheUJ1ZmZlclZpZXcqIGRhdGEpCit2b2lkIFdlYkdMUmVuZGVyaW5n Q29udGV4dDo6Y29tcHJlc3NlZFRleEltYWdlMkQoCisgICAgR0MzRGVudW0gdGFyZ2V0LCBHQzNE aW50IGxldmVsLCBHQzNEZW51bSBpbnRlcm5hbGZvcm1hdCwgR0MzRHNpemVpIHdpZHRoLAorICAg IEdDM0RzaXplaSBoZWlnaHQsIEdDM0RpbnQgYm9yZGVyLCB2b2lkKiBkYXRhLCB1bnNpZ25lZCBi eXRlTGVuZ3RoLCBBcnJheUJ1ZmZlclZpZXc6OlZpZXdUeXBlKQogewogICAgIGlmIChpc0NvbnRl eHRMb3N0KCkpCiAgICAgICAgIHJldHVybjsKQEAgLTEzMjMsNyArMTI4Niw3IEBAIHZvaWQgV2Vi R0xSZW5kZXJpbmdDb250ZXh0Ojpjb21wcmVzc2VkVGV4SW1hZ2UyRChHQzNEZW51bSB0YXJnZXQs IEdDM0RpbnQgbGV2ZWwsCiAgICAgfQogICAgIGlmICghdmFsaWRhdGVDb21wcmVzc2VkVGV4RGlt ZW5zaW9ucygiY29tcHJlc3NlZFRleEltYWdlMkQiLCBsZXZlbCwgd2lkdGgsIGhlaWdodCwgaW50 ZXJuYWxmb3JtYXQpKQogICAgICAgICByZXR1cm47Ci0gICAgaWYgKCF2YWxpZGF0ZUNvbXByZXNz ZWRUZXhGdW5jRGF0YSgiY29tcHJlc3NlZFRleEltYWdlMkQiLCB3aWR0aCwgaGVpZ2h0LCBpbnRl cm5hbGZvcm1hdCwgZGF0YSkpCisgICAgaWYgKCF2YWxpZGF0ZUNvbXByZXNzZWRUZXhGdW5jRGF0 YSgiY29tcHJlc3NlZFRleEltYWdlMkQiLCB3aWR0aCwgaGVpZ2h0LCBpbnRlcm5hbGZvcm1hdCwg ZGF0YSwgYnl0ZUxlbmd0aCkpCiAgICAgICAgIHJldHVybjsKIAogICAgIFdlYkdMVGV4dHVyZSog dGV4ID0gdmFsaWRhdGVUZXh0dXJlQmluZGluZygiY29tcHJlc3NlZFRleEltYWdlMkQiLCB0YXJn ZXQsIHRydWUpOwpAQCAtMTMzNSwxNCArMTI5OCwxNCBAQCB2b2lkIFdlYkdMUmVuZGVyaW5nQ29u dGV4dDo6Y29tcHJlc3NlZFRleEltYWdlMkQoR0MzRGVudW0gdGFyZ2V0LCBHQzNEaW50IGxldmVs LAogICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICB9CiAgICAgfQotICAgIGdyYXBoaWNzQ29u dGV4dDNEKCktPmNvbXByZXNzZWRUZXhJbWFnZTJEKHRhcmdldCwgbGV2ZWwsIGludGVybmFsZm9y bWF0LCB3aWR0aCwgaGVpZ2h0LAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIGJvcmRlciwgZGF0YS0+Ynl0ZUxlbmd0aCgpLCBkYXRhLT5iYXNlQWRkcmVzcygp KTsKKyAgICBncmFwaGljc0NvbnRleHQzRCgpLT5jb21wcmVzc2VkVGV4SW1hZ2UyRCh0YXJnZXQs IGxldmVsLCBpbnRlcm5hbGZvcm1hdCwgd2lkdGgsIGhlaWdodCwgYm9yZGVyLCBieXRlTGVuZ3Ro LCBkYXRhKTsKICAgICB0ZXgtPnNldExldmVsSW5mbyh0YXJnZXQsIGxldmVsLCBpbnRlcm5hbGZv cm1hdCwgd2lkdGgsIGhlaWdodCwgR3JhcGhpY3NDb250ZXh0M0Q6OlVOU0lHTkVEX0JZVEUpOwog ICAgIGNsZWFudXBBZnRlckdyYXBoaWNzQ2FsbChmYWxzZSk7CiB9CiAKLXZvaWQgV2ViR0xSZW5k ZXJpbmdDb250ZXh0Ojpjb21wcmVzc2VkVGV4U3ViSW1hZ2UyRChHQzNEZW51bSB0YXJnZXQsIEdD M0RpbnQgbGV2ZWwsIEdDM0RpbnQgeG9mZnNldCwgR0MzRGludCB5b2Zmc2V0LAotICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEdDM0RzaXplaSB3aWR0 aCwgR0MzRHNpemVpIGhlaWdodCwgR0MzRGVudW0gZm9ybWF0LCBBcnJheUJ1ZmZlclZpZXcqIGRh dGEpCit2b2lkIFdlYkdMUmVuZGVyaW5nQ29udGV4dDo6Y29tcHJlc3NlZFRleFN1YkltYWdlMkQo CisgICAgR0MzRGVudW0gdGFyZ2V0LCBHQzNEaW50IGxldmVsLCBHQzNEaW50IHhvZmZzZXQsIEdD M0RpbnQgeW9mZnNldCwKKyAgICBHQzNEc2l6ZWkgd2lkdGgsIEdDM0RzaXplaSBoZWlnaHQsIEdD M0RlbnVtIGZvcm1hdCwgdm9pZCogZGF0YSwgdW5zaWduZWQgYnl0ZUxlbmd0aCwgQXJyYXlCdWZm ZXJWaWV3OjpWaWV3VHlwZSkKIHsKICAgICBpZiAoaXNDb250ZXh0TG9zdCgpKQogICAgICAgICBy ZXR1cm47CkBAIC0xMzUyLDcgKzEzMTUsNyBAQCB2b2lkIFdlYkdMUmVuZGVyaW5nQ29udGV4dDo6 Y29tcHJlc3NlZFRleFN1YkltYWdlMkQoR0MzRGVudW0gdGFyZ2V0LCBHQzNEaW50IGxldgogICAg ICAgICBzeW50aGVzaXplR0xFcnJvcihHcmFwaGljc0NvbnRleHQzRDo6SU5WQUxJRF9FTlVNLCAi Y29tcHJlc3NlZFRleFN1YkltYWdlMkQiLCAiaW52YWxpZCBmb3JtYXQiKTsKICAgICAgICAgcmV0 dXJuOwogICAgIH0KLSAgICBpZiAoIXZhbGlkYXRlQ29tcHJlc3NlZFRleEZ1bmNEYXRhKCJjb21w cmVzc2VkVGV4U3ViSW1hZ2UyRCIsIHdpZHRoLCBoZWlnaHQsIGZvcm1hdCwgZGF0YSkpCisgICAg aWYgKCF2YWxpZGF0ZUNvbXByZXNzZWRUZXhGdW5jRGF0YSgiY29tcHJlc3NlZFRleFN1YkltYWdl MkQiLCB3aWR0aCwgaGVpZ2h0LCBmb3JtYXQsIGRhdGEsIGJ5dGVMZW5ndGgpKQogICAgICAgICBy ZXR1cm47CiAKICAgICBXZWJHTFRleHR1cmUqIHRleCA9IHZhbGlkYXRlVGV4dHVyZUJpbmRpbmco ImNvbXByZXNzZWRUZXhTdWJJbWFnZTJEIiwgdGFyZ2V0LCB0cnVlKTsKQEAgLTEzNjcsOCArMTMz MCw3IEBAIHZvaWQgV2ViR0xSZW5kZXJpbmdDb250ZXh0Ojpjb21wcmVzc2VkVGV4U3ViSW1hZ2Uy RChHQzNEZW51bSB0YXJnZXQsIEdDM0RpbnQgbGV2CiAgICAgaWYgKCF2YWxpZGF0ZUNvbXByZXNz ZWRUZXhTdWJEaW1lbnNpb25zKCJjb21wcmVzc2VkVGV4U3ViSW1hZ2UyRCIsIHRhcmdldCwgbGV2 ZWwsIHhvZmZzZXQsIHlvZmZzZXQsIHdpZHRoLCBoZWlnaHQsIGZvcm1hdCwgdGV4KSkKICAgICAg ICAgcmV0dXJuOwogCi0gICAgZ3JhcGhpY3NDb250ZXh0M0QoKS0+Y29tcHJlc3NlZFRleFN1Yklt YWdlMkQodGFyZ2V0LCBsZXZlbCwgeG9mZnNldCwgeW9mZnNldCwKLSAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB3aWR0aCwgaGVpZ2h0LCBmb3JtYXQsIGRh dGEtPmJ5dGVMZW5ndGgoKSwgZGF0YS0+YmFzZUFkZHJlc3MoKSk7CisgICAgZ3JhcGhpY3NDb250 ZXh0M0QoKS0+Y29tcHJlc3NlZFRleFN1YkltYWdlMkQodGFyZ2V0LCBsZXZlbCwgeG9mZnNldCwg eW9mZnNldCwgd2lkdGgsIGhlaWdodCwgZm9ybWF0LCBieXRlTGVuZ3RoLCBkYXRhKTsKICAgICBj bGVhbnVwQWZ0ZXJHcmFwaGljc0NhbGwoZmFsc2UpOwogfQogCkBAIC0zMzMyLDcgKzMyOTQsNyBA QCB2b2lkIFdlYkdMUmVuZGVyaW5nQ29udGV4dDo6cG9seWdvbk9mZnNldChHQzNEZmxvYXQgZmFj dG9yLCBHQzNEZmxvYXQgdW5pdHMpCiAgICAgY2xlYW51cEFmdGVyR3JhcGhpY3NDYWxsKGZhbHNl KTsKIH0KIAotdm9pZCBXZWJHTFJlbmRlcmluZ0NvbnRleHQ6OnJlYWRQaXhlbHMoR0MzRGludCB4 LCBHQzNEaW50IHksIEdDM0RzaXplaSB3aWR0aCwgR0MzRHNpemVpIGhlaWdodCwgR0MzRGVudW0g Zm9ybWF0LCBHQzNEZW51bSB0eXBlLCBBcnJheUJ1ZmZlclZpZXcqIHBpeGVscywgRXhjZXB0aW9u Q29kZSYpCit2b2lkIFdlYkdMUmVuZGVyaW5nQ29udGV4dDo6cmVhZFBpeGVscyhHQzNEaW50IHgs IEdDM0RpbnQgeSwgR0MzRHNpemVpIHdpZHRoLCBHQzNEc2l6ZWkgaGVpZ2h0LCBHQzNEZW51bSBm b3JtYXQsIEdDM0RlbnVtIHR5cGUsIHZvaWQqIGRhdGEsIHVuc2lnbmVkIGJ5dGVMZW5ndGgsIEFy cmF5QnVmZmVyVmlldzo6Vmlld1R5cGUgdmlld1R5cGUsIEV4Y2VwdGlvbkNvZGUmKQogewogICAg IGlmIChpc0NvbnRleHRMb3N0KCkpCiAgICAgICAgIHJldHVybjsKQEAgLTMzNDAsNyArMzMwMiw3 IEBAIHZvaWQgV2ViR0xSZW5kZXJpbmdDb250ZXh0OjpyZWFkUGl4ZWxzKEdDM0RpbnQgeCwgR0Mz RGludCB5LCBHQzNEc2l6ZWkgd2lkdGgsIEdDCiAgICAgLy8gdGFpbnQgdGhlIG9yaWdpbiB1c2lu ZyB0aGUgV2ViR0wgQVBJLgogICAgIEFTU0VSVChjYW52YXMoKS0+b3JpZ2luQ2xlYW4oKSk7CiAg ICAgLy8gVmFsaWRhdGUgaW5wdXQgcGFyYW1ldGVycy4KLSAgICBpZiAoIXBpeGVscykgeworICAg IGlmICghZGF0YSkgewogICAgICAgICBzeW50aGVzaXplR0xFcnJvcihHcmFwaGljc0NvbnRleHQz RDo6SU5WQUxJRF9WQUxVRSwgInJlYWRQaXhlbHMiLCAibm8gZGVzdGluYXRpb24gQXJyYXlCdWZm ZXJWaWV3Iik7CiAgICAgICAgIHJldHVybjsKICAgICB9CkBAIC0zMzY4LDcgKzMzMzAsNyBAQCB2 b2lkIFdlYkdMUmVuZGVyaW5nQ29udGV4dDo6cmVhZFBpeGVscyhHQzNEaW50IHgsIEdDM0RpbnQg eSwgR0MzRHNpemVpIHdpZHRoLCBHQwogICAgICAgICByZXR1cm47CiAgICAgfQogICAgIC8vIFZh bGlkYXRlIGFycmF5IHR5cGUgYWdhaW5zdCBwaXhlbCB0eXBlLgotICAgIGlmIChwaXhlbHMtPmdl dFR5cGUoKSAhPSBBcnJheUJ1ZmZlclZpZXc6OlR5cGVVaW50OCkgeworICAgIGlmICh2aWV3VHlw ZSAhPSBBcnJheUJ1ZmZlclZpZXc6OlR5cGVVaW50OCkgewogICAgICAgICBzeW50aGVzaXplR0xF cnJvcihHcmFwaGljc0NvbnRleHQzRDo6SU5WQUxJRF9PUEVSQVRJT04sICJyZWFkUGl4ZWxzIiwg IkFycmF5QnVmZmVyVmlldyBub3QgVWludDhBcnJheSIpOwogICAgICAgICByZXR1cm47CiAgICAg fQpAQCAtMzM4NiwxOSArMzM0OCwxOCBAQCB2b2lkIFdlYkdMUmVuZGVyaW5nQ29udGV4dDo6cmVh ZFBpeGVscyhHQzNEaW50IHgsIEdDM0RpbnQgeSwgR0MzRHNpemVpIHdpZHRoLCBHQwogICAgICAg ICAgICAgc3ludGhlc2l6ZUdMRXJyb3IoZXJyb3IsICJyZWFkUGl4ZWxzIiwgImludmFsaWQgZGlt ZW5zaW9ucyIpOwogICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICB9Ci0gICAgICAgIGlmIChw aXhlbHMtPmJ5dGVMZW5ndGgoKSA8IHRvdGFsQnl0ZXNSZXF1aXJlZCkgeworICAgICAgICBpZiAo Ynl0ZUxlbmd0aCA8IHRvdGFsQnl0ZXNSZXF1aXJlZCkgewogICAgICAgICAgICAgc3ludGhlc2l6 ZUdMRXJyb3IoR3JhcGhpY3NDb250ZXh0M0Q6OklOVkFMSURfT1BFUkFUSU9OLCAicmVhZFBpeGVs cyIsICJBcnJheUJ1ZmZlclZpZXcgbm90IGxhcmdlIGVub3VnaCBmb3IgZGltZW5zaW9ucyIpOwog ICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICB9CiAgICAgfQogCiAgICAgY2xlYXJJZkNvbXBv c2l0ZWQoKTsKLSAgICB2b2lkKiBkYXRhID0gcGl4ZWxzLT5iYXNlQWRkcmVzcygpOwogCiAgICAg ewogICAgICAgICBTY29wZWREcmF3aW5nQnVmZmVyQmluZGVyIGJpbmRlcihtX2RyYXdpbmdCdWZm ZXIuZ2V0KCksIG1fZnJhbWVidWZmZXJCaW5kaW5nLmdldCgpKTsKICAgICAgICAgaWYgKG1faXNS b2J1c3RuZXNzRVhUU3VwcG9ydGVkKQotICAgICAgICAgICAgbV9jb250ZXh0LT5nZXRFeHRlbnNp b25zKCktPnJlYWRuUGl4ZWxzRVhUKHgsIHksIHdpZHRoLCBoZWlnaHQsIGZvcm1hdCwgdHlwZSwg cGl4ZWxzLT5ieXRlTGVuZ3RoKCksIGRhdGEpOworICAgICAgICAgICAgbV9jb250ZXh0LT5nZXRF eHRlbnNpb25zKCktPnJlYWRuUGl4ZWxzRVhUKHgsIHksIHdpZHRoLCBoZWlnaHQsIGZvcm1hdCwg dHlwZSwgYnl0ZUxlbmd0aCwgZGF0YSk7CiAgICAgICAgIGVsc2UKICAgICAgICAgICAgIG1fY29u dGV4dC0+cmVhZFBpeGVscyh4LCB5LCB3aWR0aCwgaGVpZ2h0LCBmb3JtYXQsIHR5cGUsIGRhdGEp OwogICAgIH0KQEAgLTM2NjYsMTMgKzM2MjcsMTMgQEAgdm9pZCBXZWJHTFJlbmRlcmluZ0NvbnRl eHQ6OnRleEltYWdlMkRJbXBsKEdDM0RlbnVtIHRhcmdldCwgR0MzRGludCBsZXZlbCwgR0MzRGUK ICAgICAgICAgbV9jb250ZXh0LT5waXhlbFN0b3JlaShHcmFwaGljc0NvbnRleHQzRDo6VU5QQUNL X0FMSUdOTUVOVCwgbV91bnBhY2tBbGlnbm1lbnQpOwogfQogCi12b2lkIFdlYkdMUmVuZGVyaW5n Q29udGV4dDo6dGV4SW1hZ2UyRChHQzNEZW51bSB0YXJnZXQsIEdDM0RpbnQgbGV2ZWwsIEdDM0Rl bnVtIGludGVybmFsZm9ybWF0LAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgR0MzRHNpemVpIHdpZHRoLCBHQzNEc2l6ZWkgaGVpZ2h0LCBHQzNEaW50IGJvcmRlciwKLSAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEdDM0RlbnVtIGZvcm1hdCwgR0Mz RGVudW0gdHlwZSwgQXJyYXlCdWZmZXJWaWV3KiBwaXhlbHMsIEV4Y2VwdGlvbkNvZGUmIGVjKQor dm9pZCBXZWJHTFJlbmRlcmluZ0NvbnRleHQ6OnRleEltYWdlMkQoCisgICAgR0MzRGVudW0gdGFy Z2V0LCBHQzNEaW50IGxldmVsLCBHQzNEZW51bSBpbnRlcm5hbGZvcm1hdCwKKyAgICBHQzNEc2l6 ZWkgd2lkdGgsIEdDM0RzaXplaSBoZWlnaHQsIEdDM0RpbnQgYm9yZGVyLAorICAgIEdDM0RlbnVt IGZvcm1hdCwgR0MzRGVudW0gdHlwZSwgdm9pZCogZGF0YSwgdW5zaWduZWQgYnl0ZUxlbmd0aCwg QXJyYXlCdWZmZXJWaWV3OjpWaWV3VHlwZSB2aWV3VHlwZSwgRXhjZXB0aW9uQ29kZSYgZWMpCiB7 Ci0gICAgaWYgKGlzQ29udGV4dExvc3QoKSB8fCAhdmFsaWRhdGVUZXhGdW5jRGF0YSgidGV4SW1h Z2UyRCIsIGxldmVsLCB3aWR0aCwgaGVpZ2h0LCBmb3JtYXQsIHR5cGUsIHBpeGVscywgTnVsbEFs bG93ZWQpKQorICAgIGlmIChpc0NvbnRleHRMb3N0KCkgfHwgIXZhbGlkYXRlVGV4RnVuY0RhdGEo InRleEltYWdlMkQiLCBsZXZlbCwgd2lkdGgsIGhlaWdodCwgZm9ybWF0LCB0eXBlLCBkYXRhLCBi eXRlTGVuZ3RoLCB2aWV3VHlwZSwgTnVsbEFsbG93ZWQpKQogICAgICAgICByZXR1cm47Ci0gICAg dm9pZCogZGF0YSA9IHBpeGVscyA/IHBpeGVscy0+YmFzZUFkZHJlc3MoKSA6IDA7CiAgICAgVmVj dG9yPHVpbnQ4X3Q+IHRlbXBEYXRhOwogICAgIGJvb2wgY2hhbmdlVW5wYWNrQWxpZ25tZW50ID0g ZmFsc2U7CiAgICAgaWYgKGRhdGEgJiYgKG1fdW5wYWNrRmxpcFkgfHwgbV91bnBhY2tQcmVtdWx0 aXBseUFscGhhKSkgewpAQCAtMzkxMCwxMyArMzg3MSwxMyBAQCB2b2lkIFdlYkdMUmVuZGVyaW5n Q29udGV4dDo6dGV4U3ViSW1hZ2UyREltcGwoR0MzRGVudW0gdGFyZ2V0LCBHQzNEaW50IGxldmVs LCBHQwogICAgICAgICBtX2NvbnRleHQtPnBpeGVsU3RvcmVpKEdyYXBoaWNzQ29udGV4dDNEOjpV TlBBQ0tfQUxJR05NRU5ULCBtX3VucGFja0FsaWdubWVudCk7CiB9CiAKLXZvaWQgV2ViR0xSZW5k ZXJpbmdDb250ZXh0Ojp0ZXhTdWJJbWFnZTJEKEdDM0RlbnVtIHRhcmdldCwgR0MzRGludCBsZXZl bCwgR0MzRGludCB4b2Zmc2V0LCBHQzNEaW50IHlvZmZzZXQsCi0gICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBHQzNEc2l6ZWkgd2lkdGgsIEdDM0RzaXplaSBoZWlnaHQs Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBHQzNEZW51bSBmb3Jt YXQsIEdDM0RlbnVtIHR5cGUsIEFycmF5QnVmZmVyVmlldyogcGl4ZWxzLCBFeGNlcHRpb25Db2Rl JiBlYykKK3ZvaWQgV2ViR0xSZW5kZXJpbmdDb250ZXh0Ojp0ZXhTdWJJbWFnZTJEKAorICAgIEdD M0RlbnVtIHRhcmdldCwgR0MzRGludCBsZXZlbCwgR0MzRGludCB4b2Zmc2V0LCBHQzNEaW50IHlv ZmZzZXQsCisgICAgR0MzRHNpemVpIHdpZHRoLCBHQzNEc2l6ZWkgaGVpZ2h0LAorICAgIEdDM0Rl bnVtIGZvcm1hdCwgR0MzRGVudW0gdHlwZSwgdm9pZCogZGF0YSwgdW5zaWduZWQgYnl0ZUxlbmd0 aCwgQXJyYXlCdWZmZXJWaWV3OjpWaWV3VHlwZSB2aWV3VHlwZSwgRXhjZXB0aW9uQ29kZSYgZWMp CiB7Ci0gICAgaWYgKGlzQ29udGV4dExvc3QoKSB8fCAhdmFsaWRhdGVUZXhGdW5jRGF0YSgidGV4 U3ViSW1hZ2UyRCIsIGxldmVsLCB3aWR0aCwgaGVpZ2h0LCBmb3JtYXQsIHR5cGUsIHBpeGVscywg TnVsbE5vdEFsbG93ZWQpKQorICAgIGlmIChpc0NvbnRleHRMb3N0KCkgfHwgIXZhbGlkYXRlVGV4 RnVuY0RhdGEoInRleFN1YkltYWdlMkQiLCBsZXZlbCwgd2lkdGgsIGhlaWdodCwgZm9ybWF0LCB0 eXBlLCBkYXRhLCBieXRlTGVuZ3RoLCB2aWV3VHlwZSwgTnVsbE5vdEFsbG93ZWQpKQogICAgICAg ICByZXR1cm47Ci0gICAgdm9pZCogZGF0YSA9IHBpeGVscy0+YmFzZUFkZHJlc3MoKTsKICAgICBW ZWN0b3I8dWludDhfdD4gdGVtcERhdGE7CiAgICAgYm9vbCBjaGFuZ2VVbnBhY2tBbGlnbm1lbnQg PSBmYWxzZTsKICAgICBpZiAoZGF0YSAmJiAobV91bnBhY2tGbGlwWSB8fCBtX3VucGFja1ByZW11 bHRpcGx5QWxwaGEpKSB7CkBAIC01MDUxLDEwICs1MDEyLDEyIEBAIGJvb2wgV2ViR0xSZW5kZXJp bmdDb250ZXh0Ojp2YWxpZGF0ZVRleEZ1bmNQYXJhbWV0ZXJzKGNvbnN0IGNoYXIqIGZ1bmN0aW9u TmFtZSwKIGJvb2wgV2ViR0xSZW5kZXJpbmdDb250ZXh0Ojp2YWxpZGF0ZVRleEZ1bmNEYXRhKGNv bnN0IGNoYXIqIGZ1bmN0aW9uTmFtZSwgR0MzRGludCBsZXZlbCwKICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEdDM0RzaXplaSB3aWR0aCwgR0MzRHNpemVp IGhlaWdodCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IEdDM0RlbnVtIGZvcm1hdCwgR0MzRGVudW0gdHlwZSwKLSAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIEFycmF5QnVmZmVyVmlldyogcGl4ZWxzLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdm9pZCogZGF0YSwKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHVuc2lnbmVkIGJ5 dGVMZW5ndGgsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBBcnJheUJ1ZmZlclZpZXc6OlZpZXdUeXBlIHZpZXdUeXBlLAogICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgTnVsbERpc3Bvc2l0aW9uIGRpc3Bvc2l0aW9u KQogewotICAgIGlmICghcGl4ZWxzKSB7CisgICAgaWYgKCFkYXRhKSB7CiAgICAgICAgIGlmIChk aXNwb3NpdGlvbiA9PSBOdWxsQWxsb3dlZCkKICAgICAgICAgICAgIHJldHVybiB0cnVlOwogICAg ICAgICBzeW50aGVzaXplR0xFcnJvcihHcmFwaGljc0NvbnRleHQzRDo6SU5WQUxJRF9WQUxVRSwg ZnVuY3Rpb25OYW1lLCAibm8gcGl4ZWxzIik7CkBAIC01MDY4LDcgKzUwMzEsNyBAQCBib29sIFdl YkdMUmVuZGVyaW5nQ29udGV4dDo6dmFsaWRhdGVUZXhGdW5jRGF0YShjb25zdCBjaGFyKiBmdW5j dGlvbk5hbWUsIEdDM0RpbgogCiAgICAgc3dpdGNoICh0eXBlKSB7CiAgICAgY2FzZSBHcmFwaGlj c0NvbnRleHQzRDo6VU5TSUdORURfQllURToKLSAgICAgICAgaWYgKHBpeGVscy0+Z2V0VHlwZSgp ICE9IEFycmF5QnVmZmVyVmlldzo6VHlwZVVpbnQ4KSB7CisgICAgICAgIGlmICh2aWV3VHlwZSAh PSBBcnJheUJ1ZmZlclZpZXc6OlR5cGVVaW50OCkgewogICAgICAgICAgICAgc3ludGhlc2l6ZUdM RXJyb3IoR3JhcGhpY3NDb250ZXh0M0Q6OklOVkFMSURfT1BFUkFUSU9OLCBmdW5jdGlvbk5hbWUs ICJ0eXBlIFVOU0lHTkVEX0JZVEUgYnV0IEFycmF5QnVmZmVyVmlldyBub3QgVWludDhBcnJheSIp OwogICAgICAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgICAgICB9CkBAIC01MDc2LDEzICs1MDM5 LDEzIEBAIGJvb2wgV2ViR0xSZW5kZXJpbmdDb250ZXh0Ojp2YWxpZGF0ZVRleEZ1bmNEYXRhKGNv bnN0IGNoYXIqIGZ1bmN0aW9uTmFtZSwgR0MzRGluCiAgICAgY2FzZSBHcmFwaGljc0NvbnRleHQz RDo6VU5TSUdORURfU0hPUlRfNV82XzU6CiAgICAgY2FzZSBHcmFwaGljc0NvbnRleHQzRDo6VU5T SUdORURfU0hPUlRfNF80XzRfNDoKICAgICBjYXNlIEdyYXBoaWNzQ29udGV4dDNEOjpVTlNJR05F RF9TSE9SVF81XzVfNV8xOgotICAgICAgICBpZiAocGl4ZWxzLT5nZXRUeXBlKCkgIT0gQXJyYXlC dWZmZXJWaWV3OjpUeXBlVWludDE2KSB7CisgICAgICAgIGlmICh2aWV3VHlwZSAhPSBBcnJheUJ1 ZmZlclZpZXc6OlR5cGVVaW50MTYpIHsKICAgICAgICAgICAgIHN5bnRoZXNpemVHTEVycm9yKEdy YXBoaWNzQ29udGV4dDNEOjpJTlZBTElEX09QRVJBVElPTiwgZnVuY3Rpb25OYW1lLCAidHlwZSBV TlNJR05FRF9TSE9SVCBidXQgQXJyYXlCdWZmZXJWaWV3IG5vdCBVaW50MTZBcnJheSIpOwogICAg ICAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgICAgICB9CiAgICAgICAgIGJyZWFrOwogICAgIGNh c2UgR3JhcGhpY3NDb250ZXh0M0Q6OkZMT0FUOiAvLyBPRVNfdGV4dHVyZV9mbG9hdAotICAgICAg ICBpZiAocGl4ZWxzLT5nZXRUeXBlKCkgIT0gQXJyYXlCdWZmZXJWaWV3OjpUeXBlRmxvYXQzMikg eworICAgICAgICBpZiAodmlld1R5cGUgIT0gQXJyYXlCdWZmZXJWaWV3OjpUeXBlRmxvYXQzMikg ewogICAgICAgICAgICAgc3ludGhlc2l6ZUdMRXJyb3IoR3JhcGhpY3NDb250ZXh0M0Q6OklOVkFM SURfT1BFUkFUSU9OLCBmdW5jdGlvbk5hbWUsICJ0eXBlIEZMT0FUIGJ1dCBBcnJheUJ1ZmZlclZp ZXcgbm90IEZsb2F0MzJBcnJheSIpOwogICAgICAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgICAg ICB9CkBAIC01MDk3LDEzICs1MDYwLDEzIEBAIGJvb2wgV2ViR0xSZW5kZXJpbmdDb250ZXh0Ojp2 YWxpZGF0ZVRleEZ1bmNEYXRhKGNvbnN0IGNoYXIqIGZ1bmN0aW9uTmFtZSwgR0MzRGluCiAgICAg ICAgIHN5bnRoZXNpemVHTEVycm9yKGVycm9yLCBmdW5jdGlvbk5hbWUsICJpbnZhbGlkIHRleHR1 cmUgZGltZW5zaW9ucyIpOwogICAgICAgICByZXR1cm4gZmFsc2U7CiAgICAgfQotICAgIGlmIChw aXhlbHMtPmJ5dGVMZW5ndGgoKSA8IHRvdGFsQnl0ZXNSZXF1aXJlZCkgeworICAgIGlmIChieXRl TGVuZ3RoIDwgdG90YWxCeXRlc1JlcXVpcmVkKSB7CiAgICAgICAgIGlmIChtX3VucGFja0FsaWdu bWVudCAhPSAxKSB7Ci0gICAgICAgICAgZXJyb3IgPSBtX2NvbnRleHQtPmNvbXB1dGVJbWFnZVNp emVJbkJ5dGVzKGZvcm1hdCwgdHlwZSwgd2lkdGgsIGhlaWdodCwgMSwgJnRvdGFsQnl0ZXNSZXF1 aXJlZCwgMCk7Ci0gICAgICAgICAgaWYgKHBpeGVscy0+Ynl0ZUxlbmd0aCgpID09IHRvdGFsQnl0 ZXNSZXF1aXJlZCkgewotICAgICAgICAgICAgc3ludGhlc2l6ZUdMRXJyb3IoR3JhcGhpY3NDb250 ZXh0M0Q6OklOVkFMSURfT1BFUkFUSU9OLCBmdW5jdGlvbk5hbWUsICJBcnJheUJ1ZmZlclZpZXcg bm90IGJpZyBlbm91Z2ggZm9yIHJlcXVlc3Qgd2l0aCBVTlBBQ0tfQUxJR05NRU5UID4gMSIpOwot ICAgICAgICAgICAgcmV0dXJuIGZhbHNlOwotICAgICAgICAgIH0KKyAgICAgICAgICAgIGVycm9y ID0gbV9jb250ZXh0LT5jb21wdXRlSW1hZ2VTaXplSW5CeXRlcyhmb3JtYXQsIHR5cGUsIHdpZHRo LCBoZWlnaHQsIDEsICZ0b3RhbEJ5dGVzUmVxdWlyZWQsIDApOworICAgICAgICAgICAgaWYgKGJ5 dGVMZW5ndGggPT0gdG90YWxCeXRlc1JlcXVpcmVkKSB7CisgICAgICAgICAgICAgICAgc3ludGhl c2l6ZUdMRXJyb3IoR3JhcGhpY3NDb250ZXh0M0Q6OklOVkFMSURfT1BFUkFUSU9OLCBmdW5jdGlv bk5hbWUsICJBcnJheUJ1ZmZlclZpZXcgbm90IGJpZyBlbm91Z2ggZm9yIHJlcXVlc3Qgd2l0aCBV TlBBQ0tfQUxJR05NRU5UID4gMSIpOworICAgICAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAg ICAgICAgICAgIH0KICAgICAgICAgfQogICAgICAgICBzeW50aGVzaXplR0xFcnJvcihHcmFwaGlj c0NvbnRleHQzRDo6SU5WQUxJRF9PUEVSQVRJT04sIGZ1bmN0aW9uTmFtZSwgIkFycmF5QnVmZmVy VmlldyBub3QgYmlnIGVub3VnaCBmb3IgcmVxdWVzdCIpOwogICAgICAgICByZXR1cm4gZmFsc2U7 CkBAIC01MTE2LDExICs1MDc5LDEyIEBAIGJvb2wgV2ViR0xSZW5kZXJpbmdDb250ZXh0Ojp2YWxp ZGF0ZUNvbXByZXNzZWRUZXhGb3JtYXQoR0MzRGVudW0gZm9ybWF0KQogICAgIHJldHVybiBtX2Nv bXByZXNzZWRUZXh0dXJlRm9ybWF0cy5jb250YWlucyhmb3JtYXQpOwogfQogCi1ib29sIFdlYkdM UmVuZGVyaW5nQ29udGV4dDo6dmFsaWRhdGVDb21wcmVzc2VkVGV4RnVuY0RhdGEoY29uc3QgY2hh ciogZnVuY3Rpb25OYW1lLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIEdDM0RzaXplaSB3aWR0aCwgR0MzRHNpemVpIGhlaWdodCwKLSAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBH QzNEZW51bSBmb3JtYXQsIEFycmF5QnVmZmVyVmlldyogcGl4ZWxzKQorYm9vbCBXZWJHTFJlbmRl cmluZ0NvbnRleHQ6OnZhbGlkYXRlQ29tcHJlc3NlZFRleEZ1bmNEYXRhKAorICAgIGNvbnN0IGNo YXIqIGZ1bmN0aW9uTmFtZSwKKyAgICBHQzNEc2l6ZWkgd2lkdGgsIEdDM0RzaXplaSBoZWlnaHQs CisgICAgR0MzRGVudW0gZm9ybWF0LCB2b2lkKiBkYXRhLCB1bnNpZ25lZCBieXRlTGVuZ3RoKQog ewotICAgIGlmICghcGl4ZWxzKSB7CisgICAgaWYgKCFkYXRhKSB7CiAgICAgICAgIHN5bnRoZXNp emVHTEVycm9yKEdyYXBoaWNzQ29udGV4dDNEOjpJTlZBTElEX1ZBTFVFLCBmdW5jdGlvbk5hbWUs ICJubyBwaXhlbHMiKTsKICAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgIH0KQEAgLTUxNjEsNyAr NTEyNSw3IEBAIGJvb2wgV2ViR0xSZW5kZXJpbmdDb250ZXh0Ojp2YWxpZGF0ZUNvbXByZXNzZWRU ZXhGdW5jRGF0YShjb25zdCBjaGFyKiBmdW5jdGlvbk5hCiAgICAgICAgIHJldHVybiBmYWxzZTsK ICAgICB9CiAKLSAgICBpZiAocGl4ZWxzLT5ieXRlTGVuZ3RoKCkgIT0gYnl0ZXNSZXF1aXJlZCkg eworICAgIGlmIChieXRlTGVuZ3RoICE9IGJ5dGVzUmVxdWlyZWQpIHsKICAgICAgICAgc3ludGhl c2l6ZUdMRXJyb3IoR3JhcGhpY3NDb250ZXh0M0Q6OklOVkFMSURfVkFMVUUsIGZ1bmN0aW9uTmFt ZSwgImxlbmd0aCBvZiBBcnJheUJ1ZmZlclZpZXcgaXMgbm90IGNvcnJlY3QgZm9yIGRpbWVuc2lv bnMiKTsKICAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL2h0bWwvY2FudmFzL1dlYkdMUmVuZGVyaW5nQ29udGV4dC5oIGIvU291cmNlL1dlYkNv cmUvaHRtbC9jYW52YXMvV2ViR0xSZW5kZXJpbmdDb250ZXh0LmgKaW5kZXggNWIwZmI5MTJmODIy YmEyOGNjMTVjYTRiMWQzZmQwNzU5N2NjOWVjNy4uNjc1ZDY3OTBjNDI3MzNmY2YyZWVkYTIxN2Rl OTQ2NjdiMTc3ZjYxYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9jYW52YXMvV2Vi R0xSZW5kZXJpbmdDb250ZXh0LmgKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9jYW52YXMvV2Vi R0xSZW5kZXJpbmdDb250ZXh0LmgKQEAgLTEwMSwxMCArMTAxLDEwIEBAIHB1YmxpYzoKICAgICB2 b2lkIGJsZW5kRnVuY1NlcGFyYXRlKEdDM0RlbnVtIHNyY1JHQiwgR0MzRGVudW0gZHN0UkdCLCBH QzNEZW51bSBzcmNBbHBoYSwgR0MzRGVudW0gZHN0QWxwaGEpOwogCiAgICAgdm9pZCBidWZmZXJE YXRhKEdDM0RlbnVtIHRhcmdldCwgbG9uZyBsb25nIHNpemUsIEdDM0RlbnVtIHVzYWdlLCBFeGNl cHRpb25Db2RlJik7Ci0gICAgdm9pZCBidWZmZXJEYXRhKEdDM0RlbnVtIHRhcmdldCwgQXJyYXlC dWZmZXIqIGRhdGEsIEdDM0RlbnVtIHVzYWdlLCBFeGNlcHRpb25Db2RlJik7Ci0gICAgdm9pZCBi dWZmZXJEYXRhKEdDM0RlbnVtIHRhcmdldCwgQXJyYXlCdWZmZXJWaWV3KiBkYXRhLCBHQzNEZW51 bSB1c2FnZSwgRXhjZXB0aW9uQ29kZSYpOwotICAgIHZvaWQgYnVmZmVyU3ViRGF0YShHQzNEZW51 bSB0YXJnZXQsIGxvbmcgbG9uZyBvZmZzZXQsIEFycmF5QnVmZmVyKiBkYXRhLCBFeGNlcHRpb25D b2RlJik7Ci0gICAgdm9pZCBidWZmZXJTdWJEYXRhKEdDM0RlbnVtIHRhcmdldCwgbG9uZyBsb25n IG9mZnNldCwgQXJyYXlCdWZmZXJWaWV3KiBkYXRhLCBFeGNlcHRpb25Db2RlJik7CisgICAgdm9p ZCBidWZmZXJEYXRhKEdDM0RlbnVtIHRhcmdldCwgdm9pZCogZGF0YSwgdW5zaWduZWQgYnl0ZUxl bmd0aCwgR0MzRGVudW0gdXNhZ2UsIEV4Y2VwdGlvbkNvZGUmKTsKKyAgICB2b2lkIGJ1ZmZlckRh dGEoR0MzRGVudW0gdGFyZ2V0LCB2b2lkKiBkYXRhLCB1bnNpZ25lZCBieXRlTGVuZ3RoLCBBcnJh eUJ1ZmZlclZpZXc6OlZpZXdUeXBlLCBHQzNEZW51bSB1c2FnZSwgRXhjZXB0aW9uQ29kZSYpOwor ICAgIHZvaWQgYnVmZmVyU3ViRGF0YShHQzNEZW51bSB0YXJnZXQsIGxvbmcgbG9uZyBvZmZzZXQs IHZvaWQqIGRhdGEsIHVuc2lnbmVkIGJ5dGVMZW5ndGgsIEV4Y2VwdGlvbkNvZGUmKTsKKyAgICB2 b2lkIGJ1ZmZlclN1YkRhdGEoR0MzRGVudW0gdGFyZ2V0LCBsb25nIGxvbmcgb2Zmc2V0LCB2b2lk KiBkYXRhLCB1bnNpZ25lZCBieXRlTGVuZ3RoLCBBcnJheUJ1ZmZlclZpZXc6OlZpZXdUeXBlLCBF eGNlcHRpb25Db2RlJik7CiAKICAgICBHQzNEZW51bSBjaGVja0ZyYW1lYnVmZmVyU3RhdHVzKEdD M0RlbnVtIHRhcmdldCk7CiAgICAgdm9pZCBjbGVhcihHQzNEYml0ZmllbGQgbWFzayk7CkBAIC0x MTQsMTAgKzExNCwxMiBAQCBwdWJsaWM6CiAgICAgdm9pZCBjb2xvck1hc2soR0MzRGJvb2xlYW4g cmVkLCBHQzNEYm9vbGVhbiBncmVlbiwgR0MzRGJvb2xlYW4gYmx1ZSwgR0MzRGJvb2xlYW4gYWxw aGEpOwogICAgIHZvaWQgY29tcGlsZVNoYWRlcihXZWJHTFNoYWRlciosIEV4Y2VwdGlvbkNvZGUm KTsKIAotICAgIHZvaWQgY29tcHJlc3NlZFRleEltYWdlMkQoR0MzRGVudW0gdGFyZ2V0LCBHQzNE aW50IGxldmVsLCBHQzNEZW51bSBpbnRlcm5hbGZvcm1hdCwgR0MzRHNpemVpIHdpZHRoLAotICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgR0MzRHNpemVpIGhlaWdodCwgR0MzRGludCBib3Jk ZXIsIEFycmF5QnVmZmVyVmlldyogZGF0YSk7Ci0gICAgdm9pZCBjb21wcmVzc2VkVGV4U3ViSW1h Z2UyRChHQzNEZW51bSB0YXJnZXQsIEdDM0RpbnQgbGV2ZWwsIEdDM0RpbnQgeG9mZnNldCwgR0Mz RGludCB5b2Zmc2V0LAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR0MzRHNpemVp IHdpZHRoLCBHQzNEc2l6ZWkgaGVpZ2h0LCBHQzNEZW51bSBmb3JtYXQsIEFycmF5QnVmZmVyVmll dyogZGF0YSk7CisgICAgdm9pZCBjb21wcmVzc2VkVGV4SW1hZ2UyRCgKKyAgICAgICAgR0MzRGVu dW0gdGFyZ2V0LCBHQzNEaW50IGxldmVsLCBHQzNEZW51bSBpbnRlcm5hbGZvcm1hdCwgR0MzRHNp emVpIHdpZHRoLAorICAgICAgICBHQzNEc2l6ZWkgaGVpZ2h0LCBHQzNEaW50IGJvcmRlciwgdm9p ZCogZGF0YSwgdW5zaWduZWQgYnl0ZUxlbmd0aCwgQXJyYXlCdWZmZXJWaWV3OjpWaWV3VHlwZSk7 CisgICAgdm9pZCBjb21wcmVzc2VkVGV4U3ViSW1hZ2UyRCgKKyAgICAgICAgR0MzRGVudW0gdGFy Z2V0LCBHQzNEaW50IGxldmVsLCBHQzNEaW50IHhvZmZzZXQsIEdDM0RpbnQgeW9mZnNldCwKKyAg ICAgICAgR0MzRHNpemVpIHdpZHRoLCBHQzNEc2l6ZWkgaGVpZ2h0LCBHQzNEZW51bSBmb3JtYXQs IHZvaWQqIGRhdGEsIHVuc2lnbmVkIGJ5dGVMZW5ndGgsIEFycmF5QnVmZmVyVmlldzo6Vmlld1R5 cGUpOwogCiAgICAgdm9pZCBjb3B5VGV4SW1hZ2UyRChHQzNEZW51bSB0YXJnZXQsIEdDM0RpbnQg bGV2ZWwsIEdDM0RlbnVtIGludGVybmFsZm9ybWF0LCBHQzNEaW50IHgsIEdDM0RpbnQgeSwgR0Mz RHNpemVpIHdpZHRoLCBHQzNEc2l6ZWkgaGVpZ2h0LCBHQzNEaW50IGJvcmRlcik7CiAgICAgdm9p ZCBjb3B5VGV4U3ViSW1hZ2UyRChHQzNEZW51bSB0YXJnZXQsIEdDM0RpbnQgbGV2ZWwsIEdDM0Rp bnQgeG9mZnNldCwgR0MzRGludCB5b2Zmc2V0LCBHQzNEaW50IHgsIEdDM0RpbnQgeSwgR0MzRHNp emVpIHdpZHRoLCBHQzNEc2l6ZWkgaGVpZ2h0KTsKQEAgLTE5NCw3ICsxOTYsNyBAQCBwdWJsaWM6 CiAgICAgdm9pZCBsaW5rUHJvZ3JhbShXZWJHTFByb2dyYW0qLCBFeGNlcHRpb25Db2RlJik7CiAg ICAgdm9pZCBwaXhlbFN0b3JlaShHQzNEZW51bSBwbmFtZSwgR0MzRGludCBwYXJhbSk7CiAgICAg dm9pZCBwb2x5Z29uT2Zmc2V0KEdDM0RmbG9hdCBmYWN0b3IsIEdDM0RmbG9hdCB1bml0cyk7Ci0g ICAgdm9pZCByZWFkUGl4ZWxzKEdDM0RpbnQgeCwgR0MzRGludCB5LCBHQzNEc2l6ZWkgd2lkdGgs IEdDM0RzaXplaSBoZWlnaHQsIEdDM0RlbnVtIGZvcm1hdCwgR0MzRGVudW0gdHlwZSwgQXJyYXlC dWZmZXJWaWV3KiBwaXhlbHMsIEV4Y2VwdGlvbkNvZGUmKTsKKyAgICB2b2lkIHJlYWRQaXhlbHMo R0MzRGludCB4LCBHQzNEaW50IHksIEdDM0RzaXplaSB3aWR0aCwgR0MzRHNpemVpIGhlaWdodCwg R0MzRGVudW0gZm9ybWF0LCBHQzNEZW51bSB0eXBlLCB2b2lkKiBkYXRhLCB1bnNpZ25lZCBieXRl TGVuZ3RoLCBBcnJheUJ1ZmZlclZpZXc6OlZpZXdUeXBlLCBFeGNlcHRpb25Db2RlJik7CiAgICAg dm9pZCByZWxlYXNlU2hhZGVyQ29tcGlsZXIoKTsKICAgICB2b2lkIHJlbmRlcmJ1ZmZlclN0b3Jh Z2UoR0MzRGVudW0gdGFyZ2V0LCBHQzNEZW51bSBpbnRlcm5hbGZvcm1hdCwgR0MzRHNpemVpIHdp ZHRoLCBHQzNEc2l6ZWkgaGVpZ2h0KTsKICAgICB2b2lkIHNhbXBsZUNvdmVyYWdlKEdDM0RmbG9h dCB2YWx1ZSwgR0MzRGJvb2xlYW4gaW52ZXJ0KTsKQEAgLTIwOSw3ICsyMTEsNyBAQCBwdWJsaWM6 CiAKICAgICB2b2lkIHRleEltYWdlMkQoR0MzRGVudW0gdGFyZ2V0LCBHQzNEaW50IGxldmVsLCBH QzNEZW51bSBpbnRlcm5hbGZvcm1hdCwKICAgICAgICAgICAgICAgICAgICAgR0MzRHNpemVpIHdp ZHRoLCBHQzNEc2l6ZWkgaGVpZ2h0LCBHQzNEaW50IGJvcmRlciwKLSAgICAgICAgICAgICAgICAg ICAgR0MzRGVudW0gZm9ybWF0LCBHQzNEZW51bSB0eXBlLCBBcnJheUJ1ZmZlclZpZXcqLCBFeGNl cHRpb25Db2RlJik7CisgICAgICAgICAgICAgICAgICAgIEdDM0RlbnVtIGZvcm1hdCwgR0MzRGVu dW0gdHlwZSwgdm9pZCogZGF0YSwgdW5zaWduZWQgYnl0ZUxlbmd0aCwgQXJyYXlCdWZmZXJWaWV3 OjpWaWV3VHlwZSwgRXhjZXB0aW9uQ29kZSYpOwogICAgIHZvaWQgdGV4SW1hZ2UyRChHQzNEZW51 bSB0YXJnZXQsIEdDM0RpbnQgbGV2ZWwsIEdDM0RlbnVtIGludGVybmFsZm9ybWF0LAogICAgICAg ICAgICAgICAgICAgICBHQzNEZW51bSBmb3JtYXQsIEdDM0RlbnVtIHR5cGUsIEltYWdlRGF0YSos IEV4Y2VwdGlvbkNvZGUmKTsKICAgICB2b2lkIHRleEltYWdlMkQoR0MzRGVudW0gdGFyZ2V0LCBH QzNEaW50IGxldmVsLCBHQzNEZW51bSBpbnRlcm5hbGZvcm1hdCwKQEAgLTIyNCw5ICsyMjYsMTAg QEAgcHVibGljOgogICAgIHZvaWQgdGV4UGFyYW1ldGVyZihHQzNEZW51bSB0YXJnZXQsIEdDM0Rl bnVtIHBuYW1lLCBHQzNEZmxvYXQgcGFyYW0pOwogICAgIHZvaWQgdGV4UGFyYW1ldGVyaShHQzNE ZW51bSB0YXJnZXQsIEdDM0RlbnVtIHBuYW1lLCBHQzNEaW50IHBhcmFtKTsKIAotICAgIHZvaWQg dGV4U3ViSW1hZ2UyRChHQzNEZW51bSB0YXJnZXQsIEdDM0RpbnQgbGV2ZWwsIEdDM0RpbnQgeG9m ZnNldCwgR0MzRGludCB5b2Zmc2V0LAotICAgICAgICAgICAgICAgICAgICAgICBHQzNEc2l6ZWkg d2lkdGgsIEdDM0RzaXplaSBoZWlnaHQsCi0gICAgICAgICAgICAgICAgICAgICAgIEdDM0RlbnVt IGZvcm1hdCwgR0MzRGVudW0gdHlwZSwgQXJyYXlCdWZmZXJWaWV3KiwgRXhjZXB0aW9uQ29kZSYp OworICAgIHZvaWQgdGV4U3ViSW1hZ2UyRCgKKyAgICAgICAgR0MzRGVudW0gdGFyZ2V0LCBHQzNE aW50IGxldmVsLCBHQzNEaW50IHhvZmZzZXQsIEdDM0RpbnQgeW9mZnNldCwKKyAgICAgICAgR0Mz RHNpemVpIHdpZHRoLCBHQzNEc2l6ZWkgaGVpZ2h0LAorICAgICAgICBHQzNEZW51bSBmb3JtYXQs IEdDM0RlbnVtIHR5cGUsIHZvaWQqIGRhdGEsIHVuc2lnbmVkIGJ5dGVMZW5ndGgsIEFycmF5QnVm ZmVyVmlldzo6Vmlld1R5cGUsIEV4Y2VwdGlvbkNvZGUmKTsKICAgICB2b2lkIHRleFN1YkltYWdl MkQoR0MzRGVudW0gdGFyZ2V0LCBHQzNEaW50IGxldmVsLCBHQzNEaW50IHhvZmZzZXQsIEdDM0Rp bnQgeW9mZnNldCwKICAgICAgICAgICAgICAgICAgICAgICAgR0MzRGVudW0gZm9ybWF0LCBHQzNE ZW51bSB0eXBlLCBJbWFnZURhdGEqLCBFeGNlcHRpb25Db2RlJik7CiAgICAgdm9pZCB0ZXhTdWJJ bWFnZTJEKEdDM0RlbnVtIHRhcmdldCwgR0MzRGludCBsZXZlbCwgR0MzRGludCB4b2Zmc2V0LCBH QzNEaW50IHlvZmZzZXQsCkBAIC02MDcsMTEgKzYxMCwxNCBAQCBwdWJsaWM6CiAgICAgLy8gSGVs cGVyIGZ1bmN0aW9uIHRvIHZhbGlkYXRlIHRoYXQgdGhlIGdpdmVuIEFycmF5QnVmZmVyVmlldwog ICAgIC8vIGlzIG9mIHRoZSBjb3JyZWN0IHR5cGUgYW5kIGNvbnRhaW5zIGVub3VnaCBkYXRhIGZv ciB0aGUgdGV4SW1hZ2UgY2FsbC4KICAgICAvLyBHZW5lcmF0ZXMgR0wgZXJyb3IgYW5kIHJldHVy bnMgZmFsc2UgaWYgcGFyYW1ldGVycyBhcmUgaW52YWxpZC4KLSAgICBib29sIHZhbGlkYXRlVGV4 RnVuY0RhdGEoY29uc3QgY2hhciogZnVuY3Rpb25OYW1lLCBHQzNEaW50IGxldmVsLAotICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBHQzNEc2l6ZWkgd2lkdGgsIEdDM0RzaXplaSBoZWlnaHQs Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgIEdDM0RlbnVtIGZvcm1hdCwgR0MzRGVudW0g dHlwZSwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQXJyYXlCdWZmZXJWaWV3KiBwaXhl bHMsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgIE51bGxEaXNwb3NpdGlvbik7CisgICAg Ym9vbCB2YWxpZGF0ZVRleEZ1bmNEYXRhKAorICAgICAgICBjb25zdCBjaGFyKiBmdW5jdGlvbk5h bWUsIEdDM0RpbnQgbGV2ZWwsCisgICAgICAgIEdDM0RzaXplaSB3aWR0aCwgR0MzRHNpemVpIGhl aWdodCwKKyAgICAgICAgR0MzRGVudW0gZm9ybWF0LCBHQzNEZW51bSB0eXBlLAorICAgICAgICB2 b2lkKiBkYXRhLAorICAgICAgICB1bnNpZ25lZCBieXRlTGVuZ3RoLAorICAgICAgICBBcnJheUJ1 ZmZlclZpZXc6OlZpZXdUeXBlLAorICAgICAgICBOdWxsRGlzcG9zaXRpb24pOwogCiAgICAgLy8g SGVscGVyIGZ1bmN0aW9uIHRvIHZhbGlkYXRlIGEgZ2l2ZW4gdGV4dHVyZSBmb3JtYXQgaXMgc2V0 dGFibGUgYXMgaW4KICAgICAvLyB5b3UgY2FuIHN1cHBseSBkYXRhIHRvIHRleEltYWdlMkQsIG9y IGNhbGwgdGV4SW1hZ2UyRCwgY29weVRleEltYWdlMkQgYW5kCkBAIC02MjEsOSArNjI3LDEwIEBA IHB1YmxpYzoKIAogICAgIC8vIEhlbHBlciBmdW5jdGlvbiB0byB2YWxpZGF0ZSBjb21wcmVzc2Vk IHRleHR1cmUgZGF0YSBpcyBjb3JyZWN0IHNpemUKICAgICAvLyBmb3IgdGhlIGdpdmVuIGZvcm1h dCBhbmQgZGltZW5zaW9ucy4KLSAgICBib29sIHZhbGlkYXRlQ29tcHJlc3NlZFRleEZ1bmNEYXRh KGNvbnN0IGNoYXIqIGZ1bmN0aW9uTmFtZSwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIEdDM0RzaXplaSB3aWR0aCwgR0MzRHNpemVpIGhlaWdodCwKLSAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIEdDM0RlbnVtIGZvcm1hdCwgQXJyYXlCdWZmZXJW aWV3KiBwaXhlbHMpOworICAgIGJvb2wgdmFsaWRhdGVDb21wcmVzc2VkVGV4RnVuY0RhdGEoCisg ICAgICAgIGNvbnN0IGNoYXIqIGZ1bmN0aW9uTmFtZSwKKyAgICAgICAgR0MzRHNpemVpIHdpZHRo LCBHQzNEc2l6ZWkgaGVpZ2h0LAorICAgICAgICBHQzNEZW51bSBmb3JtYXQsIHZvaWQqIGRhdGEs IHVuc2lnbmVkIGJ5dGVMZW5ndGgpOwogCiAgICAgLy8gSGVscGVyIGZ1bmN0aW9uIGZvciB2YWxp ZGF0aW5nIGNvbXByZXNzZWQgdGV4dHVyZSBmb3JtYXRzLgogICAgIGJvb2wgdmFsaWRhdGVDb21w cmVzc2VkVGV4Rm9ybWF0KEdDM0RlbnVtIGZvcm1hdCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9odG1sL2NhbnZhcy9XZWJHTFJlbmRlcmluZ0NvbnRleHQuaWRsIGIvU291cmNlL1dlYkNv cmUvaHRtbC9jYW52YXMvV2ViR0xSZW5kZXJpbmdDb250ZXh0LmlkbAppbmRleCBmYzgwMTEwYzc2 MWI4OTc4NTc3NmJlNzY5MzA2YTMzZmYzYjFmZWI3Li5iNmY1ZTQ2MGM4OWNkMmVlNWNhNDEwMWVj MzQ1MTdjY2NiZGYzNTUxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL2NhbnZhcy9X ZWJHTFJlbmRlcmluZ0NvbnRleHQuaWRsCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvY2FudmFz L1dlYkdMUmVuZGVyaW5nQ29udGV4dC5pZGwKQEAgLTQ1OSwxMSArNDU5LDExIEBACiAgICAgW1N0 cmljdFR5cGVDaGVja2luZ10gdm9pZCAgICAgICAgIGJsZW5kRXF1YXRpb25TZXBhcmF0ZShpbiB1 bnNpZ25lZCBsb25nIG1vZGVSR0IsIGluIHVuc2lnbmVkIGxvbmcgbW9kZUFscGhhKTsKICAgICBb U3RyaWN0VHlwZUNoZWNraW5nXSB2b2lkICAgICAgICAgYmxlbmRGdW5jKGluIHVuc2lnbmVkIGxv bmcgc2ZhY3RvciwgaW4gdW5zaWduZWQgbG9uZyBkZmFjdG9yKTsKICAgICBbU3RyaWN0VHlwZUNo ZWNraW5nXSB2b2lkICAgICAgICAgYmxlbmRGdW5jU2VwYXJhdGUoaW4gdW5zaWduZWQgbG9uZyBz cmNSR0IsIGluIHVuc2lnbmVkIGxvbmcgZHN0UkdCLCBpbiB1bnNpZ25lZCBsb25nIHNyY0FscGhh LCBpbiB1bnNpZ25lZCBsb25nIGRzdEFscGhhKTsKLSAgICBbU3RyaWN0VHlwZUNoZWNraW5nXSB2 b2lkICAgICAgICAgYnVmZmVyRGF0YShpbiB1bnNpZ25lZCBsb25nIHRhcmdldCwgaW4gQXJyYXlC dWZmZXI/IGRhdGEsIGluIHVuc2lnbmVkIGxvbmcgdXNhZ2UpIHJhaXNlcyAoRE9NRXhjZXB0aW9u KTsKLSAgICBbU3RyaWN0VHlwZUNoZWNraW5nXSB2b2lkICAgICAgICAgYnVmZmVyRGF0YShpbiB1 bnNpZ25lZCBsb25nIHRhcmdldCwgaW4gQXJyYXlCdWZmZXJWaWV3PyBkYXRhLCBpbiB1bnNpZ25l ZCBsb25nIHVzYWdlKSByYWlzZXMgKERPTUV4Y2VwdGlvbik7CisgICAgW1N0cmljdFR5cGVDaGVj a2luZyxEb2VzTm90UmV0YWluVHlwZWRBcnJheXNdIHZvaWQgYnVmZmVyRGF0YShpbiB1bnNpZ25l ZCBsb25nIHRhcmdldCwgaW4gQXJyYXlCdWZmZXI/IGRhdGEsIGluIHVuc2lnbmVkIGxvbmcgdXNh Z2UpIHJhaXNlcyAoRE9NRXhjZXB0aW9uKTsKKyAgICBbU3RyaWN0VHlwZUNoZWNraW5nLERvZXNO b3RSZXRhaW5UeXBlZEFycmF5c10gdm9pZCBidWZmZXJEYXRhKGluIHVuc2lnbmVkIGxvbmcgdGFy Z2V0LCBpbiBBcnJheUJ1ZmZlclZpZXc/IGRhdGEsIGluIHVuc2lnbmVkIGxvbmcgdXNhZ2UpIHJh aXNlcyAoRE9NRXhjZXB0aW9uKTsKICAgICBbU3RyaWN0VHlwZUNoZWNraW5nXSB2b2lkICAgICAg ICAgYnVmZmVyRGF0YShpbiB1bnNpZ25lZCBsb25nIHRhcmdldCwgaW4gbG9uZyBsb25nIHNpemUs IGluIHVuc2lnbmVkIGxvbmcgdXNhZ2UpIHJhaXNlcyAoRE9NRXhjZXB0aW9uKTsKLSAgICBbU3Ry aWN0VHlwZUNoZWNraW5nXSB2b2lkICAgICAgICAgYnVmZmVyU3ViRGF0YShpbiB1bnNpZ25lZCBs b25nIHRhcmdldCwgaW4gbG9uZyBsb25nIG9mZnNldCwgaW4gQXJyYXlCdWZmZXI/IGRhdGEpIHJh aXNlcyAoRE9NRXhjZXB0aW9uKTsKLSAgICBbU3RyaWN0VHlwZUNoZWNraW5nXSB2b2lkICAgICAg ICAgYnVmZmVyU3ViRGF0YShpbiB1bnNpZ25lZCBsb25nIHRhcmdldCwgaW4gbG9uZyBsb25nIG9m ZnNldCwgaW4gQXJyYXlCdWZmZXJWaWV3PyBkYXRhKSByYWlzZXMgKERPTUV4Y2VwdGlvbik7Cisg ICAgW1N0cmljdFR5cGVDaGVja2luZyxEb2VzTm90UmV0YWluVHlwZWRBcnJheXNdIHZvaWQgICAg ICAgICBidWZmZXJTdWJEYXRhKGluIHVuc2lnbmVkIGxvbmcgdGFyZ2V0LCBpbiBsb25nIGxvbmcg b2Zmc2V0LCBpbiBBcnJheUJ1ZmZlcj8gZGF0YSkgcmFpc2VzIChET01FeGNlcHRpb24pOworICAg IFtTdHJpY3RUeXBlQ2hlY2tpbmcsRG9lc05vdFJldGFpblR5cGVkQXJyYXlzXSB2b2lkICAgICAg ICAgYnVmZmVyU3ViRGF0YShpbiB1bnNpZ25lZCBsb25nIHRhcmdldCwgaW4gbG9uZyBsb25nIG9m ZnNldCwgaW4gQXJyYXlCdWZmZXJWaWV3PyBkYXRhKSByYWlzZXMgKERPTUV4Y2VwdGlvbik7CiAK ICAgICBbU3RyaWN0VHlwZUNoZWNraW5nXSB1bnNpZ25lZCBsb25nIGNoZWNrRnJhbWVidWZmZXJT dGF0dXMoaW4gdW5zaWduZWQgbG9uZyB0YXJnZXQpOwogICAgIFtTdHJpY3RUeXBlQ2hlY2tpbmdd IHZvaWQgICAgICAgICBjbGVhcihpbiB1bnNpZ25lZCBsb25nIG1hc2spOwpAQCAtNDczLDEwICs0 NzMsMTAgQEAKICAgICBbU3RyaWN0VHlwZUNoZWNraW5nXSB2b2lkICAgICAgICAgY29sb3JNYXNr KGluIGJvb2xlYW4gcmVkLCBpbiBib29sZWFuIGdyZWVuLCBpbiBib29sZWFuIGJsdWUsIGluIGJv b2xlYW4gYWxwaGEpOwogICAgIFtTdHJpY3RUeXBlQ2hlY2tpbmddIHZvaWQgICAgICAgICBjb21w aWxlU2hhZGVyKGluIFdlYkdMU2hhZGVyIHNoYWRlcikgcmFpc2VzKERPTUV4Y2VwdGlvbik7CiAK LSAgICBbU3RyaWN0VHlwZUNoZWNraW5nXSB2b2lkICAgICAgICAgY29tcHJlc3NlZFRleEltYWdl MkQoaW4gdW5zaWduZWQgbG9uZyB0YXJnZXQsIGluIGxvbmcgbGV2ZWwsIGluIHVuc2lnbmVkIGxv bmcgaW50ZXJuYWxmb3JtYXQsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIGluIGxvbmcgd2lkdGgsIGluIGxvbmcgaGVpZ2h0LCBpbiBs b25nIGJvcmRlciwgaW4gQXJyYXlCdWZmZXJWaWV3IGRhdGEpOwotICAgIFtTdHJpY3RUeXBlQ2hl Y2tpbmddIHZvaWQgICAgICAgICBjb21wcmVzc2VkVGV4U3ViSW1hZ2UyRChpbiB1bnNpZ25lZCBs b25nIHRhcmdldCwgaW4gbG9uZyBsZXZlbCwgaW4gbG9uZyB4b2Zmc2V0LCBpbiBsb25nIHlvZmZz ZXQsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIGluIGxvbmcgd2lkdGgsIGluIGxvbmcgaGVpZ2h0LCBpbiB1bnNpZ25lZCBsb25n IGZvcm1hdCwgaW4gQXJyYXlCdWZmZXJWaWV3IGRhdGEpOworICAgIFtTdHJpY3RUeXBlQ2hlY2tp bmcsRG9lc05vdFJldGFpblR5cGVkQXJyYXlzXSB2b2lkIGNvbXByZXNzZWRUZXhJbWFnZTJEKGlu IHVuc2lnbmVkIGxvbmcgdGFyZ2V0LCBpbiBsb25nIGxldmVsLCBpbiB1bnNpZ25lZCBsb25nIGlu dGVybmFsZm9ybWF0LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGluIGxvbmcgd2lkdGgsIGluIGxvbmcg aGVpZ2h0LCBpbiBsb25nIGJvcmRlciwgaW4gQXJyYXlCdWZmZXJWaWV3IGRhdGEpOworICAgIFtT dHJpY3RUeXBlQ2hlY2tpbmcsRG9lc05vdFJldGFpblR5cGVkQXJyYXlzXSB2b2lkIGNvbXByZXNz ZWRUZXhTdWJJbWFnZTJEKGluIHVuc2lnbmVkIGxvbmcgdGFyZ2V0LCBpbiBsb25nIGxldmVsLCBp biBsb25nIHhvZmZzZXQsIGluIGxvbmcgeW9mZnNldCwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBp biBsb25nIHdpZHRoLCBpbiBsb25nIGhlaWdodCwgaW4gdW5zaWduZWQgbG9uZyBmb3JtYXQsIGlu IEFycmF5QnVmZmVyVmlldyBkYXRhKTsKICAgICAKICAgICBbU3RyaWN0VHlwZUNoZWNraW5nXSB2 b2lkICAgICAgICAgY29weVRleEltYWdlMkQoaW4gdW5zaWduZWQgbG9uZyB0YXJnZXQsIGluIGxv bmcgbGV2ZWwsIGluIHVuc2lnbmVkIGxvbmcgaW50ZXJuYWxmb3JtYXQsIGluIGxvbmcgeCwgaW4g bG9uZyB5LCBpbiBsb25nIHdpZHRoLCBpbiBsb25nIGhlaWdodCwgaW4gbG9uZyBib3JkZXIpOwog ICAgIFtTdHJpY3RUeXBlQ2hlY2tpbmddIHZvaWQgICAgICAgICBjb3B5VGV4U3ViSW1hZ2UyRChp biB1bnNpZ25lZCBsb25nIHRhcmdldCwgaW4gbG9uZyBsZXZlbCwgaW4gbG9uZyB4b2Zmc2V0LCBp biBsb25nIHlvZmZzZXQsIGluIGxvbmcgeCwgaW4gbG9uZyB5LCBpbiBsb25nIHdpZHRoLCBpbiBs b25nIGhlaWdodCk7CkBAIC01ODAsNyArNTgwLDcgQEAKICAgICBbU3RyaWN0VHlwZUNoZWNraW5n XSB2b2lkICAgICAgICAgcGl4ZWxTdG9yZWkoaW4gdW5zaWduZWQgbG9uZyBwbmFtZSwgaW4gbG9u ZyBwYXJhbSk7CiAgICAgW1N0cmljdFR5cGVDaGVja2luZ10gdm9pZCAgICAgICAgIHBvbHlnb25P ZmZzZXQoaW4gZmxvYXQgZmFjdG9yLCBpbiBmbG9hdCB1bml0cyk7CiAKLSAgICBbU3RyaWN0VHlw ZUNoZWNraW5nXSB2b2lkICAgICAgICAgcmVhZFBpeGVscyhpbiBsb25nIHgsIGluIGxvbmcgeSwg aW4gbG9uZyB3aWR0aCwgaW4gbG9uZyBoZWlnaHQsIGluIHVuc2lnbmVkIGxvbmcgZm9ybWF0LCBp biB1bnNpZ25lZCBsb25nIHR5cGUsIGluIEFycmF5QnVmZmVyVmlldyBwaXhlbHMpIHJhaXNlcyhE T01FeGNlcHRpb24pOworICAgIFtTdHJpY3RUeXBlQ2hlY2tpbmcsRG9lc05vdFJldGFpblR5cGVk QXJyYXlzXSB2b2lkIHJlYWRQaXhlbHMoaW4gbG9uZyB4LCBpbiBsb25nIHksIGluIGxvbmcgd2lk dGgsIGluIGxvbmcgaGVpZ2h0LCBpbiB1bnNpZ25lZCBsb25nIGZvcm1hdCwgaW4gdW5zaWduZWQg bG9uZyB0eXBlLCBpbiBBcnJheUJ1ZmZlclZpZXcgcGl4ZWxzKSByYWlzZXMoRE9NRXhjZXB0aW9u KTsKICAgICAKICAgICBbU3RyaWN0VHlwZUNoZWNraW5nXSB2b2lkICAgICAgICAgcmVsZWFzZVNo YWRlckNvbXBpbGVyKCk7CiAgICAgW1N0cmljdFR5cGVDaGVja2luZ10gdm9pZCAgICAgICAgIHJl bmRlcmJ1ZmZlclN0b3JhZ2UoaW4gdW5zaWduZWQgbG9uZyB0YXJnZXQsIGluIHVuc2lnbmVkIGxv bmcgaW50ZXJuYWxmb3JtYXQsIGluIGxvbmcgd2lkdGgsIGluIGxvbmcgaGVpZ2h0KTsKQEAgLTU5 OCw4ICs1OTgsOCBAQAogICAgIFtTdHJpY3RUeXBlQ2hlY2tpbmddIHZvaWQgICAgICAgICB0ZXhQ YXJhbWV0ZXJpKGluIHVuc2lnbmVkIGxvbmcgdGFyZ2V0LCBpbiB1bnNpZ25lZCBsb25nIHBuYW1l LCBpbiBsb25nIHBhcmFtKTsKIAogICAgIC8vIFN1cHBvcnRlZCBmb3JtczoKLSAgICBbU3RyaWN0 VHlwZUNoZWNraW5nXSB2b2lkICAgICAgICAgdGV4SW1hZ2UyRChpbiB1bnNpZ25lZCBsb25nIHRh cmdldCwgaW4gbG9uZyBsZXZlbCwgaW4gdW5zaWduZWQgbG9uZyBpbnRlcm5hbGZvcm1hdCwgaW4g bG9uZyB3aWR0aCwgaW4gbG9uZyBoZWlnaHQsIAotICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIGluIGxvbmcgYm9yZGVyLCBpbiB1bnNpZ25lZCBsb25nIGZv cm1hdCwgaW4gdW5zaWduZWQgbG9uZyB0eXBlLCBpbiBBcnJheUJ1ZmZlclZpZXc/IHBpeGVscykg cmFpc2VzIChET01FeGNlcHRpb24pOworICAgIFtTdHJpY3RUeXBlQ2hlY2tpbmcsRG9lc05vdFJl dGFpblR5cGVkQXJyYXlzXSB2b2lkIHRleEltYWdlMkQoaW4gdW5zaWduZWQgbG9uZyB0YXJnZXQs IGluIGxvbmcgbGV2ZWwsIGluIHVuc2lnbmVkIGxvbmcgaW50ZXJuYWxmb3JtYXQsIGluIGxvbmcg d2lkdGgsIGluIGxvbmcgaGVpZ2h0LCAKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGluIGxvbmcgYm9yZGVyLCBpbiB1bnNp Z25lZCBsb25nIGZvcm1hdCwgaW4gdW5zaWduZWQgbG9uZyB0eXBlLCBpbiBBcnJheUJ1ZmZlclZp ZXc/IHBpeGVscykgcmFpc2VzIChET01FeGNlcHRpb24pOwogICAgIFtTdHJpY3RUeXBlQ2hlY2tp bmddIHZvaWQgICAgICAgICB0ZXhJbWFnZTJEKGluIHVuc2lnbmVkIGxvbmcgdGFyZ2V0LCBpbiBs b25nIGxldmVsLCBpbiB1bnNpZ25lZCBsb25nIGludGVybmFsZm9ybWF0LAogICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGluIHVuc2lnbmVkIGxvbmcgZm9y bWF0LCBpbiB1bnNpZ25lZCBsb25nIHR5cGUsIGluIEltYWdlRGF0YT8gcGl4ZWxzKSByYWlzZXMg KERPTUV4Y2VwdGlvbik7CiAgICAgW1N0cmljdFR5cGVDaGVja2luZ10gdm9pZCAgICAgICAgIHRl eEltYWdlMkQoaW4gdW5zaWduZWQgbG9uZyB0YXJnZXQsIGluIGxvbmcgbGV2ZWwsIGluIHVuc2ln bmVkIGxvbmcgaW50ZXJuYWxmb3JtYXQsCkBAIC02MTEsOSArNjExLDkgQEAKICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpbiB1bnNpZ25lZCBsb25nIGZv cm1hdCwgaW4gdW5zaWduZWQgbG9uZyB0eXBlLCBpbiBIVE1MVmlkZW9FbGVtZW50PyB2aWRlbykg cmFpc2VzIChET01FeGNlcHRpb24pOwogI2VuZGlmCiAKLSAgICBbU3RyaWN0VHlwZUNoZWNraW5n XSB2b2lkICAgICAgICAgdGV4U3ViSW1hZ2UyRChpbiB1bnNpZ25lZCBsb25nIHRhcmdldCwgaW4g bG9uZyBsZXZlbCwgaW4gbG9uZyB4b2Zmc2V0LCBpbiBsb25nIHlvZmZzZXQsIAotICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGluIGxvbmcgd2lkdGgs IGluIGxvbmcgaGVpZ2h0LCAKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBpbiB1bnNpZ25lZCBsb25nIGZvcm1hdCwgaW4gdW5zaWduZWQgbG9uZyB0 eXBlLCBpbiBBcnJheUJ1ZmZlclZpZXc/IHBpeGVscykgcmFpc2VzIChET01FeGNlcHRpb24pOwor ICAgIFtTdHJpY3RUeXBlQ2hlY2tpbmcsRG9lc05vdFJldGFpblR5cGVkQXJyYXlzXSB2b2lkIHRl eFN1YkltYWdlMkQoaW4gdW5zaWduZWQgbG9uZyB0YXJnZXQsIGluIGxvbmcgbGV2ZWwsIGluIGxv bmcgeG9mZnNldCwgaW4gbG9uZyB5b2Zmc2V0LCAKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGluIGxvbmcgd2lkdGgs IGluIGxvbmcgaGVpZ2h0LCAKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGluIHVuc2lnbmVkIGxvbmcgZm9ybWF0LCBp biB1bnNpZ25lZCBsb25nIHR5cGUsIGluIEFycmF5QnVmZmVyVmlldz8gcGl4ZWxzKSByYWlzZXMg KERPTUV4Y2VwdGlvbik7CiAgICAgW1N0cmljdFR5cGVDaGVja2luZ10gdm9pZCAgICAgICAgIHRl eFN1YkltYWdlMkQoaW4gdW5zaWduZWQgbG9uZyB0YXJnZXQsIGluIGxvbmcgbGV2ZWwsIGluIGxv bmcgeG9mZnNldCwgaW4gbG9uZyB5b2Zmc2V0LAogICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIGluIHVuc2lnbmVkIGxvbmcgZm9ybWF0LCBpbiB1bnNp Z25lZCBsb25nIHR5cGUsIGluIEltYWdlRGF0YT8gcGl4ZWxzKSByYWlzZXMgKERPTUV4Y2VwdGlv bik7CiAgICAgW1N0cmljdFR5cGVDaGVja2luZ10gdm9pZCAgICAgICAgIHRleFN1YkltYWdlMkQo aW4gdW5zaWduZWQgbG9uZyB0YXJnZXQsIGluIGxvbmcgbGV2ZWwsIGluIGxvbmcgeG9mZnNldCwg aW4gbG9uZyB5b2Zmc2V0LAo=