158830 2016-06-15 22:37:15 -0700 [WebIDL] Add support for Conditional extended attribute for implement statement. 2022-02-27 23:10:14 -0800 1 1 1 Unclassified WebKit Bindings WebKit Nightly Build Unspecified Unspecified RESOLVED WONTFIX P2 Normal --- 156096 1 rawinder.webkit rawinder.webkit beidson cdumez cgarcia commit-queue darin esprehn+autocc kondapallykalyan nikos.andronikos sam youennf oldest_to_newest 1202873 0 rawinder.webkit 2016-06-15 22:37:15 -0700 Bug #156096 relies on "Element implements Animatable" to be conditionally applied depending on whether ENABLE_WEB_ANIMATIONS is enabled. This patch adds extra functionality to read extended attributes for the implements statement and processes the "Conditional" attribute checking the condition against the preprocessor definitions passed to the preprocess-idls.pl script. See also http://www.w3.org/TR/WebIDL/#prod-ImplementsStatement. 1202878 1 281444 rawinder.webkit 2016-06-15 23:25:00 -0700 Created attachment 281444 Patch 1203121 2 281444 cdumez 2016-06-16 17:12:18 -0700 Comment on attachment 281444 Patch Why do we need this? Why can't we simply use [Conditional] on the interface that is on the right side of the 'implements' statement. This has been sufficient so far. 1203134 3 rawinder.webkit 2016-06-16 17:43:59 -0700 (In reply to comment #2) > Comment on attachment 281444 [details] > Patch > > Why do we need this? Why can't we simply use [Conditional] on the interface > that is on the right side of the 'implements' statement. This has been > sufficient so far. See the "Build error" attachment for Bug #156096. A quick overview: - The Animatable interface does have Conditional=WEB_ANIMATIONS. - In Element.idl, I defined Element implements Animatable However, when building with the WEB_ANIMATIONS condition off, the following error is produced by preprocess-idls.pl: Could not find a the IDL file where the following implemented interface is defined: Animatable at /home/mcatanzaro/src/WebKit/Source/WebCore/bindings/scripts/preprocess-idls.pl line 102. 1203147 4 cdumez 2016-06-16 18:17:26 -0700 (In reply to comment #3) > (In reply to comment #2) > > Comment on attachment 281444 [details] > > Patch > > > > Why do we need this? Why can't we simply use [Conditional] on the interface > > that is on the right side of the 'implements' statement. This has been > > sufficient so far. > > See the "Build error" attachment for Bug #156096. > > A quick overview: > > - The Animatable interface does have Conditional=WEB_ANIMATIONS. > - In Element.idl, I defined Element implements Animatable > > However, when building with the WEB_ANIMATIONS condition off, the following > error is produced by preprocess-idls.pl: > > Could not find a the IDL file where the following implemented interface is > defined: Animatable at > /home/mcatanzaro/src/WebKit/Source/WebCore/bindings/scripts/preprocess-idls. > pl line 102. This is supposed to work and usually does AFAIK. I think you encountered a specific bug that needs fixing rather than adding support for [Conditional] on implements statements. 1203151 5 cdumez 2016-06-16 18:31:30 -0700 (In reply to comment #4) > (In reply to comment #3) > > (In reply to comment #2) > > > Comment on attachment 281444 [details] > > > Patch > > > > > > Why do we need this? Why can't we simply use [Conditional] on the interface > > > that is on the right side of the 'implements' statement. This has been > > > sufficient so far. > > > > See the "Build error" attachment for Bug #156096. > > > > A quick overview: > > > > - The Animatable interface does have Conditional=WEB_ANIMATIONS. > > - In Element.idl, I defined Element implements Animatable > > > > However, when building with the WEB_ANIMATIONS condition off, the following > > error is produced by preprocess-idls.pl: > > > > Could not find a the IDL file where the following implemented interface is > > defined: Animatable at > > /home/mcatanzaro/src/WebKit/Source/WebCore/bindings/scripts/preprocess-idls. > > pl line 102. > > This is supposed to work and usually does AFAIK. I think you encountered a > specific bug that needs fixing rather than adding support for [Conditional] > on implements statements. The error you are giving seems to indicate that Animatable.idl was not passed to preprocess-idls.pl, which probably means Animatable.idl was not properly added to build fixes (e.g. CMakeList.txt). 1203153 6 cdumez 2016-06-16 18:36:12 -0700 (In reply to comment #5) > (In reply to comment #4) > > (In reply to comment #3) > > > (In reply to comment #2) > > > > Comment on attachment 281444 [details] > > > > Patch > > > > > > > > Why do we need this? Why can't we simply use [Conditional] on the interface > > > > that is on the right side of the 'implements' statement. This has been > > > > sufficient so far. > > > > > > See the "Build error" attachment for Bug #156096. > > > > > > A quick overview: > > > > > > - The Animatable interface does have Conditional=WEB_ANIMATIONS. > > > - In Element.idl, I defined Element implements Animatable > > > > > > However, when building with the WEB_ANIMATIONS condition off, the following > > > error is produced by preprocess-idls.pl: > > > > > > Could not find a the IDL file where the following implemented interface is > > > defined: Animatable at > > > /home/mcatanzaro/src/WebKit/Source/WebCore/bindings/scripts/preprocess-idls. > > > pl line 102. > > > > This is supposed to work and usually does AFAIK. I think you encountered a > > specific bug that needs fixing rather than adding support for [Conditional] > > on implements statements. > > The error you are giving seems to indicate that Animatable.idl was not > passed to preprocess-idls.pl, which probably means Animatable.idl was not > properly added to build fixes (e.g. CMakeList.txt). s/fixes/files 1203155 7 rawinder.webkit 2016-06-16 18:44:07 -0700 (In reply to comment #5) > (In reply to comment #4) > > (In reply to comment #3) > > > (In reply to comment #2) > > > > Comment on attachment 281444 [details] > > > > Patch > > > > > > > > Why do we need this? Why can't we simply use [Conditional] on the interface > > > > that is on the right side of the 'implements' statement. This has been > > > > sufficient so far. > > > > > > See the "Build error" attachment for Bug #156096. > > > > > > A quick overview: > > > > > > - The Animatable interface does have Conditional=WEB_ANIMATIONS. > > > - In Element.idl, I defined Element implements Animatable > > > > > > However, when building with the WEB_ANIMATIONS condition off, the following > > > error is produced by preprocess-idls.pl: > > > > > > Could not find a the IDL file where the following implemented interface is > > > defined: Animatable at > > > /home/mcatanzaro/src/WebKit/Source/WebCore/bindings/scripts/preprocess-idls. > > > pl line 102. > > > > This is supposed to work and usually does AFAIK. I think you encountered a > > specific bug that needs fixing rather than adding support for [Conditional] > > on implements statements. > > The error you are giving seems to indicate that Animatable.idl was not > passed to preprocess-idls.pl, which probably means Animatable.idl was not > properly added to build fixes (e.g. CMakeList.txt). In Source/WebCore/CMakeLists.txt I only include Animatable.idl if ENABLE_WEB_ANIMATIONS is defined. So, yes for the case that WEB_ANIMATIONS is disabled it will not be passed to preprocess-idls.pl (in which case this error occurs). I understand that I could probably work around it and append Animatable.idl to WebCore_IDL_FILES in CMakeLists.txt even if WEB_ANIMATAIONS is disabled - but I feel like this solution is more consistent with the way conditions have been used in the WebKit IDL elsewhere (and also checking for [.*] before the implements statement is more correct in terms of Web IDL) 1203157 8 cdumez 2016-06-16 18:48:48 -0700 (In reply to comment #7) > (In reply to comment #5) > > (In reply to comment #4) > > > (In reply to comment #3) > > > > (In reply to comment #2) > > > > > Comment on attachment 281444 [details] > > > > > Patch > > > > > > > > > > Why do we need this? Why can't we simply use [Conditional] on the interface > > > > > that is on the right side of the 'implements' statement. This has been > > > > > sufficient so far. > > > > > > > > See the "Build error" attachment for Bug #156096. > > > > > > > > A quick overview: > > > > > > > > - The Animatable interface does have Conditional=WEB_ANIMATIONS. > > > > - In Element.idl, I defined Element implements Animatable > > > > > > > > However, when building with the WEB_ANIMATIONS condition off, the following > > > > error is produced by preprocess-idls.pl: > > > > > > > > Could not find a the IDL file where the following implemented interface is > > > > defined: Animatable at > > > > /home/mcatanzaro/src/WebKit/Source/WebCore/bindings/scripts/preprocess-idls. > > > > pl line 102. > > > > > > This is supposed to work and usually does AFAIK. I think you encountered a > > > specific bug that needs fixing rather than adding support for [Conditional] > > > on implements statements. > > > > The error you are giving seems to indicate that Animatable.idl was not > > passed to preprocess-idls.pl, which probably means Animatable.idl was not > > properly added to build fixes (e.g. CMakeList.txt). > > In Source/WebCore/CMakeLists.txt I only include Animatable.idl if > ENABLE_WEB_ANIMATIONS is defined. So, yes for the case that WEB_ANIMATIONS > is disabled it will not be passed to preprocess-idls.pl (in which case this > error occurs). > > I understand that I could probably work around it and append Animatable.idl > to WebCore_IDL_FILES in CMakeLists.txt even if WEB_ANIMATAIONS is disabled - > but I feel like this solution is more consistent with the way conditions > have been used in the WebKit IDL elsewhere (and also checking for [.*] > before the implements statement is more correct in terms of Web IDL) Really? Does WebIDL say it is expected for implements statements to have extended attributes? It looks weird to me. I also don't think we want to add complexity to the bindings generator unless we really need to. 1203160 9 rawinder.webkit 2016-06-16 18:58:17 -0700 (In reply to comment #8) > (In reply to comment #7) > > (In reply to comment #5) > > > (In reply to comment #4) > > > > (In reply to comment #3) > > > > > (In reply to comment #2) > > > > > > Comment on attachment 281444 [details] > > > > > > Patch > > > > > > > > > > > > Why do we need this? Why can't we simply use [Conditional] on the interface > > > > > > that is on the right side of the 'implements' statement. This has been > > > > > > sufficient so far. > > > > > > > > > > See the "Build error" attachment for Bug #156096. > > > > > > > > > > A quick overview: > > > > > > > > > > - The Animatable interface does have Conditional=WEB_ANIMATIONS. > > > > > - In Element.idl, I defined Element implements Animatable > > > > > > > > > > However, when building with the WEB_ANIMATIONS condition off, the following > > > > > error is produced by preprocess-idls.pl: > > > > > > > > > > Could not find a the IDL file where the following implemented interface is > > > > > defined: Animatable at > > > > > /home/mcatanzaro/src/WebKit/Source/WebCore/bindings/scripts/preprocess-idls. > > > > > pl line 102. > > > > > > > > This is supposed to work and usually does AFAIK. I think you encountered a > > > > specific bug that needs fixing rather than adding support for [Conditional] > > > > on implements statements. > > > > > > The error you are giving seems to indicate that Animatable.idl was not > > > passed to preprocess-idls.pl, which probably means Animatable.idl was not > > > properly added to build fixes (e.g. CMakeList.txt). > > > > In Source/WebCore/CMakeLists.txt I only include Animatable.idl if > > ENABLE_WEB_ANIMATIONS is defined. So, yes for the case that WEB_ANIMATIONS > > is disabled it will not be passed to preprocess-idls.pl (in which case this > > error occurs). > > > > I understand that I could probably work around it and append Animatable.idl > > to WebCore_IDL_FILES in CMakeLists.txt even if WEB_ANIMATAIONS is disabled - > > but I feel like this solution is more consistent with the way conditions > > have been used in the WebKit IDL elsewhere (and also checking for [.*] > > before the implements statement is more correct in terms of Web IDL) > > Really? Does WebIDL say it is expected for implements statements to have > extended attributes? Yes. See https://www.w3.org/TR/WebIDL/#idl [1] Definitions → ExtendedAttributeList Definition Definitions | ε [2] Definition → CallbackOrInterface | Partial | Dictionary | Exception | Enum | Typedef | ImplementsStatement > > It looks weird to me. I also don't think we want to add complexity to the > bindings generator unless we really need to. Okay. Let me know if you still think I should change the implementation of Bug #156096 1203161 10 rawinder.webkit 2016-06-16 19:00:01 -0700 (In reply to comment #9) > (In reply to comment #8) > > (In reply to comment #7) > > > (In reply to comment #5) > > > > (In reply to comment #4) > > > > > (In reply to comment #3) > > > > > > (In reply to comment #2) > > > > > > > Comment on attachment 281444 [details] > > > > > > > Patch > > > > > > > > > > > > > > Why do we need this? Why can't we simply use [Conditional] on the interface > > > > > > > that is on the right side of the 'implements' statement. This has been > > > > > > > sufficient so far. > > > > > > > > > > > > See the "Build error" attachment for Bug #156096. > > > > > > > > > > > > A quick overview: > > > > > > > > > > > > - The Animatable interface does have Conditional=WEB_ANIMATIONS. > > > > > > - In Element.idl, I defined Element implements Animatable > > > > > > > > > > > > However, when building with the WEB_ANIMATIONS condition off, the following > > > > > > error is produced by preprocess-idls.pl: > > > > > > > > > > > > Could not find a the IDL file where the following implemented interface is > > > > > > defined: Animatable at > > > > > > /home/mcatanzaro/src/WebKit/Source/WebCore/bindings/scripts/preprocess-idls. > > > > > > pl line 102. > > > > > > > > > > This is supposed to work and usually does AFAIK. I think you encountered a > > > > > specific bug that needs fixing rather than adding support for [Conditional] > > > > > on implements statements. > > > > > > > > The error you are giving seems to indicate that Animatable.idl was not > > > > passed to preprocess-idls.pl, which probably means Animatable.idl was not > > > > properly added to build fixes (e.g. CMakeList.txt). > > > > > > In Source/WebCore/CMakeLists.txt I only include Animatable.idl if > > > ENABLE_WEB_ANIMATIONS is defined. So, yes for the case that WEB_ANIMATIONS > > > is disabled it will not be passed to preprocess-idls.pl (in which case this > > > error occurs). > > > > > > I understand that I could probably work around it and append Animatable.idl > > > to WebCore_IDL_FILES in CMakeLists.txt even if WEB_ANIMATAIONS is disabled - > > > but I feel like this solution is more consistent with the way conditions > > > have been used in the WebKit IDL elsewhere (and also checking for [.*] > > > before the implements statement is more correct in terms of Web IDL) > > > > Really? Does WebIDL say it is expected for implements statements to have > > extended attributes? > > Yes. See https://www.w3.org/TR/WebIDL/#idl > > [1] Definitions → ExtendedAttributeList Definition Definitions > | ε > [2] Definition → CallbackOrInterface > | Partial > | Dictionary > | Exception > | Enum > | Typedef > | ImplementsStatement > > > > > It looks weird to me. I also don't think we want to add complexity to the > > bindings generator unless we really need to. > > Okay. Let me know if you still think I should change the implementation of > Bug #156096 i.e. whether I should pursue this patch (or not) 1203162 11 cdumez 2016-06-16 19:04:08 -0700 (In reply to comment #10) > (In reply to comment #9) > > (In reply to comment #8) > > > (In reply to comment #7) > > > > (In reply to comment #5) > > > > > (In reply to comment #4) > > > > > > (In reply to comment #3) > > > > > > > (In reply to comment #2) > > > > > > > > Comment on attachment 281444 [details] > > > > > > > > Patch > > > > > > > > > > > > > > > > Why do we need this? Why can't we simply use [Conditional] on the interface > > > > > > > > that is on the right side of the 'implements' statement. This has been > > > > > > > > sufficient so far. > > > > > > > > > > > > > > See the "Build error" attachment for Bug #156096. > > > > > > > > > > > > > > A quick overview: > > > > > > > > > > > > > > - The Animatable interface does have Conditional=WEB_ANIMATIONS. > > > > > > > - In Element.idl, I defined Element implements Animatable > > > > > > > > > > > > > > However, when building with the WEB_ANIMATIONS condition off, the following > > > > > > > error is produced by preprocess-idls.pl: > > > > > > > > > > > > > > Could not find a the IDL file where the following implemented interface is > > > > > > > defined: Animatable at > > > > > > > /home/mcatanzaro/src/WebKit/Source/WebCore/bindings/scripts/preprocess-idls. > > > > > > > pl line 102. > > > > > > > > > > > > This is supposed to work and usually does AFAIK. I think you encountered a > > > > > > specific bug that needs fixing rather than adding support for [Conditional] > > > > > > on implements statements. > > > > > > > > > > The error you are giving seems to indicate that Animatable.idl was not > > > > > passed to preprocess-idls.pl, which probably means Animatable.idl was not > > > > > properly added to build fixes (e.g. CMakeList.txt). > > > > > > > > In Source/WebCore/CMakeLists.txt I only include Animatable.idl if > > > > ENABLE_WEB_ANIMATIONS is defined. So, yes for the case that WEB_ANIMATIONS > > > > is disabled it will not be passed to preprocess-idls.pl (in which case this > > > > error occurs). > > > > > > > > I understand that I could probably work around it and append Animatable.idl > > > > to WebCore_IDL_FILES in CMakeLists.txt even if WEB_ANIMATAIONS is disabled - > > > > but I feel like this solution is more consistent with the way conditions > > > > have been used in the WebKit IDL elsewhere (and also checking for [.*] > > > > before the implements statement is more correct in terms of Web IDL) > > > > > > Really? Does WebIDL say it is expected for implements statements to have > > > extended attributes? > > > > Yes. See https://www.w3.org/TR/WebIDL/#idl > > > > [1] Definitions → ExtendedAttributeList Definition Definitions > > | ε > > [2] Definition → CallbackOrInterface > > | Partial > > | Dictionary > > | Exception > > | Enum > > | Typedef > > | ImplementsStatement > > > > > > > > It looks weird to me. I also don't think we want to add complexity to the > > > bindings generator unless we really need to. > > > > Okay. Let me know if you still think I should change the implementation of > > Bug #156096 > > i.e. whether I should pursue this patch (or not) We haven't needed this so far and I don't think there is anything new that requires us to support extended attributes for implements statements. Unless there is some specific restriction (or problem I haven't thought of), I would personally prefer if we fixed CMakeLists.txt instead of adding code to the bindings generator to make CMake happy. 1203165 12 cdumez 2016-06-16 19:11:28 -0700 Maybe Darin or Sam have an opinion given that they hack the bindings a lot as well. 1204051 13 rawinder.webkit 2016-06-20 22:28:52 -0700 (In reply to comment #12) > Maybe Darin or Sam have an opinion given that they hack the bindings a lot > as well. Okay. There are 3 methods I can try to sort out this issue. However, all 3 require changes to the bindings generator code: 1. Use this method (i.e. Check for a conditional extended attribute) 2. Make changes to the CodeGeneratorGObject.pm and possibly the other bindings generators: - See attachment 281535 in Bug 156096, comment 51 - This error occurs when I move all IDL and cpp files that are currently guarded by the ENABLE_WEB_ANIMATAIONS condition in CMakeLists.txt into the main sections - Note: There may be other errors that also need to be addressed if I pursue this method. 3. See the patch for Bug #158975 - I am able to do this when I only move the Animatable.idl file into the main body in CMakeLists.txt, rather than all the IDL and cpp files currently guarded by the WEB_ANIMATAIONS condition. Let me know what you think. 1204173 14 cdumez 2016-06-21 09:40:55 -0700 (In reply to comment #13) > (In reply to comment #12) > > Maybe Darin or Sam have an opinion given that they hack the bindings a lot > > as well. > > Okay. There are 3 methods I can try to sort out this issue. However, all 3 > require changes to the bindings generator code: > > 1. Use this method (i.e. Check for a conditional extended attribute) > > 2. Make changes to the CodeGeneratorGObject.pm and possibly the other > bindings generators: > - See attachment 281535 [details] in Bug 156096, comment 51 > - This error occurs when I move all IDL and cpp files that are currently > guarded by the ENABLE_WEB_ANIMATAIONS condition in CMakeLists.txt into the > main sections > - Note: There may be other errors that also need to be addressed if I > pursue this method. > > 3. See the patch for Bug #158975 > - I am able to do this when I only move the Animatable.idl file into the > main body in CMakeLists.txt, rather than all the IDL and cpp files currently > guarded by the WEB_ANIMATAIONS condition. > > Let me know what you think. I like option number 2. The build error seems to indicate that the GObject bindings generator does not obey [Conditional] in some cases which seems like a bug that needs fixing. 1204447 15 rawinder.webkit 2016-06-21 23:34:01 -0700 (In reply to comment #14) > (In reply to comment #13) > > (In reply to comment #12) > > > Maybe Darin or Sam have an opinion given that they hack the bindings a lot > > > as well. > > > > Okay. There are 3 methods I can try to sort out this issue. However, all 3 > > require changes to the bindings generator code: > > > > 1. Use this method (i.e. Check for a conditional extended attribute) > > > > 2. Make changes to the CodeGeneratorGObject.pm and possibly the other > > bindings generators: > > - See attachment 281535 [details] in Bug 156096, comment 51 > > - This error occurs when I move all IDL and cpp files that are currently > > guarded by the ENABLE_WEB_ANIMATAIONS condition in CMakeLists.txt into the > > main sections > > - Note: There may be other errors that also need to be addressed if I > > pursue this method. > > > > 3. See the patch for Bug #158975 > > - I am able to do this when I only move the Animatable.idl file into the > > main body in CMakeLists.txt, rather than all the IDL and cpp files currently > > guarded by the WEB_ANIMATAIONS condition. > > > > Let me know what you think. > > I like option number 2. The build error seems to indicate that the GObject > bindings generator does not obey [Conditional] in some cases which seems > like a bug that needs fixing. I think the build error for option number 3 also indicates that the JS bindings generator code doesn't obey [Conditional]. The reason I chose to just move the Animatable.idl in option 3, is so that unused generated code isn't unnecessarily generated. Also, the reason I think it doesn't obey the [Conditional] is that the code is trying to include files for a return type in a function that has a [Conditional] - however the generated code doesn't try to put it within "#if ENABLE(CONDITION)" in this particular instance. The existence of the function AddToImplIncludes (which I use) indicates that the header files are conditionally included elsewhere in the generator. 1207542 16 nikos.andronikos 2016-07-03 16:57:49 -0700 Hi Chris, <snip> (In reply to comment #14) > > I like option number 2. The build error seems to indicate that the GObject > bindings generator does not obey [Conditional] in some cases which seems > like a bug that needs fixing. What is it about option 2 that you like? To us, it seems like the most clunky solution because it involves unnecessary work by the IDL preprocessor and generates unused bindings code. Personally, I think option 1 (add support for the Conditional extended attribute on the implements statement), which is implemented in this patch, sounds like the best solution. It's the most efficient and improves WebKit's IDL support. What's your reason for not liking it? We really need to get one of these patches in so we can continue the Web Animations implementation. It's been waiting on this issue to be resolved for a few weeks now. 1212682 17 youennf 2016-07-20 00:53:47 -0700 I also prefer option 2. It seems best to add compilation guards in header/source files and let the build system compile files even if feature is disabled. Having each include file be guarded also allows including these files into other files without guarding the #include. I don't know what is the build issue when moving all those files to the main section. Maybe a patch could be dedicated to move AnimationTimeline.idl et al to the main section and make the necessary fixes for that to work. 1340438 18 281444 beidson 2017-08-19 16:02:05 -0700 Comment on attachment 281444 Patch r-, as this has been pending review for over a year now. It is near-impossible that this patch still applies to trunk and unlikely to still be relevant in its current form. 281444 2016-06-15 23:25:00 -0700 2022-02-27 23:10:14 -0800 Patch bug-158830-20160616162409.patch text/plain 40903 rawinder.webkit U3VidmVyc2lvbiBSZXZpc2lvbjogMjAyMTI1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMzgwZTZiMzVmY2RkNmVl M2E0ZTMzZGExZDQxNDdhZTFhYjdjNjVjZC4uNGYzNTBkYWYwMDQ3M2Y1MzM4NzkzYTViMDUwZGU5 MGUyZjFlMjE2OSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDYzIEBACisyMDE2LTA2LTE1ICBSYXdp bmRlciBTaW5naCAgPHJhd2luZGVyLnNpbmdoLXdlYmtpdEBjaXNyYS5jYW5vbi5jb20uYXU+CisK KyAgICAgICAgW1dlYklETF0gQWRkIHN1cHBvcnQgZm9yIENvbmRpdGlvbmFsIGV4dGVuZGVkIGF0 dHJpYnV0ZSBmb3IgaW1wbGVtZW50IHN0YXRlbWVudC4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE1ODgzMAorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoaXMgcGF0Y2ggYWRkcyBleHRyYSBmdW5jdGlvbmFs aXR5IHRvIHJlYWQgZXh0ZW5kZWQgYXR0cmlidXRlcyBmb3IgdGhlIGltcGxlbWVudHMgc3RhdGVt ZW50IGFuZAorICAgICAgICBwcm9jZXNzZXMgdGhlICJDb25kaXRpb25hbCIgYXR0cmlidXRlIGNo ZWNraW5nIHRoZSBjb25kaXRpb24gYWdhaW5zdCB0aGUgcHJlcHJvY2Vzc29yIGRlZmluaXRpb25z IAorICAgICAgICBwYXNzZWQgdG8gdGhlIHByZXByb2Nlc3MtaWRscy5wbCBzY3JpcHQuCisKKyAg ICAgICAgKiBiaW5kaW5ncy9zY3JpcHRzL3ByZXByb2Nlc3MtaWRscy5wbDoKKyAgICAgICAgKGdl dEV4dGVuZGVkQXR0cmlidXRlc0Zyb21JRExTZWN0aW9uKToKKyAgICAgICAgKGdldEltcGxlbWVu dGVkSW50ZXJmYWNlc0Zyb21JREwpOgorICAgICAgICAoZ2V0SW50ZXJmYWNlRXh0ZW5kZWRBdHRy aWJ1dGVzRnJvbUlETCk6CisgICAgICAgICogYmluZGluZ3Mvc2NyaXB0cy90ZXN0L0dPYmplY3Qv V2ViS2l0RE9NVGVzdENvbmRpdGlvbmFsSW1wbGVtZW50cy5jcHA6IEFkZGVkLgorICAgICAgICAo V2ViS2l0OjpraXQpOgorICAgICAgICAoV2ViS2l0Ojpjb3JlKToKKyAgICAgICAgKFdlYktpdDo6 d3JhcFRlc3RDb25kaXRpb25hbEltcGxlbWVudHMpOgorICAgICAgICAod2Via2l0X2RvbV90ZXN0 X2NvbmRpdGlvbmFsX2ltcGxlbWVudHNfZmluYWxpemUpOgorICAgICAgICAod2Via2l0X2RvbV90 ZXN0X2NvbmRpdGlvbmFsX2ltcGxlbWVudHNfY29uc3RydWN0b3IpOgorICAgICAgICAod2Via2l0 X2RvbV90ZXN0X2NvbmRpdGlvbmFsX2ltcGxlbWVudHNfY2xhc3NfaW5pdCk6CisgICAgICAgICh3 ZWJraXRfZG9tX3Rlc3RfY29uZGl0aW9uYWxfaW1wbGVtZW50c19pbml0KToKKyAgICAgICAgKiBi aW5kaW5ncy9zY3JpcHRzL3Rlc3QvR09iamVjdC9XZWJLaXRET01UZXN0Q29uZGl0aW9uYWxJbXBs ZW1lbnRzLmg6IEFkZGVkLgorICAgICAgICAqIGJpbmRpbmdzL3NjcmlwdHMvdGVzdC9HT2JqZWN0 L1dlYktpdERPTVRlc3RDb25kaXRpb25hbEltcGxlbWVudHNQcml2YXRlLmg6IEFkZGVkLgorICAg ICAgICAqIGJpbmRpbmdzL3NjcmlwdHMvdGVzdC9KUy9KU1Rlc3RDb25kaXRpb25hbEltcGxlbWVu dHMuY3BwOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OkpTVGVzdENvbmRpdGlvbmFsSW1wbGVt ZW50c1Byb3RvdHlwZTo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmU6OkpTVGVzdENvbmRpdGlv bmFsSW1wbGVtZW50c1Byb3RvdHlwZTo6Y3JlYXRlU3RydWN0dXJlKToKKyAgICAgICAgKFdlYkNv cmU6OkpTVGVzdENvbmRpdGlvbmFsSW1wbGVtZW50c1Byb3RvdHlwZTo6SlNUZXN0Q29uZGl0aW9u YWxJbXBsZW1lbnRzUHJvdG90eXBlKToKKyAgICAgICAgKFdlYkNvcmU6OkpTVGVzdENvbmRpdGlv bmFsSW1wbGVtZW50c0NvbnN0cnVjdG9yOjpwcm90b3R5cGVGb3JTdHJ1Y3R1cmUpOgorICAgICAg ICAoV2ViQ29yZTo6SlNUZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzQ29uc3RydWN0b3I6OmluaXRp YWxpemVQcm9wZXJ0aWVzKToKKyAgICAgICAgKFdlYkNvcmU6OkpTVGVzdENvbmRpdGlvbmFsSW1w bGVtZW50c1Byb3RvdHlwZTo6ZmluaXNoQ3JlYXRpb24pOgorICAgICAgICAoV2ViQ29yZTo6SlNU ZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzOjpKU1Rlc3RDb25kaXRpb25hbEltcGxlbWVudHMpOgor ICAgICAgICAoV2ViQ29yZTo6SlNUZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzOjpjcmVhdGVQcm90 b3R5cGUpOgorICAgICAgICAoV2ViQ29yZTo6SlNUZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzOjpw cm90b3R5cGUpOgorICAgICAgICAoV2ViQ29yZTo6SlNUZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRz OjpkZXN0cm95KToKKyAgICAgICAgKFdlYkNvcmU6OmpzVGVzdENvbmRpdGlvbmFsSW1wbGVtZW50 c0NvbnN0cnVjdG9yKToKKyAgICAgICAgKFdlYkNvcmU6OnNldEpTVGVzdENvbmRpdGlvbmFsSW1w bGVtZW50c0NvbnN0cnVjdG9yKToKKyAgICAgICAgKFdlYkNvcmU6OkpTVGVzdENvbmRpdGlvbmFs SW1wbGVtZW50czo6Z2V0Q29uc3RydWN0b3IpOgorICAgICAgICAoV2ViQ29yZTo6SlNUZXN0Q29u ZGl0aW9uYWxJbXBsZW1lbnRzT3duZXI6OmlzUmVhY2hhYmxlRnJvbU9wYXF1ZVJvb3RzKToKKyAg ICAgICAgKFdlYkNvcmU6OkpTVGVzdENvbmRpdGlvbmFsSW1wbGVtZW50c093bmVyOjpmaW5hbGl6 ZSk6CisgICAgICAgIChXZWJDb3JlOjp0b0pTTmV3bHlDcmVhdGVkKToKKyAgICAgICAgKFdlYkNv cmU6OnRvSlMpOgorICAgICAgICAoV2ViQ29yZTo6SlNUZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRz Ojp0b1dyYXBwZWQpOgorICAgICAgICAqIGJpbmRpbmdzL3NjcmlwdHMvdGVzdC9KUy9KU1Rlc3RD b25kaXRpb25hbEltcGxlbWVudHMuaDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpKU1Rlc3RD b25kaXRpb25hbEltcGxlbWVudHM6OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpKU1Rlc3RD b25kaXRpb25hbEltcGxlbWVudHM6OmNyZWF0ZVN0cnVjdHVyZSk6CisgICAgICAgIChXZWJDb3Jl OjpKU1Rlc3RDb25kaXRpb25hbEltcGxlbWVudHM6OmZpbmlzaENyZWF0aW9uKToKKyAgICAgICAg KFdlYkNvcmU6OndyYXBwZXJPd25lcik6CisgICAgICAgIChXZWJDb3JlOjp3cmFwcGVyS2V5KToK KyAgICAgICAgKFdlYkNvcmU6OnRvSlMpOgorICAgICAgICAoV2ViQ29yZTo6dG9KU05ld2x5Q3Jl YXRlZCk6CisgICAgICAgICogYmluZGluZ3Mvc2NyaXB0cy90ZXN0L09iakMvRE9NVGVzdENvbmRp dGlvbmFsSW1wbGVtZW50cy5oOiBBZGRlZC4KKyAgICAgICAgKiBiaW5kaW5ncy9zY3JpcHRzL3Rl c3QvT2JqQy9ET01UZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzLm1tOiBBZGRlZC4KKyAgICAgICAg KC1bRE9NVGVzdENvbmRpdGlvbmFsSW1wbGVtZW50cyBkZWFsbG9jXSk6CisgICAgICAgIChjb3Jl KToKKyAgICAgICAgKGtpdCk6CisgICAgICAgICogYmluZGluZ3Mvc2NyaXB0cy90ZXN0L09iakMv RE9NVGVzdENvbmRpdGlvbmFsSW1wbGVtZW50c0ludGVybmFsLmg6IEFkZGVkLgorICAgICAgICAq IGJpbmRpbmdzL3NjcmlwdHMvdGVzdC9UZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzLmlkbDogQWRk ZWQuCisKIDIwMTYtMDYtMTUgIFphbGFuIEJ1anRhcyAgPHphbGFuQGFwcGxlLmNvbT4KIAogICAg ICAgICBEZWNvdXBsZSB0aGUgcGVyY2VudCBoZWlnaHQgYW5kIHBvc2l0aW9uZWQgZGVzY2VuZGFu dHMgbWFwcy4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvcHJl cHJvY2Vzcy1pZGxzLnBsIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy9wcmVwcm9j ZXNzLWlkbHMucGwKaW5kZXggYzQyYWE1ZDg0YWUwYjNjNThkMzE3ZmVmMDg2ODFkN2Q4YzAxZTYw YS4uYThlZTE2OTdmOTgxOWZjODg5MzdlOTI5Y2UyNjEwMDYxZjQzMTg1NSAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy9wcmVwcm9jZXNzLWlkbHMucGwKKysrIGIv U291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy9wcmVwcm9jZXNzLWlkbHMucGwKQEAgLTk3 LDcgKzk3LDEwIEBAIGZvcmVhY2ggbXkgJGlkbEZpbGUgKHNvcnQga2V5cyAlaWRsRmlsZUhhc2gp IHsKICAgICBteSAkaW50ZXJmYWNlTmFtZSA9IGZpbGVwYXJzZShiYXNlbmFtZSgkaWRsRmlsZSks ICIuaWRsIik7CiAgICAgIyBIYW5kbGUgaW1wbGVtZW50cyBzdGF0ZW1lbnRzLgogICAgIG15ICRp bXBsZW1lbnRlZEludGVyZmFjZXMgPSBnZXRJbXBsZW1lbnRlZEludGVyZmFjZXNGcm9tSURMKCRp ZGxGaWxlQ29udGVudHMsICRpbnRlcmZhY2VOYW1lKTsKLSAgICBmb3JlYWNoIG15ICRpbXBsZW1l bnRlZEludGVyZmFjZSAoQHskaW1wbGVtZW50ZWRJbnRlcmZhY2VzfSkgeworICAgIGZvcmVhY2gg bXkgJGltcGxlbWVudGVkSW50ZXJmYWNlIChzb3J0IGtleXMgJXskaW1wbGVtZW50ZWRJbnRlcmZh Y2VzfSkgeworICAgICAgICAjIENoZWNrIGlmIHRoZSBpbXBsZW1lbnRzIHN0YXRlbWVudCBjb250 YWlucyBhIGNvbmRpdGlvbiwgYW5kIHdoZXRoZXIgaXQgaXMgbWV0LgorICAgICAgICBteSAkY29u ZGl0aW9uID0gJGltcGxlbWVudGVkSW50ZXJmYWNlcy0+eyRpbXBsZW1lbnRlZEludGVyZmFjZX17 IkNvbmRpdGlvbmFsIn07CisgICAgICAgIG5leHQgaWYgKGRlZmluZWQoJGNvbmRpdGlvbikgJiYg ISgkZGVmaW5lcyA9fiAvRU5BQkxFXyRjb25kaXRpb24oPzpcc3wkKS8pKTsKICAgICAgICAgbXkg JGltcGxlbWVudGVkSWRsRmlsZSA9ICRpbnRlcmZhY2VOYW1lVG9JZGxGaWxleyRpbXBsZW1lbnRl ZEludGVyZmFjZX07CiAgICAgICAgIGRpZSAiQ291bGQgbm90IGZpbmQgYSB0aGUgSURMIGZpbGUg d2hlcmUgdGhlIGZvbGxvd2luZyBpbXBsZW1lbnRlZCBpbnRlcmZhY2UgaXMgZGVmaW5lZDogJGlt cGxlbWVudGVkSW50ZXJmYWNlIiB1bmxlc3MgJGltcGxlbWVudGVkSWRsRmlsZTsKICAgICAgICAg aWYgKCRzdXBwbGVtZW50YWxEZXBlbmRlbmNpZXN7JGltcGxlbWVudGVkSWRsRmlsZX0pIHsKQEAg LTI4NCw2ICsyODcsMjUgQEAgc3ViIGdldFBhcnRpYWxJbnRlcmZhY2VOYW1lRnJvbUlETAogICAg IH0KIH0KIAorc3ViIGdldEV4dGVuZGVkQXR0cmlidXRlc0Zyb21JRExTZWN0aW9uCit7CisgICAg bXkgJGlkbFNlY3Rpb24gPSBzaGlmdDsKKworICAgIG15ICVleHRlbmRlZEF0dHJpYnV0ZXM7CisK KyAgICBteSBAcGFydHMgPSBzcGxpdChtLywoPyFbXigpXSpcKSkvLCAkaWRsU2VjdGlvbik7Cisg ICAgZm9yZWFjaCBteSAkcGFydCAoQHBhcnRzKSB7CisgICAgICAgIG15IEBrZXlWYWx1ZSA9IHNw bGl0KCc9JywgJHBhcnQpOworICAgICAgICBteSAka2V5ID0gdHJpbSgka2V5VmFsdWVbMF0pOwor ICAgICAgICBuZXh0IHVubGVzcyBsZW5ndGgoJGtleSk7CisgICAgICAgIG15ICR2YWx1ZSA9ICJW QUxVRV9JU19NSVNTSU5HIjsKKyAgICAgICAgJHZhbHVlID0gdHJpbSgka2V5VmFsdWVbMV0pIGlm IEBrZXlWYWx1ZSA+IDE7CisgICAgICAgICRleHRlbmRlZEF0dHJpYnV0ZXN7JGtleX0gPSAkdmFs dWU7CisgICAgfQorCisgICAgcmV0dXJuIFwlZXh0ZW5kZWRBdHRyaWJ1dGVzOworfQorCiAjIGlk ZW50aWZpZXItQSBpbXBsZW1lbnRzIGlkZW50aWZpZXItQjsKICMgaHR0cDovL3d3dy53My5vcmcv VFIvV2ViSURMLyNpZGwtaW1wbGVtZW50cy1zdGF0ZW1lbnRzCiBzdWIgZ2V0SW1wbGVtZW50ZWRJ bnRlcmZhY2VzRnJvbUlETApAQCAtMjkxLDEyICszMTMsMTggQEAgc3ViIGdldEltcGxlbWVudGVk SW50ZXJmYWNlc0Zyb21JREwKICAgICBteSAkZmlsZUNvbnRlbnRzID0gc2hpZnQ7CiAgICAgbXkg JGludGVyZmFjZU5hbWUgPSBzaGlmdDsKIAotICAgIG15IEBpbXBsZW1lbnRlZEludGVyZmFjZXMg PSAoKTsKLSAgICB3aGlsZSAoJGZpbGVDb250ZW50cyA9fiAvXlxzKihcdyspXHMraW1wbGVtZW50 c1xzKyhcdyspXHMqOy9tZykgewotICAgICAgICBkaWUgIklkZW50aWZpZXIgb24gdGhlIGxlZnQg b2YgdGhlICdpbXBsZW1lbnRzJyBzdGF0ZW1lbnQgc2hvdWxkIGJlICRpbnRlcmZhY2VOYW1lIGlu ICRpbnRlcmZhY2VOYW1lLmlkbCwgYnV0IGZvdW5kICQxIiBpZiAkMSBuZSAkaW50ZXJmYWNlTmFt ZTsKLSAgICAgICAgcHVzaChAaW1wbGVtZW50ZWRJbnRlcmZhY2VzLCAkMik7CisgICAgbXkgJWlt cGxlbWVudGVkSW50ZXJmYWNlczsKKworICAgICMgUmVtb3ZlIGNvbW1lbnRzIGZyb20gZmlsZUNv bnRlbnRzIGJlZm9yZSBwcm9jZXNzaW5nLgorICAgICMgRklYTUU6IFByZWZlcmVuY2UgdG8gdXNl IFJlZ2V4OjpDb21tb246OmNvbW1lbnQsIGhvd2V2ZXIgaXQgaXMgbm90IGF2YWlsYWJsZSBvbgor ICAgICMgYWxsIGJ1aWxkIHN5c3RlbXMuCisgICAgJGZpbGVDb250ZW50cyA9fiBzLyg/Oig/Oig/ OlwvXC8pKD86W15cbl0qKSg/OlxuKSl8KD86KD86XC9cKikoPzooPzpbXlwqXSt8XCooPyFcLykp KikoPzpcKlwvKSkpLy9nOworCisgICAgd2hpbGUgKCRmaWxlQ29udGVudHMgPX4gL15ccyooPzpc WyguKilcXVxzKyk/KFx3KylccytpbXBsZW1lbnRzXHMrKFx3Kylccyo7L21nKSB7CisgICAgICAg IGRpZSAiSWRlbnRpZmllciBvbiB0aGUgbGVmdCBvZiB0aGUgJ2ltcGxlbWVudHMnIHN0YXRlbWVu dCBzaG91bGQgYmUgJGludGVyZmFjZU5hbWUgaW4gJGludGVyZmFjZU5hbWUuaWRsLCBidXQgZm91 bmQgJDIiIGlmICQyIG5lICRpbnRlcmZhY2VOYW1lOworICAgICAgICAkaW1wbGVtZW50ZWRJbnRl cmZhY2VzeyQzfSA9IGRlZmluZWQgJDEgPyBnZXRFeHRlbmRlZEF0dHJpYnV0ZXNGcm9tSURMU2Vj dGlvbigkMSkgOiB7fTsKICAgICB9Ci0gICAgcmV0dXJuIFxAaW1wbGVtZW50ZWRJbnRlcmZhY2Vz CisgICAgcmV0dXJuIFwlaW1wbGVtZW50ZWRJbnRlcmZhY2VzCiB9CiAKIHN1YiBpc0NhbGxiYWNr SW50ZXJmYWNlRnJvbUlETApAQCAtMzE5LDIwICszNDcsMTIgQEAgc3ViIGdldEludGVyZmFjZUV4 dGVuZGVkQXR0cmlidXRlc0Zyb21JREwKICAgICBteSAkZXh0ZW5kZWRBdHRyaWJ1dGVzID0ge307 CiAKICAgICAjIFJlbW92ZSBjb21tZW50cyBmcm9tIGZpbGVDb250ZW50cyBiZWZvcmUgcHJvY2Vz c2luZy4KLSAgICAjIEZJWDogUHJlZmVyZW5jZSB0byB1c2UgUmVnZXg6OkNvbW1vbjo6Y29tbWVu dCwgaG93ZXZlciBpdCBpcyBub3QgYXZhaWxhYmxlIG9uCisgICAgIyBGSVhNRTogUHJlZmVyZW5j ZSB0byB1c2UgUmVnZXg6OkNvbW1vbjo6Y29tbWVudCwgaG93ZXZlciBpdCBpcyBub3QgYXZhaWxh YmxlIG9uCiAgICAgIyBhbGwgYnVpbGQgc3lzdGVtcy4KICAgICAkZmlsZUNvbnRlbnRzID1+IHMv KD86KD86KD86XC9cLykoPzpbXlxuXSopKD86XG4pKXwoPzooPzpcL1wqKSg/Oig/OlteXCpdK3xc Kig/IVwvKSkqKSg/OlwqXC8pKSkvL2c7CiAKICAgICBpZiAoJGZpbGVDb250ZW50cyA9fiAvXFso LiopXF1ccysoY2FsbGJhY2sgaW50ZXJmYWNlfGludGVyZmFjZXxleGNlcHRpb24pXHMrKFx3Kykv Z3MpIHsKLSAgICAgICAgbXkgQHBhcnRzID0gc3BsaXQobS8sKD8hW14oKV0qXCkpLywgJDEpOwot ICAgICAgICBmb3JlYWNoIG15ICRwYXJ0IChAcGFydHMpIHsKLSAgICAgICAgICAgIG15IEBrZXlW YWx1ZSA9IHNwbGl0KCc9JywgJHBhcnQpOwotICAgICAgICAgICAgbXkgJGtleSA9IHRyaW0oJGtl eVZhbHVlWzBdKTsKLSAgICAgICAgICAgIG5leHQgdW5sZXNzIGxlbmd0aCgka2V5KTsKLSAgICAg ICAgICAgIG15ICR2YWx1ZSA9ICJWQUxVRV9JU19NSVNTSU5HIjsKLSAgICAgICAgICAgICR2YWx1 ZSA9IHRyaW0oJGtleVZhbHVlWzFdKSBpZiBAa2V5VmFsdWUgPiAxOwotICAgICAgICAgICAgJGV4 dGVuZGVkQXR0cmlidXRlcy0+eyRrZXl9ID0gJHZhbHVlOwotICAgICAgICB9CisgICAgICAgICRl eHRlbmRlZEF0dHJpYnV0ZXMgPSBnZXRFeHRlbmRlZEF0dHJpYnV0ZXNGcm9tSURMU2VjdGlvbigk MSk7CiAgICAgfQogCiAgICAgcmV0dXJuICRleHRlbmRlZEF0dHJpYnV0ZXM7CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9zY3JpcHRzL3Rlc3QvR09iamVjdC9XZWJLaXRET01U ZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3Nj cmlwdHMvdGVzdC9HT2JqZWN0L1dlYktpdERPTVRlc3RDb25kaXRpb25hbEltcGxlbWVudHMuY3Bw Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAuLjNiYmQxYjVlNDBiMjFmNmZjODMyNzgxM2Q5MWIwNzkyMmQ1ZDlhNGUKLS0t IC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9zY3JpcHRzL3Rlc3QvR09i amVjdC9XZWJLaXRET01UZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzLmNwcApAQCAtMCwwICsxLDEw NCBAQAorLyoKKyAqICBUaGlzIGZpbGUgaXMgcGFydCBvZiB0aGUgV2ViS2l0IG9wZW4gc291cmNl IHByb2plY3QuCisgKiAgVGhpcyBmaWxlIGhhcyBiZWVuIGdlbmVyYXRlZCBieSBnZW5lcmF0ZS1i aW5kaW5ncy5wbC4gRE8gTk9UIE1PRElGWSEKKyAqCisgKiAgVGhpcyBsaWJyYXJ5IGlzIGZyZWUg c29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogIG1vZGlmeSBpdCB1 bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisgKiAgTGlj ZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVy CisgKiAgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBs YXRlciB2ZXJzaW9uLgorICoKKyAqICBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhl IGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqICBidXQgV0lUSE9VVCBBTlkgV0FSUkFO VFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogIE1FUkNIQU5UQUJJ TElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisg KiAgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgor ICogIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdl bmVyYWwgUHVibGljIExpY2Vuc2UKKyAqICBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRo ZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICogIHRoZSBGcmVlIFNvZnR3 YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisg KiAgQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5o IgorI2luY2x1ZGUgIldlYktpdERPTVRlc3RDb25kaXRpb25hbEltcGxlbWVudHMuaCIKKworI2lu Y2x1ZGUgIkNTU0ltcG9ydFJ1bGUuaCIKKyNpbmNsdWRlICJET01PYmplY3RDYWNoZS5oIgorI2lu Y2x1ZGUgIkRvY3VtZW50LmgiCisjaW5jbHVkZSAiRXhjZXB0aW9uQ29kZS5oIgorI2luY2x1ZGUg IkV4Y2VwdGlvbkNvZGVEZXNjcmlwdGlvbi5oIgorI2luY2x1ZGUgIkpTTWFpblRocmVhZEV4ZWNT dGF0ZS5oIgorI2luY2x1ZGUgIldlYktpdERPTVByaXZhdGUuaCIKKyNpbmNsdWRlICJXZWJLaXRE T01UZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzUHJpdmF0ZS5oIgorI2luY2x1ZGUgImdvYmplY3Qv Q29udmVydFRvVVRGOFN0cmluZy5oIgorI2luY2x1ZGUgPHd0Zi9HZXRQdHIuaD4KKyNpbmNsdWRl IDx3dGYvUmVmUHRyLmg+CisKKyNkZWZpbmUgV0VCS0lUX0RPTV9URVNUX0NPTkRJVElPTkFMX0lN UExFTUVOVFNfR0VUX1BSSVZBVEUob2JqKSBHX1RZUEVfSU5TVEFOQ0VfR0VUX1BSSVZBVEUob2Jq LCBXRUJLSVRfRE9NX1RZUEVfVEVTVF9DT05ESVRJT05BTF9JTVBMRU1FTlRTLCBXZWJLaXRET01U ZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzUHJpdmF0ZSkKKwordHlwZWRlZiBzdHJ1Y3QgX1dlYktp dERPTVRlc3RDb25kaXRpb25hbEltcGxlbWVudHNQcml2YXRlIHsKKyAgICBSZWZQdHI8V2ViQ29y ZTo6VGVzdENvbmRpdGlvbmFsSW1wbGVtZW50cz4gY29yZU9iamVjdDsKK30gV2ViS2l0RE9NVGVz dENvbmRpdGlvbmFsSW1wbGVtZW50c1ByaXZhdGU7CisKK25hbWVzcGFjZSBXZWJLaXQgeworCitX ZWJLaXRET01UZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzKiBraXQoV2ViQ29yZTo6VGVzdENvbmRp dGlvbmFsSW1wbGVtZW50cyogb2JqKQoreworICAgIGlmICghb2JqKQorICAgICAgICByZXR1cm4g MDsKKworICAgIGlmIChncG9pbnRlciByZXQgPSBET01PYmplY3RDYWNoZTo6Z2V0KG9iaikpCisg ICAgICAgIHJldHVybiBXRUJLSVRfRE9NX1RFU1RfQ09ORElUSU9OQUxfSU1QTEVNRU5UUyhyZXQp OworCisgICAgcmV0dXJuIHdyYXBUZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzKG9iaik7Cit9CisK K1dlYkNvcmU6OlRlc3RDb25kaXRpb25hbEltcGxlbWVudHMqIGNvcmUoV2ViS2l0RE9NVGVzdENv bmRpdGlvbmFsSW1wbGVtZW50cyogcmVxdWVzdCkKK3sKKyAgICByZXR1cm4gcmVxdWVzdCA/IHN0 YXRpY19jYXN0PFdlYkNvcmU6OlRlc3RDb25kaXRpb25hbEltcGxlbWVudHMqPihXRUJLSVRfRE9N X09CSkVDVChyZXF1ZXN0KS0+Y29yZU9iamVjdCkgOiAwOworfQorCitXZWJLaXRET01UZXN0Q29u ZGl0aW9uYWxJbXBsZW1lbnRzKiB3cmFwVGVzdENvbmRpdGlvbmFsSW1wbGVtZW50cyhXZWJDb3Jl OjpUZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzKiBjb3JlT2JqZWN0KQoreworICAgIEFTU0VSVChj b3JlT2JqZWN0KTsKKyAgICByZXR1cm4gV0VCS0lUX0RPTV9URVNUX0NPTkRJVElPTkFMX0lNUExF TUVOVFMoZ19vYmplY3RfbmV3KFdFQktJVF9ET01fVFlQRV9URVNUX0NPTkRJVElPTkFMX0lNUExF TUVOVFMsICJjb3JlLW9iamVjdCIsIGNvcmVPYmplY3QsIG51bGxwdHIpKTsKK30KKworfSAvLyBu YW1lc3BhY2UgV2ViS2l0CisKK0dfREVGSU5FX1RZUEUoV2ViS2l0RE9NVGVzdENvbmRpdGlvbmFs SW1wbGVtZW50cywgd2Via2l0X2RvbV90ZXN0X2NvbmRpdGlvbmFsX2ltcGxlbWVudHMsIFdFQktJ VF9ET01fVFlQRV9PQkpFQ1QpCisKK3N0YXRpYyB2b2lkIHdlYmtpdF9kb21fdGVzdF9jb25kaXRp b25hbF9pbXBsZW1lbnRzX2ZpbmFsaXplKEdPYmplY3QqIG9iamVjdCkKK3sKKyAgICBXZWJLaXRE T01UZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzUHJpdmF0ZSogcHJpdiA9IFdFQktJVF9ET01fVEVT VF9DT05ESVRJT05BTF9JTVBMRU1FTlRTX0dFVF9QUklWQVRFKG9iamVjdCk7CisKKyAgICBXZWJL aXQ6OkRPTU9iamVjdENhY2hlOjpmb3JnZXQocHJpdi0+Y29yZU9iamVjdC5nZXQoKSk7CisKKyAg ICBwcml2LT5+V2ViS2l0RE9NVGVzdENvbmRpdGlvbmFsSW1wbGVtZW50c1ByaXZhdGUoKTsKKyAg ICBHX09CSkVDVF9DTEFTUyh3ZWJraXRfZG9tX3Rlc3RfY29uZGl0aW9uYWxfaW1wbGVtZW50c19w YXJlbnRfY2xhc3MpLT5maW5hbGl6ZShvYmplY3QpOworfQorCitzdGF0aWMgR09iamVjdCogd2Vi a2l0X2RvbV90ZXN0X2NvbmRpdGlvbmFsX2ltcGxlbWVudHNfY29uc3RydWN0b3IoR1R5cGUgdHlw ZSwgZ3VpbnQgY29uc3RydWN0UHJvcGVydGllc0NvdW50LCBHT2JqZWN0Q29uc3RydWN0UGFyYW0q IGNvbnN0cnVjdFByb3BlcnRpZXMpCit7CisgICAgR09iamVjdCogb2JqZWN0ID0gR19PQkpFQ1Rf Q0xBU1Mod2Via2l0X2RvbV90ZXN0X2NvbmRpdGlvbmFsX2ltcGxlbWVudHNfcGFyZW50X2NsYXNz KS0+Y29uc3RydWN0b3IodHlwZSwgY29uc3RydWN0UHJvcGVydGllc0NvdW50LCBjb25zdHJ1Y3RQ cm9wZXJ0aWVzKTsKKworICAgIFdlYktpdERPTVRlc3RDb25kaXRpb25hbEltcGxlbWVudHNQcml2 YXRlKiBwcml2ID0gV0VCS0lUX0RPTV9URVNUX0NPTkRJVElPTkFMX0lNUExFTUVOVFNfR0VUX1BS SVZBVEUob2JqZWN0KTsKKyAgICBwcml2LT5jb3JlT2JqZWN0ID0gc3RhdGljX2Nhc3Q8V2ViQ29y ZTo6VGVzdENvbmRpdGlvbmFsSW1wbGVtZW50cyo+KFdFQktJVF9ET01fT0JKRUNUKG9iamVjdCkt PmNvcmVPYmplY3QpOworICAgIFdlYktpdDo6RE9NT2JqZWN0Q2FjaGU6OnB1dChwcml2LT5jb3Jl T2JqZWN0LmdldCgpLCBvYmplY3QpOworCisgICAgcmV0dXJuIG9iamVjdDsKK30KKworc3RhdGlj IHZvaWQgd2Via2l0X2RvbV90ZXN0X2NvbmRpdGlvbmFsX2ltcGxlbWVudHNfY2xhc3NfaW5pdChX ZWJLaXRET01UZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzQ2xhc3MqIHJlcXVlc3RDbGFzcykKK3sK KyAgICBHT2JqZWN0Q2xhc3MqIGdvYmplY3RDbGFzcyA9IEdfT0JKRUNUX0NMQVNTKHJlcXVlc3RD bGFzcyk7CisgICAgZ190eXBlX2NsYXNzX2FkZF9wcml2YXRlKGdvYmplY3RDbGFzcywgc2l6ZW9m KFdlYktpdERPTVRlc3RDb25kaXRpb25hbEltcGxlbWVudHNQcml2YXRlKSk7CisgICAgZ29iamVj dENsYXNzLT5jb25zdHJ1Y3RvciA9IHdlYmtpdF9kb21fdGVzdF9jb25kaXRpb25hbF9pbXBsZW1l bnRzX2NvbnN0cnVjdG9yOworICAgIGdvYmplY3RDbGFzcy0+ZmluYWxpemUgPSB3ZWJraXRfZG9t X3Rlc3RfY29uZGl0aW9uYWxfaW1wbGVtZW50c19maW5hbGl6ZTsKK30KKworc3RhdGljIHZvaWQg d2Via2l0X2RvbV90ZXN0X2NvbmRpdGlvbmFsX2ltcGxlbWVudHNfaW5pdChXZWJLaXRET01UZXN0 Q29uZGl0aW9uYWxJbXBsZW1lbnRzKiByZXF1ZXN0KQoreworICAgIFdlYktpdERPTVRlc3RDb25k aXRpb25hbEltcGxlbWVudHNQcml2YXRlKiBwcml2ID0gV0VCS0lUX0RPTV9URVNUX0NPTkRJVElP TkFMX0lNUExFTUVOVFNfR0VUX1BSSVZBVEUocmVxdWVzdCk7CisgICAgbmV3IChwcml2KSBXZWJL aXRET01UZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzUHJpdmF0ZSgpOworfQorCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9zY3JpcHRzL3Rlc3QvR09iamVjdC9XZWJLaXRET01U ZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzLmggYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9zY3Jp cHRzL3Rlc3QvR09iamVjdC9XZWJLaXRET01UZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzLmgKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMC4uMTlkY2JjNzQyOGVjNTI3MjY0ZjE0NjMzMWMzZmQ5OGNkZGQ4MDYwNwotLS0gL2Rl di9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvdGVzdC9HT2JqZWN0 L1dlYktpdERPTVRlc3RDb25kaXRpb25hbEltcGxlbWVudHMuaApAQCAtMCwwICsxLDUzIEBACisv KgorICogIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBXZWJLaXQgb3BlbiBzb3VyY2UgcHJvamVj dC4KKyAqICBUaGlzIGZpbGUgaGFzIGJlZW4gZ2VuZXJhdGVkIGJ5IGdlbmVyYXRlLWJpbmRpbmdz LnBsLiBETyBOT1QgTU9ESUZZIQorICoKKyAqICBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2Fy ZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiAgbW9kaWZ5IGl0IHVuZGVyIHRo ZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqICBMaWNlbnNlIGFz IHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqICB2 ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZl cnNpb24uCisgKgorICogIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0 aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0 aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiAgTUVSQ0hBTlRBQklMSVRZIG9y IEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqICBMaWJy YXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiAgWW91 IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQ dWJsaWMgTGljZW5zZQorICogIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUg Q09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgKiAgdGhlIEZyZWUgU29mdHdhcmUgRm91 bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqICBCb3N0 b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAqLworCisjaWZuZGVmIFdlYktpdERPTVRlc3RDb25k aXRpb25hbEltcGxlbWVudHNfaAorI2RlZmluZSBXZWJLaXRET01UZXN0Q29uZGl0aW9uYWxJbXBs ZW1lbnRzX2gKKworI2lmZGVmIFdFQktJVF9ET01fVVNFX1VOU1RBQkxFX0FQSQorCisjaW5jbHVk ZSA8Z2xpYi1vYmplY3QuaD4KKyNpbmNsdWRlIDx3ZWJraXRkb20vV2ViS2l0RE9NT2JqZWN0Lmg+ CisjaW5jbHVkZSA8d2Via2l0ZG9tL3dlYmtpdGRvbWRlZmluZXMtdW5zdGFibGUuaD4KKworR19C RUdJTl9ERUNMUworCisjZGVmaW5lIFdFQktJVF9ET01fVFlQRV9URVNUX0NPTkRJVElPTkFMX0lN UExFTUVOVFMgICAgICAgICAgICAod2Via2l0X2RvbV90ZXN0X2NvbmRpdGlvbmFsX2ltcGxlbWVu dHNfZ2V0X3R5cGUoKSkKKyNkZWZpbmUgV0VCS0lUX0RPTV9URVNUX0NPTkRJVElPTkFMX0lNUExF TUVOVFMob2JqKSAgICAgICAgICAgIChHX1RZUEVfQ0hFQ0tfSU5TVEFOQ0VfQ0FTVCgob2JqKSwg V0VCS0lUX0RPTV9UWVBFX1RFU1RfQ09ORElUSU9OQUxfSU1QTEVNRU5UUywgV2ViS2l0RE9NVGVz dENvbmRpdGlvbmFsSW1wbGVtZW50cykpCisjZGVmaW5lIFdFQktJVF9ET01fVEVTVF9DT05ESVRJ T05BTF9JTVBMRU1FTlRTX0NMQVNTKGtsYXNzKSAgICAoR19UWVBFX0NIRUNLX0NMQVNTX0NBU1Qo KGtsYXNzKSwgIFdFQktJVF9ET01fVFlQRV9URVNUX0NPTkRJVElPTkFMX0lNUExFTUVOVFMsIFdl YktpdERPTVRlc3RDb25kaXRpb25hbEltcGxlbWVudHNDbGFzcykKKyNkZWZpbmUgV0VCS0lUX0RP TV9JU19URVNUX0NPTkRJVElPTkFMX0lNUExFTUVOVFMob2JqKSAgICAgICAgIChHX1RZUEVfQ0hF Q0tfSU5TVEFOQ0VfVFlQRSgob2JqKSwgV0VCS0lUX0RPTV9UWVBFX1RFU1RfQ09ORElUSU9OQUxf SU1QTEVNRU5UUykpCisjZGVmaW5lIFdFQktJVF9ET01fSVNfVEVTVF9DT05ESVRJT05BTF9JTVBM RU1FTlRTX0NMQVNTKGtsYXNzKSAoR19UWVBFX0NIRUNLX0NMQVNTX1RZUEUoKGtsYXNzKSwgIFdF QktJVF9ET01fVFlQRV9URVNUX0NPTkRJVElPTkFMX0lNUExFTUVOVFMpKQorI2RlZmluZSBXRUJL SVRfRE9NX1RFU1RfQ09ORElUSU9OQUxfSU1QTEVNRU5UU19HRVRfQ0xBU1Mob2JqKSAgKEdfVFlQ RV9JTlNUQU5DRV9HRVRfQ0xBU1MoKG9iaiksICBXRUJLSVRfRE9NX1RZUEVfVEVTVF9DT05ESVRJ T05BTF9JTVBMRU1FTlRTLCBXZWJLaXRET01UZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzQ2xhc3Mp KQorCitzdHJ1Y3QgX1dlYktpdERPTVRlc3RDb25kaXRpb25hbEltcGxlbWVudHMgeworICAgIFdl YktpdERPTU9iamVjdCBwYXJlbnRfaW5zdGFuY2U7Cit9OworCitzdHJ1Y3QgX1dlYktpdERPTVRl c3RDb25kaXRpb25hbEltcGxlbWVudHNDbGFzcyB7CisgICAgV2ViS2l0RE9NT2JqZWN0Q2xhc3Mg cGFyZW50X2NsYXNzOworfTsKKworV0VCS0lUX0FQSSBHVHlwZQord2Via2l0X2RvbV90ZXN0X2Nv bmRpdGlvbmFsX2ltcGxlbWVudHNfZ2V0X3R5cGUodm9pZCk7CisKK0dfRU5EX0RFQ0xTCisKKyNl bmRpZiAvKiBXRUJLSVRfRE9NX1VTRV9VTlNUQUJMRV9BUEkgKi8KKyNlbmRpZiAvKiBXZWJLaXRE T01UZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzX2ggKi8KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL2JpbmRpbmdzL3NjcmlwdHMvdGVzdC9HT2JqZWN0L1dlYktpdERPTVRlc3RDb25kaXRpb25h bEltcGxlbWVudHNQcml2YXRlLmggYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9zY3JpcHRzL3Rl c3QvR09iamVjdC9XZWJLaXRET01UZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzUHJpdmF0ZS5oCm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAuLmZlYzFmMDMyYjhiNzQxNzRlMzU3YWQ1Y2ZlM2I3OWFmMmY2NzRlYzIKLS0tIC9k ZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9zY3JpcHRzL3Rlc3QvR09iamVj dC9XZWJLaXRET01UZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzUHJpdmF0ZS5oCkBAIC0wLDAgKzEs MzMgQEAKKy8qCisgKiAgVGhpcyBmaWxlIGlzIHBhcnQgb2YgdGhlIFdlYktpdCBvcGVuIHNvdXJj ZSBwcm9qZWN0LgorICogIFRoaXMgZmlsZSBoYXMgYmVlbiBnZW5lcmF0ZWQgYnkgZ2VuZXJhdGUt YmluZGluZ3MucGwuIERPIE5PVCBNT0RJRlkhCisgKgorICogIFRoaXMgbGlicmFyeSBpcyBmcmVl IHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqICBtb2RpZnkgaXQg dW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYworICogIExp Y2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhl cgorICogIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkg bGF0ZXIgdmVyc2lvbi4KKyAqCisgKiAgVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRo ZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJB TlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqICBNRVJDSEFOVEFC SUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQor ICogIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoK KyAqICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBH ZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiAgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0 aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyAqICB0aGUgRnJlZSBTb2Z0 d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAor ICogIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgorICovCisKKyNpZm5kZWYgV2ViS2l0RE9N VGVzdENvbmRpdGlvbmFsSW1wbGVtZW50c1ByaXZhdGVfaAorI2RlZmluZSBXZWJLaXRET01UZXN0 Q29uZGl0aW9uYWxJbXBsZW1lbnRzUHJpdmF0ZV9oCisKKyNpbmNsdWRlICJUZXN0Q29uZGl0aW9u YWxJbXBsZW1lbnRzLmgiCisjaW5jbHVkZSA8d2Via2l0ZG9tL1dlYktpdERPTVRlc3RDb25kaXRp b25hbEltcGxlbWVudHMuaD4KKworbmFtZXNwYWNlIFdlYktpdCB7CitXZWJLaXRET01UZXN0Q29u ZGl0aW9uYWxJbXBsZW1lbnRzKiB3cmFwVGVzdENvbmRpdGlvbmFsSW1wbGVtZW50cyhXZWJDb3Jl OjpUZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzKik7CitXZWJLaXRET01UZXN0Q29uZGl0aW9uYWxJ bXBsZW1lbnRzKiBraXQoV2ViQ29yZTo6VGVzdENvbmRpdGlvbmFsSW1wbGVtZW50cyopOworV2Vi Q29yZTo6VGVzdENvbmRpdGlvbmFsSW1wbGVtZW50cyogY29yZShXZWJLaXRET01UZXN0Q29uZGl0 aW9uYWxJbXBsZW1lbnRzKik7Cit9IC8vIG5hbWVzcGFjZSBXZWJLaXQKKworI2VuZGlmIC8qIFdl YktpdERPTVRlc3RDb25kaXRpb25hbEltcGxlbWVudHNQcml2YXRlX2ggKi8KZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvdGVzdC9KUy9KU1Rlc3RDb25kaXRpb25h bEltcGxlbWVudHMuY3BwIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy90ZXN0L0pT L0pTVGVzdENvbmRpdGlvbmFsSW1wbGVtZW50cy5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNDUzMzI3ZmQxOTc3 NDQ3NWQ5OGRmZTI2MjExMjQ1MWIzODRlM2JlOAotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9X ZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvdGVzdC9KUy9KU1Rlc3RDb25kaXRpb25hbEltcGxlbWVu dHMuY3BwCkBAIC0wLDAgKzEsMjAyIEBACisvKgorICAgIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRo ZSBXZWJLaXQgb3BlbiBzb3VyY2UgcHJvamVjdC4KKyAgICBUaGlzIGZpbGUgaGFzIGJlZW4gZ2Vu ZXJhdGVkIGJ5IGdlbmVyYXRlLWJpbmRpbmdzLnBsLiBETyBOT1QgTU9ESUZZIQorCisgICAgVGhp cyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9v cgorICAgIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVy YWwgUHVibGljCisgICAgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUg Rm91bmRhdGlvbjsgZWl0aGVyCisgICAgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQg eW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorCisgICAgVGhpcyBsaWJyYXJ5IGlzIGRp c3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgICAgYnV0IFdJ VEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YK KyAgICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0Uu ICBTZWUgdGhlIEdOVQorICAgIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9y ZSBkZXRhaWxzLgorCisgICAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUg R05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICAgIGFsb25nIHdpdGggdGhpcyBs aWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgICAg dGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBG aWZ0aCBGbG9vciwKKyAgICBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyovCisKKyNpbmNs dWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJKU1Rlc3RDb25kaXRpb25hbEltcGxlbWVudHMuaCIK KworI2luY2x1ZGUgIkpTRE9NQmluZGluZy5oIgorI2luY2x1ZGUgIkpTRE9NQ29uc3RydWN0b3Iu aCIKKyNpbmNsdWRlIDxydW50aW1lL0Z1bmN0aW9uUHJvdG90eXBlLmg+CisjaW5jbHVkZSA8d3Rm L0dldFB0ci5oPgorCit1c2luZyBuYW1lc3BhY2UgSlNDOworCituYW1lc3BhY2UgV2ViQ29yZSB7 CisKKy8vIEF0dHJpYnV0ZXMKKworSlNDOjpFbmNvZGVkSlNWYWx1ZSBqc1Rlc3RDb25kaXRpb25h bEltcGxlbWVudHNDb25zdHJ1Y3RvcihKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6RW5jb2RlZEpTVmFs dWUsIEpTQzo6UHJvcGVydHlOYW1lKTsKK2Jvb2wgc2V0SlNUZXN0Q29uZGl0aW9uYWxJbXBsZW1l bnRzQ29uc3RydWN0b3IoSlNDOjpFeGVjU3RhdGUqLCBKU0M6OkVuY29kZWRKU1ZhbHVlLCBKU0M6 OkVuY29kZWRKU1ZhbHVlKTsKKworY2xhc3MgSlNUZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzUHJv dG90eXBlIDogcHVibGljIEpTQzo6SlNOb25GaW5hbE9iamVjdCB7CitwdWJsaWM6CisgICAgdHlw ZWRlZiBKU0M6OkpTTm9uRmluYWxPYmplY3QgQmFzZTsKKyAgICBzdGF0aWMgSlNUZXN0Q29uZGl0 aW9uYWxJbXBsZW1lbnRzUHJvdG90eXBlKiBjcmVhdGUoSlNDOjpWTSYgdm0sIEpTQzo6SlNHbG9i YWxPYmplY3QqIGdsb2JhbE9iamVjdCwgSlNDOjpTdHJ1Y3R1cmUqIHN0cnVjdHVyZSkKKyAgICB7 CisgICAgICAgIEpTVGVzdENvbmRpdGlvbmFsSW1wbGVtZW50c1Byb3RvdHlwZSogcHRyID0gbmV3 IChOb3ROdWxsLCBKU0M6OmFsbG9jYXRlQ2VsbDxKU1Rlc3RDb25kaXRpb25hbEltcGxlbWVudHNQ cm90b3R5cGU+KHZtLmhlYXApKSBKU1Rlc3RDb25kaXRpb25hbEltcGxlbWVudHNQcm90b3R5cGUo dm0sIGdsb2JhbE9iamVjdCwgc3RydWN0dXJlKTsKKyAgICAgICAgcHRyLT5maW5pc2hDcmVhdGlv bih2bSk7CisgICAgICAgIHJldHVybiBwdHI7CisgICAgfQorCisgICAgREVDTEFSRV9JTkZPOwor ICAgIHN0YXRpYyBKU0M6OlN0cnVjdHVyZSogY3JlYXRlU3RydWN0dXJlKEpTQzo6Vk0mIHZtLCBK U0M6OkpTR2xvYmFsT2JqZWN0KiBnbG9iYWxPYmplY3QsIEpTQzo6SlNWYWx1ZSBwcm90b3R5cGUp CisgICAgeworICAgICAgICByZXR1cm4gSlNDOjpTdHJ1Y3R1cmU6OmNyZWF0ZSh2bSwgZ2xvYmFs T2JqZWN0LCBwcm90b3R5cGUsIEpTQzo6VHlwZUluZm8oSlNDOjpPYmplY3RUeXBlLCBTdHJ1Y3R1 cmVGbGFncyksIGluZm8oKSk7CisgICAgfQorCitwcml2YXRlOgorICAgIEpTVGVzdENvbmRpdGlv bmFsSW1wbGVtZW50c1Byb3RvdHlwZShKU0M6OlZNJiB2bSwgSlNDOjpKU0dsb2JhbE9iamVjdCos IEpTQzo6U3RydWN0dXJlKiBzdHJ1Y3R1cmUpCisgICAgICAgIDogSlNDOjpKU05vbkZpbmFsT2Jq ZWN0KHZtLCBzdHJ1Y3R1cmUpCisgICAgeworICAgIH0KKworICAgIHZvaWQgZmluaXNoQ3JlYXRp b24oSlNDOjpWTSYpOworfTsKKwordHlwZWRlZiBKU0RPTUNvbnN0cnVjdG9yTm90Q29uc3RydWN0 YWJsZTxKU1Rlc3RDb25kaXRpb25hbEltcGxlbWVudHM+IEpTVGVzdENvbmRpdGlvbmFsSW1wbGVt ZW50c0NvbnN0cnVjdG9yOworCit0ZW1wbGF0ZTw+IEpTVmFsdWUgSlNUZXN0Q29uZGl0aW9uYWxJ bXBsZW1lbnRzQ29uc3RydWN0b3I6OnByb3RvdHlwZUZvclN0cnVjdHVyZShKU0M6OlZNJiB2bSwg Y29uc3QgSlNET01HbG9iYWxPYmplY3QmIGdsb2JhbE9iamVjdCkKK3sKKyAgICBVTlVTRURfUEFS QU0odm0pOworICAgIHJldHVybiBnbG9iYWxPYmplY3QuZnVuY3Rpb25Qcm90b3R5cGUoKTsKK30K KwordGVtcGxhdGU8PiB2b2lkIEpTVGVzdENvbmRpdGlvbmFsSW1wbGVtZW50c0NvbnN0cnVjdG9y Ojppbml0aWFsaXplUHJvcGVydGllcyhWTSYgdm0sIEpTRE9NR2xvYmFsT2JqZWN0JiBnbG9iYWxP YmplY3QpCit7CisgICAgcHV0RGlyZWN0KHZtLCB2bS5wcm9wZXJ0eU5hbWVzLT5wcm90b3R5cGUs IEpTVGVzdENvbmRpdGlvbmFsSW1wbGVtZW50czo6cHJvdG90eXBlKHZtLCAmZ2xvYmFsT2JqZWN0 KSwgRG9udERlbGV0ZSB8IFJlYWRPbmx5IHwgRG9udEVudW0pOworICAgIHB1dERpcmVjdCh2bSwg dm0ucHJvcGVydHlOYW1lcy0+bmFtZSwganNOb250cml2aWFsU3RyaW5nKCZ2bSwgU3RyaW5nKEFT Q0lJTGl0ZXJhbCgiVGVzdENvbmRpdGlvbmFsSW1wbGVtZW50cyIpKSksIFJlYWRPbmx5IHwgRG9u dEVudW0pOworICAgIHB1dERpcmVjdCh2bSwgdm0ucHJvcGVydHlOYW1lcy0+bGVuZ3RoLCBqc051 bWJlcigwKSwgUmVhZE9ubHkgfCBEb250RW51bSk7Cit9CisKK3RlbXBsYXRlPD4gY29uc3QgQ2xh c3NJbmZvIEpTVGVzdENvbmRpdGlvbmFsSW1wbGVtZW50c0NvbnN0cnVjdG9yOjpzX2luZm8gPSB7 ICJUZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzIiwgJkJhc2U6OnNfaW5mbywgMCwgQ1JFQVRFX01F VEhPRF9UQUJMRShKU1Rlc3RDb25kaXRpb25hbEltcGxlbWVudHNDb25zdHJ1Y3RvcikgfTsKKwor LyogSGFzaCB0YWJsZSBmb3IgcHJvdG90eXBlICovCisKK3N0YXRpYyBjb25zdCBIYXNoVGFibGVW YWx1ZSBKU1Rlc3RDb25kaXRpb25hbEltcGxlbWVudHNQcm90b3R5cGVUYWJsZVZhbHVlc1tdID0K K3sKKyAgICB7ICJjb25zdHJ1Y3RvciIsIERvbnRFbnVtLCBOb0ludHJpbnNpYywgeyAoaW50cHRy X3Qpc3RhdGljX2Nhc3Q8UHJvcGVydHlTbG90OjpHZXRWYWx1ZUZ1bmM+KGpzVGVzdENvbmRpdGlv bmFsSW1wbGVtZW50c0NvbnN0cnVjdG9yKSwgKGludHB0cl90KSBzdGF0aWNfY2FzdDxQdXRQcm9w ZXJ0eVNsb3Q6OlB1dFZhbHVlRnVuYz4oc2V0SlNUZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzQ29u c3RydWN0b3IpIH0gfSwKK307CisKK2NvbnN0IENsYXNzSW5mbyBKU1Rlc3RDb25kaXRpb25hbElt cGxlbWVudHNQcm90b3R5cGU6OnNfaW5mbyA9IHsgIlRlc3RDb25kaXRpb25hbEltcGxlbWVudHNQ cm90b3R5cGUiLCAmQmFzZTo6c19pbmZvLCAwLCBDUkVBVEVfTUVUSE9EX1RBQkxFKEpTVGVzdENv bmRpdGlvbmFsSW1wbGVtZW50c1Byb3RvdHlwZSkgfTsKKwordm9pZCBKU1Rlc3RDb25kaXRpb25h bEltcGxlbWVudHNQcm90b3R5cGU6OmZpbmlzaENyZWF0aW9uKFZNJiB2bSkKK3sKKyAgICBCYXNl OjpmaW5pc2hDcmVhdGlvbih2bSk7CisgICAgcmVpZnlTdGF0aWNQcm9wZXJ0aWVzKHZtLCBKU1Rl c3RDb25kaXRpb25hbEltcGxlbWVudHNQcm90b3R5cGVUYWJsZVZhbHVlcywgKnRoaXMpOworfQor Citjb25zdCBDbGFzc0luZm8gSlNUZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzOjpzX2luZm8gPSB7 ICJUZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzIiwgJkJhc2U6OnNfaW5mbywgMCwgQ1JFQVRFX01F VEhPRF9UQUJMRShKU1Rlc3RDb25kaXRpb25hbEltcGxlbWVudHMpIH07CisKK0pTVGVzdENvbmRp dGlvbmFsSW1wbGVtZW50czo6SlNUZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzKFN0cnVjdHVyZSog c3RydWN0dXJlLCBKU0RPTUdsb2JhbE9iamVjdCYgZ2xvYmFsT2JqZWN0LCBSZWY8VGVzdENvbmRp dGlvbmFsSW1wbGVtZW50cz4mJiBpbXBsKQorICAgIDogSlNET01XcmFwcGVyPFRlc3RDb25kaXRp b25hbEltcGxlbWVudHM+KHN0cnVjdHVyZSwgZ2xvYmFsT2JqZWN0LCBXVEZNb3ZlKGltcGwpKQor eworfQorCitKU09iamVjdCogSlNUZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzOjpjcmVhdGVQcm90 b3R5cGUoVk0mIHZtLCBKU0dsb2JhbE9iamVjdCogZ2xvYmFsT2JqZWN0KQoreworICAgIHJldHVy biBKU1Rlc3RDb25kaXRpb25hbEltcGxlbWVudHNQcm90b3R5cGU6OmNyZWF0ZSh2bSwgZ2xvYmFs T2JqZWN0LCBKU1Rlc3RDb25kaXRpb25hbEltcGxlbWVudHNQcm90b3R5cGU6OmNyZWF0ZVN0cnVj dHVyZSh2bSwgZ2xvYmFsT2JqZWN0LCBnbG9iYWxPYmplY3QtPm9iamVjdFByb3RvdHlwZSgpKSk7 Cit9CisKK0pTT2JqZWN0KiBKU1Rlc3RDb25kaXRpb25hbEltcGxlbWVudHM6OnByb3RvdHlwZShW TSYgdm0sIEpTR2xvYmFsT2JqZWN0KiBnbG9iYWxPYmplY3QpCit7CisgICAgcmV0dXJuIGdldERP TVByb3RvdHlwZTxKU1Rlc3RDb25kaXRpb25hbEltcGxlbWVudHM+KHZtLCBnbG9iYWxPYmplY3Qp OworfQorCit2b2lkIEpTVGVzdENvbmRpdGlvbmFsSW1wbGVtZW50czo6ZGVzdHJveShKU0M6OkpT Q2VsbCogY2VsbCkKK3sKKyAgICBKU1Rlc3RDb25kaXRpb25hbEltcGxlbWVudHMqIHRoaXNPYmpl Y3QgPSBzdGF0aWNfY2FzdDxKU1Rlc3RDb25kaXRpb25hbEltcGxlbWVudHMqPihjZWxsKTsKKyAg ICB0aGlzT2JqZWN0LT5KU1Rlc3RDb25kaXRpb25hbEltcGxlbWVudHM6On5KU1Rlc3RDb25kaXRp b25hbEltcGxlbWVudHMoKTsKK30KKworRW5jb2RlZEpTVmFsdWUganNUZXN0Q29uZGl0aW9uYWxJ bXBsZW1lbnRzQ29uc3RydWN0b3IoRXhlY1N0YXRlKiBzdGF0ZSwgRW5jb2RlZEpTVmFsdWUgdGhp c1ZhbHVlLCBQcm9wZXJ0eU5hbWUpCit7CisgICAgSlNUZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRz UHJvdG90eXBlKiBkb21PYmplY3QgPSBqc0R5bmFtaWNDYXN0PEpTVGVzdENvbmRpdGlvbmFsSW1w bGVtZW50c1Byb3RvdHlwZSo+KEpTVmFsdWU6OmRlY29kZSh0aGlzVmFsdWUpKTsKKyAgICBpZiAo VU5MSUtFTFkoIWRvbU9iamVjdCkpCisgICAgICAgIHJldHVybiB0aHJvd1ZNVHlwZUVycm9yKHN0 YXRlKTsKKyAgICByZXR1cm4gSlNWYWx1ZTo6ZW5jb2RlKEpTVGVzdENvbmRpdGlvbmFsSW1wbGVt ZW50czo6Z2V0Q29uc3RydWN0b3Ioc3RhdGUtPnZtKCksIGRvbU9iamVjdC0+Z2xvYmFsT2JqZWN0 KCkpKTsKK30KKworYm9vbCBzZXRKU1Rlc3RDb25kaXRpb25hbEltcGxlbWVudHNDb25zdHJ1Y3Rv cihFeGVjU3RhdGUqIHN0YXRlLCBFbmNvZGVkSlNWYWx1ZSB0aGlzVmFsdWUsIEVuY29kZWRKU1Zh bHVlIGVuY29kZWRWYWx1ZSkKK3sKKyAgICBKU1ZhbHVlIHZhbHVlID0gSlNWYWx1ZTo6ZGVjb2Rl KGVuY29kZWRWYWx1ZSk7CisgICAgSlNUZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzUHJvdG90eXBl KiBkb21PYmplY3QgPSBqc0R5bmFtaWNDYXN0PEpTVGVzdENvbmRpdGlvbmFsSW1wbGVtZW50c1By b3RvdHlwZSo+KEpTVmFsdWU6OmRlY29kZSh0aGlzVmFsdWUpKTsKKyAgICBpZiAoVU5MSUtFTFko IWRvbU9iamVjdCkpIHsKKyAgICAgICAgdGhyb3dWTVR5cGVFcnJvcihzdGF0ZSk7CisgICAgICAg IHJldHVybiBmYWxzZTsKKyAgICB9CisgICAgLy8gU2hhZG93aW5nIGEgYnVpbHQtaW4gY29uc3Ry dWN0b3IKKyAgICByZXR1cm4gZG9tT2JqZWN0LT5wdXREaXJlY3Qoc3RhdGUtPnZtKCksIHN0YXRl LT5wcm9wZXJ0eU5hbWVzKCkuY29uc3RydWN0b3IsIHZhbHVlKTsKK30KKworSlNWYWx1ZSBKU1Rl c3RDb25kaXRpb25hbEltcGxlbWVudHM6OmdldENvbnN0cnVjdG9yKFZNJiB2bSwgY29uc3QgSlNH bG9iYWxPYmplY3QqIGdsb2JhbE9iamVjdCkKK3sKKyAgICByZXR1cm4gZ2V0RE9NQ29uc3RydWN0 b3I8SlNUZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzQ29uc3RydWN0b3I+KHZtLCAqanNDYXN0PGNv bnN0IEpTRE9NR2xvYmFsT2JqZWN0Kj4oZ2xvYmFsT2JqZWN0KSk7Cit9CisKK2Jvb2wgSlNUZXN0 Q29uZGl0aW9uYWxJbXBsZW1lbnRzT3duZXI6OmlzUmVhY2hhYmxlRnJvbU9wYXF1ZVJvb3RzKEpT Qzo6SGFuZGxlPEpTQzo6VW5rbm93bj4gaGFuZGxlLCB2b2lkKiwgU2xvdFZpc2l0b3ImIHZpc2l0 b3IpCit7CisgICAgVU5VU0VEX1BBUkFNKGhhbmRsZSk7CisgICAgVU5VU0VEX1BBUkFNKHZpc2l0 b3IpOworICAgIHJldHVybiBmYWxzZTsKK30KKwordm9pZCBKU1Rlc3RDb25kaXRpb25hbEltcGxl bWVudHNPd25lcjo6ZmluYWxpemUoSlNDOjpIYW5kbGU8SlNDOjpVbmtub3duPiBoYW5kbGUsIHZv aWQqIGNvbnRleHQpCit7CisgICAgYXV0byoganNUZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzID0g anNDYXN0PEpTVGVzdENvbmRpdGlvbmFsSW1wbGVtZW50cyo+KGhhbmRsZS5zbG90KCktPmFzQ2Vs bCgpKTsKKyAgICBhdXRvJiB3b3JsZCA9ICpzdGF0aWNfY2FzdDxET01XcmFwcGVyV29ybGQqPihj b250ZXh0KTsKKyAgICB1bmNhY2hlV3JhcHBlcih3b3JsZCwgJmpzVGVzdENvbmRpdGlvbmFsSW1w bGVtZW50cy0+d3JhcHBlZCgpLCBqc1Rlc3RDb25kaXRpb25hbEltcGxlbWVudHMpOworfQorCisj aWYgRU5BQkxFKEJJTkRJTkdfSU5URUdSSVRZKQorI2lmIFBMQVRGT1JNKFdJTikKKyNwcmFnbWEg d2FybmluZyhkaXNhYmxlOiA0NDgzKQorZXh0ZXJuICJDIiB7IGV4dGVybiB2b2lkICgqY29uc3Qg X19pZGVudGlmaWVyKCI/P183VGVzdENvbmRpdGlvbmFsSW1wbGVtZW50c0BXZWJDb3JlQEA2QkAi KVtdKSgpOyB9CisjZWxzZQorZXh0ZXJuICJDIiB7IGV4dGVybiB2b2lkKiBfWlRWTjdXZWJDb3Jl MjVUZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzRVtdOyB9CisjZW5kaWYKKyNlbmRpZgorCitKU0M6 OkpTVmFsdWUgdG9KU05ld2x5Q3JlYXRlZChKU0M6OkV4ZWNTdGF0ZSosIEpTRE9NR2xvYmFsT2Jq ZWN0KiBnbG9iYWxPYmplY3QsIFJlZjxUZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzPiYmIGltcGwp Cit7CisKKyNpZiBFTkFCTEUoQklORElOR19JTlRFR1JJVFkpCisgICAgdm9pZCogYWN0dWFsVlRh YmxlUG9pbnRlciA9ICoocmVpbnRlcnByZXRfY2FzdDx2b2lkKio+KGltcGwucHRyKCkpKTsKKyNp ZiBQTEFURk9STShXSU4pCisgICAgdm9pZCogZXhwZWN0ZWRWVGFibGVQb2ludGVyID0gcmVpbnRl cnByZXRfY2FzdDx2b2lkKj4oX19pZGVudGlmaWVyKCI/P183VGVzdENvbmRpdGlvbmFsSW1wbGVt ZW50c0BXZWJDb3JlQEA2QkAiKSk7CisjZWxzZQorICAgIHZvaWQqIGV4cGVjdGVkVlRhYmxlUG9p bnRlciA9ICZfWlRWTjdXZWJDb3JlMjVUZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzRVsyXTsKKyNp ZiBDT01QSUxFUihDTEFORykKKyAgICAvLyBJZiB0aGlzIGZhaWxzIFRlc3RDb25kaXRpb25hbElt cGxlbWVudHMgZG9lcyBub3QgaGF2ZSBhIHZ0YWJsZSwgc28geW91IG5lZWQgdG8gYWRkIHRoZQor ICAgIC8vIEltcGxlbWVudGF0aW9uTGFja3NWVGFibGUgYXR0cmlidXRlIHRvIHRoZSBpbnRlcmZh Y2UgZGVmaW5pdGlvbgorICAgIHN0YXRpY19hc3NlcnQoX19pc19wb2x5bW9ycGhpYyhUZXN0Q29u ZGl0aW9uYWxJbXBsZW1lbnRzKSwgIlRlc3RDb25kaXRpb25hbEltcGxlbWVudHMgaXMgbm90IHBv bHltb3JwaGljIik7CisjZW5kaWYKKyNlbmRpZgorICAgIC8vIElmIHlvdSBoaXQgdGhpcyBhc3Nl cnRpb24geW91IGVpdGhlciBoYXZlIGEgdXNlIGFmdGVyIGZyZWUgYnVnLCBvcgorICAgIC8vIFRl c3RDb25kaXRpb25hbEltcGxlbWVudHMgaGFzIHN1YmNsYXNzZXMuIElmIFRlc3RDb25kaXRpb25h bEltcGxlbWVudHMgaGFzIHN1YmNsYXNzZXMgdGhhdCBnZXQgcGFzc2VkCisgICAgLy8gdG8gdG9K UygpIHdlIGN1cnJlbnRseSByZXF1aXJlIFRlc3RDb25kaXRpb25hbEltcGxlbWVudHMgeW91IHRv IG9wdCBvdXQgb2YgYmluZGluZyBoYXJkZW5pbmcKKyAgICAvLyBieSBhZGRpbmcgdGhlIFNraXBW VGFibGVWYWxpZGF0aW9uIGF0dHJpYnV0ZSB0byB0aGUgaW50ZXJmYWNlIElETCBkZWZpbml0aW9u CisgICAgUkVMRUFTRV9BU1NFUlQoYWN0dWFsVlRhYmxlUG9pbnRlciA9PSBleHBlY3RlZFZUYWJs ZVBvaW50ZXIpOworI2VuZGlmCisgICAgcmV0dXJuIGNyZWF0ZVdyYXBwZXI8SlNUZXN0Q29uZGl0 aW9uYWxJbXBsZW1lbnRzLCBUZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzPihnbG9iYWxPYmplY3Qs IFdURk1vdmUoaW1wbCkpOworfQorCitKU0M6OkpTVmFsdWUgdG9KUyhKU0M6OkV4ZWNTdGF0ZSog c3RhdGUsIEpTRE9NR2xvYmFsT2JqZWN0KiBnbG9iYWxPYmplY3QsIFRlc3RDb25kaXRpb25hbElt cGxlbWVudHMmIGltcGwpCit7CisgICAgcmV0dXJuIHdyYXAoc3RhdGUsIGdsb2JhbE9iamVjdCwg aW1wbCk7Cit9CisKK1Rlc3RDb25kaXRpb25hbEltcGxlbWVudHMqIEpTVGVzdENvbmRpdGlvbmFs SW1wbGVtZW50czo6dG9XcmFwcGVkKEpTQzo6SlNWYWx1ZSB2YWx1ZSkKK3sKKyAgICBpZiAoYXV0 byogd3JhcHBlciA9IGpzRHluYW1pY0Nhc3Q8SlNUZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzKj4o dmFsdWUpKQorICAgICAgICByZXR1cm4gJndyYXBwZXItPndyYXBwZWQoKTsKKyAgICByZXR1cm4g bnVsbHB0cjsKK30KKworfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2Ny aXB0cy90ZXN0L0pTL0pTVGVzdENvbmRpdGlvbmFsSW1wbGVtZW50cy5oIGIvU291cmNlL1dlYkNv cmUvYmluZGluZ3Mvc2NyaXB0cy90ZXN0L0pTL0pTVGVzdENvbmRpdGlvbmFsSW1wbGVtZW50cy5o Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAuLjNkOWVkNTdkMDJjN2I1MzAwNWU4NzEyMDczNTBiMDdmYWMwNDVhOGIKLS0t IC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9zY3JpcHRzL3Rlc3QvSlMv SlNUZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzLmgKQEAgLTAsMCArMSw4OCBAQAorLyoKKyAgICBU aGlzIGZpbGUgaXMgcGFydCBvZiB0aGUgV2ViS2l0IG9wZW4gc291cmNlIHByb2plY3QuCisgICAg VGhpcyBmaWxlIGhhcyBiZWVuIGdlbmVyYXRlZCBieSBnZW5lcmF0ZS1iaW5kaW5ncy5wbC4gRE8g Tk9UIE1PRElGWSEKKworICAgIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2Fu IHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAgICBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9m IHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYworICAgIExpY2Vuc2UgYXMgcHVibGlzaGVk IGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICAgIHZlcnNpb24gMiBv ZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKwor ICAgIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwg YmUgdXNlZnVsLAorICAgIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRo ZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgICAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9S IEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAgICBMaWJyYXJ5IEdlbmVyYWwg UHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKworICAgIFlvdSBzaG91bGQgaGF2ZSBy ZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UK KyAgICBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAg SWYgbm90LCB3cml0ZSB0bworICAgIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4s IDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisgICAgQm9zdG9uLCBNQSAwMjExMC0x MzAxLCBVU0EuCisqLworCisjcHJhZ21hIG9uY2UKKworI2luY2x1ZGUgIkpTRE9NV3JhcHBlci5o IgorI2luY2x1ZGUgIlRlc3RDb25kaXRpb25hbEltcGxlbWVudHMuaCIKKyNpbmNsdWRlIDx3dGYv TmV2ZXJEZXN0cm95ZWQuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBKU1Rlc3RD b25kaXRpb25hbEltcGxlbWVudHMgOiBwdWJsaWMgSlNET01XcmFwcGVyPFRlc3RDb25kaXRpb25h bEltcGxlbWVudHM+IHsKK3B1YmxpYzoKKyAgICB0eXBlZGVmIEpTRE9NV3JhcHBlcjxUZXN0Q29u ZGl0aW9uYWxJbXBsZW1lbnRzPiBCYXNlOworICAgIHN0YXRpYyBKU1Rlc3RDb25kaXRpb25hbElt cGxlbWVudHMqIGNyZWF0ZShKU0M6OlN0cnVjdHVyZSogc3RydWN0dXJlLCBKU0RPTUdsb2JhbE9i amVjdCogZ2xvYmFsT2JqZWN0LCBSZWY8VGVzdENvbmRpdGlvbmFsSW1wbGVtZW50cz4mJiBpbXBs KQorICAgIHsKKyAgICAgICAgSlNUZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzKiBwdHIgPSBuZXcg KE5vdE51bGwsIEpTQzo6YWxsb2NhdGVDZWxsPEpTVGVzdENvbmRpdGlvbmFsSW1wbGVtZW50cz4o Z2xvYmFsT2JqZWN0LT52bSgpLmhlYXApKSBKU1Rlc3RDb25kaXRpb25hbEltcGxlbWVudHMoc3Ry dWN0dXJlLCAqZ2xvYmFsT2JqZWN0LCBXVEZNb3ZlKGltcGwpKTsKKyAgICAgICAgcHRyLT5maW5p c2hDcmVhdGlvbihnbG9iYWxPYmplY3QtPnZtKCkpOworICAgICAgICByZXR1cm4gcHRyOworICAg IH0KKworICAgIHN0YXRpYyBjb25zdCBib29sIGhhc1N0YXRpY1Byb3BlcnR5VGFibGUgPSBmYWxz ZTsKKworICAgIHN0YXRpYyBKU0M6OkpTT2JqZWN0KiBjcmVhdGVQcm90b3R5cGUoSlNDOjpWTSYs IEpTQzo6SlNHbG9iYWxPYmplY3QqKTsKKyAgICBzdGF0aWMgSlNDOjpKU09iamVjdCogcHJvdG90 eXBlKEpTQzo6Vk0mLCBKU0M6OkpTR2xvYmFsT2JqZWN0Kik7CisgICAgc3RhdGljIFRlc3RDb25k aXRpb25hbEltcGxlbWVudHMqIHRvV3JhcHBlZChKU0M6OkpTVmFsdWUpOworICAgIHN0YXRpYyB2 b2lkIGRlc3Ryb3koSlNDOjpKU0NlbGwqKTsKKworICAgIERFQ0xBUkVfSU5GTzsKKworICAgIHN0 YXRpYyBKU0M6OlN0cnVjdHVyZSogY3JlYXRlU3RydWN0dXJlKEpTQzo6Vk0mIHZtLCBKU0M6OkpT R2xvYmFsT2JqZWN0KiBnbG9iYWxPYmplY3QsIEpTQzo6SlNWYWx1ZSBwcm90b3R5cGUpCisgICAg eworICAgICAgICByZXR1cm4gSlNDOjpTdHJ1Y3R1cmU6OmNyZWF0ZSh2bSwgZ2xvYmFsT2JqZWN0 LCBwcm90b3R5cGUsIEpTQzo6VHlwZUluZm8oSlNDOjpPYmplY3RUeXBlLCBTdHJ1Y3R1cmVGbGFn cyksIGluZm8oKSk7CisgICAgfQorCisgICAgc3RhdGljIEpTQzo6SlNWYWx1ZSBnZXRDb25zdHJ1 Y3RvcihKU0M6OlZNJiwgY29uc3QgSlNDOjpKU0dsb2JhbE9iamVjdCopOworcHJvdGVjdGVkOgor ICAgIEpTVGVzdENvbmRpdGlvbmFsSW1wbGVtZW50cyhKU0M6OlN0cnVjdHVyZSosIEpTRE9NR2xv YmFsT2JqZWN0JiwgUmVmPFRlc3RDb25kaXRpb25hbEltcGxlbWVudHM+JiYpOworCisgICAgdm9p ZCBmaW5pc2hDcmVhdGlvbihKU0M6OlZNJiB2bSkKKyAgICB7CisgICAgICAgIEJhc2U6OmZpbmlz aENyZWF0aW9uKHZtKTsKKyAgICAgICAgQVNTRVJUKGluaGVyaXRzKGluZm8oKSkpOworICAgIH0K KworfTsKKworY2xhc3MgSlNUZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzT3duZXIgOiBwdWJsaWMg SlNDOjpXZWFrSGFuZGxlT3duZXIgeworcHVibGljOgorICAgIHZpcnR1YWwgYm9vbCBpc1JlYWNo YWJsZUZyb21PcGFxdWVSb290cyhKU0M6OkhhbmRsZTxKU0M6OlVua25vd24+LCB2b2lkKiBjb250 ZXh0LCBKU0M6OlNsb3RWaXNpdG9yJik7CisgICAgdmlydHVhbCB2b2lkIGZpbmFsaXplKEpTQzo6 SGFuZGxlPEpTQzo6VW5rbm93bj4sIHZvaWQqIGNvbnRleHQpOworfTsKKworaW5saW5lIEpTQzo6 V2Vha0hhbmRsZU93bmVyKiB3cmFwcGVyT3duZXIoRE9NV3JhcHBlcldvcmxkJiwgVGVzdENvbmRp dGlvbmFsSW1wbGVtZW50cyopCit7CisgICAgc3RhdGljIE5ldmVyRGVzdHJveWVkPEpTVGVzdENv bmRpdGlvbmFsSW1wbGVtZW50c093bmVyPiBvd25lcjsKKyAgICByZXR1cm4gJm93bmVyLmdldCgp OworfQorCitpbmxpbmUgdm9pZCogd3JhcHBlcktleShUZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRz KiB3cmFwcGFibGVPYmplY3QpCit7CisgICAgcmV0dXJuIHdyYXBwYWJsZU9iamVjdDsKK30KKwor SlNDOjpKU1ZhbHVlIHRvSlMoSlNDOjpFeGVjU3RhdGUqLCBKU0RPTUdsb2JhbE9iamVjdCosIFRl c3RDb25kaXRpb25hbEltcGxlbWVudHMmKTsKK2lubGluZSBKU0M6OkpTVmFsdWUgdG9KUyhKU0M6 OkV4ZWNTdGF0ZSogc3RhdGUsIEpTRE9NR2xvYmFsT2JqZWN0KiBnbG9iYWxPYmplY3QsIFRlc3RD b25kaXRpb25hbEltcGxlbWVudHMqIGltcGwpIHsgcmV0dXJuIGltcGwgPyB0b0pTKHN0YXRlLCBn bG9iYWxPYmplY3QsICppbXBsKSA6IEpTQzo6anNOdWxsKCk7IH0KK0pTQzo6SlNWYWx1ZSB0b0pT TmV3bHlDcmVhdGVkKEpTQzo6RXhlY1N0YXRlKiwgSlNET01HbG9iYWxPYmplY3QqLCBSZWY8VGVz dENvbmRpdGlvbmFsSW1wbGVtZW50cz4mJik7CitpbmxpbmUgSlNDOjpKU1ZhbHVlIHRvSlNOZXds eUNyZWF0ZWQoSlNDOjpFeGVjU3RhdGUqIHN0YXRlLCBKU0RPTUdsb2JhbE9iamVjdCogZ2xvYmFs T2JqZWN0LCBSZWZQdHI8VGVzdENvbmRpdGlvbmFsSW1wbGVtZW50cz4mJiBpbXBsKSB7IHJldHVy biBpbXBsID8gdG9KU05ld2x5Q3JlYXRlZChzdGF0ZSwgZ2xvYmFsT2JqZWN0LCBpbXBsLnJlbGVh c2VOb25OdWxsKCkpIDogSlNDOjpqc051bGwoKTsgfQorCisKK30gLy8gbmFtZXNwYWNlIFdlYkNv cmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvdGVzdC9PYmpD L0RPTVRlc3RDb25kaXRpb25hbEltcGxlbWVudHMuaCBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdz L3NjcmlwdHMvdGVzdC9PYmpDL0RPTVRlc3RDb25kaXRpb25hbEltcGxlbWVudHMuaApuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwLi5lMTZlOWQ3Y2Q2NDIwMDIwYzY5ZWNkZTY1M2U0MjhkYmYwZmMwYzYwCi0tLSAvZGV2L251 bGwKKysrIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy90ZXN0L09iakMvRE9NVGVz dENvbmRpdGlvbmFsSW1wbGVtZW50cy5oCkBAIC0wLDAgKzEsMzEgQEAKKy8qCisgKiBDb3B5cmln aHQgKEMpIDIwMDQsIDIwMDUsIDIwMDYsIDIwMDcsIDIwMDgsIDIwMDkgQXBwbGUgSW5jLiBBbGwg cmlnaHRzIHJlc2VydmVkLgorICogQ29weXJpZ2h0IChDKSAyMDA2IFNhbXVlbCBXZWluaWcgPHNh bS53ZWluaWdAZ21haWwuY29tPgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291 cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBh cmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBh cmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWlu IHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBp biBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJv dmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJP VklERUQgQlkgQVBQTEUgSU5DLiBgYEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBM SUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElN UExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFS VElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQ UExFIElOQy4gT1IKKyAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElO RElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAorICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5U SUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogUFJPQ1VSRU1F TlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9S CisgKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFO RCBPTiBBTlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNU UklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhF UldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZU V0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4g CisgKi8KKworI2ltcG9ydCA8V2ViQ29yZS9ET01PYmplY3QuaD4KKworV0VCS0lUX0NMQVNTX0FW QUlMQUJMRV9NQUMoOTg3Nl81KQorV0VCQ09SRV9FWFBPUlQgQGludGVyZmFjZSBET01UZXN0Q29u ZGl0aW9uYWxJbXBsZW1lbnRzIDogRE9NT2JqZWN0CitAZW5kCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9iaW5kaW5ncy9zY3JpcHRzL3Rlc3QvT2JqQy9ET01UZXN0Q29uZGl0aW9uYWxJbXBs ZW1lbnRzLm1tIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy90ZXN0L09iakMvRE9N VGVzdENvbmRpdGlvbmFsSW1wbGVtZW50cy5tbQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4zNWZlMDJjMmYyMzYzZThj ZmZmNzRlMzUwMDcxMTU3ZWM5OTJhYzg2Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNv cmUvYmluZGluZ3Mvc2NyaXB0cy90ZXN0L09iakMvRE9NVGVzdENvbmRpdGlvbmFsSW1wbGVtZW50 cy5tbQpAQCAtMCwwICsxLDc1IEBACisvKgorICogVGhpcyBmaWxlIGlzIHBhcnQgb2YgdGhlIFdl YktpdCBvcGVuIHNvdXJjZSBwcm9qZWN0LgorICogVGhpcyBmaWxlIGhhcyBiZWVuIGdlbmVyYXRl ZCBieSBnZW5lcmF0ZS1iaW5kaW5ncy5wbC4gRE8gTk9UIE1PRElGWSEKKyAqCisgKiBSZWRpc3Ry aWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhv dXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xs b3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBz b3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2Us IHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisg KiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFi b3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQg dGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQv b3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisg KiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gYGBBUyBJUycnIEFORCBB TlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1Qg TElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZ IEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQu ICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElB QkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVY RU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElN SVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7 IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBU SU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBX SEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVE SU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRI RSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lC SUxJVFkgT0YgU1VDSCBEQU1BR0UuIAorICovCisKKyNpbXBvcnQgImNvbmZpZy5oIgorI2ltcG9y dCAiRE9NSW50ZXJuYWwuaCIKKworI2ltcG9ydCAiRE9NVGVzdENvbmRpdGlvbmFsSW1wbGVtZW50 cy5oIgorCisjaW1wb3J0ICJET01Ob2RlSW50ZXJuYWwuaCIKKyNpbXBvcnQgIkRPTVRlc3RDb25k aXRpb25hbEltcGxlbWVudHNJbnRlcm5hbC5oIgorI2ltcG9ydCAiRXhjZXB0aW9uSGFuZGxlcnMu aCIKKyNpbXBvcnQgIkpTTWFpblRocmVhZEV4ZWNTdGF0ZS5oIgorI2ltcG9ydCAiVGVzdENvbmRp dGlvbmFsSW1wbGVtZW50cy5oIgorI2ltcG9ydCAiVGhyZWFkQ2hlY2suaCIKKyNpbXBvcnQgIldl YkNvcmVPYmpDRXh0cmFzLmgiCisjaW1wb3J0ICJXZWJTY3JpcHRPYmplY3RQcml2YXRlLmgiCisj aW1wb3J0IDx3dGYvR2V0UHRyLmg+CisKKyNkZWZpbmUgSU1QTCByZWludGVycHJldF9jYXN0PFdl YkNvcmU6OlRlc3RDb25kaXRpb25hbEltcGxlbWVudHMqPihfaW50ZXJuYWwpCisKK0BpbXBsZW1l bnRhdGlvbiBET01UZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzCisKKy0gKHZvaWQpZGVhbGxvYwor eworICAgIGlmIChXZWJDb3JlT2JqQ1NjaGVkdWxlRGVhbGxvY2F0ZU9uTWFpblRocmVhZChbRE9N VGVzdENvbmRpdGlvbmFsSW1wbGVtZW50cyBjbGFzc10sIHNlbGYpKQorICAgICAgICByZXR1cm47 CisKKyAgICBpZiAoX2ludGVybmFsKQorICAgICAgICBJTVBMLT5kZXJlZigpOworICAgIFtzdXBl ciBkZWFsbG9jXTsKK30KKworQGVuZAorCitXZWJDb3JlOjpUZXN0Q29uZGl0aW9uYWxJbXBsZW1l bnRzKiBjb3JlKERPTVRlc3RDb25kaXRpb25hbEltcGxlbWVudHMgKndyYXBwZXIpCit7CisgICAg cmV0dXJuIHdyYXBwZXIgPyByZWludGVycHJldF9jYXN0PFdlYkNvcmU6OlRlc3RDb25kaXRpb25h bEltcGxlbWVudHMqPih3cmFwcGVyLT5faW50ZXJuYWwpIDogMDsKK30KKworRE9NVGVzdENvbmRp dGlvbmFsSW1wbGVtZW50cyAqa2l0KFdlYkNvcmU6OlRlc3RDb25kaXRpb25hbEltcGxlbWVudHMq IHZhbHVlKQoreworICAgIFdlYkNvcmVUaHJlYWRWaW9sYXRpb25DaGVja1JvdW5kT25lKCk7Cisg ICAgaWYgKCF2YWx1ZSkKKyAgICAgICAgcmV0dXJuIG5pbDsKKyAgICBpZiAoRE9NVGVzdENvbmRp dGlvbmFsSW1wbGVtZW50cyAqd3JhcHBlciA9IGdldERPTVdyYXBwZXIodmFsdWUpKQorICAgICAg ICByZXR1cm4gW1t3cmFwcGVyIHJldGFpbl0gYXV0b3JlbGVhc2VdOworICAgIERPTVRlc3RDb25k aXRpb25hbEltcGxlbWVudHMgKndyYXBwZXIgPSBbW0RPTVRlc3RDb25kaXRpb25hbEltcGxlbWVu dHMgYWxsb2NdIF9pbml0XTsKKyAgICB3cmFwcGVyLT5faW50ZXJuYWwgPSByZWludGVycHJldF9j YXN0PERPTU9iamVjdEludGVybmFsKj4odmFsdWUpOworICAgIHZhbHVlLT5yZWYoKTsKKyAgICBh ZGRET01XcmFwcGVyKHdyYXBwZXIsIHZhbHVlKTsKKyAgICByZXR1cm4gW3dyYXBwZXIgYXV0b3Jl bGVhc2VdOworfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy90 ZXN0L09iakMvRE9NVGVzdENvbmRpdGlvbmFsSW1wbGVtZW50c0ludGVybmFsLmggYi9Tb3VyY2Uv V2ViQ29yZS9iaW5kaW5ncy9zY3JpcHRzL3Rlc3QvT2JqQy9ET01UZXN0Q29uZGl0aW9uYWxJbXBs ZW1lbnRzSW50ZXJuYWwuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5hMDY2YjZkYzkzYmZjMTRhY2I5Zjg2YWQxNjBl NWY4ZDJiZWZhYjNhCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3Mv c2NyaXB0cy90ZXN0L09iakMvRE9NVGVzdENvbmRpdGlvbmFsSW1wbGVtZW50c0ludGVybmFsLmgK QEAgLTAsMCArMSwzNCBAQAorLyoKKyAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBXZWJLaXQg b3BlbiBzb3VyY2UgcHJvamVjdC4KKyAqIFRoaXMgZmlsZSBoYXMgYmVlbiBnZW5lcmF0ZWQgYnkg Z2VuZXJhdGUtYmluZGluZ3MucGwuIERPIE5PVCBNT0RJRlkhCisgKgorICogUmVkaXN0cmlidXRp b24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Cisg KiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5n IGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNl IGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlz IGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4g UmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBj b3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBm b2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90 aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJ UyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisg KiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlU RUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQg RklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4g Tk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBG T1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExB UlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQg VE8sCisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NT IE9GIFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikg SE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhF UiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBO RUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNF CisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZ IE9GIFNVQ0ggREFNQUdFLiAKKyAqLworCisjaW1wb3J0IDxXZWJDb3JlL0RPTVRlc3RDb25kaXRp b25hbEltcGxlbWVudHMuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworY2xhc3MgVGVzdENvbmRp dGlvbmFsSW1wbGVtZW50czsKK30KKworV0VCQ09SRV9FWFBPUlQgV2ViQ29yZTo6VGVzdENvbmRp dGlvbmFsSW1wbGVtZW50cyogY29yZShET01UZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzICopOwor V0VCQ09SRV9FWFBPUlQgRE9NVGVzdENvbmRpdGlvbmFsSW1wbGVtZW50cyAqa2l0KFdlYkNvcmU6 OlRlc3RDb25kaXRpb25hbEltcGxlbWVudHMqKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L2JpbmRpbmdzL3NjcmlwdHMvdGVzdC9UZXN0Q29uZGl0aW9uYWxJbXBsZW1lbnRzLmlkbCBiL1Nv dXJjZS9XZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvdGVzdC9UZXN0Q29uZGl0aW9uYWxJbXBsZW1l bnRzLmlkbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwLi5kZDI0MWY4Mzc3MDJiMDZiYjg4ZTExMzIwNTBmNDBiNjYyZTBm MGJhCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy90 ZXN0L1Rlc3RDb25kaXRpb25hbEltcGxlbWVudHMuaWRsCkBAIC0wLDAgKzEsMzMgQEAKKy8qCisg KiBDb3B5cmlnaHQgKEMpIENhbm9uIEluYy4gMjAxNgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFu ZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9k aWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkLCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29u ZGl0aW9ucworICogYXJlIHJlcXVpcmVkIHRvIGJlIG1ldDoKKyAqCisgKiAxLiBSZWRpc3RyaWJ1 dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICog bm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNl IHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMg YW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqIGRvY3VtZW50YXRpb24gYW5k L29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKiAz LiBOZWl0aGVyIHRoZSBuYW1lIG9mIENhbm9uIEluYy4gbm9yIHRoZSBuYW1lcyBvZgorICogaXRz IGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMg ZGVyaXZlZAorICogZnJvbSB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3Jp dHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQ0FO T04gSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyAiQVMgSVMiIEFORCBBTlkKKyAqIEVYUFJFU1Mg T1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhF IElNUExJRUQKKyAqIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZP UiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUKKyAqIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNI QUxMIENBTk9OIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUgorICogQU5Z IERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09O U0VRVUVOVElBTAorICogREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBS T0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IKKyAqIFNFUlZJQ0VTOyBMT1NTIE9GIFVT RSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSCisg KiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRS QUNULCBTVFJJQ1QgTElBQklMSVRZLAorICogT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0Ug T1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRI SVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBE QU1BR0UuCisgKi8KKworWworXSBpbnRlcmZhY2UgVGVzdENvbmRpdGlvbmFsSW1wbGVtZW50cyB7 Cit9OworCitbQ29uZGl0aW9uYWw9RElTQUJMRURfU1dJVENIXSBUZXN0Q29uZGl0aW9uYWxJbXBs ZW1lbnRzIGltcGxlbWVudHMgVGVzdEltcGxlbWVudHM7Cg==