42405 2010-07-15 14:01:59 -0700 ANGLE integration for shader validator and compiler 2010-08-16 12:24:29 -0700 1 1 1 Unclassified WebKit WebGL 528+ (Nightly build) All All RESOLVED FIXED P2 Enhancement --- 43500 1 psawaya psawaya abarth adele cmarrin dglazkov eric kbr kenneth noam oliver psawaya sam vangelis webkit-ews webkit.review.bot zmo oldest_to_newest 252092 0 psawaya 2010-07-15 14:01:59 -0700 Need to integrate the ANGLE shader compiler into WebCore, which can validate GLSL shaders before they are compiled and executed. 252096 1 psawaya 2010-07-15 14:07:07 -0700 Will be used for shader validation (see Appendix A of http://www.khronos.org/registry/gles/specs/2.0/GLSL_ES_Specification_1.0.17.pdf). Also necessary for compiling shaders on windows. 259746 2 63388 psawaya 2010-08-03 16:46:11 -0700 Created attachment 63388 Patch to use ANGLE to compile shaders in WebGLRenderingContext 259999 3 63388 cmarrin 2010-08-04 06:30:57 -0700 Comment on attachment 63388 Patch to use ANGLE to compile shaders in WebGLRenderingContext > Index: WebCore/WebCore.xcodeproj/project.pbxproj > =================================================================== > --- WebCore/WebCore.xcodeproj/project.pbxproj (revision 64595) > +++ WebCore/WebCore.xcodeproj/project.pbxproj (working copy) > @@ -5235,6 +5235,8 @@ > FABE72FE1059C21100D999DD /* MathMLNames.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FABE72FC1059C21100D999DD /* MathMLNames.cpp */; }; > FAC12CC41120DA6900DACC36 /* RenderMathMLSubSup.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FAC12CC21120DA6900DACC36 /* RenderMathMLSubSup.cpp */; }; > FAC12CC51120DA6900DACC36 /* RenderMathMLSubSup.h in Headers */ = {isa = PBXBuildFile; fileRef = FAC12CC31120DA6900DACC36 /* RenderMathMLSubSup.h */; }; > + FBF281AF1208D35C00F7F812 /* ANGLEWebkitBridge.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FBF281AD1208D35C00F7F812 /* ANGLEWebkitBridge.cpp */; }; > + FBF281B01208D35C00F7F812 /* ANGLEWebkitBridge.h in Headers */ = {isa = PBXBuildFile; fileRef = FBF281AE1208D35C00F7F812 /* ANGLEWebkitBridge.h */; }; > FE6FD4880F676E5700092873 /* Coordinates.h in Headers */ = {isa = PBXBuildFile; fileRef = FE6FD4850F676E5700092873 /* Coordinates.h */; settings = {ATTRIBUTES = (Private, ); }; }; > FE6FD48D0F676E9300092873 /* JSCoordinates.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FE6FD48B0F676E9300092873 /* JSCoordinates.cpp */; }; > FE6FD48E0F676E9300092873 /* JSCoordinates.h in Headers */ = {isa = PBXBuildFile; fileRef = FE6FD48C0F676E9300092873 /* JSCoordinates.h */; }; > @@ -11002,6 +11004,8 @@ > FABE72FC1059C21100D999DD /* MathMLNames.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MathMLNames.cpp; sourceTree = "<group>"; }; > FAC12CC21120DA6900DACC36 /* RenderMathMLSubSup.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RenderMathMLSubSup.cpp; sourceTree = "<group>"; }; > FAC12CC31120DA6900DACC36 /* RenderMathMLSubSup.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RenderMathMLSubSup.h; sourceTree = "<group>"; }; > + FBF281AD1208D35C00F7F812 /* ANGLEWebkitBridge.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ANGLEWebkitBridge.cpp; sourceTree = "<group>"; }; > + FBF281AE1208D35C00F7F812 /* ANGLEWebkitBridge.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ANGLEWebkitBridge.h; sourceTree = "<group>"; }; > FE49EF970DC51462004266E1 /* DashboardSupportCSSPropertyNames.in */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = DashboardSupportCSSPropertyNames.in; sourceTree = "<group>"; }; > FE6FD4850F676E5700092873 /* Coordinates.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Coordinates.h; sourceTree = "<group>"; }; > FE6FD4860F676E5700092873 /* Coordinates.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Coordinates.idl; sourceTree = "<group>"; }; > @@ -15521,6 +15525,8 @@ > B27535490B053814002CE64F /* mac */, > F4EAF4AB10C74268009100D3 /* opentype */, > 49E911B20EF86D27009D0CAF /* transforms */, > + FBF281AD1208D35C00F7F812 /* ANGLEWebkitBridge.cpp */, > + FBF281AE1208D35C00F7F812 /* ANGLEWebkitBridge.h */, > A89943270B42338700D7C802 /* BitmapImage.cpp */, > A89943260B42338700D7C802 /* BitmapImage.h */, > B27535380B053814002CE64F /* Color.cpp */, > @@ -19983,6 +19989,7 @@ > D39D009D11F907E6006041F2 /* SearchPopupMenuMac.h in Headers */, > B61762541203374F00EF9114 /* IDBDatabaseBackendInterface.h in Headers */, > B61762621203490800EF9114 /* IDBDatabaseBackendImpl.h in Headers */, > + FBF281B01208D35C00F7F812 /* ANGLEWebkitBridge.h in Headers */, > ); > runOnlyForDeploymentPostprocessing = 0; > }; > @@ -20042,7 +20049,6 @@ > isa = PBXProject; > buildConfigurationList = 149C284308902B11008A9EFC /* Build configuration list for PBXProject "WebCore" */; > compatibilityVersion = "Xcode 2.4"; > - developmentRegion = English; > hasScannedForEncodings = 1; > knownRegions = ( > English, > @@ -22387,6 +22393,7 @@ > E1BE512D0CF6C512002EA959 /* XSLTUnicodeSort.cpp in Sources */, > 97DD4D860FDF4D6E00ECF9A4 /* XSSAuditor.cpp in Sources */, > C046E1AC1208A9FE00BA2CF7 /* LocalizedStrings.cpp in Sources */, > + FBF281AF1208D35C00F7F812 /* ANGLEWebkitBridge.cpp in Sources */, > ); > runOnlyForDeploymentPostprocessing = 0; > }; > Index: WebCore/html/canvas/WebGLRenderingContext.cpp > =================================================================== > --- WebCore/html/canvas/WebGLRenderingContext.cpp (revision 64595) > +++ WebCore/html/canvas/WebGLRenderingContext.cpp (working copy) > @@ -29,6 +29,7 @@ > > #include "WebGLRenderingContext.h" > > +#include "ANGLEWebkitBridge.h" > #include "CheckedInt.h" > #include "CanvasPixelArray.h" > #include "Console.h" > @@ -516,7 +517,10 @@ void WebGLRenderingContext::compileShade > UNUSED_PARAM(ec); > if (!validateWebGLObject(shader)) > return; > - m_context->compileShader(shader ? shader->object() : 0); > + > + if (ANGLEWebkitBridge::validateShader(shader,getShaderSource(shader,ec).utf8().data())) > + m_context->compileShader(shader ? shader->object() : 0); > + > cleanupAfterGraphicsCall(false); > } > > @@ -1561,7 +1565,12 @@ String WebGLRenderingContext::getShaderI > if (!validateWebGLObject(shader)) > return ""; > WebGLStateRestorer(this, false); > - return m_context->getShaderInfoLog(shader ? shader->object() : 0); > + > + // If the shader failed validation, return the ANGLE validation log instead > + if (shader->passedValidation()) > + return m_context->getShaderInfoLog(shader ? shader->object() : 0); > + else > + return shader->getValidatorLog(); > } > > String WebGLRenderingContext::getShaderSource(WebGLShader* shader, ExceptionCode& ec) > Index: WebCore/html/canvas/WebGLShader.cpp > =================================================================== > --- WebCore/html/canvas/WebGLShader.cpp (revision 64595) > +++ WebCore/html/canvas/WebGLShader.cpp (working copy) > @@ -38,8 +38,9 @@ PassRefPtr<WebGLShader> WebGLShader::cre > } > > WebGLShader::WebGLShader(WebGLRenderingContext* ctx, GraphicsContext3D::WebGLEnumType type) > - : CanvasObject(ctx) > - , m_type(type) > + : CanvasObject(ctx), > + m_type(type), > + m_validated(false) > { > setObject(context()->graphicsContext3D()->createShader(type)); > } > Index: WebCore/html/canvas/WebGLShader.h > =================================================================== > --- WebCore/html/canvas/WebGLShader.h (revision 64595) > +++ WebCore/html/canvas/WebGLShader.h (working copy) > @@ -28,6 +28,8 @@ > > #include "CanvasObject.h" > > +#include "PlatformString.h" > + > #include <wtf/PassRefPtr.h> > #include <wtf/RefCounted.h> > > @@ -36,11 +38,20 @@ namespace WebCore { > class WebGLShader : public CanvasObject { > public: > virtual ~WebGLShader() { deleteObject(); } > - > + > static PassRefPtr<WebGLShader> create(WebGLRenderingContext*, GraphicsContext3D::WebGLEnumType); > > GraphicsContext3D::WebGLEnumType getType() const { return m_type; } > > + bool passedValidation() { return m_validated; } > + void setValidated(bool validated) { m_validated = validated; } > + > + String getValidatorLog() { return m_validationLog; } > + void setValidatorLog(String messages) { m_validationLog = messages; } > + > + String getTranslatedSource() { return m_translatedSource; } > + void setTranslatedSource(String source) { m_translatedSource = source; } > + > private: > WebGLShader(WebGLRenderingContext*, GraphicsContext3D::WebGLEnumType); > > @@ -49,6 +60,13 @@ namespace WebCore { > virtual bool isShader() const { return true; } > > GraphicsContext3D::WebGLEnumType m_type; > + > + String m_validationLog; > + > + //Desktop GLSL source > + String m_translatedSource; > + > + bool m_validated; > }; > > } // namespace WebCore > Index: WebCore/platform/graphics/ANGLEWebkitBridge.cpp > =================================================================== > --- WebCore/platform/graphics/ANGLEWebkitBridge.cpp (revision 0) > +++ WebCore/platform/graphics/ANGLEWebkitBridge.cpp (revision 0) > @@ -0,0 +1,80 @@ > +/* > + * ANGLEWebkitBridge.cpp > + * WebCore > + * > + * Created by Paul Sawaya on 7/15/10. > + * Copyright 2010 Apple Inc. All rights reserved. > + * > + */ > + > +#include "config.h" > + > +#if ENABLE(3D_CANVAS) > + > +#include "ANGLEWebkitBridge.h" > + > +#include "ActiveDOMObject.h" > +#include "GraphicsContext3D.h" > +#include <OpenGL/gl.h> > +#include "ShaderLang.h" > +#include "WebGLShader.h" > + > +#include <wtf/text/CString.h> > + > +namespace WebCore { > + > + > +// Set up the per compile resources > +static void generateResources(TBuiltInResource& resources) > +{ > + resources.maxVertexAttribs = 8; > + resources.maxVertexUniformVectors = 128; > + resources.maxVaryingVectors = 8; > + resources.maxVertexTextureImageUnits = 0; > + resources.maxCombinedTextureImageUnits = 8; > + resources.maxTextureImageUnits = 8; > + resources.maxFragmentUniformVectors = 16; > + resources.maxDrawBuffers = 1; > +} > + > +bool ANGLEWebkitBridge::validateShader(WebGLShader* shader, const char* shaderSource) > +{ > + TBuiltInResource resources; > + EShLanguage shaderLang; > + ShHandle compiler; > + > + generateResources(resources); > + > +if (shader->getType() == GraphicsContext3D::VERTEX_SHADER) > + shaderLang = EShLangVertex; > + else if (shader->getType() == GraphicsContext3D::FRAGMENT_SHADER) > + shaderLang = EShLangFragment; > + else > + return false; // Invalid shader type > + > + ShInitialize(); > + > + compiler = ShConstructCompiler(shaderLang, EShSpecWebGL); > + > + const char* const shaderSourceStrings[] = {shaderSource}; > + > + bool validateSuccess = ShCompile(compiler, shaderSourceStrings, 1, EShOptNone, &resources, EDebugOpIntermediate); > + > + shader->setValidated(validateSuccess); > + > + if (validateSuccess) { > + shader->setTranslatedSource(ShGetObjectCode(compiler)); > + } > + else { > + // TODO: drop in ShGetValidatorLog once new patches are accepted by ANGLE > + shader->setValidatorLog("Validation failed."); > + } > + > + ShDestruct(compiler); > + > + return validateSuccess; > +} > + > +} > + > +#endif // ENABLE(3D_CANVAS) > Index: WebCore/platform/graphics/ANGLEWebkitBridge.h > =================================================================== > --- WebCore/platform/graphics/ANGLEWebkitBridge.h (revision 0) > +++ WebCore/platform/graphics/ANGLEWebkitBridge.h (revision 0) > @@ -0,0 +1,28 @@ > +/* > + * ANGLEWebkitBridge.h > + * WebCore > + * > + * Created by Paul Sawaya on 7/15/10. > + * Copyright 2010 Apple Inc. All rights reserved. > + * > + */ > + > +#ifndef ANGLEWebkitBridge_h > +#define ANGLEWebkitBridge_h > + > +#include "GraphicsContext3D.h" > +#include "ShaderLang.h" > +#include "WebGLShader.h" > + > +namespace WebCore { > + > +class ANGLEWebkitBridge { > +public: > + > + static bool validateShader(WebGLShader* shader, const char* shaderSource); > + > +}; > + > +} //namespace WebCore > + > +#endif WebCore/html/canvas/WebGLShader.cpp:43 + m_validated(false) WebKit style is: : CanvasObject(ctx) , m_type(type) , m_validated(false) WebCore/html/canvas/WebGLShader.h:41 + Try to avoid spurious changes like deleting whitespace WebCore/html/canvas/WebGLShader.h:48 + Since this flag indicates whether or not this shader has passed validation, maybe a better name would be m_valid. Then the calls would be isValid() and setValid(bool). WebCore/html/canvas/WebGLShader.h:54 + WebKit style is to not use "get". So the above calls would be validatorLog() and translatedSource(). WebCore/html/canvas/WebGLShader.h:65 + The calls should match the name of the variable. So it should be m_validatorLog, or the call names should be changed. WebCore/platform/graphics/ANGLEWebkitBridge.cpp:18 + #include <OpenGL/gl.h> This code is desktop GL specific? It shouldn't be. And I think GraphicsContext3D includes gl.h for Mac. WebCore/platform/graphics/ANGLEWebkitBridge.cpp:69 + // TODO: drop in ShGetValidatorLog once new patches are accepted by ANGLE WebKit style is to use FIXME rather than TODO WebCore/platform/graphics/ANGLEWebkitBridge.h:13 + #include "GraphicsContext3D.h" No need to include GraphicsContext3D.h in both the .cpp and .h files 260035 4 63388 kbr 2010-08-04 08:28:45 -0700 Comment on attachment 63388 Patch to use ANGLE to compile shaders in WebGLRenderingContext WebCore/platform/graphics/ANGLEWebkitBridge.cpp:8 + */ This copyright notice is not in the correct form. Please copy one from one of the other files in this directory. WebCore/platform/graphics/ANGLEWebkitBridge.cpp:48 + if (shader->getType() == GraphicsContext3D::VERTEX_SHADER) Indentation is incorrect here. WebCore/platform/graphics/ANGLEWebkitBridge.h:8 + */ Same issue with copyright notice. WebCore/html/canvas/WebGLShader.h:46 + bool passedValidation() { return m_validated; } Indentation is incorrect in this added block of code. WebCore/html/canvas/WebGLShader.h:64 + String m_validationLog; Indentation is incorrect. WebCore/platform/graphics/ANGLEWebkitBridge.cpp:16 + #include "ActiveDOMObject.h" This seems like an unnecessary #include. WebCore/platform/graphics/ANGLEWebkitBridge.cpp:37 + resources.maxDrawBuffers = 1; These values need to be queried from the current OpenGL context. For this reason I think ANGLEWebKitBridge should probably be a class instantiated one per WebGLRenderingContext and kept as a member so you can cache these results. You will also be able to reuse the compiler objects. See GLES2DecoderImpl::Initialize, http://src.chromium.org/viewvc/chrome/trunk/src/gpu/command_buffer/service/gles2_cmd_decoder.cc?view=markup , and its instantiation of vertex_compiler_ and fragment_compiler_. 260178 5 kbr 2010-08-04 13:16:23 -0700 Paul, I've upgraded the version of ANGLE in WebKit which involves a few minor API changes to the shader compiler. Apologies for any difficulty this causes you. Please consult the gles2_cmd_decoder.cc sources in the comment above for example usage. 260219 6 kbr 2010-08-04 14:33:48 -0700 It would also be really helpful if, when you add your new sources, you could also add them to Chromium's build generation files. Here's a diff for your current patch: Index: WebCore/WebCore.gypi =================================================================== --- WebCore/WebCore.gypi (revision 64680) +++ WebCore/WebCore.gypi (working copy) @@ -2438,6 +2438,8 @@ 'platform/graphics/wx/PenWx.cpp', 'platform/graphics/wx/SimpleFontDataWx.cpp', 'platform/graphics/wx/TransformationMatrixWx.cpp', + 'platform/graphics/ANGLEWebKitBridge.cpp', + 'platform/graphics/ANGLEWebkitBridge.h', 'platform/graphics/BitmapImage.cpp', 'platform/graphics/BitmapImage.h', 'platform/graphics/Color.cpp', 260996 7 63672 psawaya 2010-08-05 17:51:28 -0700 Created attachment 63672 Made requested changes 261002 8 kbr 2010-08-05 18:02:57 -0700 This looks really nice. Thanks for making the changes. I'm not a reviewer so can't r+ your patch, but otherwise would. Explicitly CC'ing a couple of reviewers. A couple of tiny issues: the year in the new copyright headers is wrong, and I don't know whether the naming convention of "validatorLog()/validatorLog(String)" would be preferred in WebKit, but it seems OK to me. 261003 9 63672 kbr 2010-08-05 18:08:17 -0700 Comment on attachment 63672 Made requested changes WebCore/html/canvas/WebGLRenderingContext.cpp:552 + shaderSource(shader, shader->translatedSource(), ec); Actually, sorry, I have to point out one more problem. At this level the translated shader source must not be used -- the incoming OpenGL ES 2.0 sources must be passed through to the GraphicsContext3D unmodified. This is because some GraphicsContext3D implementations may be running on OpenGL ES 2.0 directly, not desktop GL. All that should be done at the WebGLRenderingContext level is initial validation. 261004 10 psawaya 2010-08-05 18:09:49 -0700 (In reply to comment #9) > (From update of attachment 63672 [details]) > WebCore/html/canvas/WebGLRenderingContext.cpp:552 > + shaderSource(shader, shader->translatedSource(), ec); > Actually, sorry, I have to point out one more problem. At this level the translated shader source must not be used -- the incoming OpenGL ES 2.0 sources must be passed through to the GraphicsContext3D unmodified. This is because some GraphicsContext3D implementations may be running on OpenGL ES 2.0 directly, not desktop GL. All that should be done at the WebGLRenderingContext level is initial validation. No problem. Where would be a good place to hand off the translated source to OpenGL on the desktop, then? 261007 11 oliver 2010-08-05 18:21:33 -0700 (In reply to comment #9) > (From update of attachment 63672 [details]) > WebCore/html/canvas/WebGLRenderingContext.cpp:552 > + shaderSource(shader, shader->translatedSource(), ec); > Actually, sorry, I have to point out one more problem. At this level the translated shader source must not be used -- the incoming OpenGL ES 2.0 sources must be passed through to the GraphicsContext3D unmodified. This is because some GraphicsContext3D implementations may be running on OpenGL ES 2.0 directly, not desktop GL. All that should be done at the WebGLRenderingContext level is initial validation. Hmmm, i haven't looked at how ANGLE is expected to work but i would have thought that you tell it what the target platform is, and have it produce an appropriate translation. It seems at the very least inefficient to pass the untranslated code to GraphicsContext3D as the underlying implementation would need to reparse + regenerate the code before passing to the underlying runtime. 261020 12 kbr 2010-08-05 18:31:54 -0700 (In reply to comment #10) > (In reply to comment #9) > > (From update of attachment 63672 [details] [details]) > > WebCore/html/canvas/WebGLRenderingContext.cpp:552 > > + shaderSource(shader, shader->translatedSource(), ec); > > Actually, sorry, I have to point out one more problem. At this level the translated shader source must not be used -- the incoming OpenGL ES 2.0 sources must be passed through to the GraphicsContext3D unmodified. This is because some GraphicsContext3D implementations may be running on OpenGL ES 2.0 directly, not desktop GL. All that should be done at the WebGLRenderingContext level is initial validation. > > No problem. Where would be a good place to hand off the translated source to OpenGL on the desktop, then? I think it should work in the following manner. When WebGLRenderingContext::shaderSource() is called, the sources are stored in the WebGLShader object and not passed to GraphicsContext3D at all. When WebGLRenderingContext::compileShader() is called, it should run the validator on the cached source, and only if it is valid, pass through the source to a pair of calls to GraphicsContext3D::shaderSource() and compileShader(). Add a HashMap from Platform3DObject (shader ID) to String in GraphicsContext3DMac.mm. Upon a call to GraphicsContext3D::shaderSource, save off the source (GLES) string in this map. Later, in GraphicsContext3D::compileShader, run another instance of the compiler on that string and pass the result down to desktop GL. Alternatively we could change GraphicsContext3D to combine the entry points into something like compileShaderFromSource(Platform3DObject, String), although to do that and not break any platform's build you'll have to modify the Chromium and Qt ports. That may end up being a much simpler solution, though. 261022 13 kbr 2010-08-05 18:34:24 -0700 (In reply to comment #11) > (In reply to comment #9) > > (From update of attachment 63672 [details] [details]) > > WebCore/html/canvas/WebGLRenderingContext.cpp:552 > > + shaderSource(shader, shader->translatedSource(), ec); > > Actually, sorry, I have to point out one more problem. At this level the translated shader source must not be used -- the incoming OpenGL ES 2.0 sources must be passed through to the GraphicsContext3D unmodified. This is because some GraphicsContext3D implementations may be running on OpenGL ES 2.0 directly, not desktop GL. All that should be done at the WebGLRenderingContext level is initial validation. > > Hmmm, i haven't looked at how ANGLE is expected to work but i would have thought that you tell it what the target platform is, and have it produce an appropriate translation. It seems at the very least inefficient to pass the untranslated code to GraphicsContext3D as the underlying implementation would need to reparse + regenerate the code before passing to the underlying runtime. WebGLRenderingContext should not have any notion of what underlying shader language is being used by the GraphicsContext3D implementation (desktop GLSL, HLSL for Direct3D, etc.). Yes, there is a certain amount of inefficiency, but doing the translation and not just validation in WebGLRenderingContext breaks a huge number of abstraction barriers. 261026 14 oliver 2010-08-05 18:39:09 -0700 (In reply to comment #13) > (In reply to comment #11) > > (In reply to comment #9) > > > (From update of attachment 63672 [details] [details] [details]) > > > WebCore/html/canvas/WebGLRenderingContext.cpp:552 > > > + shaderSource(shader, shader->translatedSource(), ec); > > > Actually, sorry, I have to point out one more problem. At this level the translated shader source must not be used -- the incoming OpenGL ES 2.0 sources must be passed through to the GraphicsContext3D unmodified. This is because some GraphicsContext3D implementations may be running on OpenGL ES 2.0 directly, not desktop GL. All that should be done at the WebGLRenderingContext level is initial validation. > > > > Hmmm, i haven't looked at how ANGLE is expected to work but i would have thought that you tell it what the target platform is, and have it produce an appropriate translation. It seems at the very least inefficient to pass the untranslated code to GraphicsContext3D as the underlying implementation would need to reparse + regenerate the code before passing to the underlying runtime. > > WebGLRenderingContext should not have any notion of what underlying shader language is being used by the GraphicsContext3D implementation (desktop GLSL, HLSL for Direct3D, etc.). Yes, there is a certain amount of inefficiency, but doing the translation and not just validation in WebGLRenderingContext breaks a huge number of abstraction barriers. :-/ it's icky -- i don't like the idea of ever passing untranslated source anywhere near the actual backend, as you mentioned above a shader object may be best, maybe with a function akin to: ShaderObject::getSystemSource(targetRuntime) that would be called at the backend. Could we also please stop using the term "passing through" to me at least it implies that the initial source may be passed through to the backend directly, which can never happen -- even if the backend were GL|ES2, we would need to send translated content to avoid exposing security vulnerabilities due to parser differences. 261251 15 63672 cmarrin 2010-08-06 07:49:11 -0700 Comment on attachment 63672 Made requested changes WebCore/html/canvas/WebGLRenderingContext.cpp:96 + return new WebGLRenderingContext(canvas, context.release(), angleCompiler.release()); I don't see why you're creating the compiler here and passing it in. Why not just create it in the ctor? WebCore/html/canvas/WebGLRenderingContext.cpp:109 + , m_compiler(angleCompiler) You should be able to say: , m_compiler(adoptPtr(new ANGLEWebKitBridge)) WebCore/html/canvas/WebGLShader.cpp:44 + m_valid(false) WebKit style is: : WebGLObject(ctx) , m_type(type) , m_valid(false) WebCore/platform/graphics/ANGLEWebkitBridge.h:38 + ANGLEWebkitBridge(); No space needed here WebCore/platform/graphics/ANGLEWebkitBridge.h:46 + or here 261255 16 63672 cmarrin 2010-08-06 07:56:01 -0700 Comment on attachment 63672 Made requested changes WebCore/html/canvas/WebGLRenderingContext.cpp:555 + You shouldn't call shaderSource here. When the user gets the shader source, he should get what he passed in, not the translated source. This is the issue I was talking about before. We need separate validation and translation phases. GraphicsContext3D should take in GLSL ES source and translate it as needed for the current hardware. For now we should just be doing the translation phase. 261259 17 cmarrin 2010-08-06 08:00:24 -0700 (In reply to comment #11) > (In reply to comment #9) > > (From update of attachment 63672 [details] [details]) > > WebCore/html/canvas/WebGLRenderingContext.cpp:552 > > + shaderSource(shader, shader->translatedSource(), ec); > > Actually, sorry, I have to point out one more problem. At this level the translated shader source must not be used -- the incoming OpenGL ES 2.0 sources must be passed through to the GraphicsContext3D unmodified. This is because some GraphicsContext3D implementations may be running on OpenGL ES 2.0 directly, not desktop GL. All that should be done at the WebGLRenderingContext level is initial validation. > > Hmmm, i haven't looked at how ANGLE is expected to work but i would have thought that you tell it what the target platform is, and have it produce an appropriate translation. It seems at the very least inefficient to pass the untranslated code to GraphicsContext3D as the underlying implementation would need to reparse + regenerate the code before passing to the underlying runtime. Right, but I think at this point, we have to do it that way to avoid layering violations. GraphicsContext3D is a OpenGL ES 2.0 based API, so it is expecting GLSL ES code. Later we might want to move the validation back down into GraphicsContext3D and have a flag to turn validation and translation on or off. We would also need a way to get back the validation info log. This will allow us to do the validation and translation in one pass, avoid layering violations and still allow internal users to turn all this off for efficiency. Turning it off would of course mean that the client would have to make sure to send down shaders in the appropriate hardware specific language. 261265 18 cmarrin 2010-08-06 08:13:12 -0700 (In reply to comment #12) > (In reply to comment #10) > > (In reply to comment #9) > > > (From update of attachment 63672 [details] [details] [details]) > > > WebCore/html/canvas/WebGLRenderingContext.cpp:552 > > > + shaderSource(shader, shader->translatedSource(), ec); > > > Actually, sorry, I have to point out one more problem. At this level the translated shader source must not be used -- the incoming OpenGL ES 2.0 sources must be passed through to the GraphicsContext3D unmodified. This is because some GraphicsContext3D implementations may be running on OpenGL ES 2.0 directly, not desktop GL. All that should be done at the WebGLRenderingContext level is initial validation. > > > > No problem. Where would be a good place to hand off the translated source to OpenGL on the desktop, then? > > I think it should work in the following manner. When WebGLRenderingContext::shaderSource() is called, the sources are stored in the WebGLShader object and not passed to GraphicsContext3D at all. When WebGLRenderingContext::compileShader() is called, it should run the validator on the cached source, and only if it is valid, pass through the source to a pair of calls to GraphicsContext3D::shaderSource() and compileShader(). Add a HashMap from Platform3DObject (shader ID) to String in GraphicsContext3DMac.mm. Upon a call to GraphicsContext3D::shaderSource, save off the source (GLES) string in this map. Later, in GraphicsContext3D::compileShader, run another instance of the compiler on that string and pass the result down to desktop GL. > > Alternatively we could change GraphicsContext3D to combine the entry points into something like compileShaderFromSource(Platform3DObject, String), although to do that and not break any platform's build you'll have to modify the Chromium and Qt ports. That may end up being a much simpler solution, though. GraphicsContext3D should expect valid GLSL ES code and should do the translation itself as needed. This adds an extra compiler pass, but it keeps the API clean and we can deal with optimizations later. I realize this means instantiating yet another ANGLECompiler, but I think it's more important to keep the API clean at this point. For this patch, it should remain just a validator patch, not a translator patch. We should open a new bug for the translation. We should open yet another bug for the optimization. Here's how I think that should work: 1) Remove validation from WebGLRenderingContext. 2) Change GraphicsContext3D::compileShader to: bool compileShader(Platform3DObject, bool validateAndTranslate, String& validationInfoLog) 3) Put the validation and translation logic in GraphicsContext3D::compileShader. 262300 19 kbr 2010-08-09 13:39:08 -0700 (In reply to comment #18) > (In reply to comment #12) > > (In reply to comment #10) > > > (In reply to comment #9) > > > > (From update of attachment 63672 [details] [details] [details] [details]) > > > > WebCore/html/canvas/WebGLRenderingContext.cpp:552 > > > > + shaderSource(shader, shader->translatedSource(), ec); > > > > Actually, sorry, I have to point out one more problem. At this level the translated shader source must not be used -- the incoming OpenGL ES 2.0 sources must be passed through to the GraphicsContext3D unmodified. This is because some GraphicsContext3D implementations may be running on OpenGL ES 2.0 directly, not desktop GL. All that should be done at the WebGLRenderingContext level is initial validation. > > > > > > No problem. Where would be a good place to hand off the translated source to OpenGL on the desktop, then? > > > > I think it should work in the following manner. When WebGLRenderingContext::shaderSource() is called, the sources are stored in the WebGLShader object and not passed to GraphicsContext3D at all. When WebGLRenderingContext::compileShader() is called, it should run the validator on the cached source, and only if it is valid, pass through the source to a pair of calls to GraphicsContext3D::shaderSource() and compileShader(). Add a HashMap from Platform3DObject (shader ID) to String in GraphicsContext3DMac.mm. Upon a call to GraphicsContext3D::shaderSource, save off the source (GLES) string in this map. Later, in GraphicsContext3D::compileShader, run another instance of the compiler on that string and pass the result down to desktop GL. > > > > Alternatively we could change GraphicsContext3D to combine the entry points into something like compileShaderFromSource(Platform3DObject, String), although to do that and not break any platform's build you'll have to modify the Chromium and Qt ports. That may end up being a much simpler solution, though. > > GraphicsContext3D should expect valid GLSL ES code and should do the translation itself as needed. This adds an extra compiler pass, but it keeps the API clean and we can deal with optimizations later. I realize this means instantiating yet another ANGLECompiler, but I think it's more important to keep the API clean at this point. > > For this patch, it should remain just a validator patch, not a translator patch. We should open a new bug for the translation. > > We should open yet another bug for the optimization. Here's how I think that should work: > > 1) Remove validation from WebGLRenderingContext. > > 2) Change GraphicsContext3D::compileShader to: > > bool compileShader(Platform3DObject, bool validateAndTranslate, String& validationInfoLog) > > 3) Put the validation and translation logic in GraphicsContext3D::compileShader. This is certainly one way of doing it and would be fine from my standpoint, but it will still require a HashMap from shader to sources to be maintained in the GraphicsContext3D implementation. It would be easier to "buffer up" the calls at the WebGLRenderingContext layer and change the GraphicsContext3D entry point to something like compileShaderFromSource(Platform3DObject, const String& source, ...). I don't think we should add a validationInfoLog parameter to compileShader. Any validation log should simply be passed back via getShaderInfoLog. 262327 20 cmarrin 2010-08-09 14:39:46 -0700 (In reply to comment #19) > ... > > We should open yet another bug for the optimization. Here's how I think that should work: > > > > 1) Remove validation from WebGLRenderingContext. > > > > 2) Change GraphicsContext3D::compileShader to: > > > > bool compileShader(Platform3DObject, bool validateAndTranslate, String& validationInfoLog) > > > > 3) Put the validation and translation logic in GraphicsContext3D::compileShader. > > This is certainly one way of doing it and would be fine from my standpoint, but it will still require a HashMap from shader to sources to be maintained in the GraphicsContext3D implementation. It would be easier to "buffer up" the calls at the WebGLRenderingContext layer and change the GraphicsContext3D entry point to something like compileShaderFromSource(Platform3DObject, const String& source, ...). I don't think we should add a validationInfoLog parameter to compileShader. Any validation log should simply be passed back via getShaderInfoLog. The shader source has to be buffered somewhere. The way Paul has it now they're buffered in GraphicsContext3D in a HashMap as you suggest. I'd prefer the main calls work like they do in GL: source sent in shaderSource, compiled in compileSource. I suppose we could also put the info log entry returned from the validator into the HashMap rather than returning it. That would be a bit cleaner. I'll talk to Paul about it. 263090 21 64080 psawaya 2010-08-11 00:19:51 -0700 Created attachment 64080 Stores data about shader (log, translated source, if valid) in HashMap instead of WebGLShader object 263249 22 64080 cmarrin 2010-08-11 07:40:01 -0700 Comment on attachment 64080 Stores data about shader (log, translated source, if valid) in HashMap instead of WebGLShader object > @@ -998,11 +1062,12 @@ void GraphicsContext3D::shaderSource(Pla > ASSERT(shader); > > ensureContext(m_contextObj); > - const CString& cs = string.utf8(); > - const char* s = cs.data(); > - > - int length = string.length(); > - ::glShaderSource((GLuint) shader, 1, &s, &length); > + > + ShaderSourceEntry entry; > + > + entry.source = string; > + > + m_shaderSourceMap.set(shader, entry); > } > > void GraphicsContext3D::stencilFunc(unsigned long func, long ref, unsigned long mask) > @@ -1352,20 +1417,35 @@ void GraphicsContext3D::getShaderiv(Plat > String GraphicsContext3D::getShaderInfoLog(Platform3DObject shader) > { > ASSERT(shader); > ensureContext(m_contextObj); > GLint length; > ::glGetShaderiv((GLuint) shader, GL_INFO_LOG_LENGTH, &length); > - > - GLsizei size; > - GLchar* info = (GLchar*) fastMalloc(length); > - if (!info) > - return ""; > - > - ::glGetShaderInfoLog((GLuint) shader, length, &size, info); > - String s(info); > - fastFree(info); > - return s; > + > + HashMap<Platform3DObject, ShaderSourceEntry>::iterator result = m_shaderSourceMap.find(shader); > + > + if (result == m_shaderSourceMap.end()) > + return ""; > + > + ShaderSourceEntry entry = result->second; > + > + if (entry.isValid) { > + GLint length; > + ::glGetShaderiv((GLuint) shader, GL_INFO_LOG_LENGTH, &length); Do you need to get INFO_LOG_LENGTH twice? > + > + GLsizei size; > + GLchar* info = (GLchar*) fastMalloc(length); > + if (!info) > + return ""; > + > + ::glGetShaderInfoLog((GLuint) shader, length, &size, info); > + String s(info); > + fastFree(info); > + return s; > + } > + else { > + return entry.log; > + } > } > > String GraphicsContext3D::getShaderSource(Platform3DObject shader) WebCore/platform/graphics/mac/GraphicsContext3DMac.mm:1447 + } The above lines are indented 5, they should be indented 4. r+ with the above fixes Also, this really needs testing. I really want this checked in, so existing tests will do for now. Please submit a new bug for tests. You should add tests that show the appropriate message return for a failed validation. 263254 23 64080 cmarrin 2010-08-11 07:48:07 -0700 Comment on attachment 64080 Stores data about shader (log, translated source, if valid) in HashMap instead of WebGLShader object I changed this to r-. After trying to apply the patch to my tree I noticed that it fails to patch the project file, probably because it is out of date. It will be easier for you to fix this on your machine. Just svn update, which will probably result in a conflict on the project file. Fix that conflict, fix the other issues I noted in my review and then submit a new patch. If it's clean, we can have the commit-queue land it, which will be much easier. 263468 24 64080 kbr 2010-08-11 14:55:47 -0700 Comment on attachment 64080 Stores data about shader (log, translated source, if valid) in HashMap instead of WebGLShader object WebCore/platform/graphics/ANGLEWebkitBridge.cpp:2 + * Copyright (C) 2009 Apple Inc. All rights reserved. Copyright year should be 2010. WebCore/platform/graphics/ANGLEWebkitBridge.cpp:44 + printf("done with compiler constructing.\n"); printf should be removed. WebCore/platform/graphics/ANGLEWebkitBridge.h:2 + * Copyright (C) 2009 Apple Inc. All rights reserved. Copyright year. WebCore/platform/graphics/GraphicsContext3D.h:817 + HashMap<Platform3DObject, ShaderSourceEntry> m_shaderSourceMap; You could typedef HashMap<Platform3DObject, ShaderSourceEntry> to something like ShaderSourceMap for conciseness. WebCore/platform/graphics/mac/GraphicsContext3DMac.mm:664 + ShaderSourceEntry entry; I think you can use: ShaderSourceEntry& entry = result->second; to avoid the copying and re-setting of the entry in the map. WebCore/platform/graphics/mac/GraphicsContext3DMac.mm:1429 + ShaderSourceEntry entry = result->second; I think you can use const ShaderSourceEntry& entry = ... WebCore/platform/graphics/mac/GraphicsContext3DMac.mm:1427 + return ""; Indentation is off. WebCore/platform/graphics/mac/GraphicsContext3DMac.mm:1445 + else { "else" should be on same line as }. 264522 25 64381 psawaya 2010-08-13 15:49:01 -0700 Created attachment 64381 Changes to WebCore for ANGLE 264523 26 64382 psawaya 2010-08-13 15:49:22 -0700 Created attachment 64382 Changes to LayoutTests for ANGLE 264525 27 webkit.review.bot 2010-08-13 15:50:28 -0700 Attachment 64381 did not pass style-queue: Failed to run "['WebKitTools/Scripts/check-webkit-style']" exit_code: 1 WebCore/platform/graphics/ANGLEWebkitBridge.h:30: Alphabetical sorting problem. [build/include_order] [4] Total errors found: 1 in 7 files If any of these errors are false positives, please file a bug against check-webkit-style. 264527 28 webkit-ews 2010-08-13 15:54:19 -0700 Attachment 64381 did not build on qt: Build output: http://queues.webkit.org/results/3767145 264892 29 64381 cmarrin 2010-08-15 15:45:22 -0700 Comment on attachment 64381 Changes to WebCore for ANGLE Did you redo the xcodeproj file? It is still failing to patch on TOT. Please fix the style issues pointed out by the style bot WebCore/platform/graphics/GraphicsContext3D.h:29 + #include "ANGLEWebkitBridge.h" This include is causing the Qt build to fail. You can fix that by adding: class ANGLEWebkitBridge; You are already including the .h file in the Mac specific .mm file. Also, the proper case is ANGLWebKitBridge. Please change to match. 265186 30 64381 cmarrin 2010-08-16 12:00:09 -0700 Comment on attachment 64381 Changes to WebCore for ANGLE r+ after making requested changes 265187 31 64382 cmarrin 2010-08-16 12:00:30 -0700 Comment on attachment 64382 Changes to LayoutTests for ANGLE r+ 265194 32 psawaya 2010-08-16 12:20:05 -0700 Resolved in http://trac.webkit.org/changeset/65446 265196 33 webkit.review.bot 2010-08-16 12:24:29 -0700 http://trac.webkit.org/changeset/65446 might have broken Qt Linux Release minimal, Qt Linux ARMv5 Release, and Qt Linux ARMv7 Release 63388 2010-08-03 16:46:11 -0700 2010-08-05 17:51:28 -0700 Patch to use ANGLE to compile shaders in WebGLRenderingContext angle-changes-to-webkit text/plain 11068 psawaya SW5kZXg6IFdlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFdlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCShyZXZpc2lv biA2NDU5NSkKKysrIFdlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCSh3 b3JraW5nIGNvcHkpCkBAIC01MjM1LDYgKzUyMzUsOCBAQAogCQlGQUJFNzJGRTEwNTlDMjExMDBE OTk5REQgLyogTWF0aE1MTmFtZXMuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRG aWxlOyBmaWxlUmVmID0gRkFCRTcyRkMxMDU5QzIxMTAwRDk5OUREIC8qIE1hdGhNTE5hbWVzLmNw cCAqLzsgfTsKIAkJRkFDMTJDQzQxMTIwREE2OTAwREFDQzM2IC8qIFJlbmRlck1hdGhNTFN1YlN1 cC5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGQUMx MkNDMjExMjBEQTY5MDBEQUNDMzYgLyogUmVuZGVyTWF0aE1MU3ViU3VwLmNwcCAqLzsgfTsKIAkJ RkFDMTJDQzUxMTIwREE2OTAwREFDQzM2IC8qIFJlbmRlck1hdGhNTFN1YlN1cC5oIGluIEhlYWRl cnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRkFDMTJDQzMxMTIwREE2OTAw REFDQzM2IC8qIFJlbmRlck1hdGhNTFN1YlN1cC5oICovOyB9OworCQlGQkYyODFBRjEyMDhEMzVD MDBGN0Y4MTIgLyogQU5HTEVXZWJraXRCcmlkZ2UuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0g UEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRkJGMjgxQUQxMjA4RDM1QzAwRjdGODEyIC8qIEFOR0xF V2Via2l0QnJpZGdlLmNwcCAqLzsgfTsKKwkJRkJGMjgxQjAxMjA4RDM1QzAwRjdGODEyIC8qIEFO R0xFV2Via2l0QnJpZGdlLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZp bGVSZWYgPSBGQkYyODFBRTEyMDhEMzVDMDBGN0Y4MTIgLyogQU5HTEVXZWJraXRCcmlkZ2UuaCAq LzsgfTsKIAkJRkU2RkQ0ODgwRjY3NkU1NzAwMDkyODczIC8qIENvb3JkaW5hdGVzLmggaW4gSGVh ZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGRTZGRDQ4NTBGNjc2RTU3 MDAwOTI4NzMgLyogQ29vcmRpbmF0ZXMuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQ cml2YXRlLCApOyB9OyB9OwogCQlGRTZGRDQ4RDBGNjc2RTkzMDAwOTI4NzMgLyogSlNDb29yZGlu YXRlcy5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBG RTZGRDQ4QjBGNjc2RTkzMDAwOTI4NzMgLyogSlNDb29yZGluYXRlcy5jcHAgKi87IH07CiAJCUZF NkZENDhFMEY2NzZFOTMwMDA5Mjg3MyAvKiBKU0Nvb3JkaW5hdGVzLmggaW4gSGVhZGVycyAqLyA9 IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGRTZGRDQ4QzBGNjc2RTkzMDAwOTI4NzMg LyogSlNDb29yZGluYXRlcy5oICovOyB9OwpAQCAtMTEwMDIsNiArMTEwMDQsOCBAQAogCQlGQUJF NzJGQzEwNTlDMjExMDBEOTk5REQgLyogTWF0aE1MTmFtZXMuY3BwICovID0ge2lzYSA9IFBCWEZp bGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNl Y29kZS5jcHAuY3BwOyBwYXRoID0gTWF0aE1MTmFtZXMuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91 cD4iOyB9OwogCQlGQUMxMkNDMjExMjBEQTY5MDBEQUNDMzYgLyogUmVuZGVyTWF0aE1MU3ViU3Vw LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0 S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFJlbmRlck1hdGhNTFN1 YlN1cC5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUZBQzEyQ0MzMTEyMERBNjkw MERBQ0MzNiAvKiBSZW5kZXJNYXRoTUxTdWJTdXAuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5o OyBwYXRoID0gUmVuZGVyTWF0aE1MU3ViU3VwLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CisJCUZCRjI4MUFEMTIwOEQzNUMwMEY3RjgxMiAvKiBBTkdMRVdlYmtpdEJyaWRnZS5jcHAgKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBBTkdMRVdlYmtpdEJyaWRnZS5jcHA7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCUZCRjI4MUFFMTIwOEQzNUMwMEY3RjgxMiAv KiBBTkdMRVdlYmtpdEJyaWRnZS5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVF bmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBB TkdMRVdlYmtpdEJyaWRnZS5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGRTQ5RUY5 NzBEQzUxNDYyMDA0MjY2RTEgLyogRGFzaGJvYXJkU3VwcG9ydENTU1Byb3BlcnR5TmFtZXMuaW4g Ki8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3du RmlsZVR5cGUgPSB0ZXh0OyBwYXRoID0gRGFzaGJvYXJkU3VwcG9ydENTU1Byb3BlcnR5TmFtZXMu aW47IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUZFNkZENDg1MEY2NzZFNTcwMDA5Mjg3 MyAvKiBDb29yZGluYXRlcy5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNv ZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBDb29y ZGluYXRlcy5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGRTZGRDQ4NjBGNjc2RTU3 MDAwOTI4NzMgLyogQ29vcmRpbmF0ZXMuaWRsICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gdGV4dDsgcGF0aCA9IENvb3Jk aW5hdGVzLmlkbDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTE1NTIxLDYgKzE1NTI1 LDggQEAKIAkJCQlCMjc1MzU0OTBCMDUzODE0MDAyQ0U2NEYgLyogbWFjICovLAogCQkJCUY0RUFG NEFCMTBDNzQyNjgwMDkxMDBEMyAvKiBvcGVudHlwZSAqLywKIAkJCQk0OUU5MTFCMjBFRjg2RDI3 MDA5RDBDQUYgLyogdHJhbnNmb3JtcyAqLywKKwkJCQlGQkYyODFBRDEyMDhEMzVDMDBGN0Y4MTIg LyogQU5HTEVXZWJraXRCcmlkZ2UuY3BwICovLAorCQkJCUZCRjI4MUFFMTIwOEQzNUMwMEY3Rjgx MiAvKiBBTkdMRVdlYmtpdEJyaWRnZS5oICovLAogCQkJCUE4OTk0MzI3MEI0MjMzODcwMEQ3Qzgw MiAvKiBCaXRtYXBJbWFnZS5jcHAgKi8sCiAJCQkJQTg5OTQzMjYwQjQyMzM4NzAwRDdDODAyIC8q IEJpdG1hcEltYWdlLmggKi8sCiAJCQkJQjI3NTM1MzgwQjA1MzgxNDAwMkNFNjRGIC8qIENvbG9y LmNwcCAqLywKQEAgLTE5OTgzLDYgKzE5OTg5LDcgQEAKIAkJCQlEMzlEMDA5RDExRjkwN0U2MDA2 MDQxRjIgLyogU2VhcmNoUG9wdXBNZW51TWFjLmggaW4gSGVhZGVycyAqLywKIAkJCQlCNjE3NjI1 NDEyMDMzNzRGMDBFRjkxMTQgLyogSURCRGF0YWJhc2VCYWNrZW5kSW50ZXJmYWNlLmggaW4gSGVh ZGVycyAqLywKIAkJCQlCNjE3NjI2MjEyMDM0OTA4MDBFRjkxMTQgLyogSURCRGF0YWJhc2VCYWNr ZW5kSW1wbC5oIGluIEhlYWRlcnMgKi8sCisJCQkJRkJGMjgxQjAxMjA4RDM1QzAwRjdGODEyIC8q IEFOR0xFV2Via2l0QnJpZGdlLmggaW4gSGVhZGVycyAqLywKIAkJCSk7CiAJCQlydW5Pbmx5Rm9y RGVwbG95bWVudFBvc3Rwcm9jZXNzaW5nID0gMDsKIAkJfTsKQEAgLTIwMDQyLDcgKzIwMDQ5LDYg QEAKIAkJCWlzYSA9IFBCWFByb2plY3Q7CiAJCQlidWlsZENvbmZpZ3VyYXRpb25MaXN0ID0gMTQ5 QzI4NDMwODkwMkIxMTAwOEE5RUZDIC8qIEJ1aWxkIGNvbmZpZ3VyYXRpb24gbGlzdCBmb3IgUEJY UHJvamVjdCAiV2ViQ29yZSIgKi87CiAJCQljb21wYXRpYmlsaXR5VmVyc2lvbiA9ICJYY29kZSAy LjQiOwotCQkJZGV2ZWxvcG1lbnRSZWdpb24gPSBFbmdsaXNoOwogCQkJaGFzU2Nhbm5lZEZvckVu Y29kaW5ncyA9IDE7CiAJCQlrbm93blJlZ2lvbnMgPSAoCiAJCQkJRW5nbGlzaCwKQEAgLTIyMzg3 LDYgKzIyMzkzLDcgQEAKIAkJCQlFMUJFNTEyRDBDRjZDNTEyMDAyRUE5NTkgLyogWFNMVFVuaWNv ZGVTb3J0LmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTk3REQ0RDg2MEZERjRENkUwMEVDRjlBNCAv KiBYU1NBdWRpdG9yLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCUMwNDZFMUFDMTIwOEE5RkUwMEJB MkNGNyAvKiBMb2NhbGl6ZWRTdHJpbmdzLmNwcCBpbiBTb3VyY2VzICovLAorCQkJCUZCRjI4MUFG MTIwOEQzNUMwMEY3RjgxMiAvKiBBTkdMRVdlYmtpdEJyaWRnZS5jcHAgaW4gU291cmNlcyAqLywK IAkJCSk7CiAJCQlydW5Pbmx5Rm9yRGVwbG95bWVudFBvc3Rwcm9jZXNzaW5nID0gMDsKIAkJfTsK SW5kZXg6IFdlYkNvcmUvaHRtbC9jYW52YXMvV2ViR0xSZW5kZXJpbmdDb250ZXh0LmNwcAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBXZWJDb3JlL2h0bWwvY2FudmFzL1dlYkdMUmVuZGVyaW5nQ29udGV4dC5jcHAJ KHJldmlzaW9uIDY0NTk1KQorKysgV2ViQ29yZS9odG1sL2NhbnZhcy9XZWJHTFJlbmRlcmluZ0Nv bnRleHQuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yOSw2ICsyOSw3IEBACiAKICNpbmNsdWRlICJX ZWJHTFJlbmRlcmluZ0NvbnRleHQuaCIKIAorI2luY2x1ZGUgIkFOR0xFV2Via2l0QnJpZGdlLmgi CiAjaW5jbHVkZSAiQ2hlY2tlZEludC5oIgogI2luY2x1ZGUgIkNhbnZhc1BpeGVsQXJyYXkuaCIK ICNpbmNsdWRlICJDb25zb2xlLmgiCkBAIC01MTYsNyArNTE3LDEwIEBAIHZvaWQgV2ViR0xSZW5k ZXJpbmdDb250ZXh0Ojpjb21waWxlU2hhZGUKICAgICBVTlVTRURfUEFSQU0oZWMpOwogICAgIGlm ICghdmFsaWRhdGVXZWJHTE9iamVjdChzaGFkZXIpKQogICAgICAgICByZXR1cm47Ci0gICAgbV9j b250ZXh0LT5jb21waWxlU2hhZGVyKHNoYWRlciA/IHNoYWRlci0+b2JqZWN0KCkgOiAwKTsKKyAg ICAKKyAgICBpZiAoQU5HTEVXZWJraXRCcmlkZ2U6OnZhbGlkYXRlU2hhZGVyKHNoYWRlcixnZXRT aGFkZXJTb3VyY2Uoc2hhZGVyLGVjKS51dGY4KCkuZGF0YSgpKSkKKyAgICAgICAgbV9jb250ZXh0 LT5jb21waWxlU2hhZGVyKHNoYWRlciA/IHNoYWRlci0+b2JqZWN0KCkgOiAwKTsKKwogICAgIGNs ZWFudXBBZnRlckdyYXBoaWNzQ2FsbChmYWxzZSk7CiB9CiAKQEAgLTE1NjEsNyArMTU2NSwxMiBA QCBTdHJpbmcgV2ViR0xSZW5kZXJpbmdDb250ZXh0OjpnZXRTaGFkZXJJCiAgICAgaWYgKCF2YWxp ZGF0ZVdlYkdMT2JqZWN0KHNoYWRlcikpCiAgICAgICAgIHJldHVybiAiIjsKICAgICBXZWJHTFN0 YXRlUmVzdG9yZXIodGhpcywgZmFsc2UpOwotICAgIHJldHVybiBtX2NvbnRleHQtPmdldFNoYWRl ckluZm9Mb2coc2hhZGVyID8gc2hhZGVyLT5vYmplY3QoKSA6IDApOworICAgIAorICAgIC8vIElm IHRoZSBzaGFkZXIgZmFpbGVkIHZhbGlkYXRpb24sIHJldHVybiB0aGUgQU5HTEUgdmFsaWRhdGlv biBsb2cgaW5zdGVhZAorICAgIGlmIChzaGFkZXItPnBhc3NlZFZhbGlkYXRpb24oKSkKKyAgICAg ICAgcmV0dXJuIG1fY29udGV4dC0+Z2V0U2hhZGVySW5mb0xvZyhzaGFkZXIgPyBzaGFkZXItPm9i amVjdCgpIDogMCk7CisgICAgZWxzZQorICAgICAgICByZXR1cm4gc2hhZGVyLT5nZXRWYWxpZGF0 b3JMb2coKTsKIH0KIAogU3RyaW5nIFdlYkdMUmVuZGVyaW5nQ29udGV4dDo6Z2V0U2hhZGVyU291 cmNlKFdlYkdMU2hhZGVyKiBzaGFkZXIsIEV4Y2VwdGlvbkNvZGUmIGVjKQpJbmRleDogV2ViQ29y ZS9odG1sL2NhbnZhcy9XZWJHTFNoYWRlci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9odG1s L2NhbnZhcy9XZWJHTFNoYWRlci5jcHAJKHJldmlzaW9uIDY0NTk1KQorKysgV2ViQ29yZS9odG1s L2NhbnZhcy9XZWJHTFNoYWRlci5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTM4LDggKzM4LDkgQEAg UGFzc1JlZlB0cjxXZWJHTFNoYWRlcj4gV2ViR0xTaGFkZXI6OmNyZQogfQogCiBXZWJHTFNoYWRl cjo6V2ViR0xTaGFkZXIoV2ViR0xSZW5kZXJpbmdDb250ZXh0KiBjdHgsIEdyYXBoaWNzQ29udGV4 dDNEOjpXZWJHTEVudW1UeXBlIHR5cGUpCi0gICAgOiBDYW52YXNPYmplY3QoY3R4KQotICAgICwg bV90eXBlKHR5cGUpCisgICAgOiBDYW52YXNPYmplY3QoY3R4KSwKKyAgICBtX3R5cGUodHlwZSks IAorICAgIG1fdmFsaWRhdGVkKGZhbHNlKQogewogICAgIHNldE9iamVjdChjb250ZXh0KCktPmdy YXBoaWNzQ29udGV4dDNEKCktPmNyZWF0ZVNoYWRlcih0eXBlKSk7CiB9CkluZGV4OiBXZWJDb3Jl L2h0bWwvY2FudmFzL1dlYkdMU2hhZGVyLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9odG1sL2Nh bnZhcy9XZWJHTFNoYWRlci5oCShyZXZpc2lvbiA2NDU5NSkKKysrIFdlYkNvcmUvaHRtbC9jYW52 YXMvV2ViR0xTaGFkZXIuaAkod29ya2luZyBjb3B5KQpAQCAtMjgsNiArMjgsOCBAQAogCiAjaW5j bHVkZSAiQ2FudmFzT2JqZWN0LmgiCiAKKyNpbmNsdWRlICJQbGF0Zm9ybVN0cmluZy5oIgorCiAj aW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KICNpbmNsdWRlIDx3dGYvUmVmQ291bnRlZC5oPgog CkBAIC0zNiwxMSArMzgsMjAgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgIGNsYXNzIFdlYkdM U2hhZGVyIDogcHVibGljIENhbnZhc09iamVjdCB7CiAgICAgcHVibGljOgogICAgICAgICB2aXJ0 dWFsIH5XZWJHTFNoYWRlcigpIHsgZGVsZXRlT2JqZWN0KCk7IH0KLSAgICAgICAgCisKICAgICAg ICAgc3RhdGljIFBhc3NSZWZQdHI8V2ViR0xTaGFkZXI+IGNyZWF0ZShXZWJHTFJlbmRlcmluZ0Nv bnRleHQqLCBHcmFwaGljc0NvbnRleHQzRDo6V2ViR0xFbnVtVHlwZSk7CiAKICAgICAgICAgR3Jh cGhpY3NDb250ZXh0M0Q6OldlYkdMRW51bVR5cGUgZ2V0VHlwZSgpIGNvbnN0IHsgcmV0dXJuIG1f dHlwZTsgfQogCisJCWJvb2wgcGFzc2VkVmFsaWRhdGlvbigpIHsgcmV0dXJuIG1fdmFsaWRhdGVk OyB9CQkKKwkJdm9pZCBzZXRWYWxpZGF0ZWQoYm9vbCB2YWxpZGF0ZWQpIHsgbV92YWxpZGF0ZWQg PSB2YWxpZGF0ZWQ7IH0KKwkJCisJCVN0cmluZyBnZXRWYWxpZGF0b3JMb2coKSB7IHJldHVybiBt X3ZhbGlkYXRpb25Mb2c7IH0KKwkJdm9pZCBzZXRWYWxpZGF0b3JMb2coU3RyaW5nIG1lc3NhZ2Vz KSB7IG1fdmFsaWRhdGlvbkxvZyA9IG1lc3NhZ2VzOyB9CisJCQorCQlTdHJpbmcgZ2V0VHJhbnNs YXRlZFNvdXJjZSgpIHsgcmV0dXJuIG1fdHJhbnNsYXRlZFNvdXJjZTsgfQorCQl2b2lkIHNldFRy YW5zbGF0ZWRTb3VyY2UoU3RyaW5nIHNvdXJjZSkgeyBtX3RyYW5zbGF0ZWRTb3VyY2UgPSBzb3Vy Y2U7IH0KKwogICAgIHByaXZhdGU6CiAgICAgICAgIFdlYkdMU2hhZGVyKFdlYkdMUmVuZGVyaW5n Q29udGV4dCosIEdyYXBoaWNzQ29udGV4dDNEOjpXZWJHTEVudW1UeXBlKTsKIApAQCAtNDksNiAr NjAsMTMgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICB2aXJ0dWFsIGJvb2wgaXNTaGFk ZXIoKSBjb25zdCB7IHJldHVybiB0cnVlOyB9CiAKICAgICAgICAgR3JhcGhpY3NDb250ZXh0M0Q6 OldlYkdMRW51bVR5cGUgbV90eXBlOworCisJCVN0cmluZyBtX3ZhbGlkYXRpb25Mb2c7CisJCQor CQkvL0Rlc2t0b3AgR0xTTCBzb3VyY2UKKwkJU3RyaW5nIG1fdHJhbnNsYXRlZFNvdXJjZTsKKwor CQlib29sIG1fdmFsaWRhdGVkOwogICAgIH07CiAgICAgCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3Jl CkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0FOR0xFV2Via2l0QnJpZGdlLmNwcAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0FOR0xFV2Via2l0QnJpZGdl LmNwcAkocmV2aXNpb24gMCkKKysrIFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvQU5HTEVXZWJr aXRCcmlkZ2UuY3BwCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDgwIEBACisvKgorICogIEFOR0xF V2Via2l0QnJpZGdlLmNwcAorICogIFdlYkNvcmUKKyAqCisgKiAgQ3JlYXRlZCBieSBQYXVsIFNh d2F5YSBvbiA3LzE1LzEwLgorICogIENvcHlyaWdodCAyMDEwIEFwcGxlIEluYy4gQWxsIHJpZ2h0 cyByZXNlcnZlZC4KKyAqCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorCisjaWYgRU5BQkxF KDNEX0NBTlZBUykKKworI2luY2x1ZGUgIkFOR0xFV2Via2l0QnJpZGdlLmgiCisKKyNpbmNsdWRl ICJBY3RpdmVET01PYmplY3QuaCIKKyNpbmNsdWRlICJHcmFwaGljc0NvbnRleHQzRC5oIgorI2lu Y2x1ZGUgPE9wZW5HTC9nbC5oPgorI2luY2x1ZGUgIlNoYWRlckxhbmcuaCIKKyNpbmNsdWRlICJX ZWJHTFNoYWRlci5oIgorCisjaW5jbHVkZSA8d3RmL3RleHQvQ1N0cmluZy5oPgorCituYW1lc3Bh Y2UgV2ViQ29yZSB7CisgICAgICAgIAorICAgICAgICAKKy8vIFNldCB1cCB0aGUgcGVyIGNvbXBp bGUgcmVzb3VyY2VzCitzdGF0aWMgdm9pZCBnZW5lcmF0ZVJlc291cmNlcyhUQnVpbHRJblJlc291 cmNlJiByZXNvdXJjZXMpCit7CisgICAgcmVzb3VyY2VzLm1heFZlcnRleEF0dHJpYnMgPSA4Owor ICAgIHJlc291cmNlcy5tYXhWZXJ0ZXhVbmlmb3JtVmVjdG9ycyA9IDEyODsKKyAgICByZXNvdXJj ZXMubWF4VmFyeWluZ1ZlY3RvcnMgPSA4OworICAgIHJlc291cmNlcy5tYXhWZXJ0ZXhUZXh0dXJl SW1hZ2VVbml0cyA9IDA7CisgICAgcmVzb3VyY2VzLm1heENvbWJpbmVkVGV4dHVyZUltYWdlVW5p dHMgPSA4OworICAgIHJlc291cmNlcy5tYXhUZXh0dXJlSW1hZ2VVbml0cyA9IDg7CisgICAgcmVz b3VyY2VzLm1heEZyYWdtZW50VW5pZm9ybVZlY3RvcnMgPSAxNjsKKyAgICByZXNvdXJjZXMubWF4 RHJhd0J1ZmZlcnMgPSAxOworfQorCitib29sIEFOR0xFV2Via2l0QnJpZGdlOjp2YWxpZGF0ZVNo YWRlcihXZWJHTFNoYWRlciogc2hhZGVyLCBjb25zdCBjaGFyKiBzaGFkZXJTb3VyY2UpCit7Cisg ICAgVEJ1aWx0SW5SZXNvdXJjZSByZXNvdXJjZXM7CisgICAgRVNoTGFuZ3VhZ2Ugc2hhZGVyTGFu ZzsKKyAgICBTaEhhbmRsZSBjb21waWxlcjsKKworICAgIGdlbmVyYXRlUmVzb3VyY2VzKHJlc291 cmNlcyk7CisgICAgCitpZiAoc2hhZGVyLT5nZXRUeXBlKCkgPT0gR3JhcGhpY3NDb250ZXh0M0Q6 OlZFUlRFWF9TSEFERVIpCisgICAgICAgIHNoYWRlckxhbmcgPSBFU2hMYW5nVmVydGV4OworICAg IGVsc2UgaWYgKHNoYWRlci0+Z2V0VHlwZSgpID09IEdyYXBoaWNzQ29udGV4dDNEOjpGUkFHTUVO VF9TSEFERVIpCisgICAgICAgIHNoYWRlckxhbmcgPSBFU2hMYW5nRnJhZ21lbnQ7CisgICAgZWxz ZQorICAgICAgICByZXR1cm4gZmFsc2U7IC8vIEludmFsaWQgc2hhZGVyIHR5cGUKKyAgICAgICAg CisgICAgU2hJbml0aWFsaXplKCk7CisgICAgCisgICAgY29tcGlsZXIgPSBTaENvbnN0cnVjdENv bXBpbGVyKHNoYWRlckxhbmcsIEVTaFNwZWNXZWJHTCk7CisgICAgCisgICAgY29uc3QgY2hhciog Y29uc3Qgc2hhZGVyU291cmNlU3RyaW5nc1tdID0ge3NoYWRlclNvdXJjZX07CisgICAgCisgICAg Ym9vbCB2YWxpZGF0ZVN1Y2Nlc3MgPSBTaENvbXBpbGUoY29tcGlsZXIsIHNoYWRlclNvdXJjZVN0 cmluZ3MsIDEsIEVTaE9wdE5vbmUsICZyZXNvdXJjZXMsIEVEZWJ1Z09wSW50ZXJtZWRpYXRlKTsK KyAgICAKKyAgICBzaGFkZXItPnNldFZhbGlkYXRlZCh2YWxpZGF0ZVN1Y2Nlc3MpOworICAgIAor ICAgIGlmICh2YWxpZGF0ZVN1Y2Nlc3MpIHsKKyAgICAgICAgc2hhZGVyLT5zZXRUcmFuc2xhdGVk U291cmNlKFNoR2V0T2JqZWN0Q29kZShjb21waWxlcikpOworICAgIH0KKyAgICBlbHNlIHsKKyAg ICAgICAgLy8gVE9ETzogZHJvcCBpbiBTaEdldFZhbGlkYXRvckxvZyBvbmNlIG5ldyBwYXRjaGVz IGFyZSBhY2NlcHRlZCBieSBBTkdMRQorICAgICAgICBzaGFkZXItPnNldFZhbGlkYXRvckxvZygi VmFsaWRhdGlvbiBmYWlsZWQuIik7CisgICAgfQorCisgICAgU2hEZXN0cnVjdChjb21waWxlcik7 CisKKyAgICByZXR1cm4gdmFsaWRhdGVTdWNjZXNzOworfQorCit9CisKKyNlbmRpZiAvLyBFTkFC TEUoM0RfQ0FOVkFTKQpJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9BTkdMRVdlYmtp dEJyaWRnZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvQU5HTEVX ZWJraXRCcmlkZ2UuaAkocmV2aXNpb24gMCkKKysrIFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv QU5HTEVXZWJraXRCcmlkZ2UuaAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwyOCBAQAorLyoKKyAq ICBBTkdMRVdlYmtpdEJyaWRnZS5oCisgKiAgV2ViQ29yZQorICoKKyAqICBDcmVhdGVkIGJ5IFBh dWwgU2F3YXlhIG9uIDcvMTUvMTAuCisgKiAgQ29weXJpZ2h0IDIwMTAgQXBwbGUgSW5jLiBBbGwg cmlnaHRzIHJlc2VydmVkLgorICoKKyAqLworCisjaWZuZGVmIEFOR0xFV2Via2l0QnJpZGdlX2gK KyNkZWZpbmUgQU5HTEVXZWJraXRCcmlkZ2VfaAorCisjaW5jbHVkZSAiR3JhcGhpY3NDb250ZXh0 M0QuaCIKKyNpbmNsdWRlICJTaGFkZXJMYW5nLmgiCisjaW5jbHVkZSAiV2ViR0xTaGFkZXIuaCIK KworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBBTkdMRVdlYmtpdEJyaWRnZSB7CitwdWJs aWM6CisKKwlzdGF0aWMgYm9vbCB2YWxpZGF0ZVNoYWRlcihXZWJHTFNoYWRlciogc2hhZGVyLCBj b25zdCBjaGFyKiBzaGFkZXJTb3VyY2UpOworCit9OworCit9IC8vbmFtZXNwYWNlIFdlYkNvcmUK KworI2VuZGlmCg== 63672 2010-08-05 17:51:28 -0700 2010-08-11 00:19:51 -0700 Made requested changes angle-webkit-bridge text/plain 18831 psawaya SW5kZXg6IFdlYkNvcmUvV2ViQ29yZS5neXBpCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvV2ViQ29y ZS5neXBpCShyZXZpc2lvbiA2NDc4MSkKKysrIFdlYkNvcmUvV2ViQ29yZS5neXBpCSh3b3JraW5n IGNvcHkpCkBAIC0yNDM0LDYgKzI0MzQsOCBAQAogICAgICAgICAgICAgJ3BsYXRmb3JtL2dyYXBo aWNzL3d4L1Blbld4LmNwcCcsCiAgICAgICAgICAgICAncGxhdGZvcm0vZ3JhcGhpY3Mvd3gvU2lt cGxlRm9udERhdGFXeC5jcHAnLAogICAgICAgICAgICAgJ3BsYXRmb3JtL2dyYXBoaWNzL3d4L1Ry YW5zZm9ybWF0aW9uTWF0cml4V3guY3BwJywKKyAgICAgICAgICAgICdwbGF0Zm9ybS9ncmFwaGlj cy9BTkdMRVdlYmtpdEJyaWRnZS5jcHAnLAorICAgICAgICAgICAgJ3BsYXRmb3JtL2dyYXBoaWNz L0FOR0xFV2Via2l0QnJpZGdlLmgnLAogICAgICAgICAgICAgJ3BsYXRmb3JtL2dyYXBoaWNzL0Jp dG1hcEltYWdlLmNwcCcsCiAgICAgICAgICAgICAncGxhdGZvcm0vZ3JhcGhpY3MvQml0bWFwSW1h Z2UuaCcsCiAgICAgICAgICAgICAncGxhdGZvcm0vZ3JhcGhpY3MvQ29sb3IuY3BwJywKSW5kZXg6 IFdlYkNvcmUvQ29uZmlndXJhdGlvbnMvV2ViQ29yZS54Y2NvbmZpZwo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBX ZWJDb3JlL0NvbmZpZ3VyYXRpb25zL1dlYkNvcmUueGNjb25maWcJKHJldmlzaW9uIDY0NzgxKQor KysgV2ViQ29yZS9Db25maWd1cmF0aW9ucy9XZWJDb3JlLnhjY29uZmlnCSh3b3JraW5nIGNvcHkp CkBAIC00MywxNCArNDMsMTQgQEAgRlJBTUVXT1JLX1NFQVJDSF9QQVRIU19pcGhvbmVvc19Qcm9k dWN0aQogRlJBTUVXT1JLX1NFQVJDSF9QQVRIU19pcGhvbmVzaW11bGF0b3IgPSAkKEZSQU1FV09S S19TRUFSQ0hfUEFUSFNfaXBob25lb3NfJChDT05GSUdVUkFUSU9OKSk7CiBGUkFNRVdPUktfU0VB UkNIX1BBVEhTX21hY29zeCA9ICQoU1lTVEVNX0xJQlJBUllfRElSKS9GcmFtZXdvcmtzL0NhcmJv bi5mcmFtZXdvcmsvRnJhbWV3b3JrcyAkKFNZU1RFTV9MSUJSQVJZX0RJUikvRnJhbWV3b3Jrcy9B cHBsaWNhdGlvblNlcnZpY2VzLmZyYW1ld29yay9GcmFtZXdvcmtzICQoRlJBTUVXT1JLX1NFQVJD SF9QQVRIUyk7CiAKLUhFQURFUl9TRUFSQ0hfUEFUSFMgPSBGb3J3YXJkaW5nSGVhZGVycyBpY3Ug L3Vzci9pbmNsdWRlL2xpYnhzbHQgL3Vzci9pbmNsdWRlL2xpYnhtbDIgJChTUUxJVEUzX0hFQURF Ul9TRUFSQ0hfUEFUSFMpICIke0JVSUxUX1BST0RVQ1RTX0RJUn0vRGVyaXZlZFNvdXJjZXMvV2Vi Q29yZSIgJChIRUFERVJfU0VBUkNIX1BBVEhTKTsKK0hFQURFUl9TRUFSQ0hfUEFUSFMgPSBGb3J3 YXJkaW5nSGVhZGVycyBpY3UgL3Vzci9pbmNsdWRlL2xpYnhzbHQgL3Vzci9pbmNsdWRlL2xpYnht bDIgJChTUUxJVEUzX0hFQURFUl9TRUFSQ0hfUEFUSFMpICIke0JVSUxUX1BST0RVQ1RTX0RJUn0v RGVyaXZlZFNvdXJjZXMvV2ViQ29yZSIgIiR7QlVJTFRfUFJPRFVDVFNfRElSfS91c3IvbG9jYWwv aW5jbHVkZSIgJChIRUFERVJfU0VBUkNIX1BBVEhTKTsKIElORk9QTElTVF9GSUxFID0gSW5mby5w bGlzdDsKIElOU1RBTExfUEFUSCA9ICQoSU5TVEFMTF9QQVRIXyQoUkVBTF9QTEFURk9STV9OQU1F KSk7CiBJTlNUQUxMX1BBVEhfbWFjb3N4ID0gJChTWVNURU1fTElCUkFSWV9ESVIpL0ZyYW1ld29y a3MvV2ViS2l0LmZyYW1ld29yay9WZXJzaW9ucy9BL0ZyYW1ld29ya3M7CiBJTlNUQUxMSERSU19D T1BZX1BIQVNFID0gWUVTOwogSU5TVEFMTEhEUlNfU0NSSVBUX1BIQVNFID0gWUVTOwogUFJPRFVD VF9OQU1FID0gV2ViQ29yZTsKLU9USEVSX0xERkxBR1NfQkFTRSA9IC1sJChTUUxJVEUzX0xJQlJB UlkpIC1sb2JqYzsKK09USEVSX0xERkxBR1NfQkFTRSA9IC1sJChTUUxJVEUzX0xJQlJBUlkpIC1s b2JqYyAtbEFOR0xFOwogT1RIRVJfTERGTEFHUyA9ICQoT1RIRVJfTERGTEFHU18kKFJFQUxfUExB VEZPUk1fTkFNRSkpOwogT1RIRVJfTERGTEFHU19pcGhvbmVvcyA9ICQoT1RIRVJfTERGTEFHU19C QVNFKSAtZnJhbWV3b3JrIENGTmV0d29yayAtZnJhbWV3b3JrIENvcmVGb3VuZGF0aW9uIC1mcmFt ZXdvcmsgQ29yZUdyYXBoaWNzIC1mcmFtZXdvcmsgQ29yZVRleHQgLWZyYW1ld29yayBGb3VuZGF0 aW9uIC1mcmFtZXdvcmsgR3JhcGhpY3NTZXJ2aWNlcyAtZnJhbWV3b3JrIEltYWdlSU8gLWZyYW1l d29yayBRdWFydHpDb3JlOwogT1RIRVJfTERGTEFHU19pcGhvbmVzaW11bGF0b3IgPSAkKE9USEVS X0xERkxBR1NfaXBob25lb3MpOwpJbmRleDogV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9q ZWN0LnBieHByb2oKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9q ZWN0LnBieHByb2oJKHJldmlzaW9uIDY0NzgxKQorKysgV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJv ai9wcm9qZWN0LnBieHByb2oJKHdvcmtpbmcgY29weSkKQEAgLTUyMzUsNiArNTIzNSw3IEBACiAJ CUZBQkU3MkZFMTA1OUMyMTEwMEQ5OTlERCAvKiBNYXRoTUxOYW1lcy5jcHAgaW4gU291cmNlcyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGQUJFNzJGQzEwNTlDMjExMDBEOTk5 REQgLyogTWF0aE1MTmFtZXMuY3BwICovOyB9OwogCQlGQUMxMkNDNDExMjBEQTY5MDBEQUNDMzYg LyogUmVuZGVyTWF0aE1MU3ViU3VwLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IEZBQzEyQ0MyMTEyMERBNjkwMERBQ0MzNiAvKiBSZW5kZXJNYXRoTUxT dWJTdXAuY3BwICovOyB9OwogCQlGQUMxMkNDNTExMjBEQTY5MDBEQUNDMzYgLyogUmVuZGVyTWF0 aE1MU3ViU3VwLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYg PSBGQUMxMkNDMzExMjBEQTY5MDBEQUNDMzYgLyogUmVuZGVyTWF0aE1MU3ViU3VwLmggKi87IH07 CisJCUZCRjI4MUFGMTIwOEQzNUMwMEY3RjgxMiAvKiBBTkdMRVdlYmtpdEJyaWRnZS5jcHAgaW4g U291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGQkYyODFBRDEyMDhE MzVDMDBGN0Y4MTIgLyogQU5HTEVXZWJraXRCcmlkZ2UuY3BwICovOyB9OwogCQlGRTZGRDQ4ODBG Njc2RTU3MDAwOTI4NzMgLyogQ29vcmRpbmF0ZXMuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBC WEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEZFNkZENDg1MEY2NzZFNTcwMDA5Mjg3MyAvKiBDb29yZGlu YXRlcy5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJ CUZFNkZENDhEMEY2NzZFOTMwMDA5Mjg3MyAvKiBKU0Nvb3JkaW5hdGVzLmNwcCBpbiBTb3VyY2Vz ICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEZFNkZENDhCMEY2NzZFOTMwMDA5 Mjg3MyAvKiBKU0Nvb3JkaW5hdGVzLmNwcCAqLzsgfTsKIAkJRkU2RkQ0OEUwRjY3NkU5MzAwMDky ODczIC8qIEpTQ29vcmRpbmF0ZXMuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmls ZTsgZmlsZVJlZiA9IEZFNkZENDhDMEY2NzZFOTMwMDA5Mjg3MyAvKiBKU0Nvb3JkaW5hdGVzLmgg Ki87IH07CkBAIC0xMTAwMiw2ICsxMTAwMyw4IEBACiAJCUZBQkU3MkZDMTA1OUMyMTEwMEQ5OTlE RCAvKiBNYXRoTUxOYW1lcy5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGgg PSBNYXRoTUxOYW1lcy5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUZBQzEyQ0My MTEyMERBNjkwMERBQ0MzNiAvKiBSZW5kZXJNYXRoTUxTdWJTdXAuY3BwICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291 cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gUmVuZGVyTWF0aE1MU3ViU3VwLmNwcDsgc291cmNlVHJl ZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRkFDMTJDQzMxMTIwREE2OTAwREFDQzM2IC8qIFJlbmRlck1h dGhNTFN1YlN1cC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9 IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBSZW5kZXJNYXRo TUxTdWJTdXAuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJRkJGMjgxQUQxMjA4RDM1 QzAwRjdGODEyIC8qIEFOR0xFV2Via2l0QnJpZGdlLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVm ZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUu Y3BwLmNwcDsgcGF0aCA9IEFOR0xFV2Via2l0QnJpZGdlLmNwcDsgc291cmNlVHJlZSA9ICI8Z3Jv dXA+IjsgfTsKKwkJRkJGMjgxQUUxMjA4RDM1QzAwRjdGODEyIC8qIEFOR0xFV2Via2l0QnJpZGdl LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtu b3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEFOR0xFV2Via2l0QnJpZGdlLmg7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUZFNDlFRjk3MERDNTE0NjIwMDQyNjZFMSAv KiBEYXNoYm9hcmRTdXBwb3J0Q1NTUHJvcGVydHlOYW1lcy5pbiAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHRleHQ7IHBh dGggPSBEYXNoYm9hcmRTdXBwb3J0Q1NTUHJvcGVydHlOYW1lcy5pbjsgc291cmNlVHJlZSA9ICI8 Z3JvdXA+IjsgfTsKIAkJRkU2RkQ0ODUwRjY3NkU1NzAwMDkyODczIC8qIENvb3JkaW5hdGVzLmgg Ki8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3du RmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IENvb3JkaW5hdGVzLmg7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07CiAJCUZFNkZENDg2MEY2NzZFNTcwMDA5Mjg3MyAvKiBDb29yZGlu YXRlcy5pZGwgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsg bGFzdEtub3duRmlsZVR5cGUgPSB0ZXh0OyBwYXRoID0gQ29vcmRpbmF0ZXMuaWRsOyBzb3VyY2VU cmVlID0gIjxncm91cD4iOyB9OwpAQCAtMTU1MjEsNiArMTU1MjQsOCBAQAogCQkJCUIyNzUzNTQ5 MEIwNTM4MTQwMDJDRTY0RiAvKiBtYWMgKi8sCiAJCQkJRjRFQUY0QUIxMEM3NDI2ODAwOTEwMEQz IC8qIG9wZW50eXBlICovLAogCQkJCTQ5RTkxMUIyMEVGODZEMjcwMDlEMENBRiAvKiB0cmFuc2Zv cm1zICovLAorCQkJCUZCRjI4MUFEMTIwOEQzNUMwMEY3RjgxMiAvKiBBTkdMRVdlYmtpdEJyaWRn ZS5jcHAgKi8sCisJCQkJRkJGMjgxQUUxMjA4RDM1QzAwRjdGODEyIC8qIEFOR0xFV2Via2l0QnJp ZGdlLmggKi8sCiAJCQkJQTg5OTQzMjcwQjQyMzM4NzAwRDdDODAyIC8qIEJpdG1hcEltYWdlLmNw cCAqLywKIAkJCQlBODk5NDMyNjBCNDIzMzg3MDBEN0M4MDIgLyogQml0bWFwSW1hZ2UuaCAqLywK IAkJCQlCMjc1MzUzODBCMDUzODE0MDAyQ0U2NEYgLyogQ29sb3IuY3BwICovLApAQCAtMjIzODYs NiArMjIzOTEsNyBAQAogCQkJCTkzRjE5QjA1MDgyNDVFNTkwMDFFOUFCQyAvKiBYU0xUUHJvY2Vz c29yTGlieHNsdC5jcHAgaW4gU291cmNlcyAqLywKIAkJCQlFMUJFNTEyRDBDRjZDNTEyMDAyRUE5 NTkgLyogWFNMVFVuaWNvZGVTb3J0LmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTk3REQ0RDg2MEZE RjRENkUwMEVDRjlBNCAvKiBYU1NBdWRpdG9yLmNwcCBpbiBTb3VyY2VzICovLAorCQkJCUZCRjI4 MUFGMTIwOEQzNUMwMEY3RjgxMiAvKiBBTkdMRVdlYmtpdEJyaWRnZS5jcHAgaW4gU291cmNlcyAq LywKIAkJCSk7CiAJCQlydW5Pbmx5Rm9yRGVwbG95bWVudFBvc3Rwcm9jZXNzaW5nID0gMDsKIAkJ fTsKSW5kZXg6IFdlYkNvcmUvaHRtbC9jYW52YXMvV2ViR0xSZW5kZXJpbmdDb250ZXh0LmNwcAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBXZWJDb3JlL2h0bWwvY2FudmFzL1dlYkdMUmVuZGVyaW5nQ29udGV4dC5j cHAJKHJldmlzaW9uIDY0NzgxKQorKysgV2ViQ29yZS9odG1sL2NhbnZhcy9XZWJHTFJlbmRlcmlu Z0NvbnRleHQuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC00MSw2ICs0MSw3IEBACiAjaW5jbHVkZSAi Tm90SW1wbGVtZW50ZWQuaCIKICNpbmNsdWRlICJSZW5kZXJCb3guaCIKICNpbmNsdWRlICJSZW5k ZXJMYXllci5oIgorI2luY2x1ZGUgIlJlc291cmNlTGltaXRzLmgiCiAjaW5jbHVkZSAiVWludDE2 QXJyYXkuaCIKICNpbmNsdWRlICJXZWJHTEFjdGl2ZUluZm8uaCIKICNpbmNsdWRlICJXZWJHTEJ1 ZmZlci5oIgpAQCAtODUsMTQgKzg2LDE3IEBAIFBhc3NPd25QdHI8V2ViR0xSZW5kZXJpbmdDb250 ZXh0PiBXZWJHTFIKIHsKICAgICBIb3N0V2luZG93KiBob3N0V2luZG93ID0gY2FudmFzLT5kb2N1 bWVudCgpLT52aWV3KCktPnJvb3QoKS0+aG9zdFdpbmRvdygpOwogICAgIE93blB0cjxHcmFwaGlj c0NvbnRleHQzRD4gY29udGV4dChHcmFwaGljc0NvbnRleHQzRDo6Y3JlYXRlKGF0dHJzLT5hdHRy aWJ1dGVzKCksIGhvc3RXaW5kb3cpKTsKKyAgICAKKyAgICAvLyBDcmVhdGUgYW4gaW5zdGFuY2Ug b2YgdGhlIEFOR0xFIGNvbXBpbGVyCisgICAgT3duUHRyPEFOR0xFV2Via2l0QnJpZGdlPiBhbmds ZUNvbXBpbGVyKG5ldyBBTkdMRVdlYmtpdEJyaWRnZSgpKTsKIAogICAgIGlmICghY29udGV4dCkK ICAgICAgICAgcmV0dXJuIDA7CiAgICAgICAgIAotICAgIHJldHVybiBuZXcgV2ViR0xSZW5kZXJp bmdDb250ZXh0KGNhbnZhcywgY29udGV4dC5yZWxlYXNlKCkpOworICAgIHJldHVybiBuZXcgV2Vi R0xSZW5kZXJpbmdDb250ZXh0KGNhbnZhcywgY29udGV4dC5yZWxlYXNlKCksIGFuZ2xlQ29tcGls ZXIucmVsZWFzZSgpKTsKIH0KIAotV2ViR0xSZW5kZXJpbmdDb250ZXh0OjpXZWJHTFJlbmRlcmlu Z0NvbnRleHQoSFRNTENhbnZhc0VsZW1lbnQqIHBhc3NlZENhbnZhcywgUGFzc093blB0cjxHcmFw aGljc0NvbnRleHQzRD4gY29udGV4dCkKK1dlYkdMUmVuZGVyaW5nQ29udGV4dDo6V2ViR0xSZW5k ZXJpbmdDb250ZXh0KEhUTUxDYW52YXNFbGVtZW50KiBwYXNzZWRDYW52YXMsIFBhc3NPd25QdHI8 R3JhcGhpY3NDb250ZXh0M0Q+IGNvbnRleHQsIFBhc3NPd25QdHI8QU5HTEVXZWJraXRCcmlkZ2U+ IGFuZ2xlQ29tcGlsZXIpCiAgICAgOiBDYW52YXNSZW5kZXJpbmdDb250ZXh0KHBhc3NlZENhbnZh cykKICAgICAsIG1fY29udGV4dChjb250ZXh0KQogICAgICwgbV9uZWVkc1VwZGF0ZSh0cnVlKQpA QCAtMTAyLDYgKzEwNiw3IEBAIFdlYkdMUmVuZGVyaW5nQ29udGV4dDo6V2ViR0xSZW5kZXJpbmdD b24KICAgICAsIG1fdW5wYWNrQWxpZ25tZW50KDQpCiAgICAgLCBtX3VucGFja0ZsaXBZKGZhbHNl KQogICAgICwgbV91bnBhY2tQcmVtdWx0aXBseUFscGhhKGZhbHNlKQorICAgICwgbV9jb21waWxl cihhbmdsZUNvbXBpbGVyKQogewogICAgIEFTU0VSVChtX2NvbnRleHQpOwogCkBAIC0xMjcsNiAr MTMyLDI4IEBAIFdlYkdMUmVuZGVyaW5nQ29udGV4dDo6V2ViR0xSZW5kZXJpbmdDb24KICAgICBt X2NvbnRleHQtPmdldEludGVnZXJ2KEdyYXBoaWNzQ29udGV4dDNEOjpNQVhfQ1VCRV9NQVBfVEVY VFVSRV9TSVpFLCAmbV9tYXhDdWJlTWFwVGV4dHVyZVNpemUpOwogICAgIG1fbWF4Q3ViZU1hcFRl eHR1cmVMZXZlbCA9IFdlYkdMVGV4dHVyZTo6Y29tcHV0ZUxldmVsQ291bnQobV9tYXhDdWJlTWFw VGV4dHVyZVNpemUsIG1fbWF4Q3ViZU1hcFRleHR1cmVTaXplKTsKIAorICAgIFRCdWlsdEluUmVz b3VyY2UgQU5HTEVSZXNvdXJjZXM7CisgICAgCisgICAgQU5HTEVSZXNvdXJjZXMubWF4VmVydGV4 QXR0cmlicyA9IDA7CisgICAgbV9jb250ZXh0LT5nZXRJbnRlZ2VydihHcmFwaGljc0NvbnRleHQz RDo6TUFYX1ZFUlRFWF9BVFRSSUJTLCAmQU5HTEVSZXNvdXJjZXMubWF4VmVydGV4QXR0cmlicyk7 CisgICAgQU5HTEVSZXNvdXJjZXMubWF4VmVydGV4VW5pZm9ybVZlY3RvcnMgPSAwOworICAgIG1f Y29udGV4dC0+Z2V0SW50ZWdlcnYoR3JhcGhpY3NDb250ZXh0M0Q6Ok1BWF9WRVJURVhfVU5JRk9S TV9WRUNUT1JTLCAmQU5HTEVSZXNvdXJjZXMubWF4VmVydGV4VW5pZm9ybVZlY3RvcnMpOworICAg IEFOR0xFUmVzb3VyY2VzLm1heFZhcnlpbmdWZWN0b3JzID0gMDsKKyAgICBtX2NvbnRleHQtPmdl dEludGVnZXJ2KEdyYXBoaWNzQ29udGV4dDNEOjpNQVhfVkFSWUlOR19WRUNUT1JTLCAmQU5HTEVS ZXNvdXJjZXMubWF4VmFyeWluZ1ZlY3RvcnMpOworICAgIEFOR0xFUmVzb3VyY2VzLm1heFZlcnRl eFRleHR1cmVJbWFnZVVuaXRzID0gMDsKKyAgICBtX2NvbnRleHQtPmdldEludGVnZXJ2KEdyYXBo aWNzQ29udGV4dDNEOjpNQVhfVkVSVEVYX1RFWFRVUkVfSU1BR0VfVU5JVFMsICZBTkdMRVJlc291 cmNlcy5tYXhWZXJ0ZXhUZXh0dXJlSW1hZ2VVbml0cyk7CisgICAgQU5HTEVSZXNvdXJjZXMubWF4 Q29tYmluZWRUZXh0dXJlSW1hZ2VVbml0cyA9IDA7CisgICAgbV9jb250ZXh0LT5nZXRJbnRlZ2Vy dihHcmFwaGljc0NvbnRleHQzRDo6TUFYX0NPTUJJTkVEX1RFWFRVUkVfSU1BR0VfVU5JVFMsICZB TkdMRVJlc291cmNlcy5tYXhDb21iaW5lZFRleHR1cmVJbWFnZVVuaXRzKTsKKyAgICBBTkdMRVJl c291cmNlcy5tYXhUZXh0dXJlSW1hZ2VVbml0cyA9IDA7CisgICAgbV9jb250ZXh0LT5nZXRJbnRl Z2VydihHcmFwaGljc0NvbnRleHQzRDo6TUFYX1RFWFRVUkVfSU1BR0VfVU5JVFMsICZBTkdMRVJl c291cmNlcy5tYXhUZXh0dXJlSW1hZ2VVbml0cyk7CisgICAgQU5HTEVSZXNvdXJjZXMubWF4RnJh Z21lbnRVbmlmb3JtVmVjdG9ycyA9IDA7CisgICAgbV9jb250ZXh0LT5nZXRJbnRlZ2VydihHcmFw aGljc0NvbnRleHQzRDo6TUFYX0ZSQUdNRU5UX1VOSUZPUk1fVkVDVE9SUywgJkFOR0xFUmVzb3Vy Y2VzLm1heEZyYWdtZW50VW5pZm9ybVZlY3RvcnMpOworCisgICAgLy8gQWx3YXlzIHNldCB0byAx IGZvciBPcGVuR0wgRVMuCisgICAgQU5HTEVSZXNvdXJjZXMubWF4RHJhd0J1ZmZlcnMgPSAxOwor CisgICAgbV9jb21waWxlci0+c2V0UmVzb3VyY2VzKEFOR0xFUmVzb3VyY2VzKTsKKwogICAgIGlm ICghaXNHTEVTMkNvbXBsaWFudCgpKSB7CiAgICAgICAgIGNyZWF0ZUZhbGxiYWNrQmxhY2tUZXh0 dXJlczF4MSgpOwogICAgICAgICBpbml0VmVydGV4QXR0cmliMCgpOwpAQCAtNTIwLDcgKzU0Nywx MiBAQCB2b2lkIFdlYkdMUmVuZGVyaW5nQ29udGV4dDo6Y29tcGlsZVNoYWRlCiAgICAgVU5VU0VE X1BBUkFNKGVjKTsKICAgICBpZiAoIXZhbGlkYXRlV2ViR0xPYmplY3Qoc2hhZGVyKSkKICAgICAg ICAgcmV0dXJuOwotICAgIG1fY29udGV4dC0+Y29tcGlsZVNoYWRlcihvYmplY3RPclplcm8oc2hh ZGVyKSk7CisKKyAgICBpZiAobV9jb21waWxlci0+dmFsaWRhdGVTaGFkZXIoc2hhZGVyLCBnZXRT aGFkZXJTb3VyY2Uoc2hhZGVyLCBlYykudXRmOCgpLmRhdGEoKSkpIHsKKyAgICAgICAgc2hhZGVy U291cmNlKHNoYWRlciwgc2hhZGVyLT50cmFuc2xhdGVkU291cmNlKCksIGVjKTsKKyAgICAgICAg bV9jb250ZXh0LT5jb21waWxlU2hhZGVyKG9iamVjdE9yWmVybyhzaGFkZXIpKTsKKyAgICB9CisK ICAgICBjbGVhbnVwQWZ0ZXJHcmFwaGljc0NhbGwoZmFsc2UpOwogfQogCkBAIC0xNTYwLDcgKzE1 OTIsMTIgQEAgU3RyaW5nIFdlYkdMUmVuZGVyaW5nQ29udGV4dDo6Z2V0U2hhZGVySQogICAgIGlm ICghdmFsaWRhdGVXZWJHTE9iamVjdChzaGFkZXIpKQogICAgICAgICByZXR1cm4gIiI7CiAgICAg V2ViR0xTdGF0ZVJlc3RvcmVyKHRoaXMsIGZhbHNlKTsKLSAgICByZXR1cm4gbV9jb250ZXh0LT5n ZXRTaGFkZXJJbmZvTG9nKG9iamVjdE9yWmVybyhzaGFkZXIpKTsKKworICAgIC8vIElmIHRoZSBz aGFkZXIgZmFpbGVkIHZhbGlkYXRpb24sIHJldHVybiB0aGUgQU5HTEUgdmFsaWRhdGlvbiBsb2cg aW5zdGVhZAorICAgIGlmIChzaGFkZXItPmlzVmFsaWQoKSkKKyAgICAgICAgcmV0dXJuIG1fY29u dGV4dC0+Z2V0U2hhZGVySW5mb0xvZyhvYmplY3RPclplcm8oc2hhZGVyKSk7CisKKyAgICByZXR1 cm4gc2hhZGVyLT52YWxpZGF0b3JMb2coKTsKIH0KIAogU3RyaW5nIFdlYkdMUmVuZGVyaW5nQ29u dGV4dDo6Z2V0U2hhZGVyU291cmNlKFdlYkdMU2hhZGVyKiBzaGFkZXIsIEV4Y2VwdGlvbkNvZGUm IGVjKQpJbmRleDogV2ViQ29yZS9odG1sL2NhbnZhcy9XZWJHTFJlbmRlcmluZ0NvbnRleHQuaAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBXZWJDb3JlL2h0bWwvY2FudmFzL1dlYkdMUmVuZGVyaW5nQ29udGV4dC5o CShyZXZpc2lvbiA2NDc4MSkKKysrIFdlYkNvcmUvaHRtbC9jYW52YXMvV2ViR0xSZW5kZXJpbmdD b250ZXh0LmgJKHdvcmtpbmcgY29weSkKQEAgLTI2LDYgKzI2LDcgQEAKICNpZm5kZWYgV2ViR0xS ZW5kZXJpbmdDb250ZXh0X2gKICNkZWZpbmUgV2ViR0xSZW5kZXJpbmdDb250ZXh0X2gKIAorI2lu Y2x1ZGUgIkFOR0xFV2Via2l0QnJpZGdlLmgiCiAjaW5jbHVkZSAiQ2FudmFzUmVuZGVyaW5nQ29u dGV4dC5oIgogI2luY2x1ZGUgIkV4Y2VwdGlvbkNvZGUuaCIKICNpbmNsdWRlICJGbG9hdDMyQXJy YXkuaCIKQEAgLTMwMyw2ICszMDQsNyBAQCBwdWJsaWM6CiAKICAgICB2b2lkIHZpZXdwb3J0KGxv bmcgeCwgbG9uZyB5LCB1bnNpZ25lZCBsb25nIHdpZHRoLCB1bnNpZ25lZCBsb25nIGhlaWdodCk7 CiAKKyAgICBXZWJHTFJlbmRlcmluZ0NvbnRleHQoSFRNTENhbnZhc0VsZW1lbnQqLCBQYXNzT3du UHRyPEdyYXBoaWNzQ29udGV4dDNEPiwgUGFzc093blB0cjxBTkdMRVdlYmtpdEJyaWRnZT4pOwog ICAgIHZpcnR1YWwgR3JhcGhpY3NDb250ZXh0M0QqIGdyYXBoaWNzQ29udGV4dDNEKCkgY29uc3Qg eyByZXR1cm4gbV9jb250ZXh0LmdldCgpOyB9CiAKICAgICB2b2lkIHJlc2hhcGUoaW50IHdpZHRo LCBpbnQgaGVpZ2h0KTsKQEAgLTM1MSw2ICszNTMsNyBAQCBwdWJsaWM6CiAgICAgYm9vbCB2YWxp ZGF0ZVdlYkdMT2JqZWN0KFdlYkdMT2JqZWN0KiBvYmplY3QpOwogCiAgICAgT3duUHRyPEdyYXBo aWNzQ29udGV4dDNEPiBtX2NvbnRleHQ7CisKICAgICBib29sIG1fbmVlZHNVcGRhdGU7CiAgICAg Ym9vbCBtX21hcmtlZENhbnZhc0RpcnR5OwogICAgIC8vIEZJWE1FOiBJIHRoaW5rIHRoaXMgaXMg YnJva2VuIC0tIGl0IGRvZXMgbm90IGluY3JlbWVudCBhbnkKQEAgLTQyOSw2ICs0MzIsOCBAQCBw dWJsaWM6CiAgICAgYm9vbCBtX3VucGFja0ZsaXBZOwogICAgIGJvb2wgbV91bnBhY2tQcmVtdWx0 aXBseUFscGhhOwogCisgICAgT3duUHRyPEFOR0xFV2Via2l0QnJpZGdlPiBtX2NvbXBpbGVyOwor CiAgICAgLy8gSGVscGVycyBmb3IgZ2V0UGFyYW1ldGVyIGFuZCBvdGhlcnMKICAgICBXZWJHTEdl dEluZm8gZ2V0Qm9vbGVhblBhcmFtZXRlcih1bnNpZ25lZCBsb25nIHBuYW1lKTsKICAgICBXZWJH TEdldEluZm8gZ2V0Qm9vbGVhbkFycmF5UGFyYW1ldGVyKHVuc2lnbmVkIGxvbmcgcG5hbWUpOwpJ bmRleDogV2ViQ29yZS9odG1sL2NhbnZhcy9XZWJHTFNoYWRlci5jcHAKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g V2ViQ29yZS9odG1sL2NhbnZhcy9XZWJHTFNoYWRlci5jcHAJKHJldmlzaW9uIDY0NzgxKQorKysg V2ViQ29yZS9odG1sL2NhbnZhcy9XZWJHTFNoYWRlci5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTM5 LDggKzM5LDkgQEAgUGFzc1JlZlB0cjxXZWJHTFNoYWRlcj4gV2ViR0xTaGFkZXI6OmNyZQogfQog CiBXZWJHTFNoYWRlcjo6V2ViR0xTaGFkZXIoV2ViR0xSZW5kZXJpbmdDb250ZXh0KiBjdHgsIEdy YXBoaWNzQ29udGV4dDNEOjpXZWJHTEVudW1UeXBlIHR5cGUpCi0gICAgOiBXZWJHTE9iamVjdChj dHgpCi0gICAgLCBtX3R5cGUodHlwZSkKKyAgICA6IFdlYkdMT2JqZWN0KGN0eCksCisgICAgbV90 eXBlKHR5cGUpLCAKKyAgICBtX3ZhbGlkKGZhbHNlKQogewogICAgIHNldE9iamVjdChjb250ZXh0 KCktPmdyYXBoaWNzQ29udGV4dDNEKCktPmNyZWF0ZVNoYWRlcih0eXBlKSk7CiB9CkluZGV4OiBX ZWJDb3JlL2h0bWwvY2FudmFzL1dlYkdMU2hhZGVyLmgKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9o dG1sL2NhbnZhcy9XZWJHTFNoYWRlci5oCShyZXZpc2lvbiA2NDc4MSkKKysrIFdlYkNvcmUvaHRt bC9jYW52YXMvV2ViR0xTaGFkZXIuaAkod29ya2luZyBjb3B5KQpAQCAtNDAsNiArNDAsMTUgQEAg cHVibGljOgogICAgIHN0YXRpYyBQYXNzUmVmUHRyPFdlYkdMU2hhZGVyPiBjcmVhdGUoV2ViR0xS ZW5kZXJpbmdDb250ZXh0KiwgR3JhcGhpY3NDb250ZXh0M0Q6OldlYkdMRW51bVR5cGUpOwogCiAg ICAgR3JhcGhpY3NDb250ZXh0M0Q6OldlYkdMRW51bVR5cGUgZ2V0VHlwZSgpIGNvbnN0IHsgcmV0 dXJuIG1fdHlwZTsgfQorICAgIAorICAgIGJvb2wgaXNWYWxpZCgpIHsgcmV0dXJuIG1fdmFsaWQ7 IH0KKyAgICB2b2lkIHNldFZhbGlkKGJvb2wgdmFsaWRhdGVkKSB7IG1fdmFsaWQgPSB2YWxpZGF0 ZWQ7IH0KKyAgICAKKyAgICBTdHJpbmcgdmFsaWRhdG9yTG9nKCkgeyByZXR1cm4gbV92YWxpZGF0 b3JMb2c7IH0KKyAgICB2b2lkIHZhbGlkYXRvckxvZyhTdHJpbmcgbWVzc2FnZXMpIHsgbV92YWxp ZGF0b3JMb2cgPSBtZXNzYWdlczsgfQorICAgIAorICAgIFN0cmluZyB0cmFuc2xhdGVkU291cmNl KCkgeyByZXR1cm4gbV90cmFuc2xhdGVkU291cmNlOyB9CisgICAgdm9pZCB0cmFuc2xhdGVkU291 cmNlKFN0cmluZyBzb3VyY2UpIHsgbV90cmFuc2xhdGVkU291cmNlID0gc291cmNlOyB9CiAKIHBy aXZhdGU6CiAgICAgV2ViR0xTaGFkZXIoV2ViR0xSZW5kZXJpbmdDb250ZXh0KiwgR3JhcGhpY3ND b250ZXh0M0Q6OldlYkdMRW51bVR5cGUpOwpAQCAtNDksNiArNTgsMTMgQEAgcHJpdmF0ZToKICAg ICB2aXJ0dWFsIGJvb2wgaXNTaGFkZXIoKSBjb25zdCB7IHJldHVybiB0cnVlOyB9CiAKICAgICBH cmFwaGljc0NvbnRleHQzRDo6V2ViR0xFbnVtVHlwZSBtX3R5cGU7CisgICAgCisgICAgU3RyaW5n IG1fdmFsaWRhdG9yTG9nOworCisgICAgLy8gRGVza3RvcCBHTFNMIHNvdXJjZQorICAgIFN0cmlu ZyBtX3RyYW5zbGF0ZWRTb3VyY2U7CisKKyAgICBib29sIG1fdmFsaWQ7CiB9OwogCiB9IC8vIG5h bWVzcGFjZSBXZWJDb3JlCkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0FOR0xFV2Vi a2l0QnJpZGdlLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0FO R0xFV2Via2l0QnJpZGdlLmNwcAkocmV2aXNpb24gMCkKKysrIFdlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvQU5HTEVXZWJraXRCcmlkZ2UuY3BwCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDgzIEBA CisvKgorICogQ29weXJpZ2h0IChDKSAyMDA5IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZl ZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZv cm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92 aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJl ZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJp Z2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93 aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVz dCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qg b2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAg ZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRp c3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIENP TVBVVEVSLCBJTkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FS UkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBX QVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFS CisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgQ09N UFVURVIsIElOQy4gT1IKKyAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1Qs IElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAorICogRVhFTVBMQVJZLCBPUiBDT05TRVFV RU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogUFJPQ1VS RU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEs IE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VE IEFORCBPTiBBTlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1Qs IFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBP VEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBT T0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFH RS4gCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorCisjaWYgRU5BQkxFKDNEX0NBTlZBUykK KworI2luY2x1ZGUgIkFOR0xFV2Via2l0QnJpZGdlLmgiCisKKyNpbmNsdWRlICJTaGFkZXJMYW5n LmgiCisjaW5jbHVkZSAiV2ViR0xTaGFkZXIuaCIKKworI2luY2x1ZGUgPHd0Zi90ZXh0L0NTdHJp bmcuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCisKK0FOR0xFV2Via2l0QnJpZGdlOjpBTkdM RVdlYmtpdEJyaWRnZSgpCit7CisgICAgU2hJbml0aWFsaXplKCk7CisgICAgCisgICAgbV9mcmFn bWVudENvbXBpbGVyID0gU2hDb25zdHJ1Y3RDb21waWxlcihFU2hMYW5nRnJhZ21lbnQsIEVTaFNw ZWNXZWJHTCk7CisgICAgbV92ZXJ0ZXhDb21waWxlciA9IFNoQ29uc3RydWN0Q29tcGlsZXIoRVNo TGFuZ1ZlcnRleCwgRVNoU3BlY1dlYkdMKTsKK30KKworQU5HTEVXZWJraXRCcmlkZ2U6On5BTkdM RVdlYmtpdEJyaWRnZSgpCit7CisgICAgU2hEZXN0cnVjdChtX2ZyYWdtZW50Q29tcGlsZXIpOwor ICAgIFNoRGVzdHJ1Y3QobV92ZXJ0ZXhDb21waWxlcik7Cit9CisKK2Jvb2wgQU5HTEVXZWJraXRC cmlkZ2U6OnZhbGlkYXRlU2hhZGVyKFdlYkdMU2hhZGVyKiBzaGFkZXIsIGNvbnN0IGNoYXIqIHNo YWRlclNvdXJjZSkKK3sKKyAgICBTaEhhbmRsZSBjb21waWxlcjsKKyAgICAKKyAgICBpZiAoc2hh ZGVyLT5nZXRUeXBlKCkgPT0gR3JhcGhpY3NDb250ZXh0M0Q6OlZFUlRFWF9TSEFERVIpCisgICAg ICAgIGNvbXBpbGVyID0gbV92ZXJ0ZXhDb21waWxlcjsKKyAgICBlbHNlIGlmIChzaGFkZXItPmdl dFR5cGUoKSA9PSBHcmFwaGljc0NvbnRleHQzRDo6RlJBR01FTlRfU0hBREVSKQorICAgICAgICBj b21waWxlciA9IG1fZnJhZ21lbnRDb21waWxlcjsKKyAgICBlbHNlCisgICAgICAgIHJldHVybiBm YWxzZTsgLy8gSW52YWxpZCBzaGFkZXIgdHlwZQorICAgIAorICAgIGNvbnN0IGNoYXIqIGNvbnN0 IHNoYWRlclNvdXJjZVN0cmluZ3NbXSA9IHtzaGFkZXJTb3VyY2V9OworICAgIAorICAgIGJvb2wg dmFsaWRhdGVTdWNjZXNzID0gU2hDb21waWxlKGNvbXBpbGVyLCBzaGFkZXJTb3VyY2VTdHJpbmdz LCAxLCBFU2hPcHROb25lLCAmbV9yZXNvdXJjZXMsIEVEZWJ1Z09wSW50ZXJtZWRpYXRlKTsKKyAg ICAKKyAgICBzaGFkZXItPnNldFZhbGlkKHZhbGlkYXRlU3VjY2Vzcyk7CisgICAgCisgICAgaWYg KHZhbGlkYXRlU3VjY2VzcykKKyAgICAgICAgc2hhZGVyLT50cmFuc2xhdGVkU291cmNlKFNoR2V0 T2JqZWN0Q29kZShjb21waWxlcikpOworICAgIGVsc2UgeworICAgICAgICAvLyBGSVhNRTogZHJv cCBpbiBTaEdldFZhbGlkYXRvckxvZyBvbmNlIG5ldyBwYXRjaGVzIGFyZSBhY2NlcHRlZCBieSBB TkdMRQorICAgICAgICBzaGFkZXItPnZhbGlkYXRvckxvZygiVmFsaWRhdGlvbiBmYWlsZWQuIik7 CisgICAgfQorCisgICAgcmV0dXJuIHZhbGlkYXRlU3VjY2VzczsKK30KKworfQorCisjZW5kaWYg Ly8gRU5BQkxFKDNEX0NBTlZBUykKSW5kZXg6IFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvQU5H TEVXZWJraXRCcmlkZ2UuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L0FOR0xFV2Via2l0QnJpZGdlLmgJKHJldmlzaW9uIDApCisrKyBXZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL0FOR0xFV2Via2l0QnJpZGdlLmgJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNTUgQEAK Ky8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMDkgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVk LgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9y bXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3Zp ZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVk aXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmln aHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0 IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBv ZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBk b2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlz dHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgQ09N UFVURVIsIElOQy4gYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJS QU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdB UlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIK KyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBDT01Q VVRFUiwgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwg SU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVF TlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJF TUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwg T1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQg QU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwg U1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9U SEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNP RlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdF LiAKKyAqLworCisjaWZuZGVmIEFOR0xFV2Via2l0QnJpZGdlX2gKKyNkZWZpbmUgQU5HTEVXZWJr aXRCcmlkZ2VfaAorCisjaW5jbHVkZSAiR3JhcGhpY3NDb250ZXh0M0QuaCIKKyNpbmNsdWRlICJT aGFkZXJMYW5nLmgiCisjaW5jbHVkZSAiV2ViR0xTaGFkZXIuaCIKKworbmFtZXNwYWNlIFdlYkNv cmUgeworCitjbGFzcyBBTkdMRVdlYmtpdEJyaWRnZSB7CitwdWJsaWM6CisKKyAgICBBTkdMRVdl YmtpdEJyaWRnZSgpOworICAgIH5BTkdMRVdlYmtpdEJyaWRnZSgpOworICAgIAorICAgIHZvaWQg c2V0UmVzb3VyY2VzKFRCdWlsdEluUmVzb3VyY2UgcmVzb3VyY2VzKSB7IG1fcmVzb3VyY2VzID0g cmVzb3VyY2VzOyB9CisKKyAgICBib29sIHZhbGlkYXRlU2hhZGVyKFdlYkdMU2hhZGVyKiBzaGFk ZXIsIGNvbnN0IGNoYXIqIHNoYWRlclNvdXJjZSk7CisKK3ByaXZhdGU6CisgICAgCisgICAgU2hI YW5kbGUgbV9mcmFnbWVudENvbXBpbGVyOworICAgIFNoSGFuZGxlIG1fdmVydGV4Q29tcGlsZXI7 CisKKyAgICBUQnVpbHRJblJlc291cmNlIG1fcmVzb3VyY2VzOworfTsKKworfSAvLyBuYW1lc3Bh Y2UgV2ViQ29yZQorCisjZW5kaWYK 64080 2010-08-11 00:19:51 -0700 2010-08-13 15:49:01 -0700 Stores data about shader (log, translated source, if valid) in HashMap instead of WebGLShader object angle-for-translation text/plain 18065 psawaya SW5kZXg6IFdlYkNvcmUvV2ViQ29yZS5neXBpCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvV2ViQ29y ZS5neXBpCShyZXZpc2lvbiA2NTA4MCkKKysrIFdlYkNvcmUvV2ViQ29yZS5neXBpCSh3b3JraW5n IGNvcHkpCkBAIC0yNDQ4LDYgKzI0NDgsOCBAQAogICAgICAgICAgICAgJ3BsYXRmb3JtL2dyYXBo aWNzL3d4L1Blbld4LmNwcCcsCiAgICAgICAgICAgICAncGxhdGZvcm0vZ3JhcGhpY3Mvd3gvU2lt cGxlRm9udERhdGFXeC5jcHAnLAogICAgICAgICAgICAgJ3BsYXRmb3JtL2dyYXBoaWNzL3d4L1Ry YW5zZm9ybWF0aW9uTWF0cml4V3guY3BwJywKKyAgICAgICAgICAgICdwbGF0Zm9ybS9ncmFwaGlj cy9BTkdMRVdlYmtpdEJyaWRnZS5jcHAnLAorICAgICAgICAgICAgJ3BsYXRmb3JtL2dyYXBoaWNz L0FOR0xFV2Via2l0QnJpZGdlLmgnLAogICAgICAgICAgICAgJ3BsYXRmb3JtL2dyYXBoaWNzL0Jp dG1hcEltYWdlLmNwcCcsCiAgICAgICAgICAgICAncGxhdGZvcm0vZ3JhcGhpY3MvQml0bWFwSW1h Z2UuaCcsCiAgICAgICAgICAgICAncGxhdGZvcm0vZ3JhcGhpY3MvQ29sb3IuY3BwJywKSW5kZXg6 IFdlYkNvcmUvQ29uZmlndXJhdGlvbnMvV2ViQ29yZS54Y2NvbmZpZwo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBX ZWJDb3JlL0NvbmZpZ3VyYXRpb25zL1dlYkNvcmUueGNjb25maWcJKHJldmlzaW9uIDY1MDgwKQor KysgV2ViQ29yZS9Db25maWd1cmF0aW9ucy9XZWJDb3JlLnhjY29uZmlnCSh3b3JraW5nIGNvcHkp CkBAIC00MywxNCArNDMsMTQgQEAgRlJBTUVXT1JLX1NFQVJDSF9QQVRIU19pcGhvbmVvc19Qcm9k dWN0aQogRlJBTUVXT1JLX1NFQVJDSF9QQVRIU19pcGhvbmVzaW11bGF0b3IgPSAkKEZSQU1FV09S S19TRUFSQ0hfUEFUSFNfaXBob25lb3NfJChDT05GSUdVUkFUSU9OKSk7CiBGUkFNRVdPUktfU0VB UkNIX1BBVEhTX21hY29zeCA9ICQoU1lTVEVNX0xJQlJBUllfRElSKS9GcmFtZXdvcmtzL0NhcmJv bi5mcmFtZXdvcmsvRnJhbWV3b3JrcyAkKFNZU1RFTV9MSUJSQVJZX0RJUikvRnJhbWV3b3Jrcy9B cHBsaWNhdGlvblNlcnZpY2VzLmZyYW1ld29yay9GcmFtZXdvcmtzICQoRlJBTUVXT1JLX1NFQVJD SF9QQVRIUyk7CiAKLUhFQURFUl9TRUFSQ0hfUEFUSFMgPSBGb3J3YXJkaW5nSGVhZGVycyBpY3Ug L3Vzci9pbmNsdWRlL2xpYnhzbHQgL3Vzci9pbmNsdWRlL2xpYnhtbDIgJChTUUxJVEUzX0hFQURF Ul9TRUFSQ0hfUEFUSFMpICIke0JVSUxUX1BST0RVQ1RTX0RJUn0vRGVyaXZlZFNvdXJjZXMvV2Vi Q29yZSIgJChIRUFERVJfU0VBUkNIX1BBVEhTKTsKK0hFQURFUl9TRUFSQ0hfUEFUSFMgPSBGb3J3 YXJkaW5nSGVhZGVycyBpY3UgL3Vzci9pbmNsdWRlL2xpYnhzbHQgL3Vzci9pbmNsdWRlL2xpYnht bDIgJChTUUxJVEUzX0hFQURFUl9TRUFSQ0hfUEFUSFMpICIke0JVSUxUX1BST0RVQ1RTX0RJUn0v RGVyaXZlZFNvdXJjZXMvV2ViQ29yZSIgIiR7QlVJTFRfUFJPRFVDVFNfRElSfS91c3IvbG9jYWwv aW5jbHVkZSIgJChIRUFERVJfU0VBUkNIX1BBVEhTKTsKIElORk9QTElTVF9GSUxFID0gSW5mby5w bGlzdDsKIElOU1RBTExfUEFUSCA9ICQoSU5TVEFMTF9QQVRIXyQoUkVBTF9QTEFURk9STV9OQU1F KSk7CiBJTlNUQUxMX1BBVEhfbWFjb3N4ID0gJChTWVNURU1fTElCUkFSWV9ESVIpL0ZyYW1ld29y a3MvV2ViS2l0LmZyYW1ld29yay9WZXJzaW9ucy9BL0ZyYW1ld29ya3M7CiBJTlNUQUxMSERSU19D T1BZX1BIQVNFID0gWUVTOwogSU5TVEFMTEhEUlNfU0NSSVBUX1BIQVNFID0gWUVTOwogUFJPRFVD VF9OQU1FID0gV2ViQ29yZTsKLU9USEVSX0xERkxBR1NfQkFTRSA9IC1sJChTUUxJVEUzX0xJQlJB UlkpIC1sb2JqYzsKK09USEVSX0xERkxBR1NfQkFTRSA9IC1sJChTUUxJVEUzX0xJQlJBUlkpIC1s b2JqYyAtbEFOR0xFOwogT1RIRVJfTERGTEFHUyA9ICQoT1RIRVJfTERGTEFHU18kKFJFQUxfUExB VEZPUk1fTkFNRSkpOwogT1RIRVJfTERGTEFHU19pcGhvbmVvcyA9ICQoT1RIRVJfTERGTEFHU19C QVNFKSAtZnJhbWV3b3JrIENGTmV0d29yayAtZnJhbWV3b3JrIENvcmVGb3VuZGF0aW9uIC1mcmFt ZXdvcmsgQ29yZUdyYXBoaWNzIC1mcmFtZXdvcmsgQ29yZVRleHQgLWZyYW1ld29yayBGb3VuZGF0 aW9uIC1mcmFtZXdvcmsgR3JhcGhpY3NTZXJ2aWNlcyAtZnJhbWV3b3JrIEltYWdlSU8gLWZyYW1l d29yayBRdWFydHpDb3JlOwogT1RIRVJfTERGTEFHU19pcGhvbmVzaW11bGF0b3IgPSAkKE9USEVS X0xERkxBR1NfaXBob25lb3MpOwpJbmRleDogV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9q ZWN0LnBieHByb2oKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9q ZWN0LnBieHByb2oJKHJldmlzaW9uIDY1MDgwKQorKysgV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJv ai9wcm9qZWN0LnBieHByb2oJKHdvcmtpbmcgY29weSkKQEAgLTUyNzIsNiArNTI3Miw4IEBACiAJ CUZBQkU3MkZFMTA1OUMyMTEwMEQ5OTlERCAvKiBNYXRoTUxOYW1lcy5jcHAgaW4gU291cmNlcyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGQUJFNzJGQzEwNTlDMjExMDBEOTk5 REQgLyogTWF0aE1MTmFtZXMuY3BwICovOyB9OwogCQlGQUMxMkNDNDExMjBEQTY5MDBEQUNDMzYg LyogUmVuZGVyTWF0aE1MU3ViU3VwLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IEZBQzEyQ0MyMTEyMERBNjkwMERBQ0MzNiAvKiBSZW5kZXJNYXRoTUxT dWJTdXAuY3BwICovOyB9OwogCQlGQUMxMkNDNTExMjBEQTY5MDBEQUNDMzYgLyogUmVuZGVyTWF0 aE1MU3ViU3VwLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYg PSBGQUMxMkNDMzExMjBEQTY5MDBEQUNDMzYgLyogUmVuZGVyTWF0aE1MU3ViU3VwLmggKi87IH07 CisJCUZCOEM1OUNBMTIxMjEzMkMwMDBBMzcxRCAvKiBBTkdMRVdlYmtpdEJyaWRnZS5jcHAgaW4g U291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGQkYyODFBRDEyMDhE MzVDMDBGN0Y4MTIgLyogQU5HTEVXZWJraXRCcmlkZ2UuY3BwICovOyB9OworCQlGQjhDNTlDQjEy MTIxMzJDMDAwQTM3MUQgLyogQU5HTEVXZWJraXRCcmlkZ2UuaCBpbiBIZWFkZXJzICovID0ge2lz YSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEZCRjI4MUFFMTIwOEQzNUMwMEY3RjgxMiAvKiBB TkdMRVdlYmtpdEJyaWRnZS5oICovOyB9OwogCQlGRTZGRDQ4ODBGNjc2RTU3MDAwOTI4NzMgLyog Q29vcmRpbmF0ZXMuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IEZFNkZENDg1MEY2NzZFNTcwMDA5Mjg3MyAvKiBDb29yZGluYXRlcy5oICovOyBzZXR0aW5n cyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCUZFNkZENDhEMEY2NzZFOTMw MDA5Mjg3MyAvKiBKU0Nvb3JkaW5hdGVzLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IEZFNkZENDhCMEY2NzZFOTMwMDA5Mjg3MyAvKiBKU0Nvb3JkaW5h dGVzLmNwcCAqLzsgfTsKIAkJRkU2RkQ0OEUwRjY3NkU5MzAwMDkyODczIC8qIEpTQ29vcmRpbmF0 ZXMuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEZFNkZE NDhDMEY2NzZFOTMwMDA5Mjg3MyAvKiBKU0Nvb3JkaW5hdGVzLmggKi87IH07CkBAIC0xMTA4MCw2 ICsxMTA4Miw4IEBACiAJCUZBQkU3MkZDMTA1OUMyMTEwMEQ5OTlERCAvKiBNYXRoTUxOYW1lcy5j cHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtu b3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBNYXRoTUxOYW1lcy5jcHA7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUZBQzEyQ0MyMTEyMERBNjkwMERBQ0MzNiAv KiBSZW5kZXJNYXRoTUxTdWJTdXAuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZp bGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBw YXRoID0gUmVuZGVyTWF0aE1MU3ViU3VwLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsK IAkJRkFDMTJDQzMxMTIwREE2OTAwREFDQzM2IC8qIFJlbmRlck1hdGhNTFN1YlN1cC5oICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVU eXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBSZW5kZXJNYXRoTUxTdWJTdXAuaDsgc291cmNl VHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJRkJGMjgxQUQxMjA4RDM1QzAwRjdGODEyIC8qIEFOR0xF V2Via2l0QnJpZGdlLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEFO R0xFV2Via2l0QnJpZGdlLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJRkJGMjgx QUUxMjA4RDM1QzAwRjdGODEyIC8qIEFOR0xFV2Via2l0QnJpZGdlLmggKi8gPSB7aXNhID0gUEJY RmlsZVJlZmVyZW5jZTsgZXhwbGljaXRGaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBmaWxlRW5j b2RpbmcgPSA0OyBwYXRoID0gQU5HTEVXZWJraXRCcmlkZ2UuaDsgc291cmNlVHJlZSA9ICI8Z3Jv dXA+IjsgfTsKIAkJRkU0OUVGOTcwREM1MTQ2MjAwNDI2NkUxIC8qIERhc2hib2FyZFN1cHBvcnRD U1NQcm9wZXJ0eU5hbWVzLmluICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNv ZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gdGV4dDsgcGF0aCA9IERhc2hib2FyZFN1cHBv cnRDU1NQcm9wZXJ0eU5hbWVzLmluOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGRTZG RDQ4NTBGNjc2RTU3MDAwOTI4NzMgLyogQ29vcmRpbmF0ZXMuaCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuYy5oOyBwYXRoID0gQ29vcmRpbmF0ZXMuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsK IAkJRkU2RkQ0ODYwRjY3NkU1NzAwMDkyODczIC8qIENvb3JkaW5hdGVzLmlkbCAqLyA9IHtpc2Eg PSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9 IHRleHQ7IHBhdGggPSBDb29yZGluYXRlcy5pZGw7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CkBAIC0xNTYzMiw2ICsxNTYzNiw4IEBACiAJCQkJQjI3NTM1NDkwQjA1MzgxNDAwMkNFNjRGIC8q IG1hYyAqLywKIAkJCQlGNEVBRjRBQjEwQzc0MjY4MDA5MTAwRDMgLyogb3BlbnR5cGUgKi8sCiAJ CQkJNDlFOTExQjIwRUY4NkQyNzAwOUQwQ0FGIC8qIHRyYW5zZm9ybXMgKi8sCisJCQkJRkJGMjgx QUQxMjA4RDM1QzAwRjdGODEyIC8qIEFOR0xFV2Via2l0QnJpZGdlLmNwcCAqLywKKwkJCQlGQkYy ODFBRTEyMDhEMzVDMDBGN0Y4MTIgLyogQU5HTEVXZWJraXRCcmlkZ2UuaCAqLywKIAkJCQlBODk5 NDMyNzBCNDIzMzg3MDBEN0M4MDIgLyogQml0bWFwSW1hZ2UuY3BwICovLAogCQkJCUE4OTk0MzI2 MEI0MjMzODcwMEQ3QzgwMiAvKiBCaXRtYXBJbWFnZS5oICovLAogCQkJCUIyNzUzNTM4MEIwNTM4 MTQwMDJDRTY0RiAvKiBDb2xvci5jcHAgKi8sCkBAIC0yMDEyMCw2ICsyMDEyNiw3IEBACiAJCQkJ OTdERDREODcwRkRGNEQ2RTAwRUNGOUE0IC8qIFhTU0F1ZGl0b3IuaCBpbiBIZWFkZXJzICovLAog CQkJCUNFMTcyRTAxMTEzNkU4Q0UwMDYyQTUzMyAvKiBab29tTW9kZS5oIGluIEhlYWRlcnMgKi8s CiAJCQkJN0FCMEIxQzExMjExQTYyMjAwQTc2OTQwIC8qIEluc3BlY3RvclN0b3JhZ2VBZ2VudC5o IGluIEhlYWRlcnMgKi8sCisJCQkJRkI4QzU5Q0IxMjEyMTMyQzAwMEEzNzFEIC8qIEFOR0xFV2Vi a2l0QnJpZGdlLmggaW4gSGVhZGVycyAqLywKIAkJCSk7CiAJCQlydW5Pbmx5Rm9yRGVwbG95bWVu dFBvc3Rwcm9jZXNzaW5nID0gMDsKIAkJfTsKQEAgLTIyNTQyLDYgKzIyNTQ5LDcgQEAKIAkJCQlF MUJFNTEyRDBDRjZDNTEyMDAyRUE5NTkgLyogWFNMVFVuaWNvZGVTb3J0LmNwcCBpbiBTb3VyY2Vz ICovLAogCQkJCTk3REQ0RDg2MEZERjRENkUwMEVDRjlBNCAvKiBYU1NBdWRpdG9yLmNwcCBpbiBT b3VyY2VzICovLAogCQkJCTdBQjBCMUMwMTIxMUE2MjIwMEE3Njk0MCAvKiBJbnNwZWN0b3JTdG9y YWdlQWdlbnQuY3BwIGluIFNvdXJjZXMgKi8sCisJCQkJRkI4QzU5Q0ExMjEyMTMyQzAwMEEzNzFE IC8qIEFOR0xFV2Via2l0QnJpZGdlLmNwcCBpbiBTb3VyY2VzICovLAogCQkJKTsKIAkJCXJ1bk9u bHlGb3JEZXBsb3ltZW50UG9zdHByb2Nlc3NpbmcgPSAwOwogCQl9OwpJbmRleDogV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9BTkdMRVdlYmtpdEJyaWRnZS5jcHAKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9BTkdMRVdlYmtpdEJyaWRnZS5jcHAJKHJldmlzaW9uIDAp CisrKyBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0FOR0xFV2Via2l0QnJpZGdlLmNwcAkocmV2 aXNpb24gMCkKQEAgLTAsMCArMSw3NCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAwOSBBcHBs ZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVz ZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmlj YXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlv bnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVz dCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmli dXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQK KyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVy aWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FS RSBJUyBQUk9WSURFRCBCWSBBUFBMRSBDT01QVVRFUiwgSU5DLiBgYEFTIElTJycgQU5EIEFOWQor ICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1J VEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5E IEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElO IE5PIEVWRU5UIFNIQUxMIEFQUExFIENPTVBVVEVSLCBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMg QkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwK KyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBO T1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VS VklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5U RVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklM SVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAo SU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VU IE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUg UE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuIAorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIK KworI2lmIEVOQUJMRSgzRF9DQU5WQVMpCisKKyNpbmNsdWRlICJBTkdMRVdlYmtpdEJyaWRnZS5o IgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKKworQU5HTEVXZWJraXRCcmlkZ2U6OkFOR0xFV2Vi a2l0QnJpZGdlKCkgOgorICAgIG1fZnJhZ21lbnRDb21waWxlcigwKQorICAgICwgbV92ZXJ0ZXhD b21waWxlcigwKQoreworICAgIFNoSW5pdGlhbGl6ZSgpOworCisgICAgbV9mcmFnbWVudENvbXBp bGVyID0gU2hDb25zdHJ1Y3RDb21waWxlcihFU2hMYW5nRnJhZ21lbnQsIEVTaFNwZWNXZWJHTCk7 CisgICAgbV92ZXJ0ZXhDb21waWxlciA9IFNoQ29uc3RydWN0Q29tcGlsZXIoRVNoTGFuZ1ZlcnRl eCwgRVNoU3BlY1dlYkdMKTsKKyAgICAKKyAgICBwcmludGYoImRvbmUgd2l0aCBjb21waWxlciBj b25zdHJ1Y3RpbmcuXG4iKTsKK30KKworQU5HTEVXZWJraXRCcmlkZ2U6On5BTkdMRVdlYmtpdEJy aWRnZSgpCit7CisgICAgU2hEZXN0cnVjdChtX2ZyYWdtZW50Q29tcGlsZXIpOworICAgIFNoRGVz dHJ1Y3QobV92ZXJ0ZXhDb21waWxlcik7Cit9CisKK2Jvb2wgQU5HTEVXZWJraXRCcmlkZ2U6OnZh bGlkYXRlU2hhZGVyU291cmNlKGNvbnN0IGNoYXIqIHNoYWRlclNvdXJjZSwgQU5HTEVTaGFkZXJU eXBlIHNoYWRlclR5cGUsIFN0cmluZyYgdHJhbnNsYXRlZFNoYWRlclNvdXJjZSwgU3RyaW5nJiBz aGFkZXJWYWxpZGF0aW9uTG9nKQoreworICAgIFNoSGFuZGxlIGNvbXBpbGVyOworCisgICAgaWYg KHNoYWRlclR5cGUgPT0gU0hBREVSX1RZUEVfVkVSVEVYKQorICAgICAgICBjb21waWxlciA9IG1f dmVydGV4Q29tcGlsZXI7CisgICAgZWxzZSBpZiAoc2hhZGVyVHlwZSA9PSBTSEFERVJfVFlQRV9G UkFHTUVOVCkKKyAgICAgICAgY29tcGlsZXIgPSBtX2ZyYWdtZW50Q29tcGlsZXI7CisKKyAgICBj b25zdCBjaGFyKiBjb25zdCBzaGFkZXJTb3VyY2VTdHJpbmdzW10gPSB7c2hhZGVyU291cmNlfTsK KworICAgIGJvb2wgdmFsaWRhdGVTdWNjZXNzID0gU2hDb21waWxlKGNvbXBpbGVyLCBzaGFkZXJT b3VyY2VTdHJpbmdzLCAxLCBFU2hPcHROb25lLCAmbV9yZXNvdXJjZXMsIEVEZWJ1Z09wSW50ZXJt ZWRpYXRlKTsKKworICAgIHRyYW5zbGF0ZWRTaGFkZXJTb3VyY2UgPSBTaEdldE9iamVjdENvZGUo Y29tcGlsZXIpOworICAgIHNoYWRlclZhbGlkYXRpb25Mb2cgPSBTaEdldEluZm9Mb2coY29tcGls ZXIpOworCisgICAgcmV0dXJuIHZhbGlkYXRlU3VjY2VzczsKK30KKworfQorCisjZW5kaWYgLy8g RU5BQkxFKDNEX0NBTlZBUykKSW5kZXg6IFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvQU5HTEVX ZWJraXRCcmlkZ2UuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0FO R0xFV2Via2l0QnJpZGdlLmgJKHJldmlzaW9uIDApCisrKyBXZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL0FOR0xFV2Via2l0QnJpZGdlLmgJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNjEgQEAKKy8q CisgKiBDb3B5cmlnaHQgKEMpIDIwMDkgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgor ICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMs IHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVk IHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0 cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQK KyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJl cHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBj b25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1 bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJp YnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgQ09NUFVU RVIsIElOQy4gYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5U SUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJB TlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAq IFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBDT01QVVRF UiwgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5E SVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJ QUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVO VCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IK KyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5E IE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RS SUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVS V0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRX QVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLiAK KyAqLworCisjaWZuZGVmIEFOR0xFV2Via2l0QnJpZGdlX2gKKyNkZWZpbmUgQU5HTEVXZWJraXRC cmlkZ2VfaAorCisjaW5jbHVkZSAiUGxhdGZvcm1TdHJpbmcuaCIKKyNpbmNsdWRlICJTaGFkZXJM YW5nLmgiCisKKyNpbmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+CisKK25hbWVzcGFjZSBXZWJD b3JlIHsKKworZW51bSBBTkdMRVNoYWRlclR5cGUgeworICAgIFNIQURFUl9UWVBFX1ZFUlRFWCA9 IEVTaExhbmdWZXJ0ZXgsCisgICAgU0hBREVSX1RZUEVfRlJBR01FTlQgPSBFU2hMYW5nRnJhZ21l bnQKK307CisKK2NsYXNzIEFOR0xFV2Via2l0QnJpZGdlIHsKK3B1YmxpYzoKKworICAgIEFOR0xF V2Via2l0QnJpZGdlKCk7CisgICAgfkFOR0xFV2Via2l0QnJpZGdlKCk7CisgICAgCisgICAgdm9p ZCBzZXRSZXNvdXJjZXMoVEJ1aWx0SW5SZXNvdXJjZSByZXNvdXJjZXMpIHsgbV9yZXNvdXJjZXMg PSByZXNvdXJjZXM7IH0KKyAgICAKKyAgICBib29sIHZhbGlkYXRlU2hhZGVyU291cmNlKGNvbnN0 IGNoYXIqIHNoYWRlclNvdXJjZSwgQU5HTEVTaGFkZXJUeXBlIHNoYWRlclR5cGUsIFN0cmluZyYg dHJhbnNsYXRlZFNoYWRlclNvdXJjZSwgU3RyaW5nJiBzaGFkZXJWYWxpZGF0aW9uTG9nKTsKKwor cHJpdmF0ZToKKworICAgIFNoSGFuZGxlIG1fZnJhZ21lbnRDb21waWxlcjsKKyAgICBTaEhhbmRs ZSBtX3ZlcnRleENvbXBpbGVyOworCisgICAgVEJ1aWx0SW5SZXNvdXJjZSBtX3Jlc291cmNlczsK K307CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmCkluZGV4OiBXZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL0dyYXBoaWNzQ29udGV4dDNELmgKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGljc0NvbnRleHQzRC5oCShyZXZpc2lvbiA2NTA4MCkK KysrIFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3JhcGhpY3NDb250ZXh0M0QuaAkod29ya2lu ZyBjb3B5KQpAQCAtMjYsOSArMjYsMTEgQEAKICNpZm5kZWYgR3JhcGhpY3NDb250ZXh0M0RfaAog I2RlZmluZSBHcmFwaGljc0NvbnRleHQzRF9oCiAKKyNpbmNsdWRlICJBTkdMRVdlYmtpdEJyaWRn ZS5oIgogI2luY2x1ZGUgIkdyYXBoaWNzTGF5ZXIuaCIKICNpbmNsdWRlICJQbGF0Zm9ybVN0cmlu Zy5oIgogCisjaW5jbHVkZSA8d3RmL0hhc2hNYXAuaD4KICNpbmNsdWRlIDx3dGYvTGlzdEhhc2hT ZXQuaD4KICNpbmNsdWRlIDx3dGYvTm9uY29weWFibGUuaD4KICNpbmNsdWRlIDx3dGYvUGFzc093 blB0ci5oPgpAQCAtODA3LDYgKzgwOSwxNSBAQCBwdWJsaWM6CiAKICAgICBpbnQgbV9jdXJyZW50 V2lkdGgsIG1fY3VycmVudEhlaWdodDsKIAorICAgIHR5cGVkZWYgc3RydWN0IHsgCisgICAgICAg IFN0cmluZyBzb3VyY2U7IAorICAgICAgICBTdHJpbmcgbG9nOyAKKyAgICAgICAgYm9vbCBpc1Zh bGlkOworICAgIH0gU2hhZGVyU291cmNlRW50cnk7CisgICAgSGFzaE1hcDxQbGF0Zm9ybTNET2Jq ZWN0LCBTaGFkZXJTb3VyY2VFbnRyeT4gbV9zaGFkZXJTb3VyY2VNYXA7CisKKyAgICBBTkdMRVdl YmtpdEJyaWRnZSBtX2NvbXBpbGVyOworCiAjaWYgUExBVEZPUk0oTUFDKQogICAgIEF0dHJpYnV0 ZXMgbV9hdHRyczsKICAgICBWZWN0b3I8VmVjdG9yPGZsb2F0PiA+IG1fdmVydGV4QXJyYXk7Cklu ZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL21hYy9HcmFwaGljc0NvbnRleHQzRE1hYy5t bQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL21hYy9HcmFwaGljc0Nv bnRleHQzRE1hYy5tbQkocmV2aXNpb24gNjUwODApCisrKyBXZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL21hYy9HcmFwaGljc0NvbnRleHQzRE1hYy5tbQkod29ya2luZyBjb3B5KQpAQCAtMzEsNiAr MzEsNyBAQAogCiAjaW1wb3J0ICJCbG9ja0V4Y2VwdGlvbnMuaCIKIAorI2luY2x1ZGUgIkFOR0xF V2Via2l0QnJpZGdlLmgiCiAjaW5jbHVkZSAiQXJyYXlCdWZmZXIuaCIKICNpbmNsdWRlICJBcnJh eUJ1ZmZlclZpZXcuaCIKICNpbmNsdWRlICJXZWJHTE9iamVjdC5oIgpAQCAtNDEsNiArNDIsNyBA QAogI2luY2x1ZGUgIkltYWdlQnVmZmVyLmgiCiAjaW5jbHVkZSAiSW50MzJBcnJheS5oIgogI2lu Y2x1ZGUgIk5vdEltcGxlbWVudGVkLmgiCisjaW5jbHVkZSAiUmVzb3VyY2VMaW1pdHMuaCIKICNp bmNsdWRlICJVaW50OEFycmF5LmgiCiAjaW5jbHVkZSAiV2ViR0xMYXllci5oIgogI2luY2x1ZGUg PENvcmVHcmFwaGljcy9DR0JpdG1hcENvbnRleHQuaD4KQEAgLTE4MSw2ICsxODMsMzAgQEAgR3Jh cGhpY3NDb250ZXh0M0Q6OkdyYXBoaWNzQ29udGV4dDNEKEdyYQogICAgICAgICAgICAgOjpnbEdl blJlbmRlcmJ1ZmZlcnNFWFQoMSwgJm1fbXVsdGlzYW1wbGVEZXB0aFN0ZW5jaWxCdWZmZXIpOwog ICAgIH0KICAgICAKKyAgICAvLyBBTkdMRSBpbml0aWFsaXphdGlvbi4KKworICAgIFRCdWlsdElu UmVzb3VyY2UgQU5HTEVSZXNvdXJjZXM7CisKKyAgICBBTkdMRVJlc291cmNlcy5tYXhWZXJ0ZXhB dHRyaWJzID0gMDsKKyAgICBnZXRJbnRlZ2VydihHcmFwaGljc0NvbnRleHQzRDo6TUFYX1ZFUlRF WF9BVFRSSUJTLCAmQU5HTEVSZXNvdXJjZXMubWF4VmVydGV4QXR0cmlicyk7CisgICAgQU5HTEVS ZXNvdXJjZXMubWF4VmVydGV4VW5pZm9ybVZlY3RvcnMgPSAwOworICAgIGdldEludGVnZXJ2KEdy YXBoaWNzQ29udGV4dDNEOjpNQVhfVkVSVEVYX1VOSUZPUk1fVkVDVE9SUywgJkFOR0xFUmVzb3Vy Y2VzLm1heFZlcnRleFVuaWZvcm1WZWN0b3JzKTsKKyAgICBBTkdMRVJlc291cmNlcy5tYXhWYXJ5 aW5nVmVjdG9ycyA9IDA7CisgICAgZ2V0SW50ZWdlcnYoR3JhcGhpY3NDb250ZXh0M0Q6Ok1BWF9W QVJZSU5HX1ZFQ1RPUlMsICZBTkdMRVJlc291cmNlcy5tYXhWYXJ5aW5nVmVjdG9ycyk7CisgICAg QU5HTEVSZXNvdXJjZXMubWF4VmVydGV4VGV4dHVyZUltYWdlVW5pdHMgPSAwOworICAgIGdldElu dGVnZXJ2KEdyYXBoaWNzQ29udGV4dDNEOjpNQVhfVkVSVEVYX1RFWFRVUkVfSU1BR0VfVU5JVFMs ICZBTkdMRVJlc291cmNlcy5tYXhWZXJ0ZXhUZXh0dXJlSW1hZ2VVbml0cyk7CisgICAgQU5HTEVS ZXNvdXJjZXMubWF4Q29tYmluZWRUZXh0dXJlSW1hZ2VVbml0cyA9IDA7CisgICAgZ2V0SW50ZWdl cnYoR3JhcGhpY3NDb250ZXh0M0Q6Ok1BWF9DT01CSU5FRF9URVhUVVJFX0lNQUdFX1VOSVRTLCAm QU5HTEVSZXNvdXJjZXMubWF4Q29tYmluZWRUZXh0dXJlSW1hZ2VVbml0cyk7CisgICAgQU5HTEVS ZXNvdXJjZXMubWF4VGV4dHVyZUltYWdlVW5pdHMgPSAwOworICAgIGdldEludGVnZXJ2KEdyYXBo aWNzQ29udGV4dDNEOjpNQVhfVEVYVFVSRV9JTUFHRV9VTklUUywgJkFOR0xFUmVzb3VyY2VzLm1h eFRleHR1cmVJbWFnZVVuaXRzKTsKKyAgICBBTkdMRVJlc291cmNlcy5tYXhGcmFnbWVudFVuaWZv cm1WZWN0b3JzID0gMDsKKyAgICBnZXRJbnRlZ2VydihHcmFwaGljc0NvbnRleHQzRDo6TUFYX0ZS QUdNRU5UX1VOSUZPUk1fVkVDVE9SUywgJkFOR0xFUmVzb3VyY2VzLm1heEZyYWdtZW50VW5pZm9y bVZlY3RvcnMpOworCisgICAgLy8gQWx3YXlzIHNldCB0byAxIGZvciBPcGVuR0wgRVMuCisgICAg QU5HTEVSZXNvdXJjZXMubWF4RHJhd0J1ZmZlcnMgPSAxOworCisgICAgbV9jb21waWxlci5zZXRS ZXNvdXJjZXMoQU5HTEVSZXNvdXJjZXMpOworICAgIAogICAgIDo6Z2xFbmFibGUoR0xfVkVSVEVY X1BST0dSQU1fUE9JTlRfU0laRSk7CiAgICAgOjpnbENsZWFyQ29sb3IoMCwgMCwgMCwgMCk7CiB9 CkBAIC02MTcsNiArNjQzLDQ0IEBAIHZvaWQgR3JhcGhpY3NDb250ZXh0M0Q6OmNvbXBpbGVTaGFk ZXIoUGwKIHsKICAgICBBU1NFUlQoc2hhZGVyKTsKICAgICBlbnN1cmVDb250ZXh0KG1fY29udGV4 dE9iaik7CisKKyAgICBpbnQgR0xzaGFkZXJUeXBlOworICAgIEFOR0xFU2hhZGVyVHlwZSBzaGFk ZXJUeXBlOworCisgICAgZ2xHZXRTaGFkZXJpdihzaGFkZXIsIFNIQURFUl9UWVBFLCAmR0xzaGFk ZXJUeXBlKTsKKyAgICAKKyAgICBpZiAoR0xzaGFkZXJUeXBlID09IFZFUlRFWF9TSEFERVIpCisg ICAgICAgIHNoYWRlclR5cGUgPSBTSEFERVJfVFlQRV9WRVJURVg7CisgICAgZWxzZSBpZiAoR0xz aGFkZXJUeXBlID09IEZSQUdNRU5UX1NIQURFUikKKyAgICAgICAgc2hhZGVyVHlwZSA9IFNIQURF Ul9UWVBFX0ZSQUdNRU5UOworICAgIGVsc2UKKyAgICAgICAgcmV0dXJuOyAvLyBJbnZhbGlkIHNo YWRlciB0eXBlLgorCisgICAgSGFzaE1hcDxQbGF0Zm9ybTNET2JqZWN0LCBTaGFkZXJTb3VyY2VF bnRyeT46Oml0ZXJhdG9yIHJlc3VsdCA9IG1fc2hhZGVyU291cmNlTWFwLmZpbmQoc2hhZGVyKTsK KworICAgIGlmIChyZXN1bHQgPT0gbV9zaGFkZXJTb3VyY2VNYXAuZW5kKCkpCisgICAgICAgIHJl dHVybjsKKworICAgIFNoYWRlclNvdXJjZUVudHJ5IGVudHJ5OworCisgICAgZW50cnkuc291cmNl ID0gcmVzdWx0LT5zZWNvbmQuc291cmNlOworICAgIGNvbnN0IGNoYXIqIHNoYWRlclNvdXJjZVN0 cmluZyA9IGVudHJ5LnNvdXJjZS51dGY4KCkuZGF0YSgpOworCisgICAgU3RyaW5nIHRyYW5zbGF0 ZWRTaGFkZXJTb3VyY2U7CisgICAgU3RyaW5nIHNoYWRlckluZm9Mb2c7CisKKyAgICBib29sIGlz VmFsaWQgPSBtX2NvbXBpbGVyLnZhbGlkYXRlU2hhZGVyU291cmNlKHNoYWRlclNvdXJjZVN0cmlu Zywgc2hhZGVyVHlwZSwgdHJhbnNsYXRlZFNoYWRlclNvdXJjZSwgc2hhZGVySW5mb0xvZyk7CisK KyAgICBlbnRyeS5sb2cgPSBzaGFkZXJJbmZvTG9nOworICAgIGVudHJ5LmlzVmFsaWQgPSBpc1Zh bGlkOworCisgICAgbV9zaGFkZXJTb3VyY2VNYXAuc2V0KHNoYWRlciwgZW50cnkpOworCisgICAg aWYgKCFpc1ZhbGlkKQorICAgICAgICByZXR1cm47IC8vIFNoYWRlciBkaWRuJ3QgdmFsaWRhdGUs IGRvbid0IG1vdmUgZm9yd2FyZCB3aXRoIGNvbXBpbGluZyB0cmFuc2xhdGVkIHNvdXJjZQorCisg ICAgc2hhZGVyU291cmNlKHNoYWRlciwgdHJhbnNsYXRlZFNoYWRlclNvdXJjZS51dGY4KCkuZGF0 YSgpKTsKKyAgICAKICAgICA6OmdsQ29tcGlsZVNoYWRlcigoR0x1aW50KSBzaGFkZXIpOwogfQog CkBAIC05OTgsMTEgKzEwNjIsMTIgQEAgdm9pZCBHcmFwaGljc0NvbnRleHQzRDo6c2hhZGVyU291 cmNlKFBsYQogICAgIEFTU0VSVChzaGFkZXIpOwogICAgIAogICAgIGVuc3VyZUNvbnRleHQobV9j b250ZXh0T2JqKTsKLSAgICBjb25zdCBDU3RyaW5nJiBjcyA9IHN0cmluZy51dGY4KCk7Ci0gICAg Y29uc3QgY2hhciogcyA9IGNzLmRhdGEoKTsKLSAgICAKLSAgICBpbnQgbGVuZ3RoID0gc3RyaW5n Lmxlbmd0aCgpOwotICAgIDo6Z2xTaGFkZXJTb3VyY2UoKEdMdWludCkgc2hhZGVyLCAxLCAmcywg Jmxlbmd0aCk7CisKKyAgICBTaGFkZXJTb3VyY2VFbnRyeSBlbnRyeTsKKworICAgIGVudHJ5LnNv dXJjZSA9IHN0cmluZzsKKworICAgIG1fc2hhZGVyU291cmNlTWFwLnNldChzaGFkZXIsIGVudHJ5 KTsKIH0KIAogdm9pZCBHcmFwaGljc0NvbnRleHQzRDo6c3RlbmNpbEZ1bmModW5zaWduZWQgbG9u ZyBmdW5jLCBsb25nIHJlZiwgdW5zaWduZWQgbG9uZyBtYXNrKQpAQCAtMTM1MiwyMCArMTQxNywz NSBAQCB2b2lkIEdyYXBoaWNzQ29udGV4dDNEOjpnZXRTaGFkZXJpdihQbGF0CiBTdHJpbmcgR3Jh cGhpY3NDb250ZXh0M0Q6OmdldFNoYWRlckluZm9Mb2coUGxhdGZvcm0zRE9iamVjdCBzaGFkZXIp CiB7CiAgICAgQVNTRVJUKHNoYWRlcik7CiAgICAgZW5zdXJlQ29udGV4dChtX2NvbnRleHRPYmop OwogICAgIEdMaW50IGxlbmd0aDsKICAgICA6OmdsR2V0U2hhZGVyaXYoKEdMdWludCkgc2hhZGVy LCBHTF9JTkZPX0xPR19MRU5HVEgsICZsZW5ndGgpOwotICAgIAotICAgIEdMc2l6ZWkgc2l6ZTsK LSAgICBHTGNoYXIqIGluZm8gPSAoR0xjaGFyKikgZmFzdE1hbGxvYyhsZW5ndGgpOwotICAgIGlm ICghaW5mbykKLSAgICAgICAgcmV0dXJuICIiOwotICAgICAgICAKLSAgICA6OmdsR2V0U2hhZGVy SW5mb0xvZygoR0x1aW50KSBzaGFkZXIsIGxlbmd0aCwgJnNpemUsIGluZm8pOwotICAgIFN0cmlu ZyBzKGluZm8pOwotICAgIGZhc3RGcmVlKGluZm8pOwotICAgIHJldHVybiBzOworCisgICAgSGFz aE1hcDxQbGF0Zm9ybTNET2JqZWN0LCBTaGFkZXJTb3VyY2VFbnRyeT46Oml0ZXJhdG9yIHJlc3Vs dCA9IG1fc2hhZGVyU291cmNlTWFwLmZpbmQoc2hhZGVyKTsKKworICAgIGlmIChyZXN1bHQgPT0g bV9zaGFkZXJTb3VyY2VNYXAuZW5kKCkpCisgICAgICAgICByZXR1cm4gIiI7CisKKyAgICAgU2hh ZGVyU291cmNlRW50cnkgZW50cnkgPSByZXN1bHQtPnNlY29uZDsKKworICAgICBpZiAoZW50cnku aXNWYWxpZCkgeworICAgICAgICAgR0xpbnQgbGVuZ3RoOworICAgICAgICAgOjpnbEdldFNoYWRl cml2KChHTHVpbnQpIHNoYWRlciwgR0xfSU5GT19MT0dfTEVOR1RILCAmbGVuZ3RoKTsKKworICAg ICAgICAgR0xzaXplaSBzaXplOworICAgICAgICAgR0xjaGFyKiBpbmZvID0gKEdMY2hhciopIGZh c3RNYWxsb2MobGVuZ3RoKTsKKyAgICAgICAgIGlmICghaW5mbykKKyAgICAgICAgICAgICByZXR1 cm4gIiI7CisKKyAgICAgICAgIDo6Z2xHZXRTaGFkZXJJbmZvTG9nKChHTHVpbnQpIHNoYWRlciwg bGVuZ3RoLCAmc2l6ZSwgaW5mbyk7CisgICAgICAgICBTdHJpbmcgcyhpbmZvKTsKKyAgICAgICAg IGZhc3RGcmVlKGluZm8pOworICAgICAgICAgcmV0dXJuIHM7CisgICAgIH0KKyAgICAgZWxzZSB7 CisgICAgICAgICByZXR1cm4gZW50cnkubG9nOworICAgICB9CiB9CiAKIFN0cmluZyBHcmFwaGlj c0NvbnRleHQzRDo6Z2V0U2hhZGVyU291cmNlKFBsYXRmb3JtM0RPYmplY3Qgc2hhZGVyKQo= 64381 2010-08-13 15:49:01 -0700 2010-08-16 12:00:09 -0700 Changes to WebCore for ANGLE angle-for-translation text/plain 20384 psawaya SW5kZXg6IFdlYkNvcmUvV2ViQ29yZS5neXBpCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvV2ViQ29y ZS5neXBpCShyZXZpc2lvbiA2NTMwOCkKKysrIFdlYkNvcmUvV2ViQ29yZS5neXBpCSh3b3JraW5n IGNvcHkpCkBAIC0yNDUzLDYgKzI0NTMsOCBAQAogICAgICAgICAgICAgJ3BsYXRmb3JtL2dyYXBo aWNzL3d4L1Blbld4LmNwcCcsCiAgICAgICAgICAgICAncGxhdGZvcm0vZ3JhcGhpY3Mvd3gvU2lt cGxlRm9udERhdGFXeC5jcHAnLAogICAgICAgICAgICAgJ3BsYXRmb3JtL2dyYXBoaWNzL3d4L1Ry YW5zZm9ybWF0aW9uTWF0cml4V3guY3BwJywKKyAgICAgICAgICAgICdwbGF0Zm9ybS9ncmFwaGlj cy9BTkdMRVdlYmtpdEJyaWRnZS5jcHAnLAorICAgICAgICAgICAgJ3BsYXRmb3JtL2dyYXBoaWNz L0FOR0xFV2Via2l0QnJpZGdlLmgnLAogICAgICAgICAgICAgJ3BsYXRmb3JtL2dyYXBoaWNzL0Jp dG1hcEltYWdlLmNwcCcsCiAgICAgICAgICAgICAncGxhdGZvcm0vZ3JhcGhpY3MvQml0bWFwSW1h Z2UuaCcsCiAgICAgICAgICAgICAncGxhdGZvcm0vZ3JhcGhpY3MvQ29sb3IuY3BwJywKSW5kZXg6 IFdlYkNvcmUvQ29uZmlndXJhdGlvbnMvV2ViQ29yZS54Y2NvbmZpZwo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBX ZWJDb3JlL0NvbmZpZ3VyYXRpb25zL1dlYkNvcmUueGNjb25maWcJKHJldmlzaW9uIDY1MzA4KQor KysgV2ViQ29yZS9Db25maWd1cmF0aW9ucy9XZWJDb3JlLnhjY29uZmlnCSh3b3JraW5nIGNvcHkp CkBAIC00MywxNCArNDMsMTQgQEAgRlJBTUVXT1JLX1NFQVJDSF9QQVRIU19pcGhvbmVvc19Qcm9k dWN0aQogRlJBTUVXT1JLX1NFQVJDSF9QQVRIU19pcGhvbmVzaW11bGF0b3IgPSAkKEZSQU1FV09S S19TRUFSQ0hfUEFUSFNfaXBob25lb3NfJChDT05GSUdVUkFUSU9OKSk7CiBGUkFNRVdPUktfU0VB UkNIX1BBVEhTX21hY29zeCA9ICQoU1lTVEVNX0xJQlJBUllfRElSKS9GcmFtZXdvcmtzL0NhcmJv bi5mcmFtZXdvcmsvRnJhbWV3b3JrcyAkKFNZU1RFTV9MSUJSQVJZX0RJUikvRnJhbWV3b3Jrcy9B cHBsaWNhdGlvblNlcnZpY2VzLmZyYW1ld29yay9GcmFtZXdvcmtzICQoRlJBTUVXT1JLX1NFQVJD SF9QQVRIUyk7CiAKLUhFQURFUl9TRUFSQ0hfUEFUSFMgPSBGb3J3YXJkaW5nSGVhZGVycyBpY3Ug L3Vzci9pbmNsdWRlL2xpYnhzbHQgL3Vzci9pbmNsdWRlL2xpYnhtbDIgJChTUUxJVEUzX0hFQURF Ul9TRUFSQ0hfUEFUSFMpICIke0JVSUxUX1BST0RVQ1RTX0RJUn0vRGVyaXZlZFNvdXJjZXMvV2Vi Q29yZSIgJChIRUFERVJfU0VBUkNIX1BBVEhTKTsKK0hFQURFUl9TRUFSQ0hfUEFUSFMgPSBGb3J3 YXJkaW5nSGVhZGVycyBpY3UgL3Vzci9pbmNsdWRlL2xpYnhzbHQgL3Vzci9pbmNsdWRlL2xpYnht bDIgJChTUUxJVEUzX0hFQURFUl9TRUFSQ0hfUEFUSFMpICIke0JVSUxUX1BST0RVQ1RTX0RJUn0v RGVyaXZlZFNvdXJjZXMvV2ViQ29yZSIgIiR7QlVJTFRfUFJPRFVDVFNfRElSfS91c3IvbG9jYWwv aW5jbHVkZSIgJChIRUFERVJfU0VBUkNIX1BBVEhTKTsKIElORk9QTElTVF9GSUxFID0gSW5mby5w bGlzdDsKIElOU1RBTExfUEFUSCA9ICQoSU5TVEFMTF9QQVRIXyQoUkVBTF9QTEFURk9STV9OQU1F KSk7CiBJTlNUQUxMX1BBVEhfbWFjb3N4ID0gJChTWVNURU1fTElCUkFSWV9ESVIpL0ZyYW1ld29y a3MvV2ViS2l0LmZyYW1ld29yay9WZXJzaW9ucy9BL0ZyYW1ld29ya3M7CiBJTlNUQUxMSERSU19D T1BZX1BIQVNFID0gWUVTOwogSU5TVEFMTEhEUlNfU0NSSVBUX1BIQVNFID0gWUVTOwogUFJPRFVD VF9OQU1FID0gV2ViQ29yZTsKLU9USEVSX0xERkxBR1NfQkFTRSA9IC1sJChTUUxJVEUzX0xJQlJB UlkpIC1sb2JqYzsKK09USEVSX0xERkxBR1NfQkFTRSA9IC1sJChTUUxJVEUzX0xJQlJBUlkpIC1s b2JqYyAtbEFOR0xFOwogT1RIRVJfTERGTEFHUyA9ICQoT1RIRVJfTERGTEFHU18kKFJFQUxfUExB VEZPUk1fTkFNRSkpOwogT1RIRVJfTERGTEFHU19pcGhvbmVvcyA9ICQoT1RIRVJfTERGTEFHU19C QVNFKSAtZnJhbWV3b3JrIENGTmV0d29yayAtZnJhbWV3b3JrIENvcmVGb3VuZGF0aW9uIC1mcmFt ZXdvcmsgQ29yZUdyYXBoaWNzIC1mcmFtZXdvcmsgQ29yZVRleHQgLWZyYW1ld29yayBGb3VuZGF0 aW9uIC1mcmFtZXdvcmsgR3JhcGhpY3NTZXJ2aWNlcyAtZnJhbWV3b3JrIEltYWdlSU8gLWZyYW1l d29yayBRdWFydHpDb3JlOwogT1RIRVJfTERGTEFHU19pcGhvbmVzaW11bGF0b3IgPSAkKE9USEVS X0xERkxBR1NfaXBob25lb3MpOwpJbmRleDogV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9q ZWN0LnBieHByb2oKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9q ZWN0LnBieHByb2oJKHJldmlzaW9uIDY1MzA4KQorKysgV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJv ai9wcm9qZWN0LnBieHByb2oJKHdvcmtpbmcgY29weSkKQEAgLTUyODIsNiArNTI4Miw4IEBACiAJ CUZBQkU3MkZFMTA1OUMyMTEwMEQ5OTlERCAvKiBNYXRoTUxOYW1lcy5jcHAgaW4gU291cmNlcyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGQUJFNzJGQzEwNTlDMjExMDBEOTk5 REQgLyogTWF0aE1MTmFtZXMuY3BwICovOyB9OwogCQlGQUMxMkNDNDExMjBEQTY5MDBEQUNDMzYg LyogUmVuZGVyTWF0aE1MU3ViU3VwLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IEZBQzEyQ0MyMTEyMERBNjkwMERBQ0MzNiAvKiBSZW5kZXJNYXRoTUxT dWJTdXAuY3BwICovOyB9OwogCQlGQUMxMkNDNTExMjBEQTY5MDBEQUNDMzYgLyogUmVuZGVyTWF0 aE1MU3ViU3VwLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYg PSBGQUMxMkNDMzExMjBEQTY5MDBEQUNDMzYgLyogUmVuZGVyTWF0aE1MU3ViU3VwLmggKi87IH07 CisJCUZCQTM3MjJCMTIxNjAwNEEwMEIwQUIwMCAvKiBBTkdMRVdlYmtpdEJyaWRnZS5jcHAgaW4g U291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGQkEzNzIyOTEyMTYw MDRBMDBCMEFCMDAgLyogQU5HTEVXZWJraXRCcmlkZ2UuY3BwICovOyB9OworCQlGQkEzNzIyQzEy MTYwMDRCMDBCMEFCMDAgLyogQU5HTEVXZWJraXRCcmlkZ2UuaCBpbiBIZWFkZXJzICovID0ge2lz YSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEZCQTM3MjJBMTIxNjAwNEEwMEIwQUIwMCAvKiBB TkdMRVdlYmtpdEJyaWRnZS5oICovOyB9OwogCQlGRTZGRDQ4ODBGNjc2RTU3MDAwOTI4NzMgLyog Q29vcmRpbmF0ZXMuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IEZFNkZENDg1MEY2NzZFNTcwMDA5Mjg3MyAvKiBDb29yZGluYXRlcy5oICovOyBzZXR0aW5n cyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCUZFNkZENDhEMEY2NzZFOTMw MDA5Mjg3MyAvKiBKU0Nvb3JkaW5hdGVzLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IEZFNkZENDhCMEY2NzZFOTMwMDA5Mjg3MyAvKiBKU0Nvb3JkaW5h dGVzLmNwcCAqLzsgfTsKIAkJRkU2RkQ0OEUwRjY3NkU5MzAwMDkyODczIC8qIEpTQ29vcmRpbmF0 ZXMuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEZFNkZE NDhDMEY2NzZFOTMwMDA5Mjg3MyAvKiBKU0Nvb3JkaW5hdGVzLmggKi87IH07CkBAIC0xMTEwMCw2 ICsxMTEwMiw4IEBACiAJCUZBQkU3MkZDMTA1OUMyMTEwMEQ5OTlERCAvKiBNYXRoTUxOYW1lcy5j cHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtu b3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBNYXRoTUxOYW1lcy5jcHA7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUZBQzEyQ0MyMTEyMERBNjkwMERBQ0MzNiAv KiBSZW5kZXJNYXRoTUxTdWJTdXAuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZp bGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBw YXRoID0gUmVuZGVyTWF0aE1MU3ViU3VwLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsK IAkJRkFDMTJDQzMxMTIwREE2OTAwREFDQzM2IC8qIFJlbmRlck1hdGhNTFN1YlN1cC5oICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVU eXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBSZW5kZXJNYXRoTUxTdWJTdXAuaDsgc291cmNl VHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJRkJBMzcyMjkxMjE2MDA0QTAwQjBBQjAwIC8qIEFOR0xF V2Via2l0QnJpZGdlLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEFO R0xFV2Via2l0QnJpZGdlLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJRkJBMzcy MkExMjE2MDA0QTAwQjBBQjAwIC8qIEFOR0xFV2Via2l0QnJpZGdlLmggKi8gPSB7aXNhID0gUEJY RmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3Vy Y2Vjb2RlLmMuaDsgcGF0aCA9IEFOR0xFV2Via2l0QnJpZGdlLmg7IHNvdXJjZVRyZWUgPSAiPGdy b3VwPiI7IH07CiAJCUZFNDlFRjk3MERDNTE0NjIwMDQyNjZFMSAvKiBEYXNoYm9hcmRTdXBwb3J0 Q1NTUHJvcGVydHlOYW1lcy5pbiAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5j b2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHRleHQ7IHBhdGggPSBEYXNoYm9hcmRTdXBw b3J0Q1NTUHJvcGVydHlOYW1lcy5pbjsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRkU2 RkQ0ODUwRjY3NkU1NzAwMDkyODczIC8qIENvb3JkaW5hdGVzLmggKi8gPSB7aXNhID0gUEJYRmls ZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vj b2RlLmMuaDsgcGF0aCA9IENvb3JkaW5hdGVzLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CiAJCUZFNkZENDg2MEY2NzZFNTcwMDA5Mjg3MyAvKiBDb29yZGluYXRlcy5pZGwgKi8gPSB7aXNh ID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUg PSB0ZXh0OyBwYXRoID0gQ29vcmRpbmF0ZXMuaWRsOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9 OwpAQCAtMTU2NTcsNiArMTU2NjEsOCBAQAogCQkJCUIyNzUzNTQ5MEIwNTM4MTQwMDJDRTY0RiAv KiBtYWMgKi8sCiAJCQkJRjRFQUY0QUIxMEM3NDI2ODAwOTEwMEQzIC8qIG9wZW50eXBlICovLAog CQkJCTQ5RTkxMUIyMEVGODZEMjcwMDlEMENBRiAvKiB0cmFuc2Zvcm1zICovLAorCQkJCUZCQTM3 MjI5MTIxNjAwNEEwMEIwQUIwMCAvKiBBTkdMRVdlYmtpdEJyaWRnZS5jcHAgKi8sCisJCQkJRkJB MzcyMkExMjE2MDA0QTAwQjBBQjAwIC8qIEFOR0xFV2Via2l0QnJpZGdlLmggKi8sCiAJCQkJQTg5 OTQzMjcwQjQyMzM4NzAwRDdDODAyIC8qIEJpdG1hcEltYWdlLmNwcCAqLywKIAkJCQlBODk5NDMy NjBCNDIzMzg3MDBEN0M4MDIgLyogQml0bWFwSW1hZ2UuaCAqLywKIAkJCQlCMjc1MzUzODBCMDUz ODE0MDAyQ0U2NEYgLyogQ29sb3IuY3BwICovLApAQCAtMjAxNTYsNiArMjAxNjIsNyBAQAogCQkJ CTk3REQ0RDg3MEZERjRENkUwMEVDRjlBNCAvKiBYU1NBdWRpdG9yLmggaW4gSGVhZGVycyAqLywK IAkJCQlDRTE3MkUwMTExMzZFOENFMDA2MkE1MzMgLyogWm9vbU1vZGUuaCBpbiBIZWFkZXJzICov LAogCQkJCTJFRUQ1N0ZFMTIxNEE5QzIwMDc2NTZCQiAvKiBUaHJlYWRhYmxlQmxvYlJlZ2lzdHJ5 LmggaW4gSGVhZGVycyAqLywKKwkJCQlGQkEzNzIyQzEyMTYwMDRCMDBCMEFCMDAgLyogQU5HTEVX ZWJraXRCcmlkZ2UuaCBpbiBIZWFkZXJzICovLAogCQkJKTsKIAkJCXJ1bk9ubHlGb3JEZXBsb3lt ZW50UG9zdHByb2Nlc3NpbmcgPSAwOwogCQl9OwpAQCAtMjI1ODIsNiArMjI1ODksNyBAQAogCQkJ CUUxQkU1MTJEMENGNkM1MTIwMDJFQTk1OSAvKiBYU0xUVW5pY29kZVNvcnQuY3BwIGluIFNvdXJj ZXMgKi8sCiAJCQkJOTdERDREODYwRkRGNEQ2RTAwRUNGOUE0IC8qIFhTU0F1ZGl0b3IuY3BwIGlu IFNvdXJjZXMgKi8sCiAJCQkJMkVFRDU3RkQxMjE0QTlDMjAwNzY1NkJCIC8qIFRocmVhZGFibGVC bG9iUmVnaXN0cnkuY3BwIGluIFNvdXJjZXMgKi8sCisJCQkJRkJBMzcyMkIxMjE2MDA0QTAwQjBB QjAwIC8qIEFOR0xFV2Via2l0QnJpZGdlLmNwcCBpbiBTb3VyY2VzICovLAogCQkJKTsKIAkJCXJ1 bk9ubHlGb3JEZXBsb3ltZW50UG9zdHByb2Nlc3NpbmcgPSAwOwogCQl9OwpJbmRleDogV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9BTkdMRVdlYmtpdEJyaWRnZS5jcHAKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9BTkdMRVdlYmtpdEJyaWRnZS5jcHAJKHJldmlzaW9u IDApCisrKyBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0FOR0xFV2Via2l0QnJpZGdlLmNwcAko cmV2aXNpb24gMCkKQEAgLTAsMCArMSw3OSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMCBB cHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5k IHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2Rp ZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRp dGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUg bXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qg b2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0 cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmln aHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1h dGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZU V0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBDT01QVVRFUiwgSU5DLiBgYEFTIElTJycgQU5EIEFO WQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBM SU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkg QU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4g IElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIENPTVBVVEVSLCBJTkMuIE9SCisgKiBDT05UUklCVVRP UlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lB TCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJV VCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1Ig U0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1Mg SU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElB QklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisg KiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkg T1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBU SEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuIAorICovCisKKyNpbmNsdWRlICJjb25maWcu aCIKKworI2lmIEVOQUJMRSgzRF9DQU5WQVMpCisKKyNpbmNsdWRlICJBTkdMRVdlYmtpdEJyaWRn ZS5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKKworQU5HTEVXZWJraXRCcmlkZ2U6OkFOR0xF V2Via2l0QnJpZGdlKCkgOgorICAgIGJ1aWx0Q29tcGlsZXJzKGZhbHNlKQoreworICAgIFNoSW5p dGlhbGl6ZSgpOworfQorCitBTkdMRVdlYmtpdEJyaWRnZTo6fkFOR0xFV2Via2l0QnJpZGdlKCkK K3sKKyAgICBpZiAoYnVpbHRDb21waWxlcnMpIHsKKyAgICAgICAgU2hEZXN0cnVjdChtX2ZyYWdt ZW50Q29tcGlsZXIpOworICAgICAgICBTaERlc3RydWN0KG1fdmVydGV4Q29tcGlsZXIpOworICAg IH0KKyAgICAKKyAgICBTaEZpbmFsaXplKCk7Cit9CisKK2Jvb2wgQU5HTEVXZWJraXRCcmlkZ2U6 OnZhbGlkYXRlU2hhZGVyU291cmNlKGNvbnN0IGNoYXIqIHNoYWRlclNvdXJjZSwgQU5HTEVTaGFk ZXJUeXBlIHNoYWRlclR5cGUsIFN0cmluZyYgdHJhbnNsYXRlZFNoYWRlclNvdXJjZSwgU3RyaW5n JiBzaGFkZXJWYWxpZGF0aW9uTG9nKQoreworICAgIGlmICghYnVpbHRDb21waWxlcnMpIHsKKyAg ICAgICAgbV9mcmFnbWVudENvbXBpbGVyID0gU2hDb25zdHJ1Y3RDb21waWxlcihFU2hMYW5nRnJh Z21lbnQsIEVTaFNwZWNXZWJHTCwgJm1fcmVzb3VyY2VzKTsKKyAgICAgICAgbV92ZXJ0ZXhDb21w aWxlciA9IFNoQ29uc3RydWN0Q29tcGlsZXIoRVNoTGFuZ1ZlcnRleCwgRVNoU3BlY1dlYkdMLCAm bV9yZXNvdXJjZXMpOworCisgICAgICAgIGJ1aWx0Q29tcGlsZXJzID0gdHJ1ZTsKKyAgICB9Cisg ICAgCisgICAgU2hIYW5kbGUgY29tcGlsZXI7CisKKyAgICBpZiAoc2hhZGVyVHlwZSA9PSBTSEFE RVJfVFlQRV9WRVJURVgpCisgICAgICAgIGNvbXBpbGVyID0gbV92ZXJ0ZXhDb21waWxlcjsKKyAg ICBlbHNlIGlmIChzaGFkZXJUeXBlID09IFNIQURFUl9UWVBFX0ZSQUdNRU5UKQorICAgICAgICBj b21waWxlciA9IG1fZnJhZ21lbnRDb21waWxlcjsKKworICAgIGNvbnN0IGNoYXIqIGNvbnN0IHNo YWRlclNvdXJjZVN0cmluZ3NbXSA9IHsgc2hhZGVyU291cmNlIH07CisKKyAgICBib29sIHZhbGlk YXRlU3VjY2VzcyA9IFNoQ29tcGlsZShjb21waWxlciwgc2hhZGVyU291cmNlU3RyaW5ncywgMSwg RVNoT3B0Tm9uZSwgRURlYnVnT3BJbnRlcm1lZGlhdGUpOworCisgICAgdHJhbnNsYXRlZFNoYWRl clNvdXJjZSA9IFNoR2V0T2JqZWN0Q29kZShjb21waWxlcik7CisgICAgc2hhZGVyVmFsaWRhdGlv bkxvZyA9IFNoR2V0SW5mb0xvZyhjb21waWxlcik7CisKKyAgICByZXR1cm4gdmFsaWRhdGVTdWNj ZXNzOworfQorCit9CisKKyNlbmRpZiAvLyBFTkFCTEUoM0RfQ0FOVkFTKQpJbmRleDogV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9BTkdMRVdlYmtpdEJyaWRnZS5oCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvQU5HTEVXZWJraXRCcmlkZ2UuaAkocmV2aXNpb24gMCkK KysrIFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvQU5HTEVXZWJraXRCcmlkZ2UuaAkocmV2aXNp b24gMCkKQEAgLTAsMCArMSw2MyBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMCBBcHBsZSBJ bmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBp biBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRp b24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMK KyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCBy ZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29u ZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRp b25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAq ICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFs cyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJ UyBQUk9WSURFRCBCWSBBUFBMRSBDT01QVVRFUiwgSU5DLiBgYEFTIElTJycgQU5EIEFOWQorICog RVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVE IFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJ VE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5P IEVWRU5UIFNIQUxMIEFQUExFIENPTVBVVEVSLCBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUg TElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAq IEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1Qg TElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklD RVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJS VVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZ LCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5D TFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9G IFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9T U0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuIAorICovCisKKyNpZm5kZWYgQU5HTEVXZWJraXRCcmlk Z2VfaAorI2RlZmluZSBBTkdMRVdlYmtpdEJyaWRnZV9oCisKKyNpbmNsdWRlICJQbGF0Zm9ybVN0 cmluZy5oIgorI2luY2x1ZGUgIkFOR0xFL1NoYWRlckxhbmcuaCIKKworI2luY2x1ZGUgPHd0Zi90 ZXh0L0NTdHJpbmcuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitlbnVtIEFOR0xFU2hhZGVy VHlwZSB7CisgICAgU0hBREVSX1RZUEVfVkVSVEVYID0gRVNoTGFuZ1ZlcnRleCwKKyAgICBTSEFE RVJfVFlQRV9GUkFHTUVOVCA9IEVTaExhbmdGcmFnbWVudAorfTsKKworY2xhc3MgQU5HTEVXZWJr aXRCcmlkZ2UgeworcHVibGljOgorCisgICAgQU5HTEVXZWJraXRCcmlkZ2UoKTsKKyAgICB+QU5H TEVXZWJraXRCcmlkZ2UoKTsKKyAgICAKKyAgICB2b2lkIHNldFJlc291cmNlcyhUQnVpbHRJblJl c291cmNlIHJlc291cmNlcykgeyBtX3Jlc291cmNlcyA9IHJlc291cmNlczsgfQorICAgIAorICAg IGJvb2wgdmFsaWRhdGVTaGFkZXJTb3VyY2UoY29uc3QgY2hhciogc2hhZGVyU291cmNlLCBBTkdM RVNoYWRlclR5cGUgc2hhZGVyVHlwZSwgU3RyaW5nJiB0cmFuc2xhdGVkU2hhZGVyU291cmNlLCBT dHJpbmcmIHNoYWRlclZhbGlkYXRpb25Mb2cpOworCitwcml2YXRlOgorCisgICAgU2hIYW5kbGUg bV9mcmFnbWVudENvbXBpbGVyOworICAgIFNoSGFuZGxlIG1fdmVydGV4Q29tcGlsZXI7CisKKyAg ICBib29sIGJ1aWx0Q29tcGlsZXJzOworCisgICAgVEJ1aWx0SW5SZXNvdXJjZSBtX3Jlc291cmNl czsKK307CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmCkluZGV4OiBXZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL0dyYXBoaWNzQ29udGV4dDNELmgKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGljc0NvbnRleHQzRC5oCShyZXZpc2lvbiA2NTMw OCkKKysrIFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3JhcGhpY3NDb250ZXh0M0QuaAkod29y a2luZyBjb3B5KQpAQCAtMjYsOSArMjYsMTEgQEAKICNpZm5kZWYgR3JhcGhpY3NDb250ZXh0M0Rf aAogI2RlZmluZSBHcmFwaGljc0NvbnRleHQzRF9oCiAKKyNpbmNsdWRlICJBTkdMRVdlYmtpdEJy aWRnZS5oIgogI2luY2x1ZGUgIkdyYXBoaWNzTGF5ZXIuaCIKICNpbmNsdWRlICJQbGF0Zm9ybVN0 cmluZy5oIgogCisjaW5jbHVkZSA8d3RmL0hhc2hNYXAuaD4KICNpbmNsdWRlIDx3dGYvTGlzdEhh c2hTZXQuaD4KICNpbmNsdWRlIDx3dGYvTm9uY29weWFibGUuaD4KICNpbmNsdWRlIDx3dGYvUGFz c093blB0ci5oPgpAQCAtODExLDYgKzgxMywxNSBAQCBwdWJsaWM6CiAKICAgICBpbnQgbV9jdXJy ZW50V2lkdGgsIG1fY3VycmVudEhlaWdodDsKIAorICAgIHR5cGVkZWYgc3RydWN0IHsgCisgICAg ICAgIFN0cmluZyBzb3VyY2U7IAorICAgICAgICBTdHJpbmcgbG9nOyAKKyAgICAgICAgYm9vbCBp c1ZhbGlkOworICAgIH0gU2hhZGVyU291cmNlRW50cnk7CisgICAgSGFzaE1hcDxQbGF0Zm9ybTNE T2JqZWN0LCBTaGFkZXJTb3VyY2VFbnRyeT4gbV9zaGFkZXJTb3VyY2VNYXA7CisKKyAgICBBTkdM RVdlYmtpdEJyaWRnZSBtX2NvbXBpbGVyOworCiAjaWYgUExBVEZPUk0oTUFDKQogICAgIEF0dHJp YnV0ZXMgbV9hdHRyczsKICAgICBWZWN0b3I8VmVjdG9yPGZsb2F0PiA+IG1fdmVydGV4QXJyYXk7 CkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL21hYy9HcmFwaGljc0NvbnRleHQzRE1h Yy5tbQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL21hYy9HcmFwaGlj c0NvbnRleHQzRE1hYy5tbQkocmV2aXNpb24gNjUzMDgpCisrKyBXZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL21hYy9HcmFwaGljc0NvbnRleHQzRE1hYy5tbQkod29ya2luZyBjb3B5KQpAQCAtMzEs NiArMzEsOCBAQAogCiAjaW1wb3J0ICJCbG9ja0V4Y2VwdGlvbnMuaCIKIAorI2luY2x1ZGUgIkFO R0xFL1Jlc291cmNlTGltaXRzLmgiCisjaW5jbHVkZSAiQU5HTEVXZWJraXRCcmlkZ2UuaCIKICNp bmNsdWRlICJBcnJheUJ1ZmZlci5oIgogI2luY2x1ZGUgIkFycmF5QnVmZmVyVmlldy5oIgogI2lu Y2x1ZGUgIldlYkdMT2JqZWN0LmgiCkBAIC0xODEsNiArMTgzLDMwIEBAIEdyYXBoaWNzQ29udGV4 dDNEOjpHcmFwaGljc0NvbnRleHQzRChHcmEKICAgICAgICAgICAgIDo6Z2xHZW5SZW5kZXJidWZm ZXJzRVhUKDEsICZtX211bHRpc2FtcGxlRGVwdGhTdGVuY2lsQnVmZmVyKTsKICAgICB9CiAgICAg CisgICAgLy8gQU5HTEUgaW5pdGlhbGl6YXRpb24uCisKKyAgICBUQnVpbHRJblJlc291cmNlIEFO R0xFUmVzb3VyY2VzOworCisgICAgQU5HTEVSZXNvdXJjZXMubWF4VmVydGV4QXR0cmlicyA9IDA7 CisgICAgZ2V0SW50ZWdlcnYoR3JhcGhpY3NDb250ZXh0M0Q6Ok1BWF9WRVJURVhfQVRUUklCUywg JkFOR0xFUmVzb3VyY2VzLm1heFZlcnRleEF0dHJpYnMpOworICAgIEFOR0xFUmVzb3VyY2VzLm1h eFZlcnRleFVuaWZvcm1WZWN0b3JzID0gMDsKKyAgICBnZXRJbnRlZ2VydihHcmFwaGljc0NvbnRl eHQzRDo6TUFYX1ZFUlRFWF9VTklGT1JNX1ZFQ1RPUlMsICZBTkdMRVJlc291cmNlcy5tYXhWZXJ0 ZXhVbmlmb3JtVmVjdG9ycyk7CisgICAgQU5HTEVSZXNvdXJjZXMubWF4VmFyeWluZ1ZlY3RvcnMg PSAwOworICAgIGdldEludGVnZXJ2KEdyYXBoaWNzQ29udGV4dDNEOjpNQVhfVkFSWUlOR19WRUNU T1JTLCAmQU5HTEVSZXNvdXJjZXMubWF4VmFyeWluZ1ZlY3RvcnMpOworICAgIEFOR0xFUmVzb3Vy Y2VzLm1heFZlcnRleFRleHR1cmVJbWFnZVVuaXRzID0gMDsKKyAgICBnZXRJbnRlZ2VydihHcmFw aGljc0NvbnRleHQzRDo6TUFYX1ZFUlRFWF9URVhUVVJFX0lNQUdFX1VOSVRTLCAmQU5HTEVSZXNv dXJjZXMubWF4VmVydGV4VGV4dHVyZUltYWdlVW5pdHMpOworICAgIEFOR0xFUmVzb3VyY2VzLm1h eENvbWJpbmVkVGV4dHVyZUltYWdlVW5pdHMgPSAwOworICAgIGdldEludGVnZXJ2KEdyYXBoaWNz Q29udGV4dDNEOjpNQVhfQ09NQklORURfVEVYVFVSRV9JTUFHRV9VTklUUywgJkFOR0xFUmVzb3Vy Y2VzLm1heENvbWJpbmVkVGV4dHVyZUltYWdlVW5pdHMpOworICAgIEFOR0xFUmVzb3VyY2VzLm1h eFRleHR1cmVJbWFnZVVuaXRzID0gMDsKKyAgICBnZXRJbnRlZ2VydihHcmFwaGljc0NvbnRleHQz RDo6TUFYX1RFWFRVUkVfSU1BR0VfVU5JVFMsICZBTkdMRVJlc291cmNlcy5tYXhUZXh0dXJlSW1h Z2VVbml0cyk7CisgICAgQU5HTEVSZXNvdXJjZXMubWF4RnJhZ21lbnRVbmlmb3JtVmVjdG9ycyA9 IDA7CisgICAgZ2V0SW50ZWdlcnYoR3JhcGhpY3NDb250ZXh0M0Q6Ok1BWF9GUkFHTUVOVF9VTklG T1JNX1ZFQ1RPUlMsICZBTkdMRVJlc291cmNlcy5tYXhGcmFnbWVudFVuaWZvcm1WZWN0b3JzKTsK KworICAgIC8vIEFsd2F5cyBzZXQgdG8gMSBmb3IgT3BlbkdMIEVTLgorICAgIEFOR0xFUmVzb3Vy Y2VzLm1heERyYXdCdWZmZXJzID0gMTsKKyAgICAKKyAgICBtX2NvbXBpbGVyLnNldFJlc291cmNl cyhBTkdMRVJlc291cmNlcyk7CisgICAgCiAgICAgOjpnbEVuYWJsZShHTF9WRVJURVhfUFJPR1JB TV9QT0lOVF9TSVpFKTsKICAgICA6OmdsQ2xlYXJDb2xvcigwLCAwLCAwLCAwKTsKIH0KQEAgLTYx Nyw3ICs2NDMsNTIgQEAgdm9pZCBHcmFwaGljc0NvbnRleHQzRDo6Y29tcGlsZVNoYWRlcihQbAog ewogICAgIEFTU0VSVChzaGFkZXIpOwogICAgIGVuc3VyZUNvbnRleHQobV9jb250ZXh0T2JqKTsK KworICAgIGludCBHTHNoYWRlclR5cGU7CisgICAgQU5HTEVTaGFkZXJUeXBlIHNoYWRlclR5cGU7 CisKKyAgICBnbEdldFNoYWRlcml2KHNoYWRlciwgU0hBREVSX1RZUEUsICZHTHNoYWRlclR5cGUp OworICAgIAorICAgIGlmIChHTHNoYWRlclR5cGUgPT0gVkVSVEVYX1NIQURFUikKKyAgICAgICAg c2hhZGVyVHlwZSA9IFNIQURFUl9UWVBFX1ZFUlRFWDsKKyAgICBlbHNlIGlmIChHTHNoYWRlclR5 cGUgPT0gRlJBR01FTlRfU0hBREVSKQorICAgICAgICBzaGFkZXJUeXBlID0gU0hBREVSX1RZUEVf RlJBR01FTlQ7CisgICAgZWxzZQorICAgICAgICByZXR1cm47IC8vIEludmFsaWQgc2hhZGVyIHR5 cGUuCisKKyAgICBIYXNoTWFwPFBsYXRmb3JtM0RPYmplY3QsIFNoYWRlclNvdXJjZUVudHJ5Pjo6 aXRlcmF0b3IgcmVzdWx0ID0gbV9zaGFkZXJTb3VyY2VNYXAuZmluZChzaGFkZXIpOworCisgICAg aWYgKHJlc3VsdCA9PSBtX3NoYWRlclNvdXJjZU1hcC5lbmQoKSkKKyAgICAgICAgcmV0dXJuOwor CisgICAgU2hhZGVyU291cmNlRW50cnkmIGVudHJ5ID0gcmVzdWx0LT5zZWNvbmQ7CisKKyAgICBT dHJpbmcgdHJhbnNsYXRlZFNoYWRlclNvdXJjZTsKKyAgICBTdHJpbmcgc2hhZGVySW5mb0xvZzsK KworICAgIGJvb2wgaXNWYWxpZCA9IG1fY29tcGlsZXIudmFsaWRhdGVTaGFkZXJTb3VyY2UoZW50 cnkuc291cmNlLnV0ZjgoKS5kYXRhKCksIHNoYWRlclR5cGUsIHRyYW5zbGF0ZWRTaGFkZXJTb3Vy Y2UsIHNoYWRlckluZm9Mb2cpOworCisgICAgZW50cnkubG9nID0gc2hhZGVySW5mb0xvZzsKKyAg ICBlbnRyeS5pc1ZhbGlkID0gaXNWYWxpZDsKKworICAgIGlmICghaXNWYWxpZCkKKyAgICAgICAg cmV0dXJuOyAvLyBTaGFkZXIgZGlkbid0IHZhbGlkYXRlLCBkb24ndCBtb3ZlIGZvcndhcmQgd2l0 aCBjb21waWxpbmcgdHJhbnNsYXRlZCBzb3VyY2UgICAgCisKKyAgICBpbnQgdHJhbnNsYXRlZFNo YWRlckxlbmd0aCA9IHRyYW5zbGF0ZWRTaGFkZXJTb3VyY2UubGVuZ3RoKCk7CisKKyAgICBjb25z dCBDU3RyaW5nJiB0cmFuc2xhdGVkU2hhZGVyQ1N0cmluZyA9IHRyYW5zbGF0ZWRTaGFkZXJTb3Vy Y2UudXRmOCgpOworICAgIGNvbnN0IGNoYXIqIHRyYW5zbGF0ZWRTaGFkZXJQdHIgPSB0cmFuc2xh dGVkU2hhZGVyQ1N0cmluZy5kYXRhKCk7CisgICAgCisgICAgOjpnbFNoYWRlclNvdXJjZSgoR0x1 aW50KSBzaGFkZXIsIDEsICZ0cmFuc2xhdGVkU2hhZGVyUHRyLCAmdHJhbnNsYXRlZFNoYWRlckxl bmd0aCk7CisgICAgCiAgICAgOjpnbENvbXBpbGVTaGFkZXIoKEdMdWludCkgc2hhZGVyKTsKKyAg ICAKKyAgICBpbnQgR0xDb21waWxlU3VjY2VzczsKKyAgICAKKyAgICA6OmdsR2V0U2hhZGVyaXYo KEdMdWludCkgc2hhZGVyLCBDT01QSUxFX1NUQVRVUywgJkdMQ29tcGlsZVN1Y2Nlc3MpOworICAg IAorICAgIC8vIEFTU0VSVCB0aGF0IEFOR0xFIGdlbmVyYXRlZCBHTFNMIHdpbGwgYmUgYWNjZXB0 ZWQgYnkgT3BlbkdMCisgICAgQVNTRVJUKEdMQ29tcGlsZVN1Y2Nlc3MgPT0gR0xfVFJVRSk7CiB9 CiAKIHZvaWQgR3JhcGhpY3NDb250ZXh0M0Q6OmNvcHlUZXhJbWFnZTJEKHVuc2lnbmVkIGxvbmcg dGFyZ2V0LCBsb25nIGxldmVsLCB1bnNpZ25lZCBsb25nIGludGVybmFsZm9ybWF0LCBsb25nIHgs IGxvbmcgeSwgdW5zaWduZWQgbG9uZyB3aWR0aCwgdW5zaWduZWQgbG9uZyBoZWlnaHQsIGxvbmcg Ym9yZGVyKQpAQCAtOTk4LDExICsxMDY5LDEyIEBAIHZvaWQgR3JhcGhpY3NDb250ZXh0M0Q6OnNo YWRlclNvdXJjZShQbGEKICAgICBBU1NFUlQoc2hhZGVyKTsKICAgICAKICAgICBlbnN1cmVDb250 ZXh0KG1fY29udGV4dE9iaik7Ci0gICAgY29uc3QgQ1N0cmluZyYgY3MgPSBzdHJpbmcudXRmOCgp OwotICAgIGNvbnN0IGNoYXIqIHMgPSBjcy5kYXRhKCk7Ci0gICAgCi0gICAgaW50IGxlbmd0aCA9 IHN0cmluZy5sZW5ndGgoKTsKLSAgICA6OmdsU2hhZGVyU291cmNlKChHTHVpbnQpIHNoYWRlciwg MSwgJnMsICZsZW5ndGgpOworCisgICAgU2hhZGVyU291cmNlRW50cnkgZW50cnk7CisKKyAgICBl bnRyeS5zb3VyY2UgPSBzdHJpbmc7CisKKyAgICBtX3NoYWRlclNvdXJjZU1hcC5zZXQoc2hhZGVy LCBlbnRyeSk7CiB9CiAKIHZvaWQgR3JhcGhpY3NDb250ZXh0M0Q6OnN0ZW5jaWxGdW5jKHVuc2ln bmVkIGxvbmcgZnVuYywgbG9uZyByZWYsIHVuc2lnbmVkIGxvbmcgbWFzaykKQEAgLTEzNDYsMjYg KzE0MTgsNzcgQEAgdm9pZCBHcmFwaGljc0NvbnRleHQzRDo6Z2V0U2hhZGVyaXYoUGxhdAogICAg IEFTU0VSVChzaGFkZXIpOwogICAgIAogICAgIGVuc3VyZUNvbnRleHQobV9jb250ZXh0T2JqKTsK LSAgICA6OmdsR2V0U2hhZGVyaXYoKEdMdWludCkgc2hhZGVyLCBwbmFtZSwgdmFsdWUpOworICAg IAorICAgIEhhc2hNYXA8UGxhdGZvcm0zRE9iamVjdCwgU2hhZGVyU291cmNlRW50cnk+OjppdGVy YXRvciByZXN1bHQgPSBtX3NoYWRlclNvdXJjZU1hcC5maW5kKHNoYWRlcik7CisgICAgCisgICAg c3dpdGNoIChwbmFtZSkgeworICAgICAgICBjYXNlIERFTEVURV9TVEFUVVM6CisgICAgICAgIGNh c2UgU0hBREVSX1RZUEU6CisgICAgICAgICAgICAvLyBMZXQgT3BlbkdMIGhhbmRsZSB0aGVzZS4K KyAgICAgICAgCisgICAgICAgICAgICA6OmdsR2V0U2hhZGVyaXYoKEdMdWludCkgc2hhZGVyLCBw bmFtZSwgdmFsdWUpOworICAgICAgICAgICAgYnJlYWs7CisKKyAgICAgICAgY2FzZSBDT01QSUxF X1NUQVRVUzoKKyAgICAgICAgICAgIGlmIChyZXN1bHQgPT0gbV9zaGFkZXJTb3VyY2VNYXAuZW5k KCkpIHsKKyAgICAgICAgICAgICAgICAoKnZhbHVlKSA9IHN0YXRpY19jYXN0PGludD4oZmFsc2Up OworICAgICAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAg ICAKKyAgICAgICAgICAgICgqdmFsdWUpID0gc3RhdGljX2Nhc3Q8aW50PihyZXN1bHQtPnNlY29u ZC5pc1ZhbGlkKTsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgCisgICAgICAgIGNh c2UgSU5GT19MT0dfTEVOR1RIOgorICAgICAgICAgICAgaWYgKHJlc3VsdCA9PSBtX3NoYWRlclNv dXJjZU1hcC5lbmQoKSkgeworICAgICAgICAgICAgICAgICgqdmFsdWUpID0gMDsKKyAgICAgICAg ICAgICAgICByZXR1cm47CisgICAgICAgICAgICB9CisgICAgICAgICAgICAKKyAgICAgICAgICAg ICgqdmFsdWUpID0gZ2V0U2hhZGVySW5mb0xvZyhzaGFkZXIpLmxlbmd0aCgpOworICAgICAgICAg ICAgYnJlYWs7CisgICAgICAgICAgICAKKyAgICAgICAgY2FzZSBTSEFERVJfU09VUkNFX0xFTkdU SDoKKyAgICAgICAgICAgICgqdmFsdWUpID0gZ2V0U2hhZGVyU291cmNlKHNoYWRlcikubGVuZ3Ro KCk7CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgCisgICAgICAgIGRlZmF1bHQ6CisgICAg ICAgICAgICBzeW50aGVzaXplR0xFcnJvcihJTlZBTElEX0VOVU0pOworICAgIH0KIH0KIAogU3Ry aW5nIEdyYXBoaWNzQ29udGV4dDNEOjpnZXRTaGFkZXJJbmZvTG9nKFBsYXRmb3JtM0RPYmplY3Qg c2hhZGVyKQogewogICAgIEFTU0VSVChzaGFkZXIpOwotICAgIAorCiAgICAgZW5zdXJlQ29udGV4 dChtX2NvbnRleHRPYmopOwogICAgIEdMaW50IGxlbmd0aDsKICAgICA6OmdsR2V0U2hhZGVyaXYo KEdMdWludCkgc2hhZGVyLCBHTF9JTkZPX0xPR19MRU5HVEgsICZsZW5ndGgpOwotICAgIAotICAg IEdMc2l6ZWkgc2l6ZTsKLSAgICBHTGNoYXIqIGluZm8gPSAoR0xjaGFyKikgZmFzdE1hbGxvYyhs ZW5ndGgpOwotICAgIGlmICghaW5mbykKLSAgICAgICAgcmV0dXJuICIiOwotICAgICAgICAKLSAg ICA6OmdsR2V0U2hhZGVySW5mb0xvZygoR0x1aW50KSBzaGFkZXIsIGxlbmd0aCwgJnNpemUsIGlu Zm8pOwotICAgIFN0cmluZyBzKGluZm8pOwotICAgIGZhc3RGcmVlKGluZm8pOwotICAgIHJldHVy biBzOworCisgICAgSGFzaE1hcDxQbGF0Zm9ybTNET2JqZWN0LCBTaGFkZXJTb3VyY2VFbnRyeT46 Oml0ZXJhdG9yIHJlc3VsdCA9IG1fc2hhZGVyU291cmNlTWFwLmZpbmQoc2hhZGVyKTsKKworICAg IGlmIChyZXN1bHQgPT0gbV9zaGFkZXJTb3VyY2VNYXAuZW5kKCkpCisgICAgICAgICByZXR1cm4g IiI7CisKKyAgICAgU2hhZGVyU291cmNlRW50cnkgZW50cnkgPSByZXN1bHQtPnNlY29uZDsKKwor ICAgICBpZiAoZW50cnkuaXNWYWxpZCkgeworICAgICAgICAgR0xpbnQgbGVuZ3RoOworICAgICAg ICAgOjpnbEdldFNoYWRlcml2KChHTHVpbnQpIHNoYWRlciwgR0xfSU5GT19MT0dfTEVOR1RILCAm bGVuZ3RoKTsKKworICAgICAgICAgR0xzaXplaSBzaXplOworICAgICAgICAgR0xjaGFyKiBpbmZv ID0gKEdMY2hhciopIGZhc3RNYWxsb2MobGVuZ3RoKTsKKyAgICAgICAgIGlmICghaW5mbykKKyAg ICAgICAgICAgICByZXR1cm4gIiI7CisKKyAgICAgICAgIDo6Z2xHZXRTaGFkZXJJbmZvTG9nKChH THVpbnQpIHNoYWRlciwgbGVuZ3RoLCAmc2l6ZSwgaW5mbyk7CisKKyAgICAgICAgIFN0cmluZyBz KGluZm8pOworICAgICAgICAgZmFzdEZyZWUoaW5mbyk7CisgICAgICAgICByZXR1cm4gczsKKyAg ICAgfQorICAgICBlbHNlIHsKKyAgICAgICAgIHJldHVybiBlbnRyeS5sb2c7CisgICAgIH0KIH0K IAogU3RyaW5nIEdyYXBoaWNzQ29udGV4dDNEOjpnZXRTaGFkZXJTb3VyY2UoUGxhdGZvcm0zRE9i amVjdCBzaGFkZXIpCkBAIC0xMzczLDE4ICsxNDk2LDEzIEBAIFN0cmluZyBHcmFwaGljc0NvbnRl eHQzRDo6Z2V0U2hhZGVyU291cmMKICAgICBBU1NFUlQoc2hhZGVyKTsKIAogICAgIGVuc3VyZUNv bnRleHQobV9jb250ZXh0T2JqKTsKLSAgICBHTGludCBsZW5ndGg7Ci0gICAgOjpnbEdldFNoYWRl cml2KChHTHVpbnQpIHNoYWRlciwgR0xfU0hBREVSX1NPVVJDRV9MRU5HVEgsICZsZW5ndGgpOwot ICAgIAotICAgIEdMc2l6ZWkgc2l6ZTsKLSAgICBHTGNoYXIqIGluZm8gPSAoR0xjaGFyKikgZmFz dE1hbGxvYyhsZW5ndGgpOwotICAgIGlmICghaW5mbykKKworICAgIEhhc2hNYXA8UGxhdGZvcm0z RE9iamVjdCwgU2hhZGVyU291cmNlRW50cnk+OjppdGVyYXRvciByZXN1bHQgPSBtX3NoYWRlclNv dXJjZU1hcC5maW5kKHNoYWRlcik7CisKKyAgICBpZiAocmVzdWx0ID09IG1fc2hhZGVyU291cmNl TWFwLmVuZCgpKQogICAgICAgICByZXR1cm4gIiI7Ci0gICAgICAgIAotICAgIDo6Z2xHZXRTaGFk ZXJTb3VyY2UoKEdMdWludCkgc2hhZGVyLCBsZW5ndGgsICZzaXplLCBpbmZvKTsKLSAgICBTdHJp bmcgcyhpbmZvKTsKLSAgICBmYXN0RnJlZShpbmZvKTsKLSAgICByZXR1cm4gczsKKworICAgIHJl dHVybiByZXN1bHQtPnNlY29uZC5zb3VyY2U7CiB9CiAKIAo= 64382 2010-08-13 15:49:22 -0700 2010-08-16 12:00:29 -0700 Changes to LayoutTests for ANGLE angle-for-translation-tests text/plain 4151 psawaya SW5kZXg6IExheW91dFRlc3RzL2Zhc3QvY2FudmFzL3dlYmdsL2NvbnRleHQtYXR0cmlidXRlcy1h bHBoYS1kZXB0aC1zdGVuY2lsLWFudGlhbGlhcy5odG1sCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRl c3RzL2Zhc3QvY2FudmFzL3dlYmdsL2NvbnRleHQtYXR0cmlidXRlcy1hbHBoYS1kZXB0aC1zdGVu Y2lsLWFudGlhbGlhcy5odG1sCShyZXZpc2lvbiA2NTMwOCkKKysrIExheW91dFRlc3RzL2Zhc3Qv Y2FudmFzL3dlYmdsL2NvbnRleHQtYXR0cmlidXRlcy1hbHBoYS1kZXB0aC1zdGVuY2lsLWFudGlh bGlhcy5odG1sCSh3b3JraW5nIGNvcHkpCkBAIC0xNiw3ICsxNiw3IEBAIHZvaWQgbWFpbigpCiA8 L3NjcmlwdD4KIAogPHNjcmlwdCBpZD0iZnNoYWRlciIgdHlwZT0ieC1zaGFkZXIveC1mcmFnbWVu dCI+Ci12YXJ5aW5nIHZlYzQgY29sb3I7Cit2YXJ5aW5nIGhpZ2hwIHZlYzQgY29sb3I7CiAKIHZv aWQgbWFpbigpCiB7CkluZGV4OiBMYXlvdXRUZXN0cy9mYXN0L2NhbnZhcy93ZWJnbC9nbC1iaW5k LWF0dHJpYi1sb2NhdGlvbi10ZXN0Lmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFz dC9jYW52YXMvd2ViZ2wvZ2wtYmluZC1hdHRyaWItbG9jYXRpb24tdGVzdC5odG1sCShyZXZpc2lv biA2NTMwOCkKKysrIExheW91dFRlc3RzL2Zhc3QvY2FudmFzL3dlYmdsL2dsLWJpbmQtYXR0cmli LWxvY2F0aW9uLXRlc3QuaHRtbAkod29ya2luZyBjb3B5KQpAQCAtMjMsNyArMjMsNyBAQCB2b2lk IG1haW4oKQogfQogPC9zY3JpcHQ+CiA8c2NyaXB0IGlkPSJmc2hhZGVyIiB0eXBlPSJ0ZXh0L3Nv bWV0aGluZy1ub3QtamF2YXNjcmlwdCI+Ci12YXJ5aW5nIHZlYzQgY29sb3I7Cit2YXJ5aW5nIGhp Z2hwIHZlYzQgY29sb3I7CiB2b2lkIG1haW4oKQogewogICBnbF9GcmFnQ29sb3IgPSBjb2xvcjsK SW5kZXg6IExheW91dFRlc3RzL2Zhc3QvY2FudmFzL3dlYmdsL3JlYWQtcGl4ZWxzLXBhY2stYWxp Z25tZW50Lmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9jYW52YXMvd2ViZ2wv cmVhZC1waXhlbHMtcGFjay1hbGlnbm1lbnQuaHRtbAkocmV2aXNpb24gNjUzMDgpCisrKyBMYXlv dXRUZXN0cy9mYXN0L2NhbnZhcy93ZWJnbC9yZWFkLXBpeGVscy1wYWNrLWFsaWdubWVudC5odG1s CSh3b3JraW5nIGNvcHkpCkBAIC0xNiw3ICsxNiw3IEBAIHZvaWQgbWFpbigpCiA8L3NjcmlwdD4K IAogPHNjcmlwdCBpZD0iZnNoYWRlciIgdHlwZT0ieC1zaGFkZXIveC1mcmFnbWVudCI+Ci12YXJ5 aW5nIHZlYzQgY29sb3I7Cit2YXJ5aW5nIGhpZ2hwIHZlYzQgY29sb3I7CiAKIHZvaWQgbWFpbigp CiB7CkluZGV4OiBMYXlvdXRUZXN0cy9mYXN0L2NhbnZhcy93ZWJnbC90ZXhJbWFnZTJESW1hZ2VE YXRhVGVzdC5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2Zhc3QvY2FudmFzL3dlYmds L3RleEltYWdlMkRJbWFnZURhdGFUZXN0Lmh0bWwJKHJldmlzaW9uIDY1MzA4KQorKysgTGF5b3V0 VGVzdHMvZmFzdC9jYW52YXMvd2ViZ2wvdGV4SW1hZ2UyREltYWdlRGF0YVRlc3QuaHRtbAkod29y a2luZyBjb3B5KQpAQCAtMTYsNyArMTYsNyBAQAogCiAgICAgPHNjcmlwdCBpZD0iZnNoYWRlciIg dHlwZT0ieC1zaGFkZXIveC1mcmFnbWVudCI+CiAgICAgICAgIHVuaWZvcm0gc2FtcGxlcjJEIHRl eDsKLSAgICAgICAgdmFyeWluZyB2ZWMyIHRleENvb3JkOworICAgICAgICB2YXJ5aW5nIGhpZ2hw IHZlYzIgdGV4Q29vcmQ7CiAgICAgICAgIHZvaWQgbWFpbigpCiAgICAgICAgIHsKICAgICAgICAg ICAgIGdsX0ZyYWdDb2xvciA9IHRleHR1cmUyRCh0ZXgsIHRleENvb3JkKTsKSW5kZXg6IExheW91 dFRlc3RzL2Zhc3QvY2FudmFzL3dlYmdsL3RleHR1cmUtYWN0aXZlLWJpbmQuaHRtbAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBMYXlvdXRUZXN0cy9mYXN0L2NhbnZhcy93ZWJnbC90ZXh0dXJlLWFjdGl2ZS1iaW5k Lmh0bWwJKHJldmlzaW9uIDY1MzA4KQorKysgTGF5b3V0VGVzdHMvZmFzdC9jYW52YXMvd2ViZ2wv dGV4dHVyZS1hY3RpdmUtYmluZC5odG1sCSh3b3JraW5nIGNvcHkpCkBAIC0yNiw3ICsyNiw3IEBA IHZvaWQgbWFpbigpCiAKIDxzY3JpcHQgaWQ9ImZzaGFkZXIiIHR5cGU9Ingtc2hhZGVyL3gtZnJh Z21lbnQiPgogdW5pZm9ybSBzYW1wbGVyMkQgdGV4OwotdmFyeWluZyB2ZWMyIHRleENvb3JkOwor dmFyeWluZyBoaWdocCB2ZWMyIHRleENvb3JkOwogdm9pZCBtYWluKCkKIHsKICAgZ2xfRnJhZ0Nv bG9yID0gdGV4dHVyZTJEKHRleCwgdGV4Q29vcmQpOwpJbmRleDogTGF5b3V0VGVzdHMvZmFzdC9j YW52YXMvd2ViZ2wvdGV4dHVyZS1jb21wbGV0ZS5odG1sCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRl c3RzL2Zhc3QvY2FudmFzL3dlYmdsL3RleHR1cmUtY29tcGxldGUuaHRtbAkocmV2aXNpb24gNjUz MDgpCisrKyBMYXlvdXRUZXN0cy9mYXN0L2NhbnZhcy93ZWJnbC90ZXh0dXJlLWNvbXBsZXRlLmh0 bWwJKHdvcmtpbmcgY29weSkKQEAgLTE1LDcgKzE1LDcgQEAKIDxzY3JpcHQgaWQ9InZzaGFkZXIi IHR5cGU9Ingtc2hhZGVyL3gtdmVydGV4Ij4KIGF0dHJpYnV0ZSB2ZWM0IHZQb3NpdGlvbjsKIGF0 dHJpYnV0ZSB2ZWMyIHRleENvb3JkMDsKLXZhcnlpbmcgdmVjMiB0ZXhDb29yZDsKK3Zhcnlpbmcg aGlnaHAgdmVjMiB0ZXhDb29yZDsKIHZvaWQgbWFpbigpCiB7CiAgICAgZ2xfUG9zaXRpb24gPSB2 UG9zaXRpb247CkBAIC0yNSw3ICsyNSw3IEBAIHZvaWQgbWFpbigpCiAKIDxzY3JpcHQgaWQ9ImZz aGFkZXIiIHR5cGU9Ingtc2hhZGVyL3gtZnJhZ21lbnQiPgogdW5pZm9ybSBzYW1wbGVyMkQgdGV4 OwotdmFyeWluZyB2ZWMyIHRleENvb3JkOwordmFyeWluZyBoaWdocCB2ZWMyIHRleENvb3JkOwog dm9pZCBtYWluKCkKIHsKICAgICBnbF9GcmFnQ29sb3IgPSB0ZXh0dXJlMkQodGV4LCB0ZXhDb29y ZCk7CkluZGV4OiBMYXlvdXRUZXN0cy9mYXN0L2NhbnZhcy93ZWJnbC90ZXh0dXJlLXRyYW5zcGFy ZW50LXBpeGVscy1pbml0aWFsaXplZC5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2Zh c3QvY2FudmFzL3dlYmdsL3RleHR1cmUtdHJhbnNwYXJlbnQtcGl4ZWxzLWluaXRpYWxpemVkLmh0 bWwJKHJldmlzaW9uIDY1MzA4KQorKysgTGF5b3V0VGVzdHMvZmFzdC9jYW52YXMvd2ViZ2wvdGV4 dHVyZS10cmFuc3BhcmVudC1waXhlbHMtaW5pdGlhbGl6ZWQuaHRtbAkod29ya2luZyBjb3B5KQpA QCAtMTgsNyArMTgsNyBAQCB2b2lkIG1haW4oKQogCiA8c2NyaXB0IGlkPSJmc2hhZGVyIiB0eXBl PSJ4LXNoYWRlci94LWZyYWdtZW50Ij4KIHVuaWZvcm0gc2FtcGxlcjJEIHRleDsKLXZhcnlpbmcg dmVjMiB0ZXhDb29yZDsKK3ZhcnlpbmcgaGlnaHAgdmVjMiB0ZXhDb29yZDsKIAogdm9pZCBtYWlu KCkKIHsKSW5kZXg6IExheW91dFRlc3RzL2Zhc3QvY2FudmFzL3dlYmdsL3Jlc291cmNlcy9mcmFn bWVudFNoYWRlci5mcmFnCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2Zhc3QvY2FudmFzL3dl YmdsL3Jlc291cmNlcy9mcmFnbWVudFNoYWRlci5mcmFnCShyZXZpc2lvbiA2NTMwOCkKKysrIExh eW91dFRlc3RzL2Zhc3QvY2FudmFzL3dlYmdsL3Jlc291cmNlcy9mcmFnbWVudFNoYWRlci5mcmFn CSh3b3JraW5nIGNvcHkpCkBAIC0xLDQgKzEsNCBAQAotdmFyeWluZyB2ZWMzIHZfbm9ybWFsOwor dmFyeWluZyBoaWdocCB2ZWMzIHZfbm9ybWFsOwogCiB2b2lkIG1haW4oKQogewo=