185194 2018-05-02 05:33:44 -0700 [GTK] Error building WebKitGTK+ with gcc version 7.3.0 2018-05-11 14:49:51 -0700 1 1 1 Unclassified WebKit WebKitGTK WebKit Nightly Build Unspecified Unspecified RESOLVED INVALID P2 Normal --- 1 magomez webkit-unassigned aperez bugs-noreply cadubentzen jfbastien mcatanzaro ysuzuki zan oldest_to_newest 1419626 0 339297 magomez 2018-05-02 05:33:44 -0700 Created attachment 339297 Build log. WebKitGtk+ is not building on current ToT (r231227). It fails because we are using optional RefPtr attributes with classes that are forward-defined. I think it's related to https://trac.webkit.org/changeset/231223, that causes the compiler to use std::optional instead of the WTF implmentation. Maybe with std::optional we need to have the complete class definition? Attaching the build log. 1419629 1 ysuzuki 2018-05-02 05:58:06 -0700 (In reply to Miguel Gomez from comment #0) > Created attachment 339297 [details] > Build log. > > WebKitGtk+ is not building on current ToT (r231227). It fails because we are > using optional RefPtr attributes with classes that are forward-defined. I > think it's related to https://trac.webkit.org/changeset/231223, that causes > the compiler to use std::optional instead of the WTF implmentation. Maybe > with std::optional we need to have the complete class definition? > > Attaching the build log. Hmm, strange. In my environment (Debian unstable, gcc (Debian 7.3.0-17) 7.3.0), WebKitGTK+ is built without any errors. Could you take a look at this issue? 1419632 2 magomez 2018-05-02 06:13:37 -0700 Oh, sorry, testing too many environments at the same time. My gcc version is gcc (GCC) 7.3.1 20180130 (Red Hat 7.3.1-2) 1420046 3 magomez 2018-05-03 00:55:25 -0700 These are the problematic definitions: Source/WebCore/html/HTMLMediaElement.h: using MediaProvider = std::optional<Variant< #if ENABLE(MEDIA_STREAM) RefPtr<MediaStream>, #endif #if ENABLE(MEDIA_SOURCE) RefPtr<MediaSource>, #endif RefPtr<Blob>>>; Source/WebCore/html/HTMLSourceElement.h mutable std::optional<RefPtr<const MediaQuerySet>> m_cachedParsedMediaAttribute; These are easily fixed by adding the appropriate includes, but after that I'm getting into this: magomez@mars:~/webkit/WebKit (master)$ Tools/Scripts/build-webkit --gtk --release Use of uninitialized value $previousContents in chomp at /home/magomez/webkit/WebKit/Tools/Scripts/webkitdirs.pm line 1969. Use of uninitialized value $previousContents in string ne at /home/magomez/webkit/WebKit/Tools/Scripts/webkitdirs.pm line 1972. + /home/magomez/webkit/WebKit/Tools/jhbuild/jhbuild-wrapper --gtk run cmake --build /home/magomez/webkit/WebKit/WebKitBuild/Release --config Release -- -j1 [2/1674] Building CXX object Source/WebCore/CMakeFiles/WebCore.dir/__/__/DerivedSources/WebCore/unified-sources/UnifiedSource20.cpp.o FAILED: Source/WebCore/CMakeFiles/WebCore.dir/__/__/DerivedSources/WebCore/unified-sources/UnifiedSource20.cpp.o /usr/lib64/ccache/c++ -DBUILDING_GTK__=1 -DBUILDING_WEBKIT -DBUILDING_WITH_CMAKE=1 -DBUILDING_WebCore -DGETTEXT_PACKAGE=\"WebKit2GTK-4.0\" -DHAVE_CONFIG_H=1 -DJSC_GLIB_API_ENABLED -DSTATICALLY_LINKED_WITH_PAL=1 -DWEBKITGTK_API_VERSION_STRING=\"4.0\" -I. -I../../Source/WebCore -I../../Source/WebCore/Modules/airplay -I../../Source/WebCore/Modules/beacon -I../../Source/WebCore/Modules/applepay -I../../Source/WebCore/Modules/applepay/paymentrequest -I../../Source/WebCore/Modules/cache -I../../Source/WebCore/Modules/credentialmanagement -I../../Source/WebCore/Modules/encryptedmedia -I../../Source/WebCore/Modules/encryptedmedia/legacy -I../../Source/WebCore/Modules/entriesapi -I../../Source/WebCore/Modules/fetch -I../../Source/WebCore/Modules/geolocation -I../../Source/WebCore/Modules/indexeddb -I../../Source/WebCore/Modules/indexeddb/client -I../../Source/WebCore/Modules/indexeddb/server -I../../Source/WebCore/Modules/indexeddb/shared -I../../Source/WebCore/Modules/mediacapabilities -I../../Source/WebCore/Modules/mediacontrols -I../../Source/WebCore/Modules/mediasession -I../../Source/WebCore/Modules/mediasource -I../../Source/WebCore/Modules/mediastream -I../../Source/WebCore/Modules/navigatorcontentutils -I../../Source/WebCore/Modules/notifications -I../../Source/WebCore/Modules/paymentrequest -I../../Source/WebCore/Modules/plugins -I../../Source/WebCore/Modules/quota -I../../Source/WebCore/Modules/speech -I../../Source/WebCore/Modules/streams -I../../Source/WebCore/Modules/webaudio -I../../Source/WebCore/Modules/webauthn -I../../Source/WebCore/Modules/webdatabase -I../../Source/WebCore/Modules/webdriver -I../../Source/WebCore/Modules/websockets -I../../Source/WebCore/Modules/webvr -I../../Source/WebCore/accessibility -I../../Source/WebCore/animation -I../../Source/WebCore/bindings -I../../Source/WebCore/bindings/js -I../../Source/WebCore/bridge -I../../Source/WebCore/bridge/c -I../../Source/WebCore/bridge/jsc -I../../Source/WebCore/contentextensions -I../../Source/WebCore/crypto -I../../Source/WebCore/crypto/algorithms -I../../Source/WebCore/crypto/keys -I../../Source/WebCore/crypto/parameters -I../../Source/WebCore/css -I../../Source/WebCore/css/parser -I../../Source/WebCore/cssjit -I../../Source/WebCore/dom -I../../Source/WebCore/dom/default -I../../Source/WebCore/dom/messageports -I../../Source/WebCore/domjit -I../../Source/WebCore/editing -I../../Source/WebCore/fileapi -I../../Source/WebCore/history -I../../Source/WebCore/html -I../../Source/WebCore/html/canvas -I../../Source/WebCore/html/forms -I../../Source/WebCore/html/parser -I../../Source/WebCore/html/shadow -I../../Source/WebCore/html/track -I../../Source/WebCore/inspector -I../../Source/WebCore/inspector/agents -I../../Source/WebCore/inspector/agents/page -I../../Source/WebCore/inspector/agents/worker -I../../Source/WebCore/loader -I../../Source/WebCore/loader/appcache -I../../Source/WebCore/loader/archive -I../../Source/WebCore/loader/archive/mhtml -I../../Source/WebCore/loader/cache -I../../Source/WebCore/loader/icon -I../../Source/WebCore/mathml -I../../Source/WebCore/page -I../../Source/WebCore/page/animation -I../../Source/WebCore/page/csp -I../../Source/WebCore/page/scrolling -I../../Source/WebCore/platform -I../../Source/WebCore/platform/animation -I../../Source/WebCore/platform/audio -I../../Source/WebCore/platform/crypto -I../../Source/WebCore/platform/encryptedmedia -I../../Source/WebCore/platform/gamepad -I../../Source/WebCore/platform/graphics -I../../Source/WebCore/platform/graphics/cpu/arm -I../../Source/WebCore/platform/graphics/cpu/arm/filters -I../../Source/WebCore/platform/graphics/displaylists -I../../Source/WebCore/platform/graphics/filters -I../../Source/WebCore/platform/graphics/harfbuzz -I../../Source/WebCore/platform/graphics/harfbuzz/ng -I../../Source/WebCore/platform/graphics/iso -I../../Source/WebCore/platform/graphics/opentype -I../../Source/WebCore/platform/graphics/transforms -I../../Source/WebCore/platform/mediastream -I../../Source/WebCore/platform/mediastream/libwebrtc -I../../Source/WebCore/platform/mock -I../../Source/WebCore/platform/mock/mediasource -I../../Source/WebCore/platform/network -I../../Source/WebCore/platform/sql -I../../Source/WebCore/platform/text -I../../Source/WebCore/platform/text/icu -I../../Source/WebCore/platform/vr -I../../Source/WebCore/plugins -I../../Source/WebCore/rendering -I../../Source/WebCore/rendering/line -I../../Source/WebCore/rendering/mathml -I../../Source/WebCore/rendering/shapes -I../../Source/WebCore/rendering/style -I../../Source/WebCore/rendering/svg -I../../Source/WebCore/rendering/updating -I../../Source/WebCore/replay -I../../Source/WebCore/storage -I../../Source/WebCore/style -I../../Source/WebCore/svg -I../../Source/WebCore/svg/animation -I../../Source/WebCore/svg/graphics -I../../Source/WebCore/svg/graphics/filters -I../../Source/WebCore/svg/properties -I../../Source/WebCore/websockets -I../../Source/WebCore/workers -I../../Source/WebCore/workers/service -I../../Source/WebCore/workers/service/context -I../../Source/WebCore/workers/service/server -I../../Source/WebCore/xml -I../../Source/WebCore/xml/parser -IDerivedSources/WebCore -IDerivedSources/ForwardingHeaders/ANGLE -I../../Source/WebCore/platform/graphics/gpu -I../../Source/ThirdParty/openvr/headers -I../../Source/WebCore/platform/vr/openvr -I../../Source/ThirdParty/xdgmime/src -I../../Source/WebCore/platform/graphics/cairo -I../../Source/WebCore/platform/graphics/freetype -I../../Source/WebCore/platform/graphics/gstreamer -I../../Source/WebCore/platform/graphics/gstreamer/mse -I../../Source/WebCore/platform/graphics/gstreamer/eme -I../../Source/WebCore/platform/audio/gstreamer -I../../Source/WebCore/platform/image-decoders -I../../Source/WebCore/platform/image-decoders/bmp -I../../Source/WebCore/platform/image-decoders/gif -I../../Source/WebCore/platform/image-decoders/ico -I../../Source/WebCore/platform/image-decoders/jpeg -I../../Source/WebCore/platform/image-decoders/png -I../../Source/WebCore/platform/image-decoders/webp -I../../Source/WebCore/platform/graphics/texmap -I../../Source/WebCore/page/scrolling/coordinatedgraphics -I../../Source/WebCore/platform/graphics/texmap/coordinated -I../../Source/WebCore/platform/graphics/nicosia -I../../Source/WebCore/platform/graphics/nicosia/cairo -I../../Source/ThirdParty/ANGLE -I../../Source/ThirdParty/ANGLE/include/KHR -I../../Source/WebCore/accessibility/atk -I../../Source/WebCore/editing/atk -I../../Source/WebCore/page/gtk -I../../Source/WebCore/platform/geoclue -I../../Source/WebCore/platform/gtk -I../../Source/WebCore/platform/graphics/egl -I../../Source/WebCore/platform/graphics/glx -I../../Source/WebCore/platform/graphics/gtk -I../../Source/WebCore/platform/graphics/opengl -I../../Source/WebCore/platform/graphics/wayland -I../../Source/WebCore/platform/graphics/x11 -I../../Source/WebCore/platform/mediastream/gtk -I../../Source/WebCore/platform/network/gtk -I../../Source/WebCore/platform/network/soup -I../../Source/WebCore/platform/text/gtk -I../../Source/WebCore/bindings/gobject -isystem ../DependenciesGTK/Root/include/libxml2 -isystem ../../Source/ThirdParty/libwebrtc/Source -isystem ../../Source/ThirdParty/libwebrtc/Source/webrtc -isystem ../DependenciesGTK/Root/include/cairo -isystem ../DependenciesGTK/Root/include/freetype2/freetype -isystem ../DependenciesGTK/Root/include/freetype2 -isystem ../DependenciesGTK/Root/include/harfbuzz -isystem ../DependenciesGTK/Root/include/gstreamer-1.0 -isystem ../DependenciesGTK/Root/include/glib-2.0 -isystem ../DependenciesGTK/Root/lib/glib-2.0/include -isystem ../DependenciesGTK/Root/lib/gstreamer-1.0/include -isystem /usr/include/libdrm -isystem ../DependenciesGTK/Root/include/atk-1.0 -isystem /usr/include/enchant -isystem ../DependenciesGTK/Root/include/gio-unix-2.0 -isystem ../DependenciesGTK/Root/include/libsecret-1 -isystem ../DependenciesGTK/Root/include/libsoup-2.4 -IDerivedSources/ForwardingHeaders -I../../Source/bmalloc -IDerivedSources -I../../Source/ThirdParty -fdiagnostics-color=always -Wno-expansion-to-defined -Wno-attributes -Wno-noexcept-type -Wno-maybe-uninitialized -Wwrite-strings -Wundef -Wpointer-arith -Wmissing-format-attribute -Wformat-security -Wcast-align -Wextra -Wall -fno-strict-aliasing -fno-exceptions -std=c++17 -fno-rtti -O2 -DNDEBUG -fPIC -MD -MT Source/WebCore/CMakeFiles/WebCore.dir/__/__/DerivedSources/WebCore/unified-sources/UnifiedSource20.cpp.o -MF Source/WebCore/CMakeFiles/WebCore.dir/__/__/DerivedSources/WebCore/unified-sources/UnifiedSource20.cpp.o.d -o Source/WebCore/CMakeFiles/WebCore.dir/__/__/DerivedSources/WebCore/unified-sources/UnifiedSource20.cpp.o -c DerivedSources/WebCore/unified-sources/UnifiedSource20.cpp In file included from DerivedSources/ForwardingHeaders/wtf/text/StringImpl.h:32:0, from DerivedSources/ForwardingHeaders/wtf/text/WTFString.h:31, from ../../Source/WebCore/platform/graphics/ExtendedColor.h:32, from ../../Source/WebCore/platform/graphics/Color.h:29, from ../../Source/WebCore/dom/Document.h:30, from ../../Source/WebCore/dom/Element.h:28, from ../../Source/WebCore/html/DOMTokenList.h:28, from DerivedSources/WebCore/JSDOMTokenList.h:23, from DerivedSources/WebCore/JSDOMTokenList.cpp:22, from DerivedSources/WebCore/unified-sources/UnifiedSource20.cpp:1: DerivedSources/ForwardingHeaders/wtf/Vector.h: In instantiation of ‘static void WTF::VectorCopier<false, T>::uninitializedCopy(const T*, const T*, U*) [with U = WTF::Ref<WebCore::DataTransferItem>; T = WTF::Ref<WebCore::DataTransferItem>]’: DerivedSources/ForwardingHeaders/wtf/Vector.h:265:79: required from ‘static void WTF::VectorTypeOperations<T>::uninitializedCopy(const T*, const T*, T*) [with T = WTF::Ref<WebCore::DataTransferItem>]’ DerivedSources/ForwardingHeaders/wtf/Vector.h:874:42: required from ‘WTF::Vector< <template-parameter-1-1>, <anonymous>, <template-parameter-1-3>, <anonymous>, <template-parameter-1-5> >::Vector(const WTF::Vector< <template-parameter-1-1>, <anonymous>, <template-parameter-1-3>, <anonymous>, <template-parameter-1-5> >&) [with T = WTF::Ref<WebCore::DataTransferItem>; long unsigned int inlineCapacity = 0; OverflowHandler = WTF::CrashOnOverflow; long unsigned int minCapacity = 16; Malloc = WTF::FastMalloc]’ /usr/include/c++/7/type_traits:1406:12: required from ‘struct std::is_trivially_copy_constructible<WTF::Vector<WTF::Ref<WebCore::DataTransferItem> > >’ /usr/include/c++/7/optional:105:8: required from ‘class std::_Optional_base<WTF::Vector<WTF::Ref<WebCore::DataTransferItem> > >’ /usr/include/c++/7/optional:453:11: required from ‘class std::optional<WTF::Vector<WTF::Ref<WebCore::DataTransferItem> > >’ ../../Source/WebCore/dom/DataTransferItemList.h:80:58: required from here DerivedSources/ForwardingHeaders/wtf/Vector.h:162:13: error: use of deleted function ‘WTF::Ref<T, <template-parameter-1-2> >::Ref(const WTF::Ref<T, <template-parameter-1-2> >&) [with T = WebCore::DataTransferItem; PtrTraits = WTF::DumbPtrTraits<WebCore::DataTransferItem>]’ new (NotNull, dst) U(*src); ^~~~~~~~~~~~~~~~~~~~~~~~~~ In file included from ../../Source/WebCore/platform/graphics/ExtendedColor.h:30:0, from ../../Source/WebCore/platform/graphics/Color.h:29, from ../../Source/WebCore/dom/Document.h:30, from ../../Source/WebCore/dom/Element.h:28, from ../../Source/WebCore/html/DOMTokenList.h:28, from DerivedSources/WebCore/JSDOMTokenList.h:23, from DerivedSources/WebCore/JSDOMTokenList.cpp:22, from DerivedSources/WebCore/unified-sources/UnifiedSource20.cpp:1: DerivedSources/ForwardingHeaders/wtf/Ref.h:71:5: note: declared here Ref(const Ref& other) = delete; ^~~ ninja: build stopped: subcommand failed. 1420076 4 magomez 2018-05-03 03:10:28 -0700 After some tests here and there, I decided to upgrade my Fedora in case it was a bug in gcc or the std lib. I upgraded to Fedora 27, which has gcc version 7.3.1 20180303 (Red Hat 7.3.1-5) and with after that I'm able to build without errors. So this doesn't seem to be a WebKit problem. I'm closing it as invalid. Sorry for the noise. 1420423 5 mcatanzaro 2018-05-03 16:40:38 -0700 Still broken here with GCC 8.0.1 *** This bug has been marked as a duplicate of bug 185159 *** 1420430 6 mcatanzaro 2018-05-03 16:50:29 -0700 Actually, this one is different, sorry. 1421297 7 mcatanzaro 2018-05-07 09:51:04 -0700 Still happens with freedesktop SDK's GCC 7.3.0 and today's trunk, reopening 1421472 8 mcatanzaro 2018-05-07 15:43:30 -0700 JF, this might be a tricky one. Problem is, with --std=c++17 we must use the real std::optional rather than our own (fixed in bug #185159). But with, libstdc++ 7 std::optional does not support incomplete types. I've been fighting my way through the build, and most problems are fairly easy to fix by converting forward declarations to #includes, but now I've run into a circular dependency. IDBRequest.h now requires IDBIndex.h, because it uses std::optional<Source> with using Source = Variant<RefPtr<IDBObjectStore>, RefPtr<IDBIndex>, RefPtr<IDBCursor>>. But IDBIndex.h requires IDBRequest.h, since it uses ExceptionOr<Ref<IDBRequest>>. Forward declarations won't save us here: some code is going to need to be either rewritten or else seriously reorganized. There was also another case (in DataTransferItemList.h) of std::optional<Vector<something>> where I had to replace std::optional with a raw pointer Vector<something>*, which was unfortunate. I fear that's probably going to be the way to fix IDBRequest.h, which is a shame because it's used in public member functions there. 1421486 9 jfbastien 2018-05-07 16:10:32 -0700 (In reply to Michael Catanzaro from comment #8) > JF, this might be a tricky one. Problem is, with --std=c++17 we must use the > real std::optional rather than our own (fixed in bug #185159). But with, > libstdc++ 7 std::optional does not support incomplete types. Can you avoid using the provided one in that case? 1421569 10 mcatanzaro 2018-05-07 18:13:49 -0700 (In reply to JF Bastien from comment #9) > Can you avoid using the provided one in that case? No, because it's used by other stdlib headers, unless we drop back down to --std=c++14. Converting to raw pointers is probably more desirable. I'll keep going and see how much needs to be changed. 1421623 11 mcatanzaro 2018-05-07 21:21:00 -0700 I'm having a *lot* of trouble with this. JF, is it OK if I rollout r231170 for now? I think we need to; unfortunately, I don't see a path right now to using --std=c++17 with GCC 7. GCC 6 and GCC 8 don't seem to have any such problems. GCC 6 is good because it doesn't support std::optional yet; that's why all the bots are green. And I guess GCC 8 has a smarter std::optional. --std=c++17 is still experimental, even in GCC 8. I think we still gained a lot from requiring GCC 6, even if we backtrack on making the transition to C++ 17 so early on. (In reply to Miguel Gomez from comment #4) > After some tests here and there, I decided to upgrade my Fedora in case it > was a bug in gcc or the std lib. I upgraded to Fedora 27, which has gcc > version 7.3.1 20180303 (Red Hat 7.3.1-5) and with after that I'm able to > build without errors. Are you sure you kept the WebKit revision the same? Because Yusuke's patch to use system std::optional got reverted for a little while. My guess is you tested Fedora 27's GCC using a revision where it had been reverted. 1421624 12 mcatanzaro 2018-05-07 21:22:34 -0700 (In reply to Michael Catanzaro from comment #11) > GCC 6 and GCC 8 don't seem to have any such problems. GCC 6 is good because > it doesn't support std::optional yet; that's why all the bots are green. And > I guess GCC 8 has a smarter std::optional. Well, GCC 8 actually can't compile WebCore, it just crashes... I'll try to find a workaround soon. But it gets far enough that I'm pretty sure it doesn't have this problem with std::optional. 1421627 13 jfbastien 2018-05-07 21:30:45 -0700 (In reply to Michael Catanzaro from comment #11) > I'm having a *lot* of trouble with this. JF, is it OK if I rollout r231170 > for now? I think we need to; unfortunately, I don't see a path right now to > using --std=c++17 with GCC 7. I'm fine with it, but it might be better to ask on the thread where we agreed to do this migration, with an explanation of what's going on? The next step should be this: https://bugs.webkit.org/show_bug.cgi?id=185176 But I was waiting on hearing from your work to make sure I don't dig a bigger hole that we'd need to dig ourselves out of. Given the lack of bots, it seems like GCC 7 wasn't an actually supported target when we agreed to do this migration. Are you suggesting that GCC 7 should be officially supported? If so, can we ensure bot coverage of both GCC 6 as well as 7 so that breakage can be avoided? 1421628 14 ysuzuki 2018-05-07 21:34:09 -0700 (In reply to JF Bastien from comment #13) > (In reply to Michael Catanzaro from comment #11) > > I'm having a *lot* of trouble with this. JF, is it OK if I rollout r231170 > > for now? I think we need to; unfortunately, I don't see a path right now to > > using --std=c++17 with GCC 7. > > I'm fine with it, but it might be better to ask on the thread where we > agreed to do this migration, with an explanation of what's going on? > > The next step should be this: > https://bugs.webkit.org/show_bug.cgi?id=185176 > But I was waiting on hearing from your work to make sure I don't dig a > bigger hole that we'd need to dig ourselves out of. > > Given the lack of bots, it seems like GCC 7 wasn't an actually supported > target when we agreed to do this migration. Are you suggesting that GCC 7 > should be officially supported? If so, can we ensure bot coverage of both > GCC 6 as well as 7 so that breakage can be avoided? I'm really worried about GCC 7.0's current situation. Next chance we upgrade our compiler is maybe two years later. If we can upgrade our GCC to 8.0 at that time, it is OK. But if we cannot do that and we need to use GCC 7.0 at that time, it means we need 4 years to use C++17 from now. Can we solve the current compile errors by carefully splitting headers, adding includes, etc.? If we can do that, I think we should do. 1421632 15 ysuzuki 2018-05-07 21:38:06 -0700 (In reply to Michael Catanzaro from comment #8) > JF, this might be a tricky one. Problem is, with --std=c++17 we must use the > real std::optional rather than our own (fixed in bug #185159). But with, > libstdc++ 7 std::optional does not support incomplete types. I've been > fighting my way through the build, and most problems are fairly easy to fix > by converting forward declarations to #includes, but now I've run into a > circular dependency. IDBRequest.h now requires IDBIndex.h, because it uses > std::optional<Source> with using Source = Variant<RefPtr<IDBObjectStore>, > RefPtr<IDBIndex>, RefPtr<IDBCursor>>. But IDBIndex.h requires IDBRequest.h, > since it uses ExceptionOr<Ref<IDBRequest>>. Forward declarations won't save > us here: some code is going to need to be either rewritten or else seriously > reorganized. > > There was also another case (in DataTransferItemList.h) of > std::optional<Vector<something>> where I had to replace std::optional with a > raw pointer Vector<something>*, which was unfortunate. I fear that's > probably going to be the way to fix IDBRequest.h, which is a shame because > it's used in public member functions there. Another solution is, moving the current our std::optional to WTF::optional. And use it. And in some ports, we can use official std::optional. 1421704 16 mcatanzaro 2018-05-08 06:59:11 -0700 (In reply to JF Bastien from comment #13) > The next step should be this: > https://bugs.webkit.org/show_bug.cgi?id=185176 > But I was waiting on hearing from your work to make sure I don't dig a > bigger hole that we'd need to dig ourselves out of. Thanks for waiting until we get this resolved. We also have a problem with clang in bug #185198, but of course that one is related to std::optional too. > Given the lack of bots, it seems like GCC 7 wasn't an actually supported > target when we agreed to do this migration. Are you suggesting that GCC 7 > should be officially supported? If so, can we ensure bot coverage of both > GCC 6 as well as 7 so that breakage can be avoided? We definitely need to support both GCC 7 and GCC 8. I'll ask Carlos Lopez if bot coverage would be possible here. (In reply to Yusuke Suzuki from comment #14) > I'm really worried about GCC 7.0's current situation. Next chance we upgrade > our compiler is maybe two years later. > If we can upgrade our GCC to 8.0 at that time, it is OK. But if we cannot do > that and we need to use GCC 7.0 at that time, > it means we need 4 years to use C++17 from now. My expectation is this: * Debian 10 releases with GCC 8 sometime in 2019. At this point, we'll drop GCC 6 and can require GCC 7. * Ubuntu 20.04 releases with GCC 9 in April 2020. At this point, we'll drop GCC 7 and can require GCC 8. It seems like a reasonable schedule. > Can we solve the current compile errors by carefully splitting headers, > adding includes, etc.? If we can do that, I think we should do. I failed at that. (In reply to Yusuke Suzuki from comment #15) > Another solution is, moving the current our std::optional to WTF::optional. > And use it. And in some ports, we can use official std::optional. We should try this. It would be a big patch, but I think it should work. 1421772 17 zan 2018-05-08 10:21:50 -0700 GCC 7 and 8, as packaged in Debian, have no problem compiling WebKit with -std=c++17, no extraordinary fixes currently required. This is most likely an issue in how Fedora packages GCC. I would like to have the cause identified from that perspective before proceeding to apply any workarounds to WebKit. 1421795 18 cadubentzen 2018-05-08 10:46:25 -0700 GCC 7.3.1 in Arch Linux also compiled OK with -std=c++17 1422101 19 mcatanzaro 2018-05-08 18:45:32 -0700 As I mentioned earlier today, I'm actually not working with Fedora's GCC, but with the freedesktop.org GCC, which is GNOME's reference compiler, inside the BuildStream sandbox to ensure that there is no host pollution. So there is a reference platform here, and GNOME will not be able to upgrade to newer WebKit versions unless we fix this. The fact that Miguel reproduced the exact same error with Fedora's GCC indicates that it's not somehow specific to the freedesktop SDK. I intend to try replacing our std::optional with WTF::optional (but probably not until next week). I'm about 70% confident that will work. If it doesn't, I'll roll out the switch to std=c++17 and we can discuss how to proceed (or if we really want to be relying on experimental compiler features so soon). 1422195 20 zan 2018-05-09 01:26:14 -0700 (In reply to Michael Catanzaro from comment #19) > As I mentioned earlier today, I'm actually not working with Fedora's GCC, > but with the freedesktop.org GCC, which is GNOME's reference compiler, > inside the BuildStream sandbox to ensure that there is no host pollution. So > there is a reference platform here, and GNOME will not be able to upgrade to > newer WebKit versions unless we fix this. > Again, given that Debian-provided GCC and libstdc++ are working just fine, this specific regression in the transition towards C++17 utilization doesn't seem to be WebKit's fault. Consider reporting the issue to whoever is packaging GCC in this setup. > The fact that Miguel reproduced the exact same error with Fedora's GCC > indicates that it's not somehow specific to the freedesktop SDK. > He's reported in comment #4 that an upgrade fixed all issues. > I intend to try replacing our std::optional with WTF::optional (but probably > not until next week). I'm about 70% confident that will work. If it doesn't, > I'll roll out the switch to std=c++17 and we can discuss how to proceed (or > if we really want to be relying on experimental compiler features so soon). As of C++17, std::optional is not an experimental feature. 1422259 21 mcatanzaro 2018-05-09 08:22:40 -0700 (In reply to Zan Dobersek from comment #20) > Again, given that Debian-provided GCC and libstdc++ are working just fine, > this specific regression in the transition towards C++17 utilization doesn't > seem to be WebKit's fault. Consider reporting the issue to whoever is > packaging GCC in this setup. No, I'm not going to report a GCC issue to the freedesktop SDK developers, that is completely absurd. They are not GCC experts. It's the latest release of GCC, 7.3.0, without any patches. I already linked you to the packaging up above, and Miguel has provided proof that it is not a distribution-specific issue. Even if it happened to be some problem with the SDK -- which it's not -- I'm still responsible for making sure it builds. (In reply to Zan Dobersek from comment #20) > He's reported in comment #4 that an upgrade fixed all issues. I suspect he may have upgraded WebKit to a version where Yusuke's change had been rolled out, see comment #11. We won't know until he returns from holidays. > > I intend to try replacing our std::optional with WTF::optional (but probably > > not until next week). I'm about 70% confident that will work. If it doesn't, > > I'll roll out the switch to std=c++17 and we can discuss how to proceed (or > > if we really want to be relying on experimental compiler features so soon). > > As of C++17, std::optional is not an experimental feature. C++ 17 is still experimental in GCC 8. The first non-experimental release will presumably be GCC 9 or perhaps GCC 10. 1422260 22 mcatanzaro 2018-05-09 08:23:10 -0700 (In reply to Michael Catanzaro from comment #21) > It's the latest release of GCC, 7.3.0 (the latest release of GCC 7) 1423149 23 mcatanzaro 2018-05-11 09:30:57 -0700 Zan did some investigation today and found that the upstream GCC 7.3.0 release is broken, but the problem is fixed somewhere on the GCC 7 subversion branch. If Miguel was careful to test the same WebKit revision so as not to get tripped up by the revert of Yusuke's std::optional commit, then I'm guessing the fix landed in February or early March. gcc (GCC) 7.3.1 20180130 (Red Hat 7.3.1-2) is of course a January 30 snapshot, so we know that's broken. And gcc version 7.3.1 20180303 (Red Hat 7.3.1-5) is March 3. Debian 7.3.0-17's is an April 27 snapshot. You can see the history here: http://metadata.ftp-master.debian.org/changelogs/main/g/gcc-7/gcc-7_7.3.0-17_changelog I don't know if Debian makes it easy to test old packages, but the granularity there is way smaller than what we have available in Fedora (which is just January 30 and March 3). 1423151 24 mcatanzaro 2018-05-11 09:31:56 -0700 Note Fedora uses GCC 7.3.1 to indicate a SVN snapshot after 7.3.0... nowadays upstream GCC releases always end in .0. Seems pretty useless, but whatever. 1423152 25 mcatanzaro 2018-05-11 09:35:49 -0700 Maybe https://github.com/gcc-mirror/gcc/commit/57b9683f0ce55a410c567fcb2dc365a2cc848d6a 1423179 26 mcatanzaro 2018-05-11 10:48:49 -0700 So, when distributors run into this problem, we'll just have to tell them to upgrade to an SVN snapshot. That's reasonable, IMO. 1423269 27 aperez 2018-05-11 14:49:51 -0700 (In reply to Michael Catanzaro from comment #26) > So, when distributors run into this problem, we'll just have to tell them to > upgrade to an SVN snapshot. That's reasonable, IMO. I also think pointing distributors to the GCC bug and asking them to upgrade GCC packages is reasonable in this particular case—they are using a broken release of the compiler after all! 339297 2018-05-02 05:33:44 -0700 2018-05-02 05:33:44 -0700 Build log. trace text/plain 30268 magomez bWFnb21lekBtYXJzOn4vd2Via2l0L1dlYktpdCAobWFzdGVyKSQgVG9vbHMvU2NyaXB0cy9idWls ZC13ZWJraXQgLS1ndGsgLS1yZWxlYXNlClVzZSBvZiB1bmluaXRpYWxpemVkIHZhbHVlICRwcmV2 aW91c0NvbnRlbnRzIGluIGNob21wIGF0IC9ob21lL21hZ29tZXovd2Via2l0L1dlYktpdC9Ub29s cy9TY3JpcHRzL3dlYmtpdGRpcnMucG0gbGluZSAxOTY5LgpVc2Ugb2YgdW5pbml0aWFsaXplZCB2 YWx1ZSAkcHJldmlvdXNDb250ZW50cyBpbiBzdHJpbmcgbmUgYXQgL2hvbWUvbWFnb21lei93ZWJr aXQvV2ViS2l0L1Rvb2xzL1NjcmlwdHMvd2Via2l0ZGlycy5wbSBsaW5lIDE5NzIuCisgL2hvbWUv bWFnb21lei93ZWJraXQvV2ViS2l0L1Rvb2xzL2poYnVpbGQvamhidWlsZC13cmFwcGVyIC0tZ3Rr IHJ1biBjbWFrZSAtLWJ1aWxkIC9ob21lL21hZ29tZXovd2Via2l0L1dlYktpdC9XZWJLaXRCdWls ZC9SZWxlYXNlIC0tY29uZmlnIFJlbGVhc2UgLS0gLWoxClsyLzE3NDhdIEJ1aWxkaW5nIENYWCBv YmplY3QgU291cmNlL1dlYkNvcmUvQ01ha2VGaWxlcy9XZWJDb3JlUGxhdGZvcm1HVEsuZGlyL3Jl bmRlcmluZy9SZW5kZXJUaGVtZUd0ay5jcHAubwpGQUlMRUQ6IFNvdXJjZS9XZWJDb3JlL0NNYWtl RmlsZXMvV2ViQ29yZVBsYXRmb3JtR1RLLmRpci9yZW5kZXJpbmcvUmVuZGVyVGhlbWVHdGsuY3Bw Lm8gCi91c3IvbGliNjQvY2NhY2hlL2MrKyAgLURCVUlMRElOR19HVEtfXz0xIC1EQlVJTERJTkdf V0VCS0lUIC1EQlVJTERJTkdfV0lUSF9DTUFLRT0xIC1ER0VUVEVYVF9QQUNLQUdFPVwiV2ViS2l0 MkdUSy00LjBcIiAtREhBVkVfQ09ORklHX0g9MSAtREpTQ19HTElCX0FQSV9FTkFCTEVEIC1EU1RB VElDQUxMWV9MSU5LRURfV0lUSF9QQUw9MSAtRFdFQktJVEdUS19BUElfVkVSU0lPTl9TVFJJTkc9 XCI0LjBcIiAtSS4gLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZSAtSS4uLy4uL1NvdXJjZS9XZWJDb3Jl L01vZHVsZXMvYWlycGxheSAtSS4uLy4uL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvYmVhY29uIC1J Li4vLi4vU291cmNlL1dlYkNvcmUvTW9kdWxlcy9hcHBsZXBheSAtSS4uLy4uL1NvdXJjZS9XZWJD b3JlL01vZHVsZXMvYXBwbGVwYXkvcGF5bWVudHJlcXVlc3QgLUkuLi8uLi9Tb3VyY2UvV2ViQ29y ZS9Nb2R1bGVzL2NhY2hlIC1JLi4vLi4vU291cmNlL1dlYkNvcmUvTW9kdWxlcy9jcmVkZW50aWFs bWFuYWdlbWVudCAtSS4uLy4uL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvZW5jcnlwdGVkbWVkaWEg LUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2VuY3J5cHRlZG1lZGlhL2xlZ2FjeSAtSS4u Ly4uL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvZW50cmllc2FwaSAtSS4uLy4uL1NvdXJjZS9XZWJD b3JlL01vZHVsZXMvZmV0Y2ggLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2dlb2xvY2F0 aW9uIC1JLi4vLi4vU291cmNlL1dlYkNvcmUvTW9kdWxlcy9pbmRleGVkZGIgLUkuLi8uLi9Tb3Vy Y2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9jbGllbnQgLUkuLi8uLi9Tb3VyY2UvV2ViQ29y ZS9Nb2R1bGVzL2luZGV4ZWRkYi9zZXJ2ZXIgLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVz L2luZGV4ZWRkYi9zaGFyZWQgLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL21lZGlhY2Fw YWJpbGl0aWVzIC1JLi4vLi4vU291cmNlL1dlYkNvcmUvTW9kdWxlcy9tZWRpYWNvbnRyb2xzIC1J Li4vLi4vU291cmNlL1dlYkNvcmUvTW9kdWxlcy9tZWRpYXNlc3Npb24gLUkuLi8uLi9Tb3VyY2Uv V2ViQ29yZS9Nb2R1bGVzL21lZGlhc291cmNlIC1JLi4vLi4vU291cmNlL1dlYkNvcmUvTW9kdWxl cy9tZWRpYXN0cmVhbSAtSS4uLy4uL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvbmF2aWdhdG9yY29u dGVudHV0aWxzIC1JLi4vLi4vU291cmNlL1dlYkNvcmUvTW9kdWxlcy9ub3RpZmljYXRpb25zIC1J Li4vLi4vU291cmNlL1dlYkNvcmUvTW9kdWxlcy9wYXltZW50cmVxdWVzdCAtSS4uLy4uL1NvdXJj ZS9XZWJDb3JlL01vZHVsZXMvcGx1Z2lucyAtSS4uLy4uL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMv cXVvdGEgLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3NwZWVjaCAtSS4uLy4uL1NvdXJj ZS9XZWJDb3JlL01vZHVsZXMvc3RyZWFtcyAtSS4uLy4uL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMv d2ViYXVkaW8gLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1dGhuIC1JLi4vLi4v U291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJkYXRhYmFzZSAtSS4uLy4uL1NvdXJjZS9XZWJDb3Jl L01vZHVsZXMvd2ViZHJpdmVyIC1JLi4vLi4vU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJzb2Nr ZXRzIC1JLi4vLi4vU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJ2ciAtSS4uLy4uL1NvdXJjZS9X ZWJDb3JlL2FjY2Vzc2liaWxpdHkgLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9hbmltYXRpb24gLUku Li8uLi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncyAtSS4uLy4uL1NvdXJjZS9XZWJDb3JlL2JpbmRp bmdzL2pzIC1JLi4vLi4vU291cmNlL1dlYkNvcmUvYnJpZGdlIC1JLi4vLi4vU291cmNlL1dlYkNv cmUvYnJpZGdlL2MgLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9icmlkZ2UvanNjIC1JLi4vLi4vU291 cmNlL1dlYkNvcmUvY29udGVudGV4dGVuc2lvbnMgLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9jcnlw dG8gLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9jcnlwdG8vYWxnb3JpdGhtcyAtSS4uLy4uL1NvdXJj ZS9XZWJDb3JlL2NyeXB0by9rZXlzIC1JLi4vLi4vU291cmNlL1dlYkNvcmUvY3J5cHRvL3BhcmFt ZXRlcnMgLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9jc3MgLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9j c3MvcGFyc2VyIC1JLi4vLi4vU291cmNlL1dlYkNvcmUvY3Nzaml0IC1JLi4vLi4vU291cmNlL1dl YkNvcmUvZG9tIC1JLi4vLi4vU291cmNlL1dlYkNvcmUvZG9tL2RlZmF1bHQgLUkuLi8uLi9Tb3Vy Y2UvV2ViQ29yZS9kb20vbWVzc2FnZXBvcnRzIC1JLi4vLi4vU291cmNlL1dlYkNvcmUvZG9taml0 IC1JLi4vLi4vU291cmNlL1dlYkNvcmUvZWRpdGluZyAtSS4uLy4uL1NvdXJjZS9XZWJDb3JlL2Zp bGVhcGkgLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9oaXN0b3J5IC1JLi4vLi4vU291cmNlL1dlYkNv cmUvaHRtbCAtSS4uLy4uL1NvdXJjZS9XZWJDb3JlL2h0bWwvY2FudmFzIC1JLi4vLi4vU291cmNl L1dlYkNvcmUvaHRtbC9mb3JtcyAtSS4uLy4uL1NvdXJjZS9XZWJDb3JlL2h0bWwvcGFyc2VyIC1J Li4vLi4vU291cmNlL1dlYkNvcmUvaHRtbC9zaGFkb3cgLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9o dG1sL3RyYWNrIC1JLi4vLi4vU291cmNlL1dlYkNvcmUvaW5zcGVjdG9yIC1JLi4vLi4vU291cmNl L1dlYkNvcmUvaW5zcGVjdG9yL2FnZW50cyAtSS4uLy4uL1NvdXJjZS9XZWJDb3JlL2luc3BlY3Rv ci9hZ2VudHMvcGFnZSAtSS4uLy4uL1NvdXJjZS9XZWJDb3JlL2luc3BlY3Rvci9hZ2VudHMvd29y a2VyIC1JLi4vLi4vU291cmNlL1dlYkNvcmUvbG9hZGVyIC1JLi4vLi4vU291cmNlL1dlYkNvcmUv bG9hZGVyL2FwcGNhY2hlIC1JLi4vLi4vU291cmNlL1dlYkNvcmUvbG9hZGVyL2FyY2hpdmUgLUku Li8uLi9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvYXJjaGl2ZS9taHRtbCAtSS4uLy4uL1NvdXJjZS9X ZWJDb3JlL2xvYWRlci9jYWNoZSAtSS4uLy4uL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9pY29uIC1J Li4vLi4vU291cmNlL1dlYkNvcmUvbWF0aG1sIC1JLi4vLi4vU291cmNlL1dlYkNvcmUvcGFnZSAt SS4uLy4uL1NvdXJjZS9XZWJDb3JlL3BhZ2UvYW5pbWF0aW9uIC1JLi4vLi4vU291cmNlL1dlYkNv cmUvcGFnZS9jc3AgLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9wYWdlL3Njcm9sbGluZyAtSS4uLy4u L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtIC1JLi4vLi4vU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v YW5pbWF0aW9uIC1JLi4vLi4vU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vYXVkaW8gLUkuLi8uLi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9jcnlwdG8gLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9lbmNyeXB0ZWRtZWRpYSAtSS4uLy4uL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dhbWVw YWQgLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcyAtSS4uLy4uL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NwdS9hcm0gLUkuLi8uLi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9jcHUvYXJtL2ZpbHRlcnMgLUkuLi8uLi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9kaXNwbGF5bGlzdHMgLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9maWx0ZXJzIC1JLi4vLi4vU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvaGFyZmJ1enogLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9oYXJmYnV6ei9uZyAtSS4uLy4uL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2lz byAtSS4uLy4uL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL29wZW50eXBlIC1JLi4v Li4vU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvdHJhbnNmb3JtcyAtSS4uLy4uL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL21lZGlhc3RyZWFtIC1JLi4vLi4vU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vbWVkaWFzdHJlYW0vbGlid2VicnRjIC1JLi4vLi4vU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vbW9jayAtSS4uLy4uL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL21vY2svbWVkaWFzb3Vy Y2UgLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrIC1JLi4vLi4vU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vc3FsIC1JLi4vLi4vU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vdGV4 dCAtSS4uLy4uL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL3RleHQvaWN1IC1JLi4vLi4vU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vdnIgLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9wbHVnaW5zIC1JLi4v Li4vU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nIC1JLi4vLi4vU291cmNlL1dlYkNvcmUvcmVuZGVy aW5nL2xpbmUgLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvbWF0aG1sIC1JLi4vLi4v U291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL3NoYXBlcyAtSS4uLy4uL1NvdXJjZS9XZWJDb3JlL3Jl bmRlcmluZy9zdHlsZSAtSS4uLy4uL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9zdmcgLUkuLi8u Li9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvdXBkYXRpbmcgLUkuLi8uLi9Tb3VyY2UvV2ViQ29y ZS9yZXBsYXkgLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9zdG9yYWdlIC1JLi4vLi4vU291cmNlL1dl YkNvcmUvc3R5bGUgLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9zdmcgLUkuLi8uLi9Tb3VyY2UvV2Vi Q29yZS9zdmcvYW5pbWF0aW9uIC1JLi4vLi4vU291cmNlL1dlYkNvcmUvc3ZnL2dyYXBoaWNzIC1J Li4vLi4vU291cmNlL1dlYkNvcmUvc3ZnL2dyYXBoaWNzL2ZpbHRlcnMgLUkuLi8uLi9Tb3VyY2Uv V2ViQ29yZS9zdmcvcHJvcGVydGllcyAtSS4uLy4uL1NvdXJjZS9XZWJDb3JlL3dlYnNvY2tldHMg LUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS93b3JrZXJzIC1JLi4vLi4vU291cmNlL1dlYkNvcmUvd29y a2Vycy9zZXJ2aWNlIC1JLi4vLi4vU291cmNlL1dlYkNvcmUvd29ya2Vycy9zZXJ2aWNlL2NvbnRl eHQgLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS93b3JrZXJzL3NlcnZpY2Uvc2VydmVyIC1JLi4vLi4v U291cmNlL1dlYkNvcmUveG1sIC1JLi4vLi4vU291cmNlL1dlYkNvcmUveG1sL3BhcnNlciAtSURl cml2ZWRTb3VyY2VzL1dlYkNvcmUgLUlEZXJpdmVkU291cmNlcy9Gb3J3YXJkaW5nSGVhZGVycy9B TkdMRSAtSS4uLy4uL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dwdSAtSS4uLy4u L1NvdXJjZS9UaGlyZFBhcnR5L29wZW52ci9oZWFkZXJzIC1JLi4vLi4vU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vdnIvb3BlbnZyIC1JLi4vLi4vU291cmNlL1RoaXJkUGFydHkveGRnbWltZS9zcmMg LUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jYWlybyAtSS4uLy4uL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2ZyZWV0eXBlIC1JLi4vLi4vU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyIC1JLi4vLi4vU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL21zZSAtSS4uLy4uL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9lbWUgLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9hdWRpby9nc3RyZWFtZXIgLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9pbWFn ZS1kZWNvZGVycyAtSS4uLy4uL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2ltYWdlLWRlY29kZXJz L2JtcCAtSS4uLy4uL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2ltYWdlLWRlY29kZXJzL2dpZiAt SS4uLy4uL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2ltYWdlLWRlY29kZXJzL2ljbyAtSS4uLy4u L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2ltYWdlLWRlY29kZXJzL2pwZWcgLUkuLi8uLi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9pbWFnZS1kZWNvZGVycy9wbmcgLUkuLi8uLi9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9pbWFnZS1kZWNvZGVycy93ZWJwIC1JLi4vLi4vU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvdGV4bWFwIC1JLi4vLi4vU291cmNlL1dlYkNvcmUvcGFnZS9zY3Jv bGxpbmcvY29vcmRpbmF0ZWRncmFwaGljcyAtSS4uLy4uL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL3RleG1hcC9jb29yZGluYXRlZCAtSS4uLy4uL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL25pY29zaWEgLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9uaWNvc2lhL2NhaXJvIC1JLi4vLi4vU291cmNlL1RoaXJkUGFydHkvQU5HTEUgLUkuLi8u Li9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9pbmNsdWRlL0tIUiAtSS4uLy4uL1NvdXJjZS9XZWJD b3JlL2FjY2Vzc2liaWxpdHkvYXRrIC1JLi4vLi4vU291cmNlL1dlYkNvcmUvZWRpdGluZy9hdGsg LUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9wYWdlL2d0ayAtSS4uLy4uL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dlb2NsdWUgLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsgLUkuLi8u Li9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9lZ2wgLUkuLi8uLi9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nbHggLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9ndGsgLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9v cGVuZ2wgLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy93YXlsYW5kIC1J Li4vLi4vU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MveDExIC1JLi4vLi4vU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vbWVkaWFzdHJlYW0vZ3RrIC1JLi4vLi4vU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vbmV0d29yay9ndGsgLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3 b3JrL3NvdXAgLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS90ZXh0L2d0ayAtaXN5c3Rl bSAuLi9EZXBlbmRlbmNpZXNHVEsvUm9vdC9pbmNsdWRlL2xpYnhtbDIgLWlzeXN0ZW0gLi4vLi4v U291cmNlL1RoaXJkUGFydHkvbGlid2VicnRjL1NvdXJjZSAtaXN5c3RlbSAuLi8uLi9Tb3VyY2Uv VGhpcmRQYXJ0eS9saWJ3ZWJydGMvU291cmNlL3dlYnJ0YyAtaXN5c3RlbSAuLi9EZXBlbmRlbmNp ZXNHVEsvUm9vdC9pbmNsdWRlL2NhaXJvIC1pc3lzdGVtIC4uL0RlcGVuZGVuY2llc0dUSy9Sb290 L2luY2x1ZGUvZnJlZXR5cGUyL2ZyZWV0eXBlIC1pc3lzdGVtIC4uL0RlcGVuZGVuY2llc0dUSy9S b290L2luY2x1ZGUvZnJlZXR5cGUyIC1pc3lzdGVtIC4uL0RlcGVuZGVuY2llc0dUSy9Sb290L2lu Y2x1ZGUvaGFyZmJ1enogLWlzeXN0ZW0gLi4vRGVwZW5kZW5jaWVzR1RLL1Jvb3QvaW5jbHVkZS9n c3RyZWFtZXItMS4wIC1pc3lzdGVtIC4uL0RlcGVuZGVuY2llc0dUSy9Sb290L2luY2x1ZGUvZ2xp Yi0yLjAgLWlzeXN0ZW0gLi4vRGVwZW5kZW5jaWVzR1RLL1Jvb3QvbGliL2dsaWItMi4wL2luY2x1 ZGUgLWlzeXN0ZW0gLi4vRGVwZW5kZW5jaWVzR1RLL1Jvb3QvbGliL2dzdHJlYW1lci0xLjAvaW5j bHVkZSAtaXN5c3RlbSAvdXNyL2luY2x1ZGUvbGliZHJtIC1pc3lzdGVtIC4uL0RlcGVuZGVuY2ll c0dUSy9Sb290L2luY2x1ZGUvYXRrLTEuMCAtaXN5c3RlbSAvdXNyL2luY2x1ZGUvZW5jaGFudCAt aXN5c3RlbSAuLi9EZXBlbmRlbmNpZXNHVEsvUm9vdC9pbmNsdWRlL2dpby11bml4LTIuMCAtaXN5 c3RlbSAuLi9EZXBlbmRlbmNpZXNHVEsvUm9vdC9pbmNsdWRlL2xpYnNlY3JldC0xIC1pc3lzdGVt IC4uL0RlcGVuZGVuY2llc0dUSy9Sb290L2luY2x1ZGUvbGlic291cC0yLjQgLWlzeXN0ZW0gLi4v RGVwZW5kZW5jaWVzR1RLL1Jvb3QvaW5jbHVkZS9ndGstMy4wIC1pc3lzdGVtIC4uL0RlcGVuZGVu Y2llc0dUSy9Sb290L2luY2x1ZGUvcGFuZ28tMS4wIC1pc3lzdGVtIC4uL0RlcGVuZGVuY2llc0dU Sy9Sb290L2luY2x1ZGUvcGl4bWFuLTEgLWlzeXN0ZW0gL3Vzci9pbmNsdWRlL2xpYnBuZzE2IC1p c3lzdGVtIC4uL0RlcGVuZGVuY2llc0dUSy9Sb290L2luY2x1ZGUvZ2RrLXBpeGJ1Zi0yLjAgLWlz eXN0ZW0gLi4vRGVwZW5kZW5jaWVzR1RLL1Jvb3QvaW5jbHVkZS9hdC1zcGkyLWF0ay8yLjAgLWlz eXN0ZW0gLi4vRGVwZW5kZW5jaWVzR1RLL1Jvb3QvaW5jbHVkZS9hdC1zcGktMi4wIC1pc3lzdGVt IC91c3IvaW5jbHVkZS9kYnVzLTEuMCAtaXN5c3RlbSAvdXNyL2xpYjY0L2RidXMtMS4wL2luY2x1 ZGUgLUkuLi8uLi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9nb2JqZWN0IC1JRGVyaXZlZFNvdXJj ZXMvRm9yd2FyZGluZ0hlYWRlcnMgLUkuLi8uLi9Tb3VyY2UvYm1hbGxvYyAtSURlcml2ZWRTb3Vy Y2VzIC1JLi4vLi4vU291cmNlL1RoaXJkUGFydHkgLWZkaWFnbm9zdGljcy1jb2xvcj1hbHdheXMg LVduby1leHBhbnNpb24tdG8tZGVmaW5lZCAtV25vLWF0dHJpYnV0ZXMgLVduby1ub2V4Y2VwdC10 eXBlIC1Xbm8tbWF5YmUtdW5pbml0aWFsaXplZCAtV3dyaXRlLXN0cmluZ3MgLVd1bmRlZiAtV3Bv aW50ZXItYXJpdGggLVdtaXNzaW5nLWZvcm1hdC1hdHRyaWJ1dGUgLVdmb3JtYXQtc2VjdXJpdHkg LVdjYXN0LWFsaWduIC1XZXh0cmEgLVdhbGwgIC1mbm8tc3RyaWN0LWFsaWFzaW5nIC1mbm8tZXhj ZXB0aW9ucyAtc3RkPWMrKzE3IC1mbm8tcnR0aSAtTzIgLUROREVCVUcgLWZQSUMgLU1EIC1NVCBT b3VyY2UvV2ViQ29yZS9DTWFrZUZpbGVzL1dlYkNvcmVQbGF0Zm9ybUdUSy5kaXIvcmVuZGVyaW5n L1JlbmRlclRoZW1lR3RrLmNwcC5vIC1NRiBTb3VyY2UvV2ViQ29yZS9DTWFrZUZpbGVzL1dlYkNv cmVQbGF0Zm9ybUdUSy5kaXIvcmVuZGVyaW5nL1JlbmRlclRoZW1lR3RrLmNwcC5vLmQgLW8gU291 cmNlL1dlYkNvcmUvQ01ha2VGaWxlcy9XZWJDb3JlUGxhdGZvcm1HVEsuZGlyL3JlbmRlcmluZy9S ZW5kZXJUaGVtZUd0ay5jcHAubyAtYyAuLi8uLi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVu ZGVyVGhlbWVHdGsuY3BwCkluIGZpbGUgaW5jbHVkZWQgZnJvbSBEZXJpdmVkU291cmNlcy9Gb3J3 YXJkaW5nSGVhZGVycy93dGYvVmVjdG9yVHJhaXRzLmg6MjU6MCwKICAgICAgICAgICAgICAgICBm cm9tIERlcml2ZWRTb3VyY2VzL0ZvcndhcmRpbmdIZWFkZXJzL3d0Zi9WZWN0b3IuaDozOCwKICAg ICAgICAgICAgICAgICBmcm9tIC4uLy4uL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L0Rhc2hBcnJheS5oOjI5LAogICAgICAgICAgICAgICAgIGZyb20gLi4vLi4vU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3JhcGhpY3NDb250ZXh0Lmg6MjksCiAgICAgICAgICAgICAg ICAgZnJvbSAuLi8uLi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUGFpbnRJbmZvLmg6MjksCiAg ICAgICAgICAgICAgICAgZnJvbSAuLi8uLi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVy VGhlbWUuaDoyNCwKICAgICAgICAgICAgICAgICBmcm9tIC4uLy4uL1NvdXJjZS9XZWJDb3JlL3Jl bmRlcmluZy9SZW5kZXJUaGVtZUd0ay5oOjMwLAogICAgICAgICAgICAgICAgIGZyb20gLi4vLi4v U291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclRoZW1lR3RrLmNwcDoyNjoKRGVyaXZlZFNv dXJjZXMvRm9yd2FyZGluZ0hlYWRlcnMvd3RmL1JlZlB0ci5oOiBJbiBpbnN0YW50aWF0aW9uIG9m IMOiwoDCmHZvaWQgV1RGOjpyZWZJZk5vdE51bGwoVCopIFt3aXRoIFQgPSBXZWJDb3JlOjpNZWRp YVN0cmVhbV3DosKAwpk6CkRlcml2ZWRTb3VyY2VzL0ZvcndhcmRpbmdIZWFkZXJzL3d0Zi9SZWZQ dHIuaDo1OTo3NDogICByZXF1aXJlZCBmcm9tIMOiwoDCmFdURjo6UmVmUHRyPFQsIDx0ZW1wbGF0 ZS1wYXJhbWV0ZXItMS0yPiA+OjpSZWZQdHIoY29uc3QgV1RGOjpSZWZQdHI8VCwgPHRlbXBsYXRl LXBhcmFtZXRlci0xLTI+ID4mKSBbd2l0aCBUID0gV2ViQ29yZTo6TWVkaWFTdHJlYW07IFB0clRy YWl0cyA9IFdURjo6RHVtYlB0clRyYWl0czxXZWJDb3JlOjpNZWRpYVN0cmVhbT5dw6LCgMKZCkRl cml2ZWRTb3VyY2VzL0ZvcndhcmRpbmdIZWFkZXJzL3d0Zi9WYXJpYW50Lmg6NDE1Ojk6ICAgcmVx dWlyZWQgZnJvbSDDosKAwphzdGF0aWMgY29uc3RleHByIHZvaWQgV1RGOjpfX3N0b3JhZ2Vfd3Jh cHBlcjxfVHlwZT46Ol9fY29uc3RydWN0KHZvaWQqLCBfQXJncyYmIC4uLikgW3dpdGggX0FyZ3Mg PSB7Y29uc3QgV1RGOjpSZWZQdHI8V2ViQ29yZTo6TWVkaWFTdHJlYW0sIFdURjo6RHVtYlB0clRy YWl0czxXZWJDb3JlOjpNZWRpYVN0cmVhbT4gPiZ9OyBfVHlwZSA9IFdURjo6UmVmUHRyPFdlYkNv cmU6Ok1lZGlhU3RyZWFtPl3DosKAwpkKRGVyaXZlZFNvdXJjZXMvRm9yd2FyZGluZ0hlYWRlcnMv d3RmL1ZhcmlhbnQuaDo0MzM6MjA6ICAgcmVxdWlyZWQgZnJvbSDDosKAwphXVEY6Ol9fc3RvcmFn ZV93cmFwcGVyPF9UeXBlPjo6X19zdG9yYWdlX3dyYXBwZXIoX0ZpcnN0JiYsIF9BcmdzJiYgLi4u KSBbd2l0aCBfRmlyc3QgPSBjb25zdCBXVEY6OlJlZlB0cjxXZWJDb3JlOjpNZWRpYVN0cmVhbT4m OyBfQXJncyA9IHt9OyBfVHlwZSA9IFdURjo6UmVmUHRyPFdlYkNvcmU6Ok1lZGlhU3RyZWFtPl3D osKAwpkKRGVyaXZlZFNvdXJjZXMvRm9yd2FyZGluZ0hlYWRlcnMvd3RmL1ZhcmlhbnQuaDo1MzY6 NDU6ICAgcmVxdWlyZWQgZnJvbSDDosKAwphjb25zdGV4cHIgV1RGOjpfX3ZhcmlhbnRfZGF0YTxf VHlwZT46Ol9fdmFyaWFudF9kYXRhKFdURjo6aW5fcGxhY2VfaW5kZXhfdDwwPiwgX0FyZ3MmJiAu Li4pIFt3aXRoIF9BcmdzID0ge2NvbnN0IFdURjo6UmVmUHRyPFdlYkNvcmU6Ok1lZGlhU3RyZWFt LCBXVEY6OkR1bWJQdHJUcmFpdHM8V2ViQ29yZTo6TWVkaWFTdHJlYW0+ID4mfTsgX1R5cGUgPSBX VEY6OlJlZlB0cjxXZWJDb3JlOjpNZWRpYVN0cmVhbT47IFdURjo6aW5fcGxhY2VfaW5kZXhfdDww PiA9IFdURjo6aW5fcGxhY2VfdGFnICgmKShXVEY6Ol9faW5fcGxhY2VfcHJpdmF0ZTo6X192YWx1 ZV9ob2xkZXI8MD4mKV3DosKAwpkKRGVyaXZlZFNvdXJjZXMvRm9yd2FyZGluZ0hlYWRlcnMvd3Rm L1ZhcmlhbnQuaDo2MjM6NTg6ICAgcmVxdWlyZWQgZnJvbSDDosKAwphjb25zdGV4cHIgV1RGOjpf X3ZhcmlhbnRfZGF0YTxfSGVhZCwgX1Jlc3QgLi4uPjo6X192YXJpYW50X2RhdGEoV1RGOjppbl9w bGFjZV9pbmRleF90PDA+LCBfQXJncyYmIC4uLikgW3dpdGggX0FyZ3MgPSB7Y29uc3QgV1RGOjpS ZWZQdHI8V2ViQ29yZTo6TWVkaWFTdHJlYW0sIFdURjo6RHVtYlB0clRyYWl0czxXZWJDb3JlOjpN ZWRpYVN0cmVhbT4gPiZ9OyBfSGVhZCA9IFdURjo6UmVmUHRyPFdlYkNvcmU6Ok1lZGlhU3RyZWFt PjsgX1Jlc3QgPSB7V1RGOjpSZWZQdHI8V2ViQ29yZTo6TWVkaWFTb3VyY2UsIFdURjo6RHVtYlB0 clRyYWl0czxXZWJDb3JlOjpNZWRpYVNvdXJjZT4gPiwgV1RGOjpSZWZQdHI8V2ViQ29yZTo6Qmxv YiwgV1RGOjpEdW1iUHRyVHJhaXRzPFdlYkNvcmU6OkJsb2I+ID59OyBXVEY6OmluX3BsYWNlX2lu ZGV4X3Q8MD4gPSBXVEY6OmluX3BsYWNlX3RhZyAoJikoV1RGOjpfX2luX3BsYWNlX3ByaXZhdGU6 Ol9fdmFsdWVfaG9sZGVyPDA+Jildw6LCgMKZCkRlcml2ZWRTb3VyY2VzL0ZvcndhcmRpbmdIZWFk ZXJzL3d0Zi9WYXJpYW50Lmg6MTQ2Mjo5OiAgIFsgc2tpcHBpbmcgMyBpbnN0YW50aWF0aW9uIGNv bnRleHRzLCB1c2UgLWZ0ZW1wbGF0ZS1iYWNrdHJhY2UtbGltaXQ9MCB0byBkaXNhYmxlIF0KRGVy aXZlZFNvdXJjZXMvRm9yd2FyZGluZ0hlYWRlcnMvd3RmL1ZhcmlhbnQuaDoxNDg3OjUyOiAgIHJl cXVpcmVkIGZyb20gw6LCgMKYcHRyZGlmZl90IFdURjo6VmFyaWFudDwgPHRlbXBsYXRlLXBhcmFt ZXRlci0xLTE+ID46Ol9fY29weV9jb25zdHJ1Y3QoY29uc3QgV1RGOjpWYXJpYW50PCA8dGVtcGxh dGUtcGFyYW1ldGVyLTEtMT4gPiYpIFt3aXRoIF9UeXBlcyA9IHtXVEY6OlJlZlB0cjxXZWJDb3Jl OjpNZWRpYVN0cmVhbSwgV1RGOjpEdW1iUHRyVHJhaXRzPFdlYkNvcmU6Ok1lZGlhU3RyZWFtPiA+ LCBXVEY6OlJlZlB0cjxXZWJDb3JlOjpNZWRpYVNvdXJjZSwgV1RGOjpEdW1iUHRyVHJhaXRzPFdl YkNvcmU6Ok1lZGlhU291cmNlPiA+LCBXVEY6OlJlZlB0cjxXZWJDb3JlOjpCbG9iLCBXVEY6OkR1 bWJQdHJUcmFpdHM8V2ViQ29yZTo6QmxvYj4gPn07IHB0cmRpZmZfdCA9IGxvbmcgaW50XcOiwoDC mQpEZXJpdmVkU291cmNlcy9Gb3J3YXJkaW5nSGVhZGVycy93dGYvVmFyaWFudC5oOjE1NTY6MzM6 ICAgcmVxdWlyZWQgZnJvbSDDosKAwphjb25zdGV4cHIgV1RGOjpWYXJpYW50PCA8dGVtcGxhdGUt cGFyYW1ldGVyLTEtMT4gPjo6VmFyaWFudChjb25zdCB0eXBlbmFtZSBzdGQ6OmNvbmRpdGlvbmFs PFdURjo6X19hbGxfY29weV9jb25zdHJ1Y3RpYmxlPF9UeXBlcyAuLi4+Ojp2YWx1ZSwgV1RGOjpW YXJpYW50PCA8dGVtcGxhdGUtcGFyYW1ldGVyLTEtMT4gPiwgV1RGOjpWYXJpYW50PCA8dGVtcGxh dGUtcGFyYW1ldGVyLTEtMT4gPjo6X19wcml2YXRlX3R5cGU+Ojp0eXBlJikgW3dpdGggX1R5cGVz ID0ge1dURjo6UmVmUHRyPFdlYkNvcmU6Ok1lZGlhU3RyZWFtLCBXVEY6OkR1bWJQdHJUcmFpdHM8 V2ViQ29yZTo6TWVkaWFTdHJlYW0+ID4sIFdURjo6UmVmUHRyPFdlYkNvcmU6Ok1lZGlhU291cmNl LCBXVEY6OkR1bWJQdHJUcmFpdHM8V2ViQ29yZTo6TWVkaWFTb3VyY2U+ID4sIFdURjo6UmVmUHRy PFdlYkNvcmU6OkJsb2IsIFdURjo6RHVtYlB0clRyYWl0czxXZWJDb3JlOjpCbG9iPiA+fTsgdHlw ZW5hbWUgc3RkOjpjb25kaXRpb25hbDxXVEY6Ol9fYWxsX2NvcHlfY29uc3RydWN0aWJsZTxfVHlw ZXMgLi4uPjo6dmFsdWUsIFdURjo6VmFyaWFudDwgPHRlbXBsYXRlLXBhcmFtZXRlci0xLTE+ID4s IFdURjo6VmFyaWFudDwgPHRlbXBsYXRlLXBhcmFtZXRlci0xLTE+ID46Ol9fcHJpdmF0ZV90eXBl Pjo6dHlwZSA9IFdURjo6VmFyaWFudDxXVEY6OlJlZlB0cjxXZWJDb3JlOjpNZWRpYVN0cmVhbSwg V1RGOjpEdW1iUHRyVHJhaXRzPFdlYkNvcmU6Ok1lZGlhU3RyZWFtPiA+LCBXVEY6OlJlZlB0cjxX ZWJDb3JlOjpNZWRpYVNvdXJjZSwgV1RGOjpEdW1iUHRyVHJhaXRzPFdlYkNvcmU6Ok1lZGlhU291 cmNlPiA+LCBXVEY6OlJlZlB0cjxXZWJDb3JlOjpCbG9iLCBXVEY6OkR1bWJQdHJUcmFpdHM8V2Vi Q29yZTo6QmxvYj4gPiA+XcOiwoDCmQovdXNyL2luY2x1ZGUvYysrLzcvdHlwZV90cmFpdHM6MTQw NjoxMjogICByZXF1aXJlZCBmcm9tIMOiwoDCmHN0cnVjdCBzdGQ6OmlzX3RyaXZpYWxseV9jb3B5 X2NvbnN0cnVjdGlibGU8V1RGOjpWYXJpYW50PFdURjo6UmVmUHRyPFdlYkNvcmU6Ok1lZGlhU3Ry ZWFtLCBXVEY6OkR1bWJQdHJUcmFpdHM8V2ViQ29yZTo6TWVkaWFTdHJlYW0+ID4sIFdURjo6UmVm UHRyPFdlYkNvcmU6Ok1lZGlhU291cmNlLCBXVEY6OkR1bWJQdHJUcmFpdHM8V2ViQ29yZTo6TWVk aWFTb3VyY2U+ID4sIFdURjo6UmVmUHRyPFdlYkNvcmU6OkJsb2IsIFdURjo6RHVtYlB0clRyYWl0 czxXZWJDb3JlOjpCbG9iPiA+ID4gPsOiwoDCmQovdXNyL2luY2x1ZGUvYysrLzcvb3B0aW9uYWw6 MTA1Ojg6ICAgcmVxdWlyZWQgZnJvbSDDosKAwphjbGFzcyBzdGQ6Ol9PcHRpb25hbF9iYXNlPFdU Rjo6VmFyaWFudDxXVEY6OlJlZlB0cjxXZWJDb3JlOjpNZWRpYVN0cmVhbSwgV1RGOjpEdW1iUHRy VHJhaXRzPFdlYkNvcmU6Ok1lZGlhU3RyZWFtPiA+LCBXVEY6OlJlZlB0cjxXZWJDb3JlOjpNZWRp YVNvdXJjZSwgV1RGOjpEdW1iUHRyVHJhaXRzPFdlYkNvcmU6Ok1lZGlhU291cmNlPiA+LCBXVEY6 OlJlZlB0cjxXZWJDb3JlOjpCbG9iLCBXVEY6OkR1bWJQdHJUcmFpdHM8V2ViQ29yZTo6QmxvYj4g PiA+ID7DosKAwpkKL3Vzci9pbmNsdWRlL2MrKy83L29wdGlvbmFsOjQ1MzoxMTogICByZXF1aXJl ZCBmcm9tIMOiwoDCmGNsYXNzIHN0ZDo6b3B0aW9uYWw8V1RGOjpWYXJpYW50PFdURjo6UmVmUHRy PFdlYkNvcmU6Ok1lZGlhU3RyZWFtLCBXVEY6OkR1bWJQdHJUcmFpdHM8V2ViQ29yZTo6TWVkaWFT dHJlYW0+ID4sIFdURjo6UmVmUHRyPFdlYkNvcmU6Ok1lZGlhU291cmNlLCBXVEY6OkR1bWJQdHJU cmFpdHM8V2ViQ29yZTo6TWVkaWFTb3VyY2U+ID4sIFdURjo6UmVmUHRyPFdlYkNvcmU6OkJsb2Is IFdURjo6RHVtYlB0clRyYWl0czxXZWJDb3JlOjpCbG9iPiA+ID4gPsOiwoDCmQouLi8uLi9Tb3Vy Y2UvV2ViQ29yZS9odG1sL0hUTUxNZWRpYUVsZW1lbnQuaDoxMTI0OjE5OiAgIHJlcXVpcmVkIGZy b20gaGVyZQpEZXJpdmVkU291cmNlcy9Gb3J3YXJkaW5nSGVhZGVycy93dGYvUmVmUHRyLmg6Mzk6 MTQ6IGVycm9yOiBpbnZhbGlkIHVzZSBvZiBpbmNvbXBsZXRlIHR5cGUgw6LCgMKYY2xhc3MgV2Vi Q29yZTo6TWVkaWFTdHJlYW3DosKAwpkKICAgICAgICAgcHRyLT5yZWYoKTsKICAgICAgICAgfn5+ fn5efn4KSW4gZmlsZSBpbmNsdWRlZCBmcm9tIC4uLy4uL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmlu Zy9SZW5kZXJUaGVtZUd0ay5jcHA6Mzk6MDoKLi4vLi4vU291cmNlL1dlYkNvcmUvaHRtbC9IVE1M TWVkaWFFbGVtZW50Lmg6OTQ6Nzogbm90ZTogZm9yd2FyZCBkZWNsYXJhdGlvbiBvZiDDosKAwphj bGFzcyBXZWJDb3JlOjpNZWRpYVN0cmVhbcOiwoDCmQogY2xhc3MgTWVkaWFTdHJlYW07CiAgICAg ICBefn5+fn5+fn5+fgpJbiBmaWxlIGluY2x1ZGVkIGZyb20gRGVyaXZlZFNvdXJjZXMvRm9yd2Fy ZGluZ0hlYWRlcnMvd3RmL1ZlY3RvclRyYWl0cy5oOjI1OjAsCiAgICAgICAgICAgICAgICAgZnJv bSBEZXJpdmVkU291cmNlcy9Gb3J3YXJkaW5nSGVhZGVycy93dGYvVmVjdG9yLmg6MzgsCiAgICAg ICAgICAgICAgICAgZnJvbSAuLi8uLi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9E YXNoQXJyYXkuaDoyOSwKICAgICAgICAgICAgICAgICBmcm9tIC4uLy4uL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL0dyYXBoaWNzQ29udGV4dC5oOjI5LAogICAgICAgICAgICAgICAg IGZyb20gLi4vLi4vU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1BhaW50SW5mby5oOjI5LAogICAg ICAgICAgICAgICAgIGZyb20gLi4vLi4vU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclRo ZW1lLmg6MjQsCiAgICAgICAgICAgICAgICAgZnJvbSAuLi8uLi9Tb3VyY2UvV2ViQ29yZS9yZW5k ZXJpbmcvUmVuZGVyVGhlbWVHdGsuaDozMCwKICAgICAgICAgICAgICAgICBmcm9tIC4uLy4uL1Nv dXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJUaGVtZUd0ay5jcHA6MjY6CkRlcml2ZWRTb3Vy Y2VzL0ZvcndhcmRpbmdIZWFkZXJzL3d0Zi9SZWZQdHIuaDogSW4gaW5zdGFudGlhdGlvbiBvZiDD osKAwph2b2lkIFdURjo6cmVmSWZOb3ROdWxsKFQqKSBbd2l0aCBUID0gV2ViQ29yZTo6TWVkaWFT b3VyY2Vdw6LCgMKZOgpEZXJpdmVkU291cmNlcy9Gb3J3YXJkaW5nSGVhZGVycy93dGYvUmVmUHRy Lmg6NTk6NzQ6ICAgcmVxdWlyZWQgZnJvbSDDosKAwphXVEY6OlJlZlB0cjxULCA8dGVtcGxhdGUt cGFyYW1ldGVyLTEtMj4gPjo6UmVmUHRyKGNvbnN0IFdURjo6UmVmUHRyPFQsIDx0ZW1wbGF0ZS1w YXJhbWV0ZXItMS0yPiA+JikgW3dpdGggVCA9IFdlYkNvcmU6Ok1lZGlhU291cmNlOyBQdHJUcmFp dHMgPSBXVEY6OkR1bWJQdHJUcmFpdHM8V2ViQ29yZTo6TWVkaWFTb3VyY2U+XcOiwoDCmQpEZXJp dmVkU291cmNlcy9Gb3J3YXJkaW5nSGVhZGVycy93dGYvVmFyaWFudC5oOjQxNTo5OiAgIHJlcXVp cmVkIGZyb20gw6LCgMKYc3RhdGljIGNvbnN0ZXhwciB2b2lkIFdURjo6X19zdG9yYWdlX3dyYXBw ZXI8X1R5cGU+OjpfX2NvbnN0cnVjdCh2b2lkKiwgX0FyZ3MmJiAuLi4pIFt3aXRoIF9BcmdzID0g e2NvbnN0IFdURjo6UmVmUHRyPFdlYkNvcmU6Ok1lZGlhU291cmNlLCBXVEY6OkR1bWJQdHJUcmFp dHM8V2ViQ29yZTo6TWVkaWFTb3VyY2U+ID4mfTsgX1R5cGUgPSBXVEY6OlJlZlB0cjxXZWJDb3Jl OjpNZWRpYVNvdXJjZT5dw6LCgMKZCkRlcml2ZWRTb3VyY2VzL0ZvcndhcmRpbmdIZWFkZXJzL3d0 Zi9WYXJpYW50Lmg6NDMzOjIwOiAgIHJlcXVpcmVkIGZyb20gw6LCgMKYV1RGOjpfX3N0b3JhZ2Vf d3JhcHBlcjxfVHlwZT46Ol9fc3RvcmFnZV93cmFwcGVyKF9GaXJzdCYmLCBfQXJncyYmIC4uLikg W3dpdGggX0ZpcnN0ID0gY29uc3QgV1RGOjpSZWZQdHI8V2ViQ29yZTo6TWVkaWFTb3VyY2U+Jjsg X0FyZ3MgPSB7fTsgX1R5cGUgPSBXVEY6OlJlZlB0cjxXZWJDb3JlOjpNZWRpYVNvdXJjZT5dw6LC gMKZCkRlcml2ZWRTb3VyY2VzL0ZvcndhcmRpbmdIZWFkZXJzL3d0Zi9WYXJpYW50Lmg6NTM2OjQ1 OiAgIHJlcXVpcmVkIGZyb20gw6LCgMKYY29uc3RleHByIFdURjo6X192YXJpYW50X2RhdGE8X1R5 cGU+OjpfX3ZhcmlhbnRfZGF0YShXVEY6OmluX3BsYWNlX2luZGV4X3Q8MD4sIF9BcmdzJiYgLi4u KSBbd2l0aCBfQXJncyA9IHtjb25zdCBXVEY6OlJlZlB0cjxXZWJDb3JlOjpNZWRpYVNvdXJjZSwg V1RGOjpEdW1iUHRyVHJhaXRzPFdlYkNvcmU6Ok1lZGlhU291cmNlPiA+Jn07IF9UeXBlID0gV1RG OjpSZWZQdHI8V2ViQ29yZTo6TWVkaWFTb3VyY2U+OyBXVEY6OmluX3BsYWNlX2luZGV4X3Q8MD4g PSBXVEY6OmluX3BsYWNlX3RhZyAoJikoV1RGOjpfX2luX3BsYWNlX3ByaXZhdGU6Ol9fdmFsdWVf aG9sZGVyPDA+Jildw6LCgMKZCkRlcml2ZWRTb3VyY2VzL0ZvcndhcmRpbmdIZWFkZXJzL3d0Zi9W YXJpYW50Lmg6NjIzOjU4OiAgIHJlcXVpcmVkIGZyb20gw6LCgMKYY29uc3RleHByIFdURjo6X192 YXJpYW50X2RhdGE8X0hlYWQsIF9SZXN0IC4uLj46Ol9fdmFyaWFudF9kYXRhKFdURjo6aW5fcGxh Y2VfaW5kZXhfdDwwPiwgX0FyZ3MmJiAuLi4pIFt3aXRoIF9BcmdzID0ge2NvbnN0IFdURjo6UmVm UHRyPFdlYkNvcmU6Ok1lZGlhU291cmNlLCBXVEY6OkR1bWJQdHJUcmFpdHM8V2ViQ29yZTo6TWVk aWFTb3VyY2U+ID4mfTsgX0hlYWQgPSBXVEY6OlJlZlB0cjxXZWJDb3JlOjpNZWRpYVNvdXJjZT47 IF9SZXN0ID0ge1dURjo6UmVmUHRyPFdlYkNvcmU6OkJsb2IsIFdURjo6RHVtYlB0clRyYWl0czxX ZWJDb3JlOjpCbG9iPiA+fTsgV1RGOjppbl9wbGFjZV9pbmRleF90PDA+ID0gV1RGOjppbl9wbGFj ZV90YWcgKCYpKFdURjo6X19pbl9wbGFjZV9wcml2YXRlOjpfX3ZhbHVlX2hvbGRlcjwwPiYpXcOi woDCmQpEZXJpdmVkU291cmNlcy9Gb3J3YXJkaW5nSGVhZGVycy93dGYvVmFyaWFudC5oOjYyNjo2 NTogICBbIHNraXBwaW5nIDQgaW5zdGFudGlhdGlvbiBjb250ZXh0cywgdXNlIC1mdGVtcGxhdGUt YmFja3RyYWNlLWxpbWl0PTAgdG8gZGlzYWJsZSBdCkRlcml2ZWRTb3VyY2VzL0ZvcndhcmRpbmdI ZWFkZXJzL3d0Zi9WYXJpYW50Lmg6MTQ4Nzo1MjogICByZXF1aXJlZCBmcm9tIMOiwoDCmHB0cmRp ZmZfdCBXVEY6OlZhcmlhbnQ8IDx0ZW1wbGF0ZS1wYXJhbWV0ZXItMS0xPiA+OjpfX2NvcHlfY29u c3RydWN0KGNvbnN0IFdURjo6VmFyaWFudDwgPHRlbXBsYXRlLXBhcmFtZXRlci0xLTE+ID4mKSBb d2l0aCBfVHlwZXMgPSB7V1RGOjpSZWZQdHI8V2ViQ29yZTo6TWVkaWFTdHJlYW0sIFdURjo6RHVt YlB0clRyYWl0czxXZWJDb3JlOjpNZWRpYVN0cmVhbT4gPiwgV1RGOjpSZWZQdHI8V2ViQ29yZTo6 TWVkaWFTb3VyY2UsIFdURjo6RHVtYlB0clRyYWl0czxXZWJDb3JlOjpNZWRpYVNvdXJjZT4gPiwg V1RGOjpSZWZQdHI8V2ViQ29yZTo6QmxvYiwgV1RGOjpEdW1iUHRyVHJhaXRzPFdlYkNvcmU6OkJs b2I+ID59OyBwdHJkaWZmX3QgPSBsb25nIGludF3DosKAwpkKRGVyaXZlZFNvdXJjZXMvRm9yd2Fy ZGluZ0hlYWRlcnMvd3RmL1ZhcmlhbnQuaDoxNTU2OjMzOiAgIHJlcXVpcmVkIGZyb20gw6LCgMKY Y29uc3RleHByIFdURjo6VmFyaWFudDwgPHRlbXBsYXRlLXBhcmFtZXRlci0xLTE+ID46OlZhcmlh bnQoY29uc3QgdHlwZW5hbWUgc3RkOjpjb25kaXRpb25hbDxXVEY6Ol9fYWxsX2NvcHlfY29uc3Ry dWN0aWJsZTxfVHlwZXMgLi4uPjo6dmFsdWUsIFdURjo6VmFyaWFudDwgPHRlbXBsYXRlLXBhcmFt ZXRlci0xLTE+ID4sIFdURjo6VmFyaWFudDwgPHRlbXBsYXRlLXBhcmFtZXRlci0xLTE+ID46Ol9f cHJpdmF0ZV90eXBlPjo6dHlwZSYpIFt3aXRoIF9UeXBlcyA9IHtXVEY6OlJlZlB0cjxXZWJDb3Jl OjpNZWRpYVN0cmVhbSwgV1RGOjpEdW1iUHRyVHJhaXRzPFdlYkNvcmU6Ok1lZGlhU3RyZWFtPiA+ LCBXVEY6OlJlZlB0cjxXZWJDb3JlOjpNZWRpYVNvdXJjZSwgV1RGOjpEdW1iUHRyVHJhaXRzPFdl YkNvcmU6Ok1lZGlhU291cmNlPiA+LCBXVEY6OlJlZlB0cjxXZWJDb3JlOjpCbG9iLCBXVEY6OkR1 bWJQdHJUcmFpdHM8V2ViQ29yZTo6QmxvYj4gPn07IHR5cGVuYW1lIHN0ZDo6Y29uZGl0aW9uYWw8 V1RGOjpfX2FsbF9jb3B5X2NvbnN0cnVjdGlibGU8X1R5cGVzIC4uLj46OnZhbHVlLCBXVEY6OlZh cmlhbnQ8IDx0ZW1wbGF0ZS1wYXJhbWV0ZXItMS0xPiA+LCBXVEY6OlZhcmlhbnQ8IDx0ZW1wbGF0 ZS1wYXJhbWV0ZXItMS0xPiA+OjpfX3ByaXZhdGVfdHlwZT46OnR5cGUgPSBXVEY6OlZhcmlhbnQ8 V1RGOjpSZWZQdHI8V2ViQ29yZTo6TWVkaWFTdHJlYW0sIFdURjo6RHVtYlB0clRyYWl0czxXZWJD b3JlOjpNZWRpYVN0cmVhbT4gPiwgV1RGOjpSZWZQdHI8V2ViQ29yZTo6TWVkaWFTb3VyY2UsIFdU Rjo6RHVtYlB0clRyYWl0czxXZWJDb3JlOjpNZWRpYVNvdXJjZT4gPiwgV1RGOjpSZWZQdHI8V2Vi Q29yZTo6QmxvYiwgV1RGOjpEdW1iUHRyVHJhaXRzPFdlYkNvcmU6OkJsb2I+ID4gPl3DosKAwpkK L3Vzci9pbmNsdWRlL2MrKy83L3R5cGVfdHJhaXRzOjE0MDY6MTI6ICAgcmVxdWlyZWQgZnJvbSDD osKAwphzdHJ1Y3Qgc3RkOjppc190cml2aWFsbHlfY29weV9jb25zdHJ1Y3RpYmxlPFdURjo6VmFy aWFudDxXVEY6OlJlZlB0cjxXZWJDb3JlOjpNZWRpYVN0cmVhbSwgV1RGOjpEdW1iUHRyVHJhaXRz PFdlYkNvcmU6Ok1lZGlhU3RyZWFtPiA+LCBXVEY6OlJlZlB0cjxXZWJDb3JlOjpNZWRpYVNvdXJj ZSwgV1RGOjpEdW1iUHRyVHJhaXRzPFdlYkNvcmU6Ok1lZGlhU291cmNlPiA+LCBXVEY6OlJlZlB0 cjxXZWJDb3JlOjpCbG9iLCBXVEY6OkR1bWJQdHJUcmFpdHM8V2ViQ29yZTo6QmxvYj4gPiA+ID7D osKAwpkKL3Vzci9pbmNsdWRlL2MrKy83L29wdGlvbmFsOjEwNTo4OiAgIHJlcXVpcmVkIGZyb20g w6LCgMKYY2xhc3Mgc3RkOjpfT3B0aW9uYWxfYmFzZTxXVEY6OlZhcmlhbnQ8V1RGOjpSZWZQdHI8 V2ViQ29yZTo6TWVkaWFTdHJlYW0sIFdURjo6RHVtYlB0clRyYWl0czxXZWJDb3JlOjpNZWRpYVN0 cmVhbT4gPiwgV1RGOjpSZWZQdHI8V2ViQ29yZTo6TWVkaWFTb3VyY2UsIFdURjo6RHVtYlB0clRy YWl0czxXZWJDb3JlOjpNZWRpYVNvdXJjZT4gPiwgV1RGOjpSZWZQdHI8V2ViQ29yZTo6QmxvYiwg V1RGOjpEdW1iUHRyVHJhaXRzPFdlYkNvcmU6OkJsb2I+ID4gPiA+w6LCgMKZCi91c3IvaW5jbHVk ZS9jKysvNy9vcHRpb25hbDo0NTM6MTE6ICAgcmVxdWlyZWQgZnJvbSDDosKAwphjbGFzcyBzdGQ6 Om9wdGlvbmFsPFdURjo6VmFyaWFudDxXVEY6OlJlZlB0cjxXZWJDb3JlOjpNZWRpYVN0cmVhbSwg V1RGOjpEdW1iUHRyVHJhaXRzPFdlYkNvcmU6Ok1lZGlhU3RyZWFtPiA+LCBXVEY6OlJlZlB0cjxX ZWJDb3JlOjpNZWRpYVNvdXJjZSwgV1RGOjpEdW1iUHRyVHJhaXRzPFdlYkNvcmU6Ok1lZGlhU291 cmNlPiA+LCBXVEY6OlJlZlB0cjxXZWJDb3JlOjpCbG9iLCBXVEY6OkR1bWJQdHJUcmFpdHM8V2Vi Q29yZTo6QmxvYj4gPiA+ID7DosKAwpkKLi4vLi4vU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MTWVk aWFFbGVtZW50Lmg6MTEyNDoxOTogICByZXF1aXJlZCBmcm9tIGhlcmUKRGVyaXZlZFNvdXJjZXMv Rm9yd2FyZGluZ0hlYWRlcnMvd3RmL1JlZlB0ci5oOjM5OjE0OiBlcnJvcjogaW52YWxpZCB1c2Ug b2YgaW5jb21wbGV0ZSB0eXBlIMOiwoDCmGNsYXNzIFdlYkNvcmU6Ok1lZGlhU291cmNlw6LCgMKZ CiAgICAgICAgIHB0ci0+cmVmKCk7CiAgICAgICAgIH5+fn5+Xn5+CkluIGZpbGUgaW5jbHVkZWQg ZnJvbSAuLi8uLi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVGhlbWVHdGsuY3BwOjM5 OjA6Ci4uLy4uL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTE1lZGlhRWxlbWVudC5oOjkzOjc6IG5v dGU6IGZvcndhcmQgZGVjbGFyYXRpb24gb2Ygw6LCgMKYY2xhc3MgV2ViQ29yZTo6TWVkaWFTb3Vy Y2XDosKAwpkKIGNsYXNzIE1lZGlhU291cmNlOwogICAgICAgXn5+fn5+fn5+fn4KSW4gZmlsZSBp bmNsdWRlZCBmcm9tIERlcml2ZWRTb3VyY2VzL0ZvcndhcmRpbmdIZWFkZXJzL3d0Zi9WZWN0b3JU cmFpdHMuaDoyNTowLAogICAgICAgICAgICAgICAgIGZyb20gRGVyaXZlZFNvdXJjZXMvRm9yd2Fy ZGluZ0hlYWRlcnMvd3RmL1ZlY3Rvci5oOjM4LAogICAgICAgICAgICAgICAgIGZyb20gLi4vLi4v U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvRGFzaEFycmF5Lmg6MjksCiAgICAgICAg ICAgICAgICAgZnJvbSAuLi8uLi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFw aGljc0NvbnRleHQuaDoyOSwKICAgICAgICAgICAgICAgICBmcm9tIC4uLy4uL1NvdXJjZS9XZWJD b3JlL3JlbmRlcmluZy9QYWludEluZm8uaDoyOSwKICAgICAgICAgICAgICAgICBmcm9tIC4uLy4u L1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJUaGVtZS5oOjI0LAogICAgICAgICAgICAg ICAgIGZyb20gLi4vLi4vU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclRoZW1lR3RrLmg6 MzAsCiAgICAgICAgICAgICAgICAgZnJvbSAuLi8uLi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcv UmVuZGVyVGhlbWVHdGsuY3BwOjI2OgpEZXJpdmVkU291cmNlcy9Gb3J3YXJkaW5nSGVhZGVycy93 dGYvUmVmUHRyLmg6IEluIGluc3RhbnRpYXRpb24gb2Ygw6LCgMKYdm9pZCBXVEY6OmRlcmVmSWZO b3ROdWxsKFQqKSBbd2l0aCBUID0gV2ViQ29yZTo6TWVkaWFTdHJlYW1dw6LCgMKZOgpEZXJpdmVk U291cmNlcy9Gb3J3YXJkaW5nSGVhZGVycy93dGYvUmVmUHRyLmg6NzA6NDU6ICAgcmVxdWlyZWQg ZnJvbSDDosKAwphXVEY6OlJlZlB0cjxULCA8dGVtcGxhdGUtcGFyYW1ldGVyLTEtMj4gPjo6flJl ZlB0cigpIFt3aXRoIFQgPSBXZWJDb3JlOjpNZWRpYVN0cmVhbTsgUHRyVHJhaXRzID0gV1RGOjpE dW1iUHRyVHJhaXRzPFdlYkNvcmU6Ok1lZGlhU3RyZWFtPl3DosKAwpkKRGVyaXZlZFNvdXJjZXMv Rm9yd2FyZGluZ0hlYWRlcnMvd3RmL1ZhcmlhbnQuaDo0NDM6OTogICByZXF1aXJlZCBmcm9tIMOi woDCmHZvaWQgV1RGOjpfX3N0b3JhZ2Vfd3JhcHBlcjxfVHlwZT46Ol9fZGVzdHJveSgpIFt3aXRo IF9UeXBlID0gV1RGOjpSZWZQdHI8V2ViQ29yZTo6TWVkaWFTdHJlYW0+XcOiwoDCmQpEZXJpdmVk U291cmNlcy9Gb3J3YXJkaW5nSGVhZGVycy93dGYvVmFyaWFudC5oOjQ4MDo5OiAgIHJlcXVpcmVk IGZyb20gw6LCgMKYc3RhdGljIHZvaWQgV1RGOjpfX3ZhcmlhbnRfc3RvcmFnZTxfVHlwZSwgZmFs c2U+OjpfX2Rlc3Ryb3koV1RGOjpfX3ZhcmlhbnRfc3RvcmFnZTxfVHlwZSwgZmFsc2U+OjpfX3R5 cGUmKSBbd2l0aCBfVHlwZSA9IFdURjo6UmVmUHRyPFdlYkNvcmU6Ok1lZGlhU3RyZWFtPjsgV1RG OjpfX3ZhcmlhbnRfc3RvcmFnZTxfVHlwZSwgZmFsc2U+OjpfX3R5cGUgPSBXVEY6Ol9fc3RvcmFn ZV93cmFwcGVyPFdURjo6UmVmUHRyPFdlYkNvcmU6Ok1lZGlhU3RyZWFtPiA+XcOiwoDCmQpEZXJp dmVkU291cmNlcy9Gb3J3YXJkaW5nSGVhZGVycy93dGYvVmFyaWFudC5oOjU1MTo0NDogICByZXF1 aXJlZCBmcm9tIMOiwoDCmHZvaWQgV1RGOjpfX3ZhcmlhbnRfZGF0YTxfVHlwZT46Ol9fZGVzdHJv eShXVEY6OmluX3BsYWNlX2luZGV4X3Q8MD4pIFt3aXRoIF9UeXBlID0gV1RGOjpSZWZQdHI8V2Vi Q29yZTo6TWVkaWFTdHJlYW0+OyBXVEY6OmluX3BsYWNlX2luZGV4X3Q8MD4gPSBXVEY6OmluX3Bs YWNlX3RhZyAoJikoV1RGOjpfX2luX3BsYWNlX3ByaXZhdGU6Ol9fdmFsdWVfaG9sZGVyPDA+Jild w6LCgMKZCkRlcml2ZWRTb3VyY2VzL0ZvcndhcmRpbmdIZWFkZXJzL3d0Zi9WYXJpYW50Lmg6Njcw Ojk6ICAgcmVxdWlyZWQgZnJvbSDDosKAwph2b2lkIFdURjo6X192YXJpYW50X2RhdGE8X0hlYWQs IF9SZXN0IC4uLj46Ol9fZGVzdHJveShXVEY6OmluX3BsYWNlX2luZGV4X3Q8MD4pIFt3aXRoIF9I ZWFkID0gV1RGOjpSZWZQdHI8V2ViQ29yZTo6TWVkaWFTdHJlYW0+OyBfUmVzdCA9IHtXVEY6OlJl ZlB0cjxXZWJDb3JlOjpNZWRpYVNvdXJjZSwgV1RGOjpEdW1iUHRyVHJhaXRzPFdlYkNvcmU6Ok1l ZGlhU291cmNlPiA+LCBXVEY6OlJlZlB0cjxXZWJDb3JlOjpCbG9iLCBXVEY6OkR1bWJQdHJUcmFp dHM8V2ViQ29yZTo6QmxvYj4gPn07IFdURjo6aW5fcGxhY2VfaW5kZXhfdDwwPiA9IFdURjo6aW5f cGxhY2VfdGFnICgmKShXVEY6Ol9faW5fcGxhY2VfcHJpdmF0ZTo6X192YWx1ZV9ob2xkZXI8MD4m KV3DosKAwpkKRGVyaXZlZFNvdXJjZXMvRm9yd2FyZGluZ0hlYWRlcnMvd3RmL1ZhcmlhbnQuaDo4 MjU6MTM6ICAgWyBza2lwcGluZyAyIGluc3RhbnRpYXRpb24gY29udGV4dHMsIHVzZSAtZnRlbXBs YXRlLWJhY2t0cmFjZS1saW1pdD0wIHRvIGRpc2FibGUgXQpEZXJpdmVkU291cmNlcy9Gb3J3YXJk aW5nSGVhZGVycy93dGYvVmFyaWFudC5oOjE0NzA6NDU6ICAgcmVxdWlyZWQgZnJvbSDDosKAwph2 b2lkIFdURjo6VmFyaWFudDwgPHRlbXBsYXRlLXBhcmFtZXRlci0xLTE+ID46Ol9fZGVzdHJveV9z ZWxmKCkgW3dpdGggX1R5cGVzID0ge1dURjo6UmVmUHRyPFdlYkNvcmU6Ok1lZGlhU3RyZWFtLCBX VEY6OkR1bWJQdHJUcmFpdHM8V2ViQ29yZTo6TWVkaWFTdHJlYW0+ID4sIFdURjo6UmVmUHRyPFdl YkNvcmU6Ok1lZGlhU291cmNlLCBXVEY6OkR1bWJQdHJUcmFpdHM8V2ViQ29yZTo6TWVkaWFTb3Vy Y2U+ID4sIFdURjo6UmVmUHRyPFdlYkNvcmU6OkJsb2IsIFdURjo6RHVtYlB0clRyYWl0czxXZWJD b3JlOjpCbG9iPiA+fV3DosKAwpkKRGVyaXZlZFNvdXJjZXMvRm9yd2FyZGluZ0hlYWRlcnMvd3Rm L1ZhcmlhbnQuaDo5MjI6OTogICByZXF1aXJlZCBmcm9tIMOiwoDCmFdURjo6X192YXJpYW50X2Jh c2U8X0Rlcml2ZWQsIF9fdHJpdmlhbF9kZXN0cnVjdG9yPjo6fl9fdmFyaWFudF9iYXNlKCkgW3dp dGggX0Rlcml2ZWQgPSBXVEY6OlZhcmlhbnQ8V1RGOjpSZWZQdHI8V2ViQ29yZTo6TWVkaWFTdHJl YW0sIFdURjo6RHVtYlB0clRyYWl0czxXZWJDb3JlOjpNZWRpYVN0cmVhbT4gPiwgV1RGOjpSZWZQ dHI8V2ViQ29yZTo6TWVkaWFTb3VyY2UsIFdURjo6RHVtYlB0clRyYWl0czxXZWJDb3JlOjpNZWRp YVNvdXJjZT4gPiwgV1RGOjpSZWZQdHI8V2ViQ29yZTo6QmxvYiwgV1RGOjpEdW1iUHRyVHJhaXRz PFdlYkNvcmU6OkJsb2I+ID4gPjsgYm9vbCBfX3RyaXZpYWxfZGVzdHJ1Y3RvciA9IGZhbHNlXcOi woDCmQpEZXJpdmVkU291cmNlcy9Gb3J3YXJkaW5nSGVhZGVycy93dGYvVmFyaWFudC5oOjE0Mzk6 NzogICByZXF1aXJlZCBmcm9tIMOiwoDCmHN0cnVjdCBzdGQ6OmlzX3RyaXZpYWxseV9jb3B5X2Nv bnN0cnVjdGlibGU8V1RGOjpWYXJpYW50PFdURjo6UmVmUHRyPFdlYkNvcmU6Ok1lZGlhU3RyZWFt LCBXVEY6OkR1bWJQdHJUcmFpdHM8V2ViQ29yZTo6TWVkaWFTdHJlYW0+ID4sIFdURjo6UmVmUHRy PFdlYkNvcmU6Ok1lZGlhU291cmNlLCBXVEY6OkR1bWJQdHJUcmFpdHM8V2ViQ29yZTo6TWVkaWFT b3VyY2U+ID4sIFdURjo6UmVmUHRyPFdlYkNvcmU6OkJsb2IsIFdURjo6RHVtYlB0clRyYWl0czxX ZWJDb3JlOjpCbG9iPiA+ID4gPsOiwoDCmQovdXNyL2luY2x1ZGUvYysrLzcvb3B0aW9uYWw6MTA1 Ojg6ICAgcmVxdWlyZWQgZnJvbSDDosKAwphjbGFzcyBzdGQ6Ol9PcHRpb25hbF9iYXNlPFdURjo6 VmFyaWFudDxXVEY6OlJlZlB0cjxXZWJDb3JlOjpNZWRpYVN0cmVhbSwgV1RGOjpEdW1iUHRyVHJh aXRzPFdlYkNvcmU6Ok1lZGlhU3RyZWFtPiA+LCBXVEY6OlJlZlB0cjxXZWJDb3JlOjpNZWRpYVNv dXJjZSwgV1RGOjpEdW1iUHRyVHJhaXRzPFdlYkNvcmU6Ok1lZGlhU291cmNlPiA+LCBXVEY6OlJl ZlB0cjxXZWJDb3JlOjpCbG9iLCBXVEY6OkR1bWJQdHJUcmFpdHM8V2ViQ29yZTo6QmxvYj4gPiA+ ID7DosKAwpkKL3Vzci9pbmNsdWRlL2MrKy83L29wdGlvbmFsOjQ1MzoxMTogICByZXF1aXJlZCBm cm9tIMOiwoDCmGNsYXNzIHN0ZDo6b3B0aW9uYWw8V1RGOjpWYXJpYW50PFdURjo6UmVmUHRyPFdl YkNvcmU6Ok1lZGlhU3RyZWFtLCBXVEY6OkR1bWJQdHJUcmFpdHM8V2ViQ29yZTo6TWVkaWFTdHJl YW0+ID4sIFdURjo6UmVmUHRyPFdlYkNvcmU6Ok1lZGlhU291cmNlLCBXVEY6OkR1bWJQdHJUcmFp dHM8V2ViQ29yZTo6TWVkaWFTb3VyY2U+ID4sIFdURjo6UmVmUHRyPFdlYkNvcmU6OkJsb2IsIFdU Rjo6RHVtYlB0clRyYWl0czxXZWJDb3JlOjpCbG9iPiA+ID4gPsOiwoDCmQouLi8uLi9Tb3VyY2Uv V2ViQ29yZS9odG1sL0hUTUxNZWRpYUVsZW1lbnQuaDoxMTI0OjE5OiAgIHJlcXVpcmVkIGZyb20g aGVyZQpEZXJpdmVkU291cmNlcy9Gb3J3YXJkaW5nSGVhZGVycy93dGYvUmVmUHRyLmg6NDU6MTQ6 IGVycm9yOiBpbnZhbGlkIHVzZSBvZiBpbmNvbXBsZXRlIHR5cGUgw6LCgMKYY2xhc3MgV2ViQ29y ZTo6TWVkaWFTdHJlYW3DosKAwpkKICAgICAgICAgcHRyLT5kZXJlZigpOwogICAgICAgICB+fn5+ fl5+fn5+CkluIGZpbGUgaW5jbHVkZWQgZnJvbSAuLi8uLi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJp bmcvUmVuZGVyVGhlbWVHdGsuY3BwOjM5OjA6Ci4uLy4uL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRN TE1lZGlhRWxlbWVudC5oOjk0Ojc6IG5vdGU6IGZvcndhcmQgZGVjbGFyYXRpb24gb2Ygw6LCgMKY Y2xhc3MgV2ViQ29yZTo6TWVkaWFTdHJlYW3DosKAwpkKIGNsYXNzIE1lZGlhU3RyZWFtOwogICAg ICAgXn5+fn5+fn5+fn4KSW4gZmlsZSBpbmNsdWRlZCBmcm9tIERlcml2ZWRTb3VyY2VzL0Zvcndh cmRpbmdIZWFkZXJzL3d0Zi9WZWN0b3JUcmFpdHMuaDoyNTowLAogICAgICAgICAgICAgICAgIGZy b20gRGVyaXZlZFNvdXJjZXMvRm9yd2FyZGluZ0hlYWRlcnMvd3RmL1ZlY3Rvci5oOjM4LAogICAg ICAgICAgICAgICAgIGZyb20gLi4vLi4vU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv RGFzaEFycmF5Lmg6MjksCiAgICAgICAgICAgICAgICAgZnJvbSAuLi8uLi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGljc0NvbnRleHQuaDoyOSwKICAgICAgICAgICAgICAg ICBmcm9tIC4uLy4uL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9QYWludEluZm8uaDoyOSwKICAg ICAgICAgICAgICAgICBmcm9tIC4uLy4uL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJU aGVtZS5oOjI0LAogICAgICAgICAgICAgICAgIGZyb20gLi4vLi4vU291cmNlL1dlYkNvcmUvcmVu ZGVyaW5nL1JlbmRlclRoZW1lR3RrLmg6MzAsCiAgICAgICAgICAgICAgICAgZnJvbSAuLi8uLi9T b3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVGhlbWVHdGsuY3BwOjI2OgpEZXJpdmVkU291 cmNlcy9Gb3J3YXJkaW5nSGVhZGVycy93dGYvUmVmUHRyLmg6IEluIGluc3RhbnRpYXRpb24gb2Yg w6LCgMKYdm9pZCBXVEY6OmRlcmVmSWZOb3ROdWxsKFQqKSBbd2l0aCBUID0gV2ViQ29yZTo6TWVk aWFTb3VyY2Vdw6LCgMKZOgpEZXJpdmVkU291cmNlcy9Gb3J3YXJkaW5nSGVhZGVycy93dGYvUmVm UHRyLmg6NzA6NDU6ICAgcmVxdWlyZWQgZnJvbSDDosKAwphXVEY6OlJlZlB0cjxULCA8dGVtcGxh dGUtcGFyYW1ldGVyLTEtMj4gPjo6flJlZlB0cigpIFt3aXRoIFQgPSBXZWJDb3JlOjpNZWRpYVNv dXJjZTsgUHRyVHJhaXRzID0gV1RGOjpEdW1iUHRyVHJhaXRzPFdlYkNvcmU6Ok1lZGlhU291cmNl Pl3DosKAwpkKRGVyaXZlZFNvdXJjZXMvRm9yd2FyZGluZ0hlYWRlcnMvd3RmL1ZhcmlhbnQuaDo0 NDM6OTogICByZXF1aXJlZCBmcm9tIMOiwoDCmHZvaWQgV1RGOjpfX3N0b3JhZ2Vfd3JhcHBlcjxf VHlwZT46Ol9fZGVzdHJveSgpIFt3aXRoIF9UeXBlID0gV1RGOjpSZWZQdHI8V2ViQ29yZTo6TWVk aWFTb3VyY2U+XcOiwoDCmQpEZXJpdmVkU291cmNlcy9Gb3J3YXJkaW5nSGVhZGVycy93dGYvVmFy aWFudC5oOjQ4MDo5OiAgIHJlcXVpcmVkIGZyb20gw6LCgMKYc3RhdGljIHZvaWQgV1RGOjpfX3Zh cmlhbnRfc3RvcmFnZTxfVHlwZSwgZmFsc2U+OjpfX2Rlc3Ryb3koV1RGOjpfX3ZhcmlhbnRfc3Rv cmFnZTxfVHlwZSwgZmFsc2U+OjpfX3R5cGUmKSBbd2l0aCBfVHlwZSA9IFdURjo6UmVmUHRyPFdl YkNvcmU6Ok1lZGlhU291cmNlPjsgV1RGOjpfX3ZhcmlhbnRfc3RvcmFnZTxfVHlwZSwgZmFsc2U+ OjpfX3R5cGUgPSBXVEY6Ol9fc3RvcmFnZV93cmFwcGVyPFdURjo6UmVmUHRyPFdlYkNvcmU6Ok1l ZGlhU291cmNlPiA+XcOiwoDCmQpEZXJpdmVkU291cmNlcy9Gb3J3YXJkaW5nSGVhZGVycy93dGYv VmFyaWFudC5oOjU1MTo0NDogICByZXF1aXJlZCBmcm9tIMOiwoDCmHZvaWQgV1RGOjpfX3Zhcmlh bnRfZGF0YTxfVHlwZT46Ol9fZGVzdHJveShXVEY6OmluX3BsYWNlX2luZGV4X3Q8MD4pIFt3aXRo IF9UeXBlID0gV1RGOjpSZWZQdHI8V2ViQ29yZTo6TWVkaWFTb3VyY2U+OyBXVEY6OmluX3BsYWNl X2luZGV4X3Q8MD4gPSBXVEY6OmluX3BsYWNlX3RhZyAoJikoV1RGOjpfX2luX3BsYWNlX3ByaXZh dGU6Ol9fdmFsdWVfaG9sZGVyPDA+Jildw6LCgMKZCkRlcml2ZWRTb3VyY2VzL0ZvcndhcmRpbmdI ZWFkZXJzL3d0Zi9WYXJpYW50Lmg6NjcwOjk6ICAgcmVxdWlyZWQgZnJvbSDDosKAwph2b2lkIFdU Rjo6X192YXJpYW50X2RhdGE8X0hlYWQsIF9SZXN0IC4uLj46Ol9fZGVzdHJveShXVEY6OmluX3Bs YWNlX2luZGV4X3Q8MD4pIFt3aXRoIF9IZWFkID0gV1RGOjpSZWZQdHI8V2ViQ29yZTo6TWVkaWFT b3VyY2U+OyBfUmVzdCA9IHtXVEY6OlJlZlB0cjxXZWJDb3JlOjpCbG9iLCBXVEY6OkR1bWJQdHJU cmFpdHM8V2ViQ29yZTo6QmxvYj4gPn07IFdURjo6aW5fcGxhY2VfaW5kZXhfdDwwPiA9IFdURjo6 aW5fcGxhY2VfdGFnICgmKShXVEY6Ol9faW5fcGxhY2VfcHJpdmF0ZTo6X192YWx1ZV9ob2xkZXI8 MD4mKV3DosKAwpkKRGVyaXZlZFNvdXJjZXMvRm9yd2FyZGluZ0hlYWRlcnMvd3RmL1ZhcmlhbnQu aDo2NzQ6OTogICBbIHNraXBwaW5nIDMgaW5zdGFudGlhdGlvbiBjb250ZXh0cywgdXNlIC1mdGVt cGxhdGUtYmFja3RyYWNlLWxpbWl0PTAgdG8gZGlzYWJsZSBdCkRlcml2ZWRTb3VyY2VzL0Zvcndh cmRpbmdIZWFkZXJzL3d0Zi9WYXJpYW50Lmg6MTQ3MDo0NTogICByZXF1aXJlZCBmcm9tIMOiwoDC mHZvaWQgV1RGOjpWYXJpYW50PCA8dGVtcGxhdGUtcGFyYW1ldGVyLTEtMT4gPjo6X19kZXN0cm95 X3NlbGYoKSBbd2l0aCBfVHlwZXMgPSB7V1RGOjpSZWZQdHI8V2ViQ29yZTo6TWVkaWFTdHJlYW0s IFdURjo6RHVtYlB0clRyYWl0czxXZWJDb3JlOjpNZWRpYVN0cmVhbT4gPiwgV1RGOjpSZWZQdHI8 V2ViQ29yZTo6TWVkaWFTb3VyY2UsIFdURjo6RHVtYlB0clRyYWl0czxXZWJDb3JlOjpNZWRpYVNv dXJjZT4gPiwgV1RGOjpSZWZQdHI8V2ViQ29yZTo6QmxvYiwgV1RGOjpEdW1iUHRyVHJhaXRzPFdl YkNvcmU6OkJsb2I+ID59XcOiwoDCmQpEZXJpdmVkU291cmNlcy9Gb3J3YXJkaW5nSGVhZGVycy93 dGYvVmFyaWFudC5oOjkyMjo5OiAgIHJlcXVpcmVkIGZyb20gw6LCgMKYV1RGOjpfX3ZhcmlhbnRf YmFzZTxfRGVyaXZlZCwgX190cml2aWFsX2Rlc3RydWN0b3I+Ojp+X192YXJpYW50X2Jhc2UoKSBb d2l0aCBfRGVyaXZlZCA9IFdURjo6VmFyaWFudDxXVEY6OlJlZlB0cjxXZWJDb3JlOjpNZWRpYVN0 cmVhbSwgV1RGOjpEdW1iUHRyVHJhaXRzPFdlYkNvcmU6Ok1lZGlhU3RyZWFtPiA+LCBXVEY6OlJl ZlB0cjxXZWJDb3JlOjpNZWRpYVNvdXJjZSwgV1RGOjpEdW1iUHRyVHJhaXRzPFdlYkNvcmU6Ok1l ZGlhU291cmNlPiA+LCBXVEY6OlJlZlB0cjxXZWJDb3JlOjpCbG9iLCBXVEY6OkR1bWJQdHJUcmFp dHM8V2ViQ29yZTo6QmxvYj4gPiA+OyBib29sIF9fdHJpdmlhbF9kZXN0cnVjdG9yID0gZmFsc2Vd w6LCgMKZCkRlcml2ZWRTb3VyY2VzL0ZvcndhcmRpbmdIZWFkZXJzL3d0Zi9WYXJpYW50Lmg6MTQz OTo3OiAgIHJlcXVpcmVkIGZyb20gw6LCgMKYc3RydWN0IHN0ZDo6aXNfdHJpdmlhbGx5X2NvcHlf Y29uc3RydWN0aWJsZTxXVEY6OlZhcmlhbnQ8V1RGOjpSZWZQdHI8V2ViQ29yZTo6TWVkaWFTdHJl YW0sIFdURjo6RHVtYlB0clRyYWl0czxXZWJDb3JlOjpNZWRpYVN0cmVhbT4gPiwgV1RGOjpSZWZQ dHI8V2ViQ29yZTo6TWVkaWFTb3VyY2UsIFdURjo6RHVtYlB0clRyYWl0czxXZWJDb3JlOjpNZWRp YVNvdXJjZT4gPiwgV1RGOjpSZWZQdHI8V2ViQ29yZTo6QmxvYiwgV1RGOjpEdW1iUHRyVHJhaXRz PFdlYkNvcmU6OkJsb2I+ID4gPiA+w6LCgMKZCi91c3IvaW5jbHVkZS9jKysvNy9vcHRpb25hbDox MDU6ODogICByZXF1aXJlZCBmcm9tIMOiwoDCmGNsYXNzIHN0ZDo6X09wdGlvbmFsX2Jhc2U8V1RG OjpWYXJpYW50PFdURjo6UmVmUHRyPFdlYkNvcmU6Ok1lZGlhU3RyZWFtLCBXVEY6OkR1bWJQdHJU cmFpdHM8V2ViQ29yZTo6TWVkaWFTdHJlYW0+ID4sIFdURjo6UmVmUHRyPFdlYkNvcmU6Ok1lZGlh U291cmNlLCBXVEY6OkR1bWJQdHJUcmFpdHM8V2ViQ29yZTo6TWVkaWFTb3VyY2U+ID4sIFdURjo6 UmVmUHRyPFdlYkNvcmU6OkJsb2IsIFdURjo6RHVtYlB0clRyYWl0czxXZWJDb3JlOjpCbG9iPiA+ ID4gPsOiwoDCmQovdXNyL2luY2x1ZGUvYysrLzcvb3B0aW9uYWw6NDUzOjExOiAgIHJlcXVpcmVk IGZyb20gw6LCgMKYY2xhc3Mgc3RkOjpvcHRpb25hbDxXVEY6OlZhcmlhbnQ8V1RGOjpSZWZQdHI8 V2ViQ29yZTo6TWVkaWFTdHJlYW0sIFdURjo6RHVtYlB0clRyYWl0czxXZWJDb3JlOjpNZWRpYVN0 cmVhbT4gPiwgV1RGOjpSZWZQdHI8V2ViQ29yZTo6TWVkaWFTb3VyY2UsIFdURjo6RHVtYlB0clRy YWl0czxXZWJDb3JlOjpNZWRpYVNvdXJjZT4gPiwgV1RGOjpSZWZQdHI8V2ViQ29yZTo6QmxvYiwg V1RGOjpEdW1iUHRyVHJhaXRzPFdlYkNvcmU6OkJsb2I+ID4gPiA+w6LCgMKZCi4uLy4uL1NvdXJj ZS9XZWJDb3JlL2h0bWwvSFRNTE1lZGlhRWxlbWVudC5oOjExMjQ6MTk6ICAgcmVxdWlyZWQgZnJv bSBoZXJlCkRlcml2ZWRTb3VyY2VzL0ZvcndhcmRpbmdIZWFkZXJzL3d0Zi9SZWZQdHIuaDo0NTox NDogZXJyb3I6IGludmFsaWQgdXNlIG9mIGluY29tcGxldGUgdHlwZSDDosKAwphjbGFzcyBXZWJD b3JlOjpNZWRpYVNvdXJjZcOiwoDCmQogICAgICAgICBwdHItPmRlcmVmKCk7CiAgICAgICAgIH5+ fn5+Xn5+fn4KSW4gZmlsZSBpbmNsdWRlZCBmcm9tIC4uLy4uL1NvdXJjZS9XZWJDb3JlL3JlbmRl cmluZy9SZW5kZXJUaGVtZUd0ay5jcHA6Mzk6MDoKLi4vLi4vU291cmNlL1dlYkNvcmUvaHRtbC9I VE1MTWVkaWFFbGVtZW50Lmg6OTM6Nzogbm90ZTogZm9yd2FyZCBkZWNsYXJhdGlvbiBvZiDDosKA wphjbGFzcyBXZWJDb3JlOjpNZWRpYVNvdXJjZcOiwoDCmQogY2xhc3MgTWVkaWFTb3VyY2U7CiAg ICAgICBefn5+fn5+fn5+fgpuaW5qYTogYnVpbGQgc3RvcHBlZDogc3ViY29tbWFuZCBmYWlsZWQu Cg==